@forgezero/runtime 0.1.13 → 0.1.15

package/dist/finance/ledger.js

@@ -1,313 +0,0 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined")
-    return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
-// src/finance/money.ts
-class MoneyError extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "MoneyError";
-  }
-}
-var ASSETS = [
-  { code: "USDT", decimals: 6 },
-  { code: "USDC", decimals: 6 },
-  { code: "BTC", decimals: 8 },
-  { code: "ETH", decimals: 18 },
-  { code: "BNB", decimals: 18 },
-  { code: "EUR", decimals: 2 },
-  { code: "USD", decimals: 2 }
-];
-var REGISTRY = new Map(ASSETS.map((asset) => [asset.code, asset]));
-function defineAsset(spec) {
-  if (spec.decimals < 0 || spec.decimals > 30 || !Number.isInteger(spec.decimals)) {
-    throw new MoneyError("UNKNOWN_ASSET", `${spec.code}: decimals must be an integer 0–30.`);
-  }
-  REGISTRY.set(spec.code, spec);
-}
-function assetSpec(code) {
-  const spec = REGISTRY.get(code);
-  if (!spec)
-    throw new MoneyError("UNKNOWN_ASSET", `Unknown asset "${code}". Call defineAsset first.`);
-  return spec;
-}
-var money = (units, asset) => {
-  assetSpec(asset);
-  return { units, asset };
-};
-var zero = (asset) => money(0n, asset);
-function parseAmount(value, asset) {
-  const spec = assetSpec(asset);
-  const text = value.trim();
-  if (!/^-?\d+(\.\d+)?$/.test(text)) {
-    throw new MoneyError("NOT_FINITE", `"${value}" is not a plain decimal amount.`);
-  }
-  const negative = text.startsWith("-");
-  const [whole, fraction = ""] = text.replace("-", "").split(".");
-  if (fraction.length > spec.decimals) {
-    throw new MoneyError("PRECISION_LOSS", `${asset} has ${spec.decimals} decimals; "${value}" has ${fraction.length}.`);
-  }
-  const padded = fraction.padEnd(spec.decimals, "0");
-  const units = BigInt(whole + padded);
-  return { units: negative ? -units : units, asset };
-}
-function formatAmount(amount, options = {}) {
-  const spec = assetSpec(amount.asset);
-  const negative = amount.units < 0n;
-  const digits = (negative ? -amount.units : amount.units).toString().padStart(spec.decimals + 1, "0");
-  const whole = digits.slice(0, digits.length - spec.decimals);
-  let fraction = spec.decimals === 0 ? "" : digits.slice(digits.length - spec.decimals);
-  if (options.trim && fraction)
-    fraction = fraction.replace(/0+$/, "");
-  return `${negative ? "-" : ""}${whole}${fraction ? `.${fraction}` : ""}`;
-}
-function sameAsset(a, b) {
-  if (a.asset !== b.asset) {
-    throw new MoneyError("ASSET_MISMATCH", `Cannot combine ${a.asset} and ${b.asset}.`);
-  }
-}
-function add(a, b) {
-  sameAsset(a, b);
-  return { units: a.units + b.units, asset: a.asset };
-}
-function subtract(a, b) {
-  sameAsset(a, b);
-  return { units: a.units - b.units, asset: a.asset };
-}
-var negate = (amount) => ({ units: -amount.units, asset: amount.asset });
-var abs = (amount) => ({
-  units: amount.units < 0n ? -amount.units : amount.units,
-  asset: amount.asset
-});
-var isZero = (amount) => amount.units === 0n;
-var isNegative = (amount) => amount.units < 0n;
-function compare(a, b) {
-  sameAsset(a, b);
-  return a.units < b.units ? -1 : a.units > b.units ? 1 : 0;
-}
-var equals = (a, b) => a.asset === b.asset && a.units === b.units;
-var ROUNDING = ["down", "up", "half-up"];
-function divideRounded(numerator, denominator, mode) {
-  if (denominator === 0n)
-    throw new MoneyError("DIVIDE_BY_ZERO", "Division by zero.");
-  const negative = numerator < 0n !== denominator < 0n;
-  const a = numerator < 0n ? -numerator : numerator;
-  const b = denominator < 0n ? -denominator : denominator;
-  const quotient = a / b;
-  const remainder = a % b;
-  if (remainder === 0n)
-    return negative ? -quotient : quotient;
-  let result = quotient;
-  if (mode === "up")
-    result += 1n;
-  else if (mode === "half-up" && remainder * 2n >= b)
-    result += 1n;
-  return negative ? -result : result;
-}
-function mulRate(amount, rate, mode = "down") {
-  if (!/^-?\d+(\.\d+)?$/.test(rate.trim())) {
-    throw new MoneyError("NOT_FINITE", `"${rate}" is not a plain decimal rate.`);
-  }
-  const [whole, fraction = ""] = rate.trim().replace("-", "").split(".");
-  const scale = 10n ** BigInt(fraction.length);
-  const scaled = BigInt(whole + fraction) * (rate.trim().startsWith("-") ? -1n : 1n);
-  return { units: divideRounded(amount.units * scaled, scale, mode), asset: amount.asset };
-}
-function convert(amount, to, rate, mode = "down") {
-  const from = assetSpec(amount.asset);
-  const target = assetSpec(to);
-  const asTarget = mulRate({ units: amount.units, asset: to }, rate, mode);
-  const shift = target.decimals - from.decimals;
-  if (shift === 0)
-    return asTarget;
-  if (shift > 0)
-    return { units: asTarget.units * 10n ** BigInt(shift), asset: to };
-  return { units: divideRounded(asTarget.units, 10n ** BigInt(-shift), mode), asset: to };
-}
-function allocate(amount, parts) {
-  if (parts < 1)
-    throw new MoneyError("NOT_FINITE", "Cannot allocate into fewer than one part.");
-  const each = divideRounded(amount.units, BigInt(parts), "down");
-  const allocated = Array.from({ length: parts }, () => each);
-  let remainder = amount.units - each * BigInt(parts);
-  const step = remainder < 0n ? -1n : 1n;
-  for (let index = 0;remainder !== 0n; index = (index + 1) % parts) {
-    allocated[index] += step;
-    remainder -= step;
-  }
-  return allocated.map((units) => ({ units, asset: amount.asset }));
-}
-function toStep(amount, step, mode = "down") {
-  const stepUnits = parseAmount(step, amount.asset).units;
-  if (stepUnits <= 0n)
-    throw new MoneyError("NOT_FINITE", "A step must be positive.");
-  return { units: divideRounded(amount.units, stepUnits, mode) * stepUnits, asset: amount.asset };
-}
-var VERSION = "0.1.0";
-
-// src/finance/ledger.ts
-class LedgerError extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "LedgerError";
-  }
-}
-var BUCKETS = ["available", "held"];
-var ACCOUNT_KINDS = ["user", "platform", "external"];
-var accountId = (account) => `${account.kind}:${account.owner}:${account.bucket ?? "available"}`;
-function parseAccount(id) {
-  const [kind, owner, bucket] = id.split(":");
-  return { kind, owner, bucket };
-}
-var queueKeyFor = (account) => `${account.kind}:${account.owner}`;
-var MAX_LEDGER_ENTRIES = 64;
-function assertBalanced(transaction) {
-  if (transaction.entries.length < 2) {
-    throw new LedgerError("EMPTY_TRANSACTION", "A transaction needs at least two entries.");
-  }
-  if (transaction.entries.length > MAX_LEDGER_ENTRIES) {
-    throw new LedgerError("TOO_MANY_ENTRIES", `A transaction may contain at most ${MAX_LEDGER_ENTRIES} entries; split this batch into separate transactions.`);
-  }
-  const totals = new Map;
-  for (const entry of transaction.entries) {
-    if (entry.amount.units === 0n) {
-      throw new LedgerError("ZERO_ENTRY", `An entry on ${accountId(entry.account)} moves nothing. Remove it or give it an amount.`);
-    }
-    totals.set(entry.amount.asset, (totals.get(entry.amount.asset) ?? 0n) + entry.amount.units);
-  }
-  for (const [asset, total] of totals) {
-    if (total !== 0n) {
-      throw new LedgerError("UNBALANCED", `${asset} does not sum to zero — it is off by ${total} minor units. Every movement needs a counterparty.`);
-    }
-  }
-}
-function transfer(args) {
-  const transaction = {
-    reference: args.reference,
-    kind: args.kind,
-    atMs: args.atMs,
-    memo: args.memo,
-    entries: [
-      { account: args.from, amount: { units: -args.amount.units, asset: args.amount.asset } },
-      { account: args.to, amount: args.amount }
-    ]
-  };
-  assertBalanced(transaction);
-  return transaction;
-}
-var placeHold = (args) => transfer({
-  reference: args.reference,
-  kind: "hold.place",
-  from: { kind: args.kind ?? "user", owner: args.owner, bucket: "available" },
-  to: { kind: args.kind ?? "user", owner: args.owner, bucket: "held" },
-  amount: args.amount,
-  atMs: args.atMs,
-  memo: args.memo
-});
-var releaseHold = (args) => transfer({
-  reference: args.reference,
-  kind: "hold.release",
-  from: { kind: args.kind ?? "user", owner: args.owner, bucket: "held" },
-  to: { kind: args.kind ?? "user", owner: args.owner, bucket: "available" },
-  amount: args.amount,
-  atMs: args.atMs
-});
-var captureHold = (args) => transfer({
-  reference: args.reference,
-  kind: "hold.capture",
-  from: { kind: args.kind ?? "user", owner: args.owner, bucket: "held" },
-  to: args.to,
-  amount: args.amount,
-  atMs: args.atMs,
-  memo: args.memo
-});
-function balancesFrom(transactions) {
-  const balances = new Map;
-  for (const transaction of transactions) {
-    for (const entry of transaction.entries) {
-      const id = accountId(entry.account);
-      const perAsset = balances.get(id) ?? new Map;
-      const current = perAsset.get(entry.amount.asset) ?? zero(entry.amount.asset);
-      perAsset.set(entry.amount.asset, add(current, entry.amount));
-      balances.set(id, perAsset);
-    }
-  }
-  return balances;
-}
-function balanceOf(balances, account, asset) {
-  return balances.get(accountId(account))?.get(asset) ?? zero(asset);
-}
-var availableOf = (balances, owner, asset, kind = "user") => balanceOf(balances, { kind, owner, bucket: "available" }, asset);
-var heldOf = (balances, owner, asset, kind = "user") => balanceOf(balances, { kind, owner, bucket: "held" }, asset);
-var totalOf = (balances, owner, asset, kind = "user") => add(availableOf(balances, owner, asset, kind), heldOf(balances, owner, asset, kind));
-function trialBalance(transactions) {
-  const totals = new Map;
-  const accounts = new Map;
-  for (const transaction of transactions) {
-    for (const entry of transaction.entries) {
-      totals.set(entry.amount.asset, (totals.get(entry.amount.asset) ?? 0n) + entry.amount.units);
-      const seen = accounts.get(entry.amount.asset) ?? new Set;
-      seen.add(accountId(entry.account));
-      accounts.set(entry.amount.asset, seen);
-    }
-  }
-  const perAsset = [...totals.entries()].map(([asset, total]) => ({
-    asset,
-    total,
-    accounts: accounts.get(asset)?.size ?? 0
-  }));
-  const discrepancies = perAsset.filter((row) => row.total !== 0n).map((row) => ({ asset: row.asset, off: row.total }));
-  return { ok: discrepancies.length === 0, perAsset, discrepancies };
-}
-function statement(transactions, account, asset) {
-  const id = accountId(account);
-  let running = zero(asset);
-  return [...transactions].sort((a, b) => a.atMs - b.atMs).flatMap((transaction) => transaction.entries.filter((entry) => accountId(entry.account) === id && entry.amount.asset === asset).map((entry) => {
-    running = add(running, entry.amount);
-    return {
-      atMs: transaction.atMs,
-      reference: transaction.reference,
-      kind: transaction.kind,
-      amount: formatAmount(entry.amount, { trim: true }),
-      balance: formatAmount(running, { trim: true })
-    };
-  }));
-}
-function assertAvailable(balances, args) {
-  const available = availableOf(balances, args.owner, args.amount.asset, args.kind ?? "user");
-  if (subtract(available, args.amount).units < 0n) {
-    throw new LedgerError("INSUFFICIENT_AVAILABLE", `${args.owner} has ${formatAmount(available, { trim: true })} ${args.amount.asset} available; this needs ${formatAmount(args.amount, { trim: true })}.`);
-  }
-}
-var VERSION2 = "0.1.0";
-export {
-  trialBalance,
-  transfer,
-  totalOf,
-  statement,
-  releaseHold,
-  queueKeyFor,
-  placeHold,
-  parseAccount,
-  heldOf,
-  captureHold,
-  balancesFrom,
-  balanceOf,
-  availableOf,
-  assertBalanced,
-  assertAvailable,
-  accountId,
-  VERSION2 as VERSION,
-  MAX_LEDGER_ENTRIES,
-  LedgerError,
-  BUCKETS,
-  ACCOUNT_KINDS
-};

