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

package/dist/src/Evolu/Sync.d.ts

@@ -1,23 +1,77 @@
-import { ConsoleConfig, ConsoleDep } from "../Console.js";
-import { ProtocolMessage } from "./Protocol.js";
-import { Millis } from "./Timestamp.js";
-export interface Sync {
-    readonly send: (message: ProtocolMessage) => void;
+import { NonEmptyReadonlyArray } from "../Array.js";
+import { ConsoleDep } from "../Console.js";
+import { RandomBytesDep, SymmetricCryptoDecryptError, SymmetricCryptoDep } from "../Crypto.js";
+import { TransferableError } from "../Error.js";
+import { RandomDep } from "../Random.js";
+import { Result } from "../Result.js";
+import { SqliteDep, SqliteError } from "../Sqlite.js";
+import { TimeDep } from "../Time.js";
+import { CreateWebSocketDep } from "../WebSocket.js";
+import type { PostMessageDep } from "./Db.js";
+import { AppOwner, OwnerEncryptionKey, OwnerId, OwnerIdBytes, OwnerWriteKey, TransportConfig } from "./Owner.js";
+import { ProtocolError, ProtocolInvalidDataError, ProtocolTimestampMismatchError } from "./Protocol.js";
+import { MutationChange } from "./Schema.js";
+import { CrdtMessage, SqliteStorageBase, Storage } from "./Storage.js";
+import { Millis, Timestamp, TimestampBytes, TimestampConfigDep, TimestampCounterOverflowError, TimestampDriftError, TimestampTimeOutOfRangeError } from "./Timestamp.js";
+export interface Sync extends Disposable {
+    /**
+     * Assigns or removes an owner to/from transports with reference counting.
+     *
+     * Owners are only "active" if assigned to at least one transport. Uses
+     * `owner.transports` or falls back to config transports. Multiple calls
+     * increment/decrement reference counts (useful for React Hooks).
+     */
+    readonly useOwner: (use: boolean, owner: SyncOwner) => void;
+    readonly applyChanges: (changes: NonEmptyReadonlyArray<MutationChange>) => Result<void, SqliteError | TimestampCounterOverflowError | TimestampDriftError | TimestampTimeOutOfRangeError>;
 }
 export interface SyncDep {
     readonly sync: Sync;
 }
-export type CreateSync = (deps: ConsoleDep) => (config: SyncConfig) => Sync;
-export interface CreateSyncDep {
-    readonly createSync: CreateSync;
+/**
+ * Represents an owner for sync operations. This is a unified interface that
+ * abstracts over the specific owner types ({@link ShardOwner},
+ * {@link SharedOwner}, {@link SharedReadonlyOwner}) for the sync layer.
+ *
+ * The sync layer only needs the essential data for synchronization and doesn't
+ * need to distinguish between different owner types.
+ */
+export interface SyncOwner {
+    readonly id: OwnerId;
+    readonly encryptionKey: OwnerEncryptionKey;
+    /** Optional for read-only owners like {@link SharedReadonlyOwner}. */
+    readonly writeKey?: OwnerWriteKey;
+    readonly transports?: ReadonlyArray<TransportConfig>;
+}
+export interface SyncConfig {
+    readonly appOwner: AppOwner;
+    readonly transports: ReadonlyArray<TransportConfig>;
+    /**
+     * Delay in milliseconds before disposing unused WebSocket connections.
+     * Defaults to 100ms.
+     */
+    readonly disposalDelayMs?: number;
+    readonly onError: (error: ProtocolError | ProtocolInvalidDataError | ProtocolTimestampMismatchError | SqliteError | SymmetricCryptoDecryptError | TimestampCounterOverflowError | TimestampDriftError | TimestampTimeOutOfRangeError | TransferableError) => void;
+    readonly onReceive: () => void;
+}
+export declare const createSync: (deps: ClockDep & ConsoleDep & CreateWebSocketDep & PostMessageDep & RandomBytesDep & RandomDep & SqliteDep & SymmetricCryptoDep & TimeDep & TimestampConfigDep) => (config: SyncConfig) => Result<Sync, SqliteError>;
+export interface ClockDep {
+    readonly clock: Clock;
+}
+export interface Clock {
+    readonly get: () => Timestamp;
+    readonly save: (timestamp: Timestamp) => Result<void, SqliteError>;
 }
-export interface SyncConfig extends ConsoleConfig {
-    readonly syncUrl: string;
-    readonly onOpen: (send: Sync["send"]) => void;
-    readonly onMessage: (message: Uint8Array, send: Sync["send"]) => void;
+export declare const createClock: (deps: RandomBytesDep & SqliteDep) => (initialTimestamp?: Timestamp) => Clock;
+export interface ClientStorage extends SqliteStorageBase, Storage {
 }
-export declare const createWebSocketSync: CreateSync;
+export interface ClientStorageDep {
+    readonly storage: ClientStorage;
+}
+export declare const applyLocalOnlyChange: (deps: SqliteDep & TimeDep) => (change: MutationChange) => Result<void, SqliteError>;
+export declare const applyMessageToTimestampAndHistoryTables: (deps: ClientStorageDep & SqliteDep) => (ownerId: OwnerIdBytes, message: CrdtMessage) => Result<void, SqliteError>;
 /**
+ * TODO: Rework for the new owners API.
+ *
  * The possible states of a synchronization process. The `SyncState` can be one
  * of the following:
  *
@@ -56,4 +110,14 @@ export interface PaymentRequiredError {
     readonly type: "PaymentRequiredError";
 }
 export declare const initialSyncState: 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 declare const getExistingTimestamps: (deps: SqliteDep) => (ownerIdBytes: OwnerIdBytes, timestampsBytes: NonEmptyReadonlyArray<TimestampBytes>) => Result<ReadonlyArray<TimestampBytes>, SqliteError>;
 //# sourceMappingURL=Sync.d.ts.map

package/dist/src/Evolu/Sync.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Sync.d.ts","sourceRoot":"","sources":["../../../src/Evolu/Sync.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE1D,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAExC,MAAM,WAAW,IAAI;IACnB,QAAQ,CAAC,IAAI,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,IAAI,CAAC;CACnD;AAED,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;CACrB;AAED,MAAM,MAAM,UAAU,GAAG,CAAC,IAAI,EAAE,UAAU,KAAK,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI,CAAC;AAE5E,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;CACjC;AAED,MAAM,WAAW,UAAW,SAAQ,aAAa;IAC/C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,IAAI,CAAC;IAC9C,QAAQ,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,IAAI,CAAC;CACvE;AAED,eAAO,MAAM,mBAAmB,EAAE,UA2BjC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,SAAS,GACjB,gBAAgB,GAChB,kBAAkB,GAClB,iBAAiB,GACjB,oBAAoB,CAAC;AAEzB;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;CACnC;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;CACrC;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAC;IACtC,QAAQ,CAAC,KAAK,EAAE,YAAY,GAAG,WAAW,GAAG,oBAAoB,CAAC;CACnE;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;CAC/B;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAC;CACvC;AAED,eAAO,MAAM,gBAAgB,EAAE,gBAA+C,CAAC"}
+{"version":3,"file":"Sync.d.ts","sourceRoot":"","sources":["../../../src/Evolu/Sync.ts"],"names":[],"mappings":"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"}

package/dist/src/Evolu/Sync.js

@@ -1,29 +1,462 @@
-import { createWebSocket } from "../WebSocket.js";
-export const createWebSocketSync = (_deps) => (config) => {
+import { assert } from "../Assert.js";
+import { concatBytes } from "../Buffer.js";
+import { eqArrayNumber } from "../Eq.js";
+import { createTransferableError } from "../Error.js";
+import { constFalse } from "../Function.js";
+import { objectToEntries } from "../Object.js";
+import { createRefCountedResourceManager } from "../RefCountedResourceManager.js";
+import { ok } from "../Result.js";
+import { sql } from "../Sqlite.js";
+import { createMutex } from "../Task.js";
+import { idBytesToId, idToIdBytes } from "../Type.js";
+import { ownerIdBytesToOwnerId, ownerIdToOwnerIdBytes, } from "./Owner.js";
+import { applyProtocolMessageAsClient, createProtocolMessageForSync, createProtocolMessageForUnsubscribe, createProtocolMessageFromCrdtMessages, decryptAndDecodeDbChange, encodeAndEncryptDbChange, SubscriptionFlags, } from "./Protocol.js";
+import { createSqliteStorageBase, } from "./Storage.js";
+import { createInitialTimestamp, receiveTimestamp, sendTimestamp, timestampBytesToTimestamp, timestampToTimestampBytes, timestampToTimestampString, } from "./Timestamp.js";
+export const createSync = (deps) => (config) => {
+    let isDisposed = false;
+    /** Returns owner data only if actively assigned to at least one transport. */
+    const getSyncOwner = (ownerId) => {
+        if (isDisposed)
+            return null;
+        return transports.getConsumer(ownerId);
+    };
+    const storageResult = createClientStorage({
+        ...deps,
+        getSyncOwner,
+    })(config);
+    if (!storageResult.ok)
+        return storageResult;
+    const storage = storageResult.value;
+    const createResource = (transportConfig) => {
+        const transportKey = createTransportKey(transportConfig);
+        deps.console.log("[sync]", "createWebSocket", {
+            transportKey,
+            url: transportConfig.url,
+        });
+        return deps.createWebSocket(transportConfig.url, {
+            binaryType: "arraybuffer",
+            onOpen: () => {
+                if (isDisposed)
+                    return;
+                const webSocket = transports.getResource(transportKey);
+                if (!webSocket)
+                    return;
+                const ownerIds = transports.getConsumersForResource(transportKey);
+                deps.console.log("[sync]", "onOpen", { transportKey, ownerIds });
+                for (const ownerId of ownerIds) {
+                    const message = createProtocolMessageForSync({ storage })(ownerId, SubscriptionFlags.Subscribe);
+                    if (!message)
+                        continue;
+                    deps.console.log("[sync]", "send", { message });
+                    webSocket.send(message);
+                }
+            },
+            onClose: (event) => {
+                deps.console.log("[sync]", "onClose", {
+                    transportKey,
+                    code: event.code,
+                    reason: event.reason,
+                    wasClean: event.wasClean,
+                });
+            },
+            onError: (error) => {
+                deps.console.warn("[sync]", "onError", { transportKey, error });
+            },
+            onMessage: (data) => {
+                // Only handle ArrayBuffer data for sync messages
+                if (isDisposed || !(data instanceof ArrayBuffer))
+                    return;
+                const webSocket = transports.getResource(transportKey);
+                if (!webSocket)
+                    return;
+                const input = new Uint8Array(data);
+                deps.console.log("[sync]", "onMessage", {
+                    transportKey,
+                    message: input,
+                });
+                applyProtocolMessageAsClient({ storage })(input, {
+                    // No write key, no sync (for a case when an owner was unused).
+                    getWriteKey: (ownerId) => getSyncOwner(ownerId)?.writeKey ?? null,
+                })
+                    .then((message) => {
+                    if (!message.ok) {
+                        config.onError(message.error);
+                        return;
+                    }
+                    switch (message.value.type) {
+                        case "response":
+                            webSocket.send(message.value.message);
+                            break;
+                        case "no-response":
+                            // Sync complete, no response needed
+                            break;
+                        case "broadcast":
+                            // This was a broadcast message, don't affect sync counter
+                            break;
+                    }
+                })
+                    .catch((error) => {
+                    config.onError(createTransferableError(error));
+                });
+            },
+        });
+    };
+    const transports = createRefCountedResourceManager({
+        createResource,
+        getResourceKey: createTransportKey,
+        getConsumerId: (owner) => owner.id,
+        disposalDelay: config.disposalDelayMs ?? 100,
+        onConsumerAdded: (owner, webSocket) => {
+            deps.console.log("[sync]", "onConsumerAdded", {
+                ownerId: owner.id,
+                isOpen: webSocket.isOpen(),
+            });
+            // The onOpen handler will sync it.
+            if (!webSocket.isOpen())
+                return;
+            const message = createProtocolMessageForSync({ storage })(owner.id, SubscriptionFlags.Subscribe);
+            if (message)
+                webSocket.send(message);
+        },
+        onConsumerRemoved: (owner, webSocket) => {
+            deps.console.log("[sync]", "onConsumerRemoved", {
+                ownerId: owner.id,
+                isOpen: webSocket.isOpen(),
+            });
+            const message = createProtocolMessageForUnsubscribe(owner.id);
+            webSocket.send(message);
+        },
+    });
     const sync = {
-        send: (message) => {
-            /**
-             * We don't need an in-memory queue; apps can be offline for a long time,
-             * and mutations are stored in SQLite. Dropped CRDT messages are synced
-             * when the web socket connection is open.
-             */
-            if (socket.getReadyState() !== "open")
+        useOwner: (use, owner) => {
+            if (isDisposed) {
+                deps.console.warn("[sync]", "useOwner called on disposed Sync instance", { owner });
                 return;
-            socket.send(message);
+            }
+            deps.console.log("[sync]", "useOwner", { use, owner });
+            const transportsToUse = owner.transports ?? config.transports;
+            if (use) {
+                transports.addConsumer(owner, transportsToUse);
+            }
+            else {
+                const result = transports.removeConsumer(owner, transportsToUse);
+                if (!result.ok) {
+                    deps.console.warn("[sync]", "Failed to remove consumer", {
+                        transportsToUse,
+                        ownerId: owner.id,
+                        error: result.error,
+                    });
+                }
+            }
+        },
+        applyChanges: (changes) => {
+            deps.console.log("[sync]", "applyChanges", { changes });
+            let clockTimestamp = deps.clock.get();
+            const ownerMessages = new Map();
+            for (const change of changes) {
+                const nextTimestamp = sendTimestamp(deps)(clockTimestamp);
+                if (!nextTimestamp.ok)
+                    return nextTimestamp;
+                clockTimestamp = nextTimestamp.value;
+                const { ownerId = config.appOwner.id, ...dbChange } = change;
+                const message = { timestamp: clockTimestamp, change: dbChange };
+                const messages = ownerMessages.get(ownerId);
+                if (messages)
+                    messages.push(message);
+                else
+                    ownerMessages.set(ownerId, [message]);
+            }
+            for (const [ownerId, messages] of ownerMessages) {
+                const result = applyMessages({ ...deps, storage })(ownerId, messages);
+                if (!result.ok)
+                    return result;
+                const owner = getSyncOwner(ownerId);
+                if (!owner?.writeKey)
+                    continue;
+                const message = createProtocolMessageFromCrdtMessages(deps)({
+                    id: owner.id,
+                    encryptionKey: owner.encryptionKey,
+                    writeKey: owner.writeKey,
+                }, messages);
+                const transportsToUse = owner.transports ?? config.transports;
+                // Send message to all transports for this owner
+                for (const transportConfig of transportsToUse) {
+                    const transportKey = createTransportKey(transportConfig);
+                    const webSocket = transports.getResource(transportKey);
+                    if (!webSocket)
+                        continue;
+                    if (webSocket.isOpen()) {
+                        deps.console.log("[sync]", "send", { transportKey, message });
+                        webSocket.send(message);
+                    }
+                }
+            }
+            return deps.clock.save(clockTimestamp);
+        },
+        [Symbol.dispose]: () => {
+            if (isDisposed)
+                return;
+            isDisposed = true;
+            transports[Symbol.dispose]();
+        },
+    };
+    return ok(sync);
+};
+export const createClock = (deps) => (initialTimestamp = createInitialTimestamp(deps)) => {
+    let currentTimestamp = initialTimestamp;
+    return {
+        get: () => currentTimestamp,
+        save: (timestamp) => {
+            currentTimestamp = timestamp;
+            const timestampString = timestampToTimestampString(timestamp);
+            const result = deps.sqlite.exec(sql.prepared `
+          update evolu_config set "clock" = ${timestampString};
+        `);
+            if (!result.ok)
+                return result;
+            return ok();
         },
     };
-    const socket = createWebSocket(config.syncUrl, {
-        binaryType: "arraybuffer",
-        onOpen: () => {
-            config.onOpen(sync.send);
+};
+const createClientStorage = (deps) => (config) => {
+    const sqliteStorageBase = createSqliteStorageBase(deps)({
+        onStorageError: config.onError,
+    });
+    if (!sqliteStorageBase.ok)
+        return sqliteStorageBase;
+    const mutex = createMutex();
+    const storage = {
+        ...sqliteStorageBase.value,
+        validateWriteKey: constFalse,
+        setWriteKey: constFalse,
+        writeMessages: async (ownerIdBytes, encryptedMessages) => {
+            const writeResult = await mutex.withLock(async () => {
+                const ownerId = ownerIdBytesToOwnerId(ownerIdBytes);
+                const owner = deps.getSyncOwner(ownerId);
+                // Owner can be removed during syncing.
+                if (!owner)
+                    return ok(false);
+                const messages = [];
+                for (const message of encryptedMessages) {
+                    const change = decryptAndDecodeDbChange(deps)(message, owner.encryptionKey);
+                    if (!change.ok)
+                        return change;
+                    messages.push({
+                        timestamp: message.timestamp,
+                        change: change.value,
+                    });
+                }
+                const transaction = deps.sqlite.transaction(() => {
+                    let clockTimestamp = deps.clock.get();
+                    for (const message of messages) {
+                        const nextTimestamp = receiveTimestamp(deps)(clockTimestamp, message.timestamp);
+                        if (!nextTimestamp.ok)
+                            return nextTimestamp;
+                        clockTimestamp = nextTimestamp.value;
+                    }
+                    const applyMessagesResult = applyMessages({ ...deps, storage })(owner.id, messages);
+                    if (!applyMessagesResult.ok)
+                        return applyMessagesResult;
+                    // // Apply local mutations atomically with approved messages
+                    // for (const change of localMutations) {
+                    //   const result = applyLocalOnlyChange(deps)(change);
+                    //   if (!result.ok) return result;
+                    // }
+                    return deps.clock.save(clockTimestamp);
+                });
+                if (!transaction.ok)
+                    return transaction;
+                return ok(true);
+            })();
+            if (!writeResult.ok) {
+                if (writeResult.error.type !== "AbortError") {
+                    config.onError(writeResult.error);
+                }
+                return false;
+            }
+            config.onReceive();
+            return true;
         },
-        onMessage: (data) => {
-            if (data instanceof ArrayBuffer) {
-                const messages = new Uint8Array(data);
-                config.onMessage(messages, sync.send);
+        readDbChange: (ownerId, timestamp) => {
+            const owner = deps.getSyncOwner(ownerIdBytesToOwnerId(ownerId));
+            // Owner can be removed to stop syncing.
+            if (!owner)
+                return null;
+            const result = deps.sqlite.exec(sql `
+          select "table", "id", "column", "value"
+          from evolu_history
+          where "ownerId" = ${ownerId} and "timestamp" = ${timestamp};
+        `);
+            if (!result.ok) {
+                config.onError(result.error);
+                return null;
+            }
+            const { rows } = result.value;
+            assert(rows.length > 0, "Rows must not be empty");
+            const { table, id } = rows[0];
+            const values = {};
+            for (const r of rows) {
+                assert(r.table === table, "All rows must have the same table");
+                assert(eqArrayNumber(r.id, id), "All rows must have the same Id");
+                values[r.column] = r.value;
             }
+            const message = {
+                timestamp: timestampBytesToTimestamp(timestamp),
+                change: {
+                    table: rows[0].table,
+                    id: idBytesToId(rows[0].id),
+                    values,
+                },
+            };
+            return encodeAndEncryptDbChange(deps)(message, owner.encryptionKey);
         },
-    });
-    return sync;
+    };
+    return ok(storage);
+};
+/** Creates a unique identifier for a transport configuration. */
+const createTransportKey = (transportConfig) => {
+    return `${transportConfig.type}:${transportConfig.url}`;
+};
+export const applyLocalOnlyChange = (deps) => (change) => {
+    const dbChange = {
+        table: change.table,
+        id: change.id,
+        values: change.values,
+    };
+    const isDeletion = "isDeleted" in dbChange.values && dbChange.values.isDeleted === 1;
+    if (isDeletion) {
+        const result = deps.sqlite.exec(sql `
+        delete from ${sql.identifier(dbChange.table)}
+        where id = ${dbChange.id};
+      `);
+        if (!result.ok)
+            return result;
+    }
+    else {
+        const date = new Date(deps.time.now()).toISOString();
+        for (const [column, value] of objectToEntries(dbChange.values)) {
+            const result = deps.sqlite.exec(sql.prepared `
+          insert into ${sql.identifier(dbChange.table)}
+            ("id", ${sql.identifier(column)}, createdAt, updatedAt)
+          values (${dbChange.id}, ${value}, ${date}, ${date})
+          on conflict ("id") do update
+            set
+              ${sql.identifier(column)} = ${value},
+              updatedAt = ${date};
+        `);
+            if (!result.ok)
+                return result;
+        }
+    }
+    return ok();
+};
+const applyMessages = (deps) => (ownerId, messages) => {
+    const ownerIdBytes = ownerIdToOwnerIdBytes(ownerId);
+    for (const message of messages) {
+        const result1 = applyMessageToAppTable(deps)(ownerIdBytes, message);
+        if (!result1.ok)
+            return result1;
+        const result2 = applyMessageToTimestampAndHistoryTables(deps)(ownerIdBytes, message);
+        if (!result2.ok)
+            return result2;
+    }
+    return ok();
+};
+const applyMessageToAppTable = (deps) => (ownerId, message) => {
+    const timestamp = timestampToTimestampBytes(message.timestamp);
+    const updatedAt = new Date(message.timestamp.millis).toISOString();
+    for (const [column, value] of objectToEntries(message.change.values)) {
+        const result = deps.sqlite.exec(sql.prepared `
+        with
+          lastTimestamp as (
+            select "timestamp"
+            from evolu_history
+            where
+              "ownerId" = ${ownerId}
+              and "table" = ${message.change.table}
+              and "id" = ${message.change.id}
+              and "column" = ${column}
+            order by "timestamp" desc
+            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}
+        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};
+      `);
+        if (!result.ok)
+            return result;
+    }
+    return ok();
+};
+export const applyMessageToTimestampAndHistoryTables = (deps) => (ownerId, message) => {
+    const timestamp = timestampToTimestampBytes(message.timestamp);
+    const id = idToIdBytes(message.change.id);
+    const result = deps.storage.insertTimestamp(ownerId, timestamp);
+    if (!result.ok)
+        return result;
+    for (const [column, value] of Object.entries(message.change.values)) {
+        const result = deps.sqlite.exec(sql.prepared `
+        insert into evolu_history
+          ("ownerId", "table", "id", "column", "value", "timestamp")
+        values
+          (
+            ${ownerId},
+            ${message.change.table},
+            ${id},
+            ${column},
+            ${value},
+            ${timestamp}
+          )
+        on conflict do nothing;
+      `);
+        if (!result.ok)
+            return result;
+    }
+    return ok();
 };
 export const initialSyncState = { 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) => (ownerIdBytes, timestampsBytes) => {
+    const concatenatedTimestamps = concatBytes(...timestampsBytes);
+    const result = deps.sqlite.exec(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));
+};