@kubun/plugin-p2p 0.8.0 → 0.8.1

package/lib/context/join.js

@@ -1 +1 @@
-import{createKeyPackageBundle as e}from"@enkaku/group";import{decodeInvitePayload as i,encodeJoinRequest as t}from"../spaces/invite-payload.js";import{createSpaceFromJoin as a}from"../spaces/join-utils.js";import{checkPeerAccess as r}from"./types.js";export function createJoinContext(n,p){return{p2pPrepareJoinRequest:async()=>{r(n.viewerDID,p.identity.id,p.autoAcceptPeers);let i=p.identity,a=await e(i);return p.pendingJoinRequests.set(n.viewerDID,{publicPackage:a.publicPackage,privatePackage:a.privatePackage,did:i.id}),{joinRequest:t({did:i.id,publicPackage:a.publicPackage})}},p2pCompleteJoin:async e=>{r(n.viewerDID,p.identity.id,p.autoAcceptPeers);let t=p.pendingJoinRequests.get(n.viewerDID);if(null==t)throw Error("No pending join request found — call prepareJoinRequest first");let c=await p.getDB(),o=p.identity,s=i(e),d={publicPackage:t.publicPackage,privatePackage:t.privatePackage,ownerDID:o.id};await p.spaceManager.joinSpace({identity:o,spaceID:s.spaceID,invite:s.invite,keyPackageBundle:d,welcomeMessage:s.welcomeMessage,ratchetTree:s.ratchetTree},c);let u=await a({db:c,adapter:p.adapter,hlc:p.hlc,emitter:p.emitter,identity:o,invite:s});return p.pendingJoinRequests.delete(n.viewerDID),u}}}
+import{createKeyPackageBundle as e}from"@enkaku/group";import{decodeInvitePayload as t,encodeJoinRequest as i}from"../spaces/invite-payload.js";import{createSpaceFromJoin as a}from"../spaces/join-utils.js";import{checkPeerAccess as r}from"./types.js";export function createJoinContext(n,s){return{p2pPrepareJoinRequest:async()=>{r(n.viewerDID,s.identity.id,s.autoAcceptPeers);let t=s.identity,a=await e(t);return s.pendingJoinRequests.set(n.viewerDID,{publicPackage:a.publicPackage,privatePackage:a.privatePackage,did:t.id}),{joinRequest:i({did:t.id,publicPackage:a.publicPackage})}},p2pCompleteJoin:async e=>{r(n.viewerDID,s.identity.id,s.autoAcceptPeers);let i=s.pendingJoinRequests.get(n.viewerDID);if(null==i)throw Error("No pending join request found — call prepareJoinRequest first");let o=s.identity,p=t(e),c={publicPackage:i.publicPackage,privatePackage:i.privatePackage,ownerDID:o.id};await s.spaceManager.joinSpace({stores:s.stores,identity:o,spaceID:p.spaceID,invite:p.invite,keyPackageBundle:c,welcomeMessage:p.welcomeMessage,ratchetTree:p.ratchetTree});let u=await a({stores:s.stores,hlc:s.hlc,emitter:s.emitter,identity:o,invite:p});return s.pendingJoinRequests.delete(n.viewerDID),u}}}

package/lib/context/space.js

