@dittolive/ditto 4.5.1-experimental.aarch64-linux.1.aarch64 → 4.5.2-rc.2

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

@@ -0,0 +1,2012 @@
+//
+// 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 { 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'
+
+/** @internal */
+export type FFIDocument = 'CDocument_t'
+
+/** @internal */
+export type FFIDqlResult = 'CDqlResult_t'
+
+/** @internal */
+export type FFIDqlResponse = 'CDqlResponse_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 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 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<FFIDqlResponse>
+}
+
+/** @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 ------
+
+export function dittoAddInternalBLEClientTransport(ditto: Pointer<FFIDitto>): any {
+  if (Environment.isNodeBuild) {
+    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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    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()
+
+  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()
+
+  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()
+
+  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()
+
+  const collectionNameX = bytesFromString(collectionName)
+
+  let strategy
+  switch (writeStrategy) {
+    case 'merge':
+      strategy = 'Merge'
+      break
+    case 'insertIfAbsent':
+      strategy = 'InsertIfAbsent'
+      break
+    case 'insertDefaultIfAbsent':
+      strategy = 'InsertDefaultIfAbsent'
+      break
+    default:
+      throw new Error('Invalid write strategy 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()
+
+  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()
+
+  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 tryExperimentalExecQueryStr(ditto: Pointer<FFIDitto>, writeTransaction: Pointer<FFIWriteTransaction> | null, query: string, queryArgsCBOR: Uint8Array | null): Promise<Pointer<FFIDqlResponse>> {
+  trace()
+  ensureInitialized()
+
+  const queryBytesPointer = bytesFromString(query)
+  const result = await dittoCore.dittoffi_try_experimental_exec_statement_str(ditto, writeTransaction, queryBytesPointer, queryArgsCBOR)
+  throwOnErrorResult(result.error, 'dittoffi_try_experimental_exec_statement_str')
+  return result.success
+}
+
+/** @internal */
+export function addSubscription(ditto: Pointer<FFIDitto>, collectionName: string, query: string, queryArgsCBOR: Uint8Array | null, orderBy: OrderBy[], limit: number, offset: number) {
+  trace()
+  ensureInitialized()
+
+  const collectionNameX = bytesFromString(collectionName)
+  const queryX = bytesFromString(query)
+  return dittoCore.ditto_add_subscription(ditto, collectionNameX, queryX, queryArgsCBOR, orderBy, limit, offset)
+}
+
+/** @internal */
+export function removeSubscription(ditto: Pointer<FFIDitto>, collectionName: string, query: string, queryArgsCBOR: Uint8Array | null, orderBy: OrderBy[], limit: number, offset: number) {
+  trace()
+  ensureInitialized()
+
+  const collectionNameX = bytesFromString(collectionName)
+  const queryX = bytesFromString(query)
+  return dittoCore.ditto_remove_subscription(ditto, collectionNameX, queryX, queryArgsCBOR, orderBy, limit, offset)
+}
+
+/** @internal */
+export function tryExperimentalAddDQLSubscription(dittoPointer: Pointer<FFIDitto>, query: string, queryArgsCBOR: Uint8Array | null): void {
+  trace()
+  ensureInitialized()
+
+  const queryBuffer = bytesFromString(query)
+  const result = dittoCore.dittoffi_try_experimental_add_dql_subscription(dittoPointer, queryBuffer, queryArgsCBOR)
+  throwOnErrorResult(result.error, 'dittoffi_try_experimental_add_dql_subscription')
+  return
+}
+
+/** @internal */
+export function tryExperimentalRemoveDQLSubscription(dittoPointer: Pointer<FFIDitto>, query: string, queryArgsCBOR: Uint8Array | null): void {
+  trace()
+  ensureInitialized()
+
+  const queryBuffer = bytesFromString(query)
+  const result = dittoCore.dittoffi_try_experimental_remove_dql_subscription(dittoPointer, queryBuffer, queryArgsCBOR)
+  throwOnErrorResult(result.error, 'dittoffi_try_experimental_remove_dql_subscription')
+  return
+}
+
+// ----------------------------------------------------------- DqlResponse ------
+
+/**
+ * Doesn't error
+ *
+ * @internal
+ */
+export function dqlResponseFree(responsePointer: Pointer<FFIDqlResponse>) {
+  trace()
+  ensureInitialized()
+
+  dittoCore.ditto_dql_response_free(responsePointer)
+}
+
+/**
+ * Doesn't error
+ *
+ * @internal
+ */
+export function dqlResultFree(resultPointer: Pointer<FFIDqlResult>) {
+  trace()
+  ensureInitialized()
+
+  dittoCore.ditto_dql_result_free(resultPointer)
+}
+
+/**
+ * Can error only on internal bug.
+ *
+ * @internal */
+export function dqlResponseResults(responsePointer: Pointer<FFIDqlResponse>): Pointer<FFIDqlResult>[] {
+  trace()
+  ensureInitialized()
+
+  const rv = []
+  const resultCount = dittoCore.ditto_dql_response_result_count(responsePointer)
+  for (let i = 0; i < resultCount; i++) {
+    rv.push(dittoCore.ditto_dql_response_result_at(responsePointer, i))
+  }
+  return rv
+}
+
+/**
+ * Doesn't error
+ *
+ * @internal
+ */
+export function dqlMutatedDocumentIDs(responsePointer: Pointer<FFIDqlResponse>): Uint8Array[] {
+  trace()
+  ensureInitialized()
+
+  const rv = []
+  const resultCount = dittoCore.ditto_dql_response_affected_document_id_count(responsePointer)
+  for (let i = 0; i < resultCount; i++) {
+    const cborBytes = dittoCore.ditto_dql_response_affected_document_id_at(responsePointer, 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. Currently
+ * only values from registers are returned and non-register fields are
+ * ignored. Reading values from other CRDTs will be supported with
+ * definition support.
+ *
+ * Doesn't error
+ *
+ * @internal
+ */
+export function dqlResultCBOR(resultPointer: Pointer<FFIDqlResult>): Uint8Array {
+  trace()
+  ensureInitialized()
+
+  const cborBytes = dittoCore.ditto_result_cbor(resultPointer)
+  return dittoCore.boxCBytesIntoBuffer(cborBytes)
+}
+
+/**
+ * Returns JSON-encoded results given a DQL result pointer.
+ *
+ * Compare for {@link dqlResultCBOR} above.
+ *
+ * Doesn't error
+ *
+ * @internal
+ */
+export function dqlResultJSON(resultPointer: Pointer<FFIDqlResult>): string {
+  trace()
+  ensureInitialized()
+
+  const jsonBytes = dittoCore.ditto_result_json(resultPointer)
+  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 tryExperimentalWebhookRegisterDqlLiveQuery(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_experimental_webhook_register_dql_live_query_str(ditto, queryBuffer, queryArgsCBOR, urlBuffer)
+  throwOnErrorResult(result.error, 'dittoffi_try_experimental_webhook_register_dql_live_query_str')
+  const documentIdCBOR = result.success
+
+  return dittoCore.boxCBytesIntoBuffer(documentIdCBOR)
+}
+
+// ------------------------------------------------------ ReadTransaction ------
+
+/** @internal */
+export async function readTransaction(ditto: Pointer<FFIDitto>): Promise<Pointer<FFIReadTransaction>> {
+  trace()
+  ensureInitialized()
+
+  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()
+
+  return dittoCore.ditto_read_transaction_free(self)
+}
+
+// ----------------------------------------------------- WriteTransaction ------
+
+/** @internal */
+export async function writeTransaction(ditto: Pointer<FFIDitto>): Promise<Pointer<FFIWriteTransaction>> {
+  trace()
+  ensureInitialized()
+
+  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 uninitializedDittoMake(path: string): Pointer<FFIUninitializedDitto> {
+  trace()
+  ensureInitialized()
+  const pathX = bytesFromString(path)
+  return dittoCore.ditto_uninitialized_ditto_make(pathX)
+}
+
+/** @internal */
+export function dittoMake(uninitializedDitto: Pointer<FFIUninitializedDitto>, identityConfig: Pointer<FFIIdentityConfig>): Pointer<FFIDitto> {
+  trace()
+  ensureInitialized()
+  return dittoCore.ditto_make(uninitializedDitto, identityConfig, 'Disabled')
+}
+
+/** @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()
+
+  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 async function dittoRegisterPresenceV1Callback(self: Pointer<FFIDitto>, cb: (string) => void): Promise<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()
+  await dittoCore.ditto_clear_presence_callback(self)
+}
+
+/** @internal */
+export async function dittoRegisterPresenceV3Callback(self: Pointer<FFIDitto>, cb: (string) => 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>) {
+  trace()
+  ensureInitialized()
+  dittoCore.ditto_clear_presence_v3_callback(self)
+}
+
+/** @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 async function dittoSmallPeerInfoCollectionSetTransportConfigData(self: Pointer<FFIDitto>, transportConfigData: Uint8Array) {
+  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) {
+  trace()
+  ensureInitialized()
+
+  let deviceNameCString = bytesFromString(deviceName)
+
+  if (Environment.isWebBuild) {
+    if (deviceNameCString.length > 64) {
+      const sanitizedDeviceName = deviceName.replace(/[^ -~]+/g, '')
+      deviceNameCString = bytesFromString(sanitizedDeviceName.substr(0, 63))
+
+      // NOTE: to reproduce the issue, comment the following two in. You'll see
+      // that an ASCII string of 64 characters and more will make prevent sync
+      // from working.
+      //
+      // const demoDeviceName = "123456789-10-456789-20-456789-30-456789-40-456789-50-456789-60-4" //56789-70-456789-80-456789-90-456789" // 100
+      // deviceNameCString = bytesFromString(demoDeviceName)
+    }
+  }
+
+  return dittoCore.ditto_set_device_name(dittoPointer, deviceNameCString)
+}
+
+/** @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 Error(errorMessage() || `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 Error(errorMessage() || `ditto_new_attachment_from_bytes() failed with error code: ${errorCode}`)
+  }
+  return outAttachment
+}
+
+/** @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 { status_code: errorCode, cancel_token: cancelToken } = await dittoCore.ditto_resolve_attachment(ditto, id, wrapBackgroundCbForFFI(onError, onComplete), wrapBackgroundCbForFFI(onError, onProgress), wrapBackgroundCbForFFI(onError, onDelete))
+  if (errorCode !== 0) {
+    throw new Error(errorMessage() || `ditto_resolve_attachment() failed with error code: ${errorCode}`)
+  }
+  return cancelToken
+}
+
+/** @internal */
+export function dittoCancelResolveAttachment(dittoPointer: Pointer<FFIDitto>, id: Uint8Array, cancelToken: any) {
+  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)
+}
+
+// ------------------------------------------------------------- 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()
+
+  const transportsErrorPointer = dittoCore.ditto_sdk_transports_error_new()
+  const wasInitialized = dittoCore.ditto_sdk_transports_init(transportsErrorPointer)
+
+  const errorType: TransportsError = dittoCore.ditto_sdk_transports_error_value(transportsErrorPointer)
+  dittoCore.ditto_sdk_transports_error_free(transportsErrorPointer)
+
+  if (wasInitialized === false) {
+    throw new Error(`Failed to initialize transports (${errorType} error)`)
+  }
+}
+
+/** @internal */
+export function transportsBLEIsAvailable(ditto: Pointer<FFIDitto>): boolean {
+  trace()
+  ensureInitialized()
+
+  return dittoCore.ditto_sdk_transports_ble_is_available(ditto)
+}
+
+/** @internal */
+export function transportsBLECreate(ditto: Pointer<FFIDitto>): Pointer<TransportBluetooth> | null | void {
+  trace()
+  ensureInitialized()
+
+  const transportsErrorPointer = dittoCore.ditto_sdk_transports_error_new()
+  const blePointer: Pointer<TransportBluetooth> = dittoCore.ditto_sdk_transports_ble_create(ditto, transportsErrorPointer)
+
+  const errorType: TransportsError = dittoCore.ditto_sdk_transports_error_value(transportsErrorPointer)
+  dittoCore.ditto_sdk_transports_error_free(transportsErrorPointer)
+
+  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()
+
+  const ffiError = dittoCore.ditto_sdk_transports_error_new()
+  const wasDestroyed = dittoCore.ditto_sdk_transports_ble_destroy(ble, ffiError)
+
+  const errorType: TransportsError = dittoCore.ditto_sdk_transports_error_value(ffiError)
+  dittoCore.ditto_sdk_transports_error_free(ffiError)
+
+  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()
+
+  return dittoCore.ditto_sdk_transports_lan_is_available(ditto)
+}
+
+/** @internal */
+export function transportsLANCreate(ditto: Pointer<FFIDitto>): Pointer<TransportLAN> | void {
+  trace()
+  ensureInitialized()
+
+  const transportsErrorPointer = dittoCore.ditto_sdk_transports_error_new()
+  const lanPointer: Pointer<TransportLAN> = dittoCore.ditto_sdk_transports_lan_create(ditto, transportsErrorPointer)
+
+  const errorType: TransportsError = dittoCore.ditto_sdk_transports_error_value(transportsErrorPointer)
+  dittoCore.ditto_sdk_transports_error_free(transportsErrorPointer)
+
+  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()
+
+  const ffiError = dittoCore.ditto_sdk_transports_error_new()
+  const wasDestroyed = dittoCore.ditto_sdk_transports_lan_destroy(lan, ffiError)
+
+  const error: TransportsError = dittoCore.ditto_sdk_transports_error_value(ffiError)
+  dittoCore.ditto_sdk_transports_error_free(ffiError)
+
+  if (wasDestroyed === true) {
+    log('Info', 'LAN transport disabled.')
+  } else {
+    log('Error', `LAN transport could not be disabled (${error} error).`)
+  }
+  return wasDestroyed
+}
+
+/** @internal */
+export function transportsAWDLIsAvailable(ditto: Pointer<FFIDitto>): boolean {
+  trace()
+  ensureInitialized()
+
+  return dittoCore.ditto_sdk_transports_awdl_is_available(ditto)
+}
+
+/** @internal */
+export function transportsAWDLCreate(ditto: Pointer<FFIDitto>): Pointer<TransportAWDL> | null | void {
+  trace()
+  ensureInitialized()
+
+  const transportsErrorPointer = dittoCore.ditto_sdk_transports_error_new()
+  const awdlPointer: Pointer<TransportAWDL> = dittoCore.ditto_sdk_transports_awdl_create(ditto, transportsErrorPointer)
+
+  const errorType: TransportsError = dittoCore.ditto_sdk_transports_error_value(transportsErrorPointer)
+  dittoCore.ditto_sdk_transports_error_free(transportsErrorPointer)
+
+  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()
+
+  const ffiError = dittoCore.ditto_sdk_transports_error_new()
+  const wasDestroyed = dittoCore.ditto_sdk_transports_awdl_destroy(awdl, ffiError)
+
+  const errorType: TransportsError = dittoCore.ditto_sdk_transports_error_value(ffiError)
+  dittoCore.ditto_sdk_transports_error_free(ffiError)
+
+  if (wasDestroyed === true) {
+    log('Info', 'AWDL transport disabled.')
+  } else {
+    log('Error', `AWDL transport could not be disabled (${errorType} error).`)
+  }
+  return wasDestroyed
+}
+
+// ---------------------------------------------------------------- Other ------
+
+/** @internal */
+let isInitialized = false
+
+/** @internal */
+let withOutPtr: (ptr_type: string, callback: any) => any
+
+if (Environment.isNodeBuild) {
+  isInitialized = true
+  withOutPtr = wrapFFIOutFunction(dittoCore.withOutPtr)
+}
+
+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
+    withOutPtr = wrapFFIOutFunction(dittoCore.withOutPtr)
+  }
+}
+
+/** @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 verifyLicense(license: string): { result: LicenseVerificationResult; errorMessage?: string } {
+  trace()
+  ensureInitialized()
+
+  const licenseBuffer = bytesFromString(license)
+  let result: LicenseVerificationResult
+  const errorMessageCString = withOutPtr('char *', (outErrorMessage) => {
+    result = dittoCore.ditto_verify_license(licenseBuffer, outErrorMessage)
+    return outErrorMessage
+  })
+
+  const errorMessage = dittoCore.boxCStringIntoString(errorMessageCString)
+  return { result, errorMessage }
+}
+
+// ---------------------------------------------------- React Native only ------
+
+/** @internal */
+export function getDeviceName(): string | void {
+  if (Environment.isReactNativeBuild) {
+    // @ts-expect-error Throws method not-found on non-RN envs.
+    return dittoCore.getDeviceName()
+  }
+}
+
+/** @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)
+  }
+}
+
+// -------------------------------------------------------------- Private ------
+
+/** @internal */
+const NOT_FOUND_ERROR_CODE = -30798
+
+/** @internal */
+function wrapBackgroundCbForFFI(onError: null | ((err: any) => void), cb: any): any {
+  // There's no need to wrap callbacks through JSI while they are not returning
+  // anything.
+  if (Environment.isReactNativeBuild) {
+    return cb
+  }
+  // Basic fallback based off: https://stackoverflow.com/a/3390635
+  if (onError === undefined) {
+    onError = (err: any) => log('Error', `The registered callback failed with ${err}`)
+  }
+  return (ret_sender, ...args) => {
+    let ret
+    try {
+      ret = cb(...args)
+    } catch (err) {
+      try {
+        onError(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 wrapFFIOutFunction(ffiOutFunction: any): any {
+  return function (...args) {
+    let occurredError = undefined
+    let callbackResult = undefined
+    let isCallbackResultOutParameter = false
+
+    const callback = args[args.length - 1]
+    const previous_args = args.splice(0, args.length - 1)
+
+    const dittoCoreResult = ffiOutFunction(...previous_args, (outParameter) => {
+      try {
+        callbackResult = callback(outParameter)
+        isCallbackResultOutParameter = callbackResult === outParameter
+      } catch (error) {
+        occurredError = error
+      }
+    })
+
+    if (occurredError) {
+      throw occurredError
+    }
+
+    return isCallbackResultOutParameter ? dittoCoreResult : callbackResult
+  }
+}
+
+/** @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.')
+  }
+}