devframe 0.1.20 → 0.1.22

package/dist/{static-dump-C1aVSwxY.mjs → static-dump-D7AvjrgL.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-CkZuoz-m.mjs";
 import { DEVTOOLS_RPC_DUMP_DIRNAME } from "./constants.mjs";
 //#region src/node/static-dump.ts
 function makeDumpKey(name) {

package/dist/storage-CNC38eU-.mjs

@@ -0,0 +1,117 @@
+import { n as logger } from "./diagnostics-BFhNNmST.mjs";
+import { t as createSharedState } from "./shared-state-DCDs0e7y.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
+const DEBOUNCE_DEFAULTS = { trailing: true };
+/**
+Debounce functions
+@param fn - Promise-returning/async function to debounce.
+@param wait - Milliseconds to wait before calling `fn`. Default value is 25ms
+@returns A function that delays calling `fn` until after `wait` milliseconds have elapsed since the last time it was called.
+@example
+```
+import { debounce } from 'perfect-debounce';
+const expensiveCall = async input => input;
+const debouncedFn = debounce(expensiveCall, 200);
+for (const number of [1, 2, 3]) {
+console.log(await debouncedFn(number));
+}
+//=> 1
+//=> 2
+//=> 3
+```
+*/
+function debounce(fn, wait = 25, options = {}) {
+	options = {
+		...DEBOUNCE_DEFAULTS,
+		...options
+	};
+	if (!Number.isFinite(wait)) throw new TypeError("Expected `wait` to be a finite number");
+	let leadingValue;
+	let timeout;
+	let resolveList = [];
+	let currentPromise;
+	let trailingArgs;
+	const applyFn = (_this, args) => {
+		currentPromise = _applyPromised(fn, _this, args);
+		currentPromise.finally(() => {
+			currentPromise = null;
+			if (options.trailing && trailingArgs && !timeout) {
+				const promise = applyFn(_this, trailingArgs);
+				trailingArgs = null;
+				return promise;
+			}
+		});
+		return currentPromise;
+	};
+	const debounced = function(...args) {
+		if (options.trailing) trailingArgs = args;
+		if (currentPromise) return currentPromise;
+		return new Promise((resolve) => {
+			const shouldCallNow = !timeout && options.leading;
+			clearTimeout(timeout);
+			timeout = setTimeout(() => {
+				timeout = null;
+				const promise = options.leading ? leadingValue : applyFn(this, args);
+				trailingArgs = null;
+				for (const _resolve of resolveList) _resolve(promise);
+				resolveList = [];
+			}, wait);
+			if (shouldCallNow) {
+				leadingValue = applyFn(this, args);
+				resolve(leadingValue);
+			} else resolveList.push(resolve);
+		});
+	};
+	const _clearTimeout = (timer) => {
+		if (timer) {
+			clearTimeout(timer);
+			timeout = null;
+		}
+	};
+	debounced.isPending = () => !!timeout;
+	debounced.cancel = () => {
+		_clearTimeout(timeout);
+		resolveList = [];
+		trailingArgs = null;
+	};
+	debounced.flush = () => {
+		_clearTimeout(timeout);
+		if (!trailingArgs || currentPromise) return;
+		const args = trailingArgs;
+		trailingArgs = null;
+		return applyFn(this, args);
+	};
+	return debounced;
+}
+async function _applyPromised(fn, _this, args) {
+	return await fn.apply(_this, args);
+}
+//#endregion
+//#region src/node/storage.ts
+function createStorage(options) {
+	const { mergeInitialValue = (initialValue, savedValue) => ({
+		...initialValue,
+		...savedValue
+	}), debounce: debounceTime = 100 } = options;
+	let initialValue = options.initialValue;
+	if (fs.existsSync(options.filepath)) try {
+		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();
+		initialValue = options.initialValue;
+	}
+	const state = createSharedState({
+		initialValue,
+		enablePatches: false
+	});
+	state.on("updated", debounce((newState) => {
+		fs.mkdirSync(dirname(options.filepath), { recursive: true });
+		fs.writeFileSync(options.filepath, `${JSON.stringify(newState, null, 2)}\n`);
+	}, debounceTime));
+	return state;
+}
+//#endregion
+export { createStorage as t };

package/dist/structured-clone-DcDc2Dds.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 DevToolsRpcServerFunctions, $t as AgentManifest, At as DevToolsViewCustomRender, Bt as DevToolsDiagnosticsHost, Ct as DevToolsDockEntryBase, Dt as DevToolsDockUserEntry, Et as DevToolsDockHost, Ft as JsonRenderElement, G as DevToolsChildProcessExecuteOptions, Gt as DevToolsCommandHandle, H as EntriesToObject, Ht as DevToolsClientCommand, It as JsonRenderSpec, J as DevToolsTerminalSession, Jt as DevToolsCommandsHost, K as DevToolsChildProcessTerminalSession, Kt as DevToolsCommandKeybinding, Lt as JsonRenderer, Mt as DevToolsViewJsonRender, Nt as DevToolsViewLauncher, Ot as DevToolsViewAction, Pt as DevToolsViewLauncherStatus, Q as DevToolsRpcClientFunctions, Qt as AgentHandle, Rt as RemoteDockOptions, St as DevToolsDockEntry, Tt as DevToolsDockEntryIcon, U as PartialWithoutId, Ut as DevToolsCommandBase, V as DevToolsViewHost, Vt as DevToolsDiagnosticsLogger, W as Thenable, Wt as DevToolsCommandEntry, X as DevToolsTerminalStatus, Xt as DevToolsServerCommandEntry, Y as DevToolsTerminalSessionBase, Yt as DevToolsCommandsHostEvents, Z as DevToolsDocksUserSettings, Zt as DevToolsServerCommandInput, _ as RpcSharedStateGetOptions, _t as DevToolsMessagesClient, a as DevtoolRuntime, an as DevToolsAgentHost, at as DevToolsLogFilePosition, b as RpcStreamingChannelOptions, bt as ClientScriptEntry, c as defineDevtool, cn as EventUnsubscribe, ct as DevToolsLogsClient, d as DevToolsNodeContext, dt as DevToolsMessageEntry, en as AgentResource, et as DevToolsRpcSharedStates, f as DevToolsNodeUtils, ft as DevToolsMessageEntryFrom, g as RpcFunctionsHost, gt as DevToolsMessageLevel, h as RpcBroadcastOptions, ht as DevToolsMessageHandle, i as DevtoolDeploymentKind, in as AgentToolInput, it as DevToolsLogEntryInput, jt as DevToolsViewIframe, kt as DevToolsViewBuiltin, l as ConnectionMeta, ln as EventsMap, lt as DevToolsLogsHost, m as DevToolsNodeRpcSession, mt as DevToolsMessageFilePosition, n as DevtoolCliOptions, nn as AgentResourceInput, nt as DevToolsLogEntry, o as DevtoolSetupInfo, on as DevToolsAgentHostEvents, ot as DevToolsLogHandle, p as RemoteConnectionInfo, pt as DevToolsMessageEntryInput, q as DevToolsTerminalHost, qt as DevToolsCommandShortcutOverrides, r as DevtoolDefinition, rn as AgentTool, rt as DevToolsLogEntryFrom, s as DevtoolSpaOptions, sn as EventEmitter, st as DevToolsLogLevel, t as DevtoolBrowserContext, tn as AgentResourceContent, tt as DevToolsLogElementPosition, u as DevToolsCapabilities, ut as DevToolsMessageElementPosition, v as RpcSharedStateHost, vt as DevToolsMessagesHost, wt as DevToolsDockEntryCategory, x as RpcStreamingHost, xt as DevToolsDockEntriesGrouped, y as RpcStreamingChannel, yt as DevToolsHost, zt as DevToolsDiagnosticsDefinition } from "../devtool-Bm6zZAw5.mjs";
-import { m as RpcFunctionAgentOptions } from "../types-ag029cAe.mjs";
-import { t as DevToolsNodeRpcSessionMeta } from "../ws-server-VQqESKAs.mjs";
-export { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, ClientScriptEntry, ConnectionMeta, DevToolsAgentHost, DevToolsAgentHostEvents, DevToolsCapabilities, DevToolsChildProcessExecuteOptions, DevToolsChildProcessTerminalSession, DevToolsClientCommand, DevToolsCommandBase, DevToolsCommandEntry, DevToolsCommandHandle, DevToolsCommandKeybinding, DevToolsCommandShortcutOverrides, DevToolsCommandsHost, DevToolsCommandsHostEvents, DevToolsDiagnosticsDefinition, DevToolsDiagnosticsHost, DevToolsDiagnosticsLogger, DevToolsDockEntriesGrouped, DevToolsDockEntry, DevToolsDockEntryBase, DevToolsDockEntryCategory, DevToolsDockEntryIcon, DevToolsDockHost, DevToolsDockUserEntry, DevToolsDocksUserSettings, DevToolsHost, DevToolsLogElementPosition, DevToolsLogEntry, DevToolsLogEntryFrom, DevToolsLogEntryInput, DevToolsLogFilePosition, DevToolsLogHandle, DevToolsLogLevel, DevToolsLogsClient, DevToolsLogsHost, DevToolsMessageElementPosition, DevToolsMessageEntry, DevToolsMessageEntryFrom, DevToolsMessageEntryInput, DevToolsMessageFilePosition, DevToolsMessageHandle, DevToolsMessageLevel, DevToolsMessagesClient, DevToolsMessagesHost, DevToolsNodeContext, DevToolsNodeRpcSession, DevToolsNodeRpcSessionMeta, DevToolsNodeUtils, DevToolsRpcClientFunctions, DevToolsRpcServerFunctions, DevToolsRpcSharedStates, DevToolsServerCommandEntry, DevToolsServerCommandInput, DevToolsTerminalHost, DevToolsTerminalSession, DevToolsTerminalSessionBase, DevToolsTerminalStatus, DevToolsViewAction, DevToolsViewBuiltin, DevToolsViewCustomRender, DevToolsViewHost, DevToolsViewIframe, DevToolsViewJsonRender, DevToolsViewLauncher, DevToolsViewLauncherStatus, DevtoolBrowserContext, DevtoolCliOptions, DevtoolDefinition, DevtoolDeploymentKind, DevtoolRuntime, DevtoolSetupInfo, DevtoolSpaOptions, EntriesToObject, EventEmitter, EventUnsubscribe, EventsMap, JsonRenderElement, JsonRenderSpec, JsonRenderer, PartialWithoutId, RemoteConnectionInfo, RemoteDockOptions, RpcBroadcastOptions, RpcFunctionAgentOptions, RpcFunctionsHost, RpcSharedStateGetOptions, RpcSharedStateHost, RpcStreamingChannel, RpcStreamingChannelOptions, RpcStreamingHost, Thenable, defineDevtool };
+import { $ as DevToolsRpcSharedStates, C as RpcSharedStateGetOptions, D as RpcStreamingHost, E as RpcStreamingChannelOptions, J as EntriesToObject, Q as DevToolsRpcServerFunctions, S as RpcFunctionsHost, T as RpcStreamingChannel, X as Thenable, Y as PartialWithoutId, Z as DevToolsRpcClientFunctions, _ as ConnectionMeta, a as DevframeRuntime, at as AgentManifest, b as DevToolsNodeRpcSession, c as DevtoolBrowserContext, ct as AgentResourceInput, d as DevtoolDeploymentKind, dt as DevToolsAgentHost, et as DevToolsHost, f as DevtoolRuntime, ft as DevToolsAgentHostEvents, g as defineDevtool, h as defineDevframe, ht as EventsMap, i as DevframeDeploymentKind, it as AgentHandle, l as DevtoolCliOptions, lt as AgentTool, m as DevtoolSpaOptions, mt as EventUnsubscribe, n as DevframeCliOptions, nt as DevToolsDiagnosticsHost, o as DevframeSetupInfo, ot as AgentResource, p as DevtoolSetupInfo, pt as EventEmitter, q as DevToolsViewHost, r as DevframeDefinition, rt as DevToolsDiagnosticsLogger, s as DevframeSpaOptions, st as AgentResourceContent, t as DevframeBrowserContext, tt as DevToolsDiagnosticsDefinition, u as DevtoolDefinition, ut as AgentToolInput, v as DevToolsCapabilities, w as RpcSharedStateHost, x as RpcBroadcastOptions, y as DevToolsNodeContext } from "../devframe-DulcIxwu.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, DevtoolBrowserContext, DevtoolCliOptions, DevtoolDefinition, DevtoolDeploymentKind, DevtoolRuntime, DevtoolSetupInfo, DevtoolSpaOptions, EntriesToObject, EventEmitter, EventUnsubscribe, EventsMap, PartialWithoutId, RpcBroadcastOptions, RpcFunctionAgentOptions, RpcFunctionsHost, RpcSharedStateGetOptions, RpcSharedStateHost, RpcStreamingChannel, RpcStreamingChannelOptions, RpcStreamingHost, Thenable, defineDevframe, defineDevtool };

package/dist/types/index.mjs

@@ -1,6 +1,15 @@
-//#region src/types/devtool.ts
+//#region src/types/devframe.ts
+function defineDevframe(d) {
+	return d;
+}
+let warnedDefineDevtool = false;
+/** @deprecated Use `defineDevframe`. */
 function defineDevtool(d) {
+	if (!warnedDefineDevtool) {
+		warnedDefineDevtool = true;
+		console.warn("[devframe] `defineDevtool` is deprecated; use `defineDevframe` instead.");
+	}
 	return d;
 }
 //#endregion
-export { defineDevtool };
+export { defineDevframe, defineDevtool };

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-Bl4W18Mh.mjs";
+export { colors };

package/dist/utils/events.d.mts

@@ -1,4 +1,4 @@
-import { ln as EventsMap, sn as EventEmitter } from "../devtool-Bm6zZAw5.mjs";
+import { ht as EventsMap, pt as EventEmitter } from "../devframe-DulcIxwu.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-BHZbo80D.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-CHS0s28X.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-KA_21J1T.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-DmFp0qZA.mjs";
+export { open };

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

@@ -0,0 +1,30 @@
+import { IncomingMessage, ServerResponse } from "node:http";
+import { EventHandler, EventHandlerRequest } 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<EventHandlerRequest>;
+/**
+ * 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, serveStaticHandler, serveStaticNodeMiddleware };