@symmio/trading-core 1.1.0 → 2.0.0

package/dist/tpsl/grouping/plan-group-tpsl/plan-group-tpsl.js

@@ -0,0 +1,142 @@
+import { resolveChildSide as e } from "../resolve-child-side.js";
+import { validateTpSl as t } from "../../validate-tpsl.js";
+import { formatUnits as n } from "viem";
+import { toDecimal as r } from "@symmio/utils/decimal";
+//#region src/tpsl/grouping/plan-group-tpsl/plan-group-tpsl.ts
+var i = 18;
+function a(t) {
+	let { children: r, desired: a, pricePrecision: c, referencePrice: l, config: u, only: d } = t, f = d === void 0 ? void 0 : new Set(d), p = [];
+	for (let t of r) {
+		if (f !== void 0 && !f.has(t.key)) continue;
+		let r = a[t.key];
+		if (!r || r.tp === void 0 && r.sl === void 0) {
+			p.push({
+				action: "skip",
+				key: t.key,
+				reason: "nothing-to-do"
+			});
+			continue;
+		}
+		if (t.quoteId === void 0 || t.virtualAccount === void 0) {
+			p.push({
+				action: "skip",
+				key: t.key,
+				reason: "not-anchored"
+			});
+			continue;
+		}
+		if (t.openQuantity <= 0n) {
+			p.push({
+				action: "skip",
+				key: t.key,
+				reason: "no-open-quantity"
+			});
+			continue;
+		}
+		let d = e(t, "tp", a), m = e(t, "sl", a), h = o(d, c), g = o(m, c);
+		if (h.kind === "unparseable" || g.kind === "unparseable") {
+			p.push({
+				action: "skip",
+				key: t.key,
+				reason: "invalid",
+				validation: {
+					ok: !1,
+					tpError: h.kind === "unparseable" ? "Enter a valid price" : void 0,
+					slError: g.kind === "unparseable" ? "Enter a valid price" : void 0
+				}
+			});
+			continue;
+		}
+		let _ = s(t, d, m, c, l, u);
+		if (_ && !_.ok) {
+			p.push({
+				action: "skip",
+				key: t.key,
+				reason: "invalid",
+				validation: _
+			});
+			continue;
+		}
+		if (h.kind === "delete" && p.push({
+			action: "delete",
+			key: t.key,
+			quoteId: t.quoteId,
+			virtualAccount: t.virtualAccount,
+			cohQuoteId: h.cohQuoteId,
+			conditionalOrderType: "take_profit"
+		}), g.kind === "delete" && p.push({
+			action: "delete",
+			key: t.key,
+			quoteId: t.quoteId,
+			virtualAccount: t.virtualAccount,
+			cohQuoteId: g.cohQuoteId,
+			conditionalOrderType: "stop_loss"
+		}), h.kind === "set" || g.kind === "set") {
+			p.push({
+				action: "set",
+				key: t.key,
+				quoteId: t.quoteId,
+				virtualAccount: t.virtualAccount,
+				symbolId: t.symbolId,
+				positionType: t.positionType,
+				quantity: n(t.openQuantity, i),
+				tp: h.kind === "set" ? h.side : void 0,
+				sl: g.kind === "set" ? g.side : void 0
+			});
+			continue;
+		}
+		h.kind === "none" && g.kind === "none" && p.push({
+			action: "skip",
+			key: t.key,
+			reason: "unchanged"
+		});
+	}
+	let m = p.filter((e) => e.action === "set"), h = p.filter((e) => e.action === "delete"), g = p.filter((e) => e.action === "skip");
+	return {
+		actions: p,
+		sets: m,
+		deletes: h,
+		skips: g,
+		hasInvalid: g.some((e) => e.reason === "invalid"),
+		isNoop: m.length === 0 && h.length === 0
+	};
+}
+function o(e, t) {
+	let n = c(e.triggerPrice, t);
+	if (n === void 0) return { kind: "unparseable" };
+	let r = c(e.confirmedPrice, t) ?? "";
+	return n ? n === r && e.priceType === e.confirmedPriceType ? { kind: "none" } : {
+		kind: "set",
+		side: {
+			triggerPrice: n,
+			priceType: e.priceType
+		}
+	} : r && e.cohQuoteId ? {
+		kind: "delete",
+		cohQuoteId: e.cohQuoteId
+	} : { kind: "none" };
+}
+function s(e, n, r, i, a, o) {
+	if (!(a === void 0 || o === void 0)) return t({
+		takeProfitPrice: n.triggerPrice || void 0,
+		stopLossPrice: r.triggerPrice || void 0,
+		openPrice: a,
+		positionType: e.positionType,
+		pricePrecision: i,
+		config: o,
+		isOpenPosition: !0
+	});
+}
+function c(e, t) {
+	if (!e) return "";
+	try {
+		let n = r(e);
+		return n.isFinite() ? n.toFixed(t) : void 0;
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { a as planGroupTpSl };
+
+//# sourceMappingURL=plan-group-tpsl.js.map

package/dist/tpsl/grouping/plan-group-tpsl/plan-group-tpsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-group-tpsl.js","names":[],"sources":["../../../../src/tpsl/grouping/plan-group-tpsl/plan-group-tpsl.ts"],"sourcesContent":["import { toDecimal } from \"@symmio/utils/decimal\";\nimport { formatUnits } from \"viem\";\nimport type { SetTpSlSide } from \"../../set-quote-tpsl/set-quote-tpsl\";\nimport type { TpSlConfig, TpSlValidation } from \"../../types\";\nimport { validateTpSl } from \"../../validate-tpsl\";\nimport { resolveChildSide, type ResolvedChildSide } from \"../resolve-child-side\";\nimport type { GroupTpSlAction, GroupTpSlChild, GroupTpSlDesiredMap, PlanGroupTpSlResult } from \"../types\";\n\n/** Decimal places of an 18-decimal-wei fixed-point value. */\nconst WEI_DECIMALS = 18;\n\n/** Parameters for {@link planGroupTpSl}. */\nexport interface PlanGroupTpSlParameters {\n  /** The grouped position's children with their confirmed snapshots. */\n  children: readonly GroupTpSlChild[];\n  /** Desired state per child key. A child with no entry is skipped as `\"nothing-to-do\"`. */\n  desired: GroupTpSlDesiredMap;\n  /**\n   * Market price precision. Trigger prices are rounded to it **before** diffing,\n   * so `\"100\"` and `\"100.0000\"` compare as unchanged.\n   */\n  pricePrecision: number;\n  /**\n   * Reference price every child validates against (decimal string). Pass the\n   * live **mark** price — a grouped position is validated against what the\n   * trader is looking at, not against each child's own open price. Omit\n   * (together with `config`) to skip validation entirely.\n   */\n  referencePrice?: string;\n  /** Live handler `/configs/` rules. Required for validation to run. */\n  config?: TpSlConfig;\n  /** Restrict planning to these child keys — the retry-failed-only path. Others are omitted. */\n  only?: readonly string[];\n}\n\n/**\n * Diff a desired grouped TP/SL state against what the handler already holds and\n * decide, per child, whether to `set`, `delete`, or `skip`.\n *\n * The handler has **no bulk endpoint** — one signed request per quote — so the\n * planner's job is to make that fan-out as small as honestly possible:\n *\n * - a side whose rounded trigger price **and** price type already match the\n *   confirmed snapshot is dropped from the leg, so `setQuoteTpSl` receives only\n *   the sides that actually changed; when both sides drop, the child is skipped\n *   as `\"unchanged\"`;\n * - a side cleared to `\"\"` while the handler holds a live order becomes a\n *   `delete`; cleared with nothing live, it is dropped;\n * - unanchored / zero-open-size children are skipped with a typed reason rather\n *   than throwing;\n * - when `referencePrice` and `config` are supplied, each child runs\n *   `validateTpSl` against its **resulting** pair (so the TP↔SL spread rule sees\n *   an untouched side too) with `isOpenPosition: true`; a failure becomes\n *   `\"invalid\"` carrying the `TpSlValidation` for inline errors.\n *\n * A child can yield two actions (cancel one side, write the other), so\n * `actions` is not one entry per child. Pure and deterministic.\n *\n * @param parameters - Children, desired state, precision, optional validation inputs.\n * @returns Per-child actions plus the pre-split `sets` / `deletes` / `skips` lists.\n *\n * @example\n * ```ts\n * const plan = planGroupTpSl({\n *   children,\n *   desired: Object.fromEntries(children.map((child) => [child.key, { tp: { triggerPrice: \"150\" } }])),\n *   pricePrecision: 4,\n *   referencePrice: markPrice,\n *   config: tpslConfig,\n * });\n * if (plan.hasInvalid) return;\n * for (const set of plan.sets) await setQuoteTpSl(config, { ...set, subAccount, pricePrecision: 4 });\n * ```\n */\nexport function planGroupTpSl(parameters: PlanGroupTpSlParameters): PlanGroupTpSlResult {\n  const { children, desired, pricePrecision, referencePrice, config, only } = parameters;\n  const allowed = only === undefined ? undefined : new Set(only);\n  const actions: GroupTpSlAction[] = [];\n\n  for (const child of children) {\n    if (allowed !== undefined && !allowed.has(child.key)) continue;\n\n    const entry = desired[child.key];\n    if (!entry || (entry.tp === undefined && entry.sl === undefined)) {\n      actions.push({ action: \"skip\", key: child.key, reason: \"nothing-to-do\" });\n      continue;\n    }\n\n    if (child.quoteId === undefined || child.virtualAccount === undefined) {\n      actions.push({ action: \"skip\", key: child.key, reason: \"not-anchored\" });\n      continue;\n    }\n\n    if (child.openQuantity <= 0n) {\n      actions.push({ action: \"skip\", key: child.key, reason: \"no-open-quantity\" });\n      continue;\n    }\n\n    const tp = resolveChildSide(child, \"tp\", desired);\n    const sl = resolveChildSide(child, \"sl\", desired);\n\n    const tpDecision = decideSide(tp, pricePrecision);\n    const slDecision = decideSide(sl, pricePrecision);\n\n    // Unparseable prices are caught by the decision step, so validation below\n    // only ever sees numbers.\n    if (tpDecision.kind === \"unparseable\" || slDecision.kind === \"unparseable\") {\n      actions.push({\n        action: \"skip\",\n        key: child.key,\n        reason: \"invalid\",\n        validation: {\n          ok: false,\n          tpError: tpDecision.kind === \"unparseable\" ? \"Enter a valid price\" : undefined,\n          slError: slDecision.kind === \"unparseable\" ? \"Enter a valid price\" : undefined,\n        },\n      });\n      continue;\n    }\n\n    const validation = validateResultingPair(child, tp, sl, pricePrecision, referencePrice, config);\n    if (validation && !validation.ok) {\n      actions.push({ action: \"skip\", key: child.key, reason: \"invalid\", validation });\n      continue;\n    }\n\n    if (tpDecision.kind === \"delete\") {\n      actions.push({\n        action: \"delete\",\n        key: child.key,\n        quoteId: child.quoteId,\n        virtualAccount: child.virtualAccount,\n        cohQuoteId: tpDecision.cohQuoteId,\n        conditionalOrderType: \"take_profit\",\n      });\n    }\n    if (slDecision.kind === \"delete\") {\n      actions.push({\n        action: \"delete\",\n        key: child.key,\n        quoteId: child.quoteId,\n        virtualAccount: child.virtualAccount,\n        cohQuoteId: slDecision.cohQuoteId,\n        conditionalOrderType: \"stop_loss\",\n      });\n    }\n\n    if (tpDecision.kind === \"set\" || slDecision.kind === \"set\") {\n      actions.push({\n        action: \"set\",\n        key: child.key,\n        quoteId: child.quoteId,\n        virtualAccount: child.virtualAccount,\n        symbolId: child.symbolId,\n        positionType: child.positionType,\n        quantity: formatUnits(child.openQuantity, WEI_DECIMALS),\n        tp: tpDecision.kind === \"set\" ? tpDecision.side : undefined,\n        sl: slDecision.kind === \"set\" ? slDecision.side : undefined,\n      });\n      continue;\n    }\n\n    if (tpDecision.kind === \"none\" && slDecision.kind === \"none\") {\n      actions.push({ action: \"skip\", key: child.key, reason: \"unchanged\" });\n    }\n  }\n\n  const sets = actions.filter((action) => action.action === \"set\");\n  const deletes = actions.filter((action) => action.action === \"delete\");\n  const skips = actions.filter((action) => action.action === \"skip\");\n\n  return {\n    actions,\n    sets,\n    deletes,\n    skips,\n    hasInvalid: skips.some((skip) => skip.reason === \"invalid\"),\n    isNoop: sets.length === 0 && deletes.length === 0,\n  };\n}\n\n/** What the planner decided for a single side of a single child. */\ntype SideDecision =\n  | { kind: \"none\" }\n  | { kind: \"set\"; side: SetTpSlSide }\n  | { kind: \"delete\"; cohQuoteId: string }\n  | { kind: \"unparseable\" };\n\n/**\n * Diff one resolved side. Rounding both the wanted and the confirmed price to\n * `pricePrecision` before comparing is what makes `\"100\"` and `\"100.0000\"`\n * equal — the handler stores whatever it rounded to, so a raw string compare\n * would resubmit unchanged orders forever.\n */\nfunction decideSide(resolved: ResolvedChildSide, pricePrecision: number): SideDecision {\n  const wanted = round(resolved.triggerPrice, pricePrecision);\n  if (wanted === undefined) return { kind: \"unparseable\" };\n  const current = round(resolved.confirmedPrice, pricePrecision) ?? \"\";\n\n  if (!wanted) {\n    if (current && resolved.cohQuoteId) return { kind: \"delete\", cohQuoteId: resolved.cohQuoteId };\n    return { kind: \"none\" };\n  }\n\n  if (wanted === current && resolved.priceType === resolved.confirmedPriceType) return { kind: \"none\" };\n\n  return { kind: \"set\", side: { triggerPrice: wanted, priceType: resolved.priceType } };\n}\n\n/**\n * Validate the pair the child would **end up with**, not just the edited side —\n * otherwise raising a take-profit could silently violate the TP↔SL spread rule\n * against an untouched stop-loss.\n */\nfunction validateResultingPair(\n  child: GroupTpSlChild,\n  tp: ResolvedChildSide,\n  sl: ResolvedChildSide,\n  pricePrecision: number,\n  referencePrice?: string,\n  config?: TpSlConfig,\n): TpSlValidation | undefined {\n  if (referencePrice === undefined || config === undefined) return undefined;\n  return validateTpSl({\n    takeProfitPrice: tp.triggerPrice || undefined,\n    stopLossPrice: sl.triggerPrice || undefined,\n    openPrice: referencePrice,\n    positionType: child.positionType,\n    pricePrecision,\n    config,\n    isOpenPosition: true,\n  });\n}\n\n/**\n * Round a decimal price string to `pricePrecision`. Empty input stays empty;\n * a string that is not a number at all returns `undefined` so the caller can\n * report it as invalid instead of silently reading it as \"clear this side\".\n */\nfunction round(price: string, pricePrecision: number): string | undefined {\n  if (!price) return \"\";\n  try {\n    const decimal = toDecimal(price);\n    if (!decimal.isFinite()) return undefined;\n    return decimal.toFixed(pricePrecision);\n  } catch {\n    return undefined;\n  }\n}\n"],"mappings":"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"}

