@toshicloud/sdk 0.3.2 → 0.5.0

package/dist/test/index.d.ts

@@ -0,0 +1,58 @@
+/**
+ * A fake Toshi for tests: an in-memory Workspace API served through
+ * `@connectrpc/connect`'s router transport.
+ *
+ * A test creates a fake, tells it what to answer, and calls the client:
+ *
+ * ```ts
+ * const fake = createFake();
+ * fake.job("job-1").stdout("deployed\n").exitCode(0);
+ * const toshi = fake.client();
+ * ```
+ *
+ * `createFake` serves every service of `toshi.workspace.v1` from one
+ * in-memory transport: no server, no port, nothing to close, and no Node
+ * module, so it runs wherever the client runs. `client` returns a
+ * `ToshiClient` wired to it, with the token "test-token" and the scope
+ * default/production.
+ *
+ * # What the fake answers
+ *
+ * The fake holds one workspace and has no clock: every call answers at once
+ * with what the test set. It knows the job and the sandbox lifecycle and
+ * nothing else.
+ *
+ * - `job`, `sandbox` and `execute` set what the fake answers: a job's or a
+ *   sandbox's state, and the standard output, the standard error and the exit
+ *   code of a job or of a command run in a sandbox. A job or a sandbox the
+ *   test set no state for is running; a job or a command the test set no exit
+ *   code for exits 0.
+ * - CreateJob answers the jobs registered with `job`, in the order they were
+ *   registered, and then creates job-1, job-2, ... of its own. CreateSandbox
+ *   does the same for `sandbox` and sandbox-1, sandbox-2, .... A create whose
+ *   request key the fake has already answered returns the same workload.
+ * - GetJob, ListJobs, CancelJob, WaitJob and WatchOutput answer from the jobs
+ *   that exist; GetSandbox, ListSandboxes, WaitSandbox and WatchSandboxes
+ *   from the sandboxes. An id the fake does not hold is NOT_FOUND. The lists
+ *   answer every workload the fake holds, in creation order: they do not apply
+ *   the request's filters or page size.
+ * - WaitJob and WaitSandbox answer at once, reached, with the workload as the
+ *   test set it.
+ * - WatchOutput streams a job's standard output and standard error from the
+ *   offsets the request names, then the job's end.
+ * - WatchJobs and WatchSandboxes report each change made after the cursor the
+ *   request names: a workload the fake creates, and each state the test sets.
+ *   ListJobs and ListSandboxes answer the cursor a watch starts at.
+ * - Execute answers the start message with an execution id, the standard
+ *   output, the standard error and the exit code the test set for the sandbox.
+ *   It does not read standard input.
+ *
+ * Every other procedure is hook-only. An unhooked procedure the state machine
+ * does not cover answers UNIMPLEMENTED, naming the procedure and the `on` call
+ * that supplies an answer. A hook replaces the state machine for its method.
+ *
+ * `calls` returns every call the fake received, in order, with its request and
+ * its headers.
+ */
+export { createFake, testToken } from "./fake.js";
+export type { Call, Fake, FakeExecution, FakeJob, FakeOptions, FakeSandbox } from "./fake.js";

package/dist/test/index.js

