@hansenexus/hud 0.2.0 → 0.4.0

package/dist/plugins/ops.js

@@ -0,0 +1,362 @@
+import { i as definePlugin, n as HudApiError } from "../plugins-DVy_vaYr.js";
+import { i as OPS_CAPABILITY, r as stateRating, t as TELEMETRY_RANGES } from "../types-QJUajwWq.js";
+import { useCallback, useState, useSyncExternalStore } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+//#region src/plugins/ops/poll.ts
+/** Entries per plugin context, so the pill and the panel share one poller per path. */
+const entries = /* @__PURE__ */ new WeakMap();
+function entryFor(ctx, path) {
+	let byPath = entries.get(ctx);
+	if (!byPath) {
+		byPath = /* @__PURE__ */ new Map();
+		entries.set(ctx, byPath);
+	}
+	let entry = byPath.get(path);
+	if (!entry) {
+		entry = {
+			state: { loading: true },
+			listeners: /* @__PURE__ */ new Set(),
+			inflight: false
+		};
+		byPath.set(path, entry);
+	}
+	return entry;
+}
+/** A readable message for a failed poll; 502 bodies carry the provider's own. */
+function describeError(error) {
+	if (error instanceof HudApiError) {
+		if (error.status === 404) return "route not mounted: add ops() to createHudHandler";
+		const body = error.body;
+		if (typeof body?.error === "string") return body.error;
+		return `HTTP ${error.status}`;
+	}
+	return error instanceof Error ? error.message : "request failed";
+}
+function set(entry, state) {
+	entry.state = state;
+	for (const listener of entry.listeners) listener();
+}
+async function tick(ctx, path, entry, force = false) {
+	if (entry.inflight || !force && typeof document !== "undefined" && document.hidden) return;
+	entry.inflight = true;
+	try {
+		set(entry, {
+			data: await ctx.api(path),
+			loading: false
+		});
+	} catch (error) {
+		set(entry, {
+			...entry.state,
+			error: describeError(error),
+			loading: false
+		});
+	} finally {
+		entry.inflight = false;
+	}
+}
+/**
+* Polls one of the plugin's routes while anything renders it. Pauses while
+* the tab is hidden; subscribers of the same path share one request.
+*/
+function usePoll(ctx, path, intervalMs) {
+	const entry = entryFor(ctx, path);
+	const subscribe = useCallback((listener) => {
+		entry.listeners.add(listener);
+		if (entry.listeners.size === 1) {
+			tick(ctx, path, entry);
+			entry.timer = setInterval(() => void tick(ctx, path, entry), intervalMs);
+		}
+		return () => {
+			entry.listeners.delete(listener);
+			if (entry.listeners.size === 0) clearInterval(entry.timer);
+		};
+	}, [
+		ctx,
+		path,
+		entry,
+		intervalMs
+	]);
+	const state = useSyncExternalStore(subscribe, () => entry.state, () => entry.state);
+	const refresh = useCallback(() => void tick(ctx, path, entry, true), [
+		ctx,
+		path,
+		entry
+	]);
+	return {
+		...state,
+		refresh
+	};
+}
+//#endregion
+//#region src/plugins/ops/styles.ts
+/** Panel styles, rendered as a `<style>` inside the panel, so inside the shadow root. */
+const OPS_CSS = `
+.ops { display: grid; gap: 12px; }
+.ops section { display: grid; gap: 6px; }
+.ops h3 {
+  margin: 0;
+  font-size: 10px;
+  font-weight: 600;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  color: var(--hud-fg-muted);
+}
+.ops .head { display: flex; align-items: center; gap: 6px; font-family: var(--hud-mono); }
+.ops .head .branch { font-weight: 600; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.ops .warn { color: var(--hud-warn); margin: 0; }
+.ops .muted { color: var(--hud-fg-muted); }
+.ops ul { list-style: none; margin: 0; padding: 0; display: grid; gap: 2px; }
+.ops li a, .ops li > span {
+  display: grid;
+  grid-template-columns: 6px minmax(0, 1fr) auto auto;
+  align-items: center;
+  gap: 8px;
+  padding: 3px 4px;
+  border-radius: 4px;
+  color: inherit;
+  text-decoration: none;
+}
+.ops li a:hover { background: var(--hud-bg-subtle); }
+.ops .title { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.ops .title small { color: var(--hud-fg-muted); margin-left: 6px; }
+.ops .mono { font-family: var(--hud-mono); color: var(--hud-fg-muted); }
+.ops .stats { display: grid; grid-template-columns: repeat(3, 1fr); gap: 6px; }
+.ops .stat { padding: 6px 8px; border: 1px solid var(--hud-border); border-radius: 6px; }
+.ops .stat b { display: block; font-family: var(--hud-mono); font-size: 13px; }
+.ops .stat span { font-size: 10px; color: var(--hud-fg-muted); }
+.ops .row { display: flex; align-items: center; justify-content: space-between; gap: 6px; }
+.ops .ranges { display: flex; gap: 2px; }
+.ops button.chip { padding: 1px 6px; border-radius: 999px; font-family: var(--hud-mono); }
+.ops button.chip:hover, .ops button.chip[aria-pressed="true"] { background: var(--hud-bg-subtle); }
+`;
+//#endregion
+//#region src/plugins/ops/ops-panel.tsx
+const CI_POLL_MS = 6e4;
+const TELEMETRY_POLL_MS = 6e4;
+const STATE_LABEL = {
+	success: "passing",
+	failure: "failing",
+	cancelled: "cancelled",
+	running: "running",
+	queued: "queued",
+	neutral: "neutral"
+};
+function stateLabel(state) {
+	return state ? STATE_LABEL[state] : "no runs";
+}
+/** `3m`, `5h`, `2d` since `iso`. */
+function age(iso, now = Date.now()) {
+	if (!iso) return "";
+	const seconds = Math.max(0, Math.round((now - Date.parse(iso)) / 1e3));
+	if (seconds < 60) return `${seconds}s`;
+	if (seconds < 3600) return `${Math.round(seconds / 60)}m`;
+	if (seconds < 86400) return `${Math.round(seconds / 3600)}h`;
+	return `${Math.round(seconds / 86400)}d`;
+}
+function Missing({ name }) {
+	return /* @__PURE__ */ jsxs("p", {
+		className: "warn",
+		children: [
+			"Not configured: set ",
+			/* @__PURE__ */ jsx("code", { children: name ?? "its env" }),
+			" in the app's server env."
+		]
+	});
+}
+function RunRow({ run }) {
+	const content = /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx("span", {
+			className: "dot",
+			"data-rating": stateRating(run.state),
+			title: STATE_LABEL[run.state]
+		}),
+		/* @__PURE__ */ jsxs("span", {
+			className: "title",
+			title: run.title,
+			children: [run.name, /* @__PURE__ */ jsx("small", { children: run.title })]
+		}),
+		/* @__PURE__ */ jsx("span", {
+			className: "mono",
+			children: run.sha
+		}),
+		/* @__PURE__ */ jsx("span", {
+			className: "mono",
+			children: age(run.startedAt)
+		})
+	] });
+	return /* @__PURE__ */ jsx("li", { children: run.url ? /* @__PURE__ */ jsx("a", {
+		href: run.url,
+		target: "_blank",
+		rel: "noreferrer",
+		children: content
+	}) : /* @__PURE__ */ jsx("span", { children: content }) });
+}
+function Deployment({ deployment }) {
+	if (!deployment) return /* @__PURE__ */ jsx("p", {
+		className: "muted",
+		children: "Nothing deployed."
+	});
+	const rows = [
+		["Environment", deployment.environment],
+		["Image", deployment.image],
+		["Sha", deployment.sha],
+		["Ready", deployment.ready],
+		["Since", deployment.at && `${age(deployment.at)} ago`]
+	];
+	return /* @__PURE__ */ jsx("table", {
+		className: "vitals",
+		children: /* @__PURE__ */ jsx("tbody", { children: rows.flatMap(([label, value]) => value ? /* @__PURE__ */ jsxs("tr", { children: [/* @__PURE__ */ jsx("td", {
+			className: "label",
+			children: label
+		}), /* @__PURE__ */ jsx("td", { children: value })] }, label) : []) })
+	});
+}
+function CiSection({ ctx }) {
+	const { data, error, loading, refresh } = usePoll(ctx, "/ci", CI_POLL_MS);
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsxs("section", {
+		"aria-label": "CI",
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "row",
+				children: [/* @__PURE__ */ jsxs("h3", { children: ["CI", data ? ` · ${data.repo}` : ""] }), /* @__PURE__ */ jsx("button", {
+					type: "button",
+					className: "chip",
+					onClick: refresh,
+					children: "refresh"
+				})]
+			}),
+			loading && /* @__PURE__ */ jsx("p", {
+				className: "muted",
+				children: "Loading…"
+			}),
+			error && /* @__PURE__ */ jsx("p", {
+				className: "warn",
+				children: error
+			}),
+			data && !data.configured && /* @__PURE__ */ jsx(Missing, { name: data.missing }),
+			data?.configured && /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsxs("div", {
+				className: "head",
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						className: "dot",
+						"data-rating": stateRating(data.state)
+					}),
+					/* @__PURE__ */ jsx("span", {
+						className: "branch",
+						children: data.branch ?? "no branch"
+					}),
+					/* @__PURE__ */ jsxs("span", {
+						className: "muted",
+						children: [data.branch ? stateLabel(data.state) : "latest runs, all branches", data.sha ? ` @ ${data.sha}` : ""]
+					})
+				]
+			}), data.runs.length > 0 ? /* @__PURE__ */ jsx("ul", { children: data.runs.map((run) => /* @__PURE__ */ jsx(RunRow, { run }, run.id)) }) : /* @__PURE__ */ jsxs("p", {
+				className: "muted",
+				children: [
+					"No runs",
+					data.branch ? ` on ${data.branch}` : "",
+					"."
+				]
+			})] })
+		]
+	}), data && data.deployment !== void 0 && /* @__PURE__ */ jsxs("section", {
+		"aria-label": "Deployment",
+		children: [/* @__PURE__ */ jsx("h3", { children: "Deployment" }), /* @__PURE__ */ jsx(Deployment, { deployment: data.deployment })]
+	})] });
+}
+function formatStat(value, unit) {
+	if (value === null) return "–";
+	return `${value.toFixed(value < 10 ? 2 : 0)}${unit}`;
+}
+function TelemetrySection({ ctx }) {
+	const [range, setRange] = useState("1h");
+	const { data, error, loading } = usePoll(ctx, `/telemetry?range=${range}`, TELEMETRY_POLL_MS);
+	return /* @__PURE__ */ jsxs("section", {
+		"aria-label": "Telemetry",
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "row",
+				children: [/* @__PURE__ */ jsxs("h3", { children: ["Telemetry", data ? ` · ${data.service}` : ""] }), /* @__PURE__ */ jsx("div", {
+					className: "ranges",
+					children: TELEMETRY_RANGES.map((r) => /* @__PURE__ */ jsx("button", {
+						type: "button",
+						className: "chip",
+						"aria-pressed": r === range,
+						onClick: () => setRange(r),
+						children: r
+					}, r))
+				})]
+			}),
+			loading && !data && /* @__PURE__ */ jsx("p", {
+				className: "muted",
+				children: "Loading…"
+			}),
+			error && /* @__PURE__ */ jsx("p", {
+				className: "warn",
+				children: error
+			}),
+			data && !data.configured && /* @__PURE__ */ jsx(Missing, { name: data.missing }),
+			data?.configured && /* @__PURE__ */ jsxs("div", {
+				className: "stats",
+				children: [
+					/* @__PURE__ */ jsxs("div", {
+						className: "stat",
+						children: [/* @__PURE__ */ jsx("b", { children: formatStat(data.errorRate, "/s") }), /* @__PURE__ */ jsx("span", { children: "errors" })]
+					}),
+					/* @__PURE__ */ jsxs("div", {
+						className: "stat",
+						children: [/* @__PURE__ */ jsx("b", { children: formatStat(data.p95Ms, " ms") }), /* @__PURE__ */ jsx("span", { children: "p95" })]
+					}),
+					/* @__PURE__ */ jsxs("div", {
+						className: "stat",
+						children: [/* @__PURE__ */ jsx("b", { children: formatStat(data.requestRate, "/s") }), /* @__PURE__ */ jsx("span", { children: "requests" })]
+					})
+				]
+			})
+		]
+	});
+}
+function createOpsPanel({ ci, telemetry }) {
+	function OpsPanel({ ctx }) {
+		return /* @__PURE__ */ jsxs("div", {
+			className: "ops",
+			children: [
+				/* @__PURE__ */ jsx("style", { children: OPS_CSS }),
+				ci && /* @__PURE__ */ jsx(CiSection, { ctx }),
+				telemetry && /* @__PURE__ */ jsx(TelemetrySection, { ctx })
+			]
+		});
+	}
+	return OpsPanel;
+}
+//#endregion
+//#region src/plugins/ops/index.tsx
+function OpsPill({ ctx }) {
+	const { data, error } = usePoll(ctx, "/ci", CI_POLL_MS);
+	const label = !data && error ? "error" : !data ? "–" : !data.configured ? "off" : stateLabel(data.state);
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("span", {
+		className: "dot",
+		"data-rating": data ? stateRating(data.state) : void 0
+	}), `CI ${label}`] });
+}
+/**
+* CI and telemetry: the pill shows the CI state of the branch the server runs
+* on, the panel lists recent runs, the deployment (when the CI provider knows
+* it) and error rate, p95 and request rate. Client half; the providers live in
+* the server half, `@hansenexus/hud/plugins/ops/server`, which reads tokens
+* from env and never sends them to the browser.
+*/
+function ops({ ci = true, telemetry = true } = {}) {
+	return definePlugin({
+		id: "ops",
+		title: "Ops",
+		capability: OPS_CAPABILITY,
+		panel: createOpsPanel({
+			ci,
+			telemetry
+		}),
+		...ci ? { pill: OpsPill } : {}
+	});
+}
+//#endregion
+export { ops };