package/dist/tpsl/grouping/plan-group-tpsl-delete.d.ts

@@ -0,0 +1,24 @@
+import { GroupTpSlChild, GroupTpSlDeleteScope, PlanGroupTpSlDeleteResult } from './types.js';
+/**
+ * Enumerate every cancellable TP/SL order across a grouped position — the
+ * "cancel all" plan.
+ *
+ * Each target's `cohQuoteId` is read straight off the child's **confirmed**
+ * snapshot, which the handler rows and the TP/SL WebSocket keep current. A side
+ * that is still `"pending"` / `"confirming"` is excluded (cancelling it would
+ * race the handler), and so is a side that only exists as a local edit.
+ *
+ * @param children - The grouped position's children.
+ * @param scope - Both sides (default) or one.
+ * @returns Cancellable targets plus typed skips.
+ *
+ * @example
+ * ```ts
+ * const plan = planGroupTpSlDelete(children, "stop_loss");
+ * for (const target of plan.targets) {
+ *   await deleteQuoteTpSl(config, { ...target });
+ * }
+ * ```
+ */
+export declare function planGroupTpSlDelete(children: readonly GroupTpSlChild[], scope?: GroupTpSlDeleteScope): PlanGroupTpSlDeleteResult;
+//# sourceMappingURL=plan-group-tpsl-delete.d.ts.map