@@ -1 +1 @@
-import{HLC as e}from"@kubun/hlc";import{restoreGroupHandle as t}from"../spaces/group-handle.js";import{decodeFullJoinRequest as a,decodeInvitePayload as r,decodeJoinRequest as i,encodeInvitePayload as c}from"../spaces/invite-payload.js";import{createSpaceFromJoin as l}from"../spaces/join-utils.js";import{checkPeerAccess as s,normalizeCredential as d,toISO as n}from"./types.js";export function createSpaceContext(p,o){return{spaceCreateSpace:async e=>await p.transaction(async t=>{let a=t.db,r=await o.spaceManager.createSpace({identity:o.identity,name:e.name,description:e.description},a);await t.db.updateTable("kubun_spaces").set({created_by:p.viewerDID}).where("id","=",r.spaceID).execute();let i=await t.db.selectFrom("kubun_spaces").selectAll().where("id","=",r.spaceID).executeTakeFirst();if(null==i)throw Error("Failed to create space");t.emit("space:created",{spaceID:r.spaceID});let c={id:i.id,name:i.name,description:i.description,createdBy:i.created_by,createdAt:n(i.created_at)};return await o.emitter.emit("spaceJoined",c),c}),spaceGetSpaces:async()=>{let e=await o.getDB();return(await e.selectFrom("kubun_spaces").selectAll().execute()).map(e=>({id:e.id,name:e.name,description:e.description,createdBy:e.created_by,createdAt:n(e.created_at)}))},spaceGetSpace:async e=>{let t=await o.getDB(),a=await t.selectFrom("kubun_spaces").selectAll().where("id","=",e).executeTakeFirst();return null==a?null:{id:a.id,name:a.name,description:a.description,createdBy:a.created_by,createdAt:n(a.created_at)}},spaceAddSpaceMember:async(e,t,a)=>{let r=await o.getDB();await r.insertInto("kubun_space_members").values({space_id:e,member_did:t,role:a}).onConflict(e=>e.columns(["space_id","member_did"]).doUpdateSet(e=>({role:e.ref("excluded.role"),updated_at:o.adapter.encodeTimestamp(new Date)}))).execute();let i=await r.selectFrom("kubun_space_members").selectAll().where("space_id","=",e).where("member_did","=",t).executeTakeFirst();if(null==i)throw Error("Failed to add space member");let c={spaceID:i.space_id,memberDID:i.member_did,role:i.role,createdAt:n(i.created_at)};return await o.emitter.emit("spaceMemberJoined",{...c,spaceID:c.spaceID}),c},spaceGetSpaceMembers:async e=>{let t=await o.getDB();return(await t.selectFrom("kubun_space_members").selectAll().where("space_id","=",e).execute()).map(e=>({spaceID:e.space_id,memberDID:e.member_did,role:e.role,createdAt:n(e.created_at)}))},spaceCreateCircle:async e=>{let t=await o.spaceManager.createCircle({spaceID:e.spaceID,name:e.name,description:e.description}),a=await o.getDB(),r=await a.selectFrom("kubun_circles").selectAll().where("id","=",t.circleID).executeTakeFirst();if(null==r)throw Error("Failed to create circle");let i={id:r.id,spaceID:r.space_id,name:r.name,description:r.description,createdAt:n(r.created_at)};return await o.emitter.emit("circleCreated",{...i,spaceID:i.spaceID}),i},spaceGetCircles:async e=>{let t=await o.getDB();return(await t.selectFrom("kubun_circles").selectAll().where("space_id","=",e).execute()).map(e=>({id:e.id,spaceID:e.space_id,name:e.name,description:e.description,createdAt:n(e.created_at)}))},spaceAddCircleMember:async(t,a,r)=>{let i=await o.getDB(),c=e.serialize(o.hlc.now());await i.insertInto("kubun_circle_members").values({circle_id:t,member_did:a,role:r,hlc:c}).onConflict(e=>e.columns(["circle_id","member_did"]).doUpdateSet(e=>({role:e.ref("excluded.role"),hlc:e.ref("excluded.hlc")}))).execute();let l=await i.selectFrom("kubun_circle_members").selectAll().where("circle_id","=",t).where("member_did","=",a).executeTakeFirst();if(null==l)throw Error("Failed to add circle member");let s={circleID:l.circle_id,memberDID:l.member_did,role:l.role,createdAt:n(l.created_at)};return await o.emitter.emit("circleMemberAdded",{...s,circleID:s.circleID}),s},spaceCreateCatalog:async t=>{let a=await o.getDB(),r=o.runtime.getRandomID(),i=e.serialize(o.hlc.now());await a.insertInto("kubun_catalogs").values({id:r,owner_did:p.viewerDID,name:t.name,description:t.description??"",filter_criteria:o.adapter.encodeJSON("string"==typeof t.filterCriteria?JSON.parse(t.filterCriteria):t.filterCriteria),hlc:i}).execute();let c=await a.selectFrom("kubun_catalogs").selectAll().where("id","=",r).executeTakeFirst();if(null==c)throw Error("Failed to create catalog");return{id:c.id,ownerDID:c.owner_did,name:c.name,description:c.description,filterCriteria:"string"==typeof c.filter_criteria?c.filter_criteria:JSON.stringify(c.filter_criteria),createdAt:n(c.created_at)}},spaceGetCatalogs:async e=>{let t=(await o.getDB()).selectFrom("kubun_catalogs").selectAll();return null!=e&&(t=t.where("owner_did","=",e)),(await t.execute()).map(e=>({id:e.id,ownerDID:e.owner_did,name:e.name,description:e.description,filterCriteria:"string"==typeof e.filter_criteria?e.filter_criteria:JSON.stringify(e.filter_criteria),createdAt:n(e.created_at)}))},spaceInviteToSpace:async(e,a)=>{s(p.viewerDID,o.identity.id,o.autoAcceptPeers);let r=await o.getDB(),l=o.identity,n=await r.selectFrom("kubun_space_mls_state").selectAll().where("space_id","=",e).where("device_id","=",l.id).executeTakeFirst();if(null==n)throw Error(`No MLS state for space ${e}`);let m=await t({mlsState:n.mls_state,credential:d(n.credential),epoch:n.epoch,rootCapability:n.root_capability}),u=i(a),w=await o.spaceManager.inviteToSpace({spaceID:e,identity:l,groupHandle:m,recipientDID:u.did,recipientKeyPackage:u.publicPackage,permission:"member"},r),_=await r.selectFrom("kubun_spaces").select(["name","hub_urls"]).where("id","=",e).executeTakeFirst(),D="string"==typeof _?.hub_urls?JSON.parse(_.hub_urls):_?.hub_urls??[],b=c({spaceID:e,spaceName:_?.name??"",hubURLs:D,invite:w.invite,welcomeMessage:w.welcomeMessage,ratchetTree:w.updatedGroupHandle.state.ratchetTree});return await o.emitter.emit("spaceMemberJoined",{spaceID:e,memberDID:u.did,role:"member",createdAt:new Date().toISOString()}),{invitePayload:b,spaceID:e,spaceName:_?.name??""}},spaceJoinSpace:async(e,t)=>{let i=await o.getDB(),c=o.identity,s=r(e),d=a(t),n={publicPackage:d.publicPackage,privatePackage:d.privatePackage,ownerDID:d.did};return await o.spaceManager.joinSpace({identity:c,spaceID:s.spaceID,invite:s.invite,keyPackageBundle:n,welcomeMessage:s.welcomeMessage,ratchetTree:s.ratchetTree},i),await l({db:i,adapter:o.adapter,hlc:o.hlc,emitter:o.emitter,identity:c,invite:s})},spaceLeaveSpace:async e=>{let t=await o.getDB(),a=await t.selectFrom("kubun_spaces").selectAll().where("id","=",e).executeTakeFirst(),r=o.identity;return await o.spaceManager.leaveSpace({spaceID:e,identity:r}),null!=a&&await o.emitter.emit("spaceLeft",{id:a.id,name:a.name,description:a.description,createdBy:a.created_by,createdAt:n(a.created_at),spaceID:e}),{spaceID:e}},spaceRemoveSpaceMember:async(e,a)=>{let r=await o.getDB(),i=o.identity,c=await r.selectFrom("kubun_space_mls_state").selectAll().where("space_id","=",e).where("device_id","=",i.id).executeTakeFirst();if(null==c)throw Error(`No MLS state for space ${e}`);let l=await t({mlsState:c.mls_state,credential:d(c.credential),epoch:c.epoch,rootCapability:c.root_capability});return await o.spaceManager.removeSpaceMember({spaceID:e,groupHandle:l,memberDID:a},r),await o.emitter.emit("spaceMemberLeft",{spaceID:e,memberDID:a,role:"",createdAt:new Date().toISOString()}),{spaceID:e}},spaceUpdateSpace:async e=>{await o.spaceManager.updateSpace({spaceID:e.spaceID,update:{name:e.name,description:e.description}});let t=await o.getDB(),a=await t.selectFrom("kubun_spaces").selectAll().where("id","=",e.spaceID).executeTakeFirst();if(null==a)throw Error(`Space ${e.spaceID} not found`);let r={id:a.id,name:a.name,description:a.description,createdBy:a.created_by,createdAt:n(a.created_at)};return await o.emitter.emit("spaceDataChanged",{...r,spaceID:e.spaceID}),r},spaceUpdateCircle:async e=>{await o.spaceManager.updateCircle({circleID:e.circleID,update:{name:e.name,description:e.description,catalogIDs:e.catalogIDs}});let t=await o.getDB(),a=await t.selectFrom("kubun_circles").selectAll().where("id","=",e.circleID).executeTakeFirst();if(null==a)throw Error(`Circle ${e.circleID} not found`);let r={id:a.id,spaceID:a.space_id,name:a.name,description:a.description,createdAt:n(a.created_at)};return null!=e.catalogIDs?await o.emitter.emit("circleCatalogsChanged",{...r,circleID:e.circleID}):await o.emitter.emit("circleDataChanged",{...r,circleID:e.circleID}),r},spaceUpdateCatalog:async t=>{let a=await o.getDB(),r={hlc:e.serialize(o.hlc.now())};null!=t.name&&(r.name=t.name),null!=t.filterCriteria&&(r.filter_criteria=o.adapter.encodeJSON("string"==typeof t.filterCriteria?JSON.parse(t.filterCriteria):t.filterCriteria)),r.updated_at=o.adapter.encodeTimestamp(new Date),await a.updateTable("kubun_catalogs").set(r).where("id","=",t.catalogID).execute();let i=await a.selectFrom("kubun_catalogs").selectAll().where("id","=",t.catalogID).executeTakeFirst();if(null==i)throw Error(`Catalog ${t.catalogID} not found`);return{id:i.id,ownerDID:i.owner_did,name:i.name,description:i.description,filterCriteria:"string"==typeof i.filter_criteria?i.filter_criteria:JSON.stringify(i.filter_criteria),createdAt:n(i.created_at)}},spaceDeleteCatalog:async e=>{let t=await o.getDB();return await t.deleteFrom("kubun_catalogs").where("id","=",e).execute(),{deletedID:e}},spaceDeleteCircle:async e=>{let t=await o.getDB(),a=await t.selectFrom("kubun_circles").selectAll().where("id","=",e).executeTakeFirst();return await o.spaceManager.deleteCircle({circleID:e}),null!=a&&await o.emitter.emit("circleDeleted",{id:a.id,spaceID:a.space_id,name:a.name,description:a.description,createdAt:n(a.created_at)}),{deletedID:e}},spaceRemoveCircleMember:async(e,t)=>(await o.spaceManager.removeCircleMember({circleID:e,memberDID:t}),await o.emitter.emit("circleMemberRemoved",{circleID:e,memberDID:t,role:"",createdAt:new Date().toISOString()}),{circleID:e,memberDID:t})}}
+import{HLC as e}from"@kubun/hlc";import{getGraphStore as a}from"@kubun/store-graph";import{getSpaceStore as t}from"@kubun/store-space";import{restoreGroupHandle as r}from"../spaces/group-handle.js";import{decodeFullJoinRequest as i,decodeInvitePayload as c,decodeJoinRequest as s,encodeInvitePayload as n}from"../spaces/invite-payload.js";import{createSpaceFromJoin as d}from"../spaces/join-utils.js";import{checkPeerAccess as l,normalizeCredential as o,toISO as p}from"./types.js";export function createSpaceContext(m,w){let D=null,g=null,u=()=>D??=t(w.stores),I=()=>g??=a(w.stores);return{spaceCreateSpace:async e=>{let a=await w.spaceManager.createSpace({stores:w.stores,identity:w.identity,name:e.name,description:e.description,createdBy:m.viewerDID}),t=await u(),r=await t.getSpace(a.spaceID);if(null==r)throw Error("Failed to create space");let i={id:r.id,name:r.name,description:r.description,createdBy:r.created_by,createdAt:p(r.created_at)};return await w.emitter.emit("spaceJoined",i),i},spaceGetSpaces:async()=>{let e=await u();return(await e.listSpaces()).map(e=>({id:e.id,name:e.name,description:e.description,createdBy:e.created_by,createdAt:p(e.created_at)}))},spaceGetSpace:async e=>{let a=await u(),t=await a.getSpace(e);return null==t?null:{id:t.id,name:t.name,description:t.description,createdBy:t.created_by,createdAt:p(t.created_at)}},spaceAddSpaceMember:async(e,a,t)=>{let r=await u();await r.addSpaceMember({space_id:e,member_did:a,role:t});let i=await r.getSpaceMember(e,a);if(null==i)throw Error("Failed to add space member");let c={spaceID:i.space_id,memberDID:i.member_did,role:i.role,createdAt:p(i.created_at)};return await w.emitter.emit("spaceMemberJoined",{...c,spaceID:c.spaceID}),c},spaceGetSpaceMembers:async e=>{let a=await u();return(await a.listSpaceMembers(e)).map(e=>({spaceID:e.space_id,memberDID:e.member_did,role:e.role,createdAt:p(e.created_at)}))},spaceCreateCircle:async e=>{let a=await w.spaceManager.createCircle({stores:w.stores,spaceID:e.spaceID,name:e.name,description:e.description}),t=await u(),r=await t.getCircle(a.circleID);if(null==r)throw Error("Failed to create circle");let i={id:r.id,spaceID:r.space_id,name:r.name,description:r.description,createdAt:p(r.created_at)};return await w.emitter.emit("circleCreated",{...i,spaceID:i.spaceID}),i},spaceGetCircles:async e=>{let a=await u();return(await a.listCirclesBySpace(e)).map(e=>({id:e.id,spaceID:e.space_id,name:e.name,description:e.description,createdAt:p(e.created_at)}))},spaceAddCircleMember:async(a,t,r)=>{let i=await u(),c=e.serialize(w.hlc.now());await i.addCircleMember({circle_id:a,member_did:t,role:r,hlc:c});let s=(await i.listCircleMembers(a)).find(e=>e.member_did===t);if(null==s)throw Error("Failed to add circle member");let n={circleID:s.circle_id,memberDID:s.member_did,role:s.role,createdAt:p(s.created_at)};return await w.emitter.emit("circleMemberAdded",{...n,circleID:n.circleID}),n},spaceCreateCatalog:async a=>{let t=await I(),r=w.runtime.getRandomID(),i=e.serialize(w.hlc.now());await t.createCatalog({id:r,owner_did:m.viewerDID,name:a.name,description:a.description??"",filter_criteria:JSON.parse(a.filterCriteria),hlc:i});let c=await t.getCatalog(r);if(null==c)throw Error("Failed to create catalog");return{id:c.id,ownerDID:c.owner_did,name:c.name,description:c.description,filterCriteria:JSON.stringify(c.filter_criteria),createdAt:p(c.created_at)}},spaceGetCatalogs:async e=>{let a=await I();if(null!=e)return(await a.listCatalogs(e)).map(e=>({id:e.id,ownerDID:e.owner_did,name:e.name,description:e.description,filterCriteria:JSON.stringify(e.filter_criteria),createdAt:p(e.created_at)}));let t=await u(),r=new Set((await t.listSpaces()).map(e=>e.created_by));return(await Promise.all(Array.from(r).map(e=>a.listCatalogs(e)))).flat().map(e=>({id:e.id,ownerDID:e.owner_did,name:e.name,description:e.description,filterCriteria:JSON.stringify(e.filter_criteria),createdAt:p(e.created_at)}))},spaceInviteToSpace:async(e,a)=>{l(m.viewerDID,w.identity.id,w.autoAcceptPeers);let t=await u(),i=w.identity,c=await t.getMLSState(e,i.id);if(null==c)throw Error(`No MLS state for space ${e}`);let d=await r({mlsState:c.mls_state,credential:o(c.credential),epoch:c.epoch,rootCapability:c.root_capability}),p=s(a),D=await w.spaceManager.inviteToSpace({stores:w.stores,spaceID:e,identity:i,groupHandle:d,recipientDID:p.did,recipientKeyPackage:p.publicPackage,permission:"member"}),g=await t.getSpace(e),I=n({spaceID:e,spaceName:g?.name??"",hubURLs:g?.hub_urls??[],invite:D.invite,welcomeMessage:D.welcomeMessage,ratchetTree:D.updatedGroupHandle.state.ratchetTree});return await w.emitter.emit("spaceMemberJoined",{spaceID:e,memberDID:p.did,role:"member",createdAt:new Date().toISOString()}),{invitePayload:I,spaceID:e,spaceName:g?.name??""}},spaceJoinSpace:async(e,a)=>{let t=w.identity,r=c(e),s=i(a),n={publicPackage:s.publicPackage,privatePackage:s.privatePackage,ownerDID:s.did};return await w.spaceManager.joinSpace({stores:w.stores,identity:t,spaceID:r.spaceID,invite:r.invite,keyPackageBundle:n,welcomeMessage:r.welcomeMessage,ratchetTree:r.ratchetTree}),await d({stores:w.stores,hlc:w.hlc,emitter:w.emitter,identity:t,invite:r})},spaceLeaveSpace:async e=>{let a=await u(),t=await a.getSpace(e),r=w.identity;return await w.spaceManager.leaveSpace({stores:w.stores,spaceID:e,identity:r}),null!=t&&await w.emitter.emit("spaceLeft",{id:t.id,name:t.name,description:t.description,createdBy:t.created_by,createdAt:p(t.created_at),spaceID:e}),{spaceID:e}},spaceRemoveSpaceMember:async(e,a)=>{let t=await u(),i=w.identity,c=await t.getMLSState(e,i.id);if(null==c)throw Error(`No MLS state for space ${e}`);let s=await r({mlsState:c.mls_state,credential:o(c.credential),epoch:c.epoch,rootCapability:c.root_capability});return await w.spaceManager.removeSpaceMember({stores:w.stores,spaceID:e,groupHandle:s,memberDID:a}),await w.emitter.emit("spaceMemberLeft",{spaceID:e,memberDID:a,role:"",createdAt:new Date().toISOString()}),{spaceID:e}},spaceUpdateSpace:async e=>{await w.spaceManager.updateSpace({stores:w.stores,spaceID:e.spaceID,update:{name:e.name,description:e.description}});let a=await u(),t=await a.getSpace(e.spaceID);if(null==t)throw Error(`Space ${e.spaceID} not found`);let r={id:t.id,name:t.name,description:t.description,createdBy:t.created_by,createdAt:p(t.created_at)};return await w.emitter.emit("spaceDataChanged",{...r,spaceID:e.spaceID}),r},spaceUpdateCircle:async e=>{await w.spaceManager.updateCircle({stores:w.stores,circleID:e.circleID,update:{name:e.name,description:e.description,catalogIDs:e.catalogIDs}});let a=await u(),t=await a.getCircle(e.circleID);if(null==t)throw Error(`Circle ${e.circleID} not found`);let r={id:t.id,spaceID:t.space_id,name:t.name,description:t.description,createdAt:p(t.created_at)};return null!=e.catalogIDs?await w.emitter.emit("circleCatalogsChanged",{...r,circleID:e.circleID}):await w.emitter.emit("circleDataChanged",{...r,circleID:e.circleID}),r},spaceUpdateCatalog:async a=>{let t=await I(),r={hlc:e.serialize(w.hlc.now())};null!=a.name&&(r.name=a.name),null!=a.filterCriteria&&(r.filter_criteria=JSON.parse(a.filterCriteria)),await t.updateCatalog(a.catalogID,r);let i=await t.getCatalog(a.catalogID);if(null==i)throw Error(`Catalog ${a.catalogID} not found`);return{id:i.id,ownerDID:i.owner_did,name:i.name,description:i.description,filterCriteria:JSON.stringify(i.filter_criteria),createdAt:p(i.created_at)}},spaceDeleteCatalog:async e=>{let a=await I();return await a.deleteCatalog(e),{deletedID:e}},spaceDeleteCircle:async e=>{let a=await u(),t=await a.getCircle(e);return await w.spaceManager.deleteCircle({stores:w.stores,circleID:e}),null!=t&&await w.emitter.emit("circleDeleted",{id:t.id,spaceID:t.space_id,name:t.name,description:t.description,createdAt:p(t.created_at)}),{deletedID:e}},spaceRemoveCircleMember:async(e,a)=>(await w.spaceManager.removeCircleMember({stores:w.stores,circleID:e,memberDID:a}),await w.emitter.emit("circleMemberRemoved",{circleID:e,memberDID:a,role:"",createdAt:new Date().toISOString()}),{circleID:e,memberDID:a})}}

package/lib/context/sync.js

@@ -1 +1 @@
-export function createSyncContext(e,n){return{syncAddPeer:e=>n.syncManager.addPeer(e),syncRemovePeer:e=>n.syncManager.removePeer(e),syncListPeers:()=>n.syncManager.listPeers(),syncGetStatus:e=>n.syncManager.getStatus(e)}}
+export function createSyncContext(e,s){return{syncAddPeer:e=>s.syncManager.addPeer({config:e,stores:s.stores}),syncRemovePeer:e=>s.syncManager.removePeer({peerDID:e,stores:s.stores}),syncListPeers:()=>s.syncManager.listPeers({stores:s.stores}),syncGetStatus:e=>s.syncManager.getStatus({peerDID:e,stores:s.stores})}}

package/lib/context/types.d.ts

