@toshicloud/sdk 0.3.1 → 0.4.0

package/dist/test/fake.js

@@ -0,0 +1,845 @@
+import { clone, create } from "@bufbuild/protobuf";
+import { Code, ConnectError, createRouterTransport } from "@connectrpc/connect";
+import { createToshiClient } from "../client.js";
+import { CancelJobResponseSchema, CreateJobResponseSchema, CreateSandboxResponseSchema, GetJobResponseSchema, GetSandboxResponseSchema, ListJobsResponseSchema, ListSandboxesResponseSchema, WaitJobResponseSchema, WaitSandboxResponseSchema, WatchJobsResponseSchema, WatchSandboxesResponseSchema, WorkloadService, } from "../gen/toshi/workspace/v1/workloads_pb.js";
+import { EndReason, EventType, ExecuteResponseSchema, ExecutionExitSchema, ExecutionStartedSchema, JobSchema, JobState, JobStatusSchema, OutputEndSchema, RecordingPolicy, SandboxSchema, SandboxState, SandboxStatusSchema, WatchOutputResponseSchema, } from "../gen/toshi/workspace/v1/workspace_pb.js";
+import { apiMethods, apiPackage, hookOnly as hookOnlyMethods, isApiMethod, procedurePath } from "./procedures.js";
+/** The token `client` sends. */
+export const testToken = "test-token";
+// The scope client fills into a request.
+const projectScope = "default";
+const environmentScope = "production";
+// Answers a fake's errors at once, so a hook that answers UNAVAILABLE does not
+// wait through the client's backoff.
+const fastRetry = { maxAttempts: 5, initialBackoffMs: 1, maxBackoffMs: 2 };
+/** Creates a fake Toshi: an in-memory Workspace API and the state its calls answer from. */
+export function createFake() {
+    return new FakeToshi();
+}
+/** The whole API's methods, as [path, method], for the router. */
+const routerMethods = [...apiMethods];
+/** The answers the state machine gives, one entry per method it covers. */
+const builtinTable = [
+    [
+        workloadMethod("createJob"),
+        (fake) => ({
+            kind: "unary",
+            run: (request) => fake.createJobAnswer(request),
+        }),
+    ],
+    [
+        workloadMethod("getJob"),
+        (fake) => ({ kind: "unary", run: (request) => fake.getJobAnswer(request) }),
+    ],
+    [
+        workloadMethod("listJobs"),
+        (fake) => ({ kind: "unary", run: () => fake.listJobsAnswer() }),
+    ],
+    [
+        workloadMethod("cancelJob"),
+        (fake) => ({ kind: "unary", run: (request) => fake.cancelJobAnswer(request) }),
+    ],
+    [
+        workloadMethod("waitJob"),
+        (fake) => ({ kind: "unary", run: (request) => fake.waitJobAnswer(request) }),
+    ],
+    [
+        workloadMethod("createSandbox"),
+        (fake) => ({
+            kind: "unary",
+            run: (request) => fake.createSandboxAnswer(request),
+        }),
+    ],
+    [
+        workloadMethod("getSandbox"),
+        (fake) => ({ kind: "unary", run: (request) => fake.getSandboxAnswer(request) }),
+    ],
+    [
+        workloadMethod("listSandboxes"),
+        (fake) => ({ kind: "unary", run: () => fake.listSandboxesAnswer() }),
+    ],
+    [
+        workloadMethod("waitSandbox"),
+        (fake) => ({
+            kind: "unary",
+            run: (request) => fake.waitSandboxAnswer(request),
+        }),
+    ],
+    [
+        workloadMethod("watchJobs"),
+        (fake) => ({
+            kind: "server",
+            run: (request, context) => fake.watchJobsAnswer(request, context),
+        }),
+    ],
+    [
+        workloadMethod("watchOutput"),
+        (fake) => ({
+            kind: "server",
+            run: (request) => fake.watchOutputAnswer(request),
+        }),
+    ],
+    [
+        workloadMethod("watchSandboxes"),
+        (fake) => ({
+            kind: "server",
+            run: (request, context) => fake.watchSandboxesAnswer(request, context),
+        }),
+    ],
+    [
+        workloadMethod("execute"),
+        (fake) => ({
+            kind: "bidi",
+            run: (requests) => fake.executeAnswer(requests),
+        }),
+    ],
+];
+/** The procedures the state machine answers. The coverage test holds it against the API. */
+export const answeredProcedures = builtinTable.map(([method]) => method);
+/** One of WorkloadService's methods, as the descriptor the API exports. */
+function workloadMethod(name) {
+    return WorkloadService.method[name];
+}
+/** The fake itself; `createFake` hands it out as `Fake`. */
+class FakeToshi {
+    transport;
+    hooks = new Map();
+    builtin = new Map();
+    callLog = [];
+    jobs = new Map();
+    jobQueue = [];
+    jobCreated = [];
+    jobKeys = new Map();
+    jobLog = [];
+    jobWaiters = new Set();
+    nextJob = 0;
+    sandboxes = new Map();
+    sandboxQueue = [];
+    sandboxCreated = [];
+    sandboxKeys = new Map();
+    sandboxLog = [];
+    sandboxWaiters = new Set();
+    nextSandbox = 0;
+    executions = new Map();
+    nextExecution = 0;
+    constructor() {
+        for (const [method, make] of builtinTable) {
+            this.builtin.set(procedurePath(method), make(this));
+        }
+        this.transport = (interceptors) => createRouterTransport((router) => {
+            this.mount(router);
+        }, { transport: { interceptors } });
+    }
+    job(id) {
+        if (!this.jobs.has(id)) {
+            this.jobs.set(id, newJobRecord(id));
+            this.jobQueue.push(id);
+        }
+        return new JobBuilder(this, id);
+    }
+    sandbox(id) {
+        if (!this.sandboxes.has(id)) {
+            this.sandboxes.set(id, newSandboxRecord(id));
+            this.sandboxQueue.push(id);
+        }
+        return new SandboxBuilder(this, id);
+    }
+    execute(sandboxId) {
+        if (!this.sandboxes.has(sandboxId)) {
+            this.sandboxes.set(sandboxId, newSandboxRecord(sandboxId));
+        }
+        if (!this.executions.has(sandboxId)) {
+            this.executions.set(sandboxId, { stdout: "", stderr: "", exitCode: 0 });
+        }
+        return new ExecutionBuilder(this, sandboxId);
+    }
+    on(method, impl) {
+        if (!isApiMethod(method)) {
+            throw new Error(`toshi: ${procedurePath(method)} is not a method of the ${apiPackage} API`);
+        }
+        this.hooks.set(procedurePath(method), hookAnswer(method, impl));
+        return this;
+    }
+    calls() {
+        return this.callLog.slice();
+    }
+    client(options = {}) {
+        return createToshiClient({
+            transport: this.transport,
+            token: testToken,
+            project: projectScope,
+            environment: environmentScope,
+            retry: fastRetry,
+            ...options,
+        });
+    }
+    // The builders' state changes. They are public so the builders can reach
+    // them; `Fake` is the interface callers see.
+    setJobState(id, state) {
+        const record = this.jobs.get(id);
+        if (record === undefined) {
+            return;
+        }
+        record.state = state;
+        this.changedJob(id, EventType.WORKLOAD_STATE_CHANGED);
+    }
+    setJobStdout(id, stdout) {
+        const record = this.jobs.get(id);
+        if (record !== undefined) {
+            record.stdout = stdout;
+        }
+    }
+    setJobStderr(id, stderr) {
+        const record = this.jobs.get(id);
+        if (record !== undefined) {
+            record.stderr = stderr;
+        }
+    }
+    setJobExitCode(id, code) {
+        const record = this.jobs.get(id);
+        if (record === undefined) {
+            return;
+        }
+        record.exitCode = code;
+        record.state = JobState.ENDED;
+        record.endReason = EndReason.EXITED;
+        this.changedJob(id, EventType.WORKLOAD_STATE_CHANGED);
+    }
+    setSandboxState(id, state) {
+        const record = this.sandboxes.get(id);
+        if (record === undefined) {
+            return;
+        }
+        record.state = state;
+        this.changedSandbox(id, EventType.WORKLOAD_STATE_CHANGED);
+    }
+    setExecutionStdout(sandboxId, stdout) {
+        const record = this.executions.get(sandboxId);
+        if (record !== undefined) {
+            record.stdout = stdout;
+        }
+    }
+    setExecutionStderr(sandboxId, stderr) {
+        const record = this.executions.get(sandboxId);
+        if (record !== undefined) {
+            record.stderr = stderr;
+        }
+    }
+    setExecutionExitCode(sandboxId, code) {
+        const record = this.executions.get(sandboxId);
+        if (record !== undefined) {
+            record.exitCode = code;
+        }
+    }
+    // The state machine.
+    createJobAnswer(request) {
+        const key = request.requestKey;
+        if (key !== "") {
+            const replayed = this.jobKeys.get(key);
+            if (replayed !== undefined) {
+                return create(CreateJobResponseSchema, { job: jobProto(replayed) });
+            }
+        }
+        const record = this.newJob();
+        record.project = request.project;
+        record.environment = request.environment;
+        record.spec = request.spec;
+        record.labels = { ...request.labels };
+        record.recording = request.recording;
+        record.created = true;
+        if (key !== "") {
+            this.jobKeys.set(key, record);
+        }
+        this.jobCreated.push(record.id);
+        const response = create(CreateJobResponseSchema, { job: jobProto(record) });
+        this.changedJob(record.id, EventType.WORKLOAD_CREATED);
+        return response;
+    }
+    getJobAnswer(request) {
+        const record = this.jobs.get(request.id);
+        if (record === undefined) {
+            throw notFound("job", request.id);
+        }
+        return create(GetJobResponseSchema, { job: jobProto(record) });
+    }
+    listJobsAnswer() {
+        const jobs = [];
+        for (const id of this.jobCreated) {
+            const record = this.jobs.get(id);
+            if (record !== undefined) {
+                jobs.push(jobProto(record));
+            }
+        }
+        return create(ListJobsResponseSchema, { jobs, cursor: String(this.jobLog.length) });
+    }
+    cancelJobAnswer(request) {
+        const record = this.jobs.get(request.id);
+        if (record === undefined) {
+            throw notFound("job", request.id);
+        }
+        if (record.state !== JobState.ENDED) {
+            record.state = JobState.ENDED;
+            record.endReason = EndReason.CANCELLED;
+        }
+        const response = create(CancelJobResponseSchema, { job: jobProto(record) });
+        this.changedJob(request.id, EventType.WORKLOAD_STATE_CHANGED);
+        return response;
+    }
+    waitJobAnswer(request) {
+        const record = this.jobs.get(request.id);
+        if (record === undefined) {
+            throw notFound("job", request.id);
+        }
+        return create(WaitJobResponseSchema, { job: jobProto(record), reached: true });
+    }
+    createSandboxAnswer(request) {
+        const key = request.requestKey;
+        if (key !== "") {
+            const replayed = this.sandboxKeys.get(key);
+            if (replayed !== undefined) {
+                return create(CreateSandboxResponseSchema, { sandbox: sandboxProto(replayed) });
+            }
+        }
+        const record = this.newSandbox();
+        record.project = request.project;
+        record.environment = request.environment;
+        record.spec = request.spec;
+        record.labels = { ...request.labels };
+        record.recording = request.recording;
+        record.created = true;
+        if (key !== "") {
+            this.sandboxKeys.set(key, record);
+        }
+        this.sandboxCreated.push(record.id);
+        const response = create(CreateSandboxResponseSchema, { sandbox: sandboxProto(record) });
+        this.changedSandbox(record.id, EventType.WORKLOAD_CREATED);
+        return response;
+    }
+    getSandboxAnswer(request) {
+        const record = this.sandboxes.get(request.id);
+        if (record === undefined) {
+            throw notFound("sandbox", request.id);
+        }
+        return create(GetSandboxResponseSchema, { sandbox: sandboxProto(record) });
+    }
+    listSandboxesAnswer() {
+        const sandboxes = [];
+        for (const id of this.sandboxCreated) {
+            const record = this.sandboxes.get(id);
+            if (record !== undefined) {
+                sandboxes.push(sandboxProto(record));
+            }
+        }
+        return create(ListSandboxesResponseSchema, { sandboxes, cursor: String(this.sandboxLog.length) });
+    }
+    waitSandboxAnswer(request) {
+        const record = this.sandboxes.get(request.id);
+        if (record === undefined) {
+            throw notFound("sandbox", request.id);
+        }
+        return create(WaitSandboxResponseSchema, { sandbox: sandboxProto(record), reached: true });
+    }
+    /** Streams a job's output from the request's offsets, then the job's end. */
+    watchOutputAnswer(request) {
+        const record = this.jobs.get(request.id);
+        if (record === undefined) {
+            return failed(notFound("job", request.id));
+        }
+        const stdout = fromOffset(encode(record.stdout), request.stdoutOffset);
+        const stderr = fromOffset(encode(record.stderr), request.stderrOffset);
+        const cancelled = record.endReason === EndReason.CANCELLED;
+        const messages = [];
+        if (stdout.length > 0) {
+            messages.push(create(WatchOutputResponseSchema, { message: { case: "stdout", value: stdout } }));
+        }
+        if (stderr.length > 0) {
+            messages.push(create(WatchOutputResponseSchema, { message: { case: "stderr", value: stderr } }));
+        }
+        messages.push(create(WatchOutputResponseSchema, {
+            message: {
+                case: "end",
+                value: create(OutputEndSchema, { exitCode: record.exitCode, cancelled }),
+            },
+        }));
+        return iterableOf(messages);
+    }
+    /** Reports the job changes made after the cursor, then each change made while the stream is open. */
+    async *watchJobsAnswer(request, context) {
+        let from = parseCursor(request.cursor);
+        for (;;) {
+            if (from > this.jobLog.length) {
+                throw staleCursor(from);
+            }
+            while (from < this.jobLog.length) {
+                const change = this.jobLog[from];
+                from += 1;
+                yield clone(WatchJobsResponseSchema, change);
+            }
+            await waitForChange(this.jobWaiters, context.signal);
+            if (context.signal.aborted) {
+                return;
+            }
+        }
+    }
+    /** Reports the sandbox changes made after the cursor, then each change made while the stream is open. */
+    async *watchSandboxesAnswer(request, context) {
+        let from = parseCursor(request.cursor);
+        for (;;) {
+            if (from > this.sandboxLog.length) {
+                throw staleCursor(from);
+            }
+            while (from < this.sandboxLog.length) {
+                const change = this.sandboxLog[from];
+                from += 1;
+                yield clone(WatchSandboxesResponseSchema, change);
+            }
+            await waitForChange(this.sandboxWaiters, context.signal);
+            if (context.signal.aborted) {
+                return;
+            }
+        }
+    }
+    /**
+     * Answers Execute with the outcome the test set for the sandbox: an
+     * execution id, the output, and the exit code. Standard input is not read.
+     */
+    async *executeAnswer(requests) {
+        let start;
+        for await (const message of requests) {
+            const request = message;
+            if (request.message.case !== "start") {
+                throw new ConnectError("toshi: Execute needs a start message", Code.InvalidArgument);
+            }
+            start = request.message.value;
+            break;
+        }
+        if (start === undefined) {
+            throw new ConnectError("toshi: Execute needs a start message", Code.InvalidArgument);
+        }
+        const record = this.executions.get(start.sandboxId);
+        this.nextExecution += 1;
+        const executionId = `exec-${this.nextExecution}`;
+        yield create(ExecuteResponseSchema, {
+            message: { case: "started", value: create(ExecutionStartedSchema, { executionId }) },
+        });
+        const stdout = encode(record?.stdout ?? "");
+        if (stdout.length > 0) {
+            yield create(ExecuteResponseSchema, { message: { case: "stdout", value: stdout } });
+        }
+        const stderr = encode(record?.stderr ?? "");
+        if (stderr.length > 0) {
+            yield create(ExecuteResponseSchema, { message: { case: "stderr", value: stderr } });
+        }
+        yield create(ExecuteResponseSchema, {
+            message: {
+                case: "exit",
+                value: create(ExecutionExitSchema, { exitCode: record?.exitCode ?? 0, cancelled: false }),
+            },
+        });
+    }
+    // The router and the dispatch.
+    mount(router) {
+        for (const [path, method] of routerMethods) {
+            switch (method.methodKind) {
+                case "unary":
+                    router.rpc(method, ((request, context) => {
+                        this.record(method, request, context.requestHeader);
+                        return this.answerUnary(path, request, context);
+                    }));
+                    break;
+                case "server_streaming":
+                    router.rpc(method, ((request, context) => {
+                        this.record(method, request, context.requestHeader);
+                        return this.answerServer(path, request, context);
+                    }));
+                    break;
+                case "bidi_streaming":
+                    router.rpc(method, ((requests, context) => this.answerBidi(path, method, requests, context)));
+                    break;
+                case "client_streaming":
+                    router.rpc(method, (() => Promise.reject(notImplemented(path))));
+                    break;
+            }
+        }
+    }
+    answerUnary(path, request, context) {
+        let answer;
+        try {
+            answer = this.answerFor(path);
+        }
+        catch (err) {
+            return Promise.reject(errorOf(err));
+        }
+        if (answer.kind !== "unary") {
+            return Promise.reject(wrongKind(path, answer.kind));
+        }
+        return Promise.resolve(answer.run(request, context));
+    }
+    answerServer(path, request, context) {
+        let answer;
+        try {
+            answer = this.answerFor(path);
+        }
+        catch (err) {
+            return failed(errorOf(err));
+        }
+        if (answer.kind !== "server") {
+            return failed(wrongKind(path, answer.kind));
+        }
+        return answer.run(request, context);
+    }
+    answerBidi(path, method, requests, context) {
+        let answer;
+        try {
+            answer = this.answerFor(path);
+        }
+        catch (err) {
+            return failed(errorOf(err));
+        }
+        if (answer.kind !== "bidi") {
+            return failed(wrongKind(path, answer.kind));
+        }
+        // A bidirectional call is recorded when its first message arrives, as
+        // toshi-go's toshitest does; an unhooked one is answered before reading
+        // anything.
+        let recorded = false;
+        const recordedRequests = {
+            [Symbol.asyncIterator]: () => {
+                const iterator = requests[Symbol.asyncIterator]();
+                return {
+                    next: async () => {
+                        const next = await iterator.next();
+                        if (!recorded && next.done !== true) {
+                            recorded = true;
+                            this.record(method, next.value, context.requestHeader);
+                        }
+                        return next;
+                    },
+                    return: async (value) => iterator.return?.(value) ?? { done: true, value: undefined },
+                };
+            },
+        };
+        return answer.run(recordedRequests, context);
+    }
+    answerFor(path) {
+        return this.hooks.get(path) ?? this.builtin.get(path) ?? missingAnswer(path);
+    }
+    record(method, request, header) {
+        this.callLog.push({
+            procedure: procedurePath(method),
+            request: clone(method.input, request),
+            header: new Headers(header),
+        });
+    }
+    // The records the built-ins answer from.
+    newJob() {
+        const queued = this.jobQueue.shift();
+        if (queued !== undefined) {
+            const record = this.jobs.get(queued);
+            if (record !== undefined) {
+                return record;
+            }
+        }
+        for (;;) {
+            this.nextJob += 1;
+            const id = `job-${this.nextJob}`;
+            if (this.jobs.has(id)) {
+                continue;
+            }
+            const record = newJobRecord(id);
+            this.jobs.set(id, record);
+            return record;
+        }
+    }
+    newSandbox() {
+        const queued = this.sandboxQueue.shift();
+        if (queued !== undefined) {
+            const record = this.sandboxes.get(queued);
+            if (record !== undefined) {
+                return record;
+            }
+        }
+        for (;;) {
+            this.nextSandbox += 1;
+            const id = `sandbox-${this.nextSandbox}`;
+            if (this.sandboxes.has(id)) {
+                continue;
+            }
+            const record = newSandboxRecord(id);
+            this.sandboxes.set(id, record);
+            return record;
+        }
+    }
+    changedJob(id, type) {
+        const record = this.jobs.get(id);
+        if (record === undefined || !record.created) {
+            return;
+        }
+        this.jobLog.push(create(WatchJobsResponseSchema, {
+            type,
+            job: jobProto(record),
+            cursor: String(this.jobLog.length + 1),
+        }));
+        for (const wake of [...this.jobWaiters]) {
+            wake();
+        }
+    }
+    changedSandbox(id, type) {
+        const record = this.sandboxes.get(id);
+        if (record === undefined || !record.created) {
+            return;
+        }
+        this.sandboxLog.push(create(WatchSandboxesResponseSchema, {
+            type,
+            sandbox: sandboxProto(record),
+            cursor: String(this.sandboxLog.length + 1),
+        }));
+        for (const wake of [...this.sandboxWaiters]) {
+            wake();
+        }
+    }
+}
+/** Answers a job's setters. */
+class JobBuilder {
+    fake;
+    id;
+    constructor(fake, id) {
+        this.fake = fake;
+        this.id = id;
+    }
+    state(state) {
+        this.fake.setJobState(this.id, state);
+        return this;
+    }
+    stdout(stdout) {
+        this.fake.setJobStdout(this.id, stdout);
+        return this;
+    }
+    stderr(stderr) {
+        this.fake.setJobStderr(this.id, stderr);
+        return this;
+    }
+    exitCode(code) {
+        this.fake.setJobExitCode(this.id, code);
+        return this;
+    }
+}
+/** Answers a sandbox's setters. */
+class SandboxBuilder {
+    fake;
+    id;
+    constructor(fake, id) {
+        this.fake = fake;
+        this.id = id;
+    }
+    state(state) {
+        this.fake.setSandboxState(this.id, state);
+        return this;
+    }
+}
+/** Answers an execution's setters. */
+class ExecutionBuilder {
+    fake;
+    sandboxId;
+    constructor(fake, sandboxId) {
+        this.fake = fake;
+        this.sandboxId = sandboxId;
+    }
+    stdout(stdout) {
+        this.fake.setExecutionStdout(this.sandboxId, stdout);
+        return this;
+    }
+    stderr(stderr) {
+        this.fake.setExecutionStderr(this.sandboxId, stderr);
+        return this;
+    }
+    exitCode(code) {
+        this.fake.setExecutionExitCode(this.sandboxId, code);
+        return this;
+    }
+}
+/** Turns a typed hook into the uniform answer the dispatcher runs. */
+function hookAnswer(method, impl) {
+    switch (method.methodKind) {
+        case "unary": {
+            const run = impl;
+            return {
+                kind: "unary",
+                run: async (request, context) => {
+                    const response = await run(request, context);
+                    if (response === undefined) {
+                        throw new ConnectError(`toshi: the hook for ${procedurePath(method)} returned no response`, Code.Internal);
+                    }
+                    return response;
+                },
+            };
+        }
+        case "server_streaming": {
+            return { kind: "server", run: impl };
+        }
+        case "bidi_streaming": {
+            return {
+                kind: "bidi",
+                run: impl,
+            };
+        }
+        case "client_streaming":
+            throw new Error(`toshi: ${procedurePath(method)} is a client stream; fake.on answers unary, server-stream and bidirectional methods`);
+    }
+}
+/** The answer for a procedure nothing covers: UNIMPLEMENTED, naming the hook to write. */
+function missingAnswer(path) {
+    throw notImplemented(path);
+}
+/** UNIMPLEMENTED for a procedure the fake does not answer, naming the method and how to hook it. */
+function notImplemented(path) {
+    const method = apiMethods.get(path);
+    const hook = method === undefined ? "fake.on" : `fake.on(${method.parent.name}.method.${method.localName})`;
+    return new ConnectError(`toshi: ${path} has no built-in behaviour; add a hook with ${hook}`, Code.Unimplemented);
+}
+/** error as a ConnectError: a handler's failure always reaches the client as one. */
+function errorOf(error) {
+    return error instanceof ConnectError
+        ? error
+        : new ConnectError(error instanceof Error ? error.message : String(error), Code.Internal);
+}
+/** An internal error for a registered answer of the wrong kind; `on` refuses one at setup. */
+function wrongKind(path, kind) {
+    return new ConnectError(`toshi: the ${kind} answer for ${path} does not fit its method`, Code.Internal);
+}
+/** NOT_FOUND for an id the fake does not hold. */
+function notFound(kind, id) {
+    return new ConnectError(`toshi: no ${kind} "${id}"`, Code.NotFound);
+}
+/** OUT_OF_RANGE for a cursor past the last change. */
+function staleCursor(position) {
+    return new ConnectError(`toshi: cursor ${position} is past the last change`, Code.OutOfRange);
+}
+/** Reads a watch's starting position; an empty cursor starts at the beginning. */
+function parseCursor(cursor) {
+    if (cursor === "") {
+        return 0;
+    }
+    if (!/^\d+$/.test(cursor)) {
+        throw new ConnectError(`toshi: "${cursor}" is not a cursor of this workspace`, Code.OutOfRange);
+    }
+    return Number(cursor);
+}
+/** Waits for a change, or for the caller to abort; both resolve. */
+function waitForChange(waiters, signal) {
+    return new Promise((resolve) => {
+        const wake = () => {
+            waiters.delete(wake);
+            signal.removeEventListener("abort", wake);
+            resolve();
+        };
+        waiters.add(wake);
+        signal.addEventListener("abort", wake, { once: true });
+        if (signal.aborted) {
+            wake();
+        }
+    });
+}
+/** A finite stream of items, without an async generator. */
+function iterableOf(items) {
+    return {
+        [Symbol.asyncIterator]() {
+            let index = 0;
+            return {
+                next: () => {
+                    const value = index < items.length ? items[index] : undefined;
+                    index += 1;
+                    return Promise.resolve(value === undefined ? { done: true, value: undefined } : { done: false, value });
+                },
+            };
+        },
+    };
+}
+/** A stream that ends at once with error. */
+function failed(error) {
+    return {
+        [Symbol.asyncIterator]: () => ({
+            next: () => Promise.reject(error),
+        }),
+    };
+}
+/** The status of a job as the API reports it. */
+function jobProto(record) {
+    const status = create(JobStatusSchema, { state: record.state });
+    if (record.state === JobState.ENDED) {
+        status.endReason = record.endReason;
+        if (record.endReason === EndReason.EXITED) {
+            status.exitCode = record.exitCode;
+        }
+    }
+    return create(JobSchema, {
+        id: record.id,
+        project: record.project,
+        environment: record.environment,
+        spec: record.spec,
+        labels: { ...record.labels },
+        recording: record.recording,
+        status,
+    });
+}
+/** The status of a sandbox as the API reports it. */
+function sandboxProto(record) {
+    const status = create(SandboxStatusSchema, { state: record.state });
+    if (record.state === SandboxState.ENDED) {
+        status.endReason = record.endReason;
+    }
+    return create(SandboxSchema, {
+        id: record.id,
+        project: record.project,
+        environment: record.environment,
+        spec: record.spec,
+        labels: { ...record.labels },
+        recording: record.recording,
+        status,
+    });
+}
+function newJobRecord(id) {
+    return {
+        id,
+        project: "",
+        environment: "",
+        spec: undefined,
+        labels: {},
+        recording: RecordingPolicy.UNSPECIFIED,
+        state: JobState.RUNNING,
+        endReason: EndReason.UNSPECIFIED,
+        exitCode: 0,
+        stdout: "",
+        stderr: "",
+        created: false,
+    };
+}
+function newSandboxRecord(id) {
+    return {
+        id,
+        project: "",
+        environment: "",
+        spec: undefined,
+        labels: {},
+        recording: RecordingPolicy.UNSPECIFIED,
+        state: SandboxState.RUNNING,
+        endReason: EndReason.UNSPECIFIED,
+        created: false,
+    };
+}
+/** The part of bytes after offset. */
+function fromOffset(bytes, offset) {
+    if (offset <= 0n) {
+        return bytes;
+    }
+    if (offset >= BigInt(bytes.length)) {
+        return new Uint8Array(0);
+    }
+    return bytes.slice(Number(offset));
+}
+/** UTF-8 bytes of text. */
+function encode(text) {
+    return new TextEncoder().encode(text);
+}
+/** The methods the state machine does not answer, for the coverage test's comparison. */
+export const hookOnlyProcedures = hookOnlyMethods;