devframe 0.1.21 → 0.2.0

package/dist/{static-dump-D5VH8Iqk.mjs → static-dump-C67bCuse.mjs}

@@ -1,4 +1,4 @@
-import { n as dumpFunctions, s as getRpcHandler } from "./rpc-INbWfHoX.mjs";
+import { n as dumpFunctions, s as getRpcHandler } from "./rpc-DAzoVCR0.mjs";
 import { DEVTOOLS_RPC_DUMP_DIRNAME } from "./constants.mjs";
 //#region src/node/static-dump.ts
 function makeDumpKey(name) {

package/dist/{context-internal-Dx_NoSv1.mjs → storage-CNvfBGQ5.mjs}

@@ -1,43 +1,8 @@
-import { t as import_dist } from "./human-id-BLoGo_e5.mjs";
-import { n as logger } from "./diagnostics-DxPnRoXO.mjs";
-import { createSharedState } from "./utils/shared-state.mjs";
+import { n as logger } from "./diagnostics-Cg9ycFIM.mjs";
+import { t as createSharedState } from "./shared-state-q9-1EOSX.mjs";
 import fs from "node:fs";
-import { dirname, join } from "pathe";
-//#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
-//#region ../../../node_modules/.pnpm/perfect-debounce@2.1.0/node_modules/perfect-debounce/dist/index.mjs
+import { dirname } from "pathe";
+//#region ../../node_modules/.pnpm/perfect-debounce@2.1.0/node_modules/perfect-debounce/dist/index.mjs
 const DEBOUNCE_DEFAULTS = { trailing: true };
 /**
 Debounce functions
@@ -149,51 +114,4 @@ function createStorage(options) {
 	return state;
 }
 //#endregion
-//#region src/node/context-internal.ts
-const internalContextMap = /* @__PURE__ */ new WeakMap();
-function getInternalContext(context) {
-	if (!internalContextMap.has(context)) {
-		const storage = createStorage({
-			filepath: join(context.host.getStorageDir("global"), "auth.json"),
-			initialValue: { trusted: {} }
-		});
-		const remoteTokens = /* @__PURE__ */ new Map();
-		function revokeRemoteToken(token) {
-			if (!remoteTokens.delete(token)) return;
-			revokeActiveConnectionsForToken(context, token);
-		}
-		const internalContext = {
-			storage: { auth: storage },
-			revokeAuthToken: (token) => revokeAuthToken(context, storage, token),
-			remoteTokens,
-			allocateRemoteToken(dockId, origin, originLock) {
-				const token = (0, import_dist.humanId)({
-					separator: "-",
-					capitalize: false
-				});
-				remoteTokens.set(token, {
-					dockId,
-					origin,
-					originLock
-				});
-				return token;
-			},
-			revokeRemoteToken,
-			revokeRemoteTokensForDock(dockId) {
-				const tokensToRevoke = [];
-				for (const [token, record] of remoteTokens) if (record.dockId === dockId) tokensToRevoke.push(token);
-				for (const token of tokensToRevoke) revokeRemoteToken(token);
-			},
-			isRemoteTokenTrusted(token, requestOrigin) {
-				const record = remoteTokens.get(token);
-				if (!record) return false;
-				if (!record.originLock) return true;
-				return !!requestOrigin && record.origin === requestOrigin;
-			}
-		};
-		internalContextMap.set(context, internalContext);
-	}
-	return internalContextMap.get(context);
-}
-//#endregion
-export { revokeAuthToken as a, revokeActiveConnectionsForToken as i, internalContextMap as n, createStorage as r, getInternalContext as t };
+export { createStorage as t };

package/dist/structured-clone-CD2l4fI3.mjs

@@ -0,0 +1,221 @@
+//#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 (`Map`, `Set`, `Date`, `BigInt`,
+* cycles, class instances, …) into a JSON-safe records array.
+*/
+function structuredCloneSerialize(value) {
+	return serialize(value);
+}
+/**
+* Inverse of {@link structuredCloneSerialize}.
+*/
+function structuredCloneDeserialize(value) {
+	return deserialize(value);
+}
+/**
+* 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 i, structuredCloneParse as n, structuredCloneSerialize as r, structuredCloneDeserialize as t };

package/dist/types/index.d.mts

@@ -1,4 +1,4 @@
-import { $ as AgentHandle, B as EntriesToObject, G as DevToolsRpcSharedStates, H as Thenable, J as JsonRenderer, K as JsonRenderElement, Q as DevToolsDiagnosticsLogger, U as DevToolsRpcClientFunctions, V as PartialWithoutId, W as DevToolsRpcServerFunctions, X as DevToolsDiagnosticsDefinition, Y as DevToolsHost, Z as DevToolsDiagnosticsHost, _ as RpcStreamingChannel, a as DevtoolRuntime, at as AgentToolInput, c as defineDevtool, ct as EventEmitter, d as DevToolsNodeContext, et as AgentManifest, f as DevToolsNodeRpcSession, g as RpcSharedStateHost, h as RpcSharedStateGetOptions, i as DevtoolDeploymentKind, it as AgentTool, l as ConnectionMeta, lt as EventUnsubscribe, m as RpcFunctionsHost, n as DevtoolCliOptions, nt as AgentResourceContent, o as DevtoolSetupInfo, ot as DevToolsAgentHost, p as RpcBroadcastOptions, q as JsonRenderSpec, r as DevtoolDefinition, rt as AgentResourceInput, s as DevtoolSpaOptions, st as DevToolsAgentHostEvents, t as DevtoolBrowserContext, tt as AgentResource, u as DevToolsCapabilities, ut as EventsMap, v as RpcStreamingChannelOptions, y as RpcStreamingHost, z as DevToolsViewHost } from "../devtool-CNvLs2_Y.mjs";
-import { m as RpcFunctionAgentOptions } from "../types-C5OVe4AC.mjs";
-import { t as DevToolsNodeRpcSessionMeta } from "../ws-server-C7LnhOHi.mjs";
-export { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, ConnectionMeta, DevToolsAgentHost, DevToolsAgentHostEvents, DevToolsCapabilities, DevToolsDiagnosticsDefinition, DevToolsDiagnosticsHost, DevToolsDiagnosticsLogger, DevToolsHost, DevToolsNodeContext, DevToolsNodeRpcSession, DevToolsNodeRpcSessionMeta, DevToolsRpcClientFunctions, DevToolsRpcServerFunctions, DevToolsRpcSharedStates, DevToolsViewHost, DevtoolBrowserContext, DevtoolCliOptions, DevtoolDefinition, DevtoolDeploymentKind, DevtoolRuntime, DevtoolSetupInfo, DevtoolSpaOptions, EntriesToObject, EventEmitter, EventUnsubscribe, EventsMap, JsonRenderElement, JsonRenderSpec, JsonRenderer, PartialWithoutId, RpcBroadcastOptions, RpcFunctionAgentOptions, RpcFunctionsHost, RpcSharedStateGetOptions, RpcSharedStateHost, RpcStreamingChannel, RpcStreamingChannelOptions, RpcStreamingHost, Thenable, defineDevtool };
+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-R5Ex5K5L.mjs";
+import { m as RpcFunctionAgentOptions } from "../types-4rdUEi2R.mjs";
+import { t as DevToolsNodeRpcSessionMeta } from "../ws-server-DjvlwLuM.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 };

package/dist/types/index.mjs

@@ -1,6 +1,6 @@
-//#region src/types/devtool.ts
-function defineDevtool(d) {
+//#region src/types/devframe.ts
+function defineDevframe(d) {
 	return d;
 }
 //#endregion
-export { defineDevtool };
+export { defineDevframe };

package/dist/utils/colors.d.mts

@@ -0,0 +1,28 @@
+//#region src/utils/colors.d.ts
+/**
+ * A colorizer — callable as a function (`colors.red('foo')`) or as a
+ * tagged template (``colors.red`foo ${bar}` ``).
+ */
+interface ColorFn {
+  (text: unknown): string;
+  (template: TemplateStringsArray, ...values: unknown[]): string;
+}
+/**
+ * Minimal terminal color palette. Each entry is callable as both a
+ * plain function and a tagged template.
+ */
+interface Colors {
+  blue: ColorFn;
+  cyan: ColorFn;
+  gray: ColorFn;
+  green: ColorFn;
+  red: ColorFn;
+  yellow: ColorFn;
+  bold: ColorFn;
+  dim: ColorFn;
+  reset: ColorFn;
+  underline: ColorFn;
+}
+declare const colors: Colors;
+//#endregion
+export { ColorFn, Colors, colors };

