@dittolive/ditto 4.9.4-rc.1 → 4.10.0-rc.1

package/node/ditto.cjs.js

@@ -106,8 +106,6 @@ class Observer {
 }
 Observer.finalizationRegistry = new FinalizationRegistry(Observer.finalize);
 
-const isWebBuild = false;
-
 //
 // Copyright © 2021 DittoLive Incorporated. All rights reserved.
 //
@@ -284,7 +282,6 @@ const ditto = (function () {
     if (target === 'darwin-x64') return require('./ditto.darwin-x64.node')
     if (target === 'darwin-arm64') return require('./ditto.darwin-arm64.node')
     if (target === 'linux-x64') return require('./ditto.linux-x64.node')
-    if (target === 'linux-arm') return require('./ditto.linux-arm.node')
     if (target === 'linux-arm64') return require('./ditto.linux-arm64.node')
     if (target === 'win32-x64') return require('./ditto.win32-x64.node')
   } catch (error) {
@@ -293,27 +290,18 @@ const ditto = (function () {
 
   throw new Error("No native module 'ditto." + target + ".node' found. Please check the Ditto documentation for supported platforms.")
 })();
-function ble_client_free_handle(...args) { return ditto.ble_client_free_handle(...args) }
-function ble_server_free_handle(...args) { return ditto.ble_server_free_handle(...args) }
 function boxCBytesIntoBuffer(...args) { return ditto.boxCBytesIntoBuffer(...args) }
 function boxCStringIntoString(...args) { return ditto.boxCStringIntoString(...args) }
 function cStringVecToStringArray(...args) { return ditto.cStringVecToStringArray(...args) }
-function ditto_add_internal_ble_client_transport(...args) { return ditto.ditto_add_internal_ble_client_transport(...args) }
-function ditto_add_internal_ble_server_transport(...args) { return ditto.ditto_add_internal_ble_server_transport(...args) }
-function ditto_add_internal_mdns_client_transport(...args) { return ditto.ditto_add_internal_mdns_client_transport(...args) }
-function ditto_add_internal_mdns_server_transport(...args) { return ditto.ditto_add_internal_mdns_server_transport(...args) }
-function ditto_add_multicast_transport(...args) { return ditto.ditto_add_multicast_transport(...args) }
 function ditto_add_subscription(...args) { return ditto.ditto_add_subscription(...args) }
 function ditto_auth_client_get_app_id(...args) { return ditto.ditto_auth_client_get_app_id(...args) }
 function ditto_auth_client_get_site_id(...args) { return ditto.ditto_auth_client_get_site_id(...args) }
 function ditto_auth_client_is_web_valid(...args) { return ditto.ditto_auth_client_is_web_valid(...args) }
-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) }
 function ditto_auth_client_user_id(...args) { return ditto.ditto_auth_client_user_id(...args) }
 function ditto_auth_set_login_provider(...args) { return ditto.ditto_auth_set_login_provider(...args) }
 function ditto_cancel_resolve_attachment(...args) { return ditto.ditto_cancel_resolve_attachment(...args) }
