@kubun/plugin-p2p 0.8.1 → 0.8.2

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,22 +1,24 @@
 import type { KubunPlugin, PluginFactoryParams } from '@kubun/engine';
 export type { ContextDeps, PendingJoinRequest } from './context/types.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 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, negotiateDirection } from './sync/handlers.js';
 export { type PeerConfig, type PeerConfigWithID, PeerRegistry } from './sync/peer-registry.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 r}from"@enkaku/server";import{DirectTransports as t}from"@enkaku/transport";import{HLC as s}from"@kubun/hlc";import{spaceStoreDefinition as o}from"@kubun/store-space";import{createJoinContext as n}from"./context/join.js";import{createSpaceContext as a}from"./context/space.js";import{createSyncContext as c}from"./context/sync.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{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,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 function createP2PPlugin(g){return y=>{let u,f;y.db.register(o);let j=y.db.adapter,h=y.identity,v=new s({nodeID:h.id}),x=new m({identity:h,getRandomID:y.runtime.getRandomID}),P=p(),S=new l({deployClusters:async e=>{let r=Object.values(e);await y.engine.deployGraph({clusters:r})},runtime:y.runtime,identity:y.identity,logger:y.getLogger("sync")}),b=d({db:y.db,logger:y.getLogger("sync-handlers"),peerRegistry:S.peerRegistry}),R=new Map,w=[],k={addPeer:e=>S.addPeer({config:e,stores:y.db}),removePeer:e=>S.removePeer({peerDID:e,stores:y.db}),listPeers:()=>S.listPeers({stores:y.db}),syncWithPeer:e=>S.merkleSyncWithPeer({...e,stores:y.db}),getStatus:e=>S.getStatus({peerDID:e,stores:y.db}),onSyncEvent:e=>S.onSyncEvent(e),createSyncTransport:function(e){let s=new t({signal:e}),o=new r({accessControl:!1,getRandomID:y.runtime.getRandomID,handlers:b,logger:y.getLogger("sync-server"),transports:[s.server],signal:e});return w.push(o),s.client}};if(g?.http){let t="string"==typeof g.http?g.http.replace(/^\//,""):"sync";k.syncReady=(async()=>{let s=await y.engine.getAPI("http");await s.listening,u=new e({allowedOrigin:["*"]}),f=new r({accessControl:!1,getRandomID:y.runtime.getRandomID,handlers:b,logger:y.getLogger("sync-http-server"),transports:[u]}),w.push(f),s.registerProtocol(t,u.fetch.bind(u))})()}return{name:"p2p",schemaExtension:e=>i(P),api:k,createContextFactory:()=>(e,r)=>{let t={identity:h,spaceManager:x,syncManager:S,stores:r,adapter:j,hlc:v,emitter:P,pendingJoinRequests:R,runtime:y.runtime,autoAcceptPeers:g?.autoAcceptPeers};return{...a(e,t),...c(e,t),...n(e,t)}},dispose:async()=>{for(let e of w)await e.dispose();await u?.dispose(),await S.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/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 @@
-import{getGraphStore as e}from"@kubun/store-graph";import{getSpaceStore as r}from"@kubun/store-space";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,c=new Set(o??[]),u=new Set,w=new Set;return await Promise.all(d.map(async e=>{let r=await a.getClusterForModel(e);null!=r&&(u.add(r),c.has(e)||w.add(r))})),{modelIDs:d,owners:m,requiredClusterIDs:Array.from(u),missingClusterIDs:Array.from(w)}}
+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/peer-registry.js

