@kumiai/hub-server 0.12.1 → 0.13.0

package/lib/handlers.js

@@ -1,7 +1,7 @@
 import { HandlerError } from '@enkaku/server';
 import { HUB_ERROR_CODES, hubErrorCodeOf, InvalidPayloadError, KeyPackageFetchLimitError, keyPackageDigest, wakeRecipientKeyProblem } from '@kumiai/hub-protocol';
 import { fromB64, toB64 } from '@sozai/codec';
-import { getReporter } from '@sozai/log';
+import { getLogger, getReporter } from '@sozai/log';
 import { createRateLimiter } from './rateLimit.js';
 function normalizeAuthorizeDecision(decision) {
     return typeof decision === 'boolean' ? {
@@ -29,6 +29,11 @@ const reportStoreError = getReporter([
     'kumiai',
     'hub-server'
 ], '@kumiai/hub-server');
+const receiveLogger = getLogger([
+    'kumiai',
+    'hub-server',
+    'receive'
+]);
 /** What the failed operation was about, for the default log line: a DID for the per-recipient
  * methods, a topic for fan-out, nothing for a store-wide purge. */ function subjectOf(event) {
     switch(event.method){
@@ -550,11 +555,22 @@ export function createHandlers(params) {
             // backpressure stalls `writer.write` until `receiveBufferLimit` tears the channel down.
             function waitForRoom(bytes) {
                 if (tornDown || hasRoom(bytes)) return Promise.resolve();
+                receiveLogger.debug('receive window full for {recipientDID}: paused with {frames} frames ({bytes} bytes) unacked', {
+                    recipientDID: clientDID,
+                    frames: inFlight.size,
+                    bytes: inFlightBytes
+                });
                 return new Promise((resolve)=>{
                     let timer;
                     const arm = ()=>{
                         clearTimeout(timer);
                         timer = setTimeout(()=>{
+                            receiveLogger.warn('receive ack timeout for {recipientDID}: released {frames} frames ({bytes} bytes) after {timeoutMs} ms', {
+                                recipientDID: clientDID,
+                                frames: inFlight.size,
+                                bytes: inFlightBytes,
+                                timeoutMs: receiveAckTimeout
+                            });
                             releaseAll();
                             notifyWindow();
                         }, receiveAckTimeout);
@@ -593,13 +609,25 @@ export function createHandlers(params) {
             const done = new Promise((resolve)=>{
                 resolveDone = resolve;
             });
+            function logUnackedFrames() {
+                if (inFlight.size === 0) return;
+                receiveLogger.debug('receive stream ended for {recipientDID} with {frames} frames ({bytes} bytes) unacked', {
+                    recipientDID: clientDID,
+                    frames: inFlight.size,
+                    bytes: inFlightBytes
+                });
+            }
             // Idempotent teardown, shared by every failure and end path. Frames stay pending in the store
             // and redeliver on the next connect (store-and-forward).
             function finish() {
                 if (tornDown) return;
+                logUnackedFrames();
                 tornDown = true;
                 notifyWindow();
-                if (receiveToken != null) registry.releaseReceiveWriter(clientDID, receiveToken);
+                if (receiveToken != null) registry.releaseReceiveWriter({
+                    did: clientDID,
+                    token: receiveToken
+                });
                 registry.unregisterIfIdle(clientDID);
                 reader.cancel().catch(()=>{});
                 writer.abort(new Error('receive channel torn down')).catch(()=>{});
@@ -693,7 +721,11 @@ export function createHandlers(params) {
                 // Binding evicts whatever held the lane: a reconnect means the old connection broke and the
                 // server learns last, so the stale writer must give way to the live one. See
                 // `HubClientRegistry.bindReceiveWriter`.
-                const { token, evicted } = registry.bindReceiveWriter(clientDID, onLive, ()=>endEvicted?.());
+                const { token, evicted } = registry.bindReceiveWriter({
+                    did: clientDID,
+                    writer: onLive,
+                    endReceive: ()=>endEvicted?.()
+                });
                 receiveToken = token;
                 // After the bind, so the lane is never unheld between the two.
                 evicted?.();
@@ -742,9 +774,13 @@ export function createHandlers(params) {
                 }
             } catch (error) {
                 // A synchronous drain error (e.g. store.fetch threw): clean up and reject the handler.
+                if (!tornDown) logUnackedFrames();
                 tornDown = true;
                 notifyWindow();
-                if (receiveToken != null) registry.releaseReceiveWriter(clientDID, receiveToken);
+                if (receiveToken != null) registry.releaseReceiveWriter({
+                    did: clientDID,
+                    token: receiveToken
+                });
                 registry.unregisterIfIdle(clientDID);
                 reader.cancel().catch(()=>{});
                 writer.abort(error).catch(()=>{});

package/lib/hub.d.ts

@@ -1,7 +1,7 @@
 import type { ServerTransportOf } from '@enkaku/protocol';
 import type { AccessRules, ReplayOptions, ResourceLimits, Server } from '@enkaku/server';
 import type { VerifyTokenHook } from '@kokuin/capability';
-import type { Identity } from '@kokuin/token';
+import type { CryptoOptions, Identity } from '@kokuin/token';
 import type { HubProtocol, HubStore, WakeRegistry, WakeSender } from '@kumiai/hub-protocol';
 import { type AuthorizeHook, type HubRateLimits, type HubStoreErrorHook, type KeyPackageFetchLimits } from './handlers.js';
 import { HubClientRegistry } from './registry.js';
@@ -28,7 +28,7 @@ export type HubPurgeOptions = {
 };
 /** Replay settings a host may tune. The hub always enables replay checks and rejects stale tokens. */
 export type HubReplayOptions = Omit<ReplayOptions, 'enabled' | 'rejectStale'>;
-export type CreateHubParams = {
+export type CreateHubParams = CryptoOptions & {
     transport: ServerTransportOf<HubProtocol>;
     store: HubStore;
     /**

package/lib/hub.js

@@ -55,6 +55,7 @@ export function createHub(params) {
         protocol: hubProtocol,
         transport: params.transport,
         identity: params.identity,
+        crypto: params.crypto,
         accessRules: params.accessRules ?? DEFAULT_HUB_ACCESS_RULES,
         verifyToken: params.verifyToken,
         replay: {

package/lib/index.d.ts

@@ -4,6 +4,6 @@ export type { CreateHubParams, HubInstance, HubPurgeOptions, HubReplayOptions }
 export { createHub, DEFAULT_HUB_ACCESS_RULES } from './hub.js';
 export { createMemoryStore, type MemoryStoreOptions } from './memoryStore.js';
 export { createRateLimiter, type RateLimitConfig, type RateLimiter } from './rateLimit.js';
-export type { ClientEntry } from './registry.js';
+export type { ClientEntry, HubClientRegistryBindReceiveWriterParams, HubClientRegistryReleaseReceiveWriterParams, } from './registry.js';
 export { HubClientRegistry } from './registry.js';
 export { createWakeDispatcher, type WakeDispatcher, type WakeDispatcherParams, type WakeNotifyParams, } from './wake.js';

package/lib/registry.d.ts

@@ -7,6 +7,15 @@ export type ClientEntry = {
     /** Identifies the binding, so a channel can only ever release its OWN. */
     token: symbol | null;
 };
+export type HubClientRegistryBindReceiveWriterParams = {
+    did: string;
+    writer: (message: StoredMessage) => void;
+    endReceive: () => void;
+};
+export type HubClientRegistryReleaseReceiveWriterParams = {
+    did: string;
+    token: symbol;
+};
 /**
  * Tracks online clients and their live receive-channel writers. Subscription
  * state is durable in the store, not here — the registry only routes live
@@ -39,12 +48,12 @@ export declare class HubClientRegistry {
      * it. So a release names the binding it is releasing, and one that is no longer current is a
      * no-op.
      */
-    bindReceiveWriter(did: string, writer: (message: StoredMessage) => void, endReceive: () => void): {
+    bindReceiveWriter({ did, writer, endReceive }: HubClientRegistryBindReceiveWriterParams): {
         token: symbol;
         evicted: (() => void) | null;
     };
     /** Clear the binding this token names. A token that is no longer current is a no-op. */
-    releaseReceiveWriter(did: string, token: symbol): void;
+    releaseReceiveWriter({ did, token }: HubClientRegistryReleaseReceiveWriterParams): void;
     getClient(did: string): ClientEntry | undefined;
     isOnline(did: string): boolean;
     isWriterBound(did: string): boolean;

package/lib/registry.js

@@ -47,7 +47,7 @@
    * null the writer the new channel has just bound, leaving the DID online with nothing behind
    * it. So a release names the binding it is releasing, and one that is no longer current is a
    * no-op.
-   */ bindReceiveWriter(did, writer, endReceive) {
+   */ bindReceiveWriter({ did, writer, endReceive }) {
         const entry = this.#clients.get(did);
         if (entry == null) return {
             token: Symbol('unbound'),
@@ -63,7 +63,7 @@
             evicted
         };
     }
-    /** Clear the binding this token names. A token that is no longer current is a no-op. */ releaseReceiveWriter(did, token) {
+    /** Clear the binding this token names. A token that is no longer current is a no-op. */ releaseReceiveWriter({ did, token }) {
         const entry = this.#clients.get(did);
         if (entry == null || entry.token !== token) return;
         entry.sendMessage = null;

package/lib/wake.js

@@ -31,12 +31,15 @@ const DEFAULT_DEBOUNCE_MS = 10_000;
                 const registration = await params.registry.get(did);
                 if (registration == null) return;
                 const body = sealWakeHint({
-                    topicID,
-                    sequenceID,
-                    count
-                }, {
-                    publicKey: fromB64U(registration.publicKey),
-                    authSecret: fromB64U(registration.authSecret)
+                    hint: {
+                        topicID,
+                        sequenceID,
+                        count
+                    },
+                    recipient: {
+                        publicKey: fromB64U(registration.publicKey),
+                        authSecret: fromB64U(registration.authSecret)
+                    }
                 });
                 const verdict = await params.sender.send({
                     registration,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kumiai/hub-server",
-  "version": "0.12.1",
+  "version": "0.13.0",
   "description": "Hub server for Enkaku E2EE group message routing",
   "keywords": [
     "hub",
@@ -25,20 +25,21 @@
     "lib/*"
   ],
   "dependencies": {
-    "@enkaku/protocol": "^0.22.4",
-    "@enkaku/server": "^0.22.4",
-    "@kokuin/capability": "^0.5.2",
-    "@kokuin/token": "^0.6.4",
-    "@kumiai/hub-protocol": "^0.12.0",
+    "@enkaku/protocol": "^0.23.0",
+    "@enkaku/server": "^0.23.0",
+    "@kokuin/capability": "^0.7.0",
+    "@kokuin/token": "^0.7.0",
+    "@kumiai/hub-protocol": "^0.13.0",
     "@sozai/codec": "^0.4.4",
     "@sozai/event": "^0.1.6",
     "@sozai/log": "^0.4.0"
   },
   "devDependencies": {
-    "@enkaku/client": "^0.22.4",
-    "@enkaku/transport": "^0.22.4",
-    "@kumiai/hub-conformance": "^0.12.0",
-    "@kumiai/hub-wake": "^0.12.0"
+    "@enkaku/client": "^0.23.0",
+    "@enkaku/transport": "^0.23.0",
+    "@kokuin/crypto": "^0.7.0",
+    "@kumiai/hub-conformance": "^0.13.0",
+    "@kumiai/hub-wake": "^0.13.0"
   },
   "publishConfig": {
     "access": "public"