@symmio/trading-react 1.1.0 → 3.0.0

package/dist/quotes/use-force-cancel-close-request.d.ts

@@ -0,0 +1,27 @@
+import { ForceCancelCloseRequestParameters } from '@symmio/trading-core';
+import { UseMutationResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error.js';
+import { WriteParameters, WriteResult } from '../transactions/index.js';
+/** Parameters for {@link useForceCancelCloseRequest}. */
+export type UseForceCancelCloseRequestParameters = WriteParameters;
+/** Result returned by the {@link useForceCancelCloseRequest} mutation. */
+export type ForceCancelCloseRequestResult = WriteResult;
+/** Return type of {@link useForceCancelCloseRequest}. */
+export type UseForceCancelCloseRequestReturnType = UseMutationResult<ForceCancelCloseRequestResult, SymmioRequestError, ForceCancelCloseRequestParameters>;
+/**
+ * Force-cancel a stalled pending close (`forceCancelCloseRequest`, routed through
+ * the AccountLayer `_call` proxy). Only valid once the quote is
+ * `CANCEL_CLOSE_PENDING` (partyA already called `requestToCancelCloseRequest` and
+ * partyB never acted) **and** the force-cancel-close cooldown has elapsed — see
+ * {@link useCoolDownsOfMA} (index 2) plus the quote's `statusModifyTimestamp`. The
+ * quote returns to `OPENED`. On success (after the receipt) the subaccount's
+ * open-positions read is invalidated.
+ *
+ * @example
+ * ```tsx
+ * const { mutate } = useForceCancelCloseRequest();
+ * mutate({ account: "0xsub…", quoteId: 42n });
+ * ```
+ */
+export declare function useForceCancelCloseRequest(parameters?: UseForceCancelCloseRequestParameters): UseForceCancelCloseRequestReturnType;
+//# sourceMappingURL=use-force-cancel-close-request.d.ts.map

package/dist/quotes/use-force-cancel-close-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-force-cancel-close-request.d.ts","sourceRoot":"","sources":["../../src/quotes/use-force-cancel-close-request.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,iCAAiC,EACvC,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAA+B,KAAK,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE5F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAGzE,OAAO,EAAsB,KAAK,eAAe,EAAE,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAG7F,yDAAyD;AACzD,MAAM,MAAM,oCAAoC,GAAG,eAAe,CAAC;AAEnE,0EAA0E;AAC1E,MAAM,MAAM,6BAA6B,GAAG,WAAW,CAAC;AAExD,yDAAyD;AACzD,MAAM,MAAM,oCAAoC,GAAG,iBAAiB,CAClE,6BAA6B,EAC7B,kBAAkB,EAClB,iCAAiC,CAClC,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,0BAA0B,CACxC,UAAU,GAAE,oCAAyC,GACpD,oCAAoC,CAmCtC"}

package/dist/quotes/use-force-cancel-close-request.js

@@ -0,0 +1,41 @@
+"use client";
+import { useSymmioChainId as e } from "../provider/use-symmio-chain-id.js";
+import { useSymmioConfig as t } from "../provider/use-symmio-config.js";
+import { normalizeSymmError as n } from "../errors/normalize-symm-error.js";
+import { resolveWriteResult as r } from "../transactions/resolve-write-result.js";
+import { predicateMatch as i } from "../utils/predicate-match.js";
+import { forceCancelCloseRequestMutationOptions as a, getPartyAOpenPositionsQueryKey as o } from "@symmio/trading-core";
+import { useMutation as s, useQueryClient as c } from "@tanstack/react-query";
+//#region src/quotes/use-force-cancel-close-request.ts
+function l(l = {}) {
+	let u = t(l), d = e(), f = c(), p = a(u);
+	return s({
+		mutationKey: p.mutationKey,
+		mutationFn: async (e) => {
+			try {
+				let t = e.chainId ?? d;
+				return r(u, await p.mutationFn({
+					account: e.account,
+					quoteId: e.quoteId,
+					from: e.from,
+					simulateBeforeWrite: e.simulateBeforeWrite,
+					chainId: t
+				}), {
+					chainId: t,
+					waitForReceipt: l.waitForReceipt,
+					confirmations: l.confirmations
+				});
+			} catch (e) {
+				throw n(e);
+			}
+		},
+		onSuccess: (e, t) => {
+			let n = { partyA: t.account };
+			f.invalidateQueries({ predicate: i(o, n) });
+		}
+	});
+}
+//#endregion
+export { l as useForceCancelCloseRequest };
+
+//# sourceMappingURL=use-force-cancel-close-request.js.map

package/dist/quotes/use-force-cancel-close-request.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-force-cancel-close-request.js","names":[],"sources":["../../src/quotes/use-force-cancel-close-request.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  forceCancelCloseRequestMutationOptions,\n  getPartyAOpenPositionsQueryKey,\n  type ForceCancelCloseRequestParameters,\n} from \"@symmio/trading-core\";\nimport { useMutation, useQueryClient, type UseMutationResult } from \"@tanstack/react-query\";\nimport { normalizeSymmError } from \"../errors/normalize-symm-error\";\nimport type { SymmioRequestError } from \"../errors/symmio-request-error\";\nimport { useSymmioChainId } from \"../provider/use-symmio-chain-id\";\nimport { useSymmioConfig } from \"../provider/use-symmio-config\";\nimport { resolveWriteResult, type WriteParameters, type WriteResult } from \"../transactions\";\nimport { predicateMatch } from \"../utils\";\n\n/** Parameters for {@link useForceCancelCloseRequest}. */\nexport type UseForceCancelCloseRequestParameters = WriteParameters;\n\n/** Result returned by the {@link useForceCancelCloseRequest} mutation. */\nexport type ForceCancelCloseRequestResult = WriteResult;\n\n/** Return type of {@link useForceCancelCloseRequest}. */\nexport type UseForceCancelCloseRequestReturnType = UseMutationResult<\n  ForceCancelCloseRequestResult,\n  SymmioRequestError,\n  ForceCancelCloseRequestParameters\n>;\n\n/**\n * Force-cancel a stalled pending close (`forceCancelCloseRequest`, routed through\n * the AccountLayer `_call` proxy). Only valid once the quote is\n * `CANCEL_CLOSE_PENDING` (partyA already called `requestToCancelCloseRequest` and\n * partyB never acted) **and** the force-cancel-close cooldown has elapsed — see\n * {@link useCoolDownsOfMA} (index 2) plus the quote's `statusModifyTimestamp`. The\n * quote returns to `OPENED`. On success (after the receipt) the subaccount's\n * open-positions read is invalidated.\n *\n * @example\n * ```tsx\n * const { mutate } = useForceCancelCloseRequest();\n * mutate({ account: \"0xsub…\", quoteId: 42n });\n * ```\n */\nexport function useForceCancelCloseRequest(\n  parameters: UseForceCancelCloseRequestParameters = {},\n): UseForceCancelCloseRequestReturnType {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n  const queryClient = useQueryClient();\n\n  const base = forceCancelCloseRequestMutationOptions(config);\n\n  return useMutation<ForceCancelCloseRequestResult, SymmioRequestError, ForceCancelCloseRequestParameters>({\n    mutationKey: base.mutationKey,\n    mutationFn: async (variables) => {\n      try {\n        const resolvedChainId = variables.chainId ?? chainId;\n        const hash = await base.mutationFn({\n          account: variables.account,\n          quoteId: variables.quoteId,\n          from: variables.from,\n          simulateBeforeWrite: variables.simulateBeforeWrite,\n          chainId: resolvedChainId,\n        });\n        return resolveWriteResult(config, hash, {\n          chainId: resolvedChainId,\n          waitForReceipt: parameters.waitForReceipt,\n          confirmations: parameters.confirmations,\n        });\n      } catch (err) {\n        throw normalizeSymmError(err);\n      }\n    },\n    onSuccess: (_result, variables) => {\n      // The force-cancel returns the position to OPENED — refetch the owning\n      // partyA's open positions so the status updates.\n      const partial = { partyA: variables.account };\n      void queryClient.invalidateQueries({ predicate: predicateMatch(getPartyAOpenPositionsQueryKey, partial) });\n    },\n  });\n}\n"],"mappings":";;;;;;;;;AA2CA,SAAgB,EACd,IAAmD,CAAC,GACd;CACtC,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAU,EAAiB,GAC3B,IAAc,EAAe,GAE7B,IAAO,EAAuC,CAAM;CAE1D,OAAO,EAAkG;EACvG,aAAa,EAAK;EAClB,YAAY,OAAO,MAAc;GAC/B,IAAI;IACF,IAAM,IAAkB,EAAU,WAAW;IAQ7C,OAAO,EAAmB,GAAQ,MAPf,EAAK,WAAW;KACjC,SAAS,EAAU;KACnB,SAAS,EAAU;KACnB,MAAM,EAAU;KAChB,qBAAqB,EAAU;KAC/B,SAAS;IACX,CAAC,GACuC;KACtC,SAAS;KACT,gBAAgB,EAAW;KAC3B,eAAe,EAAW;IAC5B,CAAC;GACH,SAAS,GAAK;IACZ,MAAM,EAAmB,CAAG;GAC9B;EACF;EACA,YAAY,GAAS,MAAc;GAGjC,IAAM,IAAU,EAAE,QAAQ,EAAU,QAAQ;GAC5C,EAAiB,kBAAkB,EAAE,WAAW,EAAe,GAAgC,CAAO,EAAE,CAAC;EAC3G;CACF,CAAC;AACH"}

