@bunworks/inngest-realtime 0.1.0 → 0.1.5

package/middleware.mjs

@@ -0,0 +1,34 @@
+import { Realtime } from "./types.mjs";
+
+//#region src/middleware.ts
+const realtimeMiddleware = () => {
+	return {
+		name: "publish",
+		init({ client }) {
+			return { onFunctionRun({ ctx: { runId } }) {
+				return { transformInput({ ctx: { step } }) {
+					const publish = async (input) => {
+						const { topic, channel, data } = await input;
+						const publishOpts = {
+							topics: [topic],
+							channel,
+							runId
+						};
+						const action = async () => {
+							const result = await client["api"].publish(publishOpts, data);
+							if (!result.ok) throw new Error(`Failed to publish event: ${result.error?.error}`);
+						};
+						return step.run(`publish:${publishOpts.channel}`, action).then(() => {
+							return data;
+						});
+					};
+					return { ctx: { publish } };
+				} };
+			} };
+		}
+	};
+};
+
+//#endregion
+export { Realtime, realtimeMiddleware };
+//# sourceMappingURL=middleware.mjs.map

package/middleware.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.mjs","names":[],"sources":["../src/middleware.ts"],"sourcesContent":["import type { Realtime } from \"./types\";\r\n\r\nexport interface InngestMiddleware {\r\n  name: string;\r\n  init: (config: { client: any }) => {\r\n    onFunctionRun: (config: { ctx: { runId: string } }) => {\r\n      transformInput: (config: { ctx: { step: any } }) => {\r\n        ctx: {\r\n          publish: Realtime.PublishFn;\r\n        };\r\n      };\r\n    };\r\n  };\r\n}\r\n\r\nexport const realtimeMiddleware = () => {\r\n  return {\r\n    name: \"publish\",\r\n    init({ client }: { client: any }) {\r\n      return {\r\n        onFunctionRun({ ctx: { runId } }: { ctx: { runId: string } }) {\r\n          return {\r\n            transformInput({ ctx: { step } }: { ctx: { step: any } }) {\r\n              const publish: Realtime.PublishFn = async (input) => {\r\n                const { topic, channel, data } = await input;\r\n\r\n                const publishOpts = {\r\n                  topics: [topic],\r\n                  channel,\r\n                  runId,\r\n                };\r\n\r\n                const action = async () => {\r\n                  const result = await client[\"api\"].publish(publishOpts, data);\r\n\r\n                  if (!result.ok) {\r\n                    throw new Error(\r\n                      `Failed to publish event: ${result.error?.error}`,\r\n                    );\r\n                  }\r\n                };\r\n\r\n                return step\r\n                  .run(`publish:${publishOpts.channel}`, action)\r\n                  .then(() => {\r\n                    return data;\r\n                  });\r\n              };\r\n\r\n              return {\r\n                ctx: {\r\n                  /**\r\n                   * Function to publish messages to realtime channel\r\n                   */\r\n                  publish,\r\n                },\r\n              };\r\n            },\r\n          };\r\n        },\r\n      };\r\n    },\r\n  } as InngestMiddleware;\r\n};\r\n\r\n// Re-export types from here, as this is used as a separate entrypoint now\r\nexport * from \"./types\";\r\n"],"mappings":";;;AAeA,MAAa,2BAA2B;AACtC,QAAO;EACL,MAAM;EACN,KAAK,EAAE,UAA2B;AAChC,UAAO,EACL,cAAc,EAAE,KAAK,EAAE,WAAuC;AAC5D,WAAO,EACL,eAAe,EAAE,KAAK,EAAE,UAAkC;KACxD,MAAM,UAA8B,OAAO,UAAU;MACnD,MAAM,EAAE,OAAO,SAAS,SAAS,MAAM;MAEvC,MAAM,cAAc;OAClB,QAAQ,CAAC,MAAM;OACf;OACA;OACD;MAED,MAAM,SAAS,YAAY;OACzB,MAAM,SAAS,MAAM,OAAO,OAAO,QAAQ,aAAa,KAAK;AAE7D,WAAI,CAAC,OAAO,GACV,OAAM,IAAI,MACR,4BAA4B,OAAO,OAAO,QAC3C;;AAIL,aAAO,KACJ,IAAI,WAAW,YAAY,WAAW,OAAO,CAC7C,WAAW;AACV,cAAO;QACP;;AAGN,YAAO,EACL,KAAK,EAIH,SACD,EACF;OAEJ;MAEJ;;EAEJ"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bunworks/inngest-realtime",
-  "version": "0.1.0",
+  "version": "0.1.5",
   "description": "Realtime messaging для @bunworks",
   "main": "./index.js",
   "publishConfig": {
@@ -10,9 +10,10 @@
   "scripts": {
     "test": "vitest run",
     "build": "tsc -p tsconfig.build.json && tsdown --config tsdown.config.ts",
-    "postversion": "pnpm run build",
+    "postversion": "bun run build",
     "release": "cross-env DIST_DIR=dist node ../../scripts/release/publish.js",
-    "pack": "pnpm run build && mv $(npm pack ./dist --pack-destination . --silent) inngest-realtime.tgz"
+    "pack": "bun run build && mv $(npm pack ./dist --pack-destination . --silent) inngest-realtime.tgz",
+    "publish:patch": "npm version patch --no-git-tag-version && npm publish ./dist --access public"
   },
   "exports": {
     ".": {
@@ -52,10 +53,10 @@
     "websocket",
     "messaging"
   ],
-  "homepage": "https://github.com/bunworks/bunworks#readme",
+  "homepage": "https://github.com/bunworks/inngest-realtime#readme",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/bunworks/bunworks.git",
+    "url": "git+https://github.com/bunworks/inngest-realtime.git",
     "directory": "external/realtime"
   },
   "author": "Bunworks Team",

package/subscribe/StreamFanout.cjs

@@ -0,0 +1,47 @@
+
+//#region src/subscribe/StreamFanout.ts
+/**
+* Fan out a single input stream to multiple output streams
+*/
+var StreamFanout = class {
+	#writers = /* @__PURE__ */ new Set();
+	/**
+	* Create a new output stream with optional transformation
+	*/
+	createStream(transform) {
+		const { readable, writable } = new TransformStream({ transform: (chunk, controller) => {
+			controller.enqueue(transform ? transform(chunk) : chunk);
+		} });
+		const writer = writable.getWriter();
+		this.#writers.add(writer);
+		writer.closed.catch(() => {}).finally(() => {
+			this.#writers.delete(writer);
+		});
+		return readable;
+	}
+	/**
+	* Write a chunk to all active streams
+	*/
+	write(chunk) {
+		for (const writer of this.#writers) writer.ready.then(() => writer.write(chunk)).catch(() => this.#writers.delete(writer));
+	}
+	/**
+	* Close all active streams
+	*/
+	close() {
+		for (const writer of this.#writers) try {
+			writer.close();
+		} catch {}
+		this.#writers.clear();
+	}
+	/**
+	* Get the number of active streams
+	*/
+	size() {
+		return this.#writers.size;
+	}
+};
+
+//#endregion
+exports.StreamFanout = StreamFanout;
+//# sourceMappingURL=StreamFanout.cjs.map

package/subscribe/StreamFanout.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"StreamFanout.cjs","names":["#writers"],"sources":["../../src/subscribe/StreamFanout.ts"],"sourcesContent":["/**\r\n * Fan out a single input stream to multiple output streams\r\n */\r\nexport class StreamFanout<TInput = unknown> {\r\n  #writers = new Set<WritableStreamDefaultWriter<TInput>>();\r\n\r\n  /**\r\n   * Create a new output stream with optional transformation\r\n   */\r\n  createStream<TOutput = TInput>(\r\n    /**\r\n     * Optional transform function for each chunk\r\n     */\r\n    transform?: (\r\n      /**\r\n       * Input chunk\r\n       */\r\n      chunk: TInput,\r\n    ) => TOutput,\r\n  ): ReadableStream<TOutput> {\r\n    const { readable, writable } = new TransformStream<TInput, TOutput>({\r\n      transform: (chunk, controller) => {\r\n        controller.enqueue(\r\n          transform ? transform(chunk) : (chunk as unknown as TOutput),\r\n        );\r\n      },\r\n    });\r\n\r\n    const writer = writable.getWriter();\r\n    this.#writers.add(writer);\r\n\r\n    // Eagerly remove the writer is the stream is closed\r\n    writer.closed\r\n      .catch(() => {}) // Suppress unhandled promise rejection to avoid noisy logs\r\n      .finally(() => {\r\n        this.#writers.delete(writer);\r\n      });\r\n\r\n    return readable;\r\n  }\r\n\r\n  /**\r\n   * Write a chunk to all active streams\r\n   */\r\n  write(\r\n    /**\r\n     * Chunk to write\r\n     */\r\n    chunk: TInput,\r\n  ) {\r\n    for (const writer of this.#writers) {\r\n      writer.ready\r\n        .then(() => writer.write(chunk))\r\n        // Dereference the writer if we fail, as this means it's closed\r\n        .catch(() => this.#writers.delete(writer));\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Close all active streams\r\n   */\r\n  close() {\r\n    for (const writer of this.#writers) {\r\n      try {\r\n        writer.close();\r\n      } catch {\r\n        // Ignore errors, as we are closing the stream and the writer may\r\n        // already be closed, especially if the stream is closed before the\r\n        // writer is closed or if the stream is cancelled.\r\n      }\r\n    }\r\n\r\n    this.#writers.clear();\r\n  }\r\n\r\n  /**\r\n   * Get the number of active streams\r\n   */\r\n  size() {\r\n    return this.#writers.size;\r\n  }\r\n}\r\n"],"mappings":";;;;;AAGA,IAAa,eAAb,MAA4C;CAC1C,2BAAW,IAAI,KAA0C;;;;CAKzD,aAIE,WAMyB;EACzB,MAAM,EAAE,UAAU,aAAa,IAAI,gBAAiC,EAClE,YAAY,OAAO,eAAe;AAChC,cAAW,QACT,YAAY,UAAU,MAAM,GAAI,MACjC;KAEJ,CAAC;EAEF,MAAM,SAAS,SAAS,WAAW;AACnC,QAAKA,QAAS,IAAI,OAAO;AAGzB,SAAO,OACJ,YAAY,GAAG,CACf,cAAc;AACb,SAAKA,QAAS,OAAO,OAAO;IAC5B;AAEJ,SAAO;;;;;CAMT,MAIE,OACA;AACA,OAAK,MAAM,UAAU,MAAKA,QACxB,QAAO,MACJ,WAAW,OAAO,MAAM,MAAM,CAAC,CAE/B,YAAY,MAAKA,QAAS,OAAO,OAAO,CAAC;;;;;CAOhD,QAAQ;AACN,OAAK,MAAM,UAAU,MAAKA,QACxB,KAAI;AACF,UAAO,OAAO;UACR;AAOV,QAAKA,QAAS,OAAO;;;;;CAMvB,OAAO;AACL,SAAO,MAAKA,QAAS"}

package/subscribe/StreamFanout.mjs

@@ -0,0 +1,46 @@
+//#region src/subscribe/StreamFanout.ts
+/**
+* Fan out a single input stream to multiple output streams
+*/
+var StreamFanout = class {
+	#writers = /* @__PURE__ */ new Set();
+	/**
+	* Create a new output stream with optional transformation
+	*/
+	createStream(transform) {
+		const { readable, writable } = new TransformStream({ transform: (chunk, controller) => {
+			controller.enqueue(transform ? transform(chunk) : chunk);
+		} });
+		const writer = writable.getWriter();
+		this.#writers.add(writer);
+		writer.closed.catch(() => {}).finally(() => {
+			this.#writers.delete(writer);
+		});
+		return readable;
+	}
+	/**
+	* Write a chunk to all active streams
+	*/
+	write(chunk) {
+		for (const writer of this.#writers) writer.ready.then(() => writer.write(chunk)).catch(() => this.#writers.delete(writer));
+	}
+	/**
+	* Close all active streams
+	*/
+	close() {
+		for (const writer of this.#writers) try {
+			writer.close();
+		} catch {}
+		this.#writers.clear();
+	}
+	/**
+	* Get the number of active streams
+	*/
+	size() {
+		return this.#writers.size;
+	}
+};
+
+//#endregion
+export { StreamFanout };
+//# sourceMappingURL=StreamFanout.mjs.map

package/subscribe/StreamFanout.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"StreamFanout.mjs","names":["#writers"],"sources":["../../src/subscribe/StreamFanout.ts"],"sourcesContent":["/**\r\n * Fan out a single input stream to multiple output streams\r\n */\r\nexport class StreamFanout<TInput = unknown> {\r\n  #writers = new Set<WritableStreamDefaultWriter<TInput>>();\r\n\r\n  /**\r\n   * Create a new output stream with optional transformation\r\n   */\r\n  createStream<TOutput = TInput>(\r\n    /**\r\n     * Optional transform function for each chunk\r\n     */\r\n    transform?: (\r\n      /**\r\n       * Input chunk\r\n       */\r\n      chunk: TInput,\r\n    ) => TOutput,\r\n  ): ReadableStream<TOutput> {\r\n    const { readable, writable } = new TransformStream<TInput, TOutput>({\r\n      transform: (chunk, controller) => {\r\n        controller.enqueue(\r\n          transform ? transform(chunk) : (chunk as unknown as TOutput),\r\n        );\r\n      },\r\n    });\r\n\r\n    const writer = writable.getWriter();\r\n    this.#writers.add(writer);\r\n\r\n    // Eagerly remove the writer is the stream is closed\r\n    writer.closed\r\n      .catch(() => {}) // Suppress unhandled promise rejection to avoid noisy logs\r\n      .finally(() => {\r\n        this.#writers.delete(writer);\r\n      });\r\n\r\n    return readable;\r\n  }\r\n\r\n  /**\r\n   * Write a chunk to all active streams\r\n   */\r\n  write(\r\n    /**\r\n     * Chunk to write\r\n     */\r\n    chunk: TInput,\r\n  ) {\r\n    for (const writer of this.#writers) {\r\n      writer.ready\r\n        .then(() => writer.write(chunk))\r\n        // Dereference the writer if we fail, as this means it's closed\r\n        .catch(() => this.#writers.delete(writer));\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Close all active streams\r\n   */\r\n  close() {\r\n    for (const writer of this.#writers) {\r\n      try {\r\n        writer.close();\r\n      } catch {\r\n        // Ignore errors, as we are closing the stream and the writer may\r\n        // already be closed, especially if the stream is closed before the\r\n        // writer is closed or if the stream is cancelled.\r\n      }\r\n    }\r\n\r\n    this.#writers.clear();\r\n  }\r\n\r\n  /**\r\n   * Get the number of active streams\r\n   */\r\n  size() {\r\n    return this.#writers.size;\r\n  }\r\n}\r\n"],"mappings":";;;;AAGA,IAAa,eAAb,MAA4C;CAC1C,2BAAW,IAAI,KAA0C;;;;CAKzD,aAIE,WAMyB;EACzB,MAAM,EAAE,UAAU,aAAa,IAAI,gBAAiC,EAClE,YAAY,OAAO,eAAe;AAChC,cAAW,QACT,YAAY,UAAU,MAAM,GAAI,MACjC;KAEJ,CAAC;EAEF,MAAM,SAAS,SAAS,WAAW;AACnC,QAAKA,QAAS,IAAI,OAAO;AAGzB,SAAO,OACJ,YAAY,GAAG,CACf,cAAc;AACb,SAAKA,QAAS,OAAO,OAAO;IAC5B;AAEJ,SAAO;;;;;CAMT,MAIE,OACA;AACA,OAAK,MAAM,UAAU,MAAKA,QACxB,QAAO,MACJ,WAAW,OAAO,MAAM,MAAM,CAAC,CAE/B,YAAY,MAAKA,QAAS,OAAO,OAAO,CAAC;;;;;CAOhD,QAAQ;AACN,OAAK,MAAM,UAAU,MAAKA,QACxB,KAAI;AACF,UAAO,OAAO;UACR;AAOV,QAAKA,QAAS,OAAO;;;;;CAMvB,OAAO;AACL,SAAO,MAAKA,QAAS"}

package/subscribe/TokenSubscription.cjs

@@ -0,0 +1,438 @@
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_topic = require('../topic.cjs');
+const require_env = require('../env.cjs');
+const require_util = require('../util.cjs');
+const require_api = require('../api.cjs');
+const require_types = require('../types.cjs');
+const require_StreamFanout = require('./StreamFanout.cjs');
+let debug = require("debug");
+debug = require_runtime.__toESM(debug);
+
+//#region src/subscribe/TokenSubscription.ts
+/**
+* Realtime channel subscription via WebSocket
+*/
+var TokenSubscription = class {
+	#apiBaseUrl;
+	#channelId;
+	#debug = (0, debug.default)("inngest:realtime");
+	#encoder = new TextEncoder();
+	#fanout = new require_StreamFanout.StreamFanout();
+	#running = false;
+	#topics;
+	#ws = null;
+	#signingKey;
+	#signingKeyFallback;
+	#reconnectAttempts = 0;
+	#maxReconnectAttempts = 5;
+	#reconnectDelay = 1e3;
+	#connectionPromise = null;
+	#reconnectTimer = null;
+	/**
+	* Map of stream IDs to their streams and controllers
+	*/
+	#chunkStreams = /* @__PURE__ */ new Map();
+	constructor(token, apiBaseUrl, signingKey, signingKeyFallback) {
+		this.token = token;
+		this.#apiBaseUrl = apiBaseUrl;
+		this.#signingKey = signingKey;
+		this.#signingKeyFallback = signingKeyFallback;
+		if (typeof token.channel === "string") {
+			this.#channelId = token.channel;
+			this.#topics = this.token.topics.reduce((acc, name) => {
+				acc.set(name, require_topic.topic(name));
+				return acc;
+			}, /* @__PURE__ */ new Map());
+		} else {
+			this.#channelId = token.channel.name;
+			this.#topics = this.token.topics.reduce((acc, name) => {
+				acc.set(name, token.channel.topics[name] ?? require_topic.topic(name));
+				return acc;
+			}, /* @__PURE__ */ new Map());
+		}
+	}
+	async getWsUrl(token) {
+		let url;
+		const path = "/v1/realtime/connect";
+		const devEnvVar = require_env.getEnvVar("INNGEST_DEV");
+		if (this.#apiBaseUrl) url = new URL(path, this.#apiBaseUrl);
+		else if (devEnvVar) try {
+			const devUrl = new URL(devEnvVar);
+			url = new URL(path, devUrl);
+		} catch {
+			if (require_util.parseAsBoolean(devEnvVar)) url = new URL(path, "http://localhost:8288/");
+			else url = new URL(path, "https://api.inngest.com/");
+		}
+		else url = new URL(path, require_env.getEnvVar("NODE_ENV") === "production" ? "https://api.inngest.com/" : "http://localhost:8288/");
+		url.protocol = url.protocol === "http:" ? "ws:" : "wss:";
+		url.searchParams.set("token", token);
+		return url;
+	}
+	/**
+	* Establish WebSocket connection
+	*/
+	async connect() {
+		if (this.#connectionPromise) return this.#connectionPromise;
+		if (!this.#running && this.#reconnectAttempts === 0) return;
+		this.#connectionPromise = this.#connect();
+		return this.#connectionPromise;
+	}
+	async #connect() {
+		if (this.#running && this.#ws?.readyState === WebSocket.OPEN) return;
+		this.#debug(`Establishing connection to channel "${this.#channelId}" with topics ${JSON.stringify([...this.#topics.keys()])}...`);
+		if (typeof WebSocket === "undefined") throw new Error("WebSocket is not supported in current environment");
+		let key = this.token.key;
+		if (!key) {
+			this.#debug("No subscription token key passed; attempting to retrieve one automatically...");
+			key = (await this.lazilyGetSubscriptionToken({
+				...this.token,
+				signingKey: this.#signingKey,
+				signingKeyFallback: this.#signingKeyFallback
+			})).key;
+			if (!key) throw new Error("No subscription token key provided and failed to retrieve one automatically");
+		}
+		const ret = require_util.createDeferredPromise();
+		try {
+			if (this.#ws) this.#cleanupWebSocket();
+			this.#ws = new WebSocket(await this.getWsUrl(key));
+			this.#ws.onopen = () => {
+				this.#debug("WebSocket connection established");
+				this.#reconnectAttempts = 0;
+				this.#running = true;
+				this.#connectionPromise = null;
+				ret.resolve();
+			};
+			this.#ws.onmessage = async (event) => {
+				await this.#handleMessage(event);
+			};
+			this.#ws.onerror = (event) => {
+				this.#debug("WebSocket error observed:", event);
+				ret.reject(/* @__PURE__ */ new Error("WebSocket connection error"));
+			};
+			this.#ws.onclose = (event) => {
+				this.#debug("WebSocket closed:", event.code, event.reason);
+				this.#handleClose(event);
+			};
+		} catch (err) {
+			this.#connectionPromise = null;
+			ret.reject(err);
+		}
+		return ret.promise;
+	}
+	#cleanupWebSocket() {
+		if (!this.#ws) return;
+		try {
+			this.#ws.onopen = null;
+			this.#ws.onmessage = null;
+			this.#ws.onerror = null;
+			this.#ws.onclose = null;
+			if (this.#ws.readyState === WebSocket.OPEN || this.#ws.readyState === WebSocket.CONNECTING) this.#ws.close(1e3, "Cleaning up connection");
+		} catch (err) {
+			this.#debug("Error cleaning up WebSocket:", err);
+		}
+		this.#ws = null;
+	}
+	#handleClose(event) {
+		const wasRunning = this.#running;
+		this.#running = false;
+		for (const [streamId, stream] of this.#chunkStreams.entries()) try {
+			stream.controller.close();
+		} catch (err) {
+			this.#debug(`Error closing stream ${streamId}:`, err);
+		}
+		this.#chunkStreams.clear();
+		if (event.code === 1e3 || !wasRunning) {
+			this.#debug("Connection closed normally");
+			this.#connectionPromise = null;
+			this.#fanout.close();
+			return;
+		}
+		if (this.#reconnectAttempts < this.#maxReconnectAttempts) {
+			this.#reconnectAttempts++;
+			const delay = this.#reconnectDelay * Math.pow(2, this.#reconnectAttempts - 1);
+			this.#debug(`Attempting reconnection ${this.#reconnectAttempts}/${this.#maxReconnectAttempts} in ${delay}ms...`);
+			this.#connectionPromise = null;
+			this.#reconnectTimer = setTimeout(() => {
+				this.#reconnectTimer = null;
+				this.connect().catch((err) => {
+					this.#debug("Reconnection failed:", err);
+					if (this.#reconnectAttempts >= this.#maxReconnectAttempts) {
+						this.#debug("Max reconnection attempts reached, closing streams");
+						this.#connectionPromise = null;
+						this.#fanout.close();
+					}
+				});
+			}, delay);
+		} else {
+			this.#debug("Max reconnection attempts reached");
+			this.#connectionPromise = null;
+			this.#fanout.close();
+		}
+	}
+	async #handleMessage(event) {
+		let parsedData;
+		try {
+			parsedData = JSON.parse(event.data);
+		} catch (err) {
+			this.#debug("Failed to parse JSON from WebSocket message:", err);
+			this.#debug("Raw payload:", event.data);
+			return;
+		}
+		const parseRes = await require_types.Realtime.messageSchema.safeParseAsync(parsedData);
+		if (!parseRes.success) {
+			this.#debug("Received invalid message:", parseRes.error);
+			return;
+		}
+		const msg = parseRes.data;
+		if (!this.#running) {
+			this.#debug(`Received message on channel "${msg.channel}" for topic "${msg.topic}" but stream is closed`);
+			return;
+		}
+		switch (msg.kind) {
+			case "data":
+				await this.#handleDataMessage(msg);
+				break;
+			case "datastream-start":
+				this.#handleDataStreamStart(msg);
+				break;
+			case "datastream-end":
+				this.#handleDataStreamEnd(msg);
+				break;
+			case "chunk":
+				this.#handleChunk(msg);
+				break;
+			case "ping":
+				if (this.#ws?.readyState === WebSocket.OPEN) this.#ws.send(JSON.stringify({ kind: "pong" }));
+				break;
+			case "closing":
+				this.#debug("Server is closing connection, will reconnect...");
+				break;
+			default: this.#debug(`Received message on channel "${msg.channel}" with unhandled kind "${msg.kind}"`);
+		}
+	}
+	async #handleDataMessage(msg) {
+		if (!msg.channel) {
+			this.#debug(`Received message with no channel`);
+			return;
+		}
+		if (!msg.topic) {
+			this.#debug(`Received message on channel "${msg.channel}" with no topic`);
+			return;
+		}
+		const topic = this.#topics.get(msg.topic);
+		if (!topic) {
+			this.#debug(`Received message on channel "${msg.channel}" for unknown topic "${msg.topic}"`);
+			return;
+		}
+		const schema = topic.getSchema();
+		if (schema) {
+			const validateRes = await schema["~standard"].validate(msg.data);
+			if (validateRes.issues) {
+				console.error(`Received message on channel "${msg.channel}" for topic "${msg.topic}" that failed schema validation:`, validateRes.issues);
+				return;
+			}
+			msg.data = validateRes.value;
+		}
+		this.#debug(`Received message on channel "${msg.channel}" for topic "${msg.topic}":`, msg.data);
+		this.#fanout.write({
+			channel: msg.channel,
+			topic: msg.topic,
+			data: msg.data,
+			fnId: msg.fn_id,
+			createdAt: msg.created_at || /* @__PURE__ */ new Date(),
+			runId: msg.run_id,
+			kind: "data",
+			envId: msg.env_id
+		});
+	}
+	#handleDataStreamStart(msg) {
+		if (!msg.channel || !msg.topic) {
+			this.#debug(`Received datastream-start with missing channel or topic`);
+			return;
+		}
+		const streamId = msg.data;
+		if (typeof streamId !== "string" || !streamId) {
+			this.#debug(`Received datastream-start with invalid stream ID`);
+			return;
+		}
+		if (this.#chunkStreams.has(streamId)) {
+			this.#debug(`Received datastream-start for stream ID "${streamId}" that already exists`);
+			return;
+		}
+		let holderStream;
+		let holderController;
+		holderStream = new ReadableStream({
+			start: (controller) => {
+				holderController = controller;
+				this.#chunkStreams.set(streamId, {
+					stream: holderStream,
+					controller: holderController
+				});
+			},
+			cancel: () => {
+				this.#chunkStreams.delete(streamId);
+			}
+		});
+		this.#debug(`Created stream ID "${streamId}" on channel "${msg.channel}"`);
+		this.#fanout.write({
+			channel: msg.channel,
+			topic: msg.topic,
+			kind: "datastream-start",
+			data: streamId,
+			streamId,
+			fnId: msg.fn_id,
+			runId: msg.run_id,
+			stream: holderStream
+		});
+	}
+	#handleDataStreamEnd(msg) {
+		if (!msg.channel || !msg.topic) {
+			this.#debug(`Received datastream-end with missing channel or topic`);
+			return;
+		}
+		const streamId = msg.data;
+		if (typeof streamId !== "string" || !streamId) {
+			this.#debug(`Received datastream-end with invalid stream ID`);
+			return;
+		}
+		const stream = this.#chunkStreams.get(streamId);
+		if (!stream) {
+			this.#debug(`Received datastream-end for stream ID "${streamId}" that doesn't exist`);
+			return;
+		}
+		try {
+			stream.controller.close();
+		} catch (err) {
+			this.#debug(`Error closing stream ${streamId}:`, err);
+		}
+		this.#chunkStreams.delete(streamId);
+		this.#debug(`Closed stream ID "${streamId}" on channel "${msg.channel}"`);
+		this.#fanout.write({
+			channel: msg.channel,
+			topic: msg.topic,
+			kind: "datastream-end",
+			data: streamId,
+			streamId,
+			fnId: msg.fn_id,
+			runId: msg.run_id,
+			stream: stream.stream
+		});
+	}
+	#handleChunk(msg) {
+		if (!msg.channel || !msg.topic) {
+			this.#debug(`Received chunk with missing channel or topic`);
+			return;
+		}
+		if (!msg.stream_id) {
+			this.#debug(`Received chunk with no stream ID`);
+			return;
+		}
+		const stream = this.#chunkStreams.get(msg.stream_id);
+		if (!stream) {
+			this.#debug(`Received chunk for unknown stream ID "${msg.stream_id}"`);
+			return;
+		}
+		this.#debug(`Received chunk on channel "${msg.channel}" for stream ID "${msg.stream_id}":`, msg.data);
+		try {
+			stream.controller.enqueue(msg.data);
+		} catch (err) {
+			this.#debug(`Error enqueueing chunk to stream ${msg.stream_id}:`, err);
+		}
+		this.#fanout.write({
+			channel: msg.channel,
+			topic: msg.topic,
+			kind: "chunk",
+			data: msg.data,
+			streamId: msg.stream_id,
+			fnId: msg.fn_id,
+			runId: msg.run_id,
+			stream: stream.stream
+		});
+	}
+	/**
+	* Lazily get a subscription token if not provided
+	*/
+	async lazilyGetSubscriptionToken(args) {
+		const channelId = typeof args.channel === "string" ? args.channel : args.channel.name;
+		if (!channelId) throw new Error("Channel ID is required to create a subscription token");
+		const key = await require_api.api.getSubscriptionToken({
+			channel: channelId,
+			topics: args.topics,
+			signingKey: args.signingKey,
+			signingKeyFallback: args.signingKeyFallback,
+			apiBaseUrl: this.#apiBaseUrl
+		});
+		return {
+			channel: channelId,
+			topics: args.topics,
+			key
+		};
+	}
+	/**
+	* Close the connection and cleanup resources
+	*/
+	close(reason = "Userland closed connection") {
+		if (!this.#running && !this.#ws) return;
+		this.#debug("close() called; closing connection...");
+		this.#running = false;
+		if (this.#reconnectTimer) {
+			clearTimeout(this.#reconnectTimer);
+			this.#reconnectTimer = null;
+		}
+		this.#reconnectAttempts = this.#maxReconnectAttempts;
+		this.#cleanupWebSocket();
+		for (const [streamId, stream] of this.#chunkStreams.entries()) try {
+			stream.controller.close();
+		} catch (err) {
+			this.#debug(`Error closing stream ${streamId}:`, err);
+		}
+		this.#chunkStreams.clear();
+		this.#debug(`Closing ${this.#fanout.size()} streams...`);
+		this.#fanout.close();
+	}
+	/**
+	* Get a new JSON stream from the subscription
+	*/
+	getJsonStream() {
+		return this.#fanout.createStream();
+	}
+	/**
+	* Get a new encoded stream (SSE-compatible) from the subscription
+	*/
+	getEncodedStream() {
+		return this.#fanout.createStream((chunk) => {
+			return this.#encoder.encode(`${JSON.stringify(chunk)}\n`);
+		});
+	}
+	/**
+	* Use a callback to handle messages from the stream
+	*/
+	useCallback(callback, stream = this.getJsonStream()) {
+		(async () => {
+			const reader = stream.getReader();
+			try {
+				while (this.#running) {
+					const { done, value } = await reader.read();
+					if (done || !this.#running) break;
+					try {
+						callback(value);
+					} catch (err) {
+						this.#debug("Error in callback:", err);
+					}
+				}
+			} catch (err) {
+				this.#debug("Error reading from stream:", err);
+			} finally {
+				try {
+					reader.releaseLock();
+				} catch (err) {
+					this.#debug("Error releasing reader lock:", err);
+				}
+			}
+		})();
+	}
+};
+
+//#endregion
+exports.TokenSubscription = TokenSubscription;
+//# sourceMappingURL=TokenSubscription.cjs.map