@powerlines/engine 0.47.3 → 0.49.1

package/dist/helpers/finalize.d.cts

@@ -0,0 +1,12 @@
+import { ExecutionContext, ResolvedConfig } from "@powerlines/core";
+
+//#region src/helpers/finalize.d.ts
+/**
+ * Finalize the execution context by disposing resources and cleaning up.
+ *
+ * @param context - The execution context to finalize
+ */
+declare function finalize<TResolvedConfig extends ResolvedConfig = ResolvedConfig>(context: ExecutionContext<TResolvedConfig>): Promise<void>;
+//#endregion
+export { finalize };
+//# sourceMappingURL=finalize.d.cts.map

package/dist/helpers/finalize.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finalize.d.cts","names":[],"sources":["../../src/helpers/finalize.ts"],"mappings":";;;;;AA+BA;;;iBAAsB,QAAA,yBACI,cAAA,GAAiB,cAAA,CAAA,CACzC,OAAA,EAAS,gBAAA,CAAiB,eAAA,IAAgB,OAAA"}

package/dist/helpers/finalize.d.mts

@@ -0,0 +1,12 @@
+import { ExecutionContext, ResolvedConfig } from "@powerlines/core";
+
+//#region src/helpers/finalize.d.ts
+/**
+ * Finalize the execution context by disposing resources and cleaning up.
+ *
+ * @param context - The execution context to finalize
+ */
+declare function finalize<TResolvedConfig extends ResolvedConfig = ResolvedConfig>(context: ExecutionContext<TResolvedConfig>): Promise<void>;
+//#endregion
+export { finalize };
+//# sourceMappingURL=finalize.d.mts.map

package/dist/helpers/finalize.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finalize.d.mts","names":[],"sources":["../../src/helpers/finalize.ts"],"mappings":";;;;;AA+BA;;;iBAAsB,QAAA,yBACI,cAAA,GAAiB,cAAA,CAAA,CACzC,OAAA,EAAS,gBAAA,CAAiB,eAAA,IAAgB,OAAA"}

package/dist/helpers/finalize.mjs

@@ -0,0 +1,26 @@
+import { executeEnvironments } from "@powerlines/core/lib/environment";
+import { existsSync } from "node:fs";
+import { removeDirectory } from "@stryke/fs/helpers";
+import { joinPaths } from "@stryke/path/join";
+import { listFiles } from "@stryke/fs/list-files";
+import { callHook } from "@powerlines/core/lib/hooks";
+
+//#region src/helpers/finalize.ts
+/**
+* Finalize the execution context by disposing resources and cleaning up.
+*
+* @param context - The execution context to finalize
+*/
+async function finalize(context) {
+	const timer = context.timer("Finalization");
+	await executeEnvironments(context, async (env) => {
+		await callHook(context, "finalize", { environment: env });
+		await env.fs.dispose();
+		if (existsSync(env.cachePath) && !(await listFiles(joinPaths(env.cachePath, "**/*")))?.length) await removeDirectory(env.cachePath);
+	});
+	timer();
+}
+
+//#endregion
+export { finalize };
+//# sourceMappingURL=finalize.mjs.map

package/dist/helpers/finalize.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"finalize.mjs","names":[],"sources":["../../src/helpers/finalize.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                   ⚡ Storm Software - Powerlines\n\n This code was released as part of the Powerlines project. Powerlines\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/powerlines.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/powerlines\n Documentation:            https://docs.stormsoftware.com/projects/powerlines\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport type { ExecutionContext, ResolvedConfig } from \"@powerlines/core\";\nimport { executeEnvironments } from \"@powerlines/core/lib/environment\";\nimport { callHook } from \"@powerlines/core/lib/hooks\";\nimport { removeDirectory } from \"@stryke/fs/helpers\";\nimport { listFiles } from \"@stryke/fs/list-files\";\nimport { joinPaths } from \"@stryke/path/join\";\nimport { existsSync } from \"node:fs\";\n\n/**\n * Finalize the execution context by disposing resources and cleaning up.\n *\n * @param context - The execution context to finalize\n */\nexport async function finalize<\n  TResolvedConfig extends ResolvedConfig = ResolvedConfig\n>(context: ExecutionContext<TResolvedConfig>) {\n  const timer = context.timer(\"Finalization\");\n\n  await executeEnvironments(context, async env => {\n    await callHook(context, \"finalize\", { environment: env });\n    await env.fs.dispose();\n\n    if (\n      existsSync(env.cachePath) &&\n      !(await listFiles(joinPaths(env.cachePath, \"**/*\")))?.length\n    ) {\n      await removeDirectory(env.cachePath);\n    }\n  });\n\n  timer();\n}\n"],"mappings":";;;;;;;;;;;;;AA+BA,eAAsB,SAEpB,SAA4C;CAC5C,MAAM,QAAQ,QAAQ,MAAM,cAAc;CAE1C,MAAM,oBAAoB,SAAS,OAAM,QAAO;EAC9C,MAAM,SAAS,SAAS,YAAY,EAAE,aAAa,IAAI,CAAC;EACxD,MAAM,IAAI,GAAG,QAAQ;EAErB,IACE,WAAW,IAAI,SAAS,KACxB,EAAE,MAAM,UAAU,UAAU,IAAI,WAAW,MAAM,CAAC,IAAI,QAEtD,MAAM,gBAAgB,IAAI,SAAS;CAEvC,CAAC;CAED,MAAM;AACR"}

