@vampgg/utils 1.0.0-beta.1

package/dist/ws-router.mjs

@@ -0,0 +1,278 @@
+import { Message } from "./bebop.mjs";
+import { createEventIterator } from "./create-event-iterator.mjs";
+import { Deadline, Metadata, MethodType, TempoError, TempoStatusCode, TempoUtil, stringifyCredential } from "@tempojs/common";
+import { EventEmitter } from "tseep";
+import { BaseRouter, ServerContext, TempoRouterConfiguration } from "@tempojs/server";
+//#region src/ws-router.ts
+/**
+* Client-metadata keys under which {@link TempoWsRouter.process} exposes the
+* current call's message/method ids to a service handler (read via
+* `context.clientMetadata`). A streaming handler persists these so the
+* hibernation-safe broadcast path can re-frame server->client pushes.
+*/
+const STREAM_MESSAGE_ID_KEY = "tempo-message-id";
+const STREAM_METHOD_ID_KEY = "tempo-method-id";
+/**
+* Build an encoded server-stream frame identical to the one {@link TempoWsRouter}
+* emits from a streaming handler: status OK, the given `methodId`/`messageId`, and
+* the already-serialized record bytes `data`. Used by the hibernation-safe
+* broadcast path to push frames over a live socket WITHOUT a live generator — the
+* client's server-stream iterator matches them by `messageId` exactly like
+* generator-emitted frames. `messageId` MUST be the original observe call's id
+* (a GUID); `methodId` its method id.
+*/
+function encodeServerStreamFrame(opts) {
+	return new Uint8Array(Message.encode(Message({
+		methodId: opts.methodId,
+		messageId: opts.messageId,
+		status: TempoStatusCode.OK,
+		data: opts.data
+	})));
+}
+var TempoWsRouter = class extends BaseRouter {
+	events = new EventEmitter();
+	clientStreams = /* @__PURE__ */ new Map();
+	serverStreams = /* @__PURE__ */ new Map();
+	_streamEncodeCache = /* @__PURE__ */ new WeakMap();
+	constructor(logger, registry, configuration = new TempoRouterConfiguration(), authInterceptor) {
+		super(logger, registry, configuration, authInterceptor);
+	}
+	async setAuthContext(request, context) {
+		const authHeader = request.authorization;
+		if (authHeader !== void 0 && this.authInterceptor !== void 0) {
+			const authContext = await this.authInterceptor.intercept(context, authHeader);
+			if (authContext !== void 0) context.authContext = authContext;
+		}
+	}
+	async invokeUnaryMethod(request, context, method, contentType) {
+		await this.setAuthContext(request, context);
+		if (this.hooks !== void 0) await this.hooks.executeRequestHooks(context);
+		const requestData = request.data;
+		const record = this.deserializeRequest(requestData, method, contentType);
+		if (this.hooks !== void 0) await this.hooks.executeDecodeHooks(context, record);
+		return await method.invoke(record, context);
+	}
+	async invokeClientStreamMethod(request, context, method, contentType) {
+		await this.setAuthContext(request, context);
+		if (this.hooks !== void 0) await this.hooks.executeRequestHooks(context);
+		const messageId = request.messageId;
+		const stream = this.clientStreams.get(messageId);
+		if (stream) {
+			this.events.emit(messageId, request);
+			return await stream;
+		}
+		const generator = () => {
+			return createEventIterator(({ emit, cancel }) => {
+				const eventHandler = async (message) => {
+					if (this.hooks !== void 0) await this.hooks.executeRequestHooks(context);
+					if (message.status === TempoStatusCode.CANCELLED) {
+						cancel();
+						return;
+					}
+					const requestData = message.data;
+					const record = this.deserializeRequest(requestData, method, contentType);
+					if (this.hooks !== void 0) await this.hooks.executeDecodeHooks(context, record);
+					emit(record);
+				};
+				this.events.on(messageId, eventHandler);
+				return () => {
+					this.events.off(messageId, eventHandler);
+					this.clientStreams.delete(messageId);
+				};
+			});
+		};
+		const invocation = method.invoke(generator, context);
+		this.clientStreams.set(messageId, invocation);
+		this.events.emit(messageId, request);
+		return await invocation.finally(() => {
+			this.clientStreams.delete(messageId);
+		});
+	}
+	async invokeServerStreamMethod(request, context, method, contentType) {
+		await this.setAuthContext(request, context);
+		const messageId = request.messageId;
+		if (request.status === TempoStatusCode.CANCELLED) {
+			const existing = this.serverStreams.get(messageId);
+			if (existing) {
+				this.serverStreams.delete(messageId);
+				try {
+					await existing.return(void 0);
+				} catch {}
+			}
+			return (async function* () {})();
+		}
+		if (this.hooks !== void 0) await this.hooks.executeRequestHooks(context);
+		const requestData = request.data;
+		const record = this.deserializeRequest(requestData, method, contentType);
+		if (!TempoUtil.isAsyncGeneratorFunction(method.invoke.bind(method))) throw new TempoError(TempoStatusCode.INTERNAL, "service method incorrect: method must be async generator");
+		if (this.hooks !== void 0) await this.hooks.executeDecodeHooks(context, record);
+		const invocation = method.invoke(record, context);
+		this.serverStreams.set(messageId, invocation);
+		return invocation;
+	}
+	async invokeDuplexStreamMethod(request, context, method, contentType) {
+		await this.setAuthContext(request, context);
+		if (this.hooks !== void 0) await this.hooks.executeRequestHooks(context);
+		const messageId = request.messageId;
+		const stream = this.clientStreams.get(messageId);
+		if (stream) {
+			this.events.emit(messageId, request);
+			return stream;
+		}
+		if (!TempoUtil.isAsyncGeneratorFunction(method.invoke.bind(method))) throw new TempoError(TempoStatusCode.INTERNAL, "service method incorrect: method must be async generator");
+		const generator = () => {
+			return createEventIterator(({ emit, cancel }) => {
+				const eventHandler = async (message) => {
+					if (this.hooks !== void 0) await this.hooks.executeRequestHooks(context);
+					if (message.status === TempoStatusCode.CANCELLED) {
+						cancel();
+						return;
+					}
+					const requestData = message.data;
+					const record = this.deserializeRequest(requestData, method, contentType);
+					if (this.hooks !== void 0) await this.hooks.executeDecodeHooks(context, record);
+					emit(record);
+				};
+				this.events.on(messageId, eventHandler);
+				this.events.emit(messageId, request);
+				return () => {
+					this.events.off(messageId, eventHandler);
+					this.clientStreams.delete(messageId);
+				};
+			});
+		};
+		const invocation = method.invoke(generator, context);
+		this.clientStreams.set(messageId, invocation);
+		return invocation;
+	}
+	/**
+	* 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.
+	*/
+	async closeConnection() {
+		for (const id of [...this.clientStreams.keys()]) {
+			this.events.emit(id, Message({
+				messageId: id,
+				status: TempoStatusCode.CANCELLED,
+				data: new Uint8Array()
+			}));
+			this.clientStreams.delete(id);
+		}
+		for (const [id, gen] of [...this.serverStreams]) {
+			this.serverStreams.delete(id);
+			try {
+				await gen.return(void 0);
+			} catch {}
+		}
+		this.events.removeAllListeners();
+	}
+	async process(req, response, env) {
+		if (req.byteLength > this.maxReceiveMessageSize) {
+			this.logger.error(`inbound frame ${req.byteLength}B exceeds maxReceiveMessageSize ${this.maxReceiveMessageSize}B; dropping`);
+			return;
+		}
+		let request = Message.decode(new Uint8Array(req));
+		const [, ws] = env;
+		try {
+			const methodId = request.methodId;
+			const method = this.registry.getMethod(methodId);
+			if (!method) throw new TempoError(TempoStatusCode.NOT_FOUND, `no service is registered which contains a method of '${methodId}'`);
+			const previousAttempts = request.previousAttempts;
+			if (previousAttempts !== void 0) {
+				if (previousAttempts > this.maxRetryAttempts) throw new TempoError(TempoStatusCode.RESOURCE_EXHAUSTED, "max retry attempts exceeded");
+			}
+			let deadline;
+			const deadlineHeader = request.deadline;
+			if (deadlineHeader !== void 0) deadline = Deadline.fromUnixTimestamp(deadlineHeader.valueOf());
+			if (deadline !== void 0 && deadline.isExpired()) throw new TempoError(TempoStatusCode.DEADLINE_EXCEEDED, "incoming request has already exceeded its deadline");
+			const outgoingMetadata = new Metadata();
+			const incomingMetadata = new Metadata();
+			if (request.messageId !== void 0) incomingMetadata.set(STREAM_MESSAGE_ID_KEY, request.messageId);
+			if (request.methodId !== void 0) incomingMetadata.set(STREAM_METHOD_ID_KEY, String(request.methodId));
+			const incomingContext = {
+				headers: new Headers(),
+				metadata: incomingMetadata
+			};
+			if (deadline !== void 0) incomingContext.deadline = deadline;
+			const context = new ServerContext(incomingContext, { metadata: outgoingMetadata }, env);
+			const handleRequest = async () => {
+				let recordGenerator = void 0;
+				let record;
+				switch (method.type) {
+					case MethodType.Unary:
+						record = await this.invokeUnaryMethod(request, context, method, "bebop");
+						break;
+					case MethodType.ClientStream:
+						record = await this.invokeClientStreamMethod(request, context, method, "bebop");
+						break;
+					case MethodType.ServerStream:
+						recordGenerator = await this.invokeServerStreamMethod(request, context, method, "bebop");
+						break;
+					case MethodType.DuplexStream:
+						recordGenerator = await this.invokeDuplexStreamMethod(request, context, method, "bebop");
+						break;
+					default: throw new TempoError(TempoStatusCode.INTERNAL, "service method incorrect: unknown method type");
+				}
+				const outgoingCredential = context.outgoingCredential;
+				if (outgoingCredential) response.credential = stringifyCredential(outgoingCredential);
+				response.methodId = request.methodId;
+				response.messageId = request.messageId;
+				response.status = TempoStatusCode.OK;
+				response.timestamp = /* @__PURE__ */ new Date();
+				if (this.hooks !== void 0) await this.hooks.executeResponseHooks(context);
+				outgoingMetadata.freeze();
+				if (outgoingMetadata.size() > 0) response.customMetadata = outgoingMetadata.data;
+				if (recordGenerator !== void 0) {
+					const writeFrames = async () => {
+						for await (const value of recordGenerator) {
+							let payload = this._streamEncodeCache.get(value);
+							if (payload === void 0) {
+								payload = new Uint8Array(this.serializeResponse(value, method, "bebop"));
+								this._streamEncodeCache.set(value, payload);
+							}
+							response.data = payload;
+							ws.send(new Uint8Array(Message.encode(response)));
+						}
+						this.serverStreams.delete(request.messageId);
+						response.data = new Uint8Array();
+						response.status = TempoStatusCode.CANCELLED;
+						ws.send(new Uint8Array(Message.encode(response)));
+					};
+					if (deadline) await deadline.executeWithinDeadline(writeFrames);
+					else await writeFrames();
+				} else {
+					if (record === void 0) throw new TempoError(TempoStatusCode.INTERNAL, "service method did not return a record");
+					const responseData = this.serializeResponse(record, method, "bebop");
+					response.data = new Uint8Array(responseData);
+					ws.send(new Uint8Array(Message.encode(response)));
+				}
+			};
+			if (deadline !== void 0) await deadline.executeWithinDeadline(handleRequest);
+			else await handleRequest();
+		} catch (e) {
+			let status = TempoStatusCode.UNKNOWN;
+			let message = "unknown error";
+			if (e instanceof TempoError) {
+				status = e.status;
+				message = e.message;
+				if (e.status === TempoStatusCode.INTERNAL && this.transmitInternalErrors !== true) message = "internal error";
+				if (e.status === TempoStatusCode.INTERNAL) this.logger.critical(e.message, void 0, e);
+				else this.logger.error(message, void 0, e);
+			} else if (e instanceof Error) {
+				message = e.message;
+				this.logger.error(message, void 0, e);
+			}
+			if (e instanceof Error && this.hooks !== void 0) await this.hooks.executeErrorHooks(void 0, e);
+			this.clientStreams.delete(request.messageId);
+			response.status = status;
+			response.msg = message;
+			ws.send(new Uint8Array(Message.encode(response)));
+		}
+	}
+	handle(_request, _env) {
+		throw new TempoError(TempoStatusCode.UNIMPLEMENTED, "Method not implemented.");
+	}
+};
+//#endregion
+export { STREAM_MESSAGE_ID_KEY, STREAM_METHOD_ID_KEY, TempoWsRouter, encodeServerStreamFrame };

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@vampgg/utils",
+  "version": "1.0.0-beta.1",
+  "description": "Tempo RPC, Bebop serialization, transports, and async primitives for @vampgg.",
+  "homepage": "https://github.com/sammccord/vamp/tree/main/packages/utils#readme",
+  "bugs": {
+    "url": "https://github.com/sammccord/vamp/issues"
+  },
+  "license": "MIT",
+  "author": "Sam McCord <sam.mccord@protonmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sammccord/vamp.git",
+    "directory": "packages/utils"
+  },
+  "files": [
+    "dist",
+    "schema"
+  ],
+  "type": "module",
+  "exports": {
+    "./async-queue": "./dist/async-queue.mjs",
+    "./bebop": "./dist/bebop.mjs",
+    "./context-logger": "./dist/context-logger.mjs",
+    "./create-duplex-iterator": "./dist/create-duplex-iterator.mjs",
+    "./create-event-iterator": "./dist/create-event-iterator.mjs",
+    "./debug-logger": "./dist/debug-logger.mjs",
+    "./error": "./dist/error.mjs",
+    "./extension-channel": "./dist/extension-channel.mjs",
+    "./extension-router": "./dist/extension-router.mjs",
+    "./memory-storage": "./dist/memory-storage.mjs",
+    "./pino-logger": "./dist/pino-logger.mjs",
+    "./sync-storage": "./dist/sync-storage.mjs",
+    "./worker-channel": "./dist/worker-channel.mjs",
+    "./worker-router": "./dist/worker-router.mjs",
+    "./ws-channel": "./dist/ws-channel.mjs",
+    "./ws-router": "./dist/ws-router.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@tempojs/client": "^0.0.12",
+    "@tempojs/common": "^0.0.12",
+    "@tempojs/server": "^0.0.12",
+    "bebop": "3.2.3",
+    "debug": "^4.4.3",
+    "lodash-es": "^4.17.23",
+    "pino": "^10.3.1",
+    "tseep": "^1.3.1",
+    "webextension-polyfill": "^0.12.0",
+    "websocket-ts": "^2.2.1"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.14",
+    "@types/debug": "^4.1.12",
+    "@types/lodash-es": "^4.17.12",
+    "@types/node": "^25.5.0",
+    "@types/webextension-polyfill": "^0.12.5",
+    "@typescript/native-preview": "7.0.0-dev.20260315.1",
+    "bebop-tools": "^3.2.3",
+    "typescript": "^5.9.3",
+    "vite-plus": "^0.1.24",
+    "vitest": "npm:@voidzero-dev/vite-plus-test@latest"
+  },
+  "scripts": {
+    "build": "bebopc build && vp pack",
+    "dev": "bebopc build && vp pack --watch",
+    "test": "vp test",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/schema/error.bop

@@ -0,0 +1,7 @@
+struct Error {
+  uint32 code;
+  string tag;
+  string stack;
+  string msg;
+  map[string, string] details;
+}

package/schema/index.bop

@@ -0,0 +1,2 @@
+import "./error.bop"
+import "./message.bop"

package/schema/message.bop

@@ -0,0 +1,12 @@
+message Message {
+    1 -> uint32 methodId;
+    2 -> guid messageId;
+    3 -> date timestamp;
+    4 -> date deadline;
+    5 -> byte[] data;
+    6 -> string credential;
+    7 -> byte status;
+    8 -> uint8 previousAttempts;
+    9 -> string msg;
+    10 -> string authorization;
+}

package/schema/pool.bop

@@ -0,0 +1,16 @@
+message Pool {
+	1 -> uint32 points;
+	2 -> uint32 min;
+	3 -> uint32 max;
+	4 -> int32 rate;
+  5 -> uint32 interval;
+}
+
+// Pool delta - points is CRDT counter, others are last-write-wins
+message PoolDelta {
+  1 -> int32 points;      // Delta for CRDT counter (+/-)
+  2 -> int32 min;        // Delta for CRDT counter (+/-)
+  3 -> int32 max;        // Delta for CRDT counter (+/-)
+  4 -> int32 rate;        // Delta for CRDT counter (+/-)
+  5 -> int32 interval;   // Delta for CRDT counter (+/-)
+}