@pear-protocol/utils 0.5.1 → 0.5.3

package/dist/index.js

@@ -1,67 +1,88 @@
-import BigNumber9 from 'bignumber.js';
-import { sha256 } from '@noble/hashes/sha256';
-import { bytesToHex } from '@noble/hashes/utils';
+import BigNumber7 from 'bignumber.js';
+import { sha256 } from '@noble/hashes/sha2';
+import { bytesToHex, randomBytes, utf8ToBytes } from '@noble/hashes/utils';
 import { WATERMARK_FUTURE_SKEW_MS } from '@pear-protocol/types';
+import { base64urlnopad } from '@scure/base';
 
-// src/asset/compute.ts
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 function parse(value) {
-  return value instanceof BigNumber9 ? value : new BigNumber9(value);
+  return value instanceof BigNumber7 ? value : new BigNumber7(value);
 }
+__name(parse, "parse");
 function toDecimalString(value) {
   return parse(value).toFixed();
 }
+__name(toDecimalString, "toDecimalString");
 function signed(value) {
   const bn = parse(value);
   return bn.isNegative() && !bn.isZero() ? bn.toFixed() : `+${bn.toFixed()}`;
 }
+__name(signed, "signed");
 function add(a, b) {
   return parse(a).plus(parse(b));
 }
+__name(add, "add");
 function subtract(a, b) {
   return parse(a).minus(parse(b));
 }
+__name(subtract, "subtract");
 function multiply(a, b) {
   return parse(a).times(parse(b));
 }
+__name(multiply, "multiply");
 function divide(a, b) {
   return parse(a).div(parse(b));
 }
+__name(divide, "divide");
 function negate(value) {
   return parse(value).negated();
 }
+__name(negate, "negate");
 function abs(value) {
   return parse(value).abs();
 }
+__name(abs, "abs");
 function min(a, b) {
-  return BigNumber9.min(parse(a), parse(b));
+  return BigNumber7.min(parse(a), parse(b));
 }
+__name(min, "min");
 function isZero(value) {
   return parse(value).isZero();
 }
+__name(isZero, "isZero");
 function isPositive(value) {
   return parse(value).isPositive();
 }
+__name(isPositive, "isPositive");
 function isNegative(value) {
   return parse(value).isNegative();
 }
+__name(isNegative, "isNegative");
 function isFiniteDecimal(value) {
   return parse(value).isFinite();
 }
+__name(isFiniteDecimal, "isFiniteDecimal");
 function isEqualTo(a, b) {
   return parse(a).isEqualTo(parse(b));
 }
+__name(isEqualTo, "isEqualTo");
 function isGreaterThan(a, b) {
   return parse(a).isGreaterThan(parse(b));
 }
+__name(isGreaterThan, "isGreaterThan");
 function isGreaterThanOrEqual(a, b) {
   return parse(a).isGreaterThanOrEqualTo(parse(b));
 }
+__name(isGreaterThanOrEqual, "isGreaterThanOrEqual");
 function isLessThan(a, b) {
   return parse(a).isLessThan(parse(b));
 }
+__name(isLessThan, "isLessThan");
 function isLessThanOrEqual(a, b) {
   return parse(a).isLessThanOrEqualTo(parse(b));
 }
