@kubun/plugin-p2p 0.8.0 → 0.8.2

package/lib/hub/group-channel.js

@@ -0,0 +1 @@
+import{handleReceivedMessage as e}from"./receive-handler.js";import{handleSendBroadcast as t}from"./send-handler.js";export function createMutex(){let e=Promise.resolve();return{run(t){let r=e.then(()=>t());return e=r.catch(()=>{}),r}}}export class AckBatch{#e;#t;#r;#i;#s=new Set;#o=null;constructor(e){this.#e=e.flushMs,this.#t=e.flushMax,this.#r=e.send,this.#i=e.logger}add(e){let t=0===this.#s.size;if(this.#s.add(e),this.#s.size>=this.#t){null!==this.#o&&(clearTimeout(this.#o),this.#o=null),this.flush();return}t&&null===this.#o&&(this.#o=setTimeout(()=>{this.#o=null,this.flush()},this.#e))}async flush(){if(null!==this.#o&&(clearTimeout(this.#o),this.#o=null),0===this.#s.size)return;let e=Array.from(this.#s);this.#s.clear();try{await this.#r(e)}catch(t){this.#i?.error("ack batch send failed",{error:t,count:e.length})}}dispose(){null!==this.#o&&(clearTimeout(this.#o),this.#o=null),this.#s.clear()}}export function computeBackoff(e,t,r,i){let s=Math.min(t*2**e*(1+i*(2*Math.random()-1)),r);return s<0?0:s}export function abortableSleep(e,t){return new Promise((r,i)=>{if(t.aborted)return void i(t.reason??Error("aborted"));let s=setTimeout(()=>{t.removeEventListener("abort",o),r()},e),o=()=>{clearTimeout(s),t.removeEventListener("abort",o),i(t.reason??Error("aborted"))};t.addEventListener("abort",o)})}let r=Symbol("disposed");export class GroupChannel{#a;#h;#l;#n;#c;#u;#i;#p;#g;#d;#f;#b;#I;#D=new AbortController;#m=null;#k=null;#v=null;#M=null;#y=null;#w=0;#x=!1;#C=!1;constructor(e){this.#a=e.groupID,this.#h=e.hubURL,this.#l=e.deviceID,this.#n=e.pool,this.#c=e.broadcastService,this.#u=e.p2pStore,this.#i=e.logger,this.#p=e.ackFlushMs,this.#g=e.ackFlushMax,this.#d=e.backoffBaseMs,this.#f=e.backoffMaxMs,this.#b=e.backoffJitter,this.#I=createMutex()}async open(){if(this.#x)throw Error("GroupChannel already opened");try{await this.#S(),this.#x=!0}catch(e){if(null!=this.#k){try{await this.#n.release(this.#h,this.#k)}catch(e){this.#i?.debug("pool release after open failure failed",{groupID:this.#a,error:e})}this.#k=null}throw this.#m=null,e}}async #S(){if(null!=this.#k){let e=this.#k;this.#k=null,this.#m=null;try{await this.#n.release(this.#h,e)}catch(e){this.#i?.debug("pool release before reconnect failed",{groupID:this.#a,error:e})}}let{client:e,refID:t}=await this.#n.acquire(this.#h);this.#m=e,this.#k=t;let r=await this.#u.getMLSState(this.#a,this.#l);if(null==r)throw Error(`MLS state missing for group ${this.#a}; cannot join hub group`);await e.request("hub/group/join",{param:{groupID:this.#a,credential:r.credential}});let i=e.createChannel("hub/receive",{param:{groupIDs:[this.#a]},signal:this.#D.signal});this.#v=i,i.catch(()=>{}),this.#M=new AckBatch({flushMs:this.#p,flushMax:this.#g,send:async e=>{await i.send({ack:e})},logger:this.#i}),this.#y=this.#L(e).catch(e=>{this.#i?.debug("receive task tail error",{groupID:this.#a,error:e})}),this.#C=!0}async #L(t){let i=this.#v;if(null==i)return;let s=i.readable.getReader();try{for(;!this.#D.signal.aborted;){let i=s.read(),o=t.disposed.then(()=>r),a=await Promise.race([i,o]);if("symbol"==typeof a){this.#i?.debug("receive loop observed hub client disposal",{groupID:this.#a});break}let{done:h,value:l}=a;if(h)break;(await this.#I.run(()=>e({groupID:this.#a,deviceID:this.#l,message:l,p2pStore:this.#u,broadcastService:this.#c,logger:this.#i}))).ack&&this.#M?.add(l.sequenceID),this.#w=0}}catch(e){this.#i?.warn("hub receive loop error",{groupID:this.#a,error:e})}finally{try{s.releaseLock()}catch{}}this.#C=!1,this.#D.signal.aborted||this.#B()}#B(){this.#C=!1,this.#y=this.#R().catch(e=>{this.#i?.debug("reconnect task tail error",{groupID:this.#a,error:e})})}async #R(){for(;!this.#D.signal.aborted;){this.#C=!1;let e=computeBackoff(this.#w++,this.#d,this.#f,this.#b);this.#i?.debug("reconnect scheduled",{groupID:this.#a,delay:e,attempt:this.#w});try{await abortableSleep(e,this.#D.signal)}catch{return}try{this.#M?.dispose(),this.#M=null,this.#v=null,await this.#S(),this.#w=0;return}catch(e){this.#i?.warn("reconnect attempt failed",{groupID:this.#a,attempt:this.#w,error:e})}}}async close(){if(!this.#x)return;this.#C=!1;let e=this.#M;this.#M=null;try{await e?.flush()}catch(e){this.#i?.debug("ack flush during close failed",{groupID:this.#a,error:e})}e?.dispose();try{await this.#m?.request("hub/group/leave",{param:{groupID:this.#a}})}catch(e){this.#i?.warn("hub/group/leave failed",{groupID:this.#a,error:e})}try{this.#v?.close()}catch{}if(!this.#D.signal.aborted)try{this.#D.abort()}catch{}try{await this.#y}catch{}if(null!=this.#k){try{await this.#n.release(this.#h,this.#k)}catch(e){this.#i?.debug("pool release during close failed",{groupID:this.#a,error:e})}this.#k=null}this.#m=null,this.#v=null,this.#y=null,this.#x=!1}broadcast(e){return this.#x&&this.#C&&null!=this.#m?this.#I.run(async()=>{if(!this.#x||!this.#C||null==this.#m)throw Error(`GroupChannel for ${this.#a} is not ready for broadcast`);let r=this.#m;return t({groupID:this.#a,deviceID:this.#l,message:e,p2pStore:this.#u,broadcastService:this.#c,hubClient:r,logger:this.#i})}):Promise.reject(Error(`GroupChannel for ${this.#a} is not ready for broadcast`))}}

package/lib/hub/receive-handler.d.ts

@@ -0,0 +1,36 @@
+import type { Logger } from '@kubun/logger';
+import type { P2PStoreAPI } from '@kubun/store-p2p';
+import { type BroadcastService } from '../groups/broadcast-service.js';
+/**
+ * Shape of a message pushed by `hub/receive`. Matches `@enkaku/hub-protocol`
+ * server-to-client push payload.
+ */
+export type ReceivedHubMessage = {
+    sequenceID: string;
+    senderDID: string;
+    groupID?: string;
+    /** base64-encoded encrypted MLS application message */
+    payload: string;
+};
+export type HandleReceivedMessageParams = {
+    groupID: string;
+    deviceID: string;
+    message: ReceivedHubMessage;
+    p2pStore: P2PStoreAPI;
+    broadcastService: BroadcastService;
+    logger?: Logger;
+};
+export type HandleReceivedMessageResult = {
+    ack: boolean;
+};
+/**
+ * Apply a single hub-received message for a group.
+ *
+ * Returns `{ ack: true }` when the message has been processed to a state where
+ * redelivery serves no purpose (applied successfully, or decrypt failed with
+ * no recovery path). Returns `{ ack: false }` when the hub should redeliver
+ * (transient apply or save failure, MLS state missing, unexpected error).
+ * Skips with `{ ack: false }` on groupID mismatch so the message stays queued
+ * for whichever recipient it was intended for.
+ */
+export declare function handleReceivedMessage(params: HandleReceivedMessageParams): Promise<HandleReceivedMessageResult>;

package/lib/hub/receive-handler.js

@@ -0,0 +1 @@
+import{fromB64 as e}from"@enkaku/codec";import{ApplyError as r,DecryptError as a}from"../groups/broadcast-service.js";import{fromMLSStateRow as s,toMLSStateInsert as t}from"../groups/mls-state.js";export async function handleReceivedMessage(c){let n,{groupID:u,deviceID:i,message:o,p2pStore:p,broadcastService:l,logger:g}=c;if(o.groupID!==u)return g?.debug("hub message groupID mismatch, skipping",{groupID:u,messageGroupID:o.groupID,sequenceID:o.sequenceID}),{ack:!1};let d=await p.getMLSState(u,i);if(null==d)return g?.warn("mls state missing for group, skipping message",{groupID:u,sequenceID:o.sequenceID}),{ack:!1};let m=s(d),D=e(o.payload);try{n=await l.processReceived({groupID:u,encrypted:D,groupState:m})}catch(e){if(e instanceof a)return g?.debug("decrypt failed, acking and skipping",{groupID:u,sequenceID:o.sequenceID,error:e}),{ack:!0};if(e instanceof r)return g?.error("broadcast apply failed, will redeliver",{groupID:u,sequenceID:o.sequenceID,error:e}),{ack:!1};return g?.error("unexpected error processing hub message",{groupID:u,sequenceID:o.sequenceID,error:e}),{ack:!1}}try{await p.saveMLSState(t(n.updatedGroupState,u,i))}catch(e){return g?.error("save mls state failed after apply, will redeliver",{groupID:u,sequenceID:o.sequenceID,error:e}),{ack:!1}}return{ack:!0}}

package/lib/hub/relay-manager.d.ts

@@ -0,0 +1,37 @@
+import type { Client } from '@enkaku/client';
+import type { HubProtocol } from '@enkaku/hub-protocol';
+import type { Logger } from '@kubun/logger';
+import type { P2PStoreAPI } from '@kubun/store-p2p';
+import type { GroupBroadcastMessage } from '../groups/broadcast.js';
+import type { BroadcastService } from '../groups/broadcast-service.js';
+import { GroupChannel, type GroupChannelParams } from './group-channel.js';
+export type CreateHubClient = (hubURL: string) => Promise<Client<HubProtocol>>;
+export type CreateGroupChannel = (params: GroupChannelParams) => GroupChannel;
+export type HubRelayManagerParams = {
+    p2pStore: P2PStoreAPI;
+    broadcastService: BroadcastService;
+    deviceID: string;
+    createHubClient: CreateHubClient;
+    logger?: Logger;
+    ackFlushMs?: number;
+    ackFlushMax?: number;
+    backoffBaseMs?: number;
+    backoffMaxMs?: number;
+    backoffJitter?: number;
+    createGroupChannel?: CreateGroupChannel;
+};
+export declare class HubRelayManager {
+    #private;
+    constructor(params: HubRelayManagerParams);
+    /**
+     * Open channels for each group in parallel. Per-group failures are logged
+     * and swallowed: this method never rejects, so a single bad group does not
+     * block the others from starting. Callers who need per-group readiness
+     * signals must check `addGroup` / `broadcast` results individually.
+     */
+    start(groupIDs: Array<string>): Promise<void>;
+    addGroup(groupID: string): Promise<void>;
+    removeGroup(groupID: string): Promise<void>;
+    broadcast(groupID: string, message: GroupBroadcastMessage): Promise<void>;
+    stop(): Promise<void>;
+}

package/lib/hub/relay-manager.js

@@ -0,0 +1 @@
+import{HubConnectionPool as e}from"./connection-pool.js";import{GroupChannel as a}from"./group-channel.js";export class HubRelayManager{#e;#a;#t;#s;#r;#o;#i;#l;#c;#h;#u;#p=new Map;constructor(t){this.#e=t.p2pStore,this.#a=t.broadcastService,this.#t=t.deviceID,this.#r=t.logger,this.#o=t.ackFlushMs??500,this.#i=t.ackFlushMax??10,this.#l=t.backoffBaseMs??1e3,this.#c=t.backoffMaxMs??6e4,this.#h=t.backoffJitter??.25,this.#s=new e({createHubClient:t.createHubClient,logger:t.logger}),this.#u=t.createGroupChannel??(e=>new a(e))}async start(e){(await Promise.allSettled(e.map(e=>this.addGroup(e)))).forEach((a,t)=>{"rejected"===a.status&&this.#r?.error("addGroup failed during start",{groupID:e[t],error:a.reason})})}async addGroup(e){if(this.#p.has(e))return void this.#r?.debug("group already added",{groupID:e});let a=await this.#e.getGroup(e);if(null==a)throw Error(`Group ${e} not found`);let t=a.hub_urls;if(null==t||0===t.length)return void this.#r?.warn("group has no hub URLs, skipping",{groupID:e});t.length>1&&this.#r?.warn("multi-hub not yet supported, using first",{groupID:e,hubURLs:t});let s=this.#u({groupID:e,hubURL:t[0],deviceID:this.#t,pool:this.#s,broadcastService:this.#a,p2pStore:this.#e,logger:this.#r,ackFlushMs:this.#o,ackFlushMax:this.#i,backoffBaseMs:this.#l,backoffMaxMs:this.#c,backoffJitter:this.#h});await s.open(),this.#p.set(e,s)}async removeGroup(e){let a=this.#p.get(e);null!=a&&(this.#p.delete(e),await a.close())}async broadcast(e,a){let t=this.#p.get(e);if(null==t)throw Error(`Group ${e} is not active in HubRelayManager`);await t.broadcast(a)}async stop(){let e=[...this.#p.values()];this.#p.clear(),(await Promise.allSettled(e.map(e=>e.close()))).forEach(e=>{"rejected"===e.status&&this.#r?.warn("GroupChannel close failed",{error:e.reason})}),await this.#s.disposeAll()}}

package/lib/hub/send-handler.d.ts

@@ -0,0 +1,28 @@
+import type { Client } from '@enkaku/client';
+import type { HubProtocol } from '@enkaku/hub-protocol';
+import type { Logger } from '@kubun/logger';
+import type { P2PStoreAPI } from '@kubun/store-p2p';
+import type { GroupBroadcastMessage } from '../groups/broadcast.js';
+import type { BroadcastService } from '../groups/broadcast-service.js';
+export type HandleSendBroadcastParams = {
+    groupID: string;
+    deviceID: string;
+    message: GroupBroadcastMessage;
+    p2pStore: P2PStoreAPI;
+    broadcastService: BroadcastService;
+    hubClient: Client<HubProtocol>;
+    logger?: Logger;
+};
+/**
+ * Encrypt + send a broadcast for a group, then persist the advanced MLS state.
+ *
+ * Failure semantics:
+ * - Missing MLS state for (group, device) → throw, caller cannot broadcast.
+ * - `prepareSend` failure → throw, no save (epoch unchanged on disk).
+ * - `hub/group/send` failure → throw, do NOT save advanced MLS state.
+ *   Prevents an MLS epoch wedge where local state outpaces recipients.
+ * - `saveMLSState` failure → throw. State has advanced in memory; on next call
+ *   the load-from-disk path will re-derive a fresh handle from the prior epoch
+ *   and re-encrypt. (Wedge protection only applies pre-save by design.)
+ */
+export declare function handleSendBroadcast(params: HandleSendBroadcastParams): Promise<void>;

package/lib/hub/send-handler.js

@@ -0,0 +1 @@
+import{toB64 as a}from"@enkaku/codec";import{fromMLSStateRow as r,toMLSStateInsert as t}from"../groups/mls-state.js";export async function handleSendBroadcast(e){let{groupID:o,deviceID:s,message:n,p2pStore:i,broadcastService:p,hubClient:d,logger:u}=e,c=await i.getMLSState(o,s);if(null==c)throw Error(`MLS state missing for group ${o}; cannot broadcast`);let l=r(c),{encrypted:m,updatedGroupState:S}=await p.prepareSend({groupID:o,message:n,groupState:l});try{await d.request("hub/group/send",{param:{groupID:o,payload:a(m)}})}catch(a){throw u?.error("hub/group/send failed",{groupID:o,error:a}),a}await i.saveMLSState(t(S,o,s))}

package/lib/index.d.ts

@@ -1,23 +1,24 @@
 import type { KubunPlugin, PluginFactoryParams } from '@kubun/engine';
 export type { ContextDeps, PendingJoinRequest } from './context/types.js';
-export { createP2PMigrations, type MigrationContext } from './migrations.js';
+export { type GroupBroadcastMessage, type ProcessBroadcastParams, processBroadcast, } from './groups/broadcast.js';
+export { deserializeBroadcast, serializeBroadcast } from './groups/broadcast-codec.js';
+export { ApplyError, type BroadcastEvent, BroadcastService, type BroadcastServiceEvents, type BroadcastServiceParams, DecryptError, type ReceiveBroadcastParams, type ReceiveBroadcastResult, type SendBroadcastParams, type SendBroadcastResult, } from './groups/broadcast-service.js';
+export { createFilteredGenerator, createGroupEventEmitter, type GroupEventEmitter, type GroupEventMap, } from './groups/events.js';
+export { decodeFullJoinRequest, decodeInvitePayload, decodeJoinRequest, encodeFullJoinRequest, encodeInvitePayload, encodeJoinRequest, type FullJoinRequestPayload, type InvitePayload, type JoinRequestPayload, } from './groups/invite-payload.js';
+export { type AddCircleMemberParams, type AddCircleMemberResult, type CreateCircleParams, type CreateCircleResult, type CreateGroupParams, type CreateGroupResult, type DeleteCircleParams, type DeleteCircleResult, GroupManager, type GroupManagerParams, type InviteToGroupParams, type InviteToGroupResult, type JoinGroupParams, type JoinGroupResult, type LeaveGroupParams, type LeaveGroupResult, type RemoveCircleMemberParams, type RemoveCircleMemberResult, type RemoveGroupMemberParams, type RemoveGroupMemberResult, type RemoveMemberParams, type RemoveMemberResult, type UpdateCircleParams, type UpdateCircleResult, type UpdateGroupParams, type UpdateGroupResult, } from './groups/manager.js';
+export { type MLSGroupHandle, restoreMLSGroupHandle } from './groups/mls-group-handle.js';
+export { replacer as mlsJSONReplacer, reviver as mlsJSONReviver } from './groups/mls-json.js';
+export { deserializeMLSGroupState, type MLSGroupState, type SerializedMLSGroupState, serializeMLSGroupState, } from './groups/mls-state.js';
 export type { SyncClientMessage, SyncProtocol, SyncServerMessage } from './protocol.js';
 export { createP2PSchemaExtension } from './schema.js';
-export { type ProcessBroadcastParams, processBroadcast, type SpaceBroadcastMessage, } from './spaces/broadcast.js';
-export { deserializeBroadcast, serializeBroadcast } from './spaces/broadcast-codec.js';
-export { type BroadcastEvent, BroadcastService, type BroadcastServiceEvents, type BroadcastServiceParams, type ReceiveBroadcastParams, type ReceiveBroadcastResult, type SendBroadcastParams, type SendBroadcastResult, } from './spaces/broadcast-service.js';
-export { createFilteredGenerator, createSpaceEventEmitter, type SpaceEventEmitter, type SpaceEventMap, } from './spaces/events.js';
-export { restoreGroupHandle } from './spaces/group-handle.js';
-export { decodeFullJoinRequest, decodeInvitePayload, decodeJoinRequest, encodeFullJoinRequest, encodeInvitePayload, encodeJoinRequest, type FullJoinRequestPayload, type InvitePayload, type JoinRequestPayload, } from './spaces/invite-payload.js';
-export { type AddCircleMemberParams, type AddCircleMemberResult, type CreateCircleParams, type CreateCircleResult, type CreateSpaceParams, type CreateSpaceResult, type DeleteCircleParams, type DeleteCircleResult, type InviteToSpaceParams, type InviteToSpaceResult, type JoinSpaceParams, type JoinSpaceResult, type LeaveSpaceParams, type LeaveSpaceResult, type QueryRunner, type RemoveCircleMemberParams, type RemoveCircleMemberResult, type RemoveMemberParams, type RemoveMemberResult, type RemoveSpaceMemberParams, type RemoveSpaceMemberResult, SpaceManager, type SpaceManagerParams, type UpdateCircleParams, type UpdateCircleResult, type UpdateSpaceParams, type UpdateSpaceResult, } from './spaces/manager.js';
-export { replacer as mlsJSONReplacer, reviver as mlsJSONReviver } from './spaces/mls-json.js';
-export { deserializeGroupState, type GroupState, type SerializedGroupState, serializeGroupState, } from './spaces/mls-state.js';
 export { type CatalogSyncScope, resolveCatalogSyncScopes } from './sync/catalog-scope.js';
-export { checkSyncDelegation } from './sync/handlers.js';
+export { checkSyncDelegation, negotiateDirection } from './sync/handlers.js';
 export { type PeerConfig, type PeerConfigWithID, PeerRegistry } from './sync/peer-registry.js';
-export { type MerkleSyncMessage, SyncClient, type SyncClientParams, type SyncScope, type SyncTransportProvider, } from './sync/sync-client.js';
+export { SyncClient, type SyncClientParams, type SyncScope, type SyncTransportProvider, } from './sync/sync-client.js';
 export { type SyncEvent, SyncManager, type SyncManagerParams, type SyncSessionInfo, type SyncStatus, } from './sync/sync-manager.js';
-export type { CatalogData, CircleData, CircleMemberData, DeleteCatalogData, DeleteCircleData, InviteToSpaceData, JoinSpaceData, LeaveSpaceData, P2PJoinRequestContext, RemoveCircleMemberData, RemoveSpaceMemberData, SpaceData, SpaceMemberData, SpaceRequestContext, SyncPluginAPI, SyncRequestContext, SyncSessionResult, UpdateCircleInput, UpdateSpaceInput, } from './types.js';
+export type { GroupChannel, GroupChannelParams } from './hub/group-channel.js';
+export { type CreateGroupChannel, type CreateHubClient, HubRelayManager, type HubRelayManagerParams, } from './hub/relay-manager.js';
+export type { CatalogData, CircleData, CircleMemberData, DeleteCatalogData, DeleteCircleData, GroupData, GroupMemberData, GroupRequestContext, InviteToGroupData, JoinGroupData, LeaveGroupData, P2PJoinRequestContext, RemoveCircleMemberData, RemoveGroupMemberData, SyncPluginAPI, SyncRequestContext, SyncSessionResult, UpdateCircleInput, UpdateGroupInput, } from './types.js';
 export type P2PPluginOptions = {
     autoAcceptPeers?: Array<string>;
     http?: boolean | string;

package/lib/index.js

@@ -1 +1 @@
-import{ServerTransport as e}from"@enkaku/http-server-transport";import{Server as t}from"@enkaku/server";import{DirectTransports as r}from"@enkaku/transport";import{HLC as s}from"@kubun/hlc";import{createJoinContext as o}from"./context/join.js";import{createSpaceContext as n}from"./context/space.js";import{createSyncContext as a}from"./context/sync.js";import{createP2PMigrations as c}from"./migrations.js";import{createP2PSchemaExtension as i}from"./schema.js";import{createSpaceEventEmitter as p}from"./spaces/events.js";import{SpaceManager as m}from"./spaces/manager.js";import{createSyncHandlers as d}from"./sync/handlers.js";import{SyncManager as l}from"./sync/sync-manager.js";export{createP2PMigrations}from"./migrations.js";export{createP2PSchemaExtension}from"./schema.js";export{processBroadcast}from"./spaces/broadcast.js";export{deserializeBroadcast,serializeBroadcast}from"./spaces/broadcast-codec.js";export{BroadcastService}from"./spaces/broadcast-service.js";export{createFilteredGenerator,createSpaceEventEmitter}from"./spaces/events.js";export{restoreGroupHandle}from"./spaces/group-handle.js";export{decodeFullJoinRequest,decodeInvitePayload,decodeJoinRequest,encodeFullJoinRequest,encodeInvitePayload,encodeJoinRequest}from"./spaces/invite-payload.js";export{SpaceManager}from"./spaces/manager.js";export{replacer as mlsJSONReplacer,reviver as mlsJSONReviver}from"./spaces/mls-json.js";export{deserializeGroupState,serializeGroupState}from"./spaces/mls-state.js";export{resolveCatalogSyncScopes}from"./sync/catalog-scope.js";export{checkSyncDelegation}from"./sync/handlers.js";export{PeerRegistry}from"./sync/peer-registry.js";export{SyncClient}from"./sync/sync-client.js";export{SyncManager}from"./sync/sync-manager.js";export function createP2PPlugin(g){return y=>{let u,f,j=y.db.getDB(),h=y.db.adapter,v=y.identity,x=new s({nodeID:v.id}),P=new m({kysely:j,adapter:h,identity:v,getRandomID:y.runtime.getRandomID}),S=p(),w=new l({db:y.db,deployClusters:async e=>{let t=Object.values(e);await y.engine.deployGraph({clusters:t})},runtime:y.runtime,identity:y.identity,logger:y.getLogger("sync")}),R=d({db:y.db,logger:y.getLogger("sync-handlers")}),b=new Map,k=[],I={types:h.types,functions:h.functions};async function D(){return await j}let C={addPeer:e=>w.addPeer(e),removePeer:e=>w.removePeer(e),listPeers:()=>w.listPeers(),syncWithPeer:({peerDID:e,scopes:t,delegationTokens:r,knownModelIDs:s})=>w.merkleSyncWithPeer(e,t,r,{knownModelIDs:s}),getStatus:e=>w.getStatus(e),onSyncEvent:e=>w.onSyncEvent(e),createSyncTransport:function(e){let s=new r({signal:e}),o=new t({accessControl:!1,getRandomID:y.runtime.getRandomID,handlers:R,logger:y.getLogger("sync-server"),transports:[s.server],signal:e});return k.push(o),s.client}};if(g?.http){let r="string"==typeof g.http?g.http.replace(/^\//,""):"sync";C.syncReady=(async()=>{let s=await y.engine.getAPI("http");await s.listening,u=new e({allowedOrigin:["*"]}),f=new t({accessControl:!1,getRandomID:y.runtime.getRandomID,handlers:R,logger:y.getLogger("sync-http-server"),transports:[u]}),k.push(f),s.registerProtocol(r,u.fetch.bind(u))})()}return{name:"p2p",migrations:{name:"p2p",migrations:()=>c(I)},schemaExtension:e=>i(S),api:C,createContextFactory:()=>{let e={identity:v,spaceManager:P,syncManager:w,adapter:h,hlc:x,emitter:S,pendingJoinRequests:b,getDB:D,runtime:y.runtime,autoAcceptPeers:g?.autoAcceptPeers};return t=>({...n(t,e),...a(t,e),...o(t,e)})},dispose:async()=>{for(let e of k)await e.dispose();await u?.dispose(),await w.dispose()}}}}
+import{ServerTransport as e}from"@enkaku/http-server-transport";import{Server as r}from"@enkaku/server";import{DirectTransports as t}from"@enkaku/transport";import{HLC as o}from"@kubun/hlc";import{p2pStoreDefinition as s}from"@kubun/store-p2p";import{createGroupContext as n}from"./context/group.js";import{createJoinContext as a}from"./context/join.js";import{createSyncContext as i}from"./context/sync.js";import{createGroupEventEmitter as p}from"./groups/events.js";import{GroupManager as c}from"./groups/manager.js";import{createP2PSchemaExtension as m}from"./schema.js";import{createSyncHandlers as g}from"./sync/handlers.js";import{SyncManager as d}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,createGroupEventEmitter}from"./groups/events.js";export{decodeFullJoinRequest,decodeInvitePayload,decodeJoinRequest,encodeFullJoinRequest,encodeInvitePayload,encodeJoinRequest}from"./groups/invite-payload.js";export{GroupManager}from"./groups/manager.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{resolveCatalogSyncScopes}from"./sync/catalog-scope.js";export{checkSyncDelegation,negotiateDirection}from"./sync/handlers.js";export{PeerRegistry}from"./sync/peer-registry.js";export{SyncClient}from"./sync/sync-client.js";export{SyncManager}from"./sync/sync-manager.js";export{HubRelayManager}from"./hub/relay-manager.js";export function createP2PPlugin(l){return u=>{let y,f;u.db.register(s);let j=u.db.adapter,h=u.identity,v=new o({nodeID:h.id}),x=new c({identity:h,getRandomID:u.runtime.getRandomID}),P=p(),S=new d({deployClusters:async e=>{let r=Object.values(e);await u.engine.deployGraph({clusters:r})},runtime:u.runtime,identity:u.identity,logger:u.getLogger("sync")}),b=g({db:u.db,logger:u.getLogger("sync-handlers"),peerRegistry:S.peerRegistry}),R=new Map,w=[],k={addPeer:e=>S.addPeer({config:e,stores:u.db}),removePeer:e=>S.removePeer({peerDID:e,stores:u.db}),listPeers:()=>S.listPeers({stores:u.db}),syncWithPeer:e=>S.merkleSyncWithPeer({...e,stores:u.db}),getStatus:e=>S.getStatus({peerDID:e,stores:u.db}),onSyncEvent:e=>S.onSyncEvent(e),createSyncTransport:function(e){let o=new t({signal:e}),s=new r({accessControl:!1,getRandomID:u.runtime.getRandomID,handlers:b,logger:u.getLogger("sync-server"),transports:[o.server],signal:e});return w.push(s),o.client}};if(l?.http){let t="string"==typeof l.http?l.http.replace(/^\//,""):"sync";k.syncReady=(async()=>{let o=await u.engine.getAPI("http");await o.listening,y=new e({allowedOrigin:["*"]}),f=new r({accessControl:!1,getRandomID:u.runtime.getRandomID,handlers:b,logger:u.getLogger("sync-http-server"),transports:[y]}),w.push(f),o.registerProtocol(t,y.fetch.bind(y))})()}return{name:"p2p",schemaExtension:e=>m(P),api:k,createContextFactory:()=>(e,r)=>{let t={identity:h,groupManager:x,syncManager:S,stores:r,adapter:j,hlc:v,emitter:P,pendingJoinRequests:R,runtime:u.runtime,autoAcceptPeers:l?.autoAcceptPeers};return{...n(e,t),...i(e,t),...a(e,t)}},dispose:async()=>{for(let e of w)await e.dispose();await y?.dispose(),await S.dispose()}}}}

package/lib/protocol.d.ts

@@ -44,6 +44,10 @@ export declare const syncProtocol: {
                     };
                     readonly description: "Model IDs the requester already has — used to identify missing clusters";
                 };
+                readonly direction: {
+                    readonly type: "string";
+                    readonly enum: readonly ["push", "pull", "both"];
+                };
             };
             readonly required: readonly ["delegationTokens"];
             readonly additionalProperties: false;
@@ -51,6 +55,10 @@ export declare const syncProtocol: {
         readonly result: {
             readonly type: "object";
             readonly properties: {
+                readonly direction: {
+                    readonly type: "string";
+                    readonly enum: readonly ["push", "pull", "both"];
+                };
                 readonly acceptedScopes: {
                     readonly type: "array";
                     readonly items: {
@@ -84,7 +92,7 @@ export declare const syncProtocol: {
         };
     };
     readonly 'sync/merkle-sync': {
-        readonly type: "stream";
+        readonly type: "channel";
         readonly param: {
             readonly type: "object";
             readonly properties: {
@@ -117,11 +125,15 @@ export declare const syncProtocol: {
                         readonly type: "string";
                     };
                 };
+                readonly direction: {
+                    readonly type: "string";
+                    readonly enum: readonly ["push", "pull", "both"];
+                };
             };
-            readonly required: readonly ["scopes", "excludedDocumentIDs", "tree"];
+            readonly required: readonly ["scopes", "excludedDocumentIDs", "tree", "direction"];
             readonly additionalProperties: false;
         };
-        readonly receive: {
+        readonly send: {
             readonly type: "object";
             readonly properties: {
                 readonly type: {
@@ -135,13 +147,30 @@ export declare const syncProtocol: {
                     };
                     readonly description: "Signed mutation JWTs for divergent time buckets";
                 };
-                readonly divergentBuckets: {
-                    readonly type: "number";
-                    readonly description: "Number of divergent minute buckets found";
+            };
+            readonly required: readonly ["type"];
+            readonly additionalProperties: false;
+        };
+        readonly receive: {
+            readonly type: "object";
+            readonly properties: {
+                readonly type: {
+                    readonly type: "string";
+                    readonly enum: readonly ["tree", "mutations", "complete"];
                 };
-                readonly totalMutations: {
-                    readonly type: "number";
-                    readonly description: "Total mutations sent";
+                readonly tree: {
+                    readonly type: "object";
+                    readonly description: "Responder merkle tree bucket hashes";
+                    readonly additionalProperties: {
+                        readonly type: "string";
+                    };
+                };
+                readonly mutationJWTs: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "Signed mutation JWTs for divergent time buckets";
                 };
             };
             readonly required: readonly ["type"];
@@ -159,8 +188,11 @@ export declare const syncProtocol: {
                 readonly mutationsSent: {
                     readonly type: "number";
                 };
+                readonly mutationsReceived: {
+                    readonly type: "number";
+                };
             };
-            readonly required: readonly ["success", "divergentBuckets", "mutationsSent"];
+            readonly required: readonly ["success", "divergentBuckets", "mutationsSent", "mutationsReceived"];
             readonly additionalProperties: false;
         };
     };
@@ -169,7 +201,9 @@ export type SyncProtocol = typeof syncProtocol;
 export type SyncNegotiateParams = FromSchema<SyncProtocol['sync/negotiate']['param']>;
 export type SyncNegotiateResult = FromSchema<SyncProtocol['sync/negotiate']['result']>;
 export type SyncMerkleSyncParams = FromSchema<SyncProtocol['sync/merkle-sync']['param']>;
+export type SyncMerkleSyncSend = FromSchema<SyncProtocol['sync/merkle-sync']['send']>;
 export type SyncMerkleSyncReceive = FromSchema<SyncProtocol['sync/merkle-sync']['receive']>;
 export type SyncMerkleSyncResult = FromSchema<SyncProtocol['sync/merkle-sync']['result']>;
+export type SyncDirection = 'push' | 'pull' | 'both';
 export type SyncClientMessage = AnyClientMessageOf<SyncProtocol>;
 export type SyncServerMessage = AnyServerMessageOf<SyncProtocol>;

package/lib/protocol.js

@@ -1 +1 @@
-export const syncProtocol={"sync/negotiate":{type:"request",param:{type:"object",properties:{scopes:{type:"array",items:{type:"object",properties:{modelID:{type:"string"},ownerDID:{type:"string"}},required:["modelID","ownerDID"],additionalProperties:!1},description:"Requested sync scopes as (model, owner) pairs"},delegationTokens:{type:"array",items:{type:"string"},description:"JWT delegation tokens for authorization"},catalogIDs:{type:"array",items:{type:"string"},description:"Catalog IDs to resolve sync scope from criteria"},knownModelIDs:{type:"array",items:{type:"string"},description:"Model IDs the requester already has — used to identify missing clusters"}},required:["delegationTokens"],additionalProperties:!1},result:{type:"object",properties:{acceptedScopes:{type:"array",items:{type:"object",properties:{modelID:{type:"string"},ownerDID:{type:"string"}},required:["modelID","ownerDID"],additionalProperties:!1}},excludedDocumentIDs:{type:"array",items:{type:"string"}},missingClusters:{type:"object",description:"Cluster definitions for models the requester does not have yet",additionalProperties:!0}},required:["acceptedScopes","excludedDocumentIDs"],additionalProperties:!1}},"sync/merkle-sync":{type:"stream",param:{type:"object",properties:{scopes:{type:"array",items:{type:"object",properties:{modelID:{type:"string"},ownerDID:{type:"string"}},required:["modelID","ownerDID"],additionalProperties:!1}},excludedDocumentIDs:{type:"array",items:{type:"string"}},tree:{type:"object",description:"Merkle tree bucket hashes from requester",additionalProperties:{type:"string"}}},required:["scopes","excludedDocumentIDs","tree"],additionalProperties:!1},receive:{type:"object",properties:{type:{type:"string",enum:["mutations","complete"]},mutationJWTs:{type:"array",items:{type:"string"},description:"Signed mutation JWTs for divergent time buckets"},divergentBuckets:{type:"number",description:"Number of divergent minute buckets found"},totalMutations:{type:"number",description:"Total mutations sent"}},required:["type"],additionalProperties:!1},result:{type:"object",properties:{success:{type:"boolean"},divergentBuckets:{type:"number"},mutationsSent:{type:"number"}},required:["success","divergentBuckets","mutationsSent"],additionalProperties:!1}}};
+export const syncProtocol={"sync/negotiate":{type:"request",param:{type:"object",properties:{scopes:{type:"array",items:{type:"object",properties:{modelID:{type:"string"},ownerDID:{type:"string"}},required:["modelID","ownerDID"],additionalProperties:!1},description:"Requested sync scopes as (model, owner) pairs"},delegationTokens:{type:"array",items:{type:"string"},description:"JWT delegation tokens for authorization"},catalogIDs:{type:"array",items:{type:"string"},description:"Catalog IDs to resolve sync scope from criteria"},knownModelIDs:{type:"array",items:{type:"string"},description:"Model IDs the requester already has — used to identify missing clusters"},direction:{type:"string",enum:["push","pull","both"]}},required:["delegationTokens"],additionalProperties:!1},result:{type:"object",properties:{direction:{type:"string",enum:["push","pull","both"]},acceptedScopes:{type:"array",items:{type:"object",properties:{modelID:{type:"string"},ownerDID:{type:"string"}},required:["modelID","ownerDID"],additionalProperties:!1}},excludedDocumentIDs:{type:"array",items:{type:"string"}},missingClusters:{type:"object",description:"Cluster definitions for models the requester does not have yet",additionalProperties:!0}},required:["acceptedScopes","excludedDocumentIDs"],additionalProperties:!1}},"sync/merkle-sync":{type:"channel",param:{type:"object",properties:{scopes:{type:"array",items:{type:"object",properties:{modelID:{type:"string"},ownerDID:{type:"string"}},required:["modelID","ownerDID"],additionalProperties:!1}},excludedDocumentIDs:{type:"array",items:{type:"string"}},tree:{type:"object",description:"Merkle tree bucket hashes from requester",additionalProperties:{type:"string"}},direction:{type:"string",enum:["push","pull","both"]}},required:["scopes","excludedDocumentIDs","tree","direction"],additionalProperties:!1},send:{type:"object",properties:{type:{type:"string",enum:["mutations","complete"]},mutationJWTs:{type:"array",items:{type:"string"},description:"Signed mutation JWTs for divergent time buckets"}},required:["type"],additionalProperties:!1},receive:{type:"object",properties:{type:{type:"string",enum:["tree","mutations","complete"]},tree:{type:"object",description:"Responder merkle tree bucket hashes",additionalProperties:{type:"string"}},mutationJWTs:{type:"array",items:{type:"string"},description:"Signed mutation JWTs for divergent time buckets"}},required:["type"],additionalProperties:!1},result:{type:"object",properties:{success:{type:"boolean"},divergentBuckets:{type:"number"},mutationsSent:{type:"number"},mutationsReceived:{type:"number"}},required:["success","divergentBuckets","mutationsSent","mutationsReceived"],additionalProperties:!1}}};

package/lib/schema.d.ts

@@ -1,3 +1,3 @@
 import type { SchemaExtension } from '@kubun/engine';
-import { type SpaceEventEmitter } from './spaces/events.js';
-export declare function createP2PSchemaExtension(emitter: SpaceEventEmitter): SchemaExtension;
+import { type GroupEventEmitter } from './groups/events.js';
+export declare function createP2PSchemaExtension(emitter: GroupEventEmitter): SchemaExtension;

package/lib/schema.js

@@ -1,5 +1,5 @@
-import{createFilteredGenerator as e}from"./spaces/events.js";let a=`
-type PeerSpace {
+import{createFilteredGenerator as e}from"./groups/events.js";let r=`
+type PeerGroup {
   id: ID!
   name: String!
   description: String
@@ -7,8 +7,8 @@ type PeerSpace {
   createdAt: String!
 }
 
-type PeerSpaceMember {
-  spaceID: ID!
+type PeerGroupMember {
+  groupID: ID!
   memberDID: String!
   role: String!
   createdAt: String!
@@ -16,7 +16,7 @@ type PeerSpaceMember {
 
 type PeerCircle {
   id: ID!
-  spaceID: ID!
+  groupID: ID!
   name: String!
   description: String
   createdAt: String!
@@ -38,23 +38,23 @@ type PeerCatalog {
   createdAt: String!
 }
 
-input CreateSpaceInput {
+input CreateGroupInput {
   name: String!
   description: String
 }
 
-type CreateSpacePayload {
-  space: PeerSpace!
+type CreateGroupPayload {
+  group: PeerGroup!
 }
 
-type InviteToSpacePayload {
+type InviteToGroupPayload {
   invitePayload: String!
-  spaceID: ID!
-  spaceName: String!
+  groupID: ID!
+  groupName: String!
 }
 
-type JoinSpacePayload {
-  space: PeerSpace
+type JoinGroupPayload {
+  group: PeerGroup
 }
 
 type PrepareJoinRequestPayload {
@@ -62,15 +62,15 @@ type PrepareJoinRequestPayload {
 }
 
 type CompleteJoinPayload {
-  space: PeerSpace
+  group: PeerGroup
 }
 
-type LeaveSpacePayload {
-  spaceID: ID!
+type LeaveGroupPayload {
+  groupID: ID!
 }
 
-type RemoveSpaceMemberPayload {
-  spaceID: ID!
+type RemoveGroupMemberPayload {
+  groupID: ID!
 }
 
 input UpdateCatalogInput {
@@ -79,14 +79,14 @@ input UpdateCatalogInput {
   filterCriteria: String
 }
 
-input UpdateSpaceInput {
-  spaceID: ID!
+input UpdateGroupInput {
+  groupID: ID!
   name: String
   description: String
 }
 
-type UpdateSpacePayload {
-  space: PeerSpace!
+type UpdateGroupPayload {
+  group: PeerGroup!
 }
 
 input UpdateCircleInput {
@@ -141,28 +141,28 @@ type RemoveSyncPeerPayload {
 }
 
 extend type Query {
-  spaces: [PeerSpace!]!
-  space(id: ID!): PeerSpace
-  spaceMembers(spaceID: ID!): [PeerSpaceMember!]!
-  circles(spaceID: ID!): [PeerCircle!]!
+  groups: [PeerGroup!]!
+  group(id: ID!): PeerGroup
+  groupMembers(groupID: ID!): [PeerGroupMember!]!
+  circles(groupID: ID!): [PeerCircle!]!
   syncPeers: [SyncPeer!]!
   syncStatus: SyncStatus!
 }
 
 extend type Mutation {
-  createSpace(input: CreateSpaceInput!): CreateSpacePayload!
-  addSpaceMember(spaceID: ID!, memberDID: String!, role: String!): PeerSpaceMember!
-  createCircle(spaceID: ID!, name: String!, description: String): PeerCircle!
+  createGroup(input: CreateGroupInput!): CreateGroupPayload!
+  addGroupMember(groupID: ID!, memberDID: String!, role: String!): PeerGroupMember!
+  createCircle(groupID: ID!, name: String!, description: String): PeerCircle!
   addCircleMember(circleID: ID!, memberDID: String!, role: String!): PeerCircleMember!
   createCatalog(name: String!, description: String, filterCriteria: String!): PeerCatalog!
-  inviteToSpace(spaceID: ID!, joinRequest: String!): InviteToSpacePayload!
-  joinSpace(invitePayload: String!, joinRequestPayload: String!): JoinSpacePayload!
+  inviteToGroup(groupID: ID!, joinRequest: String!): InviteToGroupPayload!
+  joinGroup(invitePayload: String!, joinRequestPayload: String!): JoinGroupPayload!
   prepareJoinRequest: PrepareJoinRequestPayload!
   completeJoin(invitePayload: String!): CompleteJoinPayload!
-  leaveSpace(spaceID: ID!): LeaveSpacePayload!
-  removeSpaceMember(spaceID: ID!, memberDID: String!): RemoveSpaceMemberPayload!
+  leaveGroup(groupID: ID!): LeaveGroupPayload!
+  removeGroupMember(groupID: ID!, memberDID: String!): RemoveGroupMemberPayload!
   updateCatalog(input: UpdateCatalogInput!): PeerCatalog!
-  updateSpace(input: UpdateSpaceInput!): UpdateSpacePayload!
+  updateGroup(input: UpdateGroupInput!): UpdateGroupPayload!
   updateCircle(input: UpdateCircleInput!): UpdateCirclePayload!
   deleteCatalog(catalogID: ID!): DeleteCatalogPayload!
   deleteCircle(circleID: ID!): DeleteCirclePayload!
@@ -172,16 +172,16 @@ extend type Mutation {
 }
 
 extend type Subscription {
-  spaceJoined: PeerSpace!
-  spaceLeft: PeerSpace!
-  spaceDataChanged(spaceID: ID!): PeerSpace!
-  spaceMemberJoined(spaceID: ID!): PeerSpaceMember!
-  spaceMemberLeft(spaceID: ID!): PeerSpaceMember!
-  circleCreated(spaceID: ID!): PeerCircle!
-  circleDeleted(spaceID: ID!): PeerCircle!
+  groupJoined: PeerGroup!
+  groupLeft: PeerGroup!
+  groupDataChanged(groupID: ID!): PeerGroup!
+  groupMemberJoined(groupID: ID!): PeerGroupMember!
+  groupMemberLeft(groupID: ID!): PeerGroupMember!
+  circleCreated(groupID: ID!): PeerCircle!
+  circleDeleted(groupID: ID!): PeerCircle!
   circleDataChanged(circleID: ID!): PeerCircle!
   circleMemberAdded(circleID: ID!): PeerCircleMember!
   circleMemberRemoved(circleID: ID!): PeerCircleMember!
   circleCatalogsChanged(circleID: ID!): PeerCircle!
 }
-`;export function createP2PSchemaExtension(r){return{sdl:a,resolvers:{queryFields:{spaces:async(e,a,r)=>await r.spaceGetSpaces(),space:async(e,a,r)=>await r.spaceGetSpace(a.id),spaceMembers:async(e,a,r)=>await r.spaceGetSpaceMembers(a.spaceID),circles:async(e,a,r)=>await r.spaceGetCircles(a.spaceID),syncPeers:async(e,a,r)=>await r.syncListPeers(),syncStatus:(e,a,r)=>{let c=r.syncGetStatus();return{...c,lastSyncByPeer:JSON.stringify(c.lastSyncByPeer)}}},mutationFields:{createSpace:async(e,a,r)=>{let c=a.input;return{space:await r.spaceCreateSpace(c)}},addSpaceMember:async(e,a,r)=>await r.spaceAddSpaceMember(a.spaceID,a.memberDID,a.role),createCircle:async(e,a,r)=>await r.spaceCreateCircle({spaceID:a.spaceID,name:a.name,description:a.description}),addCircleMember:async(e,a,r)=>await r.spaceAddCircleMember(a.circleID,a.memberDID,a.role),createCatalog:async(e,a,r)=>await r.spaceCreateCatalog({name:a.name,description:a.description,filterCriteria:a.filterCriteria}),inviteToSpace:async(e,a,r)=>await r.spaceInviteToSpace(a.spaceID,a.joinRequest),joinSpace:async(e,a,r)=>await r.spaceJoinSpace(a.invitePayload,a.joinRequestPayload),prepareJoinRequest:async(e,a,r)=>await r.p2pPrepareJoinRequest(),completeJoin:async(e,a,r)=>await r.p2pCompleteJoin(a.invitePayload),leaveSpace:async(e,a,r)=>await r.spaceLeaveSpace(a.spaceID),removeSpaceMember:async(e,a,r)=>await r.spaceRemoveSpaceMember(a.spaceID,a.memberDID),updateCatalog:async(e,a,r)=>{let c=a.input;return await r.spaceUpdateCatalog(c)},updateSpace:async(e,a,r)=>{let c=a.input;return{space:await r.spaceUpdateSpace(c)}},updateCircle:async(e,a,r)=>{let c=a.input;return{circle:await r.spaceUpdateCircle(c)}},deleteCatalog:async(e,a,r)=>await r.spaceDeleteCatalog(a.catalogID),deleteCircle:async(e,a,r)=>await r.spaceDeleteCircle(a.circleID),removeCircleMember:async(e,a,r)=>await r.spaceRemoveCircleMember(a.circleID,a.memberDID),addSyncPeer:async(e,a,r)=>(await r.syncAddPeer({peerDID:a.peerDID,endpoint:a.endpoint,mode:a.mode??"on-demand",allowedUsers:{all:!0},priority:a.priority??"0",trustLevel:a.trustLevel??"trusted"}),!0),removeSyncPeer:async(e,a,r)=>(await r.syncRemovePeer(a.peerDID),{success:!0})},subscriptionFields:{spaceJoined:{resolve:e=>e,subscribe:()=>e(r,"spaceJoined")},spaceLeft:{resolve:e=>e,subscribe:()=>e(r,"spaceLeft")},spaceDataChanged:{resolve:e=>e,subscribe:(a,c)=>e(r,"spaceDataChanged",e=>e.spaceID===c.spaceID)},spaceMemberJoined:{resolve:e=>e,subscribe:(a,c)=>e(r,"spaceMemberJoined",e=>e.spaceID===c.spaceID)},spaceMemberLeft:{resolve:e=>e,subscribe:(a,c)=>e(r,"spaceMemberLeft",e=>e.spaceID===c.spaceID)},circleCreated:{resolve:e=>e,subscribe:(a,c)=>e(r,"circleCreated",e=>e.spaceID===c.spaceID)},circleDeleted:{resolve:e=>e,subscribe:(a,c)=>e(r,"circleDeleted",e=>e.spaceID===c.spaceID)},circleDataChanged:{resolve:e=>e,subscribe:(a,c)=>e(r,"circleDataChanged",e=>e.circleID===c.circleID)},circleMemberAdded:{resolve:e=>e,subscribe:(a,c)=>e(r,"circleMemberAdded",e=>e.circleID===c.circleID)},circleMemberRemoved:{resolve:e=>e,subscribe:(a,c)=>e(r,"circleMemberRemoved",e=>e.circleID===c.circleID)},circleCatalogsChanged:{resolve:e=>e,subscribe:(a,c)=>e(r,"circleCatalogsChanged",e=>e.circleID===c.circleID)}}}}}
+`;export function createP2PSchemaExtension(t){return{sdl:r,resolvers:{queryFields:{groups:async(e,r,t)=>await t.p2pGetGroups(),group:async(e,r,t)=>await t.p2pGetGroup(r.id),groupMembers:async(e,r,t)=>await t.p2pGetGroupMembers(r.groupID),circles:async(e,r,t)=>await t.p2pGetCircles(r.groupID),syncPeers:async(e,r,t)=>await t.syncListPeers(),syncStatus:(e,r,t)=>{let i=t.syncGetStatus();return{...i,lastSyncByPeer:JSON.stringify(i.lastSyncByPeer)}}},mutationFields:{createGroup:async(e,r,t)=>{let i=r.input;return{group:await t.p2pCreateGroup(i)}},addGroupMember:async(e,r,t)=>await t.p2pAddGroupMember(r.groupID,r.memberDID,r.role),createCircle:async(e,r,t)=>await t.p2pCreateCircle({groupID:r.groupID,name:r.name,description:r.description}),addCircleMember:async(e,r,t)=>await t.p2pAddCircleMember(r.circleID,r.memberDID,r.role),createCatalog:async(e,r,t)=>await t.p2pCreateCatalog({name:r.name,description:r.description,filterCriteria:r.filterCriteria}),inviteToGroup:async(e,r,t)=>await t.p2pInviteToGroup(r.groupID,r.joinRequest),joinGroup:async(e,r,t)=>await t.p2pJoinGroup(r.invitePayload,r.joinRequestPayload),prepareJoinRequest:async(e,r,t)=>await t.p2pPrepareJoinRequest(),completeJoin:async(e,r,t)=>await t.p2pCompleteJoin(r.invitePayload),leaveGroup:async(e,r,t)=>await t.p2pLeaveGroup(r.groupID),removeGroupMember:async(e,r,t)=>await t.p2pRemoveGroupMember(r.groupID,r.memberDID),updateCatalog:async(e,r,t)=>{let i=r.input;return await t.p2pUpdateCatalog(i)},updateGroup:async(e,r,t)=>{let i=r.input;return{group:await t.p2pUpdateGroup(i)}},updateCircle:async(e,r,t)=>{let i=r.input;return{circle:await t.p2pUpdateCircle(i)}},deleteCatalog:async(e,r,t)=>await t.p2pDeleteCatalog(r.catalogID),deleteCircle:async(e,r,t)=>await t.p2pDeleteCircle(r.circleID),removeCircleMember:async(e,r,t)=>await t.p2pRemoveCircleMember(r.circleID,r.memberDID),addSyncPeer:async(e,r,t)=>(await t.syncAddPeer({peerDID:r.peerDID,endpoint:r.endpoint,mode:r.mode??"on-demand",allowedUsers:{all:!0},priority:r.priority??"0",trustLevel:r.trustLevel??"trusted"}),!0),removeSyncPeer:async(e,r,t)=>(await t.syncRemovePeer(r.peerDID),{success:!0})},subscriptionFields:{groupJoined:{resolve:e=>e,subscribe:()=>e(t,"groupJoined")},groupLeft:{resolve:e=>e,subscribe:()=>e(t,"groupLeft")},groupDataChanged:{resolve:e=>e,subscribe:(r,i)=>e(t,"groupDataChanged",e=>e.groupID===i.groupID)},groupMemberJoined:{resolve:e=>e,subscribe:(r,i)=>e(t,"groupMemberJoined",e=>e.groupID===i.groupID)},groupMemberLeft:{resolve:e=>e,subscribe:(r,i)=>e(t,"groupMemberLeft",e=>e.groupID===i.groupID)},circleCreated:{resolve:e=>e,subscribe:(r,i)=>e(t,"circleCreated",e=>e.groupID===i.groupID)},circleDeleted:{resolve:e=>e,subscribe:(r,i)=>e(t,"circleDeleted",e=>e.groupID===i.groupID)},circleDataChanged:{resolve:e=>e,subscribe:(r,i)=>e(t,"circleDataChanged",e=>e.circleID===i.circleID)},circleMemberAdded:{resolve:e=>e,subscribe:(r,i)=>e(t,"circleMemberAdded",e=>e.circleID===i.circleID)},circleMemberRemoved:{resolve:e=>e,subscribe:(r,i)=>e(t,"circleMemberRemoved",e=>e.circleID===i.circleID)},circleCatalogsChanged:{resolve:e=>e,subscribe:(r,i)=>e(t,"circleCatalogsChanged",e=>e.circleID===i.circleID)}}}}}

package/lib/sync/catalog-scope.js

@@ -1 +1 @@
-export async function resolveCatalogSyncScopes(e,r,o){let l=new Set,t=new Set,a=!1;for(let o of r){let r=await e.resolveCatalogScope(o);if(null!=r.models)for(let e of r.models)l.add(e);if(null!=r.owners)for(let e of(a=!0,r.owners))t.add(e)}let s=Array.from(l),n=a?Array.from(t):void 0,d=new Set(o??[]),f=new Set,i=new Set;return await Promise.all(s.map(async r=>{let o=await e.getClusterForModel(r);null!=o&&(f.add(o),d.has(r)||i.add(o))})),{modelIDs:s,owners:n,requiredClusterIDs:Array.from(f),missingClusterIDs:Array.from(i)}}
+import{getGraphStore as e}from"@kubun/store-graph";import{getP2PStore as r}from"@kubun/store-p2p";export async function resolveCatalogSyncScopes(l,t,o){let[a,i]=await Promise.all([e(l),r(l)]),s=new Set,f=new Set,n=!1;for(let e of t){let r=await a.resolveCatalogScope(e);if(null!=r.models)for(let e of r.models)s.add(e);if(null!=r.owners)for(let e of(n=!0,r.owners))f.add(e);let l=await a.getCatalog(e);if(null!=l){let e=l.filter_criteria;if(null!=e.circles&&e.circles.length>0)for(let r of(n=!0,e.circles))for(let e of(await i.listCircleMembers(r)))f.add(e.member_did)}}let d=Array.from(s),m=n?Array.from(f):void 0,u=new Set(o??[]),c=new Set,w=new Set;return await Promise.all(d.map(async e=>{let r=await a.getClusterForModel(e);null!=r&&(c.add(r),u.has(e)||w.add(r))})),{modelIDs:d,owners:m,requiredClusterIDs:Array.from(c),missingClusterIDs:Array.from(w)}}

package/lib/sync/handlers.d.ts

@@ -1,5 +1,7 @@
 import type { KubunDB } from '@kubun/db';
 import type { Logger } from '@kubun/logger';
+import type { SyncDirection } from '../protocol.js';
+import type { PeerRegistry } from './peer-registry.js';
 /**
  * Check if delegation tokens grant the viewer read access to a user's documents.
  *
@@ -12,7 +14,15 @@ export declare function checkSyncDelegation(viewerDID: string, ownerDID: string,
 export type CreateSyncHandlersParams = {
     db: KubunDB;
     logger: Logger;
+    peerRegistry: PeerRegistry;
 };
+/**
+ * Resolve the effective sync direction given what the initiator requested
+ * and what the responder's per-peer policy allows.
+ * If allowed is 'both' (or unset), the request passes through.
+ * Otherwise the responder's policy wins.
+ */
+export declare function negotiateDirection(requested: SyncDirection, allowed: SyncDirection): SyncDirection;
 /**
  * Create sync protocol handlers served by plugin-p2p's own Enkaku server.
  */

package/lib/sync/handlers.js

@@ -1 +1 @@
-import{checkCapability as e}from"@enkaku/capability";import{resolveCatalogSyncScopes as t}from"./catalog-scope.js";import{buildMerkleTree as n,findDivergentBuckets as r,getTimeBuckets as s}from"./merkle-tree.js";export async function checkSyncDelegation(t,n,r){if(!r||0===r.length)return!1;let s=["*","urn:kubun:user:*",`urn:kubun:user:${n}`],l="document/read";for(let o of s)try{return await e({act:l,res:o},{iss:t,sub:n,cap:r}),!0}catch{}for(let o of r)for(let r of s)try{return await e({act:l,res:r},{iss:t,sub:n,cap:o}),!0}catch{}return!1}export function createSyncHandlers(e){let{db:l,logger:o}=e;return{"sync/negotiate":async e=>{let n,{scopes:r,delegationTokens:s,catalogIDs:a,knownModelIDs:c}=e.param,i=e.message.payload,u=i.sub||i.iss;o.debug("sync/negotiate requested",{scopes:r,catalogIDs:a,viewerDID:u});let g=[];if(null!=a&&a.length>0){let e=await t(l,a,c);if(e.modelIDs.length>0)if(null!=e.owners)for(let t of e.modelIDs)for(let n of e.owners){let e=u===n,r=!e&&await checkSyncDelegation(u,n,s);(e||r)&&g.push({modelID:t,ownerDID:n})}else for(let t of e.modelIDs)for(let e of(await l.getDistinctOwnersForModel(t))){let n=u===e,r=!n&&await checkSyncDelegation(u,e,s);(n||r)&&g.push({modelID:t,ownerDID:e})}e.missingClusterIDs.length>0&&(n=await l.getClusters(e.missingClusterIDs))}if(null!=r)for(let e of r){let t=u===e.ownerDID,n=!t&&await checkSyncDelegation(u,e.ownerDID,s);t||n?g.push(e):o.debug("sync/negotiate: scope rejected",{scope:e,viewerDID:u})}let m=new Set,f=g.filter(e=>{let t=`${e.modelID}:${e.ownerDID}`;return!m.has(t)&&(m.add(t),!0)});return o.info("sync/negotiate completed",{requested:(r?.length??0)+(a?.length??0),accepted:f.length,missingClusters:null!=n?Object.keys(n).length:0}),{acceptedScopes:f,excludedDocumentIDs:[],...null!=n&&{missingClusters:n}}},"sync/merkle-sync":async e=>{let{scopes:t,excludedDocumentIDs:a,tree:c}=e.param,i=e.writable.getWriter();o.info("sync/merkle-sync started",{scopes:t,excludedDocumentIDs:a});let u=0,g=0;try{let e=await l.getDocumentIDsForScope(t,a);if(0===e.length)return await i.write({type:"complete",divergentBuckets:0,totalMutations:0}),{success:!0,divergentBuckets:0,mutationsSent:0};let m=await l.getMutationLogForDocuments(e),f=n(m),y={root:c.root??"",buckets:c},d=r(f,y);if(u=d.length,0===d.length)return o.info("sync/merkle-sync: no divergent buckets, already in sync"),await i.write({type:"complete",divergentBuckets:0,totalMutations:0}),{success:!0,divergentBuckets:0,mutationsSent:0};let p=new Set(d),w=m.filter(e=>{let{minute:t}=s(e.hlc);return p.has(t)});for(let e=0;e<w.length;e+=1e3){let t=w.slice(e,e+1e3);await i.write({type:"mutations",mutationJWTs:t.map(e=>e.mutation_jwt)}),g+=t.length}await i.write({type:"complete",divergentBuckets:u,totalMutations:g})}catch(e){throw o.error("sync/merkle-sync error",{error:e}),e}finally{try{await i.close()}catch{}}return o.info("sync/merkle-sync completed",{divergentBuckets:u,mutationsSent:g}),{success:!0,divergentBuckets:u,mutationsSent:g}}}}
+import{checkCapability as e}from"@enkaku/capability";import{getGraphStore as t}from"@kubun/store-graph";import{resolveCatalogSyncScopes as n}from"./catalog-scope.js";import{createMerkleSyncChannelHandler as o}from"./merkle-channel.js";export async function checkSyncDelegation(t,n,o){if(!o||0===o.length)return!1;let r=["*","urn:kubun:user:*",`urn:kubun:user:${n}`],l="document/read";for(let a of r)try{return await e({act:l,res:a},{iss:t,sub:n,cap:o}),!0}catch{}for(let a of o)for(let o of r)try{return await e({act:l,res:o},{iss:t,sub:n,cap:a}),!0}catch{}return!1}export function negotiateDirection(e,t){return"both"===t?e:"both"===e?t:e===t?e:t}export function createSyncHandlers(e){let{db:r,logger:l,peerRegistry:a}=e;return{"sync/negotiate":async e=>{let o,{scopes:s,delegationTokens:i,catalogIDs:c,knownModelIDs:u,direction:g}=e.param,f=e.message.payload,d=f.sub||f.iss;l.debug("sync/negotiate requested",{scopes:s,catalogIDs:c,viewerDID:d});let p=[],D=await t(r);if(null!=c&&c.length>0){let e=await n(r,c,u);if(e.modelIDs.length>0)if(null!=e.owners)for(let t of e.modelIDs)for(let n of e.owners){let e=d===n,o=!e&&await checkSyncDelegation(d,n,i);(e||o)&&p.push({modelID:t,ownerDID:n})}else for(let t of e.modelIDs)for(let e of(await D.getDistinctOwnersForModel(t))){let n=d===e,o=!n&&await checkSyncDelegation(d,e,i);(n||o)&&p.push({modelID:t,ownerDID:e})}e.missingClusterIDs.length>0&&(o=await D.getClusters(e.missingClusterIDs))}if(null!=s)for(let e of s){let t=d===e.ownerDID,n=!t&&await checkSyncDelegation(d,e.ownerDID,i);t||n?p.push(e):l.debug("sync/negotiate: scope rejected",{scope:e,viewerDID:d})}let h=new Set,m=p.filter(e=>{let t=`${e.modelID}:${e.ownerDID}`;return!h.has(t)&&(h.add(t),!0)});l.info("sync/negotiate completed",{requested:(s?.length??0)+(c?.length??0),accepted:m.length,missingClusters:null!=o?Object.keys(o).length:0});let w=g??"pull",y=await a.getPeer({peerDID:d,stores:r}),b=y?.allowedDirection??"both",k=negotiateDirection(w,b);return k!==w&&l.info("sync/negotiate: direction downgraded",{requested:w,allowed:b,agreed:k}),{direction:k,acceptedScopes:m,excludedDocumentIDs:[],...null!=o&&{missingClusters:o}}},"sync/merkle-sync":o({db:r,logger:l})}}

package/lib/sync/merkle-apply.js

@@ -1 +1 @@
-import{asType as t,createValidator as a}from"@enkaku/schema";import{verifyToken as i}from"@enkaku/token";import{computeMutationHash as o}from"@kubun/engine";import{DocumentID as n}from"@kubun/id";import{applyMutation as u}from"@kubun/mutation";import{documentMutation as e}from"@kubun/protocol";let r=a(e);export async function applySyncMutations(a){let{db:e,mutationJWTs:m}=a,s=0,d=0,l=0,c=0,h={db:e,validators:{}};for(let a of m){let m,p=o(a);if(await e.hasMutationHash(p)){c++;continue}try{let o=await i(a);m=t(r,o.payload)}catch{d++;continue}let _=m.sub,f=n.fromString(_).model.toString(),w=n.fromString(_);if(null==await e.getDocument(w)&&"change"===m.typ){await e.insertMutationLogEntry({mutation_hash:p,model_id:f,document_id:_,author_did:m.iss,hlc:m.hlc,mutation_jwt:a,status:"pending"}),l++;continue}try{if(await u(h,m),await e.insertMutationLogEntry({mutation_hash:p,model_id:f,document_id:_,author_did:m.iss,hlc:m.hlc,mutation_jwt:a,status:"applied"}),s++,"set"===m.typ)for(let a of(await e.getPendingMutations(_)))try{let o=await i(a.mutation_jwt),n=t(r,o.payload);await u(h,n),await e.updateMutationStatus(a.mutation_hash,"applied"),s++}catch{await e.updateMutationStatus(a.mutation_hash,"rejected"),d++}}catch{await e.insertMutationLogEntry({mutation_hash:p,model_id:f,document_id:_,author_did:m.iss,hlc:m.hlc,mutation_jwt:a,status:"rejected"}),d++}}return{applied:s,rejected:d,pending:l,skipped:c}}
+import{asType as t,createValidator as a}from"@enkaku/schema";import{verifyToken as i}from"@enkaku/token";import{computeMutationHash as o}from"@kubun/engine";import{DocumentID as n}from"@kubun/id";import{applyMutation as u}from"@kubun/mutation";import{documentMutation as e}from"@kubun/protocol";import{getGraphStore as r}from"@kubun/store-graph";let m=a(e);export async function applySyncMutations(a){let{db:e,mutationJWTs:s}=a,d=await r(e),l=0,c=0,h=0,p=0,_={store:d,validators:{}};for(let a of s){let e,r=o(a);if(await d.hasMutationHash(r)){p++;continue}try{let o=await i(a);e=t(m,o.payload)}catch{c++;continue}let s=e.sub,f=n.fromString(s).model.toString(),w=n.fromString(s);if(null==await d.getDocument(w)&&"change"===e.typ){await d.insertMutationLogEntry({mutation_hash:r,model_id:f,document_id:s,author_did:e.iss,hlc:e.hlc,mutation_jwt:a,status:"pending"}),h++;continue}try{if(await u(_,e),await d.insertMutationLogEntry({mutation_hash:r,model_id:f,document_id:s,author_did:e.iss,hlc:e.hlc,mutation_jwt:a,status:"applied"}),l++,"set"===e.typ)for(let a of(await d.getPendingMutations(s)))try{let o=await i(a.mutation_jwt),n=t(m,o.payload);await u(_,n),await d.updateMutationStatus(a.mutation_hash,"applied"),l++}catch{await d.updateMutationStatus(a.mutation_hash,"rejected"),c++}}catch{await d.insertMutationLogEntry({mutation_hash:r,model_id:f,document_id:s,author_did:e.iss,hlc:e.hlc,mutation_jwt:a,status:"rejected"}),c++}}return{applied:l,rejected:c,pending:h,skipped:p}}

package/lib/sync/merkle-channel.d.ts

@@ -0,0 +1,18 @@
+import type { KubunDB } from '@kubun/db';
+import type { Logger } from '@kubun/logger';
+import type { SyncMerkleSyncParams, SyncMerkleSyncReceive, SyncMerkleSyncResult, SyncMerkleSyncSend } from '../protocol.js';
+/**
+ * Minimal handler context shape for sync/merkle-sync channel.
+ * Matches the Enkaku ChannelHandlerContext at runtime.
+ */
+type MerkleSyncChannelContext = {
+    param: SyncMerkleSyncParams;
+    readable: ReadableStream<SyncMerkleSyncSend>;
+    writable: WritableStream<SyncMerkleSyncReceive>;
+};
+export type CreateMerkleSyncChannelHandlerParams = {
+    db: KubunDB;
+    logger: Logger;
+};
+export declare function createMerkleSyncChannelHandler(params: CreateMerkleSyncChannelHandlerParams): (ctx: MerkleSyncChannelContext) => Promise<SyncMerkleSyncResult>;
+export {};

package/lib/sync/merkle-channel.js

@@ -0,0 +1 @@
+import{getGraphStore as e}from"@kubun/store-graph";import{applySyncMutations as t}from"./merkle-apply.js";import{buildMerkleTree as r,findDivergentBuckets as a,getTimeBuckets as n,SYNC_BATCH_SIZE as l}from"./merkle-tree.js";export function createMerkleSyncChannelHandler(i){let{db:o,logger:s}=i;return async i=>{let{scopes:c,excludedDocumentIDs:m,tree:u,direction:p}=i.param,y=i.writable.getWriter();s.info("sync/merkle-sync channel started",{scopes:c,excludedDocumentIDs:m,direction:p});let w=0,f=0,k=0;try{let h=await e(o),d=await h.getDocumentIDsForScope(c,m),g=await h.getMutationLogForDocuments(d),b=r(g);await y.write({type:"tree",tree:b.buckets});let v={root:u.root??"",buckets:u},W=a(b,v);w=W.length;let J=async()=>{if("pull"===p||"both"===p){let e=new Set(W),t=g.filter(t=>{let{minute:r}=n(t.hlc);return e.has(r)});for(let e=0;e<t.length;e+=l){let r=t.slice(e,e+l);await y.write({type:"mutations",mutationJWTs:r.map(e=>e.mutation_jwt)}),f+=r.length}await y.write({type:"complete"})}else await y.write({type:"complete"})},S=async()=>{let e=[],t=i.readable.getReader();try{for(;;){let{done:r,value:a}=await t.read();if(r)break;if("mutations"===a.type&&null!=a.mutationJWTs)e.push(...a.mutationJWTs);else if("complete"===a.type)break}}finally{t.releaseLock()}return e},[,T]=await Promise.all([J(),S()]);if(T.length>0){let e=await t({db:o,mutationJWTs:T});k=e.applied+e.pending,s.info("sync/merkle-sync: applied received mutations",{result:e})}}catch(e){return s.error("sync/merkle-sync channel error",{error:e}),{success:!1,divergentBuckets:0,mutationsSent:0,mutationsReceived:0}}finally{try{await y.close()}catch{}}return s.info("sync/merkle-sync channel completed",{divergentBuckets:w,mutationsSent:f,mutationsReceived:k}),{success:!0,divergentBuckets:w,mutationsSent:f,mutationsReceived:k}}}