@kubun/store-p2p 0.19.0 → 0.20.0

package/lib/ops/groups.js

@@ -1,10 +1,10 @@
 import { normalizeDID } from '@kokuin/token';
 import { chunked } from '@kubun/db-adapter';
-import { clearAppOutboxRows, lockAppOutboxForErasure } from './app-outbox.js';
-export function createGroupOps(db, adapter) {
+import { clearAppOutboxRows, lockAppOutboxForErasure, withAppOutboxLock } from './app-outbox.js';
+export function createGroupOps(db, adapter, context) {
     const ops = {
         async createGroup (group) {
-            await db.insertInto('kubun_p2p_groups').values({
+            await db.insertInto('p2p_groups').values({
                 id: group.id,
                 name: group.name,
                 description: group.description,
@@ -13,7 +13,7 @@ export function createGroupOps(db, adapter) {
             }).execute();
         },
         async getGroup (id) {
-            return await db.selectFrom('kubun_p2p_groups').selectAll().where('id', '=', id).executeTakeFirst();
+            return await db.selectFrom('p2p_groups').selectAll().where('id', '=', id).executeTakeFirst();
         },
         async updateGroup (id, update) {
             const values = {};
@@ -22,7 +22,7 @@ export function createGroupOps(db, adapter) {
             if (update.hlc != null) values.hlc = update.hlc;
             const changed = Object.entries(values);
             values.updated_at = adapter.encodeTimestamp(new Date());
-            let query = db.updateTable('kubun_p2p_groups').set(values).where('id', '=', id);
+            let query = db.updateTable('p2p_groups').set(values).where('id', '=', id);
             // Rewriting the values a row already holds is not a change: a reproject
             // that agrees with the stored row leaves it, `updated_at` included, alone.
             if (changed.length > 0) {
@@ -31,25 +31,25 @@ export function createGroupOps(db, adapter) {
             await query.execute();
         },
         async markGroupProjectionsDirty (id, token) {
-            await db.updateTable('kubun_p2p_groups').set({
+            await db.updateTable('p2p_groups').set({
                 projections_dirty: token
             }).where('id', '=', id).execute();
         },
         async clearGroupProjectionsDirty (id, token, epoch) {
-            const result = await db.updateTable('kubun_p2p_groups').set({
+            const result = await db.updateTable('p2p_groups').set({
                 projections_dirty: null,
                 projections_epoch: epoch
             }).where('id', '=', id).where('projections_dirty', token == null ? 'is' : '=', token).executeTakeFirst();
             return (result.numUpdatedRows ?? 0n) > 0n;
         },
         async getGroupLeaveRequestHLC (groupID, memberDID) {
-            const row = await db.selectFrom('kubun_p2p_group_leave_requests').select('hlc').where('group_id', '=', groupID).where('member_did', '=', normalizeDID(memberDID)).executeTakeFirst();
+            const row = await db.selectFrom('p2p_group_leave_requests').select('hlc').where('group_id', '=', groupID).where('member_did', '=', normalizeDID(memberDID)).executeTakeFirst();
             return row?.hlc;
         },
         async swapGroupLeaveRequestHLC (params) {
             const memberDID = normalizeDID(params.memberDID);
             if (params.expected == null) {
-                const inserted = await db.insertInto('kubun_p2p_group_leave_requests').values({
+                const inserted = await db.insertInto('p2p_group_leave_requests').values({
                     group_id: params.groupID,
                     member_did: memberDID,
                     hlc: params.hlc
@@ -59,7 +59,7 @@ export function createGroupOps(db, adapter) {
                     ]).doNothing()).executeTakeFirst();
                 return (inserted.numInsertedOrUpdatedRows ?? 0n) > 0n;
             }
-            const updated = await db.updateTable('kubun_p2p_group_leave_requests').set({
+            const updated = await db.updateTable('p2p_group_leave_requests').set({
                 hlc: params.hlc
             }).where('group_id', '=', params.groupID).where('member_did', '=', memberDID).where('hlc', '=', params.expected).executeTakeFirst();
             return (updated.numUpdatedRows ?? 0n) > 0n;
@@ -67,24 +67,23 @@ export function createGroupOps(db, adapter) {
         async deleteGroup (id) {
             const remove = async (trx)=>{
                 await clearAppOutboxRows(trx, id);
-                await trx.deleteFrom('kubun_p2p_log_handler_completion').where('group_id', '=', id).execute();
-                await trx.deleteFrom('kubun_p2p_catalog_offers').where('group_id', '=', id).execute();
-                await trx.deleteFrom('kubun_p2p_catalog_routes').where('group_id', '=', id).execute();
-                await trx.deleteFrom('kubun_p2p_groups').where('id', '=', id).execute();
+                await trx.deleteFrom('p2p_log_handler_completion').where('group_id', '=', id).execute();
+                await trx.deleteFrom('p2p_catalog_offers').where('group_id', '=', id).execute();
+                await trx.deleteFrom('p2p_catalog_routes').where('group_id', '=', id).execute();
+                await trx.deleteFrom('p2p_groups').where('id', '=', id).execute();
             };
             // A caller already inside a provider transaction owns atomicity; opening
             // a nested one is unsupported.
-            if (db.isTransaction) await remove(db);
-            else await db.transaction().execute(remove);
+            await withAppOutboxLock(context, id, remove);
         },
         async listGroups () {
-            return await db.selectFrom('kubun_p2p_groups').selectAll().where('status', '=', 'joined').execute();
+            return await db.selectFrom('p2p_groups').selectAll().where('status', '=', 'joined').execute();
         },
         async listLeavingGroups () {
-            return await db.selectFrom('kubun_p2p_groups').selectAll().where('status', '=', 'leaving').execute();
+            return await db.selectFrom('p2p_groups').selectAll().where('status', '=', 'leaving').execute();
         },
         async listAllGroups () {
-            return await db.selectFrom('kubun_p2p_groups').selectAll().execute();
+            return await db.selectFrom('p2p_groups').selectAll().execute();
         },
         async setGroupStatus (id, status, options) {
             const update = async (tx)=>{
@@ -94,19 +93,18 @@ export function createGroupOps(db, adapter) {
                 }
                 if (status === 'left') {
                     cleared = await clearAppOutboxRows(tx, id, options);
-                    await tx.deleteFrom('kubun_p2p_log_handler_completion').where('group_id', '=', id).execute();
+                    await tx.deleteFrom('p2p_log_handler_completion').where('group_id', '=', id).execute();
                 }
-                await tx.updateTable('kubun_p2p_groups').set({
+                await tx.updateTable('p2p_groups').set({
                     status
                 }).where('id', '=', id).execute();
                 return cleared;
             };
-            if (db.isTransaction) return await update(db);
-            return await db.transaction().execute(update);
+            return await withAppOutboxLock(context, id, update);
         },
         async listGroupsOffsetPaged (params) {
             const { limit, offset } = params;
-            let query = db.selectFrom('kubun_p2p_groups').selectAll().where('status', '=', 'joined').orderBy('name');
+            let query = db.selectFrom('p2p_groups').selectAll().where('status', '=', 'joined').orderBy('name');
             if (offset != null) {
                 query = query.offset(offset);
             }
@@ -127,7 +125,7 @@ export function createGroupOps(db, adapter) {
         },
         // --- Group member operations ---
         async addGroupMember (member) {
-            const row = await db.insertInto('kubun_p2p_group_members').values({
+            const row = await db.insertInto('p2p_group_members').values({
                 group_id: member.group_id,
                 member_did: normalizeDID(member.member_did),
                 role: member.role,
@@ -142,10 +140,10 @@ export function createGroupOps(db, adapter) {
                         updated_at: adapter.encodeTimestamp(new Date())
                     })).where((eb)=>eb.or([
                         eb.and([
-                            eb('kubun_p2p_group_members.removed_at_hlc', 'is', null),
-                            eb('kubun_p2p_group_members.hlc', '<', eb.ref('excluded.hlc'))
+                            eb('p2p_group_members.removed_at_hlc', 'is', null),
+                            eb('p2p_group_members.hlc', '<', eb.ref('excluded.hlc'))
                         ]),
-                        eb('kubun_p2p_group_members.removed_at_hlc', '<', eb.ref('excluded.hlc'))
+                        eb('p2p_group_members.removed_at_hlc', '<', eb.ref('excluded.hlc'))
                     ]))).returning('member_did').executeTakeFirst();
             return row != null;
         },
@@ -153,7 +151,7 @@ export function createGroupOps(db, adapter) {
             if (members.length === 0) {
                 return new Set();
             }
-            const rows = await db.insertInto('kubun_p2p_group_members').values(members.map((member)=>({
+            const rows = await db.insertInto('p2p_group_members').values(members.map((member)=>({
                     group_id: member.group_id,
                     member_did: normalizeDID(member.member_did),
                     role: member.role,
@@ -168,15 +166,15 @@ export function createGroupOps(db, adapter) {
                         updated_at: adapter.encodeTimestamp(new Date())
                     })).where((eb)=>eb.or([
                         eb.and([
-                            eb('kubun_p2p_group_members.removed_at_hlc', 'is', null),
-                            eb('kubun_p2p_group_members.hlc', '<', eb.ref('excluded.hlc'))
+                            eb('p2p_group_members.removed_at_hlc', 'is', null),
+                            eb('p2p_group_members.hlc', '<', eb.ref('excluded.hlc'))
                         ]),
-                        eb('kubun_p2p_group_members.removed_at_hlc', '<', eb.ref('excluded.hlc'))
+                        eb('p2p_group_members.removed_at_hlc', '<', eb.ref('excluded.hlc'))
                     ]))).returning('member_did').execute();
             return new Set(rows.map((row)=>row.member_did));
         },
         async markMemberRemoved (groupID, memberDID, hlc) {
-            const row = await db.updateTable('kubun_p2p_group_members').set({
+            const row = await db.updateTable('p2p_group_members').set({
                 removed_at_hlc: hlc,
                 updated_at: adapter.encodeTimestamp(new Date())
             }).where('group_id', '=', groupID).where('member_did', '=', normalizeDID(memberDID)).where('removed_at_hlc', 'is', null).where('hlc', '<', hlc).returning('member_did').executeTakeFirst();
@@ -186,7 +184,7 @@ export function createGroupOps(db, adapter) {
             if (memberDIDs.length === 0) {
                 return new Set();
             }
-            const rows = await db.updateTable('kubun_p2p_group_members').set({
+            const rows = await db.updateTable('p2p_group_members').set({
                 removed_at_hlc: hlc,
                 updated_at: adapter.encodeTimestamp(new Date())
             }).where('group_id', '=', groupID).where('member_did', 'in', memberDIDs.map(normalizeDID)).where('removed_at_hlc', 'is', null).where('hlc', '<', hlc).returning('member_did').execute();
@@ -194,14 +192,14 @@ export function createGroupOps(db, adapter) {
         },
         async listGroupMembershipStamps (groupID, memberDIDs) {
             if (memberDIDs.length === 0) return [];
-            return await db.selectFrom('kubun_p2p_group_members').select([
+            return await db.selectFrom('p2p_group_members').select([
                 'member_did',
                 'hlc',
                 'removed_at_hlc'
             ]).where('group_id', '=', groupID).where('member_did', 'in', memberDIDs.map(normalizeDID)).execute();
         },
         async getMemberRemoval (groupID, memberDID) {
-            const row = await db.selectFrom('kubun_p2p_group_members').select('removed_at_hlc').where('group_id', '=', groupID).where('member_did', '=', normalizeDID(memberDID)).executeTakeFirst();
+            const row = await db.selectFrom('p2p_group_members').select('removed_at_hlc').where('group_id', '=', groupID).where('member_did', '=', normalizeDID(memberDID)).executeTakeFirst();
             return row == null ? undefined : {
                 removed_at_hlc: row.removed_at_hlc
             };
@@ -213,7 +211,7 @@ export function createGroupOps(db, adapter) {
             ];
             const memberDID = normalizeDID(params.memberDID);
             for (const chunk of chunked(groupIDs)){
-                const rows = await db.selectFrom('kubun_p2p_group_members').select([
+                const rows = await db.selectFrom('p2p_group_members').select([
                     'group_id',
                     'removed_at_hlc'
                 ]).where('group_id', 'in', chunk).where('member_did', '=', memberDID).execute();
@@ -227,14 +225,14 @@ export function createGroupOps(db, adapter) {
             return await ops.markMemberRemoved(groupID, memberDID, hlc);
         },
         async getGroupMember (groupID, memberDID) {
-            return await db.selectFrom('kubun_p2p_group_members').selectAll().where('group_id', '=', groupID).where('member_did', '=', normalizeDID(memberDID)).where('removed_at_hlc', 'is', null).executeTakeFirst();
+            return await db.selectFrom('p2p_group_members').selectAll().where('group_id', '=', groupID).where('member_did', '=', normalizeDID(memberDID)).where('removed_at_hlc', 'is', null).executeTakeFirst();
         },
         async isGroupMember (groupID, memberDID) {
-            const row = await db.selectFrom('kubun_p2p_group_members').select('member_did').where('group_id', '=', groupID).where('member_did', '=', normalizeDID(memberDID)).where('removed_at_hlc', 'is', null).executeTakeFirst();
+            const row = await db.selectFrom('p2p_group_members').select('member_did').where('group_id', '=', groupID).where('member_did', '=', normalizeDID(memberDID)).where('removed_at_hlc', 'is', null).executeTakeFirst();
             return row != null;
         },
         async isGroupMemberAtHLC (groupID, did, atHLC) {
-            let query = db.selectFrom('kubun_p2p_group_members').select('member_did').where('group_id', '=', groupID).where('member_did', '=', normalizeDID(did));
+            let query = db.selectFrom('p2p_group_members').select('member_did').where('group_id', '=', groupID).where('member_did', '=', normalizeDID(did));
             if (atHLC == null) {
                 query = query.where('removed_at_hlc', 'is', null);
             } else {
@@ -247,7 +245,7 @@ export function createGroupOps(db, adapter) {
             return row != null;
         },
         async isGroupAdmin (groupID, did, atHLC) {
-            let query = db.selectFrom('kubun_p2p_group_members').select('member_did').where('group_id', '=', groupID).where('member_did', '=', normalizeDID(did)).where('role', '=', 'admin');
+            let query = db.selectFrom('p2p_group_members').select('member_did').where('group_id', '=', groupID).where('member_did', '=', normalizeDID(did)).where('role', '=', 'admin');
             if (atHLC == null) {
                 query = query.where('removed_at_hlc', 'is', null);
             } else {
@@ -266,7 +264,7 @@ export function createGroupOps(db, adapter) {
             // Update-only by design: a missing row leaves the table untouched, so a
             // role grant can never conjure a phantom member. hlc/removed_at_hlc are
             // left alone to keep membership LWW and tombstones intact.
-            await db.updateTable('kubun_p2p_group_members').set({
+            await db.updateTable('p2p_group_members').set({
                 role,
                 updated_at: adapter.encodeTimestamp(new Date())
             }).where('group_id', '=', groupID).where('member_did', '=', normalizeDID(memberDID)).execute();
@@ -291,7 +289,7 @@ export function createGroupOps(db, adapter) {
             }
             const now = adapter.encodeTimestamp(new Date());
             for (const [role, dids] of didsByRole){
-                await db.updateTable('kubun_p2p_group_members').set({
+                await db.updateTable('p2p_group_members').set({
                     role,
                     updated_at: now
                 }).where('group_id', '=', groupID).where('member_did', 'in', dids).execute();
@@ -299,22 +297,22 @@ export function createGroupOps(db, adapter) {
         },
         async isMemberOfAnyGroup (viewerDID, groupIDs) {
             if (groupIDs.length === 0) return false;
-            const row = await db.selectFrom('kubun_p2p_group_members').select('group_id').where('member_did', '=', normalizeDID(viewerDID)).where('group_id', 'in', groupIDs).where('removed_at_hlc', 'is', null).limit(1).executeTakeFirst();
+            const row = await db.selectFrom('p2p_group_members').select('group_id').where('member_did', '=', normalizeDID(viewerDID)).where('group_id', 'in', groupIDs).where('removed_at_hlc', 'is', null).limit(1).executeTakeFirst();
             return row != null;
         },
         // Same predicate as `isGroupMember`, projecting the matching group ids rather
-        // than collapsing to one existence answer. No join to `kubun_p2p_groups` —
+        // than collapsing to one existence answer. No join to `p2p_groups` —
         // membership stands on its own row.
         async listMemberGroupIDs (memberDID, groupIDs) {
             if (groupIDs.length === 0) return [];
-            const rows = await db.selectFrom('kubun_p2p_group_members').select('group_id').where('member_did', '=', normalizeDID(memberDID)).where('group_id', 'in', groupIDs).where('removed_at_hlc', 'is', null).execute();
+            const rows = await db.selectFrom('p2p_group_members').select('group_id').where('member_did', '=', normalizeDID(memberDID)).where('group_id', 'in', groupIDs).where('removed_at_hlc', 'is', null).execute();
             return rows.map((row)=>row.group_id);
         },
         async listGroupMembers (groupID) {
-            return await db.selectFrom('kubun_p2p_group_members').selectAll().where('group_id', '=', groupID).where('removed_at_hlc', 'is', null).execute();
+            return await db.selectFrom('p2p_group_members').selectAll().where('group_id', '=', groupID).where('removed_at_hlc', 'is', null).execute();
         },
         async getGroupsForMember (memberDID) {
-            return await db.selectFrom('kubun_p2p_group_members').innerJoin('kubun_p2p_groups', 'kubun_p2p_groups.id', 'kubun_p2p_group_members.group_id').selectAll('kubun_p2p_groups').where('kubun_p2p_group_members.member_did', '=', normalizeDID(memberDID)).where('kubun_p2p_group_members.removed_at_hlc', 'is', null).execute();
+            return await db.selectFrom('p2p_group_members').innerJoin('p2p_groups', 'p2p_groups.id', 'p2p_group_members.group_id').selectAll('p2p_groups').where('p2p_group_members.member_did', '=', normalizeDID(memberDID)).where('p2p_group_members.removed_at_hlc', 'is', null).execute();
         },
         // Result Map is keyed by the normalized stored `member_did`; callers must
         // normalize before looking up by key (existing callers iterate `.values()`).
@@ -322,20 +320,20 @@ export function createGroupOps(db, adapter) {
             const result = new Map();
             if (memberDIDs.length === 0) return result;
             const normalizedDIDs = memberDIDs.map(normalizeDID);
-            const rows = await db.selectFrom('kubun_p2p_group_members').innerJoin('kubun_p2p_groups', 'kubun_p2p_groups.id', 'kubun_p2p_group_members.group_id').select([
-                'kubun_p2p_group_members.member_did as member_did',
-                'kubun_p2p_groups.id as id',
-                'kubun_p2p_groups.name as name',
-                'kubun_p2p_groups.description as description',
-                'kubun_p2p_groups.created_by as created_by',
-                'kubun_p2p_groups.status as status',
-                'kubun_p2p_groups.kind as kind',
-                'kubun_p2p_groups.projections_dirty as projections_dirty',
-                'kubun_p2p_groups.projections_epoch as projections_epoch',
-                'kubun_p2p_groups.hlc as hlc',
-                'kubun_p2p_groups.created_at as created_at',
-                'kubun_p2p_groups.updated_at as updated_at'
-            ]).where('kubun_p2p_group_members.member_did', 'in', normalizedDIDs).where('kubun_p2p_group_members.removed_at_hlc', 'is', null).execute();
+            const rows = await db.selectFrom('p2p_group_members').innerJoin('p2p_groups', 'p2p_groups.id', 'p2p_group_members.group_id').select([
+                'p2p_group_members.member_did as member_did',
+                'p2p_groups.id as id',
+                'p2p_groups.name as name',
+                'p2p_groups.description as description',
+                'p2p_groups.created_by as created_by',
+                'p2p_groups.status as status',
+                'p2p_groups.kind as kind',
+                'p2p_groups.projections_dirty as projections_dirty',
+                'p2p_groups.projections_epoch as projections_epoch',
+                'p2p_groups.hlc as hlc',
+                'p2p_groups.created_at as created_at',
+                'p2p_groups.updated_at as updated_at'
+            ]).where('p2p_group_members.member_did', 'in', normalizedDIDs).where('p2p_group_members.removed_at_hlc', 'is', null).execute();
             for (const row of rows){
                 const { member_did, ...group } = row;
                 const list = result.get(member_did);

package/lib/ops/hubs.js

@@ -1,26 +1,7 @@
+import { withStoreTransaction } from '@kubun/db';
 import { sql } from 'kysely';
 import { canonicalHubURL } from '../hub-url.js';
 import { COMMIT_HUB_UNIQUE_INDEX } from '../migrations.js';
-/**
- * Run `write` as a single atomic unit. The store API is built on whatever Kysely
- * instance the provider hands it, which is a transaction-scoped one whenever the
- * caller runs inside an ambient write transaction. Kysely rejects a nested
- * `transaction()` call, and the ambient transaction already provides the
- * atomicity, so in that case the statements run inline; otherwise a transaction
- * is opened around them.
- *
- * Multi-statement invariants (clear-then-set, read-then-insert) must go through
- * this: a crash between two independent statements can leave a group with no
- * commit hub at all, and a device with no commit hub cannot commit.
- */ async function writeAtomically(db, write) {
-    if (db.isTransaction) {
-        await write(db);
-        return;
-    }
-    await db.transaction().execute(async (tx)=>{
-        await write(tx);
-    });
-}
 /**
  * Run `run` so that a failed statement inside it can be caught and recovered
  * from. Postgres aborts the WHOLE transaction on any statement error, so a
@@ -60,13 +41,13 @@ import { COMMIT_HUB_UNIQUE_INDEX } from '../migrations.js';
  * row was actually inserted.
  */ async function bindGroupHub(db, binding, claimDesignation) {
     let inserted = false;
-    await writeAtomically(db, async (tx)=>{
+    await withStoreTransaction(db, async (tx)=>{
         let designate = false;
         if (claimDesignation) {
-            const existing = await tx.selectFrom('kubun_p2p_group_hubs').select('hub_id').where('group_id', '=', binding.group_id).where('is_commit_hub', '=', 1).executeTakeFirst();
+            const existing = await tx.selectFrom('p2p_group_hubs').select('hub_id').where('group_id', '=', binding.group_id).where('is_commit_hub', '=', 1).executeTakeFirst();
             designate = existing == null;
         }
-        const result = await tx.insertInto('kubun_p2p_group_hubs').values({
+        const result = await tx.insertInto('p2p_group_hubs').values({
             group_id: binding.group_id,
             hub_id: binding.hub_id,
             is_commit_hub: designate ? 1 : 0
@@ -81,7 +62,7 @@ import { COMMIT_HUB_UNIQUE_INDEX } from '../migrations.js';
 export function createHubOps(db, adapter) {
     return {
         async insertHub (hub) {
-            await db.insertInto('kubun_p2p_hubs').values({
+            await db.insertInto('p2p_hubs').values({
                 id: hub.id,
                 label: hub.label,
                 url: canonicalHubURL(hub.url),
@@ -89,10 +70,10 @@ export function createHubOps(db, adapter) {
             }).execute();
         },
         async getHub (id) {
-            return await db.selectFrom('kubun_p2p_hubs').selectAll().where('id', '=', id).executeTakeFirst();
+            return await db.selectFrom('p2p_hubs').selectAll().where('id', '=', id).executeTakeFirst();
         },
         async getHubByURL (url) {
-            return await db.selectFrom('kubun_p2p_hubs').selectAll().where('url', '=', canonicalHubURL(url)).executeTakeFirst();
+            return await db.selectFrom('p2p_hubs').selectAll().where('url', '=', canonicalHubURL(url)).executeTakeFirst();
         },
         async updateHub (id, update) {
             const values = {};
@@ -100,13 +81,13 @@ export function createHubOps(db, adapter) {
             if (update.url !== undefined) values.url = canonicalHubURL(update.url);
             if (update.server_did !== undefined) values.server_did = update.server_did;
             values.updated_at = adapter.encodeTimestamp(new Date());
-            await db.updateTable('kubun_p2p_hubs').set(values).where('id', '=', id).execute();
+            await db.updateTable('p2p_hubs').set(values).where('id', '=', id).execute();
         },
         async deleteHub (id) {
-            await db.deleteFrom('kubun_p2p_hubs').where('id', '=', id).execute();
+            await db.deleteFrom('p2p_hubs').where('id', '=', id).execute();
         },
         async listHubs () {
-            return await db.selectFrom('kubun_p2p_hubs').selectAll().execute();
+            return await db.selectFrom('p2p_hubs').selectAll().execute();
         },
         // --- Group-hub binding operations ---
         async insertGroupHub (binding) {
@@ -132,55 +113,55 @@ export function createHubOps(db, adapter) {
             }
         },
         async deleteGroupHub (params) {
-            const result = await db.deleteFrom('kubun_p2p_group_hubs').where('group_id', '=', params.groupID).where('hub_id', '=', params.hubID).executeTakeFirst();
+            const result = await db.deleteFrom('p2p_group_hubs').where('group_id', '=', params.groupID).where('hub_id', '=', params.hubID).executeTakeFirst();
             return (result.numDeletedRows ?? 0n) > 0n;
         },
         async listGroupIDsByHubID (hubID) {
-            const rows = await db.selectFrom('kubun_p2p_group_hubs').select('group_id').where('hub_id', '=', hubID).execute();
+            const rows = await db.selectFrom('p2p_group_hubs').select('group_id').where('hub_id', '=', hubID).execute();
             return rows.map((r)=>r.group_id);
         },
         async listHubsByGroupID (groupID) {
-            return await db.selectFrom('kubun_p2p_group_hubs').innerJoin('kubun_p2p_hubs', 'kubun_p2p_hubs.id', 'kubun_p2p_group_hubs.hub_id').selectAll('kubun_p2p_hubs').where('kubun_p2p_group_hubs.group_id', '=', groupID).execute();
+            return await db.selectFrom('p2p_group_hubs').innerJoin('p2p_hubs', 'p2p_hubs.id', 'p2p_group_hubs.hub_id').selectAll('p2p_hubs').where('p2p_group_hubs.group_id', '=', groupID).execute();
         },
         async listGroupsByHubID (hubID) {
-            const rows = await db.selectFrom('kubun_p2p_group_hubs').innerJoin('kubun_p2p_groups', 'kubun_p2p_groups.id', 'kubun_p2p_group_hubs.group_id').select([
-                'kubun_p2p_groups.id as id',
-                'kubun_p2p_groups.name as name',
-                'kubun_p2p_groups.description as description',
-                'kubun_p2p_groups.created_by as created_by',
-                'kubun_p2p_groups.status as status',
-                'kubun_p2p_groups.kind as kind',
-                'kubun_p2p_groups.projections_dirty as projections_dirty',
-                'kubun_p2p_groups.projections_epoch as projections_epoch',
-                'kubun_p2p_groups.hlc as hlc',
-                'kubun_p2p_groups.created_at as created_at',
-                'kubun_p2p_groups.updated_at as updated_at'
-            ]).where('kubun_p2p_group_hubs.hub_id', '=', hubID).execute();
+            const rows = await db.selectFrom('p2p_group_hubs').innerJoin('p2p_groups', 'p2p_groups.id', 'p2p_group_hubs.group_id').select([
+                'p2p_groups.id as id',
+                'p2p_groups.name as name',
+                'p2p_groups.description as description',
+                'p2p_groups.created_by as created_by',
+                'p2p_groups.status as status',
+                'p2p_groups.kind as kind',
+                'p2p_groups.projections_dirty as projections_dirty',
+                'p2p_groups.projections_epoch as projections_epoch',
+                'p2p_groups.hlc as hlc',
+                'p2p_groups.created_at as created_at',
+                'p2p_groups.updated_at as updated_at'
+            ]).where('p2p_group_hubs.hub_id', '=', hubID).execute();
             return rows;
         },
         async deleteGroupHubsByHubID (hubID) {
-            await db.deleteFrom('kubun_p2p_group_hubs').where('hub_id', '=', hubID).execute();
+            await db.deleteFrom('p2p_group_hubs').where('hub_id', '=', hubID).execute();
         },
         async getCommitHub (groupID) {
-            return await db.selectFrom('kubun_p2p_group_hubs').innerJoin('kubun_p2p_hubs', 'kubun_p2p_hubs.id', 'kubun_p2p_group_hubs.hub_id').selectAll('kubun_p2p_hubs').where('kubun_p2p_group_hubs.group_id', '=', groupID).where('kubun_p2p_group_hubs.is_commit_hub', '=', 1).executeTakeFirst();
+            return await db.selectFrom('p2p_group_hubs').innerJoin('p2p_hubs', 'p2p_hubs.id', 'p2p_group_hubs.hub_id').selectAll('p2p_hubs').where('p2p_group_hubs.group_id', '=', groupID).where('p2p_group_hubs.is_commit_hub', '=', 1).executeTakeFirst();
         },
         async setCommitHub (params) {
             // Clear then set so at most one bound hub per group carries the flag — the
             // single-designation invariant a fork-free commit log depends on. Both
             // statements run as one unit: a crash after the clear would leave the group
             // with no commit hub, and a device with none cannot commit.
-            await writeAtomically(db, async (tx)=>{
+            await withStoreTransaction(db, async (tx)=>{
                 // The hub must already be bound. Without this check an unbound hubID
                 // clears every flag and sets none — silently leaving the group unable to
                 // commit, which reads as a hang rather than an error.
-                const bound = await tx.selectFrom('kubun_p2p_group_hubs').select('hub_id').where('group_id', '=', params.groupID).where('hub_id', '=', params.hubID).executeTakeFirst();
+                const bound = await tx.selectFrom('p2p_group_hubs').select('hub_id').where('group_id', '=', params.groupID).where('hub_id', '=', params.hubID).executeTakeFirst();
                 if (bound == null) {
                     throw new Error(`Cannot designate commit hub ${params.hubID} for group ${params.groupID}: the hub is not bound to the group`);
                 }
-                await tx.updateTable('kubun_p2p_group_hubs').set({
+                await tx.updateTable('p2p_group_hubs').set({
                     is_commit_hub: 0
                 }).where('group_id', '=', params.groupID).execute();
-                await tx.updateTable('kubun_p2p_group_hubs').set({
+                await tx.updateTable('p2p_group_hubs').set({
                     is_commit_hub: 1
                 }).where('group_id', '=', params.groupID).where('hub_id', '=', params.hubID).execute();
             });
@@ -192,31 +173,31 @@ export function createHubOps(db, adapter) {
             }
             // Match and reflag as one unit: a crash between the clear and the set
             // would leave the group with no commit hub at all.
-            await writeAtomically(db, async (tx)=>{
+            await withStoreTransaction(db, async (tx)=>{
                 // The bound hub whose URL matches the designation, if this device has
                 // bound it. The join is what makes "bound to THIS group with that URL"
                 // the match, rather than any hub row that happens to carry the URL. When
                 // both sides carry a server DID it must match too: the same URL served
                 // by a different server DID is a different hub identity, and flagging it
                 // would designate a peer the group never chose.
-                let matchQuery = tx.selectFrom('kubun_p2p_group_hubs').innerJoin('kubun_p2p_hubs', 'kubun_p2p_hubs.id', 'kubun_p2p_group_hubs.hub_id').select('kubun_p2p_group_hubs.hub_id as hub_id').where('kubun_p2p_group_hubs.group_id', '=', groupID).where('kubun_p2p_hubs.url', '=', canonicalHubURL(commitHub.url));
+                let matchQuery = tx.selectFrom('p2p_group_hubs').innerJoin('p2p_hubs', 'p2p_hubs.id', 'p2p_group_hubs.hub_id').select('p2p_group_hubs.hub_id as hub_id').where('p2p_group_hubs.group_id', '=', groupID).where('p2p_hubs.url', '=', canonicalHubURL(commitHub.url));
                 if (commitHub.serverDID != null) {
                     // A bound row with no recorded server DID stays eligible — it has not
                     // claimed a conflicting identity, only an unknown one.
                     matchQuery = matchQuery.where((eb)=>eb.or([
-                            eb('kubun_p2p_hubs.server_did', '=', commitHub.serverDID),
-                            eb('kubun_p2p_hubs.server_did', 'is', null)
+                            eb('p2p_hubs.server_did', '=', commitHub.serverDID),
+                            eb('p2p_hubs.server_did', 'is', null)
                         ]));
                 }
                 const match = await matchQuery.executeTakeFirst();
                 // Clear every row first so at most one carries the flag — and so a
                 // designated-but-unbound hub leaves the device with NO flagged row rather
                 // than a stale non-designated one (that fallback is the fork).
-                await tx.updateTable('kubun_p2p_group_hubs').set({
+                await tx.updateTable('p2p_group_hubs').set({
                     is_commit_hub: 0
                 }).where('group_id', '=', groupID).execute();
                 if (match != null) {
-                    await tx.updateTable('kubun_p2p_group_hubs').set({
+                    await tx.updateTable('p2p_group_hubs').set({
                         is_commit_hub: 1
                     }).where('group_id', '=', groupID).where('hub_id', '=', match.hub_id).execute();
                 }

package/lib/ops/log-handler-completion.js

@@ -1,7 +1,7 @@
 export function createLogHandlerCompletionOps(db) {
     return {
         async beginLogHandlerCompletion ({ key, notify }) {
-            const row = await db.insertInto('kubun_p2p_log_handler_completion').values({
+            const row = await db.insertInto('p2p_log_handler_completion').values({
                 group_id: key.groupID,
                 procedure: key.procedure,
                 entity: key.entity,
@@ -18,11 +18,11 @@ export function createLogHandlerCompletionOps(db) {
             return row.notify === 1;
         },
         async hasLogHandlerCompleted (key) {
-            const row = await db.selectFrom('kubun_p2p_log_handler_completion').select('hlc').where('group_id', '=', key.groupID).where('procedure', '=', key.procedure).where('entity', '=', key.entity).where('hlc', '=', key.hlc).where('completed', '=', 1).executeTakeFirst();
+            const row = await db.selectFrom('p2p_log_handler_completion').select('hlc').where('group_id', '=', key.groupID).where('procedure', '=', key.procedure).where('entity', '=', key.entity).where('hlc', '=', key.hlc).where('completed', '=', 1).executeTakeFirst();
             return row != null;
         },
         async markLogHandlerCompleted (key) {
-            await db.insertInto('kubun_p2p_log_handler_completion').values({
+            await db.insertInto('p2p_log_handler_completion').values({
                 group_id: key.groupID,
                 procedure: key.procedure,
                 entity: key.entity,

package/lib/ops/mls.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 { GroupMLSState, InsertGroupMLSState, P2PStoreTables } from '../tables.js';
 export type ReserveSenderGenerationsParams = {