@kubun/store-p2p 0.16.0 → 0.18.0

package/lib/ops/catalog-sync.js

@@ -0,0 +1,251 @@
+import { AbstractPostgresAdapter } from '@kubun/db-adapter';
+import { sql } from 'kysely';
+/** Listed repair rows one peer may account for in one group; the oldest go first. */ export const MAX_REPAIRS_PER_LISTER = 10_000;
+function scheduleFromRow(row, triedPeers) {
+    return {
+        documentID: row.document_id,
+        fetchHLC: row.fetch_hlc,
+        attempts: Number(row.attempts),
+        nextAttemptAt: Number(row.next_attempt_at),
+        triedPeers
+    };
+}
+/** Some adapters parse JSON text on read. */ function parseJSON(value) {
+    return typeof value === 'string' ? JSON.parse(value) : value;
+}
+export function createCatalogSyncOps(db, adapter) {
+    const triedPeersOf = async (documentIDs, from = db)=>{
+        const tried = new Map();
+        if (documentIDs.length === 0) return tried;
+        const rows = await from.selectFrom('kubun_p2p_observation_repair_peers').selectAll().where('document_id', 'in', [
+            ...documentIDs
+        ]).orderBy('peer_did').execute();
+        for (const row of rows){
+            const peers = tried.get(row.document_id) ?? [];
+            peers.push(row.peer_did);
+            tried.set(row.document_id, peers);
+        }
+        return tried;
+    };
+    const readSchedules = async (from, documentIDs)=>{
+        const schedules = new Map();
+        if (documentIDs.length === 0) return schedules;
+        const rows = await from.selectFrom('kubun_p2p_observation_repairs').selectAll().where('document_id', 'in', [
+            ...documentIDs
+        ]).execute();
+        const tried = await triedPeersOf(rows.map((row)=>row.document_id), from);
+        for (const row of rows){
+            schedules.set(row.document_id, scheduleFromRow(row, tried.get(row.document_id) ?? []));
+        }
+        return schedules;
+    };
+    const writeSchedule = async (tx, schedule)=>{
+        const triedPeers = [
+            ...new Set(schedule.triedPeers)
+        ].sort();
+        const values = {
+            fetch_hlc: schedule.fetchHLC,
+            attempts: schedule.attempts,
+            next_attempt_at: schedule.nextAttemptAt,
+            tried_count: triedPeers.length
+        };
+        await tx.insertInto('kubun_p2p_observation_repairs').values({
+            document_id: schedule.documentID,
+            ...values
+        }).onConflict((oc)=>oc.column('document_id').doUpdateSet(values)).execute();
+        await tx.deleteFrom('kubun_p2p_observation_repair_peers').where('document_id', '=', schedule.documentID).execute();
+        if (triedPeers.length > 0) {
+            await tx.insertInto('kubun_p2p_observation_repair_peers').values(triedPeers.map((peerDID)=>({
+                    document_id: schedule.documentID,
+                    peer_did: peerDID
+                }))).execute();
+        }
+    };
+    const inTransaction = async (fn)=>db.isTransaction ? await fn(db) : await db.transaction().execute(fn);
+    const ops = {
+        async getCatalogCursor (peerDID, groupID) {
+            const row = await db.selectFrom('kubun_p2p_catalog_cursors').selectAll().where('peer_did', '=', peerDID).where('group_id', '=', groupID).executeTakeFirst();
+            if (row == null) return null;
+            return {
+                rulesHash: row.rules_hash,
+                cursor: row.last_key ?? null,
+                token: row.last_token ?? null,
+                cycleClear: Number(row.cycle_clear) === 1,
+                bounds: parseJSON(row.bounds)
+            };
+        },
+        async setCatalogCursor (peerDID, groupID, state) {
+            const values = {
+                rules_hash: state.rulesHash,
+                last_key: state.cursor,
+                last_token: state.token,
+                cycle_clear: state.cycleClear ? 1 : 0,
+                bounds: JSON.stringify(state.bounds)
+            };
+            await db.insertInto('kubun_p2p_catalog_cursors').values({
+                peer_did: peerDID,
+                group_id: groupID,
+                ...values
+            }).onConflict((oc)=>oc.columns([
+                    'peer_did',
+                    'group_id'
+                ]).doUpdateSet(values)).execute();
+        },
+        async getDocumentRepairs (groupID, documentIDs) {
+            const rows = new Map();
+            if (documentIDs.length === 0) return rows;
+            const ids = [
+                ...documentIDs
+            ];
+            const [found, answers] = await Promise.all([
+                db.selectFrom('kubun_p2p_document_repairs').selectAll().where('group_id', '=', groupID).where('document_id', 'in', ids).execute(),
+                db.selectFrom('kubun_p2p_document_repair_answers').selectAll().where('group_id', '=', groupID).where('document_id', 'in', ids).execute()
+            ]);
+            for (const row of found){
+                rows.set(row.document_id, {
+                    listedBy: row.listed_by ?? null,
+                    holdingsDigest: row.holdings_digest,
+                    answers: {},
+                    createdAt: Number(row.created_at),
+                    attemptedAt: Number(row.attempted_at)
+                });
+            }
+            for (const answer of answers){
+                const row = rows.get(answer.document_id);
+                if (row != null) row.answers[answer.peer_did] = answer.answer;
+            }
+            return rows;
+        },
+        async recordDocumentRepair (groupID, documentID, params) {
+            const existing = (await ops.getDocumentRepairs(groupID, [
+                documentID
+            ])).get(documentID);
+            const listedBy = existing?.listedBy ?? (params.listed ? params.peerDID : null);
+            if (params.listed && existing?.listedBy == null) {
+                // A peer that lists more than its share pushes out its own oldest rows.
+                const counted = await db.selectFrom('kubun_p2p_document_repairs').select((eb)=>eb.fn.countAll().as('count')).where('group_id', '=', groupID).where('listed_by', '=', params.peerDID).executeTakeFirst();
+                const excess = Number(counted?.count ?? 0) + 1 - MAX_REPAIRS_PER_LISTER;
+                if (excess > 0) {
+                    const oldest = await db.selectFrom('kubun_p2p_document_repairs').select('document_id').where('group_id', '=', groupID).where('listed_by', '=', params.peerDID).orderBy('attempted_at').orderBy('document_id').limit(excess).execute();
+                    await ops.resolveDocumentRepairs(groupID, oldest.map((row)=>row.document_id));
+                }
+            }
+            if (existing != null && existing.holdingsDigest !== params.holdingsDigest) {
+                await db.deleteFrom('kubun_p2p_document_repair_answers').where('group_id', '=', groupID).where('document_id', '=', documentID).execute();
+            }
+            const values = {
+                listed_by: listedBy,
+                holdings_digest: params.holdingsDigest,
+                attempted_at: params.attemptedAt
+            };
+            await db.insertInto('kubun_p2p_document_repairs').values({
+                group_id: groupID,
+                document_id: documentID,
+                created_at: existing?.createdAt ?? params.attemptedAt,
+                ...values
+            }).onConflict((oc)=>oc.columns([
+                    'group_id',
+                    'document_id'
+                ]).doUpdateSet({
+                    ...values,
+                    listed_by: sql`coalesce(kubun_p2p_document_repairs.listed_by, ${listedBy})`
+                })).execute();
+            if (params.answer == null) {
+                await db.deleteFrom('kubun_p2p_document_repair_answers').where('group_id', '=', groupID).where('document_id', '=', documentID).where('peer_did', '=', params.peerDID).execute();
+            } else {
+                await db.insertInto('kubun_p2p_document_repair_answers').values({
+                    group_id: groupID,
+                    document_id: documentID,
+                    peer_did: params.peerDID,
+                    answer: params.answer
+                }).onConflict((oc)=>oc.columns([
+                        'group_id',
+                        'document_id',
+                        'peer_did'
+                    ]).doUpdateSet({
+                        answer: params.answer
+                    })).execute();
+            }
+        },
+        async resolveDocumentRepairs (groupID, documentIDs) {
+            if (documentIDs.length === 0) return;
+            for (const table of [
+                'kubun_p2p_document_repair_answers',
+                'kubun_p2p_document_repairs'
+            ]){
+                await db.deleteFrom(table).where('group_id', '=', groupID).where('document_id', 'in', [
+                    ...documentIDs
+                ]).execute();
+            }
+        },
+        async listDocumentRepairs (groupID, peerDID, limit) {
+            const rows = await db.selectFrom('kubun_p2p_document_repairs as r').select('r.document_id').where('r.group_id', '=', groupID).where('r.listed_by', 'is not', null).where(({ not, exists, selectFrom })=>not(exists(selectFrom('kubun_p2p_document_repair_answers as a').select('a.peer_did').whereRef('a.group_id', '=', 'r.group_id').whereRef('a.document_id', '=', 'r.document_id').where('a.peer_did', '=', peerDID)))).orderBy('r.attempted_at').orderBy('r.document_id').limit(limit).execute();
+            return rows.map((row)=>row.document_id);
+        },
+        async pruneDocumentRepairs (groupID, createdBefore) {
+            await db.deleteFrom('kubun_p2p_document_repair_answers').where('group_id', '=', groupID).where('document_id', 'in', (eb)=>eb.selectFrom('kubun_p2p_document_repairs').select('document_id').where('group_id', '=', groupID).where('created_at', '<', createdBefore)).execute();
+            await db.deleteFrom('kubun_p2p_document_repairs').where('group_id', '=', groupID).where('created_at', '<', createdBefore).execute();
+        },
+        async getObservationRepairSchedules (documentIDs) {
+            return await readSchedules(db, documentIDs);
+        },
+        async listDueObservationRepairSchedules (query) {
+            let select = db.selectFrom('kubun_p2p_observation_repairs as r').selectAll('r').where((eb)=>eb.or([
+                    eb('r.next_attempt_at', '<=', query.now),
+                    eb.and([
+                        eb('r.tried_count', '<', query.maxTriedPeers),
+                        eb.not(eb.exists(eb.selectFrom('kubun_p2p_observation_repair_peers as p').select('p.peer_did').whereRef('p.document_id', '=', 'r.document_id').where('p.peer_did', '=', query.peerDID)))
+                    ])
+                ]));
+            const after = query.after;
+            if (after !== null) {
+                select = select.where((eb)=>eb.or([
+                        eb('r.next_attempt_at', '>', after.nextAttemptAt),
+                        eb.and([
+                            eb('r.next_attempt_at', '=', after.nextAttemptAt),
+                            eb('r.document_id', '>', after.documentID)
+                        ])
+                    ]));
+            }
+            const rows = await select.orderBy('r.next_attempt_at').orderBy('r.document_id').limit(query.limit).execute();
+            const tried = await triedPeersOf(rows.map((row)=>row.document_id));
+            return rows.map((row)=>scheduleFromRow(row, tried.get(row.document_id) ?? []));
+        },
+        async setObservationRepairSchedule (schedule) {
+            await inTransaction(async (tx)=>await writeSchedule(tx, schedule));
+        },
+        async updateObservationRepairSchedule (documentID, update) {
+            return await inTransaction(async (tx)=>{
+                // Postgres runs sessions concurrently: serialize updates of one
+                // document. SQLite transactions already run one at a time.
+                if (adapter instanceof AbstractPostgresAdapter) {
+                    await sql`select pg_advisory_xact_lock(hashtextextended(${`kubun_p2p_observation_repairs:${documentID}`}, 0))`.execute(tx);
+                }
+                const current = (await readSchedules(tx, [
+                    documentID
+                ])).get(documentID);
+                const next = update(current);
+                if (next === null) return current;
+                await writeSchedule(tx, next);
+                return next;
+            });
+        },
+        async listObservationRepairScheduleIDs ({ after, limit }) {
+            let query = db.selectFrom('kubun_p2p_observation_repairs').select('document_id').orderBy('document_id').limit(limit);
+            if (after !== null) query = query.where('document_id', '>', after);
+            return (await query.execute()).map((row)=>row.document_id);
+        },
+        async deleteObservationRepairSchedules (documentIDs) {
+            if (documentIDs.length === 0) return;
+            await inTransaction(async (tx)=>{
+                await tx.deleteFrom('kubun_p2p_observation_repair_peers').where('document_id', 'in', [
+                    ...documentIDs
+                ]).execute();
+                await tx.deleteFrom('kubun_p2p_observation_repairs').where('document_id', 'in', [
+                    ...documentIDs
+                ]).execute();
+            });
+        }
+    };
+    return ops;
+}

