@interop/was-react 0.20.1 → 0.21.0

package/dist/sync/pushWrites.js

@@ -1,221 +0,0 @@
-import { formatEtag } from '@interop/was-client/sync';
-import { bodiesEqual, copyOptionalBodyFields, WasSyncAuthError, WasSyncConflictError } from './types.js';
-/**
- * Maps a re-read master state into the RxDB conflict entry for one row, or --
- * when the re-read found the resource genuinely absent (`master === null`, a
- * delete/delete race) -- synthesizes the tombstone conflict entry from what we
- * know locally. Shared by the `412` assembler and the `/meta` 404 recovery, so
- * both report an absent master identically.
- *
- * @param options {object}
- * @param options.id {string}
- * @param options.master {MasterState | null}
- * @param options.fallbackUpdatedAt {string}   used if the resource is now absent
- * @param options.fallbackVersion {number}     used if the resource is now absent
- * @returns {WithDeleted<SyncedDoc>}
- */
-function masterOrTombstone({ id, master, fallbackUpdatedAt, fallbackVersion }) {
-    if (master === null) {
-        return {
-            id,
-            updatedAt: fallbackUpdatedAt,
-            version: fallbackVersion,
-            _deleted: true
-        };
-    }
-    const conflict = {
-        id,
-        updatedAt: master.updatedAt,
-        version: master.version,
-        _deleted: master.deleted
-    };
-    copyOptionalBodyFields({ source: master, target: conflict });
-    return conflict;
-}
-/**
- * Sends one local change to the remote Collection as up to two conditional
- * writes (content, then metadata). Returns the master-state conflict entry on a
- * `412` at either step, or the accepted writes' acked revisions on success
- * (`ack: null` when no response carried a revision). A conflict on the
- * metadata half still returns the content half's earned ack alongside the
- * conflict entry, so an accepted content version is never discarded.
- *
- * @param options {object}
- * @param options.port {WasSyncPort}
- * @param options.newDocumentState {WithDeleted<SyncedDoc>}
- * @param [options.assumedMasterState] {WithDeleted<SyncedDoc>}
- * @param [options.cache] {MasterReadCache}   the push batch's shared
- *   master-read memo
- * @returns {Promise<{ conflict: WithDeleted<SyncedDoc> | null,
- *   ack: PushWriteAck | null }>}
- */
-async function pushRow({ port, newDocumentState, assumedMasterState, cache }) {
-    const { id } = newDocumentState;
-    const assumedVersion = assumedMasterState?.version;
-    const isCreate = assumedMasterState === undefined;
-    const ack = { id };
-    const hasAck = () => ack.version !== undefined || ack.metaVersion !== undefined;
-    const fallbackVersion = () => ack.version ?? assumedVersion ?? newDocumentState.version;
-    // Re-reads this row's master. A row that has ALREADY written this batch
-    // (a content write accepted before a `/meta` rejection) bypasses the batch
-    // memo: a sibling's feed read may have paged past this resource before our
-    // own write landed, and the conflict entry must carry the revision that write
-    // produced. Rows that wrote nothing -- the ordinary content 412, the common
-    // case -- are exactly what the memo is for.
-    const readMaster = async () => hasAck()
-        ? port.get({ id })
-        : port.get({ id, ...(cache !== undefined && { cache }) });
-    // Builds the conflict outcome from a re-read master (or from its absence, a
-    // delete/delete race), PRESERVING any ack already earned: a content write
-    // accepted before a `/meta` 412 must keep its acked `version` (and feed it to
-    // the absent-master fallback), or the local row keeps the pre-write version
-    // and every later conditional write sends a stale `If-Match`.
-    const conflictOutcome = (master) => ({
-        conflict: masterOrTombstone({
-            id,
-            master,
-            fallbackUpdatedAt: newDocumentState.updatedAt,
-            fallbackVersion: fallbackVersion()
-        }),
-        ack: hasAck() ? ack : null
-    });
-    // The 412 path: re-read the resource, then report its real master state.
-    const conflictResult = async () => conflictOutcome(await readMaster());
-    try {
-        if (newDocumentState._deleted) {
-            // Delete supersedes any metadata write: drop the content, tombstone wins.
-            const ackedVersion = await port.deleteContent({
-                id,
-                ...(assumedVersion !== undefined && {
-                    ifMatch: formatEtag(assumedVersion)
-                })
-            });
-            if (ackedVersion !== undefined) {
-                ack.version = ackedVersion;
-            }
-            return { conflict: null, ack: ack.version !== undefined ? ack : null };
-        }
-        // Content half: write on create, or when the content body changed. For a
-        // content-addressed collection the update case never fires (an immutable
-        // body for a stable id), but it is handled for generality.
-        const contentChanged = isCreate || !bodiesEqual(newDocumentState.data, assumedMasterState?.data);
-        if (contentChanged) {
-            const ackedVersion = await port.putContent({
-                id,
-                data: newDocumentState.data ?? null,
-                ...(newDocumentState.epoch !== undefined && {
-                    epoch: newDocumentState.epoch
-                }),
-                ...(isCreate
-                    ? { ifNoneMatch: true }
-                    : assumedVersion !== undefined && {
-                        ifMatch: formatEtag(assumedVersion)
-                    })
-            });
-            if (ackedVersion !== undefined) {
-                ack.version = ackedVersion;
-            }
-        }
-    }
-    catch (err) {
-        if (err instanceof WasSyncConflictError) {
-            return await conflictResult();
-        }
-        // Any non-conflict error (network, 5xx, auth) propagates so RxDB retries
-        // the whole batch with backoff.
-        throw err;
-    }
-    // Metadata half: write when the metadata changed -- including a CLEAR (the
-    // new state carries no `custom` while the assumed master does; `putMeta`
-    // with no `custom` writes the cleared state). On a create this runs after
-    // the content write (the resource must exist first). Its own try/catch so a
-    // rejection here can never discard an ack the content half already earned.
-    const metadataChanged = !bodiesEqual(newDocumentState.custom, assumedMasterState?.custom);
-    if (metadataChanged) {
-        try {
-            const assumedMetaVersion = assumedMasterState?.metaVersion;
-            const ackedMetaVersion = await port.putMeta({
-                id,
-                ...(newDocumentState.custom !== undefined && {
-                    custom: newDocumentState.custom
-                }),
-                ...(assumedMetaVersion !== undefined
-                    ? { ifMatch: formatEtag(assumedMetaVersion) }
-                    : { ifNoneMatch: true })
-            });
-            if (ackedMetaVersion !== undefined) {
-                ack.metaVersion = ackedMetaVersion;
-            }
-        }
-        catch (err) {
-            if (err instanceof WasSyncConflictError) {
-                return await conflictResult();
-            }
-            // Corroborate before condemnation: under WAS 404-masking a `/meta` 404
-            // is ambiguous -- expired access, or an ordinary race with a remote
-            // delete (a PUT to the `/meta` of a nonexistent resource legitimately
-            // 404s). An independent request decides: re-read the master off the
-            // changes feed. A feed read that is itself denied rethrows its own auth
-            // error (access genuinely expired, so the controller escalates); a feed
-            // that answers with an absent/deleted master confirms the delete race,
-            // and the row is resolved with that tombstone as the conflict entry
-            // (the conflict handler reconciles it) instead of flipping the whole
-            // session to "access expired" and wedging the batch in RxDB's retries.
-            if (err instanceof WasSyncAuthError && err.status === 404) {
-                const master = await readMaster();
-                if (master === null || master.deleted) {
-                    return conflictOutcome(master);
-                }
-                // The resource is alive and readable while its `/meta` write 404s:
-                // the write itself was rejected, so the auth signal stands.
-            }
-            throw err;
-        }
-    }
-    return { conflict: null, ack: hasAck() ? ack : null };
-}
-/**
- * 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.
- *
- * Each accepted write's acked server revision(s) are handed to
- * `onWriteAccepted` (when supplied) as soon as that row's writes settle, so the
- * caller can write the new `version` / `metaVersion` back into the local row
- * and keep subsequent conditional writes' `If-Match` in step with the server.
- *
- * Each batch gets one short-lived master-read memo, shared by its rows and
- * discarded with the batch (never held across batches, where it would go
- * stale). A conflict re-read walks the changes feed from its origin and so pages
- * past every other conflicting row's master on the way; without the memo a batch
- * with k conflicts would run k concurrent full-feed walks.
- *
- * @param port {WasSyncPort}
- * @param [onWriteAccepted] {(ack: PushWriteAck) => Promise<void>}
- * @returns {(rows: Array<{ newDocumentState: WithDeleted<SyncedDoc>,
- *   assumedMasterState?: WithDeleted<SyncedDoc> }>) =>
- *   Promise<WithDeleted<SyncedDoc>[]>}
- */
-export function createPushHandler(port, onWriteAccepted) {
-    return async function push(rows) {
-        const cache = { byId: new Map(), inFlight: null };
-        const results = await Promise.all(rows.map(async (row) => {
-            const result = await pushRow({
-                port,
-                newDocumentState: row.newDocumentState,
-                assumedMasterState: row.assumedMasterState,
-                cache
-            });
-            if (result.ack !== null && onWriteAccepted !== undefined) {
-                await onWriteAccepted(result.ack);
-            }
-            return result;
-        }));
-        return results
-            .map(result => result.conflict)
-            .filter((conflict) => conflict !== null);
-    };
-}
-//# sourceMappingURL=pushWrites.js.map

