@interop/was-react 0.1.0

package/dist/sync/docCipher.js

@@ -0,0 +1,89 @@
+import { createEdvEncryption } from '@interop/was-client/edv';
+/**
+ * Whether a stored body is an EDV encryption envelope (carries an object `jwe`)
+ * rather than plaintext. Lets read paths stay tolerant of any legacy plaintext
+ * row.
+ *
+ * @param data {Json | undefined}
+ * @returns {boolean}
+ */
+export function isEncryptedEnvelope(data) {
+    if (data === undefined || data === null || typeof data !== 'object') {
+        return false;
+    }
+    const jwe = data.jwe;
+    return jwe !== null && typeof jwe === 'object';
+}
+/**
+ * Builds a {@link DocCipher} for one collection from its derived key material
+ * (the per-collection X25519 key agreement key). Keys are supplied directly (no
+ * keystore lookup). `idDerivation: 'random'` mints a stable random id updated in
+ * place via `sequence` -- the mutable head-document model every entity here uses
+ * (constant bump / toggle / re-categorize edits).
+ *
+ * @param options {object}
+ * @param options.keyAgreementKey {IKeyAgreementKey}
+ * @param options.keyResolver {IKeyResolver}
+ * @param options.collectionId {string}   labels errors; the codec is agnostic
+ * @returns {Promise<DocCipher>}
+ */
+export async function createDocCipher({ keyAgreementKey, keyResolver, collectionId }) {
+    const provider = createEdvEncryption({
+        resolveKeys: async () => null,
+        idDerivation: 'random'
+    });
+    const codec = await provider.codecFor({
+        spaceId: 'local',
+        collectionId,
+        scheme: 'edv',
+        keys: { keyAgreementKey, keyResolver }
+    });
+    if (!codec) {
+        throw new Error(`Could not build the EDV cipher for collection "${collectionId}".`);
+    }
+    // Parses the codec's `EncodedWrite` (id + envelope body bytes) into the
+    // stored `{ id, envelope }` shape. Shared by the create and update paths.
+    const readEncoded = (encoded) => {
+        if (typeof encoded.id !== 'string' ||
+            !(encoded.body instanceof Uint8Array)) {
+            throw new Error(`EDV encrypt for collection "${collectionId}" returned no id/envelope body.`);
+        }
+        const envelope = JSON.parse(new TextDecoder().decode(encoded.body));
+        return { id: encoded.id, envelope };
+    };
+    return {
+        async encrypt({ data }) {
+            // `encode` with no caller id is the create path: encrypt, then use the
+            // minted random id.
+            const encoded = await codec.encode({
+                data: data
+            });
+            return readEncoded(encoded);
+        },
+        async encryptUpdate({ id, data, current }) {
+            // The update path: hand the codec the prior stored envelope so it advances
+            // `sequence` from it and re-encrypts under the same id. The codec reads
+            // `current.data` (the prior envelope) and its `etag` header (unused here;
+            // the wire `If-Match` is derived from the synced-doc `version`, not this).
+            const priorResponse = {
+                data: current,
+                json: async () => current,
+                headers: { get: () => null }
+            };
+            const encoded = await codec.encode({
+                id,
+                data: data,
+                current: priorResponse
+            });
+            return readEncoded(encoded);
+        },
+        async decrypt({ envelope }) {
+            const response = {
+                data: envelope,
+                json: async () => envelope
+            };
+            return (await codec.decode(response));
+        }
+    };
+}
+//# sourceMappingURL=docCipher.js.map