@@ -1,10 +1,9 @@
 import type { KeyPackageBundle } from '@enkaku/group';
 import type { Runtime } from '@enkaku/runtime';
 import type { OwnIdentity } from '@enkaku/token';
-import type { Database } from '@kubun/db';
+import type { StoreProvider } from '@kubun/db';
 import type { Adapter } from '@kubun/db-adapter';
 import type { HLC } from '@kubun/hlc';
-import type { Kysely } from 'kysely';
 import type { SpaceEventEmitter } from '../spaces/events.js';
 import type { SpaceManager } from '../spaces/manager.js';
 import type { SyncManager } from '../sync/sync-manager.js';
@@ -17,11 +16,11 @@ export type ContextDeps = {
     identity: OwnIdentity;
     spaceManager: SpaceManager;
     syncManager: SyncManager;
+    stores: StoreProvider;
     adapter: Adapter;
     hlc: HLC;
     emitter: SpaceEventEmitter;
     pendingJoinRequests: Map<string, PendingJoinRequest>;
-    getDB: () => Promise<Kysely<Database>>;
     runtime: Runtime;
     autoAcceptPeers?: Array<string>;
 };

package/lib/index.d.ts

@@ -1,6 +1,5 @@
 import type { KubunPlugin, PluginFactoryParams } from '@kubun/engine';
 export type { ContextDeps, PendingJoinRequest } from './context/types.js';
-export { createP2PMigrations, type MigrationContext } from './migrations.js';
 export type { SyncClientMessage, SyncProtocol, SyncServerMessage } from './protocol.js';
 export { createP2PSchemaExtension } from './schema.js';
 export { type ProcessBroadcastParams, processBroadcast, type SpaceBroadcastMessage, } from './spaces/broadcast.js';
@@ -9,13 +8,13 @@ export { type BroadcastEvent, BroadcastService, type BroadcastServiceEvents, typ
 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 { 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 } 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 P2PPluginOptions = {

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 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()}}}}

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/spaces/broadcast-service.d.ts

@@ -1,7 +1,6 @@
 import { EventEmitter } from '@enkaku/event';
