tradeblocks-mcp 3.0.1 → 3.0.2

package/{dist/chunk-CCITWAAI.js → server/chunk-PNKG7RY7.js}

@@ -1,9 +1,10 @@
+#!/usr/bin/env node
 import {
   getSofrRateByKey
-} from "./chunk-QTTR7AAW.js";
+} from "./chunk-72GKJE2U.js";
 import {
   loadMddsProtoRoot
-} from "./chunk-FGZH632F.js";
+} from "./chunk-FBNDMCT5.js";
 
 // src/utils/providers/massive.ts
 import { z } from "zod";
@@ -751,18 +752,18 @@ var MassiveProvider = class {
     const s3Path = `s3massive:flatfiles/${assetPath}/${year}/${month}/${date}.csv.gz`;
     const tmpDir = assetClass === "index" ? "/tmp/massive-flat-index" : "/tmp/massive-flat";
     const localPath = `${tmpDir}/${date}.csv.gz`;
-    const { existsSync, mkdirSync } = await import("fs");
+    const { existsSync: existsSync2, mkdirSync } = await import("fs");
     const { execFile } = await import("child_process");
     const { promisify } = await import("util");
     const execFileAsync = promisify(execFile);
     mkdirSync(tmpDir, { recursive: true });
-    if (existsSync(localPath)) return localPath;
+    if (existsSync2(localPath)) return localPath;
     try {
       await execFileAsync("rclone", ["copy", s3Path, `${tmpDir}/`], { timeout: 12e4 });
     } catch {
       return null;
     }
-    return existsSync(localPath) ? localPath : null;
+    return existsSync2(localPath) ? localPath : null;
   }
   async downloadBulkData(options) {
     const { date, dataset, assetClass, tickers, outputPath } = options;
@@ -1385,7 +1386,7 @@ var ThetaMddsClient = class {
   fetchImpl;
   loadGrpcPackage;
   constructor(env = process.env, fetchImpl = fetch, loadGrpcPackage = async () => {
-    const { loadMddsGrpcPackage } = await import("./proto-3HZTCWK4.js");
+    const { loadMddsGrpcPackage } = await import("./proto-DWRZJO4E.js");
     return loadMddsGrpcPackage();
   }) {
     this.env = env;
@@ -1527,22 +1528,23 @@ var PRICE_TYPE_FACTORS = [
   1e9
 ];
 var ET_MINUTE_PATTERN = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}$/;
+var ET_MINUTE_FORMAT = new Intl.DateTimeFormat("en-CA", {
+  timeZone: "America/New_York",
+  year: "numeric",
+  month: "2-digit",
+  day: "2-digit",
+  hour: "2-digit",
+  minute: "2-digit",
+  hour12: false,
+  hourCycle: "h23"
+});
 function thetaPriceToNumber(price) {
   return price.type === 0 ? Number.NaN : price.value * PRICE_TYPE_FACTORS[price.type];
 }
 function thetaTimestampToEtMinute(value) {
   if (typeof value === "string" && ET_MINUTE_PATTERN.test(value)) return value;
   const date = value instanceof Date ? value : new Date(value);
-  const parts = new Intl.DateTimeFormat("en-CA", {
-    timeZone: "America/New_York",
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit",
-    hour: "2-digit",
-    minute: "2-digit",
-    hour12: false,
-    hourCycle: "h23"
-  }).formatToParts(date);
+  const parts = ET_MINUTE_FORMAT.formatToParts(date);
   const get = (type) => parts.find((part) => part.type === type)?.value ?? "";
   return `${get("year")}-${get("month")}-${get("day")} ${get("hour")}:${get("minute")}`;
 }
@@ -1668,17 +1670,6 @@ function normalizeThetaFirstOrderGreekRow(row) {
     underlyingPrice: asNumber(row.underlying_price)
   };
 }
-function normalizeThetaImpliedVolatilityRow(row) {
-  return {
-    ...normalizeThetaQuoteRow(row),
-    bidIv: asNumber(row.bid_implied_vol),
-    midIv: asNumber(row.implied_vol ?? row.midpoint_implied_vol),
-    askIv: asNumber(row.ask_implied_vol),
-    ivError: asNumber(row.iv_error),
-    underlyingTimestamp: row.underlying_timestamp == null ? null : thetaTimestampToEtMinute(asText(row.underlying_timestamp)),
-    underlyingPrice: asNumber(row.underlying_price)
-  };
-}
 function normalizeThetaContractListRow(row) {
   return {
     symbol: requiredText(row.symbol, "contract-list row", "symbol").toUpperCase(),
@@ -1898,30 +1889,6 @@ async function indexHistoryEod(client, params) {
   );
   return decodeThetaRows(chunks).map(normalizeThetaIndexEodRow);
 }
-async function optionAtTimeQuote(client, params) {
-  const symbol = validateSymbol(params.symbol);
-  const expiration = validateHyphenDate(params.expiration, "expiration");
-  const strike = validateStrike(params.strike);
-  const date = validateHyphenDate(params.date, "date");
-  const strikeRange = optionalPositiveInteger2(params.strikeRange, "strike_range");
-  const chunks = await client.callStream(
-    "GetOptionAtTimeQuote",
-    endpointRequest(client.queryInfo(), {
-      contractSpec: {
-        symbol,
-        expiration,
-        strike,
-        right: thetaRequestRight(params.right)
-      },
-      startDate: date,
-      endDate: date,
-      timeOfDay: mddsTime(params.time, "09:45:00.000"),
-      expiration,
-      ...strikeRange == null ? {} : { strikeRange }
-    })
-  );
-  return decodeThetaRows(chunks).map(normalizeThetaQuoteRow);
-}
 async function optionHistoryGreeksFirstOrder(client, params) {
   const symbol = validateSymbol(params.symbol);
   const expiration = validateHyphenDate(params.expiration, "expiration");
@@ -1975,57 +1942,6 @@ async function optionHistoryGreeksFirstOrderBand(client, params) {
   );
   return decodeThetaRows(chunks).map(normalizeThetaFirstOrderGreekRow);
 }
-async function optionHistoryImpliedVolatilityBand(client, params) {
-  const symbol = validateSymbol(params.symbol);
-  const expiration = params.expiration === "*" ? "*" : validateHyphenDate(params.expiration, "expiration");
-  const date = validateHyphenDate(params.date, "date");
-  const strikeRange = optionalPositiveInteger2(params.strikeRange, "strike_range");
-  const chunks = await client.callStream(
-    "GetOptionHistoryGreeksImpliedVolatility",
-    endpointRequest(client.queryInfo(), {
-      contractSpec: {
-        symbol,
-        expiration,
-        strike: THETA_WILDCARD_STRIKE,
-        right: "both"
-      },
-      expiration,
-      date,
-      interval: params.interval ?? "1m",
-      startTime: mddsTime(params.startTime, "09:30:00.000"),
-      endTime: mddsTime(params.endTime, "16:00:00.000"),
-      rateType: params.rateType ?? "sofr",
-      ...params.annualDividend == null ? {} : { annualDividend: params.annualDividend },
-      version: "latest",
-      strikeRange
-    })
-  );
-  return decodeThetaRows(chunks).map(normalizeThetaImpliedVolatilityRow);
-}
-async function optionHistoryQuoteBand(client, params) {
-  const symbol = validateSymbol(params.symbol);
-  const expiration = params.expiration === "*" ? "*" : validateHyphenDate(params.expiration, "expiration");
-  const date = validateHyphenDate(params.date, "date");
-  const strikeRange = optionalPositiveInteger2(params.strikeRange, "strike_range");
-  const chunks = await client.callStream(
-    "GetOptionHistoryQuote",
-    endpointRequest(client.queryInfo(), {
-      contractSpec: {
-        symbol,
-        expiration,
-        strike: THETA_WILDCARD_STRIKE,
-        right: "both"
-      },
-      expiration,
-      date,
-      interval: params.interval ?? "1m",
-      startTime: mddsTime(params.startTime, "09:30:00.000"),
-      endTime: mddsTime(params.endTime, "16:00:00.000"),
-      ...strikeRange == null ? {} : { strikeRange }
-    })
-  );
-  return decodeThetaRows(chunks).map(normalizeThetaQuoteRow);
-}
 async function optionHistoryOpenInterest(client, params) {
   const symbol = validateSymbol(params.symbol);
   const expiration = params.expiration === "*" ? "*" : validateHyphenDate(params.expiration, "expiration");
@@ -2079,25 +1995,335 @@ function computeFractionalDte(date, time, expiration) {
   return Math.max(dayDiff + remainingMinutes / (24 * 60), 0);
 }
 
+// src/utils/iv-solver-pool.ts
+import { Worker } from "worker_threads";
+import { availableParallelism } from "os";
+import { existsSync } from "fs";
+import { fileURLToPath } from "url";
+
+// src/utils/iv-solver-worker.ts
+import { parentPort } from "worker_threads";
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function solveIvBatch(req) {
+  const { id, count } = req;
+  const delta = new Float64Array(count);
+  const gamma = new Float64Array(count);
+  const theta = new Float64Array(count);
+  const vega = new Float64Array(count);
+  const iv = new Float64Array(count);
+  const ok = new Uint8Array(count);
+  for (let i = 0; i < count; i++) {
+    const result = computeLegGreeks(
+      req.optionPrice[i],
+      req.underlyingPrice[i],
+      req.strike[i],
+      req.dte[i],
+      req.type[i] === 0 ? "C" : "P",
+      req.riskFreeRate[i],
+      req.dividendYield[i]
+    );
+    if (isFiniteNumber(result.delta) && isFiniteNumber(result.gamma) && isFiniteNumber(result.theta) && isFiniteNumber(result.vega) && isFiniteNumber(result.iv)) {
+      delta[i] = result.delta;
+      gamma[i] = result.gamma;
+      theta[i] = result.theta;
+      vega[i] = result.vega;
+      iv[i] = result.iv;
+      ok[i] = 1;
+    } else {
+      ok[i] = 0;
+    }
+  }
+  return { id, count, delta, gamma, theta, vega, iv, ok };
+}
+if (parentPort) {
+  const port = parentPort;
+  port.on("message", (req) => {
+    const reply = solveIvBatch(req);
+    port.postMessage(reply, [
+      reply.delta.buffer,
+      reply.gamma.buffer,
+      reply.theta.buffer,
+      reply.vega.buffer,
+      reply.iv.buffer,
+      reply.ok.buffer
+    ]);
+  });
+}
+
+// src/utils/iv-solver-pool.ts
+var DEFAULT_INLINE_THRESHOLD = 2e3;
+var MIN_SHARD = 1e3;
+function resolveWorkerUrl() {
+  const jsUrl = new URL("./iv-solver-worker.js", import.meta.url);
+  if (existsSync(fileURLToPath(jsUrl))) return jsUrl;
+  return new URL("./iv-solver-worker.ts", import.meta.url);
+}
+function workersDisabledByEnv() {
+  const flag = process.env.TRADEBLOCKS_IV_WORKERS;
+  return flag === "0" || flag === "false" || flag === "off";
+}
+function defaultMaxWorkers() {
+  const cores = Math.max(1, availableParallelism());
+  return Math.max(1, cores - 1);
+}
+function jobsToColumns(jobs) {
+  const count = jobs.length;
+  const cols = {
+    count,
+    optionPrice: new Float64Array(count),
+    underlyingPrice: new Float64Array(count),
+    strike: new Float64Array(count),
+    dte: new Float64Array(count),
+    riskFreeRate: new Float64Array(count),
+    dividendYield: new Float64Array(count),
+    type: new Uint8Array(count)
+  };
+  for (let i = 0; i < count; i++) {
+    const job = jobs[i];
+    cols.optionPrice[i] = job.optionPrice;
+    cols.underlyingPrice[i] = job.underlyingPrice;
+    cols.strike[i] = job.strike;
+    cols.dte[i] = job.dte;
+    cols.riskFreeRate[i] = job.riskFreeRate;
+    cols.dividendYield[i] = job.dividendYield;
+    cols.type[i] = job.type === "C" ? 0 : 1;
+  }
+  return cols;
+}
+function shardRequest(cols, id, lo, hi) {
+  return {
+    id,
+    count: hi - lo,
+    optionPrice: cols.optionPrice.slice(lo, hi),
+    underlyingPrice: cols.underlyingPrice.slice(lo, hi),
+    strike: cols.strike.slice(lo, hi),
+    dte: cols.dte.slice(lo, hi),
+    riskFreeRate: cols.riskFreeRate.slice(lo, hi),
+    dividendYield: cols.dividendYield.slice(lo, hi),
+    type: cols.type.slice(lo, hi)
+  };
+}
+function wholeRequest(cols, id) {
+  return {
+    id,
+    count: cols.count,
+    optionPrice: cols.optionPrice,
+    underlyingPrice: cols.underlyingPrice,
+    strike: cols.strike,
+    dte: cols.dte,
+    riskFreeRate: cols.riskFreeRate,
+    dividendYield: cols.dividendYield,
+    type: cols.type
+  };
+}
+function columnsResultFrom(reply) {
+  return {
+    count: reply.count,
+    delta: reply.delta,
+    gamma: reply.gamma,
+    theta: reply.theta,
+    vega: reply.vega,
+    iv: reply.iv,
+    ok: reply.ok
+  };
+}
+function resultsFromColumns(cols) {
+  const out = new Array(cols.count);
+  for (let i = 0; i < cols.count; i++) {
+    out[i] = {
+      delta: cols.delta[i],
+      gamma: cols.gamma[i],
+      theta: cols.theta[i],
+      vega: cols.vega[i],
+      iv: cols.iv[i],
+      ok: cols.ok[i] === 1
+    };
+  }
+  return out;
+}
+var IvSolverPool = class {
+  maxWorkers;
+  inlineThreshold;
+  workerUrl;
+  enabled;
+  pool = [];
+  nextRequestId = 1;
+  // Serializes parallel solves against the shared worker set. The `busy`/slot
+  // accounting in solveColumnsParallel is only correct when a single solve
+  // owns the whole pool; without this gate, two concurrent callers could route
+  // shards onto the same worker and corrupt the busy bookkeeping. Inline solves
+  // don't touch workers and bypass the gate.
+  parallelChain = Promise.resolve();
+  constructor(options = {}) {
+    this.maxWorkers = Math.max(1, options.maxWorkers ?? defaultMaxWorkers());
+    this.inlineThreshold = options.inlineThreshold ?? DEFAULT_INLINE_THRESHOLD;
+    this.workerUrl = resolveWorkerUrl();
+    this.enabled = !workersDisabledByEnv() && this.maxWorkers > 1;
+  }
+  /**
+   * Solve a batch of jobs, returning one result per job in input order. Thin
+   * wrapper over `solveColumns` — convenient for callers (and tests) that hold
+   * an `IvSolveJob[]`. The hot ingest path uses `solveColumns` directly to
+   * avoid materializing the object array.
+   */
+  async solve(jobs) {
+    if (jobs.length === 0) return [];
+    const result = await this.solveColumns(jobsToColumns(jobs));
+    return resultsFromColumns(result);
+  }
+  /**
+   * Solve a pre-built column batch. Uses the worker pool when the batch is
+   * large enough and workers are enabled; otherwise solves inline via the same
+   * `solveIvBatch` the workers run (so inline and parallel are interchangeable).
+   * The reply columns are positionally aligned with the input.
+   */
+  async solveColumns(cols) {
+    if (cols.count === 0) {
+      return {
+        count: 0,
+        delta: new Float64Array(0),
+        gamma: new Float64Array(0),
+        theta: new Float64Array(0),
+        vega: new Float64Array(0),
+        iv: new Float64Array(0),
+        ok: new Uint8Array(0)
+      };
+    }
+    const shardCount = this.enabled ? Math.min(this.maxWorkers, Math.ceil(cols.count / MIN_SHARD)) : 1;
+    if (shardCount <= 1 || cols.count < this.inlineThreshold) {
+      return columnsResultFrom(solveIvBatch(wholeRequest(cols, 0)));
+    }
+    const run = this.parallelChain.catch(() => void 0).then(() => this.solveColumnsParallel(cols, shardCount));
+    this.parallelChain = run;
+    return run;
+  }
+  async solveColumnsParallel(cols, shardCount) {
+    this.ensureWorkers(shardCount);
+    const out = {
+      count: cols.count,
+      delta: new Float64Array(cols.count),
+      gamma: new Float64Array(cols.count),
+      theta: new Float64Array(cols.count),
+      vega: new Float64Array(cols.count),
+      iv: new Float64Array(cols.count),
+      ok: new Uint8Array(cols.count)
+    };
+    const base = Math.floor(cols.count / shardCount);
+    const remainder = cols.count % shardCount;
+    const shardPromises = [];
+    let cursor = 0;
+    for (let s = 0; s < shardCount; s++) {
+      const size = base + (s < remainder ? 1 : 0);
+      const lo = cursor;
+      const hi = cursor + size;
+      cursor = hi;
+      if (size === 0) continue;
+      const request = shardRequest(cols, this.nextRequestId++, lo, hi);
+      shardPromises.push(
+        this.runOnWorker(request).then((reply) => {
+          out.delta.set(reply.delta, lo);
+          out.gamma.set(reply.gamma, lo);
+          out.theta.set(reply.theta, lo);
+          out.vega.set(reply.vega, lo);
+          out.iv.set(reply.iv, lo);
+          out.ok.set(reply.ok, lo);
+        })
+      );
+    }
+    await Promise.all(shardPromises);
+    return out;
+  }
+  ensureWorkers(target) {
+    while (this.pool.length < target) {
+      const worker = new Worker(this.workerUrl);
+      worker.setMaxListeners(0);
+      worker.on("error", (err) => {
+        throw err;
+      });
+      this.pool.push({ worker, busy: false });
+    }
+  }
+  runOnWorker(request) {
+    return new Promise((resolve, reject) => {
+      const slot = this.acquire();
+      const onMessage = (reply) => {
+        if (reply.id !== request.id) return;
+        cleanup();
+        slot.busy = false;
+        resolve(reply);
+      };
+      const onError = (err) => {
+        cleanup();
+        slot.busy = false;
+        reject(err);
+      };
+      const cleanup = () => {
+        slot.worker.off("message", onMessage);
+        slot.worker.off("error", onError);
+      };
+      slot.worker.on("message", onMessage);
+      slot.worker.once("error", onError);
+      slot.worker.postMessage(request, [
+        request.optionPrice.buffer,
+        request.underlyingPrice.buffer,
+        request.strike.buffer,
+        request.dte.buffer,
+        request.riskFreeRate.buffer,
+        request.dividendYield.buffer,
+        request.type.buffer
+      ]);
+    });
+  }
+  acquire() {
+    const free = this.pool.find((w) => !w.busy);
+    const slot = free ?? this.pool[0];
+    slot.busy = true;
+    return slot;
+  }
+  /** Terminate all workers. Idempotent. */
+  async destroy() {
+    const workers = this.pool;
+    this.pool = [];
+    await Promise.all(workers.map(({ worker }) => worker.terminate()));
+  }
+};
+var sharedPool = null;
+function getSharedIvSolverPool() {
+  if (!sharedPool) {
+    sharedPool = new IvSolverPool();
+  }
+  return sharedPool;
+}
+
 // src/utils/option-quote-greeks.ts
 var OPTION_QUOTE_GREEKS_REVISION = 3;
 var OPTION_QUOTE_GREEKS_RATE_TYPE = "sofr";
 var OPTION_QUOTE_GREEKS_GAMMA_SOURCE = "computed_sofr_q0";
 var OPTION_QUOTE_GREEKS_DIVIDEND_YIELD = 0;
-function isFiniteNumber(value) {
+function isFiniteNumber2(value) {
   return typeof value === "number" && Number.isFinite(value);
 }
+var sofrRateByDateKey = /* @__PURE__ */ new Map();
+function memoizedSofrRate(dateKey) {
+  const cached = sofrRateByDateKey.get(dateKey);
+  if (cached !== void 0) return cached;
+  const rate = getSofrRateByKey(dateKey);
+  sofrRateByDateKey.set(dateKey, rate);
+  return rate;
+}
 function hasQuoteGreeks(row) {
-  return isFiniteNumber(row.delta ?? null) && isFiniteNumber(row.gamma ?? null) && isFiniteNumber(row.theta ?? null) && isFiniteNumber(row.vega ?? null) && isFiniteNumber(row.iv ?? null);
+  return isFiniteNumber2(row.delta ?? null) && isFiniteNumber2(row.gamma ?? null) && isFiniteNumber2(row.theta ?? null) && isFiniteNumber2(row.vega ?? null) && isFiniteNumber2(row.iv ?? null);
 }
 function hasProviderFirstOrderGreeks(row) {
-  return row.greeks_source === "thetadata" && isFiniteNumber(row.delta ?? null) && (row.gamma == null || isFiniteNumber(row.gamma)) && isFiniteNumber(row.theta ?? null) && isFiniteNumber(row.vega ?? null) && isFiniteNumber(row.iv ?? null);
+  return row.greeks_source === "thetadata" && isFiniteNumber2(row.delta ?? null) && (row.gamma == null || isFiniteNumber2(row.gamma)) && isFiniteNumber2(row.theta ?? null) && isFiniteNumber2(row.vega ?? null) && isFiniteNumber2(row.iv ?? null);
 }
 function hasExistingQuoteGreeks(row) {
   return hasQuoteGreeks(row) || hasProviderFirstOrderGreeks(row);
 }
 function hasQuoteGreekProvenanceFields(row) {
-  return row.rate_type === OPTION_QUOTE_GREEKS_RATE_TYPE && isFiniteNumber(row.rate_value ?? null) && row.gamma_source === OPTION_QUOTE_GREEKS_GAMMA_SOURCE;
+  return row.rate_type === OPTION_QUOTE_GREEKS_RATE_TYPE && isFiniteNumber2(row.rate_value ?? null) && row.gamma_source === OPTION_QUOTE_GREEKS_GAMMA_SOURCE;
 }
 function normalizeExistingQuoteGreeks(row, defaultSource) {
   if (!hasExistingQuoteGreeks(row)) return;
@@ -2108,55 +2334,8 @@ function normalizeExistingQuoteGreeks(row, defaultSource) {
     row.greeks_revision = OPTION_QUOTE_GREEKS_REVISION;
   }
 }
-function computeQuoteGreeks(params) {
-  const {
-    optionPrice,
-    underlyingPrice,
-    strike,
-    date,
-    time,
-    expiration,
-    contractType
-  } = params;
-  if (!(optionPrice > 0) || !(underlyingPrice > 0) || !(strike > 0)) return null;
-  const dte = computeFractionalDte(date, time.slice(0, 5), expiration);
-  if (!(dte >= 0)) return null;
-  const riskFreeRate = getSofrRateByKey(date) / 100;
-  const result = computeLegGreeks(
-    optionPrice,
-    underlyingPrice,
-    strike,
-    dte,
-    contractType === "call" ? "C" : "P",
-    riskFreeRate,
-    OPTION_QUOTE_GREEKS_DIVIDEND_YIELD
-  );
-  if (!hasQuoteGreeks(result)) return null;
+function emptyStats() {
   return {
-    delta: result.delta,
-    gamma: result.gamma,
-    theta: result.theta,
-    vega: result.vega,
-    iv: result.iv,
-    greeks_source: "computed",
-    greeks_revision: OPTION_QUOTE_GREEKS_REVISION,
-    rate_type: OPTION_QUOTE_GREEKS_RATE_TYPE,
-    rate_value: riskFreeRate,
-    gamma_source: OPTION_QUOTE_GREEKS_GAMMA_SOURCE
-  };
-}
-function applyQuoteGreeks(params) {
-  const {
-    rows,
-    getDate,
-    getTime,
-    getMid,
-    getContractMeta,
-    getUnderlyingPrice,
-    mode = "auto",
-    defaultProviderSource
-  } = params;
-  const stats = {
     rowsVisited: 0,
     existingGreeksRows: 0,
     computedRows: 0,
@@ -2165,55 +2344,132 @@ function applyQuoteGreeks(params) {
     mathFailedRows: 0,
     unresolvedRows: 0
   };
-  for (const row of rows) {
-    stats.rowsVisited++;
-    if (mode !== "compute" && hasExistingQuoteGreeks(row)) {
-      normalizeExistingQuoteGreeks(row, defaultProviderSource);
+}
+function resolveQuoteGreeksRow(row, params, defaultProviderSource, mode) {
+  if (mode !== "compute" && hasExistingQuoteGreeks(row)) {
+    normalizeExistingQuoteGreeks(row, defaultProviderSource);
+    return { kind: "existing" };
+  }
+  const meta = params.getContractMeta(row);
+  if (!meta) return { kind: "missingContract" };
+  if (mode === "provider") return { kind: "providerUnresolved" };
+  const date = params.getDate(row);
+  const time = params.getTime(row).slice(0, 5);
+  const underlyingPrice = params.getUnderlyingPrice(date, time);
+  if (!(underlyingPrice != null && underlyingPrice > 0)) {
+    return { kind: "missingUnderlying" };
+  }
+  const optionPrice = params.getMid(row);
+  if (!(optionPrice > 0) || !(meta.strike > 0)) return { kind: "mathFailed" };
+  const dte = computeFractionalDte(date, time, meta.expiration);
+  if (!(dte >= 0)) return { kind: "mathFailed" };
+  const riskFreeRate = memoizedSofrRate(date) / 100;
+  return {
+    kind: "compute",
+    optionPrice,
+    underlyingPrice,
+    strike: meta.strike,
+    dte,
+    type: meta.contract_type === "call" ? 0 : 1,
+    riskFreeRate
+  };
+}
+function writeComputedGreeks(row, greeks, riskFreeRate) {
+  row.delta = greeks.delta;
+  row.gamma = greeks.gamma;
+  row.theta = greeks.theta;
+  row.vega = greeks.vega;
+  row.iv = greeks.iv;
+  row.greeks_source = "computed";
+  row.greeks_revision = OPTION_QUOTE_GREEKS_REVISION;
+  row.rate_type = OPTION_QUOTE_GREEKS_RATE_TYPE;
+  row.rate_value = riskFreeRate;
+  row.gamma_source = OPTION_QUOTE_GREEKS_GAMMA_SOURCE;
+}
+function tallySkip(stats, kind) {
+  switch (kind) {
+    case "existing":
       stats.existingGreeksRows++;
-      continue;
-    }
-    const meta = getContractMeta(row);
-    if (!meta) {
+      return;
+    case "missingContract":
       stats.missingContractRows++;
       stats.unresolvedRows++;
-      continue;
-    }
-    if (mode === "provider") {
+      return;
+    case "providerUnresolved":
       stats.unresolvedRows++;
-      continue;
-    }
-    const date = getDate(row);
-    const time = getTime(row).slice(0, 5);
-    const underlyingPrice = getUnderlyingPrice(date, time);
-    if (!(underlyingPrice != null && underlyingPrice > 0)) {
+      return;
+    case "missingUnderlying":
       stats.missingUnderlyingRows++;
       stats.unresolvedRows++;
+      return;
+    case "mathFailed":
+      stats.mathFailedRows++;
+      stats.unresolvedRows++;
+      return;
+    case "compute":
+      return;
+  }
+}
+async function applyQuoteGreeksParallel(params) {
+  const { rows, mode = "auto", defaultProviderSource } = params;
+  const stats = emptyStats();
+  const pool = params.pool ?? getSharedIvSolverPool();
+  const n = rows.length;
+  const optionPrice = new Float64Array(n);
+  const underlyingPrice = new Float64Array(n);
+  const strike = new Float64Array(n);
+  const dte = new Float64Array(n);
+  const riskFreeRate = new Float64Array(n);
+  const dividendYield = new Float64Array(n);
+  const type = new Uint8Array(n);
+  const jobRowIndex = new Int32Array(n);
+  let count = 0;
+  for (let i = 0; i < n; i++) {
+    stats.rowsVisited++;
+    const resolution = resolveQuoteGreeksRow(rows[i], params, defaultProviderSource, mode);
+    if (resolution.kind !== "compute") {
+      tallySkip(stats, resolution.kind);
       continue;
     }
-    const greeks = computeQuoteGreeks({
-      optionPrice: getMid(row),
-      underlyingPrice,
-      strike: meta.strike,
-      date,
-      time,
-      expiration: meta.expiration,
-      contractType: meta.contract_type
-    });
-    if (!greeks) {
+    optionPrice[count] = resolution.optionPrice;
+    underlyingPrice[count] = resolution.underlyingPrice;
+    strike[count] = resolution.strike;
+    dte[count] = resolution.dte;
+    riskFreeRate[count] = resolution.riskFreeRate;
+    dividendYield[count] = OPTION_QUOTE_GREEKS_DIVIDEND_YIELD;
+    type[count] = resolution.type;
+    jobRowIndex[count] = i;
+    count++;
+  }
+  if (count === 0) return stats;
+  const columns = {
+    count,
+    optionPrice: optionPrice.subarray(0, count),
+    underlyingPrice: underlyingPrice.subarray(0, count),
+    strike: strike.subarray(0, count),
+    dte: dte.subarray(0, count),
+    riskFreeRate: riskFreeRate.subarray(0, count),
+    dividendYield: dividendYield.subarray(0, count),
+    type: type.subarray(0, count)
+  };
+  const result = await pool.solveColumns(columns);
+  for (let j = 0; j < count; j++) {
+    if (result.ok[j] !== 1) {
       stats.mathFailedRows++;
       stats.unresolvedRows++;
       continue;
     }
-    row.delta = greeks.delta;
-    row.gamma = greeks.gamma;
-    row.theta = greeks.theta;
-    row.vega = greeks.vega;
-    row.iv = greeks.iv;
-    row.greeks_source = greeks.greeks_source;
-    row.greeks_revision = greeks.greeks_revision;
-    row.rate_type = greeks.rate_type;
-    row.rate_value = greeks.rate_value;
-    row.gamma_source = greeks.gamma_source;
+    writeComputedGreeks(
+      rows[jobRowIndex[j]],
+      {
+        delta: result.delta[j],
+        gamma: result.gamma[j],
+        theta: result.theta[j],
+        vega: result.vega[j],
+        iv: result.iv[j]
+      },
+      riskFreeRate[j]
+    );
     stats.computedRows++;
   }
   return stats;
@@ -2235,19 +2491,19 @@ function joinKey(row) {
     row.timestamp
   ].join("|");
 }
-function isFiniteNumber2(value) {
+function isFiniteNumber3(value) {
   return typeof value === "number" && Number.isFinite(value);
 }
 function hasProviderFirstOrderGreeks2(row) {
-  return isFiniteNumber2(row.delta) && isFiniteNumber2(row.theta) && isFiniteNumber2(row.vega) && isFiniteNumber2(row.iv);
+  return isFiniteNumber3(row.delta) && isFiniteNumber3(row.theta) && isFiniteNumber3(row.vega) && isFiniteNumber3(row.iv);
 }
 function splitTimestamp(timestamp) {
   const [date, time = ""] = timestamp.split(" ");
   return { date, time: time.slice(0, 5) };
 }
 function computeGamma(row, greek) {
-  if (!isFiniteNumber2(greek.iv) || !(greek.iv > 0)) return { gamma: null, rateValue: null };
-  if (!isFiniteNumber2(greek.underlyingPrice) || !(greek.underlyingPrice > 0)) {
+  if (!isFiniteNumber3(greek.iv) || !(greek.iv > 0)) return { gamma: null, rateValue: null };
+  if (!isFiniteNumber3(greek.underlyingPrice) || !(greek.underlyingPrice > 0)) {
     return { gamma: null, rateValue: null };
   }
   if (!(row.strike > 0)) return { gamma: null, rateValue: null };
@@ -2303,7 +2559,7 @@ function joinThetaQuotesAndFirstOrderGreeks(options) {
   }
   const rows = [];
   for (const quote of options.quotes) {
-    if (!isFiniteNumber2(quote.bid) || !isFiniteNumber2(quote.ask)) {
+    if (!isFiniteNumber3(quote.bid) || !isFiniteNumber3(quote.ask)) {
       stats.droppedQuoteRows++;
       continue;
     }
@@ -2342,61 +2598,6 @@ function joinThetaQuotesAndFirstOrderGreeks(options) {
   return { rows, stats };
 }
 
-// src/utils/providers/thetadata/quote-mid-greeks.ts
-var OPTION_QUOTE_MID_GREEKS_REVISION = 6;
-var OPTION_QUOTE_MID_GREEKS_DIVIDEND_YIELD = OPTION_QUOTE_GREEKS_DIVIDEND_YIELD;
-var OPTION_QUOTE_MID_GREEKS_GAMMA_SOURCE = "computed_thetadata_quote_mid_sofr_q0";
-function isFiniteNumber3(value) {
-  return typeof value === "number" && Number.isFinite(value);
-}
-function splitTimestamp2(timestamp) {
-  const [date, time = ""] = timestamp.split(" ");
-  return { date, time: time.slice(0, 5) };
-}
-function computeThetaQuoteMidGreekRow(params) {
-  const { quote, underlyingPrice } = params;
-  if (!isFiniteNumber3(quote.bid) || !isFiniteNumber3(quote.ask)) return null;
-  if (!isFiniteNumber3(underlyingPrice) || !(underlyingPrice > 0)) return null;
-  if (!(quote.strike > 0)) return null;
-  const optionPrice = (quote.bid + quote.ask) / 2;
-  if (!(optionPrice > 0)) return null;
-  const { date, time } = splitTimestamp2(quote.timestamp);
-  const dte = computeFractionalDte(date, time, quote.expiration);
-  if (!(dte > 0)) return null;
-  const rateValue = getSofrRateByKey(date) / 100;
-  const greeks = computeLegGreeks(
-    optionPrice,
-    underlyingPrice,
-    quote.strike,
-    dte,
-    quote.right === "call" ? "C" : "P",
-    rateValue,
-    OPTION_QUOTE_MID_GREEKS_DIVIDEND_YIELD
-  );
-  if (!isFiniteNumber3(greeks.delta) || !isFiniteNumber3(greeks.gamma) || !isFiniteNumber3(greeks.theta) || !isFiniteNumber3(greeks.vega) || !isFiniteNumber3(greeks.iv)) {
-    return null;
-  }
-  return {
-    ticker: buildTicker(quote),
-    timestamp: quote.timestamp,
-    bid: quote.bid,
-    ask: quote.ask,
-    delta: greeks.delta,
-    gamma: greeks.gamma,
-    theta: greeks.theta,
-    // vega is stored per 1% IV move, matching computeLegGreeks' convention and
-    // the rest of the emit path (the per-contract x100 multiplier belongs to the
-    // consumer, not the stored greek).
-    vega: greeks.vega,
-    iv: greeks.iv,
-    greeks_source: "computed",
-    greeks_revision: OPTION_QUOTE_MID_GREEKS_REVISION,
-    rate_type: OPTION_QUOTE_GREEKS_RATE_TYPE,
-    rate_value: rateValue,
-    gamma_source: OPTION_QUOTE_MID_GREEKS_GAMMA_SOURCE
-  };
-}
-
 // src/utils/providers/thetadata.ts
 var BULK_YIELD_CHUNK = 5e4;
 var BULK_GREEKS_STRIKE_RANGE = 20;
@@ -2844,74 +3045,17 @@ function _resetProvider() {
 
 export {
   BACHELIER_DTE_THRESHOLD,
-  pdf,
-  cdf,
   bsPrice,
-  bsDelta,
-  bsGamma,
-  bsTheta,
-  bsVega,
-  solveIV,
   bachelierPrice,
-  bachelierDelta,
-  bachelierGamma,
-  bachelierTheta,
-  bachelierVega,
-  solveNormalIV,
-  computeLegGreeks,
-  resolveMassiveDataTier,
-  MassiveBarSchema,
-  MassiveAggregateResponseSchema,
-  MassiveQuoteSchema,
-  MassiveQuotesResponseSchema,
-  MassiveSnapshotContractSchema,
-  MassiveSnapshotResponseSchema,
-  MASSIVE_BASE_URL,
-  MASSIVE_MAX_LIMIT,
-  MASSIVE_MAX_PAGES,
-  toMassiveTicker,
-  fromMassiveTicker,
-  massiveTimestampToETDate,
-  massiveTimestampToETTime,
-  nanosToETMinuteKey,
-  MassiveProvider,
   markPrice,
-  findNearestTimestamp,
   parseLegsString,
   buildOccTicker,
   computeStrategyPnlPath,
   computeReplayMfeMae,
-  ThetaMddsClient,
-  thetaTimestampToEtMinute,
-  decodeThetaResponseData,
-  normalizeThetaFirstOrderGreekRow,
-  normalizeThetaOpenInterestRow,
-  normalizeThetaStockOhlcRow,
-  normalizeThetaStockEodRow,
-  normalizeThetaIndexOhlcRow,
-  normalizeThetaIndexEodRow,
-  optionHistoryQuote,
-  stockHistoryOhlc,
-  stockHistoryEod,
-  indexHistoryOhlc,
-  indexHistoryEod,
-  optionAtTimeQuote,
-  optionHistoryGreeksFirstOrder,
-  optionHistoryGreeksFirstOrderBand,
-  optionHistoryImpliedVolatilityBand,
-  optionHistoryQuoteBand,
-  optionHistoryOpenInterest,
-  optionListContracts,
-  computeFractionalDte,
-  OPTION_QUOTE_GREEKS_REVISION,
-  hasQuoteGreeks,
-  applyQuoteGreeks,
-  joinThetaQuotesAndFirstOrderGreeks,
-  OPTION_QUOTE_MID_GREEKS_REVISION,
-  OPTION_QUOTE_MID_GREEKS_GAMMA_SOURCE,
-  computeThetaQuoteMidGreekRow,
+  MassiveProvider,
+  applyQuoteGreeksParallel,
   ThetaDataProvider,
   getProvider,
   _resetProvider
 };
-//# sourceMappingURL=chunk-CCITWAAI.js.map
+//# sourceMappingURL=chunk-PNKG7RY7.js.map