@vampgg/utils 1.0.0-beta.6 → 1.0.0-beta.7

package/dist/async-queue.mjs

@@ -55,10 +55,10 @@ var AsyncQueue = class {
 			const resolve = this.pendingResolve;
 			this.pendingResolve = null;
 			this.pendingReject = null;
-			resolve({
+			this.dispose().finally(() => resolve({
 				value: void 0,
 				done: true
-			});
+			}));
 		}
 	}
 	/** Producer: terminate the stream with an error thrown into the consumer. Idempotent. */
@@ -70,7 +70,7 @@ var AsyncQueue = class {
 			const reject = this.pendingReject;
 			this.pendingResolve = null;
 			this.pendingReject = null;
-			reject(cause);
+			this.dispose().finally(() => reject(cause));
 		}
 	}
 	async next() {

package/dist/ws-router.d.mts

@@ -1,6 +1,6 @@
 import { Message } from "./bebop.mjs";
 import { TempoLogger } from "@tempojs/common";
-import { AuthInterceptor, BaseRouter, ServiceRegistry, TempoRouterConfiguration } from "@tempojs/server";
+import { AuthInterceptor, BaseRouter, ServerContext, ServiceRegistry, TempoRouterConfiguration } from "@tempojs/server";
 
 //#region src/ws-router.d.ts
 interface GenericWs {
@@ -28,20 +28,30 @@ declare function encodeServerStreamFrame(opts: {
   messageId: string;
   data: Uint8Array;
 }): Uint8Array;
+/**
+ * The abort signal of the server stream `context` belongs to, if it was opened
+ * by a {@link TempoWsRouter}. It fires when the client cancels the stream or its
+ * connection closes. A handler parked on an external event source (one that
+ * never yields on its own) must end its generator when this fires: the router
+ * cannot interrupt a generator suspended in `await`.
+ */
+declare function streamAbortSignal(context: ServerContext): AbortSignal | undefined;
 declare class TempoWsRouter<Context, Ws extends GenericWs = WebSocket, Env extends [Context, Ws] = [Context, Ws]> extends BaseRouter<ArrayBuffer, Env, Message> {
-  private readonly core;
-  private readonly serverStreams;
+  private readonly connections;
   private readonly _streamEncodeCache;
   constructor(logger: TempoLogger, registry: ServiceRegistry, configuration?: TempoRouterConfiguration, authInterceptor?: AuthInterceptor);
+  private connection;
   private invokeServerStreamMethod;
   /**
-   * Tear down all open streams for this connection (driven by the DO socket
-   * close/error lifecycle). Emits a synthetic CANCELLED to each in-flight
-   * client/duplex stream so its generator ends, then clears all listeners.
+   * Tear down every open stream on `ws` (driven by the socket close/error
+   * lifecycle). Client/duplex streams get a synthetic CANCELLED; server streams
+   * are aborted (see {@link streamAbortSignal}). Never waits on a generator, so
+   * a handler parked on an external source cannot stall teardown. Other
+   * connections are untouched.
    */
-  closeConnection(): Promise<void>;
+  closeConnection(ws: Ws): void;
   process(req: ArrayBuffer, response: Message, env: Env): Promise<void>;
   handle(_request: ArrayBuffer, _env: Env): Promise<Message>;
 }
 //#endregion
-export { STREAM_MESSAGE_ID_KEY, STREAM_METHOD_ID_KEY, TempoWsRouter, encodeServerStreamFrame };
+export { STREAM_MESSAGE_ID_KEY, STREAM_METHOD_ID_KEY, TempoWsRouter, encodeServerStreamFrame, streamAbortSignal };

package/dist/ws-router.mjs

@@ -28,53 +28,83 @@ function encodeServerStreamFrame(opts) {
 		data: opts.data
 	})));
 }