package/dist/tpsl/grouping/plan-group-tpsl-delete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-group-tpsl-delete.d.ts","sourceRoot":"","sources":["../../../src/tpsl/grouping/plan-group-tpsl-delete.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,cAAc,EACd,oBAAoB,EAGpB,yBAAyB,EAC1B,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,SAAS,cAAc,EAAE,EACnC,KAAK,GAAE,oBAA4B,GAClC,yBAAyB,CAmC3B"}

package/dist/tpsl/grouping/plan-group-tpsl-delete.js

@@ -0,0 +1,51 @@
+import { GROUP_TPSL_SIDES as e, resolveChildSide as t } from "./resolve-child-side.js";
+//#region src/tpsl/grouping/plan-group-tpsl-delete.ts
+function n(n, r = "all") {
+	let i = [], a = [];
+	for (let o of n) for (let n of e) {
+		let e = t(o, n);
+		if (!(r !== "all" && r !== e.conditionalOrderType) && e.confirmedPrice) {
+			if (e.isPending) {
+				a.push({
+					key: o.key,
+					conditionalOrderType: e.conditionalOrderType,
+					reason: "in-flight"
+				});
+				continue;
+			}
+			if (!e.cohQuoteId) {
+				a.push({
+					key: o.key,
+					conditionalOrderType: e.conditionalOrderType,
+					reason: "no-coh-id"
+				});
+				continue;
+			}
+			if (o.quoteId === void 0 || o.virtualAccount === void 0) {
+				a.push({
+					key: o.key,
+					conditionalOrderType: e.conditionalOrderType,
+					reason: "not-anchored"
+				});
+				continue;
+			}
+			i.push({
+				key: o.key,
+				quoteId: o.quoteId,
+				virtualAccount: o.virtualAccount,
+				cohQuoteId: e.cohQuoteId,
+				conditionalOrderType: e.conditionalOrderType,
+				triggerPrice: e.confirmedPrice
+			});
+		}
+	}
+	return {
+		targets: i,
+		skipped: a,
+		isNoop: i.length === 0
+	};
+}
+//#endregion
+export { n as planGroupTpSlDelete };
+
+//# sourceMappingURL=plan-group-tpsl-delete.js.map

package/dist/tpsl/grouping/plan-group-tpsl-delete.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-group-tpsl-delete.js","names":[],"sources":["../../../src/tpsl/grouping/plan-group-tpsl-delete.ts"],"sourcesContent":["import { GROUP_TPSL_SIDES, resolveChildSide } from \"./resolve-child-side\";\nimport type {\n  GroupTpSlChild,\n  GroupTpSlDeleteScope,\n  GroupTpSlDeleteSkip,\n  GroupTpSlDeleteTarget,\n  PlanGroupTpSlDeleteResult,\n} from \"./types\";\n\n/**\n * Enumerate every cancellable TP/SL order across a grouped position — the\n * \"cancel all\" plan.\n *\n * Each target's `cohQuoteId` is read straight off the child's **confirmed**\n * snapshot, which the handler rows and the TP/SL WebSocket keep current. A side\n * that is still `\"pending\"` / `\"confirming\"` is excluded (cancelling it would\n * race the handler), and so is a side that only exists as a local edit.\n *\n * @param children - The grouped position's children.\n * @param scope - Both sides (default) or one.\n * @returns Cancellable targets plus typed skips.\n *\n * @example\n * ```ts\n * const plan = planGroupTpSlDelete(children, \"stop_loss\");\n * for (const target of plan.targets) {\n *   await deleteQuoteTpSl(config, { ...target });\n * }\n * ```\n */\nexport function planGroupTpSlDelete(\n  children: readonly GroupTpSlChild[],\n  scope: GroupTpSlDeleteScope = \"all\",\n): PlanGroupTpSlDeleteResult {\n  const targets: GroupTpSlDeleteTarget[] = [];\n  const skipped: GroupTpSlDeleteSkip[] = [];\n\n  for (const child of children) {\n    for (const side of GROUP_TPSL_SIDES) {\n      const resolved = resolveChildSide(child, side);\n      if (scope !== \"all\" && scope !== resolved.conditionalOrderType) continue;\n      if (!resolved.confirmedPrice) continue;\n\n      if (resolved.isPending) {\n        skipped.push({ key: child.key, conditionalOrderType: resolved.conditionalOrderType, reason: \"in-flight\" });\n        continue;\n      }\n      if (!resolved.cohQuoteId) {\n        skipped.push({ key: child.key, conditionalOrderType: resolved.conditionalOrderType, reason: \"no-coh-id\" });\n        continue;\n      }\n      if (child.quoteId === undefined || child.virtualAccount === undefined) {\n        skipped.push({ key: child.key, conditionalOrderType: resolved.conditionalOrderType, reason: \"not-anchored\" });\n        continue;\n      }\n\n      targets.push({\n        key: child.key,\n        quoteId: child.quoteId,\n        virtualAccount: child.virtualAccount,\n        cohQuoteId: resolved.cohQuoteId,\n        conditionalOrderType: resolved.conditionalOrderType,\n        triggerPrice: resolved.confirmedPrice,\n      });\n    }\n  }\n\n  return { targets, skipped, isNoop: targets.length === 0 };\n}\n"],"mappings":";;AA8BA,SAAgB,EACd,GACA,IAA8B,OACH;CAC3B,IAAM,IAAmC,CAAC,GACpC,IAAiC,CAAC;CAExC,KAAK,IAAM,KAAS,GAClB,KAAK,IAAM,KAAQ,GAAkB;EACnC,IAAM,IAAW,EAAiB,GAAO,CAAI;EACzC,YAAU,SAAS,MAAU,EAAS,yBACrC,EAAS,gBAEd;OAAI,EAAS,WAAW;IACtB,EAAQ,KAAK;KAAE,KAAK,EAAM;KAAK,sBAAsB,EAAS;KAAsB,QAAQ;IAAY,CAAC;IACzG;GACF;GACA,IAAI,CAAC,EAAS,YAAY;IACxB,EAAQ,KAAK;KAAE,KAAK,EAAM;KAAK,sBAAsB,EAAS;KAAsB,QAAQ;IAAY,CAAC;IACzG;GACF;GACA,IAAI,EAAM,YAAY,KAAA,KAAa,EAAM,mBAAmB,KAAA,GAAW;IACrE,EAAQ,KAAK;KAAE,KAAK,EAAM;KAAK,sBAAsB,EAAS;KAAsB,QAAQ;IAAe,CAAC;IAC5G;GACF;GAEA,EAAQ,KAAK;IACX,KAAK,EAAM;IACX,SAAS,EAAM;IACf,gBAAgB,EAAM;IACtB,YAAY,EAAS;IACrB,sBAAsB,EAAS;IAC/B,cAAc,EAAS;GACzB,CAAC;EAjBD;CAkBF;CAGF,OAAO;EAAE;EAAS;EAAS,QAAQ,EAAQ,WAAW;CAAE;AAC1D"}

