@interop/was-react 0.20.1 → 0.22.0

package/dist/sync/changesQuery.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"changesQuery.js","sourceRoot":"","sources":["../../src/sync/changesQuery.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAA;AAEnD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,cAAc,CAAC,GAAY;IACzC,MAAM,KAAK,GAA2B;QACpC,EAAE,EAAE,GAAG,CAAC,EAAE;QACV,SAAS,EAAE,GAAG,CAAC,SAAS;QACxB,OAAO,EAAE,GAAG,CAAC,OAAO;QACpB,QAAQ,EAAE,GAAG,CAAC,QAAQ;KACvB,CAAA;IACD,sBAAsB,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAA;IACtD,OAAO,KAAK,CAAA;AACd,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAiB;IACjD,OAAO,KAAK,UAAU,IAAI,CACxB,cAA0C,EAC1C,SAAiB;QAKjB,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC;YAChC,kEAAkE;YAClE,iCAAiC;YACjC,GAAG,CAAC,cAAc,KAAK,SAAS,IAAI,EAAE,UAAU,EAAE,cAAc,EAAE,CAAC;YACnE,KAAK,EAAE,SAAS;SACjB,CAAC,CAAA;QACF,OAAO;YACL,SAAS,EAAE,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,cAAc,CAAC;YACjD,oEAAoE;YACpE,8DAA8D;YAC9D,UAAU,EAAE,QAAQ,CAAC,UAAU,IAAI,cAAc;SAClD,CAAA;IACH,CAAC,CAAA;AACH,CAAC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"docCipher.d.ts","sourceRoot":"","sources":["../../src/sync/docCipher.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,EACV,gBAAgB,EAChB,YAAY,EACb,MAAM,8BAA8B,CAAA;AACrC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAA;AAG/D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAEtC;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAKzD;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,SAAS;IACxB,OAAO,CAAC,OAAO,EAAE;QACf,IAAI,EAAE,IAAI,CAAA;KACX,GAAG,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,IAAI,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IAC3D,aAAa,CAAC,OAAO,EAAE;QACrB,EAAE,EAAE,MAAM,CAAA;QACV,IAAI,EAAE,IAAI,CAAA;QACV,OAAO,EAAE,IAAI,CAAA;KACd,GAAG,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,IAAI,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IAC3D,OAAO,CAAC,OAAO,EAAE;QAAE,QAAQ,EAAE,IAAI,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACnD,SAAS,CAAC,CAAC,OAAO,EAAE;QAAE,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;CAC5D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,uBAAuB,CAAC,EACtC,YAAY,EACb,EAAE;IACD,YAAY,EAAE,MAAM,CAAA;CACrB,GAAG,SAAS,CAiCZ;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAsB,eAAe,CAAC,EACpC,eAAe,EACf,WAAW,EACX,YAAY,EACZ,UAAU,EACV,IAAI,EACL,EAAE;IACD,eAAe,EAAE,gBAAgB,CAAA;IACjC,WAAW,EAAE,YAAY,CAAA;IACzB,YAAY,EAAE,MAAM,CAAA;IACpB,UAAU,EAAE,oBAAoB,CAAA;IAChC,IAAI,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,CAAA;CAC5B,GAAG,OAAO,CAAC,SAAS,CAAC,CAUrB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,4BAA4B,CAAC,EAC3C,YAAY,EACb,EAAE;IACD,YAAY,EAAE,MAAM,CAAA;CACrB,GAAG,SAAS,CAkBZ"}

package/dist/sync/docCipher.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"docCipher.js","sourceRoot":"","sources":["../../src/sync/docCipher.ts"],"names":[],"mappings":"AA6BA,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAC/E,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAG9D;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,mBAAmB,CAAC,GAAY;IAC9C,OAAO,CACL,GAAG,YAAY,iBAAiB;QAChC,CAAC,GAAG,YAAY,KAAK,IAAI,GAAG,CAAC,IAAI,KAAK,mBAAmB,CAAC,CAC3D,CAAA;AACH,CAAC;AA6BD;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,uBAAuB,CAAC,EACtC,YAAY,EAGb;IACC,MAAM,SAAS,GAAG,CAAC,IAAU,EAAU,EAAE;QACvC,MAAM,EAAE,GAAI,IAAgC,EAAE,EAAE,CAAA;QAChD,IAAI,OAAO,EAAE,KAAK,QAAQ,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC9C,MAAM,IAAI,KAAK,CACb,kCAAkC,YAAY,2BAA2B,CAC1E,CAAA;QACH,CAAC;QACD,OAAO,EAAE,CAAA;IACX,CAAC,CAAA;IACD,MAAM,eAAe,GAAG,CAAC,IAAU,EAAQ,EAAE;QAC3C,IAAI,mBAAmB,CAAC,IAAI,CAAC,EAAE,CAAC;YAC9B,MAAM,IAAI,KAAK,CACb,eAAe,YAAY,yCAAyC;gBAClE,yBAAyB,CAC5B,CAAA;QACH,CAAC;QACD,OAAO,IAAI,CAAA;IACb,CAAC,CAAA;IAED,OAAO;QACL,KAAK,CAAC,OAAO,CAAC,EAAE,IAAI,EAAkB;YACpC,OAAO,EAAE,EAAE,EAAE,SAAS,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAA;QAChD,CAAC;QAED,KAAK,CAAC,aAAa,CAAC,EAAE,EAAE,EAAE,IAAI,EAA8B;YAC1D,OAAO,EAAE,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAA;QAC/B,CAAC;QAED,KAAK,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAsB;YAC5C,OAAO,eAAe,CAAC,QAAQ,CAAC,CAAA;QAClC,CAAC;KACF,CAAA;AACH,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,EACpC,eAAe,EACf,WAAW,EACX,YAAY,EACZ,UAAU,EACV,IAAI,EAOL;IACC,MAAM,MAAM,GAAG,MAAM,kBAAkB,CAAC;QACtC,eAAe;QACf,WAAW;QACX,YAAY;QACZ,YAAY,EAAE,QAAQ;QACtB,UAAU;QACV,GAAG,CAAC,IAAI,KAAK,SAAS,IAAI,EAAE,IAAI,EAAE,CAAC;KACpC,CAAC,CAAA;IACF,OAAO,MAA8B,CAAA;AACvC,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,4BAA4B,CAAC,EAC3C,YAAY,EAGb;IACC,MAAM,WAAW,GAAG,GAAU,EAAE;QAC9B,MAAM,IAAI,KAAK,CACb,eAAe,YAAY,2CAA2C;YACpE,4DAA4D,CAC/D,CAAA;IACH,CAAC,CAAA;IACD,OAAO;QACL,KAAK,CAAC,OAAO;YACX,OAAO,WAAW,EAAE,CAAA;QACtB,CAAC;QACD,KAAK,CAAC,aAAa;YACjB,OAAO,WAAW,EAAE,CAAA;QACtB,CAAC;QACD,KAAK,CAAC,OAAO;YACX,MAAM,IAAI,iBAAiB,CAAC,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,CAAA;QACzD,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/sync/feedMasterPort.d.ts

@@ -1,38 +0,0 @@
-/*!
- * Copyright (c) 2026 Interop Alliance. All rights reserved.
- */
-/**
- * The `get` half of a {@link WasSyncPort}: resolves a resource's current master
- * state (for the 412 conflict re-read) from the CHANGES-FEED BODY. Wraps a
- * {@link WasSyncBasePort} (query + conditional writes) and adds the `get` the
- * conflict assembler needs, producing a full {@link WasSyncPort}.
- *
- * Why the feed body rather than a `GET` ETag header: the mutable-head model
- * settles a 412 by re-reading the resource's current `version` and comparing
- * payloads (LWW). A raw `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
- * would make a cross-origin re-read report `version: 0`, so the loser of a push
- * race would 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).
- */
-import type { WasSyncBasePort, WasSyncPort } from './types.js';
-/**
- * Wraps a base port with a `get` that resolves the master state from the changes
- * feed. `query`, `putContent`, `deleteContent`, and `putMeta` pass straight
- * through.
- *
- * A walk starts at the feed's origin, so resolving one resource pages past many
- * others. With a per-push-batch `cache` the walk memoizes every one of them, and
- * a row that finds a walk already running waits for it rather than starting a
- * second -- so a batch of k conflicting rows costs one feed scan instead of k
- * concurrent ones. Without a `cache` the behavior is exactly as before.
- *
- * @param base {WasSyncBasePort}
- * @returns {WasSyncPort}
- */
-export declare function withFeedMasterRead(base: WasSyncBasePort): WasSyncPort;
-//# sourceMappingURL=feedMasterPort.d.ts.map

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

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

package/dist/sync/feedMasterPort.js

@@ -1,116 +0,0 @@
-import { copyOptionalBodyFields } from './types.js';
-// 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
-    };
-    copyOptionalBodyFields({ source: doc, target: master });
-    return master;
-}
-/**
- * Walks the changes feed from its origin looking for one resource, memoizing
- * every document it pages past when the caller supplied a batch `cache`.
- *
- * @param options {object}
- * @param options.base {WasSyncBasePort}
- * @param options.id {string}
- * @param [options.cache] {MasterReadCache}
- * @returns {Promise<MasterState | null>}
- */
-async function walkFeedFor({ base, id, cache }) {
-    let checkpoint;
-    for (let page = 0; page < MAX_PAGES; page++) {
-        const { documents, checkpoint: next } = await base.query({
-            ...(checkpoint !== undefined && { checkpoint }),
-            limit: PAGE_SIZE
-        });
-        const byId = new Map(documents.map(doc => [doc.id, doc]));
-        if (cache !== undefined) {
-            for (const [docId, doc] of byId) {
-                cache.byId.set(docId, toMasterState(doc));
-            }
-        }
-        const found = byId.get(id);
-        if (found) {
-            return toMasterState(found);
-        }
-        // Reached the end of the feed without finding it: the resource is
-        // genuinely absent (a delete/delete race), so report `null` and let the
-        // conflict assembler synthesize a tombstone. Only THIS id is memoized as
-        // absent, never "every id this completed walk did not see": a row of the
-        // same batch may have created its resource after this walk read the feed,
-        // and answering `null` for it would fabricate a tombstone and drop a live
-        // payload -- exactly what the scan-budget throw below guards against.
-        if (next === null || documents.length === 0) {
-            cache?.byId.set(id, null);
-            return null;
-        }
-        checkpoint = next;
-    }
-    // The page budget ran out before the feed's end. The feed is keyset-ordered
-    // ascending on `updatedAt`, so a just-conflicted resource sits at the tail --
-    // the least-reachable position -- and may well be past the cap. Reporting
-    // `null` here would fabricate a false tombstone in the conflict assembler and
-    // drop the winner's payload. Throw instead: RxDB treats a thrown push-handler
-    // error as retryable, so the whole replication cycle retries rather than
-    // diverging.
-    throw new Error(`Feed master re-read for resource "${id}" exhausted its ` +
-        `${MAX_PAGES}-page scan budget without reaching the end of the ` +
-        `changes feed; retrying.`);
-}
-/**
- * Wraps a base port with a `get` that resolves the master state from the changes
- * feed. `query`, `putContent`, `deleteContent`, and `putMeta` pass straight
- * through.
- *
- * A walk starts at the feed's origin, so resolving one resource pages past many
- * others. With a per-push-batch `cache` the walk memoizes every one of them, and
- * a row that finds a walk already running waits for it rather than starting a
- * second -- so a batch of k conflicting rows costs one feed scan instead of k
- * concurrent ones. Without a `cache` the behavior is exactly as before.
- *
- * @param base {WasSyncBasePort}
- * @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, cache }) {
-            if (cache === undefined) {
-                return walkFeedFor({ base, id });
-            }
-            // Wait out whatever walk this batch already has running -- it pages past
-            // every resource, so it may well answer this read -- then re-check the
-            // memo. Looped because the walk we waited for can be followed by another.
-            while (cache.inFlight !== null) {
-                await cache.inFlight;
-            }
-            const memoized = cache.byId.get(id);
-            if (memoized !== undefined) {
-                return memoized;
-            }
-            // Publish this walk for the batch's other rows. Nothing above awaits
-            // between the memo miss and here, so two rows can never both get past it.
-            // The published promise SETTLES either way: a walk that threw is this
-            // row's error to propagate, not a waiting row's.
-            const walk = walkFeedFor({ base, id, cache });
-            const clear = () => {
-                cache.inFlight = null;
-            };
-            cache.inFlight = walk.then(clear, clear);
-            return walk;
-        }
-    };
-}
-//# sourceMappingURL=feedMasterPort.js.map

package/dist/sync/feedMasterPort.js.map

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

package/dist/sync/index.d.ts

@@ -1,23 +0,0 @@
-/*!
- * 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, type PushWriteAck } from './pushWrites.js';
-export { WasSyncConflictError, WasSyncAuthError, type Json, type SyncCheckpoint, type WireDoc, type SyncedDoc, type MasterState, type MasterReadCache, type WasSyncBasePort, type WasSyncPort } from './types.js';
-export { createWasSyncPort } from './wasSyncPort.js';
-export { withFeedMasterRead } from './feedMasterPort.js';
-export { createDocCipher, createPlaintextDocCodec, createUnprovisionedDocCipher, isUnknownEpochError, type DocCipher } from './docCipher.js';
-export { makeLwwConflictHandler } from './lwwConflictHandler.js';
-export { lwwFields, remotePayloadWins, type LwwFields } from './lww.js';
-export { errorStatus, errorMessage, formatEtag, isEncryptedEnvelope } from '@interop/was-client/sync';
-export { hasKeyEpochs, epochRostersEqual } from '@interop/was-client/edv';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"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,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAA;AACtE,OAAO,EACL,oBAAoB,EACpB,gBAAgB,EAChB,KAAK,IAAI,EACT,KAAK,cAAc,EACnB,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,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,uBAAuB,EACvB,4BAA4B,EAC5B,mBAAmB,EACnB,KAAK,SAAS,EACf,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAA;AAChE,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,KAAK,SAAS,EAAE,MAAM,UAAU,CAAA;AAGvE,OAAO,EACL,WAAW,EACX,YAAY,EACZ,UAAU,EACV,mBAAmB,EACpB,MAAM,0BAA0B,CAAA;AAGjC,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA"}

package/dist/sync/index.js

@@ -1,27 +0,0 @@
-/*!
- * 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 } from './pushWrites.js';
-export { WasSyncConflictError, WasSyncAuthError } from './types.js';
-export { createWasSyncPort } from './wasSyncPort.js';
-export { withFeedMasterRead } from './feedMasterPort.js';
-export { createDocCipher, createPlaintextDocCodec, createUnprovisionedDocCipher, isUnknownEpochError } from './docCipher.js';
-export { makeLwwConflictHandler } from './lwwConflictHandler.js';
-export { lwwFields, remotePayloadWins } from './lww.js';
-// Owned by the client's sync subpath and re-exported verbatim, so the names this
-// package's consumers already import stay put.
-export { errorStatus, errorMessage, formatEtag, isEncryptedEnvelope } from '@interop/was-client/sync';
-// The crypto-free predicates over a collection's encryption descriptor, owned by
-// the client's EDV subpath and re-exported verbatim for the same reason.
-export { hasKeyEpochs, epochRostersEqual } from '@interop/was-client/edv';
-//# sourceMappingURL=index.js.map

package/dist/sync/index.js.map

@@ -1 +0,0 @@
-{"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,EAAqB,MAAM,iBAAiB,CAAA;AACtE,OAAO,EACL,oBAAoB,EACpB,gBAAgB,EASjB,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AACxD,OAAO,EACL,eAAe,EACf,uBAAuB,EACvB,4BAA4B,EAC5B,mBAAmB,EAEpB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAA;AAChE,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAkB,MAAM,UAAU,CAAA;AACvE,iFAAiF;AACjF,+CAA+C;AAC/C,OAAO,EACL,WAAW,EACX,YAAY,EACZ,UAAU,EACV,mBAAmB,EACpB,MAAM,0BAA0B,CAAA;AACjC,iFAAiF;AACjF,yEAAyE;AACzE,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA"}

package/dist/sync/lww.d.ts

@@ -1,50 +0,0 @@
-/*!
- * 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) decides, compared CHRONOLOGICALLY (parsed to
- * epoch ms, never lexically -- `updatedAt` is app-owned, so mixed precision like
- * `...05Z` vs `...05.400Z`, or a `+00:00` offset, must still order by instant);
- * `writerId` breaks an exact-instant tie deterministically. Both fields live in
- * the payload (never the envelope-level checkpoint `updatedAt`).
- */
-/**
- * The two fields the last-write-wins rule reads off a payload: the app-owned
- * ISO-8601 edit stamp and the writing client's id (the exact-instant
- * tiebreaker). Read off a doc with {@link lwwFields}; compared with
- * {@link remotePayloadWins}.
- */
-export interface LwwFields {
-    updatedAt: string;
-    writerId: string;
-}
-/**
- * Whether the remote payload wins over the local one under last-write-wins.
- * The chronologically later `updatedAt` wins; on an exact-instant tie the
- * lexically greater `writerId` wins (an arbitrary but deterministic,
- * replica-independent choice).
- *
- * Unparseable `updatedAt` values are rejected as losers: a side whose stamp
- * does not parse loses to one whose stamp does (a replica-independent rule, so
- * every device converges on the same winner). When neither side parses, the
- * lexical compare of the raw strings is the deterministic fallback.
- *
- * @param remote {LwwFields}
- * @param local {LwwFields}
- * @returns {boolean}   true if the remote payload should replace the local one
- */
-export declare function remotePayloadWins(remote: LwwFields, local: LwwFields): boolean;
-/**
- * Reads the LWW fields off a doc when it carries them. Storage payloads are
- * generic over `{ id: string }`, so docs without `updatedAt`/`writerId` are
- * legal; callers fall back to their own rule for those.
- *
- * @param doc {unknown}
- * @returns {LwwFields | null}
- */
-export declare function lwwFields(doc: unknown): LwwFields | null;
-//# sourceMappingURL=lww.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"lww.d.ts","sourceRoot":"","sources":["../../src/sync/lww.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;GAUG;AAEH;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACxB,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;CACjB;AAUD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,SAAS,GACf,OAAO,CAeT;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,OAAO,GAAG,SAAS,GAAG,IAAI,CAQxD"}

