@johannc-dev/zyrk 0.0.0-stage → 0.2.1

package/dist/local.js

@@ -0,0 +1,1147 @@
+import { randomFillSync } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getHeapStatistics } from "node:v8";
+import vm from "node:vm";
+import { buildProgram } from "./build.js";
+import { DELIVERY_BATCH, REPLAY_MAX_BATCH, MISSING_OPERATION_FIELDS, intervalEvents, replayEvents, } from "./local-replay.js";
+import { LocalData, ReadFailed, spec as readSpec, } from "./local-data.js";
+import { LocalStorage, StorageOpError, } from "./local-storage.js";
+import { accountLimits, execLimits, subscriptionLimits } from "./limits.js";
+const here = dirname(fileURLToPath(import.meta.url));
+let batchReadsSaid = false;
+function batchReadsFromEnv() {
+    const raw = process.env.FUNRUN_BATCH_READS;
+    const v = (raw ?? "").trim();
+    const on = v === "on" || v === "1" || v === "true";
+    if (raw !== undefined && !batchReadsSaid) {
+        batchReadsSaid = true;
+        process.stderr.write(`zyrk local runner: FUNRUN_BATCH_READS=${JSON.stringify(raw)}: batched history reads ${on ? "on" : "off"} (hosted functions batch only when the service has the same setting; off there by default)\n`);
+    }
+    return on;
+}
+let bootstrapText;
+export function sandboxBootstrap() {
+    return (bootstrapText ??= readFileSync(join(here, "sandbox-bootstrap.js"), "utf8"));
+}
+class HostError extends Error {
+    kind;
+    code;
+    retryAfterMs;
+    constructor(kind, code, message, retryAfterMs) {
+        super(message);
+        this.kind = kind;
+        this.code = code;
+        this.retryAfterMs = retryAfterMs;
+    }
+}
+const program = (code, message) => new HostError("program", code, message);
+const limit = (code, message) => new HostError("limit", code, message);
+const LIMIT_CODES = new Set([
+    "read_limit",
+    "read_time_limit",
+    "op_limit",
+    "memory_limit",
+    "cpu_limit",
+    "wall_limit",
+    "output_limit",
+    "input_limit",
+    "stack_limit",
+    "query_work_limit",
+]);
+const INFRA_CODES = new Set([
+    "history_preparing",
+    "storage_busy",
+    "history_unavailable",
+]);
+const kindOfSdkCode = (code) => LIMIT_CODES.has(code)
+    ? "limit"
+    : INFRA_CODES.has(code)
+        ? "infrastructure"
+        : code === "cancelled"
+            ? "permission"
+            : "program";
+const NAME = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
+const MAX_OP_BYTES = 2 * 1024 * 1024 + 4096;
+const MAX_STORAGE_OP_BYTES = 6 * 1024 * 1024 + 4096;
+const EMIT_OVERHEAD_BYTES = 768;
+const WEBHOOK_MAX_PER_EXECUTION = 32;
+const WEBHOOK_PAYLOAD_BYTES = 16 * 1024;
+const WEBHOOK_OVERHEAD_BYTES = 256;
+const WEBHOOK_QUEUE_LIMIT = 1000;
+const MAX_MESSAGE_BYTES = 2048;
+const openWhenExported = (v) => {
+    const c = v?.coverage;
+    return (typeof c === "object" &&
+        c !== null &&
+        (c.unsealed === true ||
+            (c.liveUntilMs !== null && c.liveUntilMs !== undefined)));
+};
+const jsonBytes = (v) => Buffer.byteLength(JSON.stringify(v) ?? "null");
+const truncate = (m) => Buffer.byteLength(m) <= MAX_MESSAGE_BYTES
+    ? m
+    : Buffer.from(m).subarray(0, MAX_MESSAGE_BYTES).toString("utf8");
+const final = (e) => (e.next ? final(e.next) : e);
+const jobResult = (e) => {
+    const f = final(e);
+    const id = e.chain;
+    switch (f.status) {
+        case "succeeded":
+            return { id, status: "succeeded", result: f.result ?? null };
+        case "failed":
+            return { id, status: "failed", error: f.error };
+        case "queued":
+        case "running":
+            return { id, status: f.status };
+        default:
+            return { id, status: f.status };
+    }
+};
+export class LocalRunner {
+    data;
+    storage;
+    limits;
+    state = new Map();
+    subscriptions = new Map();
+    warnings = [];
+    #code;
+    #object;
+    #functions;
+    #options;
+    #name;
+    #version;
+    #jobs = new Map();
+    #queue = [];
+    #workflows = new Map();
+    #errors = new WeakMap();
+    #isolated = false;
+    #webhookSeq = 0;
+    #webhookPending = 0;
+    #running = 0;
+    #waiting = 0;
+    #runs = 0;
+    #idle = [];
+    #warned = new Set();
+    constructor(code, object, functions, subscriptions, options) {
+        this.#code = code;
+        this.#object = object;
+        this.#functions = new Set(functions);
+        this.#options = options;
+        this.#name = options.program ?? "local";
+        this.#version = object ? "local-object" : `local-${fnv(code)}`;
+        this.limits = {
+            exec: { ...execLimits, ...options.limits?.exec },
+            account: { ...accountLimits, ...options.limits?.account },
+        };
+        this.data =
+            typeof options.data === "string"
+                ? new LocalData(options.data)
+                : options.data;
+        this.storage =
+            options.storage instanceof LocalStorage
+                ? options.storage
+                : new LocalStorage(options.storage && options.storage !== "memory"
+                    ? options.storage
+                    : undefined, options.storageAreas, options.now);
+        for (const [name, s] of Object.entries(subscriptions))
+            this.subscriptions.set(name, s);
+        if (typeof options.state === "string") {
+            const file = this.#stateFile();
+            if (file && existsSync(file))
+                for (const [k, v] of Object.entries(JSON.parse(readFileSync(file, "utf8"))))
+                    this.state.set(k, v);
+        }
+        else if (options.state)
+            for (const [k, v] of Object.entries(options.state))
+                this.state.set(k, v);
+        if (object)
+            this.#warn("A program object runs with Node's globals (fetch, timers, process): only a built bundle (an entry path) runs with the sandbox's globals.");
+    }
+    static async load(source, options = {}) {
+        let code = "";
+        let object;
+        if (typeof source === "string") {
+            code = (await buildProgram(source, { typecheck: options.typecheck ?? true })).code;
+        }
+        else if ("code" in source && typeof source.code === "string") {
+            code = source.code;
+        }
+        else {
+            object = source;
+        }
+        const probe = loadContext(code, object, () => ({ maxDepth: 16 }));
+        const description = JSON.parse(probe.describe());
+        if (description.sdk !== "0.2")
+            throw new Error("sdk_version_unsupported: build the program with defineProgram of @johannc-dev/zyrk 0.2");
+        return new LocalRunner(code, object, description.functions, description.subscriptions, options);
+    }
+    #stateFile() {
+        const dir = this.#options.state;
+        return typeof dir === "string"
+            ? join(dir, `${this.#name}.json`)
+            : undefined;
+    }
+    #saveState() {
+        const file = this.#stateFile();
+        if (!file)
+            return;
+        mkdirSync(dirname(file), { recursive: true });
+        writeFileSync(`${file}.tmp`, JSON.stringify(Object.fromEntries(this.state)));
+        renameSync(`${file}.tmp`, file);
+    }
+    #warn(message) {
+        if (this.#warned.has(message))
+            return;
+        this.#warned.add(message);
+        this.warnings.push(message);
+    }
+    #create(id, chain, workflow, fn, args, depth, onComplete, scale = 1) {
+        let finish = () => { };
+        const done = new Promise((r) => (finish = r));
+        const e = {
+            id,
+            chain,
+            workflow,
+            function: fn,
+            args,
+            depth,
+            onComplete,
+            status: "queued",
+            logs: [],
+            emits: [],
+            webhooks: [],
+            webhookCalls: 0,
+            scale,
+            usage: {
+                cpuMs: 0,
+                readMs: 0,
+                wallMs: 0,
+                readBytes: 0,
+                readCalls: 0,
+                hostOps: 0,
+                outputBytes: 0,
+                peakHeapBytes: 0,
+            },
+            children: [],
+            state: new Map(),
+            subs: new Map(),
+            readOver: false,
+            pending: 0,
+            io: { bytes: 0 },
+            startedAt: 0,
+            done,
+            finish,
+        };
+        if (!this.#workflows.has(workflow))
+            this.#workflows.set(workflow, { readBytes: 0, executions: 0 });
+        return e;
+    }
+    #schedule(e) {
+        if (e.id === e.chain)
+            this.#jobs.set(e.id, e);
+        this.#queue.push(e);
+        this.#pump();
+    }
+    #pump() {
+        while (this.#running < this.limits.account.parallelExecutions &&
+            this.#queue.length > 0) {
+            const e = this.#queue.shift();
+            this.#running++;
+            void this.#execute(e).finally(() => {
+                this.#running--;
+                this.#pump();
+                if (this.#running === 0 && this.#queue.length === 0) {
+                    const waiting = this.#idle;
+                    this.#idle = [];
+                    for (const w of waiting)
+                        w();
+                }
+            });
+        }
+    }
+    #cancelChildren(e) {
+        for (const id of e.children) {
+            const child = this.#jobs.get(id);
+            if (!child)
+                continue;
+            for (let x = child; x; x = x.next) {
+                if (x.status === "queued") {
+                    const at = this.#queue.indexOf(x);
+                    if (at >= 0)
+                        this.#queue.splice(at, 1);
+                    x.status = "cancelled";
+                    x.error = {
+                        kind: "permission",
+                        code: "cancelled",
+                        message: "Its parent failed: the job was cancelled",
+                    };
+                    x.finish();
+                    this.#cancelChildren(x);
+                }
+                else if (x.status === "running")
+                    x.cancelled = true;
+            }
+        }
+    }
+    idle() {
+        if (this.#running === 0 && this.#queue.length === 0)
+            return Promise.resolve();
+        return new Promise((r) => this.#idle.push(r));
+    }
+    jobs() {
+        return [...this.#jobs.values()].map(jobResult);
+    }
+    executions() {
+        const out = [];
+        for (const e of this.#jobs.values())
+            for (let x = e; x; x = x.next)
+                out.push(view(x));
+        return out;
+    }
+    async run(fn, args = null) {
+        return this.#run(fn, args, 1);
+    }
+    async #run(fn, args, scale) {
+        const id = `local-${++this.#runs}`;
+        const e = this.#create(id, id, id, fn, args, 0, null, scale);
+        this.#schedule(e);
+        return this.#settled(e);
+    }
+    async #settled(e) {
+        await chainDone(e);
+        const chain = [];
+        for (let x = e; x; x = x.next)
+            chain.push(x);
+        const f = chain[chain.length - 1];
+        return {
+            id: e.chain,
+            status: f.status === "succeeded"
+                ? "succeeded"
+                : f.status === "cancelled"
+                    ? "cancelled"
+                    : "failed",
+            ...(f.status === "succeeded"
+                ? { result: f.result ?? null, resultText: f.resultText ?? "null" }
+                : {}),
+            ...(f.error ? { error: f.error } : {}),
+            logs: chain.flatMap((x) => x.logs),
+            emits: chain.flatMap((x) => x.emits),
+            webhooks: chain.flatMap((x) => x.webhooks),
+            executions: chain.map(view),
+            warnings: [...this.warnings],
+        };
+    }
+    async #execute(e) {
+        e.status = "running";
+        e.startedAt = performance.now();
+        const cpu0 = process.cpuUsage();
+        const heap0 = getHeapStatistics().used_heap_size;
+        const wf = this.#workflows.get(e.workflow);
+        wf.executions++;
+        const sample = () => {
+            const used = getHeapStatistics().used_heap_size - heap0;
+            if (used > e.usage.peakHeapBytes)
+                e.usage.peakHeapBytes = used;
+        };
+        try {
+            if (wf.executions > this.limits.account.workflowAttempts)
+                throw limit("workflow_budget_exhausted", "Workflow budget exhausted");
+            const argsText = JSON.stringify(e.args) ?? "null";
+            const inputBytes = e.args?.kind === "events"
+                ? this.limits.exec.eventInputBytes * e.scale
+                : this.limits.exec.inputBytes;
+            if (Buffer.byteLength(argsText) > inputBytes)
+                throw limit("input_limit", `The arguments are larger than ${inputBytes} bytes`);
+            const guest = loadContext(this.#code, this.#object, (realm, mode) => this.#natives(e, realm, mode, sample));
+            const text = await guest.start(e.function, argsText, JSON.stringify({
+                id: e.id,
+                workflow: e.workflow,
+                program: this.#name,
+                version: this.#version,
+                attempt: 1,
+            }));
+            if (e.fatal)
+                throw e.fatal;
+            if (e.pending > 0)
+                throw program("unawaited_operation", "The function returned while a ctx call was still pending: await every ctx call");
+            const resultText = String(text);
+            const size = Buffer.byteLength(resultText);
+            if (e.usage.outputBytes + size > this.limits.exec.outputBytes * e.scale)
+                throw limit("output_limit", `Result, logs and emits went over ${this.limits.exec.outputBytes * e.scale} bytes`);
+            e.usage.outputBytes += size;
+            if (performance.now() - e.startedAt > this.limits.exec.wallMs)
+                throw limit("wall_limit", `The execution ran over ${this.limits.exec.wallMs} ms (measured locally, not preempted)`);
+            if (e.cancelled)
+                throw new HostError("permission", "cancelled", "Its parent failed: the job was cancelled");
+            for (const [k, v] of e.state)
+                if (v === undefined)
+                    this.state.delete(k);
+                else
+                    this.state.set(k, v);
+            for (const [k, s] of e.subs)
+                if (s === null)
+                    this.subscriptions.delete(k);
+                else
+                    this.subscriptions.set(k, s);
+            if (e.state.size > 0)
+                this.#saveState();
+            e.result = JSON.parse(resultText);
+            e.resultText = resultText;
+            e.status = "succeeded";
+        }
+        catch (error) {
+            const failure = e.fatal ??
+                (error instanceof HostError
+                    ? error
+                    : (this.#errors.get(error) ??
+                        new HostError("program", "program_error", String(error?.stack ??
+                            error?.message ??
+                            error))));
+            e.status = "failed";
+            e.error = {
+                kind: failure.kind,
+                code: failure.code,
+                message: truncate(failure.message),
+            };
+        }
+        finally {
+            this.storage.endExecution(e.id);
+            sample();
+            const cpu = process.cpuUsage(cpu0);
+            e.usage.wallMs = performance.now() - e.startedAt;
+            e.usage.cpuMs = Math.max(0, (cpu.user + cpu.system) / 1000 - e.usage.readMs);
+        }
+        if (e.error?.code === "cancelled")
+            e.status = "cancelled";
+        if (e.status === "failed" || e.status === "cancelled")
+            this.#cancelChildren(e);
+        if (e.usage.cpuMs > this.limits.exec.cpuMs)
+            this.#warn(`${e.function}: about ${Math.round(e.usage.cpuMs)} ms of CPU, over the service's ${this.limits.exec.cpuMs} ms (cpu_limit). Measured roughly here: check with zyrk run.`);
+        if (e.usage.peakHeapBytes > this.limits.exec.heapBytes)
+            this.#warn(`${e.function}: about ${Math.round(e.usage.peakHeapBytes / 2 ** 20)} MiB of heap, over the service's ${this.limits.exec.heapBytes / 2 ** 20} MiB (memory_limit). Measured roughly here.`);
+        if (e.status === "succeeded" && e.continuation) {
+            const next = this.#create(e.continuation.id, e.chain, e.workflow, e.function, e.continuation.args, e.depth, e.onComplete, e.scale);
+            e.next = next;
+            e.finish();
+            this.#queue.push(next);
+            return;
+        }
+        e.finish();
+        const head = this.#jobs.get(e.chain);
+        if (head?.onComplete) {
+            const status = final(head).status;
+            const id = `${e.chain}:complete`;
+            this.#schedule(this.#create(id, id, e.workflow, head.onComplete, { kind: "completion", executionId: e.chain, status }, head.depth, null));
+        }
+    }
+    #natives(e, realm, mode, sample) {
+        const sdkError = (err) => {
+            const error = new realm.Error(err.message);
+            error.code = err.code;
+            if (err.retryAfterMs !== undefined)
+                error.retryAfterMs = err.retryAfterMs;
+            this.#errors.set(error, err);
+            return error;
+        };
+        const fromRead = (f) => new HostError(kindOfSdkCode(f.code), f.code, f.message, f.retryAfterMs);
+        const guestJson = (v) => realm.JSON.parse(JSON.stringify(v) ?? "null");
+        const ms = (v) => typeof v === "number" && Number.isFinite(v) && Math.abs(v) < 9e15
+            ? Math.trunc(v)
+            : undefined;
+        const readLimit = () => {
+            e.readOver = true;
+            return sdkError(limit("read_limit", `History reads went over ${this.limits.exec.readBytes} bytes`));
+        };
+        const readAllowed = () => {
+            if (mode() === "load")
+                throw sdkError(program("invalid_program", "History reads are not available at load"));
+            if (e.readOver || e.usage.readBytes >= this.limits.exec.readBytes)
+                throw readLimit();
+            if (e.usage.readMs > this.limits.exec.readMs) {
+                e.fatal = limit("read_time_limit", `History reads took over ${this.limits.exec.readMs} ms`);
+                throw sdkError(e.fatal);
+            }
+            this.#checkWall(e);
+        };
+        const charge = (bytes) => {
+            e.usage.readBytes += bytes;
+            const wf = this.#workflows.get(e.workflow);
+            wf.readBytes += bytes;
+            if (e.usage.readBytes > this.limits.exec.readBytes ||
+                wf.readBytes > this.limits.account.workflowReadBytes)
+                throw readLimit();
+        };
+        const data = () => {
+            if (!this.data)
+                throw sdkError(program("local_data_missing", "No data directory: export history with zyrk export, then pass --data (or { data })."));
+            return this.data;
+        };
+        const saved = (answer, failure, missing) => {
+            let value;
+            let failed;
+            try {
+                value = answer();
+                failed = value === undefined ? failure() : undefined;
+            }
+            catch (error) {
+                if (error instanceof ReadFailed)
+                    throw sdkError(fromRead(error.failure));
+                throw error;
+            }
+            if (failed)
+                throw sdkError(fromRead(failed));
+            if (value === undefined)
+                throw sdkError(program("local_data_missing", missing));
+            if (openWhenExported(value))
+                this.#warn("Totals or volume search pages were exported while an hour was still open: the service may now answer otherwise. Run zyrk export again (--totals, --volume-search) to download them again.");
+            charge(jsonBytes(value));
+            return guestJson(value);
+        };
+        return {
+            maxDepth: this.limits.account.maxDepth,
+            batchReads: batchReadsFromEnv(),
+            hint: () => undefined,
+            fail: (code, message) => sdkError(new HostError(kindOfSdkCode(String(code)), String(code), String(message))),
+            op: (text, awaited) => this.#op(e, text, !!awaited, realm, mode, sdkError, guestJson, sample),
+            read: (kind, key, since, until, side, allowPartial, withSignatures, after, withMarket, withEvents, withOrder, withTx) => {
+                if (typeof key !== "string")
+                    throw sdkError(program("invalid_argument", "Expected an address string"));
+                if (kind !== "wallet" && kind !== "token")
+                    throw sdkError(program("invalid_argument", "Unknown history scope"));
+                const sinceMs = ms(since);
+                const untilMs = ms(until);
+                if (sinceMs === undefined || untilMs === undefined)
+                    throw sdkError(program("invalid_window", "sinceMs and untilMs must be finite numbers"));
+                if (side !== "any" && side !== "buy" && side !== "sell")
+                    throw sdkError(program("invalid_argument", 'side must be "buy" or "sell"'));
+                const afterHour = after === null || after === undefined ? null : ms(after);
+                if (afterHour === undefined)
+                    throw sdkError(program("invalid_argument", "Invalid read cursor"));
+                readAllowed();
+                e.usage.readCalls++;
+                const t0 = performance.now();
+                let hour;
+                try {
+                    hour = data().readHour(readSpec({
+                        scope: kind,
+                        key,
+                        side,
+                        withSignatures: withSignatures === true,
+                        withMarket: withMarket === true,
+                        withEvents: withEvents === true,
+                        withOrder: withOrder === true,
+                        withTx: withTx === true,
+                    }), sinceMs, untilMs, allowPartial === true, afterHour, realm);
+                }
+                catch (error) {
+                    if (error instanceof ReadFailed)
+                        throw sdkError(fromRead(error.failure));
+                    throw error;
+                }
+                finally {
+                    e.usage.readMs += performance.now() - t0;
+                    sample();
+                }
+                if (hour === null)
+                    return null;
+                if (hour.stale)
+                    this.#warn("Some hours were open or not sealed when they were exported, or were exported by an older version: the service may now answer otherwise. Run zyrk export again to download them again.");
+                if (hour.recut)
+                    this.#warn("A read used a narrower window than its export: its edge hours were cut locally. Values are the service's; the address indexes and market.flags (chainBreak, chainUnchecked) of a cut hour may differ. Export the exact window for byte-identical batches.");
+                charge(hour.bytes);
+                return hour.batch;
+            },
+            totals: (mint, quote) => {
+                readAllowed();
+                e.usage.readCalls++;
+                if (typeof mint !== "string" ||
+                    (quote !== null && typeof quote !== "string"))
+                    throw sdkError(program("invalid_argument", "Expected a mint address"));
+                return saved(() => data().totals(mint, quote), () => data().totalsFailure(mint, quote), `No exported totals for ${mint}: zyrk export --totals ${mint}${quote ? ` --quote ${quote}` : ""}`);
+            },
+            info: (mint) => {
+                readAllowed();
+                e.usage.readCalls++;
+                if (typeof mint !== "string")
+                    throw sdkError(program("invalid_argument", "Expected a mint address"));
+                return saved(() => data().info(mint), () => data().infoFailure(mint), `No exported info for ${mint} (exports by older versions saved only its totals): zyrk export --totals ${mint}`);
+            },
+            volume: (text) => {
+                readAllowed();
+                e.usage.readCalls++;
+                const params = JSON.parse(String(text));
+                return saved(() => data().volumePage(params), () => data().volumeFailure(params), `No exported volume page for these parameters: zyrk export --volume-search '${JSON.stringify(Object.fromEntries(params.filter(([k]) => k !== "cursor")))}'`);
+            },
+            encode: (text) => {
+                const bytes = Buffer.from(String(text), "utf8");
+                const out = new realm.Uint8Array(bytes.length);
+                out.set(bytes);
+                return out;
+            },
+            decode: (view, fatal, ignoreBOM) => new TextDecoder("utf-8", {
+                fatal: !!fatal,
+                ignoreBOM: !!ignoreBOM,
+            }).decode(new Uint8Array(view.buffer, view.byteOffset, view.byteLength)),
+            random: (array) => {
+                randomFillSync(new Uint8Array(array.buffer, array.byteOffset, array.byteLength));
+            },
+            b64encode: (view) => {
+                if (view.byteLength > 4 * 1024 * 1024)
+                    throw new realm.Error("b64encode is limited to 4 MiB");
+                return Buffer.from(view.buffer, view.byteOffset, view.byteLength).toString("base64");
+            },
+            b64decodeInto: (text, out, offset) => {
+                if (typeof text !== "string")
+                    return -1;
+                const bytes = Buffer.from(text, "base64");
+                if (offset + bytes.length > out.length)
+                    return -1;
+                new Uint8Array(out.buffer, out.byteOffset, out.byteLength).set(bytes, offset);
+                return bytes.length;
+            },
+        };
+    }
+    #checkWall(e) {
+        if (performance.now() - e.startedAt > this.limits.exec.wallMs) {
+            e.fatal ??= limit("wall_limit", `The execution ran over ${this.limits.exec.wallMs} ms`);
+            throw e.fatal;
+        }
+    }
+    #op(e, text, awaited, realm, mode, sdkError, guestJson, sample) {
+        const reject = (err) => awaited ? realm.Promise.reject(sdkError(err)) : undefined;
+        if (mode() === "load")
+            return reject(program("invalid_program", "Context operations are not available at load"));
+        if (e.usage.hostOps >= this.limits.exec.hostOps * e.scale)
+            return reject(limit("op_limit", `More than ${this.limits.exec.hostOps * e.scale} context operations`));
+        const cap = /^\{"Storage/.test(String(text))
+            ? MAX_STORAGE_OP_BYTES
+            : MAX_OP_BYTES;
+        if (typeof text !== "string" || text.length > cap)
+            return reject(program("invalid_argument", "Context operation payload is too large"));
+        let name;
+        let payload;
+        try {
+            const op = JSON.parse(text);
+            name = Object.keys(op)[0];
+            payload = op[name];
+            if (typeof payload !== "object" || payload === null)
+                throw new Error();
+        }
+        catch {
+            return reject(program("invalid_argument", "Invalid context operation"));
+        }
+        e.usage.hostOps++;
+        if (awaited)
+            e.pending++;
+        const answer = new realm.Promise((resolve, rejectGuest) => {
+            this.#hostOp(e, name, payload).then((value) => {
+                if (awaited)
+                    e.pending--;
+                sample();
+                resolve(guestJson(value));
+            }, (error) => {
+                if (awaited)
+                    e.pending--;
+                const err = error instanceof HostError
+                    ? error
+                    : error instanceof StorageOpError
+                        ? new HostError(error.kind, error.code, error.message)
+                        : new HostError("infrastructure", "runtime_failure", String(error));
+                rejectGuest(sdkError(err));
+            });
+        });
+        if (awaited)
+            return answer;
+        answer.catch(() => { });
+        return undefined;
+    }
+    async #hostOp(e, name, a) {
+        this.#checkWall(e);
+        const account = this.limits.account;
+        const output = (size) => {
+            e.usage.outputBytes += size;
+            if (e.usage.outputBytes > this.limits.exec.outputBytes * e.scale)
+                throw limit("output_limit", `Result, logs and emits went over ${this.limits.exec.outputBytes * e.scale} bytes`);
+        };
+        const key = (k) => {
+            if (typeof k !== "string" || !NAME.test(k))
+                throw program("invalid_sdk_request", "key: expected ^[A-Za-z][A-Za-z0-9_-]{0,63}$");
+            return k;
+        };
+        const print = (kind, value) => {
+            const c = this.#options.console;
+            if (typeof c === "function")
+                c({ kind, execution: e.id, function: e.function, value });
+            else if (c)
+                process.stderr.write(`[${kind} ${e.function} ${e.id}] ${typeof value === "string" ? value : JSON.stringify(value)}\n`);
+        };
+        switch (name) {
+            case "StateGet": {
+                const k = key(a.key);
+                if (e.state.has(k))
+                    return e.state.get(k) ?? null;
+                return this.state.get(k) ?? null;
+            }
+            case "StateSet": {
+                const k = key(a.key);
+                const value = (a.value ?? null);
+                if (jsonBytes(value) > account.stateValueBytes)
+                    throw limit("state_value_too_large", "A state value is limited to 1 MiB");
+                e.state.set(k, value);
+                const merged = new Map(this.state);
+                for (const [x, v] of e.state)
+                    if (v === undefined)
+                        merged.delete(x);
+                    else
+                        merged.set(x, v);
+                let total = 0;
+                for (const [x, v] of merged)
+                    total += jsonBytes(v) + x.length;
+                if (total > account.stateBytesPerProgram)
+                    throw limit("state_too_large", "The state of a program is limited to 32 MiB");
+                return null;
+            }
+            case "StateDelete":
+                e.state.set(key(a.key), undefined);
+                return null;
+            case "Log": {
+                const value = (a.value ?? null);
+                output(jsonBytes(value) + 1);
+                e.logs.push(value);
+                print("log", value);
+                return null;
+            }
+            case "Emit": {
+                const value = (a.value ?? null);
+                output(jsonBytes(value) + EMIT_OVERHEAD_BYTES);
+                e.emits.push(value);
+                print("emit", value);
+                return null;
+            }
+            case "WebhookSend": {
+                if (e.webhookCalls >= WEBHOOK_MAX_PER_EXECUTION)
+                    throw limit("webhook_limit", `At most ${WEBHOOK_MAX_PER_EXECUTION} ctx.webhook.send calls per execution`);
+                const payload = (a.payload ?? null);
+                const size = jsonBytes(payload);
+                if (size > WEBHOOK_PAYLOAD_BYTES)
+                    throw limit("webhook_payload_too_large", `A webhook payload is limited to ${WEBHOOK_PAYLOAD_BYTES} bytes`);
+                output(size + WEBHOOK_OVERHEAD_BYTES);
+                const index = e.webhookCalls++;
+                if (this.#isolated) {
+                    e.webhooks.push(payload);
+                    print("webhook", payload);
+                    return { id: null, seq: null, dropped: true, replayed: true };
+                }
+                const hook = this.#options.webhook;
+                if (!hook?.configured || hook.enabled === false)
+                    throw program("webhook_not_configured", "No enabled webhook for this account: PUT /v1/functions/webhook first");
+                const queueLimit = hook.queueLimit ?? WEBHOOK_QUEUE_LIMIT;
+                if (this.#webhookPending >= queueLimit) {
+                    if (a.drop_if_full === true)
+                        return { id: null, seq: null, dropped: true };
+                    throw limit("webhook_queue_full", `${this.#webhookPending} webhook messages are waiting for delivery (the limit): ` +
+                        "check the receiver and GET /v1/functions/webhook/deliveries");
+                }
+                this.#webhookPending++;
+                this.#webhookSeq++;
+                e.webhooks.push(payload);
+                print("webhook", payload);
+                return {
+                    id: `${e.id}~webhook-${index}`,
+                    seq: this.#webhookSeq,
+                    dropped: false,
+                };
+            }
+            case "Replay":
+                if (this.#isolated)
+                    throw program("replay_isolated", "A replay never changes live subscriptions nor starts another replay");
+                throw program("local_unsupported", "ctx.subscriptions.replay is not run locally: use runner.replay(...) or zyrk dev --replay");
+            case "Continue": {
+                if (e.continuation)
+                    throw program("continuation_already_requested", "ctx.jobs.continue was already called in this execution");
+                const args = (a.args ?? null);
+                if (jsonBytes(args) > this.limits.exec.inputBytes)
+                    throw limit("continuation_state_too_large", "Continuation arguments over 32 KiB");
+                const id = `${e.id}~continue`;
+                e.continuation = { args, id };
+                return id;
+            }
+            case "JobStart": {
+                const fn = a.function;
+                if (typeof fn !== "string" || !this.#functions.has(fn))
+                    throw program("unknown_function", `Unknown function: ${String(fn)}`);
+                const onComplete = (a.on_complete ?? null);
+                if (onComplete !== null && !this.#functions.has(onComplete))
+                    throw program("unknown_function", `Unknown function: ${onComplete}`);
+                if (e.children.length >= account.maxChildren ||
+                    e.depth + 1 > account.maxDepth)
+                    throw limit("child_execution_limit", `At most ${account.maxChildren} jobs per execution, depth ${account.maxDepth}`);
+                const args = (a.args ?? null);
+                if (jsonBytes(args) > this.limits.exec.inputBytes)
+                    throw limit("input_too_large", "Job arguments over 32 KiB");
+                const id = `${e.chain}.${e.children.length}`;
+                e.children.push(id);
+                this.#schedule(this.#create(id, id, e.workflow, fn, args, e.depth + 1, onComplete));
+                return id;
+            }
+            case "JobWait": {
+                const ids = (Array.isArray(a.ids) ? a.ids : []);
+                const jobs = ids.map((id) => {
+                    const j = typeof id === "string" ? this.#jobs.get(id) : undefined;
+                    if (!j)
+                        throw program("execution_not_found", `Unknown execution: ${String(id)}`);
+                    return j;
+                });
+                if (this.#waiting >= account.parallelExecutions - 1)
+                    throw limit("job_wait_limit", `At most ${account.parallelExecutions - 1} executions wait at once`);
+                const left = this.limits.exec.wallMs - (performance.now() - e.startedAt);
+                const timeout = Math.max(0, Math.min(typeof a.timeout_ms === "number" ? a.timeout_ms : left, left));
+                this.#waiting++;
+                let timer;
+                try {
+                    await Promise.race([
+                        Promise.all(jobs.map((j) => chainDone(j))),
+                        new Promise((r) => (timer = setTimeout(r, timeout))),
+                    ]);
+                }
+                finally {
+                    clearTimeout(timer);
+                    this.#waiting--;
+                }
+                return jobs.map(jobResult);
+            }
+            case "JobResult": {
+                const j = typeof a.id === "string" ? this.#jobs.get(a.id) : undefined;
+                if (!j)
+                    throw program("execution_not_found", `Unknown execution: ${String(a.id)}`);
+                return jobResult(j);
+            }
+            case "Subscribe":
+            case "Unsubscribe":
+                if (this.#isolated)
+                    throw program("replay_isolated", "A replay cannot change subscriptions");
+        }
+        switch (name) {
+            case "Subscribe": {
+                const n = a.name;
+                if (typeof n !== "string" || !NAME.test(n))
+                    throw program("invalid_sdk_request", "invalid subscription name");
+                const s = a.subscription;
+                if (!s || typeof s !== "object" || !this.#functions.has(s.function))
+                    throw program("invalid_sdk_request", "invalid subscription");
+                const kinds = [
+                    "trade",
+                    "volume",
+                    "priceVariation",
+                    "interval",
+                    "poolEvent",
+                ];
+                if (!s.trigger || !kinds.includes(s.trigger.kind))
+                    throw program("invalid_sdk_request", "invalid subscription trigger");
+                const after = new Map(this.subscriptions);
+                for (const [k, v] of e.subs)
+                    after.set(k, v);
+                after.set(n, s);
+                const active = [...after.values()].filter((v) => v !== null);
+                if (active.length > account.maxSubscriptions)
+                    throw limit("subscription_limit", "At most 64 subscriptions");
+                if (active.filter((v) => v.trigger.kind === "priceVariation").length >
+                    account.maxPriceSubscriptions)
+                    throw limit("price_subscription_limit", "At most 8 price subscriptions");
+                e.subs.set(n, s);
+                return null;
+            }
+            case "Unsubscribe": {
+                const n = a.name;
+                if (typeof n !== "string" || !NAME.test(n))
+                    throw program("invalid_sdk_request", "invalid subscription name");
+                e.subs.set(n, null);
+                return null;
+            }
+            default:
+                if (name.startsWith("Storage"))
+                    return this.storage.op(name, a, e.id, e.io);
+                throw program("invalid_argument", `Invalid context operation: ${name}`);
+        }
+    }
+    async replay(options) {
+        const s = this.subscriptions.get(options.subscription);
+        if (!s)
+            throw new Error(`Unknown subscription ${options.subscription}: declare it in subscriptions or set it with ctx.subscriptions.set`);
+        const progress = {
+            eventsRead: 0,
+            eventsDelivered: 0,
+            deliveries: 0,
+            gaps: 0,
+            orderFallbacks: 0,
+        };
+        const warnings = [];
+        const pending = this.#replayEvents(s, options, progress, warnings);
+        if (options.batchSize !== undefined &&
+            (!Number.isInteger(options.batchSize) ||
+                options.batchSize < 1 ||
+                options.batchSize > REPLAY_MAX_BATCH))
+            throw new Error(`batchSize: 1 to ${REPLAY_MAX_BATCH} events`);
+        if (options.batchSize !== undefined && s.trigger.kind === "interval")
+            throw new Error("batchSize: an interval replay delivers one tick at a time");
+        const per = s.trigger.kind === "interval"
+            ? 1
+            : (options.batchSize ??
+                Math.min(Math.max(1, options.eventsPerDelivery ?? DELIVERY_BATCH), subscriptionLimits.eventsPerDelivery));
+        const scale = Math.ceil(per / DELIVERY_BATCH);
+        const keep = options.keepStorage && checkKeep(options.keepStorage);
+        const short = this.storage.areas.short;
+        const scratch = new LocalStorage(undefined, this.storage.areas, this.storage.now, short
+            ? {
+                quotaBytes: short.quotaBytes,
+                outside: () => this.storage.usedBytes("short"),
+            }
+            : undefined);
+        const isolated = new LocalRunner(this.#code, this.#object, [...this.#functions], {}, {
+            ...this.#options,
+            state: {},
+            storage: scratch,
+            data: this.data ?? "",
+            limits: this.limits,
+        });
+        isolated.#isolated = true;
+        const id = `replay-${++this.#runs}`;
+        const runs = [];
+        const emits = [];
+        const feedLimit = options.feedBytes ?? REPLAY_FEED_BYTES;
+        let feedBytes = 0;
+        let feedSeq = 0;
+        const send = (item) => {
+            const sent = { ...item, seq: ++feedSeq };
+            if (options.onFeed)
+                return options.onFeed(sent);
+            feedBytes += jsonBytes(sent);
+            if (feedBytes > feedLimit)
+                throw new HostError("limit", "replay_feed_full", `The emits and results of this replay went over ${feedLimit} bytes without a reader: pass onFeed to receive them as they come`);
+        };
+        const deadline = performance.now() + (options.maxDurationMs ?? REPLAY_MAX_DURATION_MS);
+        let error;
+        for (let i = 0; i < pending.length; i += per) {
+            if (options.maxDeliveries !== undefined &&
+                progress.deliveries >= options.maxDeliveries)
+                break;
+            if (performance.now() >= deadline) {
+                error = {
+                    kind: "limit",
+                    code: "replay_duration_limit",
+                    message: `A replay runs at most ${(options.maxDurationMs ?? REPLAY_MAX_DURATION_MS) / 60_000} minutes: split the window`,
+                };
+                break;
+            }
+            const chunk = pending.slice(i, i + per);
+            const clock = chunk[chunk.length - 1].time;
+            progress.eventsDelivered += chunk.filter((p) => !p.gap).length;
+            progress.deliveries++;
+            const run = await isolated.#run(s.function, {
+                kind: "events",
+                subscription: options.subscription,
+                events: chunk.map((p) => p.event),
+                replay: {
+                    id,
+                    delivery: progress.deliveries,
+                    clockMs: clock,
+                    sinceMs: options.sinceMs,
+                    untilMs: options.untilMs,
+                    simulated: true,
+                },
+            }, scale);
+            await isolated.idle();
+            try {
+                for (const value of run.emits)
+                    send({ kind: "emitted", data: value });
+                send({
+                    kind: "execution",
+                    execution: {
+                        id: run.id,
+                        status: run.status,
+                        ...(run.result !== undefined ? { result: run.result } : {}),
+                        ...(run.error ? { error: run.error } : {}),
+                        logs: run.logs,
+                    },
+                });
+            }
+            catch (e) {
+                if (!(e instanceof HostError))
+                    throw e;
+                error = { kind: e.kind, code: e.code, message: e.message };
+                break;
+            }
+            if (!options.onFeed) {
+                runs.push(run);
+                emits.push(...run.emits);
+            }
+            if (run.status !== "succeeded") {
+                error = {
+                    kind: run.error?.kind ?? "program",
+                    code: "delivery_failed",
+                    message: `Delivery ${progress.deliveries} failed: ${run.error?.code ?? run.status}`,
+                };
+                break;
+            }
+        }
+        for (const w of isolated.warnings)
+            if (!warnings.includes(w))
+                warnings.push(w);
+        let keptStorage;
+        if (keep && !error) {
+            try {
+                const copied = this.storage.copyFrom(scratch, keep.from ?? keep.to, keep.to, keep.keys);
+                keptStorage = { copied: true, ...copied };
+            }
+            catch (e) {
+                const f = e;
+                keptStorage = {
+                    copied: false,
+                    error: {
+                        kind: (f.kind ?? "limit"),
+                        code: f.code ?? "quota_exceeded",
+                        message: f.message ?? String(e),
+                    },
+                };
+            }
+        }
+        return {
+            id,
+            status: error ? "failed" : "succeeded",
+            ...(error ? { error } : {}),
+            runs,
+            state: new Map(isolated.state),
+            emits,
+            progress,
+            warnings,
+            ...(keptStorage ? { keptStorage } : {}),
+        };
+    }
+    replayEvents(s, o) {
+        return this.#replayEvents(s, o, {
+            eventsRead: 0,
+            eventsDelivered: 0,
+            deliveries: 0,
+            gaps: 0,
+            orderFallbacks: 0,
+        }, []);
+    }
+    #replayEvents(s, o, progress, warnings) {
+        const t = s.trigger;
+        if (t.kind === "interval")
+            return intervalEvents(t.everyMs, o.sinceMs, o.untilMs);
+        if (t.kind === "priceVariation")
+            throw new Error("priceVariation signals come from the service's price engine: replay them with client.replay (they cannot be rebuilt from exported trades)");
+        if (!this.data)
+            throw new Error("replay needs exported history (data)");
+        const wallet = t.kind === "trade" ? t.wallet : undefined;
+        const scope = t.mint
+            ? "token"
+            : wallet
+                ? "wallet"
+                : undefined;
+        const key = t.mint ?? wallet;
+        if (!scope || !key)
+            throw new Error("A local replay needs a trigger with a mint (or a wallet for trade): market-wide triggers cannot be exported");
+        const events = t.kind === "poolEvent";
+        const sinceCreation = t.kind === "volume" && t.windowMs === undefined;
+        let reads;
+        try {
+            reads = this.data.reads();
+        }
+        catch (e) {
+            throw new Error(e instanceof Error ? e.message : String(e));
+        }
+        const meta = reads
+            .filter((r) => r.scope === scope &&
+            r.key === key &&
+            r.side === "any" &&
+            r.sinceMs <= o.sinceMs &&
+            o.untilMs <= r.untilMs &&
+            r.done &&
+            (!events || r.withEvents))
+            .sort((a, b) => Number(b.withOrder) - Number(a.withOrder) ||
+            Number(!!b.withTx) - Number(!!a.withTx) ||
+            Number(b.withMarket) - Number(a.withMarket))[0];
+        const command = `zyrk export --${scope} ${key} --since ${new Date(o.sinceMs).toISOString()} --until ${new Date(o.untilMs).toISOString()} --with-order --with-tx${events ? " --with-events" : sinceCreation ? " --with-market" : ""}`;
+        if (!meta)
+            throw new Error(`No export covers this replay: ${command}`);
+        if (!meta.withOrder)
+            warnings.push(`The export has no on-chain order: events come in provider order, each with orderFallback: true. For the service's order: ${command}`);
+        if (!meta.withTx)
+            warnings.push(`The export has no transaction ids: every operation.tx is unknown. For the service's: ${command}`);
+        if (sinceCreation && !meta.withMarket)
+            warnings.push(`volume since creation needs the creations (market flags): without them no token has a complete total and nothing fires. Export with: ${command}`);
+        warnings.push(`Replayed operations lack fields of the live JSON: ${MISSING_OPERATION_FIELDS.join(", ")}.`);
+        return replayEvents(this.data, meta, s, o.sinceMs, o.untilMs, progress);
+    }
+}
+export const REPLAY_MAX_DURATION_MS = 30 * 60_000;
+export const REPLAY_FEED_BYTES = 16 * 1024 * 1024;
+const checkKeep = (k) => {
+    if (k.to !== "long" && k.to !== "durable")
+        throw new Error("keepStorage.to: expected long or durable");
+    if (k.from !== undefined && !["short", "long", "durable"].includes(k.from))
+        throw new Error("keepStorage.from: expected short, long or durable");
+    if (k.keys !== undefined && (k.keys.length < 1 || k.keys.length > 1000))
+        throw new Error("keepStorage.keys: 1 to 1000 keys");
+    return k;
+};
+const chainDone = async (e) => {
+    for (let x = e; x; x = x.next)
+        await x.done;
+};
+function view(e) {
+    return {
+        id: e.id,
+        function: e.function,
+        args: e.args,
+        status: e.status,
+        ...(e.result !== undefined ? { result: e.result } : {}),
+        ...(e.error ? { error: e.error } : {}),
+        logs: e.logs,
+        emits: e.emits,
+        usage: { ...e.usage },
+        children: [...e.children],
+        ...(e.next ? { next: e.next.id } : {}),
+    };
+}
+function loadContext(code, object, natives) {
+    const context = vm.createContext({});
+    const realm = vm.runInContext("({ Uint8Array, Uint16Array, Uint32Array, Int32Array, BigUint64Array, Float64Array, Array, Object, Error, Promise, JSON })", context);
+    let mode = "load";
+    const N = natives(realm, () => mode);
+    const factory = vm.runInContext(sandboxBootstrap(), context, {
+        filename: "bootstrap.js",
+    });
+    const guest = factory(N);
+    if (object)
+        context.__app = { default: object };
+    else
+        vm.runInContext(code, context, {
+            filename: "program.js",
+            timeout: execLimits.cpuMs,
+        });
+    return {
+        describe: () => guest.describe(),
+        start: (fn, args, execution) => {
+            mode = "run";
+            return guest.start(fn, args, execution);
+        },
+    };
+}
+function fnv(text) {
+    let h = 0xcbf29ce484222325n;
+    for (let i = 0; i < text.length; i++) {
+        h ^= BigInt(text.charCodeAt(i));
+        h = (h * 0x100000001b3n) & 0xffffffffffffffffn;
+    }
+    return h.toString(16).padStart(16, "0");
+}
+export async function runLocal(source, fn, args = null, options = {}) {
+    const runner = await LocalRunner.load(source, options);
+    const run = await runner.run(fn, args);
+    await runner.idle();
+    return { ...run, warnings: [...runner.warnings] };
+}