@kubun/store-p2p 0.17.0 → 0.18.1

package/lib/ops/app-outbox.js

@@ -0,0 +1,236 @@
+import { encodeMultibase, multihashSHA256 } from '@kokuin/token';
+import { AppEntryTooLargeError, AppOutboxFullError, MAX_APP_ENTRY_BYTES, SendNotAdmissibleError } from '@kumiai/rpc';
+import { gcm } from '@noble/ciphers/aes.js';
+const KEY_LENGTH = 32;
+const IV_LENGTH = 12;
+export class AppOutboxDecryptionError extends Error {
+    name = 'AppOutboxDecryptionError';
+}
+export class AppOutboxTransactionError extends Error {
+    name = 'AppOutboxTransactionError';
+}
+export class PendingRevocationAdmissionError extends Error {
+    name = 'PendingRevocationAdmissionError';
+}
+/** A voluntary leave would erase revocations the hub has not accepted yet. */ export class UndeliveredRevocationsError extends Error {
+    name = 'UndeliveredRevocationsError';
+}
+function isRecord(value) {
+    return value != null && typeof value === 'object' && !Array.isArray(value);
+}
+function pendingDelegationAdmission(entry) {
+    if (entry.protocol !== 'control' || entry.prc !== 'control/delegationShare' && entry.prc !== 'control/delegationRevoke') {
+        return null;
+    }
+    try {
+        const envelope = JSON.parse(new TextDecoder().decode(entry.data));
+        if (!isRecord(envelope) || envelope.v !== 2 || !isRecord(envelope.payload)) return null;
+        const payload = envelope.payload;
+        if (payload.typ !== 'event' || payload.prc !== entry.prc || !isRecord(payload.data)) return null;
+        const data = payload.data;
+        if (typeof data.token !== 'string' || data.token.length === 0 || typeof data.hlc !== 'string' || data.hlc.length === 0) {
+            return null;
+        }
+        return {
+            kind: entry.prc === 'control/delegationShare' ? 'grant' : 'revocation',
+            hlc: data.hlc,
+            digest: encodeMultibase(multihashSHA256(new TextEncoder().encode(data.token)))
+        };
+    } catch  {
+        // Generic outbox payloads remain valid even when they are not delegation envelopes.
+        return null;
+    }
+}
+function associatedData(groupID, entry) {
+    // Fixed field order survives JSONB's reordering of lastAttempt keys.
+    return new TextEncoder().encode(JSON.stringify([
+        'kubun/app-outbox/v1',
+        groupID,
+        entry.seq,
+        entry.protocol,
+        entry.prc,
+        entry.lastAttempt?.epoch ?? null,
+        entry.lastAttempt?.floor ?? null,
+        entry.lastAttempt?.attempts ?? null
+    ]));
+}
+async function hasUndeliveredRevocations(db, groupID) {
+    const marker = await db.selectFrom('kubun_p2p_group_delegation').select('jti').where('group_id', '=', groupID).where('pending_revocation_hlc', 'is not', null).limit(1).executeTakeFirst();
+    if (marker != null) return true;
+    const queued = await db.selectFrom('kubun_p2p_app_outbox').select('seq').where('group_id', '=', groupID).where('protocol', '=', 'control').where('prc', '=', 'control/delegationRevoke').limit(1).executeTakeFirst();
+    return queued != null;
+}
+/** Coordinate status transitions with revocation admission and outbox erasure. */ export async function lockAppOutboxForErasure(db, groupID, options) {
+    // Lock first-write creation too, even when the group has never held a key.
+    await db.insertInto('kubun_p2p_app_outbox_state').values({
+        group_id: groupID
+    }).onConflict((oc)=>oc.column('group_id').doUpdateSet({
+            group_id: groupID
+        })).execute();
+    // Under the erasure lock: a revocation committed after the leaver's delivery
+    // check is either seen here or blocks until this transaction ends.
+    if (options?.requireRevocationsDelivered === true && await hasUndeliveredRevocations(db, groupID)) {
+        throw new UndeliveredRevocationsError(`Group ${groupID} has capability revocations the hub has not accepted yet`);
+    }
+}
+/** The caller's transaction also covers group leave or deletion. */ export async function clearAppOutboxRows(db, groupID, options) {
+    await lockAppOutboxForErasure(db, groupID, options);
+    await db.updateTable('kubun_p2p_group_delegation').set({
+        pending_grant_hlc: null,
+        pending_grant_digest: null,
+        pending_revocation_hlc: null,
+        pending_revocation_digest: null
+    }).where('group_id', '=', groupID).execute();
+    await db.deleteFrom('kubun_p2p_app_outbox_state').where('group_id', '=', groupID).execute();
+    const deleted = await db.deleteFrom('kubun_p2p_app_outbox').where('group_id', '=', groupID).returning('seq').execute();
+    return deleted.map((entry)=>entry.seq).sort((a, b)=>a - b);
+}
+export function createAppOutboxOps(db, adapter, getRandomValues) {
+    const clearAppOutbox = async (groupID)=>{
+        const clear = async (tx)=>{
+            await clearAppOutboxRows(tx, groupID);
+        };
+        if (db.isTransaction) await clear(db);
+        else await db.transaction().execute(clear);
+    };
+    return {
+        clearAppOutbox,
+        hasUndeliveredRevocations: (groupID)=>hasUndeliveredRevocations(db, groupID),
+        appOutboxFor (groupID, options) {
+            if (db.isTransaction) {
+                throw new AppOutboxTransactionError('App outbox ports require a top-level store');
+            }
+            return {
+                async put (entry) {
+                    if (entry.data.byteLength > MAX_APP_ENTRY_BYTES) {
+                        throw new AppEntryTooLargeError('App entry exceeds the plaintext bound');
+                    }
+                    const admission = pendingDelegationAdmission(entry);
+                    const put = async (tx)=>{
+                        // The upsert locks the key row against concurrent crypto-erasure.
+                        const state = await tx.insertInto('kubun_p2p_app_outbox_state').values({
+                            group_id: groupID
+                        }).onConflict((oc)=>oc.column('group_id').doUpdateSet({
+                                group_id: groupID
+                            })).returning('key').executeTakeFirstOrThrow();
+                        // Check after acquiring the erasure lock: a put resumed after removal
+                        // must not recreate the destroyed key or an encrypted outbox row.
+                        const group = await tx.selectFrom('kubun_p2p_groups').select('status').where('id', '=', groupID).executeTakeFirst();
+                        if (group?.status === 'left' || admission != null && group?.status !== 'joined') {
+                            throw new SendNotAdmissibleError('lapsed');
+                        }
+                        if (admission?.kind !== 'revocation') {
+                            const accepted = await tx.selectFrom('kubun_p2p_app_outbox').select('seq').where('group_id', '=', groupID).where('seq', '=', entry.seq).executeTakeFirst();
+                            // Accepted entries must stay writable so draining can release capacity.
+                            if (accepted == null) {
+                                const pendingRevocation = await tx.selectFrom('kubun_p2p_group_delegation').select('jti').where('group_id', '=', groupID).where('pending_revocation_hlc', 'is not', null).limit(1).executeTakeFirst();
+                                if (pendingRevocation != null && admission?.kind === 'grant') {
+                                    throw new PendingRevocationAdmissionError('Pending revocations must be admitted before new grants');
+                                }
+                                if (pendingRevocation != null && options?.limit != null) {
+                                    // Other retained traffic leaves the last slot to revocations, so a
+                                    // revocation that cannot be admitted never holds presence back.
+                                    const queued = await tx.selectFrom('kubun_p2p_app_outbox').select((eb)=>eb.fn.countAll().as('count')).where('group_id', '=', groupID).executeTakeFirstOrThrow();
+                                    if (Number(queued.count) >= options.limit - 1) {
+                                        throw new AppOutboxFullError('App outbox slot reserved for revocations');
+                                    }
+                                }
+                            }
+                        }
+                        let key = state.key;
+                        if (key == null) {
+                            key = getRandomValues(new Uint8Array(KEY_LENGTH));
+                            await tx.updateTable('kubun_p2p_app_outbox_state').set({
+                                key: adapter.encodeBinary(key)
+                            }).where('group_id', '=', groupID).execute();
+                        }
+                        const iv = getRandomValues(new Uint8Array(IV_LENGTH));
+                        const data = gcm(key, iv, associatedData(groupID, entry)).encrypt(entry.data);
+                        await tx.insertInto('kubun_p2p_app_outbox').values({
+                            group_id: groupID,
+                            seq: entry.seq,
+                            protocol: entry.protocol,
+                            prc: entry.prc,
+                            data: adapter.encodeBinary(data),
+                            iv: adapter.encodeBinary(iv),
+                            last_attempt: entry.lastAttempt == null ? null : adapter.encodeJSON(entry.lastAttempt)
+                        }).onConflict((oc)=>oc.columns([
+                                'group_id',
+                                'seq'
+                            ]).doUpdateSet((eb)=>({
+                                    protocol: eb.ref('excluded.protocol'),
+                                    prc: eb.ref('excluded.prc'),
+                                    data: eb.ref('excluded.data'),
+                                    iv: eb.ref('excluded.iv'),
+                                    last_attempt: eb.ref('excluded.last_attempt')
+                                }))).execute();
+                        if (admission != null) {
+                            const hlcColumn = admission.kind === 'grant' ? 'pending_grant_hlc' : 'pending_revocation_hlc';
+                            const digestColumn = admission.kind === 'grant' ? 'pending_grant_digest' : 'pending_revocation_digest';
+                            // Admission and marker clear commit together, matching the exact stored token.
+                            await tx.updateTable('kubun_p2p_group_delegation').set(admission.kind === 'grant' ? {
+                                pending_grant_hlc: null,
+                                pending_grant_digest: null
+                            } : {
+                                pending_revocation_hlc: null,
+                                pending_revocation_digest: null
+                            }).where('group_id', '=', groupID).where(hlcColumn, '=', admission.hlc).where(digestColumn, '=', admission.digest).execute();
+                        }
+                    };
+                    await db.transaction().execute(put);
+                },
+                async list () {
+                    const rows = await db.selectFrom('kubun_p2p_app_outbox as entry').leftJoin('kubun_p2p_app_outbox_state as state', 'state.group_id', 'entry.group_id').select([
+                        'entry.seq',
+                        'entry.protocol',
+                        'entry.prc',
+                        'entry.data',
+                        'entry.iv',
+                        'entry.last_attempt',
+                        'state.key'
+                    ]).where('entry.group_id', '=', groupID).orderBy('entry.seq').execute();
+                    return rows.map((row)=>{
+                        const entry = {
+                            seq: row.seq,
+                            protocol: row.protocol,
+                            prc: row.prc,
+                            lastAttempt: row.last_attempt
+                        };
+                        if (row.key == null) {
+                            throw new AppOutboxDecryptionError(`App outbox key is absent for group ${groupID}`);
+                        }
+                        try {
+                            const data = gcm(row.key, row.iv, associatedData(groupID, entry)).decrypt(row.data);
+                            return {
+                                ...entry,
+                                data
+                            };
+                        } catch (cause) {
+                            throw new AppOutboxDecryptionError(`App outbox entry ${row.seq} failed authentication for group ${groupID}`, {
+                                cause
+                            });
+                        }
+                    });
+                },
+                async remove (seq) {
+                    await db.deleteFrom('kubun_p2p_app_outbox').where('group_id', '=', groupID).where('seq', '=', seq).execute();
+                },
+                clear: ()=>clearAppOutbox(groupID),
+                async getCommitCursor () {
+                    const state = await db.selectFrom('kubun_p2p_app_outbox_state').select('commit_cursor').where('group_id', '=', groupID).executeTakeFirst();
+                    return state?.commit_cursor ?? null;
+                },
+                async putCommitCursor (cursor) {
+                    // A write after clear can recreate a key-less row with a stale cursor.
+                    // Kumiai resets that cursor when rejoin changes the epoch.
+                    await db.insertInto('kubun_p2p_app_outbox_state').values({
+                        group_id: groupID,
+                        commit_cursor: cursor == null ? null : adapter.encodeJSON(cursor)
+                    }).onConflict((oc)=>oc.column('group_id').doUpdateSet((eb)=>({
+                                commit_cursor: eb.ref('excluded.commit_cursor')
+                            }))).execute();
+                }
+            };
+        }
+    };
+}

