@pear-protocol/utils 1.6.0 → 1.7.0

package/dist/index.js

@@ -1,7 +1,6 @@
 import BigNumber7 from 'bignumber.js';
 import { sha256 } from '@noble/hashes/sha2';
 import { bytesToHex, utf8ToBytes, randomBytes } from '@noble/hashes/utils';
-import { WATERMARK_FUTURE_SKEW_MS } from '@pear-protocol/types';
 import { keccak_256 } from '@noble/hashes/sha3';
 import { base64urlnopad } from '@scure/base';
 
@@ -1011,6 +1010,168 @@ function computeRealizedForSymbol(fills) {
   return realized;
 }
 __name(computeRealizedForSymbol, "computeRealizedForSymbol");
+BigNumber7.config({
+  DECIMAL_PLACES: 30,
+  ROUNDING_MODE: BigNumber7.ROUND_DOWN
+});
+var InvalidPriceError = class extends Error {
+  static {
+    __name(this, "InvalidPriceError");
+  }
+};
+function precisePrice(connector, raw, precision, side = "BUY", slippageToleranceBps = 0, rounding = "marketable") {
+  const normalized = normalizePrice(raw);
+  if (!normalized.isFinite() || !normalized.isGreaterThan(0)) {
+    throw new InvalidPriceError(`Price ${String(raw)} is not a positive, finite price`);
+  }
+  const effectiveRaw = withSlippageTolerance(normalized, slippageToleranceBps, side);
+  const roundingMode = resolveRoundingMode(side, rounding);
+  const precise = preciseOnGrid(connector, effectiveRaw, precision, roundingMode);
+  const clampsToOneStep = rounding === "marketable" && side === "SELL" && !new BigNumber7(precise).isGreaterThan(0);
+  const result = clampsToOneStep ? smallestGridPrice(connector, precision) : precise;
+  const resultBN = new BigNumber7(result);
+  if (!resultBN.isFinite() || !resultBN.isGreaterThan(0)) {
+    throw new InvalidPriceError(`Price ${effectiveRaw.toFixed()} has no valid ${side} price on the grid`);
+  }
+  return result;
+}
+__name(precisePrice, "precisePrice");
+function preciseOnGrid(connector, price, precision, rounding) {
+  switch (connector) {
+    case "hyperliquid":
+      return preciseHyperliquidPrice(price, precision, rounding);
+    case "binance":
+    case "bybit":
+    case "okx":
+    case "lighter":
+    case "lighter_rhc":
+      return preciseTickGridPrice(price, precision, rounding);
+  }
+}
+__name(preciseOnGrid, "preciseOnGrid");
+function smallestGridPrice(connector, precision) {
+  return preciseOnGrid(connector, new BigNumber7(1).shiftedBy(-precision.price.decimals), precision, BigNumber7.ROUND_CEIL);
+}
+__name(smallestGridPrice, "smallestGridPrice");
+function resolveRoundingMode(side, rounding) {
+  switch (rounding) {
+    // Towards crossing: the buffer survives rounding.
+    case "marketable":
+      return side === "BUY" ? BigNumber7.ROUND_CEIL : BigNumber7.ROUND_FLOOR;
+    // Away from crossing: the limit holds.
+    case "within_limit":
+      return side === "BUY" ? BigNumber7.ROUND_FLOOR : BigNumber7.ROUND_CEIL;
+  }
+}
+__name(resolveRoundingMode, "resolveRoundingMode");
+function withSlippageTolerance(normalized, slippageToleranceBps, side) {
+  if (slippageToleranceBps === 0) {
+    return normalized;
+  }
+  const bps = new BigNumber7(slippageToleranceBps);
+  const factor = bps.div(1e4);
+  return side === "BUY" ? normalized.times(new BigNumber7(1).plus(factor)) : normalized.times(new BigNumber7(1).minus(factor));
+}
+__name(withSlippageTolerance, "withSlippageTolerance");
+function preciseHyperliquidPrice(price, precision, rounding) {
+  const maxDecimals = precision.price.decimals;
+  const maxSigFigs = precision.price.sigFigs ?? 5;
+  price = price.decimalPlaces(maxDecimals, rounding);
+  price = clampSigFigs(price, maxSigFigs, maxDecimals, rounding);
+  return price.toFixed();
+}
+__name(preciseHyperliquidPrice, "preciseHyperliquidPrice");
+function preciseTickGridPrice(price, precision, rounding) {
+  const tick = precision.price.tick ?? 1e-4;
+  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 = /* @__PURE__ */ __name((value) => value.toFixed().replace(".", "").replace(/^0+/, "").length, "countSigFigs");
+  if (countSigFigs(price) <= maxSigFigs) {
+    return price;
+  }
+  for (let decimals = maxDecimals; decimals >= 1; decimals--) {
+    const candidate = price.decimalPlaces(decimals, rounding);
+    if (countSigFigs(candidate) <= maxSigFigs) {
+      return candidate;
+    }
+  }
+  return price.decimalPlaces(0, rounding);
+}
+__name(clampSigFigs, "clampSigFigs");
+function normalizePrice(value) {
+  const parsed = new BigNumber7(value);
+  return new BigNumber7(parsed.toFixed());
+}
+__name(normalizePrice, "normalizePrice");
+
+// src/market-reference-price.ts
+function resolveMarketLimitPrice(connector, quote, precision, side, slippageToleranceBps, pricing) {
+  const reference = resolveMarketReference(quote, side, pricing);
+  return precisePrice(connector, reference.price, precision, side, slippageToleranceBps, reference.rounding);
+}
+__name(resolveMarketLimitPrice, "resolveMarketLimitPrice");
+function resolveMarketReference(quote, side, pricing) {
+  const reference = parse(quote.p);
+  const touch = resolveUsableTouch(quote, reference);
+  if (pricing === "mid" || !touch) {
+    return {
+      price: reference.toFixed(),
+      rounding: "marketable"
+    };
+  }
+  switch (side) {
+    case "BUY":
+      return {
+        price: touch.ask.toFixed(),
+        rounding: "within_limit"
+      };
+    case "SELL":
+      return {
+        price: touch.bid.toFixed(),
+        rounding: "within_limit"
+      };
+  }
+}
+__name(resolveMarketReference, "resolveMarketReference");
+function marketPricingFor(origin) {
+  switch (origin) {
+    case "direct":
+    case "copy":
+    case "manual-rebalance":
+      return "touch";
+    case "trigger":
+    case "schedule":
+    case "auto-rebalance":
+    case "vault-liquidity":
+      return "mid";
+  }
+}
+__name(marketPricingFor, "marketPricingFor");
+function resolveUsableTouch(quote, reference) {
+  if (quote.bid === null || quote.ask === null) {
+    return null;
+  }
+  if (!isFiniteDecimal(quote.bid) || !isFiniteDecimal(quote.ask)) {
+    return null;
+  }
+  const bid = parse(quote.bid);
+  const ask = parse(quote.ask);
+  if (!bid.isGreaterThan(0) || !bid.isLessThan(ask) || reference.isLessThan(bid) || reference.isGreaterThan(ask)) {
+    return null;
+  }
+  return {
+    bid,
+    ask
+  };
+}
+__name(resolveUsableTouch, "resolveUsableTouch");
 
 // src/position/compute.ts
 function computeUnrealizedPositionState(exposureMap, priceMap, fills) {
@@ -1188,106 +1349,6 @@ BigNumber7.config({
   DECIMAL_PLACES: 30,
   ROUNDING_MODE: BigNumber7.ROUND_DOWN
 });
-var InvalidPriceError = class extends Error {
-  static {
-    __name(this, "InvalidPriceError");
-  }
-};
-function precisePrice(connector, raw, precision, side = "BUY", slippageToleranceBps = 0, rounding = "marketable") {
-  const normalized = normalizePrice(raw);
-  if (!normalized.isFinite() || !normalized.isGreaterThan(0)) {
-    throw new InvalidPriceError(`Price ${String(raw)} is not a positive, finite price`);
-  }
-  const effectiveRaw = withSlippageTolerance(normalized, slippageToleranceBps, side);
-  const roundingMode = resolveRoundingMode(side, rounding);
-  const precise = preciseOnGrid(connector, effectiveRaw, precision, roundingMode);
-  const clampsToOneStep = rounding === "marketable" && side === "SELL" && !new BigNumber7(precise).isGreaterThan(0);
-  const result = clampsToOneStep ? smallestGridPrice(connector, precision) : precise;
-  const resultBN = new BigNumber7(result);
-  if (!resultBN.isFinite() || !resultBN.isGreaterThan(0)) {
-    throw new InvalidPriceError(`Price ${effectiveRaw.toFixed()} has no valid ${side} price on the grid`);
-  }
-  return result;
-}
-__name(precisePrice, "precisePrice");
-function preciseOnGrid(connector, price, precision, rounding) {
-  switch (connector) {
-    case "hyperliquid":
-      return preciseHyperliquidPrice(price, precision, rounding);
-    case "binance":
-    case "bybit":
-    case "okx":
-    case "lighter":
-    case "lighter_rhc":
-      return preciseTickGridPrice(price, precision, rounding);
-  }
-}
-__name(preciseOnGrid, "preciseOnGrid");
-function smallestGridPrice(connector, precision) {
-  return preciseOnGrid(connector, new BigNumber7(1).shiftedBy(-precision.price.decimals), precision, BigNumber7.ROUND_CEIL);
-}
-__name(smallestGridPrice, "smallestGridPrice");
-function resolveRoundingMode(side, rounding) {
-  switch (rounding) {
-    // Towards crossing: the buffer survives rounding.
-    case "marketable":
-      return side === "BUY" ? BigNumber7.ROUND_CEIL : BigNumber7.ROUND_FLOOR;
-    // Away from crossing: the limit holds.
-    case "within_limit":
-      return side === "BUY" ? BigNumber7.ROUND_FLOOR : BigNumber7.ROUND_CEIL;
-  }
-}
-__name(resolveRoundingMode, "resolveRoundingMode");
-function withSlippageTolerance(normalized, slippageToleranceBps, side) {
-  if (slippageToleranceBps === 0) {
-    return normalized;
-  }
-  const bps = new BigNumber7(slippageToleranceBps);
-  const factor = bps.div(1e4);
-  return side === "BUY" ? normalized.times(new BigNumber7(1).plus(factor)) : normalized.times(new BigNumber7(1).minus(factor));
-}
-__name(withSlippageTolerance, "withSlippageTolerance");
-function preciseHyperliquidPrice(price, precision, rounding) {
-  const maxDecimals = precision.price.decimals;
-  const maxSigFigs = precision.price.sigFigs ?? 5;
-  price = price.decimalPlaces(maxDecimals, rounding);
-  price = clampSigFigs(price, maxSigFigs, maxDecimals, rounding);
-  return price.toFixed();
-}
-__name(preciseHyperliquidPrice, "preciseHyperliquidPrice");
-function preciseTickGridPrice(price, precision, rounding) {
-  const tick = precision.price.tick ?? 1e-4;
-  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 = /* @__PURE__ */ __name((value) => value.toFixed().replace(".", "").replace(/^0+/, "").length, "countSigFigs");
-  if (countSigFigs(price) <= maxSigFigs) {
-    return price;
-  }
-  for (let decimals = maxDecimals; decimals >= 1; decimals--) {
-    const candidate = price.decimalPlaces(decimals, rounding);
-    if (countSigFigs(candidate) <= maxSigFigs) {
-      return candidate;
-    }
-  }
-  return price.decimalPlaces(0, rounding);
-}
-__name(clampSigFigs, "clampSigFigs");
-function normalizePrice(value) {
-  const parsed = new BigNumber7(value);
-  return new BigNumber7(parsed.toFixed());
-}
-__name(normalizePrice, "normalizePrice");
-BigNumber7.config({
-  DECIMAL_PLACES: 30,
-  ROUNDING_MODE: BigNumber7.ROUND_DOWN
-});
 function preciseQuantity(connector, raw, precision, side, rounding = "side") {
   const roundingMode = resolveRoundingMode2(side, rounding);
   switch (connector) {
@@ -1329,6 +1390,20 @@ function preciseStepGridQuantity(raw, precision, roundingMode) {
 }
 __name(preciseStepGridQuantity, "preciseStepGridQuantity");
 
+// src/precise-quantity-with-mode.ts
+function preciseQuantityWithMode(connector, leg, precision, referencePrice, constrainUsdQuantity = false) {
+  switch (leg.mode) {
+    case "QUANTITY":
+      return preciseQuantity(connector, leg.amount, precision, leg.side);
+    case "USD": {
+      const quantity = divide(leg.amount, referencePrice);
+      const roundingSide = constrainUsdQuantity && !leg.reduceOnly ? "BUY" : leg.side;
+      return preciseQuantity(connector, quantity, precision, roundingSide);
+    }
+  }
+}
+__name(preciseQuantityWithMode, "preciseQuantityWithMode");
+
 // src/proxy.ts
 var activeOrigin = null;
 function configureProxy(config) {
@@ -1437,8 +1512,8 @@ function requestedBaseQuantity(leg, referencePrice) {
   }
 }
 __name(requestedBaseQuantity, "requestedBaseQuantity");
-function isRefusedBelowMinimum(quantity, price, precision, heldByAnotherPosition) {
-  if (!heldByAnotherPosition) {
+function isRefusedBelowMinimum(quantity, price, precision, isPartialVenueReduce) {
+  if (!isPartialVenueReduce) {
     return false;
   }
   const minQuantity = precision.quantity.min;
@@ -1451,1271 +1526,15 @@ function isRefusedBelowMinimum(quantity, price, precision, heldByAnotherPosition
 }
 __name(isRefusedBelowMinimum, "isRefusedBelowMinimum");
 
-// src/sync/applicables/constants.ts
-var DUST = parse("0.00000001");
-var LATE_FILL_GRACE_MS = 5 * 6e4;
-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: /* @__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) {
-  if (!cloid) {
+// src/validate-leverage.ts
+function validateLeverage(leverage, instrument) {
+  if (leverage < 1 || leverage > 100) {
     return false;
   }
-  return PEAR_CLOID_CHECK[connector](cloid);
-}
-__name(isPearCloid, "isPearCloid");
-var PEAR_CLOID_CHECK = {
-  hyperliquid: /* @__PURE__ */ __name((cloid) => cloid.startsWith("0x50454152"), "hyperliquid"),
-  lighter: isLighterPearCloid,
-  lighter_rhc: isLighterPearCloid,
-  // No Pear brand is minted into a CEX client order id, so provenance cannot be read from it.
-  binance: /* @__PURE__ */ __name(() => false, "binance"),
-  bybit: /* @__PURE__ */ __name(() => false, "bybit"),
-  okx: /* @__PURE__ */ __name(() => false, "okx")
-};
-function isLighterPearCloid(cloid) {
-  return cloid.length === 15 && cloid.startsWith("10");
-}
-__name(isLighterPearCloid, "isLighterPearCloid");
-
-// src/sync/applicables/basket.ts
-var Basket = class _Basket {
-  static {
-    __name(this, "Basket");
-  }
-  legs;
-  fills;
-  constructor(legs, fills) {
-    this.legs = legs;
-    this.fills = fills;
-  }
-  /** Detect baskets from a fill stream, returned in ascending time order. */
-  static detect(fills) {
-    return groupFillsIntoBaskets(fills).map((group) => new _Basket(combineFillsBySymbolAndSide(group), group));
-  }
-};
-var CombinedLeg = class {
-  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)
-    });
-  }
-  /**
-  * 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;
-  }
-};
-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);
-  }
-  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) {
-    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);
+  if (leverage > instrument.leverage) {
+    return false;
   }
-  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;
-  }
-  /** 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 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;
-  }
-  /** 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/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);
-}
-__name(addFillsForMissedHistory, "addFillsForMissedHistory");
-function alignPositionsWithExchange(args) {
-  const { positions, pear, snapshot, tradeAccountId } = args;
-  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
-    // on the dedup index and synthetic generation stays idempotent.
-    exchangeFillId: syntheticFillId(args),
-    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
-  };
-}
-__name(buildSyntheticFill, "buildSyntheticFill");
-function syntheticFillId(args) {
-  if (args.lifecycleStartedAt === null) {
-    return `synthetic-${args.positionKey}-${args.symbol}-${args.side}`;
-  }
-  return `synthetic-${args.positionKey}-${args.lifecycleStartedAt}-${args.symbol}-${args.side}`;
-}
-__name(syntheticFillId, "syntheticFillId");
-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 = /* @__PURE__ */ __name((symbol) => add(pearTotals.get(symbol) ?? ZERO, fillTotals.get(symbol) ?? ZERO), "haveBySymbol");
-  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()}-${watermark}`,
-      cloid: null,
-      symbol,
-      price,
-      quantity: gap.quantity,
-      side: gap.side,
-      reduceOnly: false,
-      timestamp: watermark,
-      tradeFee: "0",
-      builderFee: "0",
-      liquidation: null
-    });
-  }
-  return result;
-}
-__name(buildMissedHistoryFills, "buildMissedHistoryFills");
-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));
-  }
-  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;
-}
-__name(priceForMissedHistoryFill, "priceForMissedHistoryFill");
-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 = /* @__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,
-    haveBySymbol,
-    snapshot
-  })) {
-    switch (gap.kind) {
-      case "gone":
-        result.set(gap.symbol, {
-          symbol: gap.symbol,
-          side: gap.side,
-          quantity: gap.quantity,
-          closedReason: "USER"
-        });
-        break;
-      case "gap":
-        result.set(gap.symbol, {
-          symbol: gap.symbol,
-          side: gap.side,
-          quantity: gap.quantity
-        });
-        break;
-    }
-  }
-  return result;
-}
-__name(findNeededSynthetics, "findNeededSynthetics");
-function assignSyntheticsToPositions(args) {
-  const { neededSynthetics, positions, pear, tradeAccountId } = args;
-  const keyOf = /* @__PURE__ */ __name((symbols) => generateDeterministicPositionKey({
-    tradeAccountId,
-    symbols
-  }), "keyOf");
-  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 ? existing.positionKey : keyOf([
-        symbol
-      ]);
-      const isKeyTarget = /* @__PURE__ */ __name((pos) => pos.positionKey === positionKey && (!existing || pos.existingOrigin !== void 0), "isKeyTarget");
-      target = positions.find(isKeyTarget) ?? created.find(isKeyTarget);
-      if (!target) {
-        target = existing ? (
-          // seed its exposure and origin so folding the synthetic yields the true
-          // final state (a gone-close nets to zero -> CLOSED/USER, a gap writes
-          // the full total, not just the delta).
-          {
-            positionKey,
-            parts: [],
-            closed: false,
-            exposure: Exposure.fromRecord(existing.exposure),
-            existingOrigin: existing.origin,
-            lifecycleStartedAt: Date.parse(existing.createdAt)
-          }
-        ) : {
-          positionKey,
-          parts: [],
-          closed: false,
-          exposure: Exposure.empty(),
-          lifecycleStartedAt: null
-        };
-        created.push(target);
-      }
-    }
-    const list = byPosition.get(target) ?? [];
-    list.push(spec);
-    byPosition.set(target, list);
-  }
-  return {
-    positions: [
-      ...positions,
-      ...created
-    ],
-    synthByPosition: byPosition
-  };
-}
-__name(assignSyntheticsToPositions, "assignSyntheticsToPositions");
-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);
-    }
-  }
-  return gaps;
-}
-__name(gapsToTarget, "gapsToTarget");
-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 residual = subtract(target, have);
-  if (isGreaterThan(abs(residual), DUST)) {
-    return {
-      kind: "gap",
-      symbol,
-      side: residual.isPositive() ? "BUY" : "SELL",
-      quantity: residual.abs().toFixed()
-    };
-  }
-  return null;
-}
-__name(findGapToTarget, "findGapToTarget");
-
-// 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 at = basketTime(basket);
-    book.foldIntoLive(at);
-    const leftover = applyCloses({
-      legs: basket.legs,
-      book,
-      at
-    });
-    if (leftover.length === 0) {
-      continue;
-    }
-    const target = resolveLeftoverTarget({
-      book,
-      leftover,
-      at
-    });
-    applyLeftover(target, leftover);
-  }
-  book.foldIntoLive(Number.POSITIVE_INFINITY);
-  return book.toMatched();
-}
-__name(matchPositions, "matchPositions");
-function basketTime(basket) {
-  const realTimestamps = basket.fills.filter((fill) => !isMissedHistoryFill(fill)).map((fill) => fill.timestamp);
-  if (realTimestamps.length === 0) {
-    return Number.POSITIVE_INFINITY;
-  }
-  return Math.min(...realTimestamps);
-}
-__name(basketTime, "basketTime");
-var WorkingBook = class WorkingBook2 {
-  static {
-    __name(this, "WorkingBook");
-  }
-  tradeAccountId;
-  all = [];
-  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 WorkingBook2(tradeAccountId);
-    for (const p of openPositions) {
-      const position = {
-        // Trust the position's own stored key — never recompute it from exposure.
-        // A partial fill on the original order leaves exposure short of the
-        // symbols the key was hashed from, so a recomputed key would never match.
-        positionKey: p.positionKey,
-        createdAt: Date.parse(p.createdAt),
-        orderId: p.id,
-        exposure: Exposure.fromRecord(p.exposure),
-        parts: [],
-        closed: false,
-        existingOrigin: p.origin,
-        // A seeded position takes fills from its creation, less the late-arrival grace.
-        liveFrom: Date.parse(p.createdAt) - LATE_FILL_GRACE_MS
-      };
-      book.all.push(position);
-    }
-    return book;
-  }
-  /** Deterministic position key for a symbol set under this book's trade account. */
-  keyFor(symbols) {
-    return generateDeterministicPositionKey({
-      tradeAccountId: this.tradeAccountId,
-      symbols
-    });
-  }
-  /** Working positions open and already existing at basket time `at`, in creation order. */
-  live(at) {
-    return this.all.filter((position) => !position.closed && position.liveFrom <= at).sort((a, b) => a.createdAt - b.createdAt || a.orderId.localeCompare(b.orderId));
-  }
-  /** Look up a position open and existing at `at` by its positionKey (for dedup on merge). */
-  findLiveByKey(key, at) {
-    return this.live(at).find((position) => position.positionKey === key);
-  }
-  /**
-  * Fold every open position opened mid-replay into the open seeded position sharing its
-  * key once that seeded position is live at `at`. The earlier open was still holding
-  * exposure when the seeded position was created, and the server keeps at most one open
-  * row per key. Ownership is ambiguous here — exposure and timestamps cannot prove the
-  * seeded position traded on top of that history — so the fold conservatively keeps
-  * the attribution the matcher gave before #1067.
-  */
-  foldIntoLive(at) {
-    for (const seeded of this.live(at).filter((position) => position.existingOrigin !== void 0)) {
-      const earlier = this.all.filter((position) => position.existingOrigin === void 0 && !position.closed && position.positionKey === seeded.positionKey);
-      for (const position of earlier) {
-        seeded.parts.push(...position.parts);
-        for (const symbol of position.exposure.symbols()) {
-          seeded.exposure.addDelta(symbol, position.exposure.get(symbol));
-        }
-        this.all = this.all.filter((candidate) => candidate !== position);
-      }
-      this.markClosedIfFlat(seeded);
-    }
-  }
-  /** Register a fresh empty working position under `key` and return it. */
-  create(key, createdAt) {
-    const position = {
-      positionKey: key,
-      createdAt,
-      orderId: key,
-      exposure: Exposure.empty(),
-      parts: [],
-      closed: false,
-      // Opened by this replay's own fills, so it takes fills from the start.
-      liveFrom: Number.NEGATIVE_INFINITY
-    };
-    this.all.push(position);
-    return position;
-  }
-  /** Flip a position to closed once every leg is exactly zero. */
-  markClosedIfFlat(position) {
-    if (position.closed || !position.exposure.isAllZero()) {
-      return;
-    }
-    position.closed = true;
-  }
-  /** 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,
-      lifecycleStartedAt: position.createdAt
-    }));
-  }
-};
-function applyCloses(args) {
-  const { legs, book, at } = args;
-  const openList = book.live(at);
-  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();
-    });
-    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 (isGreaterThan(remaining, ZERO)) {
-      leftover.push({
-        side: leg.side,
-        qty: remaining,
-        leg
-      });
-    }
-  }
-  return leftover;
-}
-__name(applyCloses, "applyCloses");
-function resolveLeftoverTarget(args) {
-  const { book, leftover, at } = 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.live(at).find((position) => {
-    const { longs, shorts } = position.exposure.activeLegs();
-    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 positionKey = book.keyFor(symbols);
-  return book.findLiveByKey(positionKey, at) ?? book.create(positionKey, at);
-}
-__name(resolveLeftoverTarget, "resolveLeftoverTarget");
-function applyLeftover(target, leftover) {
-  for (const entry of leftover) {
-    const parts = entry.leg.take(entry.qty);
-    target.parts.push(...parts);
-    if (target.existingOrigin === void 0) {
-      target.createdAt = Math.min(...target.parts.map((part) => part.source.timestamp));
-      target.orderId = target.parts.filter((part) => part.source.timestamp === target.createdAt).map((part) => part.source.exchangeFillId).sort()[0] ?? target.positionKey;
-    }
-    target.exposure.addSigned(entry.leg.symbol, entry.qty.toFixed(), entry.side);
-  }
-}
-__name(applyLeftover, "applyLeftover");
-function setEq(a, b) {
-  return a.size === b.size && [
-    ...a
-  ].every((symbol) => b.has(symbol));
-}
-__name(setEq, "setEq");
-
-// src/sync/applicables/fills.ts
-function sourceToApplicableFill(fill, connector) {
-  const synthetic = isMissedHistoryFill(fill);
-  return {
-    exchangeFillId: fill.exchangeFillId,
-    connector,
-    symbol: fill.symbol,
-    side: fill.side,
-    quantity: fill.quantity,
-    price: fill.price,
-    usd: multiply(fill.quantity, fill.price).toFixed(),
-    timestamp: fill.timestamp,
-    cloid: synthetic ? null : fill.cloid ?? null,
-    reduceOnly: synthetic ? false : fill.reduceOnly,
-    synthetic,
-    isExternal: synthetic || !isPearCloid(connector, fill.cloid),
-    tradeFee: synthetic ? "0" : fill.tradeFee,
-    builderFee: synthetic ? "0" : fill.builderFee,
-    liquidation: synthetic ? null : fill.liquidation
-  };
-}
-__name(sourceToApplicableFill, "sourceToApplicableFill");
-
-// src/sync/applicables/position.ts
-function assembleApplicables(args) {
-  const { positions, connector, synthByPosition, now } = args;
-  const fillsById = /* @__PURE__ */ new Map();
-  const applicables = [];
-  for (const pos of positions) {
-    const applicable = assembleOneApplicable(pos, connector, fillsById, synthByPosition.get(pos) ?? [], now);
-    if (applicable) {
-      applicables.push(applicable);
-    }
-  }
-  return {
-    fills: [
-      ...fillsById.values()
-    ].sort((a, b) => a.timestamp - b.timestamp || a.exchangeFillId.localeCompare(b.exchangeFillId)),
-    applicables
-  };
-}
-__name(assembleApplicables, "assembleApplicables");
-function assembleOneApplicable(pos, connector, fillsById, assignedSynthetics, now) {
-  const { realFills, assignments, closedReason } = finalizeRealFills(pos, connector);
-  const syntheticFills = assignedSynthetics.map((synthetic) => buildSyntheticFill({
-    positionKey: pos.positionKey,
-    lifecycleStartedAt: pos.lifecycleStartedAt,
-    connector,
-    timestamp: anchorSyntheticTimestamp(realFills, synthetic.symbol, now),
-    ...synthetic
-  }));
-  for (const part of pos.parts) {
-    fillsById.set(part.source.exchangeFillId, sourceToApplicableFill(part.source, connector));
-  }
-  for (const fill of syntheticFills) {
-    fillsById.set(fill.exchangeFillId, fill);
-    assignments.push({
-      exchangeFillId: fill.exchangeFillId,
-      quantity: fill.quantity
-    });
-  }
-  if (realFills.length === 0 && syntheticFills.length === 0) {
-    return null;
-  }
-  const exposure = finalExposure(pos, assignedSynthetics);
-  const closed = exposure.isAllZero();
-  const status = closed ? "CLOSED" : "OPEN";
-  const origin = mergeOrigin(pos.existingOrigin, [
-    ...realFills,
-    ...syntheticFills
-  ]);
-  return {
-    positionKey: pos.positionKey,
-    exposure: exposure.toSigned(),
-    origin,
-    status,
-    ...closed ? {
-      closedReason
-    } : {},
-    assignments: assignments.sort((a, b) => (fillsById.get(a.exchangeFillId)?.timestamp ?? 0) - (fillsById.get(b.exchangeFillId)?.timestamp ?? 0)),
-    metadata: buildMetadata(new Set(exposure.symbols()), realFills)
-  };
-}
-__name(assembleOneApplicable, "assembleOneApplicable");
-function finalizeRealFills(position, connector) {
-  const newestFirst = [
-    ...position.parts
-  ].sort((a, b) => a.source.timestamp - b.source.timestamp).reverse();
-  const exposure = position.exposure.clone();
-  const realFills = [];
-  const assignments = [];
-  let closedReason = "USER";
-  for (const [index, part] of newestFirst.entries()) {
-    const after = exposure.get(part.source.symbol);
-    const flatAfter = exposure.isAllZero();
-    exposure.addDelta(part.source.symbol, negate(signedBySide(part.quantity, part.source.side)));
-    const reducesLeg = isGreaterThan(exposure.get(part.source.symbol).abs(), after.abs());
-    const liquidationOutcome = part.source.liquidation && reducesLeg ? flatAfter ? "CLOSED" : "REDUCED" : null;
-    if (index === 0 && position.closed && liquidationOutcome === "CLOSED") {
-      closedReason = "LIQUIDATED";
-    }
-    realFills.push({
-      ...sourceToApplicableFill(part.source, connector),
-      quantity: part.quantity,
-      usd: multiply(part.quantity, part.source.price).toFixed()
-    });
-    assignments.push({
-      exchangeFillId: part.source.exchangeFillId,
-      quantity: part.quantity,
-      ...liquidationOutcome === null ? {} : {
-        liquidationOutcome
-      }
-    });
-  }
-  realFills.reverse();
-  assignments.reverse();
-  return {
-    realFills,
-    assignments,
-    closedReason
-  };
-}
-__name(finalizeRealFills, "finalizeRealFills");
-function finalExposure(pos, synthetics) {
-  const exposure = pos.exposure.clone();
-  for (const synthetic of synthetics) {
-    exposure.addSigned(synthetic.symbol, synthetic.quantity, synthetic.side);
-  }
-  return exposure;
-}
-__name(finalExposure, "finalExposure");
-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;
-}
-__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 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
-  };
-}
-__name(buildMetadata, "buildMetadata");
-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";
-}
-__name(mergeOrigin, "mergeOrigin");
-
-// src/sync/applicables/snapshot.ts
-var ExchangeSnapshot = class _ExchangeSnapshot {
-  static {
-    __name(this, "ExchangeSnapshot");
-  }
-  bySymbol;
-  constructor(bySymbol) {
-    this.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 {
-  static {
-    __name(this, "PearHoldings");
-  }
-  filtered;
-  constructor(filtered) {
-    this.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).sort((a, b) => Date.parse(a.createdAt) - Date.parse(b.createdAt) || a.id.localeCompare(b.id)));
-  }
-  /** 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
-  });
-}
-__name(buildApplicables, "buildApplicables");
-
-// src/sync/cutoff.ts
-function selectFirstSyncCutoff(args) {
-  const { fills, exchangePositions, connector } = args;
-  if (fills.length === 0) {
-    return null;
-  }
-  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());
-    }
-  }
-  return null;
-}
-__name(selectFirstSyncCutoff, "selectFirstSyncCutoff");
-function findFirstPearFillIndex(connector, fills) {
-  const index = fills.findIndex((fill) => isPearCloid(connector, fill.cloid));
-  if (index === -1) {
-    return null;
-  }
-  return index;
-}
-__name(findFirstPearFillIndex, "findFirstPearFillIndex");
-function isStrictTimestampBoundary(fills, boundary) {
-  const before = fills[boundary - 1];
-  const after = fills[boundary];
-  if (!before || !after) {
-    return true;
-  }
-  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 fillsToProcess = _prepareExternalFills(externalFills, confirmedExchangeFillIds);
-  const orphans = _excludeClaimedFills(provisionalFills.filter((fill) => fill.tradeAccountId === tradeAccountId && fill.connector === connector), fillsToProcess);
-  const { keptOrphans, firstSyncTrim } = applyFirstSyncCutoff({
-    neverSynced,
-    fillsToProcess,
-    orphans,
-    exchangePositions,
-    connector
-  });
-  const { fills, applicables } = buildApplicables({
-    tradeAccountId,
-    connector,
-    orphanFills: keptOrphans,
-    openPositions,
-    entryBySymbol,
-    exchangePositions
-  });
-  const mustPostFirstSyncCheckpoint = neverSynced;
-  if (!mustPostFirstSyncCheckpoint && applicables.length === 0) {
-    return null;
-  }
-  const externalMaxTs = latestFillTimestamp(fillsToProcess);
-  return {
-    fills,
-    applicables,
-    exchangePositions,
-    meta: {
-      externalMaxTs
-    },
-    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 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(dedupedByExchangeFillId.values()).sort((a, b) => a.timestamp - b.timestamp);
-}
-__name(_prepareExternalFills, "_prepareExternalFills");
-function _excludeClaimedFills(provisionalFills, externalFills) {
-  const ownedCloids = /* @__PURE__ */ new Set();
-  for (const fill of provisionalFills) {
-    const cloid = _normalizeCloid(fill.cloid);
-    if (cloid) {
-      ownedCloids.add(`${fill.connector}:${cloid}`);
-    }
-  }
-  return externalFills.filter((fill) => {
-    const cloid = _normalizeCloid(fill.cloid);
-    return cloid === void 0 || !ownedCloids.has(`${fill.connector}:${cloid}`);
-  });
-}
-__name(_excludeClaimedFills, "_excludeClaimedFills");
-function _normalizeCloid(cloid) {
-  const value = cloid?.trim();
-  if (!value) {
-    return void 0;
-  }
-  return value;
-}
-__name(_normalizeCloid, "_normalizeCloid");
-function _normalizeExchangeFillId(exchangeFillId) {
-  const value = exchangeFillId?.trim().toLowerCase();
-  if (!value) {
-    return void 0;
-  }
-  return value;
-}
-__name(_normalizeExchangeFillId, "_normalizeExchangeFillId");
-function _isValidExternalQuantity(quantity) {
-  if (/e/i.test(quantity)) {
-    return false;
-  }
-  if (!isFiniteDecimal(quantity)) {
-    return false;
-  }
-  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 latestFillTimestamp(fills) {
-  const last = fills[fills.length - 1];
-  if (!last) {
-    return null;
-  }
-  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
-    };
-  }
-  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)
-    }
-  };
-}
-__name(applyFirstSyncCutoff, "applyFirstSyncCutoff");
-
-// src/validate-leverage.ts
-function validateLeverage(leverage, instrument) {
-  if (leverage < 1 || leverage > 100) {
-    return false;
-  }
-  if (leverage > instrument.leverage) {
-    return false;
-  }
-  return true;
+  return true;
 }
 __name(validateLeverage, "validateLeverage");
 var VAULT_ACTION_DOMAIN = {
@@ -2800,6 +1619,26 @@ var VAULT_ACTION_TYPES = {
       }
     ]
   },
+  "set-account-mode": {
+    SetAccountMode: [
+      {
+        name: "vault",
+        type: "address"
+      },
+      {
+        name: "mode",
+        type: "string"
+      },
+      {
+        name: "nonce",
+        type: "string"
+      },
+      {
+        name: "deadline",
+        type: "uint256"
+      }
+    ]
+  },
   "update-metadata": {
     UpdateVaultMetadata: [
       {
@@ -2913,6 +1752,17 @@ function buildLeaderActionTypedData(action, vaultAddress, body) {
           deadline
         }
       };
+    case "set-account-mode":
+      return {
+        types: VAULT_ACTION_TYPES[action],
+        primaryType: "SetAccountMode",
+        message: {
+          vault,
+          mode: String(body.mode ?? ""),
+          nonce,
+          deadline
+        }
+      };
     case "update-metadata":
       return {
         types: VAULT_ACTION_TYPES[action],
@@ -3029,4 +1879,4 @@ function takeVerifier(handoffId, storage) {
 }
 __name(takeVerifier, "takeVerifier");
 
-export { BIPS, CREATE_VAULT_TYPES, InvalidPriceError, VAULT_ACTION_DOMAIN, VAULT_ACTION_TYPES, ZERO, abs, add, aggregateRealizedPositionState, baseToContracts, buildApplicables, buildCreateVaultMessage, buildLeaderActionTypedData, compareValue, computeAssetEntryNotional, computeAssetGrossRealizedPnL, computeAssetRealizedPnLs, computeAssetUndeterminedSizes, computeAssetUnrealizedPnL, computeAssetUnrealizedPnLs, computeBasketWeightedRatioV1, computeDeployedCapital, computeDeployedCapitalState, computeEntryEquityFraction, computeEntryPriceForAsset, computeEquityFraction, computeFillTransitions, computeFilledEntrySizing, computeMaxBasketSize, computeMultiQuoteBasketSize, computeNotionalEquityFraction, computePositionEntryPrices, computeRealizedPnlBySymbol, computeRealizedPnlFromFills, computeRealizedPositionState, computeSyncPayload, computeUnrealizedPositionState, computeUnrealizedPositionStateFromEntryPrices, configureProxy, contractsToBase, countDecimals, deriveBasketKey, divide, exponentiate, findWholeCloseQuantity, finishXHandoff, generateDeterministicPositionKey, groupFillsByAsset, groupFillsByPosition, isEqualTo, isFiniteDecimal, isGreaterThan, isGreaterThanOrEqual, isLessThan, isLessThanOrEqual, isNegative, isPositive, isRefusedBelowMinimum, isZero, min, multiply, negate, parse, precisePrice, preciseQuantity, proxyFetch, requestedBaseQuantity, sideSign, sign, signed, signedBySide, sizeBasket, sizeBasketByLeverageMode, sizeBasketPerAssetLeverage, startXHandoff, stripXReturn, subtract, sumAttributedFunding, toDecimalString, validateLeverage, validateQuantity, walkPositionLedger, walkPositionTransitions };
+export { BIPS, CREATE_VAULT_TYPES, InvalidPriceError, VAULT_ACTION_DOMAIN, VAULT_ACTION_TYPES, ZERO, abs, add, aggregateRealizedPositionState, baseToContracts, buildCreateVaultMessage, buildLeaderActionTypedData, compareValue, computeAssetEntryNotional, computeAssetGrossRealizedPnL, computeAssetRealizedPnLs, computeAssetUndeterminedSizes, computeAssetUnrealizedPnL, computeAssetUnrealizedPnLs, computeBasketWeightedRatioV1, computeDeployedCapital, computeDeployedCapitalState, computeEntryEquityFraction, computeEntryPriceForAsset, computeEquityFraction, computeFillTransitions, computeFilledEntrySizing, computeMaxBasketSize, computeMultiQuoteBasketSize, computeNotionalEquityFraction, computePositionEntryPrices, computeRealizedPnlBySymbol, computeRealizedPnlFromFills, computeRealizedPositionState, computeUnrealizedPositionState, computeUnrealizedPositionStateFromEntryPrices, configureProxy, contractsToBase, countDecimals, deriveBasketKey, divide, exponentiate, findWholeCloseQuantity, finishXHandoff, generateDeterministicPositionKey, groupFillsByAsset, groupFillsByPosition, isEqualTo, isFiniteDecimal, isGreaterThan, isGreaterThanOrEqual, isLessThan, isLessThanOrEqual, isNegative, isPositive, isRefusedBelowMinimum, isZero, marketPricingFor, min, multiply, negate, parse, precisePrice, preciseQuantity, preciseQuantityWithMode, proxyFetch, requestedBaseQuantity, resolveMarketLimitPrice, resolveMarketReference, sideSign, sign, signed, signedBySide, sizeBasket, sizeBasketByLeverageMode, sizeBasketPerAssetLeverage, startXHandoff, stripXReturn, subtract, sumAttributedFunding, toDecimalString, validateLeverage, validateQuantity, walkPositionLedger, walkPositionTransitions };