package/dist/plugins/vitals.d.ts

@@ -0,0 +1,25 @@
+import { Metric } from "web-vitals";
+//#region src/plugins/vitals/vitals-panel.d.ts
+declare function VitalsPanel(): import("react").JSX.Element;
+//#endregion
+//#region src/plugins/vitals/store.d.ts
+type VitalName = Metric["name"];
+type VitalRating = Metric["rating"];
+interface Vital {
+  name: VitalName;
+  value: number;
+  rating: VitalRating;
+}
+type VitalsSnapshot = Partial<Record<VitalName, Vital>>;
+//#endregion
+//#region src/plugins/vitals/index.d.ts
+declare function VitalsPill(): import("react").JSX.Element;
+/** Core Web Vitals: LCP in the pill, all five metrics in the panel. Client only. */
+export declare function vitals(): {
+  readonly id: "vitals";
+  readonly title: "Vitals";
+  readonly pill: typeof VitalsPill;
+  readonly panel: typeof VitalsPanel;
+};
+//#endregion
+export type { Vital, VitalName, VitalRating, VitalsSnapshot };

package/dist/plugins/vitals.js

@@ -0,0 +1,26 @@
+import { i as definePlugin } from "../plugins-DVy_vaYr.js";
+import { i as useVitals, n as formatVital, r as startVitals, t as VitalsPanel } from "../vitals-panel-Dvc5dnR-.js";
+import { useEffect } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+//#region src/plugins/vitals/index.tsx
+function VitalsPill() {
+	useEffect(() => {
+		startVitals();
+	}, []);
+	const lcp = useVitals().LCP;
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("span", {
+		className: "dot",
+		"data-rating": lcp?.rating
+	}), lcp ? `LCP ${formatVital("LCP", lcp.value)}` : "LCP –"] });
+}
+/** Core Web Vitals: LCP in the pill, all five metrics in the panel. Client only. */
+function vitals() {
+	return definePlugin({
+		id: "vitals",
+		title: "Vitals",
+		pill: VitalsPill,
+		panel: VitalsPanel
+	});
+}
+//#endregion
+export { vitals };

