hypervibes 0.0.0-stage → 0.4.0

package/dist/indicators/indicator-store.js

@@ -0,0 +1,137 @@
+import { randomUUID } from "node:crypto";
+import { and, desc, eq } from "drizzle-orm";
+import { bodyHash, canonical } from "../canonical.js";
+import { hvIndicators, hvIndicatorOperations, hvIndicatorVersions } from "../db/indicator-schema.js";
+import { applicationDatabase } from "../db/shared-database.js";
+import { indicatorEngine, indicatorLimits, indicatorWrapperVersion } from "./contracts.js";
+import { IndicatorError, parseIndicatorId, validateSource } from "./validation.js";
+export function indicatorPage(offset = 0, limit = indicatorLimits.listLimit) {
+    if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(limit) || limit < 1 || limit > indicatorLimits.maxListLimit)
+        throw new IndicatorError("Invalid indicator page");
+    return { offset, limit };
+}
+function validateSave(request) {
+    for (const [value, max, field] of [[request.name, 100, "name"], [request.description, 2000, "description"], [request.interpretation, 8000, "interpretation"]]) {
+        if (typeof value !== "string" || value.length > max || (field === "name" && !value.trim()))
+            throw new IndicatorError(`Invalid indicator ${field}`);
+    }
+    validateSource(request.source);
+    if (request.indicatorId) {
+        if (parseIndicatorId(request.indicatorId).kind !== "custom")
+            throw new IndicatorError("Built-in indicators are read-only");
+        if (!Number.isSafeInteger(request.expectedVersion) || request.expectedVersion < 1)
+            throw new IndicatorError("expectedVersion is required on updates");
+    }
+    else if (request.expectedVersion !== undefined)
+        throw new IndicatorError("New indicators cannot specify expectedVersion");
+}
+/** Application-owned immutable source history. Network/VM validation occurs outside the short SQL transaction. */
+export class IndicatorStore {
+    database;
+    db;
+    constructor(database) {
+        this.database = database;
+        this.db = applicationDatabase(database);
+    }
+    async agentTx(tx, agentId) {
+        const agent = await tx.get("SELECT state FROM hv_agents WHERE id=?", agentId);
+        if (!agent)
+            throw new IndicatorError("Agent not found", 404);
+        if (agent.state === "stopping" || agent.state === "stopped")
+            throw new IndicatorError("Agent is being deleted", 409);
+    }
+    async assertAgent(agentId) { await this.agentTx(this.database, agentId); }
+    async list(agentId) {
+        await this.assertAgent(agentId);
+        // A hard 100-definition quota bounds this metadata-only merge with the static catalog.
+        const definitions = await this.db.select().from(hvIndicators).where(eq(hvIndicators.agentId, agentId)).orderBy(desc(hvIndicators.updatedAt)).all();
+        return Promise.all(definitions.map((definition) => this.get(agentId, `custom:${definition.id}`).then((entry) => entry.descriptor)));
+    }
+    async get(agentId, id, version) {
+        const parsed = parseIndicatorId(id);
+        if (parsed.kind !== "custom")
+            throw new IndicatorError("Not a custom indicator");
+        if (version !== undefined && (!Number.isSafeInteger(version) || version < 1))
+            throw new IndicatorError("Invalid indicator version");
+        await this.assertAgent(agentId);
+        const definition = await this.db.select().from(hvIndicators).where(and(eq(hvIndicators.id, parsed.uuid), eq(hvIndicators.agentId, agentId))).get();
+        if (!definition)
+            throw new IndicatorError("Indicator not found", 404);
+        const saved = await this.db.select().from(hvIndicatorVersions).where(and(eq(hvIndicatorVersions.indicatorId, definition.id), eq(hvIndicatorVersions.version, version ?? definition.currentVersion))).get();
+        if (!saved)
+            throw new IndicatorError("Indicator version not found", 404);
+        const metadata = JSON.parse(saved.metadata);
+        return { source: saved.source, createdAt: saved.createdAt, descriptor: { id: `custom:${definition.id}`, builtIn: false, name: definition.name, description: definition.description, interpretation: definition.interpretation,
+                version: saved.version, sourceHash: saved.sourceHash, inputs: metadata.inputs, overlay: metadata.overlay } };
+    }
+    async versions(agentId, id, options = {}) {
+        await this.get(agentId, id);
+        const parsed = parseIndicatorId(id);
+        if (parsed.kind !== "custom")
+            throw new IndicatorError("Not a custom indicator");
+        const { offset, limit } = indicatorPage(options.offset, options.limit);
+        const rows = await this.db.select({ version: hvIndicatorVersions.version, sourceHash: hvIndicatorVersions.sourceHash, createdAt: hvIndicatorVersions.createdAt, actorKind: hvIndicatorVersions.actorKind }).from(hvIndicatorVersions)
+            .where(eq(hvIndicatorVersions.indicatorId, parsed.uuid)).orderBy(desc(hvIndicatorVersions.version)).offset(offset).limit(limit + 1).all();
+        return { versions: rows.slice(0, limit), nextOffset: rows.length > limit ? offset + limit : null };
+    }
+    async save(agentId, request, operationKey, actor, validate, signal, engineVersion = indicatorEngine.version) {
+        validateSave(request);
+        if (!operationKey || operationKey.length > 200)
+            throw new IndicatorError("Invalid indicator operation key");
+        await this.assertAgent(agentId);
+        const hash = bodyHash(canonical(request));
+        const replay = async () => {
+            const receipt = await this.db.select().from(hvIndicatorOperations).where(and(eq(hvIndicatorOperations.agentId, agentId), eq(hvIndicatorOperations.key, operationKey))).get();
+            if (!receipt)
+                return undefined;
+            if (receipt.hash !== hash)
+                throw new IndicatorError("Operation key was used with different content", 409);
+            return JSON.parse(receipt.result);
+        };
+        const previousReceipt = await replay();
+        if (previousReceipt)
+            return previousReceipt;
+        const previous = request.indicatorId ? await this.get(agentId, request.indicatorId) : undefined;
+        if (previous && request.expectedVersion !== previous.descriptor.version)
+            throw new IndicatorError("Indicator changed; reread before saving", 409);
+        const sourceChanged = !previous || previous.source !== request.source;
+        if (sourceChanged && !request.validation)
+            throw new IndicatorError("A real closed-candle validation window is required for source changes");
+        signal?.throwIfAborted();
+        const metadata = sourceChanged ? await validate() : { inputs: previous.descriptor.inputs, overlay: previous.descriptor.overlay };
+        signal?.throwIfAborted();
+        const uuid = previous ? parseIndicatorId(previous.descriptor.id) : undefined;
+        const id = uuid?.kind === "custom" ? uuid.uuid : randomUUID();
+        const sourceHash = bodyHash(request.source), now = Date.now();
+        return this.database.appTransaction(async (db, tx) => {
+            signal?.throwIfAborted();
+            await this.agentTx(tx, agentId);
+            const receipt = await db.select().from(hvIndicatorOperations).where(and(eq(hvIndicatorOperations.agentId, agentId), eq(hvIndicatorOperations.key, operationKey))).get();
+            if (receipt) {
+                if (receipt.hash !== hash)
+                    throw new IndicatorError("Operation key was used with different content", 409);
+                return JSON.parse(receipt.result);
+            }
+            const current = await db.select().from(hvIndicators).where(and(eq(hvIndicators.id, id), eq(hvIndicators.agentId, agentId))).get();
+            if (previous && (!current || current.currentVersion !== request.expectedVersion))
+                throw new IndicatorError("Indicator changed; reread before saving", 409);
+            const version = current ? current.currentVersion + (sourceChanged ? 1 : 0) : 1;
+            if (version > indicatorLimits.versions)
+                throw new IndicatorError("Indicator source-version limit (200) reached", 409);
+            if (!current) {
+                const quota = await tx.get("SELECT count(*) AS count FROM hv_indicators WHERE agent_id=?", agentId);
+                if ((quota?.count ?? 0) >= indicatorLimits.customPerAgent)
+                    throw new IndicatorError("Custom indicator limit (100) reached", 409);
+                await db.insert(hvIndicators).values({ id, agentId, name: request.name, description: request.description, interpretation: request.interpretation, currentVersion: version, createdAt: now, updatedAt: now }).run();
+            }
+            else
+                await db.update(hvIndicators).set({ name: request.name, description: request.description, interpretation: request.interpretation, currentVersion: version, updatedAt: now }).where(eq(hvIndicators.id, id)).run();
+            if (sourceChanged)
+                await db.insert(hvIndicatorVersions).values({ indicatorId: id, version, source: request.source, sourceHash, metadata: JSON.stringify(metadata), engineVersion, wrapperVersion: indicatorWrapperVersion,
+                    createdAt: now, actorKind: actor.kind, userId: actor.userId, subagentId: actor.subagentId, runId: actor.runId, conversationId: actor.conversationId, taskId: actor.taskId }).run();
+            const result = { indicatorId: `custom:${id}`, version, sourceHash };
+            await db.insert(hvIndicatorOperations).values({ agentId, key: operationKey, hash, result: JSON.stringify(result) }).run();
+            return result;
+        });
+    }
+}