package/dist/utils/colors.mjs

@@ -0,0 +1,2 @@
+import { t as colors } from "../colors-DS7k8ljB.mjs";
+export { colors };

package/dist/utils/events.d.mts

@@ -1,4 +1,4 @@
-import { ct as EventEmitter, ut as EventsMap } from "../devtool-CNvLs2_Y.mjs";
+import { at as EventEmitter, st as EventsMap } from "../devframe-R5Ex5K5L.mjs";
 
 //#region src/utils/events.d.ts
 /**

package/dist/utils/hash.d.mts

@@ -0,0 +1,7 @@
+//#region src/utils/hash.d.ts
+/**
+ * Stable, deterministic hash of any structured-cloneable value.
+ */
+declare function hash(value: unknown): string;
+//#endregion
+export { hash };

package/dist/utils/hash.mjs

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

package/dist/utils/human-id.d.mts

@@ -1,10 +1,8 @@
-//#region ../../../node_modules/.pnpm/human-id@4.1.3/node_modules/human-id/dist/index.d.ts
-interface Options {
-  separator?: string;
-  capitalize?: boolean;
-  adjectiveCount?: number;
-  addAdverb?: boolean;
-}
-declare function humanId(options?: Options | string | boolean): string;
+//#region src/utils/human-id.d.ts
+/**
+ * Generate a human-readable, lowercase, dash-separated random ID
+ * (e.g. `bright-orange-tiger`).
+ */
+declare function humanId(): string;
 //#endregion
 export { humanId };