package/dist/quotes/use-force-cancel-quote.d.ts

@@ -0,0 +1,26 @@
+import { ForceCancelQuoteParameters } from '@symmio/trading-core';
+import { UseMutationResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error.js';
+import { WriteParameters, WriteResult } from '../transactions/index.js';
+/** Parameters for {@link useForceCancelQuote}. */
+export type UseForceCancelQuoteParameters = WriteParameters;
+/** Result returned by the {@link useForceCancelQuote} mutation. */
+export type ForceCancelQuoteResult = WriteResult;
+/** Return type of {@link useForceCancelQuote}. */
+export type UseForceCancelQuoteReturnType = UseMutationResult<ForceCancelQuoteResult, SymmioRequestError, ForceCancelQuoteParameters>;
+/**
+ * Force-cancel a stalled quote (`forceCancelQuote`, routed through the
+ * AccountLayer `_call` proxy). Only valid once the quote is `CANCEL_PENDING`
+ * (partyA already called `requestToCancelQuote` on a `LOCKED` order) **and** the
+ * force-cancel cooldown has elapsed — see {@link useCoolDownsOfMA} (index 1) plus
+ * the quote's `statusModifyTimestamp`. On success (after the receipt) the
+ * subaccount's pending-quotes reads are invalidated so the order drops out.
+ *
+ * @example
+ * ```tsx
+ * const { mutate } = useForceCancelQuote();
+ * mutate({ account: "0xsub…", quoteId: 42n });
+ * ```
+ */
+export declare function useForceCancelQuote(parameters?: UseForceCancelQuoteParameters): UseForceCancelQuoteReturnType;
+//# sourceMappingURL=use-force-cancel-quote.d.ts.map

package/dist/quotes/use-force-cancel-quote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-force-cancel-quote.d.ts","sourceRoot":"","sources":["../../src/quotes/use-force-cancel-quote.ts"],"names":[],"mappings":"AAEA,OAAO,EAML,KAAK,0BAA0B,EAChC,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAA+B,KAAK,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE5F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAGzE,OAAO,EAAsB,KAAK,eAAe,EAAE,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAG7F,kDAAkD;AAClD,MAAM,MAAM,6BAA6B,GAAG,eAAe,CAAC;AAE5D,mEAAmE;AACnE,MAAM,MAAM,sBAAsB,GAAG,WAAW,CAAC;AAEjD,kDAAkD;AAClD,MAAM,MAAM,6BAA6B,GAAG,iBAAiB,CAC3D,sBAAsB,EACtB,kBAAkB,EAClB,0BAA0B,CAC3B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,GAAE,6BAAkC,GAAG,6BAA6B,CAkDjH"}

package/dist/quotes/use-force-cancel-quote.js

@@ -0,0 +1,42 @@
+"use client";
+import { useSymmioChainId as e } from "../provider/use-symmio-chain-id.js";
+import { useSymmioConfig as t } from "../provider/use-symmio-config.js";
+import { normalizeSymmError as n } from "../errors/normalize-symm-error.js";
+import { resolveWriteResult as r } from "../transactions/resolve-write-result.js";
+import { predicateMatch as i } from "../utils/predicate-match.js";
+import { invalidateAccountBalances as a } from "../utils/invalidate-account-balances.js";
+import { forceCancelQuoteMutationOptions as o, getPartyAOpenPositionsQueryKey as s, getPartyAPendingQuotesQueryKey as c, getPendingQuotesQueryKey as l, getQuoteQueryKey as u } from "@symmio/trading-core";
+import { useMutation as d, useQueryClient as f } from "@tanstack/react-query";
+//#region src/quotes/use-force-cancel-quote.ts
+function p(p = {}) {
+	let m = t(p), h = e(), g = f(), _ = o(m);
+	return d({
+		mutationKey: _.mutationKey,
+		mutationFn: async (e) => {
+			try {
+				let t = e.chainId ?? h;
+				return r(m, await _.mutationFn({
+					account: e.account,
+					quoteId: e.quoteId,
+					from: e.from,
+					simulateBeforeWrite: e.simulateBeforeWrite,
+					chainId: t
+				}), {
+					chainId: t,
+					waitForReceipt: p.waitForReceipt,
+					confirmations: p.confirmations
+				});
+			} catch (e) {
+				throw n(e);
+			}
+		},
+		onSuccess: (e, t) => {
+			let n = { partyA: t.account };
+			g.invalidateQueries({ predicate: i(l, n) }), g.invalidateQueries({ predicate: i(c, n) }), g.invalidateQueries({ predicate: i(s, n) }), g.invalidateQueries({ predicate: i(u, { quoteId: t.quoteId }) }), a(g, { configKey: m.getChainConfigKey(t.chainId ?? h) });
+		}
+	});
+}
+//#endregion
+export { p as useForceCancelQuote };
+
+//# sourceMappingURL=use-force-cancel-quote.js.map

package/dist/quotes/use-force-cancel-quote.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-force-cancel-quote.js","names":[],"sources":["../../src/quotes/use-force-cancel-quote.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  forceCancelQuoteMutationOptions,\n  getPartyAOpenPositionsQueryKey,\n  getPartyAPendingQuotesQueryKey,\n  getPendingQuotesQueryKey,\n  getQuoteQueryKey,\n  type ForceCancelQuoteParameters,\n} from \"@symmio/trading-core\";\nimport { useMutation, useQueryClient, type UseMutationResult } from \"@tanstack/react-query\";\nimport { normalizeSymmError } from \"../errors/normalize-symm-error\";\nimport type { SymmioRequestError } from \"../errors/symmio-request-error\";\nimport { useSymmioChainId } from \"../provider/use-symmio-chain-id\";\nimport { useSymmioConfig } from \"../provider/use-symmio-config\";\nimport { resolveWriteResult, type WriteParameters, type WriteResult } from \"../transactions\";\nimport { invalidateAccountBalances, predicateMatch } from \"../utils\";\n\n/** Parameters for {@link useForceCancelQuote}. */\nexport type UseForceCancelQuoteParameters = WriteParameters;\n\n/** Result returned by the {@link useForceCancelQuote} mutation. */\nexport type ForceCancelQuoteResult = WriteResult;\n\n/** Return type of {@link useForceCancelQuote}. */\nexport type UseForceCancelQuoteReturnType = UseMutationResult<\n  ForceCancelQuoteResult,\n  SymmioRequestError,\n  ForceCancelQuoteParameters\n>;\n\n/**\n * Force-cancel a stalled quote (`forceCancelQuote`, routed through the\n * AccountLayer `_call` proxy). Only valid once the quote is `CANCEL_PENDING`\n * (partyA already called `requestToCancelQuote` on a `LOCKED` order) **and** the\n * force-cancel cooldown has elapsed — see {@link useCoolDownsOfMA} (index 1) plus\n * the quote's `statusModifyTimestamp`. On success (after the receipt) the\n * subaccount's pending-quotes reads are invalidated so the order drops out.\n *\n * @example\n * ```tsx\n * const { mutate } = useForceCancelQuote();\n * mutate({ account: \"0xsub…\", quoteId: 42n });\n * ```\n */\nexport function useForceCancelQuote(parameters: UseForceCancelQuoteParameters = {}): UseForceCancelQuoteReturnType {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n  const queryClient = useQueryClient();\n\n  const base = forceCancelQuoteMutationOptions(config);\n\n  return useMutation<ForceCancelQuoteResult, SymmioRequestError, ForceCancelQuoteParameters>({\n    mutationKey: base.mutationKey,\n    mutationFn: async (variables) => {\n      try {\n        const resolvedChainId = variables.chainId ?? chainId;\n        const hash = await base.mutationFn({\n          account: variables.account,\n          quoteId: variables.quoteId,\n          from: variables.from,\n          simulateBeforeWrite: variables.simulateBeforeWrite,\n          chainId: resolvedChainId,\n        });\n        return resolveWriteResult(config, hash, {\n          chainId: resolvedChainId,\n          waitForReceipt: parameters.waitForReceipt,\n          confirmations: parameters.confirmations,\n        });\n      } catch (err) {\n        throw normalizeSymmError(err);\n      }\n    },\n    onSuccess: (_result, variables) => {\n      // The force-cancelled quote leaves the pending set — refetch the pending\n      // reads (full quotes + ids), the open positions for this partyA, and the\n      // quote's own `getQuote` hydration (the read carrying `quoteStatus`) after the\n      // receipt, so managed-quotes drops the now-terminal quote.\n      const partial = { partyA: variables.account };\n      void queryClient.invalidateQueries({ predicate: predicateMatch(getPendingQuotesQueryKey, partial) });\n      void queryClient.invalidateQueries({ predicate: predicateMatch(getPartyAPendingQuotesQueryKey, partial) });\n      void queryClient.invalidateQueries({ predicate: predicateMatch(getPartyAOpenPositionsQueryKey, partial) });\n      void queryClient.invalidateQueries({\n        predicate: predicateMatch(getQuoteQueryKey, { quoteId: variables.quoteId }),\n      });\n      /**\n       * A force-cancel refunds the open trading fee and releases both parties'\n       * pending locked balances in the same transaction, so every balance read is now\n       * stale.\n       */\n      invalidateAccountBalances(queryClient, {\n        configKey: config.getChainConfigKey(variables.chainId ?? chainId),\n      });\n    },\n  });\n}\n"],"mappings":";;;;;;;;;;AA6CA,SAAgB,EAAoB,IAA4C,CAAC,GAAkC;CACjH,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAU,EAAiB,GAC3B,IAAc,EAAe,GAE7B,IAAO,EAAgC,CAAM;CAEnD,OAAO,EAAoF;EACzF,aAAa,EAAK;EAClB,YAAY,OAAO,MAAc;GAC/B,IAAI;IACF,IAAM,IAAkB,EAAU,WAAW;IAQ7C,OAAO,EAAmB,GAAQ,MAPf,EAAK,WAAW;KACjC,SAAS,EAAU;KACnB,SAAS,EAAU;KACnB,MAAM,EAAU;KAChB,qBAAqB,EAAU;KAC/B,SAAS;IACX,CAAC,GACuC;KACtC,SAAS;KACT,gBAAgB,EAAW;KAC3B,eAAe,EAAW;IAC5B,CAAC;GACH,SAAS,GAAK;IACZ,MAAM,EAAmB,CAAG;GAC9B;EACF;EACA,YAAY,GAAS,MAAc;GAKjC,IAAM,IAAU,EAAE,QAAQ,EAAU,QAAQ;GAY5C,AAXA,EAAiB,kBAAkB,EAAE,WAAW,EAAe,GAA0B,CAAO,EAAE,CAAC,GACnG,EAAiB,kBAAkB,EAAE,WAAW,EAAe,GAAgC,CAAO,EAAE,CAAC,GACzG,EAAiB,kBAAkB,EAAE,WAAW,EAAe,GAAgC,CAAO,EAAE,CAAC,GACzG,EAAiB,kBAAkB,EACjC,WAAW,EAAe,GAAkB,EAAE,SAAS,EAAU,QAAQ,CAAC,EAC5E,CAAC,GAMD,EAA0B,GAAa,EACrC,WAAW,EAAO,kBAAkB,EAAU,WAAW,CAAO,EAClE,CAAC;EACH;CACF,CAAC;AACH"}