package/dist/indicators/normalize.js

@@ -0,0 +1,149 @@
+/** Self-contained trusted function, serialized into QuickJS. No host capabilities or module captures. */
+export function normalizePineContext(raw, args) {
+    const row = (value) => {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            throw new Error("Malformed PineTS output object");
+        return value;
+    };
+    const array = (value) => { if (!Array.isArray(value))
+        throw new Error("Malformed PineTS output collection"); return value; };
+    const num = (value) => { if (typeof value !== "number" || !Number.isFinite(value))
+        throw new Error("Non-finite PineTS coordinate/value"); return value; };
+    const integer = (value) => { const n = num(value); if (!Number.isSafeInteger(n))
+        throw new Error("Invalid PineTS integer"); return n; };
+    const text = (value, fallback = "") => { if (value === undefined || value === null)
+        return fallback; if (typeof value !== "string")
+        throw new Error("Invalid PineTS text"); return value; };
+    const optionalText = (value) => value === undefined || value === null ? undefined : text(value);
+    const numberOrNull = (value) => value === null || value === undefined || (typeof value === "number" && Number.isNaN(value)) ? null : num(value);
+    const context = row(raw), declaration = row(context.indicator), plots = row(context.plots);
+    const overlay = declaration.overlay === true;
+    const outputs = [], levels = [], fills = [], markers = [], drawings = [];
+    const times = new Set(args.candles.map((c) => c.openTime / 1000));
+    const timeIndexes = new Map(args.candles.map((c, index) => [c.openTime / 1000, index]));
+    const time = (value) => { const t = num(value) / 1000; if (!times.has(t))
+        throw new Error("Plot time is outside the input candles"); return t; };
+    const pane = (options) => ({ overlay: options.overlay === true || (options.overlay === undefined && overlay), forceOverlay: options.force_overlay === true });
+    const style = (options) => ({
+        color: optionalText(options.color), width: options.linewidth === undefined ? undefined : num(options.linewidth),
+        lineStyle: optionalText(options.linestyle), hidden: options.display === 0 || options.display === "none",
+        offset: options.offset === undefined ? 0 : integer(options.offset), showLast: options.show_last === undefined ? undefined : integer(options.show_last),
+    });
+    const anchor = (x, y, xloc) => {
+        const price = num(y);
+        if (xloc === "bt" || xloc === "bar_time")
+            return { time: num(x) / 1000, price };
+        if (xloc !== "bi" && xloc !== "bar_index" && xloc !== undefined)
+            throw new Error(`Unsupported drawing xloc: ${String(xloc)}`);
+        const barIndex = integer(x), candle = args.candles[barIndex];
+        const first = args.candles[0];
+        if (!first)
+            throw new Error("Drawing requires input candles");
+        return { time: (candle?.openTime ?? first.openTime + barIndex * args.intervalMs) / 1000, price, barIndex };
+    };
+    const extension = (value) => {
+        if (value === "r" || value === "right")
+            return "right";
+        if (value === "l" || value === "left")
+            return "left";
+        if (value === "b" || value === "both")
+            return "both";
+        if (value === undefined || value === "n" || value === "none")
+            return "none";
+        throw new Error(`Unsupported drawing extension: ${String(value)}`);
+    };
+    let markerOutputs = 0;
+    for (const [id, rawPlot] of Object.entries(plots)) {
+        if (["__proto__", "constructor", "prototype"].includes(id))
+            throw new Error("Unsafe PineTS plot ID");
+        const plot = row(rawPlot), data = array(plot.data), options = row(plot.options ?? {});
+        if (!id.startsWith("__") && data.length > args.limits.candles)
+            throw new Error("Output point limit exceeded");
+        if (id.startsWith("__")) {
+            const objects = data.flatMap((point) => array(row(point).value));
+            const live = objects.map(row).filter((object) => object._deleted !== true);
+            if (!["__lines__", "__boxes__", "__labels__"].includes(id)) {
+                if (live.length)
+                    throw new Error(`Unsupported nonempty PineTS output: ${id}`);
+                continue;
+            }
+            for (const object of live) {
+                if (drawings.length >= args.limits.drawings)
+                    throw new Error("Generated drawing limit exceeded");
+                const base = { id: `${id}:${String(object.id)}`, ...pane({ ...options, force_overlay: object.force_overlay }),
+                    color: optionalText(object.color ?? object.border_color), width: object.width === undefined && object.border_width === undefined ? undefined : num(object.width ?? object.border_width),
+                    lineStyle: optionalText(object.style ?? object.border_style), extend: extension(object.extend) };
+                if (id === "__lines__")
+                    drawings.push({ ...base, kind: "line", from: anchor(object.x1, object.y1, object.xloc), to: anchor(object.x2, object.y2, object.xloc) });
+                else if (id === "__boxes__")
+                    drawings.push({ ...base, kind: "box", from: anchor(object.left, object.top, object.xloc), to: anchor(object.right, object.bottom, object.xloc), background: optionalText(object.bgcolor), text: text(object.text), textColor: optionalText(object.text_color), size: optionalText(object.text_size) });
+                else
+                    drawings.push({ ...base, kind: "label", at: anchor(object.x, object.y, object.xloc), text: text(object.text), textColor: optionalText(object.textcolor), size: optionalText(object.size), shape: optionalText(object.style), location: text(object.yloc, "pr") });
+            }
+            continue;
+        }
+        const title = text(plot.title, id), kind = text(options.style, "style_line"), settings = style(options);
+        const visible = (t) => !settings.hidden && (settings.showLast === undefined || timeIndexes.get(t) >= args.candles.length - settings.showLast);
+        if (kind === "fill") {
+            fills.push({ id, title, from: text(plot.plot1 ?? options.plot1), to: text(plot.plot2 ?? options.plot2), color: optionalText(options.color), hidden: settings.hidden,
+                points: data.flatMap((item) => { const p = row(item), opts = row(p.options ?? {}), t = time(p.time); return visible(t) ? [{ time: t, color: optionalText(opts.color ?? options.color) }] : []; }) });
+            continue;
+        }
+        if (kind === "hline") {
+            const values = data.map((p) => numberOrNull(row(p).value)).filter((v) => v !== null);
+            if (values.length && values.some((v) => v !== values[0]))
+                throw new Error("Horizontal level changed within calculation");
+            if (values.length)
+                levels.push({ id, title, value: values[0], ...pane(options), style: settings });
+            continue;
+        }
+        if (["shape", "char", "arrow"].includes(kind)) {
+            if (++markerOutputs > args.limits.markerOutputs)
+                throw new Error("Marker output limit exceeded");
+            const markerKind = text(plot._callsiteId).startsWith("plotarrow") || kind === "arrow" ? "arrow" : kind === "char" ? "char" : "shape";
+            for (const [index, item] of data.entries()) {
+                const p = row(item), opts = { ...options, ...row(p.options ?? {}) }, value = p.value;
+                if (value === null || value === undefined || value === false || value === 0 || (typeof value === "number" && Number.isNaN(value)))
+                    continue;
+                if (typeof value !== "boolean")
+                    num(value);
+                const pointSettings = style(opts), sourceTime = time(p.time);
+                if (!visible(sourceTime) || pointSettings.hidden)
+                    continue;
+                if (markers.length >= args.limits.markerEvents)
+                    throw new Error("Marker event limit exceeded");
+                markers.push({ id: `${id}:${index}`, outputId: id, kind: markerKind, time: sourceTime,
+                    displayTime: sourceTime + pointSettings.offset * args.intervalMs / 1000, offset: pointSettings.offset,
+                    value: value, ...pane(opts), location: text(opts.location, "AboveBar"), shape: optionalText(opts.shape),
+                    text: optionalText(opts.text), character: optionalText(opts.char), color: optionalText(opts.color), textColor: optionalText(opts.textcolor), size: optionalText(opts.size) });
+            }
+            continue;
+        }
+        if (!["style_line", "style_linebr", "style_histogram", "style_columns"].includes(kind)) {
+            if (data.some((p) => { const v = row(p).value; return v !== null && v !== undefined && !(typeof v === "number" && Number.isNaN(v)); }))
+                throw new Error(`Unsupported nonempty PineTS output style: ${kind}`);
+            continue;
+        }
+        if (outputs.length >= args.limits.numericOutputs)
+            throw new Error("Numeric output limit exceeded");
+        const points = data.map((item) => {
+            const p = row(item), opts = { ...options, ...row(p.options ?? {}) }, t = time(p.time);
+            return { time: t, displayTime: t + style(opts).offset * args.intervalMs / 1000, value: numberOrNull(p.value), color: optionalText(opts.color) };
+        });
+        const finite = points.filter((p) => p.value !== null);
+        outputs.push({ id, title, kind: kind === "style_histogram" ? "histogram" : kind === "style_columns" ? "columns" : "line", ...pane(options), style: settings,
+            finiteCount: finite.length, firstFiniteTime: finite[0]?.time ?? null,
+            points: points.map((p) => ({ ...p, ...(visible(p.time) ? {} : { color: "#00000000" }) })) });
+    }
+    if (outputs.length + levels.length > args.limits.numericOutputs)
+        throw new Error("Numeric output limit exceeded");
+    for (const fill of fills)
+        if (![outputs, levels].flat().some((p) => p.id === fill.from) || ![outputs, levels].flat().some((p) => p.id === fill.to))
+            throw new Error("Fill references an unsupported output");
+    markers.sort((a, b) => a.time - b.time || a.outputId.localeCompare(b.outputId) || a.id.localeCompare(b.id));
+    const byTime = new Map(outputs.map((output) => [output.id, new Map(output.points.map((p) => [p.time, p.value]))]));
+    const values = args.candles.map((c) => ({ time: c.openTime / 1000, value: Object.fromEntries(outputs.map((o) => [o.id, byTime.get(o.id)?.get(c.openTime / 1000) ?? null])) }));
+    const warnings = array(context.warnings ?? []).map((w) => typeof w === "string" ? w : JSON.stringify(w));
+    return { title: text(declaration.title), overlay, outputs, levels, fills, markers, drawings, values,
+        warnings: warnings.slice(0, args.limits.warnings), warningsOmitted: Math.max(0, warnings.length - args.limits.warnings) };
+}