@@ -323,6 +311,7 @@ function ditto_collection_evict(...args) { return ditto.ditto_collection_evict(.
 function ditto_collection_evict_query_str(...args) { return ditto.ditto_collection_evict_query_str(...args) }
 function ditto_collection_exec_query_str(...args) { return ditto.ditto_collection_exec_query_str(...args) }
 function ditto_collection_get(...args) { return ditto.ditto_collection_get(...args) }
+function ditto_collection_get_with_write_transaction(...args) { return ditto.ditto_collection_get_with_write_transaction(...args) }
 function ditto_collection_insert_value(...args) { return ditto.ditto_collection_insert_value(...args) }
 function ditto_collection_remove(...args) { return ditto.ditto_collection_remove(...args) }
 function ditto_collection_remove_query_str(...args) { return ditto.ditto_collection_remove_query_str(...args) }
@@ -366,7 +355,6 @@ function ditto_logger_minimum_log_level(...args) { return ditto.ditto_logger_min
 function ditto_logger_minimum_log_level_get(...args) { return ditto.ditto_logger_minimum_log_level_get(...args) }
 function ditto_logger_set_custom_log_cb(...args) { return ditto.ditto_logger_set_custom_log_cb(...args) }
 function ditto_logger_set_log_file(...args) { return ditto.ditto_logger_set_log_file(...args) }
-function ditto_make(...args) { return ditto.ditto_make(...args) }
 function ditto_new_attachment_from_bytes(...args) { return ditto.ditto_new_attachment_from_bytes(...args) }
 function ditto_new_attachment_from_file(...args) { return ditto.ditto_new_attachment_from_file(...args) }
 function ditto_presence_v1(...args) { return ditto.ditto_presence_v1(...args) }
@@ -376,28 +364,14 @@ function ditto_read_transaction_free(...args) { return ditto.ditto_read_transact
 function ditto_register_presence_v1_callback(...args) { return ditto.ditto_register_presence_v1_callback(...args) }
 function ditto_register_presence_v3_callback(...args) { return ditto.ditto_register_presence_v3_callback(...args) }
 function ditto_register_transport_condition_changed_callback(...args) { return ditto.ditto_register_transport_condition_changed_callback(...args) }
-function ditto_remove_multicast_transport(...args) { return ditto.ditto_remove_multicast_transport(...args) }
 function ditto_remove_subscription(...args) { return ditto.ditto_remove_subscription(...args) }
 function ditto_resolve_attachment(...args) { return ditto.ditto_resolve_attachment(...args) }
 function ditto_run_garbage_collection(...args) { return ditto.ditto_run_garbage_collection(...args) }
-function ditto_sdk_transports_awdl_create(...args) { return ditto.ditto_sdk_transports_awdl_create(...args) }
-function ditto_sdk_transports_awdl_destroy(...args) { return ditto.ditto_sdk_transports_awdl_destroy(...args) }
-function ditto_sdk_transports_awdl_is_available(...args) { return ditto.ditto_sdk_transports_awdl_is_available(...args) }
-function ditto_sdk_transports_ble_create(...args) { return ditto.ditto_sdk_transports_ble_create(...args) }
-function ditto_sdk_transports_ble_destroy(...args) { return ditto.ditto_sdk_transports_ble_destroy(...args) }
-function ditto_sdk_transports_ble_is_available(...args) { return ditto.ditto_sdk_transports_ble_is_available(...args) }
 function ditto_sdk_transports_error_free(...args) { return ditto.ditto_sdk_transports_error_free(...args) }
 function ditto_sdk_transports_error_new(...args) { return ditto.ditto_sdk_transports_error_new(...args) }
 function ditto_sdk_transports_error_value(...args) { return ditto.ditto_sdk_transports_error_value(...args) }
 function ditto_sdk_transports_init(...args) { return ditto.ditto_sdk_transports_init(...args) }
-function ditto_sdk_transports_lan_create(...args) { return ditto.ditto_sdk_transports_lan_create(...args) }
-function ditto_sdk_transports_lan_destroy(...args) { return ditto.ditto_sdk_transports_lan_destroy(...args) }
-function ditto_sdk_transports_lan_is_available(...args) { return ditto.ditto_sdk_transports_lan_is_available(...args) }
-function ditto_set_connect_retry_interval(...args) { return ditto.ditto_set_connect_retry_interval(...args) }
 function ditto_set_device_name(...args) { return ditto.ditto_set_device_name(...args) }
-function ditto_set_static_tcp_clients(...args) { return ditto.ditto_set_static_tcp_clients(...args) }
-function ditto_set_static_websocket_clients(...args) { return ditto.ditto_set_static_websocket_clients(...args) }
-function ditto_set_sync_group(...args) { return ditto.ditto_set_sync_group(...args) }
 function ditto_shutdown(...args) { return ditto.ditto_shutdown(...args) }
 function ditto_small_peer_info_get_is_enabled(...args) { return ditto.ditto_small_peer_info_get_is_enabled(...args) }
 function ditto_small_peer_info_get_metadata(...args) { return ditto.ditto_small_peer_info_get_metadata(...args) }
@@ -405,15 +379,13 @@ function ditto_small_peer_info_get_sync_scope(...args) { return ditto.ditto_smal
 function ditto_small_peer_info_set_enabled(...args) { return ditto.ditto_small_peer_info_set_enabled(...args) }
 function ditto_small_peer_info_set_metadata(...args) { return ditto.ditto_small_peer_info_set_metadata(...args) }
 function ditto_small_peer_info_set_sync_scope(...args) { return ditto.ditto_small_peer_info_set_sync_scope(...args) }
-function ditto_small_peer_info_set_transport_config_data(...args) { return ditto.ditto_small_peer_info_set_transport_config_data(...args) }
-function ditto_start_http_server(...args) { return ditto.ditto_start_http_server(...args) }
-function ditto_start_tcp_server(...args) { return ditto.ditto_start_tcp_server(...args) }
-function ditto_stop_http_server(...args) { return ditto.ditto_stop_http_server(...args) }
-function ditto_stop_tcp_server(...args) { return ditto.ditto_stop_tcp_server(...args) }
 function ditto_validate_document_id(...args) { return ditto.ditto_validate_document_id(...args) }
 function ditto_write_transaction(...args) { return ditto.ditto_write_transaction(...args) }
 function ditto_write_transaction_commit(...args) { return ditto.ditto_write_transaction_commit(...args) }
 function ditto_write_transaction_rollback(...args) { return ditto.ditto_write_transaction_rollback(...args) }
+function dittoffi_authentication_status_free(...args) { return ditto.dittoffi_authentication_status_free(...args) }
+function dittoffi_authentication_status_is_authenticated(...args) { return ditto.dittoffi_authentication_status_is_authenticated(...args) }
+function dittoffi_authentication_status_user_id(...args) { return ditto.dittoffi_authentication_status_user_id(...args) }
 function dittoffi_base64_encode(...args) { return ditto.dittoffi_base64_encode(...args) }
 function dittoffi_connection_request_authorize(...args) { return ditto.dittoffi_connection_request_authorize(...args) }
 function dittoffi_connection_request_connection_type(...args) { return ditto.dittoffi_connection_request_connection_type(...args) }
@@ -422,11 +394,20 @@ function dittoffi_connection_request_identity_service_metadata_json(...args) { r
 function dittoffi_connection_request_peer_key_string(...args) { return ditto.dittoffi_connection_request_peer_key_string(...args) }
 function dittoffi_connection_request_peer_metadata_json(...args) { return ditto.dittoffi_connection_request_peer_metadata_json(...args) }
 function dittoffi_crypto_generate_secure_random_token(...args) { return ditto.dittoffi_crypto_generate_secure_random_token(...args) }
+function dittoffi_ditto_is_activated(...args) { return ditto.dittoffi_ditto_is_activated(...args) }
+function dittoffi_ditto_is_sync_active(...args) { return ditto.dittoffi_ditto_is_sync_active(...args) }
+function dittoffi_ditto_set_authentication_status_handler(...args) { return ditto.dittoffi_ditto_set_authentication_status_handler(...args) }
+function dittoffi_ditto_set_cloud_sync_enabled(...args) { return ditto.dittoffi_ditto_set_cloud_sync_enabled(...args) }
+function dittoffi_ditto_stop_sync(...args) { return ditto.dittoffi_ditto_stop_sync(...args) }
+function dittoffi_ditto_transport_config(...args) { return ditto.dittoffi_ditto_transport_config(...args) }
+function dittoffi_ditto_try_set_transport_config(...args) { return ditto.dittoffi_ditto_try_set_transport_config(...args) }
+function dittoffi_ditto_try_start_sync(...args) { return ditto.dittoffi_ditto_try_start_sync(...args) }
 function dittoffi_error_code(...args) { return ditto.dittoffi_error_code(...args) }
 function dittoffi_error_description(...args) { return ditto.dittoffi_error_description(...args) }
 function dittoffi_error_free(...args) { return ditto.dittoffi_error_free(...args) }
 function dittoffi_get_sdk_semver(...args) { return ditto.dittoffi_get_sdk_semver(...args) }
 function dittoffi_logger_try_export_to_file_async(...args) { return ditto.dittoffi_logger_try_export_to_file_async(...args) }
+function dittoffi_make_with_transport_config_mode(...args) { return ditto.dittoffi_make_with_transport_config_mode(...args) }
 function dittoffi_presence_peer_metadata_json(...args) { return ditto.dittoffi_presence_peer_metadata_json(...args) }
 function dittoffi_presence_set_connection_request_handler(...args) { return ditto.dittoffi_presence_set_connection_request_handler(...args) }
 function dittoffi_presence_try_set_peer_metadata_json(...args) { return ditto.dittoffi_presence_try_set_peer_metadata_json(...args) }
@@ -442,13 +423,10 @@ function dittoffi_try_add_sync_subscription(...args) { return ditto.dittoffi_try
 function dittoffi_try_base64_decode(...args) { return ditto.dittoffi_try_base64_decode(...args) }
 function dittoffi_try_exec_statement(...args) { return ditto.dittoffi_try_exec_statement(...args) }
 function dittoffi_try_experimental_register_change_observer_str_detached(...args) { return ditto.dittoffi_try_experimental_register_change_observer_str_detached(...args) }
-function dittoffi_try_register_store_observer_webhook(...args) { return ditto.dittoffi_try_register_store_observer_webhook(...args) }
 function dittoffi_try_remove_sync_subscription(...args) { return ditto.dittoffi_try_remove_sync_subscription(...args) }
 function dittoffi_try_verify_license(...args) { return ditto.dittoffi_try_verify_license(...args) }
 function getDeadlockTimeout$1(...args) { return ditto.getDeadlockTimeout(...args) }
 function jsDocsToCDocs(...args) { return ditto.jsDocsToCDocs(...args) }
-function mdns_client_free_handle(...args) { return ditto.mdns_client_free_handle(...args) }
-function mdns_server_free_handle(...args) { return ditto.mdns_server_free_handle(...args) }
 function refCBytesIntoBuffer(...args) { return ditto.refCBytesIntoBuffer(...args) }
 function refCStringToString(...args) { return ditto.refCStringToString(...args) }
 function setDeadlockTimeout$1(...args) { return ditto.setDeadlockTimeout(...args) }
@@ -566,34 +544,6 @@ var DittoCRDTType;
     DittoCRDTType[DittoCRDTType["rga"] = 3] = "rga";
     DittoCRDTType[DittoCRDTType["rwMap"] = 4] = "rwMap";
 })(DittoCRDTType || (DittoCRDTType = {}));
-// -------------------------------------- Linux & Windows Transports Hack ------
-// HACK: quick and dirty, wrap the internal BLE functions which
-// 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);
-}
-function dittoAddInternalBLEServerTransport(ditto) {
-    return ditto_add_internal_ble_server_transport(ditto);
-}
-function bleClientFreeHandle(handle) {
-    return ble_client_free_handle(handle);
-}
-function bleServerFreeHandle(handle) {
-    return ble_server_free_handle(handle);
-}
-function dittoAddInternalMdnsTransport(ditto) {
-    return ditto_add_internal_mdns_client_transport(ditto);
-}
-function mdnsClientFreeHandle(handle) {
-    return mdns_client_free_handle(handle);
-}
-function dittoAddInternalMdnsAdvertiser(ditto) {
-    return ditto_add_internal_mdns_server_transport(ditto);
-}
-function mdnsServerFreeHandle(handle) {
-    return mdns_server_free_handle(handle);
-}
 // ------------------------------------------------------------- Document ------
 /** @internal */
 function documentSetCBORWithTimestamp(document, path, cbor, timestamp) {
@@ -685,8 +635,8 @@ function validateDocumentID(docID) {
 async function collectionGet(ditto, collectionName, documentID, readTransaction) {
     ensureInitialized();
     // REFACTOR: add proper error handling.
-    const collectionNameX = bytesFromString(collectionName);
-    const { status_code: errorCode, document } = await ditto_collection_get(ditto, collectionNameX, documentID, readTransaction);
+    const collectionNamePointer = bytesFromString(collectionName);
+    const { status_code: errorCode, document } = await ditto_collection_get(ditto, collectionNamePointer, documentID, readTransaction);
     if (errorCode === NOT_FOUND_ERROR_CODE)
         return null;
     if (errorCode !== 0) {
@@ -696,6 +646,19 @@ async function collectionGet(ditto, collectionName, documentID, readTransaction)
     return document;
 }
 /** @internal */
+async function collectionGetWithWriteTransaction(ditto, collectionName, documentID, writeTransaction) {
+    ensureInitialized();
+    const collectionNamePointer = bytesFromString(collectionName);
+    const { status_code: errorCode, document } = await ditto_collection_get_with_write_transaction(ditto, collectionNamePointer, documentID, writeTransaction);
+    if (errorCode === NOT_FOUND_ERROR_CODE)
+        return null;
+    if (errorCode !== 0) {
+        throw new Error(errorMessage() ||
+            `ditto_collection_get_with_write_transaction() failed with error code: ${errorCode}`);
+    }
+    return document;
+}
+/** @internal */
 async function collectionInsertValue(ditto, collectionName, doc_cbor, writeStrategy, writeTransaction) {
     ensureInitialized();
     // REFACTOR: add proper error handling.
@@ -798,10 +761,10 @@ async function collectionEvictQueryStr(ditto, collectionName, writeTransaction,
  *
  * @internal
  */
-async function tryExecStatement(ditto, writeTransaction, query, queryArgsCBOR) {
+async function tryExecStatement(ditto, query, queryArgsCBOR) {
     ensureInitialized();
     const queryBytesPointer = bytesFromString(query);
-    const result = await dittoffi_try_exec_statement(ditto, writeTransaction, queryBytesPointer, queryArgsCBOR);
+    const result = await dittoffi_try_exec_statement(ditto, queryBytesPointer, queryArgsCBOR);
     throwOnErrorResult(result.error, 'dittoffi_try_exec_statement');
     return result.success;
 }
@@ -982,16 +945,6 @@ async function liveQueryWebhookRegister(ditto, collectionName, query, orderBy, l
     }
     return boxCBytesIntoBuffer(id);
 }
-/** @internal */
-async function tryRegisterStoreObserverWebhook(ditto, query, queryArgsCBOR, url) {
-    ensureInitialized();
-    const queryBuffer = bytesFromString(query);
-    const urlBuffer = bytesFromString(url);
-    const result = await dittoffi_try_register_store_observer_webhook(ditto, queryBuffer, queryArgsCBOR, urlBuffer);
-    throwOnErrorResult(result.error, 'dittoffi_try_register_store_observer_webhook');
-    const documentIdCBOR = result.success;
-    return boxCBytesIntoBuffer(documentIdCBOR);
-}
 // ------------------------------------------------------ ReadTransaction ------
 /** @internal */
 async function readTransaction(ditto) {
@@ -1206,10 +1159,6 @@ function dittoAuthClientIsWebValid(ditto) {
     ensureInitialized();
     return ditto_auth_client_is_web_valid(ditto) !== 0;
 }
-function dittoAuthClientIsX509Valid(ditto) {
-    ensureInitialized();
-    return ditto_auth_client_is_x509_valid(ditto) !== 0;
-}
 async function dittoAuthClientLoginWithTokenAndFeedback(ditto, token, provider) {
     ensureInitialized();
     const tokenBytes = bytesFromString(token);
@@ -1257,12 +1206,31 @@ async function dittoAuthClientLogout(ditto) {
         throw new Error(errorMessage() || `Ditto failed to logout (error code: ${errorCode}).`);
     }
 }
+/** @internal */
+function dittoSetAuthenticationStatusHandler(ditto, authenticationStatusUpdateCb, 
+// Cb may be called in parallel at any point, so let's use an optional error handler
+onError) {
+    ensureInitialized();
+    dittoffi_ditto_set_authentication_status_handler(ditto, wrapBackgroundCbForFFI(onError, authenticationStatusUpdateCb));
+}
+function authenticationStatusUserID(ffiAuthenticationStatus) {
+    ensureInitialized();
+    return boxCStringIntoString(dittoffi_authentication_status_user_id(ffiAuthenticationStatus));
+}
+function authenticationStatusIsAuthenticated(ffiAuthenticationStatus) {
+    ensureInitialized();
+    return dittoffi_authentication_status_is_authenticated(ffiAuthenticationStatus);
+}
+function authenticationStatusFree(ffiAuthenticationStatus) {
+    ensureInitialized();
+    dittoffi_authentication_status_free(ffiAuthenticationStatus);
+}
 // ---------------------------------------------------------------- Ditto ------
 /** @internal */
-function dittoMake(path, identityConfig, historyTracking) {
+function dittoMakeWithTransportConfigMode(path, identityConfig, historyTracking, transportConfigMode) {
     ensureInitialized();
     const pathPointer = bytesFromString(path);
-    return ditto_make(pathPointer, identityConfig, historyTracking);
+    return dittoffi_make_with_transport_config_mode(pathPointer, identityConfig, historyTracking, transportConfigMode);
 }
 /** @internal */
 async function dittoGetCollectionNames(self) {
@@ -1392,6 +1360,44 @@ function presenceSetConnectionRequestHandler(ditto, connectionRequestHandler, on
     }
 }
 /** @internal */
+function dittoIsActivated(ditto) {
+    ensureInitialized();
+    return dittoffi_ditto_is_activated(ditto);
+}
+/** @internal */
+function dittoIsSyncActive(ditto) {
+    ensureInitialized();
+    return dittoffi_ditto_is_sync_active(ditto);
+}
+/** @internal */
+function dittoStartSync(ditto) {
+    ensureInitialized();
+    const result = dittoffi_ditto_try_start_sync(ditto);
+    throwOnErrorResult(result.error, 'dittoffi_ditto_try_start_sync');
+}
+/** @internal */
+function dittoStopSync(ditto) {
+    ensureInitialized();
+    return dittoffi_ditto_stop_sync(ditto);
+}
+/** @internal */
+function dittoSetTransportConfig(ditto, transportConfigData) {
+    ensureInitialized();
+    const result = dittoffi_ditto_try_set_transport_config(ditto, transportConfigData, true);
+    throwOnErrorResult(result.error, 'dittoffi_ditto_try_set_transport_config');
+}
+/** @internal */
+function dittoTransportConfig(ditto) {
+    ensureInitialized();
+    const cborBytes = dittoffi_ditto_transport_config(ditto);
+    return boxCBytesIntoBuffer(cborBytes);
+}
+/** @internal */
+function dittoSetCloudSyncEnabled(ditto, cloudSyncEnabled) {
+    ensureInitialized();
+    dittoffi_ditto_set_cloud_sync_enabled(ditto, cloudSyncEnabled);
+}
+/** @internal */
 function dittoSmallPeerInfoGetIsEnabled(dittoPointer) {
     ensureInitialized();
     return ditto_small_peer_info_get_is_enabled(dittoPointer);
@@ -1439,11 +1445,6 @@ function dittoSmallPeerInfoSetMetadata(dittoPointer, metadata) {
     }
 }
 /** @internal */
-function dittoSmallPeerInfoCollectionSetTransportConfigData(self, transportConfigData) {
-    ensureInitialized();
-    ditto_small_peer_info_set_transport_config_data(self, transportConfigData);
-}
-/** @internal */
 function dittoRegisterTransportConditionChangedCallback(self, cb) {
     ensureInitialized();
     if (!cb) {
@@ -1461,20 +1462,6 @@ function dittoSetDeviceName(dittoPointer, deviceName) {
     const truncatedDeviceNameCString = ditto_set_device_name(dittoPointer, deviceNameCString);
     return boxCStringIntoString(truncatedDeviceNameCString);
 }
-/** @internal */
-function dittoSetConnectRetryInterval(dittoPointer, retryInterval) {
-    ensureInitialized();
-    // Unfortunately JS doesn't have a u32::MAX const...
-    const UINT32_MAX = 4294967295;
-    // Clamp the provided interval to u32 range (0 .. 2^32-1).
-    const clampedInterval = Math.min(Math.max(0, retryInterval), UINT32_MAX);
-    return ditto_set_connect_retry_interval(dittoPointer, clampedInterval);
-}
-/** @internal */
-function dittoSetSyncGroup(dittoPointer, syncGroup) {
-    ensureInitialized();
-    return ditto_set_sync_group(dittoPointer, syncGroup);
-}
 // Not supported on Wasm.
 /** @internal */
 function dittoNewAttachmentFromFile(ditto, sourcePath, fileOperation) {
@@ -1561,46 +1548,11 @@ function dittoPresenceV3(self) {
     return boxCStringIntoString(cString);
 }
 /** @internal */
-function dittoStartTCPServer(dittoPointer, bind) {
-    ensureInitialized();
-    const bindBuffer = bytesFromString(bind);
-    return ditto_start_tcp_server(dittoPointer, bindBuffer);
-}
-/** @internal */
-function dittoStopTCPServer(dittoPointer) {
-    ensureInitialized();
-    return ditto_stop_tcp_server(dittoPointer);
-}
-/** @internal */
 async function dittoShutdown(dittoPointer) {
     ensureInitialized();
     return await ditto_shutdown(dittoPointer);
 }
 /** @internal */
-function dittoAddMulticastTransport(dittoPointer) {
-    ensureInitialized();
-    return ditto_add_multicast_transport(dittoPointer);
-}
-/** @internal */
-function dittoRemoveMulticastTransport(dittoPointer) {
-    ensureInitialized();
-    return ditto_remove_multicast_transport(dittoPointer);
-}
-/** @internal */
-function dittoStartHTTPServer(dittoPointer, bind, staticPath, websocketMode, tlsCertPath, tlsKeyPath) {
-    ensureInitialized();
-    const bindBuffer = bytesFromString(bind);
-    const staticPathBuffer = bytesFromString(staticPath);
-    const tlsCertPathBuffer = bytesFromString(tlsCertPath);
-    const tlsKeyPathBuffer = bytesFromString(tlsKeyPath);
-    return ditto_start_http_server(dittoPointer, bindBuffer, staticPathBuffer, websocketMode, tlsCertPathBuffer, tlsKeyPathBuffer);
-}
-/** @internal */
-function dittoStopHTTPServer(dittoPointer) {
-    ensureInitialized();
-    return ditto_stop_http_server(dittoPointer);
-}
-/** @internal */
 async function dittoRunGarbageCollection(dittoPointer) {
     ensureInitialized();
     const statusCode = await ditto_run_garbage_collection(dittoPointer);
@@ -1618,20 +1570,6 @@ async function dittoDisableSyncWithV3(dittoPointer) {
             `ditto_disable_sync_with_v3() failed with error code: ${errorCode}`);
     }
 }
-function dittoSetStaticTCPClients(ditto, listOfServers) {
-    ensureInitialized();
-    // TODO(Vincent): add error handling.
-    {
-        const listOfServersBytes = listOfServers.map((server) => bytesFromString(server));
-        ditto_set_static_tcp_clients(ditto, listOfServersBytes);
-    }
-}
-function dittoSetStaticWebsocketClients(ditto, listOfServers, routingHint) {
-    ensureInitialized();
-    // TODO(Vincent): add error handling.
-    const listOfServersBytes = listOfServers.map((server) => bytesFromString(server));
-    ditto_set_static_websocket_clients(ditto, listOfServersBytes, routingHint);
-}
 // ------------------------------------------------------ Hash & Mnemonic ------
 /** @internal */
 function documentsHash(documents) {
@@ -1682,16 +1620,6 @@ onError) {
     ensureInitialized();
     return ditto_auth_client_make_login_provider(wrapBackgroundCbForFFI(onError, expiringCb));
 }
-/** @internal */
-function dittoAuthClientSetValidityListener(ditto, validityUpdateCb, 
-// Cb may be called in parallel at any point, so let's use an optional error handler
-onError) {
-    ensureInitialized();
-    const validityUpdateRawCb = wrapBackgroundCbForFFI(onError, function (isWebValidInt, isX509ValidInt) {
-        return validityUpdateCb(isWebValidInt === 1, isX509ValidInt === 1);
-    });
-    return ditto_auth_client_set_validity_listener(ditto, validityUpdateRawCb);
-}
 // ----------------------------------------------------------- Transports ------
 /** @internal */
 function transportsInit() {
@@ -1700,97 +1628,6 @@ function transportsInit() {
     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);
-}
-/** @internal */
-function transportsBLECreate(ditto) {
-    ensureInitialized();
-    {
-        const { output: blePointer, errorType } = withTransportsError(ditto_sdk_transports_ble_create, ditto);
-        if (blePointer != null)
-            log('Info', `Bluetooth transport created.`);
-        else
-            log('Error', `Can't create bluetooth transport (${errorType} error).`);
-        return blePointer;
-    }
-}
-/** @internal */
-function transportsBLEDestroy(ble) {
-    ensureInitialized();
-    {
-        const { output: wasDestroyed, errorType } = withTransportsError(ditto_sdk_transports_ble_destroy, ble);
-        if (wasDestroyed === true) {
-            log('Info', 'Bluetooth transport disabled.');
-        }
-        else {
-            log('Error', `Bluetooth transport could not be disabled (${errorType} error).`);
-        }
-        return wasDestroyed;
-    }
-}
-/** @internal */
-function transportsLANIsAvailable(ditto) {
-    ensureInitialized();
-    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)
-            log('Info', `LAN transport created.`);
-        else
-            log('Error', `Can't create LAN transport (${errorType} error).`);
-        return lanPointer;
-    }
-}
-/** @internal */
-function transportsLANDestroy(lan) {
-    ensureInitialized();
-    {
-        const { output: wasDestroyed, errorType } = withTransportsError(ditto_sdk_transports_lan_destroy, lan);
-        if (wasDestroyed === true)
-            log('Info', 'LAN transport disabled.');
-        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);
-}
-/** @internal */
-function transportsAWDLCreate(ditto) {
-    ensureInitialized();
-    {
-        const { output: awdlPointer, errorType } = withTransportsError(ditto_sdk_transports_awdl_create, ditto);
-        if (awdlPointer != null)
-            log('Info', `AWDL transport created.`);
-        else
-            log('Error', `Can't create AWDL transport (${errorType} error).`);
-        return awdlPointer;
-    }
-}
-/** @internal */
-function transportsAWDLDestroy(awdl) {
-    ensureInitialized();
-    {
-        const { output: wasDestroyed, errorType } = withTransportsError(ditto_sdk_transports_awdl_destroy, awdl);
-        if (wasDestroyed === true) {
-            log('Info', 'AWDL transport disabled.');
-        }
-        else {
-            log('Error', `AWDL transport could not be disabled (${errorType} error).`);
-        }
-        return wasDestroyed;
-    }
-}
 /**
  * Calls the given FFI function with the passed in arguments and a newly
  * allocated `transportsErrorPointer` as the last argument, then returns its
@@ -1829,10 +1666,10 @@ function initSDKVersion(platform, language, semVer) {
     }
 }
 /** @internal */
-function tryVerifyLicense(license) {
+function tryVerifyLicense(ditto, license) {
     ensureInitialized();
     const licenseBuffer = bytesFromString(license);
-    const result = dittoffi_try_verify_license(licenseBuffer);
+    const result = dittoffi_try_verify_license(ditto, licenseBuffer);
     throwOnErrorResult(result.error, 'dittoffi_try_verify_license');
 }
 // -------------------------------------------------------------- Private ------
@@ -1957,6 +1794,8 @@ const ERROR_CODES = {
     //
     /** Error for invalid DQL query arguments. */
     'query/arguments-invalid': 'The query arguments were invalid.',
+    /** Errors that occur during evaluation of a query */
+    'query/evaluation': 'The query could not be evaluated.',
     /** Errors that occur during execution of a query */
     'query/execution': 'The query could not be executed.',
     /** Error for an invalid DQL query. */
@@ -1974,6 +1813,8 @@ const ERROR_CODES = {
     'store/crdt': 'An error occurred processing a CRDT.',
     /** Error for a document not found. */
     'store/document-not-found': 'The document with the provided ID could not be found.',
+    /** Error for an invalid document ID. */
+    'store/document-id': 'The document ID is invalid.',
     /** Permission has been denied for a file operation when working with attachments. */
     'store/attachment-file-permission-denied': 'Permission has been denied for a file operation when working with attachments.',
     /** The source file for an attachment does not exist. */
@@ -1997,12 +1838,16 @@ const ERROR_CODES = {
     'activation/license-token-unsupported-future-version': 'The provided license token is in an unsupported future format.',
     /** The operation failed because it requires an activated Ditto instance. */
     'activation/not-activated': 'The operation failed because the Ditto instance has not yet been activated.',
+    /** Activation is unnecessary for this Ditto instance, because of its identity. */
+    'activation/unnecessary': 'Activation is unnecessary for this Ditto instance, because of its identity.',
     /** A validation error where the maximum depth limit was exceeded. */
     'validation/depth-limit-exceeded': 'The maximum depth limit has been exceeded.',
     /** A validation error where the value is not valid CBOR. */
     'validation/invalid-cbor': 'The value provided is not valid CBOR.',
     /** A validation error where the value is not valid JSON. */
     'validation/invalid-json': 'The value provided is not valid JSON.',
+    /** A validation error where the TransportConfig is invalid for the active platform. */
+    'validation/invalid-transport-config': 'The TransportConfig is invalid for the active platform.',
     /** A validation error where a value is required to be a JavaScript object */
     'validation/not-an-object': 'The value provided is not of type object.',
     /** The value provided can not be serialized as JSON. */
@@ -2027,6 +1872,7 @@ const DEFAULT_STATUS_CODE_MAPPING = {
         'activation/license-token-unsupported-future-version',
     ],
     ActivationNotActivated: ['activation/not-activated'],
+    ActivationUnnecessary: ['activation/unnecessary'],
     //
     // Input/output errors
     //
@@ -2044,6 +1890,7 @@ const DEFAULT_STATUS_CODE_MAPPING = {
     //
     // DQL errors
     //
+    DqlEvaluationError: ['query/evaluation'],
     DqlQueryCompilation: ['query/invalid'],
     DqlInvalidQueryArgs: ['query/arguments-invalid'],
     DqlUnsupported: ['query/unsupported'],
@@ -2052,8 +1899,9 @@ const DEFAULT_STATUS_CODE_MAPPING = {
     //
     // Store errors
     //
-    StoreDocumentNotFound: ['store/document-not-found'],
     StoreDatabase: ['store/backend'],
+    StoreDocumentId: ['store/document-id'],
+    StoreDocumentNotFound: ['store/document-not-found'],
     Crdt: ['store/crdt'],
     //
     // Validation errors
@@ -2061,11 +1909,27 @@ const DEFAULT_STATUS_CODE_MAPPING = {
     // This gets mapped to `internal` by default but depending on the context,
     // it should be mapped to a more specific error code.
     Base64Invalid: ['internal', 'Invalid base64 encoding.'],
+    CborInvalid: ['internal', 'Invalid CBOR encoding.'],
+    CborUnsupported: ['internal', 'Unsupported CBOR encoding.'],
     ValidationDepthLimitExceeded: ['validation/depth-limit-exceeded'],
     ValidationInvalidCbor: ['validation/invalid-cbor'],
     ValidationInvalidJson: ['validation/invalid-json'],
+    ValidationInvalidTransportConfig: ['validation/invalid-transport-config'],
     ValidationNotAMap: ['validation/not-an-object'],
     ValidationSizeLimitExceeded: ['validation/size-limit-exceeded'],
+    //
+    // Lifecycle errors
+    //
+    // FIXME: A locked Ditto working directory should eventually not result in an
+    // `internal` error. Here it is mapped to that until
+    // https://github.com/getditto/ditto/issues/12096 is fixed, and this kind of
+    // error is actually thrown instead of the SDK panicking when the persistence
+    // directory is locked.
+    LockedDittoWorkingDirectory: [
+        'internal',
+        'Ditto working directory is locked.',
+    ],
+    Transport: ['internal', 'Transport error.'],
     Unsupported: ['sdk/unsupported'],
     Unknown: ['internal/unknown-error'], // May be updated in v5, c.f. #12755
     default: ['internal/unknown-error'],
@@ -2310,11 +2174,16 @@ class AttachmentToken {
 
 // 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.9.4-rc.1';
+const fullBuildVersionString = '4.10.0-rc.1';
 
 //
 // Copyright © 2021 DittoLive Incorporated. All rights reserved.
 //
+// Replacing {custom-sdk-name} with any string that doesn't contain '{' in the
+// final build output switches the SDK_NAME to the custom name.
+const SDK_NAME = '{custom-sdk-name}'.includes('{')
+    ? 'JavaScript'
+    : '{custom-sdk-name}';
 /**
  * Initializes the whole Ditto module. Needs to be called and complete before
  * any of the Ditto API is used.
@@ -2326,19 +2195,19 @@ async function init(options = {}) {
 {
     switch (process.platform) {
         case 'android':
-            initSDKVersion('Android', 'JavaScript', fullBuildVersionString);
+            initSDKVersion('Android', SDK_NAME, fullBuildVersionString);
             break;
         case 'darwin':
-            initSDKVersion('Mac', 'JavaScript', fullBuildVersionString);
+            initSDKVersion('Mac', SDK_NAME, fullBuildVersionString);
             break;
         case 'linux':
-            initSDKVersion('Linux', 'JavaScript', fullBuildVersionString);
+            initSDKVersion('Linux', SDK_NAME, fullBuildVersionString);
             break;
         case 'win32':
-            initSDKVersion('Windows', 'JavaScript', fullBuildVersionString);
+            initSDKVersion('Windows', SDK_NAME, fullBuildVersionString);
             break;
         default:
-            initSDKVersion('Unknown', 'JavaScript', fullBuildVersionString);
+            initSDKVersion('Unknown', SDK_NAME, fullBuildVersionString);
             break;
     }
 }
@@ -4440,10 +4309,6 @@ const defaultDittoCloudDomain = `cloud.ditto.live`;
 function defaultAuthURL(appID) {
     return `https://${appID}.${defaultDittoCloudDomain}`;
 }
-/** @internal */
-function defaultDittoCloudURL(appID) {
-    return `wss://${appID}.${defaultDittoCloudDomain}`;
-}
 // ---------------------------------------------------------- Validations ------
 /**
  * Validates a number and returns it as-is if all requirements are met,
@@ -5539,13 +5404,18 @@ class BasePendingIDSpecificOperation {
         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);
+            if (transaction == null) {
+                const readTransactionPointer = await readTransaction(dittoHandle.deref());
+                try {
+                    documentPointer = await collectionGet(dittoHandle.deref(), this.collection.name, this.documentIDCBOR, readTransactionPointer);
+                }
+                finally {
+                    readTransactionFree(readTransactionPointer);
+                }
             }
-            finally {
-                readTransactionFree(readTransactionPointer);
+            else {
+                documentPointer = await collectionGetWithWriteTransaction(dittoHandle.deref(), this.collection.name, this.documentIDCBOR, transaction.writeTransactionPointer);
             }
             const errorMessageAsyncClosure = `Expected ${publicAPIName} to be called with a synchronous ` +
                 'closure but it was called with an async closure';
@@ -5816,6 +5686,17 @@ class ObserverManager {
 //
 // Copyright © 2021 DittoLive Incorporated. All rights reserved.
 //
+const AuthenticationStatus = {
+    fromFFI(ffiAuthenticationStatus) {
+        const isAuthenticated = authenticationStatusIsAuthenticated(ffiAuthenticationStatus);
+        const userID = authenticationStatusUserID(ffiAuthenticationStatus);
+        authenticationStatusFree(ffiAuthenticationStatus);
+        return {
+            isAuthenticated,
+            userID,
+        };
+    },
+};
 // -----------------------------------------------------------------------------
 /**
  * Log in to a remote authentication service, using an
@@ -5910,10 +5791,6 @@ class Authenticator {
         throw new Error(`Authenticator['@ditto.authenticationExpiring']() is abstract and must be implemented by subclasses.`);
     }
     /** @internal */
-    '@ditto.authClientValidityChanged'(isWebValid, isX509Valid) {
-        throw new Error(`Authenticator['@ditto.authClientValidityChanged']() is abstract and must be implemented by subclasses.`);
-    }
-    /** @internal */
     close() {
         this.observerManager.close();
     }
@@ -5966,6 +5843,18 @@ class OnlineAuthenticator extends Authenticator {
         this._status = { isAuthenticated: false, userID: null };
         this.ditto = new WeakRef(ditto);
         this.authenticationHandler = authenticationHandler;
+        const weakThis = new WeakRef(this);
+        ditto.deferClose((dittoHandle) => {
+            dittoSetAuthenticationStatusHandler(dittoHandle.deref(), function (ffiAuthenticationStatus) {
+                const authenticator = weakThis.deref();
+                if (authenticator == null) {
+                    Logger.info('Authenticator is null, ignoring authentication status change');
+                    return;
+                }
+                const authenticationStatus = AuthenticationStatus.fromFFI(ffiAuthenticationStatus);
+                authenticator.authenticationStatusUpdated(authenticationStatus);
+            });
+        });
         this.updateAndNotify(false);
     }
     '@ditto.authenticationExpiring'(secondsRemaining) {
@@ -5975,11 +5864,19 @@ class OnlineAuthenticator extends Authenticator {
         else
             authenticationHandler.authenticationRequired(this);
     }
-    '@ditto.authClientValidityChanged'(isWebValid, isX509Valid) {
-        this.updateAndNotify(true);
+    authenticationStatusUpdated(authenticationStatus) {
+        var _a;
+        const previousStatus = this.status;
+        this._status = authenticationStatus;
+        const sameStatus = !!previousStatus.isAuthenticated ===
+            !!authenticationStatus.isAuthenticated &&
+            previousStatus.userID === authenticationStatus.userID;
+        if (!sameStatus) {
+            (_a = this.authenticationHandler.authenticationStatusDidChange) === null || _a === void 0 ? void 0 : _a.call(this.authenticationHandler, this);
+            this.observerManager.notify(authenticationStatus);
+        }
     }
     updateAndNotify(shouldNotify) {
-        var _a;
         const ditto = this.ditto.deref();
         if (!ditto) {
             Logger.debug('Unable to update auth status and notify, related Ditto object does not exist anymore.');
@@ -5991,18 +5888,16 @@ class OnlineAuthenticator extends Authenticator {
             Logger.debug('Unable to update auth status and notify, related Ditto object does not exist anymore.');
             return;
         }
-        const wasAuthenticated = this.status.isAuthenticated;
-        const previousUserID = this.status.userID;
         const isAuthenticated = dittoAuthClientIsWebValid(dittoPointer);
         const userID = dittoAuthClientUserID(dittoPointer);
         const status = { isAuthenticated, userID };
-        this._status = status;
         if (shouldNotify) {
-            const sameStatus = !!wasAuthenticated === !!isAuthenticated && previousUserID === userID;
-            if (!sameStatus) {
-                (_a = this.authenticationHandler.authenticationStatusDidChange) === null || _a === void 0 ? void 0 : _a.call(this.authenticationHandler, this);
-                this.observerManager.notify(status);
-            }
+            // We don't need to set the `_status` property here because it's done in
+            // `authenticationStatusUpdated`.
+            this.authenticationStatusUpdated(status);
+        }
+        else {
+            this._status = status;
         }
     }
 }
@@ -6024,9 +5919,6 @@ class NotAvailableAuthenticator extends Authenticator {
     '@ditto.authenticationExpiring'(secondsRemaining) {
         throw new Error(`Internal inconsistency, authentication is not available, yet the @ditto.authenticationExpiring() was called on authenticator: ${this}`);
     }
-    '@ditto.authClientValidityChanged'(isWebValid, isX509Valid) {
-        throw new Error(`Internal inconsistency, authentication is not available, yet the @ditto.authClientValidityChanged() was called on authenticator: ${this}`);
-    }
 }
 
 //
@@ -7841,6 +7733,20 @@ class WriteTransactionPendingIDSpecificOperation extends BasePendingIDSpecificOp
         transaction.addResult('updated', this.documentID, this.collection.name);
         return updateResults;
     }
+    async exec() {
+        const ditto = this.collection.store.ditto;
+        return ditto.deferCloseAsync(async (dittoHandle) => {
+            return await performAsyncToWorkaroundNonAsyncFFIAPI(async () => {
+                const transaction = this.collection
+                    .writeTransaction;
+                const documentPointer = await collectionGetWithWriteTransaction(dittoHandle.deref(), this.collection.name, this.documentIDCBOR, transaction.writeTransactionPointer);
+                let document = undefined;
+                if (documentPointer)
+                    document = Bridge.document.bridge(documentPointer);
+                return document;
+            });
+        });
+    }
     // ----------------------------------------------------------- Internal ------
     /** @internal */
     constructor(documentID, collection) {
@@ -8196,9 +8102,6 @@ class Store {
             throw new DittoError('query/invalid', `Expected parameter 'query' to be of type 'string', found: ${typeof query}`);
         }
         return this.ditto.deferCloseAsync(async (dittoHandle) => {
-            // A one-off query execution uses a transaction internally but a
-            // transaction API is not implemented yet.
-            const writeTransaction = null;
             let queryArgumentsCBOR = null;
             if (queryArguments != null) {
                 try {
@@ -8209,7 +8112,7 @@ class Store {
                     throw new DittoError('query/arguments-invalid', `Unable to encode query arguments: ${error.message}`);
                 }
             }
-            const queryResultPointer = await mapFFIErrorsAsync(async () => await performAsyncToWorkaroundNonAsyncFFIAPI(() => tryExecStatement(dittoHandle.deref(), writeTransaction, query, queryArgumentsCBOR)));
+            const queryResultPointer = await mapFFIErrorsAsync(async () => await performAsyncToWorkaroundNonAsyncFFIAPI(() => tryExecStatement(dittoHandle.deref(), query, queryArgumentsCBOR)));
             return Bridge.queryResult.bridge(queryResultPointer, () => new QueryResult(queryResultPointer));
         });
     }
@@ -8436,38 +8339,6 @@ class Store {
         this.attachmentFetchers = Object.freeze([]);
         this.ditto = ditto;
     }
-    /**
-     * Registers a URL to be called whenever the given `SELECT` query observes
-     * changes.
-     *
-     * No validation is performed on the URL, so it is up to the caller to ensure
-     * that the URL is valid and can be reached.
-     *
-     * @internal
-     * @returns a promise for a document id that acts as a webhook id
-     * @throws {@link DittoError} `store/query-invalid`: if the query is invalid
-     * @throws {@link DittoError} `store/query-arguments-invalid`: if the query arguments
-     * are invalid
-     * @throws {@link DittoError} `store/query-unsupported`: if the query is not a
-     * `SELECT` query
-     * @throws {@link DittoError} for any other error that occurs during query execution
-     */
-    async registerObserverWebhook(query, url, queryArguments) {
-        let queryArgumentsCBOR = null;
-        if (queryArguments != null) {
-            try {
-                const queryArgumentsJSON = desugarJSObject(queryArguments);
-                queryArgumentsCBOR = CBOR.encode(queryArgumentsJSON);
-            }
-            catch (error) {
-                throw new DittoError('query/arguments-invalid', `Invalid query arguments: ${error.message}`);
-            }
-        }
-        return this.ditto.deferCloseAsync(async (dittoHandle) => {
-            const webhookIDCBOR = await mapFFIErrorsAsync(async () => await tryRegisterStoreObserverWebhook(dittoHandle.deref(), query, queryArgumentsCBOR, url));
-            return new DocumentID(webhookIDCBOR, true);
-        });
-    }
     /**
      * Unregister a store observer. No-op if the change observer has already
      * been removed.
@@ -9182,10 +9053,6 @@ class Sync {
     }
     // ---------------------------------------------------------- Internal ------
     /** @internal */
-    get parameters() {
-        return this.state.underlyingSyncParameters;
-    }
-    /** @internal */
     constructor(ditto) {
         /**
          * All currently active {@link SyncSubscription | sync subscriptions}.
@@ -9197,24 +9064,7 @@ class Sync {
          * existing sync subscription.
          */
         this.subscriptions = Object.freeze([]);
-        this.bluetoothLETransportPointer = null;
-        this.awdlTransportPointer = null;
-        this.lanTransportPointer = null;
-        this.mdnsClientTransportPointer = null;
-        this.mdnsServerAdvertiserPointer = null;
-        const identity = ditto.identity;
-        const transportConfig = new TransportConfig();
-        const parameters = {
-            identity,
-            transportConfig,
-            ditto,
-            isWebValid: false,
-            isX509Valid: false,
-            isSyncActive: false,
-        };
         this.ditto = ditto;
-        this.state = stateFrom(parameters);
-        transportsInit();
     }
     /**
      * Removes the passed in `syncSubscription`, configuring Ditto to not receive
@@ -9252,312 +9102,12 @@ class Sync {
         return true;
     }
     /** @internal */
-    update(parameters) {
-        // NOTE: updating is a two-step process. Given all parameters, we
-        // first compute the final "state" we want the transports stuff to
-        // be in via the `stateFrom()` function. We then take that "desired" state
-        // and feed it into the various update methods, which essentially perform
-        // a diff on the state before and after, and update the low-level transports
-        // machinery accordingly.
-        const stateOld = this.state;
-        const stateNew = stateFrom(parameters);
-        this.updatePeerToPeerBluetoothLE(stateOld, stateNew);
-        this.updatePeerToPeerAWDL(stateOld, stateNew);
-        this.updatePeerToPeerLAN(stateOld, stateNew);
-        this.updateListenTCP(stateOld, stateNew);
-        this.updateListenHTTP(stateOld, stateNew);
-        this.updateConnectTCPServers(stateOld, stateNew);
-        this.updateConnectWebsocketURLs(stateOld, stateNew);
-        this.updateGlobal(stateOld, stateNew);
-        this.updateConnectRetryInterval(stateOld, stateNew);
-        this.state = stateNew;
-    }
-    /** @internal */
     close() {
-        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)
             subscription.cancel();
         // Nothing to do, when sync is stopped, this object should be
         // already be cleaned up properly.
     }
-    updatePeerToPeerBluetoothLE(stateOld, stateNew) {
-        this.ditto.deferClose((dittoHandle) => {
-            const bluetoothLEOld = stateOld.effectiveTransportConfig.peerToPeer.bluetoothLE;
-            const bluetoothLENew = stateNew.effectiveTransportConfig.peerToPeer.bluetoothLE;
-            const shouldStart = !bluetoothLEOld.isEnabled && bluetoothLENew.isEnabled;
-            const shouldStop = bluetoothLEOld.isEnabled && !bluetoothLENew.isEnabled;
-            if (shouldStart && this.bluetoothLETransportPointer) {
-                throw new Error(`Internal inconsistency, when starting BLE transport, no BLE transport pointer should exist.`);
-            }
-            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.
-            if (process.platform === 'linux' || process.platform === 'win32') {
-                if (shouldStart) {
-                    const clientTransport = dittoAddInternalBLEClientTransport(dittoHandle.deref());
-                    const serverTransport = dittoAddInternalBLEServerTransport(dittoHandle.deref());
-                    const blePlatform = { clientTransport, serverTransport };
-                    this.bluetoothLETransportPointer = blePlatform;
-                }
-                if (shouldStop) {
-                    const blePlatform = this.bluetoothLETransportPointer;
-                    const { clientTransport, serverTransport } = blePlatform;
-                    bleServerFreeHandle(serverTransport);
-                    bleClientFreeHandle(clientTransport);
-                    this.bluetoothLETransportPointer = null;
-                }
-                return;
-            }
-            if (shouldStart) {
-                this.bluetoothLETransportPointer = transportsBLECreate(dittoHandle.deref());
-            }
-            if (shouldStop) {
-                // null check is performed above
-                transportsBLEDestroy(this
-                    .bluetoothLETransportPointer);
-                this.bluetoothLETransportPointer = null;
-            }
-        });
-    }
-    updatePeerToPeerAWDL(stateOld, stateNew) {
-        this.ditto.deferClose((dittoHandle) => {
-            const awdlOld = stateOld.effectiveTransportConfig.peerToPeer.awdl;
-            const awdlNew = stateNew.effectiveTransportConfig.peerToPeer.awdl;
-            const shouldStart = !awdlOld.isEnabled && awdlNew.isEnabled;
-            const shouldStop = awdlOld.isEnabled && !awdlNew.isEnabled;
-            if (shouldStart && this.awdlTransportPointer) {
-                throw new Error(`Internal inconsistency, when starting AWDL transport, no AWDL transport pointer should exist.`);
-            }
-            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());
-            }
-            if (shouldStop) {
-                // null check is performed above
-                transportsAWDLDestroy(this.awdlTransportPointer);
-                this.awdlTransportPointer = null;
-            }
-        });
-    }
-    updatePeerToPeerLAN(stateOld, stateNew) {
-        this.ditto.deferClose((dittoHandle) => {
-            const lanOld = stateOld.effectiveTransportConfig.peerToPeer.lan;
-            const lanNew = stateNew.effectiveTransportConfig.peerToPeer.lan;
-            // HACK: quick & dirty Linux & Windows hack. A proper implementation
-            // should encapsulate everything behind the transports module. To undo,
-            // remove the whole if block.
-            if (process.platform === 'win32' || process.platform === 'linux') {
-                if (lanOld.isEnabled) {
-                    if (lanOld.isMdnsEnabled) {
-                        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) {
-                            throw new Error(`Internal inconsistency, when stopping LAN transport, a LAN transport pointer should exist.`);
-                        }
-                        mdnsServerFreeHandle(this.mdnsServerAdvertiserPointer);
-                        this.mdnsServerAdvertiserPointer = null;
-                    }
-                    if (lanOld.isMulticastEnabled)
-                        dittoRemoveMulticastTransport(dittoHandle.deref());
-                }
-                if (lanNew.isEnabled) {
-                    if (lanNew.isMdnsEnabled) {
-                        this.mdnsClientTransportPointer = dittoAddInternalMdnsTransport(dittoHandle.deref());
-                        this.mdnsServerAdvertiserPointer =
-                            dittoAddInternalMdnsAdvertiser(dittoHandle.deref());
-                    }
-                    if (lanNew.isMulticastEnabled)
-                        dittoAddMulticastTransport(dittoHandle.deref());
-                }
-                return;
-            }
-            // IDEA: move the logic for this dance into stateFrom() signal
-            // via some additional state signaling the actions here.
-            if (lanOld.isEnabled) {
-                if (lanOld.isMdnsEnabled) {
-                    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)
-                    dittoRemoveMulticastTransport(dittoHandle.deref());
-            }
-            if (lanNew.isEnabled) {
-                if (lanNew.isMdnsEnabled) {
-                    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)
-                    dittoAddMulticastTransport(dittoHandle.deref());
-            }
-        });
-    }
-    updateListenTCP(stateOld, stateNew) {
-        this.ditto.deferClose((dittoHandle) => {
-            const tcpOld = stateOld.effectiveTransportConfig.listen.tcp;
-            const tcpNew = stateNew.effectiveTransportConfig.listen.tcp;
-            if (TransportConfig.areListenTCPsEqual(tcpNew, tcpOld))
-                return;
-            if (tcpOld.isEnabled)
-                dittoStopTCPServer(dittoHandle.deref());
-            if (tcpNew.isEnabled) {
-                dittoStartTCPServer(dittoHandle.deref(), `${tcpNew.interfaceIP}:${tcpNew.port}`);
-            }
-        });
-    }
-    updateListenHTTP(stateOld, stateNew) {
-        this.ditto.deferClose((dittoHandle) => {
-            const httpOld = stateOld.effectiveTransportConfig.listen.http;
-            const httpNew = stateNew.effectiveTransportConfig.listen.http;
-            if (TransportConfig.areListenHTTPsEqual(httpOld, httpNew))
-                return;
-            if (httpOld.isEnabled)
-                dittoStopHTTPServer(dittoHandle.deref());
-            /* eslint-disable */
-            if (httpNew.isEnabled) {
-                dittoStartHTTPServer(dittoHandle.deref(), `${httpNew.interfaceIP}:${httpNew.port}`, httpNew.staticContentPath || null, httpNew.websocketSync ? 'Enabled' : 'Disabled', httpNew.tlsCertificatePath || null, httpNew.tlsKeyPath || null);
-            }
-            /* eslint-enable */
-        });
-    }
-    updateConnectTCPServers(stateOld, stateNew) {
-        this.ditto.deferClose((dittoHandle) => {
-            const tcpServers = stateNew.effectiveTransportConfig.connect.tcpServers;
-            dittoSetStaticTCPClients(dittoHandle.deref(), tcpServers);
-        });
-    }
-    updateConnectWebsocketURLs(stateOld, stateNew) {
-        this.ditto.deferClose((dittoHandle) => {
-            const websocketURLs = stateNew.effectiveTransportConfig.connect.websocketURLs;
-            const routingHint = stateNew.effectiveTransportConfig.global.routingHint;
-            dittoSetStaticWebsocketClients(dittoHandle.deref(), websocketURLs, routingHint);
-        });
-    }
-    updateGlobal(stateOld, stateNew) {
-        this.ditto.deferClose((dittoHandle) => {
-            if (stateOld.effectiveTransportConfig.global.syncGroup !==
-                stateNew.effectiveTransportConfig.global.syncGroup) {
-                dittoSetSyncGroup(dittoHandle.deref(), stateNew.effectiveTransportConfig.global.syncGroup);
-            }
-        });
-    }
-    updateConnectRetryInterval(stateOld, stateNew) {
-        this.ditto.deferClose((dittoHandle) => {
-            dittoSetConnectRetryInterval(dittoHandle.deref(), stateNew.effectiveTransportConfig.connect.retryInterval);
-        });
-    }
-}
-/**
- * Computes the effective transport config given a desired transport config and
- * some additional state.
- *
- * Disables all transports that are unavailable due to the runtime environment
- * or authentication requirements. Adds websocket URL for Ditto Cloud if
- * enabled.
- *
- * Throws if the target transport config enables sync but contains transports
- * that are not available in the current environment. Does not throw when
- * transports are enabled but not available due to authentication requirements.
- *
- * @private
- */
-function stateFrom(parameters) {
-    // IMPORTANT: this function maps a set of sync parameters to an effective
-    // transport config plus some extra state where need be. Make sure
-    // to keep this function free of side-effects.
-    var _a, _b;
-    const identity = parameters.identity;
-    const isSyncActive = parameters.isSyncActive;
-    const isX509Valid = parameters.isX509Valid;
-    const isWebValid = parameters.isWebValid;
-    let appID;
-    let customDittoCloudURL;
-    let isDittoCloudSyncEnabled = false;
-    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;
-        isDittoCloudSyncEnabled = (_b = identity.enableDittoCloudSync) !== null && _b !== void 0 ? _b : true;
-    }
-    validateEnabledTransportsAvailable(parameters.ditto, parameters.transportConfig);
-    const transportConfig = parameters.transportConfig.copy();
-    if (!isSyncActive || !isX509Valid) {
-        transportConfig.peerToPeer.bluetoothLE.isEnabled = false;
-        transportConfig.peerToPeer.awdl.isEnabled = false;
-        transportConfig.peerToPeer.lan.isEnabled = false;
-        transportConfig.listen.tcp.isEnabled = false;
-        transportConfig.connect.tcpServers = [];
-    }
-    if (!isSyncActive || !isWebValid)
-        transportConfig.connect.websocketURLs = [];
-    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) {
-        // @ts-ignore To fix this type error, refactor using a switch
-        // statement, c.f.
-        // https://github.com/getditto/ditto/blob/d35b6c1cb280cdd6368d14137c97609b9b9b9296/js/sources/sync.ts#L488
-        const dittoCloudURL = customDittoCloudURL !== null && customDittoCloudURL !== void 0 ? customDittoCloudURL : defaultDittoCloudURL(appID);
-        transportConfig.connect.websocketURLs.push(dittoCloudURL);
-    }
-    return {
-        underlyingSyncParameters: parameters,
-        effectiveTransportConfig: transportConfig.freeze(),
-    };
-}
-/**
- * Validate that all enabled transports are available in the current environment
- * and throw an error if not.
- *
- * @private
- */
-function validateEnabledTransportsAvailable(ditto, transportConfig) {
-    return ditto.deferClose((dittoHandle) => {
-        // - BLE
-        // - AWDL
-        // - LAN / mDNS
-        const unavailableButEnabledP2PTransports = [];
-        const isBLEAvailable = transportsBLEIsAvailable(dittoHandle.deref());
-        const isAWDLAvailable = transportsAWDLIsAvailable(dittoHandle.deref());
-        const isLANAvailable = transportsLANIsAvailable(dittoHandle.deref());
-        if (transportConfig.peerToPeer.bluetoothLE.isEnabled && !isBLEAvailable)
-            unavailableButEnabledP2PTransports.push('BluetoothLE');
-        if (transportConfig.peerToPeer.awdl.isEnabled && !isAWDLAvailable)
-            unavailableButEnabledP2PTransports.push('AWDL');
-        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) {
-            throw new Error(`The transport config contains TCP servers, but this transport is not supported in web environments`);
-        }
-        if (transportConfig.listen.http.isEnabled && isWebBuild) {
-            throw new Error(`The transport config contains an HTTP listener, which is not supported in web environments`);
-        }
-        if (transportConfig.listen.tcp.isEnabled && isWebBuild) {
-            throw new Error(`The transport config contains a TCP listener, which is not supported in web environments`);
-        }
-    });
 }
 
 //
@@ -9928,8 +9478,9 @@ class Ditto {
      * @see {@link setOfflineOnlyLicenseToken | setOfflineOnlyLicenseToken()}
      */
     get isActivated() {
-        var _a;
-        return (_a = this._isActivated) !== null && _a !== void 0 ? _a : false;
+        return this.deferClose((dittoHandle) => {
+            return dittoIsActivated(dittoHandle.deref());
+        });
     }
     /**
      * `true` once {@link Ditto.close | Ditto.close()} has been called, otherwise
@@ -9945,8 +9496,9 @@ class Ditto {
      * {@link stopSync | stopSync()} to deactivate sync.
      */
     get isSyncActive() {
-        var _a;
-        return (_a = this._isSyncActive) !== null && _a !== void 0 ? _a : false;
+        return this.deferClose((dittoHandle) => {
+            return dittoIsSyncActive(dittoHandle.deref());
+        });
     }
     /**
      * Initializes a new `Ditto` instance.
@@ -9969,11 +9521,9 @@ class Ditto {
      * validation of the provided identity.
      */
     constructor(identity, persistenceDirectory) {
+        var _a, _b;
         // ------------------------------------------------------------ Private ------
         this.deferCloseAllowed = true;
-        this.isWebValid = false;
-        this.isX509Valid = false;
-        this._isSyncActive = false;
         this._isClosed = false;
         /** Set of pending operations that need to complete before the Ditto instance can be closed in a safe manner. */
         this.pendingOperations = new Set();
@@ -10026,25 +9576,23 @@ class Ditto {
         })();
         // History tracking is an experimental feature that is not supported in the JS SDK.
         const historyTracking = 'Disabled';
-        const dittoPointer = dittoMake(this.persistenceDirectory, identityConfig, historyTracking);
-        dittoAuthClientSetValidityListener(dittoPointer, function (...args) {
-            const ditto = weakThis.deref();
-            if (ditto == null || ditto.isClosed)
-                Logger.info('Ditto is closed, ignoring auth client validity change');
-            else
-                ditto.authClientValidityChanged(...args);
-        });
-        const isWebValid = dittoAuthClientIsWebValid(dittoPointer);
-        const isX509Valid = dittoAuthClientIsX509Valid(dittoPointer);
+        // The JS SDK, unlike (nearly all of) the other SDKs, expects its `TransportConfig`s to have
+        // certain transports enabled/disabled by default. Specifically, it expects this to be
+        // determined for P2P transports based on the environment. We specify this here by setting
+        // `transportConfigMode` to 'PlatformDependent'.
+        const transportConfigMode = 'PlatformDependent';
+        const dittoPointer = dittoMakeWithTransportConfigMode(this.persistenceDirectory, identityConfig, historyTracking, transportConfigMode);
         const appID = dittoAuthClientGetAppID(dittoPointer);
         const siteID = dittoAuthClientGetSiteID(dittoPointer);
         Bridge.ditto.bridge(dittoPointer, this);
+        let enableDittoCloudSync = false;
         // IMPORTANT: Keeping the auth client around accumulates run-times and
         // resources which becomes a problem specifically in tests (where we use one
         // Ditto instance per test). We therefore keep it only if needed, i.e.
         // _only_ for the onlineWithAuthentication and online identities and
         // transfer ownership of it to the authenticator.
         if (validIdentity.type === 'onlineWithAuthentication') {
+            enableDittoCloudSync = (_a = validIdentity.enableDittoCloudSync) !== null && _a !== void 0 ? _a : false;
             this.auth = new OnlineAuthenticator(this.keepAlive, this, validIdentity.authHandler);
             const loginProviderX = dittoAuthClientMakeLoginProvider(function (secondsRemaining) {
                 const strongThis = weakThis.deref();
@@ -10068,6 +9616,7 @@ class Ditto {
             void dittoAuthSetLoginProvider(dittoPointer, loginProviderX);
         }
         else if (validIdentity.type === 'onlinePlayground') {
+            enableDittoCloudSync = (_b = validIdentity.enableDittoCloudSync) !== null && _b !== void 0 ? _b : false;
             this.auth = new OnlineAuthenticator(this.keepAlive, this, {
                 authenticationRequired: function (authenticator) {
                     // No-op.
@@ -10080,27 +9629,14 @@ class Ditto {
         else {
             this.auth = new NotAvailableAuthenticator(this.keepAlive);
         }
-        const transportConfig = this.makeDefaultTransportConfig().freeze();
+        dittoSetCloudSyncEnabled(dittoPointer, enableDittoCloudSync);
+        transportsInit();
         //
         // Assign instance properties.
         //
         this.appID = appID;
         this.siteID = siteID;
-        this.isX509Valid = isX509Valid;
-        this.isWebValid = isWebValid;
         this.sync = new Sync(this);
-        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.store = new Store(this);
         this.smallPeerInfo = new SmallPeerInfo(this);
         this.presence = new Presence(this);
@@ -10265,9 +9801,11 @@ class Ditto {
      */
     setOfflineOnlyLicenseToken(licenseToken) {
         if (IdentityTypesRequiringOfflineLicenseToken.includes(this.identity.type)) {
-            this._isActivated = false;
-            mapFFIErrors(() => tryVerifyLicense(licenseToken));
-            this._isActivated = true;
+            this.deferClose((dittoHandle) => {
+                mapFFIErrors(() => {
+                    tryVerifyLicense(dittoHandle.deref(), licenseToken);
+                });
+            });
         }
         else {
             Logger.error(`The identity type '${this.identity.type}' does not require an offline license token.`);
@@ -10285,7 +9823,11 @@ class Ditto {
      * @see {@link updateTransportConfig | updateTransportConfig()}
      */
     get transportConfig() {
-        return this.sync.parameters.transportConfig;
+        return this.deferClose((dittoHandle) => {
+            const configCBOR = dittoTransportConfig(dittoHandle.deref());
+            const transportConfig = transportConfigFromDeserializable(CBOR.decode(configCBOR));
+            return transportConfig.freeze();
+        });
     }
     /**
      * Assigns a new transports configuration. By default peer-to-peer transports
@@ -10298,21 +9840,10 @@ class Ditto {
      */
     setTransportConfig(transportConfig) {
         const transportConfigNew = transportConfig.copy().freeze();
-        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,
-        });
         const configSerializeReady = transportConfigToSerializable(transportConfigNew);
         const configCBOR = CBOR.encode(configSerializeReady);
         this.deferClose((dittoHandle) => {
-            dittoSmallPeerInfoCollectionSetTransportConfigData(dittoHandle.deref(), configCBOR);
+            dittoSetTransportConfig(dittoHandle.deref(), configCBOR);
         });
     }
     /**
@@ -10352,7 +9883,16 @@ class Ditto {
      * @see {@link stopSync | stopSync()}
      */
     startSync() {
-        this.setSyncActive(true);
+        this.deferClose((dittoHandle) => {
+            if (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)
+                this.keepAlive.retain('sync');
+            this._deviceName = dittoSetDeviceName(dittoHandle.deref(), this.deviceName);
+            dittoStartSync(dittoHandle.deref());
+        });
     }
     /**
      * Stops all network transports.
@@ -10364,7 +9904,11 @@ class Ditto {
      * @see {@link startSync | startSync()}
      */
     stopSync() {
-        this.setSyncActive(false);
+        this.deferClose((dittoHandle) => {
+            if (this.isSyncActive)
+                this.keepAlive.release('sync');
+            dittoStopSync(dittoHandle.deref());
+        });
     }
     /**
      * Registers an observer for info about Ditto peers in range of this device.
@@ -10540,24 +10084,6 @@ class Ditto {
         }
         return result;
     }
-    authClientValidityChanged(isWebValid, isX509Valid) {
-        const transportConfig = this.transportConfig;
-        const identity = this.identity;
-        const isSyncActive = this.isSyncActive;
-        this.isX509Valid;
-        this.isWebValid;
-        this.isX509Valid = isX509Valid;
-        this.isWebValid = isWebValid;
-        this.auth['@ditto.authClientValidityChanged'](isWebValid, isX509Valid);
-        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.
@@ -10607,45 +10133,6 @@ class Ditto {
         if (identity.type === 'onlineWithAuthentication') ;
         return validIdentity;
     }
-    setSyncActive(flag) {
-        this.deferClose((dittoHandle) => {
-            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)
-                this.keepAlive.retain('sync');
-            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,
-            });
-        });
-    }
-    makeDefaultTransportConfig() {
-        return this.deferClose((dittoHandle) => {
-            const transportConfig = new TransportConfig();
-            if (transportsBLEIsAvailable(dittoHandle.deref()))
-                transportConfig.peerToPeer.bluetoothLE.isEnabled = true;
-            if (transportsAWDLIsAvailable(dittoHandle.deref()))
-                transportConfig.peerToPeer.awdl.isEnabled = true;
-            if (transportsLANIsAvailable(dittoHandle.deref()))
-                transportConfig.peerToPeer.lan.isEnabled = true;
-            return transportConfig.freeze();
-        });
-    }
 }
 /**
  * Returns true if the current JS environment supports all required APIs.
@@ -10895,6 +10382,7 @@ Bridge.ditto.registerType(Ditto);
 exports.Attachment = Attachment;
 exports.AttachmentFetcher = AttachmentFetcher;
 exports.AttachmentToken = AttachmentToken;
+exports.AuthenticationStatus = AuthenticationStatus;
 exports.Authenticator = Authenticator;
 exports.BasePendingCursorOperation = BasePendingCursorOperation;
 exports.BasePendingIDSpecificOperation = BasePendingIDSpecificOperation;