package/dist/quotes/use-force-close-eligibility.d.ts

@@ -0,0 +1,30 @@
+import { ConfigParameter, ForceCloseEligibility, Quote } from '@symmio/trading-core';
+/** The quote fields {@link useForceCloseEligibility} needs. */
+export type ForceCloseEligibilityQuote = Pick<Quote, "quoteStatus" | "orderType" | "statusModifyTimestamp" | "deadline" | "symbolId">;
+/** Parameters for {@link useForceCloseEligibility}. */
+export type UseForceCloseEligibilityParameters = ConfigParameter & {
+    /** The quote (or a subset with the needed fields) to gate. */
+    quote?: ForceCloseEligibilityQuote;
+};
+/** Return type of {@link useForceCloseEligibility}. */
+export type UseForceCloseEligibilityReturnType = ForceCloseEligibility & {
+    /** `true` while the force-close params are loading (eligibility not yet known). */
+    isLoading: boolean;
+};
+/**
+ * Live force-close eligibility for a quote — the button gate + cooldown
+ * countdown. Reads the market's force-close params ({@link useForceCloseParams})
+ * and runs the pure `checkForceCloseEligibility` against a 1-second clock, so
+ * `cooldownRemaining` ticks down and `eligible` flips on the moment the cooldown
+ * elapses, without a manual refresh. Send with {@link useForceClose}.
+ *
+ * Force close is a limit-order feature (majors / rasa), so it is never eligible
+ * on a solver that does not support limit orders.
+ *
+ * @example
+ * ```tsx
+ * const { eligible, reason, cooldownRemaining } = useForceCloseEligibility({ quote });
+ * ```
+ */
+export declare function useForceCloseEligibility(parameters?: UseForceCloseEligibilityParameters): UseForceCloseEligibilityReturnType;
+//# sourceMappingURL=use-force-close-eligibility.d.ts.map

package/dist/quotes/use-force-close-eligibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-force-close-eligibility.d.ts","sourceRoot":"","sources":["../../src/quotes/use-force-close-eligibility.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC1B,KAAK,KAAK,EACX,MAAM,sBAAsB,CAAC;AAK9B,+DAA+D;AAC/D,MAAM,MAAM,0BAA0B,GAAG,IAAI,CAC3C,KAAK,EACL,aAAa,GAAG,WAAW,GAAG,uBAAuB,GAAG,UAAU,GAAG,UAAU,CAChF,CAAC;AAEF,uDAAuD;AACvD,MAAM,MAAM,kCAAkC,GAAG,eAAe,GAAG;IACjE,8DAA8D;IAC9D,KAAK,CAAC,EAAE,0BAA0B,CAAC;CACpC,CAAC;AAEF,uDAAuD;AACvD,MAAM,MAAM,kCAAkC,GAAG,qBAAqB,GAAG;IACvE,mFAAmF;IACnF,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAIF;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,wBAAwB,CACtC,UAAU,GAAE,kCAAuC,GAClD,kCAAkC,CA8BpC"}

package/dist/quotes/use-force-close-eligibility.js

@@ -0,0 +1,39 @@
+"use client";
+import { useSupportsLimitOrder as e } from "../solvers/use-solver-capabilities.js";
+import { useForceCloseParams as t } from "./use-force-close-params.js";
+import { checkForceCloseEligibility as n } from "@symmio/trading-core";
+import { useEffect as r, useMemo as i, useState as a } from "react";
+//#region src/quotes/use-force-close-eligibility.ts
+var o = {
+	eligible: !1,
+	cooldownRemaining: 0n
+};
+function s(s = {}) {
+	let { quote: c, config: l } = s, u = e({ config: l }), d = t({
+		symbolId: c?.symbolId ?? 0n,
+		config: l,
+		query: { enabled: c !== void 0 }
+	}), f = d.data, [p, m] = a(() => BigInt(Math.floor(Date.now() / 1e3)));
+	return r(() => {
+		let e = setInterval(() => m(BigInt(Math.floor(Date.now() / 1e3))), 1e3);
+		return () => clearInterval(e);
+	}, []), {
+		...i(() => !u || !c || !f ? o : n({
+			quote: c,
+			firstCooldown: f.firstCooldown,
+			secondCooldown: f.secondCooldown,
+			minSigPeriod: f.minSigPeriod,
+			now: p
+		}), [
+			u,
+			c,
+			f,
+			p
+		]),
+		isLoading: d.isLoading
+	};
+}
+//#endregion
+export { s as useForceCloseEligibility };
+
+//# sourceMappingURL=use-force-close-eligibility.js.map