package/dist/sync/pushWrites.js.map

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

package/dist/sync/syncedDocSchema.d.ts

@@ -1,22 +0,0 @@
-/*!
- * Copyright (c) 2026 Interop Alliance. All rights reserved.
- */
-/**
- * The single generic RxDB JSON schema reused across every synced collection.
- * One shape (`{ id, updatedAt, version, metaVersion?, data?, custom? }`) carries
- * both a content revision and an independently-versioned metadata sub-resource;
- * `_deleted` is added by RxDB via `deletedField`. `data` / `custom` are opaque
- * bodies (plaintext JSON, or an EDV envelope on an encrypted collection), so
- * they are typed as free-form objects.
- */
-import type { RxJsonSchema } from 'rxdb/plugins/core';
-import type { SyncedDoc } from './types.js';
-/**
- * Returns the synced-doc schema. `id` is the primary key (the WAS resourceId);
- * `updatedAt` is indexed because it is the change-feed sort field / checkpoint
- * component.
- *
- * @returns {RxJsonSchema<SyncedDoc>}
- */
-export declare function syncedDocSchema(): RxJsonSchema<SyncedDoc>;
-//# sourceMappingURL=syncedDocSchema.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"syncedDocSchema.d.ts","sourceRoot":"","sources":["../../src/sync/syncedDocSchema.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAE3C;;;;;;GAMG;AACH,wBAAgB,eAAe,IAAI,YAAY,CAAC,SAAS,CAAC,CAoBzD"}

