@kubun/store-p2p 0.19.0 → 0.20.0

package/lib/ops/circles.js

@@ -18,22 +18,22 @@ import { sql } from 'kysely';
  * at current state, so closing the circle revokes the open arm immediately.
  *
  * Every circle reader shares this one predicate: an open circle carries no
- * membership rows, so a reader resolving access from `kubun_p2p_circle_members`
+ * membership rows, so a reader resolving access from `p2p_circle_members`
  * alone would see an empty set for a member whose access is purely implicit.
  * Callers must still filter tombstoned circles themselves.
  */ function circleAccessPredicate(eb, normalizedDID) {
     return eb.or([
-        eb.exists(eb.selectFrom('kubun_p2p_circle_members').select('kubun_p2p_circle_members.circle_id').whereRef('kubun_p2p_circle_members.circle_id', '=', 'kubun_p2p_circles.id').where('kubun_p2p_circle_members.member_did', '=', normalizedDID).where('kubun_p2p_circle_members.removed_at_hlc', 'is', null)),
+        eb.exists(eb.selectFrom('p2p_circle_members').select('p2p_circle_members.circle_id').whereRef('p2p_circle_members.circle_id', '=', 'p2p_circles.id').where('p2p_circle_members.member_did', '=', normalizedDID).where('p2p_circle_members.removed_at_hlc', 'is', null)),
         eb.and([
-            eb('kubun_p2p_circles.open', '=', 1),
-            eb.exists(eb.selectFrom('kubun_p2p_group_members').select('kubun_p2p_group_members.member_did').whereRef('kubun_p2p_group_members.group_id', '=', 'kubun_p2p_circles.group_id').where('kubun_p2p_group_members.member_did', '=', normalizedDID).where('kubun_p2p_group_members.removed_at_hlc', 'is', null))
+            eb('p2p_circles.open', '=', 1),
+            eb.exists(eb.selectFrom('p2p_group_members').select('p2p_group_members.member_did').whereRef('p2p_group_members.group_id', '=', 'p2p_circles.group_id').where('p2p_group_members.member_did', '=', normalizedDID).where('p2p_group_members.removed_at_hlc', 'is', null))
         ])
     ]);
 }
 export function createCircleOps(db, adapter) {
     return {
         async createCircle (circle) {
-            await db.insertInto('kubun_p2p_circles').values({
+            await db.insertInto('p2p_circles').values({
                 id: circle.id,
                 group_id: circle.group_id,
                 name: circle.name,
@@ -42,7 +42,7 @@ export function createCircleOps(db, adapter) {
             }).execute();
         },
         async getCircle (id, options) {
-            let query = db.selectFrom('kubun_p2p_circles').selectAll().where('id', '=', id);
+            let query = db.selectFrom('p2p_circles').selectAll().where('id', '=', id);
             if (!options?.includeRemoved) {
                 query = query.where('removed_at_hlc', 'is', null);
             }
@@ -51,7 +51,7 @@ export function createCircleOps(db, adapter) {
         async getCircles (ids) {
             const result = new Map();
             for (const chunk of chunked(ids)){
-                const rows = await db.selectFrom('kubun_p2p_circles').selectAll().where('id', 'in', chunk).execute();
+                const rows = await db.selectFrom('p2p_circles').selectAll().where('id', 'in', chunk).execute();
                 for (const row of rows){
                     result.set(row.id, row);
                 }
@@ -69,10 +69,10 @@ export function createCircleOps(db, adapter) {
                 values.removed_at_hlc = null;
             }
             values.updated_at = adapter.encodeTimestamp(new Date());
-            await db.updateTable('kubun_p2p_circles').set(values).where('id', '=', id).execute();
+            await db.updateTable('p2p_circles').set(values).where('id', '=', id).execute();
         },
         async deleteCircle (id) {
-            await db.deleteFrom('kubun_p2p_circles').where('id', '=', id).execute();
+            await db.deleteFrom('p2p_circles').where('id', '=', id).execute();
         },
         // Earliest-wins LWW on `removed_at_hlc`: the update lands only when the row
         // exists AND it is either not yet tombstoned or the incoming `hlc` precedes
@@ -80,7 +80,7 @@ export function createCircleOps(db, adapter) {
         // ignored — there is no circle to tombstone, and creating a row would leak
         // a phantom circle.
         async markCircleRemoved (circleID, hlc) {
-            await db.updateTable('kubun_p2p_circles').set({
+            await db.updateTable('p2p_circles').set({
                 removed_at_hlc: hlc,
                 updated_at: adapter.encodeTimestamp(new Date())
             }).where('id', '=', circleID).where((eb)=>eb.or([
@@ -89,7 +89,7 @@ export function createCircleOps(db, adapter) {
                 ])).execute();
         },
         async listCirclesByGroup (groupID, options) {
-            let query = db.selectFrom('kubun_p2p_circles').selectAll().where('group_id', '=', groupID);
+            let query = db.selectFrom('p2p_circles').selectAll().where('group_id', '=', groupID);
             if (!options?.includeRemoved) {
                 query = query.where('removed_at_hlc', 'is', null);
             }
@@ -98,7 +98,7 @@ export function createCircleOps(db, adapter) {
         async addCircleMember (member) {
             // Re-adding a previously-removed member clears the tombstone and refreshes
             // the row's HLC, so a member that left and rejoined is active again.
-            await db.insertInto('kubun_p2p_circle_members').values({
+            await db.insertInto('p2p_circle_members').values({
                 circle_id: member.circle_id,
                 member_did: normalizeDID(member.member_did),
                 role: member.role,
@@ -119,7 +119,7 @@ export function createCircleOps(db, adapter) {
         // `(circleID, memberDID)` with no local row is ignored — no phantom row is
         // created.
         async removeCircleMember (circleID, memberDID, hlc) {
-            await db.updateTable('kubun_p2p_circle_members').set({
+            await db.updateTable('p2p_circle_members').set({
                 removed_at_hlc: hlc,
                 updated_at: adapter.encodeTimestamp(new Date())
             }).where('circle_id', '=', circleID).where('member_did', '=', normalizeDID(memberDID)).where((eb)=>eb.or([
@@ -128,10 +128,10 @@ export function createCircleOps(db, adapter) {
                 ])).execute();
         },
         async getCircleMember (circleID, memberDID) {
-            return await db.selectFrom('kubun_p2p_circle_members').selectAll().where('circle_id', '=', circleID).where('member_did', '=', normalizeDID(memberDID)).executeTakeFirst();
+            return await db.selectFrom('p2p_circle_members').selectAll().where('circle_id', '=', circleID).where('member_did', '=', normalizeDID(memberDID)).executeTakeFirst();
         },
         async listCircleMembers (circleID, options) {
-            let query = db.selectFrom('kubun_p2p_circle_members').selectAll().where('circle_id', '=', circleID);
+            let query = db.selectFrom('p2p_circle_members').selectAll().where('circle_id', '=', circleID);
             if (!options?.includeRemoved) {
                 query = query.where('removed_at_hlc', 'is', null);
             }
@@ -141,13 +141,13 @@ export function createCircleOps(db, adapter) {
         // member can reach, explicitly or through the open arm.
         async getCirclesForMember (memberDID) {
             const normalized = normalizeDID(memberDID);
-            return await db.selectFrom('kubun_p2p_circles').selectAll('kubun_p2p_circles').where('kubun_p2p_circles.removed_at_hlc', 'is', null).where((eb)=>circleAccessPredicate(eb, normalized)).execute();
+            return await db.selectFrom('p2p_circles').selectAll('p2p_circles').where('p2p_circles.removed_at_hlc', 'is', null).where((eb)=>circleAccessPredicate(eb, normalized)).execute();
         },
         // Read-ACL / sync-scope source: does the member reach any of these circles?
         async isMemberOfAnyCircle (memberDID, circleIDs) {
             if (circleIDs.length === 0) return false;
             const normalized = normalizeDID(memberDID);
-            const row = await db.selectFrom('kubun_p2p_circles').select('kubun_p2p_circles.id').where('kubun_p2p_circles.id', 'in', circleIDs).where('kubun_p2p_circles.removed_at_hlc', 'is', null).where((eb)=>circleAccessPredicate(eb, normalized)).limit(1).executeTakeFirst();
+            const row = await db.selectFrom('p2p_circles').select('p2p_circles.id').where('p2p_circles.id', 'in', circleIDs).where('p2p_circles.removed_at_hlc', 'is', null).where((eb)=>circleAccessPredicate(eb, normalized)).limit(1).executeTakeFirst();
             return row != null;
         },
         // Same predicate as `isMemberOfAnyCircle`, projecting the matching rows
@@ -155,10 +155,10 @@ export function createCircleOps(db, adapter) {
         async listAccessibleCircles (memberDID, circleIDs) {
             if (circleIDs.length === 0) return [];
             const normalized = normalizeDID(memberDID);
-            const rows = await db.selectFrom('kubun_p2p_circles').select([
-                'kubun_p2p_circles.id',
-                'kubun_p2p_circles.group_id'
-            ]).where('kubun_p2p_circles.id', 'in', circleIDs).where('kubun_p2p_circles.removed_at_hlc', 'is', null).where((eb)=>circleAccessPredicate(eb, normalized)).execute();
+            const rows = await db.selectFrom('p2p_circles').select([
+                'p2p_circles.id',
+                'p2p_circles.group_id'
+            ]).where('p2p_circles.id', 'in', circleIDs).where('p2p_circles.removed_at_hlc', 'is', null).where((eb)=>circleAccessPredicate(eb, normalized)).execute();
             return rows.map((row)=>({
                     id: row.id,
                     groupID: row.group_id
@@ -172,15 +172,15 @@ export function createCircleOps(db, adapter) {
             // The explicit rows and the circle row are independent, so both go out at
             // once; only the group read depends on what the circle says.
             const [explicit, circle] = await Promise.all([
-                db.selectFrom('kubun_p2p_circle_members').select('member_did').where('circle_id', '=', circleID).where('removed_at_hlc', 'is', null).execute(),
-                db.selectFrom('kubun_p2p_circles').select([
+                db.selectFrom('p2p_circle_members').select('member_did').where('circle_id', '=', circleID).where('removed_at_hlc', 'is', null).execute(),
+                db.selectFrom('p2p_circles').select([
                     'group_id',
                     'open'
                 ]).where('id', '=', circleID).where('removed_at_hlc', 'is', null).executeTakeFirst()
             ]);
             const owners = new Set(explicit.map((row)=>row.member_did));
             if (circle != null && circle.open === 1) {
-                const groupMembers = await db.selectFrom('kubun_p2p_group_members').select('member_did').where('group_id', '=', circle.group_id).where('removed_at_hlc', 'is', null).execute();
+                const groupMembers = await db.selectFrom('p2p_group_members').select('member_did').where('group_id', '=', circle.group_id).where('removed_at_hlc', 'is', null).execute();
                 for (const row of groupMembers){
                     owners.add(row.member_did);
                 }
@@ -196,13 +196,13 @@ export function createCircleOps(db, adapter) {
             // First two are independent and go out together; the third needs the open
             // circles' groups, so it waits.
             const [explicit, openCircles] = await Promise.all([
-                db.selectFrom('kubun_p2p_circle_members').select('member_did').where('circle_id', 'in', circleIDs).where('removed_at_hlc', 'is', null).execute(),
-                db.selectFrom('kubun_p2p_circles').select('group_id').where('id', 'in', circleIDs).where('removed_at_hlc', 'is', null).where('open', '=', 1).execute()
+                db.selectFrom('p2p_circle_members').select('member_did').where('circle_id', 'in', circleIDs).where('removed_at_hlc', 'is', null).execute(),
+                db.selectFrom('p2p_circles').select('group_id').where('id', 'in', circleIDs).where('removed_at_hlc', 'is', null).where('open', '=', 1).execute()
             ]);
             const owners = new Set(explicit.map((row)=>row.member_did));
             const groupIDs = Array.from(new Set(openCircles.map((row)=>row.group_id)));
             if (groupIDs.length > 0) {
-                const groupMembers = await db.selectFrom('kubun_p2p_group_members').select('member_did').where('group_id', 'in', groupIDs).where('removed_at_hlc', 'is', null).execute();
+                const groupMembers = await db.selectFrom('p2p_group_members').select('member_did').where('group_id', 'in', groupIDs).where('removed_at_hlc', 'is', null).execute();
                 for (const row of groupMembers){
                     owners.add(row.member_did);
                 }
@@ -216,12 +216,12 @@ export function createCircleOps(db, adapter) {
         async reconcileCircleOpenFlags (groupID, openCircleIDs) {
             const now = adapter.encodeTimestamp(new Date());
             if (openCircleIDs.length > 0) {
-                await db.updateTable('kubun_p2p_circles').set({
+                await db.updateTable('p2p_circles').set({
                     open: 1,
                     updated_at: now
                 }).where('group_id', '=', groupID).where('id', 'in', openCircleIDs).where('open', '<>', 1).execute();
             }
-            let closeQuery = db.updateTable('kubun_p2p_circles').set({
+            let closeQuery = db.updateTable('p2p_circles').set({
                 open: 0,
                 updated_at: now
             }).where('group_id', '=', groupID).where('open', '<>', 0);
@@ -236,7 +236,7 @@ export function createCircleOps(db, adapter) {
         // resolved the winner via the ledger fold, so the store write must not
         // re-arbitrate.
         async reconcileCircleProjection (params) {
-            await db.insertInto('kubun_p2p_circles').values({
+            await db.insertInto('p2p_circles').values({
                 id: params.id,
                 group_id: params.groupID,
                 name: params.name,
@@ -259,10 +259,10 @@ export function createCircleOps(db, adapter) {
                         'hlc',
                         'removed_at_hlc',
                         'open'
-                    ].map((column)=>differs('kubun_p2p_circles', column))))).execute();
+                    ].map((column)=>differs('p2p_circles', column))))).execute();
         },
         async reconcileCircleMemberProjection (params) {
-            await db.insertInto('kubun_p2p_circle_members').values({
+            await db.insertInto('p2p_circle_members').values({
                 circle_id: params.circleID,
                 member_did: normalizeDID(params.memberDID),
                 role: params.role,
@@ -280,7 +280,7 @@ export function createCircleOps(db, adapter) {
                         'role',
                         'hlc',
                         'removed_at_hlc'
-                    ].map((column)=>differs('kubun_p2p_circle_members', column))))).execute();
+                    ].map((column)=>differs('p2p_circle_members', column))))).execute();
         }
     };
 }

package/lib/ops/control.d.ts

@@ -1,4 +1,4 @@
-import type { Adapter } from '@kubun/db-adapter';
+import { type Adapter } from '@kubun/db-adapter';
 import type { Kysely } from 'kysely';
 import type { CommitJournalEntry, ControlRequest, P2PStoreTables } from '../tables.js';
 export type ControlRequestKind = 'ledger' | 'invite' | 'remove';

package/lib/ops/control.js

@@ -1,7 +1,8 @@
+import { decodeJSON } from '@kubun/db-adapter';
 export function createControlOps(db, adapter) {
     return {
         async enqueueControlRequest (params) {
-            await db.insertInto('kubun_p2p_control_requests').values({
+            await db.insertInto('p2p_control_requests').values({
                 id: params.id,
                 group_id: params.groupID,
                 kind: params.kind,
@@ -9,7 +10,7 @@ export function createControlOps(db, adapter) {
             }).execute();
         },
         async getControlRequest (id) {
-            return await db.selectFrom('kubun_p2p_control_requests').selectAll().where('id', '=', id).executeTakeFirst();
+            return await db.selectFrom('p2p_control_requests').selectAll().where('id', '=', id).executeTakeFirst();
         },
         // Every row still in the table is either `pending` or a settled row the
         // client has not acked yet — no status filter is needed beyond the optional
@@ -18,7 +19,7 @@ export function createControlOps(db, adapter) {
             // `enqueued_at` is a caller-supplied string, so equal stamps are routine —
             // two requests enqueued in one transaction share one. The id breaks the tie
             // so a page is a stable order rather than the storage engine's whim.
-            let query = db.selectFrom('kubun_p2p_control_requests').selectAll().orderBy('enqueued_at').orderBy('id');
+            let query = db.selectFrom('p2p_control_requests').selectAll().orderBy('enqueued_at').orderBy('id');
             if (groupID != null) {
                 query = query.where('group_id', '=', groupID);
             }
@@ -47,7 +48,7 @@ export function createControlOps(db, adapter) {
             if (params.result !== undefined) {
                 update.result = params.result;
             }
-            await db.updateTable('kubun_p2p_control_requests').set(update)// The terminal-state guard, in the WHERE so it is decided by the same
+            await db.updateTable('p2p_control_requests').set(update)// The terminal-state guard, in the WHERE so it is decided by the same
             // statement that writes: only a `pending` row, or a re-settle to the
             // outcome already stored, matches. A different outcome over a terminal
             // row matches nothing and the settle is silently dropped — the stored
@@ -59,13 +60,13 @@ export function createControlOps(db, adapter) {
                 ])).execute();
         },
         async getControlRequestResult (id) {
-            const row = await db.selectFrom('kubun_p2p_control_requests').select('result').where('id', '=', id).executeTakeFirst();
+            const row = await db.selectFrom('p2p_control_requests').select('result').where('id', '=', id).executeTakeFirst();
             return row?.result ?? null;
         },
         // Only a settled row is deleted; a `pending` row (or an already-absent id)
         // matches no row and the delete is a silent no-op.
         async ackControlRequest (id) {
-            await db.deleteFrom('kubun_p2p_control_requests').where('id', '=', id).where('status', '!=', 'pending').execute();
+            await db.deleteFrom('p2p_control_requests').where('id', '=', id).where('status', '!=', 'pending').execute();
         },
         // --- Commit journal operations ---
         async putCommitJournalEntry (params) {
@@ -81,7 +82,7 @@ export function createControlOps(db, adapter) {
                 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,
+            await db.insertInto('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
             // commit's acceptance) — never a merge.
             .onConflict((oc)=>oc.column('group_id').doUpdateSet((eb)=>({
@@ -97,23 +98,24 @@ export function createControlOps(db, adapter) {
                     }))).execute();
         },
         async getCommitJournalEntry (groupID) {
-            const row = await db.selectFrom('kubun_p2p_commit_journal').selectAll().where('group_id', '=', groupID).executeTakeFirst();
+            const row = await db.selectFrom('p2p_commit_journal').selectAll().where('group_id', '=', groupID).executeTakeFirst();
             return row == null ? undefined : {
                 ...row,
+                bodies: decodeJSON(adapter.kind, row.bodies),
                 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.
         async markCommitJournalAccepted (params) {
-            await db.updateTable('kubun_p2p_commit_journal').set({
+            await db.updateTable('p2p_commit_journal').set({
                 accepted_as: params.sequenceID
             }).where('group_id', '=', params.groupID).where('publish_id', '=', params.publishID).execute();
         },
         // A no-op if the slot no longer holds `publishID` — never deletes a
         // different pending commit.
         async clearCommitJournalEntry (params) {
-            await db.deleteFrom('kubun_p2p_commit_journal').where('group_id', '=', params.groupID).where('publish_id', '=', params.publishID).execute();
+            await db.deleteFrom('p2p_commit_journal').where('group_id', '=', params.groupID).where('publish_id', '=', params.publishID).execute();
         }
     };
 }

package/lib/ops/delegations.d.ts

@@ -1,3 +1,4 @@
+import type { StoreAPIContext } from '@kubun/db';
 import type { Kysely } from 'kysely';
 import type { InsertGroupDelegation, P2PStoreTables } from '../tables.js';
 /** The `jti` -> group edges the p2p layer keeps for delegation tokens. */
@@ -53,4 +54,4 @@ export type DelegationOps = {
      */
     getGroupIDsByJTIs(jtis: Array<string>): Promise<Map<string, string>>;
 };
-export declare function createDelegationOps(db: Kysely<P2PStoreTables>): DelegationOps;
+export declare function createDelegationOps(db: Kysely<P2PStoreTables>, context: StoreAPIContext): DelegationOps;

package/lib/ops/delegations.js

@@ -1,21 +1,20 @@
 import { encodeMultibase, multihashSHA256 } from '@kokuin/token';
-export function createDelegationOps(db) {
+import { withAppOutboxLock } from './app-outbox.js';
+export function createDelegationOps(db, context) {
     const lockJoinedGroup = async (tx, groupID)=>{
-        await tx.insertInto('kubun_p2p_app_outbox_state').values({
+        // Pending admission retains a state row before an encryption key exists.
+        await tx.insertInto('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();
+        }).onConflict((oc)=>oc.column('group_id').doNothing()).execute();
+        const group = await tx.selectFrom('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));
+            return await withAppOutboxLock(context, groupID, (tx)=>lockJoinedGroup(tx, groupID));
         },
         async addGroupDelegation (edge) {
-            await db.insertInto('kubun_p2p_group_delegation').values({
+            await db.insertInto('p2p_group_delegation').values({
                 group_id: edge.group_id,
                 jti: edge.jti
             }).onConflict((oc)=>oc.column('jti').doNothing()).execute();
@@ -25,7 +24,7 @@ export function createDelegationOps(db) {
                 // 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' ? {
+                await tx.updateTable('p2p_group_delegation').set(params.kind === 'grant' ? {
                     pending_grant_hlc: params.hlc,
                     pending_grant_digest: digest
                 } : {
@@ -33,32 +32,26 @@ export function createDelegationOps(db) {
                     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);
+            await withAppOutboxLock(context, params.groupID, 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();
+            const row = await db.selectFrom('p2p_group_delegation as delegation').innerJoin('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([
+            return await db.selectFrom('p2p_group_delegation as delegation').innerJoin('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' ? {
+                await tx.updateTable('p2p_group_delegation').set(params.kind === 'grant' ? {
                     pending_grant_hlc: null,
                     pending_grant_digest: null
                 } : {
@@ -66,11 +59,10 @@ export function createDelegationOps(db) {
                     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);
+            await withAppOutboxLock(context, params.groupID, clear);
         },
         async clearPendingDelegations (groupID) {
-            await db.updateTable('kubun_p2p_group_delegation').set({
+            await db.updateTable('p2p_group_delegation').set({
                 pending_grant_hlc: null,
                 pending_grant_digest: null,
                 pending_revocation_hlc: null,
@@ -78,14 +70,14 @@ export function createDelegationOps(db) {
             }).where('group_id', '=', groupID).execute();
         },
         async getGroupIDByJTI (jti) {
-            const row = await db.selectFrom('kubun_p2p_group_delegation').select('group_id').where('jti', '=', jti).executeTakeFirst();
+            const row = await db.selectFrom('p2p_group_delegation').select('group_id').where('jti', '=', jti).executeTakeFirst();
             return row?.group_id ?? null;
         },
         async getGroupIDsByJTIs (jtis) {
             if (jtis.length === 0) {
                 return new Map();
             }
-            const rows = await db.selectFrom('kubun_p2p_group_delegation').select([
+            const rows = await db.selectFrom('p2p_group_delegation').select([
                 'jti',
                 'group_id'
             ]).where('jti', 'in', jtis).execute();

package/lib/ops/discovery.d.ts

@@ -1,4 +1,4 @@
-import type { Adapter } from '@kubun/db-adapter';
+import { type Adapter } from '@kubun/db-adapter';
 import type { Kysely } from 'kysely';
 import type { LocalPeerProfile, P2PStoreTables, PeerAnnouncement, PeerCapabilityRecord, PendingJoinRequestRow } from '../tables.js';
 export type PutPendingJoinRequestParams = {

package/lib/ops/discovery.js

@@ -1,4 +1,5 @@
 import { normalizeDID } from '@kokuin/token';
+import { decodeJSON } from '@kubun/db-adapter';
 /**
  * How long a prepared join request stays usable. The exchange it belongs to is a
  * human round-trip — a payload pasted into a message, answered whenever the other
@@ -26,7 +27,7 @@ export function createDiscoveryOps(db, adapter) {
                 announced_at: adapter.encodeTimestamp(new Date()),
                 announced_epoch: params.epoch
             };
-            await db.insertInto('kubun_p2p_peer_announcements').values(values).onConflict((oc)=>oc.columns([
+            await db.insertInto('p2p_peer_announcements').values(values).onConflict((oc)=>oc.columns([
                     'group_id',
                     'peer_did'
                 ]).doUpdateSet((eb)=>({
@@ -39,16 +40,24 @@ export function createDiscoveryOps(db, adapter) {
                     }))).execute();
         },
         async getPeerAnnouncement (params) {
-            return await db.selectFrom('kubun_p2p_peer_announcements').selectAll().where('group_id', '=', params.groupID).where('peer_did', '=', normalizeDID(params.peerDID)).executeTakeFirst();
+            const row = await db.selectFrom('p2p_peer_announcements').selectAll().where('group_id', '=', params.groupID).where('peer_did', '=', normalizeDID(params.peerDID)).executeTakeFirst();
+            return row == null ? undefined : {
+                ...row,
+                capabilities: decodeJSON(adapter.kind, row.capabilities)
+            };
         },
         async listPeerAnnouncements (groupID) {
-            return await db.selectFrom('kubun_p2p_peer_announcements').selectAll().where('group_id', '=', groupID).orderBy('peer_did').execute();
+            const rows = await db.selectFrom('p2p_peer_announcements').selectAll().where('group_id', '=', groupID).orderBy('peer_did').execute();
+            return rows.map((row)=>({
+                    ...row,
+                    capabilities: decodeJSON(adapter.kind, row.capabilities)
+                }));
         },
         async deletePeerAnnouncements (params) {
             if (params.peerDIDs.length === 0) {
                 return;
             }
-            await db.deleteFrom('kubun_p2p_peer_announcements').where('group_id', '=', params.groupID).where('peer_did', 'in', params.peerDIDs.map(normalizeDID)).execute();
+            await db.deleteFrom('p2p_peer_announcements').where('group_id', '=', params.groupID).where('peer_did', 'in', params.peerDIDs.map(normalizeDID)).execute();
         },
         async setLocalPeerProfile (params) {
             const values = {
@@ -58,7 +67,7 @@ export function createDiscoveryOps(db, adapter) {
                 capabilities: adapter.encodeJSON(params.capabilities),
                 updated_at: adapter.encodeTimestamp(new Date())
             };
-            await db.insertInto('kubun_p2p_local_peer_profile').values(values).onConflict((oc)=>oc.column('peer_did').doUpdateSet((eb)=>({
+            await db.insertInto('p2p_local_peer_profile').values(values).onConflict((oc)=>oc.column('peer_did').doUpdateSet((eb)=>({
                         label: eb.ref('excluded.label'),
                         availability: eb.ref('excluded.availability'),
                         capabilities: eb.ref('excluded.capabilities'),
@@ -66,25 +75,29 @@ export function createDiscoveryOps(db, adapter) {
                     }))).execute();
         },
         async getLocalPeerProfile (peerDID) {
-            return await db.selectFrom('kubun_p2p_local_peer_profile').selectAll().where('peer_did', '=', normalizeDID(peerDID)).executeTakeFirst();
+            const row = await db.selectFrom('p2p_local_peer_profile').selectAll().where('peer_did', '=', normalizeDID(peerDID)).executeTakeFirst();
+            return row == null ? undefined : {
+                ...row,
+                capabilities: decodeJSON(adapter.kind, row.capabilities)
+            };
         },
         async putPendingJoinRequest (params) {
             // Swept on write rather than on a timer: preparing a request is the only
             // moment this table grows, so it is the only moment it needs collecting.
-            await db.deleteFrom('kubun_p2p_pending_join_requests').where('created_at', '<', expiredBefore(adapter)).execute();
+            await db.deleteFrom('p2p_pending_join_requests').where('created_at', '<', expiredBefore(adapter)).execute();
             const values = {
                 did: normalizeDID(params.did),
                 payload: params.payload
             };
-            await db.insertInto('kubun_p2p_pending_join_requests').values(values).onConflict((oc)=>oc.column('did').doUpdateSet((eb)=>({
+            await db.insertInto('p2p_pending_join_requests').values(values).onConflict((oc)=>oc.column('did').doUpdateSet((eb)=>({
                         payload: eb.ref('excluded.payload')
                     }))).execute();
         },
         async getPendingJoinRequest (did) {
-            return await db.selectFrom('kubun_p2p_pending_join_requests').selectAll().where('did', '=', normalizeDID(did)).where('created_at', '>=', expiredBefore(adapter)).executeTakeFirst();
+            return await db.selectFrom('p2p_pending_join_requests').selectAll().where('did', '=', normalizeDID(did)).where('created_at', '>=', expiredBefore(adapter)).executeTakeFirst();
         },
         async deletePendingJoinRequest (did) {
-            await db.deleteFrom('kubun_p2p_pending_join_requests').where('did', '=', normalizeDID(did)).execute();
+            await db.deleteFrom('p2p_pending_join_requests').where('did', '=', normalizeDID(did)).execute();
         }
     };
 }

package/lib/ops/document-sweep.js

@@ -2,15 +2,15 @@ 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'
+                'p2p_document_repair_answers',
+                'p2p_document_repairs',
+                'p2p_observation_repair_peers',
+                '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();
+            await db.deleteFrom('p2p_broadcast_log').where('doc_id', '=', documentID).execute();
         }
     };
 }

package/lib/ops/groups.d.ts

@@ -1,3 +1,4 @@
+import type { StoreAPIContext } from '@kubun/db';
 import { type Adapter } from '@kubun/db-adapter';
 import type { Kysely } from 'kysely';
 import type { Group, GroupMember, GroupStatus, InsertGroup, InsertGroupMember, P2PStoreTables, PaginatedResult, PaginationParams } from '../tables.js';
@@ -159,7 +160,7 @@ export type GroupOps = {
      * "any".
      *
      * Reads the membership rows ONLY. Not interchangeable with
-     * {@link getGroupsForMember}, which inner-joins `kubun_p2p_groups` and so
+     * {@link getGroupsForMember}, which inner-joins `p2p_groups` and so
      * answers false for a membership whose group row this device does not hold —
      * an authorization gate must not deny on that.
      */
@@ -177,4 +178,4 @@ export type GroupOps = {
      */
     getGroupsForMembers(memberDIDs: Array<string>): Promise<Map<string, Array<Group>>>;
 };
-export declare function createGroupOps(db: Kysely<P2PStoreTables>, adapter: Adapter): GroupOps;
+export declare function createGroupOps(db: Kysely<P2PStoreTables>, adapter: Adapter, context: StoreAPIContext): GroupOps;