package/dist/sync/docCipher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"docCipher.js","sourceRoot":"","sources":["../../src/sync/docCipher.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAA;AAmB7D;;;;;;;GAOG;AACH,MAAM,UAAU,mBAAmB,CAAC,IAAsB;IACxD,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;QACpE,OAAO,KAAK,CAAA;IACd,CAAC;IACD,MAAM,GAAG,GAAI,IAA0B,CAAC,GAAG,CAAA;IAC3C,OAAO,GAAG,KAAK,IAAI,IAAI,OAAO,GAAG,KAAK,QAAQ,CAAA;AAChD,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,EACpC,eAAe,EACf,WAAW,EACX,YAAY,EAKb;IACC,MAAM,QAAQ,GAAG,mBAAmB,CAAC;QACnC,WAAW,EAAE,KAAK,IAAI,EAAE,CAAC,IAAI;QAC7B,YAAY,EAAE,QAAQ;KACvB,CAAC,CAAA;IACF,MAAM,KAAK,GAAG,MAAM,QAAQ,CAAC,QAAQ,CAAC;QACpC,OAAO,EAAE,OAAO;QAChB,YAAY;QACZ,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,EAAE,eAAe,EAAE,WAAW,EAAE;KACvC,CAAC,CAAA;IACF,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,MAAM,IAAI,KAAK,CACb,kDAAkD,YAAY,IAAI,CACnE,CAAA;IACH,CAAC;IAED,wEAAwE;IACxE,0EAA0E;IAC1E,MAAM,WAAW,GAAG,CAAC,OAGpB,EAAkC,EAAE;QACnC,IACE,OAAO,OAAO,CAAC,EAAE,KAAK,QAAQ;YAC9B,CAAC,CAAC,OAAO,CAAC,IAAI,YAAY,UAAU,CAAC,EACrC,CAAC;YACD,MAAM,IAAI,KAAK,CACb,+BAA+B,YAAY,iCAAiC,CAC7E,CAAA;QACH,CAAC;QACD,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAS,CAAA;QAC3E,OAAO,EAAE,EAAE,EAAE,OAAO,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAA;IACrC,CAAC,CAAA;IAED,OAAO;QACL,KAAK,CAAC,OAAO,CAAC,EAAE,IAAI,EAAkB;YACpC,uEAAuE;YACvE,oBAAoB;YACpB,MAAM,OAAO,GAAG,MAAM,KAAK,CAAC,MAAM,CAAC;gBACjC,IAAI,EAAE,IAA6B;aACpC,CAAC,CAAA;YACF,OAAO,WAAW,CAAC,OAAO,CAAC,CAAA;QAC7B,CAAC;QAED,KAAK,CAAC,aAAa,CAAC,EAClB,EAAE,EACF,IAAI,EACJ,OAAO,EAKR;YACC,2EAA2E;YAC3E,wEAAwE;YACxE,0EAA0E;YAC1E,2EAA2E;YAC3E,MAAM,aAAa,GAAG;gBACpB,IAAI,EAAE,OAAO;gBACb,IAAI,EAAE,KAAK,IAAI,EAAE,CAAC,OAAO;gBACzB,OAAO,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,IAAI,EAAE;aAC+B,CAAA;YAC7D,MAAM,OAAO,GAAG,MAAM,KAAK,CAAC,MAAM,CAAC;gBACjC,EAAE;gBACF,IAAI,EAAE,IAA6B;gBACnC,OAAO,EAAE,aAAa;aACvB,CAAC,CAAA;YACF,OAAO,WAAW,CAAC,OAAO,CAAC,CAAA;QAC7B,CAAC;QAED,KAAK,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAsB;YAC5C,MAAM,QAAQ,GAAG;gBACf,IAAI,EAAE,QAAQ;gBACd,IAAI,EAAE,KAAK,IAAI,EAAE,CAAC,QAAQ;aACsB,CAAA;YAClD,OAAO,CAAC,MAAM,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAS,CAAA;QAC/C,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/sync/feedMasterPort.d.ts

@@ -0,0 +1,30 @@
+/*!
+ * Copyright (c) 2026 Interop Alliance. All rights reserved.
+ */
+/**
+ * A thin adapter over a {@link WasSyncPort} that resolves a resource's current
+ * master state (for the 412 conflict re-read) from the CHANGES-FEED BODY rather
+ * than the base port's `GET` ETag header.
+ *
+ * Why this exists: the mutable-head model settles a 412 by re-reading the
+ * resource's current `version` and comparing payloads (LWW). The verbatim
+ * `wasSyncPort.get()` reads that `version` from the response's `etag` header --
+ * which a browser hides on a CROSS-ORIGIN response unless the server sends
+ * `Access-Control-Expose-Headers: etag`. A server that does not expose it makes
+ * cross-origin `get()` report `version: 0`, which makes the loser of a push race
+ * re-push forever with a stale `If-Match` and never converge. The `changes` feed
+ * carries `version` (and `data`, `_deleted`, ...) in the JSON BODY, which CORS
+ * never strips, so resolving the master from the feed is both correct and
+ * origin-independent. Normal pull/push are unaffected (they already read
+ * `version` from the feed body), so only `get` is overridden.
+ */
+import type { WasSyncPort } from './types.js';
+/**
+ * Wraps a base port so its `get` resolves the master state from the changes feed.
+ * `query`, `putContent`, `deleteContent`, and `putMeta` pass straight through.
+ *
+ * @param base {WasSyncPort}
+ * @returns {WasSyncPort}
+ */
+export declare function withFeedMasterRead(base: WasSyncPort): WasSyncPort;
+//# sourceMappingURL=feedMasterPort.d.ts.map

package/dist/sync/feedMasterPort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feedMasterPort.d.ts","sourceRoot":"","sources":["../../src/sync/feedMasterPort.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAIV,WAAW,EAEZ,MAAM,YAAY,CAAA;AA4BnB;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,WAAW,GAAG,WAAW,CAyBjE"}

package/dist/sync/feedMasterPort.js

@@ -0,0 +1,58 @@
+// A generous page cap so a pathological feed cannot spin forever; conflicts are
+// rare and the dev/e2e feed is small, so a full scan is acceptable.
+const MAX_PAGES = 50;
+const PAGE_SIZE = 500;
+/**
+ * Builds a `MasterState` from a `changes`-feed document (all fields in-body).
+ */
+function toMasterState(doc) {
+    const master = {
+        version: doc.version,
+        updatedAt: doc.updatedAt,
+        deleted: doc._deleted
+    };
+    if (doc.data !== undefined) {
+        master.data = doc.data;
+    }
+    if (doc.metaVersion !== undefined) {
+        master.metaVersion = doc.metaVersion;
+    }
+    if (doc.custom !== undefined) {
+        master.custom = doc.custom;
+    }
+    return master;
+}
+/**
+ * Wraps a base port so its `get` resolves the master state from the changes feed.
+ * `query`, `putContent`, `deleteContent`, and `putMeta` pass straight through.
+ *
+ * @param base {WasSyncPort}
+ * @returns {WasSyncPort}
+ */
+export function withFeedMasterRead(base) {
+    return {
+        query: base.query.bind(base),
+        putContent: base.putContent.bind(base),
+        deleteContent: base.deleteContent.bind(base),
+        putMeta: base.putMeta.bind(base),
+        async get({ id }) {
+            let checkpoint;
+            for (let page = 0; page < MAX_PAGES; page++) {
+                const { documents, checkpoint: next } = await base.query({
+                    ...(checkpoint !== undefined && { checkpoint }),
+                    limit: PAGE_SIZE
+                });
+                const found = documents.find(doc => doc.id === id);
+                if (found) {
+                    return toMasterState(found);
+                }
+                if (next === null || documents.length === 0) {
+                    break;
+                }
+                checkpoint = next;
+            }
+            return null;
+        }
+    };
+}
+//# sourceMappingURL=feedMasterPort.js.map

package/dist/sync/feedMasterPort.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feedMasterPort.js","sourceRoot":"","sources":["../../src/sync/feedMasterPort.ts"],"names":[],"mappings":"AA4BA,gFAAgF;AAChF,oEAAoE;AACpE,MAAM,SAAS,GAAG,EAAE,CAAA;AACpB,MAAM,SAAS,GAAG,GAAG,CAAA;AAErB;;GAEG;AACH,SAAS,aAAa,CAAC,GAAY;IACjC,MAAM,MAAM,GAAgB;QAC1B,OAAO,EAAE,GAAG,CAAC,OAAO;QACpB,SAAS,EAAE,GAAG,CAAC,SAAS;QACxB,OAAO,EAAE,GAAG,CAAC,QAAQ;KACtB,CAAA;IACD,IAAI,GAAG,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;QAC3B,MAAM,CAAC,IAAI,GAAG,GAAG,CAAC,IAAY,CAAA;IAChC,CAAC;IACD,IAAI,GAAG,CAAC,WAAW,KAAK,SAAS,EAAE,CAAC;QAClC,MAAM,CAAC,WAAW,GAAG,GAAG,CAAC,WAAW,CAAA;IACtC,CAAC;IACD,IAAI,GAAG,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;QAC7B,MAAM,CAAC,MAAM,GAAG,GAAG,CAAC,MAAc,CAAA;IACpC,CAAC;IACD,OAAO,MAAM,CAAA;AACf,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAAiB;IAClD,OAAO;QACL,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC;QAC5B,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC;QACtC,aAAa,EAAE,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC;QAC5C,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC;QAChC,KAAK,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE;YACd,IAAI,UAAsC,CAAA;YAC1C,KAAK,IAAI,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,SAAS,EAAE,IAAI,EAAE,EAAE,CAAC;gBAC5C,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,IAAI,EAAE,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC;oBACvD,GAAG,CAAC,UAAU,KAAK,SAAS,IAAI,EAAE,UAAU,EAAE,CAAC;oBAC/C,KAAK,EAAE,SAAS;iBACjB,CAAC,CAAA;gBACF,MAAM,KAAK,GAAG,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,CAAA;gBAClD,IAAI,KAAK,EAAE,CAAC;oBACV,OAAO,aAAa,CAAC,KAAK,CAAC,CAAA;gBAC7B,CAAC;gBACD,IAAI,IAAI,KAAK,IAAI,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;oBAC5C,MAAK;gBACP,CAAC;gBACD,UAAU,GAAG,IAAI,CAAA;YACnB,CAAC;YACD,OAAO,IAAI,CAAA;QACb,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/sync/index.d.ts

@@ -0,0 +1,21 @@
+/*!
+ * Copyright (c) 2026 Interop Alliance. All rights reserved.
+ */
+/**
+ * Public surface of the collection-agnostic WAS replication layer. Framework-
+ * agnostic: consumers supply an RxDB collection and a {@link WasSyncPort};
+ * nothing in the core adapter imports React. The port adapter
+ * (`createWasSyncPort`) and the document cipher (`createDocCipher`) bridge to
+ * `@interop/was-client`.
+ */
+export { createWasReplication } from './wasReplication.js';
+export { syncedDocSchema } from './syncedDocSchema.js';
+export { createPullHandler, wireDocToRxDoc } from './changesQuery.js';
+export { createPushHandler, formatEtag } from './pushWrites.js';
+export { WasSyncConflictError, type Json, type SyncCheckpoint, type WireDoc, type SyncedDoc, type MasterState, type WasSyncPort } from './types.js';
+export { createWasSyncPort } from './wasSyncPort.js';
+export { withFeedMasterRead } from './feedMasterPort.js';
+export { createDocCipher, isEncryptedEnvelope, type DocCipher } from './docCipher.js';
+export { makeLwwConflictHandler } from './lwwConflictHandler.js';
+export { remotePayloadWins } from './lww.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/sync/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sync/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;GAMG;AACH,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAA;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AACtD,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACrE,OAAO,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAC/D,OAAO,EACL,oBAAoB,EACpB,KAAK,IAAI,EACT,KAAK,cAAc,EACnB,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,WAAW,EACjB,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AACxD,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,KAAK,SAAS,EACf,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAA;AAChE,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA"}

package/dist/sync/index.js

@@ -0,0 +1,21 @@
+/*!
+ * Copyright (c) 2026 Interop Alliance. All rights reserved.
+ */
+/**
+ * Public surface of the collection-agnostic WAS replication layer. Framework-
+ * agnostic: consumers supply an RxDB collection and a {@link WasSyncPort};
+ * nothing in the core adapter imports React. The port adapter
+ * (`createWasSyncPort`) and the document cipher (`createDocCipher`) bridge to
+ * `@interop/was-client`.
+ */
+export { createWasReplication } from './wasReplication.js';
+export { syncedDocSchema } from './syncedDocSchema.js';
+export { createPullHandler, wireDocToRxDoc } from './changesQuery.js';
+export { createPushHandler, formatEtag } from './pushWrites.js';
+export { WasSyncConflictError } from './types.js';
+export { createWasSyncPort } from './wasSyncPort.js';
+export { withFeedMasterRead } from './feedMasterPort.js';
+export { createDocCipher, isEncryptedEnvelope } from './docCipher.js';
+export { makeLwwConflictHandler } from './lwwConflictHandler.js';
+export { remotePayloadWins } from './lww.js';
+//# sourceMappingURL=index.js.map

package/dist/sync/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/sync/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;GAMG;AACH,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAA;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AACtD,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACrE,OAAO,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAC/D,OAAO,EACL,oBAAoB,EAOrB,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AACxD,OAAO,EACL,eAAe,EACf,mBAAmB,EAEpB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAA;AAChE,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA"}

package/dist/sync/lww.d.ts

@@ -0,0 +1,29 @@
+/*!
+ * Copyright (c) 2026 Interop Alliance. All rights reserved.
+ */
+/**
+ * The last-write-wins tiebreak for a mutable head document. Pure -- no React, no
+ * storage imports -- so both replicas run this identical rule against the same
+ * two payloads and converge on the same winner with no coordination.
+ *
+ * `updatedAt` (an ISO-8601 string, so lexical compare == chronological compare)
+ * decides; `deviceId` breaks an exact tie deterministically. Both fields live in
+ * the payload (never the envelope-level checkpoint `updatedAt`).
+ */
+/**
+ * Whether the remote payload wins over the local one under last-write-wins.
+ * Later `updatedAt` wins; on an exact `updatedAt` tie the lexically greater
+ * `deviceId` wins (an arbitrary but deterministic, replica-independent choice).
+ *
+ * @param remote {{ updatedAt: string; deviceId: string }}
+ * @param local {{ updatedAt: string; deviceId: string }}
+ * @returns {boolean}   true if the remote payload should replace the local one
+ */
+export declare function remotePayloadWins(remote: {
+    updatedAt: string;
+    deviceId: string;
+}, local: {
+    updatedAt: string;
+    deviceId: string;
+}): boolean;
+//# sourceMappingURL=lww.d.ts.map

package/dist/sync/lww.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lww.d.ts","sourceRoot":"","sources":["../../src/sync/lww.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;GAQG;AAEH;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,EAC/C,KAAK,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAC7C,OAAO,CAKT"}

package/dist/sync/lww.js

@@ -0,0 +1,28 @@
+/*!
+ * Copyright (c) 2026 Interop Alliance. All rights reserved.
+ */
+/**
+ * The last-write-wins tiebreak for a mutable head document. Pure -- no React, no
+ * storage imports -- so both replicas run this identical rule against the same
+ * two payloads and converge on the same winner with no coordination.
+ *
+ * `updatedAt` (an ISO-8601 string, so lexical compare == chronological compare)
+ * decides; `deviceId` breaks an exact tie deterministically. Both fields live in
+ * the payload (never the envelope-level checkpoint `updatedAt`).
+ */
+/**
+ * Whether the remote payload wins over the local one under last-write-wins.
+ * Later `updatedAt` wins; on an exact `updatedAt` tie the lexically greater
+ * `deviceId` wins (an arbitrary but deterministic, replica-independent choice).
+ *
+ * @param remote {{ updatedAt: string; deviceId: string }}
+ * @param local {{ updatedAt: string; deviceId: string }}
+ * @returns {boolean}   true if the remote payload should replace the local one
+ */
+export function remotePayloadWins(remote, local) {
+    if (remote.updatedAt !== local.updatedAt) {
+        return remote.updatedAt > local.updatedAt;
+    }
+    return remote.deviceId > local.deviceId;
+}
+//# sourceMappingURL=lww.js.map

package/dist/sync/lww.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lww.js","sourceRoot":"","sources":["../../src/sync/lww.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;GAQG;AAEH;;;;;;;;GAQG;AACH,MAAM,UAAU,iBAAiB,CAC/B,MAA+C,EAC/C,KAA8C;IAE9C,IAAI,MAAM,CAAC,SAAS,KAAK,KAAK,CAAC,SAAS,EAAE,CAAC;QACzC,OAAO,MAAM,CAAC,SAAS,GAAG,KAAK,CAAC,SAAS,CAAA;IAC3C,CAAC;IACD,OAAO,MAAM,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAA;AACzC,CAAC"}

package/dist/sync/lww.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=lww.test.d.ts.map

package/dist/sync/lww.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lww.test.d.ts","sourceRoot":"","sources":["../../src/sync/lww.test.ts"],"names":[],"mappings":""}

package/dist/sync/lww.test.js

@@ -0,0 +1,28 @@
+/*!
+ * Copyright (c) 2026 Interop Alliance. All rights reserved.
+ */
+/**
+ * Unit tests for the last-write-wins tiebreak.
+ *
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest';
+import { remotePayloadWins } from './lww.js';
+describe('remotePayloadWins', () => {
+    it('later updatedAt wins (remote newer)', () => {
+        expect(remotePayloadWins({ updatedAt: '2026-01-02T00:00:00.000Z', deviceId: 'a' }, { updatedAt: '2026-01-01T00:00:00.000Z', deviceId: 'z' })).toBe(true);
+    });
+    it('earlier updatedAt loses (local newer)', () => {
+        expect(remotePayloadWins({ updatedAt: '2026-01-01T00:00:00.000Z', deviceId: 'z' }, { updatedAt: '2026-01-02T00:00:00.000Z', deviceId: 'a' })).toBe(false);
+    });
+    it('breaks an exact updatedAt tie by greater deviceId', () => {
+        const at = '2026-01-01T00:00:00.000Z';
+        expect(remotePayloadWins({ updatedAt: at, deviceId: 'b' }, { updatedAt: at, deviceId: 'a' })).toBe(true);
+        expect(remotePayloadWins({ updatedAt: at, deviceId: 'a' }, { updatedAt: at, deviceId: 'b' })).toBe(false);
+    });
+    it('a fully identical payload does not let remote win', () => {
+        const same = { updatedAt: '2026-01-01T00:00:00.000Z', deviceId: 'a' };
+        expect(remotePayloadWins(same, same)).toBe(false);
+    });
+});
+//# sourceMappingURL=lww.test.js.map

package/dist/sync/lww.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lww.test.js","sourceRoot":"","sources":["../../src/sync/lww.test.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;GAIG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAA;AAC7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAE5C,QAAQ,CAAC,mBAAmB,EAAE,GAAG,EAAE;IACjC,EAAE,CAAC,qCAAqC,EAAE,GAAG,EAAE;QAC7C,MAAM,CACJ,iBAAiB,CACf,EAAE,SAAS,EAAE,0BAA0B,EAAE,QAAQ,EAAE,GAAG,EAAE,EACxD,EAAE,SAAS,EAAE,0BAA0B,EAAE,QAAQ,EAAE,GAAG,EAAE,CACzD,CACF,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IACd,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,uCAAuC,EAAE,GAAG,EAAE;QAC/C,MAAM,CACJ,iBAAiB,CACf,EAAE,SAAS,EAAE,0BAA0B,EAAE,QAAQ,EAAE,GAAG,EAAE,EACxD,EAAE,SAAS,EAAE,0BAA0B,EAAE,QAAQ,EAAE,GAAG,EAAE,CACzD,CACF,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IACf,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,mDAAmD,EAAE,GAAG,EAAE;QAC3D,MAAM,EAAE,GAAG,0BAA0B,CAAA;QACrC,MAAM,CACJ,iBAAiB,CACf,EAAE,SAAS,EAAE,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,EAChC,EAAE,SAAS,EAAE,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,CACjC,CACF,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QACZ,MAAM,CACJ,iBAAiB,CACf,EAAE,SAAS,EAAE,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,EAChC,EAAE,SAAS,EAAE,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,CACjC,CACF,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IACf,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,mDAAmD,EAAE,GAAG,EAAE;QAC3D,MAAM,IAAI,GAAG,EAAE,SAAS,EAAE,0BAA0B,EAAE,QAAQ,EAAE,GAAG,EAAE,CAAA;QACrE,MAAM,CAAC,iBAAiB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IACnD,CAAC,CAAC,CAAA;AACJ,CAAC,CAAC,CAAA"}

package/dist/sync/lwwConflictHandler.d.ts

@@ -0,0 +1,49 @@
+/*!
+ * Copyright (c) 2026 Interop Alliance. All rights reserved.
+ */
+/**
+ * The RxDB conflict handler for a mutable-head (LWW) collection. RxDB's default
+ * handler always drops the local fork and keeps the remote master, which is
+ * correct for content-addressed (immutable-per-id) collections but wrong here:
+ * every entity is a mutable head that two devices can edit concurrently, so a
+ * genuine content conflict must be settled by last-write-wins on the payload's
+ * own `updatedAt` (deviceId tiebreak) -- exactly the rule two offline replicas
+ * apply independently to converge.
+ *
+ * The wrinkle is that the conflicting bodies are EDV envelopes (ciphertext), so
+ * `resolve` must decrypt both sides through this collection's cipher before it
+ * can compare the plaintext `updatedAt` / `deviceId`. `isEqual` stays cheap and
+ * synchronous (a structural compare of the opaque bodies), as RxDB requires.
+ *
+ * Convergence: the server holds ONE winner of the push race as `realMasterState`;
+ * every replica compares that same master against its own local edit, and the
+ * `payloadWins` comparator is a total order over `(updatedAt, deviceId)`, so the
+ * globally-latest payload wins on every replica with no coordination.
+ */
+import type { WithDeleted } from 'rxdb/plugins/core';
+import type { Json, SyncedDoc } from './types.js';
+/** The LWW fields read out of a decrypted entity payload. */
+interface LwwPayload {
+    updatedAt: string;
+    deviceId: string;
+}
+/**
+ * Builds an RxDB conflict handler that settles content conflicts by payload LWW,
+ * decrypting through the supplied per-collection `decrypt`.
+ *
+ * @param decrypt {(envelope: Json) => Promise<Json>}   this collection's decrypt
+ * @param [payloadWins] {(remote: LwwPayload, local: LwwPayload) => boolean}
+ *   the total-order comparator deciding whether the remote payload replaces the
+ *   local one; defaults to {@link remotePayloadWins} (later `updatedAt` wins,
+ *   `deviceId` breaks a tie)
+ * @returns {import('rxdb/plugins/core').RxConflictHandler<SyncedDoc>}
+ */
+export declare function makeLwwConflictHandler(decrypt: (envelope: Json) => Promise<Json>, payloadWins?: (remote: LwwPayload, local: LwwPayload) => boolean): {
+    isEqual(a: WithDeleted<SyncedDoc>, b: WithDeleted<SyncedDoc>): boolean;
+    resolve({ realMasterState, newDocumentState }: {
+        realMasterState: WithDeleted<SyncedDoc>;
+        newDocumentState: WithDeleted<SyncedDoc>;
+    }): Promise<WithDeleted<SyncedDoc>>;
+};
+export {};
+//# sourceMappingURL=lwwConflictHandler.d.ts.map

package/dist/sync/lwwConflictHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lwwConflictHandler.d.ts","sourceRoot":"","sources":["../../src/sync/lwwConflictHandler.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AACpD,OAAO,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAGjD,6DAA6D;AAC7D,UAAU,UAAU;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;CACjB;AAiCD;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,CAAC,QAAQ,EAAE,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC,EAC1C,WAAW,GAAE,CACX,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,UAAU,KACd,OAA2B;eAKnB,WAAW,CAAC,SAAS,CAAC,KAAK,WAAW,CAAC,SAAS,CAAC,GAAG,OAAO;mDAOnE;QACD,eAAe,EAAE,WAAW,CAAC,SAAS,CAAC,CAAA;QACvC,gBAAgB,EAAE,WAAW,CAAC,SAAS,CAAC,CAAA;KACzC,GAAG,OAAO,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;EAmBtC"}

package/dist/sync/lwwConflictHandler.js

@@ -0,0 +1,65 @@
+import { remotePayloadWins } from './lww.js';
+/** Structural equality of two opaque bodies (used for the fast `isEqual`). */
+function bodiesEqual(a, b) {
+    return JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
+}
+/**
+ * Decrypts one side's envelope into its `{ updatedAt, deviceId }`, or `null`
+ * when the side has no decryptable payload (a tombstone, or an absent/corrupt
+ * body). `null` means "no comparable timestamp", handled by the caller.
+ */
+async function lwwFieldsOf(doc, decrypt) {
+    if (doc._deleted || doc.data === undefined) {
+        return null;
+    }
+    try {
+        const payload = (await decrypt(doc.data));
+        if (typeof payload.updatedAt === 'string' &&
+            typeof payload.deviceId === 'string') {
+            return { updatedAt: payload.updatedAt, deviceId: payload.deviceId };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Builds an RxDB conflict handler that settles content conflicts by payload LWW,
+ * decrypting through the supplied per-collection `decrypt`.
+ *
+ * @param decrypt {(envelope: Json) => Promise<Json>}   this collection's decrypt
+ * @param [payloadWins] {(remote: LwwPayload, local: LwwPayload) => boolean}
+ *   the total-order comparator deciding whether the remote payload replaces the
+ *   local one; defaults to {@link remotePayloadWins} (later `updatedAt` wins,
+ *   `deviceId` breaks a tie)
+ * @returns {import('rxdb/plugins/core').RxConflictHandler<SyncedDoc>}
+ */
+export function makeLwwConflictHandler(decrypt, payloadWins = remotePayloadWins) {
+    return {
+        // Non-async and fast, as RxDB requires: no real conflict when the opaque
+        // content + deletion flag already agree (e.g. our own write echoing back).
+        isEqual(a, b) {
+            return a._deleted === b._deleted && bodiesEqual(a.data, b.data);
+        },
+        async resolve({ realMasterState, newDocumentState }) {
+            const [remote, local] = await Promise.all([
+                lwwFieldsOf(realMasterState, decrypt),
+                lwwFieldsOf(newDocumentState, decrypt)
+            ]);
+            // Both sides comparable: pure payload LWW.
+            if (remote && local) {
+                return payloadWins(remote, local) ? realMasterState : newDocumentState;
+            }
+            // A live local edit against a remote tombstone (or otherwise
+            // incomparable remote): keep the edit (resurrect / re-assert the write).
+            if (local && !remote) {
+                return newDocumentState;
+            }
+            // Everything else (local tombstone, both incomparable): the master wins,
+            // which is deterministic and convergent across replicas.
+            return realMasterState;
+        }
+    };
+}
+//# sourceMappingURL=lwwConflictHandler.js.map

package/dist/sync/lwwConflictHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lwwConflictHandler.js","sourceRoot":"","sources":["../../src/sync/lwwConflictHandler.ts"],"names":[],"mappings":"AAwBA,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAQ5C,8EAA8E;AAC9E,SAAS,WAAW,CAAC,CAAmB,EAAE,CAAmB;IAC3D,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,IAAI,IAAI,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,CAAC,IAAI,IAAI,CAAC,CAAA;AAChE,CAAC;AAED;;;;GAIG;AACH,KAAK,UAAU,WAAW,CACxB,GAA2B,EAC3B,OAA0C;IAE1C,IAAI,GAAG,CAAC,QAAQ,IAAI,GAAG,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;QAC3C,OAAO,IAAI,CAAA;IACb,CAAC;IACD,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,CAAC,MAAM,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAwB,CAAA;QAChE,IACE,OAAO,OAAO,CAAC,SAAS,KAAK,QAAQ;YACrC,OAAO,OAAO,CAAC,QAAQ,KAAK,QAAQ,EACpC,CAAC;YACD,OAAO,EAAE,SAAS,EAAE,OAAO,CAAC,SAAS,EAAE,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAAE,CAAA;QACrE,CAAC;QACD,OAAO,IAAI,CAAA;IACb,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAA;IACb,CAAC;AACH,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,sBAAsB,CACpC,OAA0C,EAC1C,cAGe,iBAAiB;IAEhC,OAAO;QACL,yEAAyE;QACzE,2EAA2E;QAC3E,OAAO,CAAC,CAAyB,EAAE,CAAyB;YAC1D,OAAO,CAAC,CAAC,QAAQ,KAAK,CAAC,CAAC,QAAQ,IAAI,WAAW,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAA;QACjE,CAAC;QAED,KAAK,CAAC,OAAO,CAAC,EACZ,eAAe,EACf,gBAAgB,EAIjB;YACC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;gBACxC,WAAW,CAAC,eAAe,EAAE,OAAO,CAAC;gBACrC,WAAW,CAAC,gBAAgB,EAAE,OAAO,CAAC;aACvC,CAAC,CAAA;YACF,2CAA2C;YAC3C,IAAI,MAAM,IAAI,KAAK,EAAE,CAAC;gBACpB,OAAO,WAAW,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,gBAAgB,CAAA;YACxE,CAAC;YACD,6DAA6D;YAC7D,yEAAyE;YACzE,IAAI,KAAK,IAAI,CAAC,MAAM,EAAE,CAAC;gBACrB,OAAO,gBAAgB,CAAA;YACzB,CAAC;YACD,yEAAyE;YACzE,yDAAyD;YACzD,OAAO,eAAe,CAAA;QACxB,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/sync/lwwConflictHandler.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=lwwConflictHandler.test.d.ts.map

package/dist/sync/lwwConflictHandler.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lwwConflictHandler.test.d.ts","sourceRoot":"","sources":["../../src/sync/lwwConflictHandler.test.ts"],"names":[],"mappings":""}

package/dist/sync/lwwConflictHandler.test.js

@@ -0,0 +1,78 @@
+/*!
+ * Copyright (c) 2026 Interop Alliance. All rights reserved.
+ */
+import { describe, it, expect } from 'vitest';
+import { makeLwwConflictHandler } from './lwwConflictHandler.js';
+// A fake cipher whose "envelope" is just the plaintext payload wrapped in
+// `{ jwe: payload }`; decrypt unwraps it. Lets us drive the handler's LWW
+// decision without real crypto.
+const decrypt = async (envelope) => envelope.jwe;
+function row(payload, { deleted = false, version = 0 } = {}) {
+    const doc = {
+        id: 'r1',
+        updatedAt: '2026-01-01T00:00:00Z',
+        version,
+        _deleted: deleted
+    };
+    if (payload !== null) {
+        doc.data = { jwe: payload };
+    }
+    return doc;
+}
+const handler = makeLwwConflictHandler(decrypt);
+describe('makeLwwConflictHandler', () => {
+    it('isEqual is true only when body + deletion agree', () => {
+        const a = row({ updatedAt: 't1', deviceId: 'd1' });
+        const b = row({ updatedAt: 't1', deviceId: 'd1' });
+        const c = row({ updatedAt: 't2', deviceId: 'd1' });
+        expect(handler.isEqual(a, b)).toBe(true);
+        expect(handler.isEqual(a, c)).toBe(false);
+        expect(handler.isEqual(a, { ...b, _deleted: true })).toBe(false);
+    });
+    it('resolves to the later payload (remote wins)', async () => {
+        const remote = row({ updatedAt: '2026-02-02T00:00:00Z', deviceId: 'dB' });
+        const local = row({ updatedAt: '2026-01-01T00:00:00Z', deviceId: 'dA' });
+        const winner = await handler.resolve({
+            realMasterState: remote,
+            newDocumentState: local
+        });
+        expect(winner).toBe(remote);
+    });
+    it('resolves to the later payload (local wins)', async () => {
+        const remote = row({ updatedAt: '2026-01-01T00:00:00Z', deviceId: 'dB' });
+        const local = row({ updatedAt: '2026-02-02T00:00:00Z', deviceId: 'dA' });
+        const winner = await handler.resolve({
+            realMasterState: remote,
+            newDocumentState: local
+        });
+        expect(winner).toBe(local);
+    });
+    it('breaks an exact updatedAt tie by greater deviceId', async () => {
+        const remote = row({ updatedAt: 'T', deviceId: 'dZ' });
+        const local = row({ updatedAt: 'T', deviceId: 'dA' });
+        const winner = await handler.resolve({
+            realMasterState: remote,
+            newDocumentState: local
+        });
+        expect(winner).toBe(remote);
+    });
+    it('keeps a live local edit over a remote tombstone', async () => {
+        const remote = row(null, { deleted: true, version: 3 });
+        const local = row({ updatedAt: 'T', deviceId: 'dA' });
+        const winner = await handler.resolve({
+            realMasterState: remote,
+            newDocumentState: local
+        });
+        expect(winner).toBe(local);
+    });
+    it('defaults to the master when incomparable (local tombstone)', async () => {
+        const remote = row({ updatedAt: 'T', deviceId: 'dB' }, { version: 2 });
+        const local = row(null, { deleted: true });
+        const winner = await handler.resolve({
+            realMasterState: remote,
+            newDocumentState: local
+        });
+        expect(winner).toBe(remote);
+    });
+});
+//# sourceMappingURL=lwwConflictHandler.test.js.map

package/dist/sync/lwwConflictHandler.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lwwConflictHandler.test.js","sourceRoot":"","sources":["../../src/sync/lwwConflictHandler.test.ts"],"names":[],"mappings":"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"}

package/dist/sync/pushWrites.d.ts

@@ -0,0 +1,57 @@
+/*!
+ * Copyright (c) 2026 Interop Alliance. All rights reserved.
+ */
+/**
+ * The push side of the WAS replication adapter: fans each local change out to
+ * conditional WAS writes and assembles the RxDB conflict entry when the server
+ * rejects a write with `412`.
+ *
+ * A single RxDB document spans two independently-versioned sub-resources: the
+ * content (`data` / `version`, at `PUT/DELETE /:id`) and the metadata (`custom`
+ * / `metaVersion`, at `PUT /:id/meta`). This handler diffs the new local state
+ * against the assumed master to route each half:
+ *
+ * - content changed -> `PUT /:id` (`If-Match: "<version>"`) or, on create,
+ *   `PUT /:id` (`If-None-Match: *`); a delete -> `DELETE /:id`.
+ * - metadata changed -> `PUT /:id/meta` (`If-Match: "<metaVersion>"`, or
+ *   `If-None-Match: *` when the resource has no metadata yet).
+ *
+ * Content is written before metadata on a create, because the server rejects a
+ * `/meta` write to a resource that does not yet exist.
+ *
+ * RxDB's push contract asks only for *conflicts* back (the current master state
+ * of each rejected row); a successful write's new `version` / `metaVersion` is
+ * not returned here -- it is picked up on the next pull, where our own write
+ * echoes back as a remote change (idempotent, since the bodies are
+ * byte-identical). We deliberately do not capture the `204` ETag to short-circuit
+ * that echo: doing so would require a side write to the local revision fields
+ * from inside the push handler, which risks a re-push loop, for no correctness
+ * gain on immutable content-addressed collections.
+ */
+import type { WithDeleted } from 'rxdb/plugins/core';
+import type { SyncedDoc, WasSyncPort } from './types.js';
+/**
+ * Formats a master revision (`version` or `metaVersion`) as the quoted strong
+ * ETag the server compares `If-Match` against (revision `3` becomes `"3"`).
+ *
+ * @param revision {number}
+ * @returns {string}
+ */
+export declare function formatEtag(revision: number): string;
+/**
+ * Builds the RxDB push handler that fans a batch of local changes out to
+ * conditional WAS writes and returns the conflicting rows' master states.
+ *
+ * Rows are pushed concurrently; if any non-conflict error is thrown the whole
+ * batch rejects (RxDB re-sends it later), matching RxDB's all-or-nothing retry.
+ *
+ * @param port {WasSyncPort}
+ * @returns {(rows: Array<{ newDocumentState: WithDeleted<SyncedDoc>,
+ *   assumedMasterState?: WithDeleted<SyncedDoc> }>) =>
+ *   Promise<WithDeleted<SyncedDoc>[]>}
+ */
+export declare function createPushHandler(port: WasSyncPort): (rows: Array<{
+    newDocumentState: WithDeleted<SyncedDoc>;
+    assumedMasterState?: WithDeleted<SyncedDoc>;
+}>) => Promise<WithDeleted<SyncedDoc>[]>;
+//# sourceMappingURL=pushWrites.d.ts.map

package/dist/sync/pushWrites.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pushWrites.d.ts","sourceRoot":"","sources":["../../src/sync/pushWrites.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AACpD,OAAO,KAAK,EAAqB,SAAS,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAG3E;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEnD;AA0JD;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,WAAW,IAE/C,MAAM,KAAK,CAAC;IACV,gBAAgB,EAAE,WAAW,CAAC,SAAS,CAAC,CAAA;IACxC,kBAAkB,CAAC,EAAE,WAAW,CAAC,SAAS,CAAC,CAAA;CAC5C,CAAC,KACD,OAAO,CAAC,WAAW,CAAC,SAAS,CAAC,EAAE,CAAC,CAcrC"}