package/dist/helpers/index.cjs

@@ -0,0 +1,12 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_helpers_rpc = require('./rpc.cjs');
+const require_helpers_stream = require('./stream.cjs');
+const require_helpers_create_execution_host = require('./create-execution-host.cjs');
+const require_helpers_finalize = require('./finalize.cjs');
+
+exports.MessagePortDuplex = require_helpers_stream.MessagePortDuplex;
+exports.MessagePortReadable = require_helpers_stream.MessagePortReadable;
+exports.MessagePortWritable = require_helpers_stream.MessagePortWritable;
+exports.createExecutionHost = require_helpers_create_execution_host.createExecutionHost;
+exports.createRpcClient = require_helpers_rpc.createRpcClient;
+exports.finalize = require_helpers_finalize.finalize;

package/dist/helpers/index.d.cts

@@ -0,0 +1,5 @@
+import { createExecutionHost } from "./create-execution-host.cjs";
+import { finalize } from "./finalize.cjs";
+import { createRpcClient } from "./rpc.cjs";
+import { MessagePortDuplex, MessagePortDuplexOptions, MessagePortReadable, MessagePortWritable } from "./stream.cjs";
+export { MessagePortDuplex, MessagePortDuplexOptions, MessagePortReadable, MessagePortWritable, createExecutionHost, createRpcClient, finalize };

package/dist/helpers/index.d.mts

@@ -0,0 +1,5 @@
+import { createExecutionHost } from "./create-execution-host.mjs";
+import { finalize } from "./finalize.mjs";
+import { createRpcClient } from "./rpc.mjs";
+import { MessagePortDuplex, MessagePortDuplexOptions, MessagePortReadable, MessagePortWritable } from "./stream.mjs";
+export { MessagePortDuplex, MessagePortDuplexOptions, MessagePortReadable, MessagePortWritable, createExecutionHost, createRpcClient, finalize };

package/dist/helpers/index.mjs

@@ -0,0 +1,6 @@
+import { createRpcClient } from "./rpc.mjs";
+import { MessagePortDuplex, MessagePortReadable, MessagePortWritable } from "./stream.mjs";
+import { createExecutionHost } from "./create-execution-host.mjs";
+import { finalize } from "./finalize.mjs";
+
+export { MessagePortDuplex, MessagePortReadable, MessagePortWritable, createExecutionHost, createRpcClient, finalize };

package/dist/helpers/rpc.cjs

