@forgezero/runtime 0.1.0

package/dist/finance/rates.js

@@ -0,0 +1,292 @@
+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/rates.ts
+class RateError extends Error {
+  code;
+  asset;
+  constructor(code, message, asset) {
+    super(message);
+    this.code = code;
+    this.asset = asset;
+    this.name = "RateError";
+  }
+}
+var BASE_ASSET = "USD";
+var RATE_SOURCES = ["peg", "venue", "manual"];
+var DECIMAL = /^\d+(\.\d+)?$/;
+function assertRate(rate) {
+  if (!DECIMAL.test(rate.usd.trim())) {
+    throw new RateError("BAD_RATE", `"${rate.usd}" is not a plain positive decimal.`, rate.asset);
+  }
+  if (Number(rate.usd) <= 0) {
+    throw new RateError("BAD_RATE", `A rate of ${rate.usd} for ${rate.asset} cannot be right.`, rate.asset);
+  }
+  if (rate.source === "peg" && rate.atMs !== undefined) {
+    throw new RateError("BAD_RATE", `${rate.asset} is pegged, so it has no timestamp — a peg that appears to age invites somebody to refresh it.`, rate.asset);
+  }
+  if (rate.source !== "peg" && rate.atMs === undefined) {
+    throw new RateError("BAD_RATE", `${rate.asset} is quoted from ${rate.source}, so it must carry when it was true. A rate with no age keeps quoting yesterday after the feed dies.`, rate.asset);
+  }
+}
+var peg = (asset, usd = "1") => ({ asset, source: "peg", usd });
+function createRateTable(options = {}) {
+  const maxAgeMs = options.maxAgeMs ?? 15 * 60000;
+  const now = options.now ?? Date.now;
+  const rates = new Map;
+  return {
+    set(rate) {
+      assertRate(rate);
+      rates.set(rate.asset, rate);
+    },
+    peek: (asset) => rates.get(asset),
+    ageOf(asset) {
+      const rate = rates.get(asset);
+      return rate?.atMs === undefined ? undefined : now() - rate.atMs;
+    },
+    isStale(asset) {
+      const rate = rates.get(asset);
+      if (!rate)
+        return true;
+      if (rate.source === "peg")
+        return false;
+      return now() - (rate.atMs ?? 0) > maxAgeMs;
+    },
+    require(asset) {
+      const rate = rates.get(asset);
+      if (!rate) {
+        throw new RateError("NO_RATE", `No USD rate is configured for ${asset}. Add a peg, a venue source, or a manual value.`, asset);
+      }
+      if (rate.source !== "peg" && now() - (rate.atMs ?? 0) > maxAgeMs) {
+        throw new RateError("STALE_RATE", `The ${asset} rate is ${Math.round((now() - (rate.atMs ?? 0)) / 60000)} minutes old; the limit is ${Math.round(maxAgeMs / 60000)}.`, asset);
+      }
+      return rate;
+    },
+    toUsd(amount) {
+      if (amount.asset === BASE_ASSET)
+        return amount;
+      return convert(amount, BASE_ASSET, this.require(amount.asset).usd, "down");
+    },
+    totalUsd(amounts) {
+      let total = parseAmount("0", BASE_ASSET);
+      for (const amount of amounts) {
+        const valued = this.toUsd(amount);
+        total = { units: total.units + valued.units, asset: BASE_ASSET };
+      }
+      return total;
+    },
+    all: () => [...rates.values()],
+    clear: () => rates.clear()
+  };
+}
+function registerAsset(entry) {
+  defineAsset({ code: entry.code, decimals: entry.decimals, label: entry.label });
+  assertRate(entry.rate);
+}
+var isRegistered = (code) => {
+  try {
+    assetSpec(code);
+    return true;
+  } catch {
+    return false;
+  }
+};
+async function refreshRates(table, fetcher, args) {
+  const now = args.now ?? Date.now;
+  const report = { refreshed: [], failed: [], skipped: [] };
+  for (const entry of args.assets) {
+    if (!entry.enabled || entry.rate.source !== "venue") {
+      report.skipped.push(entry.code);
+      continue;
+    }
+    try {
+      const usd = await fetcher.quote(entry.code);
+      if (!usd) {
+        report.failed.push({ asset: entry.code, reason: "the source does not quote it" });
+        continue;
+      }
+      table.set({ asset: entry.code, source: "venue", usd, atMs: now(), via: entry.rate.via });
+      report.refreshed.push(entry.code);
+    } catch (cause) {
+      report.failed.push({
+        asset: entry.code,
+        reason: cause instanceof Error ? cause.message : "unknown error"
+      });
+    }
+  }
+  return report;
+}
+function rateRefreshJob(args) {
+  return {
+    key: args.key ?? "rates.refresh",
+    everyMs: args.everyMs ?? 5 * 60000,
+    run: async () => {
+      const report = await refreshRates(args.table, args.fetcher, { assets: args.assets() });
+      return { ok: report.failed.length === 0, detail: report };
+    }
+  };
+}
+var describeRate = (rate, ageMs) => rate.source === "peg" ? `1 ${rate.asset} = ${formatAmount(parseAmount(rate.usd, BASE_ASSET), { trim: true })} USD, pegged` : `1 ${rate.asset} = ${rate.usd} USD from ${rate.via ?? rate.source}, ${ageMs === undefined ? "age unknown" : `${Math.round(ageMs / 1000)}s old`}`;
+export {
+  registerAsset,
+  refreshRates,
+  rateRefreshJob,
+  peg,
+  isRegistered,
+  describeRate,
+  createRateTable,
+  assertRate,
+  RateError,
+  RATE_SOURCES,
+  BASE_ASSET
+};