package/lib/ops/catalog-offers.d.ts

@@ -0,0 +1,18 @@
+import { type Kysely } from 'kysely';
+import type { P2PStoreTables } from '../tables.js';
+export type CatalogOffer = {
+    owner: string;
+    exposureID: string;
+    catalogID: string;
+    groupID: string;
+    circleID: string;
+};
+export type CatalogOfferOps = {
+    putCatalogOffer(offer: CatalogOffer): Promise<void>;
+    removeCatalogOffer(owner: string, exposureID: string): Promise<void>;
+    removeCatalogOffersForCatalog(owner: string, catalogID: string): Promise<void>;
+    replaceCatalogOffers(groupID: string, offers: ReadonlyArray<CatalogOffer>): Promise<void>;
+    activeCatalogOffers(groupID: string, circleID: string | null): Promise<Array<CatalogOffer>>;
+    allCatalogOffers(): Promise<Array<CatalogOffer>>;
+};
+export declare function createCatalogOfferOps(db: Kysely<P2PStoreTables>): CatalogOfferOps;

package/lib/ops/catalog-offers.js

@@ -0,0 +1,59 @@
+import { Transaction } from 'kysely';
+export function createCatalogOfferOps(db) {
+    const project = (row)=>({
+            owner: row.owner,
+            exposureID: row.exposure_id,
+            catalogID: row.catalog_id,
+            groupID: row.group_id,
+            circleID: row.circle_id
+        });
+    return {
+        async putCatalogOffer (offer) {
+            await db.insertInto('kubun_p2p_catalog_offers').values({
+                owner: offer.owner,
+                exposure_id: offer.exposureID,
+                catalog_id: offer.catalogID,
+                group_id: offer.groupID,
+                circle_id: offer.circleID
+            }).onConflict((oc)=>oc.columns([
+                    'owner',
+                    'exposure_id'
+                ]).doUpdateSet({
+                    catalog_id: offer.catalogID,
+                    group_id: offer.groupID,
+                    circle_id: offer.circleID
+                })).execute();
+        },
+        async removeCatalogOffer (owner, exposureID) {
+            await db.deleteFrom('kubun_p2p_catalog_offers').where('owner', '=', owner).where('exposure_id', '=', exposureID).execute();
+        },
+        async removeCatalogOffersForCatalog (owner, catalogID) {
+            await db.deleteFrom('kubun_p2p_catalog_offers').where('owner', '=', owner).where('catalog_id', '=', catalogID).execute();
+        },
+        async allCatalogOffers () {
+            return (await db.selectFrom('kubun_p2p_catalog_offers').selectAll().execute()).map(project);
+        },
+        async replaceCatalogOffers (groupID, offers) {
+            if (offers.some((offer)=>offer.groupID !== groupID)) throw new Error('Catalog offer group does not match replacement scope');
+            const replace = async (tx)=>{
+                await tx.deleteFrom('kubun_p2p_catalog_offers').where('group_id', '=', groupID).execute();
+                if (offers.length === 0) return;
+                await tx.insertInto('kubun_p2p_catalog_offers').values(offers.map((offer)=>({
+                        owner: offer.owner,
+                        exposure_id: offer.exposureID,
+                        catalog_id: offer.catalogID,
+                        group_id: offer.groupID,
+                        circle_id: offer.circleID
+                    }))).execute();
+            };
+            if (db instanceof Transaction) await replace(db);
+            else await db.transaction().execute(replace);
+        },
+        async activeCatalogOffers (groupID, circleID) {
+            let query = db.selectFrom('kubun_p2p_catalog_offers').selectAll().where('group_id', '=', groupID);
+            if (circleID !== null) query = query.where('circle_id', '=', circleID);
+            const rows = await query.orderBy('owner').orderBy('exposure_id').execute();
+            return rows.map(project);
+        }
+    };
+}

