hypervibes 0.0.0-stage → 0.4.0

package/.build/server/assets/decimal-BthtZ77w.js

@@ -0,0 +1,97 @@
+//#region src/hyperliquid/decimal.ts
+/**
+* Minimal string-decimal helpers for display-only exchange amounts. Values
+* arriving from Hyperliquid are kept as strings and combined with integer
+* arithmetic; these are never used for signed amounts or order placement.
+*/
+/** Splits a plain decimal string like `-12.3400`; returns null when malformed. */
+function parseDecimal(value) {
+	if (!/^-?\d+(?:\.\d+)?$/.test(value) || value.includes("e") || value.includes("E")) return null;
+	const negative = value.startsWith("-");
+	const unsigned = negative ? value.slice(1) : value;
+	const separator = unsigned.indexOf(".");
+	const whole = separator === -1 ? unsigned : unsigned.slice(0, separator);
+	const fraction = separator === -1 ? "" : unsigned.slice(separator + 1);
+	return {
+		negative,
+		whole: BigInt(whole),
+		fraction
+	};
+}
+/** Scales two parsed decimals to a common denominator and returns the parts. */
+function commonScale(left, right) {
+	const scale = Math.max(left.fraction.length, right.fraction.length);
+	const scaleUp = (part) => BigInt(part.negative ? -1 : 1) * (part.whole * 10n ** BigInt(scale) + BigInt(part.fraction.padEnd(scale, "0") || "0"));
+	return {
+		leftScaled: scaleUp(left),
+		rightScaled: scaleUp(right),
+		scale
+	};
+}
+/** Adds two plain decimal strings; returns null when either is malformed. */
+function addDecimals(left, right) {
+	const parsedLeft = parseDecimal(left);
+	const parsedRight = parseDecimal(right);
+	if (!parsedLeft || !parsedRight) return null;
+	const { leftScaled, rightScaled, scale } = commonScale(parsedLeft, parsedRight);
+	return formatScaled(leftScaled + rightScaled, scale);
+}
+function formatScaled(scaled, scale) {
+	const negative = scaled < 0n;
+	const absolute = negative ? -scaled : scaled;
+	const denominator = 10n ** BigInt(scale);
+	const whole = absolute / denominator;
+	const canonical = (absolute % denominator).toString().padStart(scale, "0").replace(/0+$/, "");
+	const body = canonical ? `${whole}.${canonical}` : `${whole}`;
+	return negative && absolute !== 0n ? `-${body}` : body;
+}
+/** Compares two plain decimal strings; null when either is malformed. */
+function compareDecimals(left, right) {
+	const parsedLeft = parseDecimal(left);
+	const parsedRight = parseDecimal(right);
+	if (!parsedLeft || !parsedRight) return null;
+	const { leftScaled, rightScaled } = commonScale(parsedLeft, parsedRight);
+	return leftScaled === rightScaled ? 0 : leftScaled < rightScaled ? -1 : 1;
+}
+/**
+* Formats a plain decimal string with fixed precision (4 places by default),
+* half-up rounding, thousands separators and negatives in parentheses.
+*/
+function formatMoneyText(value, decimalPlaces = 4) {
+	if (!value) return "-";
+	const parsed = parseDecimal(value);
+	if (!parsed) return "-";
+	const guard = BigInt(decimalPlaces + 1);
+	const scale = 10n ** guard;
+	const rounded = (parsed.whole * scale + BigInt(parsed.fraction.padEnd(Number(guard), "0").slice(0, Number(guard)) || "0") + 5n) / 10n;
+	const denominator = 10n ** BigInt(decimalPlaces);
+	const whole = rounded / denominator;
+	const fraction = (rounded % denominator).toString().padStart(decimalPlaces, "0");
+	const formatted = `${whole.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",")}.${fraction}`;
+	return parsed.negative && rounded !== 0n ? `(${formatted})` : formatted;
+}
+/** Formats an exchange amount for display: exact fraction preserved (padded to
+* at least 2 decimals), thousands separators on the whole part, and negatives in
+* parentheses. Never rounds; prices and sizes are exchange-exact. */
+function formatAmountText(value) {
+	if (!value) return "-";
+	const parsed = parseDecimal(value);
+	if (!parsed) return "-";
+	const fraction = parsed.fraction.length < 2 ? parsed.fraction.padEnd(2, "0") : parsed.fraction;
+	const body = `${parsed.whole.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",")}.${fraction}`;
+	return parsed.negative ? `(${body})` : body;
+}
+/** Splits formatted money into the whole part and optional decimals. */
+function moneyParts(value) {
+	if (!value) return {
+		whole: "-",
+		decimals: null
+	};
+	const separator = value.indexOf(".");
+	return {
+		whole: separator === -1 ? value : value.slice(0, separator),
+		decimals: separator === -1 ? null : value.slice(separator + 1)
+	};
+}
+//#endregion
+export { moneyParts as a, formatMoneyText as i, compareDecimals as n, formatAmountText as r, addDecimals as t };

