@kubun/plugin-p2p 0.13.1 → 0.14.0

package/lib/index.js

@@ -28,6 +28,7 @@ import { createP2PSchemaExtension } from './schema.js';
 import { wireAccessDefaultSender } from './sync/access-default-sender.js';
 import { createBroadcastQueue, DEFAULT_BROADCAST_BATCH_CONFIG } from './sync/broadcast-queue.js';
 import { DEFAULT_PUSH_SYNC_CONFIG, wireBroadcastSender } from './sync/broadcast-sender.js';
+import { createGroupSyncWorkflow, GROUP_SYNC_CONCURRENCY, GROUP_SYNC_WORKFLOW, wireGroupPeriodicSyncArming } from './sync/group-sync-workflow.js';
 import { createSyncHandlers } from './sync/handlers.js';
 import { SyncManager } from './sync/sync-manager.js';
 export { GROUP_CONTROL_DENIED, LAST_GROUP_ADMIN, NOT_GROUP_ADMIN, requireGroupAdmin } from './context/require-admin.js';
@@ -76,6 +77,26 @@ export { SyncManager } from './sync/sync-manager.js';
 function isOwnIdentity(identity) {
     return isFullIdentity(identity) && 'privateKey' in identity;
 }
+// Fixed 30s after a pass that pulled mutations; idle 2m→30m, offline 1m→30m,
+// error 30s→15m (both backing off exponentially). Group catch-up is a cheap
+// merkle diff, so the productive cadence is tighter than the connector's.
+const DEFAULT_GROUP_PERIODIC_SYNC_POLICY = {
+    changed: 30_000,
+    idle: {
+        base: 120_000,
+        max: 1_800_000
+    },
+    offline: {
+        base: 60_000,
+        max: 1_800_000,
+        backoff: 'exponential'
+    },
+    error: {
+        base: 30_000,
+        max: 900_000,
+        backoff: 'exponential'
+    }
+};
 export function createP2PPlugin(options) {
     return (params)=>{
         params.db.register(p2pStoreDefinition);
@@ -178,7 +199,7 @@ export function createP2PPlugin(options) {
             logger: params.getLogger('peer-connections')
         });
         // The p2p plugin manages its own Enkaku server for sync handlers,
-        // separate from plugin-rpc's graph server.
+        // separate from the graph service's server.
         const syncServers = [];
         function createSyncTransport(signal) {
             const directTransports = new DirectTransports({
@@ -390,8 +411,74 @@ export function createP2PPlugin(options) {
             logger: params.getLogger('controller-handlers'),
             autoAcceptPeers: options?.autoAcceptPeers
         });
+        // Recurring group catch-up over the workflow engine's adaptive scheduler. One
+        // `catchUpWithBestPeer` pass is one durable tick, run viewer-independent through
+        // the SAME sync context the GraphQL surface and the API use, so a scheduled
+        // catch-up cannot ask for scopes an explicit one would not.
+        const groupSyncWorkflow = createGroupSyncWorkflow({
+            catchUpWithBestPeer: (groupID)=>createSyncContext(null, buildContextDeps(params.db)).catchUpWithBestPeer(groupID),
+            logger: params.getLogger('group-sync')
+        });
+        let workflowAPIPromise;
+        const getWorkflowAPI = ()=>{
+            if (workflowAPIPromise == null) {
+                workflowAPIPromise = params.engine.getAPI('workflow').then((api)=>{
+                    api.defineQueue(GROUP_SYNC_WORKFLOW, {
+                        concurrency: GROUP_SYNC_CONCURRENCY
+                    });
+                    api.register(groupSyncWorkflow.definition);
+                    return api;
+                }).catch(()=>undefined);
+            }
+            return workflowAPIPromise;
+        };
+        // Resolve once at boot so the definition + queue register before any due
+        // schedule fires: an implicit schedule armed on a prior run is promoted by the
+        // engine at startup and needs its handler present, which the connector's
+        // lazy-only resolve does not have to guarantee (nothing schedules it implicitly).
+        void getWorkflowAPI();
+        // Implicit activation: arm a schedule the first time a group is joined,
+        // insert-if-absent (see `wireGroupPeriodicSyncArming`).
+        wireGroupPeriodicSyncArming({
+            emitter,
+            getWorkflowAPI,
+            policy: DEFAULT_GROUP_PERIODIC_SYNC_POLICY,
+            logger: params.getLogger('group-sync')
+        });
+        // Explicit control. `enable` always (re)activates — the deliberate opposite of
+        // the implicit insert-if-absent guard — so the user turning it back on wins.
+        const groupPeriodicSyncControl = {
+            enableGroupPeriodicSync: async (groupID, policyOverride)=>{
+                const api = await getWorkflowAPI();
+                if (api == null) {
+                    throw new Error('workflow plugin required for periodic sync');
+                }
+                const { id } = await api.scheduleAdaptive(GROUP_SYNC_WORKFLOW, {
+                    groupID
+                }, {
+                    policy: policyOverride ?? DEFAULT_GROUP_PERIODIC_SYNC_POLICY,
+                    subjectKey: groupID
+                });
+                return api.getPeriodicSync(id);
+            },
+            disableGroupPeriodicSync: async (groupID)=>{
+                const api = await getWorkflowAPI();
+                if (api == null) {
+                    throw new Error('workflow plugin required for periodic sync');
+                }
+                return api.setPeriodicSyncEnabled(`${GROUP_SYNC_WORKFLOW}:${groupID}`, false);
+            },
+            getGroupPeriodicSync: async (groupID)=>{
+                const api = await getWorkflowAPI();
+                if (api == null) {
+                    throw new Error('workflow plugin required for periodic sync');
+                }
+                return api.getPeriodicSync(`${GROUP_SYNC_WORKFLOW}:${groupID}`);
+            }
+        };
         const pluginAPI = {
             hubReady: hub.ready,
+            ...groupPeriodicSyncControl,
             addPeer: (config)=>syncManager.addPeer({
                     config,
                     stores: params.db
@@ -432,11 +519,19 @@ export function createP2PPlugin(options) {
                     peerConnections,
                     getBlobAPI: ()=>params.engine.getAPI('blob'),
                     fetch: params.runtime.fetch
-                }, attachmentID, options),
-            fetchControllerLog: (did)=>fetchControllerLog({
+                }, attachmentID, options)
+        };
+        // The controller resolver pulls a `did:kokuin:` log over `controller/get-log`
+        // from a connected group peer on a store miss/expiry. Registered as a
+        // `networked` provider (the engine times it out and folds the result) rather
+        // than an API member the engine reached by string.
+        params.registerProvider('controller-log-source', {
+            name: 'p2p',
+            transport: 'networked',
+            fetch: (did)=>fetchControllerLog({
                     peerConnections
                 }, did)
-        };
+        });
         let httpSyncTransport;
         let httpSyncServer;
         let httpPeerTransport;
@@ -528,7 +623,7 @@ export function createP2PPlugin(options) {
         }
         return {
             name: 'p2p',
-            schemaExtension: (_config)=>createP2PSchemaExtension(emitter, syncManager, params.getLogger('p2p-schema')),
+            schemaExtension: (config)=>createP2PSchemaExtension(emitter, syncManager, params.getLogger('p2p-schema'), groupPeriodicSyncControl, config),
             api: pluginAPI,
             createContextFactory: ()=>{
                 return (ctx, stores)=>{

package/lib/peer/blob-fetch.d.ts

@@ -1,24 +1,8 @@
+import type { BlobAPI } from '@kubun/plugin-blob-api';
 import type { Fetch } from '@sozai/runtime';
 import type { BlobManifestResult } from '../protocol.js';
 import type { PeerConnection, PeerConnectionRegistry } from './connection-registry.js';
-export type BlobFetchAPI = {
-    getAttachment(attachmentID: string): Promise<{
-        state: string;
-    } | null>;
-    beginFetch(params: {
-        attachmentID: string;
-        chunkSize: number;
-        chunkDigests: Array<Uint8Array>;
-    }): Promise<void>;
-    getPresentChunks(attachmentID: string): Promise<Array<number>>;
-    stageChunk(params: {
-        attachmentID: string;
-        index: number;
-        offset: number;
-        bytes: Uint8Array;
-    }): Promise<void>;
-    completeFetch(attachmentID: string): Promise<void>;
-};
+export type BlobFetchAPI = Pick<BlobAPI, 'getAttachment' | 'beginFetch' | 'getPresentChunks' | 'stageChunk' | 'completeFetch'>;
 export type PeerConnectionLister = {
     list(): Array<PeerConnection>;
 };

package/lib/schema.d.ts

@@ -1,5 +1,20 @@
 import type { SchemaExtension } from '@kubun/engine';
 import { type Logger } from '@kubun/logger';
+import type { AdaptivePolicy } from '@kubun/plugin-workflow-api';
 import { type P2PEventEmitter } from './groups/events.js';
 import type { SyncManager } from './sync/sync-manager.js';
-export declare function createP2PSchemaExtension(emitter: P2PEventEmitter, syncManager: SyncManager, logger?: Logger): SchemaExtension;
+/**
+ * Recurring group catch-up control the GraphQL resolvers call, threaded from the
+ * plugin so they reach the same workflow-backed schedule the runtime API arms.
+ * Results are the workflow plugin's PeriodicSync projection (opaque here).
+ */
+export type GroupPeriodicSyncControl = {
+    enableGroupPeriodicSync(groupID: string, policy?: AdaptivePolicy): Promise<unknown>;
+    disableGroupPeriodicSync(groupID: string): Promise<unknown | null>;
+    getGroupPeriodicSync(groupID: string): Promise<unknown | null>;
+};
+/** Deploy-config the p2p schema extension reads. */
+export type P2PSchemaConfig = {
+    periodicSync?: boolean;
+};
+export declare function createP2PSchemaExtension(emitter: P2PEventEmitter, syncManager: SyncManager, logger?: Logger, control?: GroupPeriodicSyncControl, config?: P2PSchemaConfig): SchemaExtension;

package/lib/schema.js

@@ -760,9 +760,30 @@ extend type Subscription {
   controlRequestSettled(groupID: ID, requestID: ID): ControlRequest!
 }
 `;
-export function createP2PSchemaExtension(emitter, syncManager, logger = getKubunLogger('p2p-schema')) {
+// Recurring-sync control fields, appended only when the deploy opted in. Gated
+// because they reference `PeriodicSync`, defined by the co-deployed workflow
+// plugin — referencing it on a p2p-only graph would fail schema build.
+const periodicSyncSDL = `
+extend type Query {
+  groupPeriodicSync(groupID: ID!): PeriodicSync
+}
+
+extend type Mutation {
+  enableGroupPeriodicSync(groupID: ID!, policy: JSON): PeriodicSync!
+  disableGroupPeriodicSync(groupID: ID!): PeriodicSync
+}
+`;
+export function createP2PSchemaExtension(emitter, syncManager, logger = getKubunLogger('p2p-schema'), control, config) {
+    const periodicSyncEnabled = config?.periodicSync === true && control != null;
+    const periodicSyncQueryFields = periodicSyncEnabled ? {
+        groupPeriodicSync: (_source, args, _context)=>control.getGroupPeriodicSync(args.groupID)
+    } : {};
+    const periodicSyncMutationFields = periodicSyncEnabled ? {
+        enableGroupPeriodicSync: (_source, args, _context)=>control.enableGroupPeriodicSync(args.groupID, args.policy),
+        disableGroupPeriodicSync: (_source, args, _context)=>control.disableGroupPeriodicSync(args.groupID)
+    } : {};
     return {
-        sdl,
+        sdl: periodicSyncEnabled ? sdl + periodicSyncSDL : sdl,
         // These mutations perform network I/O (peer discovery, the MLS dance,
         // merkle sync) and/or apply received mutations in their own per-step
         // transactions. Running them inside `mutateGraph`'s write transaction would
@@ -789,10 +810,20 @@ export function createP2PSchemaExtension(emitter, syncManager, logger = getKubun
             // Waits for its Add commit to land. The lane reads the group's handle on
             // the registry's own connection, so holding a write transaction across
             // that wait deadlocks single-connection SQLite.
-            'requestInviteToGroup'
+            'requestInviteToGroup',
+            // Write the workflow store synchronously and must return the resulting
+            // projection; running them inside `mutateGraph`'s write transaction would
+            // hold the single-connection DB across the workflow-store write and
+            // deadlock (as the connector's enable/disable are declared for the same
+            // reason).
+            ...periodicSyncEnabled ? [
+                'enableGroupPeriodicSync',
+                'disableGroupPeriodicSync'
+            ] : []
         ],
         resolvers: {
             queryFields: {
+                ...periodicSyncQueryFields,
                 groups: async (_source, _args, context)=>{
                     return await requireP2P(context).group.list();
                 },
@@ -875,6 +906,7 @@ export function createP2PSchemaExtension(emitter, syncManager, logger = getKubun
                 }
             },
             mutationFields: {
+                ...periodicSyncMutationFields,
                 connectPeer: async (_source, args, context)=>{
                     const peer = await requireP2P(context).peer.connect(args.url);
                     return {

package/lib/sync/group-sync-workflow.d.ts

@@ -0,0 +1,77 @@
+import type { Logger } from '@kubun/logger';
+import type { AdaptivePolicy, WorkflowOutcome } from '@kubun/plugin-workflow-api';
+import type { P2PEventEmitter } from '../groups/events.js';
+import type { PeerCatchUpData } from '../types.js';
+/** Queue lane (and workflow name) for group catch-up sync. */
+export declare const GROUP_SYNC_WORKFLOW = "group-sync";
+/** How many group catch-up passes may run at once on this peer. */
+export declare const GROUP_SYNC_CONCURRENCY = 4;
+type HandlerContext = {
+    state: Record<string, unknown>;
+    params?: unknown;
+    signal?: AbortSignal;
+};
+type HandlerResult = {
+    status: 'end';
+    state: Record<string, unknown>;
+    outcome?: WorkflowOutcome;
+};
+type GroupSyncHandler = (ctx: HandlerContext) => Promise<HandlerResult>;
+export type GroupSyncWorkflowDefinition = {
+    name: string;
+    initialAction: {
+        name: string;
+    };
+    handlers: Record<string, GroupSyncHandler>;
+};
+/**
+ * Map one catch-up pass to the outcome that paces the next run. A reachable peer
+ * that shipped mutations is productive (`changed`); a reachable peer with nothing
+ * new, or no scope to pull, is `idle`; no peer answered (none known, or none on)
+ * is `offline` so the scheduler backs off. A thrown apply never reaches here —
+ * the engine forces `error` on the failed terminal.
+ */
+export declare function classifyCatchUp(data: PeerCatchUpData): WorkflowOutcome;
+export type GroupSyncWorkflowParams = {
+    catchUpWithBestPeer: (groupID: string) => Promise<PeerCatchUpData>;
+    logger: Logger;
+};
+/**
+ * Build the `group-sync` workflow definition. The single `start` handler runs one
+ * `catchUpWithBestPeer` pass and classifies its result; a genuine throw is left to
+ * propagate so the engine forces the terminal `error` (and its backoff), never
+ * swallowed into a false success.
+ */
+export declare function createGroupSyncWorkflow(params: GroupSyncWorkflowParams): {
+    definition: GroupSyncWorkflowDefinition;
+};
+export type PeriodicSyncArmingAPI = {
+    scheduleAdaptive(name: string, params: unknown, opts: {
+        policy: AdaptivePolicy;
+        subjectKey: string;
+    }): Promise<{
+        id: string;
+    }>;
+    getPeriodicSync(scheduleID: string): Promise<unknown | null>;
+};
+/**
+ * Arm a group's recurring catch-up the first time it is joined — INSERT-IF-ABSENT.
+ * `scheduleAdaptive` is insert-OR-reactivate, so guarding on the existing
+ * projection is what stops a re-join or reboot resurrecting a schedule the user
+ * explicitly disabled. Deliberately the opposite of the explicit enable, which
+ * always (re)activates.
+ */
+export declare function armGroupPeriodicSyncIfAbsent(api: PeriodicSyncArmingAPI, groupID: string, policy: AdaptivePolicy): Promise<void>;
+/**
+ * Subscribe implicit arming to `groupJoined`. The listener is fire-and-forget and
+ * never throws into the emitter (`emit` rethrows listener failures, and this rides
+ * the group-create/join commit): its async work is detached and its failure logged.
+ * Returns the unsubscribe.
+ */
+export declare function wireGroupPeriodicSyncArming(params: {
+    emitter: P2PEventEmitter;
+    getWorkflowAPI: () => Promise<PeriodicSyncArmingAPI | undefined>;
+    policy: AdaptivePolicy;
+    logger: Logger;
+}): () => void;
+export {};

package/lib/sync/group-sync-workflow.js

@@ -0,0 +1,96 @@
+/** Queue lane (and workflow name) for group catch-up sync. */ export const GROUP_SYNC_WORKFLOW = 'group-sync';
+/** How many group catch-up passes may run at once on this peer. */ export const GROUP_SYNC_CONCURRENCY = 4;
+/**
+ * Map one catch-up pass to the outcome that paces the next run. A reachable peer
+ * that shipped mutations is productive (`changed`); a reachable peer with nothing
+ * new, or no scope to pull, is `idle`; no peer answered (none known, or none on)
+ * is `offline` so the scheduler backs off. A thrown apply never reaches here —
+ * the engine forces `error` on the failed terminal.
+ */ export function classifyCatchUp(data) {
+    switch(data.outcome){
+        case 'synced':
+            return data.messagesReceived > 0 ? 'changed' : 'idle';
+        case 'no-scopes':
+            return 'idle';
+        case 'no-candidates':
+        case 'no-route':
+            return 'offline';
+    }
+}
+/**
+ * Build the `group-sync` workflow definition. The single `start` handler runs one
+ * `catchUpWithBestPeer` pass and classifies its result; a genuine throw is left to
+ * propagate so the engine forces the terminal `error` (and its backoff), never
+ * swallowed into a false success.
+ */ export function createGroupSyncWorkflow(params) {
+    const { catchUpWithBestPeer, logger } = params;
+    const start = async (ctx)=>{
+        const { groupID } = ctx.params;
+        const data = await catchUpWithBestPeer(groupID);
+        const outcome = classifyCatchUp(data);
+        logger.debug('group catch-up classified', {
+            groupID,
+            outcome,
+            peerDID: data.peerDID
+        });
+        return {
+            status: 'end',
+            state: {
+                groupID
+            },
+            outcome
+        };
+    };
+    return {
+        definition: {
+            name: GROUP_SYNC_WORKFLOW,
+            initialAction: {
+                name: 'start'
+            },
+            handlers: {
+                start
+            }
+        }
+    };
+}
+/**
+ * Arm a group's recurring catch-up the first time it is joined — INSERT-IF-ABSENT.
+ * `scheduleAdaptive` is insert-OR-reactivate, so guarding on the existing
+ * projection is what stops a re-join or reboot resurrecting a schedule the user
+ * explicitly disabled. Deliberately the opposite of the explicit enable, which
+ * always (re)activates.
+ */ export async function armGroupPeriodicSyncIfAbsent(api, groupID, policy) {
+    const id = `${GROUP_SYNC_WORKFLOW}:${groupID}`;
+    if (await api.getPeriodicSync(id) == null) {
+        await api.scheduleAdaptive(GROUP_SYNC_WORKFLOW, {
+            groupID
+        }, {
+            policy,
+            subjectKey: groupID
+        });
+    }
+}
+/**
+ * Subscribe implicit arming to `groupJoined`. The listener is fire-and-forget and
+ * never throws into the emitter (`emit` rethrows listener failures, and this rides
+ * the group-create/join commit): its async work is detached and its failure logged.
+ * Returns the unsubscribe.
+ */ export function wireGroupPeriodicSyncArming(params) {
+    const { emitter, getWorkflowAPI, policy, logger } = params;
+    return emitter.on('groupJoined', (groupData)=>{
+        void (async ()=>{
+            try {
+                const api = await getWorkflowAPI();
+                if (api == null) {
+                    return;
+                }
+                await armGroupPeriodicSyncIfAbsent(api, groupData.id, policy);
+            } catch (error) {
+                logger.error('implicit group periodic-sync arm failed', {
+                    groupID: groupData.id,
+                    error
+                });
+            }
+        })();
+    });
+}

package/lib/types.d.ts

@@ -1,5 +1,5 @@
 import type { ClientTransportOf } from '@enkaku/protocol';
-import type { SignedEvent } from '@kokuin/controller';
+import type { AdaptivePolicy } from '@kubun/plugin-workflow-api';
 import type { AccessLevel } from '@kubun/store-graph';
 import type { ControlRequestKind, ControlRequestOutcome } from '@kubun/store-p2p';
 import type { PeerAvailability, PeerCapability } from './groups/group-protocols.js';
@@ -1030,11 +1030,14 @@ export type SyncPluginAPI = {
         delegationTokens?: Array<string>;
     }): Promise<void>;
     /**
-     * Pull a `did:kokuin:` controller's key-event log from a connected group peer
-     * that holds it, over `controller/get-log`. The engine calls this on a
-     * verify-time controller-store miss; the events self-authenticate, so the
-     * caller's resolver folds + verifies them. `undefined` when no connected peer
-     * answers with a non-empty log.
+     * Recurring group catch-up control. The result is the workflow plugin's
+     * PeriodicSync projection (opaque here); each needs the workflow API and throws
+     * when it is absent (a local-only device has no scheduler). Subject is the
+     * groupID — group writes are group-scoped and engine-signed, so no viewer.
+     * `enableGroupPeriodicSync` always (re)activates; the implicit `groupJoined`
+     * arming is insert-if-absent so it cannot resurrect a deliberately disabled one.
      */
-    fetchControllerLog(did: string): Promise<Array<SignedEvent> | undefined>;
+    enableGroupPeriodicSync(groupID: string, policy?: AdaptivePolicy): Promise<unknown>;
+    disableGroupPeriodicSync(groupID: string): Promise<unknown | null>;
+    getGroupPeriodicSync(groupID: string): Promise<unknown | null>;
 };

package/lib/util/handler-error.d.ts

@@ -3,14 +3,17 @@
  * `KubunErrorCode`, so `HandlerError.from` in `@enkaku/server` passes it through
  * instead of flattening it to `EK01` / "Handler execution failed".
  *
- * Anything else is returned unchanged, and that default is the security
- * property: an error with no registered code is internal, and its message may
- * carry DIDs, paths, or SQL. Forwarding a refusal is safe only because the
- * throw site attached a code the registry allows to leave the device.
+ * The `GraphQLError` case is graph-specific (its code lives in `extensions.code`
+ * and needs `graphql`), so it stays here; every other case delegates to the
+ * canonical, security-sensitive core in `@kubun/protocol`. That default — an
+ * error with no registered code is internal and stays opaque, since its message
+ * may carry DIDs, paths, or SQL — is defined in ONE place across both plugins.
  */
 export declare function toHandlerError(cause: unknown): unknown;
 /**
  * Applies {@link toHandlerError} to every handler in a procedure record, so the
- * translation lives in one place rather than in each handler.
+ * translation lives in one place rather than in each handler. Kept local because
+ * it must route through the GraphQL-aware {@link toHandlerError} above, not the
+ * plain protocol core.
  */
 export declare function wrapHandlers(handlers: Record<string, unknown>): Record<string, unknown>;

package/lib/util/handler-error.js

@@ -1,22 +1,17 @@
 import { HandlerError } from '@enkaku/server';
-import { isKubunErrorCode } from '@kubun/protocol';
+import { isKubunErrorCode, toHandlerError as protocolToHandlerError } from '@kubun/protocol';
 import { GraphQLError } from 'graphql';
-function isObject(value) {
-    return typeof value === 'object' && value != null && !Array.isArray(value);
-}
 /**
  * Translates a thrown value into a `HandlerError` when it carries a registered
  * `KubunErrorCode`, so `HandlerError.from` in `@enkaku/server` passes it through
  * instead of flattening it to `EK01` / "Handler execution failed".
  *
- * Anything else is returned unchanged, and that default is the security
- * property: an error with no registered code is internal, and its message may
- * carry DIDs, paths, or SQL. Forwarding a refusal is safe only because the
- * throw site attached a code the registry allows to leave the device.
+ * The `GraphQLError` case is graph-specific (its code lives in `extensions.code`
+ * and needs `graphql`), so it stays here; every other case delegates to the
+ * canonical, security-sensitive core in `@kubun/protocol`. That default — an
+ * error with no registered code is internal and stays opaque, since its message
+ * may carry DIDs, paths, or SQL — is defined in ONE place across both plugins.
  */ export function toHandlerError(cause) {
-    if (cause instanceof HandlerError) {
-        return cause;
-    }
     if (cause instanceof GraphQLError) {
         const { code, ...data } = cause.extensions;
         return isKubunErrorCode(code) ? new HandlerError({
@@ -26,21 +21,13 @@ function isObject(value) {
             cause
         }) : cause;
     }
-    if (isObject(cause) && isKubunErrorCode(cause.code)) {
-        const message = typeof cause.message === 'string' ? cause.message : undefined;
-        const data = isObject(cause.data) ? cause.data : {};
-        return new HandlerError({
-            code: cause.code,
-            message,
-            data,
-            cause
-        });
-    }
-    return cause;
+    return protocolToHandlerError(cause);
 }
 /**
  * Applies {@link toHandlerError} to every handler in a procedure record, so the
- * translation lives in one place rather than in each handler.
+ * translation lives in one place rather than in each handler. Kept local because
+ * it must route through the GraphQL-aware {@link toHandlerError} above, not the
+ * plain protocol core.
  */ export function wrapHandlers(handlers) {
     return Object.fromEntries(Object.entries(handlers).map(([name, handler])=>{
         if (typeof handler !== 'function') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/plugin-p2p",
-  "version": "0.13.1",
+  "version": "0.14.0",
   "license": "see LICENSE.md",
   "sideEffects": false,
   "type": "module",
@@ -23,6 +23,27 @@
     "@kokuin/capability": "^0.3.0",
     "@kokuin/controller": "^0.1.0",
     "@kokuin/token": "^0.5.0",
+    "@kubun/credential": "^0.14.0",
+    "@kubun/db": "^0.14.0",
+    "@kubun/db-adapter": "^0.14.0",
+    "@kubun/engine": "^0.14.0",
+    "@kubun/graphql": "^0.14.0",
+    "@kubun/hlc": "^0.14.0",
+    "@kubun/http-util": "^0.14.0",
+    "@kubun/id": "^0.14.0",
+    "@kubun/logger": "^0.14.0",
+    "@kubun/mutation": "^0.14.0",
+    "@kubun/plugin-blob-api": "^0.14.0",
+    "@kubun/plugin-http": "^0.14.0",
+    "@kubun/plugin-http-api": "^0.14.0",
+    "@kubun/plugin-workflow-api": "^0.14.0",
+    "@kubun/protocol": "^0.14.0",
+    "@kubun/store-blob": "^0.14.0",
+    "@kubun/store-controller": "^0.14.0",
+    "@kubun/store-credential": "^0.14.0",
+    "@kubun/store-delegation": "^0.14.0",
+    "@kubun/store-graph": "^0.14.0",
+    "@kubun/store-p2p": "^0.14.0",
     "@kumiai/broadcast": "^0.7.0",
     "@kumiai/hub-protocol": "^0.7.0",
     "@kumiai/hub-server": "^0.7.0",
@@ -41,43 +62,26 @@
     "@sozai/stream": "^0.2.0",
     "graphql": "^16.14.2",
     "kysely": "^0.29.5",
-    "ts-mls": "2.0.0-rc.13",
-    "@kubun/credential": "^0.13.0",
-    "@kubun/db-adapter": "^0.13.1",
-    "@kubun/db": "^0.13.0",
-    "@kubun/id": "^0.13.0",
-    "@kubun/graphql": "^0.13.1",
-    "@kubun/http-util": "^0.13.0",
-    "@kubun/mutation": "^0.13.0",
-    "@kubun/hlc": "^0.13.0",
-    "@kubun/plugin-http": "^0.13.2",
-    "@kubun/store-blob": "^0.13.0",
-    "@kubun/logger": "^0.13.0",
-    "@kubun/plugin-rpc": "^0.13.2",
-    "@kubun/store-controller": "^0.13.0",
-    "@kubun/engine": "^0.13.1",
-    "@kubun/store-p2p": "^0.13.0",
-    "@kubun/protocol": "^0.13.1",
-    "@kubun/store-credential": "^0.13.0",
-    "@kubun/store-delegation": "^0.13.0",
-    "@kubun/store-graph": "^0.13.2"
+    "ts-mls": "2.0.0-rc.13"
   },
   "devDependencies": {
+    "@kubun/blob-backend": "^0.14.0",
+    "@kubun/client": "^0.14.0",
+    "@kubun/db-better-sqlite": "^0.14.0",
+    "@kubun/db-node-sqlite": "^0.14.0",
+    "@kubun/db-postgres": "^0.14.0",
+    "@kubun/hub": "^0.14.0",
+    "@kubun/plugin-blob": "^0.14.0",
+    "@kubun/plugin-connector": "^0.14.0",
+    "@kubun/plugin-service-server": "^0.14.0",
+    "@kubun/plugin-workflow": "^0.14.0",
+    "@kubun/service-graph-api": "^0.14.0",
+    "@kubun/store-workflow": "^0.14.0",
+    "@kubun/test-utils": "^0.13.0",
     "@kumiai/hub-conformance": "^0.7.0",
     "@kumiai/rpc-conformance": "^0.7.0",
     "@testcontainers/postgresql": "^12.1.0",
-    "get-port": "^7.2.0",
-    "@kubun/blob-backend": "^0.13.0",
-    "@kubun/client": "^0.13.0",
-    "@kubun/db-node-sqlite": "^0.13.0",
-    "@kubun/db-better-sqlite": "^0.13.0",
-    "@kubun/db-postgres": "^0.13.0",
-    "@kubun/hub": "^0.13.0",
-    "@kubun/plugin-blob": "^0.13.0",
-    "@kubun/plugin-connector": "^0.13.1",
-    "@kubun/test-utils": "^0.13.0",
-    "@kubun/plugin-workflow": "^0.13.0",
-    "@kubun/store-workflow": "^0.13.0"
+    "get-port": "^7.2.0"
   },
   "publishConfig": {
     "access": "public"