package/dist/finance/market.d.ts

@@ -1,209 +0,0 @@
-import { type Money } from './money';
-/**
- * Prices from several venues, with staleness stated rather than assumed.
- *
- * The thing this exists to prevent is two projects each growing their own price
- * client with their own private opinion about what "current" means. That
- * disagreement is invisible — both return a number, both look right — and it
- * surfaces as one service valuing a position at a price another service already
- * considered dead.
- *
- * So the model here is small and explicit:
- *
- *   A price is a VALUE AND AN AGE. Never a value alone.
- *   Age is measured against a clock the CALLER passes in, not `Date.now()`.
- *   Past a stated limit, a price is not returned — it is refused.
- *
- * ## Refusing beats returning a stale number
- *
- * The tempting design returns the last known price with a flag, and every
- * caller is expected to check it. They do not. A liquidation priced off a
- * twenty-minute-old book is the loss this prevents, and it is prevented by
- * making the stale case impossible to consume by accident rather than by
- * documenting it.
- *
- * ## Why no HTTP here
- *
- * `@forgezero/runtime` holds no credentials and no network, and it may not
- * import `@forgezero/providers` — that direction is enforced, because pricing
- * that depends on a provider registry cannot be used by the provider registry.
- * A venue is injected as a function returning quotes. The same feed therefore
- * runs against a live socket, a recorded session, or a fixture, and the tests
- * exercise real staleness and disagreement rather than a mock of them.
- */
-export declare class MarketError extends Error {
-    readonly code: 'STALE' | 'NO_PRICE' | 'UNKNOWN_SYMBOL' | 'MALFORMED';
-    /**
-     * The measurements behind the refusal.
-     *
-     * Carried on the error because a subscriber turning a refusal into an
-     * event needs the numbers, and recomputing them from outside would mean a
-     * second implementation of the check that just ran — free to disagree
-     * with the first.
-     */
-    readonly detail: {
-        youngestAgeMs?: number;
-        spread?: number;
-    };
-    constructor(code: 'STALE' | 'NO_PRICE' | 'UNKNOWN_SYMBOL' | 'MALFORMED', message: string, 
-    /**
-     * The measurements behind the refusal.
-     *
-     * Carried on the error because a subscriber turning a refusal into an
-     * event needs the numbers, and recomputing them from outside would mean a
-     * second implementation of the check that just ran — free to disagree
-     * with the first.
-     */
-    detail?: {
-        youngestAgeMs?: number;
-        spread?: number;
-    });
-}
-/** One venue's view of one symbol at one instant. */
-export interface Quote {
-    venue: string;
-    symbol: string;
-    /** Mid, or last trade — the venue decides, and says so in `kind`. */
-    price: Money;
-    kind: 'trade' | 'mid' | 'index';
-    /** When the VENUE says this was true, not when we received it. */
-    atMs: number;
-    /** Best bid and ask, when the venue publishes a book. */
-    bid?: Money;
-    ask?: Money;
-}
-/**
- * How old a price may be before it stops being a price.
- *
- * Per symbol class rather than one global number, because the right staleness
- * for a major pair is not the right staleness for something that trades twice
- * an hour — a single limit either rejects every quote on the illiquid one or
- * accepts a dead quote on the liquid one.
- */
-export interface StalenessPolicy {
-    /** Applies to anything without a more specific rule. */
-    defaultMs: number;
-    /** Keyed by symbol. Overrides the default exactly. */
-    bySymbol?: Readonly<Record<string, number>>;
-}
-export declare const limitFor: (policy: StalenessPolicy, symbol: string) => number;
-/**
- * How old this quote is, in milliseconds.
- *
- * Negative when a venue's clock runs ahead of ours — reported rather than
- * clamped to zero. A venue consistently ahead is a real condition worth seeing,
- * and clamping makes it look like a fresh quote forever.
- */
-export declare const stalenessOf: (quote: Quote, nowMs: number) => number;
-export declare const isStale: (quote: Quote, policy: StalenessPolicy, nowMs: number) => boolean;
-/** A venue, reduced to the one thing this module needs from it. */
-export interface VenueSource {
-    venue: string;
-    /** Latest known quote, or null when this venue has never seen the symbol. */
-    latest(symbol: string): Quote | null;
-}
-export interface FeedOptions {
-    sources: readonly VenueSource[];
-    policy: StalenessPolicy;
-    /**
-     * Venue preference, most trusted first.
-     *
-     * Not a fallback list — every fresh quote is considered, and this only breaks
-     * a tie. A strict fallback order means the second venue is consulted only
-     * when the first is silent, which hides a first venue quoting nonsense.
-     */
-    prefer?: readonly string[];
-    /**
-     * How far two venues may disagree before the feed refuses to pick, as a
-     * fraction — `0.05` is five per cent.
-     *
-     * Disagreement past this is not a price to choose between; it is a signal
-     * that one venue is broken, and choosing either is how a bad print becomes a
-     * filled order. Undefined means never refuse on disagreement.
-     */
-    maxDisagreement?: number;
-}
-export interface PriceResult {
-    quote: Quote;
-    ageMs: number;
-    /** Every fresh quote considered, including the one chosen. */
-    considered: readonly Quote[];
-    /** Largest fractional gap among those, or 0 when only one venue had a price. */
-    spread: number;
-}
-/**
- * The widest fractional gap between any two of these quotes.
- *
- * Measured against the SMALLER of each pair, so the figure is what it would
- * cost to be on the wrong side — dividing by the larger understates exactly the
- * case that matters.
- */
-export declare function disagreementOf(quotes: readonly Quote[]): number;
-/**
- * A feed over several venues.
- *
- * Holds no state and starts nothing. The sources are already-connected things a
- * caller owns; this decides what to believe from them, which is the part that
- * two projects would otherwise each get slightly differently.
- */
-export declare function createFeed(options: FeedOptions): {
-    /** Every venue's current view, fresh or not. For an operator screen. */
-    snapshot(symbol: string, nowMs: number): readonly (Quote & {
-        ageMs: number;
-        stale: boolean;
-    })[];
-    /**
-     * The price, or an error explaining which of the two ways it failed.
-     *
-     * "No venue has ever seen this symbol" and "every venue's price is too old"
-     * are different problems with different fixes — a missing subscription
-     * versus a dead connection — and one error covering both sends whoever is
-     * paged to the wrong place.
-     */
-    price(symbol: string, nowMs: number): PriceResult;
-};
-export type Feed = ReturnType<typeof createFeed>;
-/**
- * The price alone, for callers that only want the number.
- *
- * Still throws on stale — the convenience is in the return type, never in the
- * checking. A helper that returned a possibly-stale number would reintroduce
- * exactly the failure this module exists to remove.
- */
-export declare const lastPrice: (feed: Feed, symbol: string, nowMs: number) => Money;
-/** A change worth telling a subscriber about. */
-export type FeedEvent = {
-    type: 'price';
-    symbol: string;
-    result: PriceResult;
-} | {
-    type: 'stale';
-    symbol: string;
-    youngestAgeMs: number;
-} | {
-    type: 'disagreement';
-    symbol: string;
-    spread: number;
-};
-/**
- * Watch a set of symbols, and be told when the ANSWER changes.
- *
- * Deliberately not "be told when a quote arrives". A busy venue publishes many
- * times a second and almost none of it changes what the feed would answer, so
- * forwarding every tick makes a subscriber's own throttling load-bearing — and
- * whichever project writes that throttle badly gets a different price from the
- * one that writes it well.
- *
- * Transitions into and out of staleness are events in their own right. A
- * subscriber that only hears about prices cannot tell a quiet market from a
- * dead connection, which is the distinction the whole module is built around.
- */
-export declare function subscribe(feed: Feed, args: {
-    symbols: readonly string[];
-    onEvent: (event: FeedEvent) => void;
-    /** Injected, so a test drives time instead of waiting for it. */
-    now: () => number;
-}): {
-    poll: () => void;
-    seen: () => ReadonlyMap<string, string>;
-};

