@evolu/common 6.0.1-preview.20 → 6.0.1-preview.21

package/src/Evolu/Protocol.ts

@@ -1,4 +1,3 @@
-/* eslint-disable jsdoc/no-undefined-types */
 /**
  * Evolu Protocol
  *
@@ -21,7 +20,7 @@
  * transfer, ownership, real-time broadcasting, request-response semantics, and
  * error handling.
  *
- * ### Message Structure
+ * ### Message structure
  *
  * | Field                          | Notes                     |
  * | :----------------------------- | :------------------------ |
@@ -44,7 +43,7 @@
  * | - {@link NonNegativeInt}       | Number of ranges.         |
  * | - {@link Range}                |                           |
  *
- * ### WriteKey Validation
+ * ### WriteKey validation
  *
  * The initiator sends a hasWriteKey flag and optionally a WriteKey. The
  * WriteKey is required when sending messages as a secure token proving the
@@ -80,33 +79,33 @@
  * initiator. In relay-to-relay or P2P sync, both sides may require the
  * {@link OwnerWriteKey} depending on who is the initiator.
  *
- * ### Protocol Errors
+ * ### Protocol errors
  *
  * The protocol uses error codes in the header to signal issues:
  *
  * - {@link ProtocolWriteKeyError}: The provided WriteKey is invalid or missing.
- * - {@link ProtocolWriteError}: A write operation failed (e.g., due to storage
- *   limits or billing).
- * - {@link ProtocolSyncError}: A generic or unexpected synchronization failure
+ * - {@link ProtocolWriteError}: A serious relay-side write failure occurred.
+ * - {@link ProtocolSyncError}: A serious relay-side synchronization failure
  *   occurred.
+ * - {@link ProtocolQuotaExceededError}: Storage or billing quota exceeded.
  * - {@link ProtocolUnsupportedVersionError}: Protocol version mismatch.
  * - {@link ProtocolInvalidDataError}: The message is malformed or corrupted.
  *
  * All protocol errors except `ProtocolInvalidDataError` include the `OwnerId`
  * to allow clients to associate errors with the correct owner.
  *
- * ### Message Size Limit
+ * ### Message size limit
  *
  * The protocol enforces a strict maximum size for all messages, defined by
- * {@link maxProtocolMessageSize}. This ensures every {@link ProtocolMessage} is
+ * {@link ProtocolMessageMaxSize}. This ensures every {@link ProtocolMessage} is
  * less than or equal to this limit, enabling stateless transports, simplified
  * relay implementation, and predictable memory usage. When all messages don't
  * fit within the limit, the protocol automatically continues synchronization in
  * subsequent rounds using range-based reconciliation.
  *
- * Individual database mutations are limited to `maxMutationSize` (640KB), which
- * is smaller than the protocol message limit to ensure efficient sync with
- * {@link maxProtocolMessageRangesSize}.
+ * Database mutations are limited to 640KB, which is smaller than the protocol
+ * message limit to ensure efficient sync with
+ * {@link defaultProtocolMessageRangesMaxSize}.
  *
  * ### Why Binary?
  *
@@ -149,6 +148,15 @@
  * Version negotiation is per-owner, allowing Evolu Protocol to evolve safely
  * over time and provide clear feedback about version mismatches.
  *
+ * ### Credible exit
+ *
+ * The protocol specification is intentionally non-configurable to ensure
+ * universal compatibility. This design allows applications (users) to switch
+ * between any compliant relay without negotiation or compatibility checks
+ * beyond version matching. Relays are generic infrastructure that any
+ * application can use interchangeably making exit from any single provider
+ * technically feasible and economically viable.
+ *
  * @module
  */
 