package/dist/plugins-CQ_0w1ot.d.ts

@@ -0,0 +1,114 @@
+import { r as GrabPayload } from "./payload-CLKDVZWl.js";
+import { ComponentType } from "react";
+//#region src/core/grabber/store.d.ts
+interface HudGrabState {
+  /** The picker is active: the next click on the page completes the grab. */
+  grabbing: boolean;
+  /** The last completed grab, until a plugin clears it. */
+  payload: GrabPayload | null;
+}
+/** Grab mode for one HUD, shared by the shell and every plugin's `ctx.grab`. */
+interface HudGrab {
+  start: () => void;
+  cancel: () => void;
+  /** Forgets the last payload, e.g. once it has been dispatched. */
+  clear: () => void;
+  getState: () => HudGrabState;
+  subscribe: (listener: () => void) => () => void;
+}
+/** Subscribes a component to a HUD's grab state: `useGrab(ctx.grab)`. */
+declare function useGrab(grab: HudGrab): HudGrabState;
+//#endregion
+//#region src/core/plugins.d.ts
+/**
+ * A capability a plugin needs, such as `"cicd.read"`. Core assumes development
+ * and grants everything; the `access` plugin brings a matrix for deployed tiers.
+ */
+type HudCapability = string;
+type PinEdge = "left" | "right" | "bottom";
+/** What a plugin's panel and pill receive from the shell. */
+interface HudPluginContext {
+  /** App slug from `defineHud({ app })`. */
+  app: string;
+  /** Whether the current tier grants `capability`. */
+  can: (capability: HudCapability) => boolean;
+  /**
+   * Fetches JSON from this plugin's server routes: `api("/runs")` requests
+   * `<apiBase>/<plugin id>/runs`. Rejects with `HudApiError` on a non-2xx status.
+   */
+  api: <T = unknown>(path: string, init?: RequestInit) => Promise<T>;
+  /** Pins this plugin's panel to an edge. Below 768 px the pin is kept but not applied. */
+  pin: (edge: PinEdge) => void;
+  /** Closes this plugin's panel. */
+  close: () => void;
+  /** Opens this plugin's panel. */
+  open: () => void;
+  /** The HUD's element grabber: start a grab, read or clear the last payload. See `useGrab`. */
+  grab: HudGrab;
+}
+interface HudPluginProps {
+  ctx: HudPluginContext;
+}
+interface HudCommand {
+  /** Unique within the plugin. */
+  id: string;
+  title: string;
+  /** Shortcut in `mod+shift+k` form; `mod` is ⌘ on macOS and Ctrl elsewhere. */
+  shortcut?: string;
+  run: (ctx: HudPluginContext) => void;
+}
+type HudHttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+interface HudRouteContext {
+  /** Values of `:name` segments in the matched path. */
+  params: Record<string, string>;
+}
+type HudRouteHandler = (request: Request, ctx: HudRouteContext) => Response | Promise<Response>;
+/**
+ * Server routes keyed by path below the plugin's prefix, then by method:
+ * `{ "/runs/:id": { GET } }` serves `GET <apiBase>/<plugin id>/runs/42`.
+ */
+type HudRoutes = Record<string, Partial<Record<HudHttpMethod, HudRouteHandler>>>;
+/**
+ * The plugin contract. A plugin ships as two subpath exports that share this
+ * type: `@hansenexus/hud/plugins/<id>` carries the client half (`panel`,
+ * `pill`, `commands`) and `@hansenexus/hud/plugins/<id>/server` the server half
+ * (`routes`), so route code never reaches a client bundle and React never
+ * reaches the route handler. Both halves carry the same `id` and `capability`.
+ */
+interface HudPlugin {
+  /** Unique per HUD; also the URL segment of the plugin's routes. */
+  id: string;
+  /** Panel title and pill label when the plugin has no `pill`. Defaults to `id`. */
+  title?: string;
+  /** Without it the plugin is dropped, client and server side. */
+  capability?: HudCapability;
+  /** Floating panel content, opened from the plugin's pill item. */
+  panel?: ComponentType<HudPluginProps>;
+  /** Live content inside the plugin's pill item. Keep it inline and non-interactive. */
+  pill?: ComponentType<HudPluginProps>;
+  commands?: readonly HudCommand[];
+  /** Called when a grab (⌘⇧G or the pill's crosshair) completes. */
+  onGrab?: (payload: GrabPayload, ctx: HudPluginContext) => void;
+  routes?: HudRoutes;
+  /** Opens deployed tiers (the `access` plugin). Without one the HUD renders only in development. */
+  access?: HudAccessControl;
+}
+/**
+ * What the `access` plugin hands `defineHud`. `env` is the loader's tier
+ * (`development`, `preview`, `staging`, `production`, `disabled`).
+ */
+interface HudAccessControl {
+  /** Capability check for the tier; outside development it narrows `can`. */
+  can: (env: string, capability: HudCapability) => boolean;
+  /** Hook: whether the operator has unlocked this tier. Until then only the access plugin shows. */
+  useUnlocked: (env: string, apiBase: string) => boolean;
+}
+/** Identity helper that types a plugin object without widening it. */
+declare function definePlugin<const P extends HudPlugin>(plugin: P): P;
+declare class HudApiError extends Error {
+  readonly status: number;
+  readonly body: unknown;
+  constructor(status: number, body: unknown, url: string);
+}
+//#endregion
+export { HudHttpMethod as a, HudPluginProps as c, HudRoutes as d, PinEdge as f, useGrab as g, HudGrabState as h, HudCommand as i, HudRouteContext as l, HudGrab as m, HudApiError as n, HudPlugin as o, definePlugin as p, HudCapability as r, HudPluginContext as s, HudAccessControl as t, HudRouteHandler as u };