package/dist/utils/human-id.mjs

@@ -1,3 +1,2 @@
-import { t as import_dist } from "../human-id-BLoGo_e5.mjs";
-var humanId = import_dist.humanId;
+import { t as humanId } from "../human-id-adtUWQLr.mjs";
 export { humanId };

package/dist/utils/launch-editor.d.mts

@@ -0,0 +1,13 @@
+//#region src/utils/launch-editor.d.ts
+/**
+ * Open a file in the user's editor.
+ *
+ * `target` may be a plain path, `file:line`, or `file:line:column`.
+ *
+ * If `editor` is provided, it is used as the editor command (e.g. `'code'`,
+ * `'subl'`) or absolute binary path. Otherwise the editor is auto-detected
+ * via the `LAUNCH_EDITOR` env var with a fallback to common defaults.
+ */
+declare function launchEditor(target: string, editor?: string): void;
+//#endregion
+export { launchEditor };

package/dist/utils/launch-editor.mjs

@@ -0,0 +1,2 @@
+import { t as launchEditor } from "../launch-editor-CX_n_0SS.mjs";
+export { launchEditor };

package/dist/utils/open.d.mts

@@ -0,0 +1,16 @@
+//#region src/utils/open.d.ts
+interface OpenOptions {
+  /**
+   * Resolve only after the launched app exits.
+   *
+   * @default false
+   */
+  wait?: boolean;
+}
+/**
+ * Open a URL, file, or other target in its default OS handler
+ * (browser for URLs, Finder/Explorer for paths, etc.).
+ */
+declare function open(target: string, options?: OpenOptions): Promise<void>;
+//#endregion
+export { OpenOptions, open };

package/dist/utils/open.mjs

@@ -0,0 +1,2 @@
+import { t as open } from "../open-B2ah1IKK.mjs";
+export { open };

package/dist/utils/serve-static.d.mts

@@ -0,0 +1,40 @@
+import { IncomingMessage, ServerResponse } from "node:http";
+import { EventHandler, H3 } from "h3";
+
+//#region src/utils/serve-static.d.ts
+interface ServeStaticOptions {
+  /** Default: `['index.html']`. */
+  indexNames?: string[];
+  /** SPA fallback to `indexNames[0]` on miss. Default: `true`. */
+  single?: boolean;
+}
+/**
+ * h3 event handler that serves files from `dir` with SPA fallback.
+ *
+ * Drop-in replacement for `fromNodeMiddleware(sirv(dir, { dev: true, single: true }))`
+ * when the surrounding server is an h3 app — no `Cache-Control` beyond
+ * `no-store`, `Content-Type` resolved via `mrmime`, and a miss with no
+ * file extension falls back to `<dir>/index.html` so client-side routing
+ * works.
+ */
+declare function serveStaticHandler(dir: string, options?: ServeStaticOptions): EventHandler;
+/**
+ * Mount {@link serveStaticHandler} on an h3 app at `base`, handling the
+ * route pattern and prefix-stripping required by h3 v2.
+ *
+ * h3 v2's `app.use(base, handler)` only matches the exact `base` path and
+ * does not strip the prefix from `event.url.pathname`. Static serving
+ * needs both subpath matching (`/base/**`) and the URL stripped so the
+ * file resolver sees paths relative to `dir` — this helper bundles both.
+ */
+declare function mountStaticHandler(app: H3, base: string, dir: string, options?: ServeStaticOptions): void;
+/**
+ * Connect/Express-style Node middleware variant of {@link serveStaticHandler}.
+ *
+ * Use when mounting onto `viteServer.middlewares.use(base, …)` or any other
+ * Connect stack — avoids forcing the host package to depend on h3 just to
+ * adapt an event handler back into Node middleware.
+ */
+declare function serveStaticNodeMiddleware(dir: string, options?: ServeStaticOptions): (req: IncomingMessage, res: ServerResponse, next?: (err?: Error) => void) => void;
+//#endregion
+export { ServeStaticOptions, mountStaticHandler, serveStaticHandler, serveStaticNodeMiddleware };