@openmarketsai/order-sheet 0.1.0

package/dist/react.cjs

@@ -0,0 +1,2137 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react.tsx
+var react_exports = {};
+__export(react_exports, {
+  CLIENT_CODE_SPECS: () => CLIENT_CODE_SPECS,
+  CONSTRAINTS_VERSION: () => CONSTRAINTS_VERSION,
+  DEFAULT_API_BASE: () => DEFAULT_API_BASE,
+  ISSUE_CODES: () => ISSUE_CODES,
+  ISSUE_DEFAULT_FIX: () => ISSUE_DEFAULT_FIX,
+  ISSUE_FIXES: () => ISSUE_FIXES,
+  ISSUE_SEVERITY: () => ISSUE_SEVERITY,
+  ODDS_FORMATS: () => ODDS_FORMATS,
+  OrderSheet: () => OrderSheet,
+  OrderSheetError: () => OrderSheetError,
+  OrderSheetProvider: () => OrderSheetProvider,
+  REQUEST_ERROR_CODES: () => REQUEST_ERROR_CODES,
+  REQUEST_ERROR_MESSAGES: () => REQUEST_ERROR_MESSAGES,
+  SERVER_CODE_MESSAGES: () => SERVER_CODE_MESSAGES,
+  buildQuote: () => buildQuote,
+  buildVenueOptions: () => buildVenueOptions,
+  contractsFromAmount: () => contractsFromAmount,
+  createInertSheet: () => createInertSheet,
+  createOrderSheetClient: () => createOrderSheetClient,
+  createOrderStream: () => createOrderStream,
+  createSheet: () => createSheet,
+  credentialSupportsStream: () => credentialSupportsStream,
+  floorToIncrement: () => floorToIncrement,
+  formatMoney: () => formatMoney,
+  formatPrice: () => formatPrice,
+  fromServerIssue: () => fromServerIssue,
+  initialSheetState: () => initialSheetState,
+  isOnGrid: () => isOnGrid,
+  isOrderSheetError: () => isOrderSheetError,
+  isSheet: () => isSheet,
+  localIssue: () => localIssue,
+  newIdempotencyKey: () => newIdempotencyKey,
+  phaseFromOrders: () => phaseFromOrders,
+  phaseFromSummary: () => phaseFromSummary,
+  resolveMaxPrice: () => resolveMaxPrice,
+  resolveOptions: () => resolveOptions,
+  round: () => round,
+  snapPrice: () => snapPrice,
+  summarize: () => summarize,
+  tabbableVenueId: () => tabbableVenueId,
+  toAmerican: () => toAmerican,
+  toDecimal: () => toDecimal,
+  toPlaceResult: () => toPlaceResult,
+  useOrderSheet: () => useOrderSheet,
+  useOrderSheetAccount: () => useOrderSheetAccount,
+  useOrderSheetClient: () => useOrderSheetClient,
+  useOrderSheetHandle: () => useOrderSheetHandle,
+  useSheetState: () => useSheetState,
+  userMessageFor: () => userMessageFor,
+  validateSheet: () => validateSheet,
+  venueKeyTarget: () => venueKeyTarget
+});
+module.exports = __toCommonJS(react_exports);
+var import_react = require("react");
+
+// src/generated/contract.ts
+var CONSTRAINTS_VERSION = "2026-09-29.1";
+var ISSUE_CODES = [
+  "real_money_not_permitted",
+  "practice_not_permitted",
+  "test_mode_requires_paper",
+  "venue_disabled",
+  "orders_not_supported",
+  "scope_not_granted",
+  "execution_limit_exceeded",
+  "insufficient_balance",
+  "venue_shard_underfunded",
+  "below_min_order",
+  "above_max_order",
+  "unfillable",
+  "below_min_contracts",
+  "amount_off_increment",
+  "price_out_of_band",
+  "above_max_price",
+  "price_off_tick",
+  "insufficient_size",
+  "insufficient_live_depth",
+  "no_viable_venues",
+  "no_live_price_for_paper",
+  "invalid_requested_amount",
+  "halted_upstream",
+  "unknown"
+];
+var ISSUE_FIXES = [
+  "raise_price",
+  "lower_price",
+  "raise_stake",
+  "lower_stake",
+  "round_stake",
+  "connect_venue",
+  "fund_venue",
+  "switch_venue",
+  "switch_to_paper",
+  "switch_to_real",
+  "use_market",
+  "use_limit",
+  "grant_scope",
+  "upgrade_plan",
+  "retry",
+  "none"
+];
+var REQUEST_ERROR_CODES = [
+  "missing_credentials",
+  "invalid_api_key",
+  "invalid_jwt",
+  "auth_error",
+  "not_authenticated",
+  "rate_limit_exceeded",
+  "account_forbidden",
+  "scope_not_granted",
+  "idempotency_error",
+  "account_scope_required",
+  "account_not_found",
+  "environment_unresolved",
+  "execution_key_required",
+  "entitlement_required",
+  "bad_request",
+  "unknown_parameter",
+  "conflicting_parameters",
+  "unsupported_order_type",
+  "test_mode_requires_paper",
+  "real_money_not_permitted",
+  "connect_scope_required",
+  "model_not_found",
+  "model_archived",
+  "opportunity_not_found",
+  "currency_mismatch",
+  "model_mismatch",
+  "idempotency_conflict",
+  "internal_error"
+];
+var REQUEST_ERROR_MESSAGES = {
+  missing_credentials: "Sign in to place orders.",
+  invalid_api_key: "This app's access key isn't valid any more.",
+  invalid_jwt: "Your session has expired \u2014 sign in again.",
+  auth_error: "We couldn't check your sign-in. Try again.",
+  not_authenticated: "Sign in to place orders.",
+  rate_limit_exceeded: "Too many requests \u2014 wait a moment and try again.",
+  account_forbidden: "This app can't act for that account.",
+  scope_not_granted: "This app hasn't been allowed to place orders.",
+  idempotency_error: "The order couldn't be submitted safely. Try again.",
+  account_scope_required: "This sign-in isn't linked to a trading account.",
+  account_not_found: "That trading account no longer exists.",
+  environment_unresolved: "We couldn't tell whether this is a test or live key.",
+  execution_key_required: "This app's key can read markets but not trade.",
+  entitlement_required: "Trading isn't included in this plan.",
+  bad_request: "Something in this order wasn't valid.",
+  unknown_parameter: "Something in this order wasn't valid.",
+  conflicting_parameters: "Something in this order wasn't valid.",
+  unsupported_order_type: "That venue doesn't take this type of order.",
+  test_mode_requires_paper: "This is a test key \u2014 it can only place practice orders.",
+  real_money_not_permitted: "Real-money trading is not included in this plan.",
+  connect_scope_required: "This account hasn't allowed this app to trade.",
+  model_not_found: "That model doesn't exist.",
+  model_archived: "That model is archived and takes no new orders.",
+  opportunity_not_found: "That order group doesn't exist.",
+  currency_mismatch: "Those orders use different currencies.",
+  model_mismatch: "That order group belongs to a different model.",
+  idempotency_conflict: "This order was already submitted with different details.",
+  internal_error: "Something went wrong on our side. Try again."
+};
+var ISSUE_SEVERITY = {
+  real_money_not_permitted: "block",
+  practice_not_permitted: "block",
+  test_mode_requires_paper: "block",
+  venue_disabled: "block",
+  orders_not_supported: "block",
+  scope_not_granted: "block",
+  execution_limit_exceeded: "block",
+  insufficient_balance: "block",
+  venue_shard_underfunded: "block",
+  below_min_order: "block",
+  above_max_order: "block",
+  unfillable: "block",
+  below_min_contracts: "block",
+  amount_off_increment: "warn",
+  price_out_of_band: "block",
+  above_max_price: "block",
+  price_off_tick: "warn",
+  insufficient_size: "block",
+  insufficient_live_depth: "block",
+  no_viable_venues: "block",
+  no_live_price_for_paper: "block",
+  invalid_requested_amount: "block",
+  halted_upstream: "info",
+  unknown: "block"
+};
+var ISSUE_DEFAULT_FIX = {
+  real_money_not_permitted: "upgrade_plan",
+  practice_not_permitted: "none",
+  test_mode_requires_paper: "switch_to_paper",
+  venue_disabled: "connect_venue",
+  orders_not_supported: "switch_venue",
+  scope_not_granted: "grant_scope",
+  execution_limit_exceeded: "none",
+  insufficient_balance: "fund_venue",
+  venue_shard_underfunded: "fund_venue",
+  below_min_order: "raise_stake",
+  above_max_order: "lower_stake",
+  unfillable: "raise_stake",
+  below_min_contracts: "raise_stake",
+  amount_off_increment: "round_stake",
+  price_out_of_band: "lower_price",
+  above_max_price: "raise_price",
+  price_off_tick: "none",
+  insufficient_size: "lower_stake",
+  insufficient_live_depth: "switch_venue",
+  no_viable_venues: "switch_venue",
+  no_live_price_for_paper: "switch_venue",
+  invalid_requested_amount: "raise_stake",
+  halted_upstream: "none",
+  unknown: "retry"
+};
+
+// src/errors.ts
+var OrderSheetError = class extends Error {
+  constructor(init) {
+    super(init.message);
+    this.name = "OrderSheetError";
+    this.code = init.code;
+    this.status = init.status ?? null;
+    this.details = init.details ?? null;
+    this.retryable = init.retryable ?? false;
+    if (init.cause !== void 0) this.cause = init.cause;
+  }
+};
+function isOrderSheetError(e) {
+  return e instanceof OrderSheetError || typeof e === "object" && e !== null && e.name === "OrderSheetError";
+}
+function userMessageFor(e) {
+  const known = REQUEST_ERROR_MESSAGES[e.code];
+  if (known) return known;
+  if (e.code === "real_money_disabled") return "Real-money orders are turned off in this app.";
+  if (e.code === "network_error" || e.status === null) return "Couldn't reach OpenMarkets. Check your connection and try again.";
+  if (e.retryable) return "Something went wrong on our side. Try again.";
+  return "This order couldn't be submitted.";
+}
+
+// src/auth.ts
+async function resolveCredential(opts) {
+  if ("apiKey" in opts && opts.apiKey) {
+    return { kind: "api_key", value: opts.apiKey, headers: { "X-API-Key": opts.apiKey } };
+  }
+  if ("auth" in opts && opts.auth) {
+    const key = await opts.auth.getApiKey();
+    if (!key) throw new OrderSheetError({ code: "no_credential", message: "Not signed in to OpenMarkets \u2014 no API key is available for this request." });
+    return { kind: "api_key", value: key, headers: { "X-API-Key": key } };
+  }
+  if ("getToken" in opts && opts.getToken) {
+    const token = await opts.getToken();
+    if (!token) throw new OrderSheetError({ code: "no_credential", message: "No session token is available for this request." });
+    return { kind: "jwt", value: token, headers: { Authorization: `Bearer ${token}` } };
+  }
+  throw new OrderSheetError({ code: "not_configured", message: "createOrderSheetClient needs one of { apiKey }, { getToken } or { auth }." });
+}
+function credentialSupportsStream(opts) {
+  return "apiKey" in opts && !!opts.apiKey || "auth" in opts && !!opts.auth;
+}
+
+// src/odds.ts
+var ODDS_FORMATS = ["cents", "percent", "american", "decimal"];
+function toAmerican(p) {
+  if (!(p > 0 && p < 1)) return "\u2014";
+  const v = p >= 0.5 ? -Math.round(100 * p / (1 - p)) : Math.round(100 * (1 - p) / p);
+  return v > 0 ? `+${v}` : `${v}`;
+}
+function toDecimal(p) {
+  if (!(p > 0 && p < 1)) return "\u2014";
+  return (1 / p).toFixed(2);
+}
+function formatPrice(p, format, american) {
+  if (p == null || !Number.isFinite(p) || p <= 0) return "\u2014";
+  switch (format) {
+    case "cents":
+      return `${Math.round(p * 100)}\xA2`;
+    case "percent":
+      return `${Math.round(p * 100)}%`;
+    case "american":
+      return american ?? toAmerican(p);
+    case "decimal":
+      return toDecimal(p);
+  }
+}
+function formatMoney(n, currency = "USD") {
+  if (n == null || !Number.isFinite(n)) return "\u2014";
+  const abs = Math.abs(n);
+  const body = abs.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+  const sign = n < 0 ? "\u2212" : "";
+  if (currency === "USD") return `${sign}$${body}`;
+  return `${sign}${body} ${currency}`;
+}
+
+// src/messages.ts
+var usd = (n, currency = "USD", fallback = "the stake") => typeof n === "number" && Number.isFinite(n) ? formatMoney(n, currency) : fallback;
+var cents = (p, fallback = "this price") => typeof p === "number" && Number.isFinite(p) ? `${Math.round(p * 100)}\xA2` : fallback;
+var venue = (ctx) => ctx.venue ?? "this venue";
+var plural = (n, one, many) => n === 1 ? one : many;
+var SERVER_CODE_MESSAGES = {
+  real_money_not_permitted: () => "Real-money trading is not included in this plan.",
+  practice_not_permitted: () => "Practice trading is not available with this credential.",
+  test_mode_requires_paper: () => "This is a test key \u2014 it can only place practice orders.",
+  venue_disabled: (c) => `${venue(c)} isn't connected on this account.`,
+  orders_not_supported: (c) => `${venue(c)} is quotes-only \u2014 it doesn't take orders.`,
+  scope_not_granted: (c) => `This account hasn't allowed trading on ${venue(c)}.`,
+  execution_limit_exceeded: (c) => c.detail ? `Blocked by your trading limits: ${c.detail}.` : "Blocked by your trading limits.",
+  insufficient_balance: (c) => typeof c.required === "number" && typeof c.balance === "number" ? `Needs ${usd(c.required, c.currency)} at ${venue(c)}; you have ${usd(c.balance, c.currency)}.` : `Not enough balance at ${venue(c)}.`,
+  venue_shard_underfunded: (c) => `Your ${venue(c)} balance couldn't be moved to cover this market.`,
+  below_min_order: (c) => `${venue(c)}'s minimum is ${usd(c.min, c.currency, "higher")}.`,
+  above_max_order: (c) => `${venue(c)}'s maximum is ${usd(c.max, c.currency, "lower")}.`,
+  unfillable: (c) => `${usd(c.amount, c.currency)} buys less than one contract at ${cents(c.price)} \u2014 it can't fill.`,
+  below_min_contracts: (c) => typeof c.min_contracts === "number" ? `${venue(c)} needs at least ${c.min_contracts} ${plural(c.min_contracts, "contract", "contracts")}; ${usd(c.amount, c.currency)} buys ${c.contracts ?? "fewer"}.` : `${usd(c.amount, c.currency)} buys fewer contracts than ${venue(c)} accepts.`,
+  amount_off_increment: (c) => `${venue(c)} takes stakes in steps of ${usd(c.increment, c.currency, "a cent")} \u2014 this will be rounded down.`,
+  price_out_of_band: (c) => typeof c.min === "number" && typeof c.max === "number" ? `Prices on ${venue(c)} run ${cents(c.min)}\u2013${cents(c.max)}.` : `That price is outside what ${venue(c)} accepts.`,
+  above_max_price: (c) => typeof c.price === "number" && typeof c.max_price === "number" ? `The book is at ${cents(c.price)}, above your ${cents(c.max_price)} limit.` : "The book is above your price limit.",
+  price_off_tick: (c) => `${venue(c)} prices in fixed steps \u2014 your limit was rounded to ${cents(c.price)}.`,
+  insufficient_size: (c) => `Only ${usd(c.available, c.currency, "less")} is available at ${cents(c.price)}.`,
+  insufficient_live_depth: () => "Nothing is available at this price right now.",
+  no_viable_venues: (c) => `${venue(c)} isn't quoting this position right now.`,
+  no_live_price_for_paper: () => "No live price to practise against.",
+  invalid_requested_amount: () => "Enter a stake above zero.",
+  halted_upstream: () => "Not placed \u2014 another leg failed first.",
+  unknown: (c) => c.detail ?? "The venue declined this order."
+};
+var CLIENT_CODE_SPECS = {
+  no_venue: { severity: "block", fix: "switch_venue", scope: "leg", message: () => "Pick a venue." },
+  no_stake: { severity: "block", fix: "raise_stake", scope: "leg", message: () => "Enter a stake." },
+  no_quote: { severity: "block", fix: "switch_venue", scope: "venue", message: (c) => `${venue(c)} has no live price for this position.` },
+  paper_limit_unsupported: { severity: "block", fix: "use_market", scope: "leg", message: () => "Practice orders fill instantly \u2014 limit orders need real money." },
+  order_type_unsupported: { severity: "block", fix: "use_market", scope: "venue", message: (c) => `${venue(c)} doesn't take ${c.detail ?? "this type of"} orders.` },
+  mode_unavailable: { severity: "block", fix: "switch_to_paper", scope: "account", message: (c) => `${c.detail === "paper" ? "Practice" : "Real-money"} trading isn't available on this account.` },
+  real_money_disabled: { severity: "block", fix: "switch_to_paper", scope: "request", message: () => "Real-money orders are turned off in this app." },
+  not_paper_bettable: { severity: "block", fix: "switch_to_real", scope: "leg", message: () => "This position can't be practised on yet." },
+  stale_quote: { severity: "warn", fix: "retry", scope: "venue", message: (c) => `${venue(c)}'s price is ${c.detail ?? "a while"} old \u2014 re-check before placing.` },
+  better_price_available: { severity: "info", fix: "switch_venue", scope: "venue", message: (c) => `${cents(c.price)} available on ${venue(c)} \u2014 switch?` },
+  constraints_stale: { severity: "info", fix: "retry", scope: "account", message: () => "Venue rules changed on the server \u2014 the preview will re-check." },
+  confirm_required: { severity: "info", fix: "none", scope: "request", message: (c) => `Confirm the real-money order for ${usd(c.amount, c.currency)} on ${venue(c)}.` },
+  confirm_expired: { severity: "block", fix: "retry", scope: "request", message: () => "The order changed since it was confirmed \u2014 review it and place it again." },
+  not_ready: { severity: "block", fix: "retry", scope: "request", message: () => "The order sheet is still loading." }
+};
+function isServerCode(code) {
+  return Object.prototype.hasOwnProperty.call(SERVER_CODE_MESSAGES, code);
+}
+function localIssue(code, ctx = {}, over = {}) {
+  if (isServerCode(code)) {
+    return {
+      code,
+      severity: over.severity ?? ISSUE_SEVERITY[code],
+      message: SERVER_CODE_MESSAGES[code](ctx),
+      detail: over.detail ?? ctx.detail ?? null,
+      fix: over.fix ?? fixFor(code, ctx),
+      scope: over.scope ?? "leg",
+      source: "local"
+    };
+  }
+  const spec = CLIENT_CODE_SPECS[code];
+  return {
+    code,
+    severity: over.severity ?? spec.severity,
+    message: spec.message(ctx),
+    detail: over.detail ?? ctx.detail ?? null,
+    fix: over.fix ?? spec.fix,
+    scope: over.scope ?? spec.scope,
+    source: "local"
+  };
+}
+function fixFor(code, ctx) {
+  if (code === "price_out_of_band" && typeof ctx.price === "number" && typeof ctx.min === "number") {
+    return ctx.price < ctx.min ? "raise_price" : "lower_price";
+  }
+  return ISSUE_DEFAULT_FIX[code];
+}
+
+// src/math.ts
+var STEP_EPS = 1e-4;
+var AMOUNT_TOL = 5e-3;
+function contractsFromAmount(amount, pricePerContract) {
+  if (!Number.isFinite(amount) || !Number.isFinite(pricePerContract) || pricePerContract <= 0) return 0;
+  return Math.floor(amount / pricePerContract + 1e-9);
+}
+function isOnGrid(value, step) {
+  if (!step) return true;
+  const ratio = value / step;
+  return Math.abs(ratio - Math.round(ratio)) <= STEP_EPS;
+}
+function decimalsFor(step) {
+  if (!Number.isFinite(step) || step <= 0) return 2;
+  const s = step.toString();
+  const i = s.indexOf(".");
+  return i === -1 ? 0 : s.length - i - 1;
+}
+function floorToIncrement(amount, step) {
+  if (!step) return round(amount, 2);
+  const floored = Math.floor((amount + 1e-6) / step) * step;
+  return Number(floored.toFixed(decimalsFor(step)));
+}
+function snapPrice(price, tick, min, max) {
+  let p = price;
+  if (tick && tick > 0) p = Math.round(p / tick) * tick;
+  p = Math.min(max, Math.max(min, p));
+  return round(p, 4);
+}
+function round(n, dp) {
+  const f = Math.pow(10, dp);
+  return Math.round(n * f) / f;
+}
+
+// src/quote.ts
+function resolveMaxPrice(venue2, orderType, userMaxPrice, slippage) {
+  const price = venue2.price;
+  const pc = venue2.constraints?.price;
+  const tick = pc ? pc.tick : 0.01;
+  const min = pc?.min ?? 0.01;
+  const max = pc?.max ?? 0.99;
+  if (userMaxPrice != null) return snapPrice(userMaxPrice, tick, min, max);
+  if (price == null) return null;
+  return snapPrice(orderType === "limit" ? price : price + slippage, tick, min, max);
+}
+function buildQuote(input) {
+  const { venue: venue2, stake } = input;
+  if (stake.value == null || !(stake.value > 0)) return null;
+  const size = venue2.constraints?.size;
+  const whole = size?.whole_contracts ?? false;
+  const increment = size?.increment_usd ?? null;
+  const price = input.orderType === "limit" ? input.maxPrice : venue2.price;
+  if (price == null || !(price > 0)) return null;
+  const maxPrice = input.maxPrice ?? price;
+  const pf = input.preflight?.leg;
+  const usePreflight = !!pf && pf.accepted;
+  const basis = usePreflight && input.orderType === "market" && pf.total_allocated > 0 ? pf.expected_fill_price : price;
+  const notional = stake.unit === "amount" ? stake.value : round(stake.value * basis, 4);
+  let contracts;
+  let cost;
+  if (usePreflight) {
+    contracts = pf.normalized.contracts;
+    cost = pf.normalized.amount;
+  } else if (stake.unit === "shares") {
+    contracts = whole ? Math.floor(stake.value + 1e-9) : stake.value;
+    cost = round(contracts * basis, 2);
+  } else if (whole) {
+    contracts = contractsFromAmount(notional, basis);
+    cost = round(contracts * basis, 2);
+  } else {
+    cost = floorToIncrement(notional, increment);
+    contracts = basis > 0 ? round(cost / basis, 4) : 0;
+  }
+  const payout = round(contracts, 2);
+  const leftover = round(Math.max(0, notional - cost), 2);
+  const direction = venue2.constraints?.fees.direction ?? null;
+  let fee = null;
+  if (usePreflight) {
+    fee = { taker: pf.total_taker_fee, maker: pf.total_maker_fee, direction, estimated: false };
+  } else if (venue2.feePacket && input.mode === "real") {
+    const k = cost / 100;
+    fee = { taker: round(venue2.feePacket.taker_fee * k, 2), maker: round(venue2.feePacket.maker_fee * k, 2), direction, estimated: true };
+  } else if (input.mode === "paper") {
+    fee = { taker: 0, maker: 0, direction: null, estimated: false };
+  }
+  const takerFee = fee?.taker ?? 0;
+  const effectivePrice = contracts > 0 ? round((cost + takerFee) / contracts, 4) : null;
+  const profit = round(payout - cost - takerFee, 2);
+  const expectedFill = usePreflight ? { allocated: pf.total_allocated, unfilled: pf.unfilled_amount, fillPrice: pf.expected_fill_price } : null;
+  const wouldRest = usePreflight ? pf.would_rest : input.orderType === "limit" && venue2.price != null && venue2.price > maxPrice + 1e-9;
+  const freshness = input.stale ? "stale" : usePreflight ? "preflight" : "quote";
+  const cur = input.currency;
+  return {
+    venuePartnerId: venue2.partnerId,
+    mode: input.mode,
+    orderType: input.orderType,
+    stake: { unit: stake.unit, value: stake.value },
+    price: round(basis, 4),
+    maxPrice: round(maxPrice, 4),
+    contracts,
+    cost,
+    payout,
+    leftover,
+    notional: round(notional, 2),
+    fee,
+    effectivePrice,
+    profit,
+    expectedFill,
+    wouldRest,
+    currency: cur,
+    freshness,
+    display: {
+      price: formatPrice(basis, input.oddsFormat, input.orderType === "market" ? venue2.americanOdds : null),
+      maxPrice: formatPrice(maxPrice, input.oddsFormat),
+      cost: formatMoney(cost, cur),
+      payout: formatMoney(payout, cur),
+      profit: formatMoney(profit, cur),
+      fee: fee ? `${formatMoney(takerFee, cur)}${fee.estimated ? " est." : ""}` : "\u2014",
+      effectivePrice: effectivePrice != null ? formatPrice(Math.min(0.9999, effectivePrice), input.oddsFormat) : "\u2014"
+    }
+  };
+}
+
+// src/validate.ts
+function validateSheet(input) {
+  const issues = [];
+  const { venue: venue2, mode, orderType, stake, account } = input;
+  const cur = input.currency;
+  const push = (i) => {
+    if (!issues.some((x) => x.code === i.code && x.scope === i.scope)) issues.push(i);
+  };
+  if (account) {
+    if (!account.moneyModes.includes(mode)) {
+      const reason = account.issues.find((i) => mode === "paper" ? i.code === "practice_not_permitted" : i.code !== "practice_not_permitted");
+      push(reason ?? localIssue("mode_unavailable", { detail: mode }));
+    }
+  }
+  if (mode === "real" && !input.realMoneyEnabled) push(localIssue("real_money_disabled"));
+  if (mode === "paper" && orderType === "limit") push(localIssue("paper_limit_unsupported"));
+  if (mode === "paper" && input.paperBettable === false) push(localIssue("not_paper_bettable"));
+  if (input.constraintsStale) push(localIssue("constraints_stale"));
+  if (!venue2) {
+    push(localIssue("no_venue"));
+    return finish(issues);
+  }
+  for (const i of venue2.eligibility.issues) push(i);
+  const c = venue2.constraints;
+  const price = orderType === "limit" ? input.maxPrice : venue2.price;
+  if (price == null) {
+    if (orderType === "limit") push(localIssue("no_stake", {}, { fix: "raise_price" }));
+  }
+  if (stake.value == null || !(stake.value > 0)) {
+    push(localIssue("no_stake"));
+    return finish(issues);
+  }
+  if (price == null) return finish(issues);
+  const notional = stake.unit === "amount" ? stake.value : stake.value * price;
+  const vctx = { venue: venue2.name, currency: cur };
+  if (c && mode === "real") {
+    const size = c.size;
+    const isFullTake = venue2.available != null && Math.abs(notional - venue2.available) <= AMOUNT_TOL;
+    if (notional + AMOUNT_TOL < size.min_usd && !(size.full_fill_bypasses_min && isFullTake)) {
+      push(localIssue("below_min_order", { ...vctx, amount: notional, min: size.min_usd }));
+    }
+    if (size.max_usd != null && notional - AMOUNT_TOL > size.max_usd) {
+      push(localIssue("above_max_order", { ...vctx, amount: notional, max: size.max_usd }));
+    }
+    if (size.whole_contracts) {
+      const contracts = stake.unit === "shares" ? Math.floor(stake.value + 1e-9) : contractsFromAmount(notional, price);
+      const minC = Math.max(1, size.min_contracts);
+      if (contracts < minC) {
+        push(contracts === 0 && minC === 1 ? localIssue("unfillable", { ...vctx, amount: notional, price }) : localIssue("below_min_contracts", { ...vctx, amount: notional, price, contracts, min_contracts: minC }));
+      }
+    } else if (size.increment_usd && stake.unit === "amount" && !isOnGrid(notional, size.increment_usd)) {
+      push(localIssue("amount_off_increment", { ...vctx, amount: notional, increment: size.increment_usd }));
+    }
+    const pc = c.price;
+    if (input.maxPrice != null) {
+      if (input.maxPrice + 1e-9 < pc.min || input.maxPrice - 1e-9 > pc.max) {
+        push(localIssue("price_out_of_band", { ...vctx, price: input.maxPrice, min: pc.min, max: pc.max }));
+      } else if (pc.tick && Math.abs(snapPrice(input.maxPrice, pc.tick, pc.min, pc.max) - input.maxPrice) > 1e-6) {
+        push(localIssue("price_off_tick", { ...vctx, price: snapPrice(input.maxPrice, pc.tick, pc.min, pc.max), tick: pc.tick }));
+      }
+    }
+    if (orderType === "market" && input.maxPrice != null && venue2.price != null && venue2.price > input.maxPrice + 1e-9) {
+      push(localIssue("above_max_price", { ...vctx, price: venue2.price, max_price: input.maxPrice }));
+    }
+    if (orderType === "market" && venue2.available != null && notional - AMOUNT_TOL > venue2.available) {
+      push(localIssue("insufficient_size", { ...vctx, available: venue2.available, price: venue2.price ?? price }));
+    }
+    const bal = venue2.account.expectedBalance;
+    if (bal != null && !venue2.account.stale && notional - AMOUNT_TOL > bal) {
+      push(localIssue("insufficient_balance", { ...vctx, required: notional, balance: bal }, { severity: "warn" }));
+    }
+  }
+  if (mode === "paper" && account?.practiceWallet.balance != null && notional - AMOUNT_TOL > account.practiceWallet.balance) {
+    push(localIssue("insufficient_balance", {
+      venue: "your practice wallet",
+      currency: account.practiceWallet.currency,
+      required: notional,
+      balance: account.practiceWallet.balance
+    }, { fix: "lower_stake" }));
+  }
+  if (orderType === "market" && input.maxPrice != null && venue2.price != null && venue2.price > input.maxPrice + 1e-9 && mode === "paper") {
+    push(localIssue("above_max_price", { ...vctx, price: venue2.price, max_price: input.maxPrice }));
+  }
+  if (input.quoteAgeMs != null && input.quoteAgeMs > input.staleAfterMs) {
+    push(localIssue("stale_quote", { ...vctx, detail: `${Math.round(input.quoteAgeMs / 1e3)}s` }));
+  }
+  const best = input.venues.find((v) => v.best);
+  if (best && best.partnerId !== venue2.partnerId && best.price != null && venue2.price != null && best.price < venue2.price - 1e-9 && orderType === "market") {
+    push(localIssue("better_price_available", { venue: best.name, price: best.price }));
+  }
+  return finish(issues);
+}
+function finish(issues) {
+  const blocking = issues.filter((i) => i.severity === "block");
+  const warnings = issues.filter((i) => i.severity === "warn");
+  const info = issues.filter((i) => i.severity === "info");
+  return { ok: blocking.length === 0, blocking, warnings, info, all: issues };
+}
+
+// src/venues.ts
+function fromServerIssue(i) {
+  return { ...i, source: "server" };
+}
+function buildVenueOptions(input) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const v of input.constraints?.venues ?? []) byId.set(v.partner_id, v);
+  const rows = input.position.partner_liquidities;
+  const practiceBook = input.account?.practiceWallet.partnerId ?? input.constraints?.account.practice_wallet.partner_id ?? null;
+  const options = [];
+  for (const row of rows) {
+    if (practiceBook && row.partner_id === practiceBook) continue;
+    const c = byId.get(row.partner_id) ?? null;
+    options.push(toOption(row, c, input));
+  }
+  let best = null;
+  for (const o of options) {
+    if (!o.actionable || o.price == null) continue;
+    if (!best || o.price < (best.price ?? Infinity)) best = o;
+  }
+  if (best) best.best = true;
+  return options.sort((a, b) => {
+    const pa = a.actionable && a.price != null ? a.price : Infinity;
+    const pb = b.actionable && b.price != null ? b.price : Infinity;
+    return pa - pb;
+  });
+}
+function toOption(row, c, input) {
+  const actionable = row.actionable !== false && row.price > 0;
+  const name = c?.name ?? row.partner_name ?? row.partner_id;
+  const issues = [];
+  if (c) {
+    const elig = input.mode === "real" ? c.eligibility.real : c.eligibility.paper;
+    for (const i of elig.issues) issues.push(fromServerIssue(i));
+    if (input.mode === "real" && c.orders_allowed && !c.order_types.includes(input.orderType)) {
+      issues.push(localIssue("order_type_unsupported", { venue: name, detail: input.orderType }));
+    }
+  } else if (input.constraints) {
+    if (input.mode === "real") issues.push(localIssue("orders_not_supported", { venue: name }, { scope: "venue" }));
+  }
+  if (input.mode === "paper" && input.orderType === "limit") {
+    issues.push(localIssue("paper_limit_unsupported", { venue: name }));
+  }
+  if (!actionable) issues.push(localIssue("no_quote", { venue: name }));
+  const status = issues.some((i) => i.severity === "block") ? "blocked" : issues.some((i) => i.severity === "warn") ? "warn" : "ok";
+  const modes = [];
+  if (c ? c.eligibility.paper.ok : true) modes.push("paper");
+  if (c ? c.eligibility.real.ok : false) modes.push("real");
+  return {
+    partnerId: row.partner_id,
+    name,
+    logoUrl: c?.logo_url ?? null,
+    liquidityHash: row.liquidity_hash ?? null,
+    buyId: row.buy_id ?? null,
+    price: actionable ? row.price : null,
+    americanOdds: row.american_odds ?? null,
+    available: actionable ? row.available : null,
+    actionable,
+    feePacket: row.fee_packet ?? null,
+    account: {
+      connected: c?.account.connected ?? false,
+      status: c?.account.status ?? null,
+      credentialStatus: c?.account.credential_status ?? null,
+      currency: c?.account.currency ?? null,
+      balance: c?.account.balance ?? null,
+      expectedBalance: c?.account.expected_balance ?? null,
+      stale: c?.account.is_stale ?? true,
+      scopeTradeExecute: c?.account.scope_trade_execute ?? true
+    },
+    supports: {
+      orderTypes: c ? [...c.order_types] : ["market"],
+      cancel: c?.cancel_supported ?? false,
+      modes
+    },
+    eligibility: { status, issues },
+    constraints: c,
+    best: false,
+    selected: input.selectedPartnerId === row.partner_id,
+    display: { price: formatPrice(actionable ? row.price : null, input.oddsFormat, row.american_odds) }
+  };
+}
+
+// src/sheet.ts
+var TERMINAL_PHASES = /* @__PURE__ */ new Set(["filled", "failed", "cancelled", "settled"]);
+function initialSheetState(o, ref, init = {}) {
+  const userMaxPrice = init.maxPrice ?? null;
+  return {
+    phase: "loading",
+    position: "position" in ref ? ref.position : null,
+    venues: [],
+    venue: null,
+    mode: init.mode ?? o.defaults.mode,
+    orderType: init.orderType ?? o.defaults.orderType,
+    stake: init.stake ? "amount" in init.stake ? { unit: "amount", value: init.stake.amount } : { unit: "shares", value: init.stake.shares } : { unit: o.defaults.stakeUnit, value: null },
+    maxPrice: userMaxPrice,
+    maxPriceIsAuto: userMaxPrice == null,
+    slippage: init.slippage ?? o.defaults.slippage,
+    oddsFormat: init.oddsFormat ?? o.defaults.oddsFormat,
+    quote: null,
+    validation: { ok: false, blocking: [], warnings: [], info: [], all: [] },
+    preflight: null,
+    preflightStatus: "idle",
+    result: null,
+    orders: [],
+    error: null,
+    account: null,
+    canPlace: false,
+    confirmLabel: "",
+    hint: null,
+    loading: true,
+    updatedAt: o.now()
+  };
+}
+function createInertSheet(o, ref, init = {}) {
+  const state = initialSheetState(o, ref, init);
+  const notReady = async () => ({ status: "blocked", issues: [localIssue("not_ready")] });
+  const noop = () => {
+  };
+  return {
+    getState: () => state,
+    subscribe: () => noop,
+    select: noop,
+    set: noop,
+    refresh: async () => {
+    },
+    preflight: async () => null,
+    place: notReady,
+    confirm: notReady,
+    cancelConfirm: noop,
+    cancel: async () => ({ cancelled: [], skipped: [] }),
+    reset: noop,
+    destroy: noop,
+    ingestOrderUpdate: noop,
+    ingestOrderSettled: noop
+  };
+}
+function createSheet(client, ref, init = {}) {
+  const o = client.options;
+  const listeners = /* @__PURE__ */ new Set();
+  let destroyed = false;
+  let userMaxPrice = init.maxPrice ?? null;
+  let selectedPartnerId = init.partnerId ?? refPartner(ref);
+  let preflightTimer = null;
+  let preflightSeq = 0;
+  let pendingIdempotencyKey = null;
+  let confirmation = null;
+  let inFlight = null;
+  let constraintsStale = false;
+  let quoteAt = null;
+  let pollTimer = null;
+  const trackedIds = /* @__PURE__ */ new Set();
+  const offs = [];
+  let state = initialSheetState(o, ref, init);
+  const emit = () => {
+    for (const l of listeners) {
+      try {
+        l(state);
+      } catch (e) {
+        console.error("[order-sheet] listener threw", e);
+      }
+    }
+  };
+  const patchState = (p) => {
+    state = { ...state, ...p, updatedAt: o.now() };
+    emit();
+  };
+  const inputKey = () => JSON.stringify([
+    selectedPartnerId,
+    state.mode,
+    state.orderType,
+    state.stake.unit,
+    state.stake.value,
+    effectiveMaxPrice()
+  ]);
+  function effectiveMaxPrice() {
+    const venue2 = currentVenue();
+    if (!venue2) return userMaxPrice;
+    return resolveMaxPrice(venue2, state.orderType, userMaxPrice, state.slippage);
+  }
+  function currentVenue() {
+    if (!state.position || !selectedPartnerId) return null;
+    const venues = buildVenueOptions({
+      position: state.position,
+      constraints: client.getCachedConstraints(),
+      account: state.account,
+      mode: state.mode,
+      orderType: state.orderType,
+      selectedPartnerId,
+      oddsFormat: state.oddsFormat
+    });
+    return venues.find((v) => v.partnerId === selectedPartnerId) ?? null;
+  }
+  function recompute(extra = {}) {
+    if (destroyed) return;
+    const next = { ...extra };
+    const position = extra.position ?? state.position;
+    const account = extra.account ?? state.account;
+    const constraints = client.getCachedConstraints();
+    const mode = extra.mode ?? state.mode;
+    const orderType = extra.orderType ?? state.orderType;
+    const stake = extra.stake ?? state.stake;
+    const oddsFormat = extra.oddsFormat ?? state.oddsFormat;
+    const slippage = extra.slippage ?? state.slippage;
+    let venues = [];
+    let venue2 = null;
+    if (position) {
+      venues = buildVenueOptions({ position, constraints, account, mode, orderType, selectedPartnerId, oddsFormat });
+      venue2 = venues.find((v) => v.partnerId === selectedPartnerId) ?? null;
+    }
+    const maxPrice = venue2 ? resolveMaxPrice(venue2, orderType, userMaxPrice, slippage) : userMaxPrice;
+    const currency = mode === "paper" ? account?.practiceWallet.currency ?? "ATLAS" : venue2?.account.currency ?? "USD";
+    const key = JSON.stringify([selectedPartnerId, mode, orderType, stake.unit, stake.value, maxPrice]);
+    const preflight = state.preflight && state.preflight.inputKey === key ? state.preflight : null;
+    const quoteAgeMs = quoteAt != null ? o.now() - quoteAt : null;
+    let validation = validateSheet({
+      account,
+      venue: venue2,
+      venues,
+      mode,
+      orderType,
+      stake,
+      maxPrice,
+      realMoneyEnabled: o.realMoney.enabled,
+      paperBettable: position ? position.paper_bettable : null,
+      quoteAgeMs,
+      staleAfterMs: o.defaults.staleAfterMs,
+      constraintsStale,
+      currency
+    });
+    if (preflight) validation = mergeServerVerdict(validation, preflight);
+    const quote = venue2 ? buildQuote({
+      venue: venue2,
+      mode,
+      orderType,
+      stake,
+      maxPrice,
+      oddsFormat,
+      preflight,
+      currency,
+      stale: quoteAgeMs != null && quoteAgeMs > o.defaults.staleAfterMs
+    }) : null;
+    if (confirmation && confirmation.key !== key) clearConfirmation();
+    const loading = extra.loading ?? state.loading;
+    let phase = state.phase;
+    if (loading) phase = "loading";
+    else if (state.phase === "placing" && !extra.phase) phase = state.phase;
+    else if (state.phase === "confirming" && !extra.phase && confirmation) phase = state.phase;
+    else if (state.result && TERMINAL_PHASES.has(state.phase) && !extra.phase) phase = state.phase;
+    else if (state.result && ["resting", "pending", "partial"].includes(state.phase) && !extra.phase) phase = state.phase;
+    else if (extra.phase) phase = extra.phase;
+    else if (!venue2 || stake.value == null) phase = "idle";
+    else phase = validation.ok && quote ? "ready" : "blocked";
+    const hintIssue = validation.info.find((i) => i.code === "better_price_available");
+    const best = hintIssue ? venues.find((v) => v.best) ?? null : null;
+    next.position = position;
+    next.account = account;
+    next.venues = venues;
+    next.venue = venue2;
+    next.mode = mode;
+    next.orderType = orderType;
+    next.stake = stake;
+    next.oddsFormat = oddsFormat;
+    next.slippage = slippage;
+    next.maxPrice = maxPrice;
+    next.maxPriceIsAuto = userMaxPrice == null;
+    next.quote = quote;
+    next.validation = validation;
+    next.preflight = preflight;
+    next.preflightStatus = preflight ? state.preflightStatus : state.preflightStatus === "pending" ? "pending" : "idle";
+    next.phase = phase;
+    next.canPlace = (phase === "ready" || phase === "confirming") && validation.ok && !!quote;
+    next.confirmLabel = confirmLabel(phase, mode, venue2, quote?.display.cost ?? null, o);
+    next.hint = best && hintIssue ? { code: "better_price_available", venue: best, message: hintIssue.message } : null;
+    next.loading = loading;
+    patchState(next);
+  }
+  function mergeServerVerdict(v, pf) {
+    const leg = pf.leg;
+    const all = [];
+    if (!leg.accepted && leg.rejected_code) {
+      all.push({
+        code: leg.rejected_code,
+        severity: "block",
+        message: leg.message_user ?? localIssue(leg.rejected_code, { detail: leg.rejected_reason ?? void 0 }).message,
+        detail: leg.rejected_reason,
+        fix: leg.fix ?? localIssue(leg.rejected_code).fix,
+        scope: "leg",
+        source: "server"
+      });
+    }
+    for (const w of leg.warnings ?? []) all.push(fromServerIssue(w));
+    const serverCodes = new Set(all.map((i) => i.code));
+    for (const i of v.all) if (!serverCodes.has(i.code) || i.source === "server") all.push(i);
+    const blocking = all.filter((i) => i.severity === "block");
+    return { ok: blocking.length === 0, blocking, warnings: all.filter((i) => i.severity === "warn"), info: all.filter((i) => i.severity === "info"), all };
+  }
+  async function load() {
+    patchState({ loading: true, error: null });
+    try {
+      const [loaded, constraints] = await Promise.all([client.loadPosition(ref), client.constraints().catch(() => null)]);
+      constraintsStale = client.constraintsStale();
+      if (!selectedPartnerId && loaded.partnerId) selectedPartnerId = loaded.partnerId;
+      quoteAt = o.now();
+      const account = constraints ? client.accountFromConstraints(constraints) : await client.account().catch(() => null);
+      recompute({ position: loaded.position, account, loading: false });
+      scheduleAutoPreflight();
+    } catch (e) {
+      const err = isOrderSheetError(e) ? e : new OrderSheetError({ code: "network_error", message: e?.message ?? String(e), cause: e });
+      patchState({ loading: false, phase: "blocked", error: err });
+    }
+  }
+  function scheduleAutoPreflight() {
+    if (!o.preflight.auto) return;
+    if (preflightTimer) {
+      o.timers.clear(preflightTimer);
+      preflightTimer = null;
+    }
+    if (!state.validation.ok || !state.quote) return;
+    if (state.preflight && state.preflight.inputKey === inputKey()) return;
+    preflightTimer = o.timers.set(() => {
+      preflightTimer = null;
+      void runPreflight({});
+    }, o.preflight.debounceMs);
+  }
+  async function runPreflight(opts) {
+    const venue2 = state.venue;
+    const leg = buildLeg();
+    if (!venue2 || !leg) return null;
+    const key = inputKey();
+    const seq = ++preflightSeq;
+    patchState({ preflightStatus: "pending" });
+    try {
+      const res = await client.preflight([leg], { verifyLiquidity: opts.verifyLiquidity });
+      if (seq !== preflightSeq || destroyed) return null;
+      const snapshot = { inputKey: key, at: o.now(), leg: res.results[0], haltedAtIndex: res.halted_at_index ?? null };
+      state = { ...state, preflight: snapshot, preflightStatus: "done", error: null };
+      recompute();
+      return snapshot;
+    } catch (e) {
+      if (seq !== preflightSeq || destroyed) return null;
+      const err = isOrderSheetError(e) ? e : new OrderSheetError({ code: "network_error", message: String(e?.message ?? e), cause: e });
+      patchState({ preflightStatus: "error", error: err });
+      recompute();
+      return null;
+    }
+  }
+  function buildLeg() {
+    const venue2 = state.venue;
+    const maxPrice = state.maxPrice;
+    if (!venue2 || state.stake.value == null || maxPrice == null) return null;
+    const leg = {
+      max_price: maxPrice,
+      // ALWAYS explicit. The API defaults an omitted mode to REAL.
+      mode: state.mode,
+      order_type: state.orderType,
+      ...state.stake.unit === "amount" ? { amount: state.stake.value } : { shares: state.stake.value }
+    };
+    if (venue2.liquidityHash) leg.liquidity_hash = venue2.liquidityHash;
+    else if (state.position) {
+      leg.position_hash = state.position.position_hash;
+      leg.partner_id = venue2.partnerId;
+    } else return null;
+    return leg;
+  }
+  function clearConfirmation() {
+    confirmation = null;
+    pendingIdempotencyKey = null;
+  }
+  function place(opts = {}) {
+    if (inFlight) return inFlight;
+    return track(placeOrConfirm(opts, false));
+  }
+  function confirm() {
+    if (inFlight) return inFlight;
+    return track(placeOrConfirm({}, true));
+  }
+  function track(p) {
+    inFlight = p;
+    const done = () => {
+      if (inFlight === p) inFlight = null;
+    };
+    p.then(done, done);
+    return p;
+  }
+  async function placeOrConfirm(opts, viaConfirm) {
+    if (preflightTimer) {
+      o.timers.clear(preflightTimer);
+      preflightTimer = null;
+    }
+    recompute();
+    const venue2 = state.venue;
+    const leg = buildLeg();
+    const key = inputKey();
+    const confirmedNow = state.phase === "confirming" && confirmation !== null && confirmation.key === key;
+    if (viaConfirm && !confirmedNow) {
+      if (state.phase === "confirming") {
+        clearConfirmation();
+        recompute();
+      }
+      return { status: "blocked", issues: [localIssue("confirm_expired")] };
+    }
+    if (!state.validation.ok || !state.quote || !venue2 || !leg) {
+      return { status: "blocked", issues: state.validation.blocking.length ? state.validation.blocking : [localIssue("no_stake")] };
+    }
+    if (state.mode === "real" && o.realMoney.confirm && !confirmedNow) {
+      confirmation = { key };
+      pendingIdempotencyKey = opts.idempotencyKey ?? newIdempotencyKey();
+      const issue = localIssue("confirm_required", { venue: venue2.name, amount: state.quote.cost, currency: state.quote.currency });
+      recompute({ phase: "confirming" });
+      return { status: "confirm_required", issues: [issue] };
+    }
+    const idempotencyKey = opts.idempotencyKey ?? pendingIdempotencyKey ?? newIdempotencyKey();
+    confirmation = null;
+    pendingIdempotencyKey = idempotencyKey;
+    recompute({ phase: "placing" });
+    let raw;
+    try {
+      raw = await client.buy([leg], { idempotencyKey, verifyLiquidity: opts.verifyLiquidity });
+    } catch (e) {
+      const err = isOrderSheetError(e) ? e : new OrderSheetError({ code: "network_error", message: String(e?.message ?? e), cause: e });
+      if (err.retryable) patchState({ error: err, phase: "failed" });
+      else {
+        pendingIdempotencyKey = null;
+        state = { ...state, error: err };
+        recompute({ phase: "blocked" });
+      }
+      throw err;
+    }
+    pendingIdempotencyKey = null;
+    const result = toPlaceResult(raw, venue2, state.account, idempotencyKey, o.now());
+    for (const l of result.legs) for (const id of l.routerOrderIds) trackedIds.add(id);
+    const orders = result.legs.flatMap((l) => l.routerOrderIds.map((id) => ({
+      routerOrderId: id,
+      partnerId: l.routedPartnerIds[0] ?? l.partnerId ?? "",
+      status: l.status === "completed" ? "closed" : "open",
+      fillStatus: l.status === "completed" ? l.fill.unfilled > 5e-3 ? "partially_filled" : "filled" : "unfilled",
+      filledAmt: l.fill.notional,
+      unfilledAmt: l.fill.unfilled,
+      avgPrice: l.fill.avgPrice,
+      settled: null,
+      updatedAt: new Date(o.now()).toISOString()
+    })));
+    state = { ...state, result, orders, error: null };
+    recompute({ phase: phaseFromSummary(result.summary) });
+    if (result.summary === "resting" || result.summary === "pending") followOrders().catch(() => {
+    });
+    return { status: "placed", result };
+  }
+  async function followOrders() {
+    if (credentialSupportsStream(o.auth) && o.stream.enabled) {
+      await client.ensureStream();
+      return;
+    }
+    if (pollTimer || !o.stream.pollIntervalMs) return;
+    const tick = async () => {
+      pollTimer = null;
+      if (destroyed || !state.position || trackedIds.size === 0 || TERMINAL_PHASES.has(state.phase)) return;
+      try {
+        const rows = await client.listOrders({ contestId: state.position.contest_id });
+        for (const r of rows) if (trackedIds.has(r.router_order_id)) applyOrderRow(r);
+      } catch {
+      }
+      if (!destroyed && !TERMINAL_PHASES.has(state.phase)) pollTimer = o.timers.set(tick, o.stream.pollIntervalMs);
+    };
+    pollTimer = o.timers.set(tick, o.stream.pollIntervalMs);
+  }
+  function applyOrderRow(r) {
+    ingestOrderUpdate({
+      type: "order.update",
+      router_order_id: r.router_order_id,
+      partner_id: r.partner_id,
+      router_contest_id: r.contest_id,
+      status: r.status,
+      fill_status: r.fill_status ?? "unfilled",
+      filled_amt: r.filled_amt ?? 0,
+      unfilled_amt: r.unfilled_amt ?? 0,
+      avg_price: null,
+      timestamp: new Date(o.now()).toISOString()
+    });
+    if (r.result) ingestOrderSettled({
+      type: "order.settled",
+      router_order_id: r.router_order_id,
+      partner_id: r.partner_id,
+      router_contest_id: r.contest_id,
+      result: r.result,
+      winnings: r.winnings ?? 0,
+      net_winnings: r.net_winnings ?? 0,
+      timestamp: new Date(o.now()).toISOString()
+    });
+  }
+  function ingestOrderUpdate(frame) {
+    if (!trackedIds.has(frame.router_order_id)) return;
+    const orders = state.orders.map((t) => t.routerOrderId === frame.router_order_id ? { ...t, status: frame.status, fillStatus: frame.fill_status, filledAmt: frame.filled_amt, unfilledAmt: frame.unfilled_amt, avgPrice: frame.avg_price ?? t.avgPrice, updatedAt: frame.timestamp } : t);
+    state = { ...state, orders };
+    recompute({ phase: phaseFromOrders(orders, state.phase) });
+  }
+  function ingestOrderSettled(frame) {
+    if (!trackedIds.has(frame.router_order_id)) return;
+    const orders = state.orders.map((t) => t.routerOrderId === frame.router_order_id ? { ...t, settled: { result: frame.result, winnings: frame.winnings, netWinnings: frame.net_winnings }, updatedAt: frame.timestamp } : t);
+    state = { ...state, orders };
+    recompute({ phase: orders.every((t) => t.settled) ? "settled" : state.phase });
+  }
+  offs.push(client.events.on("order.update", ingestOrderUpdate));
+  offs.push(client.events.on("order.settled", ingestOrderSettled));
+  offs.push(client.events.on("constraints", () => {
+    constraintsStale = client.constraintsStale();
+    recompute();
+    scheduleAutoPreflight();
+  }));
+  offs.push(client.events.on("stream.connected", () => {
+    void refetchTracked();
+  }));
+  async function refetchTracked() {
+    if (destroyed || !state.position || trackedIds.size === 0 || TERMINAL_PHASES.has(state.phase)) return;
+    try {
+      const rows = await client.listOrders({ contestId: state.position.contest_id });
+      if (destroyed) return;
+      for (const r of rows) if (trackedIds.has(r.router_order_id)) applyOrderRow(r);
+    } catch {
+    }
+  }
+  void load();
+  return {
+    getState: () => state,
+    subscribe(l) {
+      listeners.add(l);
+      return () => {
+        listeners.delete(l);
+      };
+    },
+    select(partnerId) {
+      if (state.phase === "placing") return;
+      clearConfirmation();
+      selectedPartnerId = partnerId;
+      if (state.maxPriceIsAuto) userMaxPrice = null;
+      state = { ...state, preflight: null, preflightStatus: "idle" };
+      recompute();
+      scheduleAutoPreflight();
+    },
+    set(patch) {
+      const next = {};
+      if (patch.stake !== void 0) {
+        next.stake = patch.stake === null ? { unit: state.stake.unit, value: null } : "amount" in patch.stake ? { unit: "amount", value: patch.stake.amount } : { unit: "shares", value: patch.stake.shares };
+      }
+      if (patch.maxPrice !== void 0) userMaxPrice = patch.maxPrice;
+      if (patch.orderType !== void 0) {
+        next.orderType = patch.orderType;
+        if (state.maxPriceIsAuto) userMaxPrice = null;
+      }
+      if (patch.mode !== void 0) next.mode = patch.mode;
+      if (patch.oddsFormat !== void 0) next.oddsFormat = patch.oddsFormat;
+      if (patch.slippage !== void 0) next.slippage = patch.slippage;
+      clearConfirmation();
+      state = { ...state, error: null };
+      recompute(next);
+      scheduleAutoPreflight();
+    },
+    refresh: load,
+    preflight: (opts = {}) => runPreflight(opts),
+    place,
+    confirm,
+    cancelConfirm() {
+      if (state.phase === "placing") return;
+      clearConfirmation();
+      recompute();
+    },
+    async cancel() {
+      const ids = state.orders.filter((t) => t.fillStatus !== "filled" && !t.settled).map((t) => t.routerOrderId);
+      if (ids.length === 0) return { cancelled: [], skipped: [] };
+      const res = await client.cancelOrders(ids);
+      const cancelled = res.cancelled.map((c) => c.router_order_id);
+      const orders = state.orders.map((t) => cancelled.includes(t.routerOrderId) ? { ...t, status: "cancelled", updatedAt: new Date(o.now()).toISOString() } : t);
+      state = { ...state, orders };
+      recompute({ phase: cancelled.length > 0 && orders.every((t) => t.status === "cancelled" || t.fillStatus === "filled") ? "cancelled" : state.phase });
+      return { cancelled, skipped: [...res.skipped.map((s) => s.router_order_id), ...res.errors.map((e) => e.router_order_id)] };
+    },
+    reset() {
+      if (state.phase === "placing") return;
+      clearConfirmation();
+      userMaxPrice = init.maxPrice ?? null;
+      trackedIds.clear();
+      state = { ...state, stake: { unit: state.stake.unit, value: null }, result: null, orders: [], preflight: null, preflightStatus: "idle", error: null };
+      recompute({ phase: "idle" });
+    },
+    destroy() {
+      if (destroyed) return;
+      destroyed = true;
+      clearConfirmation();
+      listeners.clear();
+      for (const off of offs) off();
+      if (preflightTimer) o.timers.clear(preflightTimer);
+      if (pollTimer) o.timers.clear(pollTimer);
+    },
+    ingestOrderUpdate,
+    ingestOrderSettled
+  };
+}
+function refPartner(ref) {
+  if ("liquidityHash" in ref) return ref.liquidityHash.split(":")[0] || null;
+  if ("partnerId" in ref && ref.partnerId) return ref.partnerId;
+  return null;
+}
+function newIdempotencyKey() {
+  const c = globalThis.crypto;
+  if (c?.randomUUID) return `oms_${c.randomUUID()}`;
+  return `oms_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 12)}`;
+}
+function confirmLabel(phase, mode, venue2, cost, o) {
+  const L = o.labels;
+  if (phase === "placing") return L.placing;
+  if (phase === "confirming") return `${L.confirmReal}${cost ? ` \xB7 ${cost}` : ""}${venue2 ? ` on ${venue2.name}` : ""}`;
+  const verb = mode === "real" ? L.placeReal : L.placePractice;
+  return cost && phase !== "idle" ? `${verb} \xB7 ${cost}` : verb;
+}
+function phaseFromSummary(summary) {
+  switch (summary) {
+    case "filled":
+      return "filled";
+    case "partial":
+      return "partial";
+    case "resting":
+      return "resting";
+    case "pending":
+      return "pending";
+    case "failed":
+      return "failed";
+  }
+}
+function phaseFromOrders(orders, current) {
+  if (orders.length === 0) return current;
+  if (orders.every((t) => t.settled)) return "settled";
+  if (orders.every((t) => t.fillStatus === "filled")) return "filled";
+  if (orders.every((t) => t.status === "cancelled")) return orders.some((t) => t.filledAmt > 0) ? "partial" : "cancelled";
+  if (orders.some((t) => t.status === "cancelled" || t.status === "closed")) {
+    return orders.some((t) => t.filledAmt > 0) ? "partial" : "failed";
+  }
+  if (orders.some((t) => t.fillStatus === "partially_filled")) return "partial";
+  return current === "pending" ? "pending" : "resting";
+}
+function toPlaceResult(raw, venue2, account, idempotencyKey, now) {
+  const practiceBook = account?.practiceWallet.partnerId ?? null;
+  const legs = raw.results.map((r) => {
+    const routed = r.venues.map((v) => v.partner_id);
+    const isPaperBook = routed.length > 0 && practiceBook != null && routed.every((p) => p === practiceBook);
+    const substituted = !!r.requested_partner_id && routed.length > 0 && routed.some((p) => p !== r.requested_partner_id) && !isPaperBook;
+    const issue = r.rejected_code ? {
+      code: r.rejected_code,
+      severity: "block",
+      scope: "leg",
+      source: "server",
+      message: r.message_user ?? localIssue(r.rejected_code, { venue: venue2.name, detail: r.rejected_reason ?? void 0 }).message,
+      detail: r.rejected_reason,
+      fix: r.fix ?? localIssue(r.rejected_code).fix
+    } : r.status === "failed" || r.status === "rejected" ? { code: "unknown", severity: "block", scope: "leg", source: "server", message: r.rejected_reason ?? "The venue declined this order.", detail: r.rejected_reason, fix: "retry" } : null;
+    return {
+      index: r.index,
+      status: r.status,
+      partnerId: r.requested_partner_id,
+      routedPartnerIds: routed,
+      substituted,
+      routerOrderIds: r.venues.map((v) => v.router_order_id).filter((id) => !!id),
+      fill: { notional: r.filled_notional, shares: r.filled_shares, avgPrice: r.avg_price, unfilled: r.unfilled_notional },
+      issue,
+      sorDecisionId: r.sor_decision_id
+    };
+  });
+  return { summary: summarize(legs), legs, opportunityId: raw.opportunity_id, idempotencyKey, placedAt: now, raw };
+}
+function summarize(legs) {
+  if (legs.length === 0) return "failed";
+  if (legs.some((l) => l.status === "failed" || l.status === "rejected")) {
+    return legs.some((l) => l.fill.notional > 0) ? "partial" : "failed";
+  }
+  if (legs.some((l) => l.status === "resting")) return "resting";
+  if (legs.some((l) => l.status === "pending")) return "pending";
+  return legs.some((l) => l.fill.unfilled > 5e-3) ? "partial" : "filled";
+}
+
+// src/http.ts
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 425, 429, 500, 502, 503, 504]);
+function createHttp(options) {
+  const baseUrl = options.baseUrl.replace(/\/+$/, "");
+  const doFetch = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+  async function request(method, path, opts = {}) {
+    const cred = await resolveCredential(options.auth);
+    const headers = {
+      Accept: "application/json",
+      ...cred.headers,
+      ...options.actAs ? { "X-OpenMarkets-Account": options.actAs } : {},
+      ...opts.body !== void 0 ? { "Content-Type": "application/json" } : {},
+      ...opts.headers ?? {}
+    };
+    let res;
+    try {
+      res = await doFetch(`${baseUrl}${path}`, {
+        method,
+        headers,
+        body: opts.body !== void 0 ? JSON.stringify(opts.body) : void 0,
+        signal: opts.signal
+      });
+    } catch (cause) {
+      if (cause?.name === "AbortError") throw cause;
+      throw new OrderSheetError({ code: "network_error", message: `Could not reach ${baseUrl}: ${cause?.message ?? String(cause)}`, retryable: true, cause });
+    }
+    let parsed = null;
+    const text = await res.text();
+    if (text) {
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        throw new OrderSheetError({ code: "invalid_response", message: `Non-JSON response (${res.status}) from ${method} ${path}`, status: res.status, retryable: res.status >= 500 });
+      }
+    }
+    if (!res.ok) {
+      const err = parsed?.error;
+      throw new OrderSheetError({
+        code: err?.code ?? `http_${res.status}`,
+        message: err?.message ?? `${method} ${path} failed with ${res.status}`,
+        status: res.status,
+        details: err?.details ?? null,
+        retryable: RETRYABLE_STATUS.has(res.status)
+      });
+    }
+    const env = parsed;
+    if (!env || typeof env !== "object" || !("data" in env)) {
+      throw new OrderSheetError({ code: "invalid_response", message: `Unexpected response shape from ${method} ${path}`, status: res.status });
+    }
+    return env.data;
+  }
+  return { request, baseUrl };
+}
+
+// src/stream.ts
+function createOrderStream(options) {
+  const channels = options.channels ?? ["orders", "balance"];
+  const timers = options.timers ?? { set: setTimeout, clear: clearTimeout };
+  const backoff = { initialMs: 1e3, maxMs: 3e4, maxAttempts: Infinity, ...options.backoff ?? {} };
+  const handlers = /* @__PURE__ */ new Map();
+  const balanceVersions = /* @__PURE__ */ new Map();
+  let ws = null;
+  let status = "idle";
+  let attempts = 0;
+  let wantOpen = false;
+  let reconnectTimer = null;
+  let pingTimer = null;
+  const emit = (event, payload) => {
+    for (const h of handlers.get(event) ?? []) {
+      try {
+        h(payload);
+      } catch (e) {
+        console.error("[order-sheet] stream handler threw", e);
+      }
+    }
+  };
+  const setStatus = (s) => {
+    if (s !== status) {
+      status = s;
+      emit("status", s);
+    }
+  };
+  const stopPing = () => {
+    if (pingTimer) {
+      timers.clear(pingTimer);
+      pingTimer = null;
+    }
+  };
+  const schedulePing = () => {
+    stopPing();
+    const every = options.pingIntervalMs ?? 25e3;
+    if (!(every > 0)) return;
+    pingTimer = timers.set(() => {
+      if (ws && ws.readyState === 1) {
+        try {
+          ws.send(JSON.stringify({ action: "ping" }));
+        } catch {
+        }
+      }
+      schedulePing();
+    }, every);
+  };
+  function ingest(frame) {
+    switch (frame.type) {
+      case "connected": {
+        attempts = 0;
+        for (const channel of channels) ws?.send(JSON.stringify({ action: "subscribe", channel }));
+        emit("connected", { server_time: frame.server_time ?? null });
+        return;
+      }
+      case "order.update":
+        emit("order.update", frame);
+        return;
+      case "order.settled":
+        emit("order.settled", frame);
+        return;
+      case "balance.update": {
+        const f = frame;
+        const last = balanceVersions.get(f.account_partner_id);
+        if (last != null && typeof f.balance_version === "number" && f.balance_version <= last) return;
+        if (typeof f.balance_version === "number") balanceVersions.set(f.account_partner_id, f.balance_version);
+        emit("balance.update", f);
+        return;
+      }
+      case "error": {
+        const f = frame;
+        emit("error", { code: f.code ?? "stream_error", message: f.message ?? "stream error" });
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  async function open() {
+    const Ctor = options.WebSocket ?? globalThis.WebSocket;
+    if (!Ctor) {
+      emit("error", { code: "stream_unavailable", message: "No WebSocket implementation available." });
+      setStatus("closed");
+      return;
+    }
+    const key = await options.getApiKey();
+    if (!key) {
+      emit("error", { code: "no_credential", message: "The stream needs an API key." });
+      setStatus("closed");
+      return;
+    }
+    const sep = options.url.includes("?") ? "&" : "?";
+    setStatus("connecting");
+    const socket = new Ctor(`${options.url}${sep}api_key=${encodeURIComponent(key)}`);
+    ws = socket;
+    socket.onopen = () => {
+      setStatus("open");
+      schedulePing();
+    };
+    socket.onmessage = (ev) => {
+      let frame = null;
+      try {
+        frame = JSON.parse(String(ev.data));
+      } catch {
+        return;
+      }
+      if (frame && typeof frame === "object" && typeof frame.type === "string") ingest(frame);
+    };
+    socket.onerror = () => {
+    };
+    socket.onclose = () => {
+      if (ws !== socket) return;
+      ws = null;
+      stopPing();
+      const willRetry = wantOpen && attempts < backoff.maxAttempts;
+      setStatus("closed");
+      emit("disconnected", { willRetry });
+      if (willRetry) {
+        const delay = Math.min(backoff.maxMs, backoff.initialMs * Math.pow(2, attempts));
+        attempts += 1;
+        reconnectTimer = timers.set(() => {
+          reconnectTimer = null;
+          if (wantOpen) void open();
+        }, delay);
+      }
+    };
+  }
+  return {
+    get status() {
+      return status;
+    },
+    async connect() {
+      wantOpen = true;
+      if (ws) return;
+      await open();
+    },
+    disconnect() {
+      wantOpen = false;
+      if (reconnectTimer) {
+        timers.clear(reconnectTimer);
+        reconnectTimer = null;
+      }
+      stopPing();
+      const s = ws;
+      ws = null;
+      try {
+        s?.close(1e3, "client disconnect");
+      } catch {
+      }
+      setStatus("closed");
+      if (s) emit("disconnected", { willRetry: false });
+    },
+    on(event, handler) {
+      if (!handlers.has(event)) handlers.set(event, /* @__PURE__ */ new Set());
+      const set = handlers.get(event);
+      set.add(handler);
+      return () => {
+        set.delete(handler);
+      };
+    },
+    ingest
+  };
+}
+
+// src/client.ts
+var DEFAULT_API_BASE = "https://api.openmarkets.ai";
+var DEFAULT_LABELS = {
+  placePractice: "Place practice order",
+  placeReal: "Place real order",
+  confirmReal: "Confirm real order",
+  placing: "Placing\u2026",
+  practice: "Practice",
+  real: "Real money"
+};
+function assertLegModes(legs) {
+  if (!Array.isArray(legs) || legs.length === 0) throw new OrderSheetError({ code: "bad_request", message: "At least one leg is required." });
+  legs.forEach((l, i) => {
+    const mode = l?.mode;
+    if (mode !== "paper" && mode !== "real") {
+      throw new OrderSheetError({ code: "bad_request", message: `Leg ${i}: mode must be "paper" or "real" (got ${JSON.stringify(mode)}). The API would treat a missing mode as real money.`, details: { index: i, field: "mode" } });
+    }
+  });
+}
+function resolveOptions(input) {
+  const auth = input.apiKey ? { apiKey: input.apiKey } : input.auth ? { auth: input.auth } : input.getToken ? { getToken: input.getToken } : {};
+  const baseUrl = (input.baseUrl ?? DEFAULT_API_BASE).replace(/\/+$/, "");
+  return {
+    auth,
+    baseUrl,
+    streamUrl: input.streamUrl ?? `${baseUrl.replace(/^http/, "ws")}/flow/v1/stream`,
+    actAs: input.actAs ?? null,
+    defaults: { mode: "paper", orderType: "market", stakeUnit: "amount", slippage: 0.02, oddsFormat: "cents", staleAfterMs: 6e4, ...input.defaults ?? {} },
+    realMoney: { enabled: false, confirm: true, ...input.realMoney ?? {} },
+    preflight: { auto: true, debounceMs: 300, ...input.preflight ?? {} },
+    constraints: { ttlMs: 6e4, ...input.constraints ?? {} },
+    stream: { enabled: true, pollIntervalMs: 5e3, ...input.stream ?? {} },
+    labels: { ...DEFAULT_LABELS, ...input.labels ?? {} },
+    now: input.now ?? (() => Date.now()),
+    timers: input.timers ?? { set: setTimeout, clear: clearTimeout }
+  };
+}
+function createOrderSheetClient(input) {
+  const options = resolveOptions(input);
+  const http = createHttp({ baseUrl: options.baseUrl, auth: options.auth, fetch: input.fetch, actAs: options.actAs });
+  const handlers = /* @__PURE__ */ new Map();
+  const events = {
+    on(event, handler) {
+      if (!handlers.has(event)) handlers.set(event, /* @__PURE__ */ new Set());
+      handlers.get(event).add(handler);
+      return () => {
+        handlers.get(event)?.delete(handler);
+      };
+    },
+    emit(event, payload) {
+      for (const h of handlers.get(event) ?? []) {
+        try {
+          h(payload);
+        } catch (e) {
+          console.error("[order-sheet] handler threw", e);
+        }
+      }
+    }
+  };
+  let cached = null;
+  let inflight = null;
+  let stale = false;
+  let stream = null;
+  const sheets = /* @__PURE__ */ new Set();
+  async function constraints(opts = {}) {
+    const fresh = cached && !stale && options.now() - cached.at < options.constraints.ttlMs;
+    if (fresh && !opts.force) return cached.value;
+    if (inflight) return inflight;
+    inflight = http.request("GET", "/flow/v1/auth/orders/constraints").then((value) => {
+      cached = { value, at: options.now() };
+      stale = false;
+      events.emit("constraints", value);
+      return value;
+    }).finally(() => {
+      inflight = null;
+    });
+    return inflight;
+  }
+  function accountFromConstraints(c) {
+    return {
+      routerAccountId: c.account.router_account_id,
+      environment: c.account.environment,
+      canExecute: c.account.can_execute,
+      canPractice: c.account.can_practice,
+      moneyModes: [...c.account.money_modes],
+      practiceOnly: c.account.policy.practice_only,
+      isFiduciary: c.account.is_fiduciary,
+      issues: c.account.issues.map(fromServerIssue),
+      practiceWallet: { partnerId: c.account.practice_wallet.partner_id, currency: c.account.practice_wallet.currency, balance: c.account.practice_wallet.balance },
+      policy: { ...c.account.policy },
+      constraintsVersion: c.constraints_version
+    };
+  }
+  async function account(opts = {}) {
+    try {
+      return accountFromConstraints(await constraints(opts));
+    } catch (e) {
+      if (e instanceof OrderSheetError && (e.code === "account_scope_required" || e.code === "account_not_found")) {
+        const me = await http.request("GET", "/flow/v1/auth/me");
+        return {
+          routerAccountId: me.router_account_id,
+          environment: me.environment,
+          canExecute: me.can_execute,
+          canPractice: me.can_practice,
+          moneyModes: [...me.money_modes],
+          practiceOnly: false,
+          isFiduciary: false,
+          issues: [],
+          practiceWallet: { partnerId: null, currency: "ATLAS", balance: null },
+          policy: null,
+          constraintsVersion: null
+        };
+      }
+      throw e;
+    }
+  }
+  async function loadPosition(ref) {
+    if ("position" in ref) return { position: ref.position, partnerId: ref.partnerId ?? null };
+    let contestId;
+    let positionHash;
+    let partnerId;
+    if ("liquidityHash" in ref) {
+      const parts = ref.liquidityHash.split(":");
+      if (parts.length < 7) throw new OrderSheetError({ code: "bad_request", message: `Not a liquidity hash: ${ref.liquidityHash}` });
+      partnerId = parts[0];
+      positionHash = parts.slice(1).join(":");
+      contestId = parts[1];
+    } else {
+      const parts = ref.positionHash.split(":");
+      if (parts.length < 6) throw new OrderSheetError({ code: "bad_request", message: `Not a position hash: ${ref.positionHash}` });
+      positionHash = ref.positionHash;
+      contestId = parts[0];
+      partnerId = ref.partnerId ?? null;
+    }
+    const positions = await http.request("GET", `/flow/v1/contests/${encodeURIComponent(contestId)}/liquidity`);
+    const position = positions.find((p) => p.position_hash === positionHash);
+    if (!position) throw new OrderSheetError({ code: "position_not_found", message: `Position ${positionHash} is not quoted on contest ${contestId}.`, status: 404 });
+    return { position, partnerId };
+  }
+  function withAtomic(body, atomic, verifyLiquidity) {
+    if (atomic) return { ...body, check_all_first: true, on_leg_failure: "halt", placement: "parallel", verify_liquidity: true };
+    return verifyLiquidity ? { ...body, verify_liquidity: true } : body;
+  }
+  async function ensureStream() {
+    if (!options.stream.enabled || !credentialSupportsStream(options.auth)) return null;
+    if (!stream) {
+      stream = createOrderStream({
+        url: options.streamUrl,
+        getApiKey: async () => (await resolveCredential(options.auth)).value,
+        WebSocket: input.WebSocket,
+        timers: options.timers
+      });
+      stream.on("order.update", (f) => events.emit("order.update", f));
+      stream.on("order.settled", (f) => events.emit("order.settled", f));
+      stream.on("balance.update", (f) => {
+        stale = true;
+        events.emit("balance.update", f);
+        events.emit("constraints", cached?.value ?? null);
+        if (sheets.size > 0) constraints().catch(() => {
+        });
+      });
+      stream.on("connected", (f) => events.emit("stream.connected", f));
+    }
+    await stream.connect();
+    return stream;
+  }
+  const client = {
+    options,
+    http,
+    events,
+    account,
+    constraints,
+    getCachedConstraints: () => cached?.value ?? null,
+    constraintsStale: () => !!cached && cached.value.constraints_version !== CONSTRAINTS_VERSION,
+    accountFromConstraints,
+    invalidateConstraints() {
+      stale = true;
+      events.emit("constraints", cached?.value ?? null);
+    },
+    loadPosition,
+    openSheet(ref, init) {
+      const created = createSheet(client, ref, init);
+      const sheet = { ...created, destroy() {
+        sheets.delete(sheet);
+        created.destroy();
+      } };
+      sheets.add(sheet);
+      return sheet;
+    },
+    async preflight(legs, opts = {}) {
+      assertLegModes(legs);
+      return http.request("POST", "/flow/v1/auth/orders/preflight", { body: withAtomic({ orders: legs }, opts.atomic, opts.verifyLiquidity) });
+    },
+    async buy(legs, opts = {}) {
+      assertLegModes(legs);
+      if (!options.realMoney.enabled && legs.some((l) => l.mode === "real")) {
+        throw new OrderSheetError({ code: "real_money_disabled", message: 'A leg has mode "real" but real-money orders are turned off in this app (realMoney.enabled is false).' });
+      }
+      const body = withAtomic({
+        orders: legs,
+        ...opts.opportunityId ? { opportunity_id: opts.opportunityId } : {},
+        ...opts.modelId ? { model_id: opts.modelId } : {}
+      }, opts.atomic, opts.verifyLiquidity);
+      const key = opts.idempotencyKey ?? newIdempotencyKey();
+      return http.request("POST", "/flow/v1/auth/orders/buy", { body, headers: { "Idempotency-Key": key } });
+    },
+    async restingOrders() {
+      return (await http.request("GET", "/flow/v1/auth/orders/resting/me")).orders;
+    },
+    listOrders(opts = {}) {
+      const q = new URLSearchParams();
+      if (opts.contestId) q.set("contest_id", opts.contestId);
+      if (opts.status) q.set("status", opts.status);
+      q.set("limit", String(opts.limit ?? 50));
+      return http.request("GET", `/flow/v1/auth/orders?${q.toString()}`);
+    },
+    cancelOrders(routerOrderIds) {
+      return http.request("POST", "/flow/v1/auth/orders/cancel", { body: { router_order_ids: routerOrderIds } });
+    },
+    me: () => http.request("GET", "/flow/v1/auth/me"),
+    get stream() {
+      return stream;
+    },
+    ensureStream,
+    reset() {
+      cached = null;
+      stale = false;
+      stream?.disconnect();
+      stream = null;
+      for (const s of sheets) s.destroy();
+      sheets.clear();
+      events.emit("constraints", null);
+    },
+    destroy() {
+      client.reset();
+      handlers.clear();
+    }
+  };
+  return client;
+}
+
+// src/react.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var ClientContext = (0, import_react.createContext)(null);
+function OrderSheetProvider({ client, children }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ClientContext.Provider, { value: client, children });
+}
+function useOrderSheetClient() {
+  const c = (0, import_react.useContext)(ClientContext);
+  if (!c) throw new Error("useOrderSheetClient: wrap the tree in <OrderSheetProvider client={\u2026}> or pass a client explicitly.");
+  return c;
+}
+function refKey(ref) {
+  if ("position" in ref) return `pos:${ref.position.position_hash}:${ref.partnerId ?? ""}`;
+  if ("liquidityHash" in ref) return `lh:${ref.liquidityHash}`;
+  return `ph:${ref.positionHash}:${ref.partnerId ?? ""}`;
+}
+function useSheetState(sheet) {
+  return (0, import_react.useSyncExternalStore)(sheet.subscribe, sheet.getState, sheet.getState);
+}
+function isSheet(x) {
+  return typeof x === "object" && x !== null && typeof x.getState === "function" && typeof x.subscribe === "function";
+}
+function useOrderSheet(client, ref, init) {
+  const ctx = (0, import_react.useContext)(ClientContext);
+  const om = client ?? ctx;
+  const given = isSheet(ref) ? ref : null;
+  if (!om && !given) throw new Error("useOrderSheet: pass a client or wrap the tree in <OrderSheetProvider>.");
+  const key = given ? "given" : refKey(ref);
+  const latest = (0, import_react.useRef)({ ref, init });
+  latest.current = { ref, init };
+  const [opened, setOpened] = (0, import_react.useState)(null);
+  (0, import_react.useEffect)(() => {
+    if (given || !om) return;
+    const sheet2 = om.openSheet(latest.current.ref, latest.current.init);
+    setOpened({ key, om, sheet: sheet2 });
+    return () => {
+      sheet2.destroy();
+      setOpened((cur) => cur?.sheet === sheet2 ? null : cur);
+    };
+  }, [key, om, given]);
+  const inert = (0, import_react.useMemo)(
+    () => given || !om ? null : createInertSheet(om.options, latest.current.ref, latest.current.init),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [key, om, given]
+  );
+  const live = opened && opened.key === key && opened.om === om ? opened.sheet : null;
+  const sheet = given ?? live ?? inert;
+  const state = (0, import_react.useSyncExternalStore)(sheet.subscribe, sheet.getState, sheet.getState);
+  return (0, import_react.useMemo)(() => ({
+    ...state,
+    sheet,
+    select: sheet.select,
+    set: sheet.set,
+    setStake: (value, unit) => sheet.set({ stake: value == null ? null : (unit ?? state.stake.unit) === "shares" ? { shares: value } : { amount: value } }),
+    setMode: (mode) => sheet.set({ mode }),
+    setOrderType: (orderType) => sheet.set({ orderType }),
+    setMaxPrice: (maxPrice) => sheet.set({ maxPrice }),
+    place: sheet.place,
+    confirm: sheet.confirm,
+    cancelConfirm: sheet.cancelConfirm,
+    cancel: sheet.cancel,
+    runPreflight: sheet.preflight,
+    reset: sheet.reset,
+    refresh: sheet.refresh
+  }), [state, sheet]);
+}
+function useOrderSheetAccount(client) {
+  const ctx = (0, import_react.useContext)(ClientContext);
+  const om = client ?? ctx;
+  const [account, setAccount] = (0, import_react.useState)(null);
+  const [loading, setLoading] = (0, import_react.useState)(true);
+  const [error, setError] = (0, import_react.useState)(null);
+  const refresh = (0, import_react.useCallback)(async () => {
+    if (!om) return;
+    setLoading(true);
+    try {
+      setAccount(await om.account({ force: true }));
+      setError(null);
+    } catch (e) {
+      setError(e);
+    } finally {
+      setLoading(false);
+    }
+  }, [om]);
+  (0, import_react.useEffect)(() => {
+    let alive = true;
+    if (!om) return;
+    om.account().then((a) => {
+      if (alive) {
+        setAccount(a);
+        setError(null);
+      }
+    }).catch((e) => {
+      if (alive) setError(e);
+    }).finally(() => {
+      if (alive) setLoading(false);
+    });
+    const off = om.events.on("constraints", (c) => {
+      if (alive && c) setAccount(om.accountFromConstraints(c));
+    });
+    return () => {
+      alive = false;
+      off();
+    };
+  }, [om]);
+  return { account, loading, error, refresh };
+}
+var HandleContext = (0, import_react.createContext)(null);
+function useOrderSheetHandle() {
+  const h = (0, import_react.useContext)(HandleContext);
+  if (!h) throw new Error("OrderSheet.* must be rendered inside <OrderSheet.Root handle={\u2026}>.");
+  return h;
+}
+var Root = (0, import_react.forwardRef)(function Root2({ handle, onOutcome, onPlaceError, children, ...rest }, ref) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(HandleContext.Provider, { value: handle, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    "form",
+    {
+      ref,
+      "data-oms-part": "root",
+      "data-phase": handle.phase,
+      "data-mode": handle.mode,
+      "data-order-type": handle.orderType,
+      "data-loading": handle.loading || void 0,
+      noValidate: true,
+      onSubmit: (e) => {
+        e.preventDefault();
+        handle.place().then((o) => onOutcome?.(o)).catch((err) => onPlaceError?.(err));
+      },
+      ...rest,
+      children
+    }
+  ) });
+});
+var VENUE_KEYS = /* @__PURE__ */ new Set(["ArrowRight", "ArrowDown", "ArrowLeft", "ArrowUp", "Home", "End"]);
+var isEnabledVenue = (v) => v.eligibility.status !== "blocked";
+function venueKeyTarget(key, venues, fromPartnerId) {
+  const enabled = venues.filter(isEnabledVenue);
+  if (enabled.length === 0 || !VENUE_KEYS.has(key)) return null;
+  if (key === "Home") return enabled[0];
+  if (key === "End") return enabled[enabled.length - 1];
+  const forward = key === "ArrowRight" || key === "ArrowDown";
+  const at = fromPartnerId == null ? -1 : venues.findIndex((v) => v.partnerId === fromPartnerId);
+  if (at < 0) return forward ? enabled[0] : enabled[enabled.length - 1];
+  const n = venues.length;
+  for (let step = 1; step <= n; step++) {
+    const v = venues[(at + (forward ? step : -step) + n * step) % n];
+    if (isEnabledVenue(v)) return v;
+  }
+  return null;
+}
+function tabbableVenueId(venues) {
+  return (venues.find((v) => v.selected) ?? venues.find(isEnabledVenue) ?? venues[0])?.partnerId ?? null;
+}
+function Venues({ render, hideBlocked, ...rest }) {
+  const h = useOrderSheetHandle();
+  const venues = hideBlocked ? h.venues.filter(isEnabledVenue) : h.venues;
+  const nodes = (0, import_react.useRef)(/* @__PURE__ */ new Map());
+  const tabbable = tabbableVenueId(venues);
+  const move = (key, from) => {
+    const target = venueKeyTarget(key, venues, from);
+    if (!target) return false;
+    h.select(target.partnerId);
+    nodes.current.get(target.partnerId)?.focus();
+    return true;
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { "data-oms-part": "venues", role: "radiogroup", "aria-label": "Venue", ...rest, children: venues.map((v) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    "div",
+    {
+      ref: (el) => {
+        if (el) nodes.current.set(v.partnerId, el);
+        else nodes.current.delete(v.partnerId);
+      },
+      "data-oms-part": "venue",
+      "data-state": v.eligibility.status,
+      "data-selected": v.selected || void 0,
+      "data-best": v.best || void 0,
+      "data-connected": v.account.connected || void 0,
+      role: "radio",
+      "aria-checked": v.selected,
+      "aria-disabled": v.eligibility.status === "blocked" || void 0,
+      tabIndex: v.partnerId === tabbable ? 0 : -1,
+      onClick: () => h.select(v.partnerId),
+      onKeyDown: (e) => {
+        if (e.key === "Enter" || e.key === " ") {
+          e.preventDefault();
+          h.select(v.partnerId);
+          return;
+        }
+        if (move(e.key, v.partnerId)) e.preventDefault();
+      },
+      children: render ? render(v, h) : /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { "data-oms-part": "venue-name", children: v.name }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { "data-oms-part": "venue-price", children: v.display.price }),
+        v.best && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { "data-oms-part": "venue-best", children: "best" }),
+        v.eligibility.issues[0] && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { "data-oms-part": "venue-reason", children: v.eligibility.issues[0].message })
+      ] })
+    },
+    v.partnerId
+  )) });
+}
+function Mode({ labels, ...rest }) {
+  const h = useOrderSheetHandle();
+  const modes = ["paper", "real"];
+  const available = h.account?.moneyModes ?? ["paper"];
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { "data-oms-part": "mode", role: "group", "aria-label": "Money mode", ...rest, children: modes.map((m) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    "button",
+    {
+      type: "button",
+      "data-oms-part": "mode-option",
+      "data-mode": m,
+      "data-available": available.includes(m) || void 0,
+      "aria-pressed": h.mode === m,
+      disabled: h.phase === "placing",
+      onClick: () => h.setMode(m),
+      children: m === "paper" ? labels?.paper ?? "Practice" : labels?.real ?? "Real money"
+    },
+    m
+  )) });
+}
+function OrderTypeToggle(props) {
+  const h = useOrderSheetHandle();
+  const types = ["market", "limit"];
+  const supported = h.venue?.supports.orderTypes ?? ["market"];
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { "data-oms-part": "order-type", role: "group", "aria-label": "Order type", ...props, children: types.map((t) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    "button",
+    {
+      type: "button",
+      "data-oms-part": "order-type-option",
+      "data-order-type": t,
+      "data-available": supported.includes(t) && !(h.mode === "paper" && t === "limit") || void 0,
+      "aria-pressed": h.orderType === t,
+      disabled: h.phase === "placing",
+      onClick: () => h.setOrderType(t),
+      children: t === "market" ? "Market" : "Limit"
+    },
+    t
+  )) });
+}
+function Stake({ label, unitToggle = true, bare, id, ...rest }) {
+  const h = useOrderSheetHandle();
+  const auto = (0, import_react.useId)();
+  const inputId = id ?? auto;
+  const unit = h.stake.unit;
+  const input = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    "input",
+    {
+      id: inputId,
+      "data-oms-part": "stake-input",
+      "data-unit": unit,
+      type: "number",
+      inputMode: "decimal",
+      min: 0,
+      step: unit === "amount" ? 0.01 : h.venue?.constraints?.size.whole_contracts ? 1 : 0.01,
+      value: h.stake.value ?? "",
+      disabled: h.phase === "placing",
+      onChange: (e) => {
+        const n = e.target.valueAsNumber;
+        h.setStake(Number.isFinite(n) ? n : null);
+      },
+      "aria-invalid": h.validation.blocking.some((i) => i.fix === "raise_stake" || i.fix === "lower_stake" || i.fix === "round_stake") || void 0,
+      ...rest
+    }
+  );
+  if (bare) return input;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { "data-oms-part": "stake", "data-unit": unit, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("label", { "data-oms-part": "stake-label", htmlFor: inputId, children: label ?? (unit === "amount" ? "Stake" : "Contracts") }),
+    input,
+    unitToggle && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { "data-oms-part": "stake-unit", role: "group", "aria-label": "Stake unit", children: ["amount", "shares"].map((u) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "button", "data-oms-part": "stake-unit-option", "data-unit": u, "aria-pressed": unit === u, onClick: () => h.setStake(h.stake.value, u), children: u === "amount" ? h.quote?.currency === "USD" || !h.quote ? "$" : h.quote.currency : "contracts" }, u)) })
+  ] });
+}
+function Price({ label, bare, id, ...rest }) {
+  const h = useOrderSheetHandle();
+  const auto = (0, import_react.useId)();
+  const inputId = id ?? auto;
+  const tick = h.venue?.constraints?.price.tick ?? 0.01;
+  const input = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    "input",
+    {
+      id: inputId,
+      "data-oms-part": "price-input",
+      "data-auto": h.maxPriceIsAuto || void 0,
+      type: "number",
+      inputMode: "decimal",
+      min: h.venue?.constraints?.price.min ?? 0.01,
+      max: h.venue?.constraints?.price.max ?? 0.99,
+      step: tick,
+      value: h.maxPrice ?? "",
+      disabled: h.phase === "placing",
+      onChange: (e) => {
+        const n = e.target.valueAsNumber;
+        h.setMaxPrice(Number.isFinite(n) ? n : null);
+      },
+      ...rest
+    }
+  );
+  if (bare) return input;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { "data-oms-part": "price", "data-auto": h.maxPriceIsAuto || void 0, "data-order-type": h.orderType, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("label", { "data-oms-part": "price-label", htmlFor: inputId, children: label ?? (h.orderType === "limit" ? "Limit price" : "Max price") }),
+    input,
+    !h.maxPriceIsAuto && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "button", "data-oms-part": "price-reset", onClick: () => h.setMaxPrice(null), children: "auto" })
+  ] });
+}
+function Quote({ render, ...rest }) {
+  const h = useOrderSheetHandle();
+  const q = h.quote;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { "data-oms-part": "quote", "data-freshness": q?.freshness, "aria-live": "polite", ...rest, children: render ? render(h) : q ? /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("dl", { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("dt", { children: "Price" }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("dd", { "data-oms-part": "quote-price", children: q.display.price }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("dt", { children: "Cost" }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("dd", { "data-oms-part": "quote-cost", children: q.display.cost }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("dt", { children: "Contracts" }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("dd", { "data-oms-part": "quote-contracts", children: q.contracts }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("dt", { children: "To win" }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("dd", { "data-oms-part": "quote-payout", children: q.display.payout }),
+    q.fee && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("dt", { children: "Fee" }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("dd", { "data-oms-part": "quote-fee", children: q.display.fee })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("dt", { children: "Profit" }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("dd", { "data-oms-part": "quote-profit", children: q.display.profit })
+  ] }) : null });
+}
+function Issues({ severities, render, ...rest }) {
+  const h = useOrderSheetHandle();
+  const list = h.validation.all.filter((i) => !severities || severities.includes(i.severity));
+  const hasBlock = list.some((i) => i.severity === "block");
+  return (
+    // polite, not assertive: a blocking issue can change on every keystroke of the
+    // stake, and an assertive region would interrupt the user each time.
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { "data-oms-part": "issues", role: "status", "aria-live": "polite", "data-blocking": hasBlock || void 0, ...rest, children: list.map((i) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { "data-oms-part": "issue", "data-severity": i.severity, "data-code": i.code, "data-fix": i.fix, "data-source": i.source, children: render ? render(i, h) : i.message }, `${i.scope}:${i.code}`)) })
+  );
+}
+function Submit({ children, ...rest }) {
+  const h = useOrderSheetHandle();
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    "button",
+    {
+      type: "submit",
+      "data-oms-part": "submit",
+      "data-mode": h.mode,
+      "data-phase": h.phase,
+      disabled: !h.canPlace,
+      "aria-busy": h.phase === "placing" || void 0,
+      ...rest,
+      children: typeof children === "function" ? children(h) : children ?? h.confirmLabel
+    }
+  );
+}
+function Hint({ render, ...rest }) {
+  const h = useOrderSheetHandle();
+  if (!h.hint) return null;
+  const v = h.hint.venue;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { "data-oms-part": "hint", ...rest, children: render ? render(v, h) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "button", "data-oms-part": "hint-switch", onClick: () => h.select(v.partnerId), children: h.hint.message }) });
+}
+function Outcome({ render, ...rest }) {
+  const h = useOrderSheetHandle();
+  const r = h.result;
+  if (!r) return null;
+  const leg = r.legs[0];
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { "data-oms-part": "outcome", "data-summary": r.summary, "data-phase": h.phase, "aria-live": "polite", ...rest, children: render ? render(h) : /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { "data-oms-part": "outcome-summary", children: h.phase }),
+    leg?.issue && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { "data-oms-part": "outcome-issue", children: leg.issue.message }),
+    leg && leg.fill.shares > 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { "data-oms-part": "outcome-fill", children: [
+      leg.fill.shares,
+      " @ ",
+      leg.fill.avgPrice ?? "\u2014"
+    ] }),
+    leg?.substituted && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { "data-oms-part": "outcome-substituted", children: "Filled on a different venue than requested \u2014 report this." })
+  ] }) });
+}
+var OrderSheet = {
+  Root,
+  Venues,
+  Mode,
+  OrderType: OrderTypeToggle,
+  Stake,
+  Price,
+  Quote,
+  Issues,
+  Submit,
+  Hint,
+  Outcome
+};