@@ -179,12 +187,14 @@ import { SqliteValue } from "../Sqlite.js";
 import {
   Base64Url,
   base64UrlToUint8Array,
+  between,
   DateIso,
   Id,
   IdBytes,
   idBytesToId,
   idBytesTypeValueLength,
   idToIdBytes,
+  Int,
   Json,
   jsonToJsonValue,
   NonNegativeInt,
@@ -231,18 +241,71 @@ import {
 } from "./Timestamp.js";
 
 /**
- * MessagePack serializer for standard compatibility and compact encoding.
+ * Evolu uses MessagePack for numbers and JSONs.
  *
  * - `variableMapSize: true` - More compact maps, ~5-10% slower encoding
  * - `useRecords: false` - Standard MessagePack without extensions
  */
 const packr = new Packr({ variableMapSize: true, useRecords: false });
 
-/** Maximum size of the entire protocol message in bytes. */
-export const maxProtocolMessageSize = 1_000_000 as PositiveInt;
+const minProtocolMessageMaxSize = 1_000_000;
+const maxProtocolMessageMaxSize = 100_000_000;
+
+/**
+ * Protocol message maximum size.
+ *
+ * Defines the upper limit for how large a single protocol message can be.
+ * Implementations must enforce a maximum size between 1MB and 100MB to ensure
+ * compatibility across all Evolu implementations (the maximum size of mutation
+ * change is hardcoded and enforced hence the maximum size can't be smaller).
+ *
+ * Larger maximum sizes can be configured by relays to reduce roundtrips. For
+ * example, a dedicated relay with ample resources could configure a 100MB
+ * maximum to minimize roundtrips for large syncs.
+ *
+ * Only relays can safely configure larger sizes, as clients will handle them.
+ * Increasing this value on the client side would break compatibility with
+ * relays that enforce smaller limits.
+ */
+export const ProtocolMessageMaxSize = between(
+  minProtocolMessageMaxSize,
+  maxProtocolMessageMaxSize,
+)(Int);
 
-/** Maximum size of the ranges in bytes. */
-export const maxProtocolMessageRangesSize = 30_000 as PositiveInt;
+export type ProtocolMessageMaxSize = typeof ProtocolMessageMaxSize.Type;
+
+/**
+ * Default {@link ProtocolMessageMaxSize} (1MB).
+ *
+ * The standard size used across Evolu implementations. Relays with more
+ * resources can configure larger sizes to reduce roundtrips.
+ */
+export const defaultProtocolMessageMaxSize =
+  minProtocolMessageMaxSize as ProtocolMessageMaxSize;
+
+/**
+ * Protocol message ranges maximum size.
+ *
+ * Defines the upper limit for how large the ranges section of a protocol
+ * message can be. Implementations must enforce a maximum size between 3KB and
+ * 100KB to ensure compatibility.
+ *
+ * The upper bound is set to ensure ranges fit within the default 1MB
+ * {@link defaultProtocolMessageMaxSize}, maintaining compatibility between all
+ * clients and relays.
+ */
+export const ProtocolMessageRangesMaxSize = between(3_000, 100_000)(Int);
+export type ProtocolMessageRangesMaxSize =
+  typeof ProtocolMessageRangesMaxSize.Type;
+
+/**
+ * Default {@link ProtocolMessageRangesMaxSize} (30KB).
+ *
+ * The standard size used across Evolu implementations. Relays with more
+ * resources can configure larger sizes to reduce roundtrips.
+ */
+export const defaultProtocolMessageRangesMaxSize =
+  30_000 as ProtocolMessageRangesMaxSize;
 
 /** Evolu Protocol Message. */
 export type ProtocolMessage = Uint8Array & Brand<"ProtocolMessage">;
@@ -281,6 +344,8 @@ export const ProtocolErrorCode = {
   WriteError: 2,
   /** A code for {@link ProtocolSyncError}. */
   SyncError: 3,
+  /** A code for {@link ProtocolQuotaExceededError}. */
+  QuotaExceededError: 4,
 } as const;
 
 type ProtocolErrorCode =
@@ -292,6 +357,7 @@ export type ProtocolError =
   | ProtocolWriteKeyError
   | ProtocolWriteError
   | ProtocolSyncError
+  | ProtocolQuotaExceededError
   | ProtocolTimestampMismatchError;
 
 /** Base interface for all protocol errors. */
@@ -323,21 +389,32 @@ export interface ProtocolWriteKeyError extends ProtocolErrorBase {
 }
 
 /**
- * Error when a write fails due to storage limits or billing requirements.
- * Indicates the need to expand capacity or resolve payment issues.
+ * Error indicating a serious relay-side write failure. Clients should log this
+ * error and show a generic sync error to the user.
  */
 export interface ProtocolWriteError extends ProtocolErrorBase {
   readonly type: "ProtocolWriteError";
 }
 
 /**
- * Error indicating a synchronization failure during the protocol exchange. Used
- * for unexpected or generic sync errors not covered by other error types.
+ * Error indicating a serious relay-side synchronization failure. Clients should
+ * log this error and show a generic sync error to the user.
  */
 export interface ProtocolSyncError extends ProtocolErrorBase {
   readonly type: "ProtocolSyncError";
 }
 
+/**
+ * Error when storage or billing quota is exceeded. Clients should prompt the
+ * user to upgrade their plan or expand capacity.
+ *
+ * TODO: Add callback to relay config to check quota and return this error when
+ * limits are reached.
+ */
+export interface ProtocolQuotaExceededError extends ProtocolErrorBase {
+  readonly type: "ProtocolQuotaExceededError";
+}
+
 /**
  * Error when embedded timestamp doesn't match expected timestamp in
  * EncryptedDbChange. Indicates potential tampering or corruption of CRDT
@@ -352,8 +429,8 @@ export interface ProtocolTimestampMismatchError {
 /**
  * Creates a {@link ProtocolMessage} from CRDT messages.
  *
- * If the message size would exceed {@link maxProtocolMessageSize}, the protocol
- * ensures all messages will be sent in the next round(s) even over
+ * If the message size would exceed {@link defaultProtocolMessageMaxSize}, the
+ * protocol ensures all messages will be sent in the next round(s) even over
  * unidirectional and stateless transports.
  */
 export const createProtocolMessageFromCrdtMessages =
@@ -361,11 +438,11 @@ export const createProtocolMessageFromCrdtMessages =
   (
     owner: Owner,
     messages: NonEmptyReadonlyArray<CrdtMessage>,
-    maxSize?: PositiveInt,
+    maxSize?: ProtocolMessageMaxSize,
   ): ProtocolMessage => {
     const buffer = createProtocolMessageBuffer(owner.id, {
       messageType: MessageType.Request,
-      totalMaxSize: maxSize ?? maxProtocolMessageSize,
+      totalMaxSize: maxSize ?? defaultProtocolMessageMaxSize,
       writeKey: owner.writeKey,
     });
 
@@ -394,8 +471,8 @@ export const createProtocolMessageFromCrdtMessages =
        *
        * The ideal approach would be to send three ranges (skip, fingerprint,
        * skip) where the fingerprint of unsent messages would act as narrow sync
-       * probe. I think we can send {@link zeroFingerprint} which can be
-       * interpreted as an indication that the other side should reply with
+       * probe. I think we can send `zeroFingerprint` which can be interpreted
+       * as an indication that the other side should reply with
        * {@link TimestampsRange}, so no need to restart syncing.
        *
        * For now, using a random fingerprint avoids extra complexity and is good
@@ -479,8 +556,8 @@ export interface ProtocolMessageBuffer {
 export const createProtocolMessageBuffer = (
   ownerId: OwnerId,
   options: {
-    readonly totalMaxSize?: PositiveInt | undefined;
-    readonly rangesMaxSize?: PositiveInt | undefined;
+    readonly totalMaxSize?: ProtocolMessageMaxSize | undefined;
+    readonly rangesMaxSize?: ProtocolMessageRangesMaxSize | undefined;
     readonly version?: NonNegativeInt;
   } & (
     | {
@@ -498,8 +575,8 @@ export const createProtocolMessageBuffer = (
   ),
 ): ProtocolMessageBuffer => {
   const {
-    totalMaxSize = maxProtocolMessageSize,
-    rangesMaxSize = maxProtocolMessageRangesSize,
+    totalMaxSize = defaultProtocolMessageMaxSize,
+    rangesMaxSize = defaultProtocolMessageRangesMaxSize,
     version = protocolVersion,
   } = options;
 
@@ -788,8 +865,7 @@ export interface ApplyProtocolMessageAsClientOptions {
   /** For testing purposes only; should not be used in production. */
   version?: NonNegativeInt;
 
-  totalMaxSize?: PositiveInt;
-  rangesMaxSize?: PositiveInt;
+  rangesMaxSize?: ProtocolMessageRangesMaxSize;
 }
 
 /**
@@ -814,6 +890,7 @@ export const applyProtocolMessageAsClient =
       | ProtocolUnsupportedVersionError
       | ProtocolWriteError
       | ProtocolWriteKeyError
+      | ProtocolQuotaExceededError
     >
   > => {
     // try-catch instead of Result for performance and stacktraces
@@ -857,6 +934,11 @@ export const applyProtocolMessageAsClient =
                 type: "ProtocolSyncError",
                 ownerId,
               });
+            case ProtocolErrorCode.QuotaExceededError:
+              return err<ProtocolQuotaExceededError>({
+                type: "ProtocolQuotaExceededError",
+                ownerId,
+              });
             default:
               throw new ProtocolDecodeError(
                 `Invalid ProtocolErrorCode: ${errorCode}`,
@@ -898,7 +980,6 @@ export const applyProtocolMessageAsClient =
       const output = createProtocolMessageBuffer(ownerId, {
         messageType: MessageType.Request,
         writeKey,
-        totalMaxSize: options.totalMaxSize,
         rangesMaxSize: options.rangesMaxSize,
       });
 
@@ -929,8 +1010,8 @@ export interface ApplyProtocolMessageAsRelayOptions {
   /** To broadcast a protocol message to all subscribers. */
   broadcast?: (ownerId: OwnerId, message: ProtocolMessage) => void;
 
-  totalMaxSize?: PositiveInt;
-  rangesMaxSize?: PositiveInt;
+  totalMaxSize?: ProtocolMessageMaxSize;
+  rangesMaxSize?: ProtocolMessageRangesMaxSize;
 }
 
 /**

package/src/Evolu/Relay.ts

@@ -1,10 +1,12 @@
 import { isNonEmptyReadonlyArray } from "../Array.js";
-import { ConsoleConfig } from "../Console.js";
+import { ConsoleConfig, ConsoleDep } from "../Console.js";
 import { TimingSafeEqualDep } from "../Crypto.js";
+import { LazyValue } from "../Function.js";
 import { err, ok, Result } from "../Result.js";
 import { sql, SqliteError } from "../Sqlite.js";
 import { SimpleName } from "../Type.js";
-import { OwnerId, OwnerWriteKey } from "./Owner.js";
+import { OwnerId, OwnerWriteKey, TransportConfig } from "./Owner.js";
+import { ProtocolInvalidDataError } from "./Protocol.js";
 import {
   createSqliteStorageBase,
   CreateSqliteStorageBaseOptions,
@@ -17,13 +19,55 @@ import { timestampToTimestampBytes } from "./Timestamp.js";
 export interface Relay extends Disposable {}
 
 export interface RelayConfig extends ConsoleConfig {
+  /**
+   * The relay name.
+   *
+   * Implementations can use this for identification purposes (e.g., database
+   * file name, logging).
+   */
   readonly name?: SimpleName;
-}
 
-export type RelaySqliteStorageDeps = SqliteStorageDeps & TimingSafeEqualDep;
+  /**
+   * Optional callback to authenticate an {@link OwnerId} with the relay.
+   *
+   * If this callback is not provided, all owners are allowed.
+   *
+   * If provided, the callback receives the OwnerId and should return a promise
+   * that resolves to `true` to allow access, or `false` to deny.
+   *
+   * The callback returns a boolean rather than an error type because error
+   * handling and logging are the responsibility of the callback implementation,
+   * not the relay. This prevents leaking authentication implementation details
+   * into the generic relay interface.
+   *
+   * OwnerId is used for authentication rather than short-lived tokens because
+   * this only controls relay access, not write permissions. Since all data is
+   * encrypted on the relay, OwnerId exposure is safe.
+   *
+   * Owners specify which relays to connect to via {@link TransportConfig}. In
+   * WebSocket-based implementations, this check occurs before accepting the
+   * connection, with the OwnerId typically extracted from the URL path (e.g.,
+   * `ws://localhost:4000/<ownerId>`).
+   *
+   * ### Example
+   *
+   * ```ts
+   * const relay = await createNodeJsRelay(deps)({
+   *   authenticateOwner: async (ownerId) => {
+   *     const isRegistered = await db.checkOwner(ownerId);
+   *     if (!isRegistered) {
+   *       logger.warn("Unauthorized access attempt", { ownerId });
+   *     }
+   *     return isRegistered;
+   *   },
+   * });
+   * ```
+   */
+  readonly authenticateOwner?: (ownerId: OwnerId) => Promise<boolean>;
+}
 
-export const createRelayStorage =
-  (deps: RelaySqliteStorageDeps) =>
+export const createRelaySqliteStorage =
+  (deps: SqliteStorageDeps & TimingSafeEqualDep) =>
   (options: CreateSqliteStorageBaseOptions): Result<Storage, SqliteError> => {
     const sqliteStorageBase = createSqliteStorageBase(deps)(options);
     if (!sqliteStorageBase.ok) return sqliteStorageBase;
@@ -186,3 +230,133 @@ export const createRelayStorage =
       },
     });
   };