package/lib/ops/catalog-routes.d.ts

@@ -0,0 +1,25 @@
+import type { Kysely } from 'kysely';
+import type { P2PStoreTables } from '../tables.js';
+export type CatalogRoute = {
+    owner: string;
+    catalogID: string;
+    groupID: string;
+    pull: boolean;
+    push: boolean;
+};
+export type CatalogRouteOps = {
+    setCatalogRoute(owner: string, catalogID: string, groupID: string, pull: boolean, push: boolean): Promise<void>;
+    catalogRoutes(owner: string, catalogID: string): Promise<Array<CatalogRoute>>;
+    allCatalogRoutes(groupID?: string): Promise<Array<CatalogRoute>>;
+    deleteCatalogRoutes(owner: string, catalogID: string): Promise<void>;
+    deleteGroupCatalogRoutes(groupID: string): Promise<void>;
+    /** Whether this device serves the group's document data; true unless turned off. */
+    getGroupServing(params: {
+        groupID: string;
+    }): Promise<boolean>;
+    setGroupServing(params: {
+        groupID: string;
+        enabled: boolean;
+    }): Promise<void>;
+};
+export declare function createCatalogRouteOps(db: Kysely<P2PStoreTables>): CatalogRouteOps;

package/lib/ops/catalog-routes.js