@@ -0,0 +1,57 @@
+/**
+ * A fake Toshi for tests: an in-memory Workspace API served through
+ * `@connectrpc/connect`'s router transport.
+ *
+ * A test creates a fake, tells it what to answer, and calls the client:
+ *
+ * ```ts
+ * const fake = createFake();
+ * fake.job("job-1").stdout("deployed\n").exitCode(0);
+ * const toshi = fake.client();
+ * ```
+ *
+ * `createFake` serves every service of `toshi.workspace.v1` from one
+ * in-memory transport: no server, no port, nothing to close, and no Node
+ * module, so it runs wherever the client runs. `client` returns a
+ * `ToshiClient` wired to it, with the token "test-token" and the scope
+ * default/production.
+ *
+ * # What the fake answers
+ *
+ * The fake holds one workspace and has no clock: every call answers at once
+ * with what the test set. It knows the job and the sandbox lifecycle and
+ * nothing else.
+ *
+ * - `job`, `sandbox` and `execute` set what the fake answers: a job's or a
+ *   sandbox's state, and the standard output, the standard error and the exit
+ *   code of a job or of a command run in a sandbox. A job or a sandbox the
+ *   test set no state for is running; a job or a command the test set no exit
+ *   code for exits 0.
+ * - CreateJob answers the jobs registered with `job`, in the order they were
+ *   registered, and then creates job-1, job-2, ... of its own. CreateSandbox
+ *   does the same for `sandbox` and sandbox-1, sandbox-2, .... A create whose
+ *   request key the fake has already answered returns the same workload.
+ * - GetJob, ListJobs, CancelJob, WaitJob and WatchOutput answer from the jobs
+ *   that exist; GetSandbox, ListSandboxes, WaitSandbox and WatchSandboxes
+ *   from the sandboxes. An id the fake does not hold is NOT_FOUND. The lists
+ *   answer every workload the fake holds, in creation order: they do not apply
+ *   the request's filters or page size.
+ * - WaitJob and WaitSandbox answer at once, reached, with the workload as the
+ *   test set it.
+ * - WatchOutput streams a job's standard output and standard error from the
+ *   offsets the request names, then the job's end.
+ * - WatchJobs and WatchSandboxes report each change made after the cursor the
+ *   request names: a workload the fake creates, and each state the test sets.
+ *   ListJobs and ListSandboxes answer the cursor a watch starts at.
+ * - Execute answers the start message with an execution id, the standard
+ *   output, the standard error and the exit code the test set for the sandbox.
+ *   It does not read standard input.
+ *
+ * Every other procedure is hook-only. An unhooked procedure the state machine
+ * does not cover answers UNIMPLEMENTED, naming the procedure and the `on` call
+ * that supplies an answer. A hook replaces the state machine for its method.
+ *
+ * `calls` returns every call the fake received, in order, with its request and
+ * its headers.
+ */
+export { createFake, testToken } from "./fake.js";

package/dist/test/procedures.d.ts

@@ -0,0 +1,18 @@
+import type { DescMethod, DescService } from "@bufbuild/protobuf";
+/** The package the fake serves. */
+export declare const apiPackage = "toshi.workspace.v1";
+/** Every service of the Workspace API. */
+export declare const apiServices: readonly DescService[];
+/** The path a client calls a method by, for example `/toshi.workspace.v1.WorkloadService/CreateJob`. */
+export declare function procedurePath(method: DescMethod): string;
+/** Every method of the Workspace API, keyed by the path a client calls it by. */
+export declare const apiMethods: ReadonlyMap<string, DescMethod>;
+/** Whether method is a method of the Workspace API this package was generated from. */
+export declare function isApiMethod(method: DescMethod): boolean;
+/**
+ * The methods the fake has no built-in answer for: a test supplies their
+ * answer with `on`. Every method of the Workspace API is either answered by
+ * the state machine or listed here, and the coverage test fails when one is
+ * neither, so a new method is a decision and not a surprise at a caller.
+ */
+export declare const hookOnly: readonly DescMethod[];

package/dist/test/procedures.js

