@kubun/store-p2p 0.11.0 → 0.12.0

package/lib/ops/hubs.js

@@ -0,0 +1,222 @@
+import { sql } from 'kysely';
+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
+ * caller inside an ambient transaction that catches one and carries on would
+ * otherwise hit `25P02` on everything after it. A savepoint is the portable
+ * fence; outside a transaction there is nothing to fence, because the failed
+ * unit already rolled itself back.
+ */ async function recoverable(db, run) {
+    if (!db.isTransaction) {
+        return await run();
+    }
+    await sql`SAVEPOINT kubun_p2p_recoverable`.execute(db);
+    try {
+        const result = await run();
+        await sql`RELEASE SAVEPOINT kubun_p2p_recoverable`.execute(db);
+        return result;
+    } catch (error) {
+        await sql`ROLLBACK TO SAVEPOINT kubun_p2p_recoverable`.execute(db);
+        throw error;
+    }
+}
+/**
+ * Whether `error` is the partial unique index refusing a second commit-hub
+ * designation for one group. Matched on the index name, which both drivers put
+ * in the message (Postgres also in `constraint_name`) — the error classes and
+ * codes themselves have nothing in common across the two.
+ */ function isCommitHubRaceLoss(error) {
+    if (error == null || typeof error !== 'object') {
+        return false;
+    }
+    const { message, constraint_name: constraint } = error;
+    return typeof message === 'string' && message.includes(COMMIT_HUB_UNIQUE_INDEX) || constraint === COMMIT_HUB_UNIQUE_INDEX;
+}
+/**
+ * Bind `binding` to its group, claiming the commit-hub designation when
+ * `claimDesignation` is set and the group carries none yet. Returns whether a
+ * row was actually inserted.
+ */ async function bindGroupHub(db, binding, claimDesignation) {
+    let inserted = false;
+    await writeAtomically(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();
+            designate = existing == null;
+        }
+        const result = await tx.insertInto('kubun_p2p_group_hubs').values({
+            group_id: binding.group_id,
+            hub_id: binding.hub_id,
+            is_commit_hub: designate ? 1 : 0
+        }).onConflict((oc)=>oc.columns([
+                'group_id',
+                'hub_id'
+            ]).doNothing()).executeTakeFirst();
+        inserted = (result.numInsertedOrUpdatedRows ?? 0n) > 0n;
+    });
+    return inserted;
+}
+export function createHubOps(db, adapter) {
+    return {
+        async insertHub (hub) {
+            await db.insertInto('kubun_p2p_hubs').values({
+                id: hub.id,
+                label: hub.label,
+                url: hub.url,
+                server_did: hub.server_did
+            }).execute();
+        },
+        async getHub (id) {
+            return await db.selectFrom('kubun_p2p_hubs').selectAll().where('id', '=', id).executeTakeFirst();
+        },
+        async getHubByURL (url) {
+            return await db.selectFrom('kubun_p2p_hubs').selectAll().where('url', '=', url).executeTakeFirst();
+        },
+        async updateHub (id, update) {
+            const values = {};
+            if (update.label !== undefined) values.label = update.label;
+            if (update.url !== undefined) values.url = 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();
+        },
+        async deleteHub (id) {
+            await db.deleteFrom('kubun_p2p_hubs').where('id', '=', id).execute();
+        },
+        async listHubs () {
+            return await db.selectFrom('kubun_p2p_hubs').selectAll().execute();
+        },
+        // --- Group-hub binding operations ---
+        async insertGroupHub (binding) {
+            // The first hub bound to a group becomes its canonical commit hub: a group
+            // commits through exactly one hub, and with none yet designated this bind
+            // is the deterministic choice. Later binds default to 0, leaving the
+            // designation on the first-bound hub until an explicit `setCommitHub`.
+            //
+            // Running the read and the insert as one unit does NOT settle a race: two
+            // concurrent first binds touch different rows, so neither blocks the other
+            // and both read "no commit hub". The partial unique index is what arbitrates,
+            // by rejecting the second claim — so a rejection here means another bind
+            // won the designation, and this one adopts the winner and binds unflagged.
+            // Erroring instead would leave the loser unbound over a designation it
+            // never needed to own.
+            try {
+                return await recoverable(db, ()=>bindGroupHub(db, binding, true));
+            } catch (error) {
+                if (!isCommitHubRaceLoss(error)) {
+                    throw error;
+                }
+                return await bindGroupHub(db, binding, false);
+            }
+        },
+        async deleteGroupHub (params) {
+            const result = await db.deleteFrom('kubun_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();
+            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();
+        },
+        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.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();
+            return rows;
+        },
+        async deleteGroupHubsByHubID (hubID) {
+            await db.deleteFrom('kubun_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();
+        },
+        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)=>{
+                // 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();
+                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({
+                    is_commit_hub: 0
+                }).where('group_id', '=', params.groupID).execute();
+                await tx.updateTable('kubun_p2p_group_hubs').set({
+                    is_commit_hub: 1
+                }).where('group_id', '=', params.groupID).where('hub_id', '=', params.hubID).execute();
+            });
+        },
+        async reconcileCommitHub (groupID, commitHub) {
+            // No folded designation: leave the local auto-designated flag untouched.
+            if (commitHub == null) {
+                return;
+            }
+            // 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)=>{
+                // 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', '=', 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)
+                        ]));
+                }
+                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({
+                    is_commit_hub: 0
+                }).where('group_id', '=', groupID).execute();
+                if (match != null) {
+                    await tx.updateTable('kubun_p2p_group_hubs').set({
+                        is_commit_hub: 1
+                    }).where('group_id', '=', groupID).where('hub_id', '=', match.hub_id).execute();
+                }
+            });
+        }
+    };
+}