package/dist/finance/market.js

@@ -1,112 +0,0 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined")
-    return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
-// src/finance/market.ts
-class MarketError extends Error {
-  code;
-  detail;
-  constructor(code, message, detail = {}) {
-    super(message);
-    this.code = code;
-    this.detail = detail;
-    this.name = "MarketError";
-  }
-}
-var limitFor = (policy, symbol) => policy.bySymbol?.[symbol] ?? policy.defaultMs;
-var stalenessOf = (quote, nowMs) => nowMs - quote.atMs;
-var isStale = (quote, policy, nowMs) => stalenessOf(quote, nowMs) > limitFor(policy, quote.symbol);
-var asNumber = (amount) => Number(amount.units);
-function disagreementOf(quotes) {
-  if (quotes.length < 2)
-    return 0;
-  const values = quotes.map((quote) => asNumber(quote.price)).filter((value) => value > 0);
-  if (values.length < 2)
-    return 0;
-  const low = Math.min(...values);
-  const high = Math.max(...values);
-  return (high - low) / low;
-}
-function createFeed(options) {
-  if (options.sources.length === 0) {
-    throw new MarketError("MALFORMED", "A feed needs at least one venue.");
-  }
-  if (options.policy.defaultMs <= 0) {
-    throw new MarketError("MALFORMED", "A staleness limit is a positive number of milliseconds.");
-  }
-  const rank = (venue) => {
-    const at = options.prefer?.indexOf(venue) ?? -1;
-    return at === -1 ? Number.MAX_SAFE_INTEGER : at;
-  };
-  return {
-    snapshot(symbol, nowMs) {
-      return options.sources.map((source) => source.latest(symbol)).filter((quote) => quote !== null).map((quote) => ({
-        ...quote,
-        ageMs: stalenessOf(quote, nowMs),
-        stale: isStale(quote, options.policy, nowMs)
-      }));
-    },
-    price(symbol, nowMs) {
-      const seen = options.sources.map((source) => source.latest(symbol)).filter((quote) => quote !== null);
-      if (seen.length === 0) {
-        throw new MarketError("UNKNOWN_SYMBOL", `No venue has a price for ${symbol}.`);
-      }
-      const fresh = seen.filter((quote) => !isStale(quote, options.policy, nowMs));
-      if (fresh.length === 0) {
-        const youngest = Math.min(...seen.map((quote) => stalenessOf(quote, nowMs)));
-        throw new MarketError("STALE", `Every price for ${symbol} is stale — the youngest is ${youngest}ms old, and the limit is ` + `${limitFor(options.policy, symbol)}ms. Returning it anyway is how a stale book prices a liquidation.`, { youngestAgeMs: youngest });
-      }
-      const spread = disagreementOf(fresh);
-      if (options.maxDisagreement !== undefined && spread > options.maxDisagreement) {
-        throw new MarketError("NO_PRICE", `Venues disagree on ${symbol} by ${(spread * 100).toFixed(2)}%, past the ` + `${(options.maxDisagreement * 100).toFixed(2)}% limit. One of them is wrong and this cannot say which.`, { spread });
-      }
-      const chosen = [...fresh].sort((a, b) => rank(a.venue) - rank(b.venue) || b.atMs - a.atMs)[0];
-      return { quote: chosen, ageMs: stalenessOf(chosen, nowMs), considered: fresh, spread };
-    }
-  };
-}
-var lastPrice = (feed, symbol, nowMs) => feed.price(symbol, nowMs).quote.price;
-function subscribe(feed, args) {
-  const last = new Map;
-  const poll = () => {
-    const nowMs = args.now();
-    for (const symbol of args.symbols) {
-      let signature;
-      let event;
-      try {
-        const result = feed.price(symbol, nowMs);
-        signature = `price:${result.quote.venue}:${result.quote.price.units}`;
-        event = { type: "price", symbol, result };
-      } catch (cause) {
-        if (!(cause instanceof MarketError))
-          throw cause;
-        if (cause.code === "NO_PRICE") {
-          signature = "disagreement";
-          event = { type: "disagreement", symbol, spread: cause.detail.spread ?? 0 };
-        } else {
-          signature = cause.code;
-          event = { type: "stale", symbol, youngestAgeMs: cause.detail.youngestAgeMs ?? 0 };
-        }
-      }
-      if (last.get(symbol) === signature)
-        continue;
-      last.set(symbol, signature);
-      args.onEvent(event);
-    }
-  };
-  return { poll, seen: () => last };
-}
-export {
-  subscribe,
-  stalenessOf,
-  limitFor,
-  lastPrice,
-  isStale,
-  disagreementOf,
-  createFeed,
-  MarketError
-};