@@ -0,0 +1,60 @@
+export function createCatalogRouteOps(db) {
+    const project = (row)=>({
+            owner: row.owner,
+            catalogID: row.catalog_id,
+            groupID: row.group_id,
+            pull: Number(row.pull) === 1,
+            push: Number(row.push) === 1
+        });
+    return {
+        async setCatalogRoute (owner, catalogID, groupID, pull, push) {
+            if (!pull && !push) {
+                await db.deleteFrom('kubun_p2p_catalog_routes').where('owner', '=', owner).where('catalog_id', '=', catalogID).where('group_id', '=', groupID).execute();
+                return;
+            }
+            await db.insertInto('kubun_p2p_catalog_routes').values({
+                owner,
+                catalog_id: catalogID,
+                group_id: groupID,
+                pull: Number(pull),
+                push: Number(push)
+            }).onConflict((oc)=>oc.columns([
+                    'owner',
+                    'catalog_id',
+                    'group_id'
+                ]).doUpdateSet({
+                    pull: Number(pull),
+                    push: Number(push)
+                })).execute();
+        },
+        async getGroupServing ({ groupID }) {
+            const row = await db.selectFrom('kubun_p2p_unserved_groups').select('group_id').where('group_id', '=', groupID).executeTakeFirst();
+            return row == null;
+        },
+        async setGroupServing ({ groupID, enabled }) {
+            if (enabled) {
+                await db.deleteFrom('kubun_p2p_unserved_groups').where('group_id', '=', groupID).execute();
+                return;
+            }
+            await db.insertInto('kubun_p2p_unserved_groups').values({
+                group_id: groupID
+            }).onConflict((oc)=>oc.column('group_id').doNothing()).execute();
+        },
+        async catalogRoutes (owner, catalogID) {
+            const rows = await db.selectFrom('kubun_p2p_catalog_routes').selectAll().where('owner', '=', owner).where('catalog_id', '=', catalogID).orderBy('group_id').execute();
+            return rows.map(project);
+        },
+        async allCatalogRoutes (groupID) {
+            let query = db.selectFrom('kubun_p2p_catalog_routes').selectAll();
+            if (groupID != null) query = query.where('group_id', '=', groupID);
+            const rows = await query.orderBy('owner').orderBy('catalog_id').orderBy('group_id').execute();
+            return rows.map(project);
+        },
+        async deleteCatalogRoutes (owner, catalogID) {
+            await db.deleteFrom('kubun_p2p_catalog_routes').where('owner', '=', owner).where('catalog_id', '=', catalogID).execute();
+        },
+        async deleteGroupCatalogRoutes (groupID) {
+            await db.deleteFrom('kubun_p2p_catalog_routes').where('group_id', '=', groupID).execute();
+        }
+    };
+}