package/dist/sync/syncedDocSchema.js

@@ -1,29 +0,0 @@
-/**
- * Returns the synced-doc schema. `id` is the primary key (the WAS resourceId);
- * `updatedAt` is indexed because it is the change-feed sort field / checkpoint
- * component.
- *
- * @returns {RxJsonSchema<SyncedDoc>}
- */
-export function syncedDocSchema() {
-    return {
-        version: 0,
-        primaryKey: 'id',
-        type: 'object',
-        properties: {
-            id: { type: 'string', maxLength: 256 },
-            updatedAt: { type: 'string', maxLength: 64 },
-            version: { type: 'number' },
-            metaVersion: { type: 'number' },
-            // The opaque key-epoch id `data` was encrypted under (the `Key-Epoch`
-            // content-push header), when known.
-            epoch: { type: 'string', maxLength: 256 },
-            // Opaque stored bodies -- content and metadata envelopes -- moved verbatim.
-            data: { type: 'object', additionalProperties: true },
-            custom: { type: 'object', additionalProperties: true }
-        },
-        required: ['id', 'updatedAt', 'version'],
-        indexes: ['updatedAt']
-    };
-}
-//# sourceMappingURL=syncedDocSchema.js.map

package/dist/sync/syncedDocSchema.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"syncedDocSchema.js","sourceRoot":"","sources":["../../src/sync/syncedDocSchema.ts"],"names":[],"mappings":"AAcA;;;;;;GAMG;AACH,MAAM,UAAU,eAAe;IAC7B,OAAO;QACL,OAAO,EAAE,CAAC;QACV,UAAU,EAAE,IAAI;QAChB,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE;YACV,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,GAAG,EAAE;YACtC,SAAS,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,EAAE,EAAE;YAC5C,OAAO,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;YAC3B,WAAW,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;YAC/B,sEAAsE;YACtE,oCAAoC;YACpC,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,GAAG,EAAE;YACzC,4EAA4E;YAC5E,IAAI,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,oBAAoB,EAAE,IAAI,EAAE;YACpD,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,oBAAoB,EAAE,IAAI,EAAE;SACvD;QACD,QAAQ,EAAE,CAAC,IAAI,EAAE,WAAW,EAAE,SAAS,CAAC;QACxC,OAAO,EAAE,CAAC,WAAW,CAAC;KACI,CAAA;AAC9B,CAAC"}

