withruntime 0.12.0 → 0.16.0

package/dist/cli/logs.test.js

@@ -1,272 +0,0 @@
-import { expect, test } from "bun:test";
-import { logsProductCommand } from "./logs.js";
-import { terminalSafe } from "../terminal.js";
-import { logs, traces, alerts } from "../products/logs.js";
-import { Transport } from "../transport.js";
-import { InvalidRequestError } from "../errors.js";
-const input = {
-    name: "errors",
-    labels: {},
-    query: '{app="api"}',
-    condition: "above 5",
-    for: "5m",
-    actions: [],
-};
-const cases = [
-    ["logs", ["query", "{}"], { from: "1", to: "2", limit: "5" }, "GET", "/v1/logs/query_range"],
-    ["logs", ["labels"], {}, "GET", "/v1/logs/labels"],
-    ["logs", ["values", "app"], {}, "GET", "/v1/logs/labels/app/values"],
-    ["logs", ["ingest"], { body: '{"resourceLogs":[]}' }, "POST", "/v1/logs"],
-    ["traces", ["ingest"], { body: '{"resourceSpans":[]}' }, "POST", "/v1/traces"],
-    ["traces", ["get", "id"], {}, "GET", "/v1/traces/id"],
-    ["traces", ["search", "{}"], {}, "GET", "/v1/traces:search"],
-    ["traces", ["tags"], {}, "GET", "/v1/traces/tags"],
-    ["alerts", ["test", "id"], {}, "POST", "/v1/alerts/id/test"],
-    [
-        "alerts",
-        ["silence", "id"],
-        { until: "2026-10-07T00:00:00Z", reason: "maintenance" },
-        "POST",
-        "/v1/alerts/id/silence",
-    ],
-];
-for (const product of ["logs", "traces", "alerts"])
-    for (const verb of ["ls", "get", "create", "update", "delete"]) {
-        const collection = `/v1/${product}${product === "alerts" ? "" : "/views"}`;
-        cases.push([
-            product,
-            [
-                ...(product === "alerts" ? [] : ["views"]),
-                verb,
-                ...(["get", "update", "delete"].includes(verb) ? ["id"] : []),
-            ],
-            ["create", "update"].includes(verb) ? { body: JSON.stringify(input) } : {},
-            { ls: "GET", get: "GET", create: "POST", update: "PUT", delete: "DELETE" }[verb],
-            collection + (["get", "update", "delete"].includes(verb) ? "/id" : ""),
-        ]);
-    }
-function setup() {
-    const requests = [];
-    const transport = new Transport({
-        apiKey: "fake",
-        baseUrl: "https://fake.test",
-        maxRetries: 0,
-        fetch: (async (url, init) => {
-            requests.push({ url: new URL(url instanceof Request ? url.url : url), init: init ?? {} });
-            return Response.json({ ...input, id: "id", data: [], nextCursor: null, marker: "ok" });
-        }),
-    });
-    return {
-        client: { logs: logs(transport), traces: traces(transport), alerts: alerts(transport) },
-        requests,
-    };
-}
-for (const [product, positional, flags, method, path] of cases)
-    for (const mode of ["tty", "pipe", "json"])
-        test(`${product} ${positional.join(" ")} ${mode}`, async () => {
-            const { client, requests } = setup(), output = [];
-            const result = await logsProductCommand(product, positional, {
-                positional,
-                flags: new Map(Object.entries({ ...flags, "idempotency-key": "retry-key" }).map(([key, value]) => [
-                    key,
-                    [value],
-                ])),
-            }, {
-                json: mode === "json",
-                tty: mode === "tty",
-                write: (text) => output.push(text),
-                error: () => {
-                    throw new Error("unexpected stderr");
-                },
-            }, async () => client);
-            expect(result).toBe(0);
-            expect(requests).toHaveLength(1);
-            expect(requests[0].url.pathname).toBe(path);
-            expect(requests[0].init.method).toBe(method);
-            expect(output).toHaveLength(1);
-            expect(output[0]).not.toContain("\x1b");
-            const printed = JSON.parse(output[0]);
-            if (positional.includes("delete"))
-                expect(printed).toEqual({ deleted: "id" });
-            else if (positional.includes("ls"))
-                expect(printed).toEqual({ data: [], nextCursor: null });
-            else
-                expect(printed.marker).toBe("ok");
-            if (method !== "GET")
-                expect(new Headers(requests[0].init.headers).get("idempotency-key")).toBe("retry-key");
-            if (positional[0] === "query")
-                expect(Object.fromEntries(requests[0].url.searchParams)).toEqual({
-                    query: "{}",
-                    start: "1",
-                    end: "2",
-                    limit: "5",
-                });
-        });
-for (const mode of ["tty", "pipe", "json"])
-    test(`tail ${mode}, selector escaping, gap and backpressure`, async () => {
-        const { client } = setup();
-        const output = [];
-        let drained = 0;
-        const events = [
-            {
-                time: "12:00",
-                timeUnixNano: "1",
-                severity: 9,
-                severityText: "INFO",
-                labels: {},
-                attributes: {},
-                traceId: null,
-                spanId: null,
-                body: "line\x1b[2J\nnext",
-                cursor: "one",
-            },
-            { gap: true, from: "old", to: "kept" },
-        ];
-        let received;
-        client.logs.tail = async function* (query, options) {
-            received = { query, options };
-            yield* events;
-        };
-        const positional = ["tail", 'app"name'];
-        await logsProductCommand("logs", positional, {
-            positional,
-            flags: new Map([
-                ["since", ["1h"]],
-                ["grep", ['a"b']],
-            ]),
-        }, {
-            json: mode === "json",
-            tty: mode === "tty",
-            write: (text) => output.push(text),
-            error() { },
-            async drain() {
-                drained++;
-            },
-        }, async () => client, { now: Date.parse("2026-10-06T12:00:00Z") });
-        expect(received).toEqual({
-            query: '{app="app\\"name"} |= "a\\"b"',
-            options: { start: "2026-10-06T11:00:00.000Z" },
-        });
-        expect(drained).toBe(2);
-        if (mode === "json")
-            expect(output.map((text) => JSON.parse(text))).toEqual(events);
-        else {
-            if (mode === "tty")
-                expect(output[0]).toContain("line\\u001b[2J\\u000anext");
-            else
-                expect(output[0]).toContain("line\u001b[2J\nnext");
-            expect(output[1]).toContain("Logs expired");
-            expect(output[1].includes("\x1b[2m")).toBe(mode === "tty");
-        }
-    });
-test("tail survives an actual fake-fetch disconnect through the SDK", async () => {
-    let calls = 0;
-    const cursors = [], output = [];
-    const abort = new AbortController();
-    const transport = new Transport({
-        apiKey: "fake",
-        baseUrl: "https://fake.test",
-        fetch: (async (input) => {
-            cursors.push(new URL(input instanceof Request ? input.url : input).searchParams.get("cursor"));
-            const cursor = String(++calls);
-            return new Response(`id: ${cursor}\ndata: ${JSON.stringify({ time: "now", timeUnixNano: "1", labels: {}, body: "same", severityText: "INFO" })}\n\n`, { headers: { "content-type": "text/event-stream" } });
-        }),
-    });
-    const client = { logs: logs(transport), traces: traces(transport), alerts: alerts(transport) };
-    const run = logsProductCommand("logs", ["tail", "{}"], { positional: ["tail", "{}"], flags: new Map() }, {
-        json: true,
-        write(text) {
-            output.push(text);
-            if (output.length === 2)
-                abort.abort(new Error("done"));
-        },
-        error() { },
-    }, async () => client, { signal: abort.signal });
-    await expect(run).rejects.toThrow("done");
-    expect(cursors).toEqual([null, "1"]);
-    expect(output.map((text) => JSON.parse(text).cursor)).toEqual(["1", "2"]);
-});
-for (const [product, positional, flags] of [
-    ["logs", ["query", "{}"], { limit: "0" }],
-    ["logs", ["query"], {}],
-    ["logs", ["tail", "api"], { since: "forever" }],
-    ["alerts", ["create"], { body: "[1]" }],
-    ["alerts", ["create"], { body: "broken" }],
-    ["alerts", ["silence", "id"], { until: "tomorrow" }],
-    ["logs", ["ingest"], { body: "{}" }],
-    ["traces", ["ingest"], { body: "{}" }],
-    ["alerts", ["oops", "id"], {}],
-])
-    test(`refuses ${positional.join(" ")} ${JSON.stringify(flags)}`, async () => {
-        const { client, requests } = setup();
-        await expect(logsProductCommand(product, positional, { positional, flags: new Map(Object.entries(flags).map(([key, value]) => [key, [value]])) }, { json: true, write() { }, error() { } }, async () => client)).rejects.toMatchObject({ code: "usage", hint: expect.any(String) });
-        expect(requests).toHaveLength(0);
-    });
-test("help needs no credentials", async () => {
-    const output = [];
-    await logsProductCommand("logs", ["help"], { positional: ["help"], flags: new Map() }, { json: false, write: (text) => output.push(text), error() { } }, async () => {
-        throw new Error("credentials requested");
-    });
-    expect(output[0]).toContain("\nruntime logs query");
-});
-test("typed failures reach the main CLI's JSON error renderer unchanged", async () => {
-    const { client } = setup();
-    const failure = new InvalidRequestError({
-        code: "query_limit",
-        message: "Too broad",
-        status: 400,
-        hint: "Narrow the time range.",
-    });
-    client.logs.queryRange = async () => {
-        throw failure;
-    };
-    await expect(logsProductCommand("logs", ["query", "{}"], { positional: ["query", "{}"], flags: new Map() }, {
-        json: true,
-        write() {
-            throw new Error("Do not print success on failure");
-        },
-        error() { },
-    }, async () => client)).rejects.toBe(failure);
-});
-test("human JSON keeps formatting but escapes C1 terminal controls", async () => {
-    const { client } = setup();
-    const output = [];
-    client.traces.get = async () => ({ resourceSpans: [], marker: "\u009b2J" });
-    await logsProductCommand("traces", ["get", "id"], { positional: ["get", "id"], flags: new Map() }, { json: false, tty: true, write: (text) => output.push(text), error() { } }, async () => client);
-    expect(output[0]).not.toContain("\u009b");
-    expect(output[0]).toContain("\\u009b");
-    expect(output[0]).toContain("\n");
-    expect(JSON.parse(output[0]).marker).toBe("\u009b2J");
-});
-test("a terminal shows what customers' programs wrote, escaped, and nothing acts", async () => {
-    // Clipboard (OSC 52), a forged link (OSC 8), screen clear, the one-byte C1
-    // CSI and a right-to-left override; tab stays.
-    const hostile = "a\tb \x1b]52;c;c2VjcmV0\x07 \x1b]8;;https://evil.test\x07ok\x1b]8;;\x07 \x1b[2J \u009b2J \u202eevil";
-    const shown = terminalSafe(hostile);
-    // eslint-disable-next-line no-control-regex -- the test looks for control characters
-    expect(shown).not.toMatch(/[\x00-\x08\x0a-\x1f\x7f-\x9f\u202e]/);
-    expect(shown).toContain("a\tb");
-    expect(shown).toContain("\\u001b]52;c;c2VjcmV0\\u0007");
-    expect(shown).toContain("\\u009b2J \\u202eevil");
-    const run = async (tty, raw, json) => {
-        const { client } = setup();
-        client.logs.tail = async function* () {
-            yield { cursor: "c", time: "t", severityText: "INFO", body: hostile, labels: {} };
-        };
-        const output = [];
-        const flags = new Map(raw ? [["raw", ["true"]]] : []);
-        await logsProductCommand("logs", ["tail", "{}"], { positional: ["tail", "{}"], flags }, { json, tty, write: (text) => output.push(text), error() { } }, async () => client);
-        return output.join("\n");
-    };
-    for (const json of [false, true]) {
-        const onTerminal = await run(true, false, json);
-        expect(onTerminal).not.toContain("\x1b]");
-        expect(onTerminal).not.toContain("\u009b");
-        expect(onTerminal).not.toContain("\u202e");
-        if (json)
-            expect(JSON.parse(onTerminal).body).toBe(hostile);
-        // A pipe, or --raw on a terminal, gets exactly what was written.
-        expect(await run(false, false, json)).toContain(json ? JSON.stringify(hostile) : hostile);
-        expect(await run(true, true, json)).toContain(json ? JSON.stringify(hostile) : hostile);
-    }
-});

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

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

package/dist/products/logs.test.js

@@ -1,343 +0,0 @@
-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);
-});