@kubun/plugin-p2p 0.15.0 → 0.15.1

package/lib/groups/did-cache-seed.d.ts

@@ -0,0 +1,26 @@
+import { type DIDCache } from '@kokuin/token';
+import type { StoreProvider } from '@kubun/db';
+import type { Logger } from '@kubun/logger';
+import type { GroupHandleRegistry } from './group-handle-registry.js';
+export type SeedDIDCacheParams = {
+    cache: DIDCache;
+    registry: GroupHandleRegistry;
+    groupID: string;
+    stores?: StoreProvider;
+    logger?: Logger;
+};
+/**
+ * Seed the shared DID cache with every `did:peer:4` co-member's document, read
+ * off the MLS roster's authenticated leaf long forms.
+ *
+ * A co-member's short-form `iss` on a peer-lane token carries no document, so a
+ * freshly-spawned tunnel/sync Server cannot resolve it without this. The roster
+ * leaf is the one authenticated source of the long form — the membership row
+ * holds only the normalized short form, which carries none.
+ *
+ * Monotonic and idempotent: a peer:4 doc is content-addressed, so re-seeding an
+ * existing entry is a no-op and a departed member's lingering doc is harmless
+ * (per-scope authorization gates access downstream, not cache presence). So the
+ * membership-change seam only ever adds, never evicts.
+ */
+export declare function seedDIDCacheFromRoster(params: SeedDIDCacheParams): Promise<void>;

package/lib/groups/did-cache-seed.js

@@ -0,0 +1,38 @@
+import { decodePeer4, isPeer4 } from '@kokuin/token';
+/**
+ * Seed the shared DID cache with every `did:peer:4` co-member's document, read
+ * off the MLS roster's authenticated leaf long forms.
+ *
+ * A co-member's short-form `iss` on a peer-lane token carries no document, so a
+ * freshly-spawned tunnel/sync Server cannot resolve it without this. The roster
+ * leaf is the one authenticated source of the long form — the membership row
+ * holds only the normalized short form, which carries none.
+ *
+ * Monotonic and idempotent: a peer:4 doc is content-addressed, so re-seeding an
+ * existing entry is a no-op and a departed member's lingering doc is harmless
+ * (per-scope authorization gates access downstream, not cache presence). So the
+ * membership-change seam only ever adds, never evicts.
+ */ export async function seedDIDCacheFromRoster(params) {
+    const { cache, registry, groupID, stores, logger } = params;
+    const members = await registry.readHandle(groupID, (handle)=>handle.listMembers(), stores == null ? undefined : {
+        stores
+    });
+    for (const member of members){
+        // did:key members resolve natively; only a genuine peer:4 long form (≠ the
+        // short-form `id`) carries a document worth caching.
+        if (!isPeer4(member.longForm) || member.longForm === member.id) {
+            continue;
+        }
+        try {
+            const { shortForm, doc } = decodePeer4(member.longForm);
+            await cache.set(shortForm, doc);
+        } catch (error) {
+            // A single unparseable leaf must not abort seeding the rest of the roster.
+            logger?.warn('did-cache roster seed skipped a member', {
+                groupID,
+                id: member.id,
+                error
+            });
+        }
+    }
+}

package/lib/groups/group-peer-manager.d.ts

@@ -1,5 +1,5 @@
 import type { ProcedureHandlers } from '@enkaku/server';
-import type { OwnIdentity } from '@kokuin/token';
+import type { DIDCache, OwnIdentity } from '@kokuin/token';
 import type { StoreProvider } from '@kubun/db';
 import type { DefaultAccessLevel, GraphInternals } from '@kubun/engine';
 import type { HLC } from '@kubun/hlc';
@@ -132,6 +132,12 @@ export type GroupPeerManagerParams = {
     serviceServe?: ServeService;
     /** Which services to serve on an inbound service-lane session. */
     services?: Record<string, ServiceConfig>;
+    /**
+     * Shared, plugin-lifetime DID cache forwarded to the sync- and service-tunnel
+     * listeners, which seed it from each group's roster and hand it to every
+     * spawned session's Server (see {@link TunnelListenersParams.cache}).
+     */
+    cache?: DIDCache;
     /** @see TunnelListenersParams.idleTimeoutMs */
     tunnelIdleTimeoutMs?: number;
 };