-import type { Database } from '@kubun/db';
-import type { AbstractAdapter, AdapterTypes } from '@kubun/db-adapter';
-import type { Kysely } from 'kysely';
+import type { GraphStoreAPI } from '@kubun/store-graph';
+import type { SpaceStoreAPI } from '@kubun/store-space';
 import { type SpaceBroadcastMessage } from './broadcast.js';
 import { type SerializedGroupState } from './mls-state.js';
 export type BroadcastEvent = {
@@ -39,9 +38,9 @@ export type ReceiveBroadcastResult = {
  * for sending encrypted bytes via hub and delivering received bytes
  * from hub. This keeps the service testable without hub infrastructure.
  */
-export type BroadcastServiceParams<T extends AdapterTypes = AdapterTypes> = {
-    kysely: Kysely<Database>;
-    adapter: AbstractAdapter<T>;
+export type BroadcastServiceParams = {
+    spaceStore: SpaceStoreAPI;
+    graphStore: GraphStoreAPI;
 };
 export declare class BroadcastService extends EventEmitter<BroadcastServiceEvents> {
     #private;

package/lib/spaces/broadcast-service.js

@@ -1 +1 @@
-import{EventEmitter as e}from"@enkaku/event";import{processBroadcast as a}from"./broadcast.js";import{deserializeBroadcast as r,serializeBroadcast as t}from"./broadcast-codec.js";import{restoreGroupHandle as s}from"./group-handle.js";import{replacer as o,reviver as c}from"./mls-json.js";import{serializeGroupState as d}from"./mls-state.js";export class BroadcastService extends e{#e;constructor(e){super(),this.#e={kysely:e.kysely,adapter:e.adapter}}async prepareSend(e){let{message:a,groupState:r}=e,c=t(a),i=await s(r),{message:m}=await i.encrypt(c),n=d(i);return{encrypted:new TextEncoder().encode(JSON.stringify(m,o)),updatedGroupState:n}}async processReceived(e){let{spaceID:t,encrypted:o,groupState:i}=e,m=await s(i),n=JSON.parse(new TextDecoder().decode(o),c),p=r(await m.decrypt(n)),y=await a(this.#e,p),l=d(m);return await this.emit("broadcast",{spaceID:t,message:p,applied:y}),{message:p,applied:y,updatedGroupState:l}}}
+import{EventEmitter as e}from"@enkaku/event";import{processBroadcast as r}from"./broadcast.js";import{deserializeBroadcast as a,serializeBroadcast as t}from"./broadcast-codec.js";import{restoreGroupHandle as s}from"./group-handle.js";import{replacer as o,reviver as c}from"./mls-json.js";import{serializeGroupState as i}from"./mls-state.js";export class BroadcastService extends e{#e;constructor(e){super(),this.#e={spaceStore:e.spaceStore,graphStore:e.graphStore}}async prepareSend(e){let{message:r,groupState:a}=e,c=t(r),p=await s(a),{message:d}=await p.encrypt(c),m=i(p);return{encrypted:new TextEncoder().encode(JSON.stringify(d,o)),updatedGroupState:m}}async processReceived(e){let{spaceID:t,encrypted:o,groupState:p}=e,d=await s(p),m=JSON.parse(new TextDecoder().decode(o),c),n=a(await d.decrypt(m)),w=await r(this.#e,n),S=i(d);return await this.emit("broadcast",{spaceID:t,message:n,applied:w}),{message:n,applied:w,updatedGroupState:S}}}

package/lib/spaces/broadcast.d.ts

@@ -1,7 +1,6 @@
-import type { Database } from '@kubun/db';
-import type { AbstractAdapter, AdapterTypes } from '@kubun/db-adapter';
 import type { CatalogRecord, CircleMemberRecord, CircleRecord } from '@kubun/protocol';
-import type { Kysely } from 'kysely';
+import type { GraphStoreAPI } from '@kubun/store-graph';
+import type { SpaceStoreAPI } from '@kubun/store-space';
 export type SpaceBroadcastMessage = {
     type: 'circle:create';
     circle: CircleRecord;
@@ -52,9 +51,9 @@ export type SpaceBroadcastMessage = {
         hlc: string;
     };
 };
-export type ProcessBroadcastParams<T extends AdapterTypes = AdapterTypes> = {
-    kysely: Kysely<Database>;
-    adapter: AbstractAdapter<T>;
+export type ProcessBroadcastParams = {
+    spaceStore: SpaceStoreAPI;
+    graphStore: GraphStoreAPI;
 };
 /**
  * Process a received broadcast message, applying it to the local database
@@ -62,4 +61,4 @@ export type ProcessBroadcastParams<T extends AdapterTypes = AdapterTypes> = {
  *
  * Returns true if the message was applied, false if it was skipped (stale HLC or missing target).
  */
-export declare function processBroadcast<T extends AdapterTypes = AdapterTypes>(params: ProcessBroadcastParams<T>, message: SpaceBroadcastMessage): Promise<boolean>;
+export declare function processBroadcast(params: ProcessBroadcastParams, message: SpaceBroadcastMessage): Promise<boolean>;

package/lib/spaces/broadcast.js

@@ -1 +1 @@
-import{HLC as e}from"@kubun/hlc";function t(t,c){return e.compare(e.parse(t),e.parse(c))>0}export async function processBroadcast(e,c){let{kysely:a,adapter:l}=e;switch(c.type){case"circle:create":{let e=await a.selectFrom("kubun_circles").selectAll().where("id","=",c.circle.id).executeTakeFirst();if(null!=e){if(!t(c.circle.hlc,e.hlc))return!1;let r={name:c.circle.name,description:c.circle.description,catalog_ids:l.encodeJSON(c.circle.catalogIDs),hlc:c.circle.hlc,updated_at:l.encodeTimestamp(new Date)};return await a.updateTable("kubun_circles").set(r).where("id","=",c.circle.id).execute(),!0}return await a.insertInto("kubun_circles").values({id:c.circle.id,space_id:c.circle.spaceID,name:c.circle.name,description:c.circle.description,catalog_ids:l.encodeJSON(c.circle.catalogIDs),hlc:c.circle.hlc}).execute(),!0}case"circle:update":{let e=await a.selectFrom("kubun_circles").selectAll().where("id","=",c.circleID).executeTakeFirst();if(null==e||!t(c.update.hlc,e.hlc))return!1;let r={};return null!=c.update.name&&(r.name=c.update.name),null!=c.update.description&&(r.description=c.update.description),null!=c.update.catalogIDs&&(r.catalog_ids=l.encodeJSON(c.update.catalogIDs)),r.hlc=c.update.hlc,r.updated_at=l.encodeTimestamp(new Date),await a.updateTable("kubun_circles").set(r).where("id","=",c.circleID).execute(),!0}case"circle:delete":{let e=await a.selectFrom("kubun_circles").selectAll().where("id","=",c.circleID).executeTakeFirst();if(null==e||!t(c.hlc,e.hlc))return!1;return await a.deleteFrom("kubun_circles").where("id","=",c.circleID).execute(),!0}case"member:add":return await a.insertInto("kubun_circle_members").values({circle_id:c.member.circleID,member_did:c.member.memberDID,role:c.member.role,hlc:c.member.hlc}).onConflict(e=>e.columns(["circle_id","member_did"]).doUpdateSet(e=>({role:e.ref("excluded.role"),hlc:e.ref("excluded.hlc")}))).execute(),!0;case"member:remove":return await a.deleteFrom("kubun_circle_members").where("circle_id","=",c.circleID).where("member_did","=",c.memberDID).execute(),!0;case"catalog:create":{let e=await a.selectFrom("kubun_catalogs").selectAll().where("id","=",c.catalog.id).executeTakeFirst();if(null!=e){if(!t(c.catalog.hlc,e.hlc))return!1;let r={name:c.catalog.name,description:c.catalog.description,filter_criteria:l.encodeJSON(c.catalog.filterCriteria),hlc:c.catalog.hlc,updated_at:l.encodeTimestamp(new Date)};return await a.updateTable("kubun_catalogs").set(r).where("id","=",c.catalog.id).execute(),!0}return await a.insertInto("kubun_catalogs").values({id:c.catalog.id,owner_did:c.catalog.ownerDID,name:c.catalog.name,description:c.catalog.description,filter_criteria:l.encodeJSON(c.catalog.filterCriteria),hlc:c.catalog.hlc}).execute(),!0}case"catalog:update":{let e=await a.selectFrom("kubun_catalogs").selectAll().where("id","=",c.catalogID).executeTakeFirst();if(null==e||!t(c.update.hlc,e.hlc))return!1;let r={};return null!=c.update.name&&(r.name=c.update.name),null!=c.update.description&&(r.description=c.update.description),null!=c.update.filterCriteria&&(r.filter_criteria=l.encodeJSON(c.update.filterCriteria)),r.hlc=c.update.hlc,r.updated_at=l.encodeTimestamp(new Date),await a.updateTable("kubun_catalogs").set(r).where("id","=",c.catalogID).execute(),!0}case"catalog:delete":{let e=await a.selectFrom("kubun_catalogs").selectAll().where("id","=",c.catalogID).executeTakeFirst();if(null==e||!t(c.hlc,e.hlc))return!1;return await a.deleteFrom("kubun_catalogs").where("id","=",c.catalogID).execute(),!0}case"space:update":{let e=await a.selectFrom("kubun_spaces").selectAll().where("id","=",c.spaceID).executeTakeFirst();if(null==e||!t(c.update.hlc,e.hlc))return!1;let r={};return null!=c.update.name&&(r.name=c.update.name),null!=c.update.description&&(r.description=c.update.description),null!=c.update.hubURLs&&(r.hub_urls=l.encodeJSON(c.update.hubURLs)),r.hlc=c.update.hlc,r.updated_at=l.encodeTimestamp(new Date),await a.updateTable("kubun_spaces").set(r).where("id","=",c.spaceID).execute(),!0}}}
+import{HLC as e}from"@kubun/hlc";function a(a,c){return e.compare(e.parse(a),e.parse(c))>0}export async function processBroadcast(e,c){let{spaceStore:t,graphStore:r}=e;switch(c.type){case"circle:create":{let e=await t.getCircle(c.circle.id);if(null!=e){if(!a(c.circle.hlc,e.hlc))return!1;return await t.updateCircle(c.circle.id,{name:c.circle.name,description:c.circle.description,catalog_ids:c.circle.catalogIDs,hlc:c.circle.hlc}),!0}return await t.createCircle({id:c.circle.id,space_id:c.circle.spaceID,name:c.circle.name,description:c.circle.description,catalog_ids:c.circle.catalogIDs,hlc:c.circle.hlc}),!0}case"circle:update":{let e=await t.getCircle(c.circleID);if(null==e||!a(c.update.hlc,e.hlc))return!1;return await t.updateCircle(c.circleID,{name:c.update.name,description:c.update.description,catalog_ids:c.update.catalogIDs,hlc:c.update.hlc}),!0}case"circle:delete":{let e=await t.getCircle(c.circleID);if(null==e||!a(c.hlc,e.hlc))return!1;return await t.deleteCircle(c.circleID),!0}case"member:add":return await t.addCircleMember({circle_id:c.member.circleID,member_did:c.member.memberDID,role:c.member.role,hlc:c.member.hlc}),!0;case"member:remove":return await t.removeCircleMember(c.circleID,c.memberDID),!0;case"catalog:create":{let e=await r.getCatalog(c.catalog.id);if(null!=e){if(!a(c.catalog.hlc,e.hlc))return!1;return await r.updateCatalog(c.catalog.id,{name:c.catalog.name,description:c.catalog.description,filter_criteria:c.catalog.filterCriteria,hlc:c.catalog.hlc}),!0}return await r.createCatalog({id:c.catalog.id,owner_did:c.catalog.ownerDID,name:c.catalog.name,description:c.catalog.description,filter_criteria:c.catalog.filterCriteria,hlc:c.catalog.hlc}),!0}case"catalog:update":{let e=await r.getCatalog(c.catalogID);if(null==e||!a(c.update.hlc,e.hlc))return!1;return await r.updateCatalog(c.catalogID,{name:c.update.name,description:c.update.description,filter_criteria:c.update.filterCriteria,hlc:c.update.hlc}),!0}case"catalog:delete":{let e=await r.getCatalog(c.catalogID);if(null==e||!a(c.hlc,e.hlc))return!1;return await r.deleteCatalog(c.catalogID),!0}case"space:update":{let e=await t.getSpace(c.spaceID);if(null==e||!a(c.update.hlc,e.hlc))return!1;return await t.updateSpace(c.spaceID,{name:c.update.name,description:c.update.description,hub_urls:c.update.hubURLs,hlc:c.update.hlc}),!0}}}

package/lib/spaces/join-utils.d.ts

@@ -1,13 +1,10 @@
 import type { OwnIdentity } from '@enkaku/token';
-import type { Database } from '@kubun/db';
-import type { Adapter } from '@kubun/db-adapter';
+import type { StoreProvider } from '@kubun/db';
 import { HLC } from '@kubun/hlc';
-import type { Kysely } from 'kysely';
 import type { SpaceData } from '../types.js';
 import type { SpaceEventEmitter } from './events.js';
 export type CreateSpaceFromJoinParams = {
-    db: Kysely<Database>;
-    adapter: Adapter;
+    stores: StoreProvider;
     hlc: HLC;
     emitter: SpaceEventEmitter;
     identity: OwnIdentity;

package/lib/spaces/join-utils.js

@@ -1 +1 @@
-import{HLC as e}from"@kubun/hlc";import{toISO as t}from"../context/types.js";export async function createSpaceFromJoin(a){let{db:c,adapter:s,hlc:i,emitter:r,identity:n,invite:l}=a;null==await c.selectFrom("kubun_spaces").selectAll().where("id","=",l.spaceID).executeTakeFirst()&&await c.insertInto("kubun_spaces").values({id:l.spaceID,name:l.spaceName,description:"",created_by:n.id,hub_urls:s.encodeJSON(l.hubURLs),hlc:e.serialize(i.now())}).execute();let u=await c.selectFrom("kubun_spaces").selectAll().where("id","=",l.spaceID).executeTakeFirst(),o=null!=u?{id:u.id,name:u.name,description:u.description,createdBy:u.created_by,createdAt:t(u.created_at)}:null;return null!=o&&await r.emit("spaceJoined",o),{space:o}}
+import{HLC as e}from"@kubun/hlc";import{getSpaceStore as a}from"@kubun/store-space";import{toISO as t}from"../context/types.js";export async function createSpaceFromJoin(c){let{stores:i,hlc:r,emitter:n,identity:p,invite:o}=c,s=await a(i);null==await s.getSpace(o.spaceID)&&await s.createSpace({id:o.spaceID,name:o.spaceName,description:"",created_by:p.id,hub_urls:o.hubURLs,hlc:e.serialize(r.now())});let l=await s.getSpace(o.spaceID),d=null!=l?{id:l.id,name:l.name,description:l.description,createdBy:l.created_by,createdAt:t(l.created_at)}:null;return null!=d&&await n.emit("spaceJoined",d),{space:d}}

package/lib/spaces/manager.d.ts

@@ -1,27 +1,25 @@
 import { type GroupHandle, type GroupPermission, type Invite, type KeyPackageBundle } from '@enkaku/group';
 import type { Identity, OwnIdentity } from '@enkaku/token';
-import type { Database } from '@kubun/db';
-import type { AbstractAdapter, AdapterTypes } from '@kubun/db-adapter';
-import type { Kysely, Transaction } from 'kysely';
+import type { StoreProvider } from '@kubun/db';
 import type { SpaceBroadcastMessage } from './broadcast.js';
-export type QueryRunner = Kysely<Database> | Transaction<Database>;
-export type SpaceManagerParams<T extends AdapterTypes = AdapterTypes> = {
-    kysely: Kysely<Database> | Promise<Kysely<Database>>;
-    adapter: AbstractAdapter<T>;
+export type SpaceManagerParams = {
     identity: Identity;
     getRandomID: () => string;
 };
 export type CreateSpaceParams = {
+    stores: StoreProvider;
     identity: OwnIdentity;
     name: string;
     description?: string;
     hubURLs?: Array<string>;
+    createdBy?: string;
 };
 export type CreateSpaceResult = {
     spaceID: string;
     groupHandle: GroupHandle;
 };
 export type UpdateSpaceParams = {
+    stores: StoreProvider;
     spaceID: string;
     update: {
         name?: string;
@@ -33,6 +31,7 @@ export type UpdateSpaceResult = {
     broadcast: SpaceBroadcastMessage;
 };
 export type InviteToSpaceParams = {
+    stores: StoreProvider;
     spaceID: string;
     identity: OwnIdentity;
     groupHandle: GroupHandle;
@@ -47,6 +46,7 @@ export type InviteToSpaceResult = {
     updatedGroupHandle: GroupHandle;
 };
 export type JoinSpaceParams = {
+    stores: StoreProvider;
     identity: OwnIdentity;
     spaceID: string;
     invite: Invite;
@@ -58,6 +58,7 @@ export type JoinSpaceResult = {
     groupHandle: GroupHandle;
 };
 export type RemoveMemberParams = {
+    stores: StoreProvider;
     spaceID: string;
     groupHandle: GroupHandle;
     leafIndex: number;
@@ -68,6 +69,7 @@ export type RemoveMemberResult = {
     updatedGroupHandle: GroupHandle;
 };
 export type RemoveSpaceMemberParams = {
+    stores: StoreProvider;
     spaceID: string;
     groupHandle: GroupHandle;
     memberDID: string;
@@ -77,11 +79,13 @@ export type RemoveSpaceMemberResult = {
     updatedGroupHandle: GroupHandle;
 };
 export type LeaveSpaceParams = {
+    stores: StoreProvider;
     spaceID: string;
     identity: OwnIdentity;
 };
 export type LeaveSpaceResult = undefined;
 export type CreateCircleParams = {
+    stores: StoreProvider;
     spaceID: string;
     name: string;
     description?: string;
@@ -92,6 +96,7 @@ export type CreateCircleResult = {
     broadcast: SpaceBroadcastMessage;
 };
 export type UpdateCircleParams = {
+    stores: StoreProvider;
     circleID: string;
     update: {
         name?: string;
@@ -104,12 +109,14 @@ export type UpdateCircleResult = {
     broadcasts: Array<SpaceBroadcastMessage>;
 };
 export type DeleteCircleParams = {
+    stores: StoreProvider;
     circleID: string;
 };
 export type DeleteCircleResult = {
     broadcast: SpaceBroadcastMessage;
 };
 export type AddCircleMemberParams = {
+    stores: StoreProvider;
     spaceID: string;
     circleID: string;
     memberDID: string;
@@ -119,6 +126,7 @@ export type AddCircleMemberResult = {
     broadcast: SpaceBroadcastMessage;
 };
 export type RemoveCircleMemberParams = {
+    stores: StoreProvider;
     circleID: string;
     memberDID: string;
 };
@@ -128,14 +136,14 @@ export type RemoveCircleMemberResult = {
 export declare class SpaceManager {
     #private;
     constructor(params: SpaceManagerParams);
-    createSpace(params: CreateSpaceParams, db?: QueryRunner): Promise<CreateSpaceResult>;
+    createSpace(params: CreateSpaceParams): Promise<CreateSpaceResult>;
     updateSpace(params: UpdateSpaceParams): Promise<UpdateSpaceResult>;
-    inviteToSpace(params: InviteToSpaceParams, db?: QueryRunner): Promise<InviteToSpaceResult>;
-    joinSpace(params: JoinSpaceParams, db?: QueryRunner): Promise<JoinSpaceResult>;
-    removeMember(params: RemoveMemberParams, db?: QueryRunner): Promise<RemoveMemberResult>;
-    removeSpaceMember(params: RemoveSpaceMemberParams, db?: QueryRunner): Promise<RemoveSpaceMemberResult>;
-    leaveSpace(params: LeaveSpaceParams, db?: QueryRunner): Promise<LeaveSpaceResult>;
-    loadSpace(spaceID: string): Promise<{
+    inviteToSpace(params: InviteToSpaceParams): Promise<InviteToSpaceResult>;
+    joinSpace(params: JoinSpaceParams): Promise<JoinSpaceResult>;
+    removeMember(params: RemoveMemberParams): Promise<RemoveMemberResult>;
+    removeSpaceMember(params: RemoveSpaceMemberParams): Promise<RemoveSpaceMemberResult>;
+    leaveSpace(params: LeaveSpaceParams): Promise<LeaveSpaceResult>;
+    loadSpace(stores: StoreProvider, spaceID: string): Promise<{
         epoch: number;
         credential: string;
     } | undefined>;

package/lib/spaces/manager.js

@@ -1 +1 @@
-import{commitInvite as e,createGroup as t,createInvite as a,processWelcome as i,removeMember as r}from"@enkaku/group";import{HLC as c}from"@kubun/hlc";import{serializeGroupState as d}from"./mls-state.js";export class SpaceManager{#e;#t;#a;#i;#r;constructor(e){this.#e=e.kysely,this.#t=e.adapter,this.#a=e.identity.id,this.#i=e.getRandomID,this.#r=new c({nodeID:e.identity.id})}async #c(){return await this.#e}async #d(e,t,a){let i=d(t),r=a??await this.#c();await r.insertInto("kubun_space_mls_state").values({space_id:e,device_id:this.#a,mls_state:this.#t.encodeBinary(i.mlsState),credential:i.credential,epoch:i.epoch,root_capability:i.rootCapability}).onConflict(e=>e.columns(["space_id","device_id"]).doUpdateSet(e=>({mls_state:e.ref("excluded.mls_state"),credential:e.ref("excluded.credential"),epoch:e.ref("excluded.epoch"),root_capability:e.ref("excluded.root_capability"),updated_at:this.#t.encodeTimestamp(new Date)}))).execute()}async createSpace(e,a){let i=this.#i(),{group:r}=await t(e.identity,i),d=a??await this.#c();return await d.insertInto("kubun_spaces").values({id:i,name:e.name,description:e.description??"",created_by:e.identity.id,hub_urls:this.#t.encodeJSON(e.hubURLs??[]),hlc:c.serialize(this.#r.now())}).execute(),await this.#d(i,r,d),await d.insertInto("kubun_space_members").values({space_id:i,member_did:e.identity.id,role:"admin"}).onConflict(e=>e.columns(["space_id","member_did"]).doUpdateSet(e=>({role:e.ref("excluded.role"),updated_at:this.#t.encodeTimestamp(new Date)}))).execute(),{spaceID:i,groupHandle:r}}async updateSpace(e){let t=c.serialize(this.#r.now()),a={};null!=e.update.name&&(a.name=e.update.name),null!=e.update.description&&(a.description=e.update.description),null!=e.update.hubURLs&&(a.hub_urls=this.#t.encodeJSON(e.update.hubURLs)),a.hlc=t,a.updated_at=this.#t.encodeTimestamp(new Date);let i=await this.#c();return await i.updateTable("kubun_spaces").set(a).where("id","=",e.spaceID).execute(),{broadcast:{type:"space:update",spaceID:e.spaceID,update:{...e.update,hlc:t}}}}async inviteToSpace(t,i){let{invite:r}=await a({group:t.groupHandle,identity:t.identity,recipientDID:t.recipientDID,permission:t.permission}),{commitMessage:c,welcomeMessage:d,newGroup:s}=await e(t.groupHandle,t.recipientKeyPackage),l=i??await this.#c();return await this.#d(t.spaceID,s,l),await l.insertInto("kubun_space_members").values({space_id:t.spaceID,member_did:t.recipientDID,role:"admin"===t.permission?"admin":"member"}).onConflict(e=>e.columns(["space_id","member_did"]).doUpdateSet(e=>({role:e.ref("excluded.role"),updated_at:this.#t.encodeTimestamp(new Date)}))).execute(),{invite:r,welcomeMessage:d,commitMessage:c,updatedGroupHandle:s}}async joinSpace(e,t){let{group:a}=await i({identity:e.identity,invite:e.invite,welcome:e.welcomeMessage,keyPackageBundle:e.keyPackageBundle,ratchetTree:e.ratchetTree}),r=t??await this.#c();return await this.#d(e.spaceID,a,r),await r.insertInto("kubun_space_members").values({space_id:e.spaceID,member_did:e.identity.id,role:"member"}).onConflict(e=>e.columns(["space_id","member_did"]).doUpdateSet(e=>({role:e.ref("excluded.role"),updated_at:this.#t.encodeTimestamp(new Date)}))).execute(),{groupHandle:a}}async removeMember(e,t){let{commitMessage:a,newGroup:i}=await r(e.groupHandle,e.leafIndex),c=t??await this.#c();return await this.#d(e.spaceID,i,c),await c.deleteFrom("kubun_space_members").where("space_id","=",e.spaceID).where("member_did","=",e.memberDID).execute(),{commitMessage:a,updatedGroupHandle:i}}async removeSpaceMember(e,t){let a=e.groupHandle.findMemberLeafIndex(e.memberDID);if(null==a)throw Error(`Member ${e.memberDID} not found in MLS group`);let{commitMessage:i,newGroup:c}=await r(e.groupHandle,a),d=t??await this.#c();return await this.#d(e.spaceID,c,d),await d.deleteFrom("kubun_space_members").where("space_id","=",e.spaceID).where("member_did","=",e.memberDID).execute(),{commitMessage:i,updatedGroupHandle:c}}async leaveSpace(e,t){let a=async t=>{await t.deleteFrom("kubun_space_mls_state").where("space_id","=",e.spaceID).where("device_id","=",this.#a).execute(),await t.deleteFrom("kubun_space_members").where("space_id","=",e.spaceID).where("member_did","=",e.identity.id).execute()};if(null!=t)await a(t);else{let e=await this.#c();await e.transaction().execute(a)}}async loadSpace(e){let t=await this.#c(),a=await t.selectFrom("kubun_space_mls_state").selectAll().where("space_id","=",e).where("device_id","=",this.#a).executeTakeFirst();if(null!=a)return{epoch:a.epoch,credential:a.credential}}async createCircle(e){let t=this.#i(),a=c.serialize(this.#r.now()),i=e.catalogIDs??[],r=await this.#c();return await r.insertInto("kubun_circles").values({id:t,space_id:e.spaceID,name:e.name,description:e.description??"",catalog_ids:this.#t.encodeJSON(i),hlc:a}).execute(),{circleID:t,broadcast:{type:"circle:create",circle:{id:t,spaceID:e.spaceID,name:e.name,description:e.description??"",catalogIDs:i,hlc:a}}}}async updateCircle(e){let t=c.serialize(this.#r.now()),a=[],i=await this.#c();if(null!=e.update.catalogIDs){let t=await i.selectFrom("kubun_circles").selectAll().where("id","=",e.circleID).executeTakeFirst(),r=new Set(null!=t?t.catalog_ids:[]),c=e.update.catalogIDs.filter(e=>!r.has(e));for(let e of(await Promise.all(c.map(e=>i.selectFrom("kubun_catalogs").selectAll().where("id","=",e).executeTakeFirst()))))null!=e&&a.push({type:"catalog:create",catalog:{id:e.id,ownerDID:e.owner_did,name:e.name,description:e.description,filterCriteria:e.filter_criteria,hlc:e.hlc}})}let r={};null!=e.update.name&&(r.name=e.update.name),null!=e.update.description&&(r.description=e.update.description),null!=e.update.catalogIDs&&(r.catalog_ids=this.#t.encodeJSON(e.update.catalogIDs)),r.hlc=t,r.updated_at=this.#t.encodeTimestamp(new Date),await i.updateTable("kubun_circles").set(r).where("id","=",e.circleID).execute();let d={type:"circle:update",circleID:e.circleID,update:{...e.update,hlc:t}};return{broadcast:d,broadcasts:[d,...a]}}async deleteCircle(e){let t=c.serialize(this.#r.now()),a=await this.#c();return await a.deleteFrom("kubun_circles").where("id","=",e.circleID).execute(),{broadcast:{type:"circle:delete",circleID:e.circleID,hlc:t}}}async addCircleMember(e){let t=await this.#c();if(null==await t.selectFrom("kubun_space_members").select("member_did").where("space_id","=",e.spaceID).where("member_did","=",e.memberDID).executeTakeFirst())throw Error(`${e.memberDID} is not a member of space ${e.spaceID}`);let a=c.serialize(this.#r.now());return await t.insertInto("kubun_circle_members").values({circle_id:e.circleID,member_did:e.memberDID,role:e.role,hlc:a}).onConflict(e=>e.columns(["circle_id","member_did"]).doUpdateSet(e=>({role:e.ref("excluded.role"),hlc:e.ref("excluded.hlc")}))).execute(),{broadcast:{type:"member:add",member:{circleID:e.circleID,memberDID:e.memberDID,role:e.role,hlc:a}}}}async removeCircleMember(e){let t=c.serialize(this.#r.now()),a=await this.#c();return await a.deleteFrom("kubun_circle_members").where("circle_id","=",e.circleID).where("member_did","=",e.memberDID).execute(),{broadcast:{type:"member:remove",circleID:e.circleID,memberDID:e.memberDID,hlc:t}}}}
+import{commitInvite as e,createGroup as a,createInvite as t,processWelcome as i,removeMember as r}from"@enkaku/group";import{HLC as c}from"@kubun/hlc";import{getGraphStore as s}from"@kubun/store-graph";import{getSpaceStore as d}from"@kubun/store-space";import{serializeGroupState as l}from"./mls-state.js";export class SpaceManager{#e;#a;#t;constructor(e){this.#e=e.identity.id,this.#a=e.getRandomID,this.#t=new c({nodeID:e.identity.id})}async #i(e,a,t){let i=l(t),r=await d(e);await r.saveMLSState({space_id:a,device_id:this.#e,mls_state:i.mlsState,credential:i.credential,epoch:i.epoch,root_capability:i.rootCapability})}async createSpace(e){let t=this.#a(),{group:i}=await a(e.identity,t),r=await d(e.stores);return await r.createSpace({id:t,name:e.name,description:e.description??"",created_by:e.createdBy??e.identity.id,hub_urls:e.hubURLs??[],hlc:c.serialize(this.#t.now())}),await this.#i(e.stores,t,i),await r.addSpaceMember({space_id:t,member_did:e.identity.id,role:"admin"}),{spaceID:t,groupHandle:i}}async updateSpace(e){let a=c.serialize(this.#t.now()),t=await d(e.stores);return await t.updateSpace(e.spaceID,{name:e.update.name,description:e.update.description,hub_urls:e.update.hubURLs,hlc:a}),{broadcast:{type:"space:update",spaceID:e.spaceID,update:{...e.update,hlc:a}}}}async inviteToSpace(a){let{invite:i}=await t({group:a.groupHandle,identity:a.identity,recipientDID:a.recipientDID,permission:a.permission}),{commitMessage:r,welcomeMessage:c,newGroup:s}=await e(a.groupHandle,a.recipientKeyPackage);await this.#i(a.stores,a.spaceID,s);let l=await d(a.stores);return await l.addSpaceMember({space_id:a.spaceID,member_did:a.recipientDID,role:"admin"===a.permission?"admin":"member"}),{invite:i,welcomeMessage:c,commitMessage:r,updatedGroupHandle:s}}async joinSpace(e){let{group:a}=await i({identity:e.identity,invite:e.invite,welcome:e.welcomeMessage,keyPackageBundle:e.keyPackageBundle,ratchetTree:e.ratchetTree});await this.#i(e.stores,e.spaceID,a);let t=await d(e.stores);return await t.addSpaceMember({space_id:e.spaceID,member_did:e.identity.id,role:"member"}),{groupHandle:a}}async removeMember(e){let{commitMessage:a,newGroup:t}=await r(e.groupHandle,e.leafIndex);await this.#i(e.stores,e.spaceID,t);let i=await d(e.stores);return await i.removeSpaceMember(e.spaceID,e.memberDID),{commitMessage:a,updatedGroupHandle:t}}async removeSpaceMember(e){let a=e.groupHandle.findMemberLeafIndex(e.memberDID);if(null==a)throw Error(`Member ${e.memberDID} not found in MLS group`);let{commitMessage:t,newGroup:i}=await r(e.groupHandle,a);await this.#i(e.stores,e.spaceID,i);let c=await d(e.stores);return await c.removeSpaceMember(e.spaceID,e.memberDID),{commitMessage:t,updatedGroupHandle:i}}async leaveSpace(e){let a=await d(e.stores);await a.deleteMLSState(e.spaceID,this.#e),await a.removeSpaceMember(e.spaceID,e.identity.id)}async loadSpace(e,a){let t=await d(e),i=await t.getMLSState(a,this.#e);if(null!=i)return{epoch:i.epoch,credential:i.credential}}async createCircle(e){let a=this.#a(),t=c.serialize(this.#t.now()),i=e.catalogIDs??[],r=await d(e.stores);return await r.createCircle({id:a,space_id:e.spaceID,name:e.name,description:e.description??"",catalog_ids:i,hlc:t}),{circleID:a,broadcast:{type:"circle:create",circle:{id:a,spaceID:e.spaceID,name:e.name,description:e.description??"",catalogIDs:i,hlc:t}}}}async updateCircle(e){let a=c.serialize(this.#t.now()),t=[],i=await d(e.stores);if(null!=e.update.catalogIDs){let a=await i.getCircle(e.circleID),r=new Set(null!=a?a.catalog_ids:[]),c=e.update.catalogIDs.filter(e=>!r.has(e)),d=await s(e.stores);for(let e of(await Promise.all(c.map(e=>d.getCatalog(e)))))null!=e&&t.push({type:"catalog:create",catalog:{id:e.id,ownerDID:e.owner_did,name:e.name,description:e.description,filterCriteria:e.filter_criteria,hlc:e.hlc}})}await i.updateCircle(e.circleID,{name:e.update.name,description:e.update.description,catalog_ids:e.update.catalogIDs,hlc:a});let r={type:"circle:update",circleID:e.circleID,update:{...e.update,hlc:a}};return{broadcast:r,broadcasts:[r,...t]}}async deleteCircle(e){let a=c.serialize(this.#t.now()),t=await d(e.stores);return await t.deleteCircle(e.circleID),{broadcast:{type:"circle:delete",circleID:e.circleID,hlc:a}}}async addCircleMember(e){let a=await d(e.stores);if(!await a.isSpaceMember(e.spaceID,e.memberDID))throw Error(`${e.memberDID} is not a member of space ${e.spaceID}`);let t=c.serialize(this.#t.now());return await a.addCircleMember({circle_id:e.circleID,member_did:e.memberDID,role:e.role,hlc:t}),{broadcast:{type:"member:add",member:{circleID:e.circleID,memberDID:e.memberDID,role:e.role,hlc:t}}}}async removeCircleMember(e){let a=c.serialize(this.#t.now()),t=await d(e.stores);return await t.removeCircleMember(e.circleID,e.memberDID),{broadcast:{type:"member:remove",circleID:e.circleID,memberDID:e.memberDID,hlc:a}}}}

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{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)}}

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}}}

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

@@ -1,8 +1,10 @@
-import type { MutationLogEntry } from '@kubun/db';
+import type { MutationLogEntry } from '@kubun/store-graph';
 export type MerkleTree = {
     root: string;
     buckets: Record<string, string>;
 };
+/** Maximum number of mutation JWTs to send in a single channel message. */
+export declare const SYNC_BATCH_SIZE = 1000;
 export declare function getTimeBuckets(hlc: string): {
     year: string;
     month: string;

package/lib/sync/merkle-tree.js

@@ -1 +1 @@
-import{blake3 as t}from"@noble/hashes/blake3.js";let e=[4,7,10,16],o=new TextEncoder;export function getTimeBuckets(t){return{year:t.slice(0,4),month:t.slice(0,7),day:t.slice(0,10),minute:t.slice(0,16)}}function r(e){return Array.from(t(o.encode(e))).map(t=>t.toString(16).padStart(2,"0")).join("")}export function buildMerkleTree(t){if(0===t.length)return{root:"",buckets:{}};let e=new Map;for(let o of t){let{minute:t}=getTimeBuckets(o.hlc),r=e.get(t);null==r&&(r=[],e.set(t,r)),r.push(o)}let o={};for(let[t,n]of e){let e=[...n].sort((t,e)=>t.mutation_hash<e.mutation_hash?-1:+(t.mutation_hash>e.mutation_hash)).map(t=>t.mutation_hash).join("\n");o[t]=r(e)}for(let t of[10,7,4]){let e=10===t?16:7===t?10:7,n=new Map;for(let r of Object.keys(o)){if(r.length!==e)continue;let o=r.slice(0,t),s=n.get(o);null==s&&(s=[],n.set(o,s)),s.push(r)}for(let[t,e]of n){let n=e.sort().map(t=>`${t}\0${o[t]}`).join("\n");o[t]=r(n)}}let n=r(Object.keys(o).filter(t=>4===t.length).sort().map(t=>`${t}\0${o[t]}`).join("\n"));return o.root=n,{root:n,buckets:o}}export function findDivergentBuckets(t,o){if(t.root===o.root)return[];if(""===t.root)return Object.keys(o.buckets).filter(t=>16===t.length).sort();if(""===o.root)return Object.keys(t.buckets).filter(t=>16===t.length).sort();let r=[],n=new Set([...Object.keys(t.buckets),...Object.keys(o.buckets)]);return!function s(l,i){let u=e[i];for(let c of[...n].filter(t=>t.length===u&&(""===l||t.startsWith(l))).sort())t.buckets[c]!==o.buckets[c]&&(i===e.length-1?r.push(c):s(c,i+1))}("",0),r.sort()}
+import{blake3 as t}from"@noble/hashes/blake3.js";export const SYNC_BATCH_SIZE=1e3;let e=[4,7,10,16],o=new TextEncoder;export function getTimeBuckets(t){return{year:t.slice(0,4),month:t.slice(0,7),day:t.slice(0,10),minute:t.slice(0,16)}}function r(e){return Array.from(t(o.encode(e))).map(t=>t.toString(16).padStart(2,"0")).join("")}export function buildMerkleTree(t){if(0===t.length)return{root:"",buckets:{}};let e=new Map;for(let o of t){let{minute:t}=getTimeBuckets(o.hlc),r=e.get(t);null==r&&(r=[],e.set(t,r)),r.push(o)}let o={};for(let[t,n]of e){let e=[...n].sort((t,e)=>t.mutation_hash<e.mutation_hash?-1:+(t.mutation_hash>e.mutation_hash)).map(t=>t.mutation_hash).join("\n");o[t]=r(e)}for(let t of[10,7,4]){let e=10===t?16:7===t?10:7,n=new Map;for(let r of Object.keys(o)){if(r.length!==e)continue;let o=r.slice(0,t),s=n.get(o);null==s&&(s=[],n.set(o,s)),s.push(r)}for(let[t,e]of n){let n=e.sort().map(t=>`${t}\0${o[t]}`).join("\n");o[t]=r(n)}}let n=r(Object.keys(o).filter(t=>4===t.length).sort().map(t=>`${t}\0${o[t]}`).join("\n"));return o.root=n,{root:n,buckets:o}}export function findDivergentBuckets(t,o){if(t.root===o.root)return[];if(""===t.root)return Object.keys(o.buckets).filter(t=>16===t.length).sort();if(""===o.root)return Object.keys(t.buckets).filter(t=>16===t.length).sort();let r=[],n=new Set([...Object.keys(t.buckets),...Object.keys(o.buckets)]);return!function s(l,i){let u=e[i];for(let c of[...n].filter(t=>t.length===u&&(""===l||t.startsWith(l))).sort())t.buckets[c]!==o.buckets[c]&&(i===e.length-1?r.push(c):s(c,i+1))}("",0),r.sort()}

package/lib/sync/peer-registry.d.ts

@@ -1,5 +1,6 @@
 import type { Runtime } from '@enkaku/runtime';
-import type { KubunDB } from '@kubun/db';
+import type { StoreProvider } from '@kubun/db';
+import type { SyncDirection } from '../protocol.js';
 export type PeerConfig = {
     peerDID: string;
     endpoint: string;
@@ -9,6 +10,7 @@ export type PeerConfig = {
     };
     priority: string;
     trustLevel: 'trusted' | 'restricted';
+    allowedDirection?: SyncDirection;
 };
 export type PeerConfigWithID = PeerConfig & {
     id: string;
@@ -16,16 +18,33 @@ export type PeerConfigWithID = PeerConfig & {
     updatedAt: number;
 };
 export type PeerRegistryParams = {
-    db: KubunDB;
     runtime: Runtime;
 };
 export declare class PeerRegistry {
     #private;
     constructor(params: PeerRegistryParams);
-    addPeer(config: PeerConfig): Promise<void>;
-    getPeer(peerDID: string): Promise<PeerConfigWithID | undefined>;
-    listPeers(): Promise<Array<PeerConfigWithID>>;
-    updatePeer(peerDID: string, updates: Partial<PeerConfig>): Promise<void>;
-    removePeer(peerDID: string): Promise<void>;
-    isPeerAllowed(peerDID: string): Promise<boolean>;
+    addPeer(params: {
+        config: PeerConfig;
+        stores: StoreProvider;
+    }): Promise<void>;
+    getPeer(params: {
+        peerDID: string;
+        stores: StoreProvider;
+    }): Promise<PeerConfigWithID | undefined>;
+    listPeers(params: {
+        stores: StoreProvider;
+    }): Promise<Array<PeerConfigWithID>>;
+    updatePeer(params: {
+        peerDID: string;
+        updates: Partial<PeerConfig>;
+        stores: StoreProvider;
+    }): Promise<void>;
+    removePeer(params: {
+        peerDID: string;
+        stores: StoreProvider;
+    }): Promise<void>;
+    isPeerAllowed(params: {
+        peerDID: string;
+        stores: StoreProvider;
+    }): Promise<boolean>;
 }

package/lib/sync/peer-registry.js

@@ -1 +1 @@
-function e(e){var t;return{id:e.id,peerDID:e.peer_did,endpoint:e.endpoint,mode:e.mode,allowedUsers:"string"==typeof(t=e.allowed_users)?JSON.parse(t):t,priority:e.priority,trustLevel:e.trust_level,createdAt:e.created_at,updatedAt:e.updated_at}}export class PeerRegistry{#e;#t;constructor(e){this.#e=e.db,this.#t=e.runtime}async addPeer(e){let t=await this.#e.getDB();await t.insertInto("kubun_sync_peers").values({id:this.#t.getRandomID(),peer_did:e.peerDID,endpoint:e.endpoint,mode:e.mode,allowed_users:JSON.stringify(e.allowedUsers),priority:e.priority,trust_level:e.trustLevel,config:JSON.stringify({}),created_at:Date.now(),updated_at:Date.now()}).onConflict(t=>t.column("peer_did").doUpdateSet({endpoint:e.endpoint,mode:e.mode,allowed_users:JSON.stringify(e.allowedUsers),priority:e.priority,trust_level:e.trustLevel,updated_at:Date.now()})).execute()}async getPeer(t){let r=await this.#e.getDB(),i=await r.selectFrom("kubun_sync_peers").selectAll().where("peer_did","=",t).executeTakeFirst();if(i)return e(i)}async listPeers(){let t=await this.#e.getDB();return(await t.selectFrom("kubun_sync_peers").selectAll().execute()).map(t=>e(t))}async updatePeer(e,t){let r=await this.getPeer(e);if(!r)throw Error(`Peer ${e} not found`);let i={...r,...t},s=await this.#e.getDB();await s.updateTable("kubun_sync_peers").set({endpoint:i.endpoint,mode:i.mode,allowed_users:JSON.stringify(i.allowedUsers),priority:i.priority,trust_level:i.trustLevel,config:JSON.stringify({}),updated_at:Date.now()}).where("peer_did","=",e).execute()}async removePeer(e){let t=await this.#e.getDB();await t.deleteFrom("kubun_sync_peers").where("peer_did","=",e).execute()}async isPeerAllowed(e){return void 0!==await this.getPeer(e)}}
+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})}}

package/lib/sync/sync-client.d.ts

@@ -3,7 +3,7 @@ import type { ClientTransportOf } from '@enkaku/protocol';
 import type { Runtime } from '@enkaku/runtime';
 import type { SigningIdentity } from '@enkaku/token';
 import type { Logger } from '@kubun/logger';
-import type { SyncProtocol } from '../protocol.js';
+import type { SyncDirection, SyncProtocol } from '../protocol.js';
 /**
  * Provider for sync-specific transport to a peer's sync server.
  * The p2p plugin exposes this via `createSyncTransport()`.
@@ -21,14 +21,6 @@ export type SyncScope = {
     modelID: string;
     ownerDID: string;
 };
-export type MerkleSyncMessage = {
-    type: 'mutations';
-    mutationJWTs: Array<string>;
-} | {
-    type: 'complete';
-    divergentBuckets?: number;
-    totalMutations?: number;
-};
 /**
  * Client for connecting to peer servers for sync operations.
  * Supports both direct (in-process) and HTTP transports.
@@ -48,21 +40,31 @@ export declare class SyncClient {
     /**
      * Negotiate sync scopes with peer.
      */
-    negotiate(client: Client<SyncProtocol>, scopes: Array<SyncScope>, delegationTokens?: Array<string>, knownModelIDs?: Array<string>): Promise<{
+    negotiate(client: Client<SyncProtocol>, scopes: Array<SyncScope>, delegationTokens?: Array<string>, knownModelIDs?: Array<string>, direction?: SyncDirection): Promise<{
         acceptedScopes: Array<SyncScope>;
         excludedDocumentIDs: Array<string>;
         missingClusters?: Record<string, unknown>;
+        direction?: SyncDirection;
     }>;
     /**
-     * Perform Merkle tree-based sync with peer.
-     * Sends local tree, receives divergent mutation JWTs.
+     * Perform Merkle tree-based sync with peer using bidirectional channel.
+     * Sends local tree and divergent mutations, receives remote mutations.
      */
     merkleSync(client: Client<SyncProtocol>, params: {
         scopes: Array<SyncScope>;
         excludedDocumentIDs: Array<string>;
-        tree: Record<string, string>;
+        localTree: {
+            root: string;
+            buckets: Record<string, string>;
+        };
+        direction: SyncDirection;
+        localEntries: Array<{
+            hlc: string;
+            mutation_jwt: string;
+        }>;
     }): Promise<{
         mutationJWTs: Array<string>;
         divergentBuckets: number;
+        mutationsSent: number;
     }>;
 }

package/lib/sync/sync-client.js

@@ -1 +1 @@
-import{Client as e}from"@enkaku/client";import{ClientTransport as t}from"@enkaku/http-client-transport";import{createArraySink as r}from"@enkaku/stream";export class SyncClient{#e;#t;#r;#n;constructor(e){this.#e=e.runtime,this.#t=e.identity,this.#r=e.logger,this.#n=e.serverResolver}async connect(e,t){if(e.startsWith("direct://"))return this.#s(e);if(e.startsWith("http://")||e.startsWith("https://"))return this.#i(e,t);throw Error(`Unsupported endpoint scheme: ${e}`)}#i(r,n){let s=new t({url:r,fetch:this.#e.fetch});return new e({runtime:this.#e,identity:this.#t,logger:this.#r.getChild("sync-client"),serverID:n,transport:s})}#s(t){let r=t.replace("direct://","");if(!this.#n)throw Error("Server resolver not configured for direct transport");let n=this.#n(r);if(!n)throw Error(`Server not found: ${r}`);let s=n.createSyncTransport();return new e({runtime:this.#e,identity:this.#t,logger:this.#r.getChild("sync-client"),serverID:r,transport:s})}async negotiate(e,t,r=[],n){this.#r.debug("Negotiate: sending {scopeCount} scopes",{scopeCount:t.length});let s=await e.request("sync/negotiate",{param:{scopes:t,delegationTokens:r,knownModelIDs:n}});return this.#r.debug("Negotiate: accepted {acceptedCount} scopes, excluded {excludedCount} docs",{acceptedCount:s.acceptedScopes.length,excludedCount:s.excludedDocumentIDs.length}),s}async merkleSync(e,t){this.#r.debug("MerkleSync: creating stream with {buckets} local buckets",{buckets:Object.keys(t.tree).length});let[n,s]=r(),i=e.createStream("sync/merkle-sync",{param:{scopes:t.scopes,excludedDocumentIDs:t.excludedDocumentIDs,tree:t.tree}}),o=i.readable.pipeTo(n);this.#r.debug("MerkleSync: awaiting stream completion"),await Promise.all([i,o]),this.#r.debug("MerkleSync: stream completed, collecting messages");let c=await s,l=[],a=0;for(let e of c)"mutations"===e.type?l.push(...e.mutationJWTs):"complete"===e.type&&(a=e.divergentBuckets??0);return{mutationJWTs:l,divergentBuckets:a}}}
+import{Client as e}from"@enkaku/client";import{ClientTransport as t}from"@enkaku/http-client-transport";import{findDivergentBuckets as r,getTimeBuckets as n,SYNC_BATCH_SIZE as i}from"./merkle-tree.js";export class SyncClient{#e;#t;#r;#n;constructor(e){this.#e=e.runtime,this.#t=e.identity,this.#r=e.logger,this.#n=e.serverResolver}async connect(e,t){if(e.startsWith("direct://"))return this.#i(e);if(e.startsWith("http://")||e.startsWith("https://"))return this.#s(e,t);throw Error(`Unsupported endpoint scheme: ${e}`)}#s(r,n){let i=new t({url:r,fetch:this.#e.fetch});return new e({runtime:this.#e,identity:this.#t,logger:this.#r.getChild("sync-client"),serverID:n,transport:i})}#i(t){let r=t.replace("direct://","");if(!this.#n)throw Error("Server resolver not configured for direct transport");let n=this.#n(r);if(!n)throw Error(`Server not found: ${r}`);let i=n.createSyncTransport();return new e({runtime:this.#e,identity:this.#t,logger:this.#r.getChild("sync-client"),serverID:r,transport:i})}async negotiate(e,t,r=[],n,i){this.#r.debug("Negotiate: sending {scopeCount} scopes",{scopeCount:t.length});let s=await e.request("sync/negotiate",{param:{scopes:t,delegationTokens:r,knownModelIDs:n,direction:i}});return this.#r.debug("Negotiate: accepted {acceptedCount} scopes, excluded {excludedCount} docs",{acceptedCount:s.acceptedScopes.length,excludedCount:s.excludedDocumentIDs.length}),s}async merkleSync(e,t){let{scopes:s,excludedDocumentIDs:o,localTree:c,direction:l,localEntries:a}=t;this.#r.debug("MerkleSync: creating channel with {buckets} local buckets",{buckets:Object.keys(c.buckets).length});let u=e.createChannel("sync/merkle-sync",{param:{scopes:s,excludedDocumentIDs:o,tree:c.buckets,direction:l}}),h=u.readable.getReader(),d=await h.read();if(d.done)throw Error("MerkleSync: channel closed before receiving remote tree");let g=d.value;if("tree"!==g.type)throw Error(`MerkleSync: expected 'tree' message, got '${g.type}'`);let p=r(c,{root:g.tree?.root??"",buckets:g.tree??{}}),m=p.length;this.#r.debug("MerkleSync: found {count} divergent buckets",{count:m});let y=0,f=async()=>{if("push"===l||"both"===l){let e=new Set(p),t=a.filter(t=>{let{minute:r}=n(t.hlc);return e.has(r)});for(let e=0;e<t.length;e+=i){let r=t.slice(e,e+i);await u.send({type:"mutations",mutationJWTs:r.map(e=>e.mutation_jwt)}),y+=r.length}}await u.send({type:"complete"})},k=async()=>{let e=[];for(;;){let{done:t,value:r}=await h.read();if(t)break;if("mutations"===r.type&&null!=r.mutationJWTs)e.push(...r.mutationJWTs);else if("complete"===r.type)break}return h.releaseLock(),e},[,v]=await Promise.all([f(),k()]),w=await u;if(null!=w&&!w.success)throw Error("MerkleSync: responder reported failure");return this.#r.debug("MerkleSync: completed with {received} received, {sent} sent",{received:v.length,sent:y}),{mutationJWTs:v,divergentBuckets:m,mutationsSent:y}}}

package/lib/sync/sync-manager.d.ts

@@ -1,8 +1,9 @@
 import type { Runtime } from '@enkaku/runtime';
 import { type Identity, type SigningIdentity } from '@enkaku/token';
-import type { KubunDB } from '@kubun/db';
+import type { StoreProvider } from '@kubun/db';
 import type { Logger } from '@kubun/logger';
-import { type PeerConfig, type PeerConfigWithID } from './peer-registry.js';
+import type { SyncDirection } from '../protocol.js';
+import { type PeerConfig, type PeerConfigWithID, PeerRegistry } from './peer-registry.js';
 import { type SyncScope, type SyncTransportProvider } from './sync-client.js';
 export type SyncSessionInfo = {
     peerID: string;
@@ -23,19 +24,24 @@ export type SyncEvent = {
     reason?: string;
 };
 export type SyncManagerParams = {
-    db: KubunDB;
     deployClusters?: (clusters: Record<string, unknown>) => Promise<void>;
     runtime: Runtime;
     identity: Identity;
     logger: Logger;
     serverResolver?: (serverID: string) => SyncTransportProvider | undefined;
 };
-export type MerkleSyncOptions = {
+export type MerkleSyncParams = {
+    peerDID: string;
+    scopes: Array<SyncScope>;
+    stores: StoreProvider;
+    delegationTokens?: Array<string>;
     knownModelIDs?: Array<string>;
+    direction?: SyncDirection;
 };
 export declare class SyncManager {
     #private;
     constructor(params: SyncManagerParams);
+    get peerRegistry(): PeerRegistry;
     /**
      * Configure the signing identity used for sync operations.
      */
@@ -44,18 +50,37 @@ export declare class SyncManager {
      * Configure the server resolver for direct transport connections.
      */
     setServerResolver(resolver: (serverID: string) => SyncTransportProvider | undefined): void;
-    addPeer(config: PeerConfig): Promise<void>;
-    removePeer(peerDID: string): Promise<void>;
-    updatePeerConfig(peerDID: string, updates: Partial<PeerConfig>): Promise<void>;
-    listPeers(): Promise<Array<PeerConfigWithID>>;
-    getPeer(peerDID: string): Promise<PeerConfigWithID | undefined>;
-    merkleSyncWithPeer(peerDID: string, scopes: Array<SyncScope>, delegationTokens?: Array<string>, options?: MerkleSyncOptions): Promise<{
+    addPeer(params: {
+        config: PeerConfig;
+        stores: StoreProvider;
+    }): Promise<void>;
+    removePeer(params: {
+        peerDID: string;
+        stores: StoreProvider;
+    }): Promise<void>;
+    updatePeerConfig(params: {
+        peerDID: string;
+        updates: Partial<PeerConfig>;
+        stores: StoreProvider;
+    }): Promise<void>;
+    listPeers(params: {
+        stores: StoreProvider;
+    }): Promise<Array<PeerConfigWithID>>;
+    getPeer(params: {
+        peerDID: string;
+        stores: StoreProvider;
+    }): Promise<PeerConfigWithID | undefined>;
+    merkleSyncWithPeer(params: MerkleSyncParams): Promise<{
         sessionID: string;
         divergentBuckets: number;
         messagesReceived: number;
+        messagesSent: number;
         missingClusters?: Record<string, unknown>;
     }>;
-    getStatus(peerDID?: string): SyncStatus;
+    getStatus(params: {
+        peerDID?: string;
+        stores: StoreProvider;
+    }): SyncStatus;
     onSyncEvent(callback: (event: SyncEvent) => void): () => void;
     dispose(): Promise<void>;
 }

package/lib/sync/sync-manager.js

@@ -1 +1 @@
-import{EventEmitter as e}from"@enkaku/event";import{isSigningIdentity as t}from"@enkaku/token";import{applySyncMutations as s}from"./merkle-apply.js";import{buildMerkleTree as r}from"./merkle-tree.js";import{PeerRegistry as i}from"./peer-registry.js";import{SyncClient as n}from"./sync-client.js";export class SyncManager{#e;#t;#s;#r;#i;#n=new e;#o=new Map;#l=new Map;#a;#c;constructor(e){this.#e=e.db,this.#t=e.deployClusters,this.#s=e.runtime,this.#a=e.identity,this.#r=e.logger,this.#i=new i({db:e.db,runtime:e.runtime}),this.#c=e.serverResolver}setIdentity(e){this.#a=e}setServerResolver(e){this.#c=e}async addPeer(e){await this.#i.addPeer(e),this.#r.info("Peer added",{peerDID:e.peerDID})}async removePeer(e){await this.#i.removePeer(e),this.#r.info("Peer removed",{peerDID:e})}async updatePeerConfig(e,t){await this.#i.updatePeer(e,t),this.#r.info("Peer updated",{peerDID:e})}async listPeers(){return this.#i.listPeers()}async getPeer(e){return this.#i.getPeer(e)}async merkleSyncWithPeer(e,i,o=[],l){let a;this.#r.info("Starting Merkle sync with peer",{peerDID:e,scopes:i});let c=await this.#i.getPeer(e);if(!c)throw Error(`Peer ${e} not found`);let g=`merkle-sync-${e}-${Date.now()}`,m={peerID:e,startTime:Date.now(),documentsAttempted:0,documentsCompleted:0};this.#o.set(g,m),this.#g({type:"started",peerID:e,timestamp:Date.now()});try{let p=this.#a;if(!t(p))throw Error("Signing identity required for Merkle sync");let d=new n({runtime:this.#s,identity:p,logger:this.#r,serverResolver:this.#c});a=await d.connect(c.endpoint,e),this.#r.info("Negotiating sync scopes",{scopes:i});let{acceptedScopes:y,excludedDocumentIDs:h,missingClusters:u}=await d.negotiate(a,i,o,l?.knownModelIDs);if(0===y.length)return this.#r.info("No scopes accepted by peer"),this.#l.set(e,Date.now()),this.#g({type:"completed",peerID:e,timestamp:Date.now()}),this.#o.delete(g),{sessionID:g,divergentBuckets:0,messagesReceived:0,missingClusters:u};null!=u&&Object.keys(u).length>0&&(null!=this.#t?(this.#r.info("Deploying missing clusters from peer",{clusterCount:Object.keys(u).length}),await this.#t(u)):this.#r.warn("Missing clusters received but no deployClusters callback configured",{clusterCount:Object.keys(u).length})),this.#r.info("Building local Merkle tree",{acceptedScopes:y});let v=await this.#e.getDocumentIDsForScope(y,h),f=await this.#e.getMutationLogForDocuments(v),w=r(f);this.#r.info("Requesting Merkle sync from peer",{localTreeBuckets:Object.keys(w.buckets).length});let k=await d.merkleSync(a,{scopes:y,excludedDocumentIDs:h,tree:w.buckets});return k.mutationJWTs.length>0&&(this.#r.info("Applying sync mutations",{mutations:k.mutationJWTs.length}),m.documentsCompleted=(await s({db:this.#e,mutationJWTs:k.mutationJWTs})).applied),this.#l.set(e,Date.now()),this.#g({type:"completed",peerID:e,timestamp:Date.now()}),this.#r.info("Merkle sync completed",{divergentBuckets:k.divergentBuckets,mutationsReceived:k.mutationJWTs.length}),{sessionID:g,divergentBuckets:k.divergentBuckets,messagesReceived:k.mutationJWTs.length,missingClusters:u}}catch(t){throw this.#r.error("Merkle sync failed",{peerDID:e,error:t}),this.#g({type:"error",peerID:e,timestamp:Date.now(),error:t instanceof Error?t.message:String(t)}),t}finally{if(null!=a)try{a.abort("SyncComplete"),await a.dispose()}catch{}this.#o.delete(g)}}getStatus(e){let t=Array.from(this.#o.values()).filter(t=>!e||t.peerID===e).map(e=>({peerID:e.peerID,startTime:e.startTime,documentsAttempted:e.documentsAttempted,documentsCompleted:e.documentsCompleted})),s={};for(let[t,r]of this.#l.entries())e&&t!==e||(s[t]=r);return{activeSessions:t,lastSyncByPeer:s}}onSyncEvent(e){return this.#n.on("sync",e)}#g(e){this.#n.emit("sync",e).catch(e=>{this.#r.error("Error in sync event listener",{error:e})})}async dispose(){this.#o.clear(),this.#l.clear()}}
+import{EventEmitter as e}from"@enkaku/event";import{isSigningIdentity as t}from"@enkaku/token";import{getGraphStore as r}from"@kubun/store-graph";import{applySyncMutations as s}from"./merkle-apply.js";import{buildMerkleTree as i}from"./merkle-tree.js";import{PeerRegistry as n}from"./peer-registry.js";import{SyncClient as o}from"./sync-client.js";export class SyncManager{#e;#t;#r;#s;#i=new e;#n=new Map;#o=new Map;#l;#a;constructor(e){this.#e=e.deployClusters,this.#t=e.runtime,this.#l=e.identity,this.#r=e.logger,this.#s=new n({runtime:e.runtime}),this.#a=e.serverResolver}get peerRegistry(){return this.#s}setIdentity(e){this.#l=e}setServerResolver(e){this.#a=e}async addPeer(e){await this.#s.addPeer(e),this.#r.info("Peer added",{peerDID:e.config.peerDID})}async removePeer(e){await this.#s.removePeer(e),this.#r.info("Peer removed",{peerDID:e.peerDID})}async updatePeerConfig(e){await this.#s.updatePeer(e),this.#r.info("Peer updated",{peerDID:e.peerDID})}async listPeers(e){return this.#s.listPeers(e)}async getPeer(e){return this.#s.getPeer(e)}async merkleSyncWithPeer(e){let n,{peerDID:l,scopes:a,delegationTokens:c=[],knownModelIDs:g,direction:m}=e;this.#r.info("Starting Merkle sync with peer",{peerDID:l,scopes:a});let p=await this.#s.getPeer({peerDID:l,stores:e.stores});if(!p)throw Error(`Peer ${l} not found`);let y=`merkle-sync-${l}-${Date.now()}`,u={peerID:l,startTime:Date.now(),documentsAttempted:0,documentsCompleted:0};this.#n.set(y,u),this.#c({type:"started",peerID:l,timestamp:Date.now()});try{let d=this.#l;if(!t(d))throw Error("Signing identity required for Merkle sync");let h=new o({runtime:this.#t,identity:d,logger:this.#r,serverResolver:this.#a});n=await h.connect(p.endpoint,l);let v=m??"pull";this.#r.info("Negotiating sync scopes",{scopes:a,direction:v});let{acceptedScopes:f,excludedDocumentIDs:D,missingClusters:w,direction:k}=await h.negotiate(n,a,c,g,v);if(0===f.length)return this.#r.info("No scopes accepted by peer"),this.#o.set(l,Date.now()),this.#c({type:"completed",peerID:l,timestamp:Date.now()}),this.#n.delete(y),{sessionID:y,divergentBuckets:0,messagesReceived:0,messagesSent:0,missingClusters:w};null!=w&&Object.keys(w).length>0&&(null!=this.#e?(this.#r.info("Deploying missing clusters from peer",{clusterCount:Object.keys(w).length}),await this.#e(w)):this.#r.warn("Missing clusters received but no deployClusters callback configured",{clusterCount:Object.keys(w).length})),this.#r.info("Building local Merkle tree",{acceptedScopes:f});let S=await r(e.stores),P=await S.getDocumentIDsForScope(f,D),R=await S.getMutationLogForDocuments(P),I=i(R),C=k??v;this.#r.info("Requesting Merkle sync from peer",{localTreeBuckets:Object.keys(I.buckets).length,direction:C});let B=await h.merkleSync(n,{scopes:f,excludedDocumentIDs:D,localTree:I,direction:C,localEntries:R});return B.mutationJWTs.length>0&&(this.#r.info("Applying sync mutations",{mutations:B.mutationJWTs.length}),u.documentsCompleted=(await s({db:e.stores,mutationJWTs:B.mutationJWTs})).applied),this.#o.set(l,Date.now()),this.#c({type:"completed",peerID:l,timestamp:Date.now()}),this.#r.info("Merkle sync completed",{divergentBuckets:B.divergentBuckets,mutationsReceived:B.mutationJWTs.length}),{sessionID:y,divergentBuckets:B.divergentBuckets,messagesReceived:B.mutationJWTs.length,messagesSent:B.mutationsSent,missingClusters:w}}catch(e){throw this.#r.error("Merkle sync failed",{peerDID:l,error:e}),this.#c({type:"error",peerID:l,timestamp:Date.now(),error:e instanceof Error?e.message:String(e)}),e}finally{if(null!=n)try{n.abort("SyncComplete"),await n.dispose()}catch{}this.#n.delete(y)}}getStatus(e){let{peerDID:t}=e,r=Array.from(this.#n.values()).filter(e=>!t||e.peerID===t).map(e=>({peerID:e.peerID,startTime:e.startTime,documentsAttempted:e.documentsAttempted,documentsCompleted:e.documentsCompleted})),s={};for(let[e,r]of this.#o.entries())t&&e!==t||(s[e]=r);return{activeSessions:r,lastSyncByPeer:s}}onSyncEvent(e){return this.#i.on("sync",e)}#c(e){this.#i.emit("sync",e).catch(e=>{this.#r.error("Error in sync event listener",{error:e})})}async dispose(){this.#n.clear(),this.#o.clear()}}

package/lib/types.d.ts

@@ -1,5 +1,5 @@
 import type { ClientTransportOf } from '@enkaku/protocol';
-import type { SyncProtocol } from './protocol.js';
+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';
@@ -127,6 +127,7 @@ export type SyncSessionResult = {
     sessionID: string;
     divergentBuckets: number;
     messagesReceived: number;
+    messagesSent: number;
     missingClusters?: Record<string, unknown>;
 };
 export type SyncPluginAPI = {
@@ -140,6 +141,7 @@ export type SyncPluginAPI = {
         scopes: Array<SyncScope>;
         delegationTokens?: Array<string>;
         knownModelIDs?: Array<string>;
+        direction?: SyncDirection;
     }): Promise<SyncSessionResult>;
     getStatus(peerDID?: string): SyncStatus;
     onSyncEvent(callback: (event: SyncEvent) => void): () => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/plugin-p2p",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "license": "see LICENSE.md",
   "type": "module",
   "main": "lib/index.js",
@@ -34,23 +34,25 @@
     "graphql": "^16.13.2",
     "kysely": "^0.28.16",
     "@kubun/client": "^0.8.0",
-    "@kubun/graphql": "^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/graphql": "^0.8.1",
     "@kubun/hlc": "^0.8.0",
-    "@kubun/db-adapter": "^0.8.0",
-    "@kubun/db": "^0.8.0",
-    "@kubun/engine": "^0.8.0",
-    "@kubun/logger": "^0.8.0",
     "@kubun/id": "^0.8.0",
-    "@kubun/mutation": "^0.8.0",
+    "@kubun/logger": "^0.8.0",
+    "@kubun/mutation": "^0.8.1",
     "@kubun/protocol": "^0.8.0"
   },
   "devDependencies": {
     "get-port": "^7.2.0",
-    "@kubun/db-better-sqlite": "^0.8.0",
-    "@kubun/plugin-connector": "^0.8.0",
-    "@kubun/plugin-http": "^0.8.0",
-    "@kubun/plugin-rpc": "^0.8.0",
-    "@kubun/test-utils": "^0.8.0"
+    "@kubun/db-better-sqlite": "^0.8.1",
+    "@kubun/plugin-connector": "^0.8.1",
+    "@kubun/plugin-http": "^0.8.1",
+    "@kubun/test-utils": "^0.8.0",
+    "@kubun/plugin-rpc": "^0.8.1"
   },
   "scripts": {
     "build:clean": "del lib",

package/lib/migrations.d.ts

@@ -1,8 +0,0 @@
-import type { Adapter } from '@kubun/db-adapter';
-import type { PluginMigrationContext } from '@kubun/engine';
-import type { Migration } from 'kysely';
-export type MigrationContext = {
-    types: Adapter['types'];
-    functions: Adapter['functions'];
-};
-export declare function createP2PMigrations(ctx: MigrationContext | PluginMigrationContext): Record<string, Migration>;

package/lib/migrations.js

@@ -1 +0,0 @@
-export function createP2PMigrations(e){let t=e.types,a=e.functions;return{"001_create_p2p_tables":{async up(e){await e.schema.createTable("kubun_spaces").ifNotExists().addColumn("id",t.text,e=>e.notNull().primaryKey()).addColumn("name",t.text,e=>e.notNull()).addColumn("description",t.text,e=>e.notNull().defaultTo("")).addColumn("created_by",t.text,e=>e.notNull()).addColumn("hub_urls",t.json,e=>e.defaultTo("[]").notNull()).addColumn("hlc",t.text,e=>e.notNull()).addColumn("created_at",t.timestamp,e=>e.defaultTo(a.now).notNull()).addColumn("updated_at",t.timestamp).execute(),await e.schema.createTable("kubun_space_members").ifNotExists().addColumn("space_id",t.text,e=>e.notNull()).addColumn("member_did",t.text,e=>e.notNull()).addColumn("role",t.text,e=>e.notNull().defaultTo("member")).addColumn("created_at",t.timestamp,e=>e.defaultTo(a.now).notNull()).addColumn("updated_at",t.timestamp).addPrimaryKeyConstraint("pk_space_members",["space_id","member_did"]).execute(),await e.schema.createIndex("idx_space_members_did").ifNotExists().on("kubun_space_members").column("member_did").execute(),await e.schema.createTable("kubun_circles").ifNotExists().addColumn("id",t.text,e=>e.notNull().primaryKey()).addColumn("space_id",t.text,e=>e.notNull()).addColumn("name",t.text,e=>e.notNull()).addColumn("description",t.text,e=>e.notNull().defaultTo("")).addColumn("catalog_ids",t.json,e=>e.notNull().defaultTo("[]")).addColumn("hlc",t.text,e=>e.notNull()).addColumn("created_at",t.timestamp,e=>e.defaultTo(a.now).notNull()).addColumn("updated_at",t.timestamp).execute(),await e.schema.createIndex("idx_circles_space").ifNotExists().on("kubun_circles").column("space_id").execute(),await e.schema.createTable("kubun_circle_members").ifNotExists().addColumn("circle_id",t.text,e=>e.notNull()).addColumn("member_did",t.text,e=>e.notNull()).addColumn("role",t.text,e=>e.notNull().defaultTo("member")).addColumn("hlc",t.text,e=>e.notNull()).addColumn("created_at",t.timestamp,e=>e.defaultTo(a.now).notNull()).addColumn("updated_at",t.timestamp).addPrimaryKeyConstraint("pk_circle_members",["circle_id","member_did"]).execute(),await e.schema.createIndex("idx_circle_members_did").ifNotExists().on("kubun_circle_members").column("member_did").execute(),await e.schema.createTable("kubun_catalogs").ifNotExists().addColumn("id",t.text,e=>e.notNull().primaryKey()).addColumn("owner_did",t.text,e=>e.notNull()).addColumn("name",t.text,e=>e.notNull()).addColumn("description",t.text,e=>e.notNull().defaultTo("")).addColumn("filter_criteria",t.json,e=>e.notNull()).addColumn("hlc",t.text,e=>e.notNull()).addColumn("created_at",t.timestamp,e=>e.defaultTo(a.now).notNull()).addColumn("updated_at",t.timestamp).execute(),await e.schema.createIndex("idx_catalogs_owner").ifNotExists().on("kubun_catalogs").column("owner_did").execute(),await e.schema.createTable("kubun_space_mls_state").ifNotExists().addColumn("space_id",t.text,e=>e.notNull()).addColumn("device_id",t.text,e=>e.notNull()).addColumn("mls_state",t.binary,e=>e.notNull()).addColumn("credential",t.text,e=>e.notNull()).addColumn("epoch","integer",e=>e.notNull()).addColumn("root_capability",t.text,e=>e.notNull().defaultTo("")).addColumn("updated_at",t.timestamp,e=>e.defaultTo(a.now).notNull()).addPrimaryKeyConstraint("pk_space_mls_state",["space_id","device_id"]).execute(),await e.schema.createTable("kubun_sync_peers").ifNotExists().addColumn("id",t.text,e=>e.notNull().primaryKey()).addColumn("peer_did",t.text,e=>e.notNull().unique()).addColumn("endpoint",t.text,e=>e.notNull()).addColumn("mode",t.text,e=>e.notNull()).addColumn("allowed_users",t.json,e=>e.notNull()).addColumn("priority",t.text,e=>e.notNull().defaultTo("0")).addColumn("trust_level",t.text,e=>e.notNull()).addColumn("config",t.json,e=>e.notNull()).addColumn("created_at",t.timestamp,e=>e.defaultTo(a.now).notNull()).addColumn("updated_at",t.timestamp,e=>e.defaultTo(a.now).notNull()).execute(),await e.schema.createTable("kubun_sync_checkpoints").ifNotExists().addColumn("id",t.text,e=>e.notNull().primaryKey()).addColumn("peer_did",t.text,e=>e.notNull()).addColumn("scope",t.text,e=>e.notNull()).addColumn("checkpoint_hlc",t.text,e=>e.notNull()).addColumn("updated_at",t.timestamp,e=>e.defaultTo(a.now).notNull()).execute()},async down(e){await e.schema.dropTable("kubun_sync_checkpoints").ifExists().execute(),await e.schema.dropTable("kubun_sync_peers").ifExists().execute(),await e.schema.dropTable("kubun_space_mls_state").ifExists().execute(),await e.schema.dropTable("kubun_catalogs").ifExists().execute(),await e.schema.dropTable("kubun_circle_members").ifExists().execute(),await e.schema.dropTable("kubun_circles").ifExists().execute(),await e.schema.dropTable("kubun_space_members").ifExists().execute(),await e.schema.dropTable("kubun_spaces").ifExists().execute()}}}}