package/dist/sync/lww.js

@@ -1,69 +0,0 @@
-/*!
- * 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) decides, compared CHRONOLOGICALLY (parsed to
- * epoch ms, never lexically -- `updatedAt` is app-owned, so mixed precision like
- * `...05Z` vs `...05.400Z`, or a `+00:00` offset, must still order by instant);
- * `writerId` breaks an exact-instant tie deterministically. Both fields live in
- * the payload (never the envelope-level checkpoint `updatedAt`).
- */
-/**
- * Parses an ISO-8601 `updatedAt` into epoch ms, or `null` when unparseable.
- */
-function parseInstant(updatedAt) {
-    const ms = Date.parse(updatedAt);
-    return Number.isNaN(ms) ? null : ms;
-}
-/**
- * Whether the remote payload wins over the local one under last-write-wins.
- * The chronologically later `updatedAt` wins; on an exact-instant tie the
- * lexically greater `writerId` wins (an arbitrary but deterministic,
- * replica-independent choice).
- *
- * Unparseable `updatedAt` values are rejected as losers: a side whose stamp
- * does not parse loses to one whose stamp does (a replica-independent rule, so
- * every device converges on the same winner). When neither side parses, the
- * lexical compare of the raw strings is the deterministic fallback.
- *
- * @param remote {LwwFields}
- * @param local {LwwFields}
- * @returns {boolean}   true if the remote payload should replace the local one
- */
-export function remotePayloadWins(remote, local) {
-    const remoteMs = parseInstant(remote.updatedAt);
-    const localMs = parseInstant(local.updatedAt);
-    if (remoteMs !== null && localMs !== null) {
-        if (remoteMs !== localMs) {
-            return remoteMs > localMs;
-        }
-    }
-    else if (remoteMs !== null || localMs !== null) {
-        // Exactly one side parses: the parseable stamp wins.
-        return remoteMs !== null;
-    }
-    else if (remote.updatedAt !== local.updatedAt) {
-        // Neither parses: fall back to the deterministic lexical compare.
-        return remote.updatedAt > local.updatedAt;
-    }
-    return remote.writerId > local.writerId;
-}
-/**
- * Reads the LWW fields off a doc when it carries them. Storage payloads are
- * generic over `{ id: string }`, so docs without `updatedAt`/`writerId` are
- * legal; callers fall back to their own rule for those.
- *
- * @param doc {unknown}
- * @returns {LwwFields | null}
- */
-export function lwwFields(doc) {
-    const { updatedAt, writerId } = doc;
-    return typeof updatedAt === 'string' && typeof writerId === 'string'
-        ? { updatedAt, writerId }
-        : null;
-}
-//# sourceMappingURL=lww.js.map

