hypervibes 0.0.0-stage → 0.4.0

package/.build/server/assets/indicator-queries-4dY1-LXx.js

@@ -0,0 +1,171 @@
+import { t as createServerFn } from "../server.js";
+import { C as createSsrRpc, _ as optionalNumber, u as field } from "./agents-CZq-0mna.js";
+import { a as validateSource, c as requestId, i as validateInputs, o as AgentError } from "./errors-DaZqUftX.js";
+import { a as record, o as revision } from "./contracts-CG-nZuYJ.js";
+import { queryOptions } from "@tanstack/react-query";
+//#region src/web/indicators.ts
+function windowInput(value) {
+	const v = record(value), start = optionalNumber(v, "start"), end = optionalNumber(v, "end");
+	if (start === void 0 || end === void 0) throw new AgentError("An explicit validation start/end is required");
+	if (end <= start) throw new AgentError("The validation window must end after it starts");
+	return {
+		coin: field(v, "coin"),
+		interval: field(v, "interval"),
+		start,
+		end
+	};
+}
+var listIndicators = createServerFn({ method: "GET" }).validator((data) => {
+	const v = record(data), kind = v.kind;
+	if (kind !== void 0 && kind !== "all" && kind !== "builtin" && kind !== "custom") throw new AgentError("Invalid indicator kind");
+	return {
+		agentId: field(v, "agentId"),
+		query: v.query === void 0 ? void 0 : field(v, "query"),
+		kind,
+		offset: optionalNumber(v, "offset"),
+		limit: optionalNumber(v, "limit")
+	};
+}).handler(createSsrRpc("00964fe21edb108d3cda55ebd5291a54026b148db66510fc2649b642258e569a"));
+var getIndicator = createServerFn({ method: "GET" }).validator((data) => {
+	const v = record(data);
+	if (v.includeSource !== void 0 && typeof v.includeSource !== "boolean") throw new AgentError("Invalid source selection");
+	return {
+		agentId: field(v, "agentId"),
+		indicatorId: field(v, "indicatorId"),
+		version: optionalNumber(v, "version"),
+		includeSource: v.includeSource,
+		sourceOffset: optionalNumber(v, "sourceOffset"),
+		sourceLimit: optionalNumber(v, "sourceLimit")
+	};
+}).handler(createSsrRpc("a876e4fca7d57a7f00fc5fcd144ff8083d42aba4eceff7c7cc76cbca976f9d39"));
+var getIndicatorVersions = createServerFn({ method: "GET" }).validator((data) => ({
+	agentId: field(data, "agentId"),
+	indicatorId: field(data, "indicatorId"),
+	offset: optionalNumber(data, "offset"),
+	limit: optionalNumber(data, "limit")
+})).handler(createSsrRpc("6baf5bca38717239ece5c328e63517c914843a5aaa2b1705b55b2247a5658353"));
+var previewIndicator = createServerFn({ method: "POST" }).validator((data) => {
+	const v = record(data), request = record(v.request);
+	const source = field(request, "source");
+	validateSource(source);
+	const parsed = {
+		source,
+		...windowInput(request),
+		inputs: validateInputs(request.inputs ?? {}),
+		count: optionalNumber(request, "count"),
+		markerLimit: optionalNumber(request, "markerLimit")
+	};
+	return {
+		agentId: field(v, "agentId"),
+		request: parsed
+	};
+}).handler(createSsrRpc("1f55ecc9fb92e12098a1d38c2da2810dd0c81bbc989f3f89a49927a2287ca00d"));
+var previewSavedIndicator = createServerFn({ method: "POST" }).validator((data) => {
+	const v = record(data), r = record(v.request);
+	return {
+		agentId: field(v, "agentId"),
+		request: {
+			indicatorId: field(r, "indicatorId"),
+			version: optionalNumber(r, "version"),
+			...windowInput(r),
+			inputs: validateInputs(r.inputs ?? {}),
+			count: optionalNumber(r, "count")
+		}
+	};
+}).handler(createSsrRpc("14ef82e1b6f56a0be942672cb8b064436b2c64a76c4dbe66be464e6df55e02b7"));
+var saveIndicator = createServerFn({ method: "POST" }).validator((data) => {
+	const v = record(data), r = record(v.request);
+	const request = {
+		name: field(r, "name"),
+		description: field(r, "description"),
+		interpretation: field(r, "interpretation"),
+		source: field(r, "source"),
+		indicatorId: r.indicatorId === void 0 ? void 0 : field(r, "indicatorId"),
+		expectedVersion: optionalNumber(r, "expectedVersion"),
+		validation: r.validation === void 0 ? void 0 : windowInput(r.validation)
+	};
+	return {
+		agentId: field(v, "agentId"),
+		operationKey: requestId(field(v, "operationKey")),
+		request
+	};
+}).handler(createSsrRpc("107544c82d871bc1b91ed4c109db747bb4216d4db195acea4937d29234fe5dbc"));
+var renderChartIndicators = createServerFn({ method: "POST" }).validator((data) => ({
+	agentId: field(data, "agentId"),
+	layoutId: requestId(field(data, "layoutId")),
+	revision: revision(record(data).revision),
+	end: revision(record(data).end),
+	coin: field(data, "coin"),
+	interval: field(data, "interval")
+})).handler(createSsrRpc("7e4ee5e99019cdc6e596042689c4f641d4848e50bafb620da1a4530d6be302d3"));
+//#endregion
+//#region src/web/indicator-queries.ts
+var indicatorKeys = { all: (agentId) => ["indicators", agentId] };
+var indicatorListQueryOptions = (agentId, options = {}) => queryOptions({
+	queryKey: [
+		...indicatorKeys.all(agentId),
+		"list",
+		options
+	],
+	queryFn: () => listIndicators({ data: {
+		agentId,
+		...options
+	} }),
+	staleTime: 3e4
+});
+var indicatorQueryOptions = (agentId, indicatorId, options = {}) => queryOptions({
+	queryKey: [
+		...indicatorKeys.all(agentId),
+		"detail",
+		indicatorId,
+		options
+	],
+	queryFn: () => getIndicator({ data: {
+		agentId,
+		indicatorId,
+		...options
+	} }),
+	staleTime: 3e4
+});
+var indicatorVersionsQueryOptions = (agentId, indicatorId, offset = 0) => queryOptions({
+	queryKey: [
+		...indicatorKeys.all(agentId),
+		"versions",
+		indicatorId,
+		offset
+	],
+	queryFn: () => getIndicatorVersions({ data: {
+		agentId,
+		indicatorId,
+		offset
+	} }),
+	staleTime: 3e4
+});
+var chartIndicatorQueryOptions = (agentId, layoutId, revision, coin, interval, end) => queryOptions({
+	queryKey: [
+		...indicatorKeys.all(agentId),
+		"render",
+		layoutId,
+		revision,
+		coin,
+		interval,
+		end
+	],
+	queryFn: ({ signal }) => renderChartIndicators({
+		data: {
+			agentId,
+			layoutId,
+			revision,
+			coin,
+			interval,
+			end
+		},
+		signal
+	}),
+	staleTime: Infinity,
+	gcTime: 6e4,
+	retry: 2,
+	retryDelay: 2e3
+});
+//#endregion
+export { indicatorVersionsQueryOptions as a, previewSavedIndicator as c, indicatorQueryOptions as i, saveIndicator as l, indicatorKeys as n, getIndicator as o, indicatorListQueryOptions as r, previewIndicator as s, chartIndicatorQueryOptions as t };

