withruntime 0.11.1 → 0.12.0

package/dist/products/logs.js

@@ -0,0 +1,274 @@
+import { RuntimeError, InvalidRequestError } from "../errors.js";
+import { Page } from "../page.js";
+const enc = encodeURIComponent;
+const protocol = (message) => new RuntimeError({
+    code: "invalid_stream",
+    status: 422,
+    message,
+    hint: "Reconnect the log tail. If this repeats, report the request to support.",
+});
+/** Shared CRUD keeps the saved log and trace views on identical contracts. */
+function resources(t, path) {
+    const list = async (query = {}, options) => {
+        const page = await t.json({
+            method: "GET",
+            path,
+            query,
+            ...options,
+        });
+        return new Page(page.data, page.nextCursor, (cursor) => list({ ...query, cursor }, options));
+    };
+    return {
+        create: (body, options) => t.json({ method: "POST", path, body, ...options }),
+        get: (id, options) => t.json({ method: "GET", path: `${path}/${enc(id)}`, ...options }),
+        list,
+        update: (id, body, options) => t.json({ method: "PUT", path: `${path}/${enc(id)}`, body, ...options }),
+        delete: (id, options) => t.json({ method: "DELETE", path: `${path}/${enc(id)}`, ...options }),
+    };
+}
+function ingest(t, path, body, options) {
+    if (new TextEncoder().encode(JSON.stringify(body)).length > 1_048_576)
+        throw new InvalidRequestError({
+            code: "payload_too_large",
+            status: 413,
+            message: "OTLP JSON exceeds 1 MiB.",
+            hint: "Split the write into smaller batches, each with its own idempotency key.",
+        });
+    return t.json({ method: "POST", path, body, ...options });
+}
+/** Parse SSE incrementally, including split UTF-8, CRLF and multi-line data.
+ * Incomplete events at disconnect are discarded and replayed from the cursor.
+ * A finite event bound prevents a broken peer from growing memory forever. */
+async function* events(stream, signal) {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "", id = "", event = "", data = [], size = 0;
+    const cancel = () => {
+        void reader.cancel(signal?.reason).catch(() => undefined);
+    };
+    if (signal?.aborted)
+        cancel();
+    else
+        signal?.addEventListener("abort", cancel, { once: true });
+    try {
+        for (;;) {
+            signal?.throwIfAborted();
+            const chunk = await reader.read().catch((cause) => {
+                signal?.throwIfAborted();
+                throw new RuntimeError({
+                    code: "tail_connection_lost",
+                    status: 503,
+                    message: "The log stream disconnected.",
+                    hint: "The SDK resumes from the last delivered cursor.",
+                    cause,
+                });
+            });
+            signal?.throwIfAborted();
+            if (chunk.done)
+                break;
+            buffer += decoder.decode(chunk.value, { stream: true });
+            for (;;) {
+                const match = /\r\n|\r|\n/.exec(buffer);
+                if (!match || (match[0] === "\r" && match.index === buffer.length - 1))
+                    break;
+                const line = buffer.slice(0, match.index);
+                buffer = buffer.slice(match.index + match[0].length);
+                size += line.length + 1;
+                if (size > 1_048_576)
+                    throw protocol("A log event exceeds 1 MiB of text.");
+                if (!line) {
+                    if (data.length)
+                        yield { id, event, data: data.join("\n") };
+                    id = "";
+                    event = "";
+                    data = [];
+                    size = 0;
+                }
+                else if (!line.startsWith(":")) {
+                    const colon = line.indexOf(":");
+                    const field = colon < 0 ? line : line.slice(0, colon);
+                    const value = colon < 0 ? "" : line.slice(colon + 1).replace(/^ /, "");
+                    if (field === "id" && !value.includes("\0"))
+                        id = value;
+                    if (field === "event")
+                        event = value;
+                    if (field === "data")
+                        data.push(value);
+                }
+            }
+            if (buffer.length + size > 1_048_576)
+                throw protocol("A log event exceeds 1 MiB of text.");
+        }
+    }
+    finally {
+        signal?.removeEventListener("abort", cancel);
+        await reader.cancel().catch(() => undefined);
+        reader.releaseLock();
+    }
+}
+function pause(ms, signal) {
+    return new Promise((resolve, reject) => {
+        const done = () => {
+            signal?.removeEventListener("abort", abort);
+            resolve();
+        };
+        const timer = setTimeout(done, ms);
+        const abort = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", abort);
+            reject(signal?.reason instanceof Error ? signal.reason : new DOMException("Aborted", "AbortError"));
+        };
+        if (signal?.aborted)
+            abort();
+        else
+            signal?.addEventListener("abort", abort, { once: true });
+    });
+}
+/** Hidden until Logs launches. */
+export function logs(t) {
+    const search = (body, options) => t.json({ method: "POST", path: "/v1/logs:search", body, ...options });
+    return {
+        search,
+        async *pages(input, options) {
+            let cursor = input.cursor;
+            const seen = new Set();
+            if (cursor)
+                seen.add(cursor);
+            do {
+                const page = await search({ ...input, ...(cursor ? { cursor } : {}) }, options);
+                yield page;
+                cursor = page.next ?? undefined;
+                if (cursor && seen.has(cursor))
+                    throw protocol("Search repeated a paging cursor.");
+                if (cursor)
+                    seen.add(cursor);
+            } while (cursor);
+        },
+        /** The record's cursor, not timestamp or text, identifies a line. The
+         * server replays strictly after it. An echoed boundary is ignored; two
+         * identical lines at different record positions are both delivered. */
+        async *tail(query, options = {}) {
+            const { cursor: initial, start, reconnectMs = 250, ...request } = options;
+            let cursor = initial, failures = 0;
+            if (!Number.isFinite(reconnectMs) || reconnectMs < 0)
+                throw protocol("Reconnect delay must be a finite, nonnegative number.");
+            for (;;) {
+                request.signal?.throwIfAborted();
+                try {
+                    const stream = await t.fileStream({
+                        method: "GET",
+                        path: "/v1/logs/tail",
+                        query: { query, cursor, start },
+                        accept: "text/event-stream",
+                        ...request,
+                        timeoutMs: request.timeoutMs ?? 0,
+                        onResponse(response) {
+                            if (!response.headers.get("content-type")?.toLowerCase().startsWith("text/event-stream"))
+                                throw protocol("Log tail did not return text/event-stream.");
+                        },
+                    });
+                    for await (const event of events(stream, request.signal)) {
+                        let value;
+                        try {
+                            value = JSON.parse(event.data);
+                        }
+                        catch {
+                            throw protocol("Log tail returned invalid JSON.");
+                        }
+                        if (event.event === "error") {
+                            // A reader failure is retryable, but its resume id has not been
+                            // delivered as a line. Keep the last acknowledged line cursor.
+                            throw new RuntimeError({
+                                code: "tail_interrupted",
+                                status: 503,
+                                message: "The log reader stopped.",
+                                hint: "The SDK resumes from the last delivered cursor.",
+                            });
+                        }
+                        if (!event.id)
+                            throw protocol("Log tail event has no record cursor.");
+                        if (event.id === cursor)
+                            continue;
+                        if (event.event === "start") {
+                            // Where the server's tail begins: a reconnect before the first
+                            // line resumes here, so nothing written meanwhile is missed.
+                            cursor = event.id;
+                            continue;
+                        }
+                        if (event.event === "gap") {
+                            const gap = value;
+                            const from = gap?.from ?? cursor;
+                            const to = gap?.to ?? gap?.cursor;
+                            if (typeof from !== "string" || typeof to !== "string" || to !== event.id)
+                                throw protocol("Log tail gap has invalid cursors.");
+                            cursor = event.id;
+                            yield { gap: true, from, to };
+                        }
+                        else {
+                            const line = value;
+                            if (!line ||
+                                typeof line.timeUnixNano !== "string" ||
+                                typeof line.time !== "string" ||
+                                !line.labels ||
+                                !("body" in line))
+                                throw protocol("Log tail returned an invalid line.");
+                            cursor = event.id;
+                            yield { ...line, cursor };
+                        }
+                        failures = 0;
+                    }
+                }
+                catch (error) {
+                    request.signal?.throwIfAborted();
+                    if (error instanceof RuntimeError && !error.retryable)
+                        throw error;
+                    if (!(error instanceof RuntimeError) && !(error instanceof TypeError))
+                        throw error;
+                }
+                await pause(Math.min(10_000, Math.max(0, reconnectMs) * 2 ** Math.min(failures++, 6)), request.signal);
+            }
+        },
+        query: (query, options) => t.json({ method: "GET", path: "/v1/logs/query", query, ...options }),
+        queryRange: (query, options) => t.json({ method: "GET", path: "/v1/logs/query_range", query, ...options }),
+        labels: (query = {}, options) => t.json({ method: "GET", path: "/v1/logs/labels", query, ...options }),
+        labelValues: (name, query = {}, options) => t.json({
+            method: "GET",
+            path: `/v1/logs/labels/${enc(name)}/values`,
+            query,
+            ...options,
+        }),
+        views: resources(t, "/v1/logs/views"),
+        ingest: (body, options) => ingest(t, "/v1/logs", body, options),
+    };
+}
+export function traces(t) {
+    return {
+        get: (id, options) => t.json({ method: "GET", path: `/v1/traces/${enc(id)}`, ...options }),
+        search: (q, options) => t.json({
+            method: "GET",
+            path: "/v1/traces:search",
+            query: { q },
+            ...options,
+        }),
+        tags: (options) => t.json({ method: "GET", path: "/v1/traces/tags", ...options }),
+        views: resources(t, "/v1/traces/views"),
+        ingest: (body, options) => ingest(t, "/v1/traces", body, options),
+    };
+}
+export function alerts(t) {
+    return {
+        ...resources(t, "/v1/alerts"),
+        test: (id, options) => t.json({
+            method: "POST",
+            path: `/v1/alerts/${enc(id)}/test`,
+            body: {},
+            ...options,
+        }),
+        silence: (id, input, options) => t.json({
+            method: "POST",
+            path: `/v1/alerts/${enc(id)}/silence`,
+            body: input,
+            ...options,
+        }),
+    };
+}