package/dist/sync/lww.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"lww.js","sourceRoot":"","sources":["../../src/sync/lww.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;GAUG;AAaH;;GAEG;AACH,SAAS,YAAY,CAAC,SAAiB;IACrC,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAA;IAChC,OAAO,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAA;AACrC,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,iBAAiB,CAC/B,MAAiB,EACjB,KAAgB;IAEhB,MAAM,QAAQ,GAAG,YAAY,CAAC,MAAM,CAAC,SAAS,CAAC,CAAA;IAC/C,MAAM,OAAO,GAAG,YAAY,CAAC,KAAK,CAAC,SAAS,CAAC,CAAA;IAC7C,IAAI,QAAQ,KAAK,IAAI,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;QAC1C,IAAI,QAAQ,KAAK,OAAO,EAAE,CAAC;YACzB,OAAO,QAAQ,GAAG,OAAO,CAAA;QAC3B,CAAC;IACH,CAAC;SAAM,IAAI,QAAQ,KAAK,IAAI,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;QACjD,qDAAqD;QACrD,OAAO,QAAQ,KAAK,IAAI,CAAA;IAC1B,CAAC;SAAM,IAAI,MAAM,CAAC,SAAS,KAAK,KAAK,CAAC,SAAS,EAAE,CAAC;QAChD,kEAAkE;QAClE,OAAO,MAAM,CAAC,SAAS,GAAG,KAAK,CAAC,SAAS,CAAA;IAC3C,CAAC;IACD,OAAO,MAAM,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAA;AACzC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,SAAS,CAAC,GAAY;IACpC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,GAG/B,CAAA;IACD,OAAO,OAAO,SAAS,KAAK,QAAQ,IAAI,OAAO,QAAQ,KAAK,QAAQ;QAClE,CAAC,CAAC,EAAE,SAAS,EAAE,QAAQ,EAAE;QACzB,CAAC,CAAC,IAAI,CAAA;AACV,CAAC"}