@@ -0,0 +1,139 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let _powerlines_core_lib_events = require("@powerlines/core/lib/events");
+let _stryke_type_checks_is_number = require("@stryke/type-checks/is-number");
+let _stryke_type_checks_is_set = require("@stryke/type-checks/is-set");
+let _stryke_url = require("@stryke/url");
+let devframe_client = require("devframe/client");
+let devframe_rpc = require("devframe/rpc");
+let devframe_rpc_client = require("devframe/rpc/client");
+let devframe_rpc_transports_ws_client = require("devframe/rpc/transports/ws-client");
+let devframe_utils_promise = require("devframe/utils/promise");
+let human_id = require("human-id");
+let node_events = require("node:events");
+
+//#region src/helpers/rpc.ts
+function createWsRpcClientMode(baseURL, connectionMeta, events, clientRpc, authToken = (0, human_id.humanId)({
+	separator: "-",
+	capitalize: false
+}), rpcOptions = {}, wsOptions = {}) {
+	let isTrusted = false;
+	const trustedPromise = (0, devframe_utils_promise.promiseWithResolver)();
+	const url = (0, _stryke_type_checks_is_number.isNumber)(connectionMeta.websocket) || (0, _stryke_type_checks_is_set.isSet)(connectionMeta.websocket) && `${+connectionMeta.websocket}` === `${connectionMeta.websocket}` ? `${baseURL.protocol.replace("http", "ws")}//${baseURL.hostname}:${connectionMeta.websocket}` : connectionMeta.websocket;
+	const definitions = /* @__PURE__ */ new Map();
+	for (const name of connectionMeta.jsonSerializableMethods ?? []) definitions.set(name, { jsonSerializable: true });
+	const serverRpc = (0, devframe_rpc_client.createRpcClient)(clientRpc.functions, {
+		channel: (0, devframe_rpc_transports_ws_client.createWsRpcChannel)({
+			url,
+			authToken,
+			definitions,
+			...wsOptions
+		}),
+		rpcOptions
+	});
+	clientRpc.register({
+		name: "devframe:auth:revoked",
+		type: "event",
+		handler: () => {
+			isTrusted = false;
+			events.emit("rpc:is-trusted:updated", false);
+		}
+	});
+	let currentAuthToken = authToken;
+	async function requestTrustWithToken(token) {
+		currentAuthToken = token;
+		return true;
+	}
+	async function requestTrust() {
+		if (isTrusted) return true;
+		return requestTrustWithToken(currentAuthToken);
+	}
+	async function ensureTrusted(timeout = 6e4) {
+		if (isTrusted) trustedPromise.resolve(true);
+		if (timeout <= 0) return trustedPromise.promise;
+		let clear = () => {};
+		await Promise.race([trustedPromise.promise.then(clear), new Promise((resolve, reject) => {
+			const id = setTimeout(() => {
+				reject(/* @__PURE__ */ new Error("Timeout waiting for rpc to be trusted"));
+			}, timeout);
+			clear = () => clearTimeout(id);
+		})]);
+		return isTrusted;
+	}
+	return {
+		get isTrusted() {
+			return isTrusted;
+		},
+		requestTrust,
+		requestTrustWithToken,
+		ensureTrusted,
+		call: (...args) => {
+			return serverRpc.$call(...args);
+		},
+		callEvent: (...args) => {
+			return serverRpc.$callEvent(...args);
+		},
+		callOptional: (...args) => {
+			return serverRpc.$callOptional(...args);
+		}
+	};
+}
+const CONNECTION_AUTH_TOKEN_KEY = "__DEVTOOLS_CONNECTION_AUTH_TOKEN__";
+function createRpcClient(options) {
+	const baseURL = new _stryke_url.StormURL(options.baseURL);
+	const cacheManager = new devframe_rpc.RpcCacheManager({
+		functions: [],
+		...typeof options.cacheOptions === "object" ? options.cacheOptions : {}
+	});
+	const context = { rpc: void 0 };
+	const clientRpc = new devframe_rpc.RpcFunctionsCollectorBase(context);
+	node_events.EventEmitter.setMaxListeners(100);
+	const events = (0, _powerlines_core_lib_events.createEventEmitter)();
+	const mode = createWsRpcClientMode(baseURL, options.connection, events, clientRpc, void 0, {
+		...options.rpcOptions,
+		async onRequest(req, next, resolve) {
+			await options.rpcOptions?.onRequest?.call(this, req, next, resolve);
+			if (options.cacheOptions && cacheManager?.validate(req.m)) {
+				const cached = cacheManager.cached(req.m, req.a);
+				if (cached) return resolve(cached);
+				else {
+					const res = await next(req);
+					cacheManager?.apply(req, res);
+				}
+			} else await next(req);
+		}
+	}, options.wsOptions);
+	const rpc = {
+		events,
+		get isTrusted() {
+			return mode.isTrusted;
+		},
+		connectionMeta: options.connection,
+		ensureTrusted: mode.ensureTrusted,
+		requestTrust: mode.requestTrust,
+		requestTrustWithToken: async (token) => {
+			localStorage.setItem(CONNECTION_AUTH_TOKEN_KEY, token);
+			globalThis[CONNECTION_AUTH_TOKEN_KEY] = token;
+			return mode.requestTrustWithToken(token);
+		},
+		call: mode.call,
+		callEvent: mode.callEvent,
+		callOptional: mode.callOptional,
+		client: clientRpc,
+		sharedState: void 0,
+		streaming: void 0,
+		cacheManager
+	};
+	rpc.streaming = (0, devframe_client.createRpcStreamingClientHost)(rpc);
+	context.rpc = rpc;
+	mode.requestTrust();
+	try {
+		const bc = new BroadcastChannel("vite-devtools-auth");
+		bc.onmessage = (event) => {
+			if (event.data?.type === "auth-update" && event.data.authToken) rpc.requestTrustWithToken(event.data.authToken);
+		};
+	} catch {}
+	return rpc;
+}
+
+//#endregion
+exports.createRpcClient = createRpcClient;

package/dist/helpers/rpc.d.cts

@@ -0,0 +1,7 @@
+import { i as RpcClientOptions, u as RpcClient } from "../config-DKEmqMrh.cjs";
+
+//#region src/helpers/rpc.d.ts
+declare function createRpcClient(options: RpcClientOptions): RpcClient;
+//#endregion
+export { createRpcClient };
+//# sourceMappingURL=rpc.d.cts.map

package/dist/helpers/rpc.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.d.cts","names":[],"sources":["../../src/helpers/rpc.ts"],"mappings":";;;iBA0LgB,eAAA,CAAgB,OAAA,EAAS,gBAAA,GAAgB,SAAA"}

package/dist/helpers/rpc.d.mts

@@ -0,0 +1,7 @@
+import { i as RpcClientOptions, u as RpcClient } from "../config-ByLyzMI0.mjs";
+
+//#region src/helpers/rpc.d.ts
+declare function createRpcClient(options: RpcClientOptions): RpcClient;
+//#endregion
+export { createRpcClient };
+//# sourceMappingURL=rpc.d.mts.map

package/dist/helpers/rpc.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.d.mts","names":[],"sources":["../../src/helpers/rpc.ts"],"mappings":";;;iBA0LgB,eAAA,CAAgB,OAAA,EAAS,gBAAA,GAAgB,SAAA"}

package/dist/helpers/rpc.mjs