package/dist/quotes/use-force-close-eligibility.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-force-close-eligibility.js","names":[],"sources":["../../src/quotes/use-force-close-eligibility.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  checkForceCloseEligibility,\n  type ConfigParameter,\n  type ForceCloseEligibility,\n  type Quote,\n} from \"@symmio/trading-core\";\nimport { useEffect, useMemo, useState } from \"react\";\nimport { useSupportsLimitOrder } from \"../solvers/use-solver-capabilities\";\nimport { useForceCloseParams } from \"./use-force-close-params\";\n\n/** The quote fields {@link useForceCloseEligibility} needs. */\nexport type ForceCloseEligibilityQuote = Pick<\n  Quote,\n  \"quoteStatus\" | \"orderType\" | \"statusModifyTimestamp\" | \"deadline\" | \"symbolId\"\n>;\n\n/** Parameters for {@link useForceCloseEligibility}. */\nexport type UseForceCloseEligibilityParameters = ConfigParameter & {\n  /** The quote (or a subset with the needed fields) to gate. */\n  quote?: ForceCloseEligibilityQuote;\n};\n\n/** Return type of {@link useForceCloseEligibility}. */\nexport type UseForceCloseEligibilityReturnType = ForceCloseEligibility & {\n  /** `true` while the force-close params are loading (eligibility not yet known). */\n  isLoading: boolean;\n};\n\nconst NOT_ELIGIBLE: ForceCloseEligibility = { eligible: false, cooldownRemaining: 0n };\n\n/**\n * Live force-close eligibility for a quote — the button gate + cooldown\n * countdown. Reads the market's force-close params ({@link useForceCloseParams})\n * and runs the pure `checkForceCloseEligibility` against a 1-second clock, so\n * `cooldownRemaining` ticks down and `eligible` flips on the moment the cooldown\n * elapses, without a manual refresh. Send with {@link useForceClose}.\n *\n * Force close is a limit-order feature (majors / rasa), so it is never eligible\n * on a solver that does not support limit orders.\n *\n * @example\n * ```tsx\n * const { eligible, reason, cooldownRemaining } = useForceCloseEligibility({ quote });\n * ```\n */\nexport function useForceCloseEligibility(\n  parameters: UseForceCloseEligibilityParameters = {},\n): UseForceCloseEligibilityReturnType {\n  const { quote, config } = parameters;\n  const supportsLimit = useSupportsLimitOrder({ config });\n  /** `0n` is a placeholder that is never fetched — the query stays disabled until a quote is present. */\n  const paramsQuery = useForceCloseParams({\n    symbolId: quote?.symbolId ?? 0n,\n    config,\n    query: { enabled: quote !== undefined },\n  });\n  const params = paramsQuery.data;\n\n  const [nowSec, setNowSec] = useState(() => BigInt(Math.floor(Date.now() / 1000)));\n  useEffect(() => {\n    const id = setInterval(() => setNowSec(BigInt(Math.floor(Date.now() / 1000))), 1000);\n    return () => clearInterval(id);\n  }, []);\n\n  const eligibility = useMemo<ForceCloseEligibility>(() => {\n    // Force close only exists on limit-supporting solvers — never eligible otherwise.\n    if (!supportsLimit || !quote || !params) return NOT_ELIGIBLE;\n    return checkForceCloseEligibility({\n      quote,\n      firstCooldown: params.firstCooldown,\n      secondCooldown: params.secondCooldown,\n      minSigPeriod: params.minSigPeriod,\n      now: nowSec,\n    });\n  }, [supportsLimit, quote, params, nowSec]);\n\n  return { ...eligibility, isLoading: paramsQuery.isLoading };\n}\n"],"mappings":";;;;;;AA8BA,IAAM,IAAsC;CAAE,UAAU;CAAO,mBAAmB;AAAG;AAiBrF,SAAgB,EACd,IAAiD,CAAC,GACd;CACpC,IAAM,EAAE,UAAO,cAAW,GACpB,IAAgB,EAAsB,EAAE,UAAO,CAAC,GAEhD,IAAc,EAAoB;EACtC,UAAU,GAAO,YAAY;EAC7B;EACA,OAAO,EAAE,SAAS,MAAU,KAAA,EAAU;CACxC,CAAC,GACK,IAAS,EAAY,MAErB,CAAC,GAAQ,KAAa,QAAe,OAAO,KAAK,MAAM,KAAK,IAAI,IAAI,GAAI,CAAC,CAAC;CAkBhF,OAjBA,QAAgB;EACd,IAAM,IAAK,kBAAkB,EAAU,OAAO,KAAK,MAAM,KAAK,IAAI,IAAI,GAAI,CAAC,CAAC,GAAG,GAAI;EACnF,aAAa,cAAc,CAAE;CAC/B,GAAG,CAAC,CAAC,GAcE;EAAE,GAZW,QAEd,CAAC,KAAiB,CAAC,KAAS,CAAC,IAAe,IACzC,EAA2B;GAChC;GACA,eAAe,EAAO;GACtB,gBAAgB,EAAO;GACvB,cAAc,EAAO;GACrB,KAAK;EACP,CAAC,GACA;GAAC;GAAe;GAAO;GAAQ;EAAM,CAE5B;EAAa,WAAW,EAAY;CAAU;AAC5D"}

package/dist/quotes/use-force-close-params.d.ts

@@ -0,0 +1,22 @@
+import { ConfigParameter, GetForceCloseParamsData, GetForceCloseParamsOptions } from '@symmio/trading-core';
+import { UseQueryResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error.js';
+/** Parameters for {@link useForceCloseParams}: the core options (`symbolId`, chain id) plus an optional `config`. */
+export type UseForceCloseParamsParameters = GetForceCloseParamsOptions & ConfigParameter;
+/** Return type of {@link useForceCloseParams}. */
+export type UseForceCloseParamsReturnType = UseQueryResult<GetForceCloseParamsData, SymmioRequestError>;
+/**
+ * Read the protocol force-close params (cooldowns, price penalty, min signature
+ * period, and the symbol's gap ratio) for a market — the inputs to the
+ * force-close eligibility gate and price checks. These change rarely, so a long
+ * `staleTime` fits. `symbolId` is required; while it is still loading, pass a
+ * placeholder and gate with `query.enabled`. Errors are normalized to
+ * {@link SymmioRequestError}.
+ *
+ * @example
+ * ```tsx
+ * const { data: params } = useForceCloseParams({ symbolId: 1n });
+ * ```
+ */
+export declare function useForceCloseParams(parameters: UseForceCloseParamsParameters): UseForceCloseParamsReturnType;
+//# sourceMappingURL=use-force-close-params.d.ts.map

package/dist/quotes/use-force-close-params.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-force-close-params.d.ts","sourceRoot":"","sources":["../../src/quotes/use-force-close-params.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAC5B,KAAK,0BAA0B,EAChC,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAIzE,qHAAqH;AACrH,MAAM,MAAM,6BAA6B,GAAG,0BAA0B,GAAG,eAAe,CAAC;AAEzF,kDAAkD;AAClD,MAAM,MAAM,6BAA6B,GAAG,cAAc,CAAC,uBAAuB,EAAE,kBAAkB,CAAC,CAAC;AAExG;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,6BAA6B,GAAG,6BAA6B,CAkB5G"}

package/dist/quotes/use-force-close-params.js

@@ -0,0 +1,27 @@
+"use client";
+import { useSymmioChainId as e } from "../provider/use-symmio-chain-id.js";
+import { useSymmioConfig as t } from "../provider/use-symmio-config.js";
+import { normalizeSymmError as n } from "../errors/normalize-symm-error.js";
+import { getForceCloseParamsQueryOptions as r } from "@symmio/trading-core";
+import { useQuery as i } from "@tanstack/react-query";
+//#region src/quotes/use-force-close-params.ts
+function a(a) {
+	let o = t(a), s = e(), c = r(o, {
+		...a,
+		chainId: a.chainId ?? s
+	});
+	return i({
+		...c,
+		queryFn: async () => {
+			try {
+				return await c.queryFn();
+			} catch (e) {
+				throw n(e);
+			}
+		}
+	});
+}
+//#endregion
+export { a as useForceCloseParams };
+
+//# sourceMappingURL=use-force-close-params.js.map

package/dist/quotes/use-force-close-params.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-force-close-params.js","names":[],"sources":["../../src/quotes/use-force-close-params.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getForceCloseParamsQueryOptions,\n  type ConfigParameter,\n  type GetForceCloseParamsData,\n  type GetForceCloseParamsOptions,\n} from \"@symmio/trading-core\";\nimport { useQuery, type UseQueryResult } from \"@tanstack/react-query\";\nimport { normalizeSymmError } from \"../errors/normalize-symm-error\";\nimport type { SymmioRequestError } from \"../errors/symmio-request-error\";\nimport { useSymmioChainId } from \"../provider/use-symmio-chain-id\";\nimport { useSymmioConfig } from \"../provider/use-symmio-config\";\n\n/** Parameters for {@link useForceCloseParams}: the core options (`symbolId`, chain id) plus an optional `config`. */\nexport type UseForceCloseParamsParameters = GetForceCloseParamsOptions & ConfigParameter;\n\n/** Return type of {@link useForceCloseParams}. */\nexport type UseForceCloseParamsReturnType = UseQueryResult<GetForceCloseParamsData, SymmioRequestError>;\n\n/**\n * Read the protocol force-close params (cooldowns, price penalty, min signature\n * period, and the symbol's gap ratio) for a market — the inputs to the\n * force-close eligibility gate and price checks. These change rarely, so a long\n * `staleTime` fits. `symbolId` is required; while it is still loading, pass a\n * placeholder and gate with `query.enabled`. Errors are normalized to\n * {@link SymmioRequestError}.\n *\n * @example\n * ```tsx\n * const { data: params } = useForceCloseParams({ symbolId: 1n });\n * ```\n */\nexport function useForceCloseParams(parameters: UseForceCloseParamsParameters): UseForceCloseParamsReturnType {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n  const options = getForceCloseParamsQueryOptions(config, {\n    ...parameters,\n    chainId: parameters.chainId ?? chainId,\n  });\n\n  return useQuery({\n    ...options,\n    queryFn: async () => {\n      try {\n        return await options.queryFn();\n      } catch (err) {\n        throw normalizeSymmError(err);\n      }\n    },\n  }) as UseForceCloseParamsReturnType;\n}\n"],"mappings":";;;;;;;AAiCA,SAAgB,EAAoB,GAA0E;CAC5G,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAU,EAAiB,GAC3B,IAAU,EAAgC,GAAQ;EACtD,GAAG;EACH,SAAS,EAAW,WAAW;CACjC,CAAC;CAED,OAAO,EAAS;EACd,GAAG;EACH,SAAS,YAAY;GACnB,IAAI;IACF,OAAO,MAAM,EAAQ,QAAQ;GAC/B,SAAS,GAAK;IACZ,MAAM,EAAmB,CAAG;GAC9B;EACF;CACF,CAAC;AACH"}

