@supersolutions/super-chart-superscript 0.0.0 → 0.1.0

package/dist/index.js

@@ -0,0 +1,429 @@
+import {
+  SuperScriptError,
+  builtinReferenceLines,
+  check,
+  diag,
+  evaluate,
+  formatDiagnostics,
+  isSuperScriptError,
+  parse
+} from "./chunk-PAWYIS77.js";
+
+// packages/superscript/src/runtime/index.ts
+import { ta } from "@supersolutions/super-chart-core";
+var { sma, ema, rsi, highest, lowest, crossover, crossunder, wma, stdev, change, roc, trueRange, atr, sum, dev, mom, linreg, rma, hma, vwma } = ta;
+var SUPERLIB = {
+  sma,
+  ema,
+  rsi,
+  highest,
+  lowest,
+  crossover,
+  crossunder,
+  wma,
+  stdev,
+  change: (src) => change(src),
+  roc,
+  tr: trueRange,
+  atr,
+  sum,
+  dev,
+  mom,
+  linreg,
+  rma,
+  hma,
+  vwma
+};
+function tooDeep(e) {
+  if (!(e instanceof RangeError))
+    return void 0;
+  const d = diag("error", "UNSUPPORTED", "this script is too large or too deeply nested to process", { line: 1, col: 1, endCol: 1 }, "split long expressions into several named steps");
+  return new SuperScriptError(d);
+}
+function compileSuperScript(source, options = {}) {
+  let program;
+  let checked;
+  try {
+    program = parse(source);
+    checked = check(program);
+  } catch (e) {
+    throw tooDeep(e) ?? e;
+  }
+  const diagnostics = checked.diagnostics;
+  const firstError = diagnostics.find((d) => d.severity === "error");
+  if (firstError !== void 0)
+    throw new SuperScriptError(firstError, diagnostics);
+  if (options.strict === true && diagnostics.length > 0)
+    throw new SuperScriptError(diagnostics[0], diagnostics);
+  const meta = () => ({ title: program.title, inputs: checked.inputs.map((i) => ({ ...i })), overlay: program.overlay });
+  return {
+    meta: meta(),
+    diagnostics,
+    run(bars, params) {
+      let r;
+      try {
+        r = evaluate(program, bars, params);
+      } catch (e) {
+        throw tooDeep(e) ?? e;
+      }
+      return { meta: meta(), plots: r.plots, diagnostics };
+    }
+  };
+}
+function checkSuperScript(source) {
+  try {
+    return check(parse(source)).diagnostics;
+  } catch (e) {
+    const deep = tooDeep(e);
+    if (deep !== void 0)
+      return deep.diagnostics;
+    return [diag("error", "UNSUPPORTED", `internal error: ${String(e)}`, { line: 1, col: 1, endCol: 1 })];
+  }
+}
+var SuperScriptLanguage = {
+  id: "superscript",
+  name: "SuperScript",
+  compile: compileSuperScript
+};
+var JavaScriptLanguage = {
+  id: "javascript",
+  name: "JavaScript",
+  compile(source) {
+    const fn = new Function("ctx", `"use strict"; ${source}`);
+    return { meta: { title: "JavaScript" }, run: (bars) => fn({ bars, lib: SUPERLIB }) };
+  }
+};
+var LANGUAGES = /* @__PURE__ */ new Map();
+function registerLanguage(lang) {
+  LANGUAGES.set(lang.id, lang);
+}
+function getLanguage(id) {
+  return LANGUAGES.get(id);
+}
+function listLanguages() {
+  return [...LANGUAGES.values()];
+}
+registerLanguage(SuperScriptLanguage);
+function superscriptReference() {
+  return [
+    "Series: open, high, low, close, volume, hl2, hlc3, ohlc4, bar_index, time. History: close[1], close[len] (a constant whole number >= 0). na is the missing value; x/0, log(0) and other non-finite results are na.",
+    "Operators: + - * / %, comparison < <= > >= == !=, logic and/or/not (also && || !), ternary cond ? a : b.",
+    'Bind variables: name = expr, one statement per line (a line continues inside brackets or after an operator). Declare params: len = input(14, title="Length", minval=1, maxval=200, step=1); input(14, "Length") also works. Lengths and offsets must be constants: numbers, inputs, or arithmetic on them.',
+    ...builtinReferenceLines(),
+    'Draw: plot(expr, title="...", color="#rrggbb", type="line"|"histogram"|"circle", lineWidth=1, histbase=0); histogram bars grow from histbase. hline(price, title="...", color="#rrggbb") draws a dashed level.',
+    "Start the script with // @title <name>. Add // @overlay when it plots on the price scale (drawn over the candles).",
+    "Not supported (an error names the line): := and += (bindings are single-assignment series; bind a new name), if/for/while (use cond ? a : b), function definitions, request.*, strings or colours as values. Ignored with a warning: var, strategy.*, plotshape, plotchar, bgcolor, fill, alertcondition.",
+    'Pine names are accepted where the arguments match: ta.sma \u2026 ta.pivotlow, math.abs \u2026 math.sum, input.int, input.float, color.red \u2026, plot.style_*, indicator("Name", overlay=true). ta.cci and ta.mfi only over hlc3; ta.stoch only as ta.stoch(close, high, low, len); ta.vwap is session-anchored and has no equivalent.'
+  ].join("\n");
+}
+var superlib = SUPERLIB;
+
+// packages/superscript/src/ai/index.ts
+import { resolvePricePrecision } from "@supersolutions/super-chart-core";
+function createHttpAIClient(opts) {
+  return {
+    async complete({ system, prompt, signal }) {
+      const abort = combineSignals(signal, opts.timeoutMs);
+      try {
+        const res = await fetch(opts.endpoint, {
+          method: "POST",
+          headers: { "content-type": "application/json", ...opts.headers ?? {} },
+          // Exactly these two fields: never the whole input (it holds the signal).
+          body: JSON.stringify({ system, prompt }),
+          ...abort.signal !== void 0 ? { signal: abort.signal } : {}
+        });
+        if (!res.ok) {
+          const body = await res.text().catch(() => "");
+          throw new Error(`AI endpoint responded ${res.status}${body.trim() !== "" ? `: ${body.slice(0, 200)}` : ""}`);
+        }
+        const data = await res.json();
+        const text = opts.extract !== void 0 ? opts.extract(data) : textOf(data);
+        if (typeof text !== "string" || text.trim() === "")
+          throw new Error("AI endpoint returned no text");
+        return text;
+      } finally {
+        abort.dispose();
+      }
+    }
+  };
+}
+function textOf(data) {
+  if (typeof data === "string")
+    return data;
+  if (typeof data !== "object" || data === null)
+    throw new Error(`AI endpoint returned ${JSON.stringify(data)}, not text`);
+  const o = data;
+  if (o.error !== void 0 && o.error !== null) {
+    throw new Error(`AI endpoint returned an error: ${(typeof o.error === "string" ? o.error : JSON.stringify(o.error)).slice(0, 200)}`);
+  }
+  if (typeof o.text === "string")
+    return o.text;
+  if (typeof o.content === "string")
+    return o.content;
+  if (Array.isArray(o.content)) {
+    return o.content.filter((b) => typeof b === "object" && b !== null && b.type === "text" && typeof b.text === "string").map((b) => b.text).join("");
+  }
+  const keys = Object.keys(o);
+  throw new Error(`unrecognised AI response (keys: ${keys.length > 0 ? keys.join(", ") : "none"}); pass createHttpAIClient({ extract }) to read it`);
+}
+function combineSignals(signal, timeoutMs) {
+  if (signal === void 0 && timeoutMs === void 0)
+    return { dispose: () => {
+    } };
+  const c = new AbortController();
+  const onAbort = () => {
+    c.abort(signal?.reason);
+  };
+  if (signal !== void 0) {
+    if (signal.aborted)
+      c.abort(signal.reason);
+    else
+      signal.addEventListener("abort", onAbort, { once: true });
+  }
+  const timer = timeoutMs !== void 0 ? setTimeout(() => {
+    c.abort(new DOMException(`AI request timed out after ${timeoutMs} ms`, "TimeoutError"));
+  }, timeoutMs) : void 0;
+  return {
+    signal: c.signal,
+    dispose: () => {
+      if (timer !== void 0)
+        clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+    }
+  };
+}
+var SUPERSCRIPT_SYSTEM_PROMPT = `You write SuperScript, the indicator/strategy language for SUPer-Chart.
+SuperScript is line-based and Pine-flavoured, but it is not Pine: use only what this reference lists.
+${superscriptReference()}
+Return ONLY the script, no prose, no code fences.`;
+async function nlToSuperScript(client, request, opts = {}) {
+  const out = await client.complete({ system: SUPERSCRIPT_SYSTEM_PROMPT, prompt: request, ...opts.signal !== void 0 ? { signal: opts.signal } : {} });
+  const source = stripCodeFence(out);
+  const plots = SuperScriptLanguage.compile(source).run([]).plots.length;
+  if (plots === 0)
+    throw new Error(`the model's reply draws nothing, so it is not an indicator: ${JSON.stringify(out.slice(0, 200))}`);
+  return source;
+}
+async function nlToSuperScriptChecked(client, request, opts = {}) {
+  const maxRepairs = Math.max(0, Math.floor(opts.maxRepairs ?? 2));
+  let prompt = request;
+  for (let attempts = 1; ; attempts++) {
+    const out = await client.complete({ system: SUPERSCRIPT_SYSTEM_PROMPT, prompt, ...opts.signal !== void 0 ? { signal: opts.signal } : {} });
+    const source = stripCodeFence(out);
+    const diagnostics = checkSuperScript(source);
+    const failing = diagnostics.some((d) => d.severity === "error" || d.code === "NO_PLOTS");
+    if (!failing || attempts > maxRepairs)
+      return { ok: !failing, source, diagnostics, attempts };
+    prompt = [
+      `The request was: ${request}`,
+      "Your SuperScript was:",
+      source,
+      "It has these problems:",
+      formatDiagnostics(diagnostics, source),
+      "Return the corrected script only."
+    ].join("\n");
+  }
+}
+function buildChartContext(source, opts = {}) {
+  const parts = "getChart" in source ? { chart: source.getChart(), symbol: source.getSymbol(), period: source.getPeriod(), timezone: source.getTimezone() } : "getBars" in source ? workspaceParts(source) : source;
+  const chart = parts.chart;
+  if (chart === null)
+    throw new Error("buildChartContext: the chart has not mounted yet (getChart() is null)");
+  const dl = chart.getDataList();
+  const n = dl.length;
+  const clamp = (x) => Math.max(0, Math.min(n, Math.round(x)));
+  let from;
+  let to;
+  const range = opts.range ?? "visible";
+  if (range === "all") {
+    from = 0;
+    to = n;
+  } else if (range === "visible") {
+    const vr = chart.getVisibleRange();
+    from = clamp(vr.from);
+    to = clamp(vr.to);
+  } else {
+    from = clamp(range.from);
+    to = clamp(range.to);
+  }
+  if (to < from)
+    to = from;
+  const visibleBars = to - from;
+  const maxBars = Math.max(1, Math.floor(opts.maxBars ?? 200));
+  const lookback = visibleBars > 0 && maxBars < 2 ? 0 : Math.max(0, Math.min(Math.floor(opts.lookback ?? 0), from));
+  const fit = (ctx2) => {
+    let b = Math.max(1, Math.ceil((ctx2 + visibleBars) / maxBars));
+    while (Math.ceil(ctx2 / b) + Math.ceil(visibleBars / b) > maxBars)
+      b++;
+    return b;
+  };
+  let k = fit(lookback);
+  const contextBars = Math.min(Math.ceil(lookback / k), Math.floor(from / k)) * k;
+  if (contextBars === 0 && lookback > 0)
+    k = fit(0);
+  const rows = aggregate(dl.slice(from - contextBars, to), k);
+  const period = typeof parts.period === "string" ? parts.period : parts.period.text ?? `${parts.period.multiplier}${parts.period.timespan}`;
+  const format = {
+    timezone: parts.timezone ?? "UTC",
+    visibleFrom: from,
+    visibleTo: to,
+    bucket: k,
+    sourceBars: contextBars + visibleBars,
+    contextRows: contextBars / k
+  };
+  if (parts.symbol.pricePrecision === "auto") {
+    format.pricePrecision = resolvePricePrecision("auto", dl.slice(from - contextBars, to));
+  } else if (parts.symbol.pricePrecision !== void 0) {
+    format.pricePrecision = parts.symbol.pricePrecision;
+  }
+  if (parts.symbol.volumePrecision !== void 0)
+    format.volumePrecision = parts.symbol.volumePrecision;
+  const ctx = { symbol: parts.symbol.ticker, period, bars: rows, format };
+  if (opts.indicators !== void 0)
+    ctx.indicators = opts.indicators;
+  return ctx;
+}
+function workspaceParts(workspace) {
+  const timezone = workspace.chart.getRenderOptions?.().timeZone;
+  return {
+    chart: {
+      getDataList: () => workspace.getBars(),
+      getVisibleRange: () => {
+        const { i0, i1 } = workspace.chart.view.getSnapshot().viewport;
+        return { from: Math.floor(i0), to: Math.ceil(i1) + 1 };
+      }
+    },
+    symbol: workspace.getSymbol(),
+    period: workspace.getPeriod(),
+    ...timezone !== void 0 ? { timezone } : {}
+  };
+}
+function aggregate(bars, k) {
+  if (k <= 1)
+    return bars.map((b) => ({ ...b }));
+  const out = [];
+  for (let start = 0; start < bars.length; start += k) {
+    const chunk = bars.slice(start, start + k);
+    let high = -Infinity;
+    let low = Infinity;
+    let volume;
+    for (const b of chunk) {
+      high = Math.max(high, b.high);
+      low = Math.min(low, b.low);
+      if (b.volume !== void 0)
+        volume = (volume ?? 0) + b.volume;
+    }
+    const row = { timestamp: chunk[0].timestamp, open: chunk[0].open, high, low, close: chunk[chunk.length - 1].close };
+    if (volume !== void 0)
+      row.volume = volume;
+    out.push(row);
+  }
+  return out;
+}
+var ANALYST_SYSTEM_PROMPT = `You are a professional markets analyst embedded in a trading chart.
+Be concise and concrete. Reference price structure, key support/resistance, momentum,
+and lay out the most likely scenarios with invalidation levels. Never give financial
+advice or position sizing \u2014 describe the chart, not what the user should do.`;
+async function analyzeChart(client, ctx, question, opts = {}) {
+  const indicators = ctx.indicators !== void 0 && ctx.indicators.length > 0 ? `
+Indicators on chart: ${ctx.indicators.join(", ")}.` : "";
+  const data = ctx.format === void 0 ? v1Bars(ctx) : compactBars(ctx, ctx.format);
+  const prompt = `Symbol ${ctx.symbol}, period ${ctx.period}.${indicators}
+${data}
+
+` + (question ?? "Analyze the current structure, key levels, momentum, and likely scenarios.");
+  return await client.complete({ system: ANALYST_SYSTEM_PROMPT, prompt, ...opts.signal !== void 0 ? { signal: opts.signal } : {} });
+}
+function v1Bars(ctx) {
+  const recent = ctx.bars.slice(-160).map((b) => `${b.timestamp},${b.open},${b.high},${b.low},${b.close},${b.volume ?? ""}`).join("\n");
+  return `Recent OHLCV (timestamp,open,high,low,close,volume):
+${recent}`;
+}
+function compactBars(ctx, f) {
+  const bars = ctx.bars;
+  if (bars.length === 0)
+    return "No bars in view.";
+  const tz = f.timezone ?? "UTC";
+  const k = f.bucket ?? 1;
+  const header = [
+    `Bars (i,open,high,low,close,volume): start=${isoInZone(bars[0].timestamp, tz)} end=${isoInZone(bars[bars.length - 1].timestamp, tz)} step=${k > 1 ? `${k}x${ctx.period}` : ctx.period} tz=${tz} rows=${bars.length}.`,
+    "Row i starts i steps after start; times skip market closures."
+  ];
+  if (k > 1) {
+    const lastRow = f.sourceBars !== void 0 ? f.sourceBars - (bars.length - 1) * k : k;
+    header.push(`${f.sourceBars ?? bars.length * k} bars aggregated into ${bars.length} rows of ${k} bars (first open, highest high, lowest low, last close, summed volume).` + (lastRow > 0 && lastRow < k ? ` The last row holds ${lastRow} bars.` : ""));
+  }
+  const c = f.contextRows ?? 0;
+  if (c > 0)
+    header.push(`Rows 0-${c - 1} are context before the visible window; the user sees rows ${c}-${bars.length - 1}.`);
+  const p = (x) => num(x, f.pricePrecision);
+  const rows = bars.map((b, i) => `${i},${p(b.open)},${p(b.high)},${p(b.low)},${p(b.close)},${b.volume === void 0 ? "" : num(b.volume, f.volumePrecision)}`);
+  return `${header.join("\n")}
+${rows.join("\n")}`;
+}
+function num(x, precision) {
+  if (!Number.isFinite(x))
+    return "";
+  const r = precision !== void 0 && precision >= 0 && precision <= 20 ? Number(x.toFixed(precision)) : Number(x.toPrecision(8));
+  return String(r);
+}
+function isoInZone(ts, tz) {
+  try {
+    const f = new Intl.DateTimeFormat("en-US", { timeZone: tz, hourCycle: "h23", year: "numeric", month: "2-digit", day: "2-digit", hour: "2-digit", minute: "2-digit", second: "2-digit" });
+    const p = {};
+    for (const part of f.formatToParts(new Date(ts)))
+      p[part.type] = part.value;
+    const wall = Date.UTC(Number(p.year), Number(p.month) - 1, Number(p.day), Number(p.hour) % 24, Number(p.minute), Number(p.second));
+    const off = Math.round((wall - Math.floor(ts / 1e3) * 1e3) / 6e4);
+    const two = (v) => String(v).padStart(2, "0");
+    const zone = off === 0 ? "Z" : `${off < 0 ? "-" : "+"}${two(Math.floor(Math.abs(off) / 60))}:${two(Math.abs(off) % 60)}`;
+    return `${p.year}-${p.month}-${p.day}T${two(Number(p.hour) % 24)}:${p.minute}:${p.second}${zone}`;
+  } catch {
+    return new Date(ts).toISOString();
+  }
+}
+function stripCodeFence(s) {
+  const m = /```[a-z]*\n([\s\S]*?)```/i.exec(s);
+  return (m !== null ? m[1] : s).trim();
+}
+
+// packages/superscript/src/index.ts
+var enabled = /* @__PURE__ */ new Set([SuperScriptLanguage.id]);
+function registerLanguage2(lang) {
+  registerLanguage(lang);
+  enabled.add(lang.id);
+}
+function getLanguage2(id) {
+  return enabled.has(id) ? getLanguage(id) : void 0;
+}
+function listLanguages2() {
+  return listLanguages().filter((lang) => enabled.has(lang.id));
+}
+function runScript(source, bars, languageId = SuperScriptLanguage.id, params) {
+  const lang = getLanguage2(languageId);
+  if (lang === void 0) {
+    throw new Error(`language "${languageId}" is not enabled on @supersolutions/super-chart-superscript; only "superscript" runs by default. Register another language with registerLanguage() from this entry first.`);
+  }
+  return lang.compile(source).run(bars, params);
+}
+export {
+  ANALYST_SYSTEM_PROMPT,
+  JavaScriptLanguage,
+  SUPERSCRIPT_SYSTEM_PROMPT,
+  SuperScriptError,
+  SuperScriptLanguage,
+  analyzeChart,
+  buildChartContext,
+  checkSuperScript,
+  createHttpAIClient,
+  formatDiagnostics,
+  getLanguage2 as getLanguage,
+  isSuperScriptError,
+  listLanguages2 as listLanguages,
+  nlToSuperScript,
+  nlToSuperScriptChecked,
+  registerLanguage2 as registerLanguage,
+  runScript,
+  superlib,
+  superscriptReference
+};