package/lib/ops/catalog-sync.d.ts

@@ -0,0 +1,122 @@
+import { type Adapter } from '@kubun/db-adapter';
+import type { Kysely } from 'kysely';
+import type { P2PStoreTables } from '../tables.js';
+/** Absolute window bounds of one concrete rule. */
+export type CatalogCursorBounds = {
+    from: number | null;
+    to: number | null;
+    /** Bound-free slot of the offered rule this accepted window came from. */
+    offeredSlot?: string;
+};
+/**
+ * Document-sync progress with one peer in one group. `rulesHash` is the hash of
+ * the accepted rule set without absolute bounds, together with the
+ * authorization it was accepted under; `bounds` holds the absolute bounds in
+ * use for each rule, keyed by the rule's bound-free key, until the cursor
+ * wraps. `cursor` is the last resolved document key, null at the start of a
+ * cycle. `cycleClear` is false once a session in the cycle left something
+ * authorized unfetched.
+ */
+export type CatalogCursorState = {
+    rulesHash: string;
+    cursor: string | null;
+    /** The responder's sealed position matching `cursor`; null at a cycle start. */
+    token: string | null;
+    cycleClear: boolean;
+    bounds: Record<string, CatalogCursorBounds>;
+};
+/** A peer's last answer for a document that left nothing to fetch from it. */
+export type DocumentRepairAnswerKind = 'unavailable' | 'refused';
+/** Listed repair rows one peer may account for in one group; the oldest go first. */
+export declare const MAX_REPAIRS_PER_LISTER = 10000;
+/** What this device remembers of one document's difference in one group. */
+export type DocumentRepairRow = {
+    /** The first peer whose tree listed the document; null when none did. */
+    listedBy: string | null;
+    holdingsDigest: string;
+    answers: Record<string, DocumentRepairAnswerKind>;
+    createdAt: number;
+    attemptedAt: number;
+};
+export type RecordDocumentRepairParams = {
+    /** `peerDID`'s tree listed the document in this attempt. */
+    listed: boolean;
+    holdingsDigest: string;
+    peerDID: string;
+    /** Null when the answer left work pending, or is about to be applied. */
+    answer: DocumentRepairAnswerKind | null;
+    attemptedAt: number;
+};
+/**
+ * When this device next asks peers for an observed document's value: the
+ * obligation it is for, how many attempts failed so far, the earliest time of
+ * the next one and the peers already asked that answered without the value.
+ */
+export type ObservationRepairSchedule = {
+    documentID: string;
+    /** Fetch time of the observation the obligation is for; a newer one starts afresh. */
+    fetchHLC: string;
+    attempts: number;
+    nextAttemptAt: number;
+    triedPeers: Array<string>;
+};
+/** Position of a schedule in due order. */
+export type ObservationRepairPosition = {
+    nextAttemptAt: number;
+    documentID: string;
+};
+export type DueObservationRepairQuery = {
+    now: number;
+    /** A schedule that has not tried this peer is due for it before its time. */
+    peerDID: string;
+    /** A schedule whose tried set is this full no longer asks untried peers early. */
+    maxTriedPeers: number;
+    after: ObservationRepairPosition | null;
+    limit: number;
+};
+/** Durable session cursors, document repair rows and observation repair schedules. */
+export type CatalogSyncOps = {
+    getCatalogCursor(peerDID: string, groupID: string): Promise<CatalogCursorState | null>;
+    setCatalogCursor(peerDID: string, groupID: string, state: CatalogCursorState): Promise<void>;
+    /** Rows for the given documents. The caller bounds the list. */
+    getDocumentRepairs(groupID: string, documentIDs: ReadonlyArray<string>): Promise<Map<string, DocumentRepairRow>>;
+    /**
+     * Record an attempt. A listed row keeps its first lister; new holdings forget
+     * the answers given for the old ones. A peer accounts for at most
+     * {@link MAX_REPAIRS_PER_LISTER} listed rows: its oldest go when it lists more.
+     */
+    recordDocumentRepair(groupID: string, documentID: string, params: RecordDocumentRepairParams): Promise<void>;
+    /** Remove rows the caller resolved. The caller bounds the list. */
+    resolveDocumentRepairs(groupID: string, documentIDs: ReadonlyArray<string>): Promise<void>;
+    /**
+     * Listed rows `peerDID` has not answered for the current holdings, least
+     * recently attempted first, so no row starves the others.
+     */
+    listDocumentRepairs(groupID: string, peerDID: string, limit: number): Promise<Array<string>>;
+    /** Remove rows created before `createdBefore`, whoever listed them. */
+    pruneDocumentRepairs(groupID: string, createdBefore: number): Promise<void>;
+    /** Schedules for the given documents. The caller bounds the list. */
+    getObservationRepairSchedules(documentIDs: ReadonlyArray<string>): Promise<Map<string, ObservationRepairSchedule>>;
+    /**
+     * Schedules due now or not yet tried with the peer, in due order after a
+     * position, at most `limit`.
+     */
+    listDueObservationRepairSchedules(query: DueObservationRepairQuery): Promise<Array<ObservationRepairSchedule>>;
+    /** Replace a schedule, its tried peers included. */
+    setObservationRepairSchedule(schedule: ObservationRepairSchedule): Promise<void>;
+    /**
+     * Read, change and write one schedule as a unit, so concurrent updates never
+     * lose a tried peer or an attempt. `update` receives the stored schedule and
+     * returns the one to store, or null to leave it. Resolves to the schedule
+     * stored afterwards.
+     */
+    updateObservationRepairSchedule(documentID: string, update: (current: ObservationRepairSchedule | undefined) => ObservationRepairSchedule | null): Promise<ObservationRepairSchedule | undefined>;
+    /** Remove a schedule whose obligation resolved. */
+    deleteObservationRepairSchedules(documentIDs: ReadonlyArray<string>): Promise<void>;
+    /** The documents with a schedule, in ID order after `after`, at most `limit`. */
+    listObservationRepairScheduleIDs(page: {
+        after: string | null;
+        limit: number;
+    }): Promise<Array<string>>;
+};
+export declare function createCatalogSyncOps(db: Kysely<P2PStoreTables>, adapter: Adapter): CatalogSyncOps;