@@ -0,0 +1,139 @@
+import { createEventEmitter } from "@powerlines/core/lib/events";
+import { isNumber } from "@stryke/type-checks/is-number";
+import { isSet } from "@stryke/type-checks/is-set";
+import { StormURL } from "@stryke/url";
+import { createRpcStreamingClientHost } from "devframe/client";
+import { RpcCacheManager, RpcFunctionsCollectorBase } from "devframe/rpc";
+import { createRpcClient as createRpcClient$1 } from "devframe/rpc/client";
+import { createWsRpcChannel } from "devframe/rpc/transports/ws-client";
+import { promiseWithResolver } from "devframe/utils/promise";
+import { humanId } from "human-id";
+import { EventEmitter } from "node:events";
+
+//#region src/helpers/rpc.ts
+function createWsRpcClientMode(baseURL, connectionMeta, events, clientRpc, authToken = humanId({
+	separator: "-",
+	capitalize: false
+}), rpcOptions = {}, wsOptions = {}) {
+	let isTrusted = false;
+	const trustedPromise = promiseWithResolver();
+	const url = isNumber(connectionMeta.websocket) || isSet(connectionMeta.websocket) && `${+connectionMeta.websocket}` === `${connectionMeta.websocket}` ? `${baseURL.protocol.replace("http", "ws")}//${baseURL.hostname}:${connectionMeta.websocket}` : connectionMeta.websocket;
+	const definitions = /* @__PURE__ */ new Map();
+	for (const name of connectionMeta.jsonSerializableMethods ?? []) definitions.set(name, { jsonSerializable: true });
+	const serverRpc = createRpcClient$1(clientRpc.functions, {
+		channel: createWsRpcChannel({
+			url,
+			authToken,
+			definitions,
+			...wsOptions
+		}),
+		rpcOptions
+	});
+	clientRpc.register({
+		name: "devframe:auth:revoked",
+		type: "event",
+		handler: () => {
+			isTrusted = false;
+			events.emit("rpc:is-trusted:updated", false);
+		}
+	});
+	let currentAuthToken = authToken;
+	async function requestTrustWithToken(token) {
+		currentAuthToken = token;
+		return true;
+	}
+	async function requestTrust() {
+		if (isTrusted) return true;
+		return requestTrustWithToken(currentAuthToken);
+	}
+	async function ensureTrusted(timeout = 6e4) {
+		if (isTrusted) trustedPromise.resolve(true);
+		if (timeout <= 0) return trustedPromise.promise;
+		let clear = () => {};
+		await Promise.race([trustedPromise.promise.then(clear), new Promise((resolve, reject) => {
+			const id = setTimeout(() => {
+				reject(/* @__PURE__ */ new Error("Timeout waiting for rpc to be trusted"));
+			}, timeout);
+			clear = () => clearTimeout(id);
+		})]);
+		return isTrusted;
+	}
+	return {
+		get isTrusted() {
+			return isTrusted;
+		},
+		requestTrust,
+		requestTrustWithToken,
+		ensureTrusted,
+		call: (...args) => {
+			return serverRpc.$call(...args);
+		},
+		callEvent: (...args) => {
+			return serverRpc.$callEvent(...args);
+		},
+		callOptional: (...args) => {
+			return serverRpc.$callOptional(...args);
+		}
+	};
+}
+const CONNECTION_AUTH_TOKEN_KEY = "__DEVTOOLS_CONNECTION_AUTH_TOKEN__";
+function createRpcClient(options) {
+	const baseURL = new StormURL(options.baseURL);
+	const cacheManager = new RpcCacheManager({
+		functions: [],
+		...typeof options.cacheOptions === "object" ? options.cacheOptions : {}
+	});
+	const context = { rpc: void 0 };
+	const clientRpc = new RpcFunctionsCollectorBase(context);
+	EventEmitter.setMaxListeners(100);
+	const events = createEventEmitter();
+	const mode = createWsRpcClientMode(baseURL, options.connection, events, clientRpc, void 0, {
+		...options.rpcOptions,
+		async onRequest(req, next, resolve) {
+			await options.rpcOptions?.onRequest?.call(this, req, next, resolve);
+			if (options.cacheOptions && cacheManager?.validate(req.m)) {
+				const cached = cacheManager.cached(req.m, req.a);
+				if (cached) return resolve(cached);
+				else {
+					const res = await next(req);
+					cacheManager?.apply(req, res);
+				}
+			} else await next(req);
+		}
+	}, options.wsOptions);
+	const rpc = {
+		events,
+		get isTrusted() {
+			return mode.isTrusted;
+		},
+		connectionMeta: options.connection,
+		ensureTrusted: mode.ensureTrusted,
+		requestTrust: mode.requestTrust,
+		requestTrustWithToken: async (token) => {
+			localStorage.setItem(CONNECTION_AUTH_TOKEN_KEY, token);
+			globalThis[CONNECTION_AUTH_TOKEN_KEY] = token;
+			return mode.requestTrustWithToken(token);
+		},
+		call: mode.call,
+		callEvent: mode.callEvent,
+		callOptional: mode.callOptional,
+		client: clientRpc,
+		sharedState: void 0,
+		streaming: void 0,
+		cacheManager
+	};
+	rpc.streaming = createRpcStreamingClientHost(rpc);
+	context.rpc = rpc;
+	mode.requestTrust();
+	try {
+		const bc = new BroadcastChannel("vite-devtools-auth");
+		bc.onmessage = (event) => {
+			if (event.data?.type === "auth-update" && event.data.authToken) rpc.requestTrustWithToken(event.data.authToken);
+		};
+	} catch {}
+	return rpc;
+}
+
+//#endregion
+export { createRpcClient };
+//# sourceMappingURL=rpc.mjs.map