package/.build/server/assets/empty-plugin-adapters-MOWBbCMw.js

@@ -0,0 +1,5 @@
+//#region node_modules/.pnpm/@tanstack+start-server-core@1.169.43/node_modules/@tanstack/start-server-core/dist/esm/empty-plugin-adapters.js
+var pluginSerializationAdapters = [];
+var hasPluginAdapters = false;
+//#endregion
+export { hasPluginAdapters, pluginSerializationAdapters };

package/.build/server/assets/errors-DaZqUftX.js

@@ -0,0 +1,151 @@
+//#region src/agents/agent-input.ts
+var uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var agentErrorBrand = Symbol.for("hypervibes.AgentError");
+var AgentError = class extends Error {
+	status;
+	[agentErrorBrand] = true;
+	constructor(message, status = 400) {
+		super(message);
+		this.status = status;
+	}
+};
+/** Fastify and Vite SSR load separate copies of this module in development. */
+function isAgentError(error) {
+	return error instanceof Error && Reflect.get(error, agentErrorBrand) === true;
+}
+function requestId(value) {
+	if (!uuid.test(value) || value.trim() !== value) throw new AgentError("A valid request ID is required");
+	return value.toLowerCase();
+}
+//#endregion
+//#region src/indicators/contracts.ts
+var indicatorLimits = {
+	sourceBytes: 64 * 1024,
+	inputs: 32,
+	numericOutputs: 32,
+	markerOutputs: 32,
+	markerEvents: 1e4,
+	drawings: 500,
+	candles: 5e3,
+	chartInstances: 10,
+	memoryLimitBytes: 128 * 1024 * 1024,
+	timeoutMs: 15e3,
+	maxLoops: 1e4,
+	workers: 8,
+	queuedCalls: 64,
+	resultBytes: 8 * 1024 * 1024,
+	inlineBytes: 24 * 1024,
+	count: 1,
+	maxCount: 5e3,
+	inlineCount: 500,
+	markerLimit: 20,
+	maxMarkerLimit: 100,
+	warnings: 64,
+	listLimit: 20,
+	maxListLimit: 50,
+	cacheEntries: 64,
+	cacheBytes: 64 * 1024 * 1024,
+	cacheTtlMs: 3e4,
+	customPerAgent: 100,
+	versions: 200
+};
+var builtinIndicatorNames = [
+	"sma",
+	"ema",
+	"rsi",
+	"macd",
+	"bollinger",
+	"atr",
+	"adx"
+];
+//#endregion
+//#region src/indicators/validation.ts
+var IndicatorError = class extends Error {
+	status;
+	code;
+	constructor(message, status = 400, code = "indicator_invalid") {
+		super(message);
+		this.status = status;
+		this.code = code;
+		this.name = "IndicatorError";
+	}
+};
+function parseIndicatorId(value) {
+	if (typeof value !== "string") throw new IndicatorError("Invalid indicator ID");
+	if (value.startsWith("builtin:")) {
+		const name = builtinIndicatorNames.find((name) => value === `builtin:${name}`);
+		if (name) return {
+			kind: "builtin",
+			name
+		};
+	}
+	if (/^custom:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value)) return {
+		kind: "custom",
+		uuid: value.slice(7).toLowerCase()
+	};
+	throw new IndicatorError("Invalid indicator ID");
+}
+function safeInputKey(key) {
+	return ![
+		"__proto__",
+		"constructor",
+		"prototype"
+	].includes(key);
+}
+function scalarInput(value) {
+	return typeof value === "boolean" || typeof value === "string" || typeof value === "number" && Number.isFinite(value);
+}
+function validateInputs(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) throw new IndicatorError("Inputs must be a scalar-valued object");
+	const entries = Object.entries(value);
+	if (entries.length > indicatorLimits.inputs) throw new IndicatorError("Too many indicator inputs");
+	for (const [key, item] of entries) if (!safeInputKey(key) || !scalarInput(item)) throw new IndicatorError(`Invalid input: ${key}`);
+	return Object.fromEntries(entries);
+}
+/** Remove strings and comments while retaining newlines and token separation. Not a Pine parser. */
+function pineCodeTokens(source) {
+	let result = "", quote = "", comment = false;
+	for (let i = 0; i < source.length; i++) {
+		const char = source[i];
+		if (comment) if (char === "\n") {
+			comment = false;
+			result += "\n";
+		} else result += " ";
+		else if (quote) if (char === "\\") {
+			result += "  ";
+			i++;
+		} else {
+			if (char === quote) quote = "";
+			result += char === "\n" ? "\n" : " ";
+		}
+		else if (char === "\"" || char === "'") {
+			quote = char;
+			result += " ";
+		} else if (char === "/" && source[i + 1] === "/") {
+			comment = true;
+			result += "  ";
+			i++;
+		} else result += char;
+	}
+	return result;
+}
+function validateSource(source, maxBytes = indicatorLimits.sourceBytes) {
+	if (typeof source !== "string" || new TextEncoder().encode(source).length > maxBytes) throw new IndicatorError(`Pine source exceeds ${maxBytes} bytes`);
+	if (!source.split(/\r?\n/).some((line, index, lines) => /^\s*\/\/@version=[56]\s*$/.test(line) && pineCodeTokens(lines.slice(0, index).join("\n")).trim() === "")) throw new IndicatorError("Native PineScript //@version=5 or //@version=6 is required");
+	const tokens = pineCodeTokens(source);
+	if (/\brequest\s*\./.test(tokens)) throw new IndicatorError("request.* data requests are not supported");
+	if (/\b(strategy|library)\s*\(/.test(tokens) || /^\s*import\b/m.test(tokens)) throw new IndicatorError("Strategies and imported Pine libraries are not supported");
+	if (!/\bindicator\s*\(/.test(tokens)) throw new IndicatorError("An indicator() declaration is required");
+}
+//#endregion
+//#region src/hyperliquid/errors.ts
+/** Public exchange errors surfaced to users with their HTTP status. Browser-safe. */
+var HyperliquidError = class extends Error {
+	status;
+	constructor(message, status = 400) {
+		super(message);
+		this.status = status;
+	}
+};
+//#endregion
+export { validateSource as a, requestId as c, validateInputs as i, IndicatorError as n, AgentError as o, parseIndicatorId as r, isAgentError as s, HyperliquidError as t };

package/.build/server/assets/gateway-CHkruO_a.js

@@ -0,0 +1,193 @@
+import { a as getRequestHeaders, t as createServerFn } from "../server.js";
+import { n as agentUser, t as agentOperation, u as field } from "./agents-CZq-0mna.js";
+import { o as AgentError } from "./errors-DaZqUftX.js";
+import { n as hvUsers } from "./auth-user-DkLo8ojH.js";
+import { t as createServerRpc } from "./createServerRpc-DNqhdU4z.js";
+import { and, eq, sql } from "drizzle-orm";
+import { blob, check, index, integer, primaryKey, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+import { Bot } from "grammy";
+import { createCipheriv, createHash, randomBytes } from "node:crypto";
+//#region src/gateway/telegram/transport.ts
+/** Validates a bot token with Telegram and returns the bot's own username. */
+async function fetchBotUsername(token) {
+	const bot = new Bot(token);
+	await bot.init();
+	return bot.botInfo.username;
+}
+//#endregion
+//#region src/db/agent-schema.ts
+var hvAgents = sqliteTable("hv_agents", {
+	id: text("id").primaryKey(),
+	userId: text("user_id").notNull().references(() => hvUsers.id, { onDelete: "restrict" }),
+	name: text("name").notNull(),
+	creationRequestId: text("creation_request_id").notNull(),
+	state: text("state", { enum: [
+		"provisioning",
+		"ready",
+		"failed",
+		"stopping",
+		"stopped"
+	] }).notNull().default("provisioning"),
+	enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),
+	conversationId: integer("conversation_id"),
+	/** Creation intent only; current selection is owned by Durable's pi.agent. */
+	initialProvider: text("initial_provider"),
+	initialModelId: text("initial_model_id"),
+	error: text("error"),
+	/** Required for new agents by AgentService; nullable only for legacy development rows. */
+	tradingAccountAddress: text("trading_account_address"),
+	createdAt: integer("created_at").notNull(),
+	updatedAt: integer("updated_at").notNull()
+}, (table) => [
+	index("hv_agents_owner_idx").on(table.userId),
+	uniqueIndex("hv_agents_creation_request_idx").on(table.userId, table.creationRequestId),
+	uniqueIndex("hv_agents_trading_account_idx").on(table.tradingAccountAddress),
+	check("hv_agents_name_check", sql`length(trim(${table.name})) BETWEEN 1 AND 80`),
+	check("hv_agents_state_check", sql`${table.state} IN ('provisioning', 'ready', 'failed', 'stopping', 'stopped')`)
+]);
+/** One external gateway per Agent and type: bridges a bound chat with the Agent's persistent main conversation. */
+var hvGateways = sqliteTable("hv_gateways", {
+	agentId: text("agent_id").notNull().references(() => hvAgents.id, { onDelete: "cascade" }),
+	type: text("type", { enum: ["telegram"] }).notNull(),
+	/** AES-256-GCM sealed bot token; never rendered, logged, or returned to clients. */
+	botTokenCiphertext: blob("bot_token_ciphertext", { mode: "buffer" }).notNull(),
+	/** SHA-256 of the plaintext token; a unique index stops two Agents sharing one bot. */
+	botTokenHash: text("bot_token_hash").notNull(),
+	/** Encryption key id that sealed the token, for future key rotation. */
+	keyId: text("key_id").notNull(),
+	/** The bot's own username on the gateway platform. */
+	botUsername: text("bot_username").notNull(),
+	/** The external chat that completed the link flow; null until linked. */
+	chatId: integer("chat_id"),
+	chatUsername: text("chat_username"),
+	updatedAt: integer("updated_at").notNull()
+}, (table) => [primaryKey({ columns: [table.agentId, table.type] }), uniqueIndex("hv_gateways_token_hash_idx").on(table.botTokenHash)]);
+//#endregion
+//#region src/hyperliquid/crypto.ts
+var NONCE_LENGTH = 12;
+/** Encrypts a secret with AES-256-GCM: `nonce ‖ ciphertext ‖ tag`. */
+function encryptSecret(key, plaintext) {
+	const nonce = randomBytes(NONCE_LENGTH);
+	const cipher = createCipheriv("aes-256-gcm", key.bytes, nonce);
+	const ciphertext = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+	return new Uint8Array(Buffer.concat([
+		nonce,
+		ciphertext,
+		cipher.getAuthTag()
+	]));
+}
+//#endregion
+//#region src/gateway/gateway-store.ts
+/** Deterministic token fingerprint backing the cross-Agent uniqueness constraint. */
+function hashBotToken(token) {
+	return createHash("sha256").update(token).digest("hex");
+}
+async function getGateway(db, agentId, type) {
+	return db.select().from(hvGateways).where(and(eq(hvGateways.agentId, agentId), eq(hvGateways.type, type))).get();
+}
+function uniqueTokenViolation(error) {
+	let current = error;
+	for (let depth = 0; current !== null && typeof current === "object" && depth < 5; depth++) {
+		const message = current.message;
+		if (typeof message === "string" && message.includes("UNIQUE constraint failed") && message.includes("bot_token_hash")) return true;
+		current = current.cause;
+	}
+	return false;
+}
+/** Stores a newly validated bot token; the token hash stops two Agents sharing one bot. */
+async function saveGatewayToken(db, key, agentId, type, token, botUsername) {
+	const values = {
+		botTokenCiphertext: Buffer.from(encryptSecret(key, token)),
+		botTokenHash: hashBotToken(token),
+		keyId: key.id,
+		botUsername,
+		updatedAt: Date.now()
+	};
+	try {
+		await db.insert(hvGateways).values({
+			agentId,
+			type,
+			...values
+		}).run();
+	} catch (error) {
+		if (uniqueTokenViolation(error)) throw new AgentError("This bot is already linked to another Agent.", 409);
+		throw error;
+	}
+}
+/** Removes the bot token and binding; false when no gateway row exists. */
+async function deleteGateway(db, agentId, type) {
+	if (!await getGateway(db, agentId, type)) return false;
+	await db.delete(hvGateways).where(and(eq(hvGateways.agentId, agentId), eq(hvGateways.type, type))).run();
+	return true;
+}
+//#endregion
+//#region src/web/gateway.ts?tss-serverfn-split
+/** All server functions target the Telegram gateway, the platform this application currently bridges. */
+var type = "telegram";
+var getGatewayStatus_createServerFn_handler = createServerRpc({
+	id: "10661faaa1aeb1008f42fd9e7c0c674563b5197ac9e18a45aad0d6ab25b3d377",
+	name: "getGatewayStatus",
+	filename: "src/web/gateway.ts"
+}, (opts) => getGatewayStatus.__executeServer(opts));
+var getGatewayStatus = createServerFn({ method: "GET" }).validator((data) => ({ id: field(data, "id") })).handler(getGatewayStatus_createServerFn_handler, async ({ context, data }) => {
+	const user = await agentUser(context.runtime, getRequestHeaders());
+	return agentOperation(async () => {
+		await context.runtime.agents.owned(user.id, data.id, true);
+		return context.runtime.gateway.status(data.id);
+	});
+});
+var addGatewayToken_createServerFn_handler = createServerRpc({
+	id: "ba07ed3fec3c970af3b44bb80f0d77498a44614f7d8c9e5d7ff3ac99857980ce",
+	name: "addGatewayToken",
+	filename: "src/web/gateway.ts"
+}, (opts) => addGatewayToken.__executeServer(opts));
+var addGatewayToken = createServerFn({ method: "POST" }).validator((data) => ({
+	id: field(data, "id"),
+	token: field(data, "token")
+})).handler(addGatewayToken_createServerFn_handler, async ({ context, data }) => {
+	const user = await agentUser(context.runtime, getRequestHeaders(), true);
+	return agentOperation(async () => {
+		await context.runtime.agents.owned(user.id, data.id);
+		const key = context.runtime.gateway.requireKey();
+		if (await getGateway(context.runtime.db, data.id, type)) throw new AgentError("Disconnect the existing Telegram bot before adding a new one.", 409);
+		const token = data.token.trim();
+		if (!token) throw new AgentError("Enter the bot token from @BotFather.");
+		let botUsername;
+		try {
+			botUsername = await fetchBotUsername(token);
+		} catch {
+			throw new AgentError("Telegram rejected this bot token. Check the token from @BotFather.");
+		}
+		await saveGatewayToken(context.runtime.db, key, data.id, type, token, botUsername);
+		await context.runtime.gateway.ensure(data.id);
+		return context.runtime.gateway.status(data.id);
+	});
+});
+var startGatewayLink_createServerFn_handler = createServerRpc({
+	id: "cbcd092ab76fa6a883f83394a7e8dd9f7d59dfd7e2a95fd9e145e6ca94fe911b",
+	name: "startGatewayLink",
+	filename: "src/web/gateway.ts"
+}, (opts) => startGatewayLink.__executeServer(opts));
+var startGatewayLink = createServerFn({ method: "POST" }).validator((data) => ({ id: field(data, "id") })).handler(startGatewayLink_createServerFn_handler, async ({ context, data }) => {
+	const user = await agentUser(context.runtime, getRequestHeaders(), true);
+	return agentOperation(async () => {
+		await context.runtime.agents.owned(user.id, data.id);
+		return { link: await context.runtime.gateway.startLink(data.id, user.id) };
+	});
+});
+var disconnectGateway_createServerFn_handler = createServerRpc({
+	id: "c8ba021d32d5410053f8132e1123b6615d966c77f6f250cb706f2f6a6c16a92f",
+	name: "disconnectGateway",
+	filename: "src/web/gateway.ts"
+}, (opts) => disconnectGateway.__executeServer(opts));
+var disconnectGateway = createServerFn({ method: "POST" }).validator((data) => ({ id: field(data, "id") })).handler(disconnectGateway_createServerFn_handler, async ({ context, data }) => {
+	const user = await agentUser(context.runtime, getRequestHeaders(), true);
+	return agentOperation(async () => {
+		await context.runtime.agents.owned(user.id, data.id);
+		await deleteGateway(context.runtime.db, data.id, type);
+		await context.runtime.gateway.removed(data.id);
+		return context.runtime.gateway.status(data.id);
+	});
+});
+//#endregion
+export { addGatewayToken_createServerFn_handler, disconnectGateway_createServerFn_handler, getGatewayStatus_createServerFn_handler, startGatewayLink_createServerFn_handler };

package/.build/server/assets/identicon-CyawcVnx.js

@@ -0,0 +1,41 @@
+import { jsx } from "react/jsx-runtime";
+//#region src/components/identicon.tsx
+/**
+* Deterministic 8×8 identicon for a wallet address, as an SVG data URI.
+* Port of the legacy application's `identicon_data_uri` so existing users keep
+* the same identicon for their address.
+*/
+function identiconDataUri(address) {
+	let seed = 0;
+	for (let index = 0; index < address.length; index++) seed = seed * 32 - seed + address.charCodeAt(index) >>> 0;
+	const random = () => {
+		seed = (seed * 9301 + 49297) % 233280;
+		return seed / 233280;
+	};
+	const color = () => `hsl(${Math.floor(random() * 360)} ${Math.floor(random() * 60 + 40)}% ${Math.floor((random() + random() + random() + random()) * 25)}%)`;
+	const foreground = color();
+	const background = color();
+	const spot = color();
+	let squares = "";
+	for (let row = 0; row < 8; row++) {
+		const values = [
+			0,
+			1,
+			2,
+			3
+		].map(() => Math.floor(random() * 2.3));
+		values.push(values[3] ?? 0, values[2] ?? 0, values[1] ?? 0, values[0] ?? 0);
+		for (const [column, value] of values.entries()) if (value !== 0) squares += `<rect x="${column}" y="${row}" width="1" height="1" fill="${value === 1 ? foreground : spot}"/>`;
+	}
+	const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 8 8"><rect width="8" height="8" fill="${background}"/>${squares}</svg>`;
+	return `data:image/svg+xml,${encodeURIComponent(svg)}`;
+}
+function Identicon({ address, className }) {
+	return /* @__PURE__ */ jsx("img", {
+		src: identiconDataUri(address),
+		alt: "",
+		className
+	});
+}
+//#endregion
+export { Identicon as t };

package/.build/server/assets/indicator-input-fields-bzuhIh6t.js

@@ -0,0 +1,75 @@
+import { r as configInput } from "./config-dialog-9gSAjwwT.js";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/components/indicator-input-fields.tsx
+function IndicatorInputFields({ schema, value, onChange, disabled = false }) {
+	return /* @__PURE__ */ jsx("fieldset", {
+		disabled,
+		className: "space-y-3",
+		children: schema.map((input) => {
+			const actual = Object.hasOwn(value, input.key) ? value[input.key] : input.default;
+			const change = (item) => onChange({
+				...value,
+				[input.key]: item
+			});
+			return /* @__PURE__ */ jsxs("div", {
+				className: "space-y-1 text-sm",
+				children: [
+					/* @__PURE__ */ jsxs("label", {
+						className: "block",
+						children: [
+							input.title,
+							" ",
+							/* @__PURE__ */ jsxs("span", {
+								className: "text-xs text-zinc-500",
+								children: [
+									"(",
+									input.key,
+									"; default ",
+									String(input.default),
+									")"
+								]
+							}),
+							input.options ? /* @__PURE__ */ jsx("select", {
+								className: `${configInput} cursor-pointer`,
+								value: String(actual),
+								onChange: (e) => change(input.options.find((v) => String(v) === e.target.value)),
+								children: input.options.map((option) => /* @__PURE__ */ jsx("option", {
+									value: String(option),
+									children: String(option)
+								}, String(option)))
+							}) : input.type === "bool" ? /* @__PURE__ */ jsx("input", {
+								className: "ml-2 cursor-pointer",
+								type: "checkbox",
+								checked: actual === true,
+								onChange: (e) => change(e.target.checked)
+							}) : /* @__PURE__ */ jsx("input", {
+								className: configInput,
+								type: input.type === "int" || input.type === "float" ? "number" : "text",
+								value: String(actual),
+								min: input.min,
+								max: input.max,
+								step: input.step ?? (input.type === "int" ? 1 : "any"),
+								onChange: (e) => {
+									const next = input.type === "int" || input.type === "float" ? Number(e.target.value) : e.target.value;
+									change(next);
+								}
+							})
+						]
+					}),
+					input.tooltip && /* @__PURE__ */ jsx("p", {
+						className: "text-xs text-zinc-400",
+						children: input.tooltip
+					}),
+					Object.hasOwn(value, input.key) && /* @__PURE__ */ jsx("button", {
+						type: "button",
+						className: "cursor-pointer text-xs underline",
+						onClick: () => onChange(Object.fromEntries(Object.entries(value).filter(([key]) => key !== input.key))),
+						children: "Use source default"
+					})
+				]
+			}, input.key);
+		})
+	});
+}
+//#endregion
+export { IndicatorInputFields as t };