@johannc-dev/zyrk 0.2.0 → 0.2.2

package/dist/export.d.ts

@@ -5,16 +5,19 @@ export interface ExportConnection {
     readonly url: string;
     /** API key (`TH_API_KEY`) of an account with hosted functions. */
     readonly apiKey: string;
-    /** At most this many requests per minute (default: as fast as the server allows). */
+    /** At most this many requests per minute (default: as fast as the server allows, 30 a second per account). Optional pacing only. */
     readonly rpm?: number;
-    /** Network or 5xx failures tolerated in a row before giving up (default 8). */
+    /** Network failures, 502, 503 and 504 tolerated in a row before giving up (default 8); another 5xx is retried once. */
     readonly maxRetries?: number;
-    /** Longest wait accepted on a 429 before stopping (default 5 minutes): a daily quota stops the export. */
+    /** Longest wait accepted on 429s in a row before stopping (default 5 minutes): a longer one (an older server's daily quota) stops the export. */
     readonly maxWaitMs?: number;
     readonly fetch?: typeof fetch;
     readonly signal?: AbortSignal;
     readonly onProgress?: (progress: ExportProgress) => void;
-    /** Hours that may still change (open, not sealed), files downloaded again. */
+    /**
+     * Hours that may still change (open, not sealed), files downloaded again,
+     * errors saved as the answer of a call.
+     */
     readonly onWarning?: (message: string) => void;
 }
 export interface ExportProgress {
@@ -52,7 +55,7 @@ export interface ExportSummary {
 }
 /** `[since, until)` in parts of at most 30 days, ending on UTC day boundaries. */
 export declare function parts(sinceMs: number, untilMs: number): [number, number][];
-/** Meta of an export answer (`history_columns::export::hour_response`). */
+/** Meta of an export answer. */
 interface HourMeta {
     readonly format?: string;
     readonly coverage?: ReadMeta["coverage"];
@@ -76,12 +79,28 @@ export declare function parseFrame(bytes: Uint8Array): {
 export declare function staleFrom(meta: ReadMeta, dir: string): number | null;
 /** Exports one read (cut into parts of at most 30 days). Resumes an interrupted export. */
 export declare function exportHistory(connection: ExportConnection, out: string, read: ExportRead): Promise<ExportSummary>;
-/** Saves `/v1/tokens/{mint}/totals` for `ctx.data.tokenTotals`. */
+/**
+ * Saves the totals of a mint for `ctx.data.tokenTotals`, and its info for
+ * `ctx.data.tokenInfo`, as hosted programs receive them. Returns the totals,
+ * or the error answer saved for them (`{ error: { kind, code, message } }`).
+ */
 export declare function exportTotals(connection: ExportConnection, out: string, mint: string, quote?: string | null): Promise<Json>;
 /**
- * Saves every page of `/v1/volume/search` for `params`, following the
+ * Saves the answer of `ctx.compute(plan)` (a plan or an array of plans), as
+ * the service computes it for a function (`POST /v1/functions/compute`, the
+ * same engine), so that the same call in a local run finds it. Relative
+ * windows (`last`, an `until` left out) are resolved now, at export. An
+ * error answer (an invalid plan, a limit) is saved as that error.
+ */
+export declare function exportCompute(connection: ExportConnection, out: string, plan: Json): Promise<{
+    rows: number | null;
+}>;
+/**
+ * Saves every page of a volume search for `params`, following the
  * cursor exactly as `ctx.data.volumeSearch` does, so that the same call in
- * a local run finds each page.
+ * a local run finds each page. A page answered by an error (an invalid
+ * parameter...) is saved as that error, and ends the search, as it does in a
+ * hosted call.
  */
 export declare function exportVolumeSearch(connection: ExportConnection, out: string, params: VolumeSearchParams): Promise<number>;
 export {};

package/dist/export.js

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { decompressHour } from "./hourfile.js";
-import { HOUR_MS, READ_FORMAT, sha256, readId, spec as readSpec, totalsName, volumeName, } from "./local-data.js";
+import { HOUR_MS, READ_FORMAT, infoName, sha256, readId, spec as readSpec, totalsName, volumeName, computeName, } from "./local-data.js";
 import { MAX_WINDOW_MS } from "./limits.js";
 const DAY_MS = 86_400_000;
 const PART_MS = 30 * DAY_MS;
@@ -40,6 +40,8 @@ const writeAtomic = (file, data) => {
     writeFileSync(tmp, data);
     renameSync(tmp, file);
 };
+const MAX_BUSY_ATTEMPTS = 12;
+const MAX_SERVER_ERRORS = 1;
 class Http {
     c;
     requests = 0;
@@ -47,12 +49,15 @@ class Http {
     constructor(c) {
         this.c = c;
     }
-    async raw(path, query) {
+    async raw(path, query, keep, post) {
         const f = this.c.fetch ?? fetch;
         const url = new URL(this.c.url.replace(/\/+$/, "") + path);
         for (const [k, v] of Object.entries(query))
             url.searchParams.set(k, v);
         let failures = 0;
+        let serverErrors = 0;
+        let busy = 0;
+        let waited = 0;
         for (;;) {
             if (this.c.rpm) {
                 const gap = 60_000 / this.c.rpm - (Date.now() - this.#last);
@@ -65,7 +70,13 @@ class Http {
             let bytes;
             try {
                 response = await f(url, {
-                    headers: { authorization: `Bearer ${this.c.apiKey}` },
+                    headers: {
+                        authorization: `Bearer ${this.c.apiKey}`,
+                        ...(post !== undefined
+                            ? { "content-type": "application/json" }
+                            : {}),
+                    },
+                    ...(post !== undefined ? { method: "POST", body: post } : {}),
                     ...(this.c.signal ? { signal: this.c.signal } : {}),
                 });
                 bytes = new Uint8Array(await response.arrayBuffer());
@@ -88,6 +99,8 @@ class Http {
             catch {
                 body = null;
             }
+            if (keep?.(response.status, body))
+                return { status: response.status, contentType, bytes };
             const err = body?.error;
             const code = typeof err === "string"
                 ? err
@@ -105,12 +118,26 @@ class Http {
                     ? header * 1000
                     : undefined;
             if (response.status === 429) {
-                const wait = retryMs ?? 60_000;
-                if (wait > (this.c.maxWaitMs ?? 300_000))
-                    throw new ExportError(`${code}: ${message} Retry after ${Math.round(wait / 1000)} s: run the same command again then, the export resumes where it stopped.`, code, 429);
+                const maxWait = this.c.maxWaitMs ?? 300_000;
+                const asked = retryMs ?? 60_000;
+                if (asked > maxWait)
+                    throw new ExportError(`${code}: ${message} Retry after ${Math.round(asked / 1000)} s: run the same command again then, the export resumes where it stopped.`, code, 429);
+                const wait = Math.max(asked, Math.min(30_000, 1000 * 2 ** busy));
+                if (++busy >= MAX_BUSY_ATTEMPTS || waited + wait > maxWait)
+                    throw new ExportError(`${code}: ${message} The server answered 429 ${busy} times in a row (${Math.round(waited / 1000)} s): run the same command again later, the export resumes where it stopped.`, code, 429);
+                waited += wait;
                 await sleep(wait, this.c.signal);
                 continue;
             }
+            if (response.status >= 500 &&
+                response.status !== 502 &&
+                response.status !== 503 &&
+                response.status !== 504) {
+                if (++serverErrors > MAX_SERVER_ERRORS)
+                    throw new ExportError(`${response.status} ${code}: ${message}`, code, response.status);
+                await sleep(Math.min(30_000, 500 * 2 ** serverErrors), this.c.signal);
+                continue;
+            }
             if (response.status >= 500 && code !== "history_timeout") {
                 if (++failures > (this.c.maxRetries ?? 8))
                     throw new ExportError(`${response.status} ${code}: ${message}`, code, response.status);
@@ -120,11 +147,14 @@ class Http {
             throw new ExportError(`${response.status} ${code}: ${message}`, code, response.status);
         }
     }
-    async get(path, query) {
-        const answer = await this.raw(path, query);
+    async get(path, query, keep, post) {
+        const answer = await this.raw(path, query, keep, post);
         const text = new TextDecoder().decode(answer.bytes);
         try {
-            return text ? JSON.parse(text) : null;
+            return {
+                status: answer.status,
+                body: text ? JSON.parse(text) : null,
+            };
         }
         catch {
             throw new ExportError(`${path}: the answer is not JSON`, "decode");
@@ -171,9 +201,9 @@ export function staleFrom(meta, dir) {
             break;
         let live = false;
         try {
+            const { header } = decompressHour(readFileSync(join(dir, `${hour}.zhb`)));
             live =
-                decompressHour(readFileSync(join(dir, `${hour}.zhb`))).header.source ===
-                    "live";
+                header.source === "live" || (header.market && !header.virtualSides);
         }
         catch {
             live = true;
@@ -207,7 +237,7 @@ async function exportPart(http, out, s, sinceMs, untilMs, progress, refresh, onP
     if (meta.done) {
         const from = staleFrom(meta, dir);
         if (from !== null) {
-            onWarning?.(`${id}: hours from ${new Date(from * HOUR_MS).toISOString()} were open or not sealed when exported; downloading them again`);
+            onWarning?.(`${id}: hours from ${new Date(from * HOUR_MS).toISOString()} were open or not sealed when exported, or exported by an older version; downloading them again`);
             const hours = meta.hours.filter((h) => h < from);
             meta = {
                 ...meta,
@@ -307,12 +337,107 @@ export async function exportHistory(connection, out, read) {
     }
     return { reads, requests: http.requests, bytes: progress.bytes };
 }
+const RECORDED = new Set([
+    "invalid_window",
+    "invalid_parameter",
+    "invalid_limit",
+    "invalid_amount",
+    "invalid_cursor",
+    "usd_volume_unavailable",
+    "invalid_quote",
+    "partial_coverage",
+    "query_work_limit",
+]);
+const recordable = (status, body) => {
+    const e = body?.error;
+    return (status === 400 &&
+        typeof e === "object" &&
+        e !== null &&
+        typeof e.kind === "string" &&
+        typeof e.code === "string" &&
+        typeof e.message === "string" &&
+        RECORDED.has(e.code));
+};
+async function getNew(http, path, query, what) {
+    try {
+        const { status, body } = await http.get(path, query, recordable);
+        if (status !== 400)
+            return { ok: body };
+        const e = body.error;
+        const retry = body.retryAfterMs;
+        return {
+            code: e.code,
+            error: {
+                error: { kind: e.kind, code: e.code, message: e.message },
+                ...(typeof retry === "number" ? { retryAfterMs: retry } : {}),
+            },
+        };
+    }
+    catch (error) {
+        if (error instanceof ExportError && error.status === 404)
+            throw new ExportError(`This server does not export ${what} yet (it answered 404): it must be upgraded first. Trades (--token, --wallet) export as before.`, "unsupported_server", 404);
+        throw error;
+    }
+}
+function save(connection, out, [dir, name], answer, content, call) {
+    const ok = join(out, dir, name);
+    const failed = join(out, "errors", dir, name);
+    const [file, other] = "ok" in answer ? [ok, failed] : [failed, ok];
+    mkdirSync(dirname(file), { recursive: true });
+    writeAtomic(file, JSON.stringify(content));
+    rmSync(other, { force: true });
+    if (!("ok" in answer))
+        connection.onWarning?.(`${call} answered ${answer.code}: saved as its answer; the same call in a local run throws this error, as a hosted call does now`);
+}
 export async function exportTotals(connection, out, mint, quote = null) {
     const http = new Http(connection);
-    const body = await http.get(`/v1/tokens/${encodeURIComponent(mint)}/totals`, quote ? { quote } : {});
-    mkdirSync(join(out, "totals"), { recursive: true });
-    writeAtomic(join(out, "totals", totalsName(mint, quote)), JSON.stringify(body));
-    return body;
+    const key = encodeURIComponent(mint);
+    const body = await getNew(http, `/v1/functions/totals/${key}`, quote ? { quote } : {}, "totals (--totals)");
+    const info = await getNew(http, `/v1/functions/info/${key}`, {}, "totals (--totals)");
+    const content = (a) => ("ok" in a ? a.ok : a.error);
+    const totals = content(body);
+    save(connection, out, ["totals", totalsName(mint, quote)], body, totals, "tokenTotals");
+    save(connection, out, ["info", infoName(mint)], info, content(info), "tokenInfo");
+    return totals;
+}
+export async function exportCompute(connection, out, plan) {
+    const http = new Http(connection);
+    mkdirSync(join(out, "compute"), { recursive: true });
+    let answer;
+    try {
+        const { status, body } = await http.get("/v1/functions/compute", {}, recordable, JSON.stringify({ plan }));
+        if (status === 200)
+            answer = { ok: body };
+        else {
+            const e = body.error;
+            const retry = body.retryAfterMs;
+            answer = {
+                code: e.code,
+                error: {
+                    error: { kind: e.kind, code: e.code, message: e.message },
+                    ...(typeof retry === "number" ? { retryAfterMs: retry } : {}),
+                },
+            };
+        }
+    }
+    catch (error) {
+        if (error instanceof ExportError && error.status === 404)
+            throw new ExportError("This server does not run ctx.compute for local runs yet (it answered 404): it must be upgraded first.", "unsupported_server", 404);
+        throw error;
+    }
+    save(connection, out, ["compute", `${computeName(plan)}.json`], answer, "ok" in answer
+        ? { plan, result: answer.ok }
+        : { plan, ...answer.error }, "compute");
+    const ok = "ok" in answer ? answer.ok : null;
+    return {
+        rows: ok === null
+            ? null
+            : Array.isArray(ok)
+                ? ok.length
+                : typeof ok.length === "number"
+                    ? ok.length
+                    : null,
+    };
 }
 export async function exportVolumeSearch(connection, out, params) {
     const http = new Http(connection);
@@ -322,8 +447,13 @@ export async function exportVolumeSearch(connection, out, params) {
         const flat = Object.entries(p)
             .filter(([, v]) => v !== undefined && v !== null)
             .map(([k, v]) => [k, String(v)]);
-        const page = await http.get("/v1/volume/search", Object.fromEntries(flat));
-        writeAtomic(join(out, "volume", `${volumeName(flat)}.json`), JSON.stringify({ params: flat, page }));
+        const answer = await getNew(http, "/v1/functions/volume/search", Object.fromEntries(flat), "volume searches (--volume-search)");
+        save(connection, out, ["volume", `${volumeName(flat)}.json`], answer, "ok" in answer
+            ? { params: flat, page: answer.ok }
+            : { params: flat, ...answer.error }, `volumeSearch (page ${pages})`);
+        if (!("ok" in answer))
+            return pages;
+        const page = answer.ok;
         const next = page?.nextCursor;
         if (next === null || next === undefined)
             return pages;

package/dist/hourfile.d.ts

@@ -1,4 +1,4 @@
-import type { HourBatch } from "./sdk.js";
+import { type HourBatch } from "./sdk.js";
 export declare const HOUR_MAGIC = "ZHB1";
 export type ColumnType = "u8" | "u16" | "u32" | "i32" | "u64" | "f64";
 export interface HourHeader {
@@ -12,6 +12,8 @@ export interface HourHeader {
     /** Exports: timestamp of each operation counted in `skipped` (`null`: unknown). */
     readonly skippedTimes?: readonly (number | null)[];
     readonly market: boolean;
+    /** Market flags with one bit per virtual side; absent from older files. */
+    readonly virtualSides?: boolean;
     readonly order: boolean;
     /** Absent from files written before transaction ids. */
     readonly tx?: boolean;

package/dist/hourfile.js

@@ -1,4 +1,5 @@
 import { constants, zstdCompressSync, zstdDecompressSync } from "node:zlib";
+import { MarketFlag } from "./sdk.js";
 export const HOUR_MAGIC = "ZHB1";
 export const nodeRealm = {
     Uint8Array,
@@ -237,6 +238,12 @@ export function batchOf(raw, realm = nodeRealm) {
         const m = new realm.Object();
         for (const [name, type] of MARKET_COLUMNS)
             m[name] = column(`market.${name}`, type);
+        const flags = m.flags;
+        if (!header.virtualSides)
+            for (let i = 0; i < flags.length; i++)
+                if ((flags[i] & MarketFlag.virtualReserves) !== 0)
+                    flags[i] |=
+                        MarketFlag.virtualTokenReserve | MarketFlag.virtualQuoteReserve;
         batch.market = m;
     }
     if (header.order) {

package/dist/limits.d.ts

@@ -1,5 +1,5 @@
 /**
- * Limits of funrun v2, mirrored from the server defaults. The server is the
+ * Limits of hosted functions, mirrored from the server defaults. The server is the
  * authority; these constants let tools and programs plan around them.
  *
  * No dependency: safe to import from guest code.
@@ -11,7 +11,11 @@ export declare const execLimits: {
      * reads excluded: they count in `readMs`.
      */
     readonly cpuMs: 10000;
-    /** Wall time, waits (`ctx.jobs.wait`, host operations) included. */
+    /**
+     * Wall time, waits (`ctx.jobs.wait`, host operations, timers) included.
+     * Time spent waiting for history reads (`ctx.data.*`) does not count, up
+     * to `readWaitMs`.
+     */
     readonly wallMs: 60000;
     readonly heapBytes: number;
     /** JSON arguments of a direct call or a job. */
@@ -34,6 +38,16 @@ export declare const execLimits: {
     readonly readMs: 30000;
     /** User storage bytes read plus written by one execution (`io_limit`). */
     readonly storageBytes: number;
+    /**
+     * History read wait not counted in `wallMs`, at most: an execution lasts
+     * `wallMs + readWaitMs` (15 minutes) at most.
+     */
+    readonly readWaitMs: number;
+    /**
+     * Of one history read call, at most this much is given back to `wallMs`:
+     * a read that hangs still ends at the wall limit.
+     */
+    readonly readCallWaitMs: 120000;
 };
 /** User storage (`ctx.storage`), per account. Server defaults; operators may change them. */
 export declare const storageLimits: {

package/dist/limits.js

@@ -11,6 +11,8 @@ export const execLimits = {
     hostOps: 10_000,
     readMs: 30_000,
     storageBytes: 1024 * MIB,
+    readWaitMs: 14 * 60_000,
+    readCallWaitMs: 120_000,
 };
 export const storageLimits = {
     shortQuotaBytes: 1024 * MIB,

package/dist/local-data.d.ts

@@ -69,7 +69,7 @@ export declare class ReadFailed extends Error {
 export declare const sha256: (bytes: Uint8Array) => string;
 export declare function windowComplete(c: Coverage, since: number, until: number): boolean;
 export declare function hourComplete(c: Coverage, hour: number, since: number, until: number): boolean;
-/** `funrun_sandbox::natives::batch_bytes`: what a batch costs against `readBytes`. */
+/** What a batch costs against `readBytes`, as the service counts it. */
 export declare function batchBytes(h: HourHeader): number;
 export interface HourRead {
     readonly batch: HourBatch;
@@ -93,14 +93,31 @@ export declare class LocalData {
     find(s: ReadSpec, since: number, until: number): ReadMeta | undefined;
     /**
      * The next batch of a read after `afterHour` (`null`: none left), as
-     * `ColumnsReader::read_hour` answers it. Throws {@link ReadFailed}.
+     * the service's reader answers it. Throws {@link ReadFailed}.
      */
     readHour(s: ReadSpec, since: number, until: number, allowPartial: boolean, afterHour: number | null, realm?: Realm): HourRead | null;
-    /** `/v1/tokens/{mint}/totals` saved by the export, or `undefined`. */
+    /** Totals of a mint saved by the export, or `undefined`. */
     totals(mint: string, quote: string | null): Json | undefined;
-    /** A `/v1/volume/search` page saved by the export for exactly these parameters. */
+    /** Info of a mint saved by the export (`--totals`), or `undefined`. */
+    info(mint: string): Json | undefined;
+    /** The error `tokenTotals` answered at export, or `undefined`. */
+    totalsFailure(mint: string, quote: string | null): ReadFailure | undefined;
+    /** The error `tokenInfo` answered at export, or `undefined`. */
+    infoFailure(mint: string): ReadFailure | undefined;
+    /** The error a volume search page answered at export, or `undefined`. */
+    volumeFailure(params: readonly (readonly [string, string])[]): ReadFailure | undefined;
+    /** The answer `ctx.compute(plan)` gave at export (`zyrk export --compute`). */
+    computeResult(plan: unknown): Json | undefined;
+    /** The error `ctx.compute(plan)` answered at export, or `undefined`. */
+    computeFailure(plan: unknown): ReadFailure | undefined;
+    /** A volume search page saved by the export for exactly these parameters. */
     volumePage(params: readonly (readonly [string, string])[]): Json | undefined;
 }
+/** JSON with object keys sorted at every level (the name of a plan). */
+export declare function canonical(v: unknown): string;
+/** File name of a saved compute answer. */
+export declare function computeName(plan: unknown): string;
 export declare const totalsName: (mint: string, quote: string | null) => string;
+export declare const infoName: (mint: string) => string;
 /** Parameters as the sandbox passes them (`[key, string value]`), sorted. */
 export declare function volumeName(params: readonly (readonly [string, string])[]): string;

package/dist/local-data.js

@@ -315,7 +315,8 @@ export class LocalData {
                 batch: batchOf(raw, realm),
                 bytes: batchBytes(raw.header),
                 recut: recuts,
-                stale: stale(raw.header.source, hour),
+                stale: stale(raw.header.source, hour) ||
+                    (raw.header.market && !raw.header.virtualSides),
             };
         }
         return null;
@@ -330,15 +331,65 @@ export class LocalData {
             throw corrupt(file, e, again);
         }
     }
+    #failure(file, again) {
+        const saved = this.#json(join(this.dir, "errors", file), again);
+        if (saved === undefined)
+            return undefined;
+        const { code, message } = saved?.error ?? {};
+        if (typeof code !== "string" || typeof message !== "string")
+            throw corrupt(join(this.dir, "errors", file), new Error("not an error answer"), again);
+        const retry = saved.retryAfterMs;
+        return {
+            code,
+            message,
+            ...(typeof retry === "number" ? { retryAfterMs: retry } : {}),
+        };
+    }
     totals(mint, quote) {
         return this.#json(join(this.dir, "totals", totalsName(mint, quote)), `zyrk export --totals ${mint}${quote ? ` --quote ${quote}` : ""}`);
     }
+    info(mint) {
+        return this.#json(join(this.dir, "info", infoName(mint)), `zyrk export --totals ${mint}`);
+    }
+    totalsFailure(mint, quote) {
+        return this.#failure(join("totals", totalsName(mint, quote)), `zyrk export --totals ${mint}${quote ? ` --quote ${quote}` : ""}`);
+    }
+    infoFailure(mint) {
+        return this.#failure(join("info", infoName(mint)), `zyrk export --totals ${mint}`);
+    }
+    volumeFailure(params) {
+        return this.#failure(join("volume", `${volumeName(params)}.json`), "zyrk export --volume-search '<params>'");
+    }
+    computeResult(plan) {
+        const saved = this.#json(join(this.dir, "compute", `${computeName(plan)}.json`), "zyrk export --compute '<plan>'");
+        return saved?.result;
+    }
+    computeFailure(plan) {
+        return this.#failure(join("compute", `${computeName(plan)}.json`), "zyrk export --compute '<plan>'");
+    }
     volumePage(params) {
         const saved = this.#json(join(this.dir, "volume", `${volumeName(params)}.json`), "zyrk export --volume-search '<params>'");
         return saved?.page;
     }
 }
+export function canonical(v) {
+    if (Array.isArray(v))
+        return `[${v.map(canonical).join(",")}]`;
+    if (v !== null && typeof v === "object")
+        return `{${Object.keys(v)
+            .sort()
+            .map((k) => `${JSON.stringify(k)}:${canonical(v[k])}`)
+            .join(",")}}`;
+    return JSON.stringify(v) ?? "null";
+}
+export function computeName(plan) {
+    return createHash("sha256")
+        .update(canonical(plan))
+        .digest("hex")
+        .slice(0, 32);
+}
 export const totalsName = (mint, quote) => quote ? `${mint}~${quote}.json` : `${mint}.json`;
+export const infoName = (mint) => `${mint}.json`;
 export function volumeName(params) {
     const canonical = JSON.stringify([...params].sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0)));
     return createHash("sha256").update(canonical).digest("hex").slice(0, 32);

package/dist/local-replay.d.ts

@@ -1,15 +1,15 @@
 import { type LocalData, type ReadMeta } from "./local-data.js";
 import { type HourBatch, type Subscription } from "./sdk.js";
-/** `windows::LAG_MS`: the first 30 s after coverage starts are not trusted. */
+/** The first 30 s after coverage starts are not trusted (as the service). */
 export declare const LAG_MS = 30000;
 /** Events per delivery, as `delivery_batch` of the service. */
 export declare const DELIVERY_BATCH = 32;
-/** Largest `batchSize` of a replay (`replay::MAX_BATCH` of the service). */
+/** Largest `batchSize` of a replay of the service. */
 export declare const REPLAY_MAX_BATCH = 1000;
-/** History items per source page of the service (`ReplayLimits::page`). */
+/** History items per source page of the service's replays. */
 export declare const SOURCE_PAGE = 500;
 /**
- * Fields of the live operation JSON (`query::operation`) that exported
+ * Fields of the live operation JSON that exported
  * columns do not hold: absent from replayed operations.
  */
 export declare const MISSING_OPERATION_FIELDS: readonly ["prices (provider strings: read batch.price… instead)", "usdValue", "finality", "provenance", "market (the provider's raw object)"];
@@ -26,7 +26,7 @@ export interface ReplayProgress {
     gaps: number;
     orderFallbacks: number;
 }
-/** Decimal string of a raw amount (`query::dec_text`). */
+/** Decimal string of a raw amount, as the live JSON writes it. */
 export declare function formatRaw(raw: bigint, decimals: number): string;
 /** Row `i` as the live publication shapes it (without {@link MISSING_OPERATION_FIELDS}). */
 export declare function operationOf(b: HourBatch, i: number): Record<string, unknown>;

package/dist/local-replay.js

@@ -82,7 +82,8 @@ function poolEventOf(b, i, kind) {
     const m = b.market;
     const flags = m.flags[i];
     const reserves = (flags & MarketFlag.reserves) !== 0;
-    const virtual = (flags & MarketFlag.virtualReserves) !== 0;
+    const vToken = (flags & MarketFlag.virtualTokenReserve) !== 0;
+    const vQuote = (flags & MarketFlag.virtualQuoteReserve) !== 0;
     const op = operationOf(b, i);
     return {
         ...op,
@@ -93,10 +94,10 @@ function poolEventOf(b, i, kind) {
         market: {
             tokenReserveRaw: reserves ? m.tokenReserve[i].toString() : null,
             quoteReserveRaw: reserves ? m.quoteReserve[i].toString() : null,
-            virtualTokenReserveRaw: virtual
+            virtualTokenReserveRaw: vToken
                 ? m.virtualTokenReserve[i].toString()
                 : null,
-            virtualQuoteReserveRaw: virtual
+            virtualQuoteReserveRaw: vQuote
                 ? m.virtualQuoteReserve[i].toString()
                 : null,
             signer: addressAt(b, m.signer[i]),

package/dist/local-storage.d.ts

@@ -9,9 +9,9 @@ export declare const localStorageLimits: {
     readonly maxUploads: 4;
     /** Bytes read plus written by one execution (`io_limit`). */
     readonly ioBytes: number;
-    /** Quota cost floor of one object (`StorageOptions::min_object_bytes`). */
+    /** Quota cost floor of one object. */
     readonly minObjectBytes: 4096;
-    /** Objects per area (`AreaOptions::max_objects`). */
+    /** Objects per area. */
     readonly maxObjects: 100000;
 };
 export interface AreaConfig {

package/dist/local.d.ts

@@ -199,9 +199,9 @@ export interface KeepStorage {
     readonly from?: "short" | "long" | "durable";
     readonly keys?: readonly string[];
 }
-/** The service's `ReplayLimits::max_duration_ms` (30 min). */
+/** Longest replay of the service (30 min). */
 export declare const REPLAY_MAX_DURATION_MS: number;
-/** The service's `FeedLimits::replay_bytes` (16 MiB). */
+/** Unread feed of one replay on the service (16 MiB). */
 export declare const REPLAY_FEED_BYTES: number;
 /** What {@link LocalRunner.replay} answers (the service's replay record, locally). */
 export interface LocalReplay {