package/lib/groups/group-peer-manager.js

@@ -913,6 +913,9 @@ export function createGroupPeerManager(params) {
         localDID: params.localDID,
         runtime: tunnelRuntime,
         syncHandlers: params.syncHandlers,
+        ...params.cache != null ? {
+            cache: params.cache
+        } : {},
         tunnelHub: (groupID)=>{
             const hubURL = bindings.get(groupID)?.values().next().value;
             return hubURL == null ? undefined : getHubLike(hubURL);
@@ -932,6 +935,9 @@ export function createGroupPeerManager(params) {
         runtime: tunnelRuntime,
         serve: params.serviceServe,
         services: params.services,
+        ...params.cache != null ? {
+            cache: params.cache
+        } : {},
         tunnelHub: (groupID)=>{
             const hubURL = bindings.get(groupID)?.values().next().value;
             return hubURL == null ? undefined : getHubLike(hubURL);

package/lib/hub/http-client.js

@@ -9,7 +9,12 @@ export function createHTTPHubClient(params) {
         return new Client({
             transport,
             identity: params.identity,
-            serverID: opts?.serverID ?? params.serverID
+            serverID: opts?.serverID ?? params.serverID,
+            // The hub is a blind relay: no MLS roster, and a `Server` whose DID cache
+            // cannot be relied on across this client's reconnect churn. Embed the long
+            // form on every hub-facing token so a `did:peer:4` device's short-form
+            // `iss` self-resolves at the hub instead of throwing `Unknown DID`.
+            embedLongForm: true
         });
     };
 }

package/lib/hub/hub-like.js

@@ -1,5 +1,6 @@
 import { RequestError } from '@enkaku/client';
 import { ErrorCodes } from '@enkaku/protocol';
+import { normalizeDID } from '@kokuin/token';
 import { hubErrorFromCode, RetentionExceededError } from '@kumiai/hub-protocol';
 import { fromB64, toB64 } from '@sozai/codec';
 import { EventEmitter } from '@sozai/event';
@@ -79,14 +80,16 @@ function rethrowHubError(error) {
     #senderDID;
     #topicID;
     constructor(options){
-        this.#senderDID = options?.senderDID;
+        // Canonicalize the scope so a peer:4 sender attested by its long form (an
+        // embed-long-form hub client) still matches its short-form route DID.
+        this.#senderDID = options?.senderDID == null ? undefined : normalizeDID(options.senderDID);
         this.#topicID = options?.topicID;
     }
     push(message) {
         if (this.#stopped) {
             return;
         }
-        if (this.#senderDID != null && message.senderDID !== this.#senderDID) {
+        if (this.#senderDID != null && normalizeDID(message.senderDID) !== this.#senderDID) {
             return;
         }
         if (this.#topicID != null && message.topicID !== this.#topicID) {

package/lib/hub/peer-scoped-hub-view.d.ts

@@ -25,6 +25,12 @@ export type PeerScopedHubViewParams = {
  * MLS-authenticated identity. That is enough: the filter routes, MLS still
  * authorizes, and a hostile hub could only hide frames it can already drop.
  *
+ * Both sides are normalized before the match: a `did:peer:4` publisher whose hub
+ * client embeds the long form is attested by its long form, while `peerDID` is
+ * the roster's short form — a raw `===` would drop every such frame, and its
+ * request would vanish with no error (the exact failure this filter is meant to
+ * prevent for the OTHER peer's frames).
+ *
  * **`unsubscribe` is dropped.** The responder topic belongs to the (group,
  * epoch), not to a session: every listener on the device shares it, one per
  * co-member, and each respawns independently — so a departing transport must not

package/lib/hub/peer-scoped-hub-view.js

@@ -1,3 +1,4 @@
+import { normalizeDID } from '@kokuin/token';
 /**
  * A view over one device's hub that surfaces only the frames one peer sent.
  *
@@ -18,6 +19,12 @@
  * MLS-authenticated identity. That is enough: the filter routes, MLS still
  * authorizes, and a hostile hub could only hide frames it can already drop.
  *
+ * Both sides are normalized before the match: a `did:peer:4` publisher whose hub
+ * client embeds the long form is attested by its long form, while `peerDID` is
+ * the roster's short form — a raw `===` would drop every such frame, and its
+ * request would vanish with no error (the exact failure this filter is meant to
+ * prevent for the OTHER peer's frames).
+ *
  * **`unsubscribe` is dropped.** The responder topic belongs to the (group,
  * epoch), not to a session: every listener on the device shares it, one per
  * co-member, and each respawns independently — so a departing transport must not
@@ -26,6 +33,9 @@
  * therefore issued once per topic and held for the life of the view.
  */ export function createPeerScopedHubView({ hub, peerDID }) {
     const armed = new Set();
+    // Match on the canonical form so a peer:4 sender attested by its long form
+    // (an embed-long-form hub client) still routes to its short-form roster entry.
+    const scopedDID = normalizeDID(peerDID);
     const view = {
         publish: (params)=>hub.publish(params),
         subscribe: async (subscriberDID, topicID, options)=>{
@@ -58,7 +68,7 @@
                                 done: true
                             };
                         }
-                        if (result.value.senderDID === peerDID) {
+                        if (normalizeDID(result.value.senderDID) === scopedDID) {
                             return result;
                         }
                     }

package/lib/hub/wiring.d.ts

@@ -1,6 +1,6 @@
 import type { ClientTransportOf } from '@enkaku/protocol';
 import type { ProcedureHandlers } from '@enkaku/server';
-import type { OwnIdentity } from '@kokuin/token';
+import type { DIDCache, OwnIdentity } from '@kokuin/token';
 import type { KubunDB } from '@kubun/db';
 import type { DefaultAccessLevel, GraphInternals } from '@kubun/engine';
 import type { HLC } from '@kubun/hlc';
@@ -154,5 +154,11 @@ export type SetupHubRelayParams = {
     serviceServe?: ServeService;
     /** Which services to serve on an inbound service-lane session. */
     services?: Record<string, ServiceConfig>;
+    /**
+     * Shared, plugin-lifetime DID cache forwarded to the group peer manager's
+     * tunnel listeners so a co-member's short-form `did:peer:4` issuer resolves on
+     * a spawned session's Server.
+     */
+    cache?: DIDCache;
 };
 export declare function setupHubRelay(params: SetupHubRelayParams): HubWiring;

package/lib/hub/wiring.js

@@ -117,6 +117,9 @@ export function setupHubRelay(params) {
             ...params.services != null ? {
                 services: params.services
             } : {},
+            ...params.cache != null ? {
+                cache: params.cache
+            } : {},
             tunnelIdleTimeoutMs: tunnelIdleTimeoutMs ?? DEFAULT_TUNNEL_IDLE_TIMEOUT_MS
         });
         unsubscribes.push(emitter.on('groupJoined', (group)=>manager.addGroup(group.id).catch((error)=>{

package/lib/index.js

@@ -1,7 +1,7 @@
 import { ServerTransport } from '@enkaku/http-serve';
 import { Server } from '@enkaku/server';
 import { DirectTransports } from '@enkaku/transport';
-import { isFullIdentity } from '@kokuin/token';
+import { createInMemoryDIDCache, isFullIdentity } from '@kokuin/token';
 import { createDeviceAuthority } from '@kubun/credential';
 import { resolveAllowedOrigin } from '@kubun/http-util';
 import { getGraphStore } from '@kubun/store-graph';
@@ -199,6 +199,13 @@ export function createP2PPlugin(options) {
         const peerConnections = new PeerConnectionRegistry({
             logger: params.getLogger('peer-connections')
         });
+        // One plugin-lifetime DID cache, shared by every peer-lane Server. The
+        // tunnel listeners seed it from each group's MLS roster (a co-member's
+        // authenticated leaf long form), so a freshly-spawned per-session Server
+        // resolves a co-member's short-form `did:peer:4` issuer instead of defaulting
+        // its own empty cache. Content-addressed and monotonic — a stale entry is
+        // harmless, and it survives no process restart by design (re-seeded on bind).
+        const didCache = createInMemoryDIDCache();
         // The p2p plugin manages its own Enkaku server for sync handlers,
         // separate from the graph service's server.
         const syncServers = [];
@@ -222,6 +229,7 @@ export function createP2PPlugin(options) {
                 transports: [
                     directTransports.server
                 ],
+                cache: didCache,
                 signal
             });
             syncServers.push(server);
@@ -324,7 +332,9 @@ export function createP2PPlugin(options) {
             ...serviceServe != null ? {
                 serviceServe,
                 services: serviceConfig
-            } : {}
+            } : {},
+            // The shared roster-seeded cache reaches the tunnel listeners here.
+            cache: didCache
         });
         // Turn a `tunnel://<groupID>/<peerDID>` route into a live session over the
         // group's hub. Until this existed the scheme parsed and then failed at
@@ -629,7 +639,8 @@ export function createP2PPlugin(options) {
                     logger: params.getLogger('sync-http-server'),
                     transports: [
                         httpSyncTransport
-                    ]
+                    ],
+                    cache: didCache
                 });
                 syncServers.push(httpSyncServer);
                 httpAPI.registerProtocol(protocolName, httpSyncTransport.fetch.bind(httpSyncTransport));
@@ -672,7 +683,8 @@ export function createP2PPlugin(options) {
                     logger: params.getLogger('peer-http-server'),
                     transports: [
                         httpPeerTransport
-                    ]
+                    ],
+                    cache: didCache
                 });
                 httpAPI.registerProtocol('peer', httpPeerTransport.fetch.bind(httpPeerTransport));
             })();

package/lib/sync/hub-tunnel-service-listener.d.ts

@@ -1,5 +1,6 @@
 import type { ServerTransportOf } from '@enkaku/protocol';
 import type { Server } from '@enkaku/server';
+import type { DIDCache } from '@kokuin/token';
 import type { Logger } from '@kubun/logger';
 import type { ServiceConfig, ServiceProtocol } from '@kubun/plugin-service-api';
 import { type MailboxHub } from '@kumiai/hub-tunnel';
@@ -16,6 +17,8 @@ export type ServeService = (params: {
     transport: ServerTransportOf<ServiceProtocol>;
     services: Record<string, ServiceConfig>;
     requireAuth?: false;
+    /** Shared, roster-seeded DID cache forwarded to the served Server. */
+    cache?: DIDCache;
 }) => Server<ServiceProtocol>;
 /**
  * The injected {@link ServeService} was called before the `service-server`
@@ -55,6 +58,12 @@ export type HubTunnelServiceListenerParams = {
     serve: ServeService;
     /** Which services to serve, forwarded verbatim to {@link serve} on every spawn. */
     services: Record<string, ServiceConfig>;
+    /**
+     * Shared, roster-seeded DID cache forwarded to {@link serve} on every spawn,
+     * so a co-member's short-form `did:peer:4` issuer resolves on the served
+     * Server.
+     */
+    cache?: DIDCache;
     idleTimeoutMs?: number;
     logger?: Logger;
 };

package/lib/sync/hub-tunnel-service-listener.js

@@ -40,6 +40,7 @@ import { SERVICE_TUNNEL_PROTOCOL, tunnelTopic } from './tunnel-topics.js';
     #runtime;
     #serve;
     #services;
+    #cache;
     #idleTimeoutMs;
     #logger;
     #started = false;
@@ -64,6 +65,7 @@ import { SERVICE_TUNNEL_PROTOCOL, tunnelTopic } from './tunnel-topics.js';
         this.#runtime = params.runtime;
         this.#serve = params.serve;
         this.#services = params.services;
+        this.#cache = params.cache;
         this.#idleTimeoutMs = params.idleTimeoutMs;
         this.#logger = params.logger;
     }
@@ -225,7 +227,10 @@ import { SERVICE_TUNNEL_PROTOCOL, tunnelTopic } from './tunnel-topics.js';
         try {
             server = this.#serve({
                 transport,
-                services: this.#services
+                services: this.#services,
+                ...this.#cache != null ? {
+                    cache: this.#cache
+                } : {}
             });
         } catch (error) {
             await transport.dispose().catch(()=>{

package/lib/sync/hub-tunnel-sync-listener.d.ts

@@ -1,5 +1,5 @@
 import { type ProcedureHandlers } from '@enkaku/server';
-import type { OwnIdentity } from '@kokuin/token';
+import type { DIDCache, OwnIdentity } from '@kokuin/token';
 import type { Logger } from '@kubun/logger';
 import { type MailboxHub, type ObservabilityEventListener } from '@kumiai/hub-tunnel';
 import type { Runtime } from '@sozai/runtime';
@@ -26,6 +26,13 @@ export type HubTunnelSyncListenerParams = {
      * keeps one generator across the whole plugin.
      */
     runtime: Runtime;
+    /**
+     * Shared, roster-seeded DID cache handed to every spawned session's Server, so
+     * a co-member's short-form `did:peer:4` issuer resolves without a resolver the
+     * blind hub lane has none of. A fresh per-session Server would otherwise
+     * default its own empty cache.
+     */
+    cache?: DIDCache;
     idleTimeoutMs?: number;
     reconnectTimeoutMs?: number;
     inboxCapacity?: number;

package/lib/sync/hub-tunnel-sync-listener.js

@@ -15,6 +15,7 @@ export class HubTunnelSyncListener {
     #identity;
     #syncHandlers;
     #runtime;
+    #cache;
     #idleTimeoutMs;
     #reconnectTimeoutMs;
     #inboxCapacity;
@@ -42,6 +43,7 @@ export class HubTunnelSyncListener {
         this.#identity = params.identity;
         this.#syncHandlers = params.syncHandlers;
         this.#runtime = params.runtime;
+        this.#cache = params.cache;
         this.#idleTimeoutMs = params.idleTimeoutMs;
         this.#reconnectTimeoutMs = params.reconnectTimeoutMs;
         this.#inboxCapacity = params.inboxCapacity;
@@ -203,7 +205,10 @@ export class HubTunnelSyncListener {
             },
             transports: [
                 transport
-            ]
+            ],
+            ...this.#cache != null ? {
+                cache: this.#cache
+            } : {}
         });
         const session = {
             transport,

package/lib/sync/service-tunnel-listeners.d.ts

@@ -1,4 +1,4 @@
-import type { OwnIdentity } from '@kokuin/token';
+import type { DIDCache, OwnIdentity } from '@kokuin/token';
 import type { StoreProvider } from '@kubun/db';
 import type { Logger } from '@kubun/logger';
 import type { ServiceConfig } from '@kubun/plugin-service-api';
@@ -17,6 +17,12 @@ export type ServiceTunnelListenersParams = {
     serve: ServeService;
     /** Which services to serve, forwarded verbatim to `serve` on every spawn. */
     services: Record<string, ServiceConfig>;
+    /**
+     * Shared, plugin-lifetime DID cache. Seeded from each group's roster on every
+     * reconcile and forwarded to `serve` on every spawn, so a co-member's
+     * short-form `did:peer:4` issuer resolves on the served Server.
+     */
+    cache?: DIDCache;
     /** The group's device-wide drain, or `undefined` when no hub is bound. */
     tunnelHub: (groupID: string) => MailboxHub | undefined;
     logger?: Logger;

package/lib/sync/service-tunnel-listeners.js

@@ -1,5 +1,6 @@
 import { normalizeDID } from '@kokuin/token';
 import { getP2PStore } from '@kubun/store-p2p';
+import { seedDIDCacheFromRoster } from '../groups/did-cache-seed.js';
 import { HubTunnelServiceListener } from './hub-tunnel-service-listener.js';
 /**
  * The answering half of the service tunnel — one `HubTunnelServiceListener` per
@@ -63,6 +64,20 @@ import { HubTunnelServiceListener } from './hub-tunnel-service-listener.js';
         }
         attachedHubs.set(groupID, hub);
         attachedEpochs.set(groupID, epoch);
+        // Bind and membership change both land here, so this is the one seam where a
+        // co-member's roster long form is refreshed into the shared cache before any
+        // service session that must resolve its short-form issuer can spawn.
+        if (params.cache != null) {
+            await seedDIDCacheFromRoster({
+                cache: params.cache,
+                registry: params.registry,
+                groupID,
+                stores: params.stores,
+                ...logger != null ? {
+                    logger
+                } : {}
+            });
+        }
         const members = await store.listGroupMembers(groupID);
         const wanted = new Set(members.map((member)=>normalizeDID(member.member_did)).filter((did)=>did !== selfDID));
         let group = listeners.get(groupID);
@@ -105,6 +120,9 @@ import { HubTunnelServiceListener } from './hub-tunnel-service-listener.js';
                 runtime: params.runtime,
                 serve: params.serve,
                 services: params.services,
+                ...params.cache != null ? {
+                    cache: params.cache
+                } : {},
                 ...params.idleTimeoutMs != null ? {
                     idleTimeoutMs: params.idleTimeoutMs
                 } : {},

package/lib/sync/tunnel-listeners.d.ts

@@ -1,5 +1,5 @@
 import type { ProcedureHandlers } from '@enkaku/server';
-import type { OwnIdentity } from '@kokuin/token';
+import type { DIDCache, OwnIdentity } from '@kokuin/token';
 import type { StoreProvider } from '@kubun/db';
 import type { Logger } from '@kubun/logger';
 import type { MailboxHub } from '@kumiai/hub-tunnel';
@@ -13,6 +13,12 @@ export type TunnelListenersParams = {
     localDID: string;
     runtime: Runtime;
     syncHandlers: ProcedureHandlers<SyncProtocol>;
+    /**
+     * Shared, plugin-lifetime DID cache. Seeded from each group's roster on every
+     * reconcile (bind and membership change) and handed to every spawned session's
+     * Server, so a co-member's short-form `did:peer:4` issuer resolves there.
+     */
+    cache?: DIDCache;
     /** The group's device-wide drain, or `undefined` when no hub is bound. */
     tunnelHub: (groupID: string) => MailboxHub | undefined;
     logger?: Logger;

package/lib/sync/tunnel-listeners.js

@@ -1,5 +1,6 @@
 import { normalizeDID } from '@kokuin/token';
 import { getP2PStore } from '@kubun/store-p2p';
+import { seedDIDCacheFromRoster } from '../groups/did-cache-seed.js';
 import { HubTunnelSyncListener } from './hub-tunnel-sync-listener.js';
 /**
  * The answering half of the tunnel: one listener per co-member per group, so a
@@ -73,6 +74,20 @@ import { HubTunnelSyncListener } from './hub-tunnel-sync-listener.js';
         }
         attachedHubs.set(groupID, hub);
         attachedEpochs.set(groupID, epoch);
+        // Bind and membership change both land here, so this is the one seam where a
+        // co-member's roster long form is refreshed into the shared cache before any
+        // session that must resolve its short-form issuer can spawn.
+        if (params.cache != null) {
+            await seedDIDCacheFromRoster({
+                cache: params.cache,
+                registry: params.registry,
+                groupID,
+                stores: params.stores,
+                ...logger != null ? {
+                    logger
+                } : {}
+            });
+        }
         const members = await store.listGroupMembers(groupID);
         const wanted = new Set(members.map((member)=>normalizeDID(member.member_did)).filter((did)=>did !== selfDID));
         let group = listeners.get(groupID);
@@ -115,6 +130,9 @@ import { HubTunnelSyncListener } from './hub-tunnel-sync-listener.js';
                 identity: params.identity,
                 syncHandlers: params.syncHandlers,
                 runtime: params.runtime,
+                ...params.cache != null ? {
+                    cache: params.cache
+                } : {},
                 ...params.idleTimeoutMs != null ? {
                     idleTimeoutMs: params.idleTimeoutMs
                 } : {},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/plugin-p2p",
-  "version": "0.15.0",
+  "version": "0.15.1",
   "license": "see LICENSE.md",
   "sideEffects": false,
   "type": "module",
@@ -14,10 +14,10 @@
     "LICENSE.md"
   ],
   "dependencies": {
-    "@enkaku/client": "^0.21.1",
+    "@enkaku/client": "^0.21.2",
     "@enkaku/http-fetch": "^0.21.0",
     "@enkaku/http-serve": "^0.21.0",
-    "@enkaku/protocol": "^0.21.0",
+    "@enkaku/protocol": "^0.21.1",
     "@enkaku/server": "^0.21.2",
     "@enkaku/transport": "^0.21.0",
     "@kokuin/capability": "^0.3.0",
@@ -36,7 +36,7 @@
     "@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.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",
@@ -74,7 +74,7 @@
     "@kubun/hub": "^0.15.0",
     "@kubun/plugin-blob": "^0.15.0",
     "@kubun/plugin-connector": "^0.15.0",
-    "@kubun/plugin-service-server": "^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",