package/dist/sync/lwwConflictHandler.d.ts

@@ -1,83 +0,0 @@
-/*!
- * 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` (writerId 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` / `writerId`. `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, writerId)`, so the
- * globally-latest payload wins on every replica with no coordination.
- *
- * The resolution rules, in order:
- *
- * 1. Version-only conflict: when the real master's whole content (`data` +
- *    `custom` + `_deleted`) still equals the assumed master's, the server holds
- *    nothing newer than what this replica last synced -- the 412 came from a
- *    stale `If-Match` (typically our own earlier write racing its feed echo).
- *    The local state (edit or tombstone) is re-asserted and re-pushed against
- *    the corrected version. Without this rule a local delete would be dropped by
- *    rule 5 and the entity would silently resurrect. `custom` MUST be part of
- *    this comparison, or a concurrent metadata-only edit committed on the server
- *    would be misclassified here and clobbered (rule 2 is what settles it).
- * 2. Metadata conflict: `data` and `_deleted` are unchanged from the assumed
- *    master but `custom` differs -- a metadata-only edit committed on the server
- *    since this replica last synced (another device won the `/meta` race).
- *    Metadata carries no LWW timestamp of its own (the payload `updatedAt` lives
- *    in the encrypted `data`, which is equal on both sides here), so there is no
- *    payload to compare; the sound, replica-independent default is that the
- *    server-committed state wins -- the real master is adopted for `custom`.
- *    Without this rule the equal-`data` case would fall through to rule 3, where
- *    the two payloads compare equal and the tie keeps the local (stale) `custom`,
- *    silently clobbering the committed metadata.
- * 3. An UNDECRYPTABLE side (the decrypt threw -- e.g. an envelope written under
- *    a key epoch this device has not seen) is never scored as the loser: it is
- *    presumed newer, not absent. An undecryptable master is adopted (never
- *    re-pushed over with the possibly-older local payload); an undecryptable
- *    local row is re-asserted (the user's edit is not silently dropped); both
- *    undecryptable adopts the master (deterministic and convergent). Each case
- *    is logged -- distinguishable from the intended tombstone/absent-body
- *    `null` the remaining rules were written for.
- * 4. Both sides carry an LWW payload: pure payload LWW via `payloadWins`.
- * 5. A live local edit vs an incomparable remote (e.g. a remote tombstone):
- *    the edit wins and is re-pushed (resurrection).
- * 6. Everything else -- a local tombstone vs a REAL remote content change, or
- *    both sides incomparable: the master wins. Together with rule 5 this makes
- *    the delete-vs-concurrent-edit rule "the edit wins" on every replica: a
- *    tombstone carries no LWW payload of its own, so a genuine racing edit
- *    deterministically survives, whichever write reached the server first.
- */
-import type { WithDeleted } from 'rxdb/plugins/core';
-import type { Json, SyncedDoc } from './types.js';
-import { type LwwFields } from './lww.js';
-/**
- * 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: LwwFields, local: LwwFields) => boolean}
- *   the total-order comparator deciding whether the remote payload replaces the
- *   local one; defaults to {@link remotePayloadWins} (later `updatedAt` wins,
- *   `writerId` breaks a tie)
- * @returns {import('rxdb/plugins/core').RxConflictHandler<SyncedDoc>}
- */
-export declare function makeLwwConflictHandler(decrypt: (envelope: Json) => Promise<Json>, payloadWins?: (remote: LwwFields, local: LwwFields) => boolean): {
-    isEqual(a: WithDeleted<SyncedDoc>, b: WithDeleted<SyncedDoc>): boolean;
-    resolve({ realMasterState, newDocumentState, assumedMasterState }: {
-        realMasterState: WithDeleted<SyncedDoc>;
-        newDocumentState: WithDeleted<SyncedDoc>;
-        assumedMasterState?: WithDeleted<SyncedDoc>;
-    }): Promise<WithDeleted<SyncedDoc>>;
-};
-//# sourceMappingURL=lwwConflictHandler.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"lwwConflictHandler.d.ts","sourceRoot":"","sources":["../../src/sync/lwwConflictHandler.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AACpD,OAAO,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAEjD,OAAO,EAAgC,KAAK,SAAS,EAAE,MAAM,UAAU,CAAA;AAoCvE;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,CAAC,QAAQ,EAAE,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC,EAC1C,WAAW,GAAE,CACX,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,SAAS,KACb,OAA2B;eAQnB,WAAW,CAAC,SAAS,CAAC,KAAK,WAAW,CAAC,SAAS,CAAC,GAAG,OAAO;uEAcnE;QACD,eAAe,EAAE,WAAW,CAAC,SAAS,CAAC,CAAA;QACvC,gBAAgB,EAAE,WAAW,CAAC,SAAS,CAAC,CAAA;QACxC,kBAAkB,CAAC,EAAE,WAAW,CAAC,SAAS,CAAC,CAAA;KAC5C,GAAG,OAAO,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;EAiFtC"}

