@kubun/plugin-p2p 0.12.1 → 0.13.1

package/lib/protocol.d.ts

@@ -203,6 +203,170 @@ export declare const syncProtocol: {
             readonly additionalProperties: false;
         };
     };
+    readonly 'sync/reconcile-credentials': {
+        readonly type: "request";
+        readonly param: {
+            readonly type: "object";
+            readonly properties: {
+                readonly held: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly subjectKind: {
+                                readonly type: "string";
+                                readonly enum: readonly ["key", "wrapping", "entry"];
+                            };
+                            readonly subjectID: {
+                                readonly type: "string";
+                            };
+                            readonly opHash: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly required: readonly ["subjectKind", "subjectID", "opHash"];
+                        readonly additionalProperties: false;
+                    };
+                    readonly description: "Signed subject states the caller holds, for updates and revocation GC";
+                };
+            };
+            readonly required: readonly ["held"];
+            readonly additionalProperties: false;
+        };
+        readonly result: {
+            readonly type: "object";
+            readonly properties: {
+                readonly bundles: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly keyID: {
+                                readonly type: "string";
+                            };
+                            readonly keyVersion: {
+                                readonly type: "number";
+                            };
+                            readonly suite: {
+                                readonly type: "number";
+                            };
+                            readonly ownerDID: {
+                                readonly type: "string";
+                            };
+                            readonly keyOp: {
+                                readonly type: "string";
+                            };
+                            readonly keyBranches: {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly type: "string";
+                                };
+                                readonly description: "The proven key-op JWTs that introduced this key version's branches.";
+                            };
+                            readonly wrapping: {
+                                readonly type: "object";
+                                readonly properties: {
+                                    readonly wrappingID: {
+                                        readonly type: "string";
+                                    };
+                                    readonly factors: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "object";
+                                            readonly properties: {
+                                                readonly kind: {
+                                                    readonly type: "string";
+                                                };
+                                                readonly params: {
+                                                    readonly type: "object";
+                                                    readonly additionalProperties: true;
+                                                };
+                                            };
+                                            readonly required: readonly ["kind", "params"];
+                                            readonly additionalProperties: false;
+                                        };
+                                    };
+                                    readonly iv: {
+                                        readonly type: "string";
+                                    };
+                                    readonly wrappedKey: {
+                                        readonly type: "string";
+                                    };
+                                    readonly recipientDID: {
+                                        readonly type: "string";
+                                    };
+                                    readonly op: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly required: readonly ["wrappingID", "factors", "iv", "wrappedKey", "recipientDID", "op"];
+                                readonly additionalProperties: false;
+                            };
+                            readonly entries: {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly type: "object";
+                                    readonly properties: {
+                                        readonly entryID: {
+                                            readonly type: "string";
+                                        };
+                                        readonly iv: {
+                                            readonly type: "string";
+                                        };
+                                        readonly ciphertext: {
+                                            readonly type: "string";
+                                        };
+                                        readonly hlc: {
+                                            readonly type: "string";
+                                        };
+                                        readonly op: {
+                                            readonly type: "string";
+                                        };
+                                    };
+                                    readonly required: readonly ["entryID", "iv", "ciphertext", "hlc", "op"];
+                                    readonly additionalProperties: false;
+                                };
+                            };
+                        };
+                        readonly required: readonly ["keyID", "keyVersion", "suite", "ownerDID", "keyOp", "keyBranches", "wrapping", "entries"];
+                        readonly additionalProperties: false;
+                    };
+                    readonly description: "The caller's recipient-scoped catch-up bundles (missed grants and entry top-ups)";
+                };
+                readonly tombstones: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly keyID: {
+                                readonly type: "string";
+                            };
+                            readonly authorDID: {
+                                readonly type: "string";
+                            };
+                            readonly hlc: {
+                                readonly type: "string";
+                            };
+                            readonly opJWT: {
+                                readonly type: "string";
+                            };
+                            readonly opHash: {
+                                readonly type: "string";
+                            };
+                            readonly subjectID: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly required: readonly ["keyID", "authorDID", "hlc", "opJWT", "opHash", "subjectID"];
+                        readonly additionalProperties: false;
+                    };
+                    readonly description: "Tombstones for advertised held IDs that are now revoked (GC)";
+                };
+            };
+            readonly required: readonly ["bundles", "tombstones"];
+            readonly additionalProperties: false;
+        };
+    };
 };
 export type SyncProtocol = typeof syncProtocol;
 /**
@@ -406,6 +570,113 @@ export declare const peerProtocol: {
             readonly additionalProperties: false;
         };
     };
+    readonly 'blob/query-haves': {
+        readonly type: "request";
+        readonly param: {
+            readonly type: "object";
+            readonly properties: {
+                readonly attachmentIDs: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "Candidate AttachmentIDs the caller wants to locate";
+                };
+            };
+            readonly required: readonly ["attachmentIDs"];
+            readonly additionalProperties: false;
+        };
+        readonly result: {
+            readonly type: "object";
+            readonly properties: {
+                readonly have: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "The subset this node holds with all bytes local";
+                };
+            };
+            readonly required: readonly ["have"];
+            readonly additionalProperties: false;
+        };
+    };
+    readonly 'blob/manifest': {
+        readonly type: "request";
+        readonly param: {
+            readonly type: "object";
+            readonly properties: {
+                readonly attachmentID: {
+                    readonly type: "string";
+                };
+                readonly delegationTokens: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "The caller's read-delegation tokens, for scope authorization";
+                };
+            };
+            readonly required: readonly ["attachmentID", "delegationTokens"];
+            readonly additionalProperties: false;
+        };
+        readonly result: {
+            readonly type: "object";
+            readonly properties: {
+                readonly chunkSize: {
+                    readonly type: "number";
+                };
+                readonly chunkCount: {
+                    readonly type: "number";
+                };
+                readonly contentLength: {
+                    readonly type: "number";
+                };
+                readonly chunkDigests: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "Per-chunk blake3 digests, base64, ordered by index";
+                };
+                readonly capability: {
+                    readonly type: "string";
+                    readonly description: "Short-TTL signed fetch capability for the data-plane GET";
+                };
+            };
+            readonly required: readonly ["chunkSize", "chunkCount", "contentLength", "chunkDigests", "capability"];
+            readonly additionalProperties: false;
+        };
+    };
+    readonly 'controller/get-log': {
+        readonly type: "request";
+        readonly param: {
+            readonly type: "object";
+            readonly properties: {
+                readonly did: {
+                    readonly type: "string";
+                    readonly description: "The did:kokuin: controller whose log is requested";
+                };
+            };
+            readonly required: readonly ["did"];
+            readonly additionalProperties: false;
+        };
+        readonly result: {
+            readonly type: "object";
+            readonly properties: {
+                readonly events: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "object";
+                        readonly additionalProperties: true;
+                    };
+                    readonly description: "The controller's signed key-event log";
+                };
+            };
+            readonly required: readonly ["events"];
+            readonly additionalProperties: false;
+        };
+    };
 };
 export type PeerProtocol = typeof peerProtocol;
 export type PeerGroupsResult = FromSchema<PeerProtocol['peer/groups']['result']>;
@@ -416,12 +687,20 @@ export type GroupInviteParam = FromSchema<PeerProtocol['group/invite']['param']>
 export type GroupInviteResult = FromSchema<PeerProtocol['group/invite']['result']>;
 export type PushControlParam = FromSchema<PeerProtocol['group/push-control']['param']>;
 export type PushControlResult = FromSchema<PeerProtocol['group/push-control']['result']>;
+export type BlobQueryHavesParam = FromSchema<PeerProtocol['blob/query-haves']['param']>;
+export type BlobQueryHavesResult = FromSchema<PeerProtocol['blob/query-haves']['result']>;
+export type BlobManifestParam = FromSchema<PeerProtocol['blob/manifest']['param']>;
+export type BlobManifestResult = FromSchema<PeerProtocol['blob/manifest']['result']>;
+export type ControllerGetLogParam = FromSchema<PeerProtocol['controller/get-log']['param']>;
+export type ControllerGetLogResult = FromSchema<PeerProtocol['controller/get-log']['result']>;
 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 SyncReconcileCredentialsParam = FromSchema<SyncProtocol['sync/reconcile-credentials']['param']>;
+export type SyncReconcileCredentialsResult = FromSchema<SyncProtocol['sync/reconcile-credentials']['result']>;
 export type SyncDirection = 'push' | 'pull' | 'both';
 export type SyncClientMessage = AnyClientMessageOf<SyncProtocol>;
 export type SyncServerMessage = AnyServerMessageOf<SyncProtocol>;

package/lib/protocol.js

@@ -247,6 +247,224 @@ export const syncProtocol = {
             ],
             additionalProperties: false
         }
+    },
+    // Credential catch-up + revocation GC in one round, served over the same
+    // doc-sync session. The caller advertises the signed subject states it holds so
+    // the server can send missing or updated rows and name tombstones for held rows
+    // that are now revoked — a wrapping tombstone addresses no recipient once its
+    // row is gone, so it can only travel when the caller names the id. `bundles`
+    // carries the row BYTES of the keys the caller is a recipient of and was
+    // missing, shaped like a `credential:key-grant` minus its `auth` envelope: each
+    // row self-authenticates through its own `op`, and recipient scoping is
+    // enforced server-side.
+    'sync/reconcile-credentials': {
+        type: 'request',
+        param: {
+            type: 'object',
+            properties: {
+                held: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            subjectKind: {
+                                type: 'string',
+                                enum: [
+                                    'key',
+                                    'wrapping',
+                                    'entry'
+                                ]
+                            },
+                            subjectID: {
+                                type: 'string'
+                            },
+                            opHash: {
+                                type: 'string'
+                            }
+                        },
+                        required: [
+                            'subjectKind',
+                            'subjectID',
+                            'opHash'
+                        ],
+                        additionalProperties: false
+                    },
+                    description: 'Signed subject states the caller holds, for updates and revocation GC'
+                }
+            },
+            required: [
+                'held'
+            ],
+            additionalProperties: false
+        },
+        result: {
+            type: 'object',
+            properties: {
+                bundles: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            keyID: {
+                                type: 'string'
+                            },
+                            keyVersion: {
+                                type: 'number'
+                            },
+                            suite: {
+                                type: 'number'
+                            },
+                            ownerDID: {
+                                type: 'string'
+                            },
+                            keyOp: {
+                                type: 'string'
+                            },
+                            keyBranches: {
+                                type: 'array',
+                                items: {
+                                    type: 'string'
+                                },
+                                description: "The proven key-op JWTs that introduced this key version's branches."
+                            },
+                            wrapping: {
+                                type: 'object',
+                                properties: {
+                                    wrappingID: {
+                                        type: 'string'
+                                    },
+                                    factors: {
+                                        type: 'array',
+                                        items: {
+                                            type: 'object',
+                                            properties: {
+                                                kind: {
+                                                    type: 'string'
+                                                },
+                                                params: {
+                                                    type: 'object',
+                                                    additionalProperties: true
+                                                }
+                                            },
+                                            required: [
+                                                'kind',
+                                                'params'
+                                            ],
+                                            additionalProperties: false
+                                        }
+                                    },
+                                    iv: {
+                                        type: 'string'
+                                    },
+                                    wrappedKey: {
+                                        type: 'string'
+                                    },
+                                    recipientDID: {
+                                        type: 'string'
+                                    },
+                                    op: {
+                                        type: 'string'
+                                    }
+                                },
+                                required: [
+                                    'wrappingID',
+                                    'factors',
+                                    'iv',
+                                    'wrappedKey',
+                                    'recipientDID',
+                                    'op'
+                                ],
+                                additionalProperties: false
+                            },
+                            entries: {
+                                type: 'array',
+                                items: {
+                                    type: 'object',
+                                    properties: {
+                                        entryID: {
+                                            type: 'string'
+                                        },
+                                        iv: {
+                                            type: 'string'
+                                        },
+                                        ciphertext: {
+                                            type: 'string'
+                                        },
+                                        hlc: {
+                                            type: 'string'
+                                        },
+                                        op: {
+                                            type: 'string'
+                                        }
+                                    },
+                                    required: [
+                                        'entryID',
+                                        'iv',
+                                        'ciphertext',
+                                        'hlc',
+                                        'op'
+                                    ],
+                                    additionalProperties: false
+                                }
+                            }
+                        },
+                        required: [
+                            'keyID',
+                            'keyVersion',
+                            'suite',
+                            'ownerDID',
+                            'keyOp',
+                            'keyBranches',
+                            'wrapping',
+                            'entries'
+                        ],
+                        additionalProperties: false
+                    },
+                    description: "The caller's recipient-scoped catch-up bundles (missed grants and entry top-ups)"
+                },
+                tombstones: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            keyID: {
+                                type: 'string'
+                            },
+                            authorDID: {
+                                type: 'string'
+                            },
+                            hlc: {
+                                type: 'string'
+                            },
+                            opJWT: {
+                                type: 'string'
+                            },
+                            opHash: {
+                                type: 'string'
+                            },
+                            subjectID: {
+                                type: 'string'
+                            }
+                        },
+                        required: [
+                            'keyID',
+                            'authorDID',
+                            'hlc',
+                            'opJWT',
+                            'opHash',
+                            'subjectID'
+                        ],
+                        additionalProperties: false
+                    },
+                    description: 'Tombstones for advertised held IDs that are now revoked (GC)'
+                }
+            },
+            required: [
+                'bundles',
+                'tombstones'
+            ],
+            additionalProperties: false
+        }
     }
 };
 /**
@@ -515,5 +733,145 @@ export const syncProtocol = {
             ],
             additionalProperties: false
         }
+    },
+    // Blob transfer lane — control plane. Bytes never ride these; they carry
+    // discovery + a signed fetch capability. The data plane is raw HTTP Range.
+    // Gated coarsely (checkPeerAccess): just reports which bytes this node holds.
+    'blob/query-haves': {
+        type: 'request',
+        param: {
+            type: 'object',
+            properties: {
+                attachmentIDs: {
+                    type: 'array',
+                    items: {
+                        type: 'string'
+                    },
+                    description: 'Candidate AttachmentIDs the caller wants to locate'
+                }
+            },
+            required: [
+                'attachmentIDs'
+            ],
+            additionalProperties: false
+        },
+        result: {
+            type: 'object',
+            properties: {
+                have: {
+                    type: 'array',
+                    items: {
+                        type: 'string'
+                    },
+                    description: 'The subset this node holds with all bytes local'
+                }
+            },
+            required: [
+                'have'
+            ],
+            additionalProperties: false
+        }
+    },
+    // Returns the chunk manifest for one blob and mints a short-TTL fetch
+    // capability the caller presents to the data-plane HTTP route. Scope-gated:
+    // the caller must have a document in scope referencing the blob (D19), and
+    // presents its own read-delegation tokens to prove it.
+    'blob/manifest': {
+        type: 'request',
+        param: {
+            type: 'object',
+            properties: {
+                attachmentID: {
+                    type: 'string'
+                },
+                delegationTokens: {
+                    type: 'array',
+                    items: {
+                        type: 'string'
+                    },
+                    description: "The caller's read-delegation tokens, for scope authorization"
+                }
+            },
+            required: [
+                'attachmentID',
+                'delegationTokens'
+            ],
+            additionalProperties: false
+        },
+        result: {
+            type: 'object',
+            properties: {
+                chunkSize: {
+                    type: 'number'
+                },
+                chunkCount: {
+                    type: 'number'
+                },
+                contentLength: {
+                    type: 'number'
+                },
+                chunkDigests: {
+                    type: 'array',
+                    items: {
+                        type: 'string'
+                    },
+                    description: 'Per-chunk blake3 digests, base64, ordered by index'
+                },
+                capability: {
+                    type: 'string',
+                    description: 'Short-TTL signed fetch capability for the data-plane GET'
+                }
+            },
+            required: [
+                'chunkSize',
+                'chunkCount',
+                'contentLength',
+                'chunkDigests',
+                'capability'
+            ],
+            additionalProperties: false
+        }
+    },
+    // Controller log sharing. Serves a `did:kokuin:` controller's stored key-event
+    // log inline (logs are small — no blob-style data plane). Gated coarsely by
+    // `checkPeerAccess`: the log you need is that of a DID whose documents you
+    // already sync, and those are group/catalog scoped. The events are
+    // self-authenticating (inception digest == DID, every event signed), so the
+    // recipient folds + verifies them independently — the wire schema stays
+    // permissive and the fold on receipt is the real check.
+    'controller/get-log': {
+        type: 'request',
+        param: {
+            type: 'object',
+            properties: {
+                did: {
+                    type: 'string',
+                    description: 'The did:kokuin: controller whose log is requested'
+                }
+            },
+            required: [
+                'did'
+            ],
+            additionalProperties: false
+        },
+        result: {
+            type: 'object',
+            properties: {
+                events: {
+                    type: 'array',
+                    // A SignedEvent is a nested object re-verified on receipt; the wire
+                    // carries it opaquely rather than reproducing its structure.
+                    items: {
+                        type: 'object',
+                        additionalProperties: true
+                    },
+                    description: "The controller's signed key-event log"
+                }
+            },
+            required: [
+                'events'
+            ],
+            additionalProperties: false
+        }
     }
 };

package/lib/sync/access-default-sender.d.ts

@@ -2,7 +2,7 @@ import type { OwnIdentity } from '@kokuin/token';
 import type { KubunDB } from '@kubun/db';
 import type { EngineEventBus, EngineEvents } from '@kubun/engine';
 import type { Logger } from '@kubun/logger';
-import type { GroupBroadcastMessage } from '../groups/broadcast.js';
+import type { GroupBroadcastMessage } from '../groups/broadcast-message.js';
 export type AccessDefaultSenderParams = {
     db: KubunDB;
     eventBus: EngineEventBus<EngineEvents>;