package/lib/ops/mls.d.ts

@@ -0,0 +1,21 @@
+import type { Adapter } from '@kubun/db-adapter';
+import type { Kysely } from 'kysely';
+import type { GroupMLSState, InsertGroupMLSState, P2PStoreTables } from '../tables.js';
+/** Per-device MLS state for each group. */
+export type MLSOps = {
+    saveMLSState(state: InsertGroupMLSState): Promise<void>;
+    getMLSState(groupID: string, deviceID: string): Promise<GroupMLSState | undefined>;
+    deleteMLSState(groupID: string, deviceID: string): Promise<void>;
+    listMLSStates(groupID: string): Promise<Array<GroupMLSState>>;
+    /**
+     * The groups this device holds MLS state for, keyed on the same `(group_id,
+     * device_id)` pair {@link getMLSState} reads.
+     *
+     * **No production caller — a test observer.** It once answered "have I joined
+     * this group", which it cannot: a removed device still holds state. Kept for
+     * asserting that a departure left nothing behind.
+     */
+    listMLSStateGroupIDs(deviceID: string): Promise<Array<string>>;
+    deleteGroupMLSStates(groupID: string): Promise<void>;
+};
+export declare function createMLSOps(db: Kysely<P2PStoreTables>, adapter: Adapter): MLSOps;

package/lib/ops/mls.js