@@ -0,0 +1,219 @@
+import { ArtifactService, ArtifactUploadService } from "../gen/toshi/workspace/v1/artifacts_pb.js";
+import { AuditEventService } from "../gen/toshi/workspace/v1/audit_events_pb.js";
+import { ChannelService } from "../gen/toshi/workspace/v1/channels_pb.js";
+import { DisplayService } from "../gen/toshi/workspace/v1/display_pb.js";
+import { FillerService } from "../gen/toshi/workspace/v1/fillers_pb.js";
+import { HostJobService } from "../gen/toshi/workspace/v1/hostjobs_pb.js";
+import { HostService } from "../gen/toshi/workspace/v1/hosts_pb.js";
+import { ProjectService } from "../gen/toshi/workspace/v1/projects_pb.js";
+import { RecordingService } from "../gen/toshi/workspace/v1/recordings_pb.js";
+import { SecretService } from "../gen/toshi/workspace/v1/secrets_pb.js";
+import { StorageProviderService } from "../gen/toshi/workspace/v1/storage_providers_pb.js";
+import { TokenService } from "../gen/toshi/workspace/v1/tokens_pb.js";
+import { VolumeService } from "../gen/toshi/workspace/v1/volumes_pb.js";
+import { WebhookService } from "../gen/toshi/workspace/v1/webhook_pb.js";
+import { WorkloadService } from "../gen/toshi/workspace/v1/workloads_pb.js";
+import { WorkspaceService } from "../gen/toshi/workspace/v1/workspace_service_pb.js";
+/** The package the fake serves. */
+export const apiPackage = "toshi.workspace.v1";
+/** Every service of the Workspace API. */
+export const apiServices = [
+    WorkloadService,
+    SecretService,
+    ProjectService,
+    WebhookService,
+    DisplayService,
+    ChannelService,
+    RecordingService,
+    VolumeService,
+    ArtifactService,
+    ArtifactUploadService,
+    AuditEventService,
+    FillerService,
+    HostJobService,
+    HostService,
+    TokenService,
+    StorageProviderService,
+    WorkspaceService,
+];
+/** The path a client calls a method by, for example `/toshi.workspace.v1.WorkloadService/CreateJob`. */
+export function procedurePath(method) {
+    return `/${method.parent.typeName}/${method.name}`;
+}
+/** Every method of the Workspace API, keyed by the path a client calls it by. */
+export const apiMethods = buildApiMethods();
+function buildApiMethods() {
+    const found = new Map();
+    for (const service of apiServices) {
+        for (const method of service.methods) {
+            found.set(procedurePath(method), method);
+        }
+    }
+    return found;
+}
+/** Whether method is a method of the Workspace API this package was generated from. */
+export function isApiMethod(method) {
+    return apiMethods.get(procedurePath(method)) === method;
+}
+/**
+ * The methods the fake has no built-in answer for: a test supplies their
+ * answer with `on`. Every method of the Workspace API is either answered by
+ * the state machine or listed here, and the coverage test fails when one is
+ * neither, so a new method is a decision and not a surprise at a caller.
+ */
+export const hookOnly = [
+    // WorkloadService
+    WorkloadService.method.updateJob,
+    WorkloadService.method.deleteJob,
+    WorkloadService.method.updateSandbox,
+    WorkloadService.method.deleteSandbox,
+    WorkloadService.method.cancelExecution,
+    WorkloadService.method.watchTelemetry,
+    WorkloadService.method.watchGuestLog,
+    WorkloadService.method.createPreviewShareLink,
+    WorkloadService.method.listPreviewShareLinks,
+    WorkloadService.method.revokePreviewShareLink,
+    WorkloadService.method.createService,
+    WorkloadService.method.getService,
+    WorkloadService.method.listServices,
+    WorkloadService.method.updateService,
+    WorkloadService.method.deleteService,
+    WorkloadService.method.waitService,
+    WorkloadService.method.watchServices,
+    WorkloadService.method.startService,
+    WorkloadService.method.stopService,
+    WorkloadService.method.setServiceMode,
+    WorkloadService.method.wakeService,
+    WorkloadService.method.holdService,
+    WorkloadService.method.releaseService,
+    WorkloadService.method.listServiceRuns,
+    WorkloadService.method.listEvents,
+    WorkloadService.method.watchEvents,
+    WorkloadService.method.getOperation,
+    WorkloadService.method.waitOperation,
+    // SecretService
+    SecretService.method.createSecretSet,
+    SecretService.method.listSecretSets,
+    SecretService.method.deleteSecretSet,
+    SecretService.method.putSecret,
+    SecretService.method.deleteSecret,
+    SecretService.method.listSecrets,
+    SecretService.method.listSecretVersions,
+    SecretService.method.grantSecretSet,
+    SecretService.method.revokeSecretSet,
+    SecretService.method.listSecretSetGrants,
+    // ProjectService
+    ProjectService.method.listProjects,
+    ProjectService.method.getProject,
+    ProjectService.method.listRepositories,
+    ProjectService.method.createProject,
+    ProjectService.method.claimRepository,
+    ProjectService.method.createEnvironment,
+    ProjectService.method.deleteEnvironment,
+    ProjectService.method.listBranchRules,
+    ProjectService.method.setBranchRules,
+    ProjectService.method.createEmbedToken,
+    ProjectService.method.listEmbedTokens,
+    ProjectService.method.revokeEmbedToken,
+    // WebhookService
+    WebhookService.method.createWebhookEndpoint,
+    WebhookService.method.getWebhookEndpoint,
+    WebhookService.method.listWebhookEndpoints,
+    WebhookService.method.updateWebhookEndpoint,
+    WebhookService.method.deleteWebhookEndpoint,
+    WebhookService.method.rotateWebhookEndpointSecret,
+    WebhookService.method.listWebhookDeliveries,
+    WebhookService.method.replayWebhookEvents,
+    // DisplayService
+    DisplayService.method.openDisplaySession,
+    DisplayService.method.getDisplaySession,
+    DisplayService.method.listDisplaySessions,
+    DisplayService.method.closeDisplaySession,
+    DisplayService.method.sendDisplayKeys,
+    DisplayService.method.sendDisplayPointer,
+    DisplayService.method.setDisplayClipboard,
+    DisplayService.method.takeDisplayScreenshot,
+    // ChannelService
+    ChannelService.method.createChannel,
+    ChannelService.method.listChannels,
+    ChannelService.method.getChannel,
+    ChannelService.method.getChannelPolicy,
+    ChannelService.method.setChannelPolicy,
+    ChannelService.method.listChannelRequests,
+    ChannelService.method.getChannelRequest,
+    ChannelService.method.exportChannelLog,
+    ChannelService.method.createChannelConnectToken,
+    ChannelService.method.revokeChannelConnectToken,
+    ChannelService.method.deleteChannel,
+    ChannelService.method.listForwards,
+    ChannelService.method.getLink,
+    // RecordingService
+    RecordingService.method.listRecordings,
+    RecordingService.method.getRecording,
+    RecordingService.method.createRecordingShareLink,
+    RecordingService.method.listRecordingShareLinks,
+    RecordingService.method.revokeRecordingShareLink,
+    // VolumeService
+    VolumeService.method.listVolumes,
+    VolumeService.method.attachVolume,
+    VolumeService.method.detachVolume,
+    // ArtifactService
+    ArtifactService.method.listArtifacts,
+    ArtifactService.method.getArtifact,
+    ArtifactService.method.getArtifactDownloadURL,
+    // ArtifactUploadService
+    ArtifactUploadService.method.reserveUpload,
+    ArtifactUploadService.method.completeUpload,
+    // AuditEventService
+    AuditEventService.method.listAuditEvents,
+    // FillerService
+    FillerService.method.listFillers,
+    FillerService.method.putFiller,
+    FillerService.method.deleteFiller,
+    FillerService.method.setFillerEnabled,
+    FillerService.method.listFillerRuns,
+    // HostJobService
+    HostJobService.method.listHostJobs,
+    HostJobService.method.getHostJob,
+    HostJobService.method.cancelHostJob,
+    HostJobService.method.getHostJobFailure,
+    HostJobService.method.getHostJobTelemetry,
+    HostJobService.method.getHostJobDebugAccess,
+    HostJobService.method.stopHostJobDebug,
+    // HostService
+    HostService.method.listHosts,
+    HostService.method.listHostStorage,
+    HostService.method.listHostAlerts,
+    HostService.method.setHostState,
+    HostService.method.retireHost,
+    HostService.method.createCloudHost,
+    HostService.method.checkCloudHost,
+    HostService.method.createEnrollmentToken,
+    // TokenService
+    TokenService.method.listTokens,
+    TokenService.method.createWorkspaceToken,
+    TokenService.method.revokeToken,
+    // StorageProviderService
+    StorageProviderService.method.listStorageProviders,
+    StorageProviderService.method.createStorageProvider,
+    StorageProviderService.method.checkStorageProvider,
+    StorageProviderService.method.deleteStorageProvider,
+    // WorkspaceService
+    WorkspaceService.method.getWorkspace,
+    WorkspaceService.method.listWorkspaces,
+    WorkspaceService.method.getWorkspaceBilling,
+    WorkspaceService.method.getWorkspaceStatement,
+    WorkspaceService.method.setWorkspaceOwnHostsOnly,
+    WorkspaceService.method.setWorkspaceAllowOverflow,
+    WorkspaceService.method.setWorkspaceAllowCacheWarm,
+    WorkspaceService.method.setWorkspaceCancelRunOnVmDeath,
+    WorkspaceService.method.setWorkspaceSpendLimits,
+    WorkspaceService.method.listEgressIPs,
+    WorkspaceService.method.getUsage,
+    WorkspaceService.method.getQueueTimes,
+    WorkspaceService.method.getWorkflowUsage,
+    WorkspaceService.method.listPlans,
+    WorkspaceService.method.createCheckoutSession,
+    WorkspaceService.method.createBillingPortalSession,
+    WorkspaceService.method.getVersion,
+];

