@johannc-dev/zyrk 0.2.0 → 0.2.1

package/dist/sandbox-bootstrap.js

@@ -299,25 +299,25 @@
   const summary = (r) => freeze({ key: r.key, size: r.size, contentType: r.contentType, lastModified: r.lastModified, expiresAt: r.expiresAt });
   const storageArea = (area) => {
     const read = async (key, offset, length) => {
-      const first = await call({ StorageGet: { area, key, offset, length: length > CHUNK ? CHUNK : length } });
-      if (first === null) return null;
-      const end = Math.min(first.size, offset + length);
-      const total = Math.max(0, end - first.offset);
+      const first2 = await call({ StorageGet: { area, key, offset, length: length > CHUNK ? CHUNK : length } });
+      if (first2 === null) return null;
+      const end = Math.min(first2.size, offset + length);
+      const total = Math.max(0, end - first2.offset);
       const out = new U8(total);
       let at = 0;
-      let r = first;
+      let r = first2;
       for (; ; ) {
         const n = N.b64decodeInto(r.data, out, at);
         if (n < 0) throw fail("unavailable", "Corrupt storage chunk");
         at += n;
         if (at >= total || n === 0) break;
         r = await call({
-          StorageGet: { area, key, offset: first.offset + at, length: Math.min(CHUNK, total - at) }
+          StorageGet: { area, key, offset: first2.offset + at, length: Math.min(CHUNK, total - at) }
         });
-        if (r === null || r.etag !== first.etag)
+        if (r === null || r.etag !== first2.etag)
           throw fail("value_changed", "The object changed while it was read: read it again");
       }
-      return { first, body: at === total ? out : out.subarray(0, at) };
+      return { first: first2, body: at === total ? out : out.subarray(0, at) };
     };
     const get = async (key, range) => {
       keyOf(key);
@@ -449,7 +449,7 @@
         version: execution.version,
         attempt: execution.attempt
       }),
