devframe 0.2.2 → 0.2.3

package/dist/{rpc-BlVCyk9W.mjs → dump-C5LPsKJC.mjs}

@@ -1,133 +1,128 @@
-import { t as hash } from "./hash-CIBte1yS.mjs";
-import { i as logger } from "./serialization-CwO31axa.mjs";
+import { n as logger } from "./diagnostics-D7miaTpL.mjs";
 import { DEVTOOLS_RPC_DUMP_DIRNAME } from "./constants.mjs";
-//#region src/rpc/cache.ts
-/**
-* @experimental API is expected to change.
-*/
-var RpcCacheManager = class {
-	cacheMap = /* @__PURE__ */ new Map();
-	options;
-	keySerializer;
-	constructor(options) {
-		this.options = options;
-		this.keySerializer = options.keySerializer || ((args) => hash(args));
-	}
-	updateOptions(options) {
-		this.options = {
-			...this.options,
-			...options
-		};
-	}
-	cached(m, a) {
-		const methodCache = this.cacheMap.get(m);
-		if (methodCache) return methodCache.get(this.keySerializer(a));
-	}
-	apply(req, res) {
-		const methodCache = this.cacheMap.get(req.m) || /* @__PURE__ */ new Map();
-		methodCache.set(this.keySerializer(req.a), res);
-		this.cacheMap.set(req.m, methodCache);
-	}
-	validate(m) {
-		return this.options.functions.includes(m);
-	}
-	clear(fn) {
-		if (fn) this.cacheMap.delete(fn);
-		else this.cacheMap.clear();
+import { createHash } from "node:crypto";
+//#region ../../node_modules/.pnpm/ohash@2.0.11/node_modules/ohash/dist/shared/ohash.D__AXeF1.mjs
+function serialize(o) {
+	return typeof o == "string" ? `'${o}'` : new c().serialize(o);
+}
+const c = /* @__PURE__ */ function() {
+	class o {
+		#t = /* @__PURE__ */ new Map();
+		compare(t, r) {
+			const e = typeof t, n = typeof r;
+			return e === "string" && n === "string" ? t.localeCompare(r) : e === "number" && n === "number" ? t - r : String.prototype.localeCompare.call(this.serialize(t, true), this.serialize(r, true));
+		}
+		serialize(t, r) {
+			if (t === null) return "null";
+			switch (typeof t) {
+				case "string": return r ? t : `'${t}'`;
+				case "bigint": return `${t}n`;
+				case "object": return this.$object(t);
+				case "function": return this.$function(t);
+			}
+			return String(t);
+		}
+		serializeObject(t) {
+			const r = Object.prototype.toString.call(t);
+			if (r !== "[object Object]") return this.serializeBuiltInType(r.length < 10 ? `unknown:${r}` : r.slice(8, -1), t);
+			const e = t.constructor, n = e === Object || e === void 0 ? "" : e.name;
+			if (n !== "" && globalThis[n] === e) return this.serializeBuiltInType(n, t);
+			if (typeof t.toJSON == "function") {
+				const i = t.toJSON();
+				return n + (i !== null && typeof i == "object" ? this.$object(i) : `(${this.serialize(i)})`);
+			}
+			return this.serializeObjectEntries(n, Object.entries(t));
+		}
+		serializeBuiltInType(t, r) {
+			const e = this["$" + t];
+			if (e) return e.call(this, r);
+			if (typeof r?.entries == "function") return this.serializeObjectEntries(t, r.entries());
+			throw new Error(`Cannot serialize ${t}`);
+		}
+		serializeObjectEntries(t, r) {
+			const e = Array.from(r).sort((i, a) => this.compare(i[0], a[0]));
+			let n = `${t}{`;
+			for (let i = 0; i < e.length; i++) {
+				const [a, l] = e[i];
+				n += `${this.serialize(a, true)}:${this.serialize(l)}`, i < e.length - 1 && (n += ",");
+			}
+			return n + "}";
+		}
+		$object(t) {
+			let r = this.#t.get(t);
+			return r === void 0 && (this.#t.set(t, `#${this.#t.size}`), r = this.serializeObject(t), this.#t.set(t, r)), r;
+		}
+		$function(t) {
+			const r = Function.prototype.toString.call(t);
+			return r.slice(-15) === "[native code] }" ? `${t.name || ""}()[native]` : `${t.name}(${t.length})${r.replace(/\s*\n\s*/g, "")}`;
+		}
+		$Array(t) {
+			let r = "[";
+			for (let e = 0; e < t.length; e++) r += this.serialize(t[e]), e < t.length - 1 && (r += ",");
+			return r + "]";
+		}
+		$Date(t) {
+			try {
+				return `Date(${t.toISOString()})`;
+			} catch {
+				return "Date(null)";
+			}
+		}
+		$ArrayBuffer(t) {
+			return `ArrayBuffer[${new Uint8Array(t).join(",")}]`;
+		}
+		$Set(t) {
+			return `Set${this.$Array(Array.from(t).sort((r, e) => this.compare(r, e)))}`;
+		}
+		$Map(t) {
+			return this.serializeObjectEntries("Map", t.entries());
+		}
 	}
-};
+	for (const s of [
+		"Error",
+		"RegExp",
+		"URL"
+	]) o.prototype["$" + s] = function(t) {
+		return `${s}(${t})`;
+	};
+	for (const s of [
+		"Int8Array",
+		"Uint8Array",
+		"Uint8ClampedArray",
+		"Int16Array",
+		"Uint16Array",
+		"Int32Array",
+		"Uint32Array",
+		"Float32Array",
+		"Float64Array"
+	]) o.prototype["$" + s] = function(t) {
+		return `${s}[${t.join(",")}]`;
+	};
+	for (const s of ["BigInt64Array", "BigUint64Array"]) o.prototype["$" + s] = function(t) {
+		return `${s}[${t.join("n,")}${t.length > 0 ? "n" : ""}]`;
+	};
+	return o;
+}();
 //#endregion
-//#region src/rpc/handler.ts
-async function getRpcResolvedSetupResult(definition, context) {
-	if (definition.__resolved) return definition.__resolved;
-	if (!definition.setup) return {};
-	definition.__promise ??= Promise.resolve(definition.setup(context)).then((r) => {
-		definition.__resolved = r;
-		definition.__promise = void 0;
-		return r;
-	});
-	return definition.__resolved ??= await definition.__promise;
+//#region ../../node_modules/.pnpm/ohash@2.0.11/node_modules/ohash/dist/crypto/node/index.mjs
+const e = globalThis.process?.getBuiltinModule?.("crypto")?.hash, r = "sha256", s = "base64url";
+function digest(t) {
+	if (e) return e(r, t, s);
+	const o = createHash(r).update(t);
+	return globalThis.process?.versions?.webcontainer ? o.digest().toString(s) : o.digest(s);
 }
-async function getRpcHandler(definition, context) {
-	if (definition.handler) return definition.handler;
-	const result = await getRpcResolvedSetupResult(definition, context);
-	if (!result.handler) throw logger.DF0024({ name: definition.name }).throw();
-	return result.handler;
+//#endregion
+//#region ../../node_modules/.pnpm/ohash@2.0.11/node_modules/ohash/dist/index.mjs
+function hash$1(input) {
+	return digest(serialize(input));
 }
 //#endregion
-//#region src/rpc/collector.ts
-var RpcFunctionsCollectorBase = class {
-	context;
-	definitions = /* @__PURE__ */ new Map();
-	functions;
-	_onChanged = [];
-	constructor(context) {
-		this.context = context;
-		const definitions = this.definitions;
-		const self = this;
-		this.functions = new Proxy({}, {
-			get(_, prop) {
-				const definition = definitions.get(prop);
-				if (!definition) return void 0;
-				return getRpcHandler(definition, self.context);
-			},
-			has(_, prop) {
-				return definitions.has(prop);
-			},
-			getOwnPropertyDescriptor(_, prop) {
-				return {
-					value: definitions.get(prop)?.handler,
-					configurable: true,
-					enumerable: true
-				};
-			},
-			ownKeys() {
-				return Array.from(definitions.keys());
-			}
-		});
-	}
-	register(fn, force = false) {
-		if (this.definitions.has(fn.name) && !force) throw logger.DF0021({ name: fn.name }).throw();
-		assertAgentJsonSerializable(fn);
-		this.definitions.set(fn.name, fn);
-		this._onChanged.forEach((cb) => cb(fn.name));
-	}
-	update(fn, force = false) {
-		if (!this.definitions.has(fn.name) && !force) throw logger.DF0022({ name: fn.name }).throw();
-		assertAgentJsonSerializable(fn);
-		this.definitions.set(fn.name, fn);
-		this._onChanged.forEach((cb) => cb(fn.name));
-	}
-	onChanged(fn) {
-		this._onChanged.push(fn);
-		return () => {
-			const index = this._onChanged.indexOf(fn);
-			if (index !== -1) this._onChanged.splice(index, 1);
-		};
-	}
-	async getHandler(name) {
-		return await getRpcHandler(this.definitions.get(name), this.context);
-	}
-	getSchema(name) {
-		const definition = this.definitions.get(name);
-		if (!definition) throw logger.DF0023({ name: String(name) }).throw();
-		return {
-			args: definition.args,
-			returns: definition.returns
-		};
-	}
-	has(name) {
-		return this.definitions.has(name);
-	}
-	get(name) {
-		return this.definitions.get(name);
-	}
-	list() {
-		return Array.from(this.definitions.keys());
-	}
-};
-function assertAgentJsonSerializable(fn) {
-	if (fn.agent && fn.jsonSerializable !== true) throw logger.DF0019({ name: fn.name }).throw();
+//#region src/utils/hash.ts
+/**
+* Stable, deterministic hash of any structured-cloneable value.
+*/
+function hash(value) {
+	return hash$1(value);
 }
 //#endregion
 //#region ../../node_modules/.pnpm/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
@@ -339,7 +334,7 @@ function isPlainErrorShape(value) {
 	return typeof value === "object" && value !== null && typeof value.message === "string" && typeof value.name === "string";
 }
 //#endregion
-//#region src/rpc/dump/index.ts
+//#region src/rpc/dump/collect.ts
 function getDumpRecordKey(functionName, args) {
 	return `${functionName}---${hash(args)}`;
 }
@@ -501,6 +496,24 @@ function getDefinitionsWithDumps(definitions) {
 	return definitions.filter((def) => def.dump !== void 0);
 }
 //#endregion
+//#region src/rpc/handler.ts
+async function getRpcResolvedSetupResult(definition, context) {
+	if (definition.__resolved) return definition.__resolved;
+	if (!definition.setup) return {};
+	definition.__promise ??= Promise.resolve(definition.setup(context)).then((r) => {
+		definition.__resolved = r;
+		definition.__promise = void 0;
+		return r;
+	});
+	return definition.__resolved ??= await definition.__promise;
+}
+async function getRpcHandler(definition, context) {
+	if (definition.handler) return definition.handler;
+	const result = await getRpcResolvedSetupResult(definition, context);
+	if (!result.handler) throw logger.DF0024({ name: definition.name }).throw();
+	return result.handler;
+}
+//#endregion
 //#region src/rpc/dump/static.ts
 function makeDumpKey(name) {
 	return encodeURIComponent(name.replaceAll(":", "~"));
@@ -578,4 +591,4 @@ async function collectStaticRpcDump(definitions, context) {
 	};
 }
 //#endregion
-export { reviveDumpError as a, validateDefinitions as c, getRpcResolvedSetupResult as d, RpcCacheManager as f, getDefinitionsWithDumps as i, RpcFunctionsCollectorBase as l, createClientFromDump as n, serializeDumpError as o, dumpFunctions as r, validateDefinition as s, collectStaticRpcDump as t, getRpcHandler as u };
+export { dumpFunctions as a, serializeDumpError as c, hash as d, createClientFromDump as i, validateDefinition as l, getRpcHandler as n, getDefinitionsWithDumps as o, getRpcResolvedSetupResult as r, reviveDumpError as s, collectStaticRpcDump as t, validateDefinitions as u };

package/dist/helpers/vite.d.mts

@@ -1,4 +1,4 @@
-import { r as DevframeDefinition } from "../devframe-DAfZWnpI.mjs";
+import { r as DevframeDefinition } from "../devframe-C4DNeFuG.mjs";
 
 //#region src/helpers/vite.d.ts
 interface ViteDevBridgeOptions {

package/dist/helpers/vite.mjs

@@ -1,8 +1,8 @@
 import { DEVTOOLS_CONNECTION_META_FILENAME } from "../constants.mjs";
-import { n as logger } from "../diagnostics-DNxVjo6X.mjs";
-import { n as resolveBasePath } from "../_shared-CUFqO4kJ.mjs";
+import { a as logger } from "../shared-state-SzgfilJP.mjs";
+import { n as resolveBasePath } from "../_shared-BNoPn1NG.mjs";
 import { serveStaticNodeMiddleware } from "../utils/serve-static.mjs";
-import { n as resolveDevServerPort, t as createDevServer } from "../dev-CZ9ZQkuO.mjs";
+import { n as resolveDevServerPort, t as createDevServer } from "../dev-BVtS7qBK.mjs";
 import { resolve } from "pathe";
 //#region src/helpers/vite.ts
 /**

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

@@ -1,11 +1,7 @@
-import { l as RpcFunctionsCollectorBase } from "./rpc-BlVCyk9W.mjs";
-import { r as diagnostics } from "./serialization-CwO31axa.mjs";
+import { t as diagnostics } from "./diagnostics-D7miaTpL.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 { a as logger, i as diagnostics$1, n as nanoid, o as colors$1, r as createEventEmitter, t as createSharedState } from "./shared-state-SzgfilJP.mjs";
 import { consoleReporter, createLogger, defineDiagnostics } from "logs-sdk";
 import { ansiFormatter } from "logs-sdk/formatters/ansi";
 import { isatty } from "node:tty";
@@ -576,6 +572,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 = "";