@@ -1 +1 @@
-import{getSpaceStore as e}from"@kubun/store-space";function t(e){var t,r;let i="string"==typeof(t=e.config)?JSON.parse(t):t??{};return{id:e.id,peerDID:e.peer_did,endpoint:e.endpoint,mode:e.mode,allowedUsers:"string"==typeof(r=e.allowed_users)?JSON.parse(r):r,priority:e.priority,trustLevel:e.trust_level,allowedDirection:i.allowedDirection,createdAt:e.created_at,updatedAt:e.updated_at}}export class PeerRegistry{#e;constructor(e){this.#e=e.runtime}async addPeer(t){let r=await e(t.stores);await r.addSyncPeer({id:this.#e.getRandomID(),peer_did:t.config.peerDID,endpoint:t.config.endpoint,mode:t.config.mode,allowed_users:t.config.allowedUsers,priority:t.config.priority,trust_level:t.config.trustLevel,config:{allowedDirection:t.config.allowedDirection},created_at:Date.now(),updated_at:Date.now()})}async getPeer(r){let i=await e(r.stores),o=await i.getSyncPeer(r.peerDID);if(o)return t(o)}async listPeers(r){let i=await e(r.stores);return(await i.listSyncPeers()).map(e=>t(e))}async updatePeer(t){let r=await this.getPeer({peerDID:t.peerDID,stores:t.stores});if(!r)throw Error(`Peer ${t.peerDID} not found`);let i={...r,...t.updates},o=await e(t.stores);await o.updateSyncPeer(t.peerDID,{endpoint:i.endpoint,mode:i.mode,allowed_users:i.allowedUsers,priority:i.priority,trust_level:i.trustLevel,config:{allowedDirection:i.allowedDirection}})}async removePeer(t){let r=await e(t.stores);await r.removeSyncPeer(t.peerDID)}async isPeerAllowed(e){return void 0!==await this.getPeer({peerDID:e.peerDID,stores:e.stores})}}
+import{getP2PStore as e}from"@kubun/store-p2p";function t(e){var t,r;let i="string"==typeof(t=e.config)?JSON.parse(t):t??{};return{id:e.id,peerDID:e.peer_did,endpoint:e.endpoint,mode:e.mode,allowedUsers:"string"==typeof(r=e.allowed_users)?JSON.parse(r):r,priority:e.priority,trustLevel:e.trust_level,allowedDirection:i.allowedDirection,createdAt:e.created_at,updatedAt:e.updated_at}}export class PeerRegistry{#e;constructor(e){this.#e=e.runtime}async addPeer(t){let r=await e(t.stores);await r.addSyncPeer({id:this.#e.getRandomID(),peer_did:t.config.peerDID,endpoint:t.config.endpoint,mode:t.config.mode,allowed_users:t.config.allowedUsers,priority:t.config.priority,trust_level:t.config.trustLevel,config:{allowedDirection:t.config.allowedDirection},created_at:Date.now(),updated_at:Date.now()})}async getPeer(r){let i=await e(r.stores),o=await i.getSyncPeer(r.peerDID);if(o)return t(o)}async listPeers(r){let i=await e(r.stores);return(await i.listSyncPeers()).map(e=>t(e))}async updatePeer(t){let r=await this.getPeer({peerDID:t.peerDID,stores:t.stores});if(!r)throw Error(`Peer ${t.peerDID} not found`);let i={...r,...t.updates},o=await e(t.stores);await o.updateSyncPeer(t.peerDID,{endpoint:i.endpoint,mode:i.mode,allowed_users:i.allowedUsers,priority:i.priority,trust_level:i.trustLevel,config:{allowedDirection:i.allowedDirection}})}async removePeer(t){let r=await e(t.stores);await r.removeSyncPeer(t.peerDID)}async isPeerAllowed(e){return void 0!==await this.getPeer({peerDID:e.peerDID,stores:e.stores})}}

package/lib/types.d.ts

@@ -3,22 +3,22 @@ import type { SyncDirection, SyncProtocol } from './protocol.js';
 import type { PeerConfig, PeerConfigWithID } from './sync/peer-registry.js';
 import type { SyncScope } from './sync/sync-client.js';
 import type { SyncEvent, SyncStatus } from './sync/sync-manager.js';
-export type SpaceData = {
+export type GroupData = {
     id: string;
     name: string;
     description: string;
     createdBy: string;
     createdAt: string;
 };
-export type SpaceMemberData = {
-    spaceID: string;
+export type GroupMemberData = {
+    groupID: string;
     memberDID: string;
     role: string;
     createdAt: string;
 };
 export type CircleData = {
     id: string;
-    spaceID: string;
+    groupID: string;
     name: string;
     description: string;
     createdAt: string;
@@ -37,19 +37,19 @@ export type CatalogData = {
     filterCriteria: string;
     createdAt: string;
 };
-export type InviteToSpaceData = {
+export type InviteToGroupData = {
     invitePayload: string;
-    spaceID: string;
-    spaceName: string;
+    groupID: string;
+    groupName: string;
 };
-export type JoinSpaceData = {
-    space: SpaceData | null;
+export type JoinGroupData = {
+    group: GroupData | null;
 };
-export type LeaveSpaceData = {
-    spaceID: string;
+export type LeaveGroupData = {
+    groupID: string;
 };
-export type RemoveSpaceMemberData = {
-    spaceID: string;
+export type RemoveGroupMemberData = {
+    groupID: string;
 };
 export type DeleteCatalogData = {
     deletedID: string;
@@ -61,8 +61,8 @@ export type RemoveCircleMemberData = {
     circleID: string;
     memberDID: string;
 };
-export type UpdateSpaceInput = {
-    spaceID: string;
+export type UpdateGroupInput = {
+    groupID: string;
     name?: string;
     description?: string;
 };
@@ -72,42 +72,42 @@ export type UpdateCircleInput = {
     description?: string;
     catalogIDs?: Array<string>;
 };
-export type SpaceRequestContext = {
-    spaceCreateSpace: (input: {
+export type GroupRequestContext = {
+    p2pCreateGroup: (input: {
         name: string;
         description?: string;
-    }) => Promise<SpaceData>;
-    spaceGetSpaces: () => Promise<Array<SpaceData>>;
-    spaceGetSpace: (id: string) => Promise<SpaceData | null>;
-    spaceAddSpaceMember: (spaceID: string, memberDID: string, role: string) => Promise<SpaceMemberData>;
-    spaceGetSpaceMembers: (spaceID: string) => Promise<Array<SpaceMemberData>>;
-    spaceCreateCircle: (params: {
-        spaceID: string;
+    }) => Promise<GroupData>;
+    p2pGetGroups: () => Promise<Array<GroupData>>;
+    p2pGetGroup: (id: string) => Promise<GroupData | null>;
+    p2pAddGroupMember: (groupID: string, memberDID: string, role: string) => Promise<GroupMemberData>;
+    p2pGetGroupMembers: (groupID: string) => Promise<Array<GroupMemberData>>;
+    p2pCreateCircle: (params: {
+        groupID: string;
         name: string;
         description?: string;
     }) => Promise<CircleData>;
-    spaceGetCircles: (spaceID: string) => Promise<Array<CircleData>>;
-    spaceAddCircleMember: (circleID: string, memberDID: string, role: string) => Promise<CircleMemberData>;
-    spaceCreateCatalog: (params: {
+    p2pGetCircles: (groupID: string) => Promise<Array<CircleData>>;
+    p2pAddCircleMember: (circleID: string, memberDID: string, role: string) => Promise<CircleMemberData>;
+    p2pCreateCatalog: (params: {
         name: string;
         description?: string;
         filterCriteria: string;
     }) => Promise<CatalogData>;
-    spaceGetCatalogs: (ownerDID?: string) => Promise<Array<CatalogData>>;
-    spaceInviteToSpace: (spaceID: string, joinRequest: string) => Promise<InviteToSpaceData>;
-    spaceJoinSpace: (invitePayload: string, joinRequestPayload: string) => Promise<JoinSpaceData>;
-    spaceLeaveSpace: (spaceID: string) => Promise<LeaveSpaceData>;
-    spaceRemoveSpaceMember: (spaceID: string, memberDID: string) => Promise<RemoveSpaceMemberData>;
-    spaceUpdateSpace: (input: UpdateSpaceInput) => Promise<SpaceData>;
-    spaceUpdateCircle: (input: UpdateCircleInput) => Promise<CircleData>;
-    spaceUpdateCatalog: (params: {
+    p2pGetCatalogs: (ownerDID?: string) => Promise<Array<CatalogData>>;
+    p2pInviteToGroup: (groupID: string, joinRequest: string) => Promise<InviteToGroupData>;
+    p2pJoinGroup: (invitePayload: string, joinRequestPayload: string) => Promise<JoinGroupData>;
+    p2pLeaveGroup: (groupID: string) => Promise<LeaveGroupData>;
+    p2pRemoveGroupMember: (groupID: string, memberDID: string) => Promise<RemoveGroupMemberData>;
+    p2pUpdateGroup: (input: UpdateGroupInput) => Promise<GroupData>;
+    p2pUpdateCircle: (input: UpdateCircleInput) => Promise<CircleData>;
+    p2pUpdateCatalog: (params: {
         catalogID: string;
         name?: string;
         filterCriteria?: string;
     }) => Promise<CatalogData>;
-    spaceDeleteCatalog: (catalogID: string) => Promise<DeleteCatalogData>;
-    spaceDeleteCircle: (circleID: string) => Promise<DeleteCircleData>;
-    spaceRemoveCircleMember: (circleID: string, memberDID: string) => Promise<RemoveCircleMemberData>;
+    p2pDeleteCatalog: (catalogID: string) => Promise<DeleteCatalogData>;
+    p2pDeleteCircle: (circleID: string) => Promise<DeleteCircleData>;
+    p2pRemoveCircleMember: (circleID: string, memberDID: string) => Promise<RemoveCircleMemberData>;
 };
 export type SyncRequestContext = {
     syncAddPeer: (config: PeerConfig) => Promise<void>;
@@ -120,7 +120,7 @@ export type P2PJoinRequestContext = {
         joinRequest: string;
     }>;
     p2pCompleteJoin: (invitePayload: string) => Promise<{
-        space: SpaceData | null;
+        group: GroupData | null;
     }>;
 };
 export type SyncSessionResult = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/plugin-p2p",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "license": "see LICENSE.md",
   "type": "module",
   "main": "lib/index.js",
@@ -14,45 +14,47 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@enkaku/async": "^0.14.0",
+    "@enkaku/async": "^0.14.1",
     "@enkaku/capability": "^0.14.0",
-    "@enkaku/client": "^0.14.3",
+    "@enkaku/client": "^0.14.4",
     "@enkaku/codec": "^0.14.0",
     "@enkaku/event": "^0.14.1",
     "@enkaku/generator": "^0.14.0",
     "@enkaku/group": "^0.14.6",
     "@enkaku/http-client-transport": "^0.14.3",
     "@enkaku/http-server-transport": "^0.14.2",
+    "@enkaku/hub-protocol": "^0.14.0",
     "@enkaku/protocol": "^0.14.0",
     "@enkaku/runtime": "^0.14.0",
     "@enkaku/schema": "^0.14.0",
-    "@enkaku/server": "^0.14.3",
+    "@enkaku/server": "^0.14.4",
     "@enkaku/stream": "^0.14.1",
     "@enkaku/token": "0.14.1",
-    "@enkaku/transport": "0.14.0",
+    "@enkaku/transport": "0.14.1",
     "@noble/hashes": "^2.2.0",
     "graphql": "^16.13.2",
     "kysely": "^0.28.16",
     "@kubun/client": "^0.8.0",
-    "@kubun/db": "^0.8.1",
-    "@kubun/engine": "^0.8.1",
-    "@kubun/store-space": "^0.8.0",
-    "@kubun/db-adapter": "^0.8.1",
-    "@kubun/store-graph": "^0.8.0",
+    "@kubun/store-p2p": "^0.8.0",
     "@kubun/graphql": "^0.8.1",
-    "@kubun/hlc": "^0.8.0",
+    "@kubun/engine": "^0.8.2",
     "@kubun/id": "^0.8.0",
-    "@kubun/logger": "^0.8.0",
+    "@kubun/hlc": "^0.8.0",
     "@kubun/mutation": "^0.8.1",
-    "@kubun/protocol": "^0.8.0"
+    "@kubun/db": "^0.8.1",
+    "@kubun/store-graph": "^0.8.1",
+    "@kubun/protocol": "^0.8.1",
+    "@kubun/logger": "^0.8.0",
+    "@kubun/db-adapter": "^0.8.1"
   },
   "devDependencies": {
+    "@enkaku/hub-server": "^0.14.1",
     "get-port": "^7.2.0",
     "@kubun/db-better-sqlite": "^0.8.1",
     "@kubun/plugin-connector": "^0.8.1",
+    "@kubun/plugin-rpc": "^0.8.1",
     "@kubun/plugin-http": "^0.8.1",
-    "@kubun/test-utils": "^0.8.0",
-    "@kubun/plugin-rpc": "^0.8.1"
+    "@kubun/test-utils": "^0.8.0"
   },
   "scripts": {
     "build:clean": "del lib",

package/lib/context/space.d.ts

@@ -1,4 +0,0 @@
-import type { ExecutionContext } from '@kubun/engine';
-import type { SpaceRequestContext } from '../types.js';
-import type { ContextDeps } from './types.js';
-export declare function createSpaceContext(ctx: ExecutionContext, deps: ContextDeps): SpaceRequestContext;