package/dist/tpsl/grouping/resolve-child-side.d.ts

@@ -0,0 +1,44 @@
+import { TpSlConditionalOrderType, TpSlInfoState, TpSlPriceType } from '../types.js';
+import { GroupTpSlChild, GroupTpSlDesiredMap } from './types.js';
+/** Short side selector used across the grouped helpers. */
+export type GroupTpSlSideKey = "tp" | "sl";
+/** One child's side after the caller's pending edits are layered on the confirmed snapshot. */
+export interface ResolvedChildSide {
+    /** Which side this is. */
+    side: GroupTpSlSideKey;
+    /** The handler's wire name for the side. */
+    conditionalOrderType: TpSlConditionalOrderType;
+    /** Effective trigger price (decimal string). `""` means the side is unset or being cleared. */
+    triggerPrice: string;
+    /** Effective price type. Falls back to the confirmed one when the edit omits it. */
+    priceType: TpSlPriceType;
+    /** Trigger price the handler currently holds (decimal string). `""` when there is no order. */
+    confirmedPrice: string;
+    /** Price type the handler currently holds. */
+    confirmedPriceType: TpSlPriceType;
+    /** Lifecycle of the confirmed order. */
+    state: TpSlInfoState;
+    /** Handler-issued conditional-order id, when the handler holds a live order. */
+    cohQuoteId?: string;
+    /** `true` when a pending edit supplied the effective value. */
+    isOverridden: boolean;
+    /** `true` while the side is mid-flight (`"pending"` / `"confirming"`). */
+    isPending: boolean;
+}
+/** The two sides in display order — TP always precedes SL. */
+export declare const GROUP_TPSL_SIDES: readonly GroupTpSlSideKey[];
+/**
+ * Layer a caller's pending edit over a child's confirmed TP/SL snapshot.
+ *
+ * This is the single place the override rule lives, so the summary, the order
+ * list, the return estimate and the planner all agree on what a side currently
+ * "is": an edit wins over the snapshot, an edit with an empty `triggerPrice`
+ * clears the side, and an absent edit leaves the snapshot untouched.
+ *
+ * @param child - The child to resolve a side for.
+ * @param side - `"tp"` or `"sl"`.
+ * @param overrides - Pending per-child edits, keyed by `GroupTpSlChild.key`.
+ * @returns The effective and confirmed view of that side.
+ */
+export declare function resolveChildSide(child: GroupTpSlChild, side: GroupTpSlSideKey, overrides?: GroupTpSlDesiredMap): ResolvedChildSide;
+//# sourceMappingURL=resolve-child-side.d.ts.map

package/dist/tpsl/grouping/resolve-child-side.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-child-side.d.ts","sourceRoot":"","sources":["../../../src/tpsl/grouping/resolve-child-side.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACvF,OAAO,KAAK,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAEnE,2DAA2D;AAC3D,MAAM,MAAM,gBAAgB,GAAG,IAAI,GAAG,IAAI,CAAC;AAE3C,+FAA+F;AAC/F,MAAM,WAAW,iBAAiB;IAChC,0BAA0B;IAC1B,IAAI,EAAE,gBAAgB,CAAC;IACvB,4CAA4C;IAC5C,oBAAoB,EAAE,wBAAwB,CAAC;IAC/C,+FAA+F;IAC/F,YAAY,EAAE,MAAM,CAAC;IACrB,oFAAoF;IACpF,SAAS,EAAE,aAAa,CAAC;IACzB,+FAA+F;IAC/F,cAAc,EAAE,MAAM,CAAC;IACvB,8CAA8C;IAC9C,kBAAkB,EAAE,aAAa,CAAC;IAClC,wCAAwC;IACxC,KAAK,EAAE,aAAa,CAAC;IACrB,gFAAgF;IAChF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,+DAA+D;IAC/D,YAAY,EAAE,OAAO,CAAC;IACtB,0EAA0E;IAC1E,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,8DAA8D;AAC9D,eAAO,MAAM,gBAAgB,EAAE,SAAS,gBAAgB,EAAiB,CAAC;AAE1E;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,cAAc,EACrB,IAAI,EAAE,gBAAgB,EACtB,SAAS,CAAC,EAAE,mBAAmB,GAC9B,iBAAiB,CAmBnB"}

package/dist/tpsl/grouping/resolve-child-side.js

@@ -0,0 +1,21 @@
+//#region src/tpsl/grouping/resolve-child-side.ts
+var e = ["tp", "sl"];
+function t(e, t, n) {
+	let r = t === "tp" ? e.tpsl.tp : e.tpsl.sl, i = t === "tp" ? e.tpsl.tpPriceType : e.tpsl.slPriceType, a = t === "tp" ? e.tpsl.tpState : e.tpsl.slState, o = t === "tp" ? e.tpsl.tpCohQuoteId : e.tpsl.slCohQuoteId, s = n?.[e.key]?.[t];
+	return {
+		side: t,
+		conditionalOrderType: t === "tp" ? "take_profit" : "stop_loss",
+		triggerPrice: s ? s.triggerPrice.trim() : r,
+		priceType: s?.priceType ?? i,
+		confirmedPrice: r,
+		confirmedPriceType: i,
+		state: a,
+		cohQuoteId: o,
+		isOverridden: s !== void 0,
+		isPending: a === "pending" || a === "confirming"
+	};
+}
+//#endregion
+export { e as GROUP_TPSL_SIDES, t as resolveChildSide };
+
+//# sourceMappingURL=resolve-child-side.js.map