package/dist/scripts.d.ts

@@ -0,0 +1,119 @@
+import { EngineIndicatorInstance, EngineIndicatorSpec, IndicatorDefinition } from '@supersolutions/super-chart-core';
+
+/**
+ * SuperScript diagnostics: every problem has a severity, a code, a message and
+ * a 1-based position, so a person, an editor or an AI repair loop can act on
+ * it. Part of Super Chart.
+ */
+export type DiagnosticSeverity = "error" | "warning";
+/**
+ * Codes are stable; messages may be reworded.
+ *
+ * Errors (the script does not compile):
+ * UNEXPECTED_CHAR, UNTERMINATED_STRING, UNEXPECTED_TOKEN, TRAILING_TOKENS,
+ * UNBALANCED, REASSIGNMENT (`:=`, `+=`, …), CONTROL_FLOW (`if`, `for`, …),
+ * FUNCTION_DEF (`f(x) => …`), BUILTIN_REASSIGNED, UNKNOWN_IDENTIFIER,
+ * UNKNOWN_FUNCTION, ARITY, UNKNOWN_ARGUMENT, DUPLICATE_ARGUMENT,
+ * EXPECTED_CONSTANT, BAD_LENGTH, BAD_OFFSET, TYPE, PINE_MISMATCH,
+ * UNSUPPORTED, STATEMENT (`plot()` inside an expression).
+ *
+ * Warnings (the script compiles; the part named is ignored):
+ * IGNORED_STATEMENT (plotshape, bgcolor, strategy.*, …), UNUSED_EXPRESSION,
+ * IGNORED_KEYWORD (var, float, …), UNKNOWN_KEYWORD (an unknown plot()
+ * keyword), NO_PLOTS.
+ */
+export type DiagnosticCode = "UNEXPECTED_CHAR" | "UNTERMINATED_STRING" | "UNEXPECTED_TOKEN" | "TRAILING_TOKENS" | "UNBALANCED" | "REASSIGNMENT" | "CONTROL_FLOW" | "FUNCTION_DEF" | "BUILTIN_REASSIGNED" | "UNKNOWN_IDENTIFIER" | "UNKNOWN_FUNCTION" | "ARITY" | "UNKNOWN_ARGUMENT" | "DUPLICATE_ARGUMENT" | "EXPECTED_CONSTANT" | "BAD_LENGTH" | "BAD_OFFSET" | "TYPE" | "PINE_MISMATCH" | "UNSUPPORTED" | "STATEMENT" | "IGNORED_STATEMENT" | "UNUSED_EXPRESSION" | "IGNORED_KEYWORD" | "UNKNOWN_KEYWORD" | "NO_PLOTS";
+export interface Diagnostic {
+	severity: DiagnosticSeverity;
+	code: DiagnosticCode;
+	message: string;
+	/** 1-based line. */
+	line: number;
+	/** 1-based column of the first character. */
+	col: number;
+	/** 1-based column just past the last character. */
+	endCol: number;
+	/** A suggested fix, when there is one. */
+	hint?: string;
+}
+/** One `input()` of a script: what a settings form or an agent can change. */
+export interface ScriptInput {
+	/** The name it is bound to (`len = input(14)` → "len"), else "in<index>". */
+	id: string;
+	title: string;
+	defval: number;
+	min?: number;
+	max?: number;
+	step?: number;
+	type: "int" | "float";
+}
+/** Input values for `run()`: by position (the order of `meta.inputs`) or by input id. */
+export type ScriptParams = ReadonlyArray<number | null | undefined> | Readonly<Record<string, number | null | undefined>>;
+/** Per-script ceilings, not a wall-clock timeout or an isolation sandbox. */
+export interface EngineScriptLimits {
+	readonly sourceLength: number;
+	readonly nodes: number;
+	readonly depth: number;
+	readonly plots: number;
+	readonly inputs: number;
+	readonly bars: number;
+	readonly window: number;
+	readonly seriesCells: number;
+	readonly workUnits: number;
+}
+export declare const ENGINE_SCRIPT_LIMITS: Readonly<EngineScriptLimits>;
+export interface EngineScriptOptions {
+	readonly name: string;
+	readonly source: string;
+	readonly params?: ScriptParams;
+	/** Optional tighter ceilings. Raising the built-in ceilings is not supported. */
+	readonly limits?: Partial<EngineScriptLimits>;
+}
+export type EngineScriptErrorCode = "LIMIT" | "UNSUPPORTED" | "PARAMS" | "DATA" | "RESULT" | "DISPOSED";
+export declare class EngineScriptError extends Error {
+	readonly code: EngineScriptErrorCode;
+	constructor(code: EngineScriptErrorCode, message: string);
+}
+/** Structural host interface: no EngineChart, DOM, or upstream-engine import. */
+export interface EngineScriptHost {
+	registerIndicator: (definition: IndicatorDefinition) => void;
+	unregisterIndicator: (name: string, expectedCalculate?: IndicatorDefinition["calculate"]) => boolean;
+	addIndicator: (spec: EngineIndicatorSpec) => string;
+	listIndicators: () => readonly EngineIndicatorInstance[];
+	removeIndicator: (id: string) => boolean;
+	updateIndicator: (id: string, changes: Pick<EngineIndicatorSpec, "params">) => boolean;
+}
+export interface EngineScriptAttachment {
+	readonly id: string;
+	/** Validate before changing the instance. Unspecified inputs keep their current values. */
+	setParams: (params: ScriptParams) => readonly number[];
+	/** Remove only this instance, then unregister only this exact calculation if unused. */
+	dispose: () => void;
+}
+export interface EngineScriptIndicator {
+	readonly title: string;
+	readonly definition: IndicatorDefinition;
+	readonly inputs: readonly Readonly<ScriptInput>[];
+	readonly diagnostics: readonly Readonly<Diagnostic>[];
+	readonly limits: Readonly<EngineScriptLimits>;
+	attach: (host: EngineScriptHost, options?: Omit<EngineIndicatorSpec, "name" | "params"> & {
+		params?: ScriptParams;
+	}) => EngineScriptAttachment;
+	/** Detach all owned instances. Borrowed definitions remain valid until their host releases them. */
+	dispose: () => void;
+}
+/**
+ * Optional owned-engine bridge. Import this module on demand; it never imports
+ * klinecharts or the arbitrary-JavaScript language registry. The own parser and
+ * evaluator run SuperScript only; warnings about ignored constructs are errors.
+ *
+ * Calculations see every revealed raw bar, not HA values or a viewport slice.
+ * `time` is the feed's epoch milliseconds and `bar_index` starts at the first
+ * loaded bar. Prepending history therefore intentionally changes cumulative and
+ * indexed formulas. Replay must supply only its revealed prefix, as EngineChart
+ * does. Resource ceilings reject work; they never truncate or invent results.
+ * The synchronous runtime has no interruptible wall-clock deadline.
+ */
+export declare function createEngineScriptIndicator(options: EngineScriptOptions): EngineScriptIndicator;
+
+export {};