@dittolive/ditto 4.7.4 → 4.7.5-rc.2

package/react-native/src/sources/ffi.ts

@@ -1,2190 +0,0 @@
-//
-// Copyright © 2023 DittoLive Incorporated. All rights reserved.
-//
-
-// NOTE: This is a temporary *hand-written* shim file for glue code for the
-// Ditto native Node module. Mid to long term, we'll either move all of this
-// code to the native side or generate this file via a companion CLI tool or
-// something equivalent.
-//
-// IMPORTANT: please leave this file self-contained and do not import any
-// sources from the JS SDK.
-
-import * as dittoCore from './@ditto.core'
-import * as Environment from './@environment'
-import { DittoFFIError, throwOnErrorResult } from './ffi-error'
-
-// -------------------------------------------------------------- Prelude ------
-
-/** @internal */
-export type Pointer<Type> = { type: Type; addr: string }
-
-/** @internal */
-export var isTracingEnabled = false
-
-/** @internal */
-export const DittoCRDTTypeKey = '_ditto_internal_type_jkb12973t4b'
-
-/** @internal */
-export const DittoCRDTValueKey = '_value'
-
-// ---------------------------------------------------------------- Types ------
-
-/** @internal */
-export type FFIError = 'dittoffi_error_t'
-
-/** @internal */
-export type FFIWriteStrategy = 'merge' | 'insertIfAbsent' | 'insertDefaultIfAbsent' | 'updateDifferentValues'
-
-/** @internal */
-export type FFIDocument = 'CDocument_t'
-
-/** @internal */
-export type FFIQueryResultItem = 'dittoffi_query_result_item_t'
-
-/** @internal */
-export type FFIQueryResult = 'dittoffi_query_result_t'
-
-/** @internal */
-export type FFIReadTransaction = 'CReadTransaction_t'
-
-/** @internal */
-export type FFIWriteTransaction = 'CWriteTransaction_t'
-
-/** @internal */
-export type FFIUninitializedDitto = 'CUninitializedDitto_t'
-
-/** @internal */
-export type FFIDitto = 'CDitto_t'
-
-/** @internal */
-export type FFIIdentityConfig = 'CIdentityConfig_t'
-
-/** @internal */
-export type FFILoginProvider = 'CLoginProvider_t'
-
-/** @internal */
-export type FFIAuthServerAuthRequest = 'CAuthServerAuthRequest_t'
-
-/** @internal */
-export type FFIAuthServerRefreshRequest = 'CAuthServerRefreshRequest_t'
-
-/** @internal */
-export type FFIStaticTCPClient = 'TransportHandle_StaticTCPClientPlatformEvent_t'
-
-/** @internal */
-export type FFIWebsocketClient = 'TransportHandle_WebsocketClientPlatformEvent_t'
-
-/** @internal */
-export type FFISmallPeerInfoSyncScope = 'LocalPeerOnly' | 'BigPeerOnly'
-
-/** @internal */
-export type FFIConnectionType = 'dittoffi_connection_type_t'
-
-/** @internal */
-export type FFIConnectionRequest = 'dittoffi_connection_request_t'
-
-/** @internal */
-export type FFIConnectionRequestAuthorization = 'dittoffi_connection_request_authorization_t'
-
-/** @internal */
-export type LiveQueryAvailability = 'Always' | 'WhenSignalled'
-
-/** @internal */
-export type StringPrimitiveFormat = 'WithQuotes' | 'WithoutQuotes'
-
-/** @internal */
-export type LogLevel = 'Error' | 'Warning' | 'Info' | 'Debug' | 'Verbose'
-
-/** @internal */
-export type LicenseVerificationResult = 'LicenseOk' | 'VerificationFailed' | 'LicenseExpired' | 'UnsupportedFutureVersion'
-
-/** @internal */
-export type WebsocketMode = 'Enabled' | 'Disabled'
-
-/** @internal */
-export type HistoryTracking = 'Enabled' | 'Disabled'
-
-/** @internal */
-export type ConditionSource = 'Bluetooth' | 'Tcp' | 'Awdl' | 'Mdns'
-
-/** @internal */
-export type TransportCondition = 'Unknown' | 'Ok' | 'GenericFailure' | 'AppInBackground' | 'MdnsFailure' | 'TcpListenFailure' | 'NoBleCentralPermission' | 'NoBlePeripheralPermission' | 'CannotEstablishConnection' | 'BleDisabled' | 'NoBleHardware' | 'WifiDisabled' | 'TemporarilyUnavailable'
-
-/** @internal */
-export type TransportsError = 'None' | 'Generic' | 'Unavailable'
-
-/** @internal */
-export type TransportBluetooth = 'DittoTransportsBLE_t'
-
-/** @internal */
-export type TransportAWDL = 'DittoTransportsAWDL_t'
-
-/** @internal */
-export type TransportLAN = 'DittoTransportsLAN_t'
-
-/** @internal */
-export type TransportMdnsClient = 'DittoTransportsMdnsClient_t'
-
-/** @internal */
-export type TransportMdnsServer = 'DittoTransportsMdnsServer_t'
-
-/** @internal */
-export type Platform = 'Windows' | 'Mac' | 'Ios' | 'Android' | 'Linux' | 'Web' | 'Unknown'
-
-/** @internal */
-export type Language = 'Swift' | 'ObjectiveC' | 'CPlusPlus' | 'CSharp' | 'JavaScript' | 'Unknown' | 'Rust'
-
-/** @internal */
-export type OrderBy = { query: string; direction: 'Ascending' | 'Descending' }
-
-/** @internal */
-export type PathAccessorType = 'String' | 'Number' | 'Int' | 'UInt' | 'Float' | 'Double' | 'Bool' | 'Null' | 'Object' | 'Array' | 'Any' | 'Counter' | 'Register' | 'Attachment' | 'Rga' | 'RWMap'
-
-/** @internal */
-export enum DittoCRDTType {
-  counter = 0,
-  register = 1,
-  attachment = 2,
-  rga = 3,
-  rwMap = 4,
-}
-
-/** @internal */
-export type Base64PaddingMode = 'Padded' | 'Unpadded'
-
-/** @internal */
-export type ConnectionRequestAuthorization = 'Allow' | 'Deny'
-
-/** @internal */
-export type Transport = 'P2PWiFi' | 'WebSocket' | 'AccessPoint' | 'Bluetooth'
-
-/** @internal */
-export type CBParamsDocs = {
-  documents: Pointer<FFIDocument>[]
-  is_initial: boolean
-  old_documents: Pointer<FFIDocument>[]
-  insertions: number[]
-  deletions: number[]
-  updates: number[]
-  moves: [number, number][]
-}
-
-/** @internal */
-export type CBParamsQueryResult = {
-  query_result: Pointer<FFIQueryResult>
-}
-
-/** @internal */
-export type CBORPathResult = {
-  statusCode: number
-  cbor: Uint8Array
-}
-
-/** Various options to pass the web assembly module to Ditto. */
-export type WebAssemblyModule = RequestInfo | URL | Response | BufferSource | WebAssembly.Module | string | null
-
-/** @internal */
-export type AttachmentFileOperation = 'Copy' | 'Move'
-
-/** @internal */
-// IDEA: rename to AttachmentHandleType for consistency.
-export type AttachmentHandle = 'AttachmentHandle_t'
-
-/** @internal */
-export type RawAttachment = {
-  id: Uint8Array
-  len: number | BigInt
-  handle: Pointer<AttachmentHandle>
-}
-
-// -------------------------------------- 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.
-
-export function dittoAddInternalBLEClientTransport(ditto: Pointer<FFIDitto>): any {
-  if (Environment.isNodeBuild || Environment.isReactNativeBuild) {
-    return dittoCore.ditto_add_internal_ble_client_transport(ditto)
-  }
-
-  if (Environment.isWebBuild) {
-    throw new Error(`Internal inconsistency, can't add internal BLE client, only available for non-apple Ditto Node builds.`)
-  }
-}
-
-export function dittoAddInternalBLEServerTransport(ditto: Pointer<FFIDitto>): any {
-  if (Environment.isNodeBuild || Environment.isReactNativeBuild) {
-    return dittoCore.ditto_add_internal_ble_server_transport(ditto)
-  }
-
-  if (Environment.isWebBuild) {
-    throw new Error(`Internal inconsistency, can't add internal BLE server, only available for non-apple Ditto Node builds.`)
-  }
-}
-
-export function bleClientFreeHandle(handle: any) {
-  if (Environment.isNodeBuild || Environment.isReactNativeBuild) {
-    return dittoCore.ble_client_free_handle(handle)
-  }
-
-  if (Environment.isWebBuild) {
-    throw new Error(`Internal inconsistency, can't free BLE client handle, only available for non-apple Ditto Node builds.`)
-  }
-}
-
-export function bleServerFreeHandle(handle: any) {
-  if (Environment.isNodeBuild || Environment.isReactNativeBuild) {
-    return dittoCore.ble_server_free_handle(handle)
-  }
-
-  if (Environment.isWebBuild) {
-    throw new Error(`Internal inconsistency, can't free BLE server handle, only available for non-apple Ditto Node builds.`)
-  }
-}
-
-export function dittoAddInternalMdnsTransport(ditto: Pointer<FFIDitto>): any {
-  if (Environment.isNodeBuild || Environment.isReactNativeBuild) {
-    return dittoCore.ditto_add_internal_mdns_client_transport(ditto)
-  }
-
-  if (Environment.isWebBuild) {
-    throw new Error(`Internal inconsistency, can't add internal MDNS transport/client, only available for non-apple Ditto Node builds.`)
-  }
-}
-
-export function mdnsClientFreeHandle(handle: any) {
-  if (Environment.isNodeBuild || Environment.isReactNativeBuild) {
-    return dittoCore.mdns_client_free_handle(handle)
-  }
-
-  if (Environment.isWebBuild) {
-    throw new Error(`Internal inconsistency, can't free MDNS transport/client handle, only available for non-apple Ditto Node builds.`)
-  }
-}
-
-export function dittoAddInternalMdnsAdvertiser(ditto: Pointer<FFIDitto>): any {
-  if (Environment.isNodeBuild || Environment.isReactNativeBuild) {
-    return dittoCore.ditto_add_internal_mdns_server_transport(ditto)
-  }
-
-  if (Environment.isWebBuild) {
-    throw new Error(`Internal inconsistency, can't add internal MDNS advertiser/server, only available for non-apple Ditto Node builds.`)
-  }
-}
-
-export function mdnsServerFreeHandle(handle: any) {
-  if (Environment.isNodeBuild || Environment.isReactNativeBuild) {
-    return dittoCore.mdns_server_free_handle(handle)
-  }
-
-  if (Environment.isWebBuild) {
-    throw new Error(`Internal inconsistency, can't free MDNS advertiser/server handle, only available for non-apple Ditto Node builds.`)
-  }
-}
-
-// ------------------------------------------------------------- Document ------
-
-/** @internal */
-export function documentSetCBORWithTimestamp(document: Pointer<FFIDocument>, path: string, cbor: Uint8Array, timestamp: number) {
-  trace()
-  ensureInitialized()
-
-  const pathX = bytesFromString(path)
-  const errorCode = dittoCore.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}`)
-}
-
-/** @internal */
-export function documentSetCBOR(document: Pointer<FFIDocument>, path: string, cbor: Uint8Array) {
-  trace()
-  ensureInitialized()
-
-  // NOTE: not sure if this should be async or not.
-  const pathX = bytesFromString(path)
-  const errorCode = dittoCore.ditto_document_set_cbor(document, pathX, cbor)
-  if (errorCode !== 0) throw new Error(errorMessage() || `ditto_document_set_cbor() failed with error code: ${errorCode}`)
-}
-
-/** @internal */
-export function documentID(self: Pointer<FFIDocument>): Uint8Array {
-  trace()
-  ensureInitialized()
-
-  // REFACTOR: add proper error handling.
-  const documentIDX = dittoCore.ditto_document_id(self)
-  return dittoCore.boxCBytesIntoBuffer(documentIDX)
-}
-
-/** @internal */
-export function documentCBOR(self: Pointer<FFIDocument>): Uint8Array {
-  trace()
-  ensureInitialized()
-
-  const cborBytes = dittoCore.ditto_document_cbor(self)
-  return dittoCore.boxCBytesIntoBuffer(cborBytes)
-}
-
-/** @internal */
-export function documentGetCBORWithPathType(document: Pointer<FFIDocument>, path: string, pathType: PathAccessorType): CBORPathResult {
-  trace()
-  ensureInitialized()
-
-  const pathBytes = bytesFromString(path)
-  const cborPathResultRaw = dittoCore.ditto_document_get_cbor_with_path_type(document, pathBytes, pathType)
-
-  const cborPathResult: CBORPathResult = {
-    statusCode: cborPathResultRaw.status_code,
-    cbor: dittoCore.boxCBytesIntoBuffer(cborPathResultRaw.cbor),
-  }
-
-  return cborPathResult
-}
-
-/** @internal */
-export function documentRemove(document: Pointer<FFIDocument>, path: string) {
-  trace()
-  ensureInitialized()
-
-  const pathBytes = bytesFromString(path)
-  const errorCode = dittoCore.ditto_document_remove(document, pathBytes)
-  if (errorCode !== 0) throw new Error(errorMessage() || `ditto_document_remove() failed with error code: ${errorCode}`)
-}
-
-/** @internal */
-export function documentIncrementCounter(document: Pointer<FFIDocument>, path: string, amount: number) {
-  trace()
-  ensureInitialized()
-
-  const pathBytes = bytesFromString(path)
-  const errorCode = dittoCore.ditto_document_increment_counter(document, pathBytes, amount)
-  if (errorCode !== 0) throw new Error(errorMessage() || `ditto_document_increment_counter() failed with error code: ${errorCode}`)
-}
-
-/** @internal */
-export function documentFree(self: Pointer<FFIDocument>) {
-  trace()
-  ensureInitialized()
-
-  // REFACTOR: add proper error handling.
-  dittoCore.ditto_document_free(self)
-}
-
-// ----------------------------------------------------------- DocumentID ------
-
-/** @internal */
-export function documentIDQueryCompatible(docID: Uint8Array, stringPrimitiveFormat: StringPrimitiveFormat): string {
-  trace()
-  ensureInitialized()
-
-  const docIDString = dittoCore.ditto_document_id_query_compatible(docID, stringPrimitiveFormat)
-  return dittoCore.boxCStringIntoString(docIDString)
-}
-
-/** @internal */
-export function validateDocumentID(docID: Uint8Array): Uint8Array {
-  trace()
-  ensureInitialized()
-
-  const cborCBytes = dittoCore.withOutBoxCBytes((outCBOR) => {
-    const errorCode = dittoCore.ditto_validate_document_id(docID, outCBOR)
-    if (errorCode !== 0) throw new Error(errorMessage() || `ditto_validate_document_id() failed with error code: ${errorCode}`)
-    return outCBOR
-  })
-
-  return dittoCore.boxCBytesIntoBuffer(cborCBytes)
-}
-
-// ----------------------------------------------------------- Collection ------
-
-/** @internal */
-export async function collectionGet(ditto: Pointer<FFIDitto>, collectionName: string, documentID: Uint8Array, readTransaction: Pointer<FFIReadTransaction>): Promise<Pointer<FFIDocument> | null> {
-  trace()
-  ensureInitialized()
-
-  // REFACTOR: add proper error handling.
-  const collectionNameX = bytesFromString(collectionName)
-
-  const { status_code: errorCode, document } = await dittoCore.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}`)
-  return document
-}
-
-/** @internal */
-export async function collectionInsertValue(ditto: Pointer<FFIDitto>, collectionName: string, doc_cbor: Uint8Array, writeStrategy: FFIWriteStrategy, writeTransaction?: Pointer<FFIWriteTransaction>): Promise<Uint8Array> {
-  trace()
-  ensureInitialized()
-
-  // REFACTOR: add proper error handling.
-  const collectionNameX = bytesFromString(collectionName)
-
-  let strategy
-  switch (writeStrategy) {
-    case 'merge':
-      strategy = 'Merge'
-      break
-    case 'insertIfAbsent':
-      strategy = 'InsertIfAbsent'
-      break
-    case 'insertDefaultIfAbsent':
-      strategy = 'InsertDefaultIfAbsent'
-      break
-    case 'updateDifferentValues':
-      strategy = 'UpdateDifferentValues'
-      break
-    default:
-      throw new Error(`Unsupported write strategy '${writeStrategy}' provided.`)
-  }
-
-  const { status_code: errorCode, id } = await dittoCore.ditto_collection_insert_value(ditto, collectionNameX, doc_cbor, strategy, null, writeTransaction ?? null)
-  if (errorCode !== 0) throw new Error(errorMessage() || `ditto_collection_insert_value() failed with error code: ${errorCode}`)
-  return dittoCore.boxCBytesIntoBuffer(id)
-}
-
-/** @internal */
-export async function collectionRemove(ditto: Pointer<FFIDitto>, collectionName: string, writeTransaction: Pointer<FFIWriteTransaction>, documentID: Uint8Array): Promise<boolean> {
-  trace()
-  ensureInitialized()
-
-  // REFACTOR: add proper error handling.
-  const collectionNameX = bytesFromString(collectionName)
-
-  const { status_code: errorCode, bool_value: didRemove } = await dittoCore.ditto_collection_remove(ditto, collectionNameX, writeTransaction, documentID)
-  if (errorCode !== 0) throw new Error(errorMessage() || `ditto_collection_remove() failed with error code: ${errorCode}`)
-  return didRemove
-}
-
-/** @internal */
-export async function collectionEvict(ditto: Pointer<FFIDitto>, collectionName: string, writeTransaction: Pointer<FFIWriteTransaction>, documentID: Uint8Array): Promise<boolean> {
-  trace()
-  ensureInitialized()
-
-  // REFACTOR: add proper error handling.
-  const collectionNameX = bytesFromString(collectionName)
-
-  const { status_code: errorCode, bool_value: didEvict } = await dittoCore.ditto_collection_evict(ditto, collectionNameX, writeTransaction, documentID)
-  if (errorCode !== 0) throw new Error(errorMessage() || `ditto_collection_evict() failed with error code: ${errorCode}`)
-  return didEvict
-}
-
-/** @internal */
-export async function collectionUpdate(ditto: Pointer<FFIDitto>, collectionName: string, writeTransaction: Pointer<FFIWriteTransaction>, document: Pointer<FFIDocument>): Promise<void> {
-  trace()
-  ensureInitialized()
-
-  const collectionNameX = bytesFromString(collectionName)
-  const errorCode = await dittoCore.ditto_collection_update(ditto, collectionNameX, writeTransaction, document)
-  if (errorCode !== 0) throw new Error(errorMessage() || `ditto_collection_update() failed with error code: ${errorCode}`)
-}
-
-/** @internal */
-export async function collectionUpdateMultiple(ditto: Pointer<FFIDitto>, collectionName: string, writeTransaction: Pointer<FFIWriteTransaction>, documents: Pointer<FFIDocument>[]): Promise<void> {
-  trace()
-  ensureInitialized()
-
-  const collectionNameX = bytesFromString(collectionName)
-  const cDocuments = dittoCore.jsDocsToCDocs(documents)
-  const errorCode = await dittoCore.ditto_collection_update_multiple(ditto, collectionNameX, writeTransaction, cDocuments)
-  if (errorCode !== 0) throw new Error(errorMessage() || `ditto_collection_update_multiple() failed with error code: ${errorCode}`)
-}
-
-/** @internal */
-export async function collectionExecQueryStr(ditto: Pointer<FFIDitto>, collectionName: string, writeTransaction: Pointer<FFIWriteTransaction>, query: string, queryArgsCBOR: Uint8Array | null, orderBy: OrderBy[], limit: number, offset: number): Promise<Pointer<FFIDocument>[]> {
-  trace()
-  ensureInitialized()
-
-  const collectionNameX = bytesFromString(collectionName)
-  const queryX = bytesFromString(query)
-  return await dittoCore.ditto_collection_exec_query_str(ditto, collectionNameX, writeTransaction, queryX, queryArgsCBOR, orderBy, limit, offset)
-}
-
-/** @internal */
-export async function collectionRemoveQueryStr(ditto: Pointer<FFIDitto>, collectionName: string, writeTransaction: Pointer<FFIWriteTransaction>, query: string, queryArgsCBOR: Uint8Array | null, orderBy: OrderBy[], limit: number, offset: number): Promise<Uint8Array[]> {
-  trace()
-  ensureInitialized()
-
-  const collectionNameX = bytesFromString(collectionName)
-  const queryX = bytesFromString(query)
-  return await dittoCore.ditto_collection_remove_query_str(ditto, collectionNameX, writeTransaction, queryX, queryArgsCBOR, orderBy, limit, offset)
-}
-
-/** @internal */
-export async function collectionEvictQueryStr(ditto: Pointer<FFIDitto>, collectionName: string, writeTransaction: Pointer<FFIWriteTransaction>, query: string, queryArgsCBOR: Uint8Array | null, orderBy: OrderBy[], limit: number, offset: number): Promise<Uint8Array[]> {
-  trace()
-  ensureInitialized()
-
-  const collectionNameX = bytesFromString(collectionName)
-  const queryX = bytesFromString(query)
-  return await dittoCore.ditto_collection_evict_query_str(ditto, collectionNameX, writeTransaction, queryX, queryArgsCBOR, orderBy, limit, offset)
-}
-
-/**
- * This FFI can error:
- * - DQL parser error
- * - Incorrect arguments to query parameters
- * - Collection is not found.
- *
- * @internal
- */
-export async function tryExecStatement(ditto: Pointer<FFIDitto>, writeTransaction: Pointer<FFIWriteTransaction> | null, query: string, queryArgsCBOR: Uint8Array | null): Promise<Pointer<FFIQueryResult>> {
-  trace()
-  ensureInitialized()
-
-  const queryBytesPointer = bytesFromString(query)
-  const result = await dittoCore.dittoffi_try_exec_statement(ditto, writeTransaction, queryBytesPointer, queryArgsCBOR)
-  throwOnErrorResult(result.error, 'dittoffi_try_exec_statement')
-  return result.success
-}
-
-/** @internal */
-export function addSubscription(ditto: Pointer<FFIDitto>, collectionName: string, query: string, queryArgsCBOR: Uint8Array | null, orderBy: OrderBy[], limit: number, offset: number): void {
-  trace()
-  ensureInitialized()
-
-  const collectionNameX = bytesFromString(collectionName)
-  const queryX = bytesFromString(query)
-  const statusCode = dittoCore.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}`)
-}
-
-/** @internal */
-export function removeSubscription(ditto: Pointer<FFIDitto>, collectionName: string, query: string, queryArgsCBOR: Uint8Array | null, orderBy: OrderBy[], limit: number, offset: number): void {
-  trace()
-  ensureInitialized()
-
-  const collectionNameX = bytesFromString(collectionName)
-  const queryX = bytesFromString(query)
-  const statusCode = dittoCore.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}`)
-}
-
-/** @internal */
-export function tryAddSyncSubscription(dittoPointer: Pointer<FFIDitto>, query: string, queryArgsCBOR: Uint8Array | null): void {
-  trace()
-  ensureInitialized()
-
-  const queryBuffer = bytesFromString(query)
-  const result = dittoCore.dittoffi_try_add_sync_subscription(dittoPointer, queryBuffer, queryArgsCBOR)
-  throwOnErrorResult(result.error, 'dittoffi_try_add_sync_subscription')
-  return
-}
-
-/** @internal */
-export function tryRemoveSyncSubscription(dittoPointer: Pointer<FFIDitto>, query: string, queryArgsCBOR: Uint8Array | null): void {
-  trace()
-  ensureInitialized()
-
-  const queryBuffer = bytesFromString(query)
-  const result = dittoCore.dittoffi_try_remove_sync_subscription(dittoPointer, queryBuffer, queryArgsCBOR)
-  throwOnErrorResult(result.error, 'dittoffi_try_remove_sync_subscription')
-  return
-}
-
-// ----------------------------------------------------------- QueryResult ------
-
-/**
- * Doesn't error
- *
- * @internal
- */
-export function queryResultFree(queryResultPointer: Pointer<FFIQueryResult>) {
-  trace()
-  ensureInitialized()
-
-  dittoCore.dittoffi_query_result_free(queryResultPointer)
-}
-
-/**
- * Doesn't error
- *
- * @internal
- */
-export function queryResultItemFree(queryResultItemPointer: Pointer<FFIQueryResultItem>) {
-  trace()
-  ensureInitialized()
-
-  dittoCore.dittoffi_query_result_item_free(queryResultItemPointer)
-}
-
-/**
- * Can error only on internal bug.
- *
- * @internal */
-export function queryResultItems(queryResultPointer: Pointer<FFIQueryResult>): Pointer<FFIQueryResultItem>[] {
-  trace()
-  ensureInitialized()
-
-  const rv = []
-  const resultCount = dittoCore.dittoffi_query_result_item_count(queryResultPointer)
-  for (let i = 0; i < resultCount; i++) {
-    rv.push(dittoCore.dittoffi_query_result_item_at(queryResultPointer, i))
-  }
-  return rv
-}
-
-/**
- * Doesn't error
- *
- * @internal
- */
-export function queryResultMutatedDocumentIDs(queryResultPointer: Pointer<FFIQueryResult>): Uint8Array[] {
-  trace()
-  ensureInitialized()
-
-  const rv = []
-  const resultCount = dittoCore.dittoffi_query_result_mutated_document_id_count(queryResultPointer)
-  for (let i = 0; i < resultCount; i++) {
-    const cborBytes = dittoCore.dittoffi_query_result_mutated_document_id_at(queryResultPointer, i)
-    rv.push(dittoCore.boxCBytesIntoBuffer(cborBytes))
-  }
-  return rv
-}
-
-/**
- * The result CBOR contains a map/object with fields and values. No CRDTs are
- * present there as they are not needed. By default only values from registers
- * are returned and non-register fields are ignored.
- *
- * Doesn't error
- *
- * @internal
- */
-export function queryResultItemCBOR(queryResultItemPointer: Pointer<FFIQueryResultItem>): Uint8Array {
-  trace()
-  ensureInitialized()
-
-  const cborBytes = dittoCore.dittoffi_query_result_item_cbor(queryResultItemPointer)
-  return dittoCore.boxCBytesIntoBuffer(cborBytes)
-}
-
-/**
- * Returns JSON-encoded results given a DQL result item pointer.
- *
- * Compare for {@link queryResultItemCBOR} above.
- *
- * Doesn't error
- *
- * @internal
- */
-export function queryResultItemJSON(queryResultItemPointer: Pointer<FFIQueryResultItem>): string {
-  trace()
-  ensureInitialized()
-
-  const jsonBytes = dittoCore.dittoffi_query_result_item_json(queryResultItemPointer)
-  return dittoCore.boxCStringIntoString(jsonBytes)
-}
-
-// ------------------------------------------------------------ LiveQuery ------
-
-/** @internal */
-export function liveQueryRegister(
-  ditto: Pointer<FFIDitto>,
-  collectionName: string,
-  query: string,
-  queryArgsCBOR: Uint8Array | null,
-  orderBy: OrderBy[],
-  limit: number,
-  offset: number,
-  eventHandler: (cbParams: CBParamsDocs) => any,
-  // Cb may be called in parallel at any point, so let's use
-  // an optional error handler (which defaults to the ditto logger at 'Error' level).
-  onError?: (error: any) => void,
-): number {
-  trace()
-  ensureInitialized()
-
-  const collectionNameBuffer = bytesFromString(collectionName)
-  const queryBuffer = bytesFromString(query)
-  // Note(Daniel): the callback is now registered to be called in a detached
-  // manner: if the FFI / Rust does `cb()`, then when that call returns, the js
-  // 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 } = dittoCore.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}`)
-  return id
-}
-
-/** @internal */
-export function tryExperimentalRegisterChangeObserver(ditto: Pointer<FFIDitto>, query: string, queryArgsCBOR: Uint8Array | null, changeHandler: (cbParams: CBParamsQueryResult) => any): number {
-  trace()
-  ensureInitialized()
-
-  const errorHandler = (err: any) => log('Error', `The registered store observer callback failed with ${err}`)
-  const wrappedCallback = wrapBackgroundCbForFFI(errorHandler, changeHandler)
-  const queryBuffer = bytesFromString(query)
-  // Note(Daniel): the callback is registered to be called in a detached manner:
-  // if the FFI / Rust does `cb()`, then when that call returns, the js 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 result = dittoCore.dittoffi_try_experimental_register_change_observer_str_detached(ditto, queryBuffer, queryArgsCBOR, wrappedCallback)
-  throwOnErrorResult(result.error, 'dittoffi_try_experimental_register_change_observer_str_detached')
-  return result.success
-}
-
-/** @internal */
-export async function liveQueryStart(ditto: Pointer<FFIDitto>, liveQueryID: number): Promise<void> {
-  trace()
-  ensureInitialized()
-
-  const errorCode = await dittoCore.ditto_live_query_start(ditto, liveQueryID)
-  if (errorCode !== 0) throw new Error(errorMessage() || `\`ditto_live_query_start()\` failed with error code: ${errorCode}`)
-}
-
-/** @internal */
-export function liveQueryStop(ditto: Pointer<FFIDitto>, liveQueryID: number) {
-  trace()
-  ensureInitialized()
-
-  dittoCore.ditto_live_query_stop(ditto, liveQueryID)
-}
-
-/** @internal */
-export async function liveQuerySignalAvailableNext(ditto: Pointer<FFIDitto>, liveQueryID: number): Promise<void> {
-  trace()
-  ensureInitialized()
-
-  await dittoCore.ditto_live_query_signal_available_next(ditto, liveQueryID)
-}
-
-// ------------------------------------------------------------ Webhook ------
-
-/** @internal */
-export async function liveQueryWebhookRegister(ditto: Pointer<FFIDitto>, collectionName: string, query: string, orderBy: OrderBy[], limit: number, offset: number, url: string): Promise<Uint8Array> {
-  trace()
-  ensureInitialized()
-  const collectionNameBuffer = bytesFromString(collectionName)
-  const queryBuffer = bytesFromString(query)
-  const urlBuffer = bytesFromString(url)
-
-  const { status_code: errorCode, id } = await dittoCore.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}`)
-
-  return dittoCore.boxCBytesIntoBuffer(id)
-}
-
-/** @internal */
-export async function tryRegisterStoreObserverWebhook(ditto: Pointer<FFIDitto>, query: string, queryArgsCBOR: Uint8Array | null, url: string): Promise<Uint8Array> {
-  trace()
-  ensureInitialized()
-
-  const queryBuffer = bytesFromString(query)
-  const urlBuffer = bytesFromString(url)
-
-  const result = await dittoCore.dittoffi_try_register_store_observer_webhook(ditto, queryBuffer, queryArgsCBOR, urlBuffer)
-  throwOnErrorResult(result.error, 'dittoffi_try_register_store_observer_webhook')
-  const documentIdCBOR = result.success
-
-  return dittoCore.boxCBytesIntoBuffer(documentIdCBOR)
-}
-
-// ------------------------------------------------------ ReadTransaction ------
-
-/** @internal */
-export async function readTransaction(ditto: Pointer<FFIDitto>): Promise<Pointer<FFIReadTransaction>> {
-  trace()
-  ensureInitialized()
-
-  // REFACTOR: add proper error handling.
-
-  const { status_code: errorCode, txn: readTransaction } = await dittoCore.ditto_read_transaction(ditto)
-  if (errorCode !== 0) throw new Error(errorMessage() || `\`ditto_read_transaction()\` failed with error code: ${errorCode}`)
-  return readTransaction
-}
-
-/** @internal */
-export function readTransactionFree(self: Pointer<FFIReadTransaction>) {
-  trace()
-  ensureInitialized()
-
-  // REFACTOR: add proper error handling.
-  return dittoCore.ditto_read_transaction_free(self)
-}
-
-// ----------------------------------------------------- WriteTransaction ------
-
-/** @internal */
-export async function writeTransaction(ditto: Pointer<FFIDitto>): Promise<Pointer<FFIWriteTransaction>> {
-  trace()
-  ensureInitialized()
-
-  // REFACTOR: add proper error handling.
-
-  const { status_code: errorCode, txn: writeTransaction } = await dittoCore.ditto_write_transaction(ditto, null)
-  if (errorCode !== 0) throw new Error(errorMessage() || `ditto_write_transaction() failed with error code: ${errorCode}`)
-  return writeTransaction
-}
-
-/** @internal */
-export async function writeTransactionCommit(ditto: Pointer<FFIDitto>, self: Pointer<FFIWriteTransaction>): Promise<void> {
-  trace()
-  ensureInitialized()
-
-  const errorCode = await dittoCore.ditto_write_transaction_commit(ditto, self)
-  if (errorCode !== 0) throw new Error(errorMessage() || `ditto_write_transaction_commit() failed with error code: ${errorCode}`)
-}
-
-/** @internal */
-export async function writeTransactionRollback(ditto: Pointer<FFIDitto>, transaction: Pointer<FFIWriteTransaction>): Promise<void> {
-  trace()
-  ensureInitialized()
-
-  const errorCode = await dittoCore.ditto_write_transaction_rollback(ditto, transaction)
-  if (errorCode !== 0) throw new Error(errorMessage() || `ditto_write_transaction_rollback() failed with error code: ${errorCode}`)
-}
-
-// ------------------------------------------------------ StaticTCPClient ------
-
-/** @internal */
-export function addStaticTCPClient(ditto: Pointer<FFIDitto>, address: string): Pointer<FFIStaticTCPClient> {
-  trace()
-  ensureInitialized()
-
-  const addressBuffer = bytesFromString(address)
-  return dittoCore.ditto_add_static_tcp_client(ditto, addressBuffer)
-}
-
-/** @internal */
-export function staticTCPClientFreeHandle(self: Pointer<FFIStaticTCPClient>) {
-  trace()
-  dittoCore.static_tcp_client_free_handle(self)
-}
-
-// ------------------------------------------------------ WebsocketClient ------
-
-/** @internal */
-export function addWebsocketClient(ditto: Pointer<FFIDitto>, address: string, routingHint: number): Pointer<FFIWebsocketClient> {
-  trace()
-  ensureInitialized()
-
-  const addressBuffer = bytesFromString(address)
-  return dittoCore.ditto_add_websocket_client(ditto, addressBuffer, routingHint)
-}
-
-/** @internal */
-export function websocketClientFreeHandle(self: Pointer<FFIWebsocketClient>) {
-  trace()
-  ensureInitialized()
-  dittoCore.websocket_client_free_handle(self)
-}
-
-// --------------------------------------------------------------- Logger ------
-
-/** @internal */
-export function loggerInit() {
-  trace()
-  ensureInitialized()
-  dittoCore.ditto_logger_init()
-}
-
-/** @internal */
-export async function loggerSetCustomLogCb(cb: null | ((lvl: LogLevel, msg: string) => void)): Promise<void> {
-  trace()
-  ensureInitialized()
-
-  if (null === cb) {
-    await dittoCore.ditto_logger_set_custom_log_cb(null)
-  } else {
-    // IDEA: pass custom error handler here instead of null?
-    const wrappedCallback = wrapBackgroundCbForFFI(null, (loglevel: LogLevel, cMsg: Pointer<'char'>) => {
-      try {
-        const msg: string = dittoCore.boxCStringIntoString(cMsg)
-        cb(loglevel, msg)
-      } catch (e) {
-        log('Error', `The registered cb in \`ditto_logger_set_custom_log_cb()\` failed with: ${e}`)
-      }
-    })
-    await dittoCore.ditto_logger_set_custom_log_cb(wrappedCallback)
-  }
-}
-
-/** @internal */
-export function loggerEnabled(enabled: boolean) {
-  trace()
-  ensureInitialized()
-  dittoCore.ditto_logger_enabled(!!enabled)
-}
-
-/** @internal */
-export function loggerEnabledGet(): boolean {
-  trace()
-  ensureInitialized()
-  return !!dittoCore.ditto_logger_enabled_get()
-}
-
-/** @internal */
-export function loggerEmojiHeadingsEnabled(loggerEmojiHeadingsEnabled: boolean) {
-  trace()
-  ensureInitialized()
-  dittoCore.ditto_logger_emoji_headings_enabled(loggerEmojiHeadingsEnabled)
-}
-
-/** @internal */
-export function loggerEmojiHeadingsEnabledGet() {
-  trace()
-  ensureInitialized()
-  return dittoCore.ditto_logger_emoji_headings_enabled_get()
-}
-
-/** @internal */
-export function loggerMinimumLogLevel(logLevel: LogLevel) {
-  trace()
-  ensureInitialized()
-  dittoCore.ditto_logger_minimum_log_level(logLevel)
-}
-
-/** @internal */
-export function loggerMinimumLogLevelGet() {
-  trace()
-  ensureInitialized()
-  return dittoCore.ditto_logger_minimum_log_level_get()
-}
-
-/** @internal */
-export function loggerSetLogFile(path?: string) {
-  trace()
-  ensureInitialized()
-  const pathBytesOrNull = path ? bytesFromString(path) : null
-  const errorCode = dittoCore.ditto_logger_set_log_file(pathBytesOrNull)
-  if (errorCode !== 0) {
-    const message = errorMessage()
-    throw new Error(`Can't set log file, due to error: ${errorMessage}`)
-  }
-}
-
-/** @internal */
-export function log(level: LogLevel, message: string) {
-  trace()
-  ensureInitialized()
-  const messageBuffer = bytesFromString(message)
-  dittoCore.ditto_log(level, messageBuffer)
-}
-
-// ----------------------------------------------------------- AuthClient ------
-
-/** @internal */
-export function dittoIdentityConfigMakeOnlinePlayground(appID: string, sharedToken: string, baseURL: string): Pointer<FFIIdentityConfig> {
-  trace()
-  ensureInitialized()
-
-  const appIDX = bytesFromString(appID)
-  const sharedTokenX = bytesFromString(sharedToken)
-  const baseURLX = bytesFromString(baseURL)
-
-  const { status_code: errorCode, identity_config: identityConfig } = dittoCore.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}`)
-  return identityConfig
-}
-
-/** @internal */
-export function dittoIdentityConfigMakeOnlineWithAuthentication(appID: string, baseURL: string): Pointer<FFIIdentityConfig> {
-  trace()
-  ensureInitialized()
-
-  const appIDX = bytesFromString(appID)
-  const baseURLX = bytesFromString(baseURL)
-
-  const { status_code: errorCode, identity_config: identityConfig } = dittoCore.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}`)
-  return identityConfig
-}
-
-/** @internal */
-export function dittoIdentityConfigMakeOfflinePlayground(appId: string, siteID: number | BigInt): Pointer<FFIIdentityConfig> {
-  trace()
-  ensureInitialized()
-
-  const appIdX = bytesFromString(appId)
-  const siteIDX = Number(siteID)
-  const { status_code: errorCode, identity_config: identityConfig } = dittoCore.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}`)
-  return identityConfig
-}
-
-/** @internal */
-export function dittoIdentityConfigMakeSharedKey(appId: string, sharedKey: string, siteID: number | BigInt): Pointer<FFIIdentityConfig> {
-  trace()
-  ensureInitialized()
-
-  const appIdX = bytesFromString(appId)
-  const sharedKeyX = bytesFromString(sharedKey)
-  const siteIDX = Number(siteID)
-  const { status_code: errorCode, identity_config: identityConfig } = dittoCore.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}`)
-  return identityConfig
-}
-
-/** @internal */
-export function dittoIdentityConfigMakeManual(configCBORBase64: string): Pointer<FFIIdentityConfig> {
-  trace()
-  ensureInitialized()
-
-  const configCBORBase64X = bytesFromString(configCBORBase64)
-
-  const { status_code: errorCode, identity_config: identityConfig } = dittoCore.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}`)
-  return identityConfig
-}
-
-/** @internal */
-export function dittoAuthClientGetSiteID(ditto: Pointer<FFIDitto>): number | BigInt {
-  trace()
-  ensureInitialized()
-  return dittoCore.ditto_auth_client_get_site_id(ditto)
-}
-
-/** @internal */
-export function dittoAuthClientGetAppID(ditto: Pointer<FFIDitto>): string {
-  trace()
-  ensureInitialized()
-  const cString = dittoCore.ditto_auth_client_get_app_id(ditto)
-  return dittoCore.boxCStringIntoString(cString)
-}
-
-export function dittoAuthClientUserID(ditto: Pointer<FFIDitto>): string {
-  trace()
-  ensureInitialized()
-  const cStr = dittoCore.ditto_auth_client_user_id(ditto)
-  return dittoCore.boxCStringIntoString(cStr)
-}
-
-/** @internal */
-export function dittoAuthClientIsWebValid(ditto: Pointer<FFIDitto>): boolean {
-  trace()
-  ensureInitialized()
-  return dittoCore.ditto_auth_client_is_web_valid(ditto) !== 0
-}
-
-export function dittoAuthClientIsX509Valid(ditto: Pointer<FFIDitto>): boolean {
-  trace()
-  ensureInitialized()
-  return dittoCore.ditto_auth_client_is_x509_valid(ditto) !== 0
-}
-
-export async function dittoAuthClientLoginWithToken(ditto: Pointer<FFIDitto>, token: string, provider: string) {
-  trace()
-  ensureInitialized()
-
-  const tokenBytes = bytesFromString(token)
-  const providerBytes = bytesFromString(provider)
-
-  const errorCode = await dittoCore.ditto_auth_client_login_with_token(ditto, tokenBytes, providerBytes)
-  if (errorCode !== 0) throw new Error(errorMessage() || `Ditto failed to authenticate (error code: ${errorCode}).`)
-}
-
-export async function dittoAuthClientLoginWithUsernameAndPassword(ditto: Pointer<FFIDitto>, username: string, password: string, provider: string) {
-  trace()
-  ensureInitialized()
-
-  const usernameBytes = bytesFromString(username)
-  const passwordBytes = bytesFromString(password)
-  const providerBytes = bytesFromString(provider)
-
-  const errorCode = await dittoCore.ditto_auth_client_login_with_credentials(ditto, usernameBytes, passwordBytes, providerBytes)
-  if (errorCode !== 0) throw new Error(errorMessage() || `Ditto failed to authenticate (error code: ${errorCode}).`)
-}
-
-export async function dittoAuthClientLogout(ditto: Pointer<FFIDitto>) {
-  trace()
-  ensureInitialized()
-
-  const errorCode = await dittoCore.ditto_auth_client_logout(ditto)
-  if (errorCode !== 0) throw new Error(errorMessage() || `Ditto failed to logout (error code: ${errorCode}).`)
-}
-
-// ---------------------------------------------------------------- Ditto ------
-
-/** @internal */
-export function dittoMake(path: string, identityConfig: Pointer<FFIIdentityConfig>, historyTracking: string): Pointer<FFIDitto> {
-  trace()
-  ensureInitialized()
-
-  const pathPointer = bytesFromString(path)
-  return dittoCore.ditto_make(pathPointer, identityConfig, historyTracking)
-}
-
-/** @internal */
-export async function dittoGetCollectionNames(self: Pointer<FFIDitto>): Promise<string[]> {
-  trace()
-  ensureInitialized()
-
-  const result = await dittoCore.ditto_get_collection_names(self)
-  const errorCode = result.status_code
-  const cStringVec: { ptr: Pointer<'char *'>; len: number; cap: number } = result.names
-  if (errorCode !== 0) throw new Error(errorMessage() || `ditto_get_collection_names() failed with error code: ${errorCode}`)
-
-  const strings: string[] = dittoCore.cStringVecToStringArray(cStringVec) as string[]
-  return strings
-}
-
-/** @internal */
-export function dittoFree(self: Pointer<FFIDitto>) {
-  trace()
-  ensureInitialized()
-
-  // REFACTOR: add proper error handling.
-  return dittoCore.ditto_free(self)
-}
-
-/** @internal */
-export function getDeadlockTimeout(): number {
-  trace()
-  ensureInitialized()
-
-  return dittoCore.getDeadlockTimeout()
-}
-
-/** @internal */
-export function setDeadlockTimeout(duration: number): void {
-  trace()
-  ensureInitialized()
-
-  dittoCore.setDeadlockTimeout(duration)
-}
-
-/** @internal */
-export function dittoRegisterPresenceV1Callback(self: Pointer<FFIDitto>, cb: (json: string) => void): void {
-  trace()
-  ensureInitialized()
-
-  dittoCore.ditto_register_presence_v1_callback(
-    self,
-    wrapBackgroundCbForFFI(
-      (err) => log('Error', `The registered presence callback v1 errored with ${err}`),
-      (cJsonStr: Pointer<'char'>) => {
-        const jsonStr: string = dittoCore.refCStringToString(cJsonStr)
-        cb(jsonStr)
-      },
-    ),
-  )
-}
-
-/** @internal */
-export async function dittoClearPresenceCallback(self: Pointer<FFIDitto>): Promise<void> {
-  trace()
-  ensureInitialized()
-
-  return dittoCore.ditto_clear_presence_callback(self)
-}
-
-/** @internal */
-export function dittoRegisterPresenceV3Callback(self: Pointer<FFIDitto>, cb: (json: string) => void): void {
-  trace()
-  ensureInitialized()
-
-  dittoCore.ditto_register_presence_v3_callback(
-    self,
-    wrapBackgroundCbForFFI(
-      (err) => log('Error', `The registered presence callback v3 errored with ${err}`),
-      (cJsonStr: Pointer<'char'>) => {
-        const jsonStr: string = dittoCore.refCStringToString(cJsonStr)
-        cb(jsonStr)
-      },
-    ),
-  )
-}
-
-/** @internal */
-export async function dittoClearPresenceV3Callback(self: Pointer<FFIDitto>): Promise<void> {
-  trace()
-  ensureInitialized()
-
-  return dittoCore.ditto_clear_presence_v3_callback(self)
-}
-
-/** @internal */
-export function presencePeerMetadataJSON(self: Pointer<FFIDitto>): string {
-  trace()
-  ensureInitialized()
-
-  const result = dittoCore.dittoffi_presence_peer_metadata_json(self)
-  const typedArray = dittoCore.boxCBytesIntoBuffer(result)
-  const textDecoder = new TextDecoder()
-  return textDecoder.decode(typedArray)
-}
-
-/** @internal */
-export async function presenceTrySetPeerMetadataJSON(self: Pointer<FFIDitto>, jsonString: string) {
-  trace()
-  ensureInitialized()
-
-  const jsonDataCString = bytesFromString(jsonString)
-  const result = await dittoCore.dittoffi_presence_try_set_peer_metadata_json(self, jsonDataCString)
-  throwOnErrorResult(result.error, 'dittoffi_presence_try_set_peer_metadata_json')
-}
-
-/** @internal */
-export function connectionRequestPeerKeyString(connectionRequest: Pointer<FFIConnectionRequest>): string {
-  trace()
-  ensureInitialized()
-
-  const cString = dittoCore.dittoffi_connection_request_peer_key_string(connectionRequest)
-  return dittoCore.boxCStringIntoString(cString)
-}
-
-/** @internal */
-export function connectionRequestPeerMetadataJSON(connectionRequest: Pointer<FFIConnectionRequest>): string {
-  trace()
-  ensureInitialized()
-
-  const jsonByteRef = dittoCore.dittoffi_connection_request_peer_metadata_json(connectionRequest)
-  const jsonBuffer = dittoCore.refCBytesIntoBuffer(jsonByteRef)
-  const textDecoder = new TextDecoder()
-  return textDecoder.decode(jsonBuffer)
-}
-
-/** @internal */
-export function connectionRequestIdentityServiceMetadataJSON(connectionRequest: Pointer<FFIConnectionRequest>): string {
-  trace()
-  ensureInitialized()
-
-  const jsonBytesRef = dittoCore.dittoffi_connection_request_identity_service_metadata_json(connectionRequest)
-  const jsonBuffer = dittoCore.refCBytesIntoBuffer(jsonBytesRef)
-  const textDecoder = new TextDecoder()
-  return textDecoder.decode(jsonBuffer)
-}
-
-/** @internal */
-export function connectionRequestConnectionType(connectionRequest: Pointer<FFIConnectionRequest>): Transport {
-  trace()
-  ensureInitialized()
-
-  return dittoCore.dittoffi_connection_request_connection_type(connectionRequest)
-}
-
-/** @internal */
-export function connectionRequestAuthorize(connectionRequest: Pointer<FFIConnectionRequest>, authorization: ConnectionRequestAuthorization) {
-  trace()
-  ensureInitialized()
-
-  dittoCore.dittoffi_connection_request_authorize(connectionRequest, authorization)
-}
-
-/** @internal */
-export function connectionRequestFree(connectionRequest: Pointer<FFIConnectionRequest>) {
-  trace()
-  ensureInitialized()
-
-  dittoCore.dittoffi_connection_request_free(connectionRequest)
-}
-
-/** @internal */
-export function presenceSetConnectionRequestHandler(ditto: Pointer<FFIDitto>, connectionRequestHandler?: (connectionRequest: Pointer<FFIConnectionRequest>) => void, onError?: (err: any) => void) {
-  trace()
-  ensureInitialized()
-
-  if (connectionRequestHandler == null) {
-    dittoCore.dittoffi_presence_set_connection_request_handler(ditto, null)
-  } else {
-    const wrappedCallback = wrapAsyncBackgroundCbForFFI(onError, connectionRequestHandler)
-    dittoCore.dittoffi_presence_set_connection_request_handler(ditto, wrappedCallback)
-  }
-}
-
-/** @internal */
-export function dittoSmallPeerInfoGetIsEnabled(dittoPointer: Pointer<FFIDitto>): boolean {
-  trace()
-  ensureInitialized()
-
-  return dittoCore.ditto_small_peer_info_get_is_enabled(dittoPointer)
-}
-
-/** @internal */
-export async function dittoSmallPeerInfoSetEnabled(dittoPointer: Pointer<FFIDitto>, isEnabled: boolean): Promise<void> {
-  trace()
-  ensureInitialized()
-
-  dittoCore.ditto_small_peer_info_set_enabled(dittoPointer, isEnabled)
-}
-
-/** @internal */
-export async function dittoSmallPeerInfoGetSyncScope(dittoPointer: Pointer<FFIDitto>): Promise<FFISmallPeerInfoSyncScope> {
-  trace()
-  ensureInitialized()
-
-  return dittoCore.ditto_small_peer_info_get_sync_scope(dittoPointer)
-}
-
-/** @internal */
-export async function dittoSmallPeerInfoSetSyncScope(dittoPointer: Pointer<FFIDitto>, syncScope: FFISmallPeerInfoSyncScope): Promise<void> {
-  trace()
-  ensureInitialized()
-
-  return dittoCore.ditto_small_peer_info_set_sync_scope(dittoPointer, syncScope)
-}
-
-/** @internal */
-export function dittoSmallPeerInfoGetMetadata(dittoPointer: Pointer<FFIDitto>): string {
-  trace()
-  ensureInitialized()
-
-  const cString = dittoCore.ditto_small_peer_info_get_metadata(dittoPointer)
-  return dittoCore.boxCStringIntoString(cString)
-}
-
-/** @internal */
-export function dittoSmallPeerInfoSetMetadata(dittoPointer: Pointer<FFIDitto>, metadata: string): void {
-  trace()
-  ensureInitialized()
-
-  const metadataCString = bytesFromString(metadata)
-  const statusCode = dittoCore.ditto_small_peer_info_set_metadata(dittoPointer, metadataCString)
-  switch (statusCode) {
-    case 0:
-      return
-    case -1:
-      throw new Error('Internal inconsistency, the observability subsystem is unavailable.')
-    case 1:
-      throw new Error(`Validation error, size limit exceeded: ${errorMessage() || 'metadata is too big'}`)
-    case 2:
-      throw new Error(`Validation error, ${errorMessage() || 'depth limit for metadata object exceeded'}`)
-    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}`)
-  }
-}
-
-/** @internal */
-export function dittoSmallPeerInfoCollectionSetTransportConfigData(self: Pointer<FFIDitto>, transportConfigData: Uint8Array): void {
-  trace()
-  ensureInitialized()
-
-  dittoCore.ditto_small_peer_info_set_transport_config_data(self, transportConfigData)
-}
-
-/** @internal */
-export function dittoRegisterTransportConditionChangedCallback(self: Pointer<FFIDitto>, cb: null | ((ConditionSource, TransportCondition) => void)) {
-  trace()
-  ensureInitialized()
-
-  if (!cb) {
-    dittoCore.ditto_register_transport_condition_changed_callback(self, null)
-  } else {
-    dittoCore.ditto_register_transport_condition_changed_callback(
-      self,
-      wrapBackgroundCbForFFI((err) => log('Error', `The registered "transport condition changed" callback errored with ${err}`), cb),
-    )
-  }
-}
-
-/** @internal */
-export function dittoSetDeviceName(dittoPointer: Pointer<FFIDitto>, deviceName: string): string {
-  trace()
-  ensureInitialized()
-
-  const deviceNameCString = bytesFromString(deviceName)
-  const truncatedDeviceNameCString = dittoCore.ditto_set_device_name(dittoPointer, deviceNameCString)
-  return dittoCore.boxCStringIntoString(truncatedDeviceNameCString)
-}
-
-/** @internal */
-export function dittoSetConnectRetryInterval(dittoPointer: Pointer<FFIDitto>, retryInterval: number) {
-  trace()
-  ensureInitialized()
-
-  // Unfortunately JS doesn't have a u32::MAX const...
-  const UINT32_MAX = 4_294_967_295
-  // Clamp the provided interval to u32 range (0 .. 2^32-1).
-  const clampedInterval = Math.min(Math.max(0, retryInterval), UINT32_MAX)
-
-  return dittoCore.ditto_set_connect_retry_interval(dittoPointer, clampedInterval)
-}
-
-/** @internal */
-export function dittoSetSyncGroup(dittoPointer: Pointer<FFIDitto>, syncGroup: number) {
-  trace()
-  ensureInitialized()
-
-  return dittoCore.ditto_set_sync_group(dittoPointer, syncGroup)
-}
-
-// Not supported on Wasm.
-/** @internal */
-export function dittoNewAttachmentFromFile(ditto: Pointer<FFIDitto>, sourcePath: string, fileOperation: AttachmentFileOperation): RawAttachment {
-  trace()
-  ensureInitialized()
-
-  const sourcePathCString = bytesFromString(sourcePath)
-  const outAttachment: any = {}
-  const errorCode = dittoCore.ditto_new_attachment_from_file(ditto, sourcePathCString, fileOperation, outAttachment)
-  if (errorCode !== 0) {
-    throw new DittoFFIError(errorCode, null, `ditto_new_attachment_from_file() failed with error code: ${errorCode}`)
-  }
-  return outAttachment
-}
-
-/** @internal */
-export async function dittoNewAttachmentFromBytes(ditto: Pointer<FFIDitto>, bytes: Uint8Array): Promise<RawAttachment> {
-  trace()
-  ensureInitialized()
-
-  const outAttachment: any = {}
-  const errorCode = await dittoCore.ditto_new_attachment_from_bytes(ditto, bytes, outAttachment)
-  if (errorCode !== 0) {
-    throw new DittoFFIError(errorCode, null, `ditto_new_attachment_from_bytes() failed with error code: ${errorCode}`)
-  }
-  return outAttachment
-}
-
-/**
- * @throws {@link DittoFFIError}
- * @internal
- */
-export async function dittoResolveAttachment(
-  ditto: Pointer<FFIDitto>,
-  id: Uint8Array,
-  namedCallbacks: {
-    onComplete: (attachmentHandlePointer: Pointer<AttachmentHandle>) => void
-    onProgress: (downloaded: number | BigInt, toDownload: number | BigInt) => void
-    onDelete: () => void
-  },
-  // Cb may be called in parallel at any point, so let's use
-  // an optional error handler (which defaults to the ditto logger at 'Error' level).
-  onError?: (error: any) => void,
-): Promise<number | BigInt> {
-  trace()
-  ensureInitialized()
-
-  const { onComplete, onProgress, onDelete } = namedCallbacks
-
-  const wrappedOnComplete = wrapBackgroundCbForFFI(onError, onComplete)
-  const wrappedOnProgress = wrapBackgroundCbForFFI(onError, onProgress)
-  const wrappedOnDelete = wrapBackgroundCbForFFI(onError, onDelete)
-
-  const { status_code: errorCode, cancel_token: cancelToken } = await dittoCore.ditto_resolve_attachment(ditto, id, wrappedOnComplete, wrappedOnProgress, wrappedOnDelete)
-  if (errorCode !== 0) {
-    throw new DittoFFIError(errorCode, null, `ditto_resolve_attachment() failed with error code: ${errorCode}`)
-  }
-
-  return cancelToken
-}
-
-/** @internal */
-export function dittoCancelResolveAttachment(dittoPointer: Pointer<FFIDitto>, id: Uint8Array, cancelToken: number | BigInt) {
-  trace()
-  ensureInitialized()
-
-  const errorCode = dittoCore.ditto_cancel_resolve_attachment(dittoPointer, id, cancelToken)
-  if (errorCode !== 0) throw new Error(errorMessage() || `ditto_cancel_resolve_attachment() failed with error code: ${errorCode}`)
-}
-
-/** @internal */
-export function freeAttachmentHandle(attachmentHandlePointer: Pointer<AttachmentHandle>) {
-  trace()
-  ensureInitialized()
-  dittoCore.ditto_free_attachment_handle(attachmentHandlePointer)
-}
-
-/** @internal */
-export async function dittoGetAttachmentStatus(dittoPointer: Pointer<FFIDitto>, id: Uint8Array): Promise<Pointer<AttachmentHandle>> {
-  trace()
-  ensureInitialized()
-
-  const { status_code: errorCode, handle: attachmentHandle } = await dittoCore.ditto_get_attachment_status(dittoPointer, id)
-  if (errorCode !== 0) throw new Error(errorMessage() || `ditto_get_attachment_status() failed with error code: ${errorCode}`)
-  return attachmentHandle
-}
-
-/** @internal */
-export async function dittoGetCompleteAttachmentData(dittoPointer: Pointer<FFIDitto>, attachmentHandlePointer: Pointer<AttachmentHandle>): Promise<Uint8Array> {
-  trace()
-  ensureInitialized()
-
-  const { status: errorCode, data } = await dittoCore.ditto_get_complete_attachment_data(dittoPointer, attachmentHandlePointer)
-  if (errorCode !== 0) throw new Error(errorMessage() || `\`ditto_get_complete_attachment_data()\` failed with error code: ${errorCode}`)
-  return dittoCore.boxCBytesIntoBuffer(data)
-}
-
-/** @internal */
-export function dittoGetCompleteAttachmentPath(dittoPointer: Pointer<FFIDitto>, attachmentHandlePointer: Pointer<AttachmentHandle>): string {
-  trace()
-  ensureInitialized()
-
-  const pathCString = dittoCore.ditto_get_complete_attachment_path(dittoPointer, attachmentHandlePointer)
-  return dittoCore.refCStringToString(pathCString)
-}
-
-/** @internal */
-export function dittoGetSDKVersion(ditto: Pointer<FFIDitto>): string {
-  trace()
-  ensureInitialized()
-
-  const cString = dittoCore.ditto_get_sdk_version(ditto)
-  return dittoCore.boxCStringIntoString(cString)
-}
-
-/** @internal */
-export function dittoGetSDKSemver(): string {
-  trace()
-  ensureInitialized()
-
-  const cString = dittoCore.dittoffi_get_sdk_semver()
-  return dittoCore.boxCStringIntoString(cString)
-}
-
-/** @internal */
-export function dittoPresenceV1(self: Pointer<FFIDitto>): string {
-  trace()
-  ensureInitialized()
-
-  const cString = dittoCore.ditto_presence_v1(self)
-  return dittoCore.boxCStringIntoString(cString)
-}
-
-/** @internal */
-export function dittoPresenceV2(self: Pointer<FFIDitto>): string {
-  trace()
-  ensureInitialized()
-
-  const cString = dittoCore.ditto_presence_v2(self)
-  return dittoCore.boxCStringIntoString(cString)
-}
-
-/** @internal */
-export function dittoPresenceV3(self: Pointer<FFIDitto>): string {
-  trace()
-  ensureInitialized()
-
-  const cString = dittoCore.ditto_presence_v3(self)
-  return dittoCore.boxCStringIntoString(cString)
-}
-
-/** @internal */
-export function dittoStartTCPServer(dittoPointer: Pointer<FFIDitto>, bind: string) {
-  trace()
-  ensureInitialized()
-
-  const bindBuffer = bytesFromString(bind)
-  return dittoCore.ditto_start_tcp_server(dittoPointer, bindBuffer)
-}
-
-/** @internal */
-export function dittoStopTCPServer(dittoPointer: Pointer<FFIDitto>) {
-  trace()
-  ensureInitialized()
-
-  return dittoCore.ditto_stop_tcp_server(dittoPointer)
-}
-
-/** @internal */
-export async function dittoShutdown(dittoPointer: Pointer<FFIDitto>): Promise<void> {
-  trace()
-  ensureInitialized()
-
-  return await dittoCore.ditto_shutdown(dittoPointer)
-}
-
-/** @internal */
-export function dittoAddMulticastTransport(dittoPointer: Pointer<FFIDitto>) {
-  trace()
-  ensureInitialized()
-
-  return dittoCore.ditto_add_multicast_transport(dittoPointer)
-}
-
-/** @internal */
-export function dittoRemoveMulticastTransport(dittoPointer: Pointer<FFIDitto>) {
-  trace()
-  ensureInitialized()
-
-  return dittoCore.ditto_remove_multicast_transport(dittoPointer)
-}
-
-/** @internal */
-export function dittoStartHTTPServer(dittoPointer: Pointer<FFIDitto>, bind: string, staticPath: string | null, websocketMode: WebsocketMode, tlsCertPath: string | null, tlsKeyPath: string | null) {
-  trace()
-  ensureInitialized()
-
-  const bindBuffer = bytesFromString(bind)
-  const staticPathBuffer = bytesFromString(staticPath)
-  const tlsCertPathBuffer = bytesFromString(tlsCertPath)
-  const tlsKeyPathBuffer = bytesFromString(tlsKeyPath)
-  return dittoCore.ditto_start_http_server(dittoPointer, bindBuffer, staticPathBuffer, websocketMode, tlsCertPathBuffer, tlsKeyPathBuffer)
-}
-
-/** @internal */
-export function dittoStopHTTPServer(dittoPointer: Pointer<FFIDitto>) {
-  trace()
-  ensureInitialized()
-  return dittoCore.ditto_stop_http_server(dittoPointer)
-}
-
-/** @internal */
-export function dittoRunGarbageCollection(dittoPointer: Pointer<FFIDitto>) {
-  trace()
-  ensureInitialized()
-  return dittoCore.ditto_run_garbage_collection(dittoPointer)
-}
-
-/** @internal */
-export async function dittoDisableSyncWithV3(dittoPointer: Pointer<FFIDitto>): Promise<void> {
-  trace()
-  ensureInitialized()
-  const errorCode = await dittoCore.ditto_disable_sync_with_v3(dittoPointer)
-  if (errorCode !== 0) throw new Error(errorMessage() || `ditto_disable_sync_with_v3() failed with error code: ${errorCode}`)
-}
-
-export function dittoSetStaticTCPClients(ditto: Pointer<FFIDitto>, listOfServers: string[]) {
-  trace()
-  ensureInitialized()
-
-  if (Environment.isNodeBuild) {
-    const listOfServersBytes = listOfServers.map((server) => bytesFromString(server))
-    dittoCore.ditto_set_static_tcp_clients(ditto, listOfServersBytes)
-  }
-
-  if (Environment.isWebBuild) {
-    if (listOfServers.length > 0) {
-      throw new Error(`Web variant of Ditto does not support connecting to TCP servers: ${listOfServers.join(', ')}`)
-    }
-  }
-}
-
-export function dittoSetStaticWebsocketClients(ditto: Pointer<FFIDitto>, listOfServers: string[], routingHint: number) {
-  trace()
-  ensureInitialized()
-  const listOfServersBytes = listOfServers.map((server) => bytesFromString(server))
-  dittoCore.ditto_set_static_websocket_clients(ditto, listOfServersBytes, routingHint)
-}
-
-// ------------------------------------------------------ Hash & Mnemonic ------
-
-/** @internal */
-export function documentsHash(documents: Pointer<FFIDocument>[]): BigInt {
-  trace()
-  ensureInitialized()
-  const { status_code: errorCode, u64: hash } = dittoCore.ditto_documents_hash(documents)
-  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)
-}
-
-/** @internal */
-export function documentsHashMnemonic(documents: Pointer<FFIDocument>[]): string {
-  trace()
-  ensureInitialized()
-  const { status_code: errorCode, c_string } = dittoCore.ditto_documents_hash_mnemonic(documents)
-  if (errorCode !== 0) throw new Error(errorMessage() || `\`ditto_documents_hash_mnemonic()\` failed with error code: ${errorCode}`)
-  return dittoCore.boxCStringIntoString(c_string)
-}
-
-// ------------------------------------------------------------- base64 --------
-
-/** @internal */
-export function base64encode(bytes: Uint8Array, paddingMode: Base64PaddingMode): string {
-  const base64CString = dittoCore.dittoffi_base64_encode(bytes, paddingMode)
-  return dittoCore.boxCStringIntoString(base64CString)
-}
-
-/**
- * @throws {@link DittoFFIError} if the base64 string is invalid
- * @internal
- */
-export function tryBase64Decode(base64: string, paddingMode?: Base64PaddingMode): Uint8Array {
-  const base64BytesPointer = bytesFromString(base64)
-  const result = dittoCore.dittoffi_try_base64_decode(base64BytesPointer, paddingMode || null)
-  throwOnErrorResult(result.error, 'dittoffi_try_base64_decode')
-  return dittoCore.boxCBytesIntoBuffer(result.success)
-}
-
-// ------------------------------------------------------------- Auth ----------
-
-/** @internal */
-export function authServerAuthSubmitWithSuccess(req: Pointer<FFIAuthServerAuthRequest>, successCbor: Uint8Array): void {
-  trace()
-  ensureInitialized()
-  return dittoCore.auth_server_auth_submit_with_success(req, successCbor)
-}
-
-/** @internal */
-export function authServerAuthSubmitWithError(req: Pointer<FFIAuthServerAuthRequest>, errorCode: number): void {
-  trace()
-  ensureInitialized()
-  return dittoCore.auth_server_auth_submit_with_error(req, errorCode)
-}
-
-/** @internal */
-export function authServerRefreshSubmitWithSuccess(req: Pointer<FFIAuthServerRefreshRequest>, successCbor: Uint8Array): void {
-  trace()
-  ensureInitialized()
-  return dittoCore.auth_server_refresh_submit_with_success(req, successCbor)
-}
-
-/** @internal */
-export function authServerRefreshSubmitWithError(req: Pointer<FFIAuthServerRefreshRequest>, errorCode: number): void {
-  trace()
-  ensureInitialized()
-  return dittoCore.auth_server_refresh_submit_with_error(req, errorCode)
-}
-
-/** @internal */
-export function dittoUnregisterLocalAuthServer(ditto: Pointer<FFIDitto>): void {
-  trace()
-  ensureInitialized()
-  return dittoCore.ditto_unregister_local_auth_server(ditto)
-}
-
-/** @internal */
-export function dittoRegisterLocalAuthServer(namedArgs: {
-  ditto: Pointer<FFIDitto>
-  signingKeyPem: string
-  verifyingKeysPem: string[]
-  caKeyPem?: string
-  authCb: (authRequest: Pointer<FFIAuthServerAuthRequest>, cbor: Uint8Array) => void
-  refreshCb: (authRequest: Pointer<FFIAuthServerRefreshRequest>, cbor: Uint8Array) => void
-  // Cb may be called in parallel at any point, so let's use
-  // an optional error handler
-  onError?: (error: any) => void
-}): void {
-  const { ditto, signingKeyPem, verifyingKeysPem, caKeyPem, authCb, refreshCb, onError } = namedArgs
-  trace()
-  ensureInitialized()
-
-  const signingKeyPemFfi = bytesFromString(signingKeyPem)
-  const verifyingKeysPemFfi = verifyingKeysPem.map(bytesFromString)
-  const caKeyPemFfi = typeof caKeyPem !== 'undefined' ? bytesFromString(caKeyPem) : null
-  const authCbFfi = wrapBackgroundCbForFFI(onError, authCb)
-  const refreshCbFfi = wrapBackgroundCbForFFI(onError, refreshCb)
-  return dittoCore.ditto_register_local_auth_server(ditto, signingKeyPemFfi, verifyingKeysPemFfi, caKeyPemFfi, authCbFfi, refreshCbFfi)
-}
-
-/** @internal */
-export async function dittoAuthSetLoginProvider(ditto: Pointer<FFIDitto>, loginProvider: Pointer<FFILoginProvider>): Promise<void> {
-  trace()
-  ensureInitialized()
-
-  return await dittoCore.ditto_auth_set_login_provider(ditto, loginProvider)
-}
-
-/** @internal */
-export function dittoAuthClientMakeLoginProvider(
-  expiringCb: (secs_until_expiry: number) => void,
-  // Cb may be called in parallel at any point, so let's use an optional error handler
-  onError?: (error: any) => void,
-): Pointer<FFILoginProvider> {
-  trace()
-  ensureInitialized()
-
-  return dittoCore.ditto_auth_client_make_login_provider(wrapBackgroundCbForFFI(onError, expiringCb))
-}
-
-/** @internal */
-export function dittoAuthClientSetValidityListener(
-  ditto: Pointer<FFIDitto>,
-  validityUpdateCb: (isWebValid: boolean, isX509Valid: boolean) => void,
-  // Cb may be called in parallel at any point, so let's use an optional error handler
-  onError?: (error: any) => void,
-): void {
-  trace()
-  ensureInitialized()
-
-  const validityUpdateRawCb = wrapBackgroundCbForFFI(onError, function (isWebValidInt: number, isX509ValidInt: number) {
-    return validityUpdateCb(isWebValidInt === 1, isX509ValidInt === 1)
-  })
-
-  return dittoCore.ditto_auth_client_set_validity_listener(ditto, validityUpdateRawCb)
-}
-
-// ----------------------------------------------------------- Transports ------
-
-/**
- * We currently don't initialize transports through this function but rather in
- * the NAPI module registration in `transports.c` due to an issue with importing
- * the functions required by this function.
- * See https://github.com/getditto/ditto/issues/10723
- *
- * @internal
- */
-export function transportsInit(): void {
-  trace()
-  ensureInitialized()
-
-  // The symbols called below are not exported in the Wasm build.
-  if (Environment.isWebBuild) return
-
-  const { output: wasInitialized, errorType } = withTransportsError(dittoCore.ditto_sdk_transports_init)
-  if (wasInitialized === false) {
-    throw new Error(`Failed to initialize transports (${errorType} error)`)
-  }
-}
-
-/** @internal */
-export function transportsBLEIsAvailable(ditto: Pointer<FFIDitto>): boolean {
-  trace()
-  ensureInitialized()
-
-  if (Environment.isNodeBuild || Environment.isReactNativeBuild) {
-    return dittoCore.ditto_sdk_transports_ble_is_available(ditto)
-  }
-  return false
-}
-
-/** @internal */
-export function transportsBLECreate(ditto: Pointer<FFIDitto>): Pointer<TransportBluetooth> | null | void {
-  trace()
-  ensureInitialized()
-
-  if (Environment.isNodeBuild || Environment.isReactNativeBuild) {
-    const { output: blePointer, errorType } = withTransportsError(dittoCore.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 */
-export function transportsBLEDestroy(ble: Pointer<TransportBluetooth>): boolean | void {
-  trace()
-  ensureInitialized()
-
-  if (Environment.isNodeBuild || Environment.isReactNativeBuild) {
-    const { output: wasDestroyed, errorType } = withTransportsError(dittoCore.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 */
-export function transportsLANIsAvailable(ditto: Pointer<FFIDitto>): boolean {
-  trace()
-  ensureInitialized()
-
-  if (Environment.isNodeBuild || Environment.isReactNativeBuild) {
-    return dittoCore.ditto_sdk_transports_lan_is_available(ditto)
-  }
-  return false
-}
-
-/** @internal */
-export function transportsLANCreate(ditto: Pointer<FFIDitto>): Pointer<TransportLAN> | void {
-  trace()
-  ensureInitialized()
-
-  if (Environment.isNodeBuild || Environment.isReactNativeBuild) {
-    const { output: lanPointer, errorType } = withTransportsError(dittoCore.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 */
-export function transportsLANDestroy(lan: Pointer<TransportLAN>): boolean | void {
-  trace()
-  ensureInitialized()
-
-  if (Environment.isNodeBuild || Environment.isReactNativeBuild) {
-    const { output: wasDestroyed, errorType } = withTransportsError(dittoCore.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 */
-export function transportsAWDLIsAvailable(ditto: Pointer<FFIDitto>): boolean {
-  trace()
-  ensureInitialized()
-
-  if (Environment.isNodeBuild || Environment.isReactNativeBuild) {
-    return dittoCore.ditto_sdk_transports_awdl_is_available(ditto)
-  }
-  return false
-}
-
-/** @internal */
-export function transportsAWDLCreate(ditto: Pointer<FFIDitto>): Pointer<TransportAWDL> | null | void {
-  trace()
-  ensureInitialized()
-
-  if (Environment.isNodeBuild || Environment.isReactNativeBuild) {
-    const { output: awdlPointer, errorType } = withTransportsError(dittoCore.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 */
-export function transportsAWDLDestroy(awdl: Pointer<TransportAWDL>): boolean | void {
-  trace()
-  ensureInitialized()
-
-  if (Environment.isNodeBuild || Environment.isReactNativeBuild) {
-    const { output: wasDestroyed, errorType } = withTransportsError(dittoCore.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
-  }
-}
-
-/**
- * Helper type that extracts all but the last parameter from a function type.
- *
- * NOTE: will accept any parameters for functions that don't have typed parameters.
- */
-// prettier-ignore
-type ParametersExceptLast<F extends (...args: any[]) => any> = Parameters<F> extends [...infer U, any]
-  ? U
-  : any // FIXME: this should really be `never` but we don't have proper types for the FFI functions yet.
-
-/**
- * Calls the given FFI function with the passed in arguments and a newly
- * allocated `transportsErrorPointer` as the last argument, then returns its
- * result.
- *
- * The given function MUST take a `transportsErrorPointer` as its last argument.
- *
- * @param ffiFunction The FFI function to wrap.
- * @param args The arguments to pass to the FFI function, excluding the
- * `transportsErrorPointer`.
- * @returns An object with two properties: `output` and `errorType`. `output` is
- * the return value of the FFI function, and `errorType` is the value of the
- * `transportsErrorPointer` after the FFI function has been called.
- */
-function withTransportsError<T extends (...args: any[]) => any>(ffiFunction: T, ...args: ParametersExceptLast<T>): { output: ReturnType<T>; errorType: TransportsError } {
-  const transportsErrorPointer = dittoCore.ditto_sdk_transports_error_new()
-  const output = ffiFunction(...args, transportsErrorPointer)
-  const errorType: TransportsError = dittoCore.ditto_sdk_transports_error_value(transportsErrorPointer)
-  dittoCore.ditto_sdk_transports_error_free(transportsErrorPointer)
-  return { output, errorType }
-}
-
-// ---------------------------------------------------------------- Other ------
-
-/** @internal */
-let isInitialized = false
-
-if (Environment.isNodeBuild) {
-  isInitialized = true
-}
-
-if (Environment.isReactNativeBuild) {
-  isInitialized = true
-}
-
-/** @internal */
-export async function init(webAssemblyModule?: WebAssemblyModule): Promise<void> {
-  if (Environment.isWebBuild) {
-    if (webAssemblyModule) {
-      await dittoCore.init(webAssemblyModule as any)
-    } else {
-      await dittoCore.init()
-    }
-
-    isInitialized = true
-  }
-}
-
-/** @internal */
-export function initSDKVersion(platform: Platform, language: Language, semVer: string) {
-  trace()
-  ensureInitialized()
-
-  const platformCString = bytesFromString(platform)
-  const languageCString = bytesFromString(language)
-  const semVerCString = bytesFromString(semVer)
-
-  const errorCode = dittoCore.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}`)
-}
-
-/** @internal */
-export function tryVerifyLicense(license: string) {
-  trace()
-  ensureInitialized()
-
-  const licenseBuffer = bytesFromString(license)
-  const result = dittoCore.dittoffi_try_verify_license(licenseBuffer)
-  throwOnErrorResult(result.error, 'dittoffi_try_verify_license')
-}
-
-// ---------------------------------------------------- React Native only ------
-
-/** @internal */
-export function defaultDeviceName(): string | void {
-  if (Environment.isReactNativeBuild) {
-    // @ts-expect-error Throws method not-found on non-RN envs.
-    return dittoCore.defaultDeviceName()
-  }
-}
-
-/** @internal */
-export function getRandomValues<T extends ArrayBufferView>(array: T): T | void {
-  if (Environment.isReactNativeBuild) {
-    // @ts-expect-error Throws method not-found on non-RN envs.
-    return dittoCore.getRandomValues(array)
-  }
-}
-
-/** @internal */
-export function createDirectory(path: string): string | void {
-  if (Environment.isReactNativeBuild) {
-    // @ts-expect-error Throws method not-found on non-RN envs.
-    return dittoCore.createDirectory(path)
-  }
-}
-
-/** @internal */
-export function readFile(path: string): string {
-  if (Environment.isReactNativeBuild) {
-    // @ts-expect-error Throws method not-found on non-RN envs.
-    return dittoCore.readFile(path)
-  }
-}
-
-/** @internal */
-export function copyFile(source: string, destination: string, dittoPath: string): string {
-  if (Environment.isReactNativeBuild) {
-    // @ts-expect-error Throws method not-found on non-RN envs.
-    return dittoCore.copyFile(source, destination, dittoPath)
-  }
-}
-
-// -------------------------------------------------------------- Private ------
-
-/** @internal */
-const NOT_FOUND_ERROR_CODE = -30798
-
-/** @internal */
-// prettier-ignore
-function wrapBackgroundCbForFFI<
-  F extends (...args: any[]) => any,
-  E extends (err: any) => void | null
->(onError: E, cb: F): (
-  ret_sender: (result: ReturnType<F>) => any, ...args: Parameters<F>
-) => any {
-  // There's no need to wrap callbacks through JSI while they are not returning
-  // anything.
-  if (Environment.isReactNativeBuild) {
-    return cb
-  }
-
-  const errorHandler = onError ?? ((err: any) => log('Error', `The registered callback failed with ${err}`))
-
-  return (ret_sender: (result: ReturnType<F>) => any, ...args: Parameters<F>) => {
-    let ret: ReturnType<F>
-    try {
-      ret = cb(...args)
-    } catch (err) {
-      try {
-        errorHandler(err)
-      } catch (nested_error) {
-        log('Error', `Internal error: \`onError()\` handler oughtn't throw, but it did throw ${nested_error}`)
-      }
-    }
-    return ret_sender(ret)
-  }
-}
-
-/** @internal */
-// prettier-ignore
-function wrapAsyncBackgroundCbForFFI<
-  F extends (...args: any[]) => (Promise<any> | any),
-  E extends (err: any) => void | null
->(onError: E, cb: F): (
-  ret_sender: (result: ReturnType<F>) => unknown, ...args: Parameters<F>
-) => Promise<unknown> {
-  // There's no need to wrap callbacks through JSI while they are not returning
-  // anything.
-  if (Environment.isReactNativeBuild) {
-    return cb
-  }
-
-  const errorHandler = onError ?? ((err: any) => log('Error', `The registered callback failed with ${err}`))
-
-  return async (ret_sender: (result: ReturnType<F>) => any, ...args: Parameters<F>) => {
-    let ret: ReturnType<F>
-    try {
-      ret = await cb(...args)
-    } catch (err) {
-      try {
-        errorHandler(err)
-      } catch (nested_error) {
-        log('Error', `Internal error: \`onError()\` handler oughtn't throw, but it did throw ${nested_error}`)
-      }
-    }
-    return ret_sender(ret)
-  }
-}
-
-/** @internal */
-function bytesFromString(jsString: string | null | undefined): Uint8Array | null | undefined {
-  if (typeof jsString === 'undefined') return undefined
-  if (jsString === null) return null
-  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`)
-}
-
-/**
- * This is the legacy error-message retrieving function, using thread-local
- * storage.
- *
- * @internal
- */
-function errorMessage(): string {
-  trace()
-  ensureInitialized()
-
-  // eslint-disable-next-line
-  const errorMessageCString = dittoCore.ditto_error_message()
-  return dittoCore.boxCStringIntoString(errorMessageCString)
-}
-
-/** @internal */
-function trace() {
-  if (isTracingEnabled) {
-    // Copied and adapted from a Stack Overflow comment:
-    // https://stackoverflow.com/a/38435618
-    const error = new Error()
-    const stack = error.stack
-    let caller = '<unknown>'
-    try {
-      caller = stack.split('\n')[2].trim().split(/\s+/)[1].replace('Module.', '')
-    } catch (error) {
-      // Nothing to do, caller remains unknown.
-    }
-
-    // We use use `console.log()` instead of `log()` here to avoid infinite recursion.
-    // eslint-disable-next-line no-console
-    console.log(`💗 [TRACE] ${caller}()`)
-  }
-}
-
-/** @internal */
-function ensureInitialized() {
-  if (!isInitialized) {
-    throw new Error('Ditto needs to be initialized before using any of its API, please make sure to call `await init()` first.')
-  }
-}