@@ -0,0 +1,50 @@
+export function createMLSOps(db, adapter) {
+    return {
+        async saveMLSState (state) {
+            await db.insertInto('kubun_p2p_group_mls_state').values({
+                group_id: state.group_id,
+                device_id: state.device_id,
+                mls_state: adapter.encodeBinary(state.mls_state),
+                credential: state.credential,
+                epoch: state.epoch,
+                ledger_entries: state.ledger_entries
+            }).onConflict((oc)=>oc.columns([
+                    'group_id',
+                    'device_id'
+                ]).doUpdateSet((eb)=>({
+                        mls_state: eb.ref('excluded.mls_state'),
+                        credential: eb.ref('excluded.credential'),
+                        epoch: eb.ref('excluded.epoch'),
+                        ledger_entries: eb.ref('excluded.ledger_entries'),
+                        updated_at: adapter.encodeTimestamp(new Date())
+                    }))// Monotonic-epoch guard: only overwrite when the incoming epoch is
+                // at least the stored one. The MLS epoch never moves backwards, so a
+                // write carrying a lower epoch is a stale handle re-persisting an
+                // already-superseded ratchet — apply it and we roll the ratchet back.
+                // When this predicate is false the existing row is left untouched
+                // with no error (a silent no-op); a fresh insert has no conflict and
+                // is unaffected. The bound is `<=`, not `<`: decrypting an
+                // application message advances the secret-tree generation WITHIN an
+                // epoch while `epoch` stays constant, so a legitimate same-epoch
+                // re-persist carries a changed `mls_state` blob at the same epoch and
+                // must still win — `<` would reject it and wedge decryption.
+                .where((eb)=>eb('kubun_p2p_group_mls_state.epoch', '<=', eb.ref('excluded.epoch')))).execute();
+        },
+        async getMLSState (groupID, deviceID) {
+            return await db.selectFrom('kubun_p2p_group_mls_state').selectAll().where('group_id', '=', groupID).where('device_id', '=', deviceID).executeTakeFirst();
+        },
+        async deleteMLSState (groupID, deviceID) {
+            await db.deleteFrom('kubun_p2p_group_mls_state').where('group_id', '=', groupID).where('device_id', '=', deviceID).execute();
+        },
+        async listMLSStates (groupID) {
+            return await db.selectFrom('kubun_p2p_group_mls_state').selectAll().where('group_id', '=', groupID).execute();
+        },
+        async listMLSStateGroupIDs (deviceID) {
+            const rows = await db.selectFrom('kubun_p2p_group_mls_state').select('group_id').where('device_id', '=', deviceID).execute();
+            return rows.map((row)=>row.group_id);
+        },
+        async deleteGroupMLSStates (groupID) {
+            await db.deleteFrom('kubun_p2p_group_mls_state').where('group_id', '=', groupID).execute();
+        }
+    };
+}

package/lib/ops/sync.d.ts

@@ -0,0 +1,22 @@
+import type { Adapter } from '@kubun/db-adapter';
+import type { Kysely } from 'kysely';
+import type { InsertSyncPeer, P2PStoreTables, SyncPeer } from '../tables.js';
+/** Sync peers and the broadcast dedup log. */
+export type SyncOps = {
+    addSyncPeer(peer: InsertSyncPeer): Promise<void>;
+    getSyncPeer(peerDID: string): Promise<SyncPeer | undefined>;
+    listSyncPeers(): Promise<Array<SyncPeer>>;
+    updateSyncPeer(peerDID: string, update: Partial<InsertSyncPeer>): Promise<void>;
+    removeSyncPeer(peerDID: string): Promise<void>;
+    recordBroadcast(entry: {
+        docID: string;
+        version: string;
+        mlsGroupID: string;
+    }): Promise<boolean>;
+    hasBroadcast(entry: {
+        docID: string;
+        version: string;
+        mlsGroupID: string;
+    }): Promise<boolean>;
+};
+export declare function createSyncOps(db: Kysely<P2PStoreTables>, adapter: Adapter): SyncOps;

package/lib/ops/sync.js

