devframe 0.2.2 → 0.3.0

package/dist/{host-h3-DEfOpa0j.mjs → host-h3-TTunNr_n.mjs}

@@ -1,13 +1,9 @@
-import { l as RpcFunctionsCollectorBase } from "./rpc-BlVCyk9W.mjs";
-import { r as diagnostics } from "./serialization-CwO31axa.mjs";
+import { t as devframeReporter } from "./diagnostics-reporter-CBBZwoMv.mjs";
+import { t as diagnostics } from "./diagnostics-GitRGKbr.mjs";
+import { RpcFunctionsCollectorBase } from "./rpc/index.mjs";
 import { defineRpcFunction } from "./index.mjs";
-import { colors as colors$1 } from "./utils/colors.mjs";
-import { n as logger, t as diagnostics$1 } from "./diagnostics-DNxVjo6X.mjs";
-import { createEventEmitter } from "./utils/events.mjs";
-import { t as createSharedState } from "./shared-state-BJXkPxtf.mjs";
-import { createStreamReader, createStreamSink } from "./utils/streaming-channel.mjs";
-import { consoleReporter, createLogger, defineDiagnostics } from "logs-sdk";
-import { ansiFormatter } from "logs-sdk/formatters/ansi";
+import { i as diagnostics$1, n as nanoid, r as createEventEmitter, t as createSharedState } from "./shared-state-CasqoUba.mjs";
+import { defineDiagnostics } from "nostics";
 import { isatty } from "node:tty";
 import { formatWithOptions, inspect } from "node:util";
 import { existsSync } from "node:fs";
