@floegence/flowersec-core 0.19.11 → 0.20.0

package/dist/e2ee/secureChannel.js

@@ -14,6 +14,7 @@ export class SecureChannel {
     transport;
     // Maximum allowed bytes per record frame.
     maxRecordBytes;
+    outboundRecordChunkBytes;
     // Upper bound for buffered plaintext in memory.
     maxBufferedBytes;
     // Active encryption keys and nonce prefixes for the current epoch.
@@ -48,6 +49,11 @@ export class SecureChannel {
     constructor(args) {
         this.transport = args.transport;
         this.maxRecordBytes = args.maxRecordBytes;
+        const maxPlain = Math.max(1, maxPlaintextBytes(this.maxRecordBytes));
+        this.outboundRecordChunkBytes = args.outboundRecordChunkBytes ?? Math.min(64 * 1024, maxPlain);
+        if (!Number.isSafeInteger(this.outboundRecordChunkBytes) || this.outboundRecordChunkBytes <= 0 || this.outboundRecordChunkBytes > maxPlain) {
+            throw new RangeError("outboundRecordChunkBytes must be a positive integer within the record plaintext limit");
+        }
         this.maxBufferedBytes = Math.max(0, args.maxBufferedBytes ?? 4 * (1 << 20));
         this.sendKey = args.sendKey;
         this.recvKey = args.recvKey;
@@ -64,13 +70,9 @@ export class SecureChannel {
     }
     // write splits payloads into record-sized chunks and queues them for send.
     async write(plaintext) {
-        const maxPlain = Math.max(1, maxPlaintextBytes(this.maxRecordBytes) || plaintext.length);
-        let off = 0;
-        while (off < plaintext.length) {
-            const chunk = plaintext.slice(off, Math.min(plaintext.length, off + maxPlain));
-            await this.enqueueSend("app", chunk);
-            off += chunk.length;
-        }
+        if (plaintext.length === 0)
+            return;
+        await this.enqueueSend("app", plaintext.slice());
     }
     // read resolves with the next plaintext chunk or throws on errors/close.
     async read() {
@@ -216,8 +218,15 @@ export class SecureChannel {
             try {
                 let frame;
                 if (req.kind === "app") {
-                    const seq = this.reserveSendSeq();
-                    frame = encryptRecord(this.sendKey, this.sendNoncePrefix, RECORD_FLAG_APP, seq, req.payload ?? new Uint8Array(), this.maxRecordBytes);
+                    const payload = req.payload ?? new Uint8Array();
+                    for (let offset = 0; offset < payload.length; offset += this.outboundRecordChunkBytes) {
+                        const chunk = payload.subarray(offset, Math.min(payload.length, offset + this.outboundRecordChunkBytes));
+                        const seq = this.reserveSendSeq();
+                        frame = encryptRecord(this.sendKey, this.sendNoncePrefix, RECORD_FLAG_APP, seq, chunk, this.maxRecordBytes);
+                        await this.transport.writeBinary(frame);
+                    }
+                    req.resolve();
+                    continue;
                 }
                 else if (req.kind === "ping") {
                     const seq = this.reserveSendSeq();

package/dist/facade.d.ts

@@ -12,6 +12,9 @@ export type { ConnectArtifact, CorrelationContext, CorrelationKV, DirectClientCo
 export { assertConnectArtifact } from "./connect/artifact.js";
 export type { ClientObserverLike } from "./observability/observer.js";
 export type { Client, ClientPath } from "./client.js";
+export type { LivenessOptions } from "./client-connect/connectCore.js";
+export type { WebSocketLimits } from "./ws-client/binaryTransport.js";
+export type { YamuxLimits } from "./yamux/session.js";
 export type { FlowersecErrorCode, FlowersecPath, FlowersecStage } from "./utils/errors.js";
 export { FlowersecError } from "./utils/errors.js";
 export { AllowPlaintext, AllowPlaintextForLoopback, RequireTLS, } from "./client-connect/transportSecurity.js";

package/dist/node/reconnectConfig.d.ts

@@ -1,42 +1,16 @@
-import type { ConnectArtifact } from "../connect/artifact.js";
-import type { ChannelInitGrant } from "../gen/flowersec/controlplane/v1.gen.js";
-import type { DirectConnectInfo } from "../gen/flowersec/direct/v1.gen.js";
 import type { ClientObserverLike } from "../observability/observer.js";
 import type { DirectConnectOptions } from "../direct-client/connect.js";
 import type { TunnelConnectOptions } from "../tunnel-client/connect.js";
 import type { AutoReconnectConfig, ConnectConfig as ReconnectConnectConfig } from "../reconnect/index.js";
-import { type ArtifactAwareReconnectConfig, type ArtifactFactoryArgs } from "../reconnect/artifactControlplane.js";
-import type { RequestConnectArtifactInput, RequestEntryConnectArtifactInput } from "../controlplane/index.js";
-type SharedReconnectOptions = Readonly<{
+import { type ArtifactSource } from "../reconnect/artifactControlplane.js";
+export type NodeReconnectConfig = Readonly<{
+    source: ArtifactSource;
+    connect?: Omit<TunnelConnectOptions, "observer" | "signal"> | Omit<DirectConnectOptions, "observer" | "signal">;
     observer?: ClientObserverLike;
     autoReconnect?: AutoReconnectConfig;
 }>;
-type TunnelReconnectConnectOptions = Omit<TunnelConnectOptions, "observer" | "signal">;
-type DirectReconnectConnectOptions = Omit<DirectConnectOptions, "observer" | "signal">;
-type ArtifactAwareTunnelReconnectConfig = ArtifactAwareReconnectConfig & Readonly<{
-    artifact?: ConnectArtifact;
-    getArtifact?: (args: ArtifactFactoryArgs) => Promise<ConnectArtifact>;
-    artifactControlplane?: RequestConnectArtifactInput | RequestEntryConnectArtifactInput;
-}>;
-type ArtifactAwareDirectReconnectConfig = ArtifactAwareReconnectConfig & Readonly<{
-    artifact?: ConnectArtifact;
-    getArtifact?: (args: ArtifactFactoryArgs) => Promise<ConnectArtifact>;
-    artifactControlplane?: RequestConnectArtifactInput | RequestEntryConnectArtifactInput;
-}>;
-export type TunnelNodeReconnectConfig = SharedReconnectOptions & ArtifactAwareTunnelReconnectConfig & Readonly<{
-    mode?: "tunnel";
-    connect?: TunnelReconnectConnectOptions;
-    grant?: ChannelInitGrant;
-    getGrant?: () => Promise<ChannelInitGrant>;
-}>;
-export type DirectNodeReconnectConfig = SharedReconnectOptions & ArtifactAwareDirectReconnectConfig & Readonly<{
-    mode: "direct";
-    connect?: DirectReconnectConnectOptions;
-    directInfo?: DirectConnectInfo;
-    getDirectInfo?: () => Promise<DirectConnectInfo>;
-}>;
-export type NodeReconnectConfig = TunnelNodeReconnectConfig | DirectNodeReconnectConfig;
-export declare function createTunnelNodeReconnectConfig(config: TunnelNodeReconnectConfig): ReconnectConnectConfig;
-export declare function createDirectNodeReconnectConfig(config: DirectNodeReconnectConfig): ReconnectConnectConfig;
+export type TunnelNodeReconnectConfig = NodeReconnectConfig;
+export type DirectNodeReconnectConfig = NodeReconnectConfig;
 export declare function createNodeReconnectConfig(config: NodeReconnectConfig): ReconnectConnectConfig;
-export {};
+export declare const createTunnelNodeReconnectConfig: typeof createNodeReconnectConfig;
+export declare const createDirectNodeReconnectConfig: typeof createNodeReconnectConfig;

package/dist/node/reconnectConfig.js

@@ -1,78 +1,20 @@
-import { resolveConnectArtifact, updateTraceId, } from "../reconnect/artifactControlplane.js";
-import { connectDirectNode, connectNode, connectTunnelNode } from "./connect.js";
-async function resolveTunnelGrant(config) {
-    if (config.getGrant)
-        return await config.getGrant();
-    if (config.grant)
-        return config.grant;
-    throw new Error("Tunnel reconnect config requires `getGrant` or `grant`");
-}
-async function resolveDirectInfo(config) {
-    if (config.getDirectInfo)
-        return await config.getDirectInfo();
-    if (config.directInfo)
-        return config.directInfo;
-    throw new Error("Direct reconnect config requires `getDirectInfo` or `directInfo`");
-}
-export function createTunnelNodeReconnectConfig(config) {
-    let traceId = config.artifact?.correlation?.trace_id;
-    return {
-        ...(config.observer === undefined ? {} : { observer: config.observer }),
-        ...(config.autoReconnect === undefined ? {} : { autoReconnect: config.autoReconnect }),
-        connectOnce: async ({ signal, observer }) => {
-            if (config.getArtifact || config.artifact || config.artifactControlplane) {
-                const artifact = await resolveConnectArtifact(config, traceId, signal);
-                if (artifact.transport !== "tunnel") {
-                    throw new Error("Tunnel reconnect config requires a tunnel ConnectArtifact");
-                }
-                traceId = updateTraceId(traceId, artifact);
-                const connectOptions = {
-                    ...(config.connect === undefined ? {} : config.connect),
-                    signal,
-                    observer,
-                };
-                return await connectNode(artifact, connectOptions);
-            }
-            const connectOptions = {
-                ...(config.connect === undefined ? {} : config.connect),
-                signal,
-                observer,
-            };
-            return await connectTunnelNode(await resolveTunnelGrant(config), connectOptions);
-        },
-    };
-}
-export function createDirectNodeReconnectConfig(config) {
-    let traceId = config.artifact?.correlation?.trace_id;
+import { createArtifactResolver, updateTraceId } from "../reconnect/artifactControlplane.js";
+import { connectNode } from "./connect.js";
+export function createNodeReconnectConfig(config) {
+    if (config.source.kind === "once" && config.autoReconnect?.enabled) {
+        throw new Error("automatic reconnect requires a refreshable artifact source");
+    }
+    let traceId = config.source.kind === "once" ? config.source.artifact.correlation?.trace_id : undefined;
+    const acquire = createArtifactResolver(config.source);
     return {
         ...(config.observer === undefined ? {} : { observer: config.observer }),
         ...(config.autoReconnect === undefined ? {} : { autoReconnect: config.autoReconnect }),
         connectOnce: async ({ signal, observer }) => {
-            if (config.getArtifact || config.artifact || config.artifactControlplane) {
-                const artifact = await resolveConnectArtifact(config, traceId, signal);
-                if (artifact.transport !== "direct") {
-                    throw new Error("Direct reconnect config requires a direct ConnectArtifact");
-                }
-                traceId = updateTraceId(traceId, artifact);
-                const connectOptions = {
-                    ...(config.connect === undefined ? {} : config.connect),
-                    signal,
-                    observer,
-                };
-                return await connectNode(artifact, connectOptions);
-            }
-            const connectOptions = {
-                ...(config.connect === undefined ? {} : config.connect),
-                signal,
-                observer,
-            };
-            return await connectDirectNode(await resolveDirectInfo(config), connectOptions);
+            const artifact = await acquire({ ...(traceId === undefined ? {} : { traceId }), signal });
+            traceId = updateTraceId(traceId, artifact);
+            return await connectNode(artifact, { ...(config.connect ?? {}), signal, observer });
         },
     };
 }
-export function createNodeReconnectConfig(config) {
-    if (config.mode === "direct") {
-        return createDirectNodeReconnectConfig(config);
-    }
-    return createTunnelNodeReconnectConfig(config);
-}
+export const createTunnelNodeReconnectConfig = createNodeReconnectConfig;
+export const createDirectNodeReconnectConfig = createNodeReconnectConfig;

package/dist/node/wsFactory.js

@@ -67,6 +67,9 @@ export function createNodeWsFactory(opts = {}) {
             get readyState() {
                 return raw.readyState;
             },
+            get bufferedAmount() {
+                return raw.bufferedAmount;
+            },
             send(data) {
                 raw.send(data);
             },

package/dist/observability/observer.d.ts

@@ -6,13 +6,13 @@ export type AttachReason = "send_failed" | "too_many_connections" | "expected_at
 export type HandshakeResult = "ok" | "fail";
 export type HandshakeReason = "auth_tag_mismatch" | "handshake_failed" | "invalid_suite" | "invalid_version" | "timestamp_after_init_exp" | "timestamp_out_of_skew" | "timeout" | "canceled";
 export type WsCloseKind = "local" | "peer_or_error";
-export type WsErrorReason = "error" | "recv_buffer_exceeded" | "unexpected_text_frame" | "unexpected_message_type";
+export type WsErrorReason = "error" | "recv_buffer_exceeded" | "send_buffer_exceeded" | "send_buffer_timeout" | "unexpected_text_frame" | "unexpected_message_type";
 export type RpcCallResult = "ok" | "rpc_error" | "handler_not_found" | "transport_error" | "canceled";
 export type DiagnosticEvent = Readonly<{
     v: 1;
     namespace: "connect";
     path: ClientPath | "auto";
-    stage: "validate" | "normalize" | "scope" | "connect" | "attach" | "handshake" | "close" | "reconnect";
+    stage: "validate" | "normalize" | "scope" | "connect" | "attach" | "handshake" | "transport" | "yamux" | "rpc" | "close" | "reconnect";
     code_domain: "error" | "event";
     code: string;
     result: "ok" | "fail" | "retry" | "skip";
@@ -20,6 +20,9 @@ export type DiagnosticEvent = Readonly<{
     attempt_seq: number;
     trace_id?: string;
     session_id?: string;
+    resource?: string;
+    current?: number;
+    limit?: number;
 }>;
 type ObserverContext = Readonly<{
     path?: ClientPath | "auto";

package/dist/observability/observer.js

@@ -54,6 +54,9 @@ function buildDiagnosticEvent(context, event) {
         ...(context.sessionId === undefined
             ? {}
             : { session_id: context.sessionId }),
+        ...(event.resource === undefined ? {} : { resource: event.resource }),
+        ...(event.current === undefined ? {} : { current: event.current }),
+        ...(event.limit === undefined ? {} : { limit: event.limit }),
     });
 }
 function mapConnectDiagnostic(path, result, reason) {

package/dist/reconnect/artifactControlplane.d.ts

@@ -1,13 +1,16 @@
 import type { ConnectArtifact } from "../connect/artifact.js";
 import { type RequestConnectArtifactInput, type RequestEntryConnectArtifactInput } from "../controlplane/index.js";
-export type ArtifactFactoryArgs = Readonly<{
+export type ArtifactAcquireContext = Readonly<{
     traceId?: string;
     signal?: AbortSignal;
 }>;
-export type ArtifactAwareReconnectConfig = Readonly<{
-    artifact?: ConnectArtifact;
-    getArtifact?: (args: ArtifactFactoryArgs) => Promise<ConnectArtifact>;
-    artifactControlplane?: RequestConnectArtifactInput | RequestEntryConnectArtifactInput;
+export type ArtifactSource = Readonly<{
+    kind: "once";
+    artifact: ConnectArtifact;
+}> | Readonly<{
+    kind: "refreshable";
+    acquire: (context: ArtifactAcquireContext) => Promise<ConnectArtifact>;
 }>;
-export declare function resolveConnectArtifact(config: ArtifactAwareReconnectConfig, traceId?: string, signal?: AbortSignal): Promise<ConnectArtifact>;
+export declare function createControlplaneArtifactSource(input: RequestConnectArtifactInput | RequestEntryConnectArtifactInput): ArtifactSource;
+export declare function createArtifactResolver(source: ArtifactSource): (context: ArtifactAcquireContext) => Promise<ConnectArtifact>;
 export declare function updateTraceId(current: string | undefined, artifact: ConnectArtifact): string | undefined;

package/dist/reconnect/artifactControlplane.js

@@ -1,33 +1,34 @@
 import { requestConnectArtifact, requestEntryConnectArtifact, } from "../controlplane/index.js";
-export async function resolveConnectArtifact(config, traceId, signal) {
-    if (config.getArtifact) {
-        return await config.getArtifact({
-            ...(traceId === undefined ? {} : { traceId }),
-            ...(signal === undefined ? {} : { signal }),
-        });
-    }
-    if (config.artifact)
-        return config.artifact;
-    if (config.artifactControlplane) {
-        const correlation = traceId === undefined
-            ? config.artifactControlplane.correlation
-            : { traceId };
-        if ("entryTicket" in config.artifactControlplane) {
-            const input = {
-                ...config.artifactControlplane,
+export function createControlplaneArtifactSource(input) {
+    return {
+        kind: "refreshable",
+        acquire: async ({ traceId, signal }) => {
+            const correlation = traceId === undefined ? input.correlation : { traceId };
+            if ("entryTicket" in input) {
+                return await requestEntryConnectArtifact({
+                    ...input,
+                    ...(correlation === undefined ? {} : { correlation }),
+                    ...(signal === undefined ? {} : { signal }),
+                });
+            }
+            return await requestConnectArtifact({
+                ...input,
                 ...(correlation === undefined ? {} : { correlation }),
                 ...(signal === undefined ? {} : { signal }),
-            };
-            return await requestEntryConnectArtifact(input);
-        }
-        const input = {
-            ...config.artifactControlplane,
-            ...(correlation === undefined ? {} : { correlation }),
-            ...(signal === undefined ? {} : { signal }),
-        };
-        return await requestConnectArtifact(input);
-    }
-    throw new Error("Artifact reconnect config requires `getArtifact`, `artifact`, or `artifactControlplane`");
+            });
+        },
+    };
+}
+export function createArtifactResolver(source) {
+    let consumed = false;
+    return async (context) => {
+        if (source.kind === "refreshable")
+            return await source.acquire(context);
+        if (consumed)
+            throw new Error("one-time artifact source has already been consumed");
+        consumed = true;
+        return source.artifact;
+    };
 }
 export function updateTraceId(current, artifact) {
     return artifact.correlation?.trace_id ?? current;

package/dist/reconnect/index.d.ts

@@ -1,5 +1,7 @@
 import type { Client } from "../client.js";
 import { type ClientObserverLike } from "../observability/observer.js";
+export type { ArtifactAcquireContext, ArtifactSource } from "./artifactControlplane.js";
+export { createArtifactResolver, createControlplaneArtifactSource } from "./artifactControlplane.js";
 export type ConnectionStatus = "disconnected" | "connecting" | "connected" | "error";
 export type AutoReconnectConfig = Readonly<{
     enabled?: boolean;

package/dist/reconnect/index.js

@@ -1,4 +1,5 @@
 import { emitObserverDiagnostic, withObserverContext } from "../observability/observer.js";
+export { createArtifactResolver, createControlplaneArtifactSource } from "./artifactControlplane.js";
 function normalizeAutoReconnect(cfg) {
     if (!cfg?.enabled) {
         return {
@@ -159,6 +160,12 @@ export function createReconnectManager() {
             },
             onRpcCall: (...args) => user?.onRpcCall?.(...args),
             onRpcNotify: (...args) => user?.onRpcNotify?.(...args),
+            onDiagnosticEvent: (event) => {
+                user?.onDiagnosticEvent?.(event);
+                if (event.code === "liveness_timeout") {
+                    startReconnect(t, cfg, new Error("liveness timeout"));
+                }
+            },
         }, {
             attemptSeq: currentAttemptSeq,
         });

package/dist/rpc/server.d.ts

@@ -3,13 +3,38 @@ export type RpcHandler = (payload: unknown) => Promise<{
     payload: unknown;
     error?: RpcError;
 }>;
+export type RpcServerOptions = Readonly<{
+    maxConcurrentRequests?: number;
+    maxQueuedRequests?: number;
+    maxQueuedNotifications?: number;
+}>;
+export type RpcServerTransport = Readonly<{
+    readExactly(n: number): Promise<Uint8Array>;
+    write(bytes: Uint8Array): Promise<void>;
+    close(error: unknown): void;
+}>;
 export declare class RpcServer {
-    private readonly readExactly;
-    private readonly write;
+    private readonly transport;
     private readonly handlers;
     private closed;
-    constructor(readExactly: (n: number) => Promise<Uint8Array>, write: (b: Uint8Array) => Promise<void>);
+    private readonly options;
+    private readonly requests;
+    private readonly notifications;
+    private requestWaiters;
+    private notificationWaiters;
+    private writeChain;
+    private terminalError;
+    private readonly terminalSignal;
+    private signalTerminal;
+    private transportClosed;
+    constructor(transport: RpcServerTransport, options?: RpcServerOptions);
     register(typeId: number, h: RpcHandler): void;
     serve(signal?: AbortSignal): Promise<void>;
-    close(): void;
+    close(error?: unknown): void;
+    private fail;
+    private requestWorker;
+    private notificationWorker;
+    private nextWork;
+    private wakeOne;
+    private writeResponse;
 }

package/dist/rpc/server.js

@@ -1,16 +1,35 @@
 import { DEFAULT_MAX_JSON_FRAME_BYTES, readJsonFrame, writeJsonFrame } from "../framing/jsonframe.js";
 import { assertRpcEnvelope } from "./validate.js";
+const DEFAULT_RPC_SERVER_OPTIONS = Object.freeze({
+    maxConcurrentRequests: 32,
+    maxQueuedRequests: 128,
+    maxQueuedNotifications: 128,
+});
 // RpcServer dispatches request envelopes to registered handlers.
 export class RpcServer {
-    readExactly;
-    write;
+    transport;
     // Registered handlers keyed by type ID.
     handlers = new Map();
     // Closed flag to stop the serve loop.
     closed = false;
-    constructor(readExactly, write) {
-        this.readExactly = readExactly;
-        this.write = write;
+    options;
+    requests = [];
+    notifications = [];
+    requestWaiters = [];
+    notificationWaiters = [];
+    writeChain = Promise.resolve();
+    terminalError;
+    terminalSignal;
+    signalTerminal;
+    transportClosed = false;
+    constructor(transport, options = {}) {
+        this.transport = transport;
+        this.terminalSignal = new Promise((resolve) => { this.signalTerminal = resolve; });
+        this.options = {
+            maxConcurrentRequests: positiveInteger(options.maxConcurrentRequests ?? DEFAULT_RPC_SERVER_OPTIONS.maxConcurrentRequests, "maxConcurrentRequests"),
+            maxQueuedRequests: nonNegativeInteger(options.maxQueuedRequests ?? DEFAULT_RPC_SERVER_OPTIONS.maxQueuedRequests, "maxQueuedRequests"),
+            maxQueuedNotifications: nonNegativeInteger(options.maxQueuedNotifications ?? DEFAULT_RPC_SERVER_OPTIONS.maxQueuedNotifications, "maxQueuedNotifications"),
+        };
     }
     // register binds a handler to a type ID.
     register(typeId, h) {
@@ -18,50 +37,139 @@ export class RpcServer {
     }
     // serve handles request/response frames until closed or aborted.
     async serve(signal) {
-        while (!this.closed) {
-            if (signal?.aborted)
-                throw signal.reason ?? new Error("aborted");
-            const v = assertRpcEnvelope(await readJsonFrame(this.readExactly, DEFAULT_MAX_JSON_FRAME_BYTES));
-            if (v.response_to !== 0)
-                continue;
-            if (v.request_id === 0) {
-                const h = this.handlers.get(v.type_id >>> 0);
-                if (h != null) {
-                    try {
-                        await h(v.payload);
-                    }
-                    catch {
-                        // Keep the serve loop alive on notification handler errors.
+        const supervise = (worker) => worker.catch((err) => {
+            this.fail(err);
+        });
+        const workers = Array.from({ length: this.options.maxConcurrentRequests }, () => supervise(this.requestWorker()));
+        workers.push(supervise(this.notificationWorker()));
+        try {
+            while (!this.closed) {
+                if (signal?.aborted)
+                    throw signal.reason ?? new Error("aborted");
+                const next = await Promise.race([
+                    readJsonFrame(this.transport.readExactly, DEFAULT_MAX_JSON_FRAME_BYTES),
+                    this.terminalSignal.then((error) => { throw error; }),
+                ]);
+                const v = assertRpcEnvelope(next);
+                if (v.response_to !== 0)
+                    continue;
+                if (v.request_id === 0) {
+                    if (this.notifications.length >= this.options.maxQueuedNotifications) {
+                        throw new Error("rpc notification queue exhausted");
                     }
+                    this.notifications.push({ envelope: v });
+                    this.wakeOne(this.notificationWaiters);
+                    continue;
                 }
-                continue;
+                if (this.requests.length >= this.options.maxQueuedRequests) {
+                    await this.writeResponse(v, { payload: null, error: { code: 429, message: "server overloaded" } });
+                    continue;
+                }
+                this.requests.push({ envelope: v });
+                this.wakeOne(this.requestWaiters);
             }
+        }
+        catch (err) {
+            this.terminalError = err;
+            this.close(err);
+            throw err;
+        }
+        finally {
+            this.close(this.terminalError ?? new Error("rpc server closed"));
+            void Promise.allSettled(workers);
+        }
+    }
+    // close stops the serve loop and closes the underlying RPC stream.
+    close(error = new Error("rpc server closed")) {
+        if (!this.closed) {
+            this.closed = true;
+            this.signalTerminal(error);
+            for (const wake of this.requestWaiters.splice(0))
+                wake();
+            for (const wake of this.notificationWaiters.splice(0))
+                wake();
+        }
+        if (!this.transportClosed) {
+            this.transportClosed = true;
+            this.transport.close(error);
+        }
+    }
+    fail(error) {
+        if (this.terminalError !== undefined)
+            return;
+        this.terminalError = error;
+        this.close(error);
+    }
+    async requestWorker() {
+        while (!this.closed) {
+            const work = await this.nextWork(this.requests, this.requestWaiters);
+            if (work == null)
+                return;
+            const v = work.envelope;
             const h = this.handlers.get(v.type_id >>> 0);
             let out;
-            if (h == null) {
+            if (h == null)
                 out = { payload: null, error: { code: 404, message: "handler not found" } };
-            }
             else {
                 try {
                     out = await h(v.payload);
                 }
                 catch {
-                    // Keep the serve loop alive on request handler errors.
                     out = { payload: null, error: { code: 500, message: "internal error" } };
                 }
             }
-            const resp = {
-                type_id: v.type_id,
-                request_id: 0,
-                response_to: v.request_id,
-                payload: out.payload,
-                ...(out.error != null ? { error: out.error } : {})
-            };
-            await writeJsonFrame(this.write, resp);
+            if (this.closed)
+                return;
+            await this.writeResponse(v, out);
         }
     }
-    // close stops the serve loop.
-    close() {
-        this.closed = true;
+    async notificationWorker() {
+        while (!this.closed) {
+            const work = await this.nextWork(this.notifications, this.notificationWaiters);
+            if (work == null)
+                return;
+            const v = work.envelope;
+            const h = this.handlers.get(v.type_id >>> 0);
+            if (h == null)
+                continue;
+            try {
+                await h(v.payload);
+            }
+            catch { /* Notification failures are isolated. */ }
+        }
     }
+    async nextWork(queue, waiters) {
+        while (!this.closed) {
+            const work = queue.shift();
+            if (work != null)
+                return work;
+            await new Promise((resolve) => waiters.push(resolve));
+        }
+        return null;
+    }
+    wakeOne(waiters) {
+        waiters.shift()?.();
+    }
+    async writeResponse(request, out) {
+        const resp = {
+            type_id: request.type_id,
+            request_id: 0,
+            response_to: request.request_id,
+            payload: out.payload,
+            ...(out.error != null ? { error: out.error } : {}),
+        };
+        const write = this.writeChain.then(() => writeJsonFrame(this.transport.write, resp));
+        this.writeChain = write.catch(() => { });
+        await write;
+    }
+}
+function positiveInteger(value, name) {
+    if (!Number.isSafeInteger(value) || value <= 0)
+        throw new RangeError(`${name} must be a positive integer`);
+    return value;
+}
+function nonNegativeInteger(value, name) {
+    if (!Number.isSafeInteger(value) || value < 0)
+        throw new RangeError(`${name} must be a non-negative integer`);
+    return value;
 }