package/dist/tpsl/grouping/resolve-child-side.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-child-side.js","names":[],"sources":["../../../src/tpsl/grouping/resolve-child-side.ts"],"sourcesContent":["import type { TpSlConditionalOrderType, TpSlInfoState, TpSlPriceType } from \"../types\";\nimport type { GroupTpSlChild, GroupTpSlDesiredMap } from \"./types\";\n\n/** Short side selector used across the grouped helpers. */\nexport type GroupTpSlSideKey = \"tp\" | \"sl\";\n\n/** One child's side after the caller's pending edits are layered on the confirmed snapshot. */\nexport interface ResolvedChildSide {\n  /** Which side this is. */\n  side: GroupTpSlSideKey;\n  /** The handler's wire name for the side. */\n  conditionalOrderType: TpSlConditionalOrderType;\n  /** Effective trigger price (decimal string). `\"\"` means the side is unset or being cleared. */\n  triggerPrice: string;\n  /** Effective price type. Falls back to the confirmed one when the edit omits it. */\n  priceType: TpSlPriceType;\n  /** Trigger price the handler currently holds (decimal string). `\"\"` when there is no order. */\n  confirmedPrice: string;\n  /** Price type the handler currently holds. */\n  confirmedPriceType: TpSlPriceType;\n  /** Lifecycle of the confirmed order. */\n  state: TpSlInfoState;\n  /** Handler-issued conditional-order id, when the handler holds a live order. */\n  cohQuoteId?: string;\n  /** `true` when a pending edit supplied the effective value. */\n  isOverridden: boolean;\n  /** `true` while the side is mid-flight (`\"pending\"` / `\"confirming\"`). */\n  isPending: boolean;\n}\n\n/** The two sides in display order — TP always precedes SL. */\nexport const GROUP_TPSL_SIDES: readonly GroupTpSlSideKey[] = [\"tp\", \"sl\"];\n\n/**\n * Layer a caller's pending edit over a child's confirmed TP/SL snapshot.\n *\n * This is the single place the override rule lives, so the summary, the order\n * list, the return estimate and the planner all agree on what a side currently\n * \"is\": an edit wins over the snapshot, an edit with an empty `triggerPrice`\n * clears the side, and an absent edit leaves the snapshot untouched.\n *\n * @param child - The child to resolve a side for.\n * @param side - `\"tp\"` or `\"sl\"`.\n * @param overrides - Pending per-child edits, keyed by `GroupTpSlChild.key`.\n * @returns The effective and confirmed view of that side.\n */\nexport function resolveChildSide(\n  child: GroupTpSlChild,\n  side: GroupTpSlSideKey,\n  overrides?: GroupTpSlDesiredMap,\n): ResolvedChildSide {\n  const confirmedPrice = side === \"tp\" ? child.tpsl.tp : child.tpsl.sl;\n  const confirmedPriceType = side === \"tp\" ? child.tpsl.tpPriceType : child.tpsl.slPriceType;\n  const state = side === \"tp\" ? child.tpsl.tpState : child.tpsl.slState;\n  const cohQuoteId = side === \"tp\" ? child.tpsl.tpCohQuoteId : child.tpsl.slCohQuoteId;\n  const desired = overrides?.[child.key]?.[side];\n\n  return {\n    side,\n    conditionalOrderType: side === \"tp\" ? \"take_profit\" : \"stop_loss\",\n    triggerPrice: desired ? desired.triggerPrice.trim() : confirmedPrice,\n    priceType: desired?.priceType ?? confirmedPriceType,\n    confirmedPrice,\n    confirmedPriceType,\n    state,\n    cohQuoteId,\n    isOverridden: desired !== undefined,\n    isPending: state === \"pending\" || state === \"confirming\",\n  };\n}\n"],"mappings":";AA+BA,IAAa,IAAgD,CAAC,MAAM,IAAI;AAexE,SAAgB,EACd,GACA,GACA,GACmB;CACnB,IAAM,IAAiB,MAAS,OAAO,EAAM,KAAK,KAAK,EAAM,KAAK,IAC5D,IAAqB,MAAS,OAAO,EAAM,KAAK,cAAc,EAAM,KAAK,aACzE,IAAQ,MAAS,OAAO,EAAM,KAAK,UAAU,EAAM,KAAK,SACxD,IAAa,MAAS,OAAO,EAAM,KAAK,eAAe,EAAM,KAAK,cAClE,IAAU,IAAY,EAAM,OAAO;CAEzC,OAAO;EACL;EACA,sBAAsB,MAAS,OAAO,gBAAgB;EACtD,cAAc,IAAU,EAAQ,aAAa,KAAK,IAAI;EACtD,WAAW,GAAS,aAAa;EACjC;EACA;EACA;EACA;EACA,cAAc,MAAY,KAAA;EAC1B,WAAW,MAAU,aAAa,MAAU;CAC9C;AACF"}

package/dist/tpsl/grouping/summarize-group-tpsl.d.ts

@@ -0,0 +1,39 @@
+import { GroupTpSlChild, GroupTpSlDesiredMap, QuoteGroupTpSlSummary } from './types.js';
+/** Options for {@link summarizeQuoteGroupTpSl}. */
+export interface SummarizeQuoteGroupTpSlOptions {
+    /**
+     * Pending per-child edits that win over the confirmed snapshot, keyed by
+     * `GroupTpSlChild.key`. An explicit `""` trigger price clears that side.
+     *
+     * Omit for the confirmed-only view (the table cell); pass an editor's buffer
+     * for a live coverage readout while the user types.
+     */
+    overrides?: GroupTpSlDesiredMap;
+}
+/**
+ * Fold a grouped position's children into one {@link QuoteGroupTpSlSummary} —
+ * per-side counts, the uniform-vs-mixed display state, and notional-weighted
+ * coverage — in a single pass.
+ *
+ * A side is `"uniform"` only when **every** child carries a trigger and every
+ * trigger price *and* price type is identical; otherwise it is `"mixed"` (or
+ * `"none"` when no child carries one). Coverage is notional-weighted rather
+ * than count-weighted: `Σ coveredNotional / Σ totalNotional × 100`, where a
+ * child's notional is `openQuantity × openPrice`. All bigint — no float drift.
+ *
+ * Pure and order-independent.
+ *
+ * @param children - The grouped position's children.
+ * @param options - Optional pending edits to layer over the snapshots.
+ * @returns The folded summary.
+ *
+ * @example
+ * ```ts
+ * const summary = summarizeQuoteGroupTpSl(children);
+ * if (summary.isEmpty) return "Not set";
+ * if (summary.takeProfit.display === "uniform") return summary.takeProfit.price;
+ * return `${summary.takeProfit.count} TP`;
+ * ```
+ */
+export declare function summarizeQuoteGroupTpSl(children: readonly GroupTpSlChild[], options?: SummarizeQuoteGroupTpSlOptions): QuoteGroupTpSlSummary;
+//# sourceMappingURL=summarize-group-tpsl.d.ts.map

package/dist/tpsl/grouping/summarize-group-tpsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"summarize-group-tpsl.d.ts","sourceRoot":"","sources":["../../../src/tpsl/grouping/summarize-group-tpsl.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,cAAc,EACd,mBAAmB,EAGnB,qBAAqB,EACtB,MAAM,SAAS,CAAC;AAEjB,mDAAmD;AACnD,MAAM,WAAW,8BAA8B;IAC7C;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,mBAAmB,CAAC;CACjC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,SAAS,cAAc,EAAE,EACnC,OAAO,GAAE,8BAAmC,GAC3C,qBAAqB,CAcvB"}

package/dist/tpsl/grouping/summarize-group-tpsl.js

