@supersolutions/super-chart-superscript 0.0.0-stage → 0.1.0

package/dist/scripts.js

@@ -0,0 +1,443 @@
+import {
+  BUILTINS,
+  PINE_ALIASES,
+  PINE_ARG_NAMES,
+  SuperScriptError,
+  check,
+  evaluate,
+  parse
+} from "./chunk-PAWYIS77.js";
+
+// packages/superscript/src/scripts.ts
+var ENGINE_SCRIPT_LIMITS = Object.freeze({
+  sourceLength: 32768,
+  nodes: 2048,
+  depth: 64,
+  plots: 32,
+  inputs: 64,
+  bars: 1e5,
+  window: 1e4,
+  seriesCells: 8e6,
+  workUnits: 5e7
+});
+var EngineScriptError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "EngineScriptError";
+  }
+};
+var PALETTE = ["#8bafff", "#ffb454", "#cf9bff", "#58c9ac", "#f28b82", "#d8c66a"];
+function limitsOf(overrides = {}) {
+  const limits = { ...ENGINE_SCRIPT_LIMITS };
+  for (const key of Object.keys(overrides)) {
+    const value = overrides[key];
+    if (!Object.prototype.hasOwnProperty.call(ENGINE_SCRIPT_LIMITS, key) || !Number.isSafeInteger(value) || value < 1 || value > ENGINE_SCRIPT_LIMITS[key]) {
+      throw new EngineScriptError("LIMIT", `Invalid script ceiling: ${key}`);
+    }
+    limits[key] = value;
+  }
+  return Object.freeze(limits);
+}
+function sourceCode(source, limits) {
+  if (typeof source !== "string" || source.length > limits.sourceLength)
+    throw new EngineScriptError("LIMIT", "Script source is too large");
+  let code = "", quote = "", depth = 0;
+  for (let i = 0; i < source.length; i++) {
+    const c = source[i];
+    if (quote !== "") {
+      if (c === "\\") {
+        code += c + (source[++i] ?? "");
+        continue;
+      }
+      if (c === quote)
+        quote = "";
+      code += c;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      quote = c;
+      code += c;
+      continue;
+    }
+    if (c === "/" && source[i + 1] === "/") {
+      while (i < source.length && source[i] !== "\n") {
+        code += " ";
+        i++;
+      }
+      code += "\n";
+      continue;
+    }
+    if (c === "(" || c === "[") {
+      if (++depth > limits.depth)
+        throw new EngineScriptError("LIMIT", "Script nesting is too deep");
+    } else if (c === ")" || c === "]")
+      depth--;
+    code += c;
+  }
+  const tokens = code.match(/"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[A-Za-z_][\w.]*|[()[\],=]|\S/g) ?? [];
+  if (tokens.length > Math.min(4096, limits.nodes * 8))
+    throw new EngineScriptError("LIMIT", "Script token budget exceeded");
+  const calls = [];
+  let nesting = 0, unary = 0;
+  const unsupported = /* @__PURE__ */ new Set(["editable", "display", "trackprice", "show_last", "join", "transp", "force_overlay", "format", "precision"]);
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    unary = ["+", "-", "!", "not"].includes(token) ? unary + 1 : 0;
+    if (unary > limits.depth)
+      throw new EngineScriptError("LIMIT", "Script unary nesting is too deep");
+    const call = calls[calls.length - 1];
+    const styleArgument = call?.name === "plot" && call.depth === nesting && (tokens[i - 1] === "=" && ["style", "type"].includes(tokens[i - 2]) || call.argument === 4 && tokens[i - 1] === ",");
+    if (styleArgument && /^plot\.style_(stepline|area|cross)$/.test(token[0] === '"' || token[0] === "'" ? token.slice(1, -1) : token)) {
+      throw new EngineScriptError("UNSUPPORTED", "Step, area and cross script plots are not supported");
+    }
+    if (token === "(") {
+      nesting++;
+      calls.push({ name: tokens[i - 1] ?? "", depth: nesting, argument: 0 });
+    } else if (token === ")") {
+      if (calls[calls.length - 1]?.depth === nesting)
+        calls.pop();
+      nesting--;
+    } else if (token === "[")
+      nesting++;
+    else if (token === "]")
+      nesting--;
+    else if (token === "," && call?.depth === nesting)
+      call.argument++;
+    else if (tokens[i + 1] === "=" && calls[calls.length - 1]?.depth === nesting) {
+      const name = calls[calls.length - 1].name;
+      if (/^(plot|hline)$/.test(name) && unsupported.has(token) || /^(indicator|study)$/.test(name) && token !== "title" && token !== "overlay" || /^input(\.int|\.float)?$/.test(name) && !["title", "minval", "maxval", "step", "defval"].includes(token)) {
+        throw new EngineScriptError("UNSUPPORTED", `Script argument is not supported: ${name}.${token}`);
+      }
+      if (/^(indicator|study)$/.test(name) && token === "overlay" && (!["true", "false", "0", "1"].includes(tokens[i + 2]) || ![",", ")"].includes(tokens[i + 3]))) {
+        throw new EngineScriptError("UNSUPPORTED", "Indicator overlay must be a literal boolean");
+      }
+    }
+  }
+  return code;
+}
+function analyze(program, limits) {
+  let nodes = 0, statementIndex = 0;
+  const guards = [];
+  const visit = (expression, depth) => {
+    if (++nodes > limits.nodes || depth > limits.depth)
+      throw new EngineScriptError("LIMIT", "Script expression budget exceeded");
+    const child = (e) => visit(e, depth + 1);
+    switch (expression.k) {
+      case "bin":
+        child(expression.l);
+        child(expression.r);
+        break;
+      case "tern":
+        child(expression.c);
+        child(expression.a);
+        child(expression.b);
+        break;
+      case "unary":
+        child(expression.arg);
+        break;
+      case "index":
+        guards.push({ expression: expression.offset, label: "history offset", scan: false, statement: statementIndex });
+        child(expression.target);
+        child(expression.offset);
+        break;
+      case "call": {
+        expression.args.forEach(child);
+        expression.kw.forEach((kw) => child(kw.value));
+        let name = PINE_ALIASES.get(expression.name) ?? expression.name;
+        let args = expression.args;
+        if (expression.name === "ta.cci" || expression.name === "ta.mfi") {
+          name = expression.name.slice(3);
+          args = expression.args.slice(1);
+        } else if (expression.name === "ta.stoch") {
+          name = "stoch";
+          args = expression.args.slice(3);
+        }
+        const builtin = BUILTINS.get(name);
+        builtin?.params.forEach((param, index) => {
+          if (param.kind !== "length" && param.kind !== "count")
+            return;
+          const expressionValue = args[index] ?? expression.kw.find((kw) => (PINE_ARG_NAMES.get(kw.name) ?? kw.name) === param.name)?.value;
+          if (expressionValue !== void 0) {
+            guards.push({
+              expression: expressionValue,
+              label: `${name}.${param.name}`,
+              statement: statementIndex,
+              // Conservative: even amortised rolling algorithms can fall back to
+              // window scans after arithmetic overflows in a nested expression.
+              scan: param.kind === "length" || name === "pivothigh" || name === "pivotlow"
+            });
+          }
+        });
+        break;
+      }
+    }
+  };
+  for (const statement of program.statements) {
+    visit(statement.value, 1);
+    if ((statement.k === "plot" || statement.k === "hline") && statement.lineWidth !== void 0)
+      visit(statement.lineWidth, 1);
+    if (statement.k === "plot" && statement.histbase !== void 0)
+      visit(statement.histbase, 1);
+    statementIndex++;
+  }
+  return { nodes, guards };
+}
+function guardProgram(program, guards) {
+  const statements = [], plots = [], windows = [];
+  let plotIndex = 0;
+  program.statements.forEach((statement, index) => {
+    guards.forEach((guard, guardIndex) => {
+      if (guard.statement !== index)
+        return;
+      statements.push({
+        k: "plot",
+        value: { k: "num", v: 0, text: "0", at: guard.expression.at },
+        histbase: guard.expression,
+        style: {},
+        at: guard.expression.at
+      });
+      windows[guardIndex] = plotIndex++;
+    });
+    statements.push(statement);
+    if (statement.k === "plot" || statement.k === "hline")
+      plots.push(plotIndex++);
+  });
+  return { program: { ...program, statements }, plots, windows };
+}
+function figuresOf(plots) {
+  return Object.freeze(plots.map((plot, index) => {
+    const style = plot.style ?? {}, width = style.lineWidth ?? 1.5, base = style.histbase ?? 0;
+    if (!Number.isFinite(width) || width <= 0 || width > 32 || !Number.isFinite(base))
+      throw new EngineScriptError("RESULT", "Plot width/base must be finite; width must be within (0, 32]");
+    const dash = style.lineStyle === "dotted" ? [1, 3] : style.lineStyle === "dashed" || style.lineStyle === void 0 && plot.kind === "hline" ? [4, 4] : [];
+    return Object.freeze({
+      key: plot.id,
+      title: plot.title,
+      color: style.color ?? PALETTE[index % PALETTE.length],
+      type: style.type === "histogram" ? "bar" : style.type === "circle" ? "circle" : "line",
+      lineWidth: width,
+      dash: Object.freeze(dash),
+      ...style.type === "histogram" ? { base } : {}
+    });
+  }));
+}
+function sameFigures(a, b) {
+  return a.length === b.length && a.every((figure, i) => {
+    const next = b[i];
+    return figure.key === next.key && figure.title === next.title && figure.type === next.type && figure.color === next.color && figure.lineWidth === next.lineWidth && figure.base === next.base && figure.dash?.join(",") === next.dash?.join(",");
+  });
+}
+function normalizeParams(inputs, given, current) {
+  if (given !== void 0) {
+    if (typeof given !== "object" || given === null)
+      throw new EngineScriptError("PARAMS", "Script inputs must be an array or object");
+    if (Array.isArray(given) ? given.length > inputs.length : Object.keys(given).some((key) => !inputs.some((input) => input.id === key))) {
+      throw new EngineScriptError("PARAMS", "Unknown script input");
+    }
+  }
+  return Object.freeze(inputs.map((input, i) => {
+    const supplied = Array.isArray(given) ? given[i] : given !== void 0 && Object.prototype.hasOwnProperty.call(given, input.id) ? given[input.id] : void 0;
+    let value = supplied == null ? current[i] : supplied;
+    if (typeof value !== "number" || !Number.isFinite(value))
+      throw new EngineScriptError("PARAMS", `Input must be finite: ${input.id}`);
+    if (input.type === "int")
+      value = Math.round(value);
+    if (input.min !== void 0)
+      value = Math.max(input.min, value);
+    if (input.max !== void 0)
+      value = Math.min(input.max, value);
+    return value;
+  }));
+}
+function validateBars(bars, limits) {
+  if (!Array.isArray(bars) || bars.length > limits.bars)
+    throw new EngineScriptError("LIMIT", "Script history exceeds the bar ceiling; history is not silently truncated");
+  let previous = -Infinity;
+  for (const bar of bars) {
+    if (bar == null || ![bar.timestamp, bar.open, bar.high, bar.low, bar.close].every((value) => typeof value === "number" && Number.isFinite(value)) || Math.abs(bar.timestamp) > 864e13 || bar.timestamp <= previous || bar.high < Math.max(bar.open, bar.low, bar.close) || bar.low > Math.min(bar.open, bar.high, bar.close) || bar.volume !== void 0 && (typeof bar.volume !== "number" || !Number.isFinite(bar.volume) || bar.volume < 0)) {
+      throw new EngineScriptError("DATA", "Scripts require ascending unique epoch-ms timestamps, finite coherent OHLC and nonnegative reported volume");
+    }
+    previous = bar.timestamp;
+  }
+}
+function createEngineScriptIndicator(options) {
+  if (typeof options.name !== "string" || options.name.trim() === "")
+    throw new TypeError("Script indicator name must not be empty");
+  const limits = limitsOf(options.limits);
+  sourceCode(options.source, limits);
+  let program;
+  try {
+    program = parse(options.source);
+  } catch (error) {
+    if (error instanceof RangeError)
+      throw new EngineScriptError("LIMIT", "Script parser recursion budget exceeded");
+    throw error;
+  }
+  const analysis = analyze(program, limits), checked = check(program);
+  if (checked.diagnostics.length > 0)
+    throw new SuperScriptError(checked.diagnostics[0], checked.diagnostics);
+  if (checked.plots.length === 0 || checked.plots.length > limits.plots || checked.inputs.length > limits.inputs)
+    throw new EngineScriptError("LIMIT", "Script plot/input ceiling exceeded");
+  const inputs = Object.freeze(checked.inputs.map((input) => {
+    if (!Number.isFinite(input.defval) || input.min !== void 0 && !Number.isFinite(input.min) || input.max !== void 0 && !Number.isFinite(input.max) || input.min !== void 0 && input.max !== void 0 && input.min > input.max || input.min !== void 0 && input.defval < input.min || input.max !== void 0 && input.defval > input.max || input.step !== void 0 && (!Number.isFinite(input.step) || input.step <= 0) || input.type === "int" && [input.min, input.max].some((value) => value !== void 0 && !Number.isSafeInteger(value))) {
+      throw new EngineScriptError("PARAMS", `Invalid input bounds: ${input.id}`);
+    }
+    return Object.freeze({ ...input });
+  }));
+  const initialParams = normalizeParams(inputs, options.params, inputs.map((input) => input.defval));
+  const guarded = guardProgram(program, analysis.guards);
+  const preflight = (params) => {
+    const result = evaluate(guarded.program, [], params);
+    const plots = guarded.plots.map((index, i) => ({ ...result.plots[index], id: checked.plots[i].id, title: checked.plots[i].title }));
+    if (result.inputs.length !== inputs.length || result.inputs.some((input, i) => {
+      const initial = inputs[i];
+      return input.id !== initial.id || input.type !== initial.type || input.defval !== initial.defval || input.min !== initial.min || input.max !== initial.max || input.step !== initial.step;
+    }))
+      throw new EngineScriptError("UNSUPPORTED", "Input declarations depend on other inputs; use fixed defaults and bounds");
+    let scan = 0;
+    for (let i = 0; i < analysis.guards.length; i++) {
+      const guard = analysis.guards[i], value = result.plots[guarded.windows[i]]?.style?.histbase;
+      if (value === void 0 || !Number.isSafeInteger(value) || value < 0 || value > limits.window)
+        throw new EngineScriptError("LIMIT", `Script ${guard.label} exceeds the window ceiling (${limits.window})`);
+      if (guard.scan)
+        scan += 2 * value;
+    }
+    return { figures: figuresOf(plots), scan };
+  };
+  let cachedParams = initialParams, cached = preflight(initialParams);
+  const figures = cached.figures;
+  const validated = (params) => {
+    if (params.length !== inputs.length)
+      throw new EngineScriptError("PARAMS", `Script requires ${inputs.length} inputs`);
+    const normalized = normalizeParams(inputs, params, initialParams);
+    if (normalized.some((value, i) => value !== cachedParams[i])) {
+      const next = preflight(normalized);
+      if (!sameFigures(figures, next.figures))
+        throw new EngineScriptError("UNSUPPORTED", "These inputs change plot width/base; recompile the script before replacing its definition");
+      cached = next;
+      cachedParams = normalized;
+    }
+    return normalized;
+  };
+  const definition = Object.freeze({
+    name: options.name,
+    params: initialParams,
+    pane: program.overlay ? "price" : "separate",
+    figures,
+    validateParams: (params) => {
+      const normalized = validated(params);
+      if (normalized.some((value, i) => value !== params[i]))
+        throw new EngineScriptError("PARAMS", "Script inputs must respect their numeric bounds and integer type; attachment.setParams normalizes them");
+    },
+    calculate: (bars, params) => {
+      const actual = validated(params);
+      validateBars(bars, limits);
+      if (bars.length * (analysis.nodes + figures.length + 10) > limits.seriesCells || bars.length * (analysis.nodes * 8 + cached.scan) > limits.workUnits) {
+        throw new EngineScriptError("LIMIT", "Script estimated calculation budget exceeded");
+      }
+      const result = evaluate(program, bars, actual);
+      if (!sameFigures(figures, figuresOf(result.plots)) || result.plots.some((plot) => plot.values.length !== bars.length))
+        throw new EngineScriptError("RESULT", "Script results do not match their declared plots/history");
+      return bars.map((_bar, index) => {
+        const row = /* @__PURE__ */ Object.create(null);
+        for (const plot of result.plots) {
+          const value = plot.values[index];
+          row[plot.id] = typeof value === "number" && Number.isFinite(value) ? value : null;
+        }
+        return row;
+      });
+    }
+  });
+  let disposed = false;
+  const owned = /* @__PURE__ */ new Map();
+  return Object.freeze({
+    title: program.title,
+    definition,
+    inputs,
+    limits,
+    diagnostics: Object.freeze(checked.diagnostics.map((diagnostic) => Object.freeze({ ...diagnostic }))),
+    attach: (host, settings = {}) => {
+      if (disposed)
+        throw new EngineScriptError("DISPOSED", "Script bridge has been disposed");
+      if (owned.has(host))
+        throw new Error("This script is already attached to this host");
+      const params = validated(normalizeParams(inputs, settings.params, initialParams));
+      host.registerIndicator(definition);
+      let id;
+      try {
+        id = host.addIndicator({ ...settings, name: definition.name, params });
+      } catch (error) {
+        try {
+          host.unregisterIndicator(definition.name, definition.calculate);
+        } catch {
+        }
+        throw error;
+      }
+      let detached = false;
+      const attachment = Object.freeze({
+        id,
+        setParams: (given) => {
+          if (detached || disposed)
+            throw new EngineScriptError("DISPOSED", "Script attachment has been disposed");
+          const current = host.listIndicators().find((instance) => instance.id === id);
+          if (current?.name !== definition.name)
+            throw new Error("Script instance no longer exists");
+          const next = validated(normalizeParams(inputs, given, current.params));
+          if (!host.updateIndicator(id, { params: next }))
+            throw new Error("Script instance no longer exists");
+          return next;
+        },
+        dispose: () => {
+          if (detached)
+            return;
+          detached = true;
+          owned.delete(host);
+          let failure, failed = false;
+          try {
+            if (host.listIndicators().some((instance) => instance.id === id && instance.name === definition.name))
+              host.removeIndicator(id);
+          } catch (error) {
+            failure = error;
+            failed = true;
+          }
+          try {
+            host.unregisterIndicator(definition.name, definition.calculate);
+          } catch (error) {
+            if (!failed) {
+              failure = error;
+              failed = true;
+            }
+          }
+          if (failed)
+            throw failure;
+        }
+      });
+      owned.set(host, attachment);
+      return attachment;
+    },
+    dispose: () => {
+      if (disposed)
+        return;
+      disposed = true;
+      let failure, failed = false;
+      for (const attachment of [...owned.values()]) {
+        try {
+          attachment.dispose();
+        } catch (error) {
+          if (!failed) {
+            failure = error;
+            failed = true;
+          }
+        }
+      }
+      if (failed)
+        throw failure;
+    }
+  });
+}
+export {
+  ENGINE_SCRIPT_LIMITS,
+  EngineScriptError,
+  createEngineScriptIndicator
+};

package/package.json

@@ -1,6 +1,53 @@
 {
   "name": "@supersolutions/super-chart-superscript",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "SuperScript language runtime, AI helpers and the script-to-indicator bridge for Super Chart. Runs in plain Node.",
+  "license": "GPL-3.0-or-later",
+  "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Super-Solution/super-chart.git",
+    "directory": "packages/superscript"
+  },
+  "homepage": "https://github.com/Super-Solution/super-chart#readme",
+  "bugs": {
+    "url": "https://github.com/Super-Solution/super-chart/issues"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./scripts": {
+      "types": "./dist/scripts.d.ts",
+      "import": "./dist/scripts.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "scripts": [
+        "./dist/scripts.d.ts"
+      ]
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/",
+    "tag": "latest"
+  },
+  "dependencies": {
+    "@supersolutions/super-chart-core": "0.1.0"
+  },
+  "author": "SUPER SOLUTION LABS INC"
+}