-      data: freeze({
+      data: batching ? batchedData() : freeze({
         walletTrades: trades("wallet"),
         tokenTrades: trades("token"),
         tokenTotals: async (mint, o) => {
@@ -515,5 +515,167 @@
       return text === void 0 ? "null" : text;
     })();
   };
+  const batching = N.batchReads === true;
+  const BATCH = 64;
+  const MAX_REENTRY = 1e3;
+  const reflectApply = Reflect.apply;
+  const promiseThen = PromiseCtor.prototype.then;
+  const ready = PromiseCtor.resolve();
+  Object.defineProperty(ready, "constructor", { value: void 0 });
+  let open = false;
+  let direct = false;
+  let reentry = 0;
+  let first = null;
+  let last = null;
+  let epoch = 0;
+  const wait = (run, hint) => new PromiseCtor((resolve, reject) => {
+    const q = { run, hint, next: null, resolve, reject };
+    if (last === null) first = q;
+    else last.next = q;
+    last = q;
+  });
+  const checkpoint = () => {
+    let q = first;
+    first = null;
+    last = null;
+    direct = reentry >= MAX_REENTRY;
+    while (q !== null) {
+      epoch++;
+      let n = 0;
+      let hinted = 0;
+      for (let r = q; r !== null && n < BATCH; r = r.next) {
+        n++;
+        if (r.hint !== null && r.hint(epoch)) hinted++;
+      }
+      if (hinted > 0) N.hint();
+      for (; n > 0; n--) {
+        const c = q;
+        q = c.next;
+        let value;
+        try {
+          value = c.run();
+        } catch (e) {
+          c.reject(e);
+          continue;
+        }
+        c.resolve(value);
+      }
+    }
+    direct = false;
+    if (first === null) {
+      reentry = 0;
+      open = false;
+    } else {
+      reentry++;
+      reflectApply(promiseThen, ready, [checkpoint]);
+    }
+  };
+  const openBatch = () => {
+    open = true;
+    reflectApply(promiseThen, ready, [checkpoint]);
+  };
+  const waiting = () => open && !direct;
+  const tradesBatched = (kind) => (key, w) => {
+    if (typeof key !== "string") throw fail("invalid_argument", "Expected an address string");
+    const { since, until, side, allowPartial, withSignatures, withMarket, withEvents, withOrder, withTx } = checkWindow(w);
+    return freeze({
+      [asyncIterator]() {
+        let after = null;
+        let done = false;
+        let closed = false;
+        let mark = 0;
+        const end = () => ({ done: true, value: void 0 });
+        const read = () => {
+          if (done) return end();
+          const batch = N.read(kind, key, since, until, side, allowPartial, withSignatures, after, withMarket, withEvents, withOrder, withTx);
+          if (batch === null) {
+            done = true;
+            return end();
+          }
+          after = batch.hour;
+          return { done: false, value: batch };
+        };
+        const hint = (e) => {
+          if (done || mark === e) return false;
+          mark = e;
+          N.hint(kind, key, since, until, side, allowPartial, withSignatures, after, withMarket, withEvents, withOrder, withTx);
+          return true;
+        };
+        const nextNow = async () => {
+          if (done || closed) return end();
+          if (!direct) openBatch();
+          return read();
+        };
+        const returnNow = async (value) => {
+          closed = true;
+          return { done: true, value };
+        };
+        return {
+          next() {
+            if (!waiting()) return nextNow();
+            if (closed) return wait(end, null);
+            return wait(read, hint);
+          },
+          return(value) {
+            if (!waiting()) return returnNow(value);
+            closed = true;
+            return wait(() => ({ done: true, value }), null);
+          },
+          [asyncIterator]() {
+            return this;
+          }
+        };
+      }
+    });
+  };
+  const totalsNow = async (mint, o) => {
+    if (typeof mint !== "string") throw fail("invalid_argument", "Expected a mint address");
+    const rawQuote = o ? o.quote : void 0;
+    const quote = rawQuote !== void 0 ? StringCtor(rawQuote) : null;
+    return N.totals(mint, quote);
+  };
+  const infoNow = async (mint) => {
+    if (typeof mint !== "string") throw fail("invalid_argument", "Expected a mint address");
+    return N.info(mint);
+  };
+  const batchedData = () => freeze({
+    walletTrades: tradesBatched("wallet"),
+    tokenTrades: tradesBatched("token"),
+    tokenTotals: (mint, o) => {
+      if (!waiting()) return totalsNow(mint, o);
+      let quote;
+      try {
+        if (typeof mint !== "string") throw fail("invalid_argument", "Expected a mint address");
+        const rawQuote = o ? o.quote : void 0;
+        quote = rawQuote !== void 0 ? StringCtor(rawQuote) : null;
+      } catch (e) {
+        return PromiseCtor.reject(e);
+      }
+      return wait(() => N.totals(mint, quote), null);
+    },
+    tokenInfo: (mint) => {
+      if (!waiting()) return infoNow(mint);
+      if (typeof mint !== "string") return PromiseCtor.reject(fail("invalid_argument", "Expected a mint address"));
+      return wait(() => N.info(mint), null);
+    },
+    volumeSearch: async function* (params) {
+      let p = { ...params };
+      for (; ; ) {
+        let page;
+        if (waiting()) {
+          const text = flatParams(p);
+          page = await wait(() => N.volume(text), null);
+        } else page = N.volume(flatParams(p));
+        yield page;
+        const next = page === null || typeof page !== "object" ? null : page.nextCursor;
+        if (next === null || next === void 0) return;
+        if (typeof next !== "string" || next === p.cursor)
+          throw fail("history_unavailable", "Invalid next cursor");
+        const w = page.window;
+        if (w && typeof w === "object" && "since" in w) p = { ...p, since: w.since, until: w.until };
+        p = { ...p, cursor: next };
+      }
+    }
+  });
   return freeze({ start, describe });
 });

package/dist/sdk.d.ts