+/** Cancellation signals for live server streams, keyed by their ServerContext. */
+const streamSignals = /* @__PURE__ */ new WeakMap();
+/**
+* The abort signal of the server stream `context` belongs to, if it was opened
+* by a {@link TempoWsRouter}. It fires when the client cancels the stream or its
+* connection closes. A handler parked on an external event source (one that
+* never yields on its own) must end its generator when this fires: the router
+* cannot interrupt a generator suspended in `await`.
+*/
+function streamAbortSignal(context) {
+	return streamSignals.get(context);
+}
+/** End a server stream without awaiting it: `return()` queues behind a parked `next()`. */
+function endServerStream(stream) {
+	stream.abort.abort();
+	stream.generator.return(void 0).catch(() => {});
+}
 var TempoWsRouter = class extends BaseRouter {
-	core;
-	serverStreams = /* @__PURE__ */ new Map();
+	connections = /* @__PURE__ */ new WeakMap();
 	_streamEncodeCache = /* @__PURE__ */ new WeakMap();
 	constructor(logger, registry, configuration = new TempoRouterConfiguration(), authInterceptor) {
 		super(logger, registry, configuration, authInterceptor);
-		this.core = new RouterCore({
-			logger,
-			maxRetryAttempts: this.maxRetryAttempts,
-			transmitInternalErrors: this.transmitInternalErrors,
-			authInterceptor,
-			getMethod: (methodId) => this.registry.getMethod(methodId),
-			getHooks: () => this.hooks,
-			deserializeRequest: (data, method, contentType) => this.deserializeRequest(data, method, contentType),
-			serializeResponse: (record, method, contentType) => this.serializeResponse(record, method, contentType)
-		});
 	}
-	async invokeServerStreamMethod(request, context, method) {
+	connection(ws) {
+		let connection = this.connections.get(ws);
+		if (!connection) {
+			connection = {
+				core: new RouterCore({
+					logger: this.logger,
+					maxRetryAttempts: this.maxRetryAttempts,
+					transmitInternalErrors: this.transmitInternalErrors,
+					authInterceptor: this.authInterceptor,
+					getMethod: (methodId) => this.registry.getMethod(methodId),
+					getHooks: () => this.hooks,
+					deserializeRequest: (data, method, contentType) => this.deserializeRequest(data, method, contentType),
+					serializeResponse: (record, method, contentType) => this.serializeResponse(record, method, contentType)
+				}),
+				serverStreams: /* @__PURE__ */ new Map()
+			};
+			this.connections.set(ws, connection);
+		}
+		return connection;
+	}
+	async invokeServerStreamMethod(connection, request, context, method) {
 		const messageId = request.messageId;
 		if (request.status === TempoStatusCode.CANCELLED) {
-			const existing = this.serverStreams.get(messageId);
+			const existing = connection.serverStreams.get(messageId);
 			if (existing) {
-				this.serverStreams.delete(messageId);
-				try {
-					await existing.return(void 0);
-				} catch {}
+				connection.serverStreams.delete(messageId);
+				endServerStream(existing);
 			}
 			return (async function* () {})();
 		}
-		const invocation = await this.core.invokeServerStreamMethod(request, context, method, "bebop");
-		this.serverStreams.set(messageId, invocation);
-		return invocation;
+		const abort = new AbortController();
+		streamSignals.set(context, abort.signal);
+		const generator = await connection.core.invokeServerStreamMethod(request, context, method, "bebop");
+		connection.serverStreams.set(messageId, {
+			generator,
+			abort
+		});
+		return generator;
 	}
 	/**
-	* Tear down all open streams for this connection (driven by the DO socket
-	* close/error lifecycle). Emits a synthetic CANCELLED to each in-flight
-	* client/duplex stream so its generator ends, then clears all listeners.
+	* Tear down every open stream on `ws` (driven by the socket close/error
+	* lifecycle). Client/duplex streams get a synthetic CANCELLED; server streams
+	* are aborted (see {@link streamAbortSignal}). Never waits on a generator, so
+	* a handler parked on an external source cannot stall teardown. Other
+	* connections are untouched.
 	*/
-	async closeConnection() {
-		this.core.cancelClientStreams();
-		for (const [id, gen] of [...this.serverStreams]) {
-			this.serverStreams.delete(id);
-			try {
-				await gen.return(void 0);
-			} catch {}
-		}
-		this.core.removeAllListeners();
+	closeConnection(ws) {
+		const connection = this.connections.get(ws);
+		if (!connection) return;
+		this.connections.delete(ws);
+		connection.core.cancelClientStreams();
+		for (const stream of connection.serverStreams.values()) endServerStream(stream);
+		connection.serverStreams.clear();
+		connection.core.removeAllListeners();
 	}
 	async process(req, response, env) {
 		if (req.byteLength > this.maxReceiveMessageSize) {
@@ -83,10 +113,11 @@ var TempoWsRouter = class extends BaseRouter {
 		}
 		const request = Message.decode(new Uint8Array(req));
 		const [, ws] = env;
+		const connection = this.connection(ws);
 		const send = (message) => {
 			ws.send(new Uint8Array(Message.encode(message)));
 		};
-		await this.core.processRequest(request, response, env, {
+		await connection.core.processRequest(request, response, env, {
 			send,
 			buildIncomingMetadata: (message) => {
 				const incomingMetadata = new Metadata();
@@ -94,8 +125,8 @@ var TempoWsRouter = class extends BaseRouter {
 				if (message.methodId !== void 0) incomingMetadata.set(STREAM_METHOD_ID_KEY, String(message.methodId));
 				return incomingMetadata;
 			},
-			invokeServerStream: (message, context, method) => this.invokeServerStreamMethod(message, context, method),
-			writeStreamFrames: (generator, resp, method) => this.core.writeStreamFrames({
+			invokeServerStream: (message, context, method) => this.invokeServerStreamMethod(connection, message, context, method),
+			writeStreamFrames: (generator, resp, method) => connection.core.writeStreamFrames({
 				generator,
 				response: resp,
 				method,
@@ -108,7 +139,9 @@ var TempoWsRouter = class extends BaseRouter {
 					}
 					return payload;
 				},
-				onEnd: () => this.serverStreams.delete(request.messageId)
+				onEnd: () => {
+					if (connection.serverStreams.get(request.messageId)?.generator === generator) connection.serverStreams.delete(request.messageId);
+				}
 			})
 		});
 	}
@@ -117,4 +150,4 @@ var TempoWsRouter = class extends BaseRouter {
 	}
 };
 //#endregion
-export { STREAM_MESSAGE_ID_KEY, STREAM_METHOD_ID_KEY, TempoWsRouter, encodeServerStreamFrame };
+export { STREAM_MESSAGE_ID_KEY, STREAM_METHOD_ID_KEY, TempoWsRouter, encodeServerStreamFrame, streamAbortSignal };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vampgg/utils",
-  "version": "1.0.0-beta.6",
+  "version": "1.0.0-beta.7",
   "description": "Tempo RPC, Bebop serialization, transports, and async primitives for @vampgg.",
   "homepage": "https://github.com/sammccord/vamp/tree/main/packages/utils#readme",
   "bugs": {