package/dist/quotes/use-force-close.d.ts

@@ -0,0 +1,30 @@
+import { ForceCloseAutoParameters } from '@symmio/trading-core';
+import { UseMutationResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error.js';
+import { WriteParameters, WriteResult } from '../transactions/index.js';
+/** Parameters for {@link useForceClose}. */
+export type UseForceCloseParameters = WriteParameters;
+/** Result returned by the {@link useForceClose} mutation. */
+export type ForceCloseResult = WriteResult;
+/** Return type of {@link useForceClose}. */
+export type UseForceCloseReturnType = UseMutationResult<ForceCloseResult, SymmioRequestError, ForceCloseAutoParameters>;
+/**
+ * Force-close a stalled `CLOSE_PENDING` **limit** position end-to-end from just a
+ * `quoteId` (`forceCloseAuto`): read the quote + force-close params, gate on
+ * eligibility, find a price window from reference candles, fetch the Muon
+ * `HighLowPriceSig`, preflight the gap, and send `forceClosePosition` through the
+ * AccountLayer `_call` proxy. On success (after the receipt) the subaccount's
+ * open-positions read is invalidated so the row updates.
+ *
+ * Throws (normalized) on ineligibility (`FORCE_CLOSE_NOT_ELIGIBLE`), the market
+ * not having hit the price (`FORCE_CLOSE_PRICE_NOT_REACHED`), or a contract
+ * revert. Gate the button first with {@link useForceCloseEligibility}.
+ *
+ * @example
+ * ```tsx
+ * const forceClose = useForceClose();
+ * forceClose.mutate({ account: "0xsub…", quoteId: 42n });
+ * ```
+ */
+export declare function useForceClose(parameters?: UseForceCloseParameters): UseForceCloseReturnType;
+//# sourceMappingURL=use-force-close.d.ts.map

package/dist/quotes/use-force-close.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-force-close.d.ts","sourceRoot":"","sources":["../../src/quotes/use-force-close.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,wBAAwB,EAC9B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAA+B,KAAK,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE5F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAGzE,OAAO,EAAsB,KAAK,eAAe,EAAE,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAG7F,4CAA4C;AAC5C,MAAM,MAAM,uBAAuB,GAAG,eAAe,CAAC;AAEtD,6DAA6D;AAC7D,MAAM,MAAM,gBAAgB,GAAG,WAAW,CAAC;AAE3C,4CAA4C;AAC5C,MAAM,MAAM,uBAAuB,GAAG,iBAAiB,CAAC,gBAAgB,EAAE,kBAAkB,EAAE,wBAAwB,CAAC,CAAC;AAExH;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAAC,UAAU,GAAE,uBAA4B,GAAG,uBAAuB,CA6B/F"}

package/dist/quotes/use-force-close.js

@@ -0,0 +1,38 @@
+"use client";
+import { useSymmioChainId as e } from "../provider/use-symmio-chain-id.js";
+import { useSymmioConfig as t } from "../provider/use-symmio-config.js";
+import { normalizeSymmError as n } from "../errors/normalize-symm-error.js";
+import { resolveWriteResult as r } from "../transactions/resolve-write-result.js";
+import { predicateMatch as i } from "../utils/predicate-match.js";
+import { forceCloseAutoMutationOptions as a, getPartyAOpenPositionsQueryKey as o } from "@symmio/trading-core";
+import { useMutation as s, useQueryClient as c } from "@tanstack/react-query";
+//#region src/quotes/use-force-close.ts
+function l(l = {}) {
+	let u = t(l), d = e(), f = c(), p = a(u);
+	return s({
+		mutationKey: p.mutationKey,
+		mutationFn: async (e) => {
+			try {
+				let t = e.chainId ?? d;
+				return r(u, await p.mutationFn({
+					...e,
+					chainId: t
+				}), {
+					chainId: t,
+					waitForReceipt: l.waitForReceipt,
+					confirmations: l.confirmations
+				});
+			} catch (e) {
+				throw n(e);
+			}
+		},
+		onSuccess: (e, t) => {
+			let n = { partyA: t.account };
+			f.invalidateQueries({ predicate: i(o, n) });
+		}
+	});
+}
+//#endregion
+export { l as useForceClose };
+
+//# sourceMappingURL=use-force-close.js.map

package/dist/quotes/use-force-close.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-force-close.js","names":[],"sources":["../../src/quotes/use-force-close.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  forceCloseAutoMutationOptions,\n  getPartyAOpenPositionsQueryKey,\n  type ForceCloseAutoParameters,\n} from \"@symmio/trading-core\";\nimport { useMutation, useQueryClient, type UseMutationResult } from \"@tanstack/react-query\";\nimport { normalizeSymmError } from \"../errors/normalize-symm-error\";\nimport type { SymmioRequestError } from \"../errors/symmio-request-error\";\nimport { useSymmioChainId } from \"../provider/use-symmio-chain-id\";\nimport { useSymmioConfig } from \"../provider/use-symmio-config\";\nimport { resolveWriteResult, type WriteParameters, type WriteResult } from \"../transactions\";\nimport { predicateMatch } from \"../utils\";\n\n/** Parameters for {@link useForceClose}. */\nexport type UseForceCloseParameters = WriteParameters;\n\n/** Result returned by the {@link useForceClose} mutation. */\nexport type ForceCloseResult = WriteResult;\n\n/** Return type of {@link useForceClose}. */\nexport type UseForceCloseReturnType = UseMutationResult<ForceCloseResult, SymmioRequestError, ForceCloseAutoParameters>;\n\n/**\n * Force-close a stalled `CLOSE_PENDING` **limit** position end-to-end from just a\n * `quoteId` (`forceCloseAuto`): read the quote + force-close params, gate on\n * eligibility, find a price window from reference candles, fetch the Muon\n * `HighLowPriceSig`, preflight the gap, and send `forceClosePosition` through the\n * AccountLayer `_call` proxy. On success (after the receipt) the subaccount's\n * open-positions read is invalidated so the row updates.\n *\n * Throws (normalized) on ineligibility (`FORCE_CLOSE_NOT_ELIGIBLE`), the market\n * not having hit the price (`FORCE_CLOSE_PRICE_NOT_REACHED`), or a contract\n * revert. Gate the button first with {@link useForceCloseEligibility}.\n *\n * @example\n * ```tsx\n * const forceClose = useForceClose();\n * forceClose.mutate({ account: \"0xsub…\", quoteId: 42n });\n * ```\n */\nexport function useForceClose(parameters: UseForceCloseParameters = {}): UseForceCloseReturnType {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n  const queryClient = useQueryClient();\n\n  const base = forceCloseAutoMutationOptions(config);\n\n  return useMutation<ForceCloseResult, SymmioRequestError, ForceCloseAutoParameters>({\n    mutationKey: base.mutationKey,\n    mutationFn: async (variables) => {\n      try {\n        const resolvedChainId = variables.chainId ?? chainId;\n        const hash = await base.mutationFn({ ...variables, chainId: resolvedChainId });\n        return resolveWriteResult(config, hash, {\n          chainId: resolvedChainId,\n          waitForReceipt: parameters.waitForReceipt,\n          confirmations: parameters.confirmations,\n        });\n      } catch (err) {\n        throw normalizeSymmError(err);\n      }\n    },\n    onSuccess: (_result, variables) => {\n      // The force-close transitions the position — refetch the owning partyA's\n      // open positions so the status updates.\n      const partial = { partyA: variables.account };\n      void queryClient.invalidateQueries({ predicate: predicateMatch(getPartyAOpenPositionsQueryKey, partial) });\n    },\n  });\n}\n"],"mappings":";;;;;;;;;AA0CA,SAAgB,EAAc,IAAsC,CAAC,GAA4B;CAC/F,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAU,EAAiB,GAC3B,IAAc,EAAe,GAE7B,IAAO,EAA8B,CAAM;CAEjD,OAAO,EAA4E;EACjF,aAAa,EAAK;EAClB,YAAY,OAAO,MAAc;GAC/B,IAAI;IACF,IAAM,IAAkB,EAAU,WAAW;IAE7C,OAAO,EAAmB,GAAQ,MADf,EAAK,WAAW;KAAE,GAAG;KAAW,SAAS;IAAgB,CAAC,GACrC;KACtC,SAAS;KACT,gBAAgB,EAAW;KAC3B,eAAe,EAAW;IAC5B,CAAC;GACH,SAAS,GAAK;IACZ,MAAM,EAAmB,CAAG;GAC9B;EACF;EACA,YAAY,GAAS,MAAc;GAGjC,IAAM,IAAU,EAAE,QAAQ,EAAU,QAAQ;GAC5C,EAAiB,kBAAkB,EAAE,WAAW,EAAe,GAAgC,CAAO,EAAE,CAAC;EAC3G;CACF,CAAC;AACH"}

