@kubun/plugin-p2p 0.15.1 → 0.16.1

package/lib/index.js

@@ -107,11 +107,10 @@ export function createP2PPlugin(options) {
         }
         const identity = params.identity;
         // The engine's single device-wide clock. Sharing it across the p2p group/
-        // circle/member metadata paths (context, GroupManager, BroadcastService)
-        // keeps every write from this device on one monotonic counter, so two
-        // writes in the same millisecond mint strictly-increasing timestamps rather
-        // than identical ones (the second of which would silently lose under
-        // last-writer-wins).
+        // circle/member metadata paths keeps every write from this device on one
+        // monotonic counter, so two writes in the same millisecond mint
+        // strictly-increasing timestamps rather than identical ones (the second of
+        // which would silently lose under last-writer-wins).
         const hlc = params.hlc;
         // Computed up front so SyncManager + sync handlers + the hub-relay
         // BroadcastService all see the same receive policy. Hot-path invariant:
@@ -298,18 +297,33 @@ export function createP2PPlugin(options) {
             runtime: params.runtime,
             db: params.db,
             hlc,
+            // The engine's identity gate, forwarded to the presence coordinator so a
+            // self-started announce waits for verification before it mints.
+            ready: ()=>params.engine.ready(),
+            // A thunk, not the resolved value: `getWorkflowAPI` is defined further down
+            // this factory body, so it is only in the temporal dead zone until the body
+            // finishes — and the manager invokes this on peer creation, long after.
+            getWorkflowAPI: ()=>getWorkflowAPI(),
             maxDriftMS: params.maxDriftMS,
             graph: params.graph,
             emitter,
             createHubClient,
             registry,
             // Re-drive a lost `ledger` commit's surviving tokens through the group
-            // manager's own ledger write path, so the seam stays a consumer of it.
-            buildLedgerRedrive: (groupID, tokens, requestID)=>groupManager.buildEnactLedgerCommit({
+            // manager's own ledger write path, so the seam stays a consumer of it. The
+            // redrive is a self-start (the hub relay, not a request), so its commit
+            // build waits behind `ready()` before it mints under the engine's clock.
+            buildLedgerRedrive: (groupID, tokens, requestID)=>{
+                const build = groupManager.buildEnactLedgerCommit({
                     groupID,
                     tokens,
                     requestID
-                }),
+                });
+                return async ()=>{
+                    await params.engine.ready();
+                    return build();
+                };
+            },
             logger: hubRelayLogger,
             storeUnreadable: receiveConfig.storeUnreadable,
             defaultAccessLevel,
@@ -434,30 +448,47 @@ export function createP2PPlugin(options) {
         // use, executed on behalf of the verified caller against the plugin's own
         // DB (peer procedures run outside an engine transaction; `joinGroup` manages
         // its own inner transaction). No MLS logic is reimplemented here.
+        // The inbound peer dance stamps group/roster/ledger metadata under the
+        // engine's clock outside any GraphQL write entry, so each runner is a
+        // self-start driver: it awaits `ready()` before touching the deps that mint.
+        // `ready()` is resolved for a booted engine, so this only delays a dance that
+        // arrives in the window before identity verification settles.
         const peerHandlers = createPeerHandlers({
             db: params.db,
             identity,
             logger: params.getLogger('peer-handlers'),
             autoAcceptPeers: options?.autoAcceptPeers,
-            runPrepareJoin: (callerDID)=>createJoinContext(// Out-of-band peer-handler context for the verified caller; the join ops
+            runPrepareJoin: async (callerDID)=>{
+                await params.engine.ready();
+                return createJoinContext(// Out-of-band peer-handler context for the verified caller; the join ops
                 // never consult the authority, so a self-scoped device authority fits.
                 {
                     viewerDID: callerDID,
                     credentialAuthority: createDeviceAuthority(callerDID)
-                }, buildContextDeps(params.db)).prepareRequest(),
-            runCompleteJoin: (callerDID, invitePayload)=>createJoinContext({
+                }, buildContextDeps(params.db)).prepareRequest();
+            },
+            runCompleteJoin: async (callerDID, invitePayload)=>{
+                await params.engine.ready();
+                return createJoinContext({
                     viewerDID: callerDID,
                     credentialAuthority: createDeviceAuthority(callerDID)
-                }, buildContextDeps(params.db)).complete(invitePayload),
-            runInvite: (callerDID, groupID, joinRequest)=>serveGroupInvite(buildContextDeps(params.db), {
+                }, buildContextDeps(params.db)).complete(invitePayload);
+            },
+            runInvite: async (callerDID, groupID, joinRequest)=>{
+                await params.engine.ready();
+                return serveGroupInvite(buildContextDeps(params.db), {
                     callerDID,
                     groupID,
                     joinRequest
-                }),
-            runPushControl: (callerDID, param)=>servePushControl(buildContextDeps(params.db), {
+                });
+            },
+            runPushControl: async (callerDID, param)=>{
+                await params.engine.ready();
+                return servePushControl(buildContextDeps(params.db), {
                     callerDID,
                     ...param
-                })
+                });
+            }
         });
         // Blob transfer control-lane handlers, mounted on the same peer server.
         const blobHandlers = createBlobHandlers({
@@ -567,6 +598,7 @@ export function createP2PPlugin(options) {
             // runners do: the scopes an automatic catch-up asks for cannot drift from
             // the ones an explicit one asks for if there is only one implementation.
             catchUpWithBestPeer: (groupID)=>createSyncContext(null, buildContextDeps(params.db)).catchUpWithBestPeer(groupID),
+            reauthorize: (groupID)=>hub.reauthorize(groupID),
             listPeerDevices: (groupID)=>createSyncContext(null, buildContextDeps(params.db)).listPeerDevices(groupID),
             onSyncEvent: (callback)=>syncManager.onSyncEvent(callback),
             onHubServerDIDChanged: (listener)=>emitter.on('hubServerDIDChanged', listener),
@@ -577,6 +609,37 @@ export function createP2PPlugin(options) {
                 await (await hub.presence()).setProfile(profile);
             },
             getLocalPeerProfile: async ()=>await (await hub.presence()).getProfile(),
+            // The typed workflow control plane: `groupID` selects the peers, the hub
+            // wiring handles the multi-hub fan-out (discover) and directed `.to()`
+            // request (the rest). The wire results are shaped to the contract types
+            // here; a business refusal on a command travels as data, and a caller
+            // helper (plugin-workflow) reconstitutes it into a throw.
+            discoverWorkflows: (groupID, options)=>hub.discoverWorkflows(groupID, options),
+            listWorkflows: async (groupID, targetDID)=>// `workflow/list` takes no fields but its param schema is a (closed) object,
+                // so an omitted param serializes to an invalid request frame — pass `{}`.
+                await hub.requestWorkflow(groupID, targetDID, 'workflow/list', {}),
+            workflowStatus: async (groupID, targetDID, instanceID)=>await hub.requestWorkflow(groupID, targetDID, 'workflow/status', {
+                    instanceID
+                }),
+            enqueueWorkflow: async (groupID, targetDID, name, params, opts)=>await hub.requestWorkflow(groupID, targetDID, 'workflow/enqueue', {
+                    name,
+                    params,
+                    // A stable idempotency key makes the cross-hub retry safe: a directed
+                    // request can throw on the RESPONSE leg (the target already enqueued,
+                    // but the reply was lost), and the retry re-sends to the same mailbox.
+                    // Under one key the target returns the existing instance instead of
+                    // creating a second. A caller-supplied key wins; else one per call.
+                    opts: {
+                        ...opts,
+                        idempotencyKey: opts?.idempotencyKey ?? crypto.randomUUID()
+                    }
+                }),
+            cancelWorkflow: async (groupID, targetDID, instanceID)=>await hub.requestWorkflow(groupID, targetDID, 'workflow/cancel', {
+                    instanceID
+                }),
+            retryWorkflow: async (groupID, targetDID, instanceID)=>await hub.requestWorkflow(groupID, targetDID, 'workflow/retry', {
+                    instanceID
+                }),
             gatherPeers: async (groupID, options)=>await (await hub.presence()).gather(groupID, options),
             refreshPeerPresence: async (groupID, options)=>await (await hub.presence()).refresh(groupID, options),
             retryHubConnection: async ()=>await hub.retryHubs(),

package/lib/schema.js

@@ -726,7 +726,7 @@ extend type Mutation {
   createGroup(input: CreateGroupInput!): CreateGroupPayload!
   requestCreateCircle(input: RequestCreateCircleInput!): RequestCreateCirclePayload!
   requestAddCircleMember(input: RequestAddCircleMemberInput!): RequestAddCircleMemberPayload!
-  createCatalog(name: String!, description: String, filterCriteria: String!): PeerCatalog!
+  createCatalog(catalogID: ID, name: String!, description: String, filterCriteria: String!): PeerCatalog!
   requestInviteToGroup(input: RequestInviteToGroupInput!): RequestInviteToGroupPayload!
   joinGroup(invitePayload: String!, joinRequestPayload: String!): JoinGroupPayload!
   prepareJoinRequest: PrepareJoinRequestPayload!
@@ -1101,6 +1101,7 @@ export function createP2PSchemaExtension(emitter, syncManager, logger = getKubun
                 },
                 createCatalog: async (_source, args, context)=>{
                     return await requireP2P(context).group.createCatalog({
+                        catalogID: args.catalogID,
                         name: args.name,
                         description: args.description,
                         filterCriteria: args.filterCriteria

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

@@ -1,4 +1,4 @@
-import { type Identity, type SigningIdentity } from '@kokuin/token';
+import { type Identity } from '@kokuin/token';
 import type { StoreProvider } from '@kubun/db';
 import type { DefaultAccessLevel, GraphInternals } from '@kubun/engine';
 import type { Logger } from '@kubun/logger';
@@ -76,10 +76,6 @@ export declare class SyncManager {
     #private;
     constructor(params: SyncManagerParams);
     get peerRegistry(): PeerRegistry;
-    /**
-     * Configure the signing identity used for sync operations.
-     */
-    setIdentity(identity: SigningIdentity): void;
     /**
      * Configure the resolver for the transports built locally rather than dialled:
      * `direct://` (in-process) and `tunnel://` (relayed by the group's hub, whose

package/lib/sync/sync-manager.js

@@ -36,11 +36,6 @@ export class SyncManager {
         return this.#peerRegistry;
     }
     /**
-   * Configure the signing identity used for sync operations.
-   */ setIdentity(identity) {
-        this.#identity = identity;
-    }
-    /**
    * Configure the resolver for the transports built locally rather than dialled:
    * `direct://` (in-process) and `tunnel://` (relayed by the group's hub, whose
    * group id arrives as the resolver's `route`).

package/lib/types.d.ts

@@ -1,4 +1,5 @@
 import type { ClientTransportOf } from '@enkaku/protocol';
+import type { WorkflowControlPlaneAPI } from '@kubun/plugin-p2p-api';
 import type { ServiceProtocol } from '@kubun/plugin-service-api';
 import type { AdaptivePolicy } from '@kubun/plugin-workflow-api';
 import type { AccessLevel } from '@kubun/store-graph';
@@ -1082,7 +1083,7 @@ export type PeerGatherOptions = {
  * of the logs, and nothing branches on it.
  */
 export type PresenceReason = 'hub-connected' | 'epoch-changed' | 'app-window-pruned' | 'requested';
-export type SyncPluginAPI = {
+export type SyncPluginAPI = WorkflowControlPlaneAPI & {
     /** Resolves when the HTTP sync transport is registered (only present when http option is enabled). */
     syncReady?: Promise<void>;
     /**
@@ -1109,6 +1110,19 @@ export type SyncPluginAPI = {
      * decides who, and an explicit `syncPeer` ignores the ranking entirely.
      */
     catchUpWithBestPeer(groupID: string): Promise<PeerCatchUpData>;
+    /**
+     * Re-drive any group subscription this device's hub-peers latched as refused.
+     *
+     * A device subscribes its group topics the instant it joins, before the
+     * APPLICATION-level authorization that gates them at the hub has landed — so
+     * the hub answers `AuthorizationDeniedError` and the peer's mux latches it
+     * permanent (a busy retry against an answer would be worse). This layer cannot
+     * see the app's authorization state, so it cannot know on its own when to ask
+     * again; the app calls this once it knows the device is authorized (e.g. its
+     * membership row has replicated after pairing completes). Idempotent and a
+     * no-op when nothing is refused — safe to call on every authorization change.
+     */
+    reauthorize(groupID: string): Promise<void>;
     /**
      * Every device this one has heard announce in the group — the projection, and
      * never a liveness answer. {@link SyncPluginAPI.gatherPeers} is what says who

package/lib/types.js

@@ -1 +1,5 @@
+// The six caller-facing workflow control-plane methods (discover/list/status/
+// enqueue/cancel/retry, each keyed by `groupID`) are contributed by
+// WorkflowControlPlaneAPI so this plugin's public surface and the type-only
+// contract plugin-workflow imports cannot drift.
 export { };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/plugin-p2p",
-  "version": "0.15.1",
+  "version": "0.16.1",
   "license": "see LICENSE.md",
   "sideEffects": false,
   "type": "module",
@@ -23,35 +23,36 @@
     "@kokuin/capability": "^0.3.0",
     "@kokuin/controller": "^0.1.0",
     "@kokuin/token": "^0.5.0",
-    "@kubun/credential": "^0.15.0",
-    "@kubun/db": "^0.15.0",
-    "@kubun/db-adapter": "^0.15.0",
-    "@kubun/engine": "^0.15.0",
-    "@kubun/graphql": "^0.15.0",
-    "@kubun/hlc": "^0.15.0",
-    "@kubun/http-util": "^0.15.0",
-    "@kubun/id": "^0.15.0",
-    "@kubun/logger": "^0.15.0",
-    "@kubun/mutation": "^0.15.0",
-    "@kubun/plugin-blob-api": "^0.15.0",
-    "@kubun/plugin-http": "^0.15.0",
-    "@kubun/plugin-http-api": "^0.15.0",
-    "@kubun/plugin-service-api": "^0.15.1",
-    "@kubun/plugin-workflow-api": "^0.15.0",
-    "@kubun/protocol": "^0.15.0",
-    "@kubun/store-blob": "^0.15.0",
-    "@kubun/store-controller": "^0.15.0",
-    "@kubun/store-credential": "^0.15.0",
-    "@kubun/store-delegation": "^0.15.0",
-    "@kubun/store-graph": "^0.15.0",
-    "@kubun/store-p2p": "^0.15.0",
-    "@kumiai/broadcast": "^0.8.0",
-    "@kumiai/hub-protocol": "^0.8.0",
-    "@kumiai/hub-server": "^0.8.0",
-    "@kumiai/hub-tunnel": "^0.8.0",
-    "@kumiai/mls": "^0.8.0",
-    "@kumiai/mls-rpc": "^0.8.0",
-    "@kumiai/rpc": "^0.8.0",
+    "@kubun/credential": "^0.16.0",
+    "@kubun/db": "^0.16.0",
+    "@kubun/db-adapter": "^0.16.0",
+    "@kubun/engine": "^0.16.0",
+    "@kubun/graphql": "^0.16.0",
+    "@kubun/hlc": "^0.16.0",
+    "@kubun/http-util": "^0.16.0",
+    "@kubun/id": "^0.16.0",
+    "@kubun/logger": "^0.16.0",
+    "@kubun/mutation": "^0.16.0",
+    "@kubun/plugin-blob-api": "^0.16.0",
+    "@kubun/plugin-http": "^0.16.0",
+    "@kubun/plugin-http-api": "^0.16.0",
+    "@kubun/plugin-p2p-api": "^0.16.0",
+    "@kubun/plugin-service-api": "^0.16.0",
+    "@kubun/plugin-workflow-api": "^0.16.0",
+    "@kubun/protocol": "^0.16.0",
+    "@kubun/store-blob": "^0.16.0",
+    "@kubun/store-controller": "^0.16.0",
+    "@kubun/store-credential": "^0.16.0",
+    "@kubun/store-delegation": "^0.16.0",
+    "@kubun/store-graph": "^0.16.0",
+    "@kubun/store-p2p": "^0.16.0",
+    "@kumiai/broadcast": "^0.9.0",
+    "@kumiai/hub-protocol": "^0.9.0",
+    "@kumiai/hub-server": "^0.9.0",
+    "@kumiai/hub-tunnel": "^0.9.0",
+    "@kumiai/mls": "^0.9.0",
+    "@kumiai/mls-rpc": "^0.9.0",
+    "@kumiai/rpc": "^0.9.0",
     "@noble/ciphers": "^2.4.0",
     "@noble/hashes": "^2.4.0",
     "@sozai/async": "^0.2.1",
@@ -66,21 +67,21 @@
     "ts-mls": "2.0.0-rc.13"
   },
   "devDependencies": {
-    "@kubun/blob-backend": "^0.15.0",
-    "@kubun/client": "^0.15.0",
-    "@kubun/db-better-sqlite": "^0.15.0",
-    "@kubun/db-node-sqlite": "^0.15.0",
-    "@kubun/db-postgres": "^0.15.0",
-    "@kubun/hub": "^0.15.0",
-    "@kubun/plugin-blob": "^0.15.0",
-    "@kubun/plugin-connector": "^0.15.0",
-    "@kubun/plugin-service-server": "^0.15.1",
-    "@kubun/plugin-workflow": "^0.15.0",
-    "@kubun/service-graph-api": "^0.15.0",
-    "@kubun/store-workflow": "^0.15.0",
-    "@kubun/test-utils": "^0.13.0",
-    "@kumiai/hub-conformance": "^0.8.0",
-    "@kumiai/rpc-conformance": "^0.8.0",
+    "@kubun/blob-backend": "^0.16.0",
+    "@kubun/client": "^0.16.0",
+    "@kubun/db-better-sqlite": "^0.16.0",
+    "@kubun/db-node-sqlite": "^0.16.0",
+    "@kubun/db-postgres": "^0.16.0",
+    "@kubun/hub": "^0.16.0",
+    "@kubun/plugin-blob": "^0.16.0",
+    "@kubun/plugin-connector": "^0.16.0",
+    "@kubun/plugin-service-server": "^0.16.0",
+    "@kubun/plugin-workflow": "^0.16.0",
+    "@kubun/service-graph-api": "^0.16.0",
+    "@kubun/store-workflow": "^0.16.0",
+    "@kubun/test-utils": "^0.0.0",
+    "@kumiai/hub-conformance": "^0.9.0",
+    "@kumiai/rpc-conformance": "^0.9.0",
     "@testcontainers/postgresql": "^12.1.0",
     "get-port": "^7.2.0"
   },
@@ -90,8 +91,8 @@
   "scripts": {
     "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
     "build:clean": "del lib",
-    "build:js": "swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
-    "build:types": "tsc --emitDeclarationOnly --skipLibCheck",
+    "build:js": "del 'lib/**/*.js' && swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
+    "build:types": "del 'lib/**/*.d.ts' 'lib/**/*.d.ts.map' && tsc --emitDeclarationOnly --skipLibCheck",
     "test": "pnpm run test:types && pnpm run test:unit",
     "test:types": "tsc --noEmit -p tsconfig.test.json",
     "test:unit": "vitest run"