package/dist/products/logs.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/products/logs.test.js

@@ -0,0 +1,343 @@
+import { describe, expect, test } from "bun:test";
+import { Transport } from "../transport.js";
+import { InvalidRequestError, NotFoundError, RuntimeError } from "../errors.js";
+import { alerts, logs, traces, } from "./logs.js";
+const line = {
+    time: "2026-10-06T12:00:00.000000001Z",
+    timeUnixNano: "1791288000000000001",
+    severity: 9,
+    severityText: "INFO",
+    body: "same α",
+    labels: { app: "api" },
+    attributes: {},
+    traceId: null,
+    spanId: null,
+};
+const view = { name: "errors", labels: {}, query: '{app="api"}' };
+const rule = { ...view, condition: "above 5", for: "5m", actions: [] };
+const options = { idempotencyKey: "repeat-this-write" };
+function fixture(handler) {
+    const requests = [];
+    const transport = new Transport({
+        apiKey: "test-only",
+        baseUrl: "https://fake.test",
+        maxRetries: 0,
+        fetch: (async (input, init) => {
+            const url = new URL(input instanceof Request ? input.url : input);
+            requests.push({ url, init: init ?? {} });
+            return handler(url, init ?? {});
+        }),
+    });
+    return {
+        client: { logs: logs(transport), traces: traces(transport), alerts: alerts(transport) },
+        requests,
+    };
+}
+const calls = [
+    {
+        name: "search",
+        method: "POST",
+        path: "/v1/logs:search",
+        body: { query: "{}", cursor: "c", limit: 2 },
+        run: (c) => c.logs.search({ query: "{}", cursor: "c", limit: 2 }, options),
+    },
+    {
+        name: "instant query",
+        method: "GET",
+        path: "/v1/logs/query",
+        query: { query: "{}", time: "42", direction: "forward", limit: "2" },
+        run: (c) => c.logs.query({ query: "{}", time: "42", direction: "forward", limit: 2 }),
+    },
+    {
+        name: "range query",
+        method: "GET",
+        path: "/v1/logs/query_range",
+        query: { query: "{}", start: "1", end: "2", step: "1s" },
+        run: (c) => c.logs.queryRange({ query: "{}", start: "1", end: "2", step: "1s" }),
+    },
+    {
+        name: "labels",
+        method: "GET",
+        path: "/v1/logs/labels",
+        query: { start: "1", end: "2" },
+        run: (c) => c.logs.labels({ start: "1", end: "2" }),
+    },
+    {
+        name: "label values",
+        method: "GET",
+        path: "/v1/logs/labels/a%2Fb/values",
+        run: (c) => c.logs.labelValues("a/b"),
+    },
+    { name: "trace get", method: "GET", path: "/v1/traces/a%2Fb", run: (c) => c.traces.get("a/b") },
+    {
+        name: "trace search",
+        method: "GET",
+        path: "/v1/traces:search",
+        query: { q: "{duration > 1s}" },
+        run: (c) => c.traces.search("{duration > 1s}"),
+    },
+    { name: "trace tags", method: "GET", path: "/v1/traces/tags", run: (c) => c.traces.tags() },
+    {
+        name: "log ingest",
+        method: "POST",
+        path: "/v1/logs",
+        body: { resourceLogs: [] },
+        run: (c) => c.logs.ingest({ resourceLogs: [] }, options),
+    },
+    {
+        name: "trace ingest",
+        method: "POST",
+        path: "/v1/traces",
+        body: { resourceSpans: [] },
+        run: (c) => c.traces.ingest({ resourceSpans: [] }, options),
+    },
+    {
+        name: "test rule",
+        method: "POST",
+        path: "/v1/alerts/a%2Fb/test",
+        body: {},
+        run: (c) => c.alerts.test("a/b", options),
+    },
+    {
+        name: "silence rule",
+        method: "POST",
+        path: "/v1/alerts/a%2Fb/silence",
+        body: { until: "2026-10-07T00:00:00Z" },
+        run: (c) => c.alerts.silence("a/b", { until: "2026-10-07T00:00:00Z" }, options),
+    },
+];
+for (const product of ["logs", "traces", "alerts"]) {
+    const path = `/v1/${product}${product === "alerts" ? "" : "/views"}`;
+    const resource = (c) => (product === "alerts" ? c.alerts : c[product].views);
+    const input = product === "alerts" ? rule : view;
+    calls.push({
+        name: `${product} create`,
+        method: "POST",
+        path,
+        body: input,
+        run: (c) => resource(c).create(input, options),
+    }, {
+        name: `${product} get`,
+        method: "GET",
+        path: `${path}/a%2Fb`,
+        run: (c) => resource(c).get("a/b"),
+    }, {
+        name: `${product} list`,
+        method: "GET",
+        path,
+        query: { limit: "2", cursor: "next" },
+        run: (c) => resource(c).list({ limit: 2, cursor: "next" }),
+    }, {
+        name: `${product} update`,
+        method: "PUT",
+        path: `${path}/a%2Fb`,
+        body: { name: "changed" },
+        run: (c) => resource(c).update("a/b", { name: "changed" }, options),
+    }, {
+        name: `${product} delete`,
+        method: "DELETE",
+        path: `${path}/a%2Fb`,
+        run: (c) => resource(c).delete("a/b", options),
+    });
+}
+for (const entry of calls)
+    describe(entry.name, () => {
+        test("request, encoded path and idempotency", async () => {
+            const { client, requests } = fixture(() => entry.method === "DELETE"
+                ? new Response(null, { status: 204 })
+                : Response.json({ data: [], nextCursor: null, marker: "answer" }));
+            const answer = await entry.run(client);
+            if (entry.method === "DELETE")
+                expect(answer).toBeNull();
+            else if (!entry.name.endsWith(" list"))
+                expect(answer).toEqual({ data: [], nextCursor: null, marker: "answer" });
+            expect(requests).toHaveLength(1);
+            const request = requests[0];
+            expect(request.url.pathname).toBe(entry.path);
+            expect(request.init.method).toBe(entry.method);
+            expect(Object.fromEntries(request.url.searchParams)).toEqual(entry.query ?? {});
+            if (entry.body !== undefined)
+                expect(JSON.parse(request.init.body)).toEqual(entry.body);
+            if (entry.method !== "GET")
+                expect(new Headers(request.init.headers).get("idempotency-key")).toBe(options.idempotencyKey);
+        });
+        test("typed server error preserves code and hint", async () => {
+            const { client } = fixture(() => Response.json({ error: { code: "not_found", message: "Missing", hint: "List resources first." } }, { status: 404 }));
+            try {
+                await entry.run(client);
+                throw new Error("Accepted failure");
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(NotFoundError);
+                expect(error).toMatchObject({ code: "not_found", hint: "List resources first." });
+            }
+        });
+    });
+test("search paging follows opaque cursors and preserves equal timestamp lines", async () => {
+    const { client, requests } = fixture((_url, init) => Response.json({
+        lines: [line],
+        next: JSON.parse(init.body).cursor ? null : "opaque/+",
+        stats: {},
+    }));
+    const pages = [];
+    for await (const page of client.logs.pages({ query: "{}", limit: 1 }))
+        pages.push(page);
+    expect(pages.flatMap((page) => page.lines)).toEqual([line, line]);
+    expect(JSON.parse(requests[1].init.body).cursor).toBe("opaque/+");
+});
+test("search detects a cursor loop", async () => {
+    const { client } = fixture(() => Response.json({ lines: [], next: "same" }));
+    const iterator = client.logs.pages({ query: "{}", cursor: "same" });
+    await iterator.next();
+    await expect(iterator.next()).rejects.toMatchObject({ code: "invalid_stream" });
+});
+test("resource lists can follow pages", async () => {
+    const { client } = fixture((url) => Response.json({
+        data: [{ id: url.searchParams.get("cursor") ?? "first" }],
+        nextCursor: url.searchParams.has("cursor") ? null : "second",
+    }));
+    expect(await (await client.logs.views.list()).toArray()).toEqual([
+        { id: "first" },
+        { id: "second" },
+    ]);
+});
+test("UTF-8 bytes enforce the 1 MiB ingest bound before fetch", () => {
+    const { client, requests } = fixture(() => {
+        throw new Error("No fetch allowed");
+    });
+    expect(() => client.logs.ingest({ resourceLogs: [{ body: "α".repeat(530_000) }] })).toThrow(InvalidRequestError);
+    expect(() => client.traces.ingest({ resourceSpans: [{ body: "α".repeat(530_000) }] })).toThrow(InvalidRequestError);
+    expect(requests).toHaveLength(0);
+});
+const event = (id, value = line, kind = "") => `id: ${id}\r\n${kind ? `event: ${kind}\r\n` : ""}data: ${JSON.stringify(value)}\r\n\r\n`;
+function sse(text, bytes = 7) {
+    const encoded = new TextEncoder().encode(text);
+    let at = 0;
+    return new Response(new ReadableStream({
+        pull(controller) {
+            if (at === encoded.length)
+                controller.close();
+            else {
+                controller.enqueue(encoded.slice(at, at + bytes));
+                at = Math.min(at + bytes, encoded.length);
+            }
+        },
+    }), { headers: { "content-type": "text/event-stream" } });
+}
+test("SSE reconnects by cursor, discards torn events, keeps identical records and decodes split UTF-8", async () => {
+    let count = 0;
+    const { client, requests } = fixture(() => ++count === 1
+        ? sse(`: heartbeat\r\n\r\n${event("one")}id: torn\ndata: {`)
+        : sse(event("one") + event("two")));
+    const iterator = client.logs.tail("{}", { reconnectMs: 0 });
+    expect((await iterator.next()).value).toEqual({ ...line, cursor: "one" });
+    expect((await iterator.next()).value).toEqual({ ...line, cursor: "two" });
+    expect(requests[1].url.searchParams.get("cursor")).toBe("one");
+    expect(new Headers(requests[0].init.headers).get("accept")).toBe("text/event-stream");
+    await iterator.return(undefined);
+});
+test("a drop before the first line resumes from the start event's cursor", async () => {
+    let count = 0;
+    const { client, requests } = fixture(() => ++count === 1
+        ? sse(event("began", { cursor: "began" }, "start"))
+        : sse(event("began", { cursor: "began" }, "start") + event("first")));
+    const iterator = client.logs.tail("{}", { reconnectMs: 0 });
+    expect((await iterator.next()).value).toEqual({ ...line, cursor: "first" });
+    expect(requests[0].url.searchParams.get("cursor")).toBeNull();
+    expect(requests[1].url.searchParams.get("cursor")).toBe("began");
+    await iterator.return(undefined);
+});
+test("server retention gap becomes typed from/to and resumes after it", async () => {
+    const { client } = fixture(() => sse(event("kept", { cursor: "kept" }, "gap") + event("later")));
+    const iterator = client.logs.tail("{}", { cursor: "expired", reconnectMs: 0 });
+    expect((await iterator.next()).value).toEqual({ gap: true, from: "expired", to: "kept" });
+    expect((await iterator.next()).value).toMatchObject({ cursor: "later" });
+    await iterator.return(undefined);
+});
+test("reader error, including an echoed cursor, reconnects without moving the cursor", async () => {
+    let calls = 0;
+    const { client, requests } = fixture(() => sse(++calls === 1 ? event("old", { message: "reader gone" }, "error") : event("new")));
+    const iterator = client.logs.tail("{}", { cursor: "old", reconnectMs: 0 });
+    expect((await iterator.next()).value).toMatchObject({ cursor: "new" });
+    expect(requests[1].url.searchParams.get("cursor")).toBe("old");
+    await iterator.return(undefined);
+});
+for (const [name, wire] of [
+    ["JSON", "id: a\ndata: nope\n\n"],
+    ["cursor", `data: ${JSON.stringify(line)}\n\n`],
+    ["line", event("a", {})],
+    ["gap", event("a", { cursor: "wrong" }, "gap")],
+    ["oversized event", `id: a\ndata: ${"x".repeat(1_048_577)}\n\n`],
+])
+    test(`invalid ${name} fails once with a code and hint`, async () => {
+        const { client, requests } = fixture(() => sse(wire, wire.length));
+        await expect(client.logs.tail("{}", { cursor: "before", reconnectMs: 0 }).next()).rejects.toMatchObject({ code: "invalid_stream", hint: expect.any(String) });
+        expect(requests).toHaveLength(1);
+    });
+test("tail authentication errors do not reconnect", async () => {
+    const { client, requests } = fixture(() => Response.json({ error: { code: "unauthorized", hint: "Sign in." } }, { status: 401 }));
+    await expect(client.logs.tail("{}").next()).rejects.toMatchObject({
+        code: "unauthorized",
+        hint: "Sign in.",
+    });
+    expect(requests).toHaveLength(1);
+});
+test("aborting an idle connection closes its reader", async () => {
+    let cancelled = false;
+    const { client } = fixture(() => new Response(new ReadableStream({
+        cancel() {
+            cancelled = true;
+        },
+    }), { headers: { "content-type": "text/event-stream" } }));
+    const abort = new AbortController();
+    const iterator = client.logs.tail("{}", { signal: abort.signal });
+    const pending = iterator.next();
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    abort.abort(new Error("test stop"));
+    await expect(pending).rejects.toThrow("test stop");
+    expect(cancelled).toBe(true);
+});
+test("non-SSE success is refused", async () => {
+    const { client } = fixture(() => Response.json({}));
+    await expect(client.logs.tail("{}").next()).rejects.toBeInstanceOf(RuntimeError);
+});
+test("an abrupt read failure reconnects, rather than only handling clean EOF", async () => {
+    let attempt = 0;
+    const { client, requests } = fixture(() => {
+        if (++attempt > 1)
+            return sse(event("second"));
+        let pulled = false;
+        return new Response(new ReadableStream({
+            pull(controller) {
+                if (!pulled) {
+                    pulled = true;
+                    controller.enqueue(new TextEncoder().encode(event("first")));
+                }
+                else
+                    controller.error(new Error("connection reset"));
+            },
+        }), { headers: { "content-type": "text/event-stream" } });
+    });
+    const iterator = client.logs.tail("{}", { reconnectMs: 0 });
+    expect((await iterator.next()).value).toMatchObject({ cursor: "first" });
+    expect((await iterator.next()).value).toMatchObject({ cursor: "second" });
+    expect(requests[1].url.searchParams.get("cursor")).toBe("first");
+    await iterator.return(undefined);
+});
+test("a multline SSE event and the agreed from/to gap shape are accepted", async () => {
+    const { client } = fixture(() => sse('event: gap\nid: kept\ndata: {"from":"old",\ndata: "to":"kept"}\n\n'));
+    const iterator = client.logs.tail("{}", { cursor: "old" });
+    expect((await iterator.next()).value).toEqual({ gap: true, from: "old", to: "kept" });
+    await iterator.return(undefined);
+});
+test("abort during reconnect delay stops without another request", async () => {
+    const abort = new AbortController();
+    const { client, requests } = fixture(() => sse(event("first")));
+    const iterator = client.logs.tail("{}", { signal: abort.signal, reconnectMs: 1000 });
+    await iterator.next();
+    const pending = iterator.next();
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    abort.abort(new Error("stop reconnect"));
+    await expect(pending).rejects.toThrow("stop reconnect");
+    expect(requests).toHaveLength(1);
+});