@kubun/plugin-p2p 0.9.0 → 0.10.1

package/lib/types.d.ts

@@ -115,7 +115,15 @@ export type GroupRequestContext = {
         filterCriteria: string;
     }) => Promise<CatalogData>;
     listCatalogs: (ownerDID?: string) => Promise<Array<CatalogData>>;
-    invite: (groupID: string, joinRequest: string) => Promise<InviteToGroupData>;
+    /**
+     * Build an invite payload for a join request.
+     *
+     * `grants` are stringified write-capability JWTs the caller wants the joiner
+     * to hold immediately on join. `revocations` are signed revocation JWTs the
+     * caller wants the joiner to apply immediately — only verified ones travel;
+     * pending revocations (cap not yet known by the inviter) do not.
+     */
+    invite: (groupID: string, joinRequest: string, grants?: Array<string>, revocations?: Array<string>) => Promise<InviteToGroupData>;
     join: (invitePayload: string, joinRequestPayload: string) => Promise<JoinGroupData>;
     leave: (groupID: string) => Promise<LeaveGroupData>;
     removeMember: (groupID: string, memberDID: string) => Promise<RemoveGroupMemberData>;
@@ -129,6 +137,53 @@ export type GroupRequestContext = {
     deleteCatalog: (catalogID: string) => Promise<DeleteCatalogData>;
     deleteCircle: (circleID: string) => Promise<DeleteCircleData>;
     removeCircleMember: (circleID: string, memberDID: string) => Promise<RemoveCircleMemberData>;
+    /**
+     * Mint a `document/write` capability granting `to` write access on resources
+     * matching `res`. Token is stored grantor-side, broadcast to the group, and
+     * returned for direct delivery.
+     *
+     * `res` is a URN. Most-specific wins; broader URNs grant strictly more:
+     *   - `urn:kubun:document:<docID>` — single doc
+     *   - `urn:kubun:model:<modelID>` — every doc of that model owned by the grantor
+     *   - `urn:kubun:model:<interfaceID>` — every doc of every model implementing
+     *     the interface (footgun: a grant on a widely-implemented interface like
+     *     `Owned` or `Timestamped` becomes a near-wildcard)
+     *   - `urn:kubun:user:<DID>` — every doc owned by that DID (the grantor)
+     *   - `*` — every doc the grantor owns, present and future
+     *
+     * Prefer the narrowest URN that satisfies the use case. Broad grants combine
+     * with the long default `exp` (30 days) to expand the blast radius of a
+     * leaked or misdirected token.
+     */
+    grantWriteCapability: (params: {
+        to: string;
+        res: string;
+        groupID: string;
+        expiresIn?: number;
+    }) => Promise<string>;
+    /**
+     * Revoke a previously-granted `document/write` capability by its `jti`.
+     *
+     * Revocation is binary: once a peer learns of the revocation, every
+     * mutation that authenticates via this `jti` is denied. The check is
+     * reactive, not retroactive — mutations already applied locally stay
+     * applied; only future writes carrying the revoked `jti` are gated.
+     *
+     * Only the original capability issuer may revoke it. The resolver looks up
+     * the capability locally and rejects:
+     *   - `REVOCATION_CAP_UNKNOWN` when no row matches the `jti` on this peer
+     *     (multi-device-grantor case, where the issuing device is not the one
+     *     calling `revokeCapability`, is not yet supported).
+     *   - `REVOCATION_UNAUTHORIZED` when the viewer is not the capability's
+     *     issuer.
+     *
+     * Returns the boolean reported by the store: `true` when the revocation
+     * row was newly written (or materially changed), `false` on an idempotent
+     * no-op (already revoked at an equal or newer HLC).
+     */
+    revokeCapability: (params: {
+        jti: string;
+    }) => Promise<boolean>;
 };
 export type SyncRequestContext = {
     addPeer: (config: PeerConfig) => Promise<void>;
@@ -175,12 +230,56 @@ export type HubRequestContext = {
     }) => Promise<boolean>;
     listByGroup: (groupID: string) => Promise<Array<HubData>>;
     listGroups: (hubID: string) => Promise<Array<GroupData>>;