+
+export interface RelayLogger {
+  readonly started: (enableLogging: boolean, port: number) => void;
+  readonly storageError: (error: unknown) => void;
+  readonly upgradeSocketError: (error: Error) => void;
+  readonly invalidOrMissingOwnerIdInUrl: (url: string | undefined) => void;
+  readonly unauthorizedOwner: (ownerId: OwnerId) => void;
+  readonly authenticateOwnerError: (error: unknown) => void;
+  readonly connectionEstablished: (totalConnectionCount: number) => void;
+  readonly connectionWebSocketError: (error: Error) => void;
+  readonly relayOptionSubscribe: (
+    ownerId: OwnerId,
+    getSubscriberCount: LazyValue<number>,
+  ) => void;
+  readonly relayOptionUnsubscribe: (
+    ownerId: OwnerId,
+    getSubscriberCount: LazyValue<number>,
+  ) => void;
+  readonly relayOptionBroadcast: (
+    ownerId: OwnerId,
+    broadcastCount: number,
+    subscriberCount: number,
+  ) => void;
+  readonly messageLength: (messageLength: number) => void;
+  readonly applyProtocolMessageAsRelayError: (
+    error: ProtocolInvalidDataError,
+  ) => void;
+  readonly responseLength: (responseLength: number) => void;
+  readonly applyProtocolMessageAsRelayUnknownError: (error: unknown) => void;
+  readonly connectionClosed: (totalConnectionCount: number) => void;
+  readonly shuttingDown: () => void;
+  readonly webSocketServerDisposed: () => void;
+  readonly httpServerDisposed: () => void;
+}
+
+export const createRelayLogger = (deps: ConsoleDep): RelayLogger => ({
+  started: (enableLogging, port) => {
+    deps.console.enabled = true;
+    deps.console.log(`Evolu Relay started on port ${port}`);
+    deps.console.enabled = enableLogging;
+  },
+
+  storageError: (error) => {
+    deps.console.error("[relay]", "storage", error);
+  },
+
+  upgradeSocketError: (error) => {
+    deps.console.warn("[relay]", "socket error", { error });
+  },
+
+  invalidOrMissingOwnerIdInUrl: (url) => {
+    deps.console.warn("[relay]", "invalid or missing ownerId in URL", { url });
+  },
+
+  unauthorizedOwner: (ownerId) => {
+    deps.console.warn("[relay]", "unauthorized owner", { ownerId });
+  },
+
+  authenticateOwnerError: (error) => {
+    deps.console.error("[relay]", "authenticateOwner error", error);
+  },
+
+  connectionEstablished: (totalConnectionCount) => {
+    deps.console.log("[relay]", "connection", { totalConnectionCount });
+  },
+
+  connectionWebSocketError: (error) => {
+    deps.console.error("[relay]", "error", { error });
+  },
+
+  relayOptionSubscribe: (ownerId, getSubscriberCount) => {
+    if (deps.console.enabled)
+      deps.console.log("[relay]", "subscribe", {
+        ownerId,
+        subscriberCount: getSubscriberCount(),
+      });
+  },
+
+  relayOptionUnsubscribe: (ownerId, getSubscriberCount) => {
+    if (deps.console.enabled)
+      deps.console.log("[relay]", "unsubscribe", {
+        ownerId,
+        subscriberCount: getSubscriberCount(),
+      });
+  },
+
+  relayOptionBroadcast: (ownerId, broadcastCount, totalSubscribers) => {
+    deps.console.log("[relay]", "broadcast", {
+      ownerId,
+      broadcastCount,
+      totalSubscribers,
+    });
+  },
+
+  messageLength: (messageLength) => {
+    deps.console.log("[relay]", "on message", { messageLength });
+  },
+
+  applyProtocolMessageAsRelayError: (error) => {
+    deps.console.error("[relay]", "applyProtocolMessageAsRelay", error);
+  },
+
+  responseLength: (responseLength) => {
+    deps.console.log("[relay]", "responseLength", { responseLength });
+  },
+
+  applyProtocolMessageAsRelayUnknownError: (error) => {
+    deps.console.error(
+      "[relay]",
+      "applyProtocolMessageAsRelayUnknownError",
+      error,
+    );
+  },
+
+  connectionClosed: (totalConnectionCount) => {
+    deps.console.log("[relay]", "close", { totalConnectionCount });
+  },
+
+  shuttingDown: () => {
+    deps.console.log("Shutting down Evolu Relay...");
+  },
+
+  webSocketServerDisposed: () => {
+    deps.console.log("Evolu Relay WebSocketServer disposed");
+  },
+
+  httpServerDisposed: () => {
+    deps.console.log("Evolu Relay HTTP server disposed");
+  },
+});

