tradeblocks-mcp 3.0.1 → 3.0.2

package/{server/chunk-JAAQMESY.js → dist/chunk-XXYOUIZY.js}

@@ -1,10 +1,9 @@
-#!/usr/bin/env node
 import {
   getSofrRateByKey
-} from "./chunk-72GKJE2U.js";
+} from "./chunk-QTTR7AAW.js";
 import {
   loadMddsProtoRoot
-} from "./chunk-FBNDMCT5.js";
+} from "./chunk-FGZH632F.js";
 
 // src/utils/providers/massive.ts
 import { z } from "zod";
@@ -752,18 +751,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;
@@ -1386,7 +1385,7 @@ var ThetaMddsClient = class {
   fetchImpl;
   loadGrpcPackage;
   constructor(env = process.env, fetchImpl = fetch, loadGrpcPackage = async () => {
-    const { loadMddsGrpcPackage } = await import("./proto-DWRZJO4E.js");
+    const { loadMddsGrpcPackage } = await import("./proto-3HZTCWK4.js");
     return loadMddsGrpcPackage();
   }) {
     this.env = env;
@@ -1528,22 +1527,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")}`;
 }
@@ -1669,6 +1669,17 @@ 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(),
@@ -1888,6 +1899,30 @@ 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");
@@ -1941,6 +1976,57 @@ 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");
@@ -1994,25 +2080,342 @@ 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;
+}
+async function destroySharedIvSolverPool() {
+  if (sharedPool) {
+    const pool = sharedPool;
+    sharedPool = null;
+    await pool.destroy();
+  }
+}
+
 // 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;
@@ -2023,55 +2426,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,
@@ -2080,55 +2436,171 @@ 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++;
+      return;
+    case "providerUnresolved":
+      stats.unresolvedRows++;
+      return;
+    case "missingUnderlying":
+      stats.missingUnderlyingRows++;
+      stats.unresolvedRows++;
+      return;
+    case "mathFailed":
+      stats.mathFailedRows++;
+      stats.unresolvedRows++;
+      return;
+    case "compute":
+      return;
+  }
+}
+function applyQuoteGreeks(params) {
+  const { rows, mode = "auto", defaultProviderSource } = params;
+  const stats = emptyStats();
+  for (const row of rows) {
+    stats.rowsVisited++;
+    const resolution = resolveQuoteGreeksRow(row, params, defaultProviderSource, mode);
+    if (resolution.kind !== "compute") {
+      tallySkip(stats, resolution.kind);
       continue;
     }
-    if (mode === "provider") {
+    const result = computeLegGreeks(
+      resolution.optionPrice,
+      resolution.underlyingPrice,
+      resolution.strike,
+      resolution.dte,
+      resolution.type === 0 ? "C" : "P",
+      resolution.riskFreeRate,
+      OPTION_QUOTE_GREEKS_DIVIDEND_YIELD
+    );
+    if (!hasQuoteGreeks(result)) {
+      stats.mathFailedRows++;
       stats.unresolvedRows++;
       continue;
     }
-    const date = getDate(row);
-    const time = getTime(row).slice(0, 5);
-    const underlyingPrice = getUnderlyingPrice(date, time);
-    if (!(underlyingPrice != null && underlyingPrice > 0)) {
-      stats.missingUnderlyingRows++;
-      stats.unresolvedRows++;
+    writeComputedGreeks(
+      row,
+      {
+        delta: result.delta,
+        gamma: result.gamma,
+        theta: result.theta,
+        vega: result.vega,
+        iv: result.iv
+      },
+      resolution.riskFreeRate
+    );
+    stats.computedRows++;
+  }
+  return stats;
+}
+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;
@@ -2150,19 +2622,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 };
@@ -2218,7 +2690,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;
     }
@@ -2257,6 +2729,61 @@ 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 isFiniteNumber4(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 (!isFiniteNumber4(quote.bid) || !isFiniteNumber4(quote.ask)) return null;
+  if (!isFiniteNumber4(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 (!isFiniteNumber4(greeks.delta) || !isFiniteNumber4(greeks.gamma) || !isFiniteNumber4(greeks.theta) || !isFiniteNumber4(greeks.vega) || !isFiniteNumber4(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;
@@ -2704,17 +3231,78 @@ 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,
-  MassiveProvider,
+  ThetaMddsClient,
+  thetaTimestampToEtMinute,
+  decodeThetaResponseData,
+  normalizeThetaFirstOrderGreekRow,
+  normalizeThetaOpenInterestRow,
+  normalizeThetaStockOhlcRow,
+  normalizeThetaStockEodRow,
+  normalizeThetaIndexOhlcRow,
+  normalizeThetaIndexEodRow,
+  optionHistoryQuote,
+  stockHistoryOhlc,
+  stockHistoryEod,
+  indexHistoryOhlc,
+  indexHistoryEod,
+  optionAtTimeQuote,
+  optionHistoryGreeksFirstOrder,
+  optionHistoryGreeksFirstOrderBand,
+  optionHistoryImpliedVolatilityBand,
+  optionHistoryQuoteBand,
+  optionHistoryOpenInterest,
+  optionListContracts,
+  computeFractionalDte,
+  IvSolverPool,
+  getSharedIvSolverPool,
+  destroySharedIvSolverPool,
+  OPTION_QUOTE_GREEKS_REVISION,
+  hasQuoteGreeks,
   applyQuoteGreeks,
+  applyQuoteGreeksParallel,
+  joinThetaQuotesAndFirstOrderGreeks,
+  OPTION_QUOTE_MID_GREEKS_REVISION,
+  OPTION_QUOTE_MID_GREEKS_GAMMA_SOURCE,
+  computeThetaQuoteMidGreekRow,
   ThetaDataProvider,
   getProvider,
   _resetProvider
 };
-//# sourceMappingURL=chunk-JAAQMESY.js.map
+//# sourceMappingURL=chunk-XXYOUIZY.js.map