+    /** Current health snapshot for a group (state + last transition time). */
+    getGroupHealth: (groupID: string) => GroupHealthSnapshot;
+    /**
+     * Kick off stale-device recovery for a group. Fire-and-forget at the resolver
+     * boundary; the terminal outcome arrives via the `groupHealthChanged`
+     * subscription. Resolves with the flow's final result for callers that await.
+     */
+    rejoinGroup: (groupID: string) => Promise<RejoinResult>;
+};
+export type DelegationData = {
+    jwt: string;
+    jti: string;
+    grantor: string;
+    audience: string;
+    resource: string;
+    exp: number;
+};
+export type DelegationTokenCovers = {
+    modelID?: string | null;
+    docID?: string | null;
+};
+export type ListOwnDelegationTokensParams = {
+    viewerDID: string;
+    grantor?: string | null;
+    covers?: DelegationTokenCovers | null;
+};
+export type RevokedDelegationData = {
+    jti: string;
+    grantor: string;
+    audience: string;
+    revokerDID: string;
+    revokedAt: number;
+    verifiedAt: number;
+    capExp: number | null;
+    groupID: string;
+};
+export type ListOwnRevokedTokensParams = {
+    viewerDID: string;
+    grantor?: string | null;
+};
+export type DelegationRequestContext = {
+    listOwnTokens: (params: ListOwnDelegationTokensParams) => Promise<Array<DelegationData>>;
+    listOwnRevokedTokens: (params: ListOwnRevokedTokensParams) => Promise<Array<RevokedDelegationData>>;
 };
 export type P2PContext = {
     group: GroupRequestContext;
     sync: SyncRequestContext;
     join: P2PJoinRequestContext;
     hub: HubRequestContext;
+    delegation: DelegationRequestContext;
 };
 declare module '@kubun/graphql' {
     interface PluginContextMap {
@@ -194,6 +293,28 @@ export type SyncSessionResult = {
     messagesSent: number;
     missingClusters?: Record<string, unknown>;
 };
+/** A group-level health condition the monitor tracks. */
+export type GroupHealthCondition = 'epoch-stale';
+/**
+ * Persisted health state for a group. `recovered` is a transient transition
+ * surfaced only on the emitted event; `getState` collapses it to `healthy`.
+ */
+export type GroupHealthState = 'healthy' | 'degraded' | 'recovering' | 'recovered' | 'recovery-failed';
+export type GroupHealthData = {
+    groupID: string;
+    condition: GroupHealthCondition;
+    state: GroupHealthState;
+};
+/** A point-in-time health snapshot for a group (drives the GraphQL query). */
+export type GroupHealthSnapshot = {
+    state: GroupHealthState;
+    /** Epoch ms of the last state transition, or null if never transitioned. */
+    lastTransitionAt: number | null;
+};
+/** Terminal outcome of a rejoin flow. */
+export type RejoinResult = {
+    status: 'recovered' | 'recovery-failed';
+};
 export type SyncPluginAPI = {
     /** Resolves when the HTTP sync transport is registered (only present when http option is enabled). */
     syncReady?: Promise<void>;

package/lib/utils.d.ts

@@ -0,0 +1,5 @@
+/** Node returns a Timeout object with `unref()`; browsers return a number. */
+export declare function unref(timer: ReturnType<typeof setTimeout>): void;
+/** Resolve after `ms`, without keeping the process alive. */
+export declare function sleep(ms: number): Promise<void>;
+export declare function bytesEqual(a: Uint8Array, b: Uint8Array): boolean;

package/lib/utils.js

@@ -0,0 +1 @@
+export function unref(e){e.unref?.()}export function sleep(e){return new Promise(n=>{unref(setTimeout(n,e))})}export function bytesEqual(e,n){if(e.length!==n.length)return!1;for(let t=0;t<e.length;t++)if(e[t]!==n[t])return!1;return!0}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/plugin-p2p",
-  "version": "0.9.0",
+  "version": "0.10.1",
   "license": "see LICENSE.md",
   "type": "module",
   "main": "lib/index.js",
@@ -14,50 +14,50 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@enkaku/async": "^0.15.0",
-    "@enkaku/capability": "^0.15.0",
-    "@enkaku/client": "^0.15.1",
-    "@enkaku/codec": "^0.15.0",
-    "@enkaku/event": "^0.15.0",
-    "@enkaku/generator": "^0.15.0",
-    "@enkaku/group": "^0.15.0",
-    "@enkaku/http-client-transport": "^0.15.0",
-    "@enkaku/http-server-transport": "^0.15.0",
-    "@enkaku/hub-protocol": "^0.15.0",
-    "@enkaku/hub-tunnel": "^0.15.0",
-    "@enkaku/protocol": "^0.15.0",
-    "@enkaku/runtime": "^0.15.0",
-    "@enkaku/schema": "^0.15.0",
-    "@enkaku/server": "^0.15.0",
-    "@enkaku/stream": "^0.15.0",
-    "@enkaku/token": "^0.15.0",
-    "@enkaku/transport": "^0.15.0",
+    "@enkaku/async": "^0.16.0",
+    "@enkaku/capability": "^0.16.0",
+    "@enkaku/client": "^0.16.0",
+    "@enkaku/codec": "^0.16.0",
+    "@enkaku/event": "^0.16.0",
+    "@enkaku/generator": "^0.16.0",
+    "@enkaku/group": "^0.16.2",
+    "@enkaku/http-client-transport": "^0.16.0",
+    "@enkaku/http-server-transport": "^0.16.0",
+    "@enkaku/hub-protocol": "^0.16.0",
+    "@enkaku/hub-tunnel": "^0.16.0",
+    "@enkaku/protocol": "^0.16.0",
+    "@enkaku/runtime": "^0.16.0",
+    "@enkaku/schema": "^0.16.0",
+    "@enkaku/server": "^0.16.0",
+    "@enkaku/stream": "^0.16.0",
+    "@enkaku/token": "^0.16.0",
+    "@enkaku/transport": "^0.16.0",
     "@noble/hashes": "^2.2.0",
-    "graphql": "^16.13.2",
-    "kysely": "^0.28.17",
-    "@kubun/client": "^0.9.0",
-    "@kubun/db": "^0.9.0",
-    "@kubun/db-adapter": "^0.9.0",
-    "@kubun/engine": "^0.9.0",
-    "@kubun/store-p2p": "^0.9.0",
-    "@kubun/store-graph": "^0.9.0",
-    "@kubun/graphql": "^0.9.0",
-    "@kubun/hlc": "^0.9.0",
-    "@kubun/id": "^0.9.0",
-    "@kubun/logger": "^0.9.0",
-    "@kubun/mutation": "^0.9.0",
-    "@kubun/protocol": "^0.9.0"
+    "graphql": "^16.14.2",
+    "kysely": "^0.29.2",
+    "@kubun/client": "^0.10.1",
+    "@kubun/db-adapter": "^0.10.0",
+    "@kubun/db": "^0.10.0",
+    "@kubun/engine": "^0.10.3",
+    "@kubun/store-graph": "^0.10.2",
+    "@kubun/store-p2p": "^0.10.1",
+    "@kubun/hlc": "^0.10.1",
+    "@kubun/graphql": "^0.10.1",
+    "@kubun/id": "^0.10.0",
+    "@kubun/mutation": "^0.10.1",
+    "@kubun/logger": "^0.10.0",
+    "@kubun/protocol": "^0.10.0"
   },
   "devDependencies": {
-    "@enkaku/hub-server": "^0.15.0",
+    "@enkaku/hub-server": "^0.16.0",
     "get-port": "^7.2.0",
-    "@kubun/db-node-sqlite": "^0.9.0",
-    "@kubun/db-better-sqlite": "^0.9.0",
-    "@kubun/hub": "^0.9.0",
-    "@kubun/plugin-connector": "^0.9.0",
-    "@kubun/plugin-http": "^0.9.0",
-    "@kubun/plugin-rpc": "^0.9.0",
-    "@kubun/test-utils": "^0.9.0"
+    "@kubun/db-better-sqlite": "^0.10.0",
+    "@kubun/hub": "^0.10.0",
+    "@kubun/plugin-connector": "^0.10.0",
+    "@kubun/db-node-sqlite": "^0.10.0",
+    "@kubun/plugin-http": "^0.10.0",
+    "@kubun/plugin-rpc": "^0.10.0",
+    "@kubun/test-utils": "^0.10.0"
   },
   "scripts": {
     "build:clean": "del lib",

package/lib/sync/catalog-match.d.ts

@@ -1,13 +0,0 @@
-import type { CatalogFilterCriteria, DocumentNode } from '@kubun/protocol';
-import type { P2PStoreAPI } from '@kubun/store-p2p';
-/**
- * Determine whether a document matches a catalog's filter criteria.
- *
- * Mirrors the semantics of {@link resolveCatalogSyncScopes} (which collects
- * broadly-applicable models + owner filters for sync): each catalog field is
- * AND'd, values within a field are OR'd, and the `circles` field expands to a
- * union of circle members and merges with the explicit `owners` filter.
- *
- * Returns `true` iff the document would be included by this catalog.
- */
-export declare function catalogMatchesDoc(criteria: CatalogFilterCriteria, doc: Pick<DocumentNode, 'model' | 'owner'>, p2pStore: P2PStoreAPI): Promise<boolean>;

package/lib/sync/catalog-match.js

@@ -1 +0,0 @@
-export async function catalogMatchesDoc(e,l,n){if(null!=e.models&&e.models.length>0&&!e.models.includes(l.model))return!1;let c=null!=e.owners&&e.owners.length>0,r=null!=e.circles&&e.circles.length>0;return!!(!c&&!r||c&&e.owners?.includes(l.owner)||r&&null!=e.circles&&await n.isMemberOfAnyCircle(l.owner,e.circles))}