package/dist/quotes/use-grouped-quotes.d.ts

@@ -1,4 +1,5 @@
-import { GroupQuotesOptions, QuoteGroup, QuoteGroupingStrategy, UnifiedQuote } from '@symmio/trading-core';
+import { SubAccountIsolationType, GroupQuotesOptions, QuoteGroup, QuoteGroupingStrategy, UnifiedQuote } from '@symmio/trading-core';
+import { SymmioRequestError } from '../errors/symmio-request-error.js';
 import { UseManagedQuotesParameters, UseManagedQuotesResult } from './use-managed-quotes.js';
 /**
  * Parameters for {@link useGroupedQuotes}. Everything {@link useManagedQuotes}
@@ -6,10 +7,14 @@ import { UseManagedQuotesParameters, UseManagedQuotesResult } from './use-manage
  */
 export interface UseGroupedQuotesParameters extends UseManagedQuotesParameters {
     /**
-     * How to fold active positions into groups — a {@link SubAccountIsolationType}
-     * (the built-in strategies) or a custom `{ keyOf }`. Defaults to
-     * `MARKET_DIRECTION` (one group per market + side, the lowcap default).
+     * How to fold active positions into groups. The only
+     * {@link SubAccountIsolationType} accepted is `MARKET_DIRECTION` (one group per
+     * market + side), which is also the default — grouped positions are defined for
+     * that isolation alone. Passing any other isolation type throws
+     * `UNSUPPORTED_GROUPING_ISOLATION`; pass a custom `{ keyOf }` to fold on another
+     * dimension (`keyQuoteByMarket` / `keyQuotePerQuote` cover the common cases).
      *
+     * A custom `{ keyOf }` also opts out of the sub-account isolation check below.
      * Passing a fresh `{ keyOf }` object every render recomputes the groups every
      * render; memoize a custom strategy if that matters.
      */
@@ -19,13 +24,32 @@ export interface UseGroupedQuotesParameters extends UseManagedQuotesParameters {
 }
 /**
  * Value returned by {@link useGroupedQuotes} — the full {@link useManagedQuotes}
- * result, plus the grouped positions and the flat pending orders.
+ * result, plus the grouped positions, the flat pending orders, and the
+ * isolation check that decides whether grouping applies at all.
  */
 export interface UseGroupedQuotesResult extends UseManagedQuotesResult {
-    /** Active positions folded into {@link QuoteGroup}s under `strategy`, newest-first. */
+    /**
+     * Active positions folded into {@link QuoteGroup}s under `strategy`,
+     * newest-first. Always empty while {@link isGroupingSupported} is `false`.
+     */
     groups: QuoteGroup[];
     /** Resting/pending limit orders, kept flat (never grouped). */
     pending: UnifiedQuote[];
+    /**
+     * Isolation type of the sub-account owning `partyA` (resolved through the
+     * Virtual Account's parent when `partyA` is a VA). `undefined` while the read
+     * is in flight, when `partyA` is neither a sub-account nor a VA, and when a
+     * custom `{ keyOf }` strategy skipped the lookup.
+     */
+    isolationType?: SubAccountIsolationType;
+    /**
+     * `false` only when the owning sub-account's isolation is **known** and is not
+     * `MARKET_DIRECTION`. `true` while the isolation is unresolved, so a consumer
+     * gating on it never flashes an error state during the read.
+     */
+    isGroupingSupported: boolean;
+    /** The rejection behind `isGroupingSupported: false`; `null` otherwise. */
+    groupingError: SymmioRequestError | null;
 }
 /**
  * Managed quotes for one sub-account, folded into grouped positions.
@@ -36,19 +60,35 @@ export interface UseGroupedQuotesResult extends UseManagedQuotesResult {
  * Pending limit orders are returned flat in `pending` — the grouped-positions vs
  * open-orders split. The full flat list stays available on `quotes`.
  *
+ * **Grouping is a `MARKET_DIRECTION`-only feature.** It is the one isolation
+ * where a market + side cohort is a real on-chain unit (the AccountLayer
+ * allocates one Virtual Account per market + direction), so folding that cohort
+ * into a single row aggregates values that belong together — and group-level
+ * actions (group close, group TP/SL) act on quotes that really share a VA. This
+ * hook therefore resolves the isolation of the sub-account owning `partyA`
+ * (walking up from a Virtual Account to its parent when needed) and, when that
+ * isolation is anything else, returns **no groups** together with
+ * `isGroupingSupported: false` and a `groupingError` instead of silently folding
+ * unrelated positions. `quotes` and `pending` are untouched, so a consumer can
+ * still render flat rows for those accounts. The lookup is skipped for a custom
+ * `{ keyOf }` strategy — that caller has opted out of isolation-based grouping.
+ *
  * All grouping is pure and runs in a `useMemo`, so the heavy work is the
  * underlying reads, not the fold.
  *
  * @param parameters - Managed-quotes parameters plus `strategy` / `groupSort`.
- * @returns The managed-quotes result extended with `groups` and `pending`.
+ * @returns The managed-quotes result extended with `groups`, `pending`, and the isolation check.
+ * @throws {SymmError} `UNSUPPORTED_GROUPING_ISOLATION` when `strategy` is an
+ *   isolation type other than `MARKET_DIRECTION`.
  *
  * @example
  * ```tsx
- * const { groups, pending, isLoading } = useGroupedQuotes({ partyA });
+ * const { groups, pending, isGroupingSupported, groupingError } = useGroupedQuotes({ partyA });
+ * if (!isGroupingSupported) return <FlatPositions rows={pending} note={groupingError?.message} />;
  * // groups[0].metrics.openQuantity, groups[0].metrics.weightedOpenPrice, …
  *
- * // group by market instead of market + side:
- * useGroupedQuotes({ partyA, strategy: SubAccountIsolationType.MARKET });
+ * // fold on another dimension — opts out of the isolation check:
+ * useGroupedQuotes({ partyA, strategy: { keyOf: keyQuoteByMarket } });
  * ```
  */
 export declare function useGroupedQuotes(parameters: UseGroupedQuotesParameters): UseGroupedQuotesResult;

package/dist/quotes/use-grouped-quotes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-grouped-quotes.d.ts","sourceRoot":"","sources":["../../src/quotes/use-grouped-quotes.ts"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,kBAAkB,EACvB,KAAK,UAAU,EACf,KAAK,qBAAqB,EAC1B,KAAK,YAAY,EAClB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAoB,KAAK,0BAA0B,EAAE,KAAK,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAEtH;;;GAGG;AACH,MAAM,WAAW,0BAA2B,SAAQ,0BAA0B;IAC5E;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,qBAAqB,CAAC;IACjC,0FAA0F;IAC1F,SAAS,CAAC,EAAE,kBAAkB,CAAC,MAAM,CAAC,CAAC;CACxC;AAED;;;GAGG;AACH,MAAM,WAAW,sBAAuB,SAAQ,sBAAsB;IACpE,uFAAuF;IACvF,MAAM,EAAE,UAAU,EAAE,CAAC;IACrB,+DAA+D;IAC/D,OAAO,EAAE,YAAY,EAAE,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,0BAA0B,GAAG,sBAAsB,CAW/F"}
+{"version":3,"file":"use-grouped-quotes.d.ts","sourceRoot":"","sources":["../../src/quotes/use-grouped-quotes.ts"],"names":[],"mappings":"AAEA,OAAO,EAIL,uBAAuB,EAEvB,KAAK,kBAAkB,EACvB,KAAK,UAAU,EACf,KAAK,qBAAqB,EAC1B,KAAK,YAAY,EAClB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAEzE,OAAO,EAAoB,KAAK,0BAA0B,EAAE,KAAK,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAKtH;;;GAGG;AACH,MAAM,WAAW,0BAA2B,SAAQ,0BAA0B;IAC5E;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,EAAE,qBAAqB,CAAC;IACjC,0FAA0F;IAC1F,SAAS,CAAC,EAAE,kBAAkB,CAAC,MAAM,CAAC,CAAC;CACxC;AAED;;;;GAIG;AACH,MAAM,WAAW,sBAAuB,SAAQ,sBAAsB;IACpE;;;OAGG;IACH,MAAM,EAAE,UAAU,EAAE,CAAC;IACrB,+DAA+D;IAC/D,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,uBAAuB,CAAC;IACxC;;;;OAIG;IACH,mBAAmB,EAAE,OAAO,CAAC;IAC7B,2EAA2E;IAC3E,aAAa,EAAE,kBAAkB,GAAG,IAAI,CAAC;CAC1C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,0BAA0B,GAAG,sBAAsB,CAwD/F"}

package/dist/quotes/use-grouped-quotes.js

@@ -1,21 +1,47 @@
 "use client";