package/dist/sync/types.d.ts

@@ -1,319 +0,0 @@
-/*!
- * Copyright (c) 2026 Interop Alliance. All rights reserved.
- */
-/**
- * Shared types for the collection-agnostic WAS replication adapter.
- *
- * The adapter drives an RxDB `replicateRxCollection` state machine against a
- * remote WAS Collection's replication endpoints. It is deliberately free of any
- * React or app imports so it can stand alone; all WAS access is injected through
- * the {@link WasSyncPort} seam rather than importing `@interop/was-client`
- * directly.
- *
- * The wire contract follows the WAS `changes` feed and its V2 encrypted-metadata
- * profile: a synced document carries both a content revision (`version` /
- * `data`) and an independently-versioned metadata sub-resource (`metaVersion` /
- * `custom`). A metadata-only edit re-surfaces the resource with a bumped
- * `updatedAt` / `metaVersion` but unchanged `version` / `data`. The sync layer
- * moves both bodies opaquely: `data` is the stored content body (plaintext JSON,
- * or the EDV envelope on an encrypted collection) and `custom` is the stored
- * metadata body (an opaque envelope on an encrypted collection); encrypt/decrypt
- * stays a read/write-time concern above this layer.
- *
- * The two small helpers that travel with these shapes live here as well: the
- * opaque-body equality every routing decision is made on, and the optional-field
- * 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
- * is the EDV envelope. The adapter never inspects or transforms it. Re-exported
- * from `@interop/was-client`, which owns the wire model, so a body crosses the
- * port boundary without a cast.
- */
-export type { Json };
-/**
- * The optional half of a synced document, shared verbatim by every shape it
- * travels in ({@link WireDoc} on the feed, {@link SyncedDoc} locally,
- * {@link MasterState} on the conflict re-read): the independently-versioned
- * metadata revision and body, the content body, and the content body's
- * key-epoch stamp. Each is genuinely absent rather than `undefined` when the
- * server has nothing for it, so every mapping between the shapes copies them
- * conditionally -- see {@link copyOptionalBodyFields}.
- */
-export interface OptionalBodyFields {
-    metaVersion?: number;
-    data?: Json;
-    custom?: Json;
-    epoch?: string;
-}
-/**
- * Structural equality over two opaque bodies, by canonical-free JSON string.
- * Decides whether the content or the metadata half changed -- which endpoint(s)
- * a push writes, and whether two states compare equal for conflict resolution.
- * Content-addressed collections never mutate `data` for a given id, and a real
- * metadata edit re-encrypts to fresh bytes, so this coarse comparison suffices.
- *
- * @param left {Json | undefined}
- * @param right {Json | undefined}
- * @returns {boolean}
- */
-export declare function bodiesEqual(left: Json | undefined, right: Json | undefined): boolean;
-/**
- * Copies the {@link OptionalBodyFields} that are present on `source` onto
- * `target`, leaving an absent field absent (never writing an explicit
- * `undefined`, which would surface the key in a serialized body). The single
- * place every wire-to-local, feed-to-master, and master-to-conflict mapping
- * shares, so a new optional wire field is added once.
- *
- * @param options {object}
- * @param options.source {OptionalBodyFields}
- * @param options.target {OptionalBodyFields}   mutated in place
- * @returns {void}
- */
-export declare function copyOptionalBodyFields({ source, target }: {
-    source: OptionalBodyFields;
-    target: OptionalBodyFields;
-}): void;
-/**
- * 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`. The client's own checkpoint type, aliased here so the
- * replication layer and the port agree by construction.
- */
-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,
- * `version` is the content master revision (feeds the content push `If-Match`
- * ETag) and the user content body is nested under `data`; `metaVersion` is the
- * independent metadata revision (feeds the `/meta` push `If-Match` ETag) and the
- * user-writable metadata body is under `custom`. A tombstone carries
- * `_deleted: true` with no `data`. `metaVersion` / `custom` are present only
- * once metadata has been written for the resource.
- */
-export interface WireDoc {
-    id: string;
-    _deleted: boolean;
-    updatedAt: string;
-    version: number;
-    metaVersion?: number;
-    data?: Json;
-    custom?: Json;
-    /**
-     * The opaque key-epoch id the content body was encrypted under (the
-     * `key-epochs` feature), present when the server holds a stamp for the
-     * resource. Moved verbatim; the sync layer never interprets it.
-     */
-    epoch?: string;
-}
-/**
- * The local RxDB document shape, shared across every synced collection. The
- * envelope fields are top-level (`id` primary key, `updatedAt` the checkpoint
- * sort field, `version` / `metaVersion` the server master revisions); the user
- * bodies stay nested (`data` for content, `custom` for metadata) to avoid field
- * collisions. `_deleted` is managed by RxDB via `deletedField` and so is not
- * part of this "clean" shape (handlers work with RxDB's `WithDeleted<SyncedDoc>`).
- */
-export interface SyncedDoc {
-    id: string;
-    updatedAt: string;
-    version: number;
-    metaVersion?: number;
-    data?: Json;
-    custom?: Json;
-    /**
-     * The opaque key-epoch id `data` was encrypted under, when known (stamped by
-     * the encrypting cipher on a local write, or pulled off the feed). Sent as
-     * the `Key-Epoch` header on the content push so the server's stamp stays
-     * in step with the envelope.
-     */
-    epoch?: string;
-}
-/**
- * The current master state of a single resource, as read back for the 412
- * 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 extends ClientMasterState {
-    deleted: boolean;
-}
-/**
- * The short-lived master-read memo the rows of ONE push batch share. A
- * resolving `get` implementation may answer from `byId` and MUST record every
- * master it resolved on the way there; a feed-walking implementation pages past
- * all of them anyway, so a batch of k conflicts costs one walk instead of k.
- *
- * `inFlight` is what makes that hold under concurrency: the batch's rows push in
- * parallel, so without it every row would start its own walk before the first
- * one finished and the memo would never be read. A `get` that must walk
- * publishes its walk here; a `get` that finds a walk already running awaits it
- * and re-checks `byId` first. It settles (never rejects) so one row's failed
- * read is not another row's, and is `null` whenever no walk is running.
- *
- * The whole object is created per batch invocation and dropped with it: a memo
- * held across batches would go stale.
- */
-export interface MasterReadCache {
-    byId: Map<string, MasterState | null>;
-    inFlight: Promise<void> | null;
-}
-/**
- * The write/query half of the injected WAS-access seam. An adapter (the app-side
- * `createWasSyncPort`) implements this over `@interop/was-client`; the core
- * module depends only on this interface, never on `was-client` itself. Every
- * method moves the stored body verbatim -- no codec, no key handling -- so the
- * same port works for plaintext and encrypted collections alike.
- *
- * `putContent` / `deleteContent` / `putMeta` MUST throw
- * {@link WasSyncConflictError} when the server rejects a conditional write with
- * `412 precondition-failed`, and let every other error propagate so RxDB's
- * retry/backoff handles it.
- *
- * The 412 conflict re-read (`get`) is deliberately NOT part of this base:
- * `createWasSyncPort` returns a `WasSyncBasePort`, and `withFeedMasterRead`
- * supplies a `get` that resolves the master state from the changes-feed body
- * (origin-independent) to produce a full {@link WasSyncPort}.
- */
-export interface WasSyncBasePort {
-    /**
-     * Pulls one page of the `changes` feed. Omit `checkpoint` for the first page.
-     * Returns the page's `documents` and its resume `checkpoint`, or
-     * `checkpoint: null` for an empty (no-change) page.
-     *
-     * @param options {object}
-     * @param [options.checkpoint] {SyncCheckpoint}   resume position
-     * @param options.limit {number}                  requested batch size
-     * @returns {Promise<{ documents: WireDoc[], checkpoint: SyncCheckpoint | null }>}
-     */
-    query(options: {
-        checkpoint?: SyncCheckpoint;
-        limit: number;
-    }): Promise<{
-        documents: WireDoc[];
-        checkpoint: SyncCheckpoint | null;
-    }>;
-    /**
-     * Conditionally writes the content body verbatim (`PUT /:id`). Pass
-     * `ifNoneMatch: true` for a create-if-absent, or `ifMatch` (a quoted ETag over
-     * the content `version`) for an update-if-unchanged. `epoch` is the opaque
-     * key-epoch id the body was encrypted under, sent as the `Key-Epoch`
-     * header (an absent epoch clears any prior stamp on the server, per the
-     * `key-epochs` feature). Returns the new content `version` parsed from the
-     * response ETag (the acked master revision), or `undefined` when the server
-     * does not supply one.
-     *
-     * @param options {object}
-     * @param options.id {string}
-     * @param options.data {Json}
-     * @param [options.ifMatch] {string}
-     * @param [options.ifNoneMatch] {boolean}
-     * @param [options.epoch] {string}
-     * @returns {Promise<number | undefined>}
-     */
-    putContent(options: {
-        id: string;
-        data: Json;
-        ifMatch?: string;
-        ifNoneMatch?: boolean;
-        epoch?: string;
-    }): Promise<number | undefined>;
-    /**
-     * Conditionally deletes a resource (writes a tombstone; `DELETE /:id`). Pass
-     * `ifMatch` (a quoted ETag over the content `version`) to delete only if
-     * unchanged. Returns the tombstone `version` parsed from the response ETag
-     * when the server supplies one (the reference server does not). MUST treat a
-     * `404` as success (resolve `undefined`): the resource is already absent --
-     * a row deleted locally before its first push, or deleted remotely first --
-     * so the tombstone's goal state holds; rejecting would wedge the push batch
-     * in RxDB's retry loop.
-     *
-     * @param options {object}
-     * @param options.id {string}
-     * @param [options.ifMatch] {string}
-     * @returns {Promise<number | undefined>}
-     */
-    deleteContent(options: {
-        id: string;
-        ifMatch?: string;
-    }): Promise<number | undefined>;
-    /**
-     * Conditionally writes the metadata body verbatim (`PUT /:id/meta`, body
-     * `{ custom }`). An ABSENT `custom` writes the CLEARED state (a body with no
-     * `custom` member -- the server's metadata replace clears every property the
-     * body omits), so removing a resource's metadata replicates rather than being
-     * skipped. Pass `ifNoneMatch: true` when the resource has no metadata yet, or
-     * `ifMatch` (a quoted ETag over `metaVersion`) for an update-if-unchanged.
-     * The resource must already exist (the server does not create a resource from
-     * a `/meta` write). Returns the new `metaVersion` parsed from the response
-     * ETag, or `undefined` when the server does not supply one.
-     *
-     * @param options {object}
-     * @param [options.custom] {Json}   absent = write the cleared state
-     * @param options.id {string}
-     * @param [options.ifMatch] {string}
-     * @param [options.ifNoneMatch] {boolean}
-     * @returns {Promise<number | undefined>}
-     */
-    putMeta(options: {
-        id: string;
-        custom?: Json;
-        ifMatch?: string;
-        ifNoneMatch?: boolean;
-    }): Promise<number | undefined>;
-}
-/**
- * The full sync port the core consumes: a {@link WasSyncBasePort}'s write/query
- * methods plus the `get` used by the 412 conflict assembler. The push handler
- * and `createWasReplication` require this full port; build one by wrapping a
- * base port with `withFeedMasterRead`, which supplies `get`.
- */
-export interface WasSyncPort extends WasSyncBasePort {
-    /**
-     * Re-reads a single resource's current master state (content + metadata) for
-     * the 412 conflict assembler. Returns `null` when the resource is genuinely
-     * absent (a delete/delete race); throws a retryable error when the master
-     * cannot be resolved (e.g. a feed re-read that exhausts its scan budget), so
-     * the replication cycle retries rather than fabricating a false tombstone.
-     *
-     * `cache` is an OPTIONAL {@link MasterReadCache}, shared by the rows of one
-     * push batch (see its own docs for the contract). A hit is no staler than a
-     * read issued at the same moment, since the memo lives only for that batch. An
-     * implementation that ignores it is fully conformant, and a caller that omits
-     * it gets an uncached read.
-     *
-     * @param options {object}
-     * @param options.id {string}
-     * @param [options.cache] {MasterReadCache}
-     * @returns {Promise<MasterState | null>}
-     */
-    get(options: {
-        id: string;
-        cache?: MasterReadCache;
-    }): Promise<MasterState | null>;
-}
-//# sourceMappingURL=types.d.ts.map

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

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