@@ -55,7 +51,7 @@ var DevToolsAgentHost = class {
 		return existed;
 	}
 	registerResource(input) {
-		if (this.resources.has(input.id)) throw logger.DF0016({ id: input.id }).throw();
+		if (this.resources.has(input.id)) throw diagnostics$1.DF0016.throw({ id: input.id });
 		const resource = {
 			id: input.id,
 			name: input.name,
@@ -117,11 +113,11 @@ var DevToolsAgentHost = class {
 		this._rpcUnsubscribe = void 0;
 	}
 	_validateToolId(id) {
-		if (this.tools.has(id)) throw logger.DF0015({ id }).throw();
-		if (this.context.rpc.definitions.get(id)?.agent) throw logger.DF0015({ id }).throw();
+		if (this.tools.has(id)) throw diagnostics$1.DF0015.throw({ id });
+		if (this.context.rpc.definitions.get(id)?.agent) throw diagnostics$1.DF0015.throw({ id });
 	}
 	_projectTool(input) {
-		if (!input.description || typeof input.description !== "string") throw logger.DF0014({ name: input.id }).throw();
+		if (!input.description || typeof input.description !== "string") throw diagnostics$1.DF0014.throw({ name: input.id });
 		return {
 			id: input.id,
 			kind: "tool",
@@ -139,7 +135,7 @@ var DevToolsAgentHost = class {
 		for (const [name, def] of this.context.rpc.definitions) {
 			const agent = def.agent;
 			if (!agent) continue;
-			if (!agent.description || typeof agent.description !== "string") throw logger.DF0014({ name }).throw();
+			if (!agent.description || typeof agent.description !== "string") throw diagnostics$1.DF0014.throw({ name });
 			const type = def.type ?? "query";
 			const safety = agent.safety ?? inferSafety(type);
 			out.push({
@@ -190,28 +186,20 @@ function hasPositionalKeys(obj) {
 //#region src/node/host-diagnostics.ts
 var DevToolsDiagnosticsHost = class {
 	context;
-	_definitions = [];
-	_logger;
-	defineDiagnostics = defineDiagnostics;
-	createLogger = createLogger;
+	_registry = {};
+	logger = new Proxy({}, { get: (_, code) => this._registry[code] });
+	defineDiagnostics = (opts) => {
+		return defineDiagnostics({
+			...opts,
+			reporters: [devframeReporter, ...opts.reporters ?? []]
+		});
+	};
 	constructor(context, initialDefinitions = []) {
 		this.context = context;
-		this._definitions = [...initialDefinitions];
-		this._rebuild();
-	}
-	get logger() {
-		return this._logger;
+		for (const d of initialDefinitions) this.register(d);
 	}
-	register(definitions) {
-		this._definitions.push(definitions);
-		this._rebuild();
-	}
-	_rebuild() {
-		this._logger = createLogger({
-			diagnostics: this._definitions,
-			formatter: ansiFormatter(colors$1),
-			reporters: consoleReporter
-		});
+	register(diagnostics) {
+		Object.assign(this._registry, diagnostics);
 	}
 };
 //#endregion
@@ -515,7 +503,7 @@ function createRpcSharedStateServerHost(rpc) {
 	const host = {
 		get: async (key, options) => {
 			if (sharedState.has(key)) return sharedState.get(key);
-			if (options?.initialValue === void 0 && options?.sharedState === void 0) throw logger.DF0013({ key }).throw();
+			if (options?.initialValue === void 0 && options?.sharedState === void 0) throw diagnostics$1.DF0013.throw({ key });
 			debug$1("new-state", key);
 			const state = options.sharedState ?? createSharedState({
 				initialValue: options.initialValue,
@@ -576,6 +564,258 @@ function createRpcSharedStateServerHost(rpc) {
 	return host;
 }
 //#endregion
+//#region src/utils/streaming-channel.ts
+const DEFAULT_HIGH_WATER_MARK = 256;
+var StreamClosedError = class extends Error {
+	name = "StreamClosedError";
+};
+/**
+* Build a server-side stream sink. RPC-agnostic — the RPC host wires
+* `events.on('chunk' | 'end')` to broadcast, and reads `buffer` to replay
+* for late or reconnecting subscribers.
+*/
+function createStreamSink(options = {}) {
+	const id = options.id ?? nanoid();
+	const replayWindow = Math.max(0, options.replayWindow ?? 0);
+	const events = createEventEmitter();
+	const controller = new AbortController();
+	const buffer = [];
+	let closed = false;
+	let lastSeq = 0;
+	function write(chunk) {
+		if (closed) throw new StreamClosedError(`Cannot write to a closed stream "${id}"`);
+		lastSeq += 1;
+		if (replayWindow > 0) {
+			buffer.push({
+				seq: lastSeq,
+				chunk
+			});
+			if (buffer.length > replayWindow) buffer.splice(0, buffer.length - replayWindow);
+		}
+		events.emit("chunk", lastSeq, chunk);
+	}
+	function error(reason) {
+		if (closed) return;
+		closed = true;
+		const payload = toErrorPayload(reason);
+		controller.abort(reason);
+		events.emit("end", payload);
+	}
+	function close() {
+		if (closed) return;
+		closed = true;
+		if (!controller.signal.aborted) controller.abort("stream closed");
+		events.emit("end", void 0);
+	}
+	function abort(reason) {
+		if (closed) return;
+		if (!controller.signal.aborted) controller.abort(reason ?? "aborted");
+	}
+	const writable = new WritableStream({
+		write(chunk) {
+			write(chunk);
+		},
+		close() {
+			close();
+		},
+		abort(reason) {
+			error(reason);
+		}
+	});
+	return {
+		id,
+		signal: controller.signal,
+		get closed() {
+			return closed;
+		},
+		get lastSeq() {
+			return lastSeq;
+		},
+		write,
+		error,
+		close,
+		abort,
+		writable,
+		events,
+		buffer
+	};
+}
+/**
+* Build a client-side stream reader. RPC-agnostic — the RPC host calls
+* `_push(seq, chunk)` on each incoming chunk and `_end(error?)` on the
+* terminal frame. Consumers iterate with `for await` or pipe `readable`.
+*/
+function createStreamReader(options = {}) {
+	const id = options.id ?? nanoid();
+	const highWaterMark = Math.max(1, options.highWaterMark ?? DEFAULT_HIGH_WATER_MARK);
+	const queue = [];
+	let lastSeenSeq = 0;
+	let done = false;
+	let cancelled = false;
+	let endError;
+	let pending;
+	let pullController;
+	let readableInstance;
+	function drainNext() {
+		if (!pending) return;
+		if (queue.length > 0) {
+			const value = queue.shift();
+			const r = pending;
+			pending = void 0;
+			r.resolve({
+				value,
+				done: false
+			});
+			return;
+		}
+		if (done) {
+			const r = pending;
+			pending = void 0;
+			if (endError) {
+				const err = new Error(endError.message);
+				err.name = endError.name;
+				r.reject(err);
+			} else r.resolve({
+				value: void 0,
+				done: true
+			});
+		}
+	}
+	function feedReadable() {
+		if (!pullController) return;
+		while (queue.length > 0) {
+			const v = queue.shift();
+			try {
+				pullController.enqueue(v);
+			} catch {
+				break;
+			}
+		}
+		if (done && pullController) {
+			try {
+				if (endError) {
+					const err = new Error(endError.message);
+					err.name = endError.name;
+					pullController.error(err);
+				} else pullController.close();
+			} catch {}
+			pullController = void 0;
+		}
+	}
+	function push(seq, chunk) {
+		if (done || cancelled) return;
+		if (seq <= lastSeenSeq) return;
+		lastSeenSeq = seq;
+		queue.push(chunk);
+		if (queue.length > highWaterMark) {
+			const overflow = queue.length - highWaterMark;
+			queue.splice(0, overflow);
+			options.onOverflow?.(overflow);
+		}
+		drainNext();
+		if (readableInstance) feedReadable();
+	}
+	function end(error) {
+		if (done) return;
+		done = true;
+		endError = error;
+		drainNext();
+		if (readableInstance) feedReadable();
+	}
+	function cancel() {
+		if (cancelled || done) return;
+		cancelled = true;
+		options.onCancel?.();
+		end(void 0);
+	}
+	function getReadable() {
+		if (readableInstance) return readableInstance;
+		readableInstance = new ReadableStream({
+			start(controller) {
+				pullController = controller;
+				feedReadable();
+			},
+			cancel() {
+				cancel();
+			}
+		});
+		return readableInstance;
+	}
+	return {
+		id,
+		get cancelled() {
+			return cancelled;
+		},
+		get done() {
+			return done;
+		},
+		get lastSeenSeq() {
+			return lastSeenSeq;
+		},
+		get readable() {
+			return getReadable();
+		},
+		cancel,
+		_push: push,
+		_end: end,
+		[Symbol.asyncIterator]() {
+			return {
+				next() {
+					if (queue.length > 0) return Promise.resolve({
+						value: queue.shift(),
+						done: false
+					});
+					if (done) {
+						if (endError) {
+							const err = new Error(endError.message);
+							err.name = endError.name;
+							return Promise.reject(err);
+						}
+						return Promise.resolve({
+							value: void 0,
+							done: true
+						});
+					}
+					return new Promise((resolve, reject) => {
+						pending = {
+							resolve,
+							reject
+						};
+					});
+				},
+				return() {
+					cancel();
+					return Promise.resolve({
+						value: void 0,
+						done: true
+					});
+				}
+			};
+		}
+	};
+}
+function toErrorPayload(reason) {
+	if (reason instanceof Error) return {
+		name: reason.name || "Error",
+		message: reason.message
+	};
+	if (typeof reason === "string") return {
+		name: "Error",
+		message: reason
+	};
+	try {
+		return {
+			name: "Error",
+			message: JSON.stringify(reason)
+		};
+	} catch {
+		return {
+			name: "Error",
+			message: String(reason)
+		};
+	}
+}
+//#endregion
 //#region src/node/rpc-streaming.ts
 const debug = createDebug("vite:devtools:rpc:streaming");
 const STREAM_KEY_SEPARATOR = "";
@@ -628,18 +868,18 @@ function createRpcStreamingServerHost(rpc) {
 		handler(channelName, id, opts) {
 			const state = channels.get(channelName);
 			if (!state) {
-				logger.DF0030({
+				diagnostics$1.DF0030.report({
 					channel: channelName,
 					id
-				}).log();
+				}, { method: "error" });
 				return;
 			}
 			const record = state.streams.get(id);
 			if (!record) {
-				logger.DF0030({
+				diagnostics$1.DF0030.report({
 					channel: channelName,
 					id
-				}).log();
+				}, { method: "error" });
 				return;
 			}
 			const session = rpc.getCurrentRpcSession();
@@ -709,10 +949,10 @@ function createRpcStreamingServerHost(rpc) {
 		handler(channelName, id, seq, chunk) {
 			const record = channels.get(channelName)?.inbound.get(id);
 			if (!record) {
-				logger.DF0030({
+				diagnostics$1.DF0030.report({
 					channel: channelName,
 					id
-				}).log();
+				}, { method: "error" });
 				return;
 			}
 			if (!record.uploaderMeta) {
@@ -739,7 +979,7 @@ function createRpcStreamingServerHost(rpc) {
 		}
 	});
 	function createChannel(name, opts = {}) {
-		if (channels.has(name)) throw logger.DF0032({ channel: name }).throw();
+		if (channels.has(name)) throw diagnostics$1.DF0032.throw({ channel: name });
 		const replayWindow = opts.replayWindow ?? 0;
 		const state = {
 			name,
@@ -902,7 +1142,7 @@ var RpcFunctionsHost = class extends RpcFunctionsCollectorBase {
 		this.streaming._onSessionDisconnected(meta);
 	}
 	async invokeLocal(method, ...args) {
-		if (!this.definitions.has(method)) throw logger.DF0006({ name: String(method) }).throw();
+		if (!this.definitions.has(method)) throw diagnostics$1.DF0006.throw({ name: String(method) });
 		const handler = await this.getHandler(method);
 		return await Promise.resolve(handler(...args));
 	}
@@ -919,7 +1159,7 @@ var RpcFunctionsHost = class extends RpcFunctionsCollectorBase {
 		}));
 	}
 	getCurrentRpcSession() {
-		if (!this._asyncStorage) throw logger.DF0007().throw();
+		if (!this._asyncStorage) throw diagnostics$1.DF0007.throw();
 		return this._asyncStorage.getStore();
 	}
 };
@@ -935,7 +1175,7 @@ var DevToolsViewHost = class {
 		this.context = context;
 	}
 	hostStatic(baseUrl, distDir) {
-		if (!existsSync(distDir)) throw logger.DF0008({ distDir }).throw();
+		if (!existsSync(distDir)) throw diagnostics$1.DF0008.throw({ distDir });
 		this.buildStaticDirs.push({
 			baseUrl,
 			distDir