package/dist/helpers/rpc.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.mjs","names":["createDevframeRpcClient"],"sources":["../../src/helpers/rpc.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                   ⚡ Storm Software - Powerlines\n\n This code was released as part of the Powerlines project. Powerlines\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/powerlines.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/powerlines\n Documentation:            https://docs.stormsoftware.com/projects/powerlines\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport { createEventEmitter } from \"@powerlines/core/lib/events\";\nimport { isNumber } from \"@stryke/type-checks/is-number\";\nimport { isSet } from \"@stryke/type-checks/is-set\";\nimport { StormURL } from \"@stryke/url\";\nimport { BirpcOptions } from \"birpc\";\nimport {\n  createRpcStreamingClientHost,\n  DevToolsClientRpcHost,\n  DevToolsRpcClientMode,\n  RpcClientEvents\n} from \"devframe/client\";\nimport { RpcCacheManager, RpcFunctionsCollectorBase } from \"devframe/rpc\";\nimport { createRpcClient as createDevframeRpcClient } from \"devframe/rpc/client\";\nimport {\n  createWsRpcChannel,\n  WsRpcChannelOptions\n} from \"devframe/rpc/transports/ws-client\";\nimport {\n  ConnectionMeta,\n  EventEmitter as DevFrameEventEmitter\n} from \"devframe/types\";\nimport { promiseWithResolver } from \"devframe/utils/promise\";\nimport { humanId } from \"human-id\";\nimport { EventEmitter } from \"node:events\";\nimport { RpcClientOptions } from \"../types/config\";\nimport {\n  RpcClient,\n  RpcClientFunctions,\n  RpcContext,\n  RpcServerFunctions\n} from \"../types/rpc\";\n\nfunction createWsRpcClientMode(\n  baseURL: StormURL,\n  connectionMeta: ConnectionMeta,\n  events: DevFrameEventEmitter<RpcClientEvents>,\n  clientRpc: DevToolsClientRpcHost,\n  authToken: string = humanId({ separator: \"-\", capitalize: false }),\n  rpcOptions: Partial<\n    BirpcOptions<RpcServerFunctions, RpcClientFunctions, boolean>\n  > = {},\n  wsOptions: Partial<WsRpcChannelOptions> = {}\n): DevToolsRpcClientMode {\n  let isTrusted = false;\n  const trustedPromise = promiseWithResolver<boolean>();\n  const url =\n    isNumber(connectionMeta.websocket) ||\n    (isSet(connectionMeta.websocket) &&\n      `${+connectionMeta.websocket}` === `${connectionMeta.websocket}`)\n      ? `${baseURL.protocol.replace(\"http\", \"ws\")}//${baseURL.hostname}:${connectionMeta.websocket}`\n      : (connectionMeta.websocket as string);\n\n  // Build a minimal `defs` map from the connection meta so the per-call\n  // wire serializer dispatches outgoing requests with the correct\n  // encoding (JSON for `jsonSerializable: true` methods; structured-\n  // clone for the rest).\n  const definitions = new Map<string, { jsonSerializable: true }>();\n  for (const name of connectionMeta.jsonSerializableMethods ?? [])\n    definitions.set(name, { jsonSerializable: true });\n\n  const serverRpc = createDevframeRpcClient<\n    RpcServerFunctions,\n    RpcClientFunctions\n  >(clientRpc.functions, {\n    channel: createWsRpcChannel({\n      url,\n      authToken,\n      definitions,\n      ...wsOptions\n    }),\n    rpcOptions\n  });\n\n  // Handle server-initiated auth revocation\n  clientRpc.register({\n    name: \"devframe:auth:revoked\",\n    type: \"event\",\n    handler: () => {\n      isTrusted = false;\n      events.emit(\"rpc:is-trusted:updated\", false);\n    }\n  });\n\n  let currentAuthToken = authToken;\n\n  async function requestTrustWithToken(token: string) {\n    currentAuthToken = token;\n\n    // const info = parseUA(navigator.userAgent);\n    // const ua = [\n    //   \"powerlines\",\n    //   \"1.0\",\n    //   \"|\",\n    //   info.os.name,\n    //   info.os.version,\n    //   info.device.type\n    // ]\n    //   .filter(i => i)\n    //   .join(\" \");\n\n    // const result = await serverRpc.$call(\"vite:anonymous:auth\", {\n    //   authToken: token,\n    //   ua,\n    //   origin: baseURL.origin\n    // });\n\n    // isTrusted = result.isTrusted;\n    // trustedPromise.resolve(isTrusted);\n    // events.emit(\"rpc:is-trusted:updated\", isTrusted);\n    // return result.isTrusted;\n\n    return true;\n  }\n\n  async function requestTrust() {\n    if (isTrusted) return true;\n    return requestTrustWithToken(currentAuthToken);\n  }\n\n  async function ensureTrusted(timeout = 60_000): Promise<boolean> {\n    if (isTrusted) trustedPromise.resolve(true);\n\n    if (timeout <= 0) return trustedPromise.promise;\n\n    let clear = () => {};\n    await Promise.race([\n      trustedPromise.promise.then(clear),\n      new Promise((resolve, reject) => {\n        const id = setTimeout(() => {\n          reject(new Error(\"Timeout waiting for rpc to be trusted\"));\n        }, timeout);\n        clear = () => clearTimeout(id);\n      })\n    ]);\n\n    return isTrusted;\n  }\n\n  return {\n    get isTrusted() {\n      return isTrusted;\n    },\n    requestTrust,\n    requestTrustWithToken,\n    ensureTrusted,\n    call: (...args: any): any => {\n      return serverRpc.$call(\n        // @ts-expect-error casting\n        ...args\n      );\n    },\n    callEvent: (...args: any): any => {\n      return serverRpc.$callEvent(\n        // @ts-expect-error casting\n        ...args\n      );\n    },\n    callOptional: (...args: any): any => {\n      return serverRpc.$callOptional(\n        // @ts-expect-error casting\n        ...args\n      );\n    }\n  };\n}\n\nconst CONNECTION_AUTH_TOKEN_KEY = \"__DEVTOOLS_CONNECTION_AUTH_TOKEN__\";\n\nexport function createRpcClient(options: RpcClientOptions) {\n  const baseURL = new StormURL(options.baseURL);\n\n  const cacheManager = new RpcCacheManager({\n    functions: [],\n    ...(typeof options.cacheOptions === \"object\" ? options.cacheOptions : {})\n  });\n  const context: RpcContext = {\n    rpc: undefined!\n  };\n\n  const clientRpc: DevToolsClientRpcHost = new RpcFunctionsCollectorBase<\n    RpcClientFunctions,\n    RpcContext\n  >(context);\n\n  EventEmitter.setMaxListeners(100);\n  const events = createEventEmitter<RpcClientEvents>();\n\n  const mode = createWsRpcClientMode(\n    baseURL,\n    options.connection,\n    events,\n    clientRpc,\n    undefined,\n    {\n      ...options.rpcOptions,\n      async onRequest(req, next, resolve) {\n        await options.rpcOptions?.onRequest?.call(this, req, next, resolve);\n        if (options.cacheOptions && cacheManager?.validate(req.m)) {\n          const cached = cacheManager.cached(req.m, req.a);\n          if (cached) {\n            return resolve(cached);\n          } else {\n            const res = await next(req);\n            cacheManager?.apply(req, res);\n          }\n        } else {\n          await next(req);\n        }\n      }\n    },\n    options.wsOptions\n  );\n\n  const rpc: RpcClient = {\n    events,\n    get isTrusted() {\n      return mode.isTrusted;\n    },\n    connectionMeta: options.connection,\n    ensureTrusted: mode.ensureTrusted,\n    requestTrust: mode.requestTrust,\n    requestTrustWithToken: async (token: string) => {\n      // Update stored token for future reconnections\n      localStorage.setItem(CONNECTION_AUTH_TOKEN_KEY, token);\n      (globalThis as any)[CONNECTION_AUTH_TOKEN_KEY] = token;\n      return mode.requestTrustWithToken(token);\n    },\n    call: mode.call,\n    callEvent: mode.callEvent,\n    callOptional: mode.callOptional,\n    client: clientRpc,\n    sharedState: undefined!,\n    streaming: undefined!,\n    cacheManager\n  };\n\n  // rpc.sharedState = createRpcSharedStateClientHost(rpc);\n  rpc.streaming = createRpcStreamingClientHost(rpc);\n\n  // @ts-expect-error assign to readonly property\n  context.rpc = rpc;\n  void mode.requestTrust();\n\n  // Listen for auth updates from other tabs (e.g., auth URL page)\n  try {\n    const bc = new BroadcastChannel(\"vite-devtools-auth\");\n    bc.onmessage = event => {\n      if (event.data?.type === \"auth-update\" && event.data.authToken) {\n        void rpc.requestTrustWithToken(event.data.authToken);\n      }\n    };\n  } catch {\n    // BroadcastChannel is not supported in all environments, so we can safely ignore errors here\n  }\n\n  return rpc;\n}\n"],"mappings":"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"}