package/dist/timeout.d.ts

@@ -0,0 +1,29 @@
+import { ConnectError } from "@connectrpc/connect";
+import type { Transport } from "@connectrpc/connect";
+/** The error a call ends with when its timeout fires. */
+export declare function timeoutError(timeoutMs: number): ConnectError;
+/** A running deadline: one timer, one signal, and its state for the caller. */
+export interface Deadline {
+    /** Aborts when the timeout fires or the caller's signal aborts. */
+    readonly signal: AbortSignal;
+    /** Whether the timeout fired, rather than the caller's signal. */
+    readonly timedOut: boolean;
+    /** Whether the caller's own signal aborted. */
+    readonly callerAborted: boolean;
+    /** Stops the timer; safe to call more than once. */
+    clear(): void;
+}
+/** Starts the deadline for a call's timeoutMs, or returns undefined without one. */
+export declare function startDeadline(timeoutMs: number | undefined, caller?: AbortSignal): Deadline | undefined;
+/** Runs body with a deadline signal, and reports the timeout instead of an abort. */
+export declare function runWithDeadline<O extends {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}, T>(opts: O | undefined, body: (opts: O | undefined) => Promise<T>): Promise<T>;
+/**
+ * Gives every unary call defaultTimeoutMs when the caller set no timeout. The
+ * Wait calls are long polls: their request's timeout bounds them, so the
+ * default skips them. A stream keeps the timeout it was given, so a default
+ * never ends a watch.
+ */
+export declare function withDefaultUnaryTimeout(transport: Transport, timeoutMs: number | undefined): Transport;