-import { useManagedQuotes as e } from "./use-managed-quotes.js";
-import { SubAccountIsolationType as t, groupQuotes as n, partitionQuotes as r } from "@symmio/trading-core";
-import { useMemo as i } from "react";
+import { normalizeSymmError as e } from "../errors/normalize-symm-error.js";
+import { useManagedQuotes as t } from "./use-managed-quotes.js";
+import { useGroupingIsolation as n } from "./use-grouping-isolation.js";
+import { SubAccountIsolationType as r, assertQuoteGroupingSupported as i, groupQuotes as a, partitionQuotes as o, supportsQuoteGrouping as s } from "@symmio/trading-core";
+import { useEffect as c, useMemo as l, useRef as u } from "react";
 //#region src/quotes/use-grouped-quotes.ts
-function a(a) {
-	let { strategy: o = t.MARKET_DIRECTION, groupSort: s, ...c } = a, l = e(c), { positions: u, pending: d } = i(() => r(l.quotes), [l.quotes]), f = i(() => n(u, o, s ? { sort: s } : void 0), [
-		u,
-		o,
-		s
-	]);
-	return {
-		...l,
-		groups: f,
-		pending: d
+var d = [];
+function f(f) {
+	let { strategy: p = r.MARKET_DIRECTION, groupSort: m, ...h } = f, g = t(h), _ = typeof p != "object", v = n({
+		account: f.partyA,
+		chainId: f.chainId,
+		enabled: _ && (f.enabled ?? !0)
+	}), y = !_ || v === void 0 || s(v), b = l(() => {
+		if (v === void 0 || y) return null;
+		try {
+			return i(v), null;
+		} catch (t) {
+			return e(t);
+		}
+	}, [v, y]), { positions: x, pending: S } = l(() => o(g.quotes), [g.quotes]), C = l(() => (typeof p != "object" && i(p), y ? a(x, p, m ? { sort: m } : void 0) : d), [
+		x,
+		p,
+		m,
+		y
+	]), w = u(void 0);
+	return c(() => {
+		if (!b || process.env.NODE_ENV === "production") return;
+		let e = `${f.partyA}:${v}`;
+		w.current !== e && (w.current = e, console.warn(`[useGroupedQuotes] ${b.message} No groups are returned; read \`quotes\` instead.`));
+	}, [
+		b,
+		v,
+		f.partyA
+	]), {
+		...g,
+		groups: C,
+		pending: S,
+		isolationType: v,
+		isGroupingSupported: y,
+		groupingError: b
 	};
 }
 //#endregion
-export { a as useGroupedQuotes };
+export { f as useGroupedQuotes };
 
 //# sourceMappingURL=use-grouped-quotes.js.map

package/dist/quotes/use-grouped-quotes.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-grouped-quotes.js","names":[],"sources":["../../src/quotes/use-grouped-quotes.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  groupQuotes,\n  partitionQuotes,\n  SubAccountIsolationType,\n  type GroupQuotesOptions,\n  type QuoteGroup,\n  type QuoteGroupingStrategy,\n  type UnifiedQuote,\n} from \"@symmio/trading-core\";\nimport { useMemo } from \"react\";\nimport { useManagedQuotes, type UseManagedQuotesParameters, type UseManagedQuotesResult } from \"./use-managed-quotes\";\n\n/**\n * Parameters for {@link useGroupedQuotes}. Everything {@link useManagedQuotes}\n * accepts, plus how to fold the resulting positions into groups.\n */\nexport interface UseGroupedQuotesParameters extends UseManagedQuotesParameters {\n  /**\n   * How to fold active positions into groups — a {@link SubAccountIsolationType}\n   * (the built-in strategies) or a custom `{ keyOf }`. Defaults to\n   * `MARKET_DIRECTION` (one group per market + side, the lowcap default).\n   *\n   * Passing a fresh `{ keyOf }` object every render recomputes the groups every\n   * render; memoize a custom strategy if that matters.\n   */\n  strategy?: QuoteGroupingStrategy;\n  /** Optional group-ordering override forwarded to `groupQuotes` (default newest-first). */\n  groupSort?: GroupQuotesOptions[\"sort\"];\n}\n\n/**\n * Value returned by {@link useGroupedQuotes} — the full {@link useManagedQuotes}\n * result, plus the grouped positions and the flat pending orders.\n */\nexport interface UseGroupedQuotesResult extends UseManagedQuotesResult {\n  /** Active positions folded into {@link QuoteGroup}s under `strategy`, newest-first. */\n  groups: QuoteGroup[];\n  /** Resting/pending limit orders, kept flat (never grouped). */\n  pending: UnifiedQuote[];\n}\n\n/**\n * Managed quotes for one sub-account, folded into grouped positions.\n *\n * Reads every quote source via {@link useManagedQuotes}, splits the merged list\n * into active positions and pending orders (`partitionQuotes`), then folds the\n * positions into {@link QuoteGroup}s under the chosen `strategy` (`groupQuotes`).\n * Pending limit orders are returned flat in `pending` — the grouped-positions vs\n * open-orders split. The full flat list stays available on `quotes`.\n *\n * All grouping is pure and runs in a `useMemo`, so the heavy work is the\n * underlying reads, not the fold.\n *\n * @param parameters - Managed-quotes parameters plus `strategy` / `groupSort`.\n * @returns The managed-quotes result extended with `groups` and `pending`.\n *\n * @example\n * ```tsx\n * const { groups, pending, isLoading } = useGroupedQuotes({ partyA });\n * // groups[0].metrics.openQuantity, groups[0].metrics.weightedOpenPrice, …\n *\n * // group by market instead of market + side:\n * useGroupedQuotes({ partyA, strategy: SubAccountIsolationType.MARKET });\n * ```\n */\nexport function useGroupedQuotes(parameters: UseGroupedQuotesParameters): UseGroupedQuotesResult {\n  const { strategy = SubAccountIsolationType.MARKET_DIRECTION, groupSort, ...managedParameters } = parameters;\n  const managed = useManagedQuotes(managedParameters);\n\n  const { positions, pending } = useMemo(() => partitionQuotes(managed.quotes), [managed.quotes]);\n  const groups = useMemo(\n    () => groupQuotes(positions, strategy, groupSort ? { sort: groupSort } : undefined),\n    [positions, strategy, groupSort],\n  );\n\n  return { ...managed, groups, pending };\n}\n"],"mappings":";;;;;AAmEA,SAAgB,EAAiB,GAAgE;CAC/F,IAAM,EAAE,cAAW,EAAwB,kBAAkB,cAAW,GAAG,MAAsB,GAC3F,IAAU,EAAiB,CAAiB,GAE5C,EAAE,cAAW,eAAY,QAAc,EAAgB,EAAQ,MAAM,GAAG,CAAC,EAAQ,MAAM,CAAC,GACxF,IAAS,QACP,EAAY,GAAW,GAAU,IAAY,EAAE,MAAM,EAAU,IAAI,KAAA,CAAS,GAClF;EAAC;EAAW;EAAU;CAAS,CACjC;CAEA,OAAO;EAAE,GAAG;EAAS;EAAQ;CAAQ;AACvC"}
+{"version":3,"file":"use-grouped-quotes.js","names":[],"sources":["../../src/quotes/use-grouped-quotes.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  assertQuoteGroupingSupported,\n  groupQuotes,\n  partitionQuotes,\n  SubAccountIsolationType,\n  supportsQuoteGrouping,\n  type GroupQuotesOptions,\n  type QuoteGroup,\n  type QuoteGroupingStrategy,\n  type UnifiedQuote,\n} from \"@symmio/trading-core\";\nimport { useEffect, useMemo, useRef } from \"react\";\nimport { normalizeSymmError } from \"../errors/normalize-symm-error\";\nimport type { SymmioRequestError } from \"../errors/symmio-request-error\";\nimport { useGroupingIsolation } from \"./use-grouping-isolation\";\nimport { useManagedQuotes, type UseManagedQuotesParameters, type UseManagedQuotesResult } from \"./use-managed-quotes\";\n\n/** Stable empty result for the guarded case, so `groups` keeps its identity across renders. */\nconst NO_GROUPS: QuoteGroup[] = [];\n\n/**\n * Parameters for {@link useGroupedQuotes}. Everything {@link useManagedQuotes}\n * accepts, plus how to fold the resulting positions into groups.\n */\nexport interface UseGroupedQuotesParameters extends UseManagedQuotesParameters {\n  /**\n   * How to fold active positions into groups. The only\n   * {@link SubAccountIsolationType} accepted is `MARKET_DIRECTION` (one group per\n   * market + side), which is also the default — grouped positions are defined for\n   * that isolation alone. Passing any other isolation type throws\n   * `UNSUPPORTED_GROUPING_ISOLATION`; pass a custom `{ keyOf }` to fold on another\n   * dimension (`keyQuoteByMarket` / `keyQuotePerQuote` cover the common cases).\n   *\n   * A custom `{ keyOf }` also opts out of the sub-account isolation check below.\n   * Passing a fresh `{ keyOf }` object every render recomputes the groups every\n   * render; memoize a custom strategy if that matters.\n   */\n  strategy?: QuoteGroupingStrategy;\n  /** Optional group-ordering override forwarded to `groupQuotes` (default newest-first). */\n  groupSort?: GroupQuotesOptions[\"sort\"];\n}\n\n/**\n * Value returned by {@link useGroupedQuotes} — the full {@link useManagedQuotes}\n * result, plus the grouped positions, the flat pending orders, and the\n * isolation check that decides whether grouping applies at all.\n */\nexport interface UseGroupedQuotesResult extends UseManagedQuotesResult {\n  /**\n   * Active positions folded into {@link QuoteGroup}s under `strategy`,\n   * newest-first. Always empty while {@link isGroupingSupported} is `false`.\n   */\n  groups: QuoteGroup[];\n  /** Resting/pending limit orders, kept flat (never grouped). */\n  pending: UnifiedQuote[];\n  /**\n   * Isolation type of the sub-account owning `partyA` (resolved through the\n   * Virtual Account's parent when `partyA` is a VA). `undefined` while the read\n   * is in flight, when `partyA` is neither a sub-account nor a VA, and when a\n   * custom `{ keyOf }` strategy skipped the lookup.\n   */\n  isolationType?: SubAccountIsolationType;\n  /**\n   * `false` only when the owning sub-account's isolation is **known** and is not\n   * `MARKET_DIRECTION`. `true` while the isolation is unresolved, so a consumer\n   * gating on it never flashes an error state during the read.\n   */\n  isGroupingSupported: boolean;\n  /** The rejection behind `isGroupingSupported: false`; `null` otherwise. */\n  groupingError: SymmioRequestError | null;\n}\n\n/**\n * Managed quotes for one sub-account, folded into grouped positions.\n *\n * Reads every quote source via {@link useManagedQuotes}, splits the merged list\n * into active positions and pending orders (`partitionQuotes`), then folds the\n * positions into {@link QuoteGroup}s under the chosen `strategy` (`groupQuotes`).\n * Pending limit orders are returned flat in `pending` — the grouped-positions vs\n * open-orders split. The full flat list stays available on `quotes`.\n *\n * **Grouping is a `MARKET_DIRECTION`-only feature.** It is the one isolation\n * where a market + side cohort is a real on-chain unit (the AccountLayer\n * allocates one Virtual Account per market + direction), so folding that cohort\n * into a single row aggregates values that belong together — and group-level\n * actions (group close, group TP/SL) act on quotes that really share a VA. This\n * hook therefore resolves the isolation of the sub-account owning `partyA`\n * (walking up from a Virtual Account to its parent when needed) and, when that\n * isolation is anything else, returns **no groups** together with\n * `isGroupingSupported: false` and a `groupingError` instead of silently folding\n * unrelated positions. `quotes` and `pending` are untouched, so a consumer can\n * still render flat rows for those accounts. The lookup is skipped for a custom\n * `{ keyOf }` strategy — that caller has opted out of isolation-based grouping.\n *\n * All grouping is pure and runs in a `useMemo`, so the heavy work is the\n * underlying reads, not the fold.\n *\n * @param parameters - Managed-quotes parameters plus `strategy` / `groupSort`.\n * @returns The managed-quotes result extended with `groups`, `pending`, and the isolation check.\n * @throws {SymmError} `UNSUPPORTED_GROUPING_ISOLATION` when `strategy` is an\n *   isolation type other than `MARKET_DIRECTION`.\n *\n * @example\n * ```tsx\n * const { groups, pending, isGroupingSupported, groupingError } = useGroupedQuotes({ partyA });\n * if (!isGroupingSupported) return <FlatPositions rows={pending} note={groupingError?.message} />;\n * // groups[0].metrics.openQuantity, groups[0].metrics.weightedOpenPrice, …\n *\n * // fold on another dimension — opts out of the isolation check:\n * useGroupedQuotes({ partyA, strategy: { keyOf: keyQuoteByMarket } });\n * ```\n */\nexport function useGroupedQuotes(parameters: UseGroupedQuotesParameters): UseGroupedQuotesResult {\n  const { strategy = SubAccountIsolationType.MARKET_DIRECTION, groupSort, ...managedParameters } = parameters;\n  const managed = useManagedQuotes(managedParameters);\n\n  /**\n   * The sub-account check only applies to isolation-backed grouping; a custom\n   * `{ keyOf }` groups on the consumer's own dimension, so no on-chain isolation\n   * can contradict it and no read is worth firing.\n   */\n  const isIsolationStrategy = typeof strategy !== \"object\";\n  const isolationType = useGroupingIsolation({\n    account: parameters.partyA,\n    chainId: parameters.chainId,\n    enabled: isIsolationStrategy && (parameters.enabled ?? true),\n  });\n\n  /**\n   * Unresolved isolation reads as supported — never flash a failure while loading.\n   * A custom `{ keyOf }` strategy opted out of the isolation gate entirely, so it\n   * is always supported regardless of any isolation the lookup might surface.\n   */\n  const isGroupingSupported =\n    !isIsolationStrategy || isolationType === undefined || supportsQuoteGrouping(isolationType);\n\n  const groupingError = useMemo<SymmioRequestError | null>(() => {\n    if (isolationType === undefined || isGroupingSupported) return null;\n    try {\n      assertQuoteGroupingSupported(isolationType);\n      return null;\n    } catch (err) {\n      return normalizeSymmError(err);\n    }\n  }, [isolationType, isGroupingSupported]);\n\n  const { positions, pending } = useMemo(() => partitionQuotes(managed.quotes), [managed.quotes]);\n  const groups = useMemo(() => {\n    /** An unsupported `strategy` is a caller bug — throw even when the guard already blanked the groups. */\n    if (typeof strategy !== \"object\") assertQuoteGroupingSupported(strategy);\n    if (!isGroupingSupported) return NO_GROUPS;\n    return groupQuotes(positions, strategy, groupSort ? { sort: groupSort } : undefined);\n  }, [positions, strategy, groupSort, isGroupingSupported]);\n\n  /**\n   * Blanked groups are easy to misread as \"no positions\", so say why once per\n   * account — in development only, and keyed so a re-render never re-logs.\n   */\n  const warnedRef = useRef<string | undefined>(undefined);\n  useEffect(() => {\n    if (!groupingError || process.env.NODE_ENV === \"production\") return;\n    const key = `${parameters.partyA}:${isolationType}`;\n    if (warnedRef.current === key) return;\n    warnedRef.current = key;\n    console.warn(`[useGroupedQuotes] ${groupingError.message} No groups are returned; read \\`quotes\\` instead.`);\n  }, [groupingError, isolationType, parameters.partyA]);\n\n  return { ...managed, groups, pending, isolationType, isGroupingSupported, groupingError };\n}\n"],"mappings":";;;;;;;AAoBA,IAAM,IAA0B,CAAC;AA8FjC,SAAgB,EAAiB,GAAgE;CAC/F,IAAM,EAAE,cAAW,EAAwB,kBAAkB,cAAW,GAAG,MAAsB,GAC3F,IAAU,EAAiB,CAAiB,GAO5C,IAAsB,OAAO,KAAa,UAC1C,IAAgB,EAAqB;EACzC,SAAS,EAAW;EACpB,SAAS,EAAW;EACpB,SAAS,MAAwB,EAAW,WAAW;CACzD,CAAC,GAOK,IACJ,CAAC,KAAuB,MAAkB,KAAA,KAAa,EAAsB,CAAa,GAEtF,IAAgB,QAAyC;EAC7D,IAAI,MAAkB,KAAA,KAAa,GAAqB,OAAO;EAC/D,IAAI;GAEF,OADA,EAA6B,CAAa,GACnC;EACT,SAAS,GAAK;GACZ,OAAO,EAAmB,CAAG;EAC/B;CACF,GAAG,CAAC,GAAe,CAAmB,CAAC,GAEjC,EAAE,cAAW,eAAY,QAAc,EAAgB,EAAQ,MAAM,GAAG,CAAC,EAAQ,MAAM,CAAC,GACxF,IAAS,SAET,OAAO,KAAa,YAAU,EAA6B,CAAQ,GAClE,IACE,EAAY,GAAW,GAAU,IAAY,EAAE,MAAM,EAAU,IAAI,KAAA,CAAS,IADlD,IAEhC;EAAC;EAAW;EAAU;EAAW;CAAmB,CAAC,GAMlD,IAAY,EAA2B,KAAA,CAAS;CAStD,OARA,QAAgB;EACd,IAAI,CAAC,KAAA,QAAA,IAAA,aAA0C,cAAc;EAC7D,IAAM,IAAM,GAAG,EAAW,OAAO,GAAG;EAChC,EAAU,YAAY,MAC1B,EAAU,UAAU,GACpB,QAAQ,KAAK,sBAAsB,EAAc,QAAQ,kDAAkD;CAC7G,GAAG;EAAC;EAAe;EAAe,EAAW;CAAM,CAAC,GAE7C;EAAE,GAAG;EAAS;EAAQ;EAAS;EAAe;EAAqB;CAAc;AAC1F"}