tradeblocks-mcp 3.0.2 → 3.0.3

package/src/utils/greeks-decomposition.ts

@@ -15,40 +15,48 @@
  * Pure logic module — no I/O, no DuckDB, no fetch.
  */
 
-import type { PnlPoint, ReplayLeg } from './trade-replay.ts';
-import { bsPrice, bachelierPrice, BACHELIER_DTE_THRESHOLD } from './black-scholes.ts';
+import type { PnlPoint, ReplayLeg } from "./trade-replay.ts";
+import { bsPrice, bachelierPrice, BACHELIER_DTE_THRESHOLD } from "./black-scholes.ts";
 
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
 
-export type FactorName = 'delta' | 'gamma' | 'theta' | 'vega' | 'charm' | 'vanna' | 'residual' | 'time_and_vol';
+export type FactorName =
+  | "delta"
+  | "gamma"
+  | "theta"
+  | "vega"
+  | "charm"
+  | "vanna"
+  | "residual"
+  | "time_and_vol";
 
 export interface FactorContribution {
   factor: FactorName;
-  totalPnl: number;          // Sum of step contributions
-  pctOfTotal: number;        // % of total abs P&L move
-  steps: number[];           // Per-step contribution values
+  totalPnl: number; // Sum of step contributions
+  pctOfTotal: number; // % of total abs P&L move
+  steps: number[]; // Per-step contribution values
 }
 
 export interface LegGroupVega {
-  label: string;             // e.g., "front_month", "back_month"
-  legIndices: number[];      // Which legs are in this group
-  totalVegaPnl: number;      // Sum of vega P&L for this group
-  avgIvChange: number;       // Average IV change for this group's legs
-  steps: number[];           // Per-step vega contribution for this group
+  label: string; // e.g., "front_month", "back_month"
+  legIndices: number[]; // Which legs are in this group
+  totalVegaPnl: number; // Sum of vega P&L for this group
+  avgIvChange: number; // Average IV change for this group's legs
+  steps: number[]; // Per-step vega contribution for this group
 }
 
 export interface GreeksDecompositionResult {
-  factors: FactorContribution[];  // Sorted by abs(totalPnl) descending
-  legGroupVega?: LegGroupVega[];  // Per-leg-group vega attribution
-  totalPnlChange: number;         // Actual P&L change from first to last point
-  totalAttributed: number;        // Sum of factor contributions (excl residual)
-  totalResidual: number;          // Total residual
-  stepCount: number;              // Number of steps (pnlPath.length - 1)
-  summary: string;                // Human-readable summary
-  warning?: string | null;        // D-13: high residual warning
-  method: 'full_reval' | 'model' | 'numerical';  // which method produced the attribution
+  factors: FactorContribution[]; // Sorted by abs(totalPnl) descending
+  legGroupVega?: LegGroupVega[]; // Per-leg-group vega attribution
+  totalPnlChange: number; // Actual P&L change from first to last point
+  totalAttributed: number; // Sum of factor contributions (excl residual)
+  totalResidual: number; // Total residual
+  stepCount: number; // Number of steps (pnlPath.length - 1)
+  summary: string; // Human-readable summary
+  warning?: string | null; // D-13: high residual warning
+  method: "full_reval" | "model" | "numerical"; // which method produced the attribution
 }
 
 export interface LegGroupDef {
@@ -58,20 +66,20 @@ export interface LegGroupDef {
 
 export interface LegPricingInput {
   strike: number;
-  type: 'C' | 'P';
-  expiryDate: string;  // YYYY-MM-DD
+  type: "C" | "P";
+  expiryDate: string; // YYYY-MM-DD
 }
 
 export interface GreeksDecompositionConfig {
   pnlPath: PnlPoint[];
   legs: ReplayLeg[];
-  underlyingPrices?: Map<string, number>;  // timestamp -> underlying price
-  legGroups?: LegGroupDef[];               // Optional leg grouping for per-group vega
+  underlyingPrices?: Map<string, number>; // timestamp -> underlying price
+  legGroups?: LegGroupDef[]; // Optional leg grouping for per-group vega
   /** Per-leg pricing inputs for full revaluation. When provided, uses full reval
    *  instead of Taylor expansion. Falls back to Taylor when missing. */
   legPricingInputs?: LegPricingInput[];
-  riskFreeRate?: number;      // e.g. 0.045
-  dividendYield?: number;     // e.g. 0.015 for SPX
+  riskFreeRate?: number; // e.g. 0.045
+  dividendYield?: number; // e.g. 0.015 for SPX
 }
 
 // ---------------------------------------------------------------------------
@@ -88,13 +96,13 @@ const TRADING_MINUTES_PER_DAY = 390;
  * Cross day: calendar day difference (simplified — treats each gap as 1 day)
  */
 export function computeTimeDeltaDays(ts1: string, ts2: string): number {
-  const [date1, time1] = ts1.split(' ');
-  const [date2, time2] = ts2.split(' ');
+  const [date1, time1] = ts1.split(" ");
+  const [date2, time2] = ts2.split(" ");
 
   if (date1 === date2) {
     // Same day: count minutes difference
-    const [h1, m1] = time1.split(':').map(Number);
-    const [h2, m2] = time2.split(':').map(Number);
+    const [h1, m1] = time1.split(":").map(Number);
+    const [h2, m2] = time2.split(":").map(Number);
     const mins1 = h1 * 60 + m1;
     const mins2 = h2 * 60 + m2;
     const diffMins = Math.abs(mins2 - mins1);
@@ -102,19 +110,19 @@ export function computeTimeDeltaDays(ts1: string, ts2: string): number {
   }
 
   // Cross-day: compute calendar day difference
-  const d1 = new Date(date1 + 'T12:00:00'); // noon to avoid DST issues
-  const d2 = new Date(date2 + 'T12:00:00');
+  const d1 = new Date(date1 + "T12:00:00"); // noon to avoid DST issues
+  const d2 = new Date(date2 + "T12:00:00");
   const diffMs = Math.abs(d2.getTime() - d1.getTime());
   const diffDays = Math.round(diffMs / (24 * 60 * 60 * 1000));
 
   // Add fractional day from time within each day
-  const [h1, m1] = time1.split(':').map(Number);
-  const [h2, m2] = time2.split(':').map(Number);
+  const [h1, m1] = time1.split(":").map(Number);
+  const [h2, m2] = time2.split(":").map(Number);
   // Fraction of trading day for ts2's time (from market open ~9:30)
-  const minsIntoDay2 = (h2 * 60 + m2) - (9 * 60 + 30);
+  const minsIntoDay2 = h2 * 60 + m2 - (9 * 60 + 30);
   const fracDay2 = Math.max(0, minsIntoDay2) / TRADING_MINUTES_PER_DAY;
   // Fraction remaining in ts1's day
-  const minsIntoDay1 = (h1 * 60 + m1) - (9 * 60 + 30);
+  const minsIntoDay1 = h1 * 60 + m1 - (9 * 60 + 30);
   const fracDayRemaining1 = Math.max(0, 1 - minsIntoDay1 / TRADING_MINUTES_PER_DAY);
 
   // Total: remaining fraction of day1 + (diffDays - 1) full days + fraction of day2
@@ -198,31 +206,34 @@ function numericalDecomposition(
   const totalTimeAndVol = sumSteps(numResidualSteps);
 
   const rawFactors = [
-    { factor: 'delta' as FactorName, totalPnl: totalDelta, steps: numDeltaSteps },
-    { factor: 'gamma' as FactorName, totalPnl: totalGamma, steps: numGammaSteps },
-    { factor: 'time_and_vol' as FactorName, totalPnl: totalTimeAndVol, steps: numResidualSteps },
+    { factor: "delta" as FactorName, totalPnl: totalDelta, steps: numDeltaSteps },
+    { factor: "gamma" as FactorName, totalPnl: totalGamma, steps: numGammaSteps },
+    { factor: "time_and_vol" as FactorName, totalPnl: totalTimeAndVol, steps: numResidualSteps },
   ];
 
   rawFactors.sort((a, b) => Math.abs(b.totalPnl) - Math.abs(a.totalPnl));
   const totalAbsSum = rawFactors.reduce((s, f) => s + Math.abs(f.totalPnl), 0);
-  const factors: FactorContribution[] = rawFactors.map(f => ({
+  const factors: FactorContribution[] = rawFactors.map((f) => ({
     ...f,
     pctOfTotal: totalAbsSum > 0 ? (Math.abs(f.totalPnl) / totalAbsSum) * 100 : 0,
   }));
 
-  const summaryParts = factors.map(f => `${f.factor} ${f.totalPnl.toFixed(2)} (${f.pctOfTotal.toFixed(0)}%)`);
-  const summary = `P&L of ${totalPnlChange.toFixed(2)} (numerical): ${summaryParts.join(', ')}`;
+  const summaryParts = factors.map(
+    (f) => `${f.factor} ${f.totalPnl.toFixed(2)} (${f.pctOfTotal.toFixed(0)}%)`,
+  );
+  const summary = `P&L of ${totalPnlChange.toFixed(2)} (numerical): ${summaryParts.join(", ")}`;
 
   return {
     factors,
-    legGroupVega: undefined,  // Leg-group vega not available in numerical mode
+    legGroupVega: undefined, // Leg-group vega not available in numerical mode
     totalPnlChange,
     totalAttributed: totalDelta + totalGamma,
     totalResidual: totalTimeAndVol,
     stepCount,
     summary,
-    warning: 'Model-based attribution had >80% residual. Switched to numerical method (realized delta from price changes).',
-    method: 'numerical',
+    warning:
+      "Model-based attribution had >80% residual. Switched to numerical method (realized delta from price changes).",
+    method: "numerical",
   };
 }
 
@@ -234,11 +245,11 @@ function numericalDecomposition(
  * Compute DTE in days from a bar timestamp to a leg's expiry (4:00 PM ET).
  */
 function computeDte(timestamp: string, expiryDate: string): number {
-  const dateStr = timestamp.split(' ')[0];
-  const timePart = timestamp.split(' ')[1] ?? '09:30';
-  const [eyy, emm, edd] = expiryDate.split('-').map(Number);
-  const [byy, bmm, bdd] = dateStr.split('-').map(Number);
-  const [hh, min] = timePart.split(':').map(Number);
+  const dateStr = timestamp.split(" ")[0];
+  const timePart = timestamp.split(" ")[1] ?? "09:30";
+  const [eyy, emm, edd] = expiryDate.split("-").map(Number);
+  const [byy, bmm, bdd] = dateStr.split("-").map(Number);
+  const [hh, min] = timePart.split(":").map(Number);
 
   const expiryMs = new Date(eyy, emm - 1, edd).getTime() + 16 * 60 * 60 * 1000; // 4:00 PM ET
   const barMs = new Date(byy, bmm - 1, bdd).getTime() + (hh * 60 + min) * 60 * 1000;
@@ -250,7 +261,7 @@ function computeDte(timestamp: string, expiryDate: string): number {
  * Returns null if pricing fails (DTE <= 0 or IV missing).
  */
 function priceOption(
-  type: 'C' | 'P',
+  type: "C" | "P",
   S: number,
   K: number,
   dte: number,
@@ -260,7 +271,7 @@ function priceOption(
 ): number | null {
   if (dte <= 0 || iv <= 0) return null;
   const T = dte / 365;
-  const bsType = type === 'C' ? 'call' as const : 'put' as const;
+  const bsType = type === "C" ? ("call" as const) : ("put" as const);
   if (dte < BACHELIER_DTE_THRESHOLD) {
     return bachelierPrice(bsType, S, K, T, r, q, iv);
   }
@@ -279,39 +290,53 @@ function priceOption(
  * (pricing model failure for that strategy/DTE combination).
  */
 export function decomposeGreeks(config: GreeksDecompositionConfig): GreeksDecompositionResult {
-  const { pnlPath, legs, underlyingPrices, legGroups, legPricingInputs, riskFreeRate, dividendYield } = config;
+  const {
+    pnlPath,
+    legs,
+    underlyingPrices,
+    legGroups,
+    legPricingInputs,
+    riskFreeRate,
+    dividendYield,
+  } = config;
 
   // Edge case: empty or single-point path
   if (pnlPath.length <= 1) {
     const emptyFactors: FactorContribution[] = [
-      { factor: 'delta', totalPnl: 0, pctOfTotal: 0, steps: [] },
-      { factor: 'gamma', totalPnl: 0, pctOfTotal: 0, steps: [] },
-      { factor: 'theta', totalPnl: 0, pctOfTotal: 0, steps: [] },
-      { factor: 'vega', totalPnl: 0, pctOfTotal: 0, steps: [] },
-      { factor: 'residual', totalPnl: 0, pctOfTotal: 0, steps: [] },
+      { factor: "delta", totalPnl: 0, pctOfTotal: 0, steps: [] },
+      { factor: "gamma", totalPnl: 0, pctOfTotal: 0, steps: [] },
+      { factor: "theta", totalPnl: 0, pctOfTotal: 0, steps: [] },
+      { factor: "vega", totalPnl: 0, pctOfTotal: 0, steps: [] },
+      { factor: "residual", totalPnl: 0, pctOfTotal: 0, steps: [] },
     ];
     return {
       factors: emptyFactors,
-      legGroupVega: legGroups ? legGroups.map(g => ({
-        label: g.label,
-        legIndices: g.legIndices,
-        totalVegaPnl: 0,
-        avgIvChange: 0,
-        steps: [],
-      })) : undefined,
+      legGroupVega: legGroups
+        ? legGroups.map((g) => ({
+            label: g.label,
+            legIndices: g.legIndices,
+            totalVegaPnl: 0,
+            avgIvChange: 0,
+            steps: [],
+          }))
+        : undefined,
       totalPnlChange: 0,
       totalAttributed: 0,
       totalResidual: 0,
       stepCount: 0,
-      summary: 'No P&L path to decompose (0 steps)',
+      summary: "No P&L path to decompose (0 steps)",
       warning: null,
-      method: 'full_reval',
+      method: "full_reval",
     };
   }
 
   const stepCount = pnlPath.length - 1;
-  const canFullReval = legPricingInputs && legPricingInputs.length === legs.length
-    && riskFreeRate !== undefined && dividendYield !== undefined && underlyingPrices;
+  const canFullReval =
+    legPricingInputs &&
+    legPricingInputs.length === legs.length &&
+    riskFreeRate !== undefined &&
+    dividendYield !== undefined &&
+    underlyingPrices;
   const r = riskFreeRate ?? 0.045;
   const q = dividendYield ?? 0.015;
 
@@ -349,17 +374,26 @@ export function decomposeGreeks(config: GreeksDecompositionConfig): GreeksDecomp
 
     for (let j = 0; j < legCount; j++) {
       const positionSize = legs[j].quantity * legs[j].multiplier;
-      const legActualChange = ((next.legPrices?.[j] ?? 0) - (cur.legPrices?.[j] ?? 0)) * positionSize;
+      const legActualChange =
+        ((next.legPrices?.[j] ?? 0) - (cur.legPrices?.[j] ?? 0)) * positionSize;
 
       const curIv = cur.legGreeks?.[j]?.iv;
       const nextIv = next.legGreeks?.[j]?.iv;
       const lpi = legPricingInputs?.[j];
 
       // Full revaluation: reprice with one input changed at a time
-      if (canFullReval && lpi && S1 !== undefined && S2 !== undefined
-          && curIv !== null && curIv !== undefined && curIv > 0
-          && nextIv !== null && nextIv !== undefined && nextIv > 0) {
-
+      if (
+        canFullReval &&
+        lpi &&
+        S1 !== undefined &&
+        S2 !== undefined &&
+        curIv !== null &&
+        curIv !== undefined &&
+        curIv > 0 &&
+        nextIv !== null &&
+        nextIv !== undefined &&
+        nextIv > 0
+      ) {
         const dte1 = computeDte(cur.timestamp, lpi.expiryDate);
         const dte2 = computeDte(next.timestamp, lpi.expiryDate);
 
@@ -382,14 +416,25 @@ export function decomposeGreeks(config: GreeksDecompositionConfig): GreeksDecomp
           // Vanna (spot×vol): P(S2, T1, σ2) - base - delta - vega
           const priceVanna = priceOption(lpi.type, S2, lpi.strike, dte1, r, q, nextIv);
 
-          if (priceBase !== null && priceDelta !== null && priceTheta !== null
-              && priceVega !== null && priceCharm !== null && priceVanna !== null) {
+          if (
+            priceBase !== null &&
+            priceDelta !== null &&
+            priceTheta !== null &&
+            priceVega !== null &&
+            priceCharm !== null &&
+            priceVanna !== null
+          ) {
             const legDeltaPnl = (priceDelta - priceBase) * positionSize;
             const legThetaPnl = (priceTheta - priceBase) * positionSize;
             const legVegaPnl = (priceVega - priceBase) * positionSize;
-            const legCharmPnl = ((priceCharm - priceBase) - (priceDelta - priceBase) - (priceTheta - priceBase)) * positionSize;
-            const legVannaPnl = ((priceVanna - priceBase) - (priceDelta - priceBase) - (priceVega - priceBase)) * positionSize;
-            const legResidual = legActualChange - legDeltaPnl - legThetaPnl - legVegaPnl - legCharmPnl - legVannaPnl;
+            const legCharmPnl =
+              (priceCharm - priceBase - (priceDelta - priceBase) - (priceTheta - priceBase)) *
+              positionSize;
+            const legVannaPnl =
+              (priceVanna - priceBase - (priceDelta - priceBase) - (priceVega - priceBase)) *
+              positionSize;
+            const legResidual =
+              legActualChange - legDeltaPnl - legThetaPnl - legVegaPnl - legCharmPnl - legVannaPnl;
 
             stepDelta += legDeltaPnl;
             stepTheta += legThetaPnl;
@@ -439,28 +484,32 @@ export function decomposeGreeks(config: GreeksDecompositionConfig): GreeksDecomp
   // - vanna: spot×vol cross-effect (delta changing with vol)
   // - residual: triple cross (spot+time+vol simultaneously) + model error
   const rawFactors: Array<{ factor: FactorName; totalPnl: number; steps: number[] }> = [
-    { factor: 'delta', totalPnl: sumSteps(deltaSteps), steps: deltaSteps },
-    { factor: 'theta', totalPnl: sumSteps(thetaSteps), steps: thetaSteps },
-    { factor: 'vega', totalPnl: sumSteps(vegaSteps), steps: vegaSteps },
-    { factor: 'charm', totalPnl: sumSteps(charmSteps), steps: charmSteps },
-    { factor: 'vanna', totalPnl: sumSteps(vannaSteps), steps: vannaSteps },
-    { factor: 'residual', totalPnl: sumSteps(residualSteps), steps: residualSteps },
+    { factor: "delta", totalPnl: sumSteps(deltaSteps), steps: deltaSteps },
+    { factor: "theta", totalPnl: sumSteps(thetaSteps), steps: thetaSteps },
+    { factor: "vega", totalPnl: sumSteps(vegaSteps), steps: vegaSteps },
+    { factor: "charm", totalPnl: sumSteps(charmSteps), steps: charmSteps },
+    { factor: "vanna", totalPnl: sumSteps(vannaSteps), steps: vannaSteps },
+    { factor: "residual", totalPnl: sumSteps(residualSteps), steps: residualSteps },
   ];
 
   rawFactors.sort((a, b) => Math.abs(b.totalPnl) - Math.abs(a.totalPnl));
   const totalAbsSum = rawFactors.reduce((s, f) => s + Math.abs(f.totalPnl), 0);
-  const factors: FactorContribution[] = rawFactors.map(f => ({
+  const factors: FactorContribution[] = rawFactors.map((f) => ({
     ...f,
     pctOfTotal: totalAbsSum > 0 ? (Math.abs(f.totalPnl) / totalAbsSum) * 100 : 0,
   }));
 
   const totalPnlChange = pnlPath[pnlPath.length - 1].strategyPnl - pnlPath[0].strategyPnl;
   const totalResidual = sumSteps(residualSteps);
-  const totalAttributed = sumSteps(deltaSteps) + sumSteps(thetaSteps) + sumSteps(vegaSteps) + sumSteps(charmSteps) + sumSteps(vannaSteps);
+  const totalAttributed =
+    sumSteps(deltaSteps) +
+    sumSteps(thetaSteps) +
+    sumSteps(vegaSteps) +
+    sumSteps(charmSteps) +
+    sumSteps(vannaSteps);
 
-  const residualPct = Math.abs(totalPnlChange) > 0.01
-    ? Math.abs(totalResidual) / Math.abs(totalPnlChange)
-    : 0;
+  const residualPct =
+    Math.abs(totalPnlChange) > 0.01 ? Math.abs(totalResidual) / Math.abs(totalPnlChange) : 0;
 
   // Numerical fallback when full reval still produces >80% residual
   // (model pricing failure — BS/Bachelier can't accurately price these options)
@@ -502,19 +551,22 @@ export function decomposeGreeks(config: GreeksDecompositionConfig): GreeksDecomp
   }
 
   // Build summary
-  const methodLabel = canFullReval ? 'full_reval' : 'model';
+  const methodLabel = canFullReval ? "full_reval" : "model";
   const summaryParts = factors
-    .filter(f => f.factor !== 'residual')
-    .map(f => `${f.factor} ${f.totalPnl.toFixed(2)} (${f.pctOfTotal.toFixed(0)}%)`);
-  const residualFactor = factors.find(f => f.factor === 'residual');
+    .filter((f) => f.factor !== "residual")
+    .map((f) => `${f.factor} ${f.totalPnl.toFixed(2)} (${f.pctOfTotal.toFixed(0)}%)`);
+  const residualFactor = factors.find((f) => f.factor === "residual");
   if (residualFactor && Math.abs(residualFactor.totalPnl) > 0.01) {
-    summaryParts.push(`residual ${residualFactor.totalPnl.toFixed(2)} (${residualFactor.pctOfTotal.toFixed(0)}%)`);
+    summaryParts.push(
+      `residual ${residualFactor.totalPnl.toFixed(2)} (${residualFactor.pctOfTotal.toFixed(0)}%)`,
+    );
   }
-  const summary = `P&L of ${totalPnlChange.toFixed(2)} (${methodLabel}): ${summaryParts.join(', ')}`;
+  const summary = `P&L of ${totalPnlChange.toFixed(2)} (${methodLabel}): ${summaryParts.join(", ")}`;
 
-  const warning = residualPct > 0.5
-    ? `Residual ${(residualPct * 100).toFixed(0)}% — attribution limited for some legs.`
-    : null;
+  const warning =
+    residualPct > 0.5
+      ? `Residual ${(residualPct * 100).toFixed(0)}% — attribution limited for some legs.`
+      : null;
 
   return {
     factors,
@@ -525,6 +577,6 @@ export function decomposeGreeks(config: GreeksDecompositionConfig): GreeksDecomp
     stepCount,
     summary,
     warning,
-    method: canFullReval ? 'full_reval' : 'model',
+    method: canFullReval ? "full_reval" : "model",
   };
 }

package/src/utils/iv-solver-pool.ts

@@ -146,7 +146,12 @@ function jobsToColumns(jobs: IvSolveJob[]): IvSolveColumns {
 }
 
 /** Slice a column batch into a per-shard request, copying the [lo, hi) window. */
-function shardRequest(cols: IvSolveColumns, id: number, lo: number, hi: number): IvSolveBatchRequest {
+function shardRequest(
+  cols: IvSolveColumns,
+  id: number,
+  lo: number,
+  hi: number,
+): IvSolveBatchRequest {
   return {
     id,
     count: hi - lo,
@@ -283,37 +288,52 @@ export class IvSolverPool {
       ok: new Uint8Array(cols.count),
     };
 
-    const base = Math.floor(cols.count / shardCount);
-    const remainder = cols.count % shardCount;
-    const shardPromises: Promise<void>[] = [];
-    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);
-        }),
-      );
-    }
+    // Ref the workers for the duration of this in-flight solve so the event
+    // loop stays alive until every shard's result is back — the process can't
+    // exit mid-solve and lose results. Idle workers are unref'd (see
+    // ensureWorkers), so once the solve completes the pool stops pinning the
+    // loop and a one-shot process exits naturally.
+    this.refPool();
+    try {
+      const base = Math.floor(cols.count / shardCount);
+      const remainder = cols.count % shardCount;
+      const shardPromises: Promise<void>[] = [];
+      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;
+      await Promise.all(shardPromises);
+      return out;
+    } finally {
+      this.unrefPool();
+    }
   }
 
   private ensureWorkers(target: number): void {
     while (this.pool.length < target) {
       const worker = new Worker(this.workerUrl);
       worker.setMaxListeners(0);
+      // Idle workers must not keep the libuv event loop alive — otherwise a
+      // one-shot process that uses the pool and returns normally would hang
+      // forever. solveColumnsParallel ref's the pool for the duration of an
+      // in-flight solve and unref's it again when done.
+      worker.unref();
       // Surface a worker crash by failing loud; an unhandled worker error
       // would otherwise leave the pending shard promise hanging forever.
       worker.on("error", (err) => {
@@ -323,6 +343,16 @@ export class IvSolverPool {
     }
   }
 
+  /** Keep the event loop alive while a solve is in flight. */
+  private refPool(): void {
+    for (const { worker } of this.pool) worker.ref();
+  }
+
+  /** Release the event loop once a solve completes so idle workers don't pin it. */
+  private unrefPool(): void {
+    for (const { worker } of this.pool) worker.unref();
+  }
+
   private runOnWorker(request: IvSolveBatchRequest): Promise<IvSolveBatchReply> {
     return new Promise<IvSolveBatchReply>((resolve, reject) => {
       const slot = this.acquire();

package/src/utils/iv-solver-worker.ts

@@ -74,11 +74,11 @@ export function solveIvBatch(req: IvSolveBatchRequest): IvSolveBatchReply {
       req.dividendYield[i],
     );
     if (
-      isFiniteNumber(result.delta)
-      && isFiniteNumber(result.gamma)
-      && isFiniteNumber(result.theta)
-      && isFiniteNumber(result.vega)
-      && isFiniteNumber(result.iv)
+      isFiniteNumber(result.delta) &&
+      isFiniteNumber(result.gamma) &&
+      isFiniteNumber(result.theta) &&
+      isFiniteNumber(result.vega) &&
+      isFiniteNumber(result.iv)
     ) {
       delta[i] = result.delta;
       gamma[i] = result.gamma;