@@ -0,0 +1,50 @@
+export function createSyncOps(db, adapter) {
+    return {
+        async addSyncPeer (peer) {
+            const config = adapter.encodeJSON(peer.config);
+            await db.insertInto('kubun_p2p_sync_peers').values({
+                ...peer,
+                config
+            }).onConflict((oc)=>oc.column('peer_did').doUpdateSet({
+                    endpoint: peer.endpoint,
+                    config,
+                    updated_at: peer.updated_at
+                })).execute();
+        },
+        async getSyncPeer (peerDID) {
+            return await db.selectFrom('kubun_p2p_sync_peers').selectAll().where('peer_did', '=', peerDID).executeTakeFirst();
+        },
+        async listSyncPeers () {
+            return await db.selectFrom('kubun_p2p_sync_peers').selectAll().execute();
+        },
+        async updateSyncPeer (peerDID, update) {
+            const values = {};
+            if (update.endpoint != null) values.endpoint = update.endpoint;
+            if (update.config != null) values.config = adapter.encodeJSON(update.config);
+            // Through the adapter, like every sibling write: the column is a
+            // `timestamptz(3)` on Postgres, which a raw epoch number is not.
+            values.updated_at = adapter.encodeTimestamp(new Date());
+            await db.updateTable('kubun_p2p_sync_peers').set(values).where('peer_did', '=', peerDID).execute();
+        },
+        async removeSyncPeer (peerDID) {
+            await db.deleteFrom('kubun_p2p_sync_peers').where('peer_did', '=', peerDID).execute();
+        },
+        // --- Broadcast log operations ---
+        async recordBroadcast (entry) {
+            const result = await db.insertInto('kubun_p2p_broadcast_log').values({
+                doc_id: entry.docID,
+                version: entry.version,
+                mls_group_id: entry.mlsGroupID
+            }).onConflict((oc)=>oc.columns([
+                    'doc_id',
+                    'version',
+                    'mls_group_id'
+                ]).doNothing()).executeTakeFirst();
+            return (result.numInsertedOrUpdatedRows ?? 0n) > 0n;
+        },
+        async hasBroadcast (entry) {
+            const row = await db.selectFrom('kubun_p2p_broadcast_log').select('doc_id').where('doc_id', '=', entry.docID).where('version', '=', entry.version).where('mls_group_id', '=', entry.mlsGroupID).limit(1).executeTakeFirst();
+            return row != null;
+        }
+    };
+}

package/lib/tables.d.ts

@@ -1,15 +1,33 @@
 import type { CreatedAtColumn, UpdatedAtColumn } from '@kubun/db-adapter';
 import type { ColumnType, Insertable, Selectable, Updateable } from 'kysely';
 type DefaultedStringColumn = ColumnType<string, string | undefined, string>;
+type DefaultedNumberColumn = ColumnType<number, number | undefined, number>;
 type NullableStringColumn = ColumnType<string | null, string | null | undefined, string | null>;
 type JSONArrayColumn<T> = ColumnType<Array<T>, Array<T> | undefined, Array<T>>;
 type JSONValueColumn<T> = ColumnType<T, T, T>;
+/**
+ * Whether this device belongs to the group right now.
+ *
+ * Only the two states that have a writer. An `invited` state would have none:
+ * a group row is written when a join COMPLETES, so there is no moment at which
+ * a row exists and the device has merely been asked.
+ */
+export type GroupStatus = 'joined' | 'left';
 export type GroupTable = {
     id: string;
     name: string;
     description: DefaultedStringColumn;
     created_by: string;
     hlc: string;
+    /**
+     * Leaving keeps the row: its circles, circle members, peer announcements and
+     * hub bindings hang off it, and a device invited back would otherwise have to
+     * rebuild state it still holds. The status is what every LISTING reads, while
+     * a point lookup by id deliberately still finds a departed group — that is
+     * what makes rejoining the same group possible instead of forking a second
+     * row for it.
+     */
+    status: DefaultedStringColumn;
     created_at: CreatedAtColumn;
     updated_at: UpdatedAtColumn;
 };
@@ -34,6 +52,7 @@ export type CircleTable = {
     catalog_ids: JSONArrayColumn<string>;
     hlc: string;
     removed_at_hlc: NullableStringColumn;
+    open: DefaultedNumberColumn;
     created_at: CreatedAtColumn;
     updated_at: UpdatedAtColumn;
 };
@@ -62,7 +81,13 @@ export type GroupMLSStateTable = {
     mls_state: Uint8Array;
     credential: string;
     epoch: number;
-    root_capability: DefaultedStringColumn;
+    /**
+     * The handle's signed control-ledger tokens, JSON-encoded in enactment order.
+     * Replayed into `restoreGroup` so a restored handle folds the same roster it
+     * held before: without them the fold reverts to the genesis anchor alone and
+     * every admin but the creator loses authority across a restart.
+     */
+    ledger_entries: DefaultedStringColumn;
     updated_at: UpdatedAtColumn;
 };
 export type GroupMLSState = Selectable<GroupMLSStateTable>;