package/dist/helpers/stream.cjs

@@ -0,0 +1,119 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let node_stream = require("node:stream");
+
+//#region src/helpers/stream.ts
+const kPort = Symbol("kPort");
+function toTransferable(chunk) {
+	if (ArrayBuffer.isView(chunk)) return chunk.buffer instanceof ArrayBuffer ? chunk.buffer : void 0;
+	if (chunk instanceof ArrayBuffer) return chunk;
+}
+var MessagePortWritable = class extends node_stream.Writable {
+	[kPort];
+	constructor(port, options) {
+		super(options);
+		this[kPort] = port;
+	}
+	_write(chunk, _encoding, callback) {
+		const transfer = toTransferable(chunk);
+		this[kPort].postMessage(chunk, transfer ? [transfer] : []);
+		callback();
+	}
+	_writev(data, callback) {
+		const chunks = data.map((entry) => entry.chunk);
+		const transfers = data.map((entry) => toTransferable(entry.chunk)).filter((value) => Boolean(value));
+		this[kPort].postMessage(chunks, transfers);
+		callback();
+	}
+	_final(callback) {
+		this[kPort].postMessage(null);
+		callback();
+	}
+	_destroy(error, callback) {
+		this[kPort].close(() => callback(error));
+	}
+	unref() {
+		this[kPort].unref();
+		return this;
+	}
+	ref() {
+		this[kPort].ref();
+		return this;
+	}
+};
+var MessagePortReadable = class extends node_stream.Readable {
+	[kPort];
+	constructor(port, options) {
+		super(options);
+		this[kPort] = port;
+		port.onmessage = ({ data }) => {
+			this.push(data);
+		};
+	}
+	_read(_size) {
+		this[kPort].start();
+	}
+	_destroy(error, callback) {
+		this[kPort].close(() => {
+			this[kPort].onmessage = null;
+			callback(error);
+		});
+	}
+	unref() {
+		this[kPort].unref();
+		return this;
+	}
+	ref() {
+		this[kPort].ref();
+		return this;
+	}
+};
+var MessagePortDuplex = class extends node_stream.Duplex {
+	[kPort];
+	_activityAbortHandler;
+	constructor(port, options) {
+		super(options);
+		this[kPort] = port;
+		this._activityAbortHandler = options?.onActivityAbort;
+		port.onmessage = ({ data }) => {
+			this.push(data);
+		};
+	}
+	_read(_size) {
+		this[kPort].start();
+	}
+	_write(chunk, _encoding, callback) {
+		if (this._activityAbortHandler) this._activityAbortHandler();
+		const transfer = toTransferable(chunk);
+		this[kPort].postMessage(chunk, transfer ? [transfer] : []);
+		callback();
+	}
+	_writev(data, callback) {
+		const chunks = data.map((entry) => entry.chunk);
+		const transfers = data.map((entry) => toTransferable(entry.chunk)).filter((value) => Boolean(value));
+		this[kPort].postMessage(chunks, transfers);
+		callback();
+	}
+	_final(callback) {
+		this[kPort].postMessage(null);
+		callback();
+	}
+	_destroy(error, callback) {
+		this[kPort].close(() => {
+			this[kPort].onmessage = null;
+			callback(error);
+		});
+	}
+	unref() {
+		this[kPort].unref();
+		return this;
+	}
+	ref() {
+		this[kPort].ref();
+		return this;
+	}
+};
+
+//#endregion
+exports.MessagePortDuplex = MessagePortDuplex;
+exports.MessagePortReadable = MessagePortReadable;
+exports.MessagePortWritable = MessagePortWritable;