package/dist/finance/storage.d.ts

@@ -0,0 +1,113 @@
+import { type Money } from './money';
+/**
+ * How an amount is written to a database, and read back exactly.
+ *
+ * A ledger needs two incompatible things from the same value: perfect accuracy,
+ * and the ability to `SORT` and range-filter it. No single column gives both.
+ *
+ *   ACCURACY   `0.1` is not representable in IEEE-754, and 18-decimal minor
+ *              units exceed what a double can hold exactly above 2^53. Stored
+ *              as a number, a balance silently changes when it is read back.
+ *
+ *   SORTING    a string sorts lexically, so "9" comes after "10" and every
+ *              ORDER BY on a balance is wrong. Range filters are worse: they
+ *              silently return the wrong rows rather than failing.
+ *
+ * So both are stored, with one of them authoritative and the other explicitly
+ * not.
+ *
+ * ## Why the sort key cannot be an integer
+ *
+ * The obvious answer is "store minor units as a long". It does not work. One
+ * ETH is 10^18 minor units and a signed 64-bit integer stops at about
+ * 9.22 * 10^18, so the column overflows somewhere around nine ETH. For an
+ * 18-decimal asset an integer sort key is not a tradeoff, it is a defect that
+ * appears the first time somebody holds a real balance.
+ *
+ * The sort key is therefore a DOUBLE holding the whole-unit value. It is lossy
+ * by design and never read as money.
+ *
+ * ## The one property the sort key must have
+ *
+ * Monotonicity: if a is less than b, then sortKey(a) must not be greater than
+ * sortKey(b). Equal is fine — two enormous amounts a few units apart can share
+ * a double, and a tie broken by the exact string costs one comparison. What is
+ * never allowed is an INVERSION, because that is an ORDER BY that puts a larger
+ * balance below a smaller one, and no downstream code can detect it.
+ *
+ * Rounding to nearest gives exactly that: it can collapse two values together
+ * but cannot reorder them.
+ */
+/**
+ * One amount, as stored.
+ *
+ * `units` is the authority. `value` is the same number for a human and for any
+ * consumer that does not want to know the asset's decimals. `sort` is for the
+ * database and nothing else.
+ */
+export interface StoredMoney {
+    /** Minor units, as a base-10 string. THE authoritative field. */
+    units: string;
+    /** The same amount in whole units, exact, e.g. `"1234.5678"`. */
+    value: string;
+    asset: string;
+    /**
+     * Whole units as a double, for ORDER BY and range filters ONLY.
+     *
+     * Never read this back as money and never compute with it. It exists so the
+     * database can order rows it cannot otherwise order.
+     */
+    sort: number;
+}
+/** The field a query sorts on, so callers do not hardcode the name. */
+export declare const SORT_FIELD: "sort";
+/**
+ * Write an amount.
+ *
+ * `value` is derived from `units` rather than carried alongside it, so the two
+ * cannot disagree — a row where they do is a row nobody can reconcile.
+ */
+export declare function toStored(amount: Money): StoredMoney;
+/**
+ * Read an amount back, exactly.
+ *
+ * From `units`, never from `sort` and never from `value`. `units` is the only
+ * field that survives a round trip unchanged for every asset.
+ */
+export declare function fromStored(stored: StoredMoney): Money;
+/**
+ * The sortable double for an amount.
+ *
+ * Round-to-nearest via `Number(string)`, which is monotonic: it can map two
+ * distinct amounts to one double but can never swap their order.
+ *
+ * Beyond roughly 1.8e308 a double is `Infinity`. That is still monotonic and
+ * still sorts correctly at the top of the range; it is only unusable as a
+ * value, which it already was.
+ */
+export declare function sortKey(amount: Money): number;
+/**
+ * Bounds for a range filter, widened so the coarse index cannot exclude a row
+ * that genuinely matches.
+ *
+ * A filter written directly against `sort` can drop a boundary row, because the
+ * stored double may sit a fraction below the true value. Widening by one ULP in
+ * each direction makes the database step a SUPERSET, which the caller then
+ * narrows exactly. A superset is recoverable; a missing row is not, because
+ * nothing downstream knows it should have been there.
+ */
+export declare function rangeBounds(from: Money | null, to: Money | null): {
+    gte?: number;
+    lte?: number;
+};
+/** Exact comparison, for narrowing what the coarse filter returned. */
+export declare function withinRange(amount: Money, from: Money | null, to: Money | null): boolean;
+/**
+ * Sort rows exactly, breaking the ties the double could not.
+ *
+ * Used where the whole set is already in memory. For anything larger the
+ * database orders by `sort` and this settles the equal keys.
+ */
+export declare function sortExact<T>(rows: readonly T[], pick: (row: T) => Money, direction?: 'asc' | 'desc'): T[];
+/** Parse and store in one step — the common path from a form or an API body. */
+export declare const storeAmount: (value: string, asset: string) => StoredMoney;