package/dist/indicators/result-schema.js

@@ -0,0 +1,79 @@
+import { Type, validateToolArguments } from "@earendil-works/pi-ai";
+import { indicatorLimits } from "./contracts.js";
+import { resolveInputs } from "./validation.js";
+import { ArtifactMetaSchema } from "../research/contracts.js";
+const object = { additionalProperties: false };
+const str = Type.String();
+const num = Type.Number();
+const epochSeconds = Type.Number({ description: "Unix epoch seconds (UTC)" });
+const nullableEpochSeconds = Type.Union([epochSeconds, Type.Null()]);
+const epochMilliseconds = Type.Number({ description: "Unix epoch milliseconds (UTC)" });
+const optStr = Type.Optional(str);
+const optNum = Type.Optional(num);
+const scalar = Type.Union([num, str, Type.Boolean()]);
+const nullable = Type.Union([num, Type.Null()]);
+const pane = { overlay: Type.Boolean(), forceOverlay: Type.Boolean() };
+const anchor = Type.Object({ time: epochSeconds, price: num, barIndex: Type.Optional(Type.Integer()) }, object);
+const style = Type.Object({ color: optStr, width: optNum, lineStyle: optStr, hidden: Type.Boolean(), offset: Type.Integer(), showLast: Type.Optional(Type.Integer({ minimum: 0 })) }, object);
+const drawing = { id: str, ...pane, color: optStr, width: optNum, lineStyle: optStr, extend: Type.Union([Type.Literal("none"), Type.Literal("left"), Type.Literal("right"), Type.Literal("both")]) };
+export const NormalizedIndicatorSchema = Type.Object({
+    title: str, overlay: Type.Boolean(),
+    inputs: Type.Array(Type.Object({ key: str, runtimeId: str, variable: optStr, title: str,
+        type: Type.Union(["int", "float", "bool", "string", "source", "color"].map((v) => Type.Literal(v))),
+        default: scalar, min: optNum, max: optNum, step: optNum, options: Type.Optional(Type.Array(scalar)), group: optStr, tooltip: optStr }, object), { maxItems: indicatorLimits.inputs }),
+    resolvedInputs: Type.Record(Type.String(), scalar),
+    outputs: Type.Array(Type.Object({ id: str, title: str, kind: Type.Union([Type.Literal("line"), Type.Literal("histogram"), Type.Literal("columns")]), ...pane, style,
+        finiteCount: Type.Integer({ minimum: 0 }), firstFiniteTime: nullableEpochSeconds,
+        points: Type.Array(Type.Object({ time: epochSeconds, displayTime: epochSeconds, value: nullable, color: optStr }, object), { maxItems: indicatorLimits.candles }) }, object), { maxItems: indicatorLimits.numericOutputs }),
+    levels: Type.Array(Type.Object({ id: str, title: str, value: num, ...pane, style }, object), { maxItems: indicatorLimits.numericOutputs }),
+    fills: Type.Array(Type.Object({ id: str, title: str, from: str, to: str, color: optStr, hidden: Type.Boolean(), points: Type.Array(Type.Object({ time: epochSeconds, color: optStr }, object), { maxItems: indicatorLimits.candles }) }, object)),
+    markers: Type.Array(Type.Object({ id: str, outputId: str, kind: Type.Union([Type.Literal("shape"), Type.Literal("char"), Type.Literal("arrow")]), time: epochSeconds, displayTime: epochSeconds, value: Type.Union([num, Type.Boolean()]), offset: Type.Integer(), ...pane,
+        location: str, shape: optStr, text: optStr, character: optStr, color: optStr, textColor: optStr, size: optStr }, object), { maxItems: indicatorLimits.markerEvents }),
+    drawings: Type.Array(Type.Union([
+        Type.Object({ ...drawing, kind: Type.Literal("line"), from: anchor, to: anchor }, object),
+        Type.Object({ ...drawing, kind: Type.Literal("box"), from: anchor, to: anchor, background: optStr, text: str, textColor: optStr, size: optStr }, object),
+        Type.Object({ ...drawing, kind: Type.Literal("label"), at: anchor, text: str, textColor: optStr, size: optStr, shape: optStr, location: str }, object),
+    ]), { maxItems: indicatorLimits.drawings }),
+    values: Type.Array(Type.Object({ time: epochSeconds, value: Type.Record(Type.String(), nullable) }, object), { maxItems: indicatorLimits.candles }),
+    warnings: Type.Array(str, { maxItems: indicatorLimits.warnings }), warningsOmitted: Type.Integer({ minimum: 0 }),
+}, object);
+const bound = Type.Object({ count: Type.Integer(), firstOpenTime: epochSeconds, lastOpenTime: epochSeconds }, object);
+const outputBound = Type.Object({ count: Type.Integer(), firstTime: nullableEpochSeconds, lastTime: nullableEpochSeconds }, object);
+const coverage = Type.Object({ complete: Type.Boolean(), closedOnly: Type.Literal(true), expected: Type.Integer(), returned: Type.Integer(), seedCoverage: Type.Union([Type.Literal("complete"), Type.Literal("limited")]) }, object);
+const provenance = { ...Type.Omit(NormalizedIndicatorSchema, ["outputs", "levels", "fills", "drawings", "values", "markers"]).properties,
+    schemaVersion: Type.Literal(1), indicatorId: str, builtIn: Type.Boolean(), version: Type.Integer(), sourceHash: str,
+    engine: Type.Object({ name: Type.Literal("pinets"), version: Type.String({ pattern: "^\\d+\\.\\d+\\.\\d+" }) }, object), wrapperVersion: Type.Integer(), coin: str, interval: str, start: epochMilliseconds, end: epochMilliseconds,
+    inputSchemaHash: str, computedAt: epochMilliseconds, candleHash: str, resultHash: str, dataset: bound, outputDataset: outputBound, coverage };
+export const IndicatorToolResultSchema = Type.Union([
+    Type.Object({ ...provenance, outputs: Type.Array(Type.Omit(NormalizedIndicatorSchema.properties.outputs.items, ["points"])), levels: NormalizedIndicatorSchema.properties.levels, fillCount: Type.Integer(),
+        values: NormalizedIndicatorSchema.properties.values, numericalCoverage: Type.Object({ available: Type.Integer(), returned: Type.Integer() }, object),
+        markers: NormalizedIndicatorSchema.properties.markers, markerCoverage: Type.Object({ available: Type.Integer(), returned: Type.Integer(), firstSourceTime: nullableEpochSeconds, lastSourceTime: nullableEpochSeconds }, object),
+        drawings: Type.Object({ count: Type.Integer(), byKind: Type.Object({ line: Type.Integer(), box: Type.Integer(), label: Type.Integer() }, object) }, object) }, object),
+    Type.Object({ artifact: ArtifactMetaSchema, reference: str, summary: Type.Object({ ...provenance, exportScope: Type.Literal("full") }, object) }, object),
+]);
+/** Revalidate untrusted VM transport, including finite numbers (JSON must not hide NaN/infinity). */
+export function validateNormalizedIndicatorResult(value, limits = indicatorLimits) {
+    const visit = (item) => {
+        if (typeof item === "number" && !Number.isFinite(item))
+            throw new Error("Non-finite normalized result");
+        if (item && typeof item === "object")
+            for (const [key, child] of Object.entries(item)) {
+                if (["__proto__", "constructor", "prototype"].includes(key))
+                    throw new Error("Unsafe normalized result key");
+                visit(child);
+            }
+    };
+    visit(value);
+    const json = JSON.stringify(value);
+    if (!json || Buffer.byteLength(json) > limits.resultBytes)
+        throw new Error("Normalized indicator result exceeds byte limit");
+    const tool = { name: "indicator_result", description: "Validate VM result", parameters: NormalizedIndicatorSchema };
+    const result = validateToolArguments(tool, { type: "toolCall", id: "result", name: tool.name, arguments: value });
+    if (result.inputs.length > limits.inputs || result.outputs.length + result.levels.length > limits.numericOutputs || result.markers.length > limits.markerEvents || result.drawings.length > limits.drawings || result.values.length > limits.candles || result.warnings.length > limits.warnings)
+        throw new Error("Normalized indicator result exceeds limits");
+    const ids = [...result.outputs, ...result.levels].map((output) => output.id);
+    if (new Set(ids).size !== ids.length || new Set(result.inputs.map((input) => input.key)).size !== result.inputs.length)
+        throw new Error("Duplicate normalized result identity");
+    resolveInputs(result.inputs, result.resolvedInputs);
+    return result;
+}