@@ -278,7 +278,12 @@ export declare const MarketEvent: {
 export declare const MarketFlag: {
     /** `tokenReserve` and `quoteReserve` are set. */
     readonly reserves: 1;
-    /** `virtualTokenReserve` and `virtualQuoteReserve` are set. */
+    /**
+     * `virtualTokenReserve` and `virtualQuoteReserve` are both set (always
+     * with {@link MarketFlag.virtualTokenReserve} and
+     * {@link MarketFlag.virtualQuoteReserve}). PumpSwap trades usually carry
+     * one side only: test the side you need instead.
+     */
     readonly virtualReserves: 2;
     /**
      * The provider row holds several operations on this pool (e.g. a buy and
@@ -315,6 +320,14 @@ export declare const MarketFlag: {
      * trader receives 0.30 % less than `tokenRaw`. `chainBreak` accounts for it.
      */
     readonly invertedPool: 512;
+    /** `virtualTokenReserve` is set. */
+    readonly virtualTokenReserve: 1024;
+    /**
+     * `virtualQuoteReserve` is set. On PumpSwap (pools created by pump.fun)
+     * it is added to the real reserve: the effective quote reserve is
+     * `quoteReserve + virtualQuoteReserve`.
+     */
+    readonly virtualQuoteReserve: 2048;
 };
 /**
  * Pool state and fees of each trade (`withMarket: true`), entry `i` for
@@ -328,9 +341,12 @@ export interface MarketColumns {
     readonly tokenReserve: BigUint64Array;
     readonly quoteReserve: BigUint64Array;
     /**
-     * Pumpfun: the virtual reserves of the bonding curve, the ones its
-     * constant product uses. Pumpswap: the provider's virtual reserves, when
-     * it gives them.
+     * Pumpfun: the total virtual reserves of the bonding curve, the ones its
+     * constant product uses. Pumpswap: a virtual amount added to the real
+     * reserve (effective quote reserve = `quoteReserve + virtualQuoteReserve`),
+     * usually on one side only. Each side is set when its flag is
+     * ({@link MarketFlag.virtualTokenReserve},
+     * {@link MarketFlag.virtualQuoteReserve}), `0` otherwise.
      */
     readonly virtualTokenReserve: BigUint64Array;
     readonly virtualQuoteReserve: BigUint64Array;
@@ -352,11 +368,11 @@ export interface MarketColumns {
     readonly event: Uint8Array;
 }
 /**
- * Latest known token metadata (`/v1/tokens/{mint}/info`, also `metadata` of
+ * Latest known token metadata (`ctx.data.tokenInfo`, also `metadata` of
  * `tokenTotals`): provider values copied verbatim from the newest row of the
  * mint that is cheap to reach, `null` when the row lacks them. `name`,
- * `symbol` and `uri` of stored hours come from the hour's `tokens.t2` (the
- * newest hour that has them), cut at 128, 64 and 512 UTF-8 bytes.
+ * `symbol` and `uri` of sealed hours come from the token index of the newest
+ * sealed hour that has them, cut at 128, 64 and 512 UTF-8 bytes.
  */
 export type TokenMetadata = {
     readonly name: string | null;
@@ -393,8 +409,8 @@ export type TokenInfo = {
     readonly metadata: TokenMetadata | null;
 };
 /**
- * Parameters of `/v1/volume/search`, with the same names and units
- * (`since`/`until` in **seconds**, multiples of 60). Paging is handled by
+ * Parameters of `ctx.data.volumeSearch` (`since`/`until` in **seconds**,
+ * multiples of 60, `[since, until)`, at most 31 days). Paging is handled by
  * `ctx.data.volumeSearch`: there is no `cursor`.
  */
 export interface VolumeSearchParams {
@@ -501,9 +517,9 @@ export interface Subscription {
     readonly maxReplayEvents?: number;
 }
 /**
- * A trade as published by the live feed, in the JSON shape of the public API
- * (`/v1/tokens/{mint}/operations`). Only the fields most programs read are
- * typed; the others are kept as they come.
+ * A trade as published by the live feed (the `operation` of a `trade` or
+ * `volume` event), with `id` the trade id `"hour:line:op"`. Only the fields
+ * most programs read are typed; the others are kept as they come.
  */
 export interface MarketOperation {
     readonly id: string;
@@ -795,7 +811,7 @@ export interface ExecutionInfo {
     /** 1 for the first attempt. */
     readonly attempt: number;
 }
-/** Lakebed's `StoragePutOptions` (every field optional here). */
+/** Options of `put` (every field optional). */
 export interface StoragePutOptions {
     /** `type/subtype`; parameters are dropped. Default: `text/plain` for a string, else `application/octet-stream`. */
     readonly contentType?: string;
@@ -809,7 +825,7 @@ export interface StoragePutOptions {
      */
     readonly ifMatch?: string;
 }
-/** Lakebed's `StorageObjectHead`, plus where the object stands in time. */
+/** The head of a stored object, with where it stands in time. */
 export interface StorageObjectHead {
     readonly key: string;
     readonly size: number;
@@ -824,11 +840,11 @@ export interface StorageObjectHead {
     /** Changes at every write (HTTP `ETag`). */
     readonly etag: string;
 }
-/** Lakebed's `StorageReadResult`. With a range, `body` is that range and `size` the whole object's. */
+/** What `get` answers. With a range, `body` is that range and `size` the whole object's. */
 export interface StorageReadResult extends StorageObjectHead {
     readonly body: Uint8Array;
 }
-/** Lakebed's `StorageObjectSummary` (what `list` answers), plus expiry. */
+/** One object of a `list` answer, with its expiry. */
 export interface StorageObjectSummary {
     readonly key: string;
     readonly size: number;
@@ -837,14 +853,14 @@ export interface StorageObjectSummary {
     readonly expiresAt: number | null;
 }
 /**
- * What `list` answers: Lakebed's array of summaries, plus `cursor` (pass it
+ * What `list` answers: an array of summaries, plus `cursor` (pass it
  * as `after` for the next page, `null` at the end) and `truncated`.
  */
 export type StorageListPage = StorageObjectSummary[] & {
     readonly cursor: string | null;
     readonly truncated: boolean;
 };
-/** Lakebed's `StorageLedgerUsage` for one area of the account, with its limits. */
+/** Usage of one storage area of the account, with its limits. */
 export interface StorageUsage {
     readonly area: "short" | "long" | "durable";
     readonly initialized: boolean;
@@ -886,9 +902,9 @@ export interface StorageWriter {
  * execution fails afterwards.
  */
 export interface StorageArea {
-    /** Lakebed's `put`. Answers the new head. */
+    /** Writes an object. Answers the new head. */
     put(key: string, body: StorageBody, options?: StoragePutOptions): Promise<StorageObjectHead>;
-    /** Lakebed's `get`; `range` reads part of a large object. `null` when absent or expired. */
+    /** Reads an object; `range` reads part of a large object. `null` when absent or expired. */
     get(key: string, range?: {
         offset?: number;
         length?: number;
@@ -899,7 +915,7 @@ export interface StorageArea {
         ifMatch?: string;
     }): Promise<void>;
     /**
-     * Lakebed's `list`: keys starting with `prefix`, in byte order, at most
+     * Lists keys starting with `prefix`, in byte order, at most
      * `maxObjects` (1000). For the next page, pass the last key as `after`.
      */
     list(prefix?: string, options?: {
@@ -924,16 +940,23 @@ export interface Context {
         walletTrades(wallet: Address, query: TradeQuery): AsyncIterable<HourBatch>;
         /** Trades of a token, one hour per batch, oldest first. */
         tokenTrades(mint: Address, query: TradeQuery): AsyncIterable<HourBatch>;
-        /** Same JSON as `/v1/tokens/{mint}/totals` (with `metadata`). */
+        /**
+         * Volume of a token since its creation (`cumulativeRaw`, `buyRaw`,
+         * `sellRaw`, `buys`, `sells`, `sinceCreation.complete`, `coverage`), its
+         * `creation` and `metadata`, as JSON.
+         */
         tokenTotals(mint: Address, options?: {
             quote?: Address;
         }): Promise<Json>;
         /**
-         * Same JSON as `/v1/tokens/{mint}/info`: latest known metadata and the
-         * creation, at most two blocks read (no volumes).
+         * Latest known metadata and the creation, at most two blocks read (no
+         * volumes).
          */
         tokenInfo(mint: Address): Promise<TokenInfo>;
-        /** Pages of `/v1/volume/search`, in its JSON shape. */
+        /**
+         * Tokens ranked by volume over a window, page by page (`items` of
+         * `{mint, volume, buyVolume, sellVolume, buys, sells, volumeRaw}`).
+         */
         volumeSearch(params: VolumeSearchParams): AsyncIterable<Json>;
     };
     /** Private JSON state of the program, kept between executions. */
@@ -1047,7 +1070,7 @@ export declare function parseTradeId(id: string): TradeKey;
 export declare function compareTradeIds(a: string, b: string): number;
 /**
  * Id of a live-feed operation, in the {@link tradeId} format (`operation.id`
- * as delivered by funrun, else `order.ord`); `null` without order.
+ * as delivered to subscriptions, else `order.ord`); `null` without order.
  */
 export declare function operationTradeId(operation: MarketOperation): string | null;
 /**
@@ -1115,9 +1138,9 @@ export declare function tradeAt(batch: HourBatch, i: number): Trade;
  * `error.code`; `message` is for humans and may change.
  */
 export type SdkErrorCode = "invalid_window" | "partial_coverage" | "history_preparing" | "storage_busy" | "history_unavailable" | "read_limit" | "read_time_limit" | "invalid_argument" | "unknown_function" | "execution_not_found" | "state_value_too_large" | "state_limit" | "children_limit" | "subscription_limit" | "price_subscription_limit" | "output_limit" | StorageErrorCode | (string & {});
-/** Lakebed's `StorageErrorCode`, plus `already_exists`, `value_changed`, `io_limit`, `upload_limit`, `precondition_failed`. */
+/** Error codes of user storage (`ctx.storage` and the HTTP storage routes). */
 export type StorageErrorCode = "quota_exceeded" | "too_large" | "not_found" | "invalid_request" | "forbidden" | "unavailable" | "blocked_type" | "already_exists" | "value_changed" | "io_limit" | "upload_limit" | "precondition_failed";
-/** HTTP status of each storage code (Lakebed's for its seven). */
+/** HTTP status of each storage code. */
 export declare const STORAGE_STATUS_BY_CODE: Readonly<Record<StorageErrorCode, number>>;
 /** Error thrown by a `ctx` call. `retryAfterMs` comes with `storage_busy`/`history_preparing`. */
 export interface SdkError extends Error {

package/dist/sdk.js

@@ -47,6 +47,8 @@ export const MarketFlag = {
     mayhem: 128,
     feeWithoutToken: 256,
     invertedPool: 512,
+    virtualTokenReserve: 1024,
+    virtualQuoteReserve: 2048,
 };
 export function isFinal(result) {
     return result.status !== "queued" && result.status !== "running";

package/dist/stream.d.ts

@@ -15,18 +15,66 @@ export interface StreamOptions {
     readonly apiKey: string;
     /** Resume after this sequence number. */
     readonly afterSeq?: number;
+    /**
+     * How long the server must keep refusing the key, with no successful join
+     * in between, before the stream ends with `invalid_key` (or `unauthorized`).
+     * Default 360 000 ms (6 min). See {@link executionEvents}: below the
+     * server's longest key sync delay, a key created just before the stream
+     * started could end it.
+     */
+    readonly keyRefusalWindowMs?: number;
 }
 /**
- * Live execution events of the account. Gaps are emitted as values; the
- * stream fails on undecodable payloads or when the server refuses the join.
- * The socket is closed when the stream is interrupted or ends.
+ * Live execution events of the account. Gaps are emitted as values.
+ *
+ * The stream reconnects by itself after a dropped or closed connection (no
+ * network, a server restart or deploy, a connection the server closed) and
+ * resumes after the last event. It fails, once, with:
+ * - a {@link DecodeError} on an undecodable payload;
+ * - a {@link NetworkError} when the server refuses the join, with the
+ *   server's `reason` (`functions_disabled`, `functions_unavailable`);
+ * - a {@link NetworkError} whose `reason` is `functions_disabled` (Functions
+ *   access removed) or `channel_closed` (the server closed the channel:
+ *   subscribe again with `afterSeq`);
+ * - a {@link NetworkError} whose `reason` is `invalid_key` (the key was
+ *   revoked, replaced or is unknown, or its account is not active) or
+ *   `unauthorized` (the same, seen at the join): the server kept refusing
+ *   the key for {@link StreamOptions.keyRefusalWindowMs} (default 6 min)
+ *   with no successful join in between. A single refusal never ends the
+ *   stream: a key created or changed less than a key sync ago, or a server
+ *   whose key data is briefly behind, is refused too; the stream retries
+ *   (every 5 s at most) and goes on as soon as a join succeeds. A refusal
+ *   that the server does not name (a server starting, a network failure,
+ *   the connection limit) is retried with no time limit;
+ * - a {@link NetworkError} whose `reason` is `account_changed`: a
+ *   reconnection joined another account than the first join (the key was
+ *   moved to another account). No event of the other account is delivered.
+ *   This check needs a server that names the account in its join reply: a
+ *   join answered without `account` (an older server, e.g. during a rollout
+ *   or rollback) is accepted unchecked.
+ *
+ * A transient `status` `{available: false}` does not end it. An older
+ * server that does not say why it refused a connection gives no
+ * `invalid_key`: the stream then keeps reconnecting, as before. The socket
+ * is closed and no reconnection happens once the stream is interrupted or
+ * has failed.
  */
 export declare const executionEvents: (options: StreamOptions) => Stream.Stream<FunctionsMessage, StreamError>;
-/** Callback API kept for existing users; errors are tagged `StreamError`s or raw socket errors. */
+/**
+ * Callback API kept for existing users; errors are tagged `StreamError`s or
+ * raw socket errors (transient: it reconnects by itself). While the server
+ * refuses the key (see {@link executionEvents}) nothing is reported: it
+ * retries silently, and reports once if the refusal lasts the whole window.
+ * After a `NetworkError` (`functions_disabled`, `functions_unavailable`,
+ * `channel_closed`, `invalid_key`, `unauthorized`, `account_changed`) the
+ * socket is closed and nothing more arrives.
+ */
 export declare function subscribeFunctions(options: {
     url: string;
     apiKey: string;
     afterSeq?: number;
+    /** See {@link StreamOptions.keyRefusalWindowMs}. */
+    keyRefusalWindowMs?: number;
     onEvent: (event: ExecutionEvent) => void;
     onGap?: (gap: Gap) => void;
     onError?: (error: unknown) => void;

package/dist/stream.js

@@ -6,19 +6,33 @@ export { ExecutionEvent, Gap } from "./contracts.js";
 const decoder = (schema, what) => decodeWith(schema, undefined, (message) => new DecodeError({ what, message }));
 const decodeEvent = decoder(ExecutionEvent, "execution event");
 const decodeGap = decoder(Gap, "stream gap");
+const refusedKey = 4401;
+const defaultKeyRefusalWindowMs = 360_000;
+const reconnectDelay = (closes) => Math.min(5_000, 500 * 2 ** closes) * (0.5 + Math.random() / 2);
 function connect(options, handlers) {
     let cursor = options.afterSeq;
+    const window = options.keyRefusalWindowMs ?? defaultKeyRefusalWindowMs;
     const endpoint = new URL("/v1/stream", options.url);
     endpoint.protocol =
         endpoint.protocol === "https:" || endpoint.protocol === "wss:"
             ? "wss:"
             : "ws:";
     const socket = new Socket(endpoint.toString(), {
-        params: { api_key: options.apiKey },
+        params: { api_key: options.apiKey, on_refusal: "close" },
         transport: WebSocket,
     });
     const channel = socket.channel("functions", () => cursor === undefined ? {} : { after_seq: cursor });
-    channel.on("execution", (raw) => {
+    let account;
+    let checked = false;
+    let held = [];
+    const gated = (handle) => (raw) => {
+        if (closed)
+            return;
+        if (!checked)
+            return void held.push(() => handle(raw));
+        handle(raw);
+    };
+    channel.on("execution", gated((raw) => {
         const result = decodeEvent(raw);
         if (Result.isFailure(result))
             return handlers.fail(result.failure);
@@ -27,26 +41,110 @@ function connect(options, handlers) {
             return;
         cursor = event.seq;
         handlers.message({ _tag: "Execution", event });
-    });
-    channel.on("gap", (raw) => {
+    }));
+    channel.on("gap", gated((raw) => {
         const result = decodeGap(raw);
         if (Result.isFailure(result))
             return handlers.fail(result.failure);
         cursor = result.success.resumeAfter;
         handlers.message({ _tag: "Gap", gap: result.success });
+    }));
+    let closed = false;
+    let timer;
+    const stop = () => {
+        closed = true;
+        held = [];
+        clearTimeout(timer);
+        channel.leave();
+        socket.disconnect();
+    };
+    const fail = (message, cause, reason) => {
+        if (closed)
+            return;
+        stop();
+        handlers.fail(new NetworkError({
+            url: endpoint.toString(),
+            message,
+            cause,
+            ...(reason === undefined ? {} : { reason }),
+        }));
+    };
+    channel.on("status", gated((raw) => {
+        const status = raw;
+        if (status?.available === false && status.reason === "functions_disabled")
+            fail("Functions access was removed from this account: the server closed the stream", raw, "functions_disabled");
+    }));
+    channel.onClose((cause) => fail(`The server closed the stream: subscribe again with afterSeq ${cursor ?? "(unset)"}`, cause, "channel_closed"));
+    let closes = 0;
+    let pending = false;
+    const reconnect = () => {
+        if (pending)
+            return;
+        pending = true;
+        socket.disconnect();
+        timer = setTimeout(() => {
+            pending = false;
+            socket.connect();
+        }, reconnectDelay(closes++));
+    };
+    let refusedSince;
+    const refused = (reason, message, cause) => {
+        const now = Date.now();
+        refusedSince ??= now;
+        if (now - refusedSince >= window)
+            return fail(message, cause, reason);
+        reconnect();
+    };
+    socket.onClose((event) => {
+        if (closed || pending)
+            return;
+        if (event?.code === refusedKey)
+            return refused("invalid_key", `The API key is no longer valid (revoked, unknown, or its account is not active): the server refused it for ${Math.round(window / 1000)} s`, event);
+        if (event?.code === 1000)
+            reconnect();
+    });
+    const transient = (error) => queueMicrotask(() => {
+        if (!closed && refusedSince === undefined)
+            handlers.transient(error);
+    });
+    socket.onError(transient);
+    channel.onError((error) => {
+        checked = false;
+        transient(error);
     });
-    socket.onError((error) => handlers.transient(error));
-    channel.onError((error) => handlers.transient(error));
     socket.connect();
-    channel.join().receive("error", (reason) => handlers.fail(new NetworkError({
-        url: endpoint.toString(),
-        message: `Stream join refused: ${JSON.stringify(reason)}`,
-        cause: reason,
-    })));
+    channel
+        .join()
+        .receive("ok", (reply) => {
+        if (closed)
+            return;
+        const named = reply?.account;
+        if (typeof named === "string") {
+            account ??= named;
+            if (named !== account)
+                return fail("The API key now belongs to another account: the stream of the previous account ended (its events are not followed on the new one)", reply, "account_changed");
+        }
+        checked = true;
+        closes = 0;
+        refusedSince = undefined;
+        const waiting = held;
+        held = [];
+        for (const handle of waiting)
+            if (!closed)
+                handle();
+    })
+        .receive("error", (reason) => {
+        if (closed)
+            return;
+        const code = reason?.reason;
+        const message = `Stream join refused: ${JSON.stringify(reason)}`;
+        if (code === "unauthorized")
+            return refused(code, message, reason);
+        fail(message, reason, typeof code === "string" ? code : undefined);
+    });
     return {
         close() {
-            channel.leave();
-            socket.disconnect();
+            stop();
         },
         get cursor() {
             return cursor;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@johannc-dev/zyrk",
-  "version": "0.2.0",
-  "description": "SDK and CLI for Zyrk hosted functions (funrun v2)",
+  "version": "0.2.1",
+  "description": "SDK and CLI for Zyrk hosted functions",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public",
@@ -39,7 +39,7 @@
   "scripts": {
     "build": "node scripts/build.mjs",
     "typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.test.json",
-    "test": "npm run build && npm run typecheck && node --test test/*.test.ts",
+    "test": "npm run build && npm run typecheck && node --test --test-timeout=60000 --test-force-exit test/*.test.ts",
     "format": "prettier --write src types scripts test examples package.json tsconfig.json tsconfig.test.json README.md",
     "format:check": "prettier --check src types scripts test examples package.json tsconfig.json tsconfig.test.json README.md",
     "prepack": "npm run build"