package/lib/ops/circles.d.ts

@@ -1,5 +1,5 @@
-import type { Adapter } from '@kubun/db-adapter';
-import type { Kysely } from 'kysely';
+import { type Adapter } from '@kubun/db-adapter';
+import { type Kysely } from 'kysely';
 import type { Circle, CircleMember, InsertCircle, InsertCircleMember, P2PStoreTables } from '../tables.js';
 /** Circles, their membership rows, and the fold-authoritative projections. */
 export type CircleOps = {
@@ -21,7 +21,7 @@ export type CircleOps = {
      * Caller is responsible for deduplicating IDs.
      */
     getCircles(ids: Array<string>): Promise<Map<string, Circle>>;
-    updateCircle(id: string, update: Partial<Pick<InsertCircle, 'name' | 'description' | 'catalog_ids' | 'hlc'>>): Promise<void>;
+    updateCircle(id: string, update: Partial<Pick<InsertCircle, 'name' | 'description' | 'hlc'>>): Promise<void>;
     deleteCircle(id: string): Promise<void>;
     /**
      * Tombstone an existing circle row at `hlc` using earliest-wins LWW: the
@@ -130,7 +130,6 @@ export type CircleOps = {
         groupID: string;
         name: string;
         description: string;
-        catalogIDs: Array<string>;
         hlc: string;
         removedAtHLC: string | null;
         open: boolean;

package/lib/ops/circles.js

@@ -1,4 +1,15 @@
 import { normalizeDID } from '@kokuin/token';
+import { chunked } from '@kubun/db-adapter';
+import { sql } from 'kysely';
+/**
+ * True when an upsert's incoming value differs from the stored one, NULL-safe on
+ * both adapters. An upsert guarded by it leaves a row that already holds the
+ * projected values untouched, `updated_at` included.
+ */ function differs(table, column) {
+    const stored = sql.ref(`${table}.${column}`);
+    const incoming = sql.ref(`excluded.${column}`);
+    return sql`(${stored} <> ${incoming} OR (${stored} IS NULL) <> (${incoming} IS NULL))`;
+}
 /**
  * A member may access an active circle by either arm: an active explicit
  * membership row, OR the circle being open (`open = 1`) with the member holding
@@ -27,7 +38,6 @@ export function createCircleOps(db, adapter) {
                 group_id: circle.group_id,
                 name: circle.name,
                 description: circle.description,
-                catalog_ids: adapter.encodeJSON(circle.catalog_ids),
                 hlc: circle.hlc
             }).execute();
         },
@@ -40,10 +50,11 @@ export function createCircleOps(db, adapter) {
         },
         async getCircles (ids) {
             const result = new Map();
-            if (ids.length === 0) return result;
-            const rows = await db.selectFrom('kubun_p2p_circles').selectAll().where('id', 'in', ids).execute();
-            for (const row of rows){
-                result.set(row.id, row);
+            for (const chunk of chunked(ids)){
+                const rows = await db.selectFrom('kubun_p2p_circles').selectAll().where('id', 'in', chunk).execute();
+                for (const row of rows){
+                    result.set(row.id, row);
+                }
             }
             return result;
         },
@@ -51,9 +62,6 @@ export function createCircleOps(db, adapter) {
             const values = {};
             if (update.name != null) values.name = update.name;
             if (update.description != null) values.description = update.description;
-            if (update.catalog_ids != null) {
-                values.catalog_ids = adapter.encodeJSON(update.catalog_ids);
-            }
             if (update.hlc != null) {
                 values.hlc = update.hlc;
                 // A create/update that wins the apply-layer HLC check resurrects a
@@ -211,12 +219,12 @@ export function createCircleOps(db, adapter) {
                 await db.updateTable('kubun_p2p_circles').set({
                     open: 1,
                     updated_at: now
-                }).where('group_id', '=', groupID).where('id', 'in', openCircleIDs).execute();
+                }).where('group_id', '=', groupID).where('id', 'in', openCircleIDs).where('open', '<>', 1).execute();
             }
             let closeQuery = db.updateTable('kubun_p2p_circles').set({
                 open: 0,
                 updated_at: now
-            }).where('group_id', '=', groupID);
+            }).where('group_id', '=', groupID).where('open', '<>', 0);
             if (openCircleIDs.length > 0) {
                 closeQuery = closeQuery.where('id', 'not in', openCircleIDs);
             }
@@ -233,7 +241,6 @@ export function createCircleOps(db, adapter) {
                 group_id: params.groupID,
                 name: params.name,
                 description: params.description,
-                catalog_ids: adapter.encodeJSON(params.catalogIDs),
                 hlc: params.hlc,
                 removed_at_hlc: params.removedAtHLC,
                 open: params.open ? 1 : 0
@@ -241,12 +248,18 @@ export function createCircleOps(db, adapter) {
                         group_id: eb.ref('excluded.group_id'),
                         name: eb.ref('excluded.name'),
                         description: eb.ref('excluded.description'),
-                        catalog_ids: eb.ref('excluded.catalog_ids'),
                         hlc: eb.ref('excluded.hlc'),
                         removed_at_hlc: eb.ref('excluded.removed_at_hlc'),
                         open: eb.ref('excluded.open'),
                         updated_at: adapter.encodeTimestamp(new Date())
-                    }))).execute();
+                    })).where((eb)=>eb.or([
+                        'group_id',
+                        'name',
+                        'description',
+                        'hlc',
+                        'removed_at_hlc',
+                        'open'
+                    ].map((column)=>differs('kubun_p2p_circles', column))))).execute();
         },
         async reconcileCircleMemberProjection (params) {
             await db.insertInto('kubun_p2p_circle_members').values({
@@ -263,7 +276,11 @@ export function createCircleOps(db, adapter) {
                         hlc: eb.ref('excluded.hlc'),
                         removed_at_hlc: eb.ref('excluded.removed_at_hlc'),
                         updated_at: adapter.encodeTimestamp(new Date())
-                    }))).execute();
+                    })).where((eb)=>eb.or([
+                        'role',
+                        'hlc',
+                        'removed_at_hlc'
+                    ].map((column)=>differs('kubun_p2p_circle_members', column))))).execute();
         }
     };
 }

package/lib/ops/control.d.ts

@@ -63,6 +63,11 @@ export type ControlOps = {
          */
         result?: string;
         settledAt: string;
+        /**
+         * The handle epoch of the advance that lands the request, for a `committed`
+         * settle written with that advance.
+         */
+        epoch?: number;
     }): Promise<void>;
     /**
      * The settled request's artifact, or `null` when it produced none or the row
@@ -93,6 +98,7 @@ export type ControlOps = {
         bodies: Array<string>;
         kind: CommitJournalEntryKind;
         journal: Uint8Array;
+        holdsLogSends?: boolean;
     }): Promise<void>;
     /** The group's slot, or `undefined` if empty. */
     getCommitJournalEntry(groupID: string): Promise<CommitJournalEntry | undefined>;