package/dist/timeout.js

@@ -0,0 +1,67 @@
+import { Code, ConnectError } from "@connectrpc/connect";
+/** The error a call ends with when its timeout fires. */
+export function timeoutError(timeoutMs) {
+    return new ConnectError(`the call timed out after ${timeoutMs} ms`, Code.DeadlineExceeded);
+}
+/** Starts the deadline for a call's timeoutMs, or returns undefined without one. */
+export function startDeadline(timeoutMs, caller) {
+    if (timeoutMs === undefined) {
+        return undefined;
+    }
+    const controller = new AbortController();
+    let fired = false;
+    const timer = setTimeout(() => {
+        fired = true;
+        controller.abort(timeoutError(timeoutMs));
+    }, timeoutMs);
+    return {
+        signal: caller === undefined ? controller.signal : AbortSignal.any([controller.signal, caller]),
+        get timedOut() {
+            return fired;
+        },
+        get callerAborted() {
+            return caller?.aborted === true;
+        },
+        clear() {
+            clearTimeout(timer);
+        },
+    };
+}
+/** Runs body with a deadline signal, and reports the timeout instead of an abort. */
+export async function runWithDeadline(opts, body) {
+    const deadline = startDeadline(opts?.timeoutMs, opts?.signal);
+    const withDeadline = (deadline === undefined ? opts : { ...opts, signal: deadline.signal });
+    try {
+        return await body(withDeadline);
+    }
+    catch (err) {
+        if (deadline?.timedOut === true && !deadline.callerAborted) {
+            throw timeoutError(opts?.timeoutMs);
+        }
+        throw err;
+    }
+    finally {
+        deadline?.clear();
+    }
+}
+/**
+ * Gives every unary call defaultTimeoutMs when the caller set no timeout. The
+ * Wait calls are long polls: their request's timeout bounds them, so the
+ * default skips them. A stream keeps the timeout it was given, so a default
+ * never ends a watch.
+ */
+export function withDefaultUnaryTimeout(transport, timeoutMs) {
+    if (timeoutMs === undefined) {
+        return transport;
+    }
+    const unary = transport.unary.bind(transport);
+    return {
+        unary: (method, signal, timeout, header, input, contextValues) => unary(method, signal, timeout ?? (isWaitCall(method) ? undefined : timeoutMs), header, input, contextValues),
+        stream: transport.stream.bind(transport),
+    };
+}
+// WaitJob, WaitSandbox, WaitService and WaitOperation: the server holds the
+// call for the timeout the request names, so a client default would cut it.
+function isWaitCall(method) {
+    return method.name.startsWith("Wait");
+}

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+/** The package version; test/node.test.ts keeps it equal to package.json. */
+export declare const VERSION = "0.5.0";