package/dist/sync/lwwConflictHandler.js

@@ -1,114 +0,0 @@
-import { bodiesEqual } from './types.js';
-import { lwwFields, remotePayloadWins } from './lww.js';
-/**
- * Decrypts one side's envelope into its LWW comparability (see {@link LwwSide}).
- * A payload carrying no LWW stamp reads as `none`, the same as a tombstone or an
- * absent body: nothing there to compare.
- */
-async function lwwFieldsOf(doc, decrypt) {
-    if (doc._deleted || doc.data === undefined) {
-        return { kind: 'none' };
-    }
-    try {
-        const payload = lwwFields(await decrypt(doc.data));
-        return payload === null ? { kind: 'none' } : { kind: 'payload', payload };
-    }
-    catch (err) {
-        return { kind: 'undecryptable', err };
-    }
-}
-/**
- * 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: LwwFields, local: LwwFields) => boolean}
- *   the total-order comparator deciding whether the remote payload replaces the
- *   local one; defaults to {@link remotePayloadWins} (later `updatedAt` wins,
- *   `writerId` breaks a tie)
- * @returns {import('rxdb/plugins/core').RxConflictHandler<SyncedDoc>}
- */
-export function makeLwwConflictHandler(decrypt, payloadWins = remotePayloadWins) {
-    return {
-        // Non-async and fast, as RxDB requires. The server revisions (`version` /
-        // `metaVersion`) participate deliberately: our own write's feed echo comes
-        // back byte-identical but one revision ahead, and it must NOT compare
-        // equal, or the higher version is never adopted and every later
-        // conditional write sends a stale `If-Match` (a guaranteed 412).
-        isEqual(a, b) {
-            return (a._deleted === b._deleted &&
-                a.version === b.version &&
-                a.metaVersion === b.metaVersion &&
-                bodiesEqual(a.data, b.data) &&
-                bodiesEqual(a.custom, b.custom));
-        },
-        async resolve({ realMasterState, newDocumentState, assumedMasterState }) {
-            // Rule 1 -- version-only conflict: the master's whole content (`data` +
-            // `custom`) is exactly what this replica last synced (only the revision
-            // moved, e.g. our own write racing its feed echo), so nothing remote is
-            // actually newer. Re-assert the local state -- crucially including a local
-            // TOMBSTONE, which rule 5 would otherwise drop (the silent-resurrection
-            // bug). `custom` is part of this equality so a concurrent metadata-only
-            // edit is NOT misclassified here (rule 2 handles it).
-            if (assumedMasterState !== undefined &&
-                realMasterState._deleted === assumedMasterState._deleted &&
-                bodiesEqual(realMasterState.data, assumedMasterState.data) &&
-                bodiesEqual(realMasterState.custom, assumedMasterState.custom)) {
-                return newDocumentState;
-            }
-            // Rule 2 -- metadata conflict: `data` and `_deleted` are unchanged from
-            // the assumed master, but `custom` moved on the server (a metadata-only
-            // edit that won the `/meta` race on another device). Metadata has no LWW
-            // timestamp of its own -- the payload `updatedAt` lives in `data`, equal
-            // on both sides here -- so the sound, replica-independent default is that
-            // the server-committed state wins: adopt the real master for `custom`.
-            // Without this rule the equal-`data` case would reach rule 3 with two
-            // equal payloads and the tie would keep the local (stale) metadata.
-            if (assumedMasterState !== undefined &&
-                realMasterState._deleted === assumedMasterState._deleted &&
-                bodiesEqual(realMasterState.data, assumedMasterState.data) &&
-                !bodiesEqual(realMasterState.custom, assumedMasterState.custom)) {
-                return realMasterState;
-            }
-            const [remote, local] = await Promise.all([
-                lwwFieldsOf(realMasterState, decrypt),
-                lwwFieldsOf(newDocumentState, decrypt)
-            ]);
-            // Rule 3 -- an undecryptable side is never scored as the loser: it is
-            // presumed newer (typically an envelope under an unseen key epoch), not
-            // absent. Logged so it is distinguishable from a genuine tombstone.
-            if (remote.kind === 'undecryptable' || local.kind === 'undecryptable') {
-                if (remote.kind === 'undecryptable' && local.kind !== 'undecryptable') {
-                    console.warn('LWW conflict: the remote master did not decrypt; adopting it ' +
-                        'rather than re-pushing the local payload over it.', remote.err);
-                    return realMasterState;
-                }
-                if (local.kind === 'undecryptable' && remote.kind !== 'undecryptable') {
-                    console.warn('LWW conflict: the local row did not decrypt; re-asserting it ' +
-                        'rather than dropping the local edit for the master.', local.err);
-                    return newDocumentState;
-                }
-                console.warn('LWW conflict: neither side decrypted; adopting the master ' +
-                    '(deterministic and convergent).', remote.kind === 'undecryptable' ? remote.err : undefined);
-                return realMasterState;
-            }
-            // Rule 4 -- both sides comparable: pure payload LWW.
-            if (remote.kind === 'payload' && local.kind === 'payload') {
-                return payloadWins(remote.payload, local.payload)
-                    ? realMasterState
-                    : newDocumentState;
-            }
-            // Rule 5 -- a live local edit against a remote tombstone (or otherwise
-            // incomparable remote): keep the edit (resurrect / re-assert the write).
-            if (local.kind === 'payload' && remote.kind === 'none') {
-                return newDocumentState;
-            }
-            // Rule 6 -- everything else (a local tombstone racing a REAL remote
-            // content change, or both incomparable): the master wins, which is
-            // deterministic and convergent across replicas (the edit survives the
-            // delete on every device).
-            return realMasterState;
-        }
-    };
-}
-//# sourceMappingURL=lwwConflictHandler.js.map

package/dist/sync/lwwConflictHandler.js.map

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