@pear-protocol/utils 0.0.23 → 0.2.0

package/dist/index.js

@@ -1,11 +1,84 @@
-import BigNumber7, { BigNumber } from 'bignumber.js';
+import BigNumber9 from 'bignumber.js';
+import { sha256 } from '@noble/hashes/sha256';
+import { bytesToHex } from '@noble/hashes/utils';
 
 // src/asset/compute.ts
-var ZERO = new BigNumber7(0);
-var BIPS = new BigNumber7(1e4);
+function parse(value) {
+  return value instanceof BigNumber9 ? value : new BigNumber9(value);
+}
+function toDecimalString(value) {
+  return parse(value).toFixed();
+}
+function signed(value) {
+  const bn = parse(value);
+  return bn.isNegative() && !bn.isZero() ? bn.toFixed() : `+${bn.toFixed()}`;
+}
+function add(a, b) {
+  return parse(a).plus(parse(b));
+}
+function subtract(a, b) {
+  return parse(a).minus(parse(b));
+}
+function multiply(a, b) {
+  return parse(a).times(parse(b));
+}
+function divide(a, b) {
+  return parse(a).div(parse(b));
+}
+function negate(value) {
+  return parse(value).negated();
+}
+function abs(value) {
+  return parse(value).abs();
+}
+function min(a, b) {
+  return BigNumber9.min(parse(a), parse(b));
+}
+function isZero(value) {
+  return parse(value).isZero();
+}
+function isPositive(value) {
+  return parse(value).isPositive();
+}
+function isNegative(value) {
+  return parse(value).isNegative();
+}
+function isFiniteDecimal(value) {
+  return parse(value).isFinite();
+}
+function isEqualTo(a, b) {
+  return parse(a).isEqualTo(parse(b));
+}
+function isGreaterThan(a, b) {
+  return parse(a).isGreaterThan(parse(b));
+}
+function isGreaterThanOrEqual(a, b) {
+  return parse(a).isGreaterThanOrEqualTo(parse(b));
+}
+function isLessThan(a, b) {
+  return parse(a).isLessThan(parse(b));
+}
+function isLessThanOrEqual(a, b) {
+  return parse(a).isLessThanOrEqualTo(parse(b));
+}
+function sideSign(side) {
+  switch (side) {
+    case "BUY":
+      return 1;
+    case "SELL":
+      return -1;
+  }
+}
+function signedBySide(value, side) {
+  return parse(value).times(sideSign(side));
+}
+
+// src/math/index.ts
+var ZERO = new BigNumber9(0);
+var BIPS = new BigNumber9(1e4);
 function exponentiate(value) {
   const result = Math.exp(value);
-  return new BigNumber7(result);
+  return new BigNumber9(result);
 }
 function sign(value) {
   if (value.isZero()) return 0;
@@ -24,11 +97,11 @@ function computeEntryPriceForAsset(fills) {
   let entryPrice = ZERO;
   let positionSize = ZERO;
   for (const fill of fills) {
-    const price = new BigNumber7(fill.price);
-    const quantity = new BigNumber7(fill.quantity);
-    const signed = fill.side === "BUY" ? quantity : quantity.negated();
-    const newPositionSize = positionSize.plus(signed);
-    const isSameDirection = !positionSize.isZero() && positionSize.isPositive() === signed.isPositive();
+    const price = new BigNumber9(fill.price);
+    const quantity = new BigNumber9(fill.quantity);
+    const signed2 = fill.side === "BUY" ? quantity : quantity.negated();
+    const newPositionSize = positionSize.plus(signed2);
+    const isSameDirection = !positionSize.isZero() && positionSize.isPositive() === signed2.isPositive();
     const isFlip = !positionSize.isZero() && !newPositionSize.isZero() && newPositionSize.isPositive() !== positionSize.isPositive();
     if (positionSize.isZero() || isFlip) {
       entryPrice = price;
@@ -42,56 +115,52 @@ function computeEntryPriceForAsset(fills) {
 
 // src/asset/compute.ts
 function computeAssetEntryNotional(signedQuantity, fills) {
-  if (signedQuantity.isZero()) return ZERO;
+  if (signedQuantity.isZero()) {
+    return ZERO;
+  }
   const entryPrice = computeEntryPriceForAsset(fills);
-  if (entryPrice.isZero()) return ZERO;
+  if (entryPrice.isZero()) {
+    return ZERO;
+  }
   const unsignedQuantity = signedQuantity.abs();
   return unsignedQuantity.multipliedBy(entryPrice);
 }
 function computeAssetUnrealizedPnL(signedQuantity, currentPrice, fills) {
-  if (signedQuantity.isZero()) return ZERO;
+  if (signedQuantity.isZero()) {
+    return ZERO;
+  }
   const entryPrice = computeEntryPriceForAsset(fills);
-  if (entryPrice.isZero()) return ZERO;
+  if (entryPrice.isZero()) {
+    return ZERO;
+  }
   const deltaPrice = currentPrice.minus(entryPrice);
   return signedQuantity.multipliedBy(deltaPrice);
 }
 function computeAssetGrossRealizedPnL(fills) {
-  let entryPrice = ZERO;
-  let positionSize = ZERO;
-  let gross = ZERO;
-  for (const fill of fills) {
-    const price = new BigNumber7(fill.price);
-    const quantity = new BigNumber7(fill.quantity);
-    const signed = fill.side === "BUY" ? quantity : quantity.negated();
-    const newPositionSize = positionSize.plus(signed);
-    if (!positionSize.isZero() && positionSize.isPositive() !== signed.isPositive()) {
-      const closedQty = BigNumber7.min(positionSize.abs(), signed.abs());
-      if (positionSize.isPositive()) {
-        gross = gross.plus(closedQty.multipliedBy(price.minus(entryPrice)));
-      } else {
-        gross = gross.plus(closedQty.multipliedBy(entryPrice.minus(price)));
-      }
-    }
-    const isSameDirection = !positionSize.isZero() && positionSize.isPositive() === signed.isPositive();
-    const isFlip = !positionSize.isZero() && !newPositionSize.isZero() && newPositionSize.isPositive() !== positionSize.isPositive();
-    if (positionSize.isZero() || isFlip) {
-      entryPrice = price;
-    } else if (isSameDirection) {
-      entryPrice = entryPrice.times(positionSize.abs()).plus(price.times(quantity)).div(newPositionSize.abs());
+  return walkAssetFills(fills).gross;
+}
+function computeAssetUndeterminedSizes(fills) {
+  const result = {};
+  for (const asset of computeAssetRealizedPnLs(fills)) {
+    if (!asset.undeterminedSize.isZero()) {
+      result[asset.id] = asset.undeterminedSize;
     }
-    positionSize = newPositionSize;
   }
-  return gross;
+  return result;
 }
 function computeAssetUnrealizedPnLs(exposureMap, priceMap, fills) {
   const result = [];
   for (const [id, signedQtyString] of Object.entries(exposureMap)) {
     const priceString = priceMap[id];
-    if (!priceString) continue;
-    const signedQuantity = new BigNumber7(signedQtyString);
-    if (signedQuantity.isZero()) continue;
-    const currentPrice = new BigNumber7(priceString);
-    const assetFills = fills.filter((f) => f.symbol === id);
+    if (!priceString) {
+      continue;
+    }
+    const signedQuantity = new BigNumber9(signedQtyString);
+    if (signedQuantity.isZero()) {
+      continue;
+    }
+    const currentPrice = new BigNumber9(priceString);
+    const assetFills = fills.filter((fill) => fill.symbol === id);
     const entryPrice = computeEntryPriceForAsset(assetFills);
     const upnl = signedQuantity.multipliedBy(currentPrice.minus(entryPrice));
     result.push({
@@ -106,22 +175,23 @@ function computeAssetUnrealizedPnLs(exposureMap, priceMap, fills) {
 }
 function computeAssetRealizedPnLs(fills) {
   const bySymbol = /* @__PURE__ */ new Map();
-  for (const f of fills) {
-    const list = bySymbol.get(f.symbol) ?? [];
-    list.push(f);
-    bySymbol.set(f.symbol, list);
+  for (const fill of fills) {
+    const list = bySymbol.get(fill.symbol) ?? [];
+    list.push(fill);
+    bySymbol.set(fill.symbol, list);
   }
   const result = [];
   for (const [id, assetFills] of bySymbol) {
-    const tradeFees = assetFills.reduce((acc, f) => acc.plus(new BigNumber7(f.tradeFee ?? "0")), ZERO);
-    const pearFees = assetFills.reduce((acc, f) => acc.plus(new BigNumber7(f.pearFee ?? "0")), ZERO);
+    const tradeFees = assetFills.reduce((acc, fill) => acc.plus(new BigNumber9(fill.tradeFee ?? "0")), ZERO);
+    const pearFees = assetFills.reduce((acc, fill) => acc.plus(new BigNumber9(fill.pearFee ?? "0")), ZERO);
     const totalFees = tradeFees.plus(pearFees);
-    const grossPnl = computeAssetGrossRealizedPnL(assetFills);
+    const { gross: grossPnl, undeterminedSize } = walkAssetFills(assetFills);
     const netPnl = grossPnl.minus(totalFees);
     result.push({
       id,
       grossPnl,
       netPnl,
+      undeterminedSize,
       totalFees,
       tradeFees,
       pearFees
@@ -129,48 +199,148 @@ function computeAssetRealizedPnLs(fills) {
   }
   return result;
 }
+function walkAssetFills(fills) {
+  let entryPrice = ZERO;
+  let positionSize = ZERO;
+  let basisUnpriced = false;
+  let gross = ZERO;
+  let undeterminedSize = ZERO;
+  for (const fill of fills) {
+    const price = parse(fill.price);
+    const quantity = parse(fill.quantity);
+    const signedQuantity = signedBySide(quantity, fill.side);
+    const newPositionSize = add(positionSize, signedQuantity);
+    if (!isZero(positionSize) && isPositive(positionSize) !== isPositive(signedQuantity)) {
+      const closedQty = min(positionSize.abs(), signedQuantity.abs());
+      if (basisUnpriced || isZero(price)) {
+        undeterminedSize = add(undeterminedSize, closedQty);
+      } else if (isPositive(positionSize)) {
+        gross = add(gross, multiply(closedQty, subtract(price, entryPrice)));
+      } else {
+        gross = add(gross, multiply(closedQty, subtract(entryPrice, price)));
+      }
+    }
+    const isSameDirection = !isZero(positionSize) && isPositive(positionSize) === isPositive(signedQuantity);
+    const isFlip = !isZero(positionSize) && !isZero(newPositionSize) && isPositive(newPositionSize) !== isPositive(positionSize);
+    if (isZero(positionSize) || isFlip) {
+      entryPrice = price;
+      basisUnpriced = isZero(price);
+    } else if (isSameDirection) {
+      entryPrice = entryPrice.times(positionSize.abs()).plus(price.times(quantity)).div(newPositionSize.abs());
+      basisUnpriced = basisUnpriced || isZero(price);
+    }
+    positionSize = newPositionSize;
+  }
+  return { gross, undeterminedSize };
+}
 function computeBasketWeightedRatioV1(basket, priceMap) {
   let logSum = 0;
   for (const leg of basket) {
     const price = priceMap[leg.symbol];
-    if (!price) return null;
+    if (!price) {
+      return null;
+    }
     const priceNum = Number(price);
-    if (priceNum <= 0) return null;
+    if (priceNum <= 0) {
+      return null;
+    }
     const sign2 = leg.side === "BUY" ? 1 : -1;
     logSum += sign2 * leg.weight * Math.log(priceNum);
   }
   return exponentiate(logSum);
 }
 function contractsToBase(contracts, contractSize) {
-  return new BigNumber7(contracts).times(contractSize);
+  return new BigNumber9(contracts).times(contractSize);
 }
 function baseToContracts(base, contractSize) {
-  return new BigNumber7(base).div(contractSize);
+  return new BigNumber9(base).div(contractSize);
 }
-function computePositionMarkNotional(assetUPnLs) {
-  return assetUPnLs.reduce((acc, asset) => {
-    if (asset.signedQuantity.isZero()) return acc;
-    return acc.plus(asset.signedQuantity.abs().multipliedBy(asset.currentPrice));
-  }, ZERO);
+function computeRealizedPnlBySymbol(fills) {
+  const bySymbol = groupFillsBySymbol(fills);
+  const result = /* @__PURE__ */ new Map();
+  for (const [symbol, symbolFills] of bySymbol) {
+    const sorted = [...symbolFills].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+    result.set(symbol, computeRealizedForSymbol(sorted));
+  }
+  return result;
 }
-function computePositionEntryNotional(assetUPnLs) {
-  return assetUPnLs.reduce((acc, asset) => {
-    if (asset.signedQuantity.isZero()) return acc;
-    return acc.plus(asset.signedQuantity.abs().multipliedBy(asset.entryPrice));
-  }, ZERO);
+function computeRealizedPnlFromFills(fills) {
+  const byPnl = computeRealizedPnlBySymbol(fills);
+  let total = ZERO;
+  for (const pnl of byPnl.values()) {
+    total = total.plus(pnl);
+  }
+  return total;
 }
-function computePositionUnrealizedPnL(assetUPnLs) {
-  return assetUPnLs.reduce((acc, asset) => acc.plus(asset.upnl), ZERO);
+function groupFillsBySymbol(fills) {
+  const bySymbol = /* @__PURE__ */ new Map();
+  for (const fill of fills) {
+    const list = bySymbol.get(fill.symbol) ?? [];
+    list.push(fill);
+    bySymbol.set(fill.symbol, list);
+  }
+  return bySymbol;
 }
-function computePositionGrossRealizedPnL(assetPnLs) {
-  return assetPnLs.reduce((acc, asset) => acc.plus(asset.grossPnl), ZERO);
+function computeRealizedForSymbol(fills) {
+  let entryPrice = ZERO;
+  let positionSize = ZERO;
+  let realized = ZERO;
+  for (const fill of fills) {
+    const price = new BigNumber9(fill.price);
+    const quantity = new BigNumber9(fill.quantity);
+    const signed2 = fill.side === "BUY" ? quantity : quantity.negated();
+    const newPositionSize = positionSize.plus(signed2);
+    if (!positionSize.isZero() && positionSize.isPositive() !== signed2.isPositive()) {
+      const closedQty = BigNumber9.min(positionSize.abs(), signed2.abs());
+      if (positionSize.isPositive()) {
+        realized = realized.plus(closedQty.multipliedBy(price.minus(entryPrice)));
+      } else {
+        realized = realized.plus(closedQty.multipliedBy(entryPrice.minus(price)));
+      }
+    }
+    const isSameDirection = !positionSize.isZero() && positionSize.isPositive() === signed2.isPositive();
+    const isFlip = !positionSize.isZero() && !newPositionSize.isZero() && newPositionSize.isPositive() !== positionSize.isPositive();
+    if (positionSize.isZero() || isFlip) {
+      entryPrice = price;
+    } else if (isSameDirection) {
+      entryPrice = entryPrice.times(positionSize.abs()).plus(price.times(quantity)).div(newPositionSize.abs());
+    }
+    positionSize = newPositionSize;
+  }
+  return realized;
 }
-function computePositionNetRealizedPnL(assetPnLs) {
-  return assetPnLs.reduce((acc, asset) => acc.plus(asset.netPnl), ZERO);
+function computeUnrealizedPositionState(exposureMap, priceMap, fills) {
+  const assetUPnLs = computeAssetUnrealizedPnLs(exposureMap, priceMap, fills);
+  const entryPrice = computePositionEntryPrice(assetUPnLs);
+  const entryNotional = computePositionEntryNotional(assetUPnLs);
+  const markPrice = computePositionCurrentPrice(assetUPnLs);
+  const markNotional = computePositionMarkNotional(assetUPnLs);
+  const upnl = computePositionUnrealizedPnL(assetUPnLs);
+  const upnlBips = computePositionUnrealizedPnLBips(upnl, entryNotional);
+  return {
+    assetUPnLs,
+    entryPrice,
+    entryNotional,
+    markPrice,
+    markNotional,
+    upnl,
+    upnlBips
+  };
 }
-function computePositionUnrealizedPnLBips(upnl, entryNotional) {
-  if (upnl.isZero() || entryNotional.isZero()) return ZERO;
-  return upnl.div(entryNotional).multipliedBy(BIPS);
+function computeRealizedPositionState(fills) {
+  const assetPnLs = computeAssetRealizedPnLs(fills);
+  const grossPnl = computePositionGrossRealizedPnL(assetPnLs);
+  const netPnl = computePositionNetRealizedPnL(assetPnLs);
+  const tradeFees = assetPnLs.reduce((acc, asset) => acc.plus(asset.tradeFees), ZERO);
+  const pearFees = assetPnLs.reduce((acc, asset) => acc.plus(asset.pearFees), ZERO);
+  const totalFees = tradeFees.plus(pearFees);
+  return {
+    grossPnl,
+    netPnl,
+    totalFees,
+    tradeFees,
+    pearFees
+  };
 }
 function computePositionEntryPrice(assetUPnLs) {
   const { totalWeightedPrice, totalWeight } = assetUPnLs.reduce(
@@ -191,6 +361,14 @@ function computePositionEntryPrice(assetUPnLs) {
   }
   return totalWeightedPrice.dividedBy(totalWeight);
 }
+function computePositionEntryNotional(assetUPnLs) {
+  return assetUPnLs.reduce((acc, asset) => {
+    if (asset.signedQuantity.isZero()) {
+      return acc;
+    }
+    return acc.plus(asset.signedQuantity.abs().multipliedBy(asset.entryPrice));
+  }, ZERO);
+}
 function computePositionCurrentPrice(assetUPnLs) {
   const { totalWeightedPrice, totalWeight } = assetUPnLs.reduce(
     (acc, { signedQuantity, currentPrice }) => {
@@ -210,42 +388,71 @@ function computePositionCurrentPrice(assetUPnLs) {
   }
   return totalWeightedPrice.dividedBy(totalWeight);
 }
-function computeUnrealizedPositionState(exposureMap, priceMap, fills) {
-  const assetUPnLs = computeAssetUnrealizedPnLs(exposureMap, priceMap, fills);
+function computePositionMarkNotional(assetUPnLs) {
+  return assetUPnLs.reduce((acc, asset) => {
+    if (asset.signedQuantity.isZero()) {
+      return acc;
+    }
+    return acc.plus(asset.signedQuantity.abs().multipliedBy(asset.currentPrice));
+  }, ZERO);
+}
+function computePositionUnrealizedPnL(assetUPnLs) {
+  return assetUPnLs.reduce((acc, asset) => acc.plus(asset.upnl), ZERO);
+}
+function computePositionUnrealizedPnLBips(upnl, entryNotional) {
+  if (upnl.isZero() || entryNotional.isZero()) {
+    return ZERO;
+  }
+  return upnl.div(entryNotional).multipliedBy(BIPS);
+}
+function computePositionGrossRealizedPnL(assetPnLs) {
+  return assetPnLs.reduce((acc, asset) => acc.plus(asset.grossPnl), ZERO);
+}
+function computePositionNetRealizedPnL(assetPnLs) {
+  return assetPnLs.reduce((acc, asset) => acc.plus(asset.netPnl), ZERO);
+}
+function computePositionEntryPrices(exposureMap, fills) {
+  const entryPrices = {};
+  for (const instrumentId of Object.keys(exposureMap)) {
+    const assetFills = fills.filter((fill) => fill.symbol === instrumentId);
+    const entryPrice = computeEntryPriceForAsset(assetFills);
+    if (isZero(entryPrice)) continue;
+    entryPrices[instrumentId] = entryPrice.toFixed();
+  }
+  return entryPrices;
+}
+function computeUnrealizedPositionStateFromEntryPrices(exposureMap, entryPrices, priceMap) {
+  const assetUPnLs = [];
+  for (const [id, signedQuantityString] of Object.entries(exposureMap)) {
+    const currentPriceString = priceMap[id];
+    const entryPriceString = entryPrices[id];
+    if (!currentPriceString || !entryPriceString) continue;
+    const signedQuantity = parse(signedQuantityString);
+    if (isZero(signedQuantity)) continue;
+    const currentPrice = parse(currentPriceString);
+    const entryPrice2 = parse(entryPriceString);
+    const upnl2 = multiply(signedQuantity, subtract(currentPrice, entryPrice2));
+    assetUPnLs.push({ id, signedQuantity, entryPrice: entryPrice2, currentPrice, upnl: upnl2 });
+  }
   const entryPrice = computePositionEntryPrice(assetUPnLs);
   const entryNotional = computePositionEntryNotional(assetUPnLs);
   const markPrice = computePositionCurrentPrice(assetUPnLs);
   const markNotional = computePositionMarkNotional(assetUPnLs);
   const upnl = computePositionUnrealizedPnL(assetUPnLs);
   const upnlBips = computePositionUnrealizedPnLBips(upnl, entryNotional);
-  return {
-    assetUPnLs,
-    entryPrice,
-    entryNotional,
-    markPrice,
-    markNotional,
-    upnl,
-    upnlBips
-  };
+  return { assetUPnLs, entryPrice, entryNotional, markPrice, markNotional, upnl, upnlBips };
 }
-function computeRealizedPositionState(fills) {
-  const assetPnLs = computeAssetRealizedPnLs(fills);
-  const grossPnl = computePositionGrossRealizedPnL(assetPnLs);
-  const netPnl = computePositionNetRealizedPnL(assetPnLs);
-  const tradeFees = assetPnLs.reduce((acc, asset) => acc.plus(asset.tradeFees), ZERO);
-  const pearFees = assetPnLs.reduce((acc, asset) => acc.plus(asset.pearFees), ZERO);
-  const totalFees = tradeFees.plus(pearFees);
-  return {
-    grossPnl,
-    netPnl,
-    totalFees,
-    tradeFees,
-    pearFees
-  };
+function generateDeterministicPositionKey(input) {
+  const symbols = [...input.symbols].sort((a, b) => a.localeCompare(b));
+  const payload = JSON.stringify({
+    tradeAccountId: input.tradeAccountId.toLowerCase(),
+    symbols
+  });
+  return bytesToHex(sha256(new TextEncoder().encode(payload)));
 }
-BigNumber7.config({
+BigNumber9.config({
   DECIMAL_PLACES: 30,
-  ROUNDING_MODE: BigNumber7.ROUND_DOWN
+  ROUNDING_MODE: BigNumber9.ROUND_DOWN
 });
 function precisePrice(connector, raw, precision, side = "BUY", slippageToleranceBps = 0) {
   const normalized = normalizePrice(raw);
@@ -264,22 +471,22 @@ function withSlippageTolerance(normalized, slippageToleranceBps, side) {
   if (slippageToleranceBps === 0) {
     return normalized;
   }
-  const bps = new BigNumber7(slippageToleranceBps);
+  const bps = new BigNumber9(slippageToleranceBps);
   const factor = bps.div(1e4);
-  return side === "BUY" ? normalized.times(new BigNumber7(1).plus(factor)) : normalized.times(new BigNumber7(1).minus(factor));
+  return side === "BUY" ? normalized.times(new BigNumber9(1).plus(factor)) : normalized.times(new BigNumber9(1).minus(factor));
 }
 function preciseHyperliquidPrice(price, precision, side) {
   const maxDecimals = precision.price.decimals;
   const maxSigFigs = precision.price.sigFigs ?? 5;
-  const rounding = side === "BUY" ? BigNumber7.ROUND_FLOOR : BigNumber7.ROUND_CEIL;
+  const rounding = side === "BUY" ? BigNumber9.ROUND_FLOOR : BigNumber9.ROUND_CEIL;
   price = price.decimalPlaces(maxDecimals, rounding);
   price = clampSigFigs(price, maxSigFigs, maxDecimals, rounding);
   return price.toFixed();
 }
 function preciseTickGridPrice(price, precision, side) {
   const tick = precision.price.tick ?? 1e-4;
-  const rounding = side === "BUY" ? BigNumber7.ROUND_FLOOR : BigNumber7.ROUND_CEIL;
-  const tickBN = new BigNumber7(tick);
+  const rounding = side === "BUY" ? BigNumber9.ROUND_FLOOR : BigNumber9.ROUND_CEIL;
+  const tickBN = new BigNumber9(tick);
   const scaled = price.div(tickBN);
   const snapped = scaled.integerValue(rounding).times(tickBN);
   const maxDecimals = precision.price.decimals;
@@ -287,12 +494,12 @@ function preciseTickGridPrice(price, precision, side) {
   return final.toFixed();
 }
 function clampSigFigs(price, maxSigFigs, maxDecimals, rounding) {
-  const countSigFigs = (x) => x.toFixed().replace(".", "").replace(/^0+/, "").length;
+  const countSigFigs = (value) => value.toFixed().replace(".", "").replace(/^0+/, "").length;
   if (countSigFigs(price) <= maxSigFigs) {
     return price;
   }
-  for (let d = maxDecimals; d >= 0; d--) {
-    const candidate = price.decimalPlaces(d, rounding);
+  for (let decimals = maxDecimals; decimals >= 0; decimals--) {
+    const candidate = price.decimalPlaces(decimals, rounding);
     if (countSigFigs(candidate) <= maxSigFigs) {
       return candidate;
     }
@@ -300,12 +507,12 @@ function clampSigFigs(price, maxSigFigs, maxDecimals, rounding) {
   return price;
 }
 function normalizePrice(value) {
-  const bn = new BigNumber7(value);
-  return new BigNumber7(bn.toFixed());
+  const parsed = new BigNumber9(value);
+  return new BigNumber9(parsed.toFixed());
 }
-BigNumber7.config({
+BigNumber9.config({
   DECIMAL_PLACES: 30,
-  ROUNDING_MODE: BigNumber7.ROUND_DOWN
+  ROUNDING_MODE: BigNumber9.ROUND_DOWN
 });
 function preciseQuantity(connector, raw, precision, side) {
   switch (connector) {
@@ -320,222 +527,1081 @@ function preciseQuantity(connector, raw, precision, side) {
 }
 function preciseHyperliquidQuantity(raw, precision, side) {
   const decimals = precision.quantity.decimals;
-  const qty = new BigNumber7(raw);
-  const rounded = qty.decimalPlaces(decimals, side === "BUY" ? BigNumber7.ROUND_FLOOR : BigNumber7.ROUND_CEIL);
+  const quantity = new BigNumber9(raw);
+  const rounded = quantity.decimalPlaces(decimals, side === "BUY" ? BigNumber9.ROUND_FLOOR : BigNumber9.ROUND_CEIL);
   return rounded.toFixed();
 }
 function preciseStepGridQuantity(raw, precision, side) {
   const step = precision.quantity.step;
-  const qty = baseToContracts(raw, precision.quantity.contractSize);
-  const stepBN = new BigNumber7(step);
-  const scaled = qty.div(stepBN);
-  const rounded = side === "BUY" ? scaled.integerValue(BigNumber7.ROUND_FLOOR) : scaled.integerValue(BigNumber7.ROUND_CEIL);
+  const contractQuantity = baseToContracts(raw, precision.quantity.contractSize);
+  const stepBN = new BigNumber9(step);
+  const scaled = contractQuantity.div(stepBN);
+  const rounded = side === "BUY" ? scaled.integerValue(BigNumber9.ROUND_FLOOR) : scaled.integerValue(BigNumber9.ROUND_CEIL);
   const result = rounded.times(stepBN);
   const maxDecimals = precision.quantity.decimals;
-  const final = result.decimalPlaces(maxDecimals, side === "BUY" ? BigNumber7.ROUND_FLOOR : BigNumber7.ROUND_CEIL);
+  const final = result.decimalPlaces(maxDecimals, side === "BUY" ? BigNumber9.ROUND_FLOOR : BigNumber9.ROUND_CEIL);
   return final.toFixed();
 }
-async function computeSyncPayload(args) {
-  const { openPositions, provisionalFills, confirmedExchangeFillIds, externalFills } = args;
-  const fillsToProcess = _prepareExternalFills(externalFills, confirmedExchangeFillIds);
-  if (fillsToProcess.length === 0) {
-    return null;
+
+// src/proxy.ts
+var activeOrigin = null;
+function configureProxy(config) {
+  if (!config?.enabled || !config.url) {
+    activeOrigin = null;
+    return;
   }
-  const { reconcilables, confirmables, orphanCreatables } = _seggregateExternalFills(provisionalFills, fillsToProcess);
-  const groupedConfirmables = confirmables.reduce((acc, fill) => {
-    acc[fill.positionId] = [...acc[fill.positionId] || [], fill];
-    return acc;
-  }, {});
-  const groupedCreatablesBySymbol = _groupCreatablesBySymbol(orphanCreatables, openPositions);
-  const groupedCreatables = {};
-  for (const group of groupedCreatablesBySymbol.values()) {
-    const zeroCrossing = _walkBackwardsToFindLastZeroCrossing(group);
-    for (const fill of zeroCrossing) {
-      const existing = groupedCreatables[fill.positionId];
-      if (existing) {
-        groupedCreatables[fill.positionId] = [...existing, fill];
-      } else {
-        groupedCreatables[fill.positionId] = [fill];
+  try {
+    activeOrigin = new URL(config.url).origin;
+  } catch {
+    activeOrigin = null;
+  }
+}
+function toProxyUrl(target, origin) {
+  const proxied = new URL(origin);
+  proxied.pathname = target.pathname;
+  proxied.search = target.search;
+  return proxied.toString();
+}
+async function withProxyFallback(proxied, direct) {
+  try {
+    const response = await proxied();
+    if (response.status < 500) return response;
+  } catch {
+  }
+  return direct();
+}
+function proxyFetch(input, init) {
+  const origin = activeOrigin;
+  if (!origin) return fetch(input, init);
+  const target = new URL(input);
+  const headers = new Headers(init?.headers);
+  headers.set("X-Proxy-Target", target.host);
+  return withProxyFallback(
+    () => fetch(toProxyUrl(target, origin), { ...init, headers }),
+    () => fetch(input, init)
+  );
+}
+
+// src/sync/applicables/constants.ts
+var DUST = parse("0.00000001");
+var MISSED_HISTORY_FILL_PREFIX = "opening-synthetic-";
+var BASKET_RULES = [
+  // V2 Basket Hyperliquid — legs of one Pear basket order share the order's cloid.
+  {
+    matches: (fill) => fill.connector === "hyperliquid" && isPearCloid(fill.connector, fill.cloid),
+    key: (fill) => `v2-basket-hl ${fill.cloid}`
+  }
+];
+function isPearCloid(connector, cloid) {
+  if (!cloid) {
+    return false;
+  }
+  return PEAR_CLOID_CHECK[connector]?.(cloid) ?? false;
+}
+var PEAR_CLOID_CHECK = {
+  hyperliquid: (cloid) => cloid.startsWith("0x50454152"),
+  lighter: (cloid) => cloid.length === 15 && cloid.startsWith("10")
+};
+
+// src/sync/applicables/basket.ts
+var Basket = class _Basket {
+  constructor(legs) {
+    this.legs = legs;
+  }
+  legs;
+  /** Detect baskets from a fill stream, returned in ascending time order. */
+  static detect(fills) {
+    return groupFillsIntoBaskets(fills).map((group) => new _Basket(combineFillsBySymbolAndSide(group)));
+  }
+  /** Active long symbol set the matcher compares against open positions. */
+  get longs() {
+    return new Set(this.legs.filter((leg) => leg.side === "BUY").map((leg) => leg.symbol));
+  }
+  /** Active short symbol set the matcher compares against open positions. */
+  get shorts() {
+    return new Set(this.legs.filter((leg) => leg.side === "SELL").map((leg) => leg.symbol));
+  }
+};
+var CombinedLeg = class {
+  constructor(symbol, side) {
+    this.symbol = symbol;
+    this.side = side;
+  }
+  symbol;
+  side;
+  _totalSize = ZERO;
+  queue = [];
+  get totalSize() {
+    return this._totalSize;
+  }
+  /** Append a fill to this leg's queue and grow the total size. */
+  addFill(fill) {
+    this._totalSize = this._totalSize.plus(fill.quantity);
+    this.queue.push({ fill, remaining: parse(fill.quantity) });
+  }
+  /**
+   * Take `qty` of fill slices from this leg (FIFO across source fills, consumes the queue).
+   * Returns the parts taken, which are consumed from the queue.
+   */
+  take(qty) {
+    const parts = [];
+    let need = qty;
+    for (const entry of this.queue) {
+      if (need.isLessThanOrEqualTo(0)) {
+        break;
+      }
+      if (entry.remaining.isZero()) {
+        continue;
       }
+      const taken = min(entry.remaining, need);
+      parts.push({ source: entry.fill, quantity: taken.toFixed() });
+      entry.remaining = entry.remaining.minus(taken);
+      need = need.minus(taken);
     }
+    return parts;
   }
-  for (const fills of Object.values(groupedCreatables)) {
-    fills.sort((a, b) => a.timestamp - b.timestamp);
+};
+function groupFillsIntoBaskets(fills) {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const fill of fills) {
+    const rule = BASKET_RULES.find((r) => r.matches(fill));
+    const key = rule ? rule.key(fill) : `id ${fill.exchangeFillId}`;
+    const bucket = buckets.get(key) ?? { timestamp: fill.timestamp, fills: [] };
+    bucket.timestamp = Math.min(bucket.timestamp, fill.timestamp);
+    bucket.fills.push(fill);
+    buckets.set(key, bucket);
   }
-  return {
-    reconcilables: Object.keys(reconcilables).length > 0 ? reconcilables : null,
-    confirmables: Object.keys(groupedConfirmables).length > 0 ? groupedConfirmables : null,
-    creatables: Object.keys(groupedCreatables).length > 0 ? groupedCreatables : null,
-    meta: {
-      externalMinTs: fillsToProcess[0]?.timestamp ?? null,
-      externalMaxTs: fillsToProcess[fillsToProcess.length - 1]?.timestamp ?? null,
-      processedCount: fillsToProcess.length
+  const sorted = [...buckets.values()].sort((a, b) => a.timestamp - b.timestamp);
+  return sorted.map((bucket) => bucket.fills);
+}
+function combineFillsBySymbolAndSide(group) {
+  const map = /* @__PURE__ */ new Map();
+  for (const fill of group) {
+    const key = `${fill.symbol}-${fill.side}`;
+    let combined = map.get(key);
+    if (!combined) {
+      combined = new CombinedLeg(fill.symbol, fill.side);
+      map.set(key, combined);
     }
+    combined.addFill(fill);
+  }
+  return [...map.values()];
+}
+
+// src/sync/applicables/exposure.ts
+var Exposure = class _Exposure {
+  constructor(legs) {
+    this.legs = legs;
+  }
+  legs;
+  /** Create an exposure with no legs — the starting state for a new position. */
+  static empty() {
+    return new _Exposure(/* @__PURE__ */ new Map());
+  }
+  /** Build from a wire `Record<symbol, quantity>` (existing DB position exposure). */
+  static fromRecord(record) {
+    const legs = /* @__PURE__ */ new Map();
+    for (const [symbol, qty] of Object.entries(record)) {
+      legs.set(symbol, parse(qty));
+    }
+    return new _Exposure(legs);
+  }
+  /** Net signed exposure a set of fill parts contributes for `symbol` (BUY +, SELL −). */
+  static netFromParts(parts, symbol) {
+    let total = ZERO;
+    for (const part of parts) {
+      if (part.source.symbol === symbol) {
+        total = total.plus(signedBySide(part.quantity, part.source.side));
+      }
+    }
+    return total;
+  }
+  /** Return an independent copy of this exposure so mutations do not alias. */
+  clone() {
+    return new _Exposure(new Map(this.legs));
+  }
+  /** Signed exposure for `symbol` (0 when absent). */
+  get(symbol) {
+    return this.legs.get(symbol) ?? ZERO;
+  }
+  /** Apply a signed `delta` to `symbol`, creating the leg if it does not exist. */
+  addDelta(symbol, delta) {
+    this.legs.set(symbol, this.get(symbol).plus(delta));
+  }
+  /** Convert a side+quantity pair to a signed delta and forward to `addDelta`. */
+  addSigned(symbol, quantity, side) {
+    this.addDelta(symbol, signedBySide(quantity, side));
+  }
+  /** Active (non-zero) long and short leg sets. */
+  activeLegs() {
+    const longs = /* @__PURE__ */ new Set();
+    const shorts = /* @__PURE__ */ new Set();
+    for (const [symbol, qty] of this.legs) {
+      switch (sign(qty)) {
+        case 1:
+          longs.add(symbol);
+          break;
+        case -1:
+          shorts.add(symbol);
+          break;
+      }
+    }
+    return { longs, shorts };
+  }
+  /** True once every leg sits within DUST of zero (effectively closed). */
+  isFlat() {
+    for (const qty of this.legs.values()) {
+      if (isGreaterThanOrEqual(qty.abs(), DUST)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /** True when every leg is exactly zero (a fully CLOSED position). */
+  isAllZero() {
+    for (const qty of this.legs.values()) {
+      if (!qty.isZero()) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Snap every non-zero leg to exactly zero. Called once a position is flat so it
+   * reads CLOSED (all-zero exposure) and never lingers in the open list with stray
+   * dust that a later reopen of the same pair could merge into.
+   */
+  snapToZero() {
+    for (const [symbol, qty] of this.legs) {
+      if (!qty.isZero()) {
+        this.legs.set(symbol, ZERO);
+      }
+    }
+  }
+  /** All symbols with a leg, including zeroed ones (a closed leg still carries cost basis). */
+  symbols() {
+    return [...this.legs.keys()];
+  }
+  /** Canonical signed-string view for the wire (`+0` for zero). */
+  toSigned() {
+    const out = {};
+    for (const [symbol, qty] of this.legs) {
+      out[symbol] = signed(qty);
+    }
+    return out;
+  }
+};
+
+// src/sync/applicables/matching.ts
+function matchPositions(args) {
+  const { tradeAccountId, orphanFills, pear } = args;
+  const book = WorkingBook.load({ tradeAccountId, openPositions: pear.positions() });
+  for (const basket of Basket.detect(orphanFills)) {
+    const exactCloseTarget = findExactCloseTarget(book.open(), basket.longs, basket.shorts);
+    const leftover = applyCloses({ legs: basket.legs, book, exactCloseTarget });
+    if (leftover.length === 0) {
+      continue;
+    }
+    const target = resolveLeftoverTarget({ book, leftover });
+    applyLeftover(target, leftover);
+  }
+  return book.toMatched();
+}
+var WorkingBook = class _WorkingBook {
+  constructor(tradeAccountId) {
+    this.tradeAccountId = tradeAccountId;
+  }
+  tradeAccountId;
+  all = [];
+  openByKey = /* @__PURE__ */ new Map();
+  /** Seed the book from existing open DB positions (they arrive pre-filtered by connector). */
+  static load(args) {
+    const { tradeAccountId, openPositions } = args;
+    const book = new _WorkingBook(tradeAccountId);
+    for (const p of openPositions) {
+      const position = {
+        positionKey: book.keyFor(Object.keys(p.exposure)),
+        exposure: Exposure.fromRecord(p.exposure),
+        parts: [],
+        closed: false,
+        existingOrigin: p.origin
+      };
+      book.all.push(position);
+      book.openByKey.set(position.positionKey, position);
+    }
+    return book;
+  }
+  /** Deterministic position key for a symbol set under this book's trade account. */
+  keyFor(symbols) {
+    return generateDeterministicPositionKey({ tradeAccountId: this.tradeAccountId, symbols });
+  }
+  /** Currently open working positions, in insertion order. */
+  open() {
+    return this.all.filter((position) => !position.closed);
+  }
+  /** Look up an open working position by its positionKey (for dedup on merge). */
+  findOpenByKey(key) {
+    return this.openByKey.get(key);
+  }
+  /** Register a fresh empty working position under `key` and return it. */
+  create(key) {
+    const position = {
+      positionKey: key,
+      exposure: Exposure.empty(),
+      parts: [],
+      closed: false
+    };
+    this.all.push(position);
+    this.openByKey.set(key, position);
+    return position;
+  }
+  /** Flip a position to closed once every leg is within DUST of zero. */
+  markClosedIfFlat(position) {
+    if (position.closed || !position.exposure.isFlat()) {
+      return;
+    }
+    position.exposure.snapToZero();
+    position.closed = true;
+    this.openByKey.delete(position.positionKey);
+  }
+  /** Working positions that received fills become MatchedPosition records; untouched ones are dropped. */
+  toMatched() {
+    return this.all.filter((position) => position.parts.length > 0).map((position) => ({
+      positionKey: position.positionKey,
+      parts: position.parts,
+      closed: position.closed,
+      exposure: position.exposure,
+      existingOrigin: position.existingOrigin
+    }));
+  }
+};
+function findExactCloseTarget(openList, basketLongs, basketShorts) {
+  return openList.find((position) => {
+    const { longs, shorts } = position.exposure.activeLegs();
+    return setEq(longs, basketShorts) && setEq(shorts, basketLongs);
+  });
+}
+var setEq = (a, b) => a.size === b.size && [...a].every((x) => b.has(x));
+function applyCloses(args) {
+  const { legs, book, exactCloseTarget } = args;
+  const openList = book.open();
+  const leftover = [];
+  for (const leg of legs) {
+    let remaining = leg.totalSize;
+    const closeTargetIsLong = sideSign(leg.side) === -1;
+    const holders = openList.filter((position) => {
+      const qty = position.exposure.get(leg.symbol);
+      if (qty.isZero()) {
+        return false;
+      }
+      return closeTargetIsLong ? qty.isPositive() : qty.isNegative();
+    });
+    if (exactCloseTarget) {
+      holders.sort((a, b) => a === exactCloseTarget ? -1 : b === exactCloseTarget ? 1 : 0);
+    }
+    for (const position of holders) {
+      if (isLessThanOrEqual(remaining, ZERO)) {
+        break;
+      }
+      const have = position.exposure.get(leg.symbol).abs();
+      const reduce = min(have, remaining);
+      position.parts.push(...leg.take(reduce));
+      position.exposure.addDelta(leg.symbol, signedBySide(reduce, leg.side));
+      remaining = remaining.minus(reduce);
+      book.markClosedIfFlat(position);
+    }
+    if (isGreaterThanOrEqual(remaining, DUST)) {
+      leftover.push({ side: leg.side, qty: remaining, leg });
+    }
+  }
+  return leftover;
+}
+function resolveLeftoverTarget(args) {
+  const { book, leftover } = args;
+  const leftoverLongs = new Set(leftover.filter((entry) => entry.side === "BUY").map((entry) => entry.leg.symbol));
+  const leftoverShorts = new Set(leftover.filter((entry) => entry.side === "SELL").map((entry) => entry.leg.symbol));
+  const target = book.open().find((position) => {
+    const { longs, shorts } = position.exposure.activeLegs();
+    const longOk = [...leftoverLongs].every((a) => longs.has(a));
+    const shortOk = [...leftoverShorts].every((a) => shorts.has(a));
+    return longOk && shortOk;
+  });
+  if (target) {
+    return target;
+  }
+  const symbols = [.../* @__PURE__ */ new Set([...leftoverLongs, ...leftoverShorts])];
+  const positionKey = book.keyFor(symbols);
+  return book.findOpenByKey(positionKey) ?? book.create(positionKey);
+}
+function applyLeftover(target, leftover) {
+  for (const entry of leftover) {
+    target.parts.push(...entry.leg.take(entry.qty));
+    target.exposure.addSigned(entry.leg.symbol, entry.qty.toFixed(), entry.side);
+  }
+}
+
+// src/sync/applicables/synthetics.ts
+function isMissedHistoryFill(fill) {
+  return fill.exchangeFillId.startsWith(MISSED_HISTORY_FILL_PREFIX);
+}
+function addFillsForMissedHistory(args) {
+  const missedHistoryFills = buildMissedHistoryFills(args);
+  return [...missedHistoryFills, ...args.orphanFills].sort((a, b) => a.timestamp - b.timestamp);
+}
+function alignPositionsWithExchange(args) {
+  const { positions, pear, snapshot, tradeAccountId } = args;
+  const neededSynthetics = findNeededSynthetics({ positions, pear, snapshot });
+  return assignSyntheticsToPositions({ neededSynthetics, positions, pear, tradeAccountId });
+}
+function buildSyntheticFill(args) {
+  return {
+    // Content-addressed id — no wall-clock, no positionId, so re-syncs collide
+    // on the dedup index and synthetic generation stays idempotent.
+    exchangeFillId: `synthetic-${args.positionKey}-${args.symbol}-${args.side}`,
+    cloid: null,
+    connector: args.connector,
+    symbol: args.symbol,
+    side: args.side,
+    quantity: args.quantity,
+    // Gone-close: exit price is unknown. "0" is the unpriceable sentinel — real
+    // fills are never 0 and missed-history fills derive a positive price, so
+    // consumers treat a 0-price fill as unpriceable (excluded from PnL/avg-entry,
+    // its closed size routed to undeterminedSize).
+    price: "0",
+    usd: "0",
+    timestamp: args.timestamp,
+    reduceOnly: false,
+    synthetic: true,
+    isExternal: true,
+    tradeFee: "0",
+    builderFee: "0",
+    closedReason: args.closedReason,
+    liquidation: null
   };
 }
-function _prepareExternalFills(externalFills, confirmedExchangeFillIdsInput) {
-  const dedupedByExchangeFillId = /* @__PURE__ */ new Map();
-  const confirmedExchangeFillIds = new Set(
-    Array.from(confirmedExchangeFillIdsInput).map((exchangeFillId) => _normalizeExchangeFillId(exchangeFillId)).filter((exchangeFillId) => exchangeFillId !== void 0)
-  );
-  const candidates = externalFills.reduce((acc, fill) => {
-    const normalizedExchangeFillId = _normalizeExchangeFillId(fill.exchangeFillId);
-    if (!normalizedExchangeFillId) return acc;
-    if (!_isValidExternalQuantity(fill.quantity)) return acc;
-    if (!_isValidExternalTimestamp(fill.timestamp)) return acc;
-    if (confirmedExchangeFillIds.has(normalizedExchangeFillId)) return acc;
-    acc.push({ ...fill, exchangeFillId: normalizedExchangeFillId });
-    return acc;
-  }, []);
-  for (const fill of candidates) {
-    const existing = dedupedByExchangeFillId.get(fill.exchangeFillId);
-    if (!existing || fill.timestamp < existing.timestamp) {
-      dedupedByExchangeFillId.set(fill.exchangeFillId, fill);
+function buildMissedHistoryFills(args) {
+  const { orphanFills, pear, connector, entryBySymbol, snapshot } = args;
+  const fillTotals = /* @__PURE__ */ new Map();
+  const orphanNotional = /* @__PURE__ */ new Map();
+  for (const fill of orphanFills) {
+    fillTotals.set(fill.symbol, add(fillTotals.get(fill.symbol) ?? ZERO, signedBySide(fill.quantity, fill.side)));
+    const notional = multiply(fill.quantity, fill.price);
+    orphanNotional.set(fill.symbol, add(orphanNotional.get(fill.symbol) ?? ZERO, notional));
+  }
+  const pearTotals = pear.totalBySymbol();
+  const assets = /* @__PURE__ */ new Set([...orphanFills.map((fill) => fill.symbol), ...snapshot.symbols()]);
+  const earliestTs = orphanFills.reduce((min2, fill) => Math.min(min2, fill.timestamp), Infinity);
+  if (!Number.isFinite(earliestTs)) {
+    return [];
+  }
+  const watermark = Math.max(1, earliestTs - 1);
+  const haveBySymbol = (symbol) => add(pearTotals.get(symbol) ?? ZERO, fillTotals.get(symbol) ?? ZERO);
+  const result = [];
+  for (const gap of gapsToTarget({
+    assets,
+    haveBySymbol,
+    snapshot
+  })) {
+    const { symbol } = gap;
+    const price = priceForMissedHistoryFill({
+      exchangePosition: snapshot.get(symbol),
+      syntheticQty: gap.quantity,
+      pearQty: pearTotals.get(symbol) ?? ZERO,
+      pearEntry: entryBySymbol[symbol],
+      orphanNotional: orphanNotional.get(symbol) ?? ZERO
+    });
+    result.push({
+      connector,
+      exchangeFillId: `${MISSED_HISTORY_FILL_PREFIX}${symbol}-${gap.side.toLowerCase()}`,
+      cloid: null,
+      symbol,
+      price,
+      quantity: gap.quantity,
+      side: gap.side,
+      reduceOnly: false,
+      timestamp: watermark,
+      tradeFee: "0",
+      builderFee: "0",
+      liquidation: null
+    });
+  }
+  return result;
+}
+function priceForMissedHistoryFill(args) {
+  const { exchangePosition, syntheticQty, pearQty, pearEntry, orphanNotional } = args;
+  const fallback = exchangePosition?.entryPrice ?? "0";
+  if (!exchangePosition) {
+    return fallback;
+  }
+  let realNotional = orphanNotional;
+  if (!isZero(pearQty)) {
+    if (pearEntry === void 0) {
+      return fallback;
     }
+    realNotional = add(realNotional, multiply(abs(pearQty), pearEntry));
   }
-  return Array.from(dedupedByExchangeFillId.values()).sort((a, b) => a.timestamp - b.timestamp);
+  const synthQty = parse(syntheticQty);
+  if (isZero(synthQty)) {
+    return fallback;
+  }
+  const targetNotional = multiply(exchangePosition.size, exchangePosition.entryPrice);
+  const derived = divide(subtract(targetNotional, realNotional), synthQty);
+  return derived.isFinite() && derived.isPositive() ? derived.toFixed() : fallback;
 }
-function _groupCreatablesBySymbol(orphanCreatables, openPositions) {
-  const groupedCreatables = /* @__PURE__ */ new Map();
-  for (const fill of orphanCreatables) {
-    const positionCandidates = openPositions.reduce((acc, p) => {
-      const exposure = p.exposure[fill.symbol];
-      if (!exposure) return acc;
-      const quantity = new BigNumber(exposure);
-      if (quantity.isZero() || quantity.isEqualTo("-0")) return acc;
-      if (fill.timestamp < Date.parse(p.createdAt)) return acc;
-      acc.push(p);
-      return acc;
-    }, []);
-    const first = positionCandidates[0];
-    if (!first) continue;
-    const splits = _splitMaybeCompositeFillAcrossPositions(fill, [first, ...positionCandidates.slice(1)]);
-    for (const { position, maybeModifiedFill } of splits) {
-      const key = `${position.id}-${maybeModifiedFill.symbol}`;
-      const existing = groupedCreatables.get(key);
-      if (existing) {
-        existing.fills.push({ ...maybeModifiedFill, type: "create", positionId: position.id });
-        groupedCreatables.set(key, existing);
-      } else {
-        groupedCreatables.set(key, {
-          positionId: position.id,
-          symbol: maybeModifiedFill.symbol,
-          exposure: new BigNumber(position.exposure[maybeModifiedFill.symbol] ?? 0),
-          fills: [{ ...maybeModifiedFill, type: "create", positionId: position.id }]
+function findNeededSynthetics(args) {
+  const { positions, pear, snapshot } = args;
+  const pearTotals = pear.totalBySymbol();
+  const assets = /* @__PURE__ */ new Set();
+  for (const pos of positions) {
+    for (const part of pos.parts) {
+      assets.add(part.source.symbol);
+    }
+  }
+  for (const symbol of snapshot.symbols()) {
+    assets.add(symbol);
+  }
+  for (const symbol of pearTotals.keys()) {
+    assets.add(symbol);
+  }
+  const haveBySymbol = (symbol) => {
+    let totalFills = ZERO;
+    for (const pos of positions) {
+      totalFills = add(totalFills, Exposure.netFromParts(pos.parts, symbol));
+    }
+    return add(pearTotals.get(symbol) ?? ZERO, totalFills);
+  };
+  const result = /* @__PURE__ */ new Map();
+  for (const gap of gapsToTarget({
+    assets,
+    haveBySymbol,
+    snapshot
+  })) {
+    switch (gap.kind) {
+      case "gone":
+        result.set(gap.symbol, {
+          symbol: gap.symbol,
+          side: gap.side,
+          quantity: gap.quantity,
+          closedReason: "NETTED"
         });
+        break;
+      case "gap":
+        result.set(gap.symbol, {
+          symbol: gap.symbol,
+          side: gap.side,
+          quantity: gap.quantity
+        });
+        break;
+    }
+  }
+  return result;
+}
+function assignSyntheticsToPositions(args) {
+  const { neededSynthetics, positions, pear, tradeAccountId } = args;
+  const keyOf = (symbols) => generateDeterministicPositionKey({ tradeAccountId, symbols });
+  const existingBySymbol = pear.positionBySymbol();
+  const created = [];
+  const byPosition = /* @__PURE__ */ new Map();
+  for (const [symbol, spec] of neededSynthetics) {
+    let target = positions.find((pos) => !pos.closed && pos.parts.some((part) => part.source.symbol === symbol));
+    if (!target) {
+      const existing = existingBySymbol.get(symbol);
+      const positionKey = existing ? keyOf(Object.keys(existing.exposure)) : keyOf([symbol]);
+      target = positions.find((pos) => pos.positionKey === positionKey) ?? created.find((pos) => pos.positionKey === positionKey);
+      if (!target) {
+        target = existing ? (
+          // Stand-in for an existing DB position untouched by this batch's fills:
+          // seed its exposure and origin so folding the synthetic yields the true
+          // final state (a gone-close nets to zero -> CLOSED/NETTED, a gap writes
+          // the full total, not just the delta).
+          {
+            positionKey,
+            parts: [],
+            closed: false,
+            exposure: Exposure.fromRecord(existing.exposure),
+            existingOrigin: existing.origin
+          }
+        ) : {
+          positionKey,
+          parts: [],
+          closed: false,
+          exposure: Exposure.empty()
+        };
+        created.push(target);
       }
     }
+    const list = byPosition.get(target) ?? [];
+    list.push(spec);
+    byPosition.set(target, list);
   }
-  return groupedCreatables;
+  return { positions: [...positions, ...created], synthByPosition: byPosition };
 }
-function _splitMaybeCompositeFillAcrossPositions(fill, positionCandidates) {
-  if (positionCandidates.length === 1) {
-    return [{ position: positionCandidates[0], maybeModifiedFill: fill }];
+function gapsToTarget(args) {
+  const { assets, haveBySymbol, snapshot } = args;
+  const gaps = [];
+  for (const symbol of assets) {
+    const gap = findGapToTarget({
+      symbol,
+      have: haveBySymbol(symbol),
+      target: snapshot.signedSize(symbol)
+    });
+    if (gap) {
+      gaps.push(gap);
+    }
   }
-  const firstPosition = positionCandidates[0];
-  const firstExposure = new BigNumber(firstPosition.exposure[fill.symbol] ?? 0);
-  if (firstExposure.isZero() || firstExposure.isEqualTo("-0")) {
-    throw new Error("Corrupted state: first position has no exposure");
+  return gaps;
+}
+function findGapToTarget(args) {
+  const { symbol, have, target } = args;
+  if (isZero(target)) {
+    if (isGreaterThan(abs(have), DUST)) {
+      return {
+        kind: "gone",
+        symbol,
+        side: have.isPositive() ? "SELL" : "BUY",
+        quantity: have.abs().toFixed()
+      };
+    }
+    return null;
   }
-  const signedFillQuantity = new BigNumber(fill.quantity).multipliedBy(fill.side === "BUY" ? 1 : -1);
-  const firstSign = firstExposure.isGreaterThan(0) ? 1 : -1;
-  const fillSign = signedFillQuantity.isGreaterThan(0) ? 1 : -1;
-  if (firstSign === fillSign) {
-    return [{ position: firstPosition, maybeModifiedFill: fill }];
+  const residual = subtract(target, have);
+  if (isGreaterThan(abs(residual), DUST)) {
+    return {
+      kind: "gap",
+      symbol,
+      side: residual.isPositive() ? "BUY" : "SELL",
+      quantity: residual.abs().toFixed()
+    };
   }
-  const totalExposure = positionCandidates.reduce((acc, p) => {
-    acc = acc.plus(new BigNumber(p.exposure[fill.symbol] ?? 0));
-    return acc;
-  }, new BigNumber(0));
-  if (totalExposure.isZero() || totalExposure.isEqualTo("-0")) {
-    throw new Error("Corrupted state: total exposure is zero");
+  return null;
+}
+
+// src/sync/applicables/fills.ts
+function assignPartIds(positions) {
+  const bySource = /* @__PURE__ */ new Map();
+  for (const pos of positions) {
+    for (const part of pos.parts) {
+      const list = bySource.get(part.source.exchangeFillId) ?? [];
+      list.push(part);
+      bySource.set(part.source.exchangeFillId, list);
+    }
   }
-  const willBalanceToZero = totalExposure.negated().isEqualTo(signedFillQuantity);
-  if (!willBalanceToZero) {
-    return [{ position: firstPosition, maybeModifiedFill: fill }];
+  const resolution = /* @__PURE__ */ new Map();
+  for (const [sourceId, parts] of bySource) {
+    const single = parts.length === 1 ? parts[0] : void 0;
+    if (single && isEqualTo(single.quantity, single.source.quantity)) {
+      resolution.set(single, { exchangeFillId: sourceId });
+      continue;
+    }
+    parts.forEach((part, i) => {
+      resolution.set(part, {
+        exchangeFillId: `${sourceId}-p${i}`,
+        original: { exchangeFillId: sourceId, quantity: part.source.quantity }
+      });
+    });
   }
-  return positionCandidates.map((position) => {
-    const signedQuantity = position.exposure[fill.symbol] ?? "0";
-    const quantity = new BigNumber(signedQuantity).abs();
+  return (part) => {
+    const id = resolution.get(part);
+    if (!id) {
+      throw new Error("applicables: fill part was never assigned an id");
+    }
+    return id;
+  };
+}
+function partToApplicableFill(part, id, connector) {
+  const fill = part.source;
+  const base = {
+    exchangeFillId: id.exchangeFillId,
+    connector,
+    symbol: fill.symbol,
+    side: fill.side,
+    quantity: part.quantity,
+    price: fill.price,
+    usd: multiply(part.quantity, fill.price).toFixed(),
+    timestamp: fill.timestamp
+  };
+  if (isMissedHistoryFill(fill)) {
     return {
-      position,
-      maybeModifiedFill: {
-        ...fill,
-        exchangeFillId: `${fill.exchangeFillId}-${position.id}`,
-        quantity: quantity.toFixed(),
-        original: {
-          exchangeFillId: fill.exchangeFillId,
-          quantity: fill.quantity
+      ...base,
+      cloid: null,
+      reduceOnly: false,
+      synthetic: true,
+      isExternal: true,
+      tradeFee: "0",
+      builderFee: "0",
+      liquidation: null
+    };
+  }
+  const fromPear = isPearCloid(connector, fill.cloid);
+  return {
+    ...base,
+    cloid: fill.cloid ?? null,
+    reduceOnly: fill.reduceOnly,
+    synthetic: false,
+    isExternal: !fromPear,
+    tradeFee: feeShareForPart(fill.tradeFee, part.quantity, fill.quantity),
+    builderFee: feeShareForPart(fill.builderFee, part.quantity, fill.quantity),
+    liquidation: fill.liquidation,
+    ...id.original ? { original: id.original } : {}
+  };
+}
+function feeShareForPart(totalFee, partQty, sourceQty) {
+  if (isEqualTo(partQty, sourceQty)) {
+    return totalFee;
+  }
+  if (isZero(sourceQty)) {
+    return "0";
+  }
+  const feeShare = divide(multiply(totalFee, partQty), sourceQty);
+  return feeShare.toFixed();
+}
+
+// src/sync/applicables/position.ts
+function assembleApplicables(args) {
+  const { positions, connector, synthByPosition, now } = args;
+  const partIdFor = assignPartIds(positions);
+  const applicables = [];
+  for (const pos of positions) {
+    const applicable = assembleOneApplicable(pos, connector, partIdFor, synthByPosition.get(pos) ?? [], now);
+    if (applicable) {
+      applicables.push(applicable);
+    }
+  }
+  return applicables;
+}
+function assembleOneApplicable(pos, connector, partIdFor, assignedSynthetics, now) {
+  const realFills = pos.parts.map((part) => partToApplicableFill(part, partIdFor(part), connector)).sort((a, b) => a.timestamp - b.timestamp);
+  const syntheticFills = assignedSynthetics.map(
+    (synthetic) => buildSyntheticFill({
+      positionKey: pos.positionKey,
+      connector,
+      timestamp: anchorSyntheticTimestamp(realFills, synthetic.symbol, now),
+      ...synthetic
+    })
+  );
+  const fills = [...realFills, ...syntheticFills].sort((a, b) => a.timestamp - b.timestamp);
+  if (fills.length === 0) {
+    return null;
+  }
+  const exposure = finalExposure(pos, assignedSynthetics);
+  const closed = exposure.isAllZero();
+  const status = closed ? "CLOSED" : "OPEN";
+  const origin = mergeOrigin(pos.existingOrigin, fills);
+  return {
+    positionKey: pos.positionKey,
+    exposure: exposure.toSigned(),
+    origin,
+    status,
+    ...closed ? { closedReason: "NETTED" } : {},
+    fills,
+    metadata: buildMetadata(new Set(exposure.symbols()), realFills)
+  };
+}
+function finalExposure(pos, synthetics) {
+  const exposure = pos.exposure.clone();
+  for (const synthetic of synthetics) {
+    exposure.addSigned(synthetic.symbol, synthetic.quantity, synthetic.side);
+  }
+  return exposure;
+}
+function anchorSyntheticTimestamp(realFills, symbol, now) {
+  const oldestForSymbol = realFills.find((fill) => fill.symbol === symbol)?.timestamp;
+  if (oldestForSymbol !== void 0) {
+    return Math.max(1, oldestForSymbol - 1);
+  }
+  const oldestRealTs = realFills[0]?.timestamp;
+  return oldestRealTs !== void 0 ? Math.max(1, oldestRealTs - 1) : now;
+}
+function buildMetadata(symbols, realFills) {
+  const initialExposureUSD = {};
+  for (const symbol of symbols) {
+    const legFills = realFills.flatMap(
+      (fill) => fill.symbol === symbol && fill.usd != null ? [{ side: fill.side, usd: fill.usd }] : []
+    );
+    const opener = legFills[0];
+    if (!opener) {
+      continue;
+    }
+    const notional = legFills.filter((fill) => fill.side === opener.side).reduce((sum, fill) => add(sum, fill.usd), ZERO);
+    const signedNotional = signed(opener.side === "BUY" ? notional : notional.negated());
+    initialExposureUSD[symbol] = signedNotional;
+  }
+  return { initialExposureUSD };
+}
+function mergeOrigin(existing, fills) {
+  let anyExternal = false;
+  let anyPear = false;
+  switch (existing) {
+    case "EXTERNAL":
+      anyExternal = true;
+      break;
+    case "PEAR":
+      anyPear = true;
+      break;
+    case "PARTIAL":
+      anyExternal = true;
+      anyPear = true;
+      break;
+  }
+  for (const fill of fills) {
+    if (fill.isExternal) {
+      anyExternal = true;
+    } else {
+      anyPear = true;
+    }
+  }
+  if (anyExternal && anyPear) {
+    return "PARTIAL";
+  }
+  return anyPear ? "PEAR" : "EXTERNAL";
+}
+
+// src/sync/applicables/snapshot.ts
+var ExchangeSnapshot = class _ExchangeSnapshot {
+  constructor(bySymbol) {
+    this.bySymbol = bySymbol;
+  }
+  bySymbol;
+  /** Index `positions` by symbol for O(1) lookup. */
+  static from(positions) {
+    return new _ExchangeSnapshot(new Map(positions.map((position) => [position.symbol, position])));
+  }
+  /** Raw exchange position for `symbol`, or `undefined` when the exchange holds nothing. */
+  get(symbol) {
+    return this.bySymbol.get(symbol);
+  }
+  /** Signed exchange exposure for `symbol` (0 when the exchange has no position). */
+  signedSize(symbol) {
+    const position = this.bySymbol.get(symbol);
+    if (!position) {
+      return ZERO;
+    }
+    const size = parse(position.size);
+    switch (position.side) {
+      case "BUY":
+        return size;
+      case "SELL":
+        return size.negated();
+    }
+  }
+  /** All symbols the exchange currently reports a position for. */
+  symbols() {
+    return [...this.bySymbol.keys()];
+  }
+};
+var PearHoldings = class _PearHoldings {
+  constructor(filtered) {
+    this.filtered = filtered;
+  }
+  filtered;
+  /** Filter `openPositions` to the given connector and wrap. */
+  static from(args) {
+    const { openPositions, connector } = args;
+    return new _PearHoldings(openPositions.filter((position) => position.connector === connector));
+  }
+  /** The open Pear positions for this connector. */
+  positions() {
+    return this.filtered;
+  }
+  /** Sum existing open Pear exposure per symbol. */
+  totalBySymbol() {
+    const totals = /* @__PURE__ */ new Map();
+    for (const position of this.filtered) {
+      for (const [symbol, signedExposure] of Object.entries(position.exposure)) {
+        if (signedExposure) {
+          const newExposure = add(totals.get(symbol) ?? ZERO, signedExposure);
+          totals.set(symbol, newExposure);
         }
       }
-    };
+    }
+    return totals;
+  }
+  /**
+   * Which open DB position holds each active asset — the fallback target for a
+   * synthetic when no matched position already carries that asset. First open
+   * position with a non-zero leg wins per symbol.
+   */
+  positionBySymbol() {
+    const existingBySymbol = /* @__PURE__ */ new Map();
+    for (const position of this.filtered) {
+      for (const [symbol, signedQty] of Object.entries(position.exposure)) {
+        const legIsZero = isZero(signedQty);
+        const exists = existingBySymbol.has(symbol);
+        if (!legIsZero && !exists) {
+          existingBySymbol.set(symbol, position);
+        }
+      }
+    }
+    return existingBySymbol;
+  }
+};
+
+// src/sync/applicables/index.ts
+function buildApplicables(args) {
+  const { tradeAccountId, connector, orphanFills, openPositions, entryBySymbol, exchangePositions } = args;
+  const snapshot = ExchangeSnapshot.from(exchangePositions);
+  const pear = PearHoldings.from({ openPositions, connector });
+  const now = Date.now();
+  const fills = addFillsForMissedHistory({ orphanFills, pear, connector, entryBySymbol, snapshot });
+  const matched = matchPositions({ tradeAccountId, orphanFills: fills, pear });
+  const { positions, synthByPosition } = alignPositionsWithExchange({
+    positions: matched,
+    pear,
+    snapshot,
+    tradeAccountId
   });
+  return assembleApplicables({ positions, connector, synthByPosition, now });
 }
-function _walkBackwardsToFindLastZeroCrossing(group) {
-  let netDelta = new BigNumber(0);
-  for (const fill of group.fills) {
-    if (fill.symbol !== group.symbol) {
-      throw new Error("Corrupted state: fill symbol mismatch in grouped creatables");
-    }
-    const quantity = new BigNumber(fill.quantity);
-    const sign2 = fill.side === "BUY" ? 1 : -1;
-    const signedQuantity = quantity.multipliedBy(sign2);
-    netDelta = netDelta.plus(signedQuantity);
-  }
-  if (netDelta.isZero()) {
-    return group.fills;
-  }
-  let walkDelta = netDelta;
-  const indexedNewFills = group.fills.map((fill, index) => ({ fill, index }));
-  let cutoff;
-  for (let i = indexedNewFills.length - 1; i >= 0; i--) {
-    const indexedFill = indexedNewFills[i];
-    if (!indexedFill) continue;
-    const { fill, index } = indexedFill;
-    const previousExposure = group.exposure;
-    if (previousExposure.plus(walkDelta).isZero() && cutoff === void 0) {
-      cutoff = index;
-    }
-    const sign2 = fill.side === "BUY" ? 1 : -1;
-    const quantity = new BigNumber(fill.quantity).multipliedBy(sign2);
-    walkDelta = walkDelta.minus(quantity);
-  }
-  const allowed = new Set(
-    indexedNewFills.filter(({ index }) => cutoff === void 0 || index <= cutoff).map(({ fill }) => fill)
-  );
-  if (allowed.size !== group.fills.length) {
-    return Array.from(allowed.values());
+
+// src/sync/cutoff.ts
+function selectFirstSyncCutoff(args) {
+  const { fills, exchangePositions, connector } = args;
+  if (fills.length === 0) {
+    return null;
   }
-  if (group.exposure.isNegative() && netDelta.isPositive()) {
-    const newExposure = netDelta.plus(group.exposure);
-    if (newExposure.isGreaterThan(0)) return [];
+  const snapshot = ExchangeSnapshot.from(exchangePositions);
+  const book = Exposure.empty();
+  for (const symbol of snapshot.symbols()) {
+    book.addDelta(symbol, snapshot.signedSize(symbol));
+  }
+  const fillSymbols = new Set(fills.map((fill) => fill.symbol));
+  for (const symbol of snapshot.symbols()) {
+    if (!snapshot.signedSize(symbol).isZero() && !fillSymbols.has(symbol)) {
+      return null;
+    }
+  }
+  const pearIndex = connector === "hyperliquid" ? findFirstPearFillIndex(connector, fills) : null;
+  for (let boundary = fills.length; boundary >= 0; boundary--) {
+    const withinAnchor = pearIndex === null || boundary <= pearIndex;
+    if (withinAnchor && book.isAllZero() && isStrictTimestampBoundary(fills, boundary)) {
+      return boundary === 0 ? null : { keepFromIndex: boundary };
+    }
+    const preceding = fills[boundary - 1];
+    if (preceding) {
+      book.addDelta(preceding.symbol, signedBySide(preceding.quantity, preceding.side).negated());
+    }
   }
-  if (group.exposure.isPositive() && netDelta.isNegative()) {
-    const newExposure = netDelta.plus(group.exposure);
-    if (newExposure.isLessThan(0)) return [];
+  return null;
+}
+function findFirstPearFillIndex(connector, fills) {
+  const index = fills.findIndex((fill) => isPearCloid(connector, fill.cloid));
+  if (index === -1) {
+    return null;
+  }
+  return index;
+}
+function isStrictTimestampBoundary(fills, boundary) {
+  const before = fills[boundary - 1];
+  const after = fills[boundary];
+  if (!before || !after) {
+    return true;
+  }
+  return before.timestamp < after.timestamp;
+}
+
+// src/sync/compute.ts
+async function computeSyncPayload(args) {
+  const {
+    tradeAccountId,
+    connector,
+    openPositions,
+    entryBySymbol,
+    provisionalFills,
+    confirmedExchangeFillIds,
+    externalFills,
+    exchangePositions,
+    neverSynced
+  } = args;
+  const fillsToProcess = _prepareExternalFills(externalFills, confirmedExchangeFillIds);
+  const {
+    reconcilables,
+    confirmables: confirmableFills,
+    orphans
+  } = _segregateExternalFills(provisionalFills, fillsToProcess);
+  const confirmablesByPosition = groupConfirmablesByPosition(confirmableFills);
+  const { keptOrphans, firstSyncTrim } = applyFirstSyncCutoff({
+    neverSynced,
+    fillsToProcess,
+    orphans,
+    exchangePositions,
+    connector
+  });
+  const applicables = buildApplicables({
+    tradeAccountId,
+    connector,
+    orphanFills: keptOrphans,
+    openPositions,
+    entryBySymbol,
+    exchangePositions
+  });
+  const mustPostFirstSyncCheckpoint = neverSynced && fillsToProcess.length > 0;
+  if (!mustPostFirstSyncCheckpoint && isEmptyCycle(reconcilables, confirmablesByPosition, applicables)) {
+    return null;
+  }
+  const externalMaxTs = latestFillTimestamp(fillsToProcess);
+  return {
+    reconcilables: Object.keys(reconcilables).length > 0 ? reconcilables : null,
+    confirmables: Object.keys(confirmablesByPosition).length > 0 ? confirmablesByPosition : null,
+    applicables,
+    exchangePositions,
+    meta: {
+      externalMaxTs
+    },
+    firstSyncTrim
+  };
+}
+function _prepareExternalFills(externalFills, confirmedExchangeFillIdsInput) {
+  const dedupedByExchangeFillId = /* @__PURE__ */ new Map();
+  const confirmedExchangeFillIds = new Set(
+    Array.from(confirmedExchangeFillIdsInput).map((exchangeFillId) => _normalizeExchangeFillId(exchangeFillId)).filter((exchangeFillId) => exchangeFillId !== void 0)
+  );
+  const candidates = externalFills.reduce((acc, fill) => {
+    const normalizedExchangeFillId = _normalizeExchangeFillId(fill.exchangeFillId);
+    if (!normalizedExchangeFillId) {
+      return acc;
+    }
+    if (!_isValidExternalQuantity(fill.quantity)) {
+      return acc;
+    }
+    if (!_isValidExternalTimestamp(fill.timestamp)) {
+      return acc;
+    }
+    if (confirmedExchangeFillIds.has(normalizedExchangeFillId)) {
+      return acc;
+    }
+    acc.push({ ...fill, exchangeFillId: normalizedExchangeFillId });
+    return acc;
+  }, []);
+  for (const fill of candidates) {
+    const existing = dedupedByExchangeFillId.get(fill.exchangeFillId);
+    if (!existing || fill.timestamp < existing.timestamp) {
+      dedupedByExchangeFillId.set(fill.exchangeFillId, fill);
+    }
   }
-  return Array.from(allowed.values());
+  return Array.from(dedupedByExchangeFillId.values()).sort((a, b) => a.timestamp - b.timestamp);
 }
-function _seggregateExternalFills(provisionalFills, externalFills) {
+function _segregateExternalFills(provisionalFills, externalFills) {
   const provisionalFillsMap = /* @__PURE__ */ new Map();
   for (const fill of provisionalFills) {
     const cloid = _normalizeCloid(fill.cloid);
-    if (!cloid) continue;
+    if (!cloid) {
+      continue;
+    }
     provisionalFillsMap.set(cloid, fill);
   }
-  const orphanCreatables = [];
-  const cloidBuffer = /* @__PURE__ */ new Map();
+  const orphans = [];
+  const fillsByCloid = /* @__PURE__ */ new Map();
   for (const fill of externalFills) {
     const cloid = _normalizeCloid(fill.cloid);
     if (!cloid) {
-      orphanCreatables.push(fill);
+      orphans.push(fill);
     } else {
-      cloidBuffer.set(cloid, [...cloidBuffer.get(cloid) || [], fill]);
+      fillsByCloid.set(cloid, [...fillsByCloid.get(cloid) || [], fill]);
     }
   }
   const reconcilables = {};
-  const confirmables = [];
-  for (const [cloid, fills] of cloidBuffer.entries()) {
+  const confirmableFills = [];
+  for (const [cloid, fills] of fillsByCloid.entries()) {
     if (fills.length > 1) {
       const provisional = provisionalFillsMap.get(cloid);
       if (provisional) {
@@ -549,65 +1615,136 @@ function _seggregateExternalFills(provisionalFills, externalFills) {
           ...rest.map((fill) => ({ ...fill, cloid }))
         ];
       } else {
-        orphanCreatables.push(...fills);
+        orphans.push(...fills);
       }
     } else {
       const fill = fills[0];
       const provisional = provisionalFillsMap.get(cloid);
       if (provisional) {
-        confirmables.push({
+        confirmableFills.push({
           ...fill,
           type: "confirm",
           cloid,
           positionId: provisional.positionId
         });
       } else {
-        orphanCreatables.push(fill);
+        orphans.push(fill);
       }
     }
   }
-  return { reconcilables, confirmables, orphanCreatables };
+  return { reconcilables, confirmables: confirmableFills, orphans };
 }
 function _normalizeCloid(cloid) {
   const value = cloid?.trim();
-  return value ? value : void 0;
+  if (!value) {
+    return void 0;
+  }
+  return value;
 }
 function _normalizeExchangeFillId(exchangeFillId) {
   const value = exchangeFillId?.trim().toLowerCase();
-  return value ? value : void 0;
+  if (!value) {
+    return void 0;
+  }
+  return value;
 }
 function _isValidExternalQuantity(quantity) {
-  if (/e/i.test(quantity)) return false;
-  const parsed = new BigNumber(quantity);
-  if (parsed.isNaN() || !parsed.isFinite()) return false;
-  return parsed.isGreaterThan(0);
+  if (/e/i.test(quantity)) {
+    return false;
+  }
+  if (!isFiniteDecimal(quantity)) {
+    return false;
+  }
+  return isGreaterThan(quantity, ZERO);
 }
 function _isValidExternalTimestamp(timestamp) {
   return Number.isFinite(timestamp) && timestamp >= 0;
 }
+function groupConfirmablesByPosition(confirmableFills) {
+  return confirmableFills.reduce((acc, fill) => {
+    acc[fill.positionId] = [...acc[fill.positionId] || [], fill];
+    return acc;
+  }, {});
+}
+function latestFillTimestamp(fills) {
+  const last = fills[fills.length - 1];
+  if (!last) {
+    return null;
+  }
+  return last.timestamp;
+}
+function applyFirstSyncCutoff(args) {
+  const { neverSynced, fillsToProcess, orphans, exchangePositions, connector } = args;
+  if (!neverSynced || fillsToProcess.length === 0) {
+    return { keptOrphans: orphans, firstSyncTrim: null };
+  }
+  const cutoff = selectFirstSyncCutoff({
+    fills: fillsToProcess,
+    exchangePositions,
+    connector
+  });
+  if (!cutoff) {
+    return { keptOrphans: orphans, firstSyncTrim: null };
+  }
+  const keptIds = new Set(fillsToProcess.slice(cutoff.keepFromIndex).map((fill) => fill.exchangeFillId));
+  const keptOrphans = [];
+  const droppedOrphans = [];
+  for (const orphan of orphans) {
+    (keptIds.has(orphan.exchangeFillId) ? keptOrphans : droppedOrphans).push(orphan);
+  }
+  if (droppedOrphans.length === 0) {
+    return { keptOrphans, firstSyncTrim: null };
+  }
+  const firstKeptFill = fillsToProcess[cutoff.keepFromIndex];
+  return {
+    keptOrphans,
+    firstSyncTrim: {
+      cutoffTs: firstKeptFill ? firstKeptFill.timestamp : null,
+      trimmedCount: droppedOrphans.length,
+      trimmedMaxTs: droppedOrphans.reduce((max, fill) => fill.timestamp > max ? fill.timestamp : max, 0)
+    }
+  };
+}
+function isEmptyCycle(reconcilables, confirmablesByPosition, applicables) {
+  return Object.keys(reconcilables).length === 0 && Object.keys(confirmablesByPosition).length === 0 && applicables.length === 0;
+}
 
 // src/validate-leverage.ts
 function validateLeverage(leverage, instrument) {
-  if (leverage < 1 || leverage > 100) return false;
-  if (leverage > instrument.leverage) return false;
+  if (leverage < 1 || leverage > 100) {
+    return false;
+  }
+  if (leverage > instrument.leverage) {
+    return false;
+  }
   return true;
 }
 function validateQuantity(quantity, price, precision) {
-  const q = new BigNumber7(quantity);
-  if (!q.isFinite() || q.lte(0)) return false;
-  const p = new BigNumber7(price);
-  if (!p.isFinite() || p.lte(0)) return false;
-  const step = new BigNumber7(precision.quantity.step);
-  const scaled = q.div(step);
-  if (!scaled.isInteger()) return false;
-  const notional = contractsToBase(q, precision.quantity.contractSize).times(p);
+  const parsedQuantity = new BigNumber9(quantity);
+  if (!parsedQuantity.isFinite() || parsedQuantity.lte(0)) {
+    return false;
+  }
+  const parsedPrice = new BigNumber9(price);
+  if (!parsedPrice.isFinite() || parsedPrice.lte(0)) {
+    return false;
+  }
+  const step = new BigNumber9(precision.quantity.step);
+  const scaled = parsedQuantity.div(step);
+  if (!scaled.isInteger()) {
+    return false;
+  }
+  const notional = contractsToBase(parsedQuantity, precision.quantity.contractSize).times(parsedPrice);
   if (precision.notional?.min !== void 0 && precision.notional.min !== null && precision.notional.min > 0) {
-    if (notional.lt(new BigNumber7(precision.notional.min))) return false;
+    if (notional.lt(new BigNumber9(precision.notional.min))) {
+      return false;
+    }
   }
   if (precision.notional?.max !== void 0 && precision.notional.max !== null && precision.notional.max > 0) {
-    if (notional.gt(new BigNumber7(precision.notional.max))) return false;
+    if (notional.gt(new BigNumber9(precision.notional.max))) {
+      return false;
+    }
   }
   return true;
 }
 
-export { BIPS, ZERO, baseToContracts, compareValue, computeAssetEntryNotional, computeAssetGrossRealizedPnL, computeAssetRealizedPnLs, computeAssetUnrealizedPnL, computeAssetUnrealizedPnLs, computeBasketWeightedRatioV1, computeEntryPriceForAsset, computeRealizedPositionState, computeSyncPayload, computeUnrealizedPositionState, contractsToBase, countDecimals, exponentiate, precisePrice, preciseQuantity, sign, validateLeverage, validateQuantity };
+export { BIPS, ZERO, abs, add, baseToContracts, compareValue, computeAssetEntryNotional, computeAssetGrossRealizedPnL, computeAssetRealizedPnLs, computeAssetUndeterminedSizes, computeAssetUnrealizedPnL, computeAssetUnrealizedPnLs, computeBasketWeightedRatioV1, computeEntryPriceForAsset, computePositionEntryPrices, computeRealizedPnlBySymbol, computeRealizedPnlFromFills, computeRealizedPositionState, computeSyncPayload, computeUnrealizedPositionState, computeUnrealizedPositionStateFromEntryPrices, configureProxy, contractsToBase, countDecimals, divide, exponentiate, generateDeterministicPositionKey, isEqualTo, isFiniteDecimal, isGreaterThan, isGreaterThanOrEqual, isLessThan, isLessThanOrEqual, isNegative, isPositive, isZero, min, multiply, negate, parse, precisePrice, preciseQuantity, proxyFetch, sideSign, sign, signed, signedBySide, subtract, toDecimalString, validateLeverage, validateQuantity };