@kubun/hub 0.10.0 → 0.11.0

package/lib/create-relay.d.ts

@@ -1,9 +1,8 @@
-import type { HubStore } from '@enkaku/hub-protocol';
-import type { Identity } from '@enkaku/token';
+import type { Identity } from '@kokuin/token';
 import type { Adapter } from '@kubun/db-adapter';
 import { type AdapterInput } from '@kubun/db-provider';
 import { Kysely } from 'kysely';
-import { type HubDatabase } from './hub-store.js';
+import { type HubDatabase, type KubunHubStore } from './hub-store.js';
 import { type RelayObservers } from './observers.js';
 export type HubAuthConfig = {
     mode: 'open';
@@ -15,10 +14,11 @@ export type HubAuthConfig = {
 export type RelayRetentionConfig = {
     olderThanSeconds: number;
     intervalSeconds?: number;
+    subscriptionOlderThanSeconds?: number;
 };
 export type CreateRelayOptions = {
     db: AdapterInput;
-    identity?: Identity;
+    identity: Identity;
     auth?: HubAuthConfig;
     allowedOrigin?: string | Array<string>;
     retention?: RelayRetentionConfig;
@@ -26,14 +26,14 @@ export type CreateRelayOptions = {
 };
 export type Relay = {
     fetch: (request: Request) => Promise<Response>;
-    hubStore: HubStore;
+    hubStore: KubunHubStore;
     pendingDeliveries: () => Promise<number>;
     dispose: () => Promise<void>;
 };
 export type RelayInternalOptions = {
     kysely: Kysely<HubDatabase>;
     adapter: Adapter;
-    identity?: Identity;
+    identity: Identity;
     auth?: HubAuthConfig;
     allowedOrigin?: string | Array<string>;
     retention?: RelayRetentionConfig;

package/lib/create-relay.js

@@ -1 +1,214 @@
-import{ServerTransport as e}from"@enkaku/http-server-transport";import{createHandlers as t,HubClientRegistry as r}from"@enkaku/hub-server";import{Server as n}from"@enkaku/server";import{resolveAdapter as o}from"@kubun/db-provider";import{Kysely as i}from"kysely";import{Migrator as a}from"kysely/migration";import{createHubStore as l}from"./hub-store.js";import{createHubMigrations as s}from"./migrations.js";import{decorateHubStore as u}from"./observers.js";export async function createRelayInternal(o){var i;let c,d,{kysely:m,adapter:h,observers:y,ownsKysely:p}=o;if(null!=o.auth&&null==o.identity)throw Error("createRelay: 'identity' is required when 'auth' is set");let f=s({types:h.types,functions:h.functions}),w=new a({db:m,provider:{getMigrations:async()=>f},migrationTableName:"kubun_hub_migration",migrationLockTableName:"kubun_hub_migration_lock"}),{error:g}=await w.migrateToLatest();if(null!=g)throw g;let b=new r,v=l({kysely:m,adapter:h}),k=u(v,y);if(y?.onPurge!=null){let e=y.onPurge;c=v.events.on("purge",t=>{try{e({sequenceCount:t.sequenceIDs.length})}catch{}})}let _=t({registry:b,store:k}),R=new e({allowedOrigin:null==(i=o.allowedOrigin)?["*"]:"string"==typeof i?i.split(",").map(e=>e.trim()):i}),T=function(e){if(null==e)return{};switch(e.mode){case"open":return{"*":{allow:!0}};case"allowlist":{let{allowedDIDs:t,isAllowed:r}=e;if(null!=r)return{"*":{allow:async e=>{let n=e.payload.iss;return!!t?.includes(n)||await r(n)}}};return{"*":{allow:t??[]}}}}}(o.auth),j=new n(o.identity?{identity:o.identity,accessRules:T,handlers:_,transports:[R]}:{handlers:_,transports:[R]});if(y?.onAuthRejected!=null){let e=y.onAuthRejected;j.events.on("handlerError",t=>{if("auth"===t.category)try{e({reason:t.error.message})}catch{}})}if(null!=o.retention){let{olderThanSeconds:e}=o.retention;d=setInterval(()=>{k.purge({olderThan:e}).catch(e=>{if(y?.onError!=null)try{y.onError({stage:"purge",error:e})}catch{}})},Math.max(1,Math.floor(1e3*(o.retention.intervalSeconds??3600))))}return{fetch:e=>R.fetch(e),hubStore:k,pendingDeliveries:async()=>Number((await m.selectFrom("kubun_hub_deliveries").select(({fn:e})=>e.countAll().as("count")).executeTakeFirstOrThrow()).count),dispose:async()=>{null!=d&&(clearInterval(d),d=void 0),null!=c&&(c(),c=void 0),await j.dispose(),p&&await m.destroy()}}}export async function createRelay(e){let t=o(e.db),r=new i({dialect:t.dialect});return await createRelayInternal({kysely:r,adapter:t,identity:e.identity,auth:e.auth,allowedOrigin:e.allowedOrigin,retention:e.retention,observers:e.observers,ownsKysely:!0})}
+import { ServerTransport } from '@enkaku/http-serve';
+import { Server } from '@enkaku/server';
+import { resolveAdapter } from '@kubun/db-provider';
+import { resolveAllowedOrigin } from '@kubun/http-util';
+import { createHandlers as createHubHandlers, HubClientRegistry } from '@kumiai/hub-server';
+import { Kysely } from 'kysely';
+import { Migrator } from 'kysely/migration';
+import { createHubStore } from './hub-store.js';
+import { createHubMigrations } from './migrations.js';
+import { decorateHubStore } from './observers.js';
+const DEFAULT_RETENTION_INTERVAL_SECONDS = 3600;
+const DEFAULT_SUBSCRIPTION_RETENTION_SECONDS = 90 * 24 * 60 * 60;
+function resolveAccessRules(auth) {
+    if (auth == null) return {};
+    switch(auth.mode){
+        case 'open':
+            return {
+                '*': {
+                    allow: true
+                }
+            };
+        case 'allowlist':
+            {
+                const { allowedDIDs, isAllowed } = auth;
+                if (isAllowed != null) {
+                    const wrapped = async (ctx)=>{
+                        const did = ctx.payload.iss;
+                        if (allowedDIDs?.includes(did)) return true;
+                        return await isAllowed(did);
+                    };
+                    return {
+                        '*': {
+                            allow: wrapped
+                        }
+                    };
+                }
+                return {
+                    '*': {
+                        allow: allowedDIDs ?? []
+                    }
+                };
+            }
+    }
+}
+export async function createRelayInternal(options) {
+    const { kysely, adapter, observers, ownsKysely } = options;
+    const migrationCtx = {
+        types: adapter.types,
+        functions: adapter.functions
+    };
+    const migrations = createHubMigrations(migrationCtx);
+    const migrationProvider = {
+        getMigrations: async ()=>migrations
+    };
+    const migrator = new Migrator({
+        db: kysely,
+        provider: migrationProvider,
+        migrationTableName: 'kubun_hub_migration',
+        migrationLockTableName: 'kubun_hub_migration_lock'
+    });
+    const { error: migrationError } = await migrator.migrateToLatest();
+    if (migrationError != null) {
+        throw migrationError;
+    }
+    const registry = new HubClientRegistry();
+    const rawStore = createHubStore({
+        kysely,
+        adapter
+    });
+    const hubStore = decorateHubStore(rawStore, observers);
+    let unsubscribePurge;
+    if (observers?.onPurge != null) {
+        const onPurge = observers.onPurge;
+        unsubscribePurge = rawStore.events.on('purge', (info)=>{
+            try {
+                onPurge({
+                    sequenceCount: info.sequenceIDs.length
+                });
+            } catch  {
+            // Observer callbacks are diagnostics — never let them break the relay.
+            }
+        });
+    }
+    const hubHandlers = createHubHandlers({
+        registry,
+        store: hubStore
+    });
+    const allowedOrigin = resolveAllowedOrigin(options.allowedOrigin);
+    const transport = new ServerTransport({
+        allowedOrigin
+    });
+    const accessRules = resolveAccessRules(options.auth);
+    const serverParams = {
+        identity: options.identity,
+        accessRules,
+        handlers: hubHandlers,
+        transports: [
+            transport
+        ]
+    };
+    const enkakuServer = new Server(serverParams);
+    if (observers?.onAuthRejected != null) {
+        const onAuthRejected = observers.onAuthRejected;
+        enkakuServer.events.on('handlerError', (info)=>{
+            if (info.category !== 'auth') return;
+            try {
+                onAuthRejected({
+                    reason: info.error.message
+                });
+            } catch  {
+            // Observer callbacks are diagnostics — never let them break the relay.
+            }
+        });
+    }
+    let retentionTimer;
+    if (options.retention != null) {
+        const { olderThanSeconds } = options.retention;
+        const intervalSeconds = options.retention.intervalSeconds ?? DEFAULT_RETENTION_INTERVAL_SECONDS;
+        const intervalMs = Math.max(1, Math.floor(intervalSeconds * 1000));
+        // A subscriber must never be reaped while a message it would still receive
+        // is retained, so the subscription window is clamped up to the message
+        // window.
+        const configuredSubscription = options.retention.subscriptionOlderThanSeconds ?? DEFAULT_SUBSCRIPTION_RETENTION_SECONDS;
+        const subscriptionOlderThanSeconds = Math.max(configuredSubscription, olderThanSeconds);
+        if (configuredSubscription < olderThanSeconds && observers?.onRetentionConfigClamped != null) {
+            try {
+                observers.onRetentionConfigClamped({
+                    configuredSubscriptionOlderThanSeconds: configuredSubscription,
+                    clampedToSeconds: subscriptionOlderThanSeconds
+                });
+            } catch  {
+            // Observer callbacks are diagnostics — never let them break the relay.
+            }
+        }
+        retentionTimer = setInterval(()=>{
+            void hubStore.purge({
+                olderThan: olderThanSeconds
+            }).catch((err)=>{
+                if (observers?.onError != null) {
+                    try {
+                        observers.onError({
+                            stage: 'purge',
+                            error: err
+                        });
+                    } catch  {
+                    // Observer callbacks are diagnostics — never let them break the relay.
+                    }
+                }
+            });
+            void hubStore.purgeSubscribers({
+                olderThan: subscriptionOlderThanSeconds
+            }).then((purged)=>{
+                if (observers?.onSubscriptionPurge != null) {
+                    try {
+                        observers.onSubscriptionPurge({
+                            subscriptionCount: purged.length
+                        });
+                    } catch  {
+                    // Observer callbacks are diagnostics — never let them break the relay.
+                    }
+                }
+            }).catch((err)=>{
+                if (observers?.onError != null) {
+                    try {
+                        observers.onError({
+                            stage: 'subscription-purge',
+                            error: err
+                        });
+                    } catch  {
+                    // Observer callbacks are diagnostics — never let them break the relay.
+                    }
+                }
+            });
+        }, intervalMs);
+    }
+    return {
+        fetch: (request)=>transport.fetch(request),
+        hubStore,
+        pendingDeliveries: async ()=>{
+            const row = await kysely.selectFrom('kubun_hub_deliveries').select(({ fn })=>fn.countAll().as('count')).executeTakeFirstOrThrow();
+            return Number(row.count);
+        },
+        dispose: async ()=>{
+            if (retentionTimer != null) {
+                clearInterval(retentionTimer);
+                retentionTimer = undefined;
+            }
+            if (unsubscribePurge != null) {
+                unsubscribePurge();
+                unsubscribePurge = undefined;
+            }
+            await enkakuServer.dispose();
+            if (ownsKysely) {
+                await kysely.destroy();
+            }
+        }
+    };
+}
+export async function createRelay(options) {
+    const adapter = resolveAdapter(options.db);
+    const kysely = new Kysely({
+        dialect: adapter.dialect
+    });
+    return await createRelayInternal({
+        kysely,
+        adapter,
+        identity: options.identity,
+        auth: options.auth,
+        allowedOrigin: options.allowedOrigin,
+        retention: options.retention,
+        observers: options.observers,
+        ownsKysely: true
+    });
+}

package/lib/hub-store.d.ts

@@ -1,11 +1,11 @@
-import type { HubStore } from '@enkaku/hub-protocol';
 import type { Adapter } from '@kubun/db-adapter';
+import type { HubStore } from '@kumiai/hub-protocol';
 import type { ColumnType, Kysely } from 'kysely';
 export type HubDatabase = {
     kubun_hub_messages: {
         sequence_id: string;
         sender_did: string;
-        group_id: string | null;
+        topic_id: string;
         payload: Uint8Array;
         stored_at: number;
     };
@@ -18,13 +18,24 @@ export type HubDatabase = {
         owner_did: string;
         key_package: string;
     };
-    kubun_hub_group_members: {
-        group_id: string;
-        member_did: string;
+    kubun_hub_subscriptions: {
+        topic_id: string;
+        subscriber_did: string;
+        last_active_at: number;
     };
 };
 export type CreateHubStoreParams = {
     kysely: Kysely<HubDatabase> | Promise<Kysely<HubDatabase>>;
     adapter: Adapter;
 };
-export declare function createHubStore(params: CreateHubStoreParams): HubStore;
+export type PurgeSubscriptionsParams = {
+    olderThan: number;
+};
+export type PurgedSubscription = {
+    topicID: string;
+    subscriberDID: string;
+};
+export type KubunHubStore = HubStore & {
+    purgeSubscribers(params: PurgeSubscriptionsParams): Promise<Array<PurgedSubscription>>;
+};
+export declare function createHubStore(params: CreateHubStoreParams): KubunHubStore;

package/lib/hub-store.js

@@ -1 +1,205 @@
-import{EventEmitter as e}from"@enkaku/event";export function createHubStore(u){let n,t,{adapter:a}=u;async function i(){return null==n&&(n=await u.kysely),n}async function s(){let e=await i();if(null==t){let u=await e.selectFrom("kubun_hub_messages").select(e.fn.max("sequence_id").as("max_id")).executeTakeFirst();t=u?.max_id!=null?Number.parseInt(u.max_id,10):0}return String(++t).padStart(12,"0")}let r=new e;async function _(e){if(0===e.sequenceIDs.length)return;let u=await i();await u.deleteFrom("kubun_hub_deliveries").where("recipient_did","=",e.recipientDID).where("sequence_id","in",e.sequenceIDs).execute();let n=new Set((await u.selectFrom("kubun_hub_deliveries").select("sequence_id").where("sequence_id","in",e.sequenceIDs).execute()).map(e=>e.sequence_id)),t=e.sequenceIDs.filter(e=>!n.has(e));t.length>0&&await u.deleteFrom("kubun_hub_messages").where("sequence_id","in",t).execute()}async function c(e){let u=await i(),n=Date.now()-1e3*e.olderThan,t=(await u.selectFrom("kubun_hub_messages").select("sequence_id").where("stored_at","<=",n).execute()).map(e=>e.sequence_id);return 0===t.length?[]:(await u.deleteFrom("kubun_hub_deliveries").where("sequence_id","in",t).execute(),await u.deleteFrom("kubun_hub_messages").where("sequence_id","in",t).execute(),await r.emit("purge",{sequenceIDs:t}),t)}return{events:r,store:async function(e){let u=await s(),n=Date.now(),t=await i();return await t.insertInto("kubun_hub_messages").values({sequence_id:u,sender_did:e.senderDID,group_id:e.groupID??null,payload:a.encodeBinary(e.payload),stored_at:n}).execute(),e.recipients.length>0&&await t.insertInto("kubun_hub_deliveries").values(e.recipients.map(e=>({sequence_id:u,recipient_did:e}))).execute(),u},fetch:async function(e){null!=e.ack&&e.ack.length>0&&await _({recipientDID:e.recipientDID,sequenceIDs:e.ack});let u=(await i()).selectFrom("kubun_hub_deliveries").innerJoin("kubun_hub_messages","kubun_hub_messages.sequence_id","kubun_hub_deliveries.sequence_id").select(["kubun_hub_messages.sequence_id","kubun_hub_messages.sender_did","kubun_hub_messages.group_id","kubun_hub_messages.payload"]).where("kubun_hub_deliveries.recipient_did","=",e.recipientDID).orderBy("kubun_hub_messages.sequence_id","asc");null!=e.after&&(u=u.where("kubun_hub_messages.sequence_id",">",e.after));let n=e.limit;null!=n&&(u=u.limit(n+1));let t=await u.execute(),a=!1,s=t;null!=n&&t.length>n&&(a=!0,s=t.slice(0,n));let r=s.map(e=>({sequenceID:e.sequence_id,senderDID:e.sender_did,groupID:e.group_id??void 0,payload:e.payload})),c=r.length>0?r[r.length-1].sequenceID:null;return{messages:r,cursor:c,hasMore:a}},ack:_,purge:c,storeKeyPackage:async function(e,u){let n=await i();await n.insertInto("kubun_hub_key_packages").values({owner_did:e,key_package:u}).execute()},fetchKeyPackages:async function(e,u){let n=await i();return(await n.deleteFrom("kubun_hub_key_packages").where("id","in",n.selectFrom("kubun_hub_key_packages").select("id").where("owner_did","=",e).orderBy("id","asc").limit(u??1)).returning("key_package").execute()).map(e=>e.key_package)},setGroupMembers:async function(e,u){let n=await i();await n.deleteFrom("kubun_hub_group_members").where("group_id","=",e).execute(),u.length>0&&await n.insertInto("kubun_hub_group_members").values(u.map(u=>({group_id:e,member_did:u}))).execute()},getGroupMembers:async function(e){let u=await i();return(await u.selectFrom("kubun_hub_group_members").select("member_did").where("group_id","=",e).execute()).map(e=>e.member_did)}}}
+import { EventEmitter } from '@sozai/event';
+export function createHubStore(params) {
+    const { adapter } = params;
+    // Lazy DB resolution -- accepts Kysely or Promise<Kysely> and caches the resolved instance
+    let resolvedDB;
+    async function db() {
+        if (resolvedDB == null) {
+            resolvedDB = await params.kysely;
+        }
+        return resolvedDB;
+    }
+    // Lazy sequence counter -- initialized from DB on first publish() call
+    let sequenceCounter;
+    async function nextSequenceID() {
+        const kysely = await db();
+        if (sequenceCounter == null) {
+            const maxRow = await kysely.selectFrom('kubun_hub_messages').select(kysely.fn.max('sequence_id').as('max_id')).executeTakeFirst();
+            sequenceCounter = maxRow?.max_id != null ? Number.parseInt(maxRow.max_id, 10) : 0;
+        }
+        sequenceCounter++;
+        return String(sequenceCounter).padStart(12, '0');
+    }
+    const events = new EventEmitter();
+    async function publish(publishParams) {
+        const sequenceID = await nextSequenceID();
+        const kysely = await db();
+        // Recipients = current subscribers minus the sender. Zero recipients (no
+        // subscribers, or only the sender) means there is nothing to deliver, so the
+        // sequence is consumed but no message or delivery rows are stored.
+        const subscribers = await getSubscribers(publishParams.topicID);
+        const recipients = subscribers.filter((did)=>did !== publishParams.senderDID);
+        if (recipients.length === 0) {
+            return sequenceID;
+        }
+        const storedAt = Date.now();
+        // The message row and its delivery rows are written in one transaction: a
+        // partial write (message stored, deliveries failed) would orphan a message
+        // with zero deliveries — never fetched, never acked, never GC'd by `ack`,
+        // reclaimed only by the age-based purge.
+        await kysely.transaction().execute(async (trx)=>{
+            await trx.insertInto('kubun_hub_messages').values({
+                sequence_id: sequenceID,
+                sender_did: publishParams.senderDID,
+                topic_id: publishParams.topicID,
+                payload: adapter.encodeBinary(publishParams.payload),
+                stored_at: storedAt
+            }).execute();
+            await trx.insertInto('kubun_hub_deliveries').values(recipients.map((did)=>({
+                    sequence_id: sequenceID,
+                    recipient_did: did
+                }))).execute();
+        });
+        return sequenceID;
+    }
+    async function fetch(fetchParams) {
+        // Process acks first if provided
+        if (fetchParams.ack != null && fetchParams.ack.length > 0) {
+            await ack({
+                recipientDID: fetchParams.recipientDID,
+                sequenceIDs: fetchParams.ack
+            });
+        }
+        const kysely = await db();
+        let query = kysely.selectFrom('kubun_hub_deliveries').innerJoin('kubun_hub_messages', 'kubun_hub_messages.sequence_id', 'kubun_hub_deliveries.sequence_id').select([
+            'kubun_hub_messages.sequence_id',
+            'kubun_hub_messages.sender_did',
+            'kubun_hub_messages.topic_id',
+            'kubun_hub_messages.payload'
+        ]).where('kubun_hub_deliveries.recipient_did', '=', fetchParams.recipientDID).orderBy('kubun_hub_messages.sequence_id', 'asc');
+        if (fetchParams.after != null) {
+            query = query.where('kubun_hub_messages.sequence_id', '>', fetchParams.after);
+        }
+        const limit = fetchParams.limit;
+        if (limit != null) {
+            query = query.limit(limit + 1); // fetch one extra to determine hasMore
+        }
+        const rows = await query.execute();
+        let hasMore = false;
+        let resultRows = rows;
+        if (limit != null && rows.length > limit) {
+            hasMore = true;
+            resultRows = rows.slice(0, limit);
+        }
+        const messages = resultRows.map((row)=>({
+                sequenceID: row.sequence_id,
+                senderDID: row.sender_did,
+                topicID: row.topic_id,
+                payload: row.payload
+            }));
+        const cursor = messages.length > 0 ? messages[messages.length - 1].sequenceID : null;
+        return {
+            messages,
+            cursor,
+            hasMore
+        };
+    }
+    async function ack(ackParams) {
+        if (ackParams.sequenceIDs.length === 0) return;
+        const kysely = await db();
+        // Remove delivery entries for this recipient
+        await kysely.deleteFrom('kubun_hub_deliveries').where('recipient_did', '=', ackParams.recipientDID).where('sequence_id', 'in', ackParams.sequenceIDs).execute();
+        // Clean up messages with no remaining deliveries (all recipients acked)
+        const withDeliveries = await kysely.selectFrom('kubun_hub_deliveries').select('sequence_id').where('sequence_id', 'in', ackParams.sequenceIDs).execute();
+        const stillDelivered = new Set(withDeliveries.map((r)=>r.sequence_id));
+        const fullyAcked = ackParams.sequenceIDs.filter((id)=>!stillDelivered.has(id));
+        if (fullyAcked.length > 0) {
+            await kysely.deleteFrom('kubun_hub_messages').where('sequence_id', 'in', fullyAcked).execute();
+        }
+    }
+    async function purge(purgeParams) {
+        const kysely = await db();
+        const threshold = Date.now() - purgeParams.olderThan * 1000;
+        const oldMessages = await kysely.selectFrom('kubun_hub_messages').select('sequence_id').where('stored_at', '<=', threshold).execute();
+        const sequenceIDs = oldMessages.map((m)=>m.sequence_id);
+        if (sequenceIDs.length === 0) return [];
+        await kysely.deleteFrom('kubun_hub_deliveries').where('sequence_id', 'in', sequenceIDs).execute();
+        await kysely.deleteFrom('kubun_hub_messages').where('sequence_id', 'in', sequenceIDs).execute();
+        await events.emit('purge', {
+            sequenceIDs
+        });
+        return sequenceIDs;
+    }
+    async function storeKeyPackage(ownerDID, keyPackage) {
+        const kysely = await db();
+        await kysely.insertInto('kubun_hub_key_packages').values({
+            owner_did: ownerDID,
+            key_package: keyPackage
+        }).execute();
+    }
+    async function fetchKeyPackages(ownerDID, count) {
+        const kysely = await db();
+        const limit = count ?? 1;
+        // Atomic delete-returning: a non-atomic select+delete pair would let two
+        // concurrent fetches return the same key package twice.
+        const rows = await kysely.deleteFrom('kubun_hub_key_packages').where('id', 'in', kysely.selectFrom('kubun_hub_key_packages').select('id').where('owner_did', '=', ownerDID).orderBy('id', 'asc').limit(limit)).returning('key_package').execute();
+        return rows.map((r)=>r.key_package);
+    }
+    async function subscribe(subscriberDID, topicID) {
+        const kysely = await db();
+        // Upsert on the (topic_id, subscriber_did) primary key so re-subscribing an
+        // existing subscriber refreshes its activity timestamp rather than failing
+        // or duplicating.
+        await kysely.insertInto('kubun_hub_subscriptions').values({
+            topic_id: topicID,
+            subscriber_did: subscriberDID,
+            last_active_at: Date.now()
+        }).onConflict((oc)=>oc.columns([
+                'topic_id',
+                'subscriber_did'
+            ]).doUpdateSet({
+                last_active_at: (eb)=>eb.ref('excluded.last_active_at')
+            })).execute();
+    }
+    async function unsubscribe(subscriberDID, topicID) {
+        const kysely = await db();
+        await kysely.deleteFrom('kubun_hub_subscriptions').where('topic_id', '=', topicID).where('subscriber_did', '=', subscriberDID).execute();
+        // Drop this subscriber's pending deliveries for the topic, then GC any
+        // message left without a recipient (refcount → 0), mirroring ack cleanup.
+        const pending = await kysely.selectFrom('kubun_hub_deliveries').innerJoin('kubun_hub_messages', 'kubun_hub_messages.sequence_id', 'kubun_hub_deliveries.sequence_id').select('kubun_hub_deliveries.sequence_id').where('kubun_hub_deliveries.recipient_did', '=', subscriberDID).where('kubun_hub_messages.topic_id', '=', topicID).execute();
+        if (pending.length === 0) return;
+        const sequenceIDs = pending.map((r)=>r.sequence_id);
+        await kysely.deleteFrom('kubun_hub_deliveries').where('recipient_did', '=', subscriberDID).where('sequence_id', 'in', sequenceIDs).execute();
+        const remaining = await kysely.selectFrom('kubun_hub_deliveries').select('sequence_id').where('sequence_id', 'in', sequenceIDs).execute();
+        const stillDelivered = new Set(remaining.map((r)=>r.sequence_id));
+        const orphaned = sequenceIDs.filter((id)=>!stillDelivered.has(id));
+        if (orphaned.length > 0) {
+            await kysely.deleteFrom('kubun_hub_messages').where('sequence_id', 'in', orphaned).execute();
+        }
+    }
+    async function getSubscribers(topicID) {
+        const kysely = await db();
+        const rows = await kysely.selectFrom('kubun_hub_subscriptions').select('subscriber_did').where('topic_id', '=', topicID).execute();
+        return rows.map((r)=>r.subscriber_did);
+    }
+    async function purgeSubscribers(purgeParams) {
+        const kysely = await db();
+        // Strict `<`: a row refreshed exactly at the boundary survives. Subscription
+        // retention runs on a much longer window than message purge.
+        const threshold = Date.now() - purgeParams.olderThan * 1000;
+        // Atomic delete-and-return so the reported set exactly matches the rows
+        // actually removed — a subscriber who rejoins between evaluating and deleting
+        // is neither reaped nor over-reported. Mirrors `fetchKeyPackages`.
+        const deletedRows = await kysely.deleteFrom('kubun_hub_subscriptions').where('last_active_at', '<', threshold).returning([
+            'topic_id',
+            'subscriber_did'
+        ]).execute();
+        return deletedRows.map((row)=>({
+                topicID: row.topic_id,
+                subscriberDID: row.subscriber_did
+            }));
+    }
+    return {
+        events,
+        publish,
+        fetch,
+        ack,
+        purge,
+        purgeSubscribers,
+        storeKeyPackage,
+        fetchKeyPackages,
+        subscribe,
+        unsubscribe,
+        getSubscribers
+    };
+}

package/lib/index.d.ts

@@ -1,13 +1,13 @@
-import type { Identity } from '@enkaku/token';
+import type { Identity } from '@kokuin/token';
 import type { Adapter } from '@kubun/db-adapter';
 import type { Kysely } from 'kysely';
 import { type HubAuthConfig, type RelayRetentionConfig } from './create-relay.js';
 import type { HubDatabase } from './hub-store.js';
 import type { RelayObservers } from './observers.js';
 export { type CreateRelayOptions, createRelay, createRelayInternal, type HubAuthConfig, type Relay, type RelayRetentionConfig, } from './create-relay.js';
-export { type CreateHubStoreParams, createHubStore, type HubDatabase } from './hub-store.js';
+export { type CreateHubStoreParams, createHubStore, type HubDatabase, type KubunHubStore, type PurgedSubscription, type PurgeSubscriptionsParams, } from './hub-store.js';
 export { createHubMigrations, type MigrationContext } from './migrations.js';
-export { decorateHubStore, type RelayObserverAckInfo, type RelayObserverAuthRejectedInfo, type RelayObserverErrorInfo, type RelayObserverErrorStage, type RelayObserverFetchInfo, type RelayObserverPurgeInfo, type RelayObserverStoreInfo, type RelayObservers, } from './observers.js';
+export { decorateHubStore, type RelayObserverAckInfo, type RelayObserverAuthRejectedInfo, type RelayObserverErrorInfo, type RelayObserverErrorStage, type RelayObserverFetchInfo, type RelayObserverPurgeInfo, type RelayObserverRetentionConfigClampedInfo, type RelayObserverStoreInfo, type RelayObserverSubscriptionPurgeInfo, type RelayObservers, } from './observers.js';
 export type HubOptions = {
     /** Kysely instance for the hub database. */
     kysely: Kysely<HubDatabase>;
@@ -18,14 +18,14 @@ export type HubOptions = {
     /** Allowed CORS origin(s). Default: ['*']. */
     allowedOrigin?: string | Array<string>;
     /**
-     * Hub server identity. Required when `auth` is provided — the server
-     * signs response tokens and clients pin its DID for TOFU verification.
+     * Hub server identity. Required — the server signs response tokens, derives
+     * the sender DID from each verified request, and clients pin its DID for
+     * TOFU verification.
      */
-    identity?: Identity;
+    identity: Identity;
     /**
-     * Authentication configuration. When omitted, the hub runs without
-     * access control (back-compat). When provided, `identity` must also be
-     * provided.
+     * Authentication configuration layered over the required identity. When
+     * omitted, no access rules are configured beyond signature verification.
      */
     auth?: HubAuthConfig;
     /** Optional retention scheduler. */

package/lib/index.js

@@ -1 +1,42 @@
-import{serve as e}from"@hono/node-server";import t from"get-port";import{Hono as r}from"hono";import{createRelayInternal as o}from"./create-relay.js";export{createRelay,createRelayInternal}from"./create-relay.js";export{createHubStore}from"./hub-store.js";export{createHubMigrations}from"./migrations.js";export{decorateHubStore}from"./observers.js";export async function createHub(a){let s=await o({kysely:a.kysely,adapter:a.adapter,identity:a.identity,auth:a.auth,allowedOrigin:a.allowedOrigin,retention:a.retention,observers:a.observers,ownsKysely:!1}),i=new r;i.get("/health",e=>e.json({status:"ok"})),i.post("*",async e=>s.fetch(e.req.raw)),i.options("*",async e=>s.fetch(e.req.raw));let n=a.port??await t(),c=`http://localhost:${n}`,l=await new Promise(t=>{let r=e({fetch:i.fetch,port:n},()=>t(r))});return{port:n,url:c,dispose:async()=>{await s.dispose(),l.close()}}}
+import { serve } from '@hono/node-server';
+import getPort from 'get-port';
+import { Hono } from 'hono';
+import { createRelayInternal } from './create-relay.js';
+export { createRelay, createRelayInternal } from './create-relay.js';
+export { createHubStore } from './hub-store.js';
+export { createHubMigrations } from './migrations.js';
+export { decorateHubStore } from './observers.js';
+export async function createHub(options) {
+    const relay = await createRelayInternal({
+        kysely: options.kysely,
+        adapter: options.adapter,
+        identity: options.identity,
+        auth: options.auth,
+        allowedOrigin: options.allowedOrigin,
+        retention: options.retention,
+        observers: options.observers,
+        ownsKysely: false
+    });
+    const app = new Hono();
+    app.get('/health', (c)=>c.json({
+            status: 'ok'
+        }));
+    app.post('*', async (c)=>relay.fetch(c.req.raw));
+    app.options('*', async (c)=>relay.fetch(c.req.raw));
+    const port = options.port ?? await getPort();
+    const url = `http://localhost:${port}`;
+    const httpServer = await new Promise((resolve)=>{
+        const server = serve({
+            fetch: app.fetch,
+            port
+        }, ()=>resolve(server));
+    });
+    return {
+        port,
+        url,
+        dispose: async ()=>{
+            await relay.dispose();
+            httpServer.close();
+        }
+    };
+}

package/lib/migrations.js

@@ -1 +1,31 @@
-export function createHubMigrations(e){let t=e.types;return{"001_create_hub_tables":{async up(e){await e.schema.createTable("kubun_hub_messages").ifNotExists().addColumn("sequence_id",t.text,e=>e.notNull().primaryKey()).addColumn("sender_did",t.text,e=>e.notNull()).addColumn("group_id",t.text).addColumn("payload",t.binary,e=>e.notNull()).addColumn("stored_at","integer",e=>e.notNull()).execute(),await e.schema.createTable("kubun_hub_deliveries").ifNotExists().addColumn("sequence_id",t.text,e=>e.notNull()).addColumn("recipient_did",t.text,e=>e.notNull()).addPrimaryKeyConstraint("pk_hub_deliveries",["sequence_id","recipient_did"]).execute(),await e.schema.createIndex("idx_hub_deliveries_recipient").ifNotExists().on("kubun_hub_deliveries").column("recipient_did").execute(),await e.schema.createTable("kubun_hub_key_packages").ifNotExists().addColumn("id",t.serial,e=>e.primaryKey()).addColumn("owner_did",t.text,e=>e.notNull()).addColumn("key_package",t.text,e=>e.notNull()).execute(),await e.schema.createIndex("idx_hub_key_packages_owner").ifNotExists().on("kubun_hub_key_packages").column("owner_did").execute(),await e.schema.createTable("kubun_hub_group_members").ifNotExists().addColumn("group_id",t.text,e=>e.notNull()).addColumn("member_did",t.text,e=>e.notNull()).addPrimaryKeyConstraint("pk_hub_group_members",["group_id","member_did"]).execute()},async down(e){await e.schema.dropTable("kubun_hub_group_members").ifExists().execute(),await e.schema.dropTable("kubun_hub_key_packages").ifExists().execute(),await e.schema.dropTable("kubun_hub_deliveries").ifExists().execute(),await e.schema.dropTable("kubun_hub_messages").ifExists().execute()}}}}
+export function createHubMigrations(ctx) {
+    const t = ctx.types;
+    return {
+        '001_create_hub_tables': {
+            async up (db) {
+                // Hub messages
+                await db.schema.createTable('kubun_hub_messages').ifNotExists().addColumn('sequence_id', t.text, (col)=>col.notNull().primaryKey()).addColumn('sender_did', t.text, (col)=>col.notNull()).addColumn('topic_id', t.text, (col)=>col.notNull()).addColumn('payload', t.binary, (col)=>col.notNull()).addColumn('stored_at', t.bigint, (col)=>col.notNull()).execute();
+                // Hub deliveries
+                await db.schema.createTable('kubun_hub_deliveries').ifNotExists().addColumn('sequence_id', t.text, (col)=>col.notNull()).addColumn('recipient_did', t.text, (col)=>col.notNull()).addPrimaryKeyConstraint('pk_hub_deliveries', [
+                    'sequence_id',
+                    'recipient_did'
+                ]).execute();
+                await db.schema.createIndex('idx_hub_deliveries_recipient').ifNotExists().on('kubun_hub_deliveries').column('recipient_did').execute();
+                // Hub key packages
+                await db.schema.createTable('kubun_hub_key_packages').ifNotExists().addColumn('id', t.serial, (col)=>col.primaryKey()).addColumn('owner_did', t.text, (col)=>col.notNull()).addColumn('key_package', t.text, (col)=>col.notNull()).execute();
+                await db.schema.createIndex('idx_hub_key_packages_owner').ifNotExists().on('kubun_hub_key_packages').column('owner_did').execute();
+                // Hub subscriptions
+                await db.schema.createTable('kubun_hub_subscriptions').ifNotExists().addColumn('topic_id', t.text, (col)=>col.notNull()).addColumn('subscriber_did', t.text, (col)=>col.notNull()).addColumn('last_active_at', t.bigint, (col)=>col.notNull().defaultTo(0)).addPrimaryKeyConstraint('pk_hub_subscriptions', [
+                    'topic_id',
+                    'subscriber_did'
+                ]).execute();
+            },
+            async down (db) {
+                await db.schema.dropTable('kubun_hub_subscriptions').ifExists().execute();
+                await db.schema.dropTable('kubun_hub_key_packages').ifExists().execute();
+                await db.schema.dropTable('kubun_hub_deliveries').ifExists().execute();
+                await db.schema.dropTable('kubun_hub_messages').ifExists().execute();
+            }
+        }
+    };
+}

package/lib/observers.d.ts

@@ -1,8 +1,7 @@
-import type { HubStore } from '@enkaku/hub-protocol';
+import type { KubunHubStore } from './hub-store.js';
 export type RelayObserverStoreInfo = {
     senderDID: string;
-    groupID?: string;
-    recipientCount: number;
+    topicID: string;
     sequenceID: string;
 };
 export type RelayObserverFetchInfo = {
@@ -16,10 +15,17 @@ export type RelayObserverAckInfo = {
 export type RelayObserverPurgeInfo = {
     sequenceCount: number;
 };
+export type RelayObserverSubscriptionPurgeInfo = {
+    subscriptionCount: number;
+};
 export type RelayObserverAuthRejectedInfo = {
     reason: string;
 };
-export type RelayObserverErrorStage = 'store' | 'fetch' | 'ack' | 'purge';
+export type RelayObserverRetentionConfigClampedInfo = {
+    configuredSubscriptionOlderThanSeconds: number;
+    clampedToSeconds: number;
+};
+export type RelayObserverErrorStage = 'store' | 'fetch' | 'ack' | 'purge' | 'subscription-purge';
 export type RelayObserverErrorInfo = {
     stage: RelayObserverErrorStage;
     error: unknown;
@@ -29,7 +35,9 @@ export type RelayObservers = {
     onFetch?: (info: RelayObserverFetchInfo) => void;
     onAck?: (info: RelayObserverAckInfo) => void;
     onPurge?: (info: RelayObserverPurgeInfo) => void;
+    onSubscriptionPurge?: (info: RelayObserverSubscriptionPurgeInfo) => void;
     onAuthRejected?: (info: RelayObserverAuthRejectedInfo) => void;
+    onRetentionConfigClamped?: (info: RelayObserverRetentionConfigClampedInfo) => void;
     onError?: (info: RelayObserverErrorInfo) => void;
 };
-export declare function decorateHubStore(store: HubStore, observers?: RelayObservers): HubStore;
+export declare function decorateHubStore(store: KubunHubStore, observers?: RelayObservers): KubunHubStore;

package/lib/observers.js

@@ -1 +1,71 @@
-function e(e,t){if(null!=e)try{e(t)}catch{}}export function decorateHubStore(t,r){if(null==r)return t;let{onStore:n,onFetch:c,onAck:s,onError:a}=r;return{events:t.events,storeKeyPackage:t.storeKeyPackage.bind(t),fetchKeyPackages:t.fetchKeyPackages.bind(t),setGroupMembers:t.setGroupMembers.bind(t),getGroupMembers:t.getGroupMembers.bind(t),purge:t.purge.bind(t),async store(r){try{let c=await t.store(r);return e(n,{senderDID:r.senderDID,groupID:r.groupID,recipientCount:r.recipients.length,sequenceID:c}),c}catch(t){throw e(a,{stage:"store",error:t}),t}},async fetch(r){try{let n=await t.fetch(r);return e(c,{recipientDID:r.recipientDID,messageCount:n.messages.length}),n}catch(t){throw e(a,{stage:"fetch",error:t}),t}},async ack(r){try{await t.ack(r),e(s,{recipientDID:r.recipientDID,sequenceCount:r.sequenceIDs.length})}catch(t){throw e(a,{stage:"ack",error:t}),t}}}}
+function safeCall(callback, info) {
+    if (callback == null) return;
+    try {
+        callback(info);
+    } catch  {
+    // Observer callbacks are diagnostics — never let them break the relay.
+    }
+}
+export function decorateHubStore(store, observers) {
+    if (observers == null) return store;
+    const { onStore, onFetch, onAck, onError } = observers;
+    const wrappedStore = {
+        events: store.events,
+        storeKeyPackage: store.storeKeyPackage.bind(store),
+        fetchKeyPackages: store.fetchKeyPackages.bind(store),
+        subscribe: store.subscribe.bind(store),
+        unsubscribe: store.unsubscribe.bind(store),
+        getSubscribers: store.getSubscribers.bind(store),
+        purgeSubscribers: store.purgeSubscribers.bind(store),
+        purge: store.purge.bind(store),
+        async publish (params) {
+            try {
+                const sequenceID = await store.publish(params);
+                safeCall(onStore, {
+                    senderDID: params.senderDID,
+                    topicID: params.topicID,
+                    sequenceID
+                });
+                return sequenceID;
+            } catch (error) {
+                safeCall(onError, {
+                    stage: 'store',
+                    error
+                });
+                throw error;
+            }
+        },
+        async fetch (params) {
+            try {
+                const result = await store.fetch(params);
+                safeCall(onFetch, {
+                    recipientDID: params.recipientDID,
+                    messageCount: result.messages.length
+                });
+                return result;
+            } catch (error) {
+                safeCall(onError, {
+                    stage: 'fetch',
+                    error
+                });
+                throw error;
+            }
+        },
+        async ack (params) {
+            try {
+                await store.ack(params);
+                safeCall(onAck, {
+                    recipientDID: params.recipientDID,
+                    sequenceCount: params.sequenceIDs.length
+                });
+            } catch (error) {
+                safeCall(onError, {
+                    stage: 'ack',
+                    error
+                });
+                throw error;
+            }
+        }
+    };
+    return wrappedStore;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/hub",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "license": "see LICENSE.md",
   "type": "module",
   "main": "lib/index.js",
@@ -14,31 +14,35 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@enkaku/event": "^0.16.0",
-    "@enkaku/http-server-transport": "^0.16.0",
-    "@enkaku/hub-protocol": "^0.16.0",
-    "@enkaku/hub-server": "^0.16.0",
-    "@enkaku/server": "^0.16.0",
-    "@enkaku/token": "^0.16.0",
-    "@hono/node-server": "^2.0.4",
+    "@sozai/event": "^0.1.0",
+    "@enkaku/http-serve": "^0.18.1",
+    "@kumiai/hub-protocol": "^0.1.0",
+    "@kumiai/hub-server": "^0.1.0",
+    "@enkaku/server": "^0.18.1",
+    "@kokuin/token": "^0.1.1",
+    "@hono/node-server": "^2.0.8",
     "get-port": "^7.2.0",
-    "hono": "^4.12.23",
+    "hono": "^4.12.27",
     "kysely": "^0.29.2",
-    "@kubun/db-adapter": "^0.10.0",
-    "@kubun/db-provider": "^0.10.0"
+    "@kubun/db-adapter": "^0.11.0",
+    "@kubun/http-util": "^0.11.0",
+    "@kubun/db-provider": "^0.11.0"
   },
   "devDependencies": {
-    "@enkaku/async": "^0.16.0",
-    "@enkaku/client": "^0.16.0",
-    "@enkaku/http-client-transport": "^0.16.0",
-    "@enkaku/protocol": "^0.16.0",
-    "@enkaku/transport": "^0.16.0",
-    "@kubun/db-node-sqlite": "^0.10.0",
-    "@kubun/db-better-sqlite": "^0.10.0"
+    "@sozai/async": "^0.1.0",
+    "@enkaku/client": "^0.18.1",
+    "@kumiai/mls": "^0.1.0",
+    "@enkaku/http-fetch": "^0.18.1",
+    "@enkaku/protocol": "^0.18.1",
+    "@enkaku/transport": "^0.18.1",
+    "@testcontainers/postgresql": "^12.0.4",
+    "@kubun/db-better-sqlite": "^0.11.0",
+    "@kubun/db-postgres": "^0.11.0",
+    "@kubun/db-node-sqlite": "^0.11.0"
   },
   "scripts": {
     "build:clean": "del lib",
-    "build:js": "swc src -d ./lib --config-file ../../swc.json --strip-leading-paths",
+    "build:js": "swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
     "build:types": "tsc --emitDeclarationOnly --skipLibCheck",
     "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types"
   }