package/dist/finance/storage.js

@@ -0,0 +1,226 @@
+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/storage.ts
+var SORT_FIELD = "sort";
+function toStored(amount) {
+  const value = formatAmount(amount);
+  return {
+    units: amount.units.toString(),
+    value,
+    asset: amount.asset,
+    sort: sortKey(amount)
+  };
+}
+function fromStored(stored) {
+  if (!/^-?\d+$/.test(stored.units)) {
+    throw new MoneyError("NOT_FINITE", `Stored units are not an integer: ${stored.units}`);
+  }
+  assetSpec(stored.asset);
+  return { units: BigInt(stored.units), asset: stored.asset };
+}
+function sortKey(amount) {
+  return Number(formatAmount(amount));
+}
+function rangeBounds(from, to) {
+  const bounds = {};
+  if (from)
+    bounds.gte = previousDouble(sortKey(from));
+  if (to)
+    bounds.lte = nextDouble(sortKey(to));
+  return bounds;
+}
+function withinRange(amount, from, to) {
+  if (from && compare(amount, from) < 0)
+    return false;
+  if (to && compare(amount, to) > 0)
+    return false;
+  return true;
+}
+function sortExact(rows, pick, direction = "asc") {
+  const sign = direction === "asc" ? 1 : -1;
+  return [...rows].sort((a, b) => sign * compare(pick(a), pick(b)));
+}
+var storeAmount = (value, asset) => toStored(parseAmount(value, asset));
+var nextDouble = (value) => {
+  if (!Number.isFinite(value))
+    return value;
+  if (value === 0)
+    return Number.MIN_VALUE;
+  const buffer = new DataView(new ArrayBuffer(8));
+  buffer.setFloat64(0, value);
+  const bits = buffer.getBigUint64(0);
+  buffer.setBigUint64(0, value > 0 ? bits + 1n : bits - 1n);
+  return buffer.getFloat64(0);
+};
+var previousDouble = (value) => {
+  if (!Number.isFinite(value))
+    return value;
+  if (value === 0)
+    return -Number.MIN_VALUE;
+  const buffer = new DataView(new ArrayBuffer(8));
+  buffer.setFloat64(0, value);
+  const bits = buffer.getBigUint64(0);
+  buffer.setBigUint64(0, value > 0 ? bits - 1n : bits + 1n);
+  return buffer.getFloat64(0);
+};
+export {
+  withinRange,
+  toStored,
+  storeAmount,
+  sortKey,
+  sortExact,
+  rangeBounds,
+  fromStored,
+  SORT_FIELD
+};