package/dist/indicators/runtime-wrapper.js

@@ -0,0 +1,52 @@
+/** Serialized, trusted VM entry. The parameters are supplied only by the trusted runtime. */
+export async function runHyperVibesIndicator(args, lib, normalize, unknownInputsMessage) {
+    const program = new lib.Indicator(args.source);
+    if (program.getDeclarationType() !== "indicator")
+        throw new Error("Only indicator() programs are supported.");
+    const metadata = program.getInputsMeta();
+    if (metadata.length > args.limits.inputs)
+        throw new Error("Input declaration limit exceeded");
+    const safeKey = (key) => !["__proto__", "constructor", "prototype"].includes(key);
+    const scalar = (value) => typeof value === "string" || typeof value === "boolean" || (typeof value === "number" && Number.isFinite(value));
+    const counts = new Map();
+    for (const input of metadata)
+        if (input.varId)
+            counts.set(input.varId, (counts.get(input.varId) ?? 0) + 1);
+    const inputs = metadata.map((input) => {
+        if (!["int", "float", "bool", "string", "source", "color"].includes(input.type))
+            throw new Error(`Unsupported input widget: ${input.type}`);
+        const key = input.varId && counts.get(input.varId) === 1 ? input.varId : input.id;
+        if (!safeKey(key) || !safeKey(input.id) || !scalar(input.defval) || input.options?.some((value) => !scalar(value)))
+            throw new Error("Invalid indicator input metadata");
+        return { key, runtimeId: input.id, variable: input.varId, title: input.title ?? input.name,
+            type: input.type, default: input.defval, min: input.minval, max: input.maxval, step: input.step,
+            options: input.options, group: input.group, tooltip: input.tooltip };
+    });
+    if (new Set(inputs.map((input) => input.key)).size !== inputs.length)
+        throw new Error("Ambiguous indicator input keys");
+    const validKeys = inputs.map((input) => input.key);
+    const unknownKeys = Object.keys(args.inputs).filter((key) => !validKeys.includes(key));
+    if (unknownKeys.length)
+        throw new Error(unknownInputsMessage(unknownKeys, validKeys));
+    for (const [key, value] of Object.entries(args.inputs)) {
+        const binding = inputs.find((input) => input.key === key);
+        if (!safeKey(key) || !binding || !scalar(value))
+            throw new Error(`Unknown or invalid input: ${key}`);
+        program.input[binding.runtimeId] = value;
+    }
+    const resolvedInputs = Object.fromEntries(inputs.map((input) => [input.key, Object.hasOwn(args.inputs, input.key) ? args.inputs[input.key] : input.default]));
+    const pine = new lib.PineTS(args.candles, args.coin, args.pineTimeframe);
+    pine.setMaxLoops(args.limits.maxLoops);
+    const context = await pine.run(program);
+    const result = { ...normalize(context, args), inputs, resolvedInputs };
+    // QuickJS may not expose TextEncoder. Count UTF-8 bytes without host APIs or silent JSON coercion.
+    const json = JSON.stringify(result);
+    let bytes = 0;
+    for (const char of json) {
+        const code = char.codePointAt(0);
+        bytes += code < 0x80 ? 1 : code < 0x800 ? 2 : code < 0x10000 ? 3 : 4;
+    }
+    if (bytes > args.limits.resultBytes)
+        throw new Error("Normalized indicator result exceeds byte limit");
+    return result;
+}