@@ -0,0 +1,42 @@
+import { sharePercent as e } from "../../shared/utils/percent.js";
+import { childNotional as t } from "./notional.js";
+import { resolveChildSide as n } from "./resolve-child-side.js";
+//#region src/tpsl/grouping/summarize-group-tpsl.ts
+function r(e, n = {}) {
+	let r = 0n;
+	for (let n of e) r += t(n);
+	let a = i(e, "tp", r, n.overrides), o = i(e, "sl", r, n.overrides);
+	return {
+		childCount: e.length,
+		totalNotional: r,
+		takeProfit: a,
+		stopLoss: o,
+		isEmpty: a.count === 0 && o.count === 0
+	};
+}
+function i(r, i, a, o) {
+	let s = 0, c = 0n, l = !1, u, d = r.length > 0 ? n(r[0], i, o).priceType : void 0, f = !0;
+	for (let e of r) {
+		let r = n(e, i, o);
+		if (r.isPending && (l = !0), !r.triggerPrice) {
+			f = !1;
+			continue;
+		}
+		s += 1, c += t(e), u === void 0 ? (u = r.triggerPrice, d = r.priceType) : (u !== r.triggerPrice || d !== r.priceType) && (f = !1);
+	}
+	let p = s === 0 ? "none" : f ? "uniform" : "mixed";
+	return {
+		display: p,
+		count: s,
+		total: r.length,
+		price: p === "uniform" ? u : void 0,
+		priceType: p === "uniform" ? d : void 0,
+		isPending: l,
+		coveredNotional: c,
+		coveragePercent: e(c, a)
+	};
+}
+//#endregion
+export { r as summarizeQuoteGroupTpSl };
+
+//# sourceMappingURL=summarize-group-tpsl.js.map

package/dist/tpsl/grouping/summarize-group-tpsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"summarize-group-tpsl.js","names":[],"sources":["../../../src/tpsl/grouping/summarize-group-tpsl.ts"],"sourcesContent":["import { sharePercent } from \"../../shared/utils/percent\";\nimport { childNotional } from \"./notional\";\nimport { resolveChildSide, type GroupTpSlSideKey } from \"./resolve-child-side\";\nimport type {\n  GroupTpSlChild,\n  GroupTpSlDesiredMap,\n  GroupTpSlSideDisplay,\n  GroupTpSlSideSummary,\n  QuoteGroupTpSlSummary,\n} from \"./types\";\n\n/** Options for {@link summarizeQuoteGroupTpSl}. */\nexport interface SummarizeQuoteGroupTpSlOptions {\n  /**\n   * Pending per-child edits that win over the confirmed snapshot, keyed by\n   * `GroupTpSlChild.key`. An explicit `\"\"` trigger price clears that side.\n   *\n   * Omit for the confirmed-only view (the table cell); pass an editor's buffer\n   * for a live coverage readout while the user types.\n   */\n  overrides?: GroupTpSlDesiredMap;\n}\n\n/**\n * Fold a grouped position's children into one {@link QuoteGroupTpSlSummary} —\n * per-side counts, the uniform-vs-mixed display state, and notional-weighted\n * coverage — in a single pass.\n *\n * A side is `\"uniform\"` only when **every** child carries a trigger and every\n * trigger price *and* price type is identical; otherwise it is `\"mixed\"` (or\n * `\"none\"` when no child carries one). Coverage is notional-weighted rather\n * than count-weighted: `Σ coveredNotional / Σ totalNotional × 100`, where a\n * child's notional is `openQuantity × openPrice`. All bigint — no float drift.\n *\n * Pure and order-independent.\n *\n * @param children - The grouped position's children.\n * @param options - Optional pending edits to layer over the snapshots.\n * @returns The folded summary.\n *\n * @example\n * ```ts\n * const summary = summarizeQuoteGroupTpSl(children);\n * if (summary.isEmpty) return \"Not set\";\n * if (summary.takeProfit.display === \"uniform\") return summary.takeProfit.price;\n * return `${summary.takeProfit.count} TP`;\n * ```\n */\nexport function summarizeQuoteGroupTpSl(\n  children: readonly GroupTpSlChild[],\n  options: SummarizeQuoteGroupTpSlOptions = {},\n): QuoteGroupTpSlSummary {\n  let totalNotional = 0n;\n  for (const child of children) totalNotional += childNotional(child);\n\n  const takeProfit = summarizeSide(children, \"tp\", totalNotional, options.overrides);\n  const stopLoss = summarizeSide(children, \"sl\", totalNotional, options.overrides);\n\n  return {\n    childCount: children.length,\n    totalNotional,\n    takeProfit,\n    stopLoss,\n    isEmpty: takeProfit.count === 0 && stopLoss.count === 0,\n  };\n}\n\n/** Fold one side across every child. */\nfunction summarizeSide(\n  children: readonly GroupTpSlChild[],\n  side: GroupTpSlSideKey,\n  totalNotional: bigint,\n  overrides?: GroupTpSlDesiredMap,\n): GroupTpSlSideSummary {\n  let count = 0;\n  let coveredNotional = 0n;\n  let isPending = false;\n  let price: string | undefined;\n  let priceType = children.length > 0 ? resolveChildSide(children[0]!, side, overrides).priceType : undefined;\n  let allIdentical = true;\n\n  for (const child of children) {\n    const resolved = resolveChildSide(child, side, overrides);\n    if (resolved.isPending) isPending = true;\n    if (!resolved.triggerPrice) {\n      allIdentical = false;\n      continue;\n    }\n    count += 1;\n    coveredNotional += childNotional(child);\n    if (price === undefined) {\n      price = resolved.triggerPrice;\n      priceType = resolved.priceType;\n    } else if (price !== resolved.triggerPrice || priceType !== resolved.priceType) {\n      allIdentical = false;\n    }\n  }\n\n  const display: GroupTpSlSideDisplay = count === 0 ? \"none\" : allIdentical ? \"uniform\" : \"mixed\";\n\n  return {\n    display,\n    count,\n    total: children.length,\n    price: display === \"uniform\" ? price : undefined,\n    priceType: display === \"uniform\" ? priceType : undefined,\n    isPending,\n    coveredNotional,\n    coveragePercent: sharePercent(coveredNotional, totalNotional),\n  };\n}\n"],"mappings":";;;;AAgDA,SAAgB,EACd,GACA,IAA0C,CAAC,GACpB;CACvB,IAAI,IAAgB;CACpB,KAAK,IAAM,KAAS,GAAU,KAAiB,EAAc,CAAK;CAElE,IAAM,IAAa,EAAc,GAAU,MAAM,GAAe,EAAQ,SAAS,GAC3E,IAAW,EAAc,GAAU,MAAM,GAAe,EAAQ,SAAS;CAE/E,OAAO;EACL,YAAY,EAAS;EACrB;EACA;EACA;EACA,SAAS,EAAW,UAAU,KAAK,EAAS,UAAU;CACxD;AACF;AAGA,SAAS,EACP,GACA,GACA,GACA,GACsB;CACtB,IAAI,IAAQ,GACR,IAAkB,IAClB,IAAY,IACZ,GACA,IAAY,EAAS,SAAS,IAAI,EAAiB,EAAS,IAAK,GAAM,CAAS,EAAE,YAAY,KAAA,GAC9F,IAAe;CAEnB,KAAK,IAAM,KAAS,GAAU;EAC5B,IAAM,IAAW,EAAiB,GAAO,GAAM,CAAS;EAExD,IADI,EAAS,cAAW,IAAY,KAChC,CAAC,EAAS,cAAc;GAC1B,IAAe;GACf;EACF;EAGA,AAFA,KAAS,GACT,KAAmB,EAAc,CAAK,GAClC,MAAU,KAAA,KACZ,IAAQ,EAAS,cACjB,IAAY,EAAS,cACZ,MAAU,EAAS,gBAAgB,MAAc,EAAS,eACnE,IAAe;CAEnB;CAEA,IAAM,IAAgC,MAAU,IAAI,SAAS,IAAe,YAAY;CAExF,OAAO;EACL;EACA;EACA,OAAO,EAAS;EAChB,OAAO,MAAY,YAAY,IAAQ,KAAA;EACvC,WAAW,MAAY,YAAY,IAAY,KAAA;EAC/C;EACA;EACA,iBAAiB,EAAa,GAAiB,CAAa;CAC9D;AACF"}

