@kubun/plugin-p2p 0.10.0 → 0.11.0

package/lib/index.js

@@ -1 +1,392 @@
-import{ServerTransport as e}from"@enkaku/http-server-transport";import{Server as r}from"@enkaku/server";import{isFullIdentity as t}from"@enkaku/token";import{DirectTransports as o}from"@enkaku/transport";import{HLC as s}from"@kubun/hlc";import{p2pStoreDefinition as n}from"@kubun/store-p2p";import{createDelegationContext as a}from"./context/delegation.js";import{createGroupContext as i}from"./context/group.js";import{createHubContext as c}from"./context/hub.js";import{createJoinContext as p}from"./context/join.js";import{createSyncContext as d}from"./context/sync.js";import{createP2PEventEmitter as u}from"./groups/events.js";import{GroupHandleRegistry as l}from"./groups/group-handle-registry.js";import{GroupManager as g}from"./groups/manager.js";import{forwardRemoteBroadcast as m}from"./hub/forward-remote-broadcast.js";import{createHTTPHubClient as b}from"./hub/http-client.js";import{captureServerDID as y}from"./hub/manager.js";import{DISABLED_HUB as f,setupHubRelay as h}from"./hub/wiring.js";import{createP2PSchemaExtension as j}from"./schema.js";import{createBroadcastQueue as v,DEFAULT_BROADCAST_BATCH_CONFIG as x}from"./sync/broadcast-queue.js";import{DEFAULT_PUSH_SYNC_CONFIG as S,wireBroadcastSender as w}from"./sync/broadcast-sender.js";import{createSyncHandlers as D}from"./sync/handlers.js";import{SyncManager as P}from"./sync/sync-manager.js";export{processBroadcast}from"./groups/broadcast.js";export{deserializeBroadcast,serializeBroadcast}from"./groups/broadcast-codec.js";export{ApplyError,BroadcastService,DecryptError}from"./groups/broadcast-service.js";export{createFilteredGenerator,createP2PEventEmitter}from"./groups/events.js";export{GroupHandleRegistry}from"./groups/group-handle-registry.js";export{decodeFullJoinRequest,decodeInvitePayload,decodeJoinRequest,encodeFullJoinRequest,encodeInvitePayload,encodeJoinRequest}from"./groups/invite-payload.js";export{GroupManager}from"./groups/manager.js";export{MLSEncryptor}from"./groups/mls-encryptor.js";export{restoreMLSGroupHandle}from"./groups/mls-group-handle.js";export{replacer as mlsJSONReplacer,reviver as mlsJSONReviver}from"./groups/mls-json.js";export{deserializeMLSGroupState,serializeMLSGroupState}from"./groups/mls-state.js";export{createP2PSchemaExtension}from"./schema.js";export{createBroadcastQueue,DEFAULT_BROADCAST_BATCH_CONFIG}from"./sync/broadcast-queue.js";export{DEFAULT_PUSH_SYNC_CONFIG,wireBroadcastSender}from"./sync/broadcast-sender.js";export{resolveCatalogSyncScopes}from"./sync/catalog-scope.js";export{evaluateAndForward}from"./sync/forwarder.js";export{checkSyncDelegation,negotiateDirection}from"./sync/handlers.js";export{HubTunnelSyncListener}from"./sync/hub-tunnel-sync-listener.js";export{HubTunnelSyncProvider}from"./sync/hub-tunnel-sync-provider.js";export{PeerRegistry}from"./sync/peer-registry.js";export{SyncClient}from"./sync/sync-client.js";export{SyncManager}from"./sync/sync-manager.js";export{DIDObservingTransport}from"./hub/did-observing-transport.js";export{ReconnectingError}from"./hub/errors.js";export{createHTTPHubClient}from"./hub/http-client.js";export{bindHubToGroup,captureServerDID,createHub,deleteHub,getHub,HubServerDIDConflictError,listGroupsByHub,listHubs,listHubsByGroup,unbindHubFromGroup,updateHub,upsertHub}from"./hub/manager.js";export{HubRelayManager}from"./hub/relay-manager.js";export{DISABLED_HUB,setupHubRelay}from"./hub/wiring.js";export const DEFAULT_RECEIVE_CONFIG={storeUnreadable:"persist"};export function createP2PPlugin(I){return R=>{var E;let H,L,B,C;R.db.register(n);let G=R.db.adapter;if(!(t(E=R.identity)&&"privateKey"in E))throw Error("createP2PPlugin requires an OwnIdentity (full identity with privateKey) — received a narrower Identity");let A=R.identity,F=new s({nodeID:A.id}),k={...DEFAULT_RECEIVE_CONFIG,...I?.receive},T=I?.defaultAccessLevel??{read:"only_owner",write:"only_owner"},U=new l({stores:R.db,deviceID:A.id,logger:R.getLogger("group-handle-registry")}),_=new g({identity:A,getRandomID:R.runtime.getRandomID,registry:U}),O=u(),q=new P({deployClusters:async e=>{let r=Object.values(e);await R.engine.deployGraph({clusters:r})},graph:R.graph,runtime:R.runtime,identity:R.identity,logger:R.getLogger("sync"),storeUnreadable:k.storeUnreadable,defaultAccessLevel:T}),N=D({db:R.db,graph:R.graph,logger:R.getLogger("sync-handlers"),peerRegistry:q.peerRegistry,selfDID:A.id,storeUnreadable:k.storeUnreadable,defaultAccessLevel:T}),M=new Map,J=[],z=R.getLogger("hub-relay"),K=f,V={...S,...I?.pushSync};if(I?.hub){let e="object"==typeof I.hub&&null!=I.hub.createHubClient?I.hub.createHubClient:b({identity:A,fetch:R.runtime.fetch});K=h({identity:A,db:R.db,graph:R.graph,emitter:O,createHubClient:e,registry:U,onRemoteBroadcast:e=>{m(O,e,z).catch(e=>{z.error("forwardRemoteBroadcast failed",{error:e})})},logger:z,storeUnreadable:k.storeUnreadable,defaultAccessLevel:T,forwarding:I.forwarding,onServerDIDObserved:({hubURL:e,serverDID:r})=>y({stores:R.db,hubURL:e,serverDID:r}).then(()=>void 0)}),V.enabled&&(L=v({config:{...x,...I.batch},scheduleBroadcast:K.scheduleBroadcast,logger:R.getLogger("broadcast-queue")}),H=w({db:R.db,eventBus:R.eventBus,selfDID:A.id,queue:L,logger:R.getLogger("broadcast-sender")}))}let W={hubReady:K.ready,addPeer:e=>q.addPeer({config:e,stores:R.db}),removePeer:e=>q.removePeer({peerDID:e,stores:R.db}),listPeers:()=>q.listPeers({stores:R.db}),syncWithPeer:e=>q.merkleSyncWithPeer({...e,stores:R.db}),getStatus:e=>q.getStatus({peerDID:e,stores:R.db}),onSyncEvent:e=>q.onSyncEvent(e),createSyncTransport:function(e){let t=new o({signal:e}),s=new r({getRandomID:R.runtime.getRandomID,handlers:N,logger:R.getLogger("sync-server"),transports:[t.server],signal:e});return J.push(s),t.client}};if(I?.http){let t="string"==typeof I.http?I.http.replace(/^\//,""):"sync";W.syncReady=(async()=>{let o=await R.engine.getAPI("http");await o.listening,B=new e({allowedOrigin:["*"]}),C=new r({getRandomID:R.runtime.getRandomID,handlers:N,logger:R.getLogger("sync-http-server"),transports:[B]}),J.push(C),o.registerProtocol(t,B.fetch.bind(B))})()}return{name:"p2p",schemaExtension:e=>j(O),api:W,createContextFactory:()=>(e,r)=>{let t={identity:A,groupManager:_,registry:U,syncManager:q,stores:r,adapter:G,hlc:F,emitter:O,pendingJoinRequests:M,runtime:R.runtime,autoAcceptPeers:I?.autoAcceptPeers,scheduleBroadcast:K.scheduleBroadcast,broadcastNow:K.broadcastNow,scheduleSendCommit:K.scheduleSendCommit,logger:R.getLogger("context")};return{group:i(e,t),sync:d(e,t),join:p(e,t),hub:c(e,t),delegation:a(e,t)}},dispose:async()=>{if(null!=H)try{H()}catch{}if(null!=L)try{L.dispose()}catch{}let e=(async()=>{for(let e of J)await e.dispose();null!=B&&await B.dispose()})(),r=R.getLogger("dispose"),t=await Promise.allSettled([e,q.dispose(),K.dispose()]),o=["sync-http","sync-manager","hub"];t.forEach((e,t)=>{"rejected"===e.status&&r.error("dispose branch failed",{branch:o[t],error:e.reason})})}}}}
+import { ServerTransport } from '@enkaku/http-serve';
+import { Server } from '@enkaku/server';
+import { DirectTransports } from '@enkaku/transport';
+import { isFullIdentity } from '@kokuin/token';
+import { resolveAllowedOrigin } from '@kubun/http-util';
+import { p2pStoreDefinition } from '@kubun/store-p2p';
+import { createDelegationContext } from './context/delegation.js';
+import { createGroupContext } from './context/group.js';
+import { createHubContext } from './context/hub.js';
+import { createJoinContext } from './context/join.js';
+import { createSyncContext } from './context/sync.js';
+import { createP2PEventEmitter } from './groups/events.js';
+import { GroupHandleRegistry } from './groups/group-handle-registry.js';
+import { GroupHealthMonitor } from './groups/group-health-monitor.js';
+import { GroupManager } from './groups/manager.js';
+import { createHTTPHubClient } from './hub/http-client.js';
+import { captureServerDID } from './hub/manager.js';
+import { DISABLED_HUB, setupHubRelay } from './hub/wiring.js';
+import { createP2PSchemaExtension } from './schema.js';
+import { createBroadcastQueue, DEFAULT_BROADCAST_BATCH_CONFIG } from './sync/broadcast-queue.js';
+import { DEFAULT_PUSH_SYNC_CONFIG, wireBroadcastSender } from './sync/broadcast-sender.js';
+import { createSyncHandlers } from './sync/handlers.js';
+import { SyncManager } from './sync/sync-manager.js';
+// ---- Re-exports: groups ----
+export { ADMIN_ROLE_ENTRY_TYPE, ADMIN_ROSTER_PROJECTION, adminRosterReducer, applyAdminEntryIncremental, foldAdminRoster, projectAdminRoster, projectAdminRosterFromStore, reprojectAdminRoster } from './groups/admin-roster.js';
+export { processBroadcast } from './groups/broadcast.js';
+export { deserializeBroadcast, serializeBroadcast } from './groups/broadcast-codec.js';
+export { createFilteredGenerator, createP2PEventEmitter } from './groups/events.js';
+export { groupAnchorCapabilities, readGroupAnchor } from './groups/group-anchor.js';
+export { GroupHandleRegistry } from './groups/group-handle-registry.js';
+export { decodeFullJoinRequest, decodeInvitePayload, decodeJoinRequest, encodeFullJoinRequest, encodeInvitePayload, encodeJoinRequest } from './groups/invite-payload.js';
+export { ledgerEntryDigest, signLedgerEntry, verifyLedgerEntry } from './groups/ledger-entry.js';
+export { foldLedger } from './groups/ledger-fold.js';
+export { GroupManager } from './groups/manager.js';
+export { MLSEncryptor } from './groups/mls-encryptor.js';
+export { restoreMLSGroupHandle } from './groups/mls-group-handle.js';
+export { replacer as mlsJSONReplacer, reviver as mlsJSONReviver } from './groups/mls-json.js';
+export { deserializeMLSGroupState, serializeMLSGroupState } from './groups/mls-state.js';
+export { createP2PSchemaExtension } from './schema.js';
+// ---- Re-exports: sync ----
+export { createBroadcastQueue, DEFAULT_BROADCAST_BATCH_CONFIG } from './sync/broadcast-queue.js';
+export { DEFAULT_PUSH_SYNC_CONFIG, wireBroadcastSender } from './sync/broadcast-sender.js';
+export { resolveCatalogSyncScopes } from './sync/catalog-scope.js';
+export { SyncAccessDeniedError } from './sync/errors.js';
+export { evaluateAndForward } from './sync/forwarder.js';
+export { checkSyncDelegation } from './sync/handlers.js';
+export { HubTunnelSyncListener } from './sync/hub-tunnel-sync-listener.js';
+export { HubTunnelSyncProvider } from './sync/hub-tunnel-sync-provider.js';
+export { negotiateDirection, PeerRegistry } from './sync/peer-registry.js';
+export { SyncClient } from './sync/sync-client.js';
+export { SyncManager } from './sync/sync-manager.js';
+// ---- Re-exports: hub ----
+export { DIDObservingTransport } from './hub/did-observing-transport.js';
+export { createHTTPHubClient } from './hub/http-client.js';
+export { bindHubToGroup, captureServerDID, createHub, deleteHub, getHub, HubServerDIDConflictError, listGroupsByHub, listHubs, listHubsByGroup, unbindHubFromGroup, updateHub, upsertHub } from './hub/manager.js';
+export { DISABLED_HUB, setupHubRelay } from './hub/wiring.js';
+/**
+ * Default receive config. Under `'persist'` no gate is built and no extra
+ * DB lookups occur during receive.
+ */ export const DEFAULT_RECEIVE_CONFIG = {
+    storeUnreadable: 'persist'
+};
+// ---- Plugin factory ----
+function isOwnIdentity(identity) {
+    return isFullIdentity(identity) && 'privateKey' in identity;
+}
+export function createP2PPlugin(options) {
+    return (params)=>{
+        params.db.register(p2pStoreDefinition);
+        const adapter = params.db.adapter;
+        if (!isOwnIdentity(params.identity)) {
+            throw new Error('createP2PPlugin requires an OwnIdentity (full identity with privateKey) — received a narrower Identity');
+        }
+        const identity = params.identity;
+        // The engine's single device-wide clock. Sharing it across the p2p group/
+        // circle/member metadata paths (context, GroupManager, BroadcastService)
+        // keeps every write from this device on one monotonic counter, so two
+        // writes in the same millisecond mint strictly-increasing timestamps rather
+        // than identical ones (the second of which would silently lose under
+        // last-writer-wins).
+        const hlc = params.hlc;
+        // ---- Receive config ----
+        // Computed up front so SyncManager + sync handlers + the hub-relay
+        // BroadcastService all see the same receive policy. Hot-path invariant:
+        // when `storeUnreadable === 'persist'` (default), no gate is built and
+        // no extra DB lookups occur.
+        const receiveConfig = {
+            ...DEFAULT_RECEIVE_CONFIG,
+            ...options?.receive
+        };
+        const defaultAccessLevel = options?.defaultAccessLevel ?? {
+            read: 'only_owner',
+            write: 'only_owner'
+        };
+        // ---- Group handle registry ----
+        // Single canonical access point for the device's MLS GroupHandle instances.
+        // Threaded through GroupManager + BroadcastService + (Phase 4) tunnel
+        // listener/provider so all five mutation paths serialize through one
+        // per-group mutex with write-through persist.
+        const registry = new GroupHandleRegistry({
+            stores: params.db,
+            deviceID: identity.id,
+            logger: params.getLogger('group-handle-registry')
+        });
+        // ---- Group manager ----
+        const groupManager = new GroupManager({
+            identity,
+            getRandomID: params.runtime.getRandomID,
+            registry,
+            hlc
+        });
+        const emitter = createP2PEventEmitter();
+        const groupHealthMonitor = new GroupHealthMonitor({
+            emitter,
+            logger: params.getLogger('group-health-monitor')
+        });
+        // ---- Sync manager ----
+        const syncManager = new SyncManager({
+            deployClusters: async (clusters)=>{
+                // Values are ClusterModel objects serialized through the protocol —
+                // cast through unknown since SyncManager doesn't depend on protocol types.
+                const clusterModels = Object.values(clusters);
+                await params.engine.deployGraph({
+                    clusters: clusterModels
+                });
+            },
+            graph: params.graph,
+            runtime: params.runtime,
+            identity: params.identity,
+            logger: params.getLogger('sync'),
+            storeUnreadable: receiveConfig.storeUnreadable,
+            defaultAccessLevel
+        });
+        const syncHandlers = createSyncHandlers({
+            db: params.db,
+            graph: params.graph,
+            logger: params.getLogger('sync-handlers'),
+            peerRegistry: syncManager.peerRegistry,
+            selfDID: identity.id,
+            storeUnreadable: receiveConfig.storeUnreadable,
+            defaultAccessLevel
+        });
+        // ---- Pending join requests (for CLI peering flow) ----
+        const pendingJoinRequests = new Map();
+        // ---- Sync server ----
+        // The p2p plugin manages its own Enkaku server for sync handlers,
+        // separate from plugin-rpc's graph server.
+        const syncServers = [];
+        function createSyncTransport(signal) {
+            const directTransports = new DirectTransports({
+                signal
+            });
+            const server = new Server({
+                getRandomID: params.runtime.getRandomID,
+                handlers: syncHandlers,
+                identity,
+                // Open at the procedure layer by design: the sync protocol's
+                // authorization is enforced downstream, per document (read-ACL and
+                // write-delegation tokens), not by a coarse caller allow-list here.
+                accessRules: {
+                    'sync/*': {
+                        allow: true
+                    }
+                },
+                logger: params.getLogger('sync-server'),
+                transports: [
+                    directTransports.server
+                ],
+                signal
+            });
+            syncServers.push(server);
+            return directTransports.client;
+        }
+        // ---- Hub relay ----
+        const hubRelayLogger = params.getLogger('hub-relay');
+        let hub = DISABLED_HUB;
+        let unwireBroadcastSender;
+        let broadcastQueue;
+        const pushSyncConfig = {
+            ...DEFAULT_PUSH_SYNC_CONFIG,
+            ...options?.pushSync
+        };
+        if (options?.hub) {
+            const createHubClient = typeof options.hub === 'object' && options.hub.createHubClient != null ? options.hub.createHubClient : createHTTPHubClient({
+                identity,
+                fetch: params.runtime.fetch
+            });
+            hub = setupHubRelay({
+                identity,
+                getRandomID: params.runtime.getRandomID,
+                db: params.db,
+                hlc,
+                graph: params.graph,
+                emitter,
+                createHubClient,
+                registry,
+                logger: hubRelayLogger,
+                storeUnreadable: receiveConfig.storeUnreadable,
+                defaultAccessLevel,
+                // TOFU capture. The pool fires this once per fresh client when the
+                // first signed response arrives. Manager-level conflicts are caught
+                // and logged inside the pool; the pinned-DID mismatch path surfaces
+                // a typed error to callers via the transport wrapper.
+                onServerDIDObserved: ({ hubURL, serverDID })=>captureServerDID({
+                        stores: params.db,
+                        hubURL,
+                        serverDID
+                    }).then(()=>undefined)
+            });
+            // Subscribe to locally-authored mutations and fan out per-scope
+            // `mutation:apply` broadcasts through the hub. Gated independently from
+            // the hub itself: the hub is needed for receive + pull regardless, but
+            // push-sync is opt-in via `pushSync.enabled`. With `DISABLED_HUB` we'd
+            // also skip wiring (scheduleBroadcast no-ops + spurious broadcast_log
+            // rows), but the explicit gate here makes intent observable.
+            if (pushSyncConfig.enabled) {
+                const batchConfig = {
+                    ...DEFAULT_BROADCAST_BATCH_CONFIG,
+                    ...options.batch
+                };
+                broadcastQueue = createBroadcastQueue({
+                    config: batchConfig,
+                    scheduleBroadcast: hub.scheduleBroadcast,
+                    logger: params.getLogger('broadcast-queue')
+                });
+                unwireBroadcastSender = wireBroadcastSender({
+                    db: params.db,
+                    eventBus: params.eventBus,
+                    selfDID: identity.id,
+                    queue: broadcastQueue,
+                    logger: params.getLogger('broadcast-sender')
+                });
+            }
+        }
+        // ---- Plugin API ----
+        const pluginAPI = {
+            hubReady: hub.ready,
+            addPeer: (config)=>syncManager.addPeer({
+                    config,
+                    stores: params.db
+                }),
+            removePeer: (peerDID)=>syncManager.removePeer({
+                    peerDID,
+                    stores: params.db
+                }),
+            listPeers: ()=>syncManager.listPeers({
+                    stores: params.db
+                }),
+            syncWithPeer: (syncParams)=>syncManager.merkleSyncWithPeer({
+                    ...syncParams,
+                    stores: params.db
+                }),
+            getStatus: (peerDID)=>syncManager.getStatus({
+                    peerDID,
+                    stores: params.db
+                }),
+            onSyncEvent: (callback)=>syncManager.onSyncEvent(callback),
+            createSyncTransport
+        };
+        // ---- HTTP sync transport (optional) ----
+        let httpSyncTransport;
+        let httpSyncServer;
+        if (options?.http) {
+            // Capture in the outer scope so the union is narrowed before the async
+            // closure below (re-reading options.http inside the IIFE would widen it).
+            const httpOption = options.http;
+            const rawPath = typeof httpOption === 'string' ? httpOption : typeof httpOption === 'object' ? httpOption.path ?? 'sync' : 'sync';
+            const protocolName = rawPath.replace(/^\//, '');
+            // Default-deny cross-origin browser requests, consistent with the other
+            // HTTP surfaces. The sync server authenticates every request (signed
+            // Enkaku procedures), so CORS is defense-in-depth here, not the security
+            // boundary; non-browser sync clients send no Origin and are unaffected.
+            // Operators opt into cross-origin via the object form's `allowedOrigin`.
+            const allowedOrigin = resolveAllowedOrigin(typeof httpOption === 'object' ? httpOption.allowedOrigin : undefined);
+            // Maximum request body size, enforced by the transport (default 1 MiB,
+            // matching the Enkaku ServerTransport default).
+            const maxRequestBodySize = (typeof httpOption === 'object' ? httpOption.bodyLimit : undefined) ?? 1024 * 1024;
+            pluginAPI.syncReady = (async ()=>{
+                const httpAPI = await params.engine.getAPI('http');
+                await httpAPI.listening;
+                httpSyncTransport = new ServerTransport({
+                    allowedOrigin,
+                    maxRequestBodySize
+                });
+                httpSyncServer = new Server({
+                    getRandomID: params.runtime.getRandomID,
+                    handlers: syncHandlers,
+                    identity,
+                    // Open at the procedure layer by design: the sync protocol's
+                    // authorization is enforced downstream, per document (read-ACL and
+                    // write-delegation tokens), not by a coarse caller allow-list here.
+                    accessRules: {
+                        'sync/*': {
+                            allow: true
+                        }
+                    },
+                    logger: params.getLogger('sync-http-server'),
+                    transports: [
+                        httpSyncTransport
+                    ]
+                });
+                syncServers.push(httpSyncServer);
+                httpAPI.registerProtocol(protocolName, httpSyncTransport.fetch.bind(httpSyncTransport));
+            })();
+        }
+        return {
+            name: 'p2p',
+            schemaExtension: (_config)=>createP2PSchemaExtension(emitter, params.getLogger('p2p-schema')),
+            api: pluginAPI,
+            createContextFactory: ()=>{
+                return (ctx, stores)=>{
+                    const deps = {
+                        identity,
+                        groupManager,
+                        registry,
+                        syncManager,
+                        stores,
+                        adapter,
+                        hlc,
+                        emitter,
+                        pendingJoinRequests,
+                        runtime: params.runtime,
+                        autoAcceptPeers: options?.autoAcceptPeers,
+                        scheduleBroadcast: hub.scheduleBroadcast,
+                        broadcastNow: hub.broadcastNow,
+                        scheduleSendCommit: hub.scheduleSendCommit,
+                        monitor: groupHealthMonitor,
+                        rejoinGroup: hub.rejoinGroup,
+                        logger: params.getLogger('context')
+                    };
+                    return {
+                        group: createGroupContext(ctx, deps),
+                        sync: createSyncContext(ctx, deps),
+                        join: createJoinContext(ctx, deps),
+                        hub: createHubContext(ctx, deps),
+                        delegation: createDelegationContext(ctx, deps)
+                    };
+                };
+            },
+            dispose: async ()=>{
+                // Unwire the broadcast-sender subscriber first so no new broadcasts
+                // are enqueued while teardown is in flight.
+                if (unwireBroadcastSender != null) {
+                    try {
+                        unwireBroadcastSender();
+                    } catch  {
+                    // ignore
+                    }
+                }
+                // Synchronously drain the batch queue BEFORE other teardown so any
+                // pending broadcasts ship through the still-live hub transport.
+                if (broadcastQueue != null) {
+                    try {
+                        broadcastQueue.dispose();
+                    } catch  {
+                    // ignore
+                    }
+                }
+                // Sync HTTP server depends on httpSyncTransport — dispose servers
+                // first, then the transport. Runs in parallel with syncManager and
+                // hub teardown, which have no such dependency.
+                const httpPath = (async ()=>{
+                    for (const server of syncServers){
+                        await server.dispose();
+                    }
+                    if (httpSyncTransport != null) {
+                        await httpSyncTransport.dispose();
+                    }
+                })();
+                const disposeLogger = params.getLogger('dispose');
+                const results = await Promise.allSettled([
+                    httpPath,
+                    syncManager.dispose(),
+                    hub.dispose()
+                ]);
+                const labels = [
+                    'sync-http',
+                    'sync-manager',
+                    'hub'
+                ];
+                results.forEach((result, i)=>{
+                    if (result.status === 'rejected') {
+                        disposeLogger.error('dispose branch failed', {
+                            branch: labels[i],
+                            error: result.reason
+                        });
+                    }
+                });
+            }
+        };
+    };
+}

package/lib/protocol.d.ts

@@ -1,5 +1,5 @@
 import type { AnyClientMessageOf, AnyServerMessageOf } from '@enkaku/protocol';
-import type { FromSchema } from '@enkaku/schema';
+import type { FromSchema } from '@sozai/schema';
 export declare const syncProtocol: {
     readonly 'sync/negotiate': {
         readonly type: "request";
@@ -129,6 +129,13 @@ export declare const syncProtocol: {
                     readonly type: "string";
                     readonly enum: readonly ["push", "pull", "both"];
                 };
+                readonly delegationTokens: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "Delegation JWTs authorizing the caller for non-owned scopes";
+                };
             };
             readonly required: readonly ["scopes", "excludedDocumentIDs", "tree", "direction"];
             readonly additionalProperties: false;