devframe 0.2.2 → 0.3.0

package/dist/{shared-state-BJXkPxtf.mjs → shared-state-u0y123fi.mjs}

@@ -4,7 +4,7 @@ import { nanoid } from "./utils/nanoid.mjs";
 var NOTHING = Symbol.for("immer-nothing");
 var DRAFTABLE = Symbol.for("immer-draftable");
 var DRAFT_STATE = Symbol.for("immer-state");
-var errors = process.env.NODE_ENV !== "production" ? [
+var errors = [
 	function(plugin) {
 		return `The plugin for '${plugin}' has not been loaded into Immer. To enable the plugin, import and call \`enable${plugin}()\` when initializing your application.`;
 	},
@@ -31,9 +31,9 @@ var errors = process.env.NODE_ENV !== "production" ? [
 	function(thing) {
 		return `'original' expects a draft, got: ${thing}`;
 	}
-] : [];
+];
 function die(error, ...args) {
-	if (process.env.NODE_ENV !== "production") {
+	{
 		const e = errors[error];
 		const msg = isFunction(e) ? e.apply(null, args) : e;
 		throw new Error(`[Immer] ${msg}`);
@@ -438,11 +438,11 @@ for (let key in objectTraps) {
 	};
 }
 arrayTraps.deleteProperty = function(state, prop) {
-	if (process.env.NODE_ENV !== "production" && isNaN(parseInt(prop))) die(13);
+	if (isNaN(parseInt(prop))) die(13);
 	return arrayTraps.set.call(this, state, prop, void 0);
 };
 arrayTraps.set = function(state, prop, value) {
-	if (process.env.NODE_ENV !== "production" && prop !== "length" && isNaN(parseInt(prop))) die(14);
+	if (prop !== "length" && isNaN(parseInt(prop))) die(14);
 	return objectTraps.set.call(this, state[0], prop, value, state[0]);
 };
 function peek(draft, prop) {
@@ -651,7 +651,7 @@ function currentImpl(value) {
 }
 function enablePatches() {
 	const errorOffset = 16;
-	if (process.env.NODE_ENV !== "production") errors.push("Sets cannot have \"replace\" patches.", function(op) {
+	errors.push("Sets cannot have \"replace\" patches.", function(op) {
 		return "Unsupported patch operation: " + op;
 	}, function(path) {
 		return "Cannot apply patch, path doesn't resolve: " + path;

package/dist/{storage-D-jLaxDA.mjs → storage-K-OxR1xf.mjs}

@@ -1,5 +1,4 @@
-import { n as logger } from "./diagnostics-DNxVjo6X.mjs";
-import { t as createSharedState } from "./shared-state-BJXkPxtf.mjs";
+import { i as diagnostics, t as createSharedState } from "./shared-state-CasqoUba.mjs";
 import fs from "node:fs";
 import { dirname } from "pathe";
 //#region ../../node_modules/.pnpm/perfect-debounce@2.1.0/node_modules/perfect-debounce/dist/index.mjs
@@ -100,7 +99,10 @@ function createStorage(options) {
 		const savedValue = JSON.parse(fs.readFileSync(options.filepath, "utf-8"));
 		initialValue = mergeInitialValue ? mergeInitialValue(options.initialValue, savedValue) : savedValue;
 	} catch (error) {
-		logger.DF0012({ filepath: options.filepath }, { cause: error }).log();
+		diagnostics.DF0012.report({
+			filepath: options.filepath,
+			cause: error
+		}, { method: "warn" });
 		initialValue = options.initialValue;
 	}
 	const state = createSharedState({

package/dist/structured-clone-jegjz0hM.mjs

@@ -0,0 +1,208 @@
+//#region ../../node_modules/.pnpm/structured-clone-es@2.0.0/node_modules/structured-clone-es/dist/index.mjs
+const env = typeof self === "object" ? self : globalThis;
+function deserializer($, _) {
+	const as = (out, index) => {
+		$.set(index, out);
+		return out;
+	};
+	const unpair = (index) => {
+		if ($.has(index)) return $.get(index);
+		const [type, value] = _[index];
+		switch (type) {
+			case 0:
+			case -1: return as(value, index);
+			case 1: {
+				const arr = as([], index);
+				for (const index of value) arr.push(unpair(index));
+				return arr;
+			}
+			case 2: {
+				const object = as({}, index);
+				for (const [key, index] of value) object[unpair(key)] = unpair(index);
+				return object;
+			}
+			case 3: return as(new Date(value), index);
+			case 4: {
+				const { source, flags } = value;
+				return as(new RegExp(source, flags), index);
+			}
+			case 5: {
+				const map = as(/* @__PURE__ */ new Map(), index);
+				for (const [key, index] of value) map.set(unpair(key), unpair(index));
+				return map;
+			}
+			case 6: {
+				const set = as(/* @__PURE__ */ new Set(), index);
+				for (const index of value) set.add(unpair(index));
+				return set;
+			}
+			case 7: {
+				const { name, message } = value;
+				return as(new env[name](message), index);
+			}
+			case 8: return as(BigInt(value), index);
+			case "BigInt": return as(Object(BigInt(value)), index);
+			case "ArrayBuffer": return as(new Uint8Array(value).buffer, value);
+			case "DataView": {
+				const { buffer } = new Uint8Array(value);
+				return as(new DataView(buffer), value);
+			}
+		}
+		return as(new env[type](value), index);
+	};
+	return unpair;
+}
+/**
+* Returns a deserialized value from a serialized array of Records.
+* @param serialized a previously serialized value.
+*/
+function deserialize(serialized) {
+	return deserializer(/* @__PURE__ */ new Map(), serialized)(0);
+}
+const EMPTY = "";
+const { toString } = {};
+const { keys } = Object;
+function typeOf(value) {
+	const type = typeof value;
+	if (type !== "object" || !value) return [0, type];
+	const asString = toString.call(value).slice(8, -1);
+	switch (asString) {
+		case "Array": return [1, EMPTY];
+		case "Object": return [2, EMPTY];
+		case "Date": return [3, EMPTY];
+		case "RegExp": return [4, EMPTY];
+		case "Map": return [5, EMPTY];
+		case "Set": return [6, EMPTY];
+		case "DataView": return [1, asString];
+	}
+	if (asString.includes("Array")) return [1, asString];
+	if (asString.includes("Error")) return [7, asString];
+	return [2, asString];
+}
+function shouldSkip([TYPE, type]) {
+	return TYPE === 0 && (type === "function" || type === "symbol");
+}
+function serializer(strict, json, $, _) {
+	const as = (out, value) => {
+		const index = _.push(out) - 1;
+		$.set(value, index);
+		return index;
+	};
+	const pair = (value) => {
+		if ($.has(value)) return $.get(value);
+		let [TYPE, type] = typeOf(value);
+		switch (TYPE) {
+			case 0: {
+				let entry = value;
+				switch (type) {
+					case "bigint":
+						TYPE = 8;
+						entry = value.toString();
+						break;
+					case "function":
+					case "symbol":
+						if (strict) throw new TypeError(`unable to serialize ${type}`);
+						entry = null;
+						break;
+					case "undefined": return as([-1], value);
+				}
+				return as([TYPE, entry], value);
+			}
+			case 1: {
+				if (type) {
+					let spread = value;
+					if (type === "DataView") spread = new Uint8Array(value.buffer);
+					else if (type === "ArrayBuffer") spread = new Uint8Array(value);
+					return as([type, [...spread]], value);
+				}
+				const arr = [];
+				const index = as([TYPE, arr], value);
+				for (const entry of value) arr.push(pair(entry));
+				return index;
+			}
+			case 2: {
+				if (type) switch (type) {
+					case "BigInt": return as([type, value.toString()], value);
+					case "Boolean":
+					case "Number":
+					case "String": return as([type, value.valueOf()], value);
+				}
+				if (json && "toJSON" in value) return pair(value.toJSON());
+				const entries = [];
+				const index = as([TYPE, entries], value);
+				for (const key of keys(value)) if (strict || !shouldSkip(typeOf(value[key]))) entries.push([pair(key), pair(value[key])]);
+				return index;
+			}
+			case 3: return as([TYPE, value.toISOString()], value);
+			case 4: {
+				const { source, flags } = value;
+				return as([TYPE, {
+					source,
+					flags
+				}], value);
+			}
+			case 5: {
+				const entries = [];
+				const index = as([TYPE, entries], value);
+				for (const [key, entry] of value) if (strict || !(shouldSkip(typeOf(key)) || shouldSkip(typeOf(entry)))) entries.push([pair(key), pair(entry)]);
+				return index;
+			}
+			case 6: {
+				const entries = [];
+				const index = as([TYPE, entries], value);
+				for (const entry of value) if (strict || !shouldSkip(typeOf(entry))) entries.push(pair(entry));
+				return index;
+			}
+		}
+		const { message } = value;
+		return as([TYPE, {
+			name: type,
+			message
+		}], value);
+	};
+	return pair;
+}
+/**
+* Returns an array of serialized Records.
+*/
+function serialize(value, options = {}) {
+	const _ = [];
+	serializer(!(options.json || options.lossy), !!options.json, /* @__PURE__ */ new Map(), _)(value);
+	return _;
+}
+const { parse: $parse, stringify: $stringify } = JSON;
+const options = {
+	json: true,
+	lossy: true
+};
+/**
+* Revive a previously stringified structured clone.
+* @param str previously stringified data as string.
+*/
+function parse(str) {
+	return deserialize($parse(str));
+}
+/**
+* Represent a structured clone value as string.
+* @param any some clone-able value to stringify.
+*/
+function stringify(any) {
+	return $stringify(serialize(any, options));
+}
+//#endregion
+//#region src/utils/structured-clone.ts
+/**
+* Serialize a structured-cloneable value to a single string. Equivalent
+* to `JSON.stringify(structuredCloneSerialize(value))`.
+*/
+function structuredCloneStringify(value) {
+	return stringify(value);
+}
+/**
+* Inverse of {@link structuredCloneStringify}.
+*/
+function structuredCloneParse(value) {
+	return parse(value);
+}
+//#endregion
+export { structuredCloneStringify as n, structuredCloneParse as t };

package/dist/types/index.d.mts

@@ -1,4 +1,4 @@
-import { $ as AgentResourceContent, B as EntriesToObject, G as DevToolsRpcSharedStates, H as Thenable, J as DevToolsDiagnosticsHost, K as DevToolsHost, Q as AgentResource, U as DevToolsRpcClientFunctions, V as PartialWithoutId, W as DevToolsRpcServerFunctions, X as AgentHandle, Y as DevToolsDiagnosticsLogger, Z as AgentManifest, _ as RpcStreamingChannel, a as DevframeRuntime, at as EventEmitter, c as defineDevframe, d as DevToolsNodeContext, et as AgentResourceInput, f as DevToolsNodeRpcSession, g as RpcSharedStateHost, h as RpcSharedStateGetOptions, i as DevframeDeploymentKind, it as DevToolsAgentHostEvents, l as ConnectionMeta, m as RpcFunctionsHost, n as DevframeCliOptions, nt as AgentToolInput, o as DevframeSetupInfo, ot as EventUnsubscribe, p as RpcBroadcastOptions, q as DevToolsDiagnosticsDefinition, r as DevframeDefinition, rt as DevToolsAgentHost, s as DevframeSpaOptions, st as EventsMap, t as DevframeBrowserContext, tt as AgentTool, u as DevToolsCapabilities, v as RpcStreamingChannelOptions, y as RpcStreamingHost, z as DevToolsViewHost } from "../devframe-DAfZWnpI.mjs";
-import { h as RpcFunctionAgentOptions } from "../types-DmcujDa5.mjs";
-import { t as DevToolsNodeRpcSessionMeta } from "../ws-server-DKlqI8XP.mjs";
-export { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, ConnectionMeta, DevToolsAgentHost, DevToolsAgentHostEvents, DevToolsCapabilities, DevToolsDiagnosticsDefinition, DevToolsDiagnosticsHost, DevToolsDiagnosticsLogger, DevToolsHost, DevToolsNodeContext, DevToolsNodeRpcSession, DevToolsNodeRpcSessionMeta, DevToolsRpcClientFunctions, DevToolsRpcServerFunctions, DevToolsRpcSharedStates, DevToolsViewHost, DevframeBrowserContext, DevframeCliOptions, DevframeDefinition, DevframeDeploymentKind, DevframeRuntime, DevframeSetupInfo, DevframeSpaOptions, EntriesToObject, EventEmitter, EventUnsubscribe, EventsMap, PartialWithoutId, RpcBroadcastOptions, RpcFunctionAgentOptions, RpcFunctionsHost, RpcSharedStateGetOptions, RpcSharedStateHost, RpcStreamingChannel, RpcStreamingChannelOptions, RpcStreamingHost, Thenable, defineDevframe };
+import { A as DevToolsDiagnosticsDefinition, B as DevToolsAgentHost, C as PartialWithoutId, D as DevToolsRpcSharedStates, E as DevToolsRpcServerFunctions, F as AgentResource, H as EventEmitter, I as AgentResourceContent, L as AgentResourceInput, M as DevToolsDiagnosticsLogger, N as AgentHandle, O as DevToolsHost, P as AgentManifest, R as AgentTool, S as EntriesToObject, T as DevToolsRpcClientFunctions, U as EventUnsubscribe, V as DevToolsAgentHostEvents, W as EventsMap, _ as RpcStreamingChannel, a as DevframeRuntime, c as defineDevframe, d as DevToolsNodeContext, f as DevToolsNodeRpcSession, g as RpcSharedStateHost, h as RpcSharedStateGetOptions, i as DevframeDeploymentKind, j as DevToolsDiagnosticsHost, k as DevToolsDefineDiagnosticsOptions, l as ConnectionMeta, m as RpcFunctionsHost, n as DevframeCliOptions, o as DevframeSetupInfo, p as RpcBroadcastOptions, r as DevframeDefinition, s as DevframeSpaOptions, t as DevframeBrowserContext, u as DevToolsCapabilities, v as RpcStreamingChannelOptions, w as Thenable, x as DevToolsViewHost, y as RpcStreamingHost, z as AgentToolInput } from "../devframe-sc4cb5xr.mjs";
+import { h as RpcFunctionAgentOptions } from "../types-BXL7EIDM.mjs";
+import { t as DevToolsNodeRpcSessionMeta } from "../ws-server-DOwLJL23.mjs";
+export { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, ConnectionMeta, DevToolsAgentHost, DevToolsAgentHostEvents, DevToolsCapabilities, DevToolsDefineDiagnosticsOptions, DevToolsDiagnosticsDefinition, DevToolsDiagnosticsHost, DevToolsDiagnosticsLogger, DevToolsHost, DevToolsNodeContext, DevToolsNodeRpcSession, DevToolsNodeRpcSessionMeta, DevToolsRpcClientFunctions, DevToolsRpcServerFunctions, DevToolsRpcSharedStates, DevToolsViewHost, DevframeBrowserContext, DevframeCliOptions, DevframeDefinition, DevframeDeploymentKind, DevframeRuntime, DevframeSetupInfo, DevframeSpaOptions, EntriesToObject, EventEmitter, EventUnsubscribe, EventsMap, PartialWithoutId, RpcBroadcastOptions, RpcFunctionAgentOptions, RpcFunctionsHost, RpcSharedStateGetOptions, RpcSharedStateHost, RpcStreamingChannel, RpcStreamingChannelOptions, RpcStreamingHost, Thenable, defineDevframe };

package/dist/utils/events.d.mts

@@ -1,4 +1,4 @@
-import { at as EventEmitter, st as EventsMap } from "../devframe-DAfZWnpI.mjs";
+import { T as EventsMap, w as EventEmitter } from "../index-DTeZXHSi.mjs";
 
 //#region src/utils/events.d.ts
 /**

package/dist/utils/hash.mjs

@@ -1,2 +1,2 @@
-import { t as hash } from "../hash-CIBte1yS.mjs";
+import { t as hash } from "../hash-bwOD8RgU.mjs";
 export { hash };

package/dist/utils/shared-state.d.mts

@@ -1,2 +1,2 @@
-import { A as ImmutableArray, F as SharedStateEvents, I as SharedStateOptions, L as SharedStatePatch, M as ImmutableObject, N as ImmutableSet, P as SharedState, R as createSharedState, j as ImmutableMap, k as Immutable } from "../devframe-DAfZWnpI.mjs";
+import { C as createSharedState, S as SharedStatePatch, _ as ImmutableObject, b as SharedStateEvents, g as ImmutableMap, h as ImmutableArray, m as Immutable, v as ImmutableSet, x as SharedStateOptions, y as SharedState } from "../index-DTeZXHSi.mjs";
 export { Immutable, ImmutableArray, ImmutableMap, ImmutableObject, ImmutableSet, SharedState, SharedStateEvents, SharedStateOptions, SharedStatePatch, createSharedState };

package/dist/utils/shared-state.mjs

@@ -1,2 +1,2 @@
-import { t as createSharedState } from "../shared-state-BJXkPxtf.mjs";
+import { t as createSharedState } from "../shared-state-u0y123fi.mjs";
 export { createSharedState };

package/dist/utils/streaming-channel.d.mts

@@ -1,2 +1,2 @@
-import { C as StreamErrorPayload, D as createStreamReader, E as StreamSinkEvents, O as createStreamSink, S as CreateStreamSinkOptions, T as StreamSink, b as BufferedChunk, w as StreamReader, x as CreateStreamReaderOptions } from "../devframe-DAfZWnpI.mjs";
+import { a as BufferedChunk, c as StreamErrorPayload, d as StreamSinkEvents, f as createStreamReader, l as StreamReader, o as CreateStreamReaderOptions, p as createStreamSink, s as CreateStreamSinkOptions, u as StreamSink } from "../index-DTeZXHSi.mjs";
 export { BufferedChunk, CreateStreamReaderOptions, CreateStreamSinkOptions, StreamErrorPayload, StreamReader, StreamSink, StreamSinkEvents, createStreamReader, createStreamSink };

package/dist/utils/structured-clone.mjs

@@ -1,2 +1,2 @@
-import { i as structuredCloneStringify, n as structuredCloneParse, r as structuredCloneSerialize, t as structuredCloneDeserialize } from "../structured-clone-CD2l4fI3.mjs";
+import { i as structuredCloneStringify, n as structuredCloneParse, r as structuredCloneSerialize, t as structuredCloneDeserialize } from "../structured-clone-PdCZwt7F.mjs";
 export { structuredCloneDeserialize, structuredCloneParse, structuredCloneSerialize, structuredCloneStringify };

package/dist/{ws-server-DKlqI8XP.d.mts → ws-server-DOwLJL23.d.mts}

@@ -1,4 +1,4 @@
-import { _ as RpcFunctionDefinitionAny } from "./types-DmcujDa5.mjs";
+import { _ as RpcFunctionDefinitionAny } from "./types-BXL7EIDM.mjs";
 import { BirpcGroup, ChannelOptions } from "birpc";
 import { ServerOptions } from "node:https";
 import { WebSocket, WebSocketServer } from "ws";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "devframe",
   "type": "module",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "Framework for building generic DevTools",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -34,6 +34,7 @@
     "./recipes/open-helpers": "./dist/recipes/open-helpers.mjs",
     "./rpc": "./dist/rpc/index.mjs",
     "./rpc/client": "./dist/rpc/client.mjs",
+    "./rpc/dump": "./dist/rpc/dump.mjs",
     "./rpc/server": "./dist/rpc/server.mjs",
     "./rpc/transports/ws-client": "./dist/rpc/transports/ws-client.mjs",
     "./rpc/transports/ws-server": "./dist/rpc/transports/ws-server.mjs",
@@ -71,8 +72,8 @@
     "birpc": "^4.0.0",
     "cac": "^7.0.0",
     "h3": "2.0.1-rc.22",
-    "logs-sdk": "^0.0.6",
     "mrmime": "^2.0.1",
+    "nostics": "^0.1.0",
     "pathe": "^2.0.3",
     "valibot": "^1.4.0",
     "ws": "^8.20.0"

package/skills/devframe/SKILL.md

@@ -84,7 +84,7 @@ See `templates/counter-devframe.ts` for a runnable counter example, `templates/s
 |------|---------|
 | `ctx.rpc` | Register RPC functions, broadcast, shared state, streaming channels |
 | `ctx.views` | Serve static files via `hostStatic(base, distDir)` |
-| `ctx.diagnostics` | Structured diagnostics host (logs-sdk) — register custom error codes |
+| `ctx.diagnostics` | Structured diagnostics host (nostics) — register custom error codes |
 | `ctx.agent` | Expose tools + resources to coding agents (experimental) |
 | `ctx.host` | Runtime abstraction — `mountStatic`, `resolveOrigin`, `getStorageDir` |
 | `ctx.mode` | `'dev'` or `'build'` — gate setup work per runtime |

package/dist/diagnostics-DNxVjo6X.mjs

@@ -1,56 +0,0 @@
-import { colors } from "./utils/colors.mjs";
-import { consoleReporter, createLogger, defineDiagnostics } from "logs-sdk";
-import { ansiFormatter } from "logs-sdk/formatters/ansi";
-//#region src/node/diagnostics.ts
-const diagnostics = defineDiagnostics({
-	docsBase: "https://devfra.me/errors",
-	codes: {
-		DF0006: { message: (p) => `RPC function "${p.name}" is not registered` },
-		DF0007: { message: "AsyncLocalStorage is not set, it likely to be an internal bug of the DevTools foundation" },
-		DF0008: { message: (p) => `distDir ${p.distDir} does not exist` },
-		DF0012: {
-			message: (p) => `Failed to parse storage file: ${p.filepath}, falling back to defaults.`,
-			level: "warn"
-		},
-		DF0013: { message: (p) => `Shared state of "${p.key}" is not found, please provide an initial value for the first time` },
-		DF0014: {
-			message: (p) => `RPC function "${p.name}" has an invalid \`agent\` field — \`description\` must be a non-empty string.`,
-			hint: "Provide a short description (~1–3 sentences) explaining what the tool does and when agents should invoke it."
-		},
-		DF0015: {
-			message: (p) => `Agent tool "${p.id}" is already registered.`,
-			hint: "Tool ids must be unique across RPC functions with an `agent` field and tools registered via `ctx.agent.registerTool()`."
-		},
-		DF0016: { message: (p) => `Agent resource "${p.id}" is already registered.` },
-		DF0017: { message: (p) => `Failed to start MCP server (${p.transport}): ${p.reason}` },
-		DF0029: {
-			message: (p) => `Stream "${p.channel}#${p.id}" dropped ${p.dropped} chunk(s) after exceeding the client high-water mark.`,
-			hint: "The consumer is too slow for the producer. Raise `highWaterMark` on the subscription, slow the producer, or batch chunks.",
-			level: "warn"
-		},
-		DF0030: {
-			message: (p) => `Stream "${p.channel}#${p.id}" is unknown — no producer has called \`channel.start({ id: "${p.id}" })\`.`,
-			hint: "Ensure the server-side producer is running before clients subscribe, or check for typos in the stream id."
-		},
-		DF0031: {
-			message: (p) => `Cannot write to closed stream "${p.channel}#${p.id}".`,
-			hint: "Track the producer lifecycle — guard writes with the `stream.signal.aborted` flag."
-		},
-		DF0032: {
-			message: (p) => `Streaming channel "${p.channel}" is already registered.`,
-			hint: "Each channel name must be unique within a context. Pick a different name or reuse the existing channel handle."
-		},
-		DF0033: {
-			message: (p) => `Failed to start dev RPC bridge for "${p.id}": ${p.reason}`,
-			hint: "Verify the bridge port is free and the devframe setup function does not throw. Pin a port via `cli.port` / `cli.portRange` on the definition, or via `devMiddleware.port` on `viteDevBridge`.",
-			level: "warn"
-		}
-	}
-});
-const logger = createLogger({
-	diagnostics: [diagnostics],
-	formatter: ansiFormatter(colors),
-	reporters: consoleReporter
-});
-//#endregion
-export { logger as n, diagnostics as t };

package/dist/revoke-DDa7VSJa.mjs

@@ -1,35 +0,0 @@
-//#region src/node/auth/revoke.ts
-/**
-* Flip `isTrusted` to false on any live WS clients connected with `token`
-* and broadcast the `auth:revoked` event so they can react.
-*
-* Shared between persisted-auth revocation and remote-dock token revocation.
-*/
-async function revokeActiveConnectionsForToken(context, token) {
-	const rpcHost = context.rpc;
-	if (!rpcHost?._rpcGroup) return;
-	const affectedSessionIds = /* @__PURE__ */ new Set();
-	for (const client of rpcHost._rpcGroup.clients) if (client.$meta.clientAuthToken === token) {
-		affectedSessionIds.add(client.$meta.id);
-		client.$meta.isTrusted = false;
-		client.$meta.clientAuthToken = void 0;
-	}
-	if (affectedSessionIds.size === 0) return;
-	await rpcHost.broadcast({
-		method: "devframe:auth:revoked",
-		args: [],
-		filter: (client) => affectedSessionIds.has(client.$meta.id)
-	});
-}
-/**
-* Revoke an auth token: remove from storage and notify all connected clients
-* using this token that they are no longer trusted.
-*/
-async function revokeAuthToken(context, storage, token) {
-	storage.mutate((state) => {
-		delete state.trusted[token];
-	});
-	await revokeActiveConnectionsForToken(context, token);
-}
-//#endregion
-export { revokeAuthToken as n, revokeActiveConnectionsForToken as t };

package/dist/ws-client-CrLsflnY.d.mts

@@ -1,26 +0,0 @@
-import { _ as RpcFunctionDefinitionAny } from "./types-DmcujDa5.mjs";
-import { ChannelOptions } from "birpc";
-
-//#region src/rpc/transports/ws-client.d.ts
-interface WsRpcChannelOptions {
-  url: string;
-  onConnected?: (e: Event) => void;
-  onError?: (e: Error) => void;
-  onDisconnected?: (e: CloseEvent) => void;
-  authToken?: string;
-  /**
-   * RPC function definitions (or just the `jsonSerializable` flag per
-   * method) used to dispatch the per-call wire serializer. Pass an
-   * empty / partial map on clients that don't have the full registry —
-   * encoding falls back to structured-clone (the safer superset) and
-   * decoding still routes correctly via the wire prefix.
-   */
-  definitions?: ReadonlyMap<string, Pick<RpcFunctionDefinitionAny, 'jsonSerializable'>>;
-}
-/**
- * Build a birpc `ChannelOptions` object backed by a browser `WebSocket`.
- * Pass the result straight to `createRpcClient`'s `channel` option.
- */
-declare function createWsRpcChannel(options: WsRpcChannelOptions): ChannelOptions;
-//#endregion
-export { createWsRpcChannel as n, WsRpcChannelOptions as t };