package/dist/tpsl/grouping/to-group-tpsl-children.d.ts

@@ -0,0 +1,33 @@
+import { UnifiedQuote } from '../../quotes/unified-quote.js';
+import { QuoteTpSl } from '../types.js';
+import { GroupTpSlChild } from './types.js';
+/**
+ * Resolve a quote's confirmed TP/SL snapshot. Receives the whole quote so the
+ * caller can look up by `key`, by `quoteId`, by `tempQuoteId`, or through a
+ * store index that aliases all of them.
+ */
+export type GroupTpSlSnapshotLookup = (quote: UnifiedQuote) => QuoteTpSl | undefined;
+/**
+ * Build {@link GroupTpSlChild}s from a grouped position's child quotes.
+ *
+ * Every quote produces a child — including off-chain ones, which come back with
+ * `quoteId: undefined` so the summary still counts them (an unprotected leg
+ * genuinely drags coverage down) while the planner skips them as
+ * `"not-anchored"`. `openPrice` uses the same fallback `aggregateGroupMetrics`
+ * uses (`openedPrice` when settled and non-zero, else `requestedOpenPrice`);
+ * `virtualAccount` is `vaAddress ?? partyA`, which for a Virtual-Account-scoped
+ * position is the VA itself.
+ *
+ * @param quotes - The grouped position's child quotes (`QuoteGroup.quotes`).
+ * @param snapshot - Resolves each quote's confirmed TP/SL snapshot; a missing
+ *   snapshot becomes a blank one (both sides empty, both states `"canceled"`).
+ * @returns Children in input order.
+ *
+ * @example
+ * ```ts
+ * const children = toGroupTpSlChildren(group.quotes, (quote) => tpslByKey.get(quote.key));
+ * const summary = summarizeQuoteGroupTpSl(children);
+ * ```
+ */
+export declare function toGroupTpSlChildren(quotes: readonly UnifiedQuote[], snapshot: GroupTpSlSnapshotLookup): GroupTpSlChild[];
+//# sourceMappingURL=to-group-tpsl-children.d.ts.map

package/dist/tpsl/grouping/to-group-tpsl-children.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-group-tpsl-children.d.ts","sourceRoot":"","sources":["../../../src/tpsl/grouping/to-group-tpsl-children.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C;;;;GAIG;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,KAAK,EAAE,YAAY,KAAK,SAAS,GAAG,SAAS,CAAC;AAErF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,SAAS,YAAY,EAAE,EAC/B,QAAQ,EAAE,uBAAuB,GAChC,cAAc,EAAE,CAWlB"}

package/dist/tpsl/grouping/to-group-tpsl-children.js

@@ -0,0 +1,30 @@
+import { openPriceOf as e } from "../../quotes/open-price.js";
+//#region src/tpsl/grouping/to-group-tpsl-children.ts
+function t(t, r) {
+	return t.map((t) => ({
+		key: t.key,
+		quoteId: t.quoteId,
+		virtualAccount: t.vaAddress ?? t.partyA,
+		symbolId: t.symbolId,
+		positionType: t.positionType,
+		openQuantity: t.openQuantity,
+		openPrice: e(t),
+		tpsl: r(t) ?? n()
+	}));
+}
+function n() {
+	return {
+		tp: "",
+		sl: "",
+		tpOpenPrice: "",
+		slOpenPrice: "",
+		tpPriceType: "markPrice",
+		slPriceType: "markPrice",
+		tpState: "canceled",
+		slState: "canceled"
+	};
+}
+//#endregion
+export { t as toGroupTpSlChildren };
+
+//# sourceMappingURL=to-group-tpsl-children.js.map

package/dist/tpsl/grouping/to-group-tpsl-children.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-group-tpsl-children.js","names":[],"sources":["../../../src/tpsl/grouping/to-group-tpsl-children.ts"],"sourcesContent":["import { openPriceOf } from \"../../quotes/open-price\";\nimport type { UnifiedQuote } from \"../../quotes/unified-quote\";\nimport type { QuoteTpSl } from \"../types\";\nimport type { GroupTpSlChild } from \"./types\";\n\n/**\n * Resolve a quote's confirmed TP/SL snapshot. Receives the whole quote so the\n * caller can look up by `key`, by `quoteId`, by `tempQuoteId`, or through a\n * store index that aliases all of them.\n */\nexport type GroupTpSlSnapshotLookup = (quote: UnifiedQuote) => QuoteTpSl | undefined;\n\n/**\n * Build {@link GroupTpSlChild}s from a grouped position's child quotes.\n *\n * Every quote produces a child — including off-chain ones, which come back with\n * `quoteId: undefined` so the summary still counts them (an unprotected leg\n * genuinely drags coverage down) while the planner skips them as\n * `\"not-anchored\"`. `openPrice` uses the same fallback `aggregateGroupMetrics`\n * uses (`openedPrice` when settled and non-zero, else `requestedOpenPrice`);\n * `virtualAccount` is `vaAddress ?? partyA`, which for a Virtual-Account-scoped\n * position is the VA itself.\n *\n * @param quotes - The grouped position's child quotes (`QuoteGroup.quotes`).\n * @param snapshot - Resolves each quote's confirmed TP/SL snapshot; a missing\n *   snapshot becomes a blank one (both sides empty, both states `\"canceled\"`).\n * @returns Children in input order.\n *\n * @example\n * ```ts\n * const children = toGroupTpSlChildren(group.quotes, (quote) => tpslByKey.get(quote.key));\n * const summary = summarizeQuoteGroupTpSl(children);\n * ```\n */\nexport function toGroupTpSlChildren(\n  quotes: readonly UnifiedQuote[],\n  snapshot: GroupTpSlSnapshotLookup,\n): GroupTpSlChild[] {\n  return quotes.map((quote) => ({\n    key: quote.key,\n    quoteId: quote.quoteId,\n    virtualAccount: quote.vaAddress ?? quote.partyA,\n    symbolId: quote.symbolId,\n    positionType: quote.positionType,\n    openQuantity: quote.openQuantity,\n    openPrice: openPriceOf(quote),\n    tpsl: snapshot(quote) ?? blankQuoteTpSl(),\n  }));\n}\n\n/** A snapshot with no orders on either side. */\nfunction blankQuoteTpSl(): QuoteTpSl {\n  return {\n    tp: \"\",\n    sl: \"\",\n    tpOpenPrice: \"\",\n    slOpenPrice: \"\",\n    tpPriceType: \"markPrice\",\n    slPriceType: \"markPrice\",\n    tpState: \"canceled\",\n    slState: \"canceled\",\n  };\n}\n"],"mappings":";;AAkCA,SAAgB,EACd,GACA,GACkB;CAClB,OAAO,EAAO,KAAK,OAAW;EAC5B,KAAK,EAAM;EACX,SAAS,EAAM;EACf,gBAAgB,EAAM,aAAa,EAAM;EACzC,UAAU,EAAM;EAChB,cAAc,EAAM;EACpB,cAAc,EAAM;EACpB,WAAW,EAAY,CAAK;EAC5B,MAAM,EAAS,CAAK,KAAK,EAAe;CAC1C,EAAE;AACJ;AAGA,SAAS,IAA4B;CACnC,OAAO;EACL,IAAI;EACJ,IAAI;EACJ,aAAa;EACb,aAAa;EACb,aAAa;EACb,aAAa;EACb,SAAS;EACT,SAAS;CACX;AACF"}