package/dist/version.js

@@ -0,0 +1,2 @@
+/** The package version; test/node.test.ts keeps it equal to package.json. */
+export const VERSION = "0.5.0";

package/dist/wait.js

@@ -1,32 +1,35 @@
 import { abortReason } from "./retry.js";
+import { runWithDeadline } from "./timeout.js";
 /** Asks again while the job is not in a state it waits for, and returns the answer when it is. */
 export function waitJob(service, req, opts) {
-    return waitReached(() => service.waitJob(req, opts), opts);
+    return runWithDeadline(opts, (callOpts) => waitReached((o) => service.waitJob(req, o), callOpts));
 }
 /** Asks again while the sandbox is not in a state it waits for. */
 export function waitSandbox(service, req, opts) {
-    return waitReached(() => service.waitSandbox(req, opts), opts);
+    return runWithDeadline(opts, (callOpts) => waitReached((o) => service.waitSandbox(req, o), callOpts));
 }
 /** Asks again while the service is not in a state it waits for. */
 export function waitService(service, req, opts) {
-    return waitReached(() => service.waitService(req, opts), opts);
+    return runWithDeadline(opts, (callOpts) => waitReached((o) => service.waitService(req, o), callOpts));
 }
 /** Asks again while the operation is not done, and returns it when it is (wait.go:29-45). */