@@ -72,12 +97,6 @@ export type SyncPeerTable = {
     id: string;
     peer_did: string;
     endpoint: string;
-    mode: string;
-    allowed_users: JSONValueColumn<Array<string> | {
-        all: boolean;
-    }>;
-    priority: DefaultedStringColumn;
-    trust_level: string;
     config: JSONValueColumn<Record<string, unknown>>;
     created_at: CreatedAtColumn;
     updated_at: UpdatedAtColumn;
@@ -101,27 +120,45 @@ export type BroadcastLogTable = {
 };
 export type BroadcastLogEntry = Selectable<BroadcastLogTable>;
 export type InsertBroadcastLogEntry = Insertable<BroadcastLogTable>;
-export type ControlLedgerTable = {
+export type ControlRequestTable = {
+    id: string;
     group_id: string;
-    entry_id: string;
-    type: string;
-    subject: string;
-    value: JSONValueColumn<unknown>;
-    hlc: string;
-    issuer_did: string;
-    signed_token: string;
-    received_at: CreatedAtColumn;
+    kind: string;
+    status: DefaultedStringColumn;
+    error: NullableStringColumn;
+    result: NullableStringColumn;
+    enqueued_at: string;
+    settled_at: NullableStringColumn;
+};
+export type ControlRequest = Selectable<ControlRequestTable>;
+export type InsertControlRequest = Insertable<ControlRequestTable>;
+export type CommitJournalEntryTable = {
+    group_id: string;
+    publish_id: string;
+    expected_head: string | null;
+    epoch: number;
+    accepted_as: NullableStringColumn;
+    commit: Uint8Array;
+    bodies: JSONArrayColumn<string>;
+    kind: string;
+    journal: Uint8Array;
+};
+export type CommitJournalEntry = Selectable<CommitJournalEntryTable>;
+export type InsertCommitJournalEntry = Insertable<CommitJournalEntryTable>;
+export type GroupAnchorTable = {
+    group_id: string;
+    secret: Uint8Array;
+    epoch: number;
 };
-export type ControlLedgerEntry = Selectable<ControlLedgerTable>;
-export type InsertControlLedgerEntry = Insertable<ControlLedgerTable>;
-export type ProjectionStateTable = {
+export type GroupAnchor = Selectable<GroupAnchorTable>;
+export type InsertGroupAnchor = Insertable<GroupAnchorTable>;
+export type AppCursorTable = {
     group_id: string;
-    projection: string;
-    projected_through_hlc: string;
-    updated_at: UpdatedAtColumn;
+    topic_id: string;
+    position: string;
 };
-export type ProjectionState = Selectable<ProjectionStateTable>;
-export type InsertProjectionState = Insertable<ProjectionStateTable>;
+export type AppCursor = Selectable<AppCursorTable>;
+export type InsertAppCursor = Insertable<AppCursorTable>;
 export type HubTable = {
     id: string;
     label: string | null;
@@ -135,10 +172,48 @@ export type InsertHub = Insertable<HubTable>;
 export type GroupHubTable = {
     group_id: string;
     hub_id: string;
+    is_commit_hub: DefaultedNumberColumn;
     created_at: CreatedAtColumn;
 };
 export type GroupHub = Selectable<GroupHubTable>;
 export type InsertGroupHub = Insertable<GroupHubTable>;
+/**
+ * One advertised capability: an identifier matched EXACTLY on both halves, so a
+ * peer answering `kubun/sync-merkle` v1 is not offered a v2 session. `transports`
+ * is null for a capability the hub tunnel already addresses, and is where a
+ * future direct transport carries its own addressing hint.
+ */
+export type PeerCapabilityRecord = {
+    protocol: string;
+    version: number;
+    transports: Array<string> | null;
+};
+export type PeerAnnouncementTable = {
+    group_id: string;
+    peer_did: string;
+    label: string;
+    availability: string;
+    capabilities: JSONArrayColumn<PeerCapabilityRecord>;
+    hlc: string;
+    announced_at: UpdatedAtColumn;
+    announced_epoch: DefaultedNumberColumn;
+};
+export type PeerAnnouncement = Selectable<PeerAnnouncementTable>;
+export type InsertPeerAnnouncement = Insertable<PeerAnnouncementTable>;
+export type LocalPeerProfileTable = {
+    peer_did: string;
+    label: string;
+    availability: string;
+    capabilities: JSONArrayColumn<PeerCapabilityRecord>;
+    updated_at: UpdatedAtColumn;
+};
+export type LocalPeerProfile = Selectable<LocalPeerProfileTable>;
+export type PendingJoinRequestTable = {
+    did: string;
+    payload: string;
+    created_at: CreatedAtColumn;
+};
+export type PendingJoinRequestRow = Selectable<PendingJoinRequestTable>;
 export type PaginationParams = {
     limit?: number;
     offset?: number;
@@ -157,9 +232,14 @@ export type P2PStoreTables = {
     kubun_p2p_sync_peers: SyncPeerTable;
     kubun_p2p_sync_checkpoints: SyncCheckpointTable;
     kubun_p2p_broadcast_log: BroadcastLogTable;
-    kubun_p2p_control_ledger: ControlLedgerTable;
-    kubun_p2p_projection_state: ProjectionStateTable;
+    kubun_p2p_control_requests: ControlRequestTable;
+    kubun_p2p_commit_journal: CommitJournalEntryTable;
+    kubun_p2p_group_anchor: GroupAnchorTable;
+    kubun_p2p_app_cursor: AppCursorTable;
     kubun_p2p_hubs: HubTable;
     kubun_p2p_group_hubs: GroupHubTable;
+    kubun_p2p_peer_announcements: PeerAnnouncementTable;
+    kubun_p2p_local_peer_profile: LocalPeerProfileTable;
+    kubun_p2p_pending_join_requests: PendingJoinRequestTable;
 };
 export {};

package/package.json

@@ -1,41 +1,41 @@
 {
   "name": "@kubun/store-p2p",
-  "version": "0.11.0",
-  "license": "see LICENSE.md",
+  "version": "0.12.0",
   "keywords": [],
+  "license": "see LICENSE.md",
+  "sideEffects": false,
   "type": "module",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
   "exports": {
     ".": "./lib/index.js"
   },
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "files": [
     "lib/*",
     "LICENSE.md"
   ],
-  "sideEffects": false,
   "dependencies": {
-    "@kokuin/capability": "^0.1.0",
-    "@kokuin/token": "^0.1.1",
-    "kysely": "^0.29.2",
-    "@kubun/db": "^0.11.0",
-    "@kubun/logger": "^0.11.0",
-    "@kubun/db-adapter": "^0.11.0"
+    "@kokuin/capability": "^0.2.1",
+    "@kokuin/token": "^0.3.0",
+    "kysely": "^0.29.4",
+    "@kubun/db": "^0.12.0",
+    "@kubun/db-adapter": "^0.12.0",
+    "@kubun/logger": "^0.12.0"
   },
   "devDependencies": {
-    "@testcontainers/postgresql": "^12.0.4",
-    "@kubun/db-better-sqlite": "^0.11.0",
-    "@kubun/db-postgres": "^0.11.0",
-    "@kubun/hlc": "^0.11.0"
+    "@testcontainers/postgresql": "^12.1.0",
+    "@kubun/db-better-sqlite": "^0.12.0",
+    "@kubun/db-postgres": "^0.12.0",
+    "@kubun/hlc": "^0.12.0"
   },
   "scripts": {
+    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
     "build:clean": "del lib",
     "build:js": "swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
     "build:types": "tsc --emitDeclarationOnly --skipLibCheck",
     "build:types:ci": "tsc --emitDeclarationOnly --declarationMap false",
-    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
+    "test": "pnpm run test:types && pnpm run test:unit",
     "test:types": "tsc --noEmit -p tsconfig.test.json",
-    "test:unit": "vitest run",
-    "test": "pnpm run test:types && pnpm run test:unit"
+    "test:unit": "vitest run"
   }
 }