@interop/was-react 0.11.1 → 0.13.0

package/dist/sync/index.js

@@ -13,12 +13,12 @@ export { syncedDocSchema } from './syncedDocSchema.js';
 export { createPullHandler, wireDocToRxDoc } from './changesQuery.js';
 export { createPushHandler } from './pushWrites.js';
 export { WasSyncConflictError, WasSyncAuthError } from './types.js';
-export { createWasSyncPort, errorMessage } from './wasSyncPort.js';
+export { createWasSyncPort } from './wasSyncPort.js';
 export { withFeedMasterRead } from './feedMasterPort.js';
 export { createDocCipher, createPlaintextDocCodec, createUnprovisionedDocCipher, hasKeyEpochs, 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, formatEtag, isEncryptedEnvelope } from '@interop/was-client/sync';
+export { errorStatus, errorMessage, formatEtag, isEncryptedEnvelope } from '@interop/was-client/sync';
 //# sourceMappingURL=index.js.map

package/dist/sync/index.js.map

@@ -1 +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,EAAqB,MAAM,iBAAiB,CAAA;AACtE,OAAO,EACL,oBAAoB,EACpB,gBAAgB,EASjB,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAClE,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AACxD,OAAO,EACL,eAAe,EACf,uBAAuB,EACvB,4BAA4B,EAC5B,YAAY,EACZ,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,UAAU,EACV,mBAAmB,EACpB,MAAM,0BAA0B,CAAA"}
+{"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,YAAY,EACZ,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"}

package/dist/sync/lww.d.ts

@@ -9,7 +9,7 @@
  * `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);
- * `clientId` breaks an exact-instant tie deterministically. Both fields live in
+ * `writerId` breaks an exact-instant tie deterministically. Both fields live in
  * the payload (never the envelope-level checkpoint `updatedAt`).
  */
 /**
@@ -20,12 +20,12 @@
  */
 export interface LwwFields {
     updatedAt: string;
-    clientId: 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 `clientId` wins (an arbitrary but deterministic,
+ * lexically greater `writerId` wins (an arbitrary but deterministic,
  * replica-independent choice).
  *
  * Unparseable `updatedAt` values are rejected as losers: a side whose stamp
@@ -40,7 +40,7 @@ export interface LwwFields {
 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`/`clientId` are
+ * generic over `{ id: string }`, so docs without `updatedAt`/`writerId` are
  * legal; callers fall back to their own rule for those.
  *
  * @param doc {unknown}

package/dist/sync/lww.js

@@ -9,7 +9,7 @@
  * `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);
- * `clientId` breaks an exact-instant tie deterministically. Both fields live in
+ * `writerId` breaks an exact-instant tie deterministically. Both fields live in
  * the payload (never the envelope-level checkpoint `updatedAt`).
  */
 /**
@@ -22,7 +22,7 @@ function parseInstant(updatedAt) {
 /**
  * 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 `clientId` wins (an arbitrary but deterministic,
+ * lexically greater `writerId` wins (an arbitrary but deterministic,
  * replica-independent choice).
  *
  * Unparseable `updatedAt` values are rejected as losers: a side whose stamp
@@ -50,20 +50,20 @@ export function remotePayloadWins(remote, local) {
         // Neither parses: fall back to the deterministic lexical compare.
         return remote.updatedAt > local.updatedAt;
     }
-    return remote.clientId > local.clientId;
+    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`/`clientId` 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, clientId } = doc;
-    return typeof updatedAt === 'string' && typeof clientId === 'string'
-        ? { updatedAt, clientId }
+    const { updatedAt, writerId } = doc;
+    return typeof updatedAt === 'string' && typeof writerId === 'string'
+        ? { updatedAt, writerId }
         : null;
 }
 //# sourceMappingURL=lww.js.map

package/dist/sync/lwwConflictHandler.d.ts