-export async function waitOperation(service, req, opts) {
-    for (;;) {
-        throwIfAborted(opts);
-        const resp = await service.waitOperation(req, opts);
-        const op = resp.operation;
-        if (op !== undefined && op.done) {
-            return op;
+export function waitOperation(service, req, opts) {
+    return runWithDeadline(opts, async (callOpts) => {
+        for (;;) {
+            throwIfAborted(callOpts);
+            const resp = await service.waitOperation(req, callOpts);
+            const op = resp.operation;
+            if (op !== undefined && op.done) {
+                return op;
+            }
         }
-    }
+    });
 }
 // The three waits share one loop: each answers reached when the state arrived.
 async function waitReached(call, opts) {
     for (;;) {
         throwIfAborted(opts);
-        const resp = await call();
+        const resp = await call(opts);
         if (resp.reached) {
             return resp;
         }

package/dist/watch.js

@@ -2,6 +2,7 @@ import { clone, create } from "@bufbuild/protobuf";
 import { ListJobsRequestSchema, ListSandboxesRequestSchema, ListServicesRequestSchema, WatchJobsRequestSchema, WatchSandboxesRequestSchema, WatchServicesRequestSchema, } from "./gen/toshi/workspace/v1/workloads_pb.js";
 import { ListEventsRequestSchema, WatchEventsRequestSchema, WatchEventsResponseSchema, } from "./gen/toshi/workspace/v1/workspace_pb.js";
 import { READER_TAKEN, WatchState, createReader, reconnect, streamEnded } from "./stream.js";
+import { timeoutError } from "./timeout.js";
 /** Starts a job watch; with an empty cursor it lists the jobs first. */
 export function openJobWatch(service, retry, req, opts) {
     const request = clone(WatchJobsRequestSchema, req);
@@ -78,7 +79,7 @@ export function openServiceWatch(service, retry, req, opts) {
     }, retry, opts);
 }
 async function openWatch(wire, retry, opts) {
-    const state = new WatchState(wire.request.cursor, opts?.signal);
+    const state = new WatchState(wire.request.cursor, opts?.signal, opts?.timeoutMs);
     let snapshot;
     if (wire.request.cursor === "") {
         try {
@@ -88,6 +89,9 @@ async function openWatch(wire, retry, opts) {
         }
         catch (err) {
             state.close();
+            if (state.timedOut) {
+                throw timeoutError(state.timeoutMs);
+            }
             throw err;
         }
     }
@@ -124,6 +128,7 @@ async function* runWatch(wire, retry, state) {
             try {
                 wire.request.cursor = state.cursor;
                 for await (const message of wire.watch(state.signal)) {
+                    state.markOpen();
                     attempt = 0;
                     const keepalive = wire.keepalive(message);
                     if (keepalive !== undefined) {
@@ -147,6 +152,9 @@ async function* runWatch(wire, retry, state) {
                 if (state.closed) {
                     return;
                 }
+                if (state.timedOut) {
+                    throw timeoutError(state.timeoutMs);
+                }
                 cause = err;
             }
             attempt = await reconnect(retry, attempt, cause, state);
@@ -164,7 +172,7 @@ async function* runWatch(wire, retry, state) {
  * caller iterates. Every message it yields is the stream's response.
  */
 export function openEventWatch(service, retry, req, opts) {
-    const state = new WatchState(req.cursor, opts?.signal);
+    const state = new WatchState(req.cursor, opts?.signal, opts?.timeoutMs);
     const request = clone(WatchEventsRequestSchema, req);
     request.keepalive = true;
     const list = create(ListEventsRequestSchema, {
@@ -215,6 +223,7 @@ async function* runEvents(service, retry, request, list, listingAtStart, state)
                             state.cursor = event.cursor;
                             resume = event.cursor;
                         }
+                        state.markOpen();
                         yield create(WatchEventsResponseSchema, { event });
                         continue;
                     }
@@ -235,6 +244,7 @@ async function* runEvents(service, retry, request, list, listingAtStart, state)
                 }
                 request.cursor = resume;
                 for await (const message of service.watchEvents(request, { signal: state.signal })) {
+                    state.markOpen();
                     attempt = 0;
                     const keepalive = message.keepalive;
                     if (keepalive !== undefined) {
@@ -263,6 +273,9 @@ async function* runEvents(service, retry, request, list, listingAtStart, state)
                 if (state.closed) {
                     return;
                 }
+                if (state.timedOut) {
+                    throw timeoutError(state.timeoutMs);
+                }
                 cause = err;
             }
             attempt = await reconnect(retry, attempt, cause, state);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toshicloud/sdk",
-  "version": "0.3.2",
+  "version": "0.5.0",
   "description": "TypeScript client for the Toshi Workspace API",
   "license": "Apache-2.0",
   "packageManager": "pnpm@12.15.0+sha512.b3951d6d6ff4a9f13dc7cf56cd28d2b8eb37dbcc9c68e52e1e1191873ea9f82a017287ab50baadc5ccc494f036c67c0e47eb13608c2fa36f47711b61ea128e61",
@@ -10,6 +10,14 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
+    "./node": {
+      "types": "./dist/node/index.d.ts",
+      "default": "./dist/node/index.js"
+    },
+    "./test": {
+      "types": "./dist/test/index.d.ts",
+      "default": "./dist/test/index.js"
+    },
     "./package.json": "./package.json"
   },
   "types": "./dist/index.d.ts",
@@ -39,11 +47,19 @@
     "generate": "scripts/generate.sh",
     "prepack": "pnpm run build"
   },
-  "dependencies": {
+  "peerDependencies": {
     "@bufbuild/protobuf": "^2.16.0",
-    "@connectrpc/connect": "^2.2.0"
+    "@connectrpc/connect": "^2.2.0",
+    "@connectrpc/connect-node": "^2.2.0"
+  },
+  "peerDependenciesMeta": {
+    "@connectrpc/connect-node": {
+      "optional": true
+    }
   },
   "devDependencies": {
+    "@bufbuild/protobuf": "^2.16.0",
+    "@connectrpc/connect": "^2.2.0",
     "@connectrpc/connect-node": "2.2.0",
     "@connectrpc/connect-web": "2.2.0",
     "@eslint/js": "10.0.1",