hyperprop-charting-library 0.1.136 → 0.1.137

package/dist/hyperprop-charting-library.cjs

@@ -22,8 +22,10 @@ var index_exports = {};
 __export(index_exports, {
   FIB_DEFAULT_PALETTE: () => FIB_DEFAULT_PALETTE,
   POSITION_DEFAULT_COLORS: () => POSITION_DEFAULT_COLORS,
+  SCRIPT_SOURCE_INPUT_VALUES: () => SCRIPT_SOURCE_INPUT_VALUES,
   compileScriptIndicator: () => compileScriptIndicator,
   createChart: () => createChart,
+  extractScriptInputs: () => extractScriptInputs,
   validateScriptSource: () => validateScriptSource
 });
 module.exports = __toCommonJS(index_exports);
@@ -2151,6 +2153,82 @@ var hashScriptSource = (source) => {
   }
   return (hash >>> 0).toString(36);
 };
+var SCRIPT_SOURCE_INPUT_VALUES = ["open", "high", "low", "close", "hl2", "hlc3", "ohlc4"];
+var slugifyInputLabel = (label) => {
+  const slug = String(label).trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  return slug || "input";
+};
+var createScriptInputHelper = (values, registry) => {
+  const usedKeys = /* @__PURE__ */ new Set();
+  const resolveKey = (label, options) => {
+    let key = options?.key ?? slugifyInputLabel(label);
+    if (usedKeys.has(key)) {
+      let suffix = 2;
+      while (usedKeys.has(`${key}_${suffix}`)) suffix += 1;
+      key = `${key}_${suffix}`;
+    }
+    usedKeys.add(key);
+    return key;
+  };
+  const resolve = (key, fallback, coerce) => {
+    if (!values) return fallback;
+    const raw = values[key];
+    if (raw === void 0 || raw === null) return fallback;
+    const coerced = coerce(raw);
+    return coerced === void 0 ? fallback : coerced;
+  };
+  const coerceNumber = (raw) => {
+    const num = typeof raw === "number" ? raw : Number(raw);
+    return Number.isFinite(num) ? num : void 0;
+  };
+  const numberInput = (integer) => (label, defaultValue, options) => {
+    const key = resolveKey(label, options);
+    registry?.push({
+      key,
+      label,
+      type: "number",
+      default: defaultValue,
+      ...options?.min !== void 0 ? { min: options.min } : {},
+      ...options?.max !== void 0 ? { max: options.max } : {},
+      ...options?.step !== void 0 ? { step: options.step } : integer ? { step: 1 } : {}
+    });
+    const value = resolve(key, defaultValue, coerceNumber);
+    return integer ? Math.round(value) : value;
+  };
+  const selectInput = (label, defaultValue, choices, options) => {
+    const key = resolveKey(label, options);
+    const normalized = (Array.isArray(choices) ? choices : []).map(
+      (choice) => typeof choice === "string" ? { value: choice, label: choice } : { value: String(choice.value), label: String(choice.label ?? choice.value) }
+    );
+    registry?.push({ key, label, type: "select", default: defaultValue, options: normalized });
+    return resolve(key, defaultValue, (raw) => typeof raw === "string" ? raw : String(raw));
+  };
+  return Object.freeze({
+    int: numberInput(true),
+    float: numberInput(false),
+    bool: (label, defaultValue = false, options) => {
+      const key = resolveKey(label, options);
+      registry?.push({ key, label, type: "boolean", default: defaultValue });
+      return resolve(
+        key,
+        defaultValue,
+        (raw) => typeof raw === "boolean" ? raw : raw === "true" ? true : raw === "false" ? false : void 0
+      );
+    },
+    color: (label, defaultValue, options) => {
+      const key = resolveKey(label, options);
+      registry?.push({ key, label, type: "color", default: defaultValue });
+      return resolve(key, defaultValue, (raw) => typeof raw === "string" ? raw : void 0);
+    },
+    string: (label, defaultValue = "", options) => {
+      const key = resolveKey(label, options);
+      registry?.push({ key, label, type: "string", default: defaultValue });
+      return resolve(key, defaultValue, (raw) => typeof raw === "string" ? raw : String(raw));
+    },
+    select: selectInput,
+    source: (label = "Source", defaultValue = "close", options) => selectInput(label, defaultValue, SCRIPT_SOURCE_INPUT_VALUES, options)
+  });
+};
 var SCRIPT_GUARD_BUDGET_MS = 1e3;
 var ScriptBudgetError = class extends Error {
   constructor() {
@@ -2425,31 +2503,34 @@ var injectLoopGuards = (source, guardName) => {
   }
   return out;
 };
-var compileScriptCompute = (source, guard) => {
+var compileScriptFactory = (source) => {
   const makeFactory = (body) => new Function(
     "__hpGuard",
+    "input",
     `"use strict";
 ${body}
 ;if (typeof compute !== "function") { throw new Error("Script must define function compute(bars, inputs, hp)"); }
 return compute;`
   );
-  let factory;
   try {
-    factory = makeFactory(injectLoopGuards(source, "__hpGuard"));
+    return makeFactory(injectLoopGuards(source, "__hpGuard"));
   } catch {
-    factory = makeFactory(source);
+    return makeFactory(source);
   }
-  guard.reset();
-  return factory(guard);
 };
-var validateScriptSource = (source) => {
+var extractScriptInputs = (source) => {
+  const registry = [];
   try {
-    compileScriptCompute(source, createScriptGuard());
-    return null;
+    const factory = compileScriptFactory(source);
+    const guard = createScriptGuard();
+    guard.reset();
+    factory(guard, createScriptInputHelper(null, registry));
+    return { inputs: registry, error: null };
   } catch (error) {
-    return error instanceof Error ? error.message : String(error);
+    return { inputs: registry, error: error instanceof Error ? error.message : String(error) };
   }
 };
+var validateScriptSource = (source) => extractScriptInputs(source).error;
 var drawScriptError = (ctx, renderContext, name, message) => {
   ctx.save();
   ctx.font = "11px -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif";
@@ -2466,18 +2547,24 @@ var compileScriptIndicator = (definition) => {
   for (const input of definition.inputs ?? []) {
     defaultInputs[input.key] = input.default;
   }
-  let compiled = null;
+  let factory = null;
   let compileError = null;
   const guard = createScriptGuard();
   try {
-    compiled = compileScriptCompute(definition.source, guard);
+    factory = compileScriptFactory(definition.source);
+    const declared = [];
+    guard.reset();
+    factory(guard, createScriptInputHelper(null, declared));
+    for (const input of declared) {
+      defaultInputs[input.key] = input.default;
+    }
   } catch (error) {
     compileError = error instanceof Error ? error.message : String(error);
   }
   const sourceKey = hashScriptSource(definition.source);
   let trippedError = null;
   const runCompute = (data, inputs) => {
-    if (!compiled) {
+    if (!factory || compileError) {
       return { error: compileError ?? "Script failed to compile" };
     }
     if (trippedError) {
@@ -2485,6 +2572,7 @@ var compileScriptIndicator = (definition) => {
     }
     try {
       guard.reset();
+      const compiled = factory(guard, createScriptInputHelper(inputs, null));
       const result = compiled(data, inputs, SCRIPT_HELPERS);
       if (!result || !Array.isArray(result.plots)) {
         return { error: "compute() must return { plots: [...] }" };
@@ -2979,6 +3067,24 @@ function createChart(element, options = {}) {
   let drawingDoubleClickHandler = null;
   let drawingEditTextHandler = null;
   let magnetMode = "none";
+  let priceScaleMode = "linear";
+  let priceScaleInverted = false;
+  const PRICE_SCALE_LOG_FLOOR = 1e-9;
+  const priceScaleTransform = (price) => priceScaleMode === "log" ? Math.log10(Math.max(PRICE_SCALE_LOG_FLOOR, price)) : price;
+  const priceScaleUntransform = (value) => priceScaleMode === "log" ? Math.pow(10, value) : value;
+  const percentBaselineForXStart = (xStartValue) => {
+    if (priceScaleMode !== "percent") return null;
+    const bar = data[clamp(Math.round(xStartValue), 0, Math.max(0, data.length - 1))];
+    return bar && bar.c > 0 ? bar.c : null;
+  };
+  const formatPriceForScale = (price, percentBaseline) => {
+    if (percentBaseline !== null) {
+      const pct = (price / percentBaseline - 1) * 100;
+      const rounded = Math.abs(pct) < 5e-3 ? 0 : pct;
+      return `${rounded > 0 ? "+" : ""}${rounded.toFixed(2)}%`;
+    }
+    return formatPrice(price);
+  };
   let magnetModifierActive = false;
   let shiftKeyActive = false;
   const MAGNET_WEAK_THRESHOLD_PX = 16;
@@ -4312,9 +4418,14 @@ function createChart(element, options = {}) {
       yMax
     };
     plotBottomForHit = fullChartBottom;
+    const scaledYMin = priceScaleTransform(yMin);
+    const scaledYRange = priceScaleTransform(yMax) - scaledYMin || 1;
     const yFromPrice = (price) => {
-      return chartBottom - (price - yMin) / yRange * chartHeight;
+      const ratio = (priceScaleTransform(price) - scaledYMin) / scaledYRange;
+      return priceScaleInverted ? chartTop + ratio * chartHeight : chartBottom - ratio * chartHeight;
     };
+    const percentBaseline = percentBaselineForXStart(xStart);
+    const formatAxisPrice = (price) => formatPriceForScale(price, percentBaseline);
     const xFromDrawingPoint = (point) => chartLeft + (point.index + 0.5 - xStart) / xSpan * chartWidth;
     const FIB_RATIOS = [0, 0.236, 0.382, 0.5, 0.618, 0.786, 1, 1.618];
     const FIB_EXT_RATIOS = [0, 0.382, 0.5, 0.618, 1, 1.272, 1.618, 2.618];
@@ -5221,19 +5332,40 @@ function createChart(element, options = {}) {
     const yTicks = Math.max(1, Math.floor(yTickCountInput));
     const gridColor = grid.color ?? mergedOptions.gridColor;
     const priceTicks = [];
-    {
-      const targetStep = yRange / Math.max(1, yTicks);
-      let step;
-      if (targetStep > 0 && Number.isFinite(targetStep)) {
-        const base = Math.pow(10, Math.floor(Math.log10(targetStep)));
-        const frac = targetStep / base;
-        step = (frac <= 1 ? 1 : frac <= 2 ? 2 : frac <= 2.5 ? 2.5 : frac <= 5 ? 5 : 10) * base;
-        const instrumentTick = getConfiguredTickSize();
-        if (instrumentTick > 0 && step < instrumentTick * 1e6) {
-          step = Math.max(instrumentTick, Math.round(step / instrumentTick) * instrumentTick);
+    const pickNiceStep = (targetStep) => {
+      if (!(targetStep > 0) || !Number.isFinite(targetStep)) return 1;
+      const base = Math.pow(10, Math.floor(Math.log10(targetStep)));
+      const frac = targetStep / base;
+      return (frac <= 1 ? 1 : frac <= 2 ? 2 : frac <= 2.5 ? 2.5 : frac <= 5 ? 5 : 10) * base;
+    };
+    if (percentBaseline !== null) {
+      const pctMin = (yMin / percentBaseline - 1) * 100;
+      const pctMax = (yMax / percentBaseline - 1) * 100;
+      const step = pickNiceStep((pctMax - pctMin) / Math.max(1, yTicks));
+      const firstTick = Math.ceil(pctMin / step) * step;
+      for (let i = 0; ; i += 1) {
+        const pct = firstTick + i * step;
+        if (pct > pctMax + step * 1e-6) break;
+        priceTicks.push(percentBaseline * (1 + pct / 100));
+        if (priceTicks.length > 200) break;
+      }
+    } else if (priceScaleMode === "log" && yMin > 0 && yMax / yMin > 4) {
+      const mantissas = Math.log10(yMax / yMin) > 8 ? [1] : [1, 2, 5];
+      const firstDecade = Math.floor(Math.log10(Math.max(PRICE_SCALE_LOG_FLOOR, yMin)));
+      const lastDecade = Math.ceil(Math.log10(yMax));
+      for (let decade = firstDecade; decade <= lastDecade; decade += 1) {
+        for (const mantissa of mantissas) {
+          const price = mantissa * Math.pow(10, decade);
+          if (price >= yMin && price <= yMax) priceTicks.push(price);
+          if (priceTicks.length > 200) break;
         }
-      } else {
-        step = 1;
+      }
+    } else {
+      const targetStep = yRange / Math.max(1, yTicks);
+      let step = pickNiceStep(targetStep);
+      const instrumentTick = getConfiguredTickSize();
+      if (targetStep > 0 && Number.isFinite(targetStep) && instrumentTick > 0 && step < instrumentTick * 1e6) {
+        step = Math.max(instrumentTick, Math.round(step / instrumentTick) * instrumentTick);
       }
       const firstTick = Math.ceil(yMin / step) * step;
       for (let i = 0; ; i += 1) {
@@ -5996,7 +6128,7 @@ function createChart(element, options = {}) {
       ctx.font = `${yAxisFontSize}px ${mergedOptions.fontFamily}`;
       for (const price of priceTicks) {
         const y = clamp(yFromPrice(price), chartTop + priceScaleTickLabelInset, chartBottom - priceScaleTickLabelInset);
-        drawText(formatPrice(price), chartRight + 6, y, "left", "middle", yAxis.textColor);
+        drawText(formatAxisPrice(price), chartRight + 6, y, "left", "middle", yAxis.textColor);
       }
       ctx.font = prevFont;
     }
@@ -6071,7 +6203,7 @@ function createChart(element, options = {}) {
         ...ticker.showCountdownInLabel ? [getCountdownText()] : []
       ].map((value) => value === null || value === void 0 ? "" : String(value).trim()).filter((value) => value.length > 0);
       addPriceAxisLabel({
-        text: formatPrice(tickerPrice),
+        text: formatAxisPrice(tickerPrice),
         ...tickerSubtexts.length > 0 ? { subtexts: tickerSubtexts } : {},
         subtextColor: ticker.labelSubtextColor ?? ticker.labelTextColor ?? "#0b1220",
         ...ticker.labelSubtextFontSize === void 0 ? {} : { subtextFontSize: ticker.labelSubtextFontSize },
@@ -6098,7 +6230,7 @@ function createChart(element, options = {}) {
         const previousClose = previousCloseCandidate;
         drawReferenceLine(previousClose, labels.previousCloseColor, "dashed");
         addPriceAxisLabel({
-          text: `PDC ${formatPrice(previousClose)}`,
+          text: `PDC ${formatAxisPrice(previousClose)}`,
           price: previousClose,
           backgroundColor: labels.backgroundColor,
           textColor: labels.mutedTextColor,
@@ -6117,7 +6249,7 @@ function createChart(element, options = {}) {
         if (point.l < visibleLow) visibleLow = point.l;
       }
       addPriceAxisLabel({
-        text: `H ${formatPrice(visibleHigh)}`,
+        text: `H ${formatAxisPrice(visibleHigh)}`,
         price: visibleHigh,
         backgroundColor: labels.backgroundColor,
         textColor: labels.textColor,
@@ -6125,7 +6257,7 @@ function createChart(element, options = {}) {
         priority: 40
       });
       addPriceAxisLabel({
-        text: `L ${formatPrice(visibleLow)}`,
+        text: `L ${formatAxisPrice(visibleLow)}`,
         price: visibleLow,
         backgroundColor: labels.backgroundColor,
         textColor: labels.textColor,
@@ -6137,7 +6269,7 @@ function createChart(element, options = {}) {
       if (Number.isFinite(labels.bidPrice)) {
         drawReferenceLine(labels.bidPrice, labels.bidColor, "dotted");
         addPriceAxisLabel({
-          text: `B ${formatPrice(labels.bidPrice)}`,
+          text: `B ${formatAxisPrice(labels.bidPrice)}`,
           price: labels.bidPrice,
           backgroundColor: labels.bidColor,
           textColor: "#0b1220",
@@ -6148,7 +6280,7 @@ function createChart(element, options = {}) {
       if (Number.isFinite(labels.askPrice)) {
         drawReferenceLine(labels.askPrice, labels.askColor, "dotted");
         addPriceAxisLabel({
-          text: `A ${formatPrice(labels.askPrice)}`,
+          text: `A ${formatAxisPrice(labels.askPrice)}`,
           price: labels.askPrice,
           backgroundColor: labels.askColor,
           textColor: "#0b1220",
@@ -6409,8 +6541,11 @@ function createChart(element, options = {}) {
       ctx.restore();
     };
     if (crosshair.showPriceLabel) {
-      const hoverPrice = yMin + (chartBottom - cy) / chartHeight * yRange;
-      const priceText = formatPrice(hoverPrice);
+      const scaledYMin = priceScaleTransform(yMin);
+      const scaledYRange = priceScaleTransform(yMin + yRange) - scaledYMin || 1;
+      const hoverRatio = priceScaleInverted ? (cy - chartTop) / chartHeight : (chartBottom - cy) / chartHeight;
+      const hoverPrice = priceScaleUntransform(scaledYMin + hoverRatio * scaledYRange);
+      const priceText = formatPriceForScale(hoverPrice, percentBaselineForXStart(xStart));
       const priceWidth = getRightAxisLabelWidth(chartRight, getPriceLabelWidth(priceText, labelPaddingX));
       const priceX = getRightAxisLabelX(chartRight);
       const priceY = clamp(cy - labelHeight / 2, chartTop, chartBottom - labelHeight);
@@ -6578,8 +6713,8 @@ function createChart(element, options = {}) {
     const maxRange = bounds.hardSpan;
     const nextRange = clamp(currentRange * factor, minRange, maxRange);
     const anchorRatio = clamp((anchorY - drawState.chartTop) / drawState.chartHeight, 0, 1);
-    const anchorPrice = currentMax - anchorRatio * currentRange;
-    const nextMax = anchorPrice + anchorRatio * nextRange;
+    const anchorPrice = priceScaleInverted ? currentMin + anchorRatio * currentRange : currentMax - anchorRatio * currentRange;
+    const nextMax = priceScaleInverted ? anchorPrice + (1 - anchorRatio) * nextRange : anchorPrice + anchorRatio * nextRange;
     const nextMin = nextMax - nextRange;
     const clamped = clampYRange(nextMin, nextMax);
     yMinOverride = clamped.min;
@@ -6603,7 +6738,7 @@ function createChart(element, options = {}) {
       const currentMin = yMinOverride ?? drawState.yMin;
       const currentMax = yMaxOverride ?? drawState.yMax;
       const range = currentMax - currentMin || 1;
-      const priceShift = deltaY / drawState.chartHeight * range;
+      const priceShift = deltaY / drawState.chartHeight * range * (priceScaleInverted ? -1 : 1);
       const clamped = clampYRange(currentMin + priceShift, currentMax + priceShift);
       yMinOverride = clamped.min;
       yMaxOverride = clamped.max;
@@ -6836,8 +6971,14 @@ function createChart(element, options = {}) {
     if (!drawState) {
       return 0;
     }
-    const ratio = clamp((drawState.chartBottom - y) / drawState.chartHeight, 0, 1);
-    return drawState.yMin + ratio * (drawState.yMax - drawState.yMin);
+    const ratio = clamp(
+      priceScaleInverted ? (y - drawState.chartTop) / drawState.chartHeight : (drawState.chartBottom - y) / drawState.chartHeight,
+      0,
+      1
+    );
+    const scaledMin = priceScaleTransform(drawState.yMin);
+    const scaledMax = priceScaleTransform(drawState.yMax);
+    return priceScaleUntransform(scaledMin + ratio * (scaledMax - scaledMin));
   };
   const applyMagnet = (y, index, price) => {
     const effective = magnetModifierActive ? "strong" : magnetMode;
@@ -6909,8 +7050,10 @@ function createChart(element, options = {}) {
   };
   const canvasYFromDrawingPrice = (price) => {
     if (!drawState) return 0;
-    const range = drawState.yMax - drawState.yMin || 1;
-    return drawState.chartBottom - (price - drawState.yMin) / range * drawState.chartHeight;
+    const scaledMin = priceScaleTransform(drawState.yMin);
+    const scaledRange = priceScaleTransform(drawState.yMax) - scaledMin || 1;
+    const ratio = (priceScaleTransform(price) - scaledMin) / scaledRange;
+    return priceScaleInverted ? drawState.chartTop + ratio * drawState.chartHeight : drawState.chartBottom - ratio * drawState.chartHeight;
   };
   const distanceToSegment = (x, y, x1, y1, x2, y2) => {
     const dx = x2 - x1;
@@ -8924,6 +9067,16 @@ function createChart(element, options = {}) {
     magnetMode = mode;
   };
   const getMagnetMode = () => magnetMode;
+  const setPriceScale = (options2) => {
+    if (options2.mode === "linear" || options2.mode === "log" || options2.mode === "percent") {
+      priceScaleMode = options2.mode;
+    }
+    if (typeof options2.inverted === "boolean") {
+      priceScaleInverted = options2.inverted;
+    }
+    scheduleDraw();
+  };
+  const getPriceScale = () => ({ mode: priceScaleMode, inverted: priceScaleInverted });
   const getDrawings = () => drawings.map((drawing) => serializeDrawing(drawing));
   const setDrawings = (nextDrawings) => {
     drawings = dedupeDrawingIds(nextDrawings.map((drawing) => normalizeDrawingState(drawing)));
@@ -8993,6 +9146,7 @@ function createChart(element, options = {}) {
       drawings: getDrawings(),
       indicators: getIndicators(),
       magnetMode: getMagnetMode(),
+      priceScale: getPriceScale(),
       drawingDefaults
     };
   };
@@ -9012,6 +9166,9 @@ function createChart(element, options = {}) {
     if (state.magnetMode === "none" || state.magnetMode === "weak" || state.magnetMode === "strong") {
       setMagnetMode(state.magnetMode);
     }
+    if (state.priceScale && typeof state.priceScale === "object") {
+      setPriceScale(state.priceScale);
+    }
     if (state.drawingDefaults && typeof state.drawingDefaults === "object") {
       for (const [tool, defaults] of Object.entries(state.drawingDefaults)) {
         if (defaults && typeof defaults === "object") {
@@ -9106,6 +9263,8 @@ function createChart(element, options = {}) {
     onDrawingEditText,
     setMagnetMode,
     getMagnetMode,
+    setPriceScale,
+    getPriceScale,
     cancelDrawing,
     setTradeMarkers,
     setSelectedDrawing,
@@ -9132,7 +9291,9 @@ function createChart(element, options = {}) {
 0 && (module.exports = {
   FIB_DEFAULT_PALETTE,
   POSITION_DEFAULT_COLORS,
+  SCRIPT_SOURCE_INPUT_VALUES,
   compileScriptIndicator,
   createChart,
+  extractScriptInputs,
   validateScriptSource
 });

package/dist/hyperprop-charting-library.d.ts

@@ -583,6 +583,15 @@ interface ChartInstance {
     onDrawingEditText: (handler: ((event: DrawingSelectEvent) => void) | null) => void;
     setMagnetMode: (mode: "none" | "weak" | "strong") => void;
     getMagnetMode: () => "none" | "weak" | "strong";
+    /**
+     * Change the price-scale mode ("linear" | "log" | "percent") and/or invert
+     * the axis. Log maps prices through log10, percent relabels the axis
+     * relative to the first visible bar's close (TradingView behavior), and
+     * invert flips the axis top-to-bottom. Only the main price pane is
+     * affected; indicator panes keep their own scales.
+     */
+    setPriceScale: (options: Partial<PriceScaleOptions>) => void;
+    getPriceScale: () => PriceScaleOptions;
     cancelDrawing: () => boolean;
     setTradeMarkers: (markers: TradeMarkerOptions[]) => void;
     onDrawingHover: (handler: ((event: DrawingHoverEvent) => void) | null) => void;
@@ -657,8 +666,15 @@ interface ChartSavedState {
     drawings: DrawingObjectOptions[];
     indicators: IndicatorInstanceOptions[];
     magnetMode: "none" | "weak" | "strong";
+    /** Optional for backward compatibility with pre-0.1.137 blobs. */
+    priceScale?: PriceScaleOptions;
     drawingDefaults: Partial<Record<DrawingToolType, DrawingDefaults>>;
 }
+type PriceScaleMode = "linear" | "log" | "percent";
+interface PriceScaleOptions {
+    mode: PriceScaleMode;
+    inverted: boolean;
+}
 
 interface ScriptIndicatorInputDef {
     key: string;
@@ -706,6 +722,45 @@ interface ScriptComputeResult {
     guides?: number[];
     decimals?: number;
 }
+interface ScriptInputOptions {
+    /** Stable settings key; defaults to a slug of the label. */
+    key?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+}
+declare const SCRIPT_SOURCE_INPUT_VALUES: readonly ["open", "high", "low", "close", "hl2", "hlc3", "ohlc4"];
+/**
+ * The `input` object passed to script top level. In value mode it resolves
+ * each declaration against the current settings; in recording mode it
+ * additionally appends every declaration to `registry`. Keys are assigned
+ * deterministically (same order both modes), so values always line up with
+ * the extracted schema.
+ */
+declare const createScriptInputHelper: (values: Record<string, unknown> | null, registry: ScriptIndicatorInputDef[] | null) => Readonly<{
+    int: (label: string, defaultValue: number, options?: ScriptInputOptions) => number;
+    float: (label: string, defaultValue: number, options?: ScriptInputOptions) => number;
+    bool: (label: string, defaultValue?: boolean, options?: ScriptInputOptions) => boolean;
+    color: (label: string, defaultValue: string, options?: ScriptInputOptions) => string;
+    string: (label: string, defaultValue?: string, options?: ScriptInputOptions) => string;
+    select: (label: string, defaultValue: string, choices: ReadonlyArray<string | {
+        value: string;
+        label: string;
+    }>, options?: ScriptInputOptions) => string;
+    source: (label?: string, defaultValue?: string, options?: ScriptInputOptions) => string;
+}>;
+type ScriptInputHelper = ReturnType<typeof createScriptInputHelper>;
+/**
+ * Discover a script's Pine-style `input.*` declarations by running its top
+ * level with a recording helper. Returns the declared schema (empty when the
+ * script declares nothing) plus a compile/runtime error message when the
+ * script is broken. Runs under the standard execution guard, so an infinite
+ * top-level loop returns a budget error instead of hanging the caller.
+ */
+declare const extractScriptInputs: (source: string) => {
+    inputs: ScriptIndicatorInputDef[];
+    error: string | null;
+};
 /**
  * Compile-check a script without registering it: returns an error message, or
  * `null` when the script compiles. Runs with the same execution guard as the
@@ -726,4 +781,4 @@ declare const compileScriptIndicator: (definition: ScriptIndicatorDefinition) =>
 
 declare function createChart(element: HTMLElement, options?: ChartOptions): ChartInstance;
 
-export { type AxisOptions, type BuiltInIndicatorInfo, type ChartClickEvent, type ChartInstance, type ChartOptions, type ChartSavedState, type ChartType, type CrosshairMoveEvent, type CrosshairOptions, type CrosshairPriceActionEvent, type DashPatternOptions, type DrawingDefaults, type DrawingHoverEvent, type DrawingObjectOptions, type DrawingPoint, type DrawingSelectEvent, type DrawingToolType, FIB_DEFAULT_PALETTE, type GridOptions, type IndicatorInstanceOptions, type IndicatorPane, type IndicatorPaneActionEvent, type IndicatorPaneAxisOptions, type IndicatorPaneGuideLine, type IndicatorPaneHeightChangeEvent, type IndicatorPaneRenderInfo, type IndicatorPaneValue, type IndicatorPaneValueLabel, type IndicatorPlugin, type IndicatorRenderContext, type LabelsOptions, type OhlcDataPoint, type OrderActionButton, type OrderActionEvent, type OrderLineOptions, POSITION_DEFAULT_COLORS, type PriceLineOptions, type ScriptComputeResult, type ScriptIndicatorDefinition, type ScriptIndicatorInputDef, type ScriptPlotSpec, type TickerLineOptions, type TradeMarkerOptions, type ViewportState, type WatermarkOptions, compileScriptIndicator, createChart, validateScriptSource };
+export { type AxisOptions, type BuiltInIndicatorInfo, type ChartClickEvent, type ChartInstance, type ChartOptions, type ChartSavedState, type ChartType, type CrosshairMoveEvent, type CrosshairOptions, type CrosshairPriceActionEvent, type DashPatternOptions, type DrawingDefaults, type DrawingHoverEvent, type DrawingObjectOptions, type DrawingPoint, type DrawingSelectEvent, type DrawingToolType, FIB_DEFAULT_PALETTE, type GridOptions, type IndicatorInstanceOptions, type IndicatorPane, type IndicatorPaneActionEvent, type IndicatorPaneAxisOptions, type IndicatorPaneGuideLine, type IndicatorPaneHeightChangeEvent, type IndicatorPaneRenderInfo, type IndicatorPaneValue, type IndicatorPaneValueLabel, type IndicatorPlugin, type IndicatorRenderContext, type LabelsOptions, type OhlcDataPoint, type OrderActionButton, type OrderActionEvent, type OrderLineOptions, POSITION_DEFAULT_COLORS, type PriceLineOptions, type PriceScaleMode, type PriceScaleOptions, SCRIPT_SOURCE_INPUT_VALUES, type ScriptComputeResult, type ScriptIndicatorDefinition, type ScriptIndicatorInputDef, type ScriptInputHelper, type ScriptInputOptions, type ScriptPlotSpec, type TickerLineOptions, type TradeMarkerOptions, type ViewportState, type WatermarkOptions, compileScriptIndicator, createChart, extractScriptInputs, validateScriptSource };