package/lib/ops/control.js

@@ -38,6 +38,9 @@ export function createControlOps(db, adapter) {
                 status: params.outcome,
                 settled_at: params.settledAt
             };
+            if (params.epoch !== undefined) {
+                update.settled_epoch = params.epoch;
+            }
             if (params.error !== undefined) {
                 update.error = params.error;
             }
@@ -75,7 +78,8 @@ export function createControlOps(db, adapter) {
                 commit: adapter.encodeBinary(params.commit),
                 bodies: adapter.encodeJSON(params.bodies),
                 kind: params.kind,
-                journal: adapter.encodeBinary(params.journal)
+                journal: adapter.encodeBinary(params.journal),
+                holds_log_sends: params.holdsLogSends === true ? 1 : 0
             };
             await db.insertInto('kubun_p2p_commit_journal').values(values)// Single slot per group: a fresh `put` REPLACES the whole row,
             // whatever it held (including a stale `accepted_as` from a prior
@@ -88,11 +92,16 @@ export function createControlOps(db, adapter) {
                         commit: eb.ref('excluded.commit'),
                         bodies: eb.ref('excluded.bodies'),
                         kind: eb.ref('excluded.kind'),
-                        journal: eb.ref('excluded.journal')
+                        journal: eb.ref('excluded.journal'),
+                        holds_log_sends: eb.ref('excluded.holds_log_sends')
                     }))).execute();
         },
         async getCommitJournalEntry (groupID) {
-            return await db.selectFrom('kubun_p2p_commit_journal').selectAll().where('group_id', '=', groupID).executeTakeFirst();
+            const row = await db.selectFrom('kubun_p2p_commit_journal').selectAll().where('group_id', '=', groupID).executeTakeFirst();
+            return row == null ? undefined : {
+                ...row,
+                holds_log_sends: row.holds_log_sends === 1
+            };
         },
         // A no-op if the slot no longer holds `publishID` (already cleared, or
         // replaced by a later `put`) — the `WHERE` simply matches no row.