@@ -7,17 +7,17 @@
  * 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` (clientId tiebreak) -- exactly the rule two offline replicas
+ * 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` / `clientId`. `isEqual` stays cheap and
+ * 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, clientId)`, so 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:
@@ -69,7 +69,7 @@ import { type LwwFields } from './lww.js';
  * @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,
- *   `clientId` breaks a tie)
+ *   `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): {

package/dist/sync/lwwConflictHandler.js

@@ -25,7 +25,7 @@ async function lwwFieldsOf(doc, 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,
- *   `clientId` breaks a tie)
+ *   `writerId` breaks a tie)
  * @returns {import('rxdb/plugins/core').RxConflictHandler<SyncedDoc>}
  */
 export function makeLwwConflictHandler(decrypt, payloadWins = remotePayloadWins) {

package/dist/sync/types.d.ts

@@ -25,6 +25,24 @@
  * copy every wire-to-local mapping runs.
  */
 import type { Json } from '@interop/was-client';
+import type { MasterState as ClientMasterState, SyncCheckpoint as ClientSyncCheckpoint } from '@interop/was-client/sync';
+/**
+ * The typed port signals, owned by `@interop/was-client` (its sync port raises
+ * them) and re-exported here so the names this package's consumers already
+ * import stay put -- and so an `instanceof` check anywhere in this package
+ * matches the very class the port throws.
+ *
+ * `WasSyncConflictError` marks a conditional write rejected with `412
+ * precondition-failed` (a lost-update conflict, or a create-if-absent whose
+ * target already exists); the push handler catches exactly it to trigger the
+ * re-read-and-report-conflict path. `WasSyncAuthError` marks a request refused
+ * on authorization grounds -- `401`, `403`, or the `404` a WAS server masks a
+ * failed capability invocation as, which on the sync paths (where the invoked
+ * collection is known to exist) means the invocation was rejected. It keeps the
+ * offending HTTP status on `status`, which the `/meta` push path reads to tell
+ * a masked denial from an ordinary delete race.
+ */
+export { WasSyncAuthError, WasSyncConflictError } from '@interop/was-client/sync';
 /**
  * A JSON value -- the opaque stored resource body the sync layer moves verbatim.
  * For a plaintext collection this is the user document; for an encrypted one it
@@ -80,12 +98,10 @@ export declare function copyOptionalBodyFields({ source, target }: {
  * The keyset position in the change feed: the `{ id, updatedAt }` of the last
  * document a pull returned. Passed back verbatim to resume, and used as the
  * RxDB replication checkpoint. `id` is the total-order tiebreaker within a
- * single `updatedAt`.
+ * single `updatedAt`. The client's own checkpoint type, aliased here so the
+ * replication layer and the port agree by construction.
  */
-export interface SyncCheckpoint {
-    id: string;
-    updatedAt: string;
-}
+export type SyncCheckpoint = ClientSyncCheckpoint;
 /**
  * One document as it travels on the `changes` feed wire
  * (`POST /space/:s/:c/query`, profile `changes`). `id` is the WAS resourceId,
@@ -136,20 +152,15 @@ export interface SyncedDoc {
 }
 /**
  * The current master state of a single resource, as read back for the 412
- * conflict path. `deleted` distinguishes a tombstone from a live resource;
- * `metaVersion` / `custom` are present only once metadata has been written.
+ * conflict path: the client's own `MasterState` (content `version` /
+ * `updatedAt`, plus the optional `metaVersion` / `data` / `custom` /
+ * `createdBy` / `epoch`) plus the `deleted` flag that distinguishes a tombstone
+ * from a live resource. The flag is required here because this package resolves
+ * the master from the changes feed, where a tombstone travels as a document
+ * rather than as an absent read.
  */
-export interface MasterState {
-    version: number;
-    updatedAt: string;
+export interface MasterState extends ClientMasterState {
     deleted: boolean;
-    metaVersion?: number;
-    data?: Json;
-    custom?: Json;
-    /**
-     * The key-epoch stamp of the master's content body, when the feed carries one.
-     */
-    epoch?: string;
 }
 /**
  * The short-lived master-read memo the rows of ONE push batch share. A
@@ -305,32 +316,4 @@ export interface WasSyncPort extends WasSyncBasePort {
         cache?: MasterReadCache;
     }): Promise<MasterState | null>;
 }
-/**
- * Thrown by a {@link WasSyncPort} implementation when a conditional write is
- * rejected with `412 precondition-failed` (a lost-update conflict, or a
- * create-if-absent whose target already exists). The core push handler catches
- * exactly this type to trigger the re-read-and-report-conflict path; any other
- * error propagates to RxDB for retry.
- */
-export declare class WasSyncConflictError extends Error {
-    constructor(message?: string);
-}
-/**
- * Thrown by a {@link WasSyncPort} implementation when a request is rejected with
- * `401 unauthorized`, `403 forbidden`, or `404 not found` -- the
- * storage-access-expired/revoked signal. `404` qualifies because a WAS server
- * masks a failed capability invocation as `404` (never confirming to an
- * unauthorized caller whether the resource exists); on the sync paths the
- * invoked collection is known to exist, so a `404` means the invocation was
- * rejected. Mapping the raw HTTP status to a typed error at the port boundary
- * (the same way `412` becomes {@link WasSyncConflictError}) lets the sync
- * controller recognise expired access with an `instanceof` check rather than
- * re-extracting status codes from a wrapped RxDB error graph. The offending
- * HTTP status is kept on `status` -- diagnostics, plus the delete path's
- * already-absent-404 check.
- */
-export declare class WasSyncAuthError extends Error {
-    readonly status: number;
-    constructor(status: number);
-}
 //# sourceMappingURL=types.d.ts.map

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

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

package/dist/sync/types.js

@@ -1,3 +1,20 @@
+/**
+ * The typed port signals, owned by `@interop/was-client` (its sync port raises
+ * them) and re-exported here so the names this package's consumers already
+ * import stay put -- and so an `instanceof` check anywhere in this package
+ * matches the very class the port throws.
+ *
+ * `WasSyncConflictError` marks a conditional write rejected with `412
+ * precondition-failed` (a lost-update conflict, or a create-if-absent whose
+ * target already exists); the push handler catches exactly it to trigger the
+ * re-read-and-report-conflict path. `WasSyncAuthError` marks a request refused
+ * on authorization grounds -- `401`, `403`, or the `404` a WAS server masks a
+ * failed capability invocation as, which on the sync paths (where the invoked
+ * collection is known to exist) means the invocation was rejected. It keeps the
+ * offending HTTP status on `status`, which the `/meta` push path reads to tell
+ * a masked denial from an ordinary delete race.
+ */
+export { WasSyncAuthError, WasSyncConflictError } from '@interop/was-client/sync';
 /**
  * Structural equality over two opaque bodies, by canonical-free JSON string.
  * Decides whether the content or the metadata half changed -- which endpoint(s)
@@ -38,39 +55,4 @@ export function copyOptionalBodyFields({ source, target }) {
         target.epoch = source.epoch;
     }
 }
-/**
- * Thrown by a {@link WasSyncPort} implementation when a conditional write is
- * rejected with `412 precondition-failed` (a lost-update conflict, or a
- * create-if-absent whose target already exists). The core push handler catches
- * exactly this type to trigger the re-read-and-report-conflict path; any other
- * error propagates to RxDB for retry.
- */
-export class WasSyncConflictError extends Error {
-    constructor(message = 'WAS conditional write precondition failed.') {
-        super(message);
-        this.name = 'WasSyncConflictError';
-    }
-}
-/**
- * Thrown by a {@link WasSyncPort} implementation when a request is rejected with
- * `401 unauthorized`, `403 forbidden`, or `404 not found` -- the
- * storage-access-expired/revoked signal. `404` qualifies because a WAS server
- * masks a failed capability invocation as `404` (never confirming to an
- * unauthorized caller whether the resource exists); on the sync paths the
- * invoked collection is known to exist, so a `404` means the invocation was
- * rejected. Mapping the raw HTTP status to a typed error at the port boundary
- * (the same way `412` becomes {@link WasSyncConflictError}) lets the sync
- * controller recognise expired access with an `instanceof` check rather than
- * re-extracting status codes from a wrapped RxDB error graph. The offending
- * HTTP status is kept on `status` -- diagnostics, plus the delete path's
- * already-absent-404 check.
- */
-export class WasSyncAuthError extends Error {
-    status;
-    constructor(status) {
-        super(`WAS storage access denied (HTTP ${status}).`);
-        this.name = 'WasSyncAuthError';
-        this.status = status;
-    }
-}
 //# sourceMappingURL=types.js.map

package/dist/sync/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/sync/types.ts"],"names":[],"mappings":"AAqDA;;;;;;;;;;GAUG;AACH,MAAM,UAAU,WAAW,CACzB,IAAsB,EACtB,KAAuB;IAEvB,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,IAAI,IAAI,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,KAAK,IAAI,IAAI,CAAC,CAAA;AACvE,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,sBAAsB,CAAC,EACrC,MAAM,EACN,MAAM,EAIP;IACC,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;QAC9B,MAAM,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAA;IAC3B,CAAC;IACD,IAAI,MAAM,CAAC,WAAW,KAAK,SAAS,EAAE,CAAC;QACrC,MAAM,CAAC,WAAW,GAAG,MAAM,CAAC,WAAW,CAAA;IACzC,CAAC;IACD,IAAI,MAAM,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;QAChC,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAA;IAC/B,CAAC;IACD,IAAI,MAAM,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;QAC/B,MAAM,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAA;IAC7B,CAAC;AACH,CAAC;AA8OD;;;;;;GAMG;AACH,MAAM,OAAO,oBAAqB,SAAQ,KAAK;IAC7C,YAAY,OAAO,GAAG,4CAA4C;QAChE,KAAK,CAAC,OAAO,CAAC,CAAA;QACd,IAAI,CAAC,IAAI,GAAG,sBAAsB,CAAA;IACpC,CAAC;CACF;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,OAAO,gBAAiB,SAAQ,KAAK;IAChC,MAAM,CAAQ;IACvB,YAAY,MAAc;QACxB,KAAK,CAAC,mCAAmC,MAAM,IAAI,CAAC,CAAA;QACpD,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAA;QAC9B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;IACtB,CAAC;CACF"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/sync/types.ts"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EACL,gBAAgB,EAChB,oBAAoB,EACrB,MAAM,0BAA0B,CAAA;AA2BjC;;;;;;;;;;GAUG;AACH,MAAM,UAAU,WAAW,CACzB,IAAsB,EACtB,KAAuB;IAEvB,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,IAAI,IAAI,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,KAAK,IAAI,IAAI,CAAC,CAAA;AACvE,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,sBAAsB,CAAC,EACrC,MAAM,EACN,MAAM,EAIP;IACC,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;QAC9B,MAAM,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAA;IAC3B,CAAC;IACD,IAAI,MAAM,CAAC,WAAW,KAAK,SAAS,EAAE,CAAC;QACrC,MAAM,CAAC,WAAW,GAAG,MAAM,CAAC,WAAW,CAAA;IACzC,CAAC;IACD,IAAI,MAAM,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;QAChC,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAA;IAC/B,CAAC;IACD,IAAI,MAAM,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;QAC/B,MAAM,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAA;IAC7B,CAAC;AACH,CAAC"}

package/dist/sync/wasSyncPort.d.ts

@@ -3,41 +3,24 @@
  */
 /**
  * The app-side seam between the generic sync adapter and `@interop/was-client`.
- * Implements the `WasSyncBasePort` interface (query + conditional writes) for one
- * remote WAS Collection using the raw, signed `was.request()` escape hatch. The
- * 412 conflict re-read (`get`) is supplied separately by `withFeedMasterRead`,
- * which resolves the master state from the changes-feed body -- origin-
- * independent, unlike a cross-origin `GET` ETag header.
+ * Delegates to the client's own `createWasSyncPort` -- which owns the WAS URL
+ * grammar, the verbatim (codec-bypassing) `was.request()` writes, the `changes`
+ * feed pull, the key-epoch header, and the conditional-write ETag handling --
+ * and pins the two options this package needs: the collection's delegated
+ * capability, and `mapAuthErrors` so a `401` / `403` / the server's masked `404`
+ * arrive as a `WasSyncAuthError` the sync controller can `instanceof`-match.
  *
- * Using `request()` (rather than the `Resource` / `Collection` handles) is
- * deliberate: it moves the stored body VERBATIM, bypassing the encryption codec.
- * The `changes` feed already ships opaque stored bodies (plaintext for a
- * plaintext collection, the EDV envelope for an encrypted one), and the push
- * side must write those same bytes back unchanged -- running them through
- * `resource.put()` would re-encrypt an already-encrypted envelope. Encrypt /
- * decrypt stays a read/write-time concern above this layer; this port is
- * collection-agnostic and never touches keys.
- *
- * Conditional writes ride the server's monotonic `version` (content) and
- * `metaVersion` (metadata) ETags, which the reference server enforces uniformly
- * for plaintext and encrypted resources alike -- so there is no plaintext-vs-
- * encrypted fork here.
+ * What stays here is the narrowing to a {@link WasSyncBasePort}: the 412
+ * conflict re-read (`get`) is supplied separately by `withFeedMasterRead`, which
+ * resolves the master state from the changes-feed BODY -- origin-independent,
+ * unlike a cross-origin `GET` whose ETag header CORS hides.
  */
-import { type WasClient } from '@interop/was-client';
+import type { WasClient } from '@interop/was-client';
 import type { IZcap } from '@interop/data-integrity-core';
-import { type WasSyncBasePort } from './types.js';
-/**
- * Normalizes an unknown caught error into a display string: the `Error`'s
- * `message` when it is one, else its `String(...)` coercion. Shared by the
- * remote store's descriptor PUT and the session activation error path.
- *
- * @param err {unknown}
- * @returns {string}
- */
-export declare function errorMessage(err: unknown): string;
+import type { WasSyncBasePort } from './types.js';
 /**
- * Builds a `WasSyncPort` bound to a single Space + Collection on the remote WAS
- * server, backed by the session's signed `WasClient`.
+ * Builds a `WasSyncBasePort` bound to a single Space + Collection on the remote
+ * WAS server, backed by the session's signed `WasClient`.
  *
  * @param options {object}
  * @param options.was {WasClient}       the session client (holds the signer)

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

@@ -1 +1 @@
-{"version":3,"file":"wasSyncPort.d.ts","sourceRoot":"","sources":["../../src/sync/wasSyncPort.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,EAA0B,KAAK,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAE5E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAA;AAEzD,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,YAAY,CAAA;AAEnB;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAEjD;AAgCD;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,GAAG,EACH,OAAO,EACP,YAAY,EACZ,UAAU,EACX,EAAE;IACD,GAAG,EAAE,SAAS,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,YAAY,EAAE,MAAM,CAAA;IACpB,UAAU,CAAC,EAAE,KAAK,CAAA;CACnB,GAAG,eAAe,CAkHlB"}
+{"version":3,"file":"wasSyncPort.d.ts","sourceRoot":"","sources":["../../src/sync/wasSyncPort.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAEpD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAA;AACzD,OAAO,KAAK,EAAkB,eAAe,EAAW,MAAM,YAAY,CAAA;AAE1E;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,GAAG,EACH,OAAO,EACP,YAAY,EACZ,UAAU,EACX,EAAE;IACD,GAAG,EAAE,SAAS,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,YAAY,EAAE,MAAM,CAAA;IACpB,UAAU,CAAC,EAAE,KAAK,CAAA;CACnB,GAAG,eAAe,CAqClB"}

package/dist/sync/wasSyncPort.js

@@ -1,75 +1,7 @@
-/*!
- * Copyright (c) 2026 Interop Alliance. All rights reserved.
- */
-/**
- * The app-side seam between the generic sync adapter and `@interop/was-client`.
- * Implements the `WasSyncBasePort` interface (query + conditional writes) for one
- * remote WAS Collection using the raw, signed `was.request()` escape hatch. The
- * 412 conflict re-read (`get`) is supplied separately by `withFeedMasterRead`,
- * which resolves the master state from the changes-feed body -- origin-
- * independent, unlike a cross-origin `GET` ETag header.
- *
- * Using `request()` (rather than the `Resource` / `Collection` handles) is
- * deliberate: it moves the stored body VERBATIM, bypassing the encryption codec.
- * The `changes` feed already ships opaque stored bodies (plaintext for a
- * plaintext collection, the EDV envelope for an encrypted one), and the push
- * side must write those same bytes back unchanged -- running them through
- * `resource.put()` would re-encrypt an already-encrypted envelope. Encrypt /
- * decrypt stays a read/write-time concern above this layer; this port is
- * collection-agnostic and never touches keys.
- *
- * Conditional writes ride the server's monotonic `version` (content) and
- * `metaVersion` (metadata) ETags, which the reference server enforces uniformly
- * for plaintext and encrypted resources alike -- so there is no plaintext-vs-
- * encrypted fork here.
- */
-import { readEtag, writeHeaders } from '@interop/was-client';
-import { errorStatus, parseEtag } from '@interop/was-client/sync';
-import { collectionPath } from '../grants.js';
-import { WasSyncAuthError, WasSyncConflictError } from './types.js';
-/**
- * Normalizes an unknown caught error into a display string: the `Error`'s
- * `message` when it is one, else its `String(...)` coercion. Shared by the
- * remote store's descriptor PUT and the session activation error path.
- *
- * @param err {unknown}
- * @returns {string}
- */
-export function errorMessage(err) {
-    return err instanceof Error ? err.message : String(err);
-}
-/**
- * Maps a raw `was.request()` rejection to the sync layer's typed errors: `412`
- * to {@link WasSyncConflictError} (a lost-update conflict) and `401` / `403` /
- * `404` to {@link WasSyncAuthError} (expired/revoked storage access). Every
- * other error is returned unchanged so RxDB's retry/backoff handles it. Returns
- * the error to throw (the caller re-throws) rather than throwing itself.
- *
- * `404` counts as access denied because a WAS server masks a failed capability
- * invocation as `404` ("URL not found or invalid authorization") rather than
- * `403`, so an unauthorized caller cannot probe which resources exist. On the
- * sync paths the invoked space and collection are known to exist (the session
- * synced them), so a `404` means the invocation itself was rejected -- the
- * revoked/expired-grant signal. The one route where `404` is routine --
- * deleting an already-absent resource -- inspects the preserved `status` on the
- * mapped error and stays a success (see `deleteContent`).
- *
- * @param err {unknown}
- * @returns {unknown}
- */
-function toPortError(err) {
-    const status = errorStatus(err);
-    if (status === 412) {
-        return new WasSyncConflictError();
-    }
-    if (status === 401 || status === 403 || status === 404) {
-        return new WasSyncAuthError(status);
-    }
-    return err;
-}
+import { createWasSyncPort as createClientSyncPort } from '@interop/was-client/sync';
 /**
- * Builds a `WasSyncPort` bound to a single Space + Collection on the remote WAS
- * server, backed by the session's signed `WasClient`.
+ * Builds a `WasSyncBasePort` bound to a single Space + Collection on the remote
+ * WAS server, backed by the session's signed `WasClient`.
  *
  * @param options {object}
  * @param options.was {WasClient}       the session client (holds the signer)
@@ -81,106 +13,32 @@ function toPortError(err) {
  * @returns {WasSyncBasePort}
  */
 export function createWasSyncPort({ was, spaceId, collectionId, capability }) {
-    const basePath = collectionPath({ spaceId, collectionId });
-    const resourcePath = (id) => `${basePath}/${encodeURIComponent(id)}`;
-    /**
-     * Runs a conditional write, mapping the server's `412 precondition-failed`
-     * into the core's `WasSyncConflictError` and a `401` / `403` into
-     * `WasSyncAuthError` (see {@link toPortError}), and letting all else propagate.
-     * Returns the accepted write's new revision parsed from the response ETag
-     * (`version` for content writes, `metaVersion` for `/meta` writes), or
-     * `undefined` when the response carries no ETag.
-     */
-    const conditionalWrite = async (
-    // Typed off readEtag's parameter (was-client's HttpResponse) so the type
-    // needn't be imported from @interop/http-client, which is not a direct
-    // dependency here.
-    run) => {
-        try {
-            const response = await run();
-            // `readEtag` reports an absent header as `undefined`; `parseEtag` reads
-            // the `null` spelling of the same thing.
-            return parseEtag(readEtag(response) ?? null);
-        }
-        catch (err) {
-            throw toPortError(err);
-        }
-    };
+    const port = createClientSyncPort({
+        was,
+        spaceId,
+        collectionId,
+        ...(capability !== undefined && { capability }),
+        mapAuthErrors: true
+    });
+    // The client types `putMeta` as optional (a port may replicate content only);
+    // its own implementation always supplies it, and this package's replication
+    // always writes the `/meta` half, so require it at the boundary rather than
+    // guarding at every call site.
+    const { putMeta } = port;
+    if (putMeta === undefined) {
+        throw new Error('The WAS sync port does not implement `putMeta`, which this ' +
+            "package's replication requires.");
+    }
     return {
-        async query({ checkpoint, limit }) {
-            try {
-                const response = await was.request({
-                    capability,
-                    path: `${basePath}/query`,
-                    method: 'POST',
-                    json: {
-                        profile: 'changes',
-                        ...(checkpoint !== undefined && { checkpoint }),
-                        limit
-                    }
-                });
-                return response.data;
-            }
-            catch (err) {
-                // Map a pull-path auth rejection (401/403, or the masked 404) to
-                // WasSyncAuthError too, so expired/revoked access is recognised
-                // whether it surfaces on the pull or the push side.
-                throw toPortError(err);
-            }
-        },
-        async putContent({ id, data, ifMatch, ifNoneMatch, epoch }) {
-            return conditionalWrite(() => was.request({
-                capability,
-                path: resourcePath(id),
-                method: 'PUT',
-                json: data,
-                // `epoch` rides as the `Key-Epoch` header so the server's stamp
-                // stays in step with the envelope (an absent epoch clears any prior
-                // stamp, per the `key-epochs` feature).
-                headers: writeHeaders({
-                    precondition: { ifMatch, ifNoneMatch },
-                    epoch
-                })
-            }));
-        },
-        async deleteContent({ id, ifMatch }) {
-            try {
-                return await conditionalWrite(() => was.request({
-                    capability,
-                    path: resourcePath(id),
-                    method: 'DELETE',
-                    headers: writeHeaders({ precondition: { ifMatch } })
-                }));
-            }
-            catch (err) {
-                // A 404 means the resource is already absent -- the row was created
-                // and deleted locally before ever being pushed, or another device
-                // deleted it first. Either way the tombstone's goal state holds, so
-                // report success (no acked revision) instead of rejecting the batch,
-                // which RxDB would otherwise retry forever. (A masked auth-failure 404
-                // is swallowed here too -- indistinguishable by design -- but revoked
-                // access still surfaces within one pull-poll interval, where 404 maps
-                // to WasSyncAuthError.) The mapped error keeps the raw `status`, so
-                // this check works on the WasSyncAuthError conditionalWrite now throws
-                // for a 404.
-                if (errorStatus(err) === 404) {
-                    return undefined;
-                }
-                throw err;
-            }
+        async query(options) {
+            // The feed page's bodies are `unknown` upstream (a stored body is any
+            // JSON, and a future encryption scheme's envelope need not be an EDV
+            // document); this layer moves them verbatim as `Json`.
+            return (await port.query(options));
         },
-        async putMeta({ id, custom, ifMatch, ifNoneMatch }) {
-            return conditionalWrite(() => was.request({
-                capability,
-                path: `${resourcePath(id)}/meta`,
-                method: 'PUT',
-                // The `/meta` PUT is a full replacement of `custom`: a body with no
-                // `custom` member writes the CLEARED state (the server clears every
-                // property the body omits), which is how a metadata clear replicates.
-                json: custom === undefined ? {} : { custom },
-                headers: writeHeaders({ precondition: { ifMatch, ifNoneMatch } })
-            }));
-        }
+        putContent: options => port.putContent(options),
+        deleteContent: options => port.deleteContent(options),
+        putMeta: options => putMeta(options)
     };
 }
 //# sourceMappingURL=wasSyncPort.js.map

package/dist/sync/wasSyncPort.js.map

@@ -1 +1 @@
-{"version":3,"file":"wasSyncPort.js","sourceRoot":"","sources":["../../src/sync/wasSyncPort.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"wasSyncPort.js","sourceRoot":"","sources":["../../src/sync/wasSyncPort.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,iBAAiB,IAAI,oBAAoB,EAAE,MAAM,0BAA0B,CAAA;AAIpF;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,iBAAiB,CAAC,EAChC,GAAG,EACH,OAAO,EACP,YAAY,EACZ,UAAU,EAMX;IACC,MAAM,IAAI,GAAG,oBAAoB,CAAC;QAChC,GAAG;QACH,OAAO;QACP,YAAY;QACZ,GAAG,CAAC,UAAU,KAAK,SAAS,IAAI,EAAE,UAAU,EAAE,CAAC;QAC/C,aAAa,EAAE,IAAI;KACpB,CAAC,CAAA;IACF,8EAA8E;IAC9E,4EAA4E;IAC5E,4EAA4E;IAC5E,+BAA+B;IAC/B,MAAM,EAAE,OAAO,EAAE,GAAG,IAAI,CAAA;IACxB,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC1B,MAAM,IAAI,KAAK,CACb,6DAA6D;YAC3D,iCAAiC,CACpC,CAAA;IACH,CAAC;IAED,OAAO;QACL,KAAK,CAAC,KAAK,CAAC,OAAO;YACjB,sEAAsE;YACtE,qEAAqE;YACrE,uDAAuD;YACvD,OAAO,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAGhC,CAAA;QACH,CAAC;QAED,UAAU,EAAE,OAAO,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC;QAE/C,aAAa,EAAE,OAAO,CAAC,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC;QAErD,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC;KACrC,CAAA;AACH,CAAC"}