package/.build/server/assets/indicator-renderer-B2muPS-8.js

@@ -0,0 +1,395 @@
+import { HistogramSeries, LineSeries, LineStyle } from "lightweight-charts";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/charts/geometry.ts
+function lineEnds(kind, a, b, width) {
+	if (kind === "horizontal") return [{
+		x: 0,
+		y: a.y
+	}, {
+		x: width,
+		y: a.y
+	}];
+	if (kind === "horizontal-ray") return [a, {
+		x: width,
+		y: a.y
+	}];
+	const dx = b.x - a.x;
+	if (!dx || kind !== "ray" && kind !== "extended") return [a, b];
+	const at = (x) => ({
+		x,
+		y: a.y + (b.y - a.y) * (x - a.x) / dx
+	});
+	if (kind === "extended") return [at(0), at(width)];
+	return [a, at(dx > 0 ? width : 0)];
+}
+//#endregion
+//#region src/charts/indicator-primitives.ts
+function indicatorTimeCoordinate(chart, candles, time, step) {
+	const scale = chart.timeScale(), direct = scale.timeToCoordinate(time);
+	if (direct !== null) return direct;
+	if (!candles.length) return null;
+	let lo = 0, hi = candles.length - 1;
+	while (lo < hi) {
+		const mid = Math.ceil((lo + hi) / 2);
+		if (candles[mid].time <= time) lo = mid;
+		else hi = mid - 1;
+	}
+	const anchor = candles[lo], x = scale.timeToCoordinate(anchor.time);
+	return x === null ? null : x + (time - anchor.time) / step * scale.options().barSpacing;
+}
+/** Chart-native, read-only Pine visuals. Their IDs never enter the annotation editor. */
+var IndicatorPrimitive = class {
+	data;
+	chart;
+	series;
+	request;
+	hits = [];
+	renderer = { draw: (target) => target.useMediaCoordinateSpace(({ context, mediaSize }) => this.draw(context, mediaSize.width, mediaSize.height)) };
+	views = [{
+		zOrder: () => "normal",
+		renderer: () => this.renderer
+	}];
+	constructor(data) {
+		this.data = data;
+	}
+	attached(parameters) {
+		this.chart = parameters.chart;
+		this.series = parameters.series;
+		this.request = parameters.requestUpdate;
+	}
+	detached() {
+		this.chart = void 0;
+		this.series = void 0;
+		this.request = void 0;
+		this.hits.length = 0;
+	}
+	update(data) {
+		this.data = data;
+		this.request?.();
+	}
+	updateAllViews() {
+		this.hits.length = 0;
+	}
+	paneViews() {
+		return this.views;
+	}
+	hitTest(x, y) {
+		const hit = this.hits.slice().reverse().find((hit) => Math.hypot(hit.x - x, hit.y - y) < 12);
+		return hit ? {
+			externalId: hit.id,
+			zOrder: "normal",
+			cursorStyle: "default",
+			distance: Math.hypot(hit.x - x, hit.y - y),
+			hitTestPriority: 2
+		} : null;
+	}
+	describe(id) {
+		return this.hits.find((hit) => hit.id === id)?.text;
+	}
+	autoscaleInfo() {
+		const values = this.data.result.drawings.filter((d) => this.owns(d)).flatMap((d) => d.kind === "label" ? d.location === "pr" ? [d.at.price] : [] : [d.from.price, d.to.price]);
+		for (const level of this.data.result.levels) if (this.owns(level) && !level.style.hidden) values.push(level.value);
+		return values.length ? { priceRange: {
+			minValue: Math.min(...values),
+			maxValue: Math.max(...values)
+		} } : null;
+	}
+	owns(item) {
+		return (item.forceOverlay || (this.data.instance.pane === "price" ? true : this.data.instance.pane === "separate" ? false : item.overlay)) === this.data.overlay;
+	}
+	draw(ctx, width, height) {
+		if (!this.chart || !this.series) return;
+		const { result, instance, candles } = this.data;
+		const step = result.dataset.count > 1 ? (result.dataset.lastOpenTime - result.dataset.firstOpenTime) / (result.dataset.count - 1) : result.end / 1e3 - result.dataset.lastOpenTime;
+		const x = (time) => indicatorTimeCoordinate(this.chart, candles, time, step);
+		const y = (price) => this.series.priceToCoordinate(price);
+		const outputMap = new Map(result.outputs.map((output) => [output.id, new Map(output.points.map((p) => [p.time, p]))]));
+		const levels = new Map(result.levels.map((level) => [level.id, level]));
+		const point = (id, time) => {
+			const output = result.outputs.find((p) => p.id === id), level = levels.get(id);
+			if (output && !this.owns(output) || level && !this.owns(level)) return null;
+			const p = outputMap.get(id)?.get(time), value = p?.value ?? level?.value;
+			if (value === void 0 || value === null) return null;
+			const px = x(p?.displayTime ?? time), py = y(value);
+			return px === null || py === null ? null : {
+				x: px,
+				y: py
+			};
+		};
+		this.hits.length = 0;
+		ctx.save();
+		ctx.beginPath();
+		ctx.rect(0, 0, width, height);
+		ctx.clip();
+		for (const fill of result.fills) {
+			if (fill.hidden || instance.styles[fill.id]?.hidden) continue;
+			for (let i = 1; i < fill.points.length; i++) {
+				const a = fill.points[i - 1], b = fill.points[i], p1 = point(fill.from, a.time), p2 = point(fill.from, b.time), p3 = point(fill.to, b.time), p4 = point(fill.to, a.time);
+				if (!p1 || !p2 || !p3 || !p4) continue;
+				ctx.fillStyle = instance.styles[fill.id]?.color ?? b.color ?? fill.color ?? "#2962ff30";
+				ctx.beginPath();
+				ctx.moveTo(p1.x, p1.y);
+				for (const p of [
+					p2,
+					p3,
+					p4
+				]) ctx.lineTo(p.x, p.y);
+				ctx.closePath();
+				ctx.fill();
+			}
+		}
+		for (const level of result.levels) {
+			if (!this.owns(level) || level.style.hidden || instance.styles[level.id]?.hidden) continue;
+			const py = y(level.value);
+			if (py === null) continue;
+			ctx.strokeStyle = instance.styles[level.id]?.color ?? level.style.color ?? "#787b86";
+			ctx.lineWidth = instance.styles[level.id]?.width ?? level.style.width ?? 1;
+			ctx.setLineDash(level.style.lineStyle?.includes("dot") ? [2, 3] : level.style.lineStyle?.includes("dash") ? [6, 4] : []);
+			ctx.beginPath();
+			ctx.moveTo(0, py);
+			ctx.lineTo(width, py);
+			ctx.stroke();
+		}
+		ctx.setLineDash([]);
+		for (const marker of result.markers) {
+			if (!this.owns(marker) || instance.styles[marker.outputId]?.hidden) continue;
+			const px = x(marker.displayTime);
+			if (px === null || px < -50 || px > width + 50) continue;
+			const candle = candles.find((c) => c.time === marker.displayTime) ?? candles.find((c) => c.time === marker.time);
+			let py = marker.location === "Top" ? 15 : marker.location === "Bottom" ? height - 15 : marker.location === "Absolute" && typeof marker.value === "number" ? y(marker.value) : candle ? y(marker.location === "BelowBar" ? candle.low : candle.high) : null;
+			if (py === null) continue;
+			if (marker.location === "BelowBar") py += 14;
+			else if (marker.location === "AboveBar" || !marker.location) py -= 14;
+			const down = marker.kind === "arrow" ? typeof marker.value === "number" && marker.value < 0 : marker.shape?.includes("down");
+			ctx.fillStyle = instance.styles[marker.outputId]?.color ?? marker.color ?? "#a78bfa";
+			ctx.font = "12px sans-serif";
+			ctx.textAlign = "center";
+			ctx.fillText(marker.kind === "char" ? marker.character ?? "•" : marker.shape?.includes("circle") ? "●" : marker.shape?.includes("cross") ? "+" : down ? "▼" : "▲", px, py);
+			if (marker.text) {
+				ctx.fillStyle = marker.textColor ?? marker.color ?? "#d4d4d8";
+				ctx.fillText(marker.text, px, py + (down ? 16 : -14));
+			}
+			this.hits.push({
+				id: `pine:${instance.id}:${result.resultHash}:${marker.id}`,
+				x: px,
+				y: py,
+				text: `${marker.text ?? marker.character ?? marker.kind} · source ${(/* @__PURE__ */ new Date(marker.time * 1e3)).toISOString()}`
+			});
+		}
+		for (const drawing of result.drawings) {
+			if (!this.owns(drawing) || instance.styles[drawing.id]?.hidden) continue;
+			const anchor = drawing.kind === "label" ? drawing.at : drawing.from, px = x(anchor.time);
+			let py = y(anchor.price);
+			if (drawing.kind === "label" && drawing.location !== "pr") {
+				const candle = candles.find((c) => c.time === anchor.time);
+				if (candle) py = y(drawing.location === "ab" ? candle.high : candle.low);
+			}
+			if (px === null || py === null) continue;
+			ctx.strokeStyle = instance.styles[drawing.id]?.color ?? drawing.color ?? "#a78bfa";
+			ctx.fillStyle = ctx.strokeStyle;
+			ctx.lineWidth = instance.styles[drawing.id]?.width ?? drawing.width ?? 1;
+			ctx.setLineDash(drawing.lineStyle?.includes("dash") ? [6, 4] : drawing.lineStyle?.includes("dot") ? [2, 3] : []);
+			if (drawing.kind === "label") {
+				const textY = py + (drawing.location === "ab" ? -14 : drawing.location === "bl" ? 14 : 0);
+				ctx.font = `${drawing.size === "large" ? 16 : 12}px sans-serif`;
+				ctx.textAlign = "center";
+				if (drawing.color) {
+					const w = ctx.measureText(drawing.text).width + 8;
+					ctx.fillRect(px - w / 2, textY - 13, w, 18);
+				}
+				ctx.fillStyle = drawing.textColor || "#d4d4d8";
+				ctx.fillText(drawing.text, px, textY);
+			} else this.drawObject(ctx, drawing, px, py, x(drawing.to.time), y(drawing.to.price), width);
+			this.hits.push({
+				id: `pine:${instance.id}:${result.resultHash}:${drawing.id}`,
+				x: px,
+				y: py,
+				text: drawing.kind === "line" ? `Line · ${anchor.price}` : drawing.text
+			});
+		}
+		ctx.restore();
+	}
+	drawObject(ctx, drawing, x1, y1, x2, y2, width) {
+		if (x2 === null || y2 === null) return;
+		if (drawing.kind === "box") {
+			const left = drawing.extend === "left" || drawing.extend === "both" ? 0 : Math.min(x1, x2), right = drawing.extend === "right" || drawing.extend === "both" ? width : Math.max(x1, x2);
+			ctx.fillStyle = drawing.background ?? "#2962ff30";
+			ctx.fillRect(left, Math.min(y1, y2), right - left, Math.abs(y2 - y1));
+			ctx.strokeRect(left, Math.min(y1, y2), right - left, Math.abs(y2 - y1));
+			if (drawing.text) {
+				ctx.fillStyle = drawing.textColor ?? "#d4d4d8";
+				ctx.font = "12px sans-serif";
+				ctx.textAlign = "center";
+				ctx.fillText(drawing.text, (left + right) / 2, (y1 + y2) / 2);
+			}
+		} else {
+			const a = {
+				x: x1,
+				y: y1
+			}, b = {
+				x: x2,
+				y: y2
+			};
+			const [from, to] = drawing.extend === "both" ? lineEnds("extended", a, b, width) : drawing.extend === "right" ? lineEnds("ray", a.x <= b.x ? a : b, a.x <= b.x ? b : a, width) : drawing.extend === "left" ? lineEnds("ray", a.x >= b.x ? a : b, a.x >= b.x ? b : a, width) : [a, b];
+			ctx.beginPath();
+			ctx.moveTo(from.x, from.y);
+			ctx.lineTo(to.x, to.y);
+			ctx.stroke();
+		}
+	}
+};
+//#endregion
+//#region src/charts/indicator-renderer.ts
+var indicator_renderer_exports = /* @__PURE__ */ __exportAll({ createIndicatorRenderer: () => createIndicatorRenderer });
+/** Owns only indicator resources, never candles/volume/account overlays or annotation records. */
+function createIndicatorRenderer(chart, price) {
+	const owned = /* @__PURE__ */ new Map();
+	const remove = (id) => {
+		const current = owned.get(id);
+		if (!current) return;
+		for (const { series, primitive } of current.anchors) series.detachPrimitive(primitive);
+		for (const series of [...current.series, ...current.anchors.map((a) => a.series)]) chart.removeSeries(series);
+		owned.delete(id);
+	};
+	return {
+		apply(instance, result, candles) {
+			const signature = JSON.stringify([
+				instance,
+				result.resultHash,
+				candles[0]?.time,
+				candles.at(-1)?.time,
+				candles.length
+			]);
+			if (owned.get(instance.id)?.signature === signature) return;
+			const range = chart.timeScale().getVisibleRange();
+			remove(instance.id);
+			if (instance.hidden) return;
+			const state = {
+				signature,
+				series: [],
+				anchors: []
+			};
+			owned.set(instance.id, state);
+			try {
+				const target = (item) => item.forceOverlay || (instance.pane === "auto" ? item.overlay : instance.pane === "price");
+				const paneIndex = (overlay) => {
+					if (overlay) return 0;
+					if (!state.pane) {
+						state.pane = chart.addPane();
+						state.pane.setHeight(150);
+					}
+					return state.pane.paneIndex();
+				};
+				const bars = new Set(candles.map((c) => c.time));
+				for (const output of result.outputs) {
+					const override = instance.styles[output.id];
+					if (output.style.hidden || override?.hidden) continue;
+					const pane = paneIndex(target(output));
+					const color = override?.color ?? output.style.color ?? "#a78bfa";
+					const series = output.kind === "line" ? chart.addSeries(LineSeries, {
+						color,
+						lineWidth: Math.max(1, Math.min(4, override?.width ?? output.style.width ?? 2)),
+						lineStyle: output.style.lineStyle?.includes("dash") ? LineStyle.Dashed : output.style.lineStyle?.includes("dot") ? LineStyle.Dotted : LineStyle.Solid,
+						lastValueVisible: false,
+						priceLineVisible: false,
+						crosshairMarkerVisible: false
+					}, pane) : chart.addSeries(HistogramSeries, {
+						color,
+						base: 0,
+						lastValueVisible: false,
+						priceLineVisible: false
+					}, pane);
+					state.series.push(series);
+					const points = new Map(output.points.filter((p) => bars.has(p.displayTime)).map((p) => [p.displayTime, p.value === null ? { time: p.displayTime } : {
+						time: p.displayTime,
+						value: p.value,
+						color: override?.color ?? p.color ?? color
+					}]));
+					series.setData([...points.values()].sort((a, b) => Number(a.time) - Number(b.time)));
+				}
+				const panes = /* @__PURE__ */ new Set();
+				for (const item of [
+					...result.outputs,
+					...result.levels,
+					...result.markers,
+					...result.drawings
+				]) panes.add(target(item));
+				for (const overlay of panes) {
+					const pane = paneIndex(overlay);
+					const anchor = chart.addSeries(LineSeries, {
+						priceScaleId: overlay ? price.options().priceScaleId : "right",
+						color: "#00000000",
+						lastValueVisible: false,
+						priceLineVisible: false,
+						crosshairMarkerVisible: false
+					}, pane);
+					let min = Infinity, max = -Infinity;
+					for (const output of result.outputs) if (target(output) === overlay) {
+						for (const p of output.points) if (p.value !== null && bars.has(p.time)) {
+							min = Math.min(min, p.value);
+							max = Math.max(max, p.value);
+						}
+					}
+					if (overlay) {
+						min = candles[0]?.close ?? 1;
+						max = candles.at(-1)?.close ?? min;
+					} else if (!Number.isFinite(min)) {
+						min = 0;
+						max = 1;
+					}
+					const first = candles[0], last = candles.at(-1);
+					if (first && last) anchor.setData(first.time === last.time ? [{
+						time: first.time,
+						value: min
+					}] : [{
+						time: first.time,
+						value: min
+					}, {
+						time: last.time,
+						value: max
+					}]);
+					const primitive = new IndicatorPrimitive({
+						instance,
+						result,
+						candles,
+						overlay,
+						paneHeight: () => chart.panes()[pane]?.getHeight() ?? 0
+					});
+					anchor.attachPrimitive(primitive);
+					state.anchors.push({
+						series: anchor,
+						primitive
+					});
+				}
+			} catch (error) {
+				remove(instance.id);
+				throw error;
+			} finally {
+				if (range) chart.timeScale().setVisibleRange(range);
+			}
+		},
+		remove,
+		describe(id) {
+			for (const current of owned.values()) for (const { primitive } of current.anchors) {
+				const text = primitive.describe(id);
+				if (text !== void 0) return text;
+			}
+		},
+		close() {
+			for (const id of [...owned.keys()]) remove(id);
+		}
+	};
+}
+//#endregion
+export { indicator_renderer_exports as n, lineEnds as r, createIndicatorRenderer as t };