@wicklib/pro 0.0.0-stage → 0.11.0

package/dist/index.cjs

@@ -0,0 +1,1020 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AlertEngine: () => AlertEngine,
+  DepthAggregator: () => DepthAggregator,
+  FootprintAggregator: () => FootprintAggregator,
+  LicenseError: () => LicenseError,
+  PRO_CORE_FEATURES: () => PRO_CORE_FEATURES,
+  PRO_EXTENSIONS: () => PRO_EXTENSIONS,
+  PRO_FEATURES: () => PRO_FEATURES,
+  PRO_VERSION: () => PRO_VERSION,
+  addVolumeProfileOverlay: () => addVolumeProfileOverlay,
+  assertProFeature: () => assertProFeature,
+  computeDepth: () => computeDepth,
+  computeFootprint: () => computeFootprint,
+  computeVolumeProfile: () => computeVolumeProfile,
+  createLicenseContext: () => createLicenseContext,
+  detectAbsorption: () => detectAbsorption,
+  evaluateAlerts: () => evaluateAlerts,
+  getProExtensions: () => getProExtensions,
+  hasProFeature: () => hasProFeature,
+  runBacktest: () => runBacktest,
+  runScriptBacktest: () => runScriptBacktest
+});
+module.exports = __toCommonJS(index_exports);
+
+// package.json
+var package_default = {
+  name: "@wicklib/pro",
+  version: "0.11.0",
+  description: "Wicklib commercial add-on",
+  license: "SEE LICENSE IN LICENSE",
+  type: "module",
+  sideEffects: false,
+  files: [
+    "dist",
+    "README.md"
+  ],
+  main: "./dist/index.cjs",
+  module: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      import: {
+        types: "./dist/index.d.ts",
+        default: "./dist/index.js"
+      },
+      require: {
+        types: "./dist/index.d.cts",
+        default: "./dist/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  engines: {
+    node: ">=24.0.0"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/wicklib/wicklib-pro.git",
+    directory: "packages/pro"
+  },
+  peerDependencies: {
+    "@wicklib/core": "^0.11.0"
+  },
+  scripts: {
+    build: "tsup",
+    typecheck: "tsc --noEmit",
+    test: "vitest run"
+  },
+  devDependencies: {
+    tsup: "^9.0.0",
+    typescript: "^5.9.3",
+    vitest: "^5.0.5"
+  }
+};
+
+// src/version.ts
+var PRO_VERSION = package_default.version;
+
+// src/script/backtest.ts
+var import_core2 = require("@wicklib/core");
+
+// src/strategy/backtest.ts
+var import_core = require("@wicklib/core");
+var DEFAULT_OPTIONS = {
+  feeRate: 0,
+  slippage: 0
+};
+function runBacktest(context, bars, strategy, options) {
+  (0, import_core.assertFeature)(context, "strategy");
+  const initialCapital = options.initialCapital;
+  const feeRate = options.feeRate ?? DEFAULT_OPTIONS.feeRate;
+  const slippage = options.slippage ?? DEFAULT_OPTIONS.slippage;
+  if (!Number.isFinite(initialCapital) || initialCapital <= 0) {
+    throw new import_core.WickError("INVALID_ARGUMENT", "Backtest initialCapital must be positive");
+  }
+  if (!Number.isFinite(feeRate) || feeRate < 0 || feeRate >= 1) {
+    throw new import_core.WickError("INVALID_ARGUMENT", "Backtest feeRate must be in [0, 1)");
+  }
+  if (!Number.isFinite(slippage) || slippage < 0 || slippage >= 1) {
+    throw new import_core.WickError("INVALID_ARGUMENT", "Backtest slippage must be in [0, 1)");
+  }
+  if (typeof strategy !== "function") {
+    throw new import_core.WickError("INVALID_ARGUMENT", "Backtest strategy must be a function");
+  }
+  let cash = initialCapital;
+  let units = 0;
+  let position = 0;
+  let pending = null;
+  let previousTime = Number.NEGATIVE_INFINITY;
+  const fills = [];
+  const equity = [];
+  let peak = initialCapital;
+  let maxDrawdown = 0;
+  for (let index = 0; index < bars.length; index += 1) {
+    const bar = bars[index];
+    if (!Number.isFinite(bar.time) || bar.time <= previousTime || !Number.isFinite(bar.open) || !Number.isFinite(bar.close) || !Number.isFinite(bar.high) || !Number.isFinite(bar.low)) {
+      throw new import_core.WickError("INVALID_DATA", "Backtest bars require ascending finite OHLC values");
+    }
+    previousTime = bar.time;
+    if (pending !== null && pending !== position) {
+      const side = pending > position ? "buy" : "sell";
+      const price = side === "buy" ? bar.open * (1 + slippage) : bar.open * (1 - slippage);
+      const equityAtFill = cash + units * price;
+      const desiredUnits = pending * equityAtFill / price;
+      const quantity = desiredUnits - units;
+      const fee = Math.abs(quantity * price) * feeRate;
+      cash -= quantity * price + fee;
+      units = desiredUnits;
+      position = pending;
+      if (quantity !== 0) {
+        fills.push({ time: bar.time, side, price, quantity, fee });
+      }
+      pending = null;
+    }
+    const markedEquity = cash + units * bar.close;
+    peak = Math.max(peak, markedEquity);
+    if (peak > 0) {
+      maxDrawdown = Math.max(maxDrawdown, (peak - markedEquity) / peak);
+    }
+    equity.push({
+      time: bar.time,
+      cash,
+      units,
+      position,
+      price: bar.close,
+      equity: markedEquity
+    });
+    const signal = strategy({
+      bar,
+      index,
+      position,
+      cash,
+      units,
+      equity: markedEquity
+    });
+    if (signal !== void 0 && signal !== null) {
+      if (signal !== -1 && signal !== 0 && signal !== 1) {
+        throw new import_core.WickError("INVALID_DATA", "Strategy target must be -1, 0, or 1");
+      }
+      pending = signal;
+    }
+  }
+  const finalEquity = equity.at(-1)?.equity ?? initialCapital;
+  return {
+    initialCapital,
+    finalEquity,
+    returnPercent: (finalEquity - initialCapital) / initialCapital * 100,
+    maxDrawdown,
+    fills,
+    equity
+  };
+}
+
+// src/script/backtest.ts
+async function runScriptBacktest(context, script, bars, options) {
+  (0, import_core2.assertFeature)(context, "strategy");
+  if (!script || typeof script.replay !== "function") {
+    throw new import_core2.WickError("INVALID_ARGUMENT", "Script adapter requires a replay function");
+  }
+  if (typeof options.signalPlot !== "string" || options.signalPlot.trim() === "") {
+    throw new import_core2.WickError("INVALID_ARGUMENT", "Script signalPlot must be a non-empty string");
+  }
+  const result = await script.replay(bars);
+  const values = result?.plots?.[options.signalPlot];
+  if (!Array.isArray(values)) {
+    throw new import_core2.WickError("INVALID_DATA", `Script plot not found: ${options.signalPlot}`);
+  }
+  if (values.length !== bars.length) {
+    throw new import_core2.WickError("INVALID_DATA", "Script signal plot length must match the bar count");
+  }
+  if (result.alerts.length > 0 && !result.alertEvents) {
+    throw new import_core2.WickError("INVALID_DATA", "Script alerts are missing their bar events");
+  }
+  const alerts = (result.alertEvents ?? []).map((event) => validateAlert(event));
+  const backtest = runBacktest(
+    context,
+    bars,
+    ({ index }) => {
+      const value = values[index];
+      if (value === null || value === void 0) {
+        return void 0;
+      }
+      if (value !== -1 && value !== 0 && value !== 1) {
+        throw new import_core2.WickError("INVALID_DATA", "Script signal must be -1, 0, 1, or null");
+      }
+      return value;
+    },
+    options
+  );
+  return { ...backtest, alerts };
+}
+function validateAlert(event) {
+  if (!event || !Number.isFinite(event.time) || !Number.isInteger(event.barIndex) || event.barIndex < 0 || typeof event.message !== "string") {
+    throw new import_core2.WickError("INVALID_DATA", "Invalid script alert event");
+  }
+  return { time: event.time, barIndex: event.barIndex, message: event.message };
+}
+
+// src/alerts/engine.ts
+var import_core3 = require("@wicklib/core");
+var SOURCES = /* @__PURE__ */ new Set(["close", "high", "low"]);
+var AlertEngine = class {
+  rules;
+  previous = /* @__PURE__ */ new Map();
+  lastTime = Number.NEGATIVE_INFINITY;
+  constructor(context, rules) {
+    (0, import_core3.assertFeature)(context, "alerts");
+    const ids = /* @__PURE__ */ new Set();
+    for (const rule of rules) {
+      if (!rule || typeof rule.id !== "string" || rule.id.trim() === "" || !Number.isFinite(rule.price) || rule.direction !== "above" && rule.direction !== "below" && rule.direction !== "cross" || rule.source !== void 0 && !SOURCES.has(rule.source)) {
+        throw new import_core3.WickError("INVALID_ARGUMENT", "Invalid price alert rule");
+      }
+      if (ids.has(rule.id)) {
+        throw new import_core3.WickError("INVALID_ARGUMENT", `Duplicate alert rule id: ${rule.id}`);
+      }
+      ids.add(rule.id);
+    }
+    this.rules = rules.map((rule) => ({ ...rule }));
+  }
+  /**
+   * Consumes one closed bar and returns the alerts triggered by that bar.
+   */
+  update(bar) {
+    if (!Number.isFinite(bar.time)) {
+      throw new import_core3.WickError("INVALID_DATA", "Alert bar requires a finite time");
+    }
+    if (bar.time <= this.lastTime) {
+      throw new import_core3.WickError("INVALID_DATA", "Alert bars must have increasing times");
+    }
+    this.lastTime = bar.time;
+    const triggers = [];
+    for (const rule of this.rules) {
+      const source = rule.source ?? "close";
+      const value = source === "close" ? bar.close : source === "high" ? bar.high : bar.low;
+      const previous = this.previous.get(rule.id);
+      if (previous !== void 0) {
+        if (rule.direction === "above" && previous <= rule.price && value > rule.price) {
+          triggers.push(trigger(rule, bar, value, "above"));
+        } else if (rule.direction === "below" && previous >= rule.price && value < rule.price) {
+          triggers.push(trigger(rule, bar, value, "below"));
+        } else if (rule.direction === "cross") {
+          if (previous <= rule.price && value > rule.price) {
+            triggers.push(trigger(rule, bar, value, "above"));
+          } else if (previous >= rule.price && value < rule.price) {
+            triggers.push(trigger(rule, bar, value, "below"));
+          }
+        }
+      }
+      this.previous.set(rule.id, value);
+    }
+    return triggers;
+  }
+  /**
+   * Clears previous values so the next bar initializes state again.
+   */
+  reset() {
+    this.previous.clear();
+    this.lastTime = Number.NEGATIVE_INFINITY;
+  }
+};
+function evaluateAlerts(context, rules, bars) {
+  const engine = new AlertEngine(context, rules);
+  const triggers = [];
+  for (const bar of bars) {
+    triggers.push(...engine.update(bar));
+  }
+  return triggers;
+}
+function trigger(rule, bar, value, direction) {
+  return {
+    ruleId: rule.id,
+    time: bar.time,
+    direction,
+    price: rule.price,
+    value,
+    bar
+  };
+}
+
+// src/analytics/absorption.ts
+var import_core6 = require("@wicklib/core");
+
+// src/analytics/depth.ts
+var import_core4 = require("@wicklib/core");
+var DEFAULT_IMBALANCE_RATIO = 2;
+var DepthAggregator = class {
+  options;
+  bars = /* @__PURE__ */ new Map();
+  lastTime = Number.NEGATIVE_INFINITY;
+  constructor(context, options) {
+    (0, import_core4.assertFeature)(context, "orderflow");
+    if (options.priceStep === void 0 || !Number.isFinite(options.priceStep) || options.priceStep <= 0) {
+      throw new import_core4.WickError("INVALID_ARGUMENT", "Depth priceStep must be a positive number");
+    }
+    const ratio = options.imbalanceRatio ?? DEFAULT_IMBALANCE_RATIO;
+    if (!Number.isFinite(ratio) || ratio < 1) {
+      throw new import_core4.WickError("INVALID_ARGUMENT", "Depth imbalanceRatio must be at least 1");
+    }
+    this.options = { priceStep: options.priceStep, imbalanceRatio: ratio };
+  }
+  /**
+   * Adds or replaces one complete snapshot and returns its aggregated bar.
+   */
+  push(snapshot) {
+    if (!Number.isFinite(snapshot.time) || !Array.isArray(snapshot.bids) || !Array.isArray(snapshot.asks)) {
+      throw new import_core4.WickError("INVALID_DATA", "Depth snapshots require finite time, bids, and asks");
+    }
+    if (snapshot.time < this.lastTime) {
+      throw new import_core4.WickError("INVALID_DATA", "Depth snapshots must be in non-decreasing time order");
+    }
+    this.lastTime = snapshot.time;
+    const levels = /* @__PURE__ */ new Map();
+    for (const [side, entries] of [
+      ["bid", snapshot.bids],
+      ["ask", snapshot.asks]
+    ]) {
+      for (const entry of entries) {
+        if (!Number.isFinite(entry.price) || !Number.isFinite(entry.size) || entry.size < 0) {
+          throw new import_core4.WickError(
+            "INVALID_DATA",
+            "Depth levels require finite price and non-negative size"
+          );
+        }
+        const price = Math.floor(entry.price / this.options.priceStep) * this.options.priceStep;
+        let level = levels.get(price);
+        if (!level) {
+          level = { bid: 0, ask: 0 };
+          levels.set(price, level);
+        }
+        if (side === "bid") level.bid += entry.size;
+        else level.ask += entry.size;
+      }
+    }
+    let bidSize = 0;
+    let askSize = 0;
+    const sortedLevels = [...levels.entries()].sort(([first], [second]) => first - second).map(([priceLow, level]) => {
+      bidSize += level.bid;
+      askSize += level.ask;
+      return {
+        priceLow,
+        priceHigh: priceLow + this.options.priceStep,
+        bidSize: level.bid,
+        askSize: level.ask,
+        totalSize: level.bid + level.ask,
+        delta: level.bid - level.ask,
+        imbalance: imbalanceOf(level.bid, level.ask, this.options.imbalanceRatio)
+      };
+    });
+    const bar = {
+      time: snapshot.time,
+      priceLow: sortedLevels[0]?.priceLow ?? 0,
+      priceHigh: sortedLevels.at(-1)?.priceHigh ?? 0,
+      bidSize,
+      askSize,
+      totalSize: bidSize + askSize,
+      delta: bidSize - askSize,
+      imbalance: imbalanceOf(bidSize, askSize, this.options.imbalanceRatio),
+      levels: sortedLevels
+    };
+    this.bars.set(snapshot.time, bar);
+    return bar;
+  }
+  /**
+   * Returns the latest snapshot at or before a time.
+   */
+  latest(time = Number.POSITIVE_INFINITY) {
+    const eligible = [...this.bars.values()].filter((bar) => bar.time <= time).sort((first, second) => first.time - second.time);
+    return eligible.at(-1) ?? null;
+  }
+  /**
+   * Returns all snapshots in ascending time order.
+   */
+  getBars() {
+    return [...this.bars.values()].sort((first, second) => first.time - second.time);
+  }
+  /**
+   * Clears all snapshots and the streaming order guard.
+   */
+  reset() {
+    this.bars.clear();
+    this.lastTime = Number.NEGATIVE_INFINITY;
+  }
+};
+function computeDepth(context, snapshots, options) {
+  const aggregator = new DepthAggregator(context, options);
+  for (const snapshot of snapshots) {
+    aggregator.push(snapshot);
+  }
+  return aggregator.getBars();
+}
+function imbalanceOf(bid, ask, ratio) {
+  if (bid === 0 && ask === 0) return null;
+  if (ask === 0) return "bid";
+  if (bid === 0) return "ask";
+  if (bid >= ask * ratio) return "bid";
+  if (ask >= bid * ratio) return "ask";
+  return null;
+}
+
+// src/analytics/orderflow.ts
+var import_core5 = require("@wicklib/core");
+var DEFAULT_BUCKET_MS = 6e4;
+var DEFAULT_IMBALANCE_RATIO2 = 3;
+var FootprintAggregator = class {
+  options;
+  levels = /* @__PURE__ */ new Map();
+  lastTradeTime = Number.NEGATIVE_INFINITY;
+  constructor(context, options) {
+    (0, import_core5.assertFeature)(context, "orderflow");
+    this.options = resolveOptions(options);
+  }
+  /**
+   * Adds one trade and returns the updated bar for its time bucket.
+   */
+  push(trade) {
+    this.validateTrade(trade);
+    if (trade.time < this.lastTradeTime) {
+      throw new import_core5.WickError("INVALID_DATA", "Streaming trades must be in non-decreasing time order");
+    }
+    this.lastTradeTime = trade.time;
+    const time = Math.floor(trade.time / this.options.bucketMs) * this.options.bucketMs;
+    const price = Math.floor(trade.price / this.options.priceStep) * this.options.priceStep;
+    let levels = this.levels.get(time);
+    if (!levels) {
+      levels = /* @__PURE__ */ new Map();
+      this.levels.set(time, levels);
+    }
+    let level = levels.get(price);
+    if (!level) {
+      level = { buy: 0, sell: 0 };
+      levels.set(price, level);
+    }
+    if (trade.side === "buy") level.buy += trade.size;
+    else level.sell += trade.size;
+    return this.buildBar(time);
+  }
+  /**
+   * Adds multiple trades in input order.
+   */
+  pushMany(trades) {
+    for (const trade of trades) {
+      this.push(trade);
+    }
+    return this.getBars();
+  }
+  /**
+   * Returns a bar by bucket start time, or any time inside that bucket.
+   */
+  getBar(time) {
+    const bucket = Math.floor(time / this.options.bucketMs) * this.options.bucketMs;
+    return this.buildBar(bucket);
+  }
+  /**
+   * Returns all completed/current buckets in ascending time order.
+   */
+  getBars() {
+    return [...this.levels.keys()].sort((first, second) => first - second).map((time) => this.buildBar(time)).filter((bar) => bar !== null);
+  }
+  /**
+   * Clears all trades and resets the streaming order guard.
+   */
+  reset() {
+    this.levels.clear();
+    this.lastTradeTime = Number.NEGATIVE_INFINITY;
+  }
+  buildBar(time) {
+    const levels = this.levels.get(time);
+    if (!levels) {
+      return null;
+    }
+    let buyVolume = 0;
+    let sellVolume = 0;
+    const sortedLevels = [...levels.entries()].sort(([first], [second]) => first - second).map(([priceLow, volumes]) => {
+      buyVolume += volumes.buy;
+      sellVolume += volumes.sell;
+      return {
+        priceLow,
+        priceHigh: priceLow + this.options.priceStep,
+        buyVolume: volumes.buy,
+        sellVolume: volumes.sell,
+        totalVolume: volumes.buy + volumes.sell,
+        delta: volumes.buy - volumes.sell,
+        imbalance: imbalanceOf2(volumes.buy, volumes.sell, this.options.imbalanceRatio)
+      };
+    });
+    return {
+      time,
+      priceLow: sortedLevels[0]?.priceLow ?? 0,
+      priceHigh: sortedLevels.at(-1)?.priceHigh ?? 0,
+      buyVolume,
+      sellVolume,
+      totalVolume: buyVolume + sellVolume,
+      delta: buyVolume - sellVolume,
+      levels: sortedLevels
+    };
+  }
+  validateTrade(trade) {
+    if (!Number.isFinite(trade.time) || !Number.isFinite(trade.price) || !Number.isFinite(trade.size) || trade.size <= 0 || trade.price < 0 || trade.side !== "buy" && trade.side !== "sell") {
+      throw new import_core5.WickError("INVALID_DATA", "Trade ticks require finite time, price, size, and side");
+    }
+  }
+};
+function computeFootprint(context, trades, options) {
+  const aggregator = new FootprintAggregator(context, options);
+  return aggregator.pushMany([...trades].sort((first, second) => first.time - second.time));
+}
+function resolveOptions(options) {
+  const bucketMs = options.bucketMs ?? DEFAULT_BUCKET_MS;
+  const priceStep = options.priceStep;
+  const imbalanceRatio = options.imbalanceRatio ?? DEFAULT_IMBALANCE_RATIO2;
+  if (!Number.isInteger(bucketMs) || bucketMs <= 0) {
+    throw new import_core5.WickError("INVALID_ARGUMENT", "Footprint bucketMs must be a positive integer");
+  }
+  if (priceStep === void 0 || !Number.isFinite(priceStep) || priceStep <= 0) {
+    throw new import_core5.WickError("INVALID_ARGUMENT", "Footprint priceStep must be a positive number");
+  }
+  if (!Number.isFinite(imbalanceRatio) || imbalanceRatio < 1) {
+    throw new import_core5.WickError("INVALID_ARGUMENT", "Footprint imbalanceRatio must be at least 1");
+  }
+  return { bucketMs, priceStep, imbalanceRatio };
+}
+function imbalanceOf2(buy, sell, ratio) {
+  if (buy === 0 && sell === 0) return null;
+  if (sell === 0) return "buy";
+  if (buy === 0) return "sell";
+  if (buy >= sell * ratio) return "buy";
+  if (sell >= buy * ratio) return "sell";
+  return null;
+}
+
+// src/analytics/absorption.ts
+var DEFAULT_BUCKET_MS2 = 6e4;
+var DEFAULT_ABSORPTION_RATIO = 2;
+function detectAbsorption(context, trades, snapshots, options) {
+  (0, import_core6.assertFeature)(context, "orderflow");
+  const bucketMs = options.bucketMs ?? DEFAULT_BUCKET_MS2;
+  const absorptionRatio = options.absorptionRatio ?? DEFAULT_ABSORPTION_RATIO;
+  const priceStep = options.priceStep;
+  if (!Number.isInteger(bucketMs) || bucketMs <= 0) {
+    throw new import_core6.WickError("INVALID_ARGUMENT", "Absorption bucketMs must be a positive integer");
+  }
+  if (!Number.isFinite(absorptionRatio) || absorptionRatio < 1) {
+    throw new import_core6.WickError("INVALID_ARGUMENT", "Absorption ratio must be at least 1");
+  }
+  if (priceStep === void 0 || !Number.isFinite(priceStep) || priceStep <= 0) {
+    throw new import_core6.WickError("INVALID_ARGUMENT", "Absorption priceStep must be a positive number");
+  }
+  const footprints = new FootprintAggregator(context, {
+    bucketMs,
+    priceStep
+  });
+  for (const trade of [...trades].sort((first, second) => first.time - second.time)) {
+    footprints.push(trade);
+  }
+  const depth = new DepthAggregator(context, { priceStep });
+  for (const snapshot of [...snapshots].sort((first, second) => first.time - second.time)) {
+    depth.push(snapshot);
+  }
+  const events = [];
+  for (const bar of footprints.getBars()) {
+    const book = depth.latest(bar.time + bucketMs - 1);
+    if (!book) {
+      continue;
+    }
+    const depthByPrice = new Map(book.levels.map((level) => [level.priceLow, level]));
+    for (const level of bar.levels) {
+      const depthLevel = depthByPrice.get(level.priceLow);
+      if (!depthLevel) {
+        continue;
+      }
+      const candidates = [
+        { side: "buy", aggressive: level.buyVolume, passive: depthLevel.askSize },
+        { side: "sell", aggressive: level.sellVolume, passive: depthLevel.bidSize }
+      ];
+      for (const candidate of candidates) {
+        if (candidate.passive <= 0 || candidate.aggressive <= 0) {
+          continue;
+        }
+        const ratio = candidate.aggressive / candidate.passive;
+        if (ratio >= absorptionRatio) {
+          events.push({
+            time: bar.time,
+            priceLow: level.priceLow,
+            priceHigh: level.priceHigh,
+            side: candidate.side,
+            aggressiveVolume: candidate.aggressive,
+            passiveVolume: candidate.passive,
+            ratio
+          });
+        }
+      }
+    }
+  }
+  return events;
+}
+
+// src/analytics/volume-profile.ts
+var import_core7 = require("@wicklib/core");
+var DEFAULT_OPTIONS2 = {
+  bins: 24,
+  valueArea: 0.7,
+  distribution: "uniform"
+};
+function computeVolumeProfile(context, bars, options = {}) {
+  (0, import_core7.assertFeature)(context, "volume-profile");
+  const binCount = options.bins ?? DEFAULT_OPTIONS2.bins;
+  const valueAreaFraction = options.valueArea ?? DEFAULT_OPTIONS2.valueArea;
+  const distribution = options.distribution ?? DEFAULT_OPTIONS2.distribution;
+  if (!Number.isInteger(binCount) || binCount <= 0 || binCount > 2e3) {
+    throw new import_core7.WickError("INVALID_ARGUMENT", "Volume profile bins must be between 1 and 2000");
+  }
+  if (!Number.isFinite(valueAreaFraction) || valueAreaFraction <= 0 || valueAreaFraction > 1) {
+    throw new import_core7.WickError("INVALID_ARGUMENT", "Volume profile valueArea must be in (0, 1]");
+  }
+  let min;
+  let max;
+  if (options.priceRange) {
+    min = options.priceRange.min;
+    max = options.priceRange.max;
+    if (!Number.isFinite(min) || !Number.isFinite(max) || max <= min) {
+      throw new import_core7.WickError("INVALID_ARGUMENT", "Volume profile priceRange must have max > min");
+    }
+  } else {
+    min = Number.POSITIVE_INFINITY;
+    max = Number.NEGATIVE_INFINITY;
+    for (const bar of bars) {
+      if (!Number.isFinite(bar.volume) || bar.volume <= 0) continue;
+      min = Math.min(min, bar.low);
+      max = Math.max(max, bar.high);
+    }
+    if (!Number.isFinite(min) || !Number.isFinite(max)) {
+      throw new import_core7.WickError("INVALID_DATA", "Volume profile requires bars with volume");
+    }
+    if (max <= min) {
+      max = min + 1;
+    }
+  }
+  const width = (max - min) / binCount;
+  const volumes = new Array(binCount).fill(0);
+  for (const bar of bars) {
+    const volume = bar.volume;
+    if (!Number.isFinite(volume) || volume === void 0 || volume <= 0) continue;
+    if (distribution === "close") {
+      const index = clampIndex(Math.floor((bar.close - min) / width), binCount);
+      volumes[index] += volume;
+      continue;
+    }
+    const low = Math.max(bar.low, min);
+    const high = Math.min(bar.high, max);
+    if (high <= low) {
+      const index = clampIndex(Math.floor((bar.close - min) / width), binCount);
+      volumes[index] += volume;
+      continue;
+    }
+    const first = clampIndex(Math.floor((low - min) / width), binCount);
+    const last = clampIndex(Math.floor((high - min) / width), binCount);
+    let assigned = 0;
+    for (let index = first; index <= last; index += 1) {
+      const binLow = min + index * width;
+      const binHigh = index === binCount - 1 ? max : binLow + width;
+      const overlap = Math.max(0, Math.min(high, binHigh) - Math.max(low, binLow));
+      const part = index === last ? volume - assigned : volume * overlap / (high - low);
+      volumes[index] += part;
+      assigned += part;
+    }
+  }
+  const totalVolume = volumes.reduce((sum, value) => sum + value, 0);
+  if (!(totalVolume > 0)) {
+    throw new import_core7.WickError("INVALID_DATA", "Volume profile requires bars with volume");
+  }
+  const bins = volumes.map((volume, index) => ({
+    index,
+    priceLow: min + index * width,
+    priceHigh: index === binCount - 1 ? max : min + (index + 1) * width,
+    priceMid: min + (index + 0.5) * width,
+    volume
+  }));
+  let pocIndex = 0;
+  for (let index = 1; index < bins.length; index += 1) {
+    if (bins[index].volume > bins[pocIndex].volume) {
+      pocIndex = index;
+    }
+  }
+  const target = totalVolume * valueAreaFraction;
+  let lowIndex = pocIndex;
+  let highIndex = pocIndex;
+  let valueVolume = bins[pocIndex].volume;
+  while (valueVolume < target && (lowIndex > 0 || highIndex < bins.length - 1)) {
+    const lower = lowIndex > 0 ? bins[lowIndex - 1].volume : -1;
+    const upper = highIndex < bins.length - 1 ? bins[highIndex + 1].volume : -1;
+    if (upper > lower) {
+      highIndex += 1;
+      valueVolume += bins[highIndex].volume;
+    } else {
+      lowIndex -= 1;
+      valueVolume += bins[lowIndex].volume;
+    }
+  }
+  return {
+    bins,
+    range: { min, max },
+    totalVolume,
+    poc: bins[pocIndex] ?? null,
+    valueArea: {
+      low: bins[lowIndex].priceLow,
+      high: bins[highIndex].priceHigh,
+      volume: valueVolume
+    }
+  };
+}
+function clampIndex(value, count) {
+  return Math.max(0, Math.min(count - 1, value));
+}
+
+// src/analytics/volume-profile-overlay.ts
+var DEFAULT_COLORS = {
+  bar: "#2962ff",
+  valueArea: "#2962ff",
+  poc: "#f0b90b"
+};
+var overlayCounter = 0;
+function addVolumeProfileOverlay(context, chart, bars, options = {}) {
+  const profile = computeVolumeProfile(context, bars, options);
+  overlayCounter += 1;
+  const id = options.id ?? `com.wicklib.volume-profile-${overlayCounter}`;
+  const side = options.side ?? "left";
+  const widthRatio = clamp(options.widthRatio ?? 0.22, 0.02, 0.9);
+  const colors = { ...DEFAULT_COLORS, ...options.colors };
+  const maxVolume = Math.max(0, ...profile.bins.map((bin) => bin.volume));
+  const valueArea = profile.valueArea;
+  const overlay = chart.addOverlay({
+    id,
+    ...options.paneId ? { paneId: options.paneId } : {},
+    draw(canvas, frame) {
+      if (maxVolume <= 0) {
+        return;
+      }
+      const maxWidth = frame.plot.width * widthRatio;
+      for (const bin of profile.bins) {
+        if (bin.volume <= 0) {
+          continue;
+        }
+        const top = frame.priceToY(bin.priceHigh);
+        const bottom = frame.priceToY(bin.priceLow);
+        const height = Math.max(1, Math.abs(bottom - top));
+        const width = bin.volume / maxVolume * maxWidth;
+        const x = side === "left" ? frame.plot.left : frame.plot.right - width;
+        const inValueArea = valueArea !== null && bin.priceMid >= valueArea.low && bin.priceMid <= valueArea.high;
+        const isPoc = profile.poc?.index === bin.index;
+        canvas.globalAlpha = isPoc ? 0.55 : inValueArea ? 0.4 : 0.22;
+        canvas.fillStyle = isPoc ? colors.poc : inValueArea ? colors.valueArea : colors.bar;
+        canvas.fillRect(x, Math.min(top, bottom), width, height);
+      }
+      canvas.globalAlpha = 1;
+    }
+  });
+  return {
+    id: overlay.id,
+    paneId: overlay.paneId,
+    requestRender: overlay.requestRender,
+    remove: overlay.remove,
+    profile
+  };
+}
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+
+// src/features.ts
+var PRO_FEATURES = [
+  "orderflow",
+  "volume-profile",
+  "panes",
+  "layouts",
+  "strategy",
+  "alerts",
+  "script-functions"
+];
+var PRO_CORE_FEATURES = PRO_FEATURES;
+
+// src/extensions.ts
+var NAMES = {
+  orderflow: "Orderflow",
+  "volume-profile": "Volume Profile",
+  panes: "Panes",
+  layouts: "Layouts",
+  strategy: "Strategy",
+  alerts: "Alerts",
+  "script-functions": "Script Functions"
+};
+var PRO_EXTENSIONS = Object.freeze(
+  [
+    "orderflow",
+    "volume-profile",
+    "panes",
+    "layouts",
+    "strategy",
+    "alerts",
+    "script-functions"
+  ].map(
+    (feature) => Object.freeze({
+      kind: "feature",
+      feature,
+      meta: Object.freeze({
+        id: `com.wicklib.${feature}`,
+        name: NAMES[feature],
+        version: PRO_VERSION,
+        license: "pro"
+      })
+    })
+  )
+);
+function getProExtensions(context) {
+  return PRO_EXTENSIONS.filter((extension) => context.hasFeature(extension.feature));
+}
+
+// src/license/verify.ts
+var LicenseError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "LicenseError";
+    this.code = code;
+  }
+};
+async function createLicenseContext(token, options) {
+  const parts = token.split(".");
+  if (parts.length !== 3) {
+    throw new LicenseError("INVALID_TOKEN", "License token must have three segments");
+  }
+  const [headerPart, payloadPart, signaturePart] = parts;
+  const header = decodeJson(headerPart, "INVALID_TOKEN");
+  if (header.alg !== "Ed25519") {
+    throw new LicenseError(
+      "UNSUPPORTED_ALGORITHM",
+      `Unsupported license algorithm: ${header.alg}`
+    );
+  }
+  const payload = decodeJson(payloadPart, "INVALID_PAYLOAD");
+  validatePayload(payload);
+  if (header.kid && header.kid !== payload.kid) {
+    throw new LicenseError("INVALID_PAYLOAD", "License header and payload kid do not match");
+  }
+  const publicKey = options.publicKeys[payload.kid];
+  if (!publicKey) {
+    throw new LicenseError("UNKNOWN_KID", `Unknown license key id: ${payload.kid}`);
+  }
+  const product = options.product ?? "wicklib-pro";
+  if (payload.product !== product) {
+    throw new LicenseError(
+      "WRONG_PRODUCT",
+      `License is for ${payload.product}, expected ${product}`
+    );
+  }
+  const now = options.now?.() ?? Math.floor(Date.now() / 1e3);
+  if (payload.exp <= now) {
+    throw new LicenseError("EXPIRED", "License has expired");
+  }
+  if (payload.domains.length > 0) {
+    if (!options.domain) {
+      throw new LicenseError("DOMAIN_REQUIRED", "This license requires a domain");
+    }
+    if (!domainAllowed(payload.domains, options.domain)) {
+      throw new LicenseError(
+        "DOMAIN_NOT_ALLOWED",
+        `Domain is not covered by the license: ${options.domain}`
+      );
+    }
+  }
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle) {
+    throw new LicenseError("CRYPTO_UNAVAILABLE", "Web Crypto is not available");
+  }
+  let key;
+  try {
+    const raw = base64UrlDecode(publicKey);
+    key = await subtle.importKey("raw", raw, { name: "Ed25519" }, false, ["verify"]);
+  } catch (error) {
+    throw new LicenseError(
+      "INVALID_PAYLOAD",
+      error instanceof Error ? `Invalid license public key: ${error.message}` : "Invalid license public key"
+    );
+  }
+  let valid = false;
+  try {
+    valid = await subtle.verify(
+      { name: "Ed25519" },
+      key,
+      base64UrlDecode(signaturePart),
+      new TextEncoder().encode(`${headerPart}.${payloadPart}`)
+    );
+  } catch (error) {
+    throw new LicenseError(
+      "SIGNATURE_INVALID",
+      error instanceof Error ? `Signature verification failed: ${error.message}` : "Signature verification failed"
+    );
+  }
+  if (!valid) {
+    throw new LicenseError("SIGNATURE_INVALID", "License signature is invalid");
+  }
+  const granted = new Set(payload.features);
+  return { hasFeature: (feature) => granted.has(feature) };
+}
+function validatePayload(payload) {
+  if (!payload || typeof payload.product !== "string" || typeof payload.plan !== "string" || typeof payload.kid !== "string" || payload.kid.length === 0 || !Number.isFinite(payload.exp) || !Number.isInteger(payload.seats) || payload.seats < 1 || !Array.isArray(payload.domains) || payload.domains.some((domain) => typeof domain !== "string") || !Array.isArray(payload.features) || payload.features.some((feature) => typeof feature !== "string")) {
+    throw new LicenseError("INVALID_PAYLOAD", "License payload is invalid");
+  }
+}
+function domainAllowed(domains, host) {
+  const normalized = normalizeDomain(host);
+  return domains.some(
+    (domain) => domain === "*" || normalizeDomain(domain) === normalized
+  );
+}
+function normalizeDomain(value) {
+  try {
+    const url = new URL(value.includes("://") ? value : `https://${value}`);
+    return url.hostname.toLowerCase();
+  } catch {
+    return value.toLowerCase();
+  }
+}
+function decodeJson(value, code) {
+  try {
+    return JSON.parse(new TextDecoder().decode(base64UrlDecode(value)));
+  } catch {
+    throw new LicenseError(code, "License token contains invalid base64url or JSON");
+  }
+}
+function base64UrlDecode(value) {
+  const normalized = value.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = normalized.padEnd(Math.ceil(normalized.length / 4) * 4, "=");
+  try {
+    const binary = atob(padded);
+    const bytes = new Uint8Array(new ArrayBuffer(binary.length));
+    for (let index = 0; index < binary.length; index += 1) {
+      bytes[index] = binary.charCodeAt(index);
+    }
+    return bytes;
+  } catch {
+    throw new LicenseError("INVALID_TOKEN", "License token contains invalid base64url");
+  }
+}
+
+// src/index.ts
+var import_core8 = require("@wicklib/core");
+function hasProFeature(context, feature) {
+  return context.hasFeature(feature);
+}
+function assertProFeature(context, feature) {
+  (0, import_core8.assertFeature)(context, feature);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AlertEngine,
+  DepthAggregator,
+  FootprintAggregator,
+  LicenseError,
+  PRO_CORE_FEATURES,
+  PRO_EXTENSIONS,
+  PRO_FEATURES,
+  PRO_VERSION,
+  addVolumeProfileOverlay,
+  assertProFeature,
+  computeDepth,
+  computeFootprint,
+  computeVolumeProfile,
+  createLicenseContext,
+  detectAbsorption,
+  evaluateAlerts,
+  getProExtensions,
+  hasProFeature,
+  runBacktest,
+  runScriptBacktest
+});
+//# sourceMappingURL=index.cjs.map