package/lib/ops/delegations.d.ts

@@ -9,6 +9,37 @@ export type DelegationOps = {
      * carries the group association the p2p layer needs.
      */
     addGroupDelegation(edge: InsertGroupDelegation): Promise<void>;
+    /** Hold the outbox erasure lock and read membership; replacement must call inside its transaction. */
+    lockJoinedGroupForDelegation(groupID: string): Promise<boolean>;
+    /** Mark a locally stored token for outbox admission while its group is joined. */
+    markDelegationPending(params: {
+        groupID: string;
+        jti: string;
+        kind: 'grant' | 'revocation';
+        hlc: string;
+        token: string;
+    }): Promise<void>;
+    /** Whether this exact locally stored token still awaits admission in a joined group. */
+    isDelegationPending(params: {
+        groupID: string;
+        jti: string;
+        kind: 'grant' | 'revocation';
+        hlc: string;
+        token: string;
+    }): Promise<boolean>;
+    /** Joined-group pending admissions, oldest first with stable JTI ordering. */
+    listPendingDelegations(groupID: string, kind: 'grant' | 'revocation'): Promise<Array<{
+        jti: string;
+        hlc: string;
+    }>>;
+    /** Clear one observed marker without removing a newer pending version. */
+    clearPendingDelegation(params: {
+        groupID: string;
+        jti: string;
+        kind: 'grant' | 'revocation';
+        hlc: string;
+    }): Promise<void>;
+    clearPendingDelegations(groupID: string): Promise<void>;
     /**
      * Resolve the group a delegation `jti` was granted in, or `null` when no edge
      * exists. Used to target revoke broadcasts and to enrich revocation listings

package/lib/ops/delegations.js

@@ -1,11 +1,82 @@
+import { encodeMultibase, multihashSHA256 } from '@kokuin/token';
 export function createDelegationOps(db) {
+    const lockJoinedGroup = async (tx, groupID)=>{
+        await tx.insertInto('kubun_p2p_app_outbox_state').values({
+            group_id: groupID
+        }).onConflict((oc)=>oc.column('group_id').doUpdateSet({
+                group_id: groupID
+            })).execute();
+        const group = await tx.selectFrom('kubun_p2p_groups').select('status').where('id', '=', groupID).executeTakeFirst();
+        return group?.status === 'joined';
+    };
     return {
+        async lockJoinedGroupForDelegation (groupID) {
+            if (db.isTransaction) return await lockJoinedGroup(db, groupID);
+            return await db.transaction().execute((tx)=>lockJoinedGroup(tx, groupID));
+        },
         async addGroupDelegation (edge) {
             await db.insertInto('kubun_p2p_group_delegation').values({
                 group_id: edge.group_id,
                 jti: edge.jti
             }).onConflict((oc)=>oc.column('jti').doNothing()).execute();
         },
+        async markDelegationPending (params) {
+            const mark = async (tx)=>{
+                // Read membership under the same lock as replacement and departure.
+                if (!await lockJoinedGroup(tx, params.groupID)) return;
+                const digest = encodeMultibase(multihashSHA256(new TextEncoder().encode(params.token)));
+                await tx.updateTable('kubun_p2p_group_delegation').set(params.kind === 'grant' ? {
+                    pending_grant_hlc: params.hlc,
+                    pending_grant_digest: digest
+                } : {
+                    pending_revocation_hlc: params.hlc,
+                    pending_revocation_digest: digest
+                }).where('group_id', '=', params.groupID).where('jti', '=', params.jti).execute();
+            };
+            if (db.isTransaction) await mark(db);
+            else await db.transaction().execute(mark);
+        },
+        async isDelegationPending (params) {
+            const hlcColumn = params.kind === 'grant' ? 'pending_grant_hlc' : 'pending_revocation_hlc';
+            const digestColumn = params.kind === 'grant' ? 'pending_grant_digest' : 'pending_revocation_digest';
+            const digest = encodeMultibase(multihashSHA256(new TextEncoder().encode(params.token)));
+            const row = await db.selectFrom('kubun_p2p_group_delegation as delegation').innerJoin('kubun_p2p_groups as group', 'group.id', 'delegation.group_id').select('delegation.jti').where('delegation.group_id', '=', params.groupID).where('delegation.jti', '=', params.jti).where('group.status', '=', 'joined').where(`delegation.${hlcColumn}`, '=', params.hlc).where(`delegation.${digestColumn}`, '=', digest).executeTakeFirst();
+            return row != null;
+        },
+        async listPendingDelegations (groupID, kind) {
+            const column = kind === 'grant' ? 'pending_grant_hlc' : 'pending_revocation_hlc';
+            return await db.selectFrom('kubun_p2p_group_delegation as delegation').innerJoin('kubun_p2p_groups as group', 'group.id', 'delegation.group_id').select([
+                'delegation.jti',
+                `delegation.${column} as hlc`
+            ]).where('delegation.group_id', '=', groupID).where('group.status', '=', 'joined').where(`delegation.${column}`, 'is not', null).orderBy(`delegation.${column}`).orderBy('delegation.jti').$narrowType().execute();
+        },
+        async clearPendingDelegation (params) {
+            const clear = async (tx)=>{
+                await tx.insertInto('kubun_p2p_app_outbox_state').values({
+                    group_id: params.groupID
+                }).onConflict((oc)=>oc.column('group_id').doUpdateSet({
+                        group_id: params.groupID
+                    })).execute();
+                const hlcColumn = params.kind === 'grant' ? 'pending_grant_hlc' : 'pending_revocation_hlc';
+                await tx.updateTable('kubun_p2p_group_delegation').set(params.kind === 'grant' ? {
+                    pending_grant_hlc: null,
+                    pending_grant_digest: null
+                } : {
+                    pending_revocation_hlc: null,
+                    pending_revocation_digest: null
+                }).where('group_id', '=', params.groupID).where('jti', '=', params.jti).where(hlcColumn, '=', params.hlc).execute();
+            };
+            if (db.isTransaction) await clear(db);
+            else await db.transaction().execute(clear);
+        },
+        async clearPendingDelegations (groupID) {
+            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();
+        },
         async getGroupIDByJTI (jti) {
             const row = await db.selectFrom('kubun_p2p_group_delegation').select('group_id').where('jti', '=', jti).executeTakeFirst();
             return row?.group_id ?? null;

package/lib/ops/document-sweep.d.ts

@@ -0,0 +1,11 @@
+import type { Kysely } from 'kysely';
+import type { P2PStoreTables } from '../tables.js';
+/** A swept document's per-document rows. */
+export type DocumentSweepOps = {
+    /**
+     * Delete the document's repair rows in every group, their answers, its observation repair
+     * schedule and tried peers, and its broadcast dedup log. Call inside the sweeping transaction.
+     */
+    sweepDocumentRows(documentID: string): Promise<void>;
+};
+export declare function createDocumentSweepOps(db: Kysely<P2PStoreTables>): DocumentSweepOps;

package/lib/ops/document-sweep.js

@@ -0,0 +1,16 @@
+export function createDocumentSweepOps(db) {
+    return {
+        async sweepDocumentRows (documentID) {
+            for (const table of [
+                'kubun_p2p_document_repair_answers',
+                'kubun_p2p_document_repairs',
+                'kubun_p2p_observation_repair_peers',
+                'kubun_p2p_observation_repairs'
+            ]){
+                await db.deleteFrom(table).where('document_id', '=', documentID).execute();
+            }
+            // Dedups sends only: a version sent again after a restore is a no-op where it was applied.
+            await db.deleteFrom('kubun_p2p_broadcast_log').where('doc_id', '=', documentID).execute();
+        }
+    };
+}