package/dist/helpers/stream.d.cts

@@ -0,0 +1,45 @@
+import { Duplex, DuplexOptions, Readable, ReadableOptions, Writable, WritableOptions } from "node:stream";
+import { MessagePort } from "node:worker_threads";
+
+//#region src/helpers/stream.d.ts
+declare const kPort: unique symbol;
+interface WritevChunk {
+  chunk: unknown;
+  encoding: BufferEncoding;
+}
+declare class MessagePortWritable extends Writable {
+  private [kPort];
+  constructor(port: MessagePort, options?: WritableOptions);
+  _write(chunk: unknown, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+  _writev(data: WritevChunk[], callback: (error?: Error | null) => void): void;
+  _final(callback: (error?: Error | null) => void): void;
+  _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+  unref(): this;
+  ref(): this;
+}
+declare class MessagePortReadable extends Readable {
+  private [kPort];
+  constructor(port: MessagePort, options?: ReadableOptions);
+  _read(_size: number): void;
+  _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+  unref(): this;
+  ref(): this;
+}
+interface MessagePortDuplexOptions extends DuplexOptions {
+  onActivityAbort?: () => void;
+}
+declare class MessagePortDuplex extends Duplex {
+  private [kPort];
+  private _activityAbortHandler?;
+  constructor(port: MessagePort, options?: MessagePortDuplexOptions);
+  _read(_size: number): void;
+  _write(chunk: unknown, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+  _writev(data: WritevChunk[], callback: (error?: Error | null) => void): void;
+  _final(callback: (error?: Error | null) => void): void;
+  _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+  unref(): this;
+  ref(): this;
+}
+//#endregion
+export { MessagePortDuplex, MessagePortDuplexOptions, MessagePortReadable, MessagePortWritable };
+//# sourceMappingURL=stream.d.cts.map

package/dist/helpers/stream.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.cts","names":[],"sources":["../../src/helpers/stream.ts"],"mappings":";;;;cA0BM,KAAA;AAAA,UAMI,WAAA;EACR,KAAA;EACA,QAAA,EAAU,cAAc;AAAA;AAAA,cAeb,mBAAA,SAA4B,QAAA;EAAA,SAC9B,KAAA;cAEU,IAAA,EAAM,WAAA,EAAa,OAAA,GAAU,eAAA;EAKhC,MAAA,CACd,KAAA,WACA,SAAA,EAAW,cAAA,EACX,QAAA,GAAW,KAAA,GAAQ,KAAA;EAOL,OAAA,CACd,IAAA,EAAM,WAAA,IACN,QAAA,GAAW,KAAA,GAAQ,KAAA;EAWL,MAAA,CAAO,QAAA,GAAW,KAAA,GAAQ,KAAA;EAK1B,QAAA,CACd,KAAA,EAAO,KAAA,SACP,QAAA,GAAW,KAAA,GAAQ,KAAA;EAKd,KAAA,CAAA;EAKA,GAAA,CAAA;AAAA;AAAA,cAMI,mBAAA,SAA4B,QAAA;EAAA,SAC9B,KAAA;cAEU,IAAA,EAAM,WAAA,EAAa,OAAA,GAAU,eAAA;EAQhC,KAAA,CAAM,KAAA;EAIN,QAAA,CACd,KAAA,EAAO,KAAA,SACP,QAAA,GAAW,KAAA,GAAQ,KAAA;EAQd,KAAA,CAAA;EAKA,GAAA,CAAA;AAAA;AAAA,UAMQ,wBAAA,SAAiC,aAAa;EAC7D,eAAe;AAAA;AAAA,cAGJ,iBAAA,SAA0B,MAAA;EAAA,SAC5B,KAAA;EAAA,QAED,qBAAA;cAEW,IAAA,EAAM,WAAA,EAAa,OAAA,GAAU,wBAAA;EAUhC,KAAA,CAAM,KAAA;EAIN,MAAA,CACd,KAAA,WACA,SAAA,EAAW,cAAA,EACX,QAAA,GAAW,KAAA,GAAQ,KAAA;EAUL,OAAA,CACd,IAAA,EAAM,WAAA,IACN,QAAA,GAAW,KAAA,GAAQ,KAAA;EAWL,MAAA,CAAO,QAAA,GAAW,KAAA,GAAQ,KAAA;EAK1B,QAAA,CACd,KAAA,EAAO,KAAA,SACP,QAAA,GAAW,KAAA,GAAQ,KAAA;EAQd,KAAA,CAAA;EAKA,GAAA,CAAA;AAAA"}

package/dist/helpers/stream.d.mts

@@ -0,0 +1,45 @@
+import { Duplex, DuplexOptions, Readable, ReadableOptions, Writable, WritableOptions } from "node:stream";
+import { MessagePort } from "node:worker_threads";
+
+//#region src/helpers/stream.d.ts
+declare const kPort: unique symbol;
+interface WritevChunk {
+  chunk: unknown;
+  encoding: BufferEncoding;
+}
+declare class MessagePortWritable extends Writable {
+  private [kPort];
+  constructor(port: MessagePort, options?: WritableOptions);
+  _write(chunk: unknown, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+  _writev(data: WritevChunk[], callback: (error?: Error | null) => void): void;
+  _final(callback: (error?: Error | null) => void): void;
+  _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+  unref(): this;
+  ref(): this;
+}
+declare class MessagePortReadable extends Readable {
+  private [kPort];
+  constructor(port: MessagePort, options?: ReadableOptions);
+  _read(_size: number): void;
+  _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+  unref(): this;
+  ref(): this;
+}
+interface MessagePortDuplexOptions extends DuplexOptions {
+  onActivityAbort?: () => void;
+}
+declare class MessagePortDuplex extends Duplex {
+  private [kPort];
+  private _activityAbortHandler?;
+  constructor(port: MessagePort, options?: MessagePortDuplexOptions);
+  _read(_size: number): void;
+  _write(chunk: unknown, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+  _writev(data: WritevChunk[], callback: (error?: Error | null) => void): void;
+  _final(callback: (error?: Error | null) => void): void;
+  _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+  unref(): this;
+  ref(): this;
+}
+//#endregion
+export { MessagePortDuplex, MessagePortDuplexOptions, MessagePortReadable, MessagePortWritable };
+//# sourceMappingURL=stream.d.mts.map

package/dist/helpers/stream.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.mts","names":[],"sources":["../../src/helpers/stream.ts"],"mappings":";;;;cA0BM,KAAA;AAAA,UAMI,WAAA;EACR,KAAA;EACA,QAAA,EAAU,cAAc;AAAA;AAAA,cAeb,mBAAA,SAA4B,QAAA;EAAA,SAC9B,KAAA;cAEU,IAAA,EAAM,WAAA,EAAa,OAAA,GAAU,eAAA;EAKhC,MAAA,CACd,KAAA,WACA,SAAA,EAAW,cAAA,EACX,QAAA,GAAW,KAAA,GAAQ,KAAA;EAOL,OAAA,CACd,IAAA,EAAM,WAAA,IACN,QAAA,GAAW,KAAA,GAAQ,KAAA;EAWL,MAAA,CAAO,QAAA,GAAW,KAAA,GAAQ,KAAA;EAK1B,QAAA,CACd,KAAA,EAAO,KAAA,SACP,QAAA,GAAW,KAAA,GAAQ,KAAA;EAKd,KAAA,CAAA;EAKA,GAAA,CAAA;AAAA;AAAA,cAMI,mBAAA,SAA4B,QAAA;EAAA,SAC9B,KAAA;cAEU,IAAA,EAAM,WAAA,EAAa,OAAA,GAAU,eAAA;EAQhC,KAAA,CAAM,KAAA;EAIN,QAAA,CACd,KAAA,EAAO,KAAA,SACP,QAAA,GAAW,KAAA,GAAQ,KAAA;EAQd,KAAA,CAAA;EAKA,GAAA,CAAA;AAAA;AAAA,UAMQ,wBAAA,SAAiC,aAAa;EAC7D,eAAe;AAAA;AAAA,cAGJ,iBAAA,SAA0B,MAAA;EAAA,SAC5B,KAAA;EAAA,QAED,qBAAA;cAEW,IAAA,EAAM,WAAA,EAAa,OAAA,GAAU,wBAAA;EAUhC,KAAA,CAAM,KAAA;EAIN,MAAA,CACd,KAAA,WACA,SAAA,EAAW,cAAA,EACX,QAAA,GAAW,KAAA,GAAQ,KAAA;EAUL,OAAA,CACd,IAAA,EAAM,WAAA,IACN,QAAA,GAAW,KAAA,GAAQ,KAAA;EAWL,MAAA,CAAO,QAAA,GAAW,KAAA,GAAQ,KAAA;EAK1B,QAAA,CACd,KAAA,EAAO,KAAA,SACP,QAAA,GAAW,KAAA,GAAQ,KAAA;EAQd,KAAA,CAAA;EAKA,GAAA,CAAA;AAAA"}