package/src/Evolu/Sync.ts

@@ -1,7 +1,6 @@
 import { NonEmptyArray, NonEmptyReadonlyArray } from "../Array.js";
 import { assert } from "../Assert.js";
 import { Brand } from "../Brand.js";
-import { concatBytes } from "../Buffer.js";
 import { ConsoleDep } from "../Console.js";
 import {
   RandomBytesDep,
@@ -60,7 +59,6 @@ import {
   receiveTimestamp,
   sendTimestamp,
   Timestamp,
-  TimestampBytes,
   timestampBytesToTimestamp,
   TimestampConfigDep,
   TimestampCounterOverflowError,
@@ -634,7 +632,7 @@ export const applyLocalOnlyChange =
     return ok();
   };
 
-const applyMessages =
+export const applyMessages =
   (deps: ClientStorageDep & ClockDep & RandomDep & SqliteDep) =>
   (
     ownerId: OwnerId,
@@ -665,30 +663,26 @@ const applyMessageToAppTable =
     for (const [column, value] of objectToEntries(message.change.values)) {
       const result = deps.sqlite.exec(sql.prepared`
         with
-          lastTimestamp as (
-            select "timestamp"
+          existingTimestamp as (
+            select 1
             from evolu_history
             where
               "ownerId" = ${ownerId}
               and "table" = ${message.change.table}
-              and "id" = ${message.change.id}
+              and "id" = ${idToIdBytes(message.change.id)}
               and "column" = ${column}
-            order by "timestamp" desc
+              and "timestamp" >= ${timestamp}
             limit 1
           )
         insert into ${sql.identifier(message.change.table)}
           ("id", ${sql.identifier(column)}, updatedAt)
         select ${message.change.id}, ${value}, ${updatedAt}
-        where
-          (select "timestamp" from lastTimestamp) is null
-          or (select "timestamp" from lastTimestamp) < ${timestamp}
+        where not exists (select 1 from existingTimestamp)
         on conflict ("id") do update
           set
             ${sql.identifier(column)} = ${value},
             updatedAt = ${updatedAt}
-          where
-            (select "timestamp" from lastTimestamp) is null
-            or (select "timestamp" from lastTimestamp) < ${timestamp};
+          where not exists (select 1 from existingTimestamp);
       `);
 
       if (!result.ok) return result;
@@ -780,47 +774,3 @@ export interface PaymentRequiredError {
 }
 
 export const initialSyncState: SyncStateInitial = { type: "SyncStateInitial" };
-
-/**
- * Efficiently checks which binary timestamps already exist in the database
- * using a single CTE query instead of N individual queries. Crucial for WASM
- * SQLite performance where JS↔WASM boundary crossings are expensive.
- *
- * Used for fast idempotency detection in writeMessages before onMessage
- * validation. While applyMessages ensures internal idempotency, this pre-check
- * is faster and required for main thread message validation.
- */
-export const getExistingTimestamps =
-  (deps: SqliteDep) =>
-  (
-    ownerIdBytes: OwnerIdBytes,
-    timestampsBytes: NonEmptyReadonlyArray<TimestampBytes>,
-  ): Result<ReadonlyArray<TimestampBytes>, SqliteError> => {
-    const concatenatedTimestamps = concatBytes(...timestampsBytes);
-
-    const result = deps.sqlite.exec<{
-      timestampBytes: TimestampBytes;
-    }>(sql`
-      with recursive
-        split_timestamps(timestampBytes, pos) as (
-          select
-            substr(${concatenatedTimestamps}, 1, 16),
-            17 as pos
-          union all
-          select
-            substr(${concatenatedTimestamps}, pos, 16),
-            pos + 16
-          from split_timestamps
-          where pos <= length(${concatenatedTimestamps})
-        )
-      select s.timestampBytes
-      from
-        split_timestamps s
-        join evolu_timestamp t
-          on t.ownerId = ${ownerIdBytes} and s.timestampBytes = t.t;
-    `);
-
-    if (!result.ok) return result;
-
-    return ok(result.value.rows.map((row) => row.timestampBytes));
-  };