package/dist/indicators/runtime.js

@@ -0,0 +1,201 @@
+import { CodemodeSandbox } from "@earendil-works/pi-codemode";
+import { readFile } from "node:fs/promises";
+import { indicatorEngine, indicatorLimits } from "./contracts.js";
+import { normalizePineContext } from "./normalize.js";
+import { runHyperVibesIndicator } from "./runtime-wrapper.js";
+import { validateNormalizedIndicatorResult } from "./result-schema.js";
+import { IndicatorError, unknownIndicatorInputsMessage, validateInputs, validateSource } from "./validation.js";
+import { IndicatorWorkerQueue } from "./worker-queue.js";
+/** Startup drift message; null when the installed pin matches the validated pin. */
+export function pineVersionDrift(installed, expected) {
+    return installed === expected ? null : `pinets@${installed} is installed, but this HyperVibes build was validated against pinets@${expected}. Indicators run on the installed engine and record that version in results and source history. Update indicatorEngine in src/indicators/contracts.ts and re-run pnpm test:server src/indicators when upgrading.`;
+}
+/** One application-owned no-capability execution owner; capacity lasts until actual worker exit. */
+export class IndicatorRuntime {
+    reportVersionDrift;
+    limits;
+    bundle;
+    initializing;
+    stopping = false;
+    closing;
+    queue;
+    exits = new Map();
+    calls = new Set();
+    deleted = new Set();
+    engineInfo = indicatorEngine;
+    /** The engine version actually installed; recorded in results and source history. Available after initialize(). */
+    get engine() { return this.engineInfo; }
+    constructor(limits = {}, reportVersionDrift = () => { }) {
+        this.reportVersionDrift = reportVersionDrift;
+        this.limits = { ...indicatorLimits, ...limits };
+        for (const key of Object.keys(this.limits)) {
+            const value = this.limits[key];
+            if (!Number.isSafeInteger(value) || value < 1 || value > indicatorLimits[key])
+                throw new Error(`Invalid indicator budget: ${key}`);
+        }
+        this.queue = new IndicatorWorkerQueue(this.limits.workers, this.limits.queuedCalls);
+    }
+    initialize() {
+        if (this.stopping)
+            return Promise.reject(new IndicatorError("Indicator runtime is closed", 503));
+        return this.initializing ??= (async () => {
+            const entry = new URL(import.meta.resolve("pinets"));
+            const pkg = JSON.parse(await readFile(new URL("../package.json", entry), "utf8"));
+            // Structural failures stay fatal: the wrong/missing package or an unreadable
+            // version makes every result's provenance a lie. A mere version drift does
+            // not: execution continues on the installed engine and records its actual
+            // version, so a routine dependency bump can never brick startup.
+            if (pkg.name !== "pinets" || typeof pkg.version !== "string" || !/^\d+\.\d+\.\d+(-[\w.+-]+)?$/.test(pkg.version))
+                throw new Error("The installed pinets package is missing or unreadable; indicator execution is unavailable");
+            this.engineInfo = { name: "pinets", version: pkg.version };
+            if (pkg.version !== indicatorEngine.version) {
+                const drift = pineVersionDrift(pkg.version, indicatorEngine.version);
+                if (drift)
+                    this.reportVersionDrift(drift);
+            }
+            const bundle = await readFile(new URL("pinets.min.browser.js", entry), "utf8");
+            if (!this.stopping)
+                this.bundle = bundle;
+        })();
+    }
+    admit(agentId) {
+        if (this.stopping || this.deleted.has(agentId))
+            throw new IndicatorError("Indicator execution is shutting down", 503, "indicator_closed");
+    }
+    async withWorker(agentId, signal, operation) {
+        const controller = new AbortController();
+        const combined = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
+        let settled;
+        const call = { agentId, controller, done: new Promise((resolve) => { settled = resolve; }) };
+        this.calls.add(call);
+        // Queueing and VM execution share one deadline. Keep workers observable until
+        // actual exit, including during startup before the host has a listening socket.
+        const timeout = new IndicatorError("Indicator execution timed out (including queue wait)", 408, "indicator_timeout");
+        const deadline = Date.now() + this.limits.timeoutMs;
+        const timer = setTimeout(() => controller.abort(timeout), this.limits.timeoutMs);
+        const keepAlive = setInterval(() => { }, 1000);
+        let release;
+        let started = false;
+        let finished = false;
+        let sandbox;
+        const check = () => {
+            if (Date.now() >= deadline)
+                controller.abort(timeout);
+            combined.throwIfAborted();
+            this.admit(agentId);
+            if (finished)
+                throw new IndicatorError("Indicator execution has already ended", 503, "indicator_closed");
+        };
+        try {
+            release = await this.queue.acquire(combined);
+            check();
+            sandbox = new CodemodeSandbox({ tools: [], globals: [], memoryLimitBytes: this.limits.memoryLimitBytes,
+                // WASM loading may finish after cancellation/result settlement. Never
+                // launch that stale worker after its reservation has been released.
+                acquireWorker: () => { check(); return () => { release?.(); clearInterval(keepAlive); }; },
+                onWorkerStarted: (exit) => { started = true; this.exits.set(exit, agentId); void exit.then(() => this.exits.delete(exit)); },
+            });
+            const result = await operation(sandbox, combined, Math.max(1, deadline - Date.now()));
+            check();
+            return result;
+        }
+        catch (error) {
+            if (combined.aborted)
+                throw combined.reason;
+            throw error;
+        }
+        finally {
+            finished = true;
+            clearTimeout(timer);
+            try {
+                await sandbox?.close();
+            }
+            finally {
+                if (!started) {
+                    release?.();
+                    clearInterval(keepAlive);
+                }
+                this.calls.delete(call);
+                settled();
+            }
+        }
+    }
+    prepare(request) {
+        validateSource(request.source, this.limits.sourceBytes);
+        const inputs = validateInputs(request.inputs);
+        if (!request.candles.length || request.candles.length > this.limits.candles)
+            throw new IndicatorError("Invalid indicator candle count");
+        if (!Number.isSafeInteger(request.intervalMs) || request.intervalMs <= 0)
+            throw new IndicatorError("Invalid indicator interval");
+        for (const [index, candle] of request.candles.entries()) {
+            if (!Object.values(candle).every((value) => typeof value === "number" && Number.isFinite(value)) || !Number.isSafeInteger(candle.openTime) || candle.closeTime !== candle.openTime + request.intervalMs
+                || candle.volume < 0 || candle.low > Math.min(candle.open, candle.close) || candle.high < Math.max(candle.open, candle.close)
+                || (index > 0 && request.candles[index - 1].closeTime !== candle.openTime))
+                throw new IndicatorError("Invalid or gapped indicator candles");
+        }
+        return { ...request, inputs, limits: this.limits };
+    }
+    async execute(agentId, request, signal) {
+        signal?.throwIfAborted();
+        this.admit(agentId);
+        if (!this.bundle)
+            throw new IndicatorError("Indicator runtime is not initialized", 503);
+        const payload = this.prepare(request);
+        return this.withWorker(agentId, signal, async (sandbox, combined, timeoutMs) => {
+            // tsx emits esbuild's __name helper inside function bodies. Bind that trusted
+            // compiler helper in the VM too; never capture a Node closure in serialized code.
+            const code = `${this.bundle}\nreturn await ((__name) => (${runHyperVibesIndicator.toString()})(${JSON.stringify(payload)}, PineTSLib, (${normalizePineContext.toString()}), (${unknownIndicatorInputsMessage.toString()})))((target, name) => Object.defineProperty(target, "name", { value: name, configurable: true }));`;
+            const result = await sandbox.execute(code, { signal: combined, timeoutMs });
+            if (!result.ok)
+                throw new IndicatorError(`PineTS ${result.error.kind}: ${result.error.message}`, result.error.kind === "aborted" ? 499 : 400, `indicator_${result.error.kind}`);
+            if (result.calls.length)
+                throw new IndicatorError("Indicator attempted a host tool call");
+            // storeWrites are deliberately discarded; indicator calculations have no persistent capabilities.
+            return validateNormalizedIndicatorResult(result.value, this.limits);
+        });
+    }
+    /** One worker for several trusted calculations (startup built-in validation): a
+     * single bundle parse and VM spawn instead of one per program. */
+    async executeBatch(agentId, requests, signal) {
+        signal?.throwIfAborted();
+        if (!requests.length || requests.length > 16)
+            throw new IndicatorError("Invalid indicator batch");
+        this.admit(agentId);
+        if (!this.bundle)
+            throw new IndicatorError("Indicator runtime is not initialized", 503);
+        const payloads = requests.map((request) => this.prepare(request));
+        return this.withWorker(agentId, signal, async (sandbox, combined, timeoutMs) => {
+            const code = `${this.bundle}\nreturn await ((__name) => (async () => { const results = []; for (const request of ${JSON.stringify(payloads)}) results.push(await (${runHyperVibesIndicator.toString()})(request, PineTSLib, (${normalizePineContext.toString()}), (${unknownIndicatorInputsMessage.toString()}))); return results; })())((target, name) => Object.defineProperty(target, "name", { value: name, configurable: true }));`;
+            const result = await sandbox.execute(code, { signal: combined, timeoutMs });
+            if (!result.ok)
+                throw new IndicatorError(`PineTS ${result.error.kind}: ${result.error.message}`, result.error.kind === "aborted" ? 499 : 400, `indicator_${result.error.kind}`);
+            if (result.calls.length)
+                throw new IndicatorError("Indicator attempted a host tool call");
+            const values = result.value;
+            if (!Array.isArray(values) || values.length !== payloads.length)
+                throw new IndicatorError("Malformed indicator batch result");
+            return values.map((value) => validateNormalizedIndicatorResult(value, this.limits));
+        });
+    }
+    async abortAgent(agentId) {
+        this.deleted.add(agentId);
+        const active = [...this.calls].filter((call) => call.agentId === agentId);
+        for (const call of active)
+            call.controller.abort(new Error("Agent deleted"));
+        await Promise.all(active.map((call) => call.done));
+        // Exits may include other Agents; deletion must not wait for their work.
+        await Promise.all([...this.exits].filter(([, owner]) => owner === agentId).map(([exit]) => exit));
+    }
+    close() {
+        return this.closing ??= (async () => {
+            this.stopping = true;
+            for (const call of this.calls)
+                call.controller.abort(new Error("Indicator runtime closed"));
+            await Promise.all([...this.calls].map((call) => call.done));
+            await Promise.allSettled(this.exits.keys());
+            await this.initializing?.catch(() => { });
+            this.bundle = undefined;
+            this.deleted.clear();
+        })();
+    }
+}