package/dist/plugins-DVy_vaYr.js

@@ -0,0 +1,70 @@
+//#region src/core/plugins.ts
+const HUD_HTTP_METHODS = [
+	"GET",
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE"
+];
+/** Identity helper that types a plugin object without widening it. */
+function definePlugin(plugin) {
+	return plugin;
+}
+const PLUGIN_ID = /^[a-z0-9][a-z0-9-]*$/;
+/**
+* Validates plugin ids and drops plugins whose capability `can` denies.
+* Ids must be unique and URL-safe because they become route segments.
+*/
+function resolvePlugins(plugins, can) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const plugin of plugins) {
+		if (!PLUGIN_ID.test(plugin.id)) throw new Error(`hud: plugin id "${plugin.id}" must match ${PLUGIN_ID}`);
+		if (seen.has(plugin.id)) throw new Error(`hud: duplicate plugin id "${plugin.id}"`);
+		seen.add(plugin.id);
+	}
+	return plugins.filter((plugin) => plugin.capability === void 0 || can(plugin.capability));
+}
+var HudApiError = class extends Error {
+	status;
+	body;
+	constructor(status, body, url) {
+		super(`hud: ${url} answered ${status}`);
+		this.status = status;
+		this.body = body;
+		this.name = "HudApiError";
+	}
+};
+function createPluginContext(plugin, { app, apiBase, can, pin, close, open, grab }) {
+	const prefix = `${apiBase.replace(/\/+$/, "")}/${plugin.id}`;
+	return {
+		app,
+		can,
+		pin,
+		close,
+		open,
+		grab,
+		api: async (path, init) => {
+			const url = `${prefix}/${path.replace(/^\/+/, "")}`;
+			const headers = new Headers(init?.headers);
+			if (!headers.has("accept")) headers.set("accept", "application/json");
+			const res = await fetch(url, {
+				...init,
+				headers
+			});
+			const body = parseBody(await res.text());
+			if (!res.ok) throw new HudApiError(res.status, body, url);
+			return body;
+		}
+	};
+}
+/** JSON when it parses, the raw text otherwise (an HTML error page, say). */
+function parseBody(text) {
+	if (!text) return void 0;
+	try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+}
+//#endregion
+export { resolvePlugins as a, definePlugin as i, HudApiError as n, createPluginContext as r, HUD_HTTP_METHODS as t };