+__name(isLessThanOrEqual, "isLessThanOrEqual");
 function sideSign(side) {
   switch (side) {
     case "BUY":
@@ -70,36 +91,42 @@ function sideSign(side) {
       return -1;
   }
 }
+__name(sideSign, "sideSign");
 function signedBySide(value, side) {
   return parse(value).times(sideSign(side));
 }
+__name(signedBySide, "signedBySide");
 
 // src/math/index.ts
-var ZERO = new BigNumber9(0);
-var BIPS = new BigNumber9(1e4);
+var ZERO = new BigNumber7(0);
+var BIPS = new BigNumber7(1e4);
 function exponentiate(value) {
   const result = Math.exp(value);
-  return new BigNumber9(result);
+  return new BigNumber7(result);
 }
+__name(exponentiate, "exponentiate");
 function sign(value) {
   if (value.isZero()) return 0;
   return value.isPositive() ? 1 : -1;
 }
+__name(sign, "sign");
 function countDecimals(value) {
   const parts = value.split(".");
   return parts[1]?.length ?? 0;
 }
+__name(countDecimals, "countDecimals");
 function compareValue(track, value, threshold) {
   return track === "PEAK" ? value.isGreaterThanOrEqualTo(threshold) : value.isLessThan(threshold);
 }
+__name(compareValue, "compareValue");
 
 // src/fills/compute.ts
 function computeEntryPriceForAsset(fills) {
   let entryPrice = ZERO;
   let positionSize = ZERO;
   for (const fill of fills) {
-    const price = new BigNumber9(fill.price);
-    const quantity = new BigNumber9(fill.quantity);
+    const price = new BigNumber7(fill.price);
+    const quantity = new BigNumber7(fill.quantity);
     const signed2 = fill.side === "BUY" ? quantity : quantity.negated();
     const newPositionSize = positionSize.plus(signed2);
     const isSameDirection = !positionSize.isZero() && positionSize.isPositive() === signed2.isPositive();
@@ -113,6 +140,7 @@ function computeEntryPriceForAsset(fills) {
   }
   return entryPrice;
 }
+__name(computeEntryPriceForAsset, "computeEntryPriceForAsset");
 
 // src/asset/compute.ts
 function computeAssetEntryNotional(signedQuantity, fills) {
@@ -126,6 +154,7 @@ function computeAssetEntryNotional(signedQuantity, fills) {
   const unsignedQuantity = signedQuantity.abs();
   return unsignedQuantity.multipliedBy(entryPrice);
 }
+__name(computeAssetEntryNotional, "computeAssetEntryNotional");
 function computeAssetUnrealizedPnL(signedQuantity, currentPrice, fills) {
   if (signedQuantity.isZero()) {
     return ZERO;
@@ -137,9 +166,11 @@ function computeAssetUnrealizedPnL(signedQuantity, currentPrice, fills) {
   const deltaPrice = currentPrice.minus(entryPrice);
   return signedQuantity.multipliedBy(deltaPrice);
 }
+__name(computeAssetUnrealizedPnL, "computeAssetUnrealizedPnL");
 function computeAssetGrossRealizedPnL(fills) {
   return walkAssetFills(fills).gross;
 }
+__name(computeAssetGrossRealizedPnL, "computeAssetGrossRealizedPnL");
 function computeAssetUndeterminedSizes(fills) {
   const result = {};
   for (const asset of computeAssetRealizedPnLs(fills)) {
@@ -149,6 +180,7 @@ function computeAssetUndeterminedSizes(fills) {
   }
   return result;
 }
+__name(computeAssetUndeterminedSizes, "computeAssetUndeterminedSizes");
 function computeAssetUnrealizedPnLs(exposureMap, priceMap, fills) {
   const result = [];
   for (const [id, signedQtyString] of Object.entries(exposureMap)) {
@@ -156,11 +188,11 @@ function computeAssetUnrealizedPnLs(exposureMap, priceMap, fills) {
     if (!priceString) {
       continue;
     }
-    const signedQuantity = new BigNumber9(signedQtyString);
+    const signedQuantity = new BigNumber7(signedQtyString);
     if (signedQuantity.isZero()) {
       continue;
     }
-    const currentPrice = new BigNumber9(priceString);
+    const currentPrice = new BigNumber7(priceString);
     const assetFills = fills.filter((fill) => fill.symbol === id);
     const entryPrice = computeEntryPriceForAsset(assetFills);
     const upnl = signedQuantity.multipliedBy(currentPrice.minus(entryPrice));
@@ -174,6 +206,7 @@ function computeAssetUnrealizedPnLs(exposureMap, priceMap, fills) {
   }
   return result;
 }
+__name(computeAssetUnrealizedPnLs, "computeAssetUnrealizedPnLs");
 function computeAssetRealizedPnLs(fills) {
   const bySymbol = /* @__PURE__ */ new Map();
   for (const fill of fills) {
@@ -183,8 +216,8 @@ function computeAssetRealizedPnLs(fills) {
   }
   const result = [];
   for (const [id, assetFills] of bySymbol) {
-    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 tradeFees = assetFills.reduce((acc, fill) => acc.plus(new BigNumber7(fill.tradeFee ?? "0")), ZERO);
+    const pearFees = assetFills.reduce((acc, fill) => acc.plus(new BigNumber7(fill.pearFee ?? "0")), ZERO);
     const totalFees = tradeFees.plus(pearFees);
     const { gross: grossPnl, undeterminedSize, closures, exitQuantity, exitNotional } = walkAssetFills(assetFills);
     const netPnl = grossPnl.minus(totalFees);
@@ -205,6 +238,7 @@ function computeAssetRealizedPnLs(fills) {
   }
   return result;
 }
+__name(computeAssetRealizedPnLs, "computeAssetRealizedPnLs");
 function walkAssetFills(fills) {
   let entryPrice = ZERO;
   let positionSize = ZERO;
@@ -262,6 +296,9 @@ function walkAssetFills(fills) {
     exitNotional
   };
 }
+__name(walkAssetFills, "walkAssetFills");
+
+// src/basket/compute.ts
 function computeBasketWeightedRatioV1(basket, priceMap) {
   let logSum = 0;
   for (const leg of basket) {
@@ -278,28 +315,39 @@ function computeBasketWeightedRatioV1(basket, priceMap) {
   }
   return exponentiate(logSum);
 }
+__name(computeBasketWeightedRatioV1, "computeBasketWeightedRatioV1");
 function deriveBasketKey(longInstrumentIds, shortInstrumentIds) {
   const payload = JSON.stringify({
-    long: [...longInstrumentIds].sort((a, b) => a.localeCompare(b)),
-    short: [...shortInstrumentIds].sort((a, b) => a.localeCompare(b))
+    long: [
+      ...longInstrumentIds
+    ].sort((a, b) => a.localeCompare(b)),
+    short: [
+      ...shortInstrumentIds
+    ].sort((a, b) => a.localeCompare(b))
   });
   return bytesToHex(sha256(new TextEncoder().encode(payload)));
 }
+__name(deriveBasketKey, "deriveBasketKey");
 function contractsToBase(contracts, contractSize) {
-  return new BigNumber9(contracts).times(contractSize);
+  return new BigNumber7(contracts).times(contractSize);
 }
+__name(contractsToBase, "contractsToBase");
 function baseToContracts(base, contractSize) {
-  return new BigNumber9(base).div(contractSize);
+  return new BigNumber7(base).div(contractSize);
 }
+__name(baseToContracts, "baseToContracts");
 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());
+    const sorted = [
+      ...symbolFills
+    ].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
     result.set(symbol, computeRealizedForSymbol(sorted));
   }
   return result;
 }
+__name(computeRealizedPnlBySymbol, "computeRealizedPnlBySymbol");
 function computeRealizedPnlFromFills(fills) {
   const byPnl = computeRealizedPnlBySymbol(fills);
   let total = ZERO;
@@ -308,6 +356,7 @@ function computeRealizedPnlFromFills(fills) {
   }
   return total;
 }
+__name(computeRealizedPnlFromFills, "computeRealizedPnlFromFills");
 function groupFillsBySymbol(fills) {
   const bySymbol = /* @__PURE__ */ new Map();
   for (const fill of fills) {
@@ -317,17 +366,18 @@ function groupFillsBySymbol(fills) {
   }
   return bySymbol;
 }
+__name(groupFillsBySymbol, "groupFillsBySymbol");
 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 price = new BigNumber7(fill.price);
+    const quantity = new BigNumber7(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());
+      const closedQty = BigNumber7.min(positionSize.abs(), signed2.abs());
       if (positionSize.isPositive()) {
         realized = realized.plus(closedQty.multipliedBy(price.minus(entryPrice)));
       } else {
@@ -345,6 +395,9 @@ function computeRealizedForSymbol(fills) {
   }
   return realized;
 }
+__name(computeRealizedForSymbol, "computeRealizedForSymbol");
+
+// src/position/compute.ts
 function computeUnrealizedPositionState(exposureMap, priceMap, fills) {
   const assetUPnLs = computeAssetUnrealizedPnLs(exposureMap, priceMap, fills);
   const entryPrice = computePositionEntryPrice(assetUPnLs);
@@ -363,9 +416,11 @@ function computeUnrealizedPositionState(exposureMap, priceMap, fills) {
     upnlBips
   };
 }
+__name(computeUnrealizedPositionState, "computeUnrealizedPositionState");
 function computeRealizedPositionState(fills) {
   return aggregateRealizedPositionState(computeAssetRealizedPnLs(fills));
 }
+__name(computeRealizedPositionState, "computeRealizedPositionState");
 function aggregateRealizedPositionState(assetPnLs) {
   const grossPnl = computePositionGrossRealizedPnL(assetPnLs);
   const netPnl = computePositionNetRealizedPnL(assetPnLs);
@@ -380,25 +435,24 @@ function aggregateRealizedPositionState(assetPnLs) {
     pearFees
   };
 }
+__name(aggregateRealizedPositionState, "aggregateRealizedPositionState");
 function computePositionEntryPrice(assetUPnLs) {
-  const { totalWeightedPrice, totalWeight } = assetUPnLs.reduce(
-    (acc, { signedQuantity, entryPrice }) => {
-      const absQuantity = signedQuantity.abs();
-      return {
-        totalWeightedPrice: acc.totalWeightedPrice.plus(absQuantity.multipliedBy(entryPrice)),
-        totalWeight: acc.totalWeight.plus(absQuantity)
-      };
-    },
-    {
-      totalWeightedPrice: ZERO,
-      totalWeight: ZERO
-    }
-  );
+  const { totalWeightedPrice, totalWeight } = assetUPnLs.reduce((acc, { signedQuantity, entryPrice }) => {
+    const absQuantity = signedQuantity.abs();
+    return {
+      totalWeightedPrice: acc.totalWeightedPrice.plus(absQuantity.multipliedBy(entryPrice)),
+      totalWeight: acc.totalWeight.plus(absQuantity)
+    };
+  }, {
+    totalWeightedPrice: ZERO,
+    totalWeight: ZERO
+  });
   if (totalWeight.isZero()) {
     return null;
   }
   return totalWeightedPrice.dividedBy(totalWeight);
 }
+__name(computePositionEntryPrice, "computePositionEntryPrice");
 function computePositionEntryNotional(assetUPnLs) {
   return assetUPnLs.reduce((acc, asset) => {
     if (asset.signedQuantity.isZero()) {
@@ -407,25 +461,24 @@ function computePositionEntryNotional(assetUPnLs) {
     return acc.plus(asset.signedQuantity.abs().multipliedBy(asset.entryPrice));
   }, ZERO);
 }
+__name(computePositionEntryNotional, "computePositionEntryNotional");
 function computePositionCurrentPrice(assetUPnLs) {
-  const { totalWeightedPrice, totalWeight } = assetUPnLs.reduce(
-    (acc, { signedQuantity, currentPrice }) => {
-      const absQuantity = signedQuantity.abs();
-      return {
-        totalWeightedPrice: acc.totalWeightedPrice.plus(absQuantity.multipliedBy(currentPrice)),
-        totalWeight: acc.totalWeight.plus(absQuantity)
-      };
-    },
-    {
-      totalWeightedPrice: ZERO,
-      totalWeight: ZERO
-    }
-  );
+  const { totalWeightedPrice, totalWeight } = assetUPnLs.reduce((acc, { signedQuantity, currentPrice }) => {
+    const absQuantity = signedQuantity.abs();
+    return {
+      totalWeightedPrice: acc.totalWeightedPrice.plus(absQuantity.multipliedBy(currentPrice)),
+      totalWeight: acc.totalWeight.plus(absQuantity)
+    };
+  }, {
+    totalWeightedPrice: ZERO,
+    totalWeight: ZERO
+  });
   if (totalWeight.isZero()) {
     return null;
   }
   return totalWeightedPrice.dividedBy(totalWeight);
 }
+__name(computePositionCurrentPrice, "computePositionCurrentPrice");
 function computePositionMarkNotional(assetUPnLs) {
   return assetUPnLs.reduce((acc, asset) => {
     if (asset.signedQuantity.isZero()) {
@@ -434,21 +487,26 @@ function computePositionMarkNotional(assetUPnLs) {
     return acc.plus(asset.signedQuantity.abs().multipliedBy(asset.currentPrice));
   }, ZERO);
 }
+__name(computePositionMarkNotional, "computePositionMarkNotional");
 function computePositionUnrealizedPnL(assetUPnLs) {
   return assetUPnLs.reduce((acc, asset) => acc.plus(asset.upnl), ZERO);
 }
+__name(computePositionUnrealizedPnL, "computePositionUnrealizedPnL");
 function computePositionUnrealizedPnLBips(upnl, entryNotional) {
   if (upnl.isZero() || entryNotional.isZero()) {
     return ZERO;
   }
   return upnl.div(entryNotional).multipliedBy(BIPS);
 }
+__name(computePositionUnrealizedPnLBips, "computePositionUnrealizedPnLBips");
 function computePositionGrossRealizedPnL(assetPnLs) {
   return assetPnLs.reduce((acc, asset) => acc.plus(asset.grossPnl), ZERO);
 }
+__name(computePositionGrossRealizedPnL, "computePositionGrossRealizedPnL");
 function computePositionNetRealizedPnL(assetPnLs) {
   return assetPnLs.reduce((acc, asset) => acc.plus(asset.netPnl), ZERO);
 }
+__name(computePositionNetRealizedPnL, "computePositionNetRealizedPnL");
 function computePositionEntryPrices(exposureMap, fills) {
   const entryPrices = {};
   for (const instrumentId of Object.keys(exposureMap)) {
@@ -459,6 +517,7 @@ function computePositionEntryPrices(exposureMap, fills) {
   }
   return entryPrices;
 }
+__name(computePositionEntryPrices, "computePositionEntryPrices");
 function computeUnrealizedPositionStateFromEntryPrices(exposureMap, entryPrices, priceMap) {
   const assetUPnLs = [];
   for (const [id, signedQuantityString] of Object.entries(exposureMap)) {
@@ -470,7 +529,13 @@ function computeUnrealizedPositionStateFromEntryPrices(exposureMap, entryPrices,
     const currentPrice = parse(currentPriceString);
     const entryPrice2 = parse(entryPriceString);
     const upnl2 = multiply(signedQuantity, subtract(currentPrice, entryPrice2));
-    assetUPnLs.push({ id, signedQuantity, entryPrice: entryPrice2, currentPrice, upnl: upnl2 });
+    assetUPnLs.push({
+      id,
+      signedQuantity,
+      entryPrice: entryPrice2,
+      currentPrice,
+      upnl: upnl2
+    });
   }
   const entryPrice = computePositionEntryPrice(assetUPnLs);
   const entryNotional = computePositionEntryNotional(assetUPnLs);
@@ -478,19 +543,31 @@ function computeUnrealizedPositionStateFromEntryPrices(exposureMap, entryPrices,
   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
+  };
 }
+__name(computeUnrealizedPositionStateFromEntryPrices, "computeUnrealizedPositionStateFromEntryPrices");
 function generateDeterministicPositionKey(input) {
-  const symbols = [...input.symbols].sort((a, b) => a.localeCompare(b));
+  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)));
 }
-BigNumber9.config({
+__name(generateDeterministicPositionKey, "generateDeterministicPositionKey");
+BigNumber7.config({
   DECIMAL_PLACES: 30,
-  ROUNDING_MODE: BigNumber9.ROUND_DOWN
+  ROUNDING_MODE: BigNumber7.ROUND_DOWN
 });
 function precisePrice(connector, raw, precision, side = "BUY", slippageToleranceBps = 0) {
   const normalized = normalizePrice(raw);
@@ -505,34 +582,38 @@ function precisePrice(connector, raw, precision, side = "BUY", slippageTolerance
       return preciseTickGridPrice(effectiveRaw, precision, side);
   }
 }
+__name(precisePrice, "precisePrice");
 function withSlippageTolerance(normalized, slippageToleranceBps, side) {
   if (slippageToleranceBps === 0) {
     return normalized;
   }
-  const bps = new BigNumber9(slippageToleranceBps);
+  const bps = new BigNumber7(slippageToleranceBps);
   const factor = bps.div(1e4);
-  return side === "BUY" ? normalized.times(new BigNumber9(1).plus(factor)) : normalized.times(new BigNumber9(1).minus(factor));
+  return side === "BUY" ? normalized.times(new BigNumber7(1).plus(factor)) : normalized.times(new BigNumber7(1).minus(factor));
 }
+__name(withSlippageTolerance, "withSlippageTolerance");
 function preciseHyperliquidPrice(price, precision, side) {
   const maxDecimals = precision.price.decimals;
   const maxSigFigs = precision.price.sigFigs ?? 5;
-  const rounding = side === "BUY" ? BigNumber9.ROUND_FLOOR : BigNumber9.ROUND_CEIL;
+  const rounding = side === "BUY" ? BigNumber7.ROUND_FLOOR : BigNumber7.ROUND_CEIL;
   price = price.decimalPlaces(maxDecimals, rounding);
   price = clampSigFigs(price, maxSigFigs, maxDecimals, rounding);
   return price.toFixed();
 }
+__name(preciseHyperliquidPrice, "preciseHyperliquidPrice");
 function preciseTickGridPrice(price, precision, side) {
   const tick = precision.price.tick ?? 1e-4;
-  const rounding = side === "BUY" ? BigNumber9.ROUND_FLOOR : BigNumber9.ROUND_CEIL;
-  const tickBN = new BigNumber9(tick);
+  const rounding = side === "BUY" ? BigNumber7.ROUND_FLOOR : BigNumber7.ROUND_CEIL;
+  const tickBN = new BigNumber7(tick);
   const scaled = price.div(tickBN);
   const snapped = scaled.integerValue(rounding).times(tickBN);
   const maxDecimals = precision.price.decimals;
   const final = snapped.decimalPlaces(maxDecimals, rounding);
   return final.toFixed();
 }
+__name(preciseTickGridPrice, "preciseTickGridPrice");
 function clampSigFigs(price, maxSigFigs, maxDecimals, rounding) {
-  const countSigFigs = (value) => value.toFixed().replace(".", "").replace(/^0+/, "").length;
+  const countSigFigs = /* @__PURE__ */ __name((value) => value.toFixed().replace(".", "").replace(/^0+/, "").length, "countSigFigs");
   if (countSigFigs(price) <= maxSigFigs) {
     return price;
   }
@@ -544,13 +625,15 @@ function clampSigFigs(price, maxSigFigs, maxDecimals, rounding) {
   }
   return price;
 }
+__name(clampSigFigs, "clampSigFigs");
 function normalizePrice(value) {
-  const parsed = new BigNumber9(value);
-  return new BigNumber9(parsed.toFixed());
+  const parsed = new BigNumber7(value);
+  return new BigNumber7(parsed.toFixed());
 }
-BigNumber9.config({
+__name(normalizePrice, "normalizePrice");
+BigNumber7.config({
   DECIMAL_PLACES: 30,
-  ROUNDING_MODE: BigNumber9.ROUND_DOWN
+  ROUNDING_MODE: BigNumber7.ROUND_DOWN
 });
 function preciseQuantity(connector, raw, precision, side) {
   switch (connector) {
@@ -563,23 +646,26 @@ function preciseQuantity(connector, raw, precision, side) {
       return preciseStepGridQuantity(raw, precision, side);
   }
 }
+__name(preciseQuantity, "preciseQuantity");
 function preciseHyperliquidQuantity(raw, precision, side) {
   const decimals = precision.quantity.decimals;
-  const quantity = new BigNumber9(raw);
-  const rounded = quantity.decimalPlaces(decimals, side === "BUY" ? BigNumber9.ROUND_FLOOR : BigNumber9.ROUND_CEIL);
+  const quantity = new BigNumber7(raw);
+  const rounded = quantity.decimalPlaces(decimals, side === "BUY" ? BigNumber7.ROUND_FLOOR : BigNumber7.ROUND_CEIL);
   return rounded.toFixed();
 }
+__name(preciseHyperliquidQuantity, "preciseHyperliquidQuantity");
 function preciseStepGridQuantity(raw, precision, side) {
   const step = precision.quantity.step;
   const contractQuantity = baseToContracts(raw, precision.quantity.contractSize);
-  const stepBN = new BigNumber9(step);
+  const stepBN = new BigNumber7(step);
   const scaled = contractQuantity.div(stepBN);
-  const rounded = side === "BUY" ? scaled.integerValue(BigNumber9.ROUND_FLOOR) : scaled.integerValue(BigNumber9.ROUND_CEIL);
+  const rounded = side === "BUY" ? scaled.integerValue(BigNumber7.ROUND_FLOOR) : scaled.integerValue(BigNumber7.ROUND_CEIL);
   const result = rounded.times(stepBN);
   const maxDecimals = precision.quantity.decimals;
-  const final = result.decimalPlaces(maxDecimals, side === "BUY" ? BigNumber9.ROUND_FLOOR : BigNumber9.ROUND_CEIL);
+  const final = result.decimalPlaces(maxDecimals, side === "BUY" ? BigNumber7.ROUND_FLOOR : BigNumber7.ROUND_CEIL);
   return final.toFixed();
 }
+__name(preciseStepGridQuantity, "preciseStepGridQuantity");
 
 // src/proxy.ts
 var activeOrigin = null;
@@ -594,12 +680,14 @@ function configureProxy(config) {
     activeOrigin = null;
   }
 }
+__name(configureProxy, "configureProxy");
 function toProxyUrl(target, origin) {
   const proxied = new URL(origin);
   proxied.pathname = target.pathname;
   proxied.search = target.search;
   return proxied.toString();
 }
+__name(toProxyUrl, "toProxyUrl");
 async function withProxyFallback(proxied, direct) {
   try {
     const response = await proxied();
@@ -608,17 +696,19 @@ async function withProxyFallback(proxied, direct) {
   }
   return direct();
 }
+__name(withProxyFallback, "withProxyFallback");
 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)
-  );
+  return withProxyFallback(() => fetch(toProxyUrl(target, origin), {
+    ...init,
+    headers
+  }), () => fetch(input, init));
 }
+__name(proxyFetch, "proxyFetch");
 
 // src/sync/applicables/constants.ts
 var DUST = parse("0.00000001");
@@ -626,8 +716,8 @@ 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}`
+    matches: /* @__PURE__ */ __name((fill) => fill.connector === "hyperliquid" && isPearCloid(fill.connector, fill.cloid), "matches"),
+    key: /* @__PURE__ */ __name((fill) => `v2-basket-hl ${fill.cloid}`, "key")
   }
 ];
 function isPearCloid(connector, cloid) {
@@ -636,17 +726,21 @@ function isPearCloid(connector, cloid) {
   }
   return PEAR_CLOID_CHECK[connector]?.(cloid) ?? false;
 }
+__name(isPearCloid, "isPearCloid");
 var PEAR_CLOID_CHECK = {
-  hyperliquid: (cloid) => cloid.startsWith("0x50454152"),
-  lighter: (cloid) => cloid.length === 15 && cloid.startsWith("10")
+  hyperliquid: /* @__PURE__ */ __name((cloid) => cloid.startsWith("0x50454152"), "hyperliquid"),
+  lighter: /* @__PURE__ */ __name((cloid) => cloid.length === 15 && cloid.startsWith("10"), "lighter")
 };
 
 // src/sync/applicables/basket.ts
 var Basket = class _Basket {
+  static {
+    __name(this, "Basket");
+  }
+  legs;
   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)));
@@ -661,26 +755,32 @@ var Basket = class _Basket {
   }
 };
 var CombinedLeg = class {
-  constructor(symbol, side) {
-    this.symbol = symbol;
-    this.side = side;
+  static {
+    __name(this, "CombinedLeg");
   }
   symbol;
   side;
   _totalSize = ZERO;
   queue = [];
+  constructor(symbol, side) {
+    this.symbol = symbol;
+    this.side = side;
+  }
   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) });
+    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` 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;
@@ -692,7 +792,10 @@ var CombinedLeg = class {
         continue;
       }
       const taken = min(entry.remaining, need);
-      parts.push({ source: entry.fill, quantity: taken.toFixed() });
+      parts.push({
+        source: entry.fill,
+        quantity: taken.toFixed()
+      });
       entry.remaining = entry.remaining.minus(taken);
       need = need.minus(taken);
     }
@@ -704,14 +807,20 @@ function groupFillsIntoBaskets(fills) {
   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: [] };
+    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);
   }
-  const sorted = [...buckets.values()].sort((a, b) => a.timestamp - b.timestamp);
+  const sorted = [
+    ...buckets.values()
+  ].sort((a, b) => a.timestamp - b.timestamp);
   return sorted.map((bucket) => bucket.fills);
 }
+__name(groupFillsIntoBaskets, "groupFillsIntoBaskets");
 function combineFillsBySymbolAndSide(group) {
   const map = /* @__PURE__ */ new Map();
   for (const fill of group) {
@@ -723,15 +832,21 @@ function combineFillsBySymbolAndSide(group) {
     }
     combined.addFill(fill);
   }
-  return [...map.values()];
+  return [
+    ...map.values()
+  ];
 }
+__name(combineFillsBySymbolAndSide, "combineFillsBySymbolAndSide");
 
 // src/sync/applicables/exposure.ts
 var Exposure = class _Exposure {
+  static {
+    __name(this, "Exposure");
+  }
+  legs;
   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());
@@ -784,7 +899,10 @@ var Exposure = class _Exposure {
           break;
       }
     }
-    return { longs, shorts };
+    return {
+      longs,
+      shorts
+    };
   }
   /** True once every leg sits within DUST of zero (effectively closed). */
   isFlat() {
@@ -805,10 +923,10 @@ var Exposure = class _Exposure {
     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.
-   */
+  * 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()) {
@@ -818,7 +936,9 @@ var Exposure = class _Exposure {
   }
   /** All symbols with a leg, including zeroed ones (a closed leg still carries cost basis). */
   symbols() {
-    return [...this.legs.keys()];
+    return [
+      ...this.legs.keys()
+    ];
   }
   /** Canonical signed-string view for the wire (`+0` for zero). */
   toSigned() {
@@ -833,29 +953,43 @@ var Exposure = class _Exposure {
 // src/sync/applicables/matching.ts
 function matchPositions(args) {
   const { tradeAccountId, orphanFills, pear } = args;
-  const book = WorkingBook.load({ tradeAccountId, openPositions: pear.positions() });
+  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 });
+    const leftover = applyCloses({
+      legs: basket.legs,
+      book,
+      exactCloseTarget
+    });
     if (leftover.length === 0) {
       continue;
     }
-    const target = resolveLeftoverTarget({ book, leftover });
+    const target = resolveLeftoverTarget({
+      book,
+      leftover
+    });
     applyLeftover(target, leftover);
   }
   return book.toMatched();
 }
-var WorkingBook = class _WorkingBook {
-  constructor(tradeAccountId) {
-    this.tradeAccountId = tradeAccountId;
+__name(matchPositions, "matchPositions");
+var WorkingBook = class WorkingBook2 {
+  static {
+    __name(this, "WorkingBook");
   }
   tradeAccountId;
   all = [];
   openByKey = /* @__PURE__ */ new Map();
+  constructor(tradeAccountId) {
+    this.tradeAccountId = tradeAccountId;
+  }
   /** 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);
+    const book = new WorkingBook2(tradeAccountId);
     for (const p of openPositions) {
       const position = {
         // Trust the position's own stored key — never recompute it from exposure.
@@ -874,7 +1008,10 @@ var WorkingBook = class _WorkingBook {
   }
   /** Deterministic position key for a symbol set under this book's trade account. */
   keyFor(symbols) {
-    return generateDeterministicPositionKey({ tradeAccountId: this.tradeAccountId, symbols });
+    return generateDeterministicPositionKey({
+      tradeAccountId: this.tradeAccountId,
+      symbols
+    });
   }
   /** Currently open working positions, in insertion order. */
   open() {
@@ -922,7 +1059,10 @@ function findExactCloseTarget(openList, basketLongs, basketShorts) {
     return setEq(longs, basketShorts) && setEq(shorts, basketLongs);
   });
 }
-var setEq = (a, b) => a.size === b.size && [...a].every((x) => b.has(x));
+__name(findExactCloseTarget, "findExactCloseTarget");
+var setEq = /* @__PURE__ */ __name((a, b) => a.size === b.size && [
+  ...a
+].every((x) => b.has(x)), "setEq");
 function applyCloses(args) {
   const { legs, book, exactCloseTarget } = args;
   const openList = book.open();
@@ -952,48 +1092,75 @@ function applyCloses(args) {
       book.markClosedIfFlat(position);
     }
     if (isGreaterThanOrEqual(remaining, DUST)) {
-      leftover.push({ side: leg.side, qty: remaining, leg });
+      leftover.push({
+        side: leg.side,
+        qty: remaining,
+        leg
+      });
     }
   }
   return leftover;
 }
+__name(applyCloses, "applyCloses");
 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;
+    const sameActiveShape = setEq(leftoverLongs, longs) && setEq(leftoverShorts, shorts);
+    const noDormantLegs = position.exposure.symbols().length === longs.size + shorts.size;
+    return sameActiveShape && noDormantLegs;
   });
   if (target) {
     return target;
   }
-  const symbols = [.../* @__PURE__ */ new Set([...leftoverLongs, ...leftoverShorts])];
+  const symbols = [
+    .../* @__PURE__ */ new Set([
+      ...leftoverLongs,
+      ...leftoverShorts
+    ])
+  ];
   const positionKey = book.keyFor(symbols);
   return book.findOpenByKey(positionKey) ?? book.create(positionKey);
 }
+__name(resolveLeftoverTarget, "resolveLeftoverTarget");
 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);
   }
 }
+__name(applyLeftover, "applyLeftover");
 
 // src/sync/applicables/synthetics.ts
 function isMissedHistoryFill(fill) {
   return fill.exchangeFillId.startsWith(MISSED_HISTORY_FILL_PREFIX);
 }
+__name(isMissedHistoryFill, "isMissedHistoryFill");
 function addFillsForMissedHistory(args) {
   const missedHistoryFills = buildMissedHistoryFills(args);
-  return [...missedHistoryFills, ...args.orphanFills].sort((a, b) => a.timestamp - b.timestamp);
+  return [
+    ...missedHistoryFills,
+    ...args.orphanFills
+  ].sort((a, b) => a.timestamp - b.timestamp);
 }
+__name(addFillsForMissedHistory, "addFillsForMissedHistory");
 function alignPositionsWithExchange(args) {
   const { positions, pear, snapshot, tradeAccountId } = args;
-  const neededSynthetics = findNeededSynthetics({ positions, pear, snapshot });
-  return assignSyntheticsToPositions({ neededSynthetics, positions, pear, tradeAccountId });
+  const neededSynthetics = findNeededSynthetics({
+    positions,
+    pear,
+    snapshot
+  });
+  return assignSyntheticsToPositions({
+    neededSynthetics,
+    positions,
+    pear,
+    tradeAccountId
+  });
 }
+__name(alignPositionsWithExchange, "alignPositionsWithExchange");
 function buildSyntheticFill(args) {
   return {
     // Content-addressed id — no wall-clock, no positionId, so re-syncs collide
@@ -1020,6 +1187,7 @@ function buildSyntheticFill(args) {
     liquidation: null
   };
 }
+__name(buildSyntheticFill, "buildSyntheticFill");
 function buildMissedHistoryFills(args) {
   const { orphanFills, pear, connector, entryBySymbol, snapshot } = args;
   const fillTotals = /* @__PURE__ */ new Map();
@@ -1030,13 +1198,16 @@ function buildMissedHistoryFills(args) {
     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 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 haveBySymbol = /* @__PURE__ */ __name((symbol) => add(pearTotals.get(symbol) ?? ZERO, fillTotals.get(symbol) ?? ZERO), "haveBySymbol");
   const result = [];
   for (const gap of gapsToTarget({
     assets,
@@ -1068,6 +1239,7 @@ function buildMissedHistoryFills(args) {
   }
   return result;
 }
+__name(buildMissedHistoryFills, "buildMissedHistoryFills");
 function priceForMissedHistoryFill(args) {
   const { exchangePosition, syntheticQty, pearQty, pearEntry, orphanNotional } = args;
   const fallback = exchangePosition?.entryPrice ?? "0";
@@ -1089,6 +1261,7 @@ function priceForMissedHistoryFill(args) {
   const derived = divide(subtract(targetNotional, realNotional), synthQty);
   return derived.isFinite() && derived.isPositive() ? derived.toFixed() : fallback;
 }
+__name(priceForMissedHistoryFill, "priceForMissedHistoryFill");
 function findNeededSynthetics(args) {
   const { positions, pear, snapshot } = args;
   const pearTotals = pear.totalBySymbol();
@@ -1104,13 +1277,13 @@ function findNeededSynthetics(args) {
   for (const symbol of pearTotals.keys()) {
     assets.add(symbol);
   }
-  const haveBySymbol = (symbol) => {
+  const haveBySymbol = /* @__PURE__ */ __name((symbol) => {
     let totalFills = ZERO;
     for (const pos of positions) {
       totalFills = add(totalFills, Exposure.netFromParts(pos.parts, symbol));
     }
     return add(pearTotals.get(symbol) ?? ZERO, totalFills);
-  };
+  }, "haveBySymbol");
   const result = /* @__PURE__ */ new Map();
   for (const gap of gapsToTarget({
     assets,
@@ -1137,9 +1310,13 @@ function findNeededSynthetics(args) {
   }
   return result;
 }
+__name(findNeededSynthetics, "findNeededSynthetics");
 function assignSyntheticsToPositions(args) {
   const { neededSynthetics, positions, pear, tradeAccountId } = args;
-  const keyOf = (symbols) => generateDeterministicPositionKey({ tradeAccountId, symbols });
+  const keyOf = /* @__PURE__ */ __name((symbols) => generateDeterministicPositionKey({
+    tradeAccountId,
+    symbols
+  }), "keyOf");
   const existingBySymbol = pear.positionBySymbol();
   const created = [];
   const byPosition = /* @__PURE__ */ new Map();
@@ -1147,11 +1324,12 @@ function assignSyntheticsToPositions(args) {
     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 ? existing.positionKey : keyOf([symbol]);
+      const positionKey = existing ? existing.positionKey : 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).
@@ -1175,8 +1353,15 @@ function assignSyntheticsToPositions(args) {
     list.push(spec);
     byPosition.set(target, list);
   }
-  return { positions: [...positions, ...created], synthByPosition: byPosition };
+  return {
+    positions: [
+      ...positions,
+      ...created
+    ],
+    synthByPosition: byPosition
+  };
 }
+__name(assignSyntheticsToPositions, "assignSyntheticsToPositions");
 function gapsToTarget(args) {
   const { assets, haveBySymbol, snapshot } = args;
   const gaps = [];
@@ -1192,6 +1377,7 @@ function gapsToTarget(args) {
   }
   return gaps;
 }
+__name(gapsToTarget, "gapsToTarget");
 function findGapToTarget(args) {
   const { symbol, have, target } = args;
   if (isZero(target)) {
@@ -1216,6 +1402,7 @@ function findGapToTarget(args) {
   }
   return null;
 }
+__name(findGapToTarget, "findGapToTarget");
 
 // src/sync/applicables/fills.ts
 function assignPartIds(positions) {
@@ -1231,13 +1418,18 @@ function assignPartIds(positions) {
   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 });
+      resolution.set(single, {
+        exchangeFillId: sourceId
+      });
       continue;
     }
     parts.forEach((part, i) => {
       resolution.set(part, {
         exchangeFillId: `${sourceId}-p${i}`,
-        original: { exchangeFillId: sourceId, quantity: part.source.quantity }
+        original: {
+          exchangeFillId: sourceId,
+          quantity: part.source.quantity
+        }
       });
     });
   }
@@ -1249,6 +1441,7 @@ function assignPartIds(positions) {
     return id;
   };
 }
+__name(assignPartIds, "assignPartIds");
 function partToApplicableFill(part, id, connector) {
   const fill = part.source;
   const base = {
@@ -1283,9 +1476,12 @@ function partToApplicableFill(part, id, connector) {
     tradeFee: feeShareForPart(fill.tradeFee, part.quantity, fill.quantity),
     builderFee: feeShareForPart(fill.builderFee, part.quantity, fill.quantity),
     liquidation: fill.liquidation,
-    ...id.original ? { original: id.original } : {}
+    ...id.original ? {
+      original: id.original
+    } : {}
   };
 }
+__name(partToApplicableFill, "partToApplicableFill");
 function feeShareForPart(totalFee, partQty, sourceQty) {
   if (isEqualTo(partQty, sourceQty)) {
     return totalFee;
@@ -1296,6 +1492,7 @@ function feeShareForPart(totalFee, partQty, sourceQty) {
   const feeShare = divide(multiply(totalFee, partQty), sourceQty);
   return feeShare.toFixed();
 }
+__name(feeShareForPart, "feeShareForPart");
 
 // src/sync/applicables/position.ts
 function assembleApplicables(args) {
@@ -1310,17 +1507,19 @@ function assembleApplicables(args) {
   }
   return applicables;
 }
+__name(assembleApplicables, "assembleApplicables");
 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);
+  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;
   }
@@ -1333,11 +1532,14 @@ function assembleOneApplicable(pos, connector, partIdFor, assignedSynthetics, no
     exposure: exposure.toSigned(),
     origin,
     status,
-    ...closed ? { closedReason: "NETTED" } : {},
+    ...closed ? {
+      closedReason: "NETTED"
+    } : {},
     fills,
     metadata: buildMetadata(new Set(exposure.symbols()), realFills)
   };
 }
+__name(assembleOneApplicable, "assembleOneApplicable");
 function finalExposure(pos, synthetics) {
   const exposure = pos.exposure.clone();
   for (const synthetic of synthetics) {
@@ -1345,6 +1547,7 @@ function finalExposure(pos, synthetics) {
   }
   return exposure;
 }
+__name(finalExposure, "finalExposure");
 function anchorSyntheticTimestamp(realFills, symbol, now) {
   const oldestForSymbol = realFills.find((fill) => fill.symbol === symbol)?.timestamp;
   if (oldestForSymbol !== void 0) {
@@ -1353,12 +1556,16 @@ function anchorSyntheticTimestamp(realFills, symbol, now) {
   const oldestRealTs = realFills[0]?.timestamp;
   return oldestRealTs !== void 0 ? Math.max(1, oldestRealTs - 1) : now;
 }
+__name(anchorSyntheticTimestamp, "anchorSyntheticTimestamp");
 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 legFills = realFills.flatMap((fill) => fill.symbol === symbol && fill.usd != null ? [
+      {
+        side: fill.side,
+        usd: fill.usd
+      }
+    ] : []);
     const opener = legFills[0];
     if (!opener) {
       continue;
@@ -1367,8 +1574,11 @@ function buildMetadata(symbols, realFills) {
     const signedNotional = signed(opener.side === "BUY" ? notional : notional.negated());
     initialExposureUSD[symbol] = signedNotional;
   }
-  return { initialExposureUSD };
+  return {
+    initialExposureUSD
+  };
 }
+__name(buildMetadata, "buildMetadata");
 function mergeOrigin(existing, fills) {
   let anyExternal = false;
   let anyPear = false;
@@ -1396,16 +1606,23 @@ function mergeOrigin(existing, fills) {
   }
   return anyPear ? "PEAR" : "EXTERNAL";
 }
+__name(mergeOrigin, "mergeOrigin");
 
 // src/sync/applicables/snapshot.ts
 var ExchangeSnapshot = class _ExchangeSnapshot {
+  static {
+    __name(this, "ExchangeSnapshot");
+  }
+  bySymbol;
   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])));
+    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) {
@@ -1427,14 +1644,19 @@ var ExchangeSnapshot = class _ExchangeSnapshot {
   }
   /** All symbols the exchange currently reports a position for. */
   symbols() {
-    return [...this.bySymbol.keys()];
+    return [
+      ...this.bySymbol.keys()
+    ];
   }
 };
 var PearHoldings = class _PearHoldings {
+  static {
+    __name(this, "PearHoldings");
+  }
+  filtered;
   constructor(filtered) {
     this.filtered = filtered;
   }
-  filtered;
   /** Filter `openPositions` to the given connector and wrap. */
   static from(args) {
     const { openPositions, connector } = args;
@@ -1458,10 +1680,10 @@ var PearHoldings = class _PearHoldings {
     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.
-   */
+  * 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) {
@@ -1481,18 +1703,37 @@ var PearHoldings = class _PearHoldings {
 function buildApplicables(args) {
   const { tradeAccountId, connector, orphanFills, openPositions, entryBySymbol, exchangePositions } = args;
   const snapshot = ExchangeSnapshot.from(exchangePositions);
-  const pear = PearHoldings.from({ openPositions, connector });
+  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 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 });
+  return assembleApplicables({
+    positions,
+    connector,
+    synthByPosition,
+    now
+  });
 }
+__name(buildApplicables, "buildApplicables");
 
 // src/sync/cutoff.ts
 function selectFirstSyncCutoff(args) {
@@ -1515,7 +1756,9 @@ function selectFirstSyncCutoff(args) {
   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 };
+      return boundary === 0 ? null : {
+        keepFromIndex: boundary
+      };
     }
     const preceding = fills[boundary - 1];
     if (preceding) {
@@ -1524,6 +1767,7 @@ function selectFirstSyncCutoff(args) {
   }
   return null;
 }
+__name(selectFirstSyncCutoff, "selectFirstSyncCutoff");
 function findFirstPearFillIndex(connector, fills) {
   const index = fills.findIndex((fill) => isPearCloid(connector, fill.cloid));
   if (index === -1) {
@@ -1531,6 +1775,7 @@ function findFirstPearFillIndex(connector, fills) {
   }
   return index;
 }
+__name(findFirstPearFillIndex, "findFirstPearFillIndex");
 function isStrictTimestampBoundary(fills, boundary) {
   const before = fills[boundary - 1];
   const after = fills[boundary];
@@ -1539,26 +1784,13 @@ function isStrictTimestampBoundary(fills, boundary) {
   }
   return before.timestamp < after.timestamp;
 }
+__name(isStrictTimestampBoundary, "isStrictTimestampBoundary");
 
 // src/sync/compute.ts
 async function computeSyncPayload(args) {
-  const {
-    tradeAccountId,
-    connector,
-    openPositions,
-    entryBySymbol,
-    provisionalFills,
-    confirmedExchangeFillIds,
-    externalFills,
-    exchangePositions,
-    neverSynced
-  } = 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 { reconcilables, confirmables: confirmableFills, orphans } = _segregateExternalFills(provisionalFills, fillsToProcess);
   const confirmablesByPosition = groupConfirmablesByPosition(confirmableFills);
   const { keptOrphans, firstSyncTrim } = applyFirstSyncCutoff({
     neverSynced,
@@ -1591,11 +1823,10 @@ async function computeSyncPayload(args) {
     firstSyncTrim
   };
 }
+__name(computeSyncPayload, "computeSyncPayload");
 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 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) {
@@ -1610,7 +1841,10 @@ function _prepareExternalFills(externalFills, confirmedExchangeFillIdsInput) {
     if (confirmedExchangeFillIds.has(normalizedExchangeFillId)) {
       return acc;
     }
-    acc.push({ ...fill, exchangeFillId: normalizedExchangeFillId });
+    acc.push({
+      ...fill,
+      exchangeFillId: normalizedExchangeFillId
+    });
     return acc;
   }, []);
   for (const fill of candidates) {
@@ -1621,6 +1855,7 @@ function _prepareExternalFills(externalFills, confirmedExchangeFillIdsInput) {
   }
   return Array.from(dedupedByExchangeFillId.values()).sort((a, b) => a.timestamp - b.timestamp);
 }
+__name(_prepareExternalFills, "_prepareExternalFills");
 function _segregateExternalFills(provisionalFills, externalFills) {
   const provisionalFillsMap = /* @__PURE__ */ new Map();
   for (const fill of provisionalFills) {
@@ -1637,7 +1872,10 @@ function _segregateExternalFills(provisionalFills, externalFills) {
     if (!cloid) {
       orphans.push(fill);
     } else {
-      fillsByCloid.set(cloid, [...fillsByCloid.get(cloid) || [], fill]);
+      fillsByCloid.set(cloid, [
+        ...fillsByCloid.get(cloid) || [],
+        fill
+      ]);
     }
   }
   const reconcilables = {};
@@ -1651,9 +1889,18 @@ function _segregateExternalFills(provisionalFills, externalFills) {
           throw new Error("Corrupted state: sibling group must contain at least 2 fills for reconcile");
         }
         reconcilables[cloid] = [
-          { ...first, cloid },
-          { ...second, cloid },
-          ...rest.map((fill) => ({ ...fill, cloid }))
+          {
+            ...first,
+            cloid
+          },
+          {
+            ...second,
+            cloid
+          },
+          ...rest.map((fill) => ({
+            ...fill,
+            cloid
+          }))
         ];
       } else {
         orphans.push(...fills);
@@ -1673,8 +1920,13 @@ function _segregateExternalFills(provisionalFills, externalFills) {
       }
     }
   }
-  return { reconcilables, confirmables: confirmableFills, orphans };
+  return {
+    reconcilables,
+    confirmables: confirmableFills,
+    orphans
+  };
 }
+__name(_segregateExternalFills, "_segregateExternalFills");
 function _normalizeCloid(cloid) {
   const value = cloid?.trim();
   if (!value) {
@@ -1682,6 +1934,7 @@ function _normalizeCloid(cloid) {
   }
   return value;
 }
+__name(_normalizeCloid, "_normalizeCloid");
 function _normalizeExchangeFillId(exchangeFillId) {
   const value = exchangeFillId?.trim().toLowerCase();
   if (!value) {
@@ -1689,6 +1942,7 @@ function _normalizeExchangeFillId(exchangeFillId) {
   }
   return value;
 }
+__name(_normalizeExchangeFillId, "_normalizeExchangeFillId");
 function _isValidExternalQuantity(quantity) {
   if (/e/i.test(quantity)) {
     return false;
@@ -1698,18 +1952,24 @@ function _isValidExternalQuantity(quantity) {
   }
   return isGreaterThan(quantity, ZERO);
 }
+__name(_isValidExternalQuantity, "_isValidExternalQuantity");
 function _isValidExternalTimestamp(timestamp) {
   if (!Number.isFinite(timestamp) || timestamp < 0) {
     return false;
   }
   return timestamp <= Date.now() + WATERMARK_FUTURE_SKEW_MS;
 }
+__name(_isValidExternalTimestamp, "_isValidExternalTimestamp");
 function groupConfirmablesByPosition(confirmableFills) {
   return confirmableFills.reduce((acc, fill) => {
-    acc[fill.positionId] = [...acc[fill.positionId] || [], fill];
+    acc[fill.positionId] = [
+      ...acc[fill.positionId] || [],
+      fill
+    ];
     return acc;
   }, {});
 }
+__name(groupConfirmablesByPosition, "groupConfirmablesByPosition");
 function latestFillTimestamp(fills) {
   const last = fills[fills.length - 1];
   if (!last) {
@@ -1717,10 +1977,14 @@ function latestFillTimestamp(fills) {
   }
   return last.timestamp;
 }
+__name(latestFillTimestamp, "latestFillTimestamp");
 function applyFirstSyncCutoff(args) {
   const { neverSynced, fillsToProcess, orphans, exchangePositions, connector } = args;
   if (!neverSynced || fillsToProcess.length === 0) {
-    return { keptOrphans: orphans, firstSyncTrim: null };
+    return {
+      keptOrphans: orphans,
+      firstSyncTrim: null
+    };
   }
   const cutoff = selectFirstSyncCutoff({
     fills: fillsToProcess,
@@ -1728,7 +1992,10 @@ function applyFirstSyncCutoff(args) {
     connector
   });
   if (!cutoff) {
-    return { keptOrphans: orphans, firstSyncTrim: null };
+    return {
+      keptOrphans: orphans,
+      firstSyncTrim: null
+    };
   }
   const keptIds = new Set(fillsToProcess.slice(cutoff.keepFromIndex).map((fill) => fill.exchangeFillId));
   const keptOrphans = [];
@@ -1737,7 +2004,10 @@ function applyFirstSyncCutoff(args) {
     (keptIds.has(orphan.exchangeFillId) ? keptOrphans : droppedOrphans).push(orphan);
   }
   if (droppedOrphans.length === 0) {
-    return { keptOrphans, firstSyncTrim: null };
+    return {
+      keptOrphans,
+      firstSyncTrim: null
+    };
   }
   const firstKeptFill = fillsToProcess[cutoff.keepFromIndex];
   return {
@@ -1749,9 +2019,11 @@ function applyFirstSyncCutoff(args) {
     }
   };
 }
+__name(applyFirstSyncCutoff, "applyFirstSyncCutoff");
 function isEmptyCycle(reconcilables, confirmablesByPosition, applicables) {
   return Object.keys(reconcilables).length === 0 && Object.keys(confirmablesByPosition).length === 0 && applicables.length === 0;
 }
+__name(isEmptyCycle, "isEmptyCycle");
 
 // src/validate-leverage.ts
 function validateLeverage(leverage, instrument) {
@@ -1763,32 +2035,104 @@ function validateLeverage(leverage, instrument) {
   }
   return true;
 }
+__name(validateLeverage, "validateLeverage");
 function validateQuantity(quantity, price, precision) {
-  const parsedQuantity = new BigNumber9(quantity);
+  const parsedQuantity = new BigNumber7(quantity);
   if (!parsedQuantity.isFinite() || parsedQuantity.lte(0)) {
     return false;
   }
-  const parsedPrice = new BigNumber9(price);
+  const parsedPrice = new BigNumber7(price);
   if (!parsedPrice.isFinite() || parsedPrice.lte(0)) {
     return false;
   }
-  const step = new BigNumber9(precision.quantity.step);
+  const step = new BigNumber7(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 BigNumber9(precision.notional.min))) {
+    if (notional.lt(new BigNumber7(precision.notional.min))) {
       return false;
     }
   }
   if (precision.notional?.max !== void 0 && precision.notional.max !== null && precision.notional.max > 0) {
-    if (notional.gt(new BigNumber9(precision.notional.max))) {
+    if (notional.gt(new BigNumber7(precision.notional.max))) {
       return false;
     }
   }
   return true;
 }
+__name(validateQuantity, "validateQuantity");
+var STORAGE_PREFIX = "pear.x-handoff.";
+function startXHandoff(storage) {
+  const handoffId = base64urlnopad.encode(randomBytes(16));
+  const verifier = base64urlnopad.encode(randomBytes(32));
+  storage.setItem(`${STORAGE_PREFIX}${handoffId}`, verifier);
+  return {
+    handoffId,
+    challenge: base64urlnopad.encode(sha256(utf8ToBytes(verifier)))
+  };
+}
+__name(startXHandoff, "startXHandoff");
+function finishXHandoff(href, storage) {
+  const url = new URL(href);
+  const linkStatus = url.searchParams.get("x_link");
+  const loginStatus = url.searchParams.get("x_login");
+  const reason = url.searchParams.get("x_reason") ?? void 0;
+  if (linkStatus === "connected" || linkStatus === "reconnected") {
+    return {
+      kind: "link-succeeded",
+      status: linkStatus
+    };
+  }
+  if (linkStatus) {
+    return {
+      kind: "link-failed",
+      reason
+    };
+  }
+  if (!loginStatus) {
+    return void 0;
+  }
+  const verifier = takeVerifier(url.searchParams.get("x_handoff"), storage);
+  const ticket = new URLSearchParams(url.hash.replace(/^#/, "")).get("x_ticket");
+  if (loginStatus !== "signed_in" || !ticket || !verifier) {
+    return {
+      kind: "login-failed",
+      reason: loginStatus === "signed_in" ? "wrong_browser" : reason
+    };
+  }
+  return {
+    kind: "login-settled",
+    ticket,
+    verifier
+  };
+}
+__name(finishXHandoff, "finishXHandoff");
+function stripXReturn(href) {
+  const url = new URL(href);
+  for (const key of [
+    "x_link",
+    "x_login",
+    "x_reason",
+    "x_handoff"
+  ]) {
+    url.searchParams.delete(key);
+  }
+  url.hash = "";
+  return `${url.pathname}${url.search}`;
+}
+__name(stripXReturn, "stripXReturn");
+function takeVerifier(handoffId, storage) {
+  if (!handoffId) {
+    return void 0;
+  }
+  const key = `${STORAGE_PREFIX}${handoffId}`;
+  const verifier = storage.getItem(key) ?? void 0;
+  storage.removeItem(key);
+  return verifier;
+}
+__name(takeVerifier, "takeVerifier");
 
-export { BIPS, ZERO, abs, add, aggregateRealizedPositionState, baseToContracts, buildApplicables, compareValue, computeAssetEntryNotional, computeAssetGrossRealizedPnL, computeAssetRealizedPnLs, computeAssetUndeterminedSizes, computeAssetUnrealizedPnL, computeAssetUnrealizedPnLs, computeBasketWeightedRatioV1, computeEntryPriceForAsset, computePositionEntryPrices, computeRealizedPnlBySymbol, computeRealizedPnlFromFills, computeRealizedPositionState, computeSyncPayload, computeUnrealizedPositionState, computeUnrealizedPositionStateFromEntryPrices, configureProxy, contractsToBase, countDecimals, deriveBasketKey, 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 };
+export { BIPS, ZERO, abs, add, aggregateRealizedPositionState, baseToContracts, buildApplicables, compareValue, computeAssetEntryNotional, computeAssetGrossRealizedPnL, computeAssetRealizedPnLs, computeAssetUndeterminedSizes, computeAssetUnrealizedPnL, computeAssetUnrealizedPnLs, computeBasketWeightedRatioV1, computeEntryPriceForAsset, computePositionEntryPrices, computeRealizedPnlBySymbol, computeRealizedPnlFromFills, computeRealizedPositionState, computeSyncPayload, computeUnrealizedPositionState, computeUnrealizedPositionStateFromEntryPrices, configureProxy, contractsToBase, countDecimals, deriveBasketKey, divide, exponentiate, finishXHandoff, generateDeterministicPositionKey, isEqualTo, isFiniteDecimal, isGreaterThan, isGreaterThanOrEqual, isLessThan, isLessThanOrEqual, isNegative, isPositive, isZero, min, multiply, negate, parse, precisePrice, preciseQuantity, proxyFetch, sideSign, sign, signed, signedBySide, startXHandoff, stripXReturn, subtract, toDecimalString, validateLeverage, validateQuantity };