package/dist/tpsl/grouping/to-group-tpsl-orders.d.ts

@@ -0,0 +1,21 @@
+import { GroupTpSlChild, GroupTpSlDesiredMap, GroupTpSlOrder } from './types.js';
+/** Options for {@link toGroupTpSlOrders}. */
+export interface ToGroupTpSlOrdersOptions {
+    /** Pending per-child edits that win over the confirmed snapshot. */
+    overrides?: GroupTpSlDesiredMap;
+}
+/**
+ * Flatten a grouped position's children into one row per live-or-desired TP/SL
+ * order — the data behind an overview list where each order can be inspected or
+ * cancelled individually.
+ *
+ * TP precedes SL within a child; children keep input order. `sizePercent` is
+ * the child's share of the group's **total** open notional (not of the covered
+ * notional), so a partially covered group's rows sum to less than 100%.
+ *
+ * @param children - The grouped position's children.
+ * @param options - Optional pending edits to layer over the snapshots.
+ * @returns One {@link GroupTpSlOrder} per side that carries a trigger.
+ */
+export declare function toGroupTpSlOrders(children: readonly GroupTpSlChild[], options?: ToGroupTpSlOrdersOptions): GroupTpSlOrder[];
+//# sourceMappingURL=to-group-tpsl-orders.d.ts.map

package/dist/tpsl/grouping/to-group-tpsl-orders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-group-tpsl-orders.d.ts","sourceRoot":"","sources":["../../../src/tpsl/grouping/to-group-tpsl-orders.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEnF,6CAA6C;AAC7C,MAAM,WAAW,wBAAwB;IACvC,oEAAoE;IACpE,SAAS,CAAC,EAAE,mBAAmB,CAAC;CACjC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,SAAS,cAAc,EAAE,EACnC,OAAO,GAAE,wBAA6B,GACrC,cAAc,EAAE,CA2BlB"}

package/dist/tpsl/grouping/to-group-tpsl-orders.js

@@ -0,0 +1,33 @@
+import { sharePercent as e } from "../../shared/utils/percent.js";
+import { childNotional as t } from "./notional.js";
+import { GROUP_TPSL_SIDES as n, resolveChildSide as r } from "./resolve-child-side.js";
+//#region src/tpsl/grouping/to-group-tpsl-orders.ts
+function i(i, a = {}) {
+	let o = 0n;
+	for (let e of i) o += t(e);
+	let s = [];
+	for (let c of i) {
+		let i = t(c);
+		for (let t of n) {
+			let n = r(c, t, a.overrides);
+			n.triggerPrice && s.push({
+				key: c.key,
+				quoteId: c.quoteId,
+				conditionalOrderType: n.conditionalOrderType,
+				triggerPrice: n.triggerPrice,
+				priceType: n.priceType,
+				sizePercent: e(i, o) ?? 0n,
+				sizeNotional: i,
+				state: n.state,
+				isPending: n.isPending,
+				hasLiveOrder: !!n.cohQuoteId,
+				cohQuoteId: n.cohQuoteId
+			});
+		}
+	}
+	return s;
+}
+//#endregion
+export { i as toGroupTpSlOrders };
+
+//# sourceMappingURL=to-group-tpsl-orders.js.map

package/dist/tpsl/grouping/to-group-tpsl-orders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-group-tpsl-orders.js","names":[],"sources":["../../../src/tpsl/grouping/to-group-tpsl-orders.ts"],"sourcesContent":["import { sharePercent } from \"../../shared/utils/percent\";\nimport { childNotional } from \"./notional\";\nimport { GROUP_TPSL_SIDES, resolveChildSide } from \"./resolve-child-side\";\nimport type { GroupTpSlChild, GroupTpSlDesiredMap, GroupTpSlOrder } from \"./types\";\n\n/** Options for {@link toGroupTpSlOrders}. */\nexport interface ToGroupTpSlOrdersOptions {\n  /** Pending per-child edits that win over the confirmed snapshot. */\n  overrides?: GroupTpSlDesiredMap;\n}\n\n/**\n * Flatten a grouped position's children into one row per live-or-desired TP/SL\n * order — the data behind an overview list where each order can be inspected or\n * cancelled individually.\n *\n * TP precedes SL within a child; children keep input order. `sizePercent` is\n * the child's share of the group's **total** open notional (not of the covered\n * notional), so a partially covered group's rows sum to less than 100%.\n *\n * @param children - The grouped position's children.\n * @param options - Optional pending edits to layer over the snapshots.\n * @returns One {@link GroupTpSlOrder} per side that carries a trigger.\n */\nexport function toGroupTpSlOrders(\n  children: readonly GroupTpSlChild[],\n  options: ToGroupTpSlOrdersOptions = {},\n): GroupTpSlOrder[] {\n  let totalNotional = 0n;\n\n  for (const child of children) totalNotional += childNotional(child);\n\n  const orders: GroupTpSlOrder[] = [];\n  for (const child of children) {\n    const notional = childNotional(child);\n    for (const side of GROUP_TPSL_SIDES) {\n      const resolved = resolveChildSide(child, side, options.overrides);\n      if (!resolved.triggerPrice) continue;\n      orders.push({\n        key: child.key,\n        quoteId: child.quoteId,\n        conditionalOrderType: resolved.conditionalOrderType,\n        triggerPrice: resolved.triggerPrice,\n        priceType: resolved.priceType,\n        sizePercent: sharePercent(notional, totalNotional) ?? 0n,\n        sizeNotional: notional,\n        state: resolved.state,\n        isPending: resolved.isPending,\n        hasLiveOrder: Boolean(resolved.cohQuoteId),\n        cohQuoteId: resolved.cohQuoteId,\n      });\n    }\n  }\n  return orders;\n}\n"],"mappings":";;;;AAwBA,SAAgB,EACd,GACA,IAAoC,CAAC,GACnB;CAClB,IAAI,IAAgB;CAEpB,KAAK,IAAM,KAAS,GAAU,KAAiB,EAAc,CAAK;CAElE,IAAM,IAA2B,CAAC;CAClC,KAAK,IAAM,KAAS,GAAU;EAC5B,IAAM,IAAW,EAAc,CAAK;EACpC,KAAK,IAAM,KAAQ,GAAkB;GACnC,IAAM,IAAW,EAAiB,GAAO,GAAM,EAAQ,SAAS;GAC3D,EAAS,gBACd,EAAO,KAAK;IACV,KAAK,EAAM;IACX,SAAS,EAAM;IACf,sBAAsB,EAAS;IAC/B,cAAc,EAAS;IACvB,WAAW,EAAS;IACpB,aAAa,EAAa,GAAU,CAAa,KAAK;IACtD,cAAc;IACd,OAAO,EAAS;IAChB,WAAW,EAAS;IACpB,cAAc,EAAQ,EAAS;IAC/B,YAAY,EAAS;GACvB,CAAC;EACH;CACF;CACA,OAAO;AACT"}