@toshicloud/sdk 0.5.0 → 0.6.0

package/dist/test/alarms.js

@@ -0,0 +1,144 @@
+import { clone, create } from "@bufbuild/protobuf";
+import { DurationSchema, TimestampSchema } from "@bufbuild/protobuf/wkt";
+import { Code, ConnectError } from "@connectrpc/connect";
+import { DeleteServiceAlarmResponseSchema, GetServiceAlarmResponseSchema, ListServiceAlarmsResponseSchema, PauseServiceAlarmResponseSchema, ResumeServiceAlarmResponseSchema, RunServiceAlarmNowResponseSchema, ServiceAlarmMisfire, ServiceAlarmOccurrenceSchema, ServiceAlarmSchema, SetServiceAlarmResponseSchema, } from "../gen/toshi/workspace/v1/workloads_pb.js";
+/** How late a missed instant may be published when SetServiceAlarm names no deadline. */
+const defaultStartingDeadline = create(DurationSchema, { seconds: 600n });
+/** How many occurrences GetServiceAlarm returns. */
+const maxOccurrences = 20;
+/**
+ * The alarms the fake keeps for any service ID: the fake holds no services. It
+ * has no clock, so an alarm publishes nothing on its own and a cron alarm has
+ * no next instant.
+ */
+export class AlarmStore {
+    alarms = new Map();
+    runs = new Map();
+    /** Creates the alarm at generation 1, or replaces it at the next generation, resumed. */
+    set(request) {
+        const alarm = create(ServiceAlarmSchema, {
+            name: request.name,
+            timezone: request.timezone,
+            channel: request.channel,
+            event: request.event,
+            data: request.data.slice(),
+            misfire: request.misfire,
+            startingDeadline: clone(DurationSchema, request.startingDeadline ?? defaultStartingDeadline),
+            generation: 1n,
+        });
+        switch (request.schedule.case) {
+            case "cron":
+                alarm.schedule = { case: "cron", value: request.schedule.value };
+                break;
+            case "at":
+                alarm.schedule = { case: "at", value: clone(TimestampSchema, request.schedule.value) };
+                alarm.nextAt = clone(TimestampSchema, request.schedule.value);
+                break;
+        }
+        if (alarm.misfire === ServiceAlarmMisfire.UNSPECIFIED) {
+            alarm.misfire = ServiceAlarmMisfire.COALESCE;
+        }
+        const key = alarmKey(request.serviceId, request.name);
+        const held = this.alarms.get(key);
+        if (held === undefined) {
+            this.alarms.set(key, {
+                serviceId: request.serviceId,
+                name: request.name,
+                alarm,
+                occurrences: [],
+            });
+        }
+        else {
+            alarm.generation = held.alarm.generation + 1n;
+            held.alarm = alarm;
+        }
+        return create(SetServiceAlarmResponseSchema, { alarm: clone(ServiceAlarmSchema, alarm) });
+    }
+    /** Returns the alarm and its most recent occurrences, newest first. */
+    get(request) {
+        const record = this.alarm(request.serviceId, request.name);
+        return create(GetServiceAlarmResponseSchema, {
+            alarm: clone(ServiceAlarmSchema, record.alarm),
+            occurrences: record.occurrences
+                .slice(0, maxOccurrences)
+                .map((occurrence) => clone(ServiceAlarmOccurrenceSchema, occurrence)),
+        });
+    }
+    /** Returns every alarm of the service, by name. */
+    list(request) {
+        const alarms = [];
+        for (const record of this.alarms.values()) {
+            if (record.serviceId === request.serviceId) {
+                alarms.push(clone(ServiceAlarmSchema, record.alarm));
+            }
+        }
+        alarms.sort((a, b) => compareNames(a.name, b.name));
+        return create(ListServiceAlarmsResponseSchema, { alarms });
+    }
+    /** Removes an alarm and its occurrences. */
+    delete(request) {
+        this.alarm(request.serviceId, request.name);
+        this.alarms.delete(alarmKey(request.serviceId, request.name));
+        return create(DeleteServiceAlarmResponseSchema, {});
+    }
+    /** Pauses an alarm; pausing a paused alarm changes nothing. */
+    pause(request) {
+        const record = this.alarm(request.serviceId, request.name);
+        record.alarm.paused = true;
+        return create(PauseServiceAlarmResponseSchema, { alarm: clone(ServiceAlarmSchema, record.alarm) });
+    }
+    /** Resumes an alarm; resuming a running alarm changes nothing. */
+    resume(request) {
+        const record = this.alarm(request.serviceId, request.name);
+        record.alarm.paused = false;
+        return create(ResumeServiceAlarmResponseSchema, { alarm: clone(ServiceAlarmSchema, record.alarm) });
+    }
+    /**
+     * Records a manual occurrence at the alarm's generation. A request key the
+     * fake has already answered returns the same occurrence.
+     */
+    runNow(request) {
+        if (request.requestKey !== "") {
+            const answered = this.runs.get(request.requestKey);
+            if (answered !== undefined) {
+                return create(RunServiceAlarmNowResponseSchema, {
+                    occurrence: clone(ServiceAlarmOccurrenceSchema, answered),
+                });
+            }
+        }
+        const record = this.alarm(request.serviceId, request.name);
+        const occurrence = create(ServiceAlarmOccurrenceSchema, {
+            generation: record.alarm.generation,
+            manual: true,
+        });
+        record.occurrences.unshift(occurrence);
+        if (request.requestKey !== "") {
+            this.runs.set(request.requestKey, occurrence);
+        }
+        return create(RunServiceAlarmNowResponseSchema, { occurrence: clone(ServiceAlarmOccurrenceSchema, occurrence) });
+    }
+    /** Returns the alarm of a service with this name. */
+    alarm(serviceId, name) {
+        const record = this.alarms.get(alarmKey(serviceId, name));
+        if (record === undefined) {
+            throw new ConnectError(`toshi: no alarm "${serviceId}/${name}"`, Code.NotFound);
+        }
+        return record;
+    }
+}
+/** The map key of one alarm: its service and its name. */
+function alarmKey(serviceId, name) {
+    return JSON.stringify([serviceId, name]);
+}
+/** Compares two names by the bytes of their UTF-8 encoding, as Go's strings.Compare does. */
+function compareNames(a, b) {
+    const left = new TextEncoder().encode(a);
+    const right = new TextEncoder().encode(b);
+    const shared = Math.min(left.length, right.length);
+    for (let index = 0; index < shared; index += 1) {
+        if (left[index] !== right[index]) {
+            return left[index] < right[index] ? -1 : 1;
+        }
+    }
+    return left.length - right.length;
+}

package/dist/test/fake.js

@@ -3,6 +3,7 @@ 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 { AlarmStore } from "./alarms.js";
 import { apiMethods, apiPackage, hookOnly as hookOnlyMethods, isApiMethod, procedurePath } from "./procedures.js";
 /** The token `client` sends. */
 export const testToken = "test-token";
@@ -93,6 +94,34 @@ const builtinTable = [
             run: (requests) => fake.executeAnswer(requests),
         }),
     ],
+    [
+        workloadMethod("setServiceAlarm"),
+        (fake) => ({ kind: "unary", run: (request) => fake.alarms.set(request) }),
+    ],
+    [
+        workloadMethod("getServiceAlarm"),
+        (fake) => ({ kind: "unary", run: (request) => fake.alarms.get(request) }),
+    ],
+    [
+        workloadMethod("listServiceAlarms"),
+        (fake) => ({ kind: "unary", run: (request) => fake.alarms.list(request) }),
+    ],
+    [
+        workloadMethod("deleteServiceAlarm"),
+        (fake) => ({ kind: "unary", run: (request) => fake.alarms.delete(request) }),
+    ],
+    [
+        workloadMethod("pauseServiceAlarm"),
+        (fake) => ({ kind: "unary", run: (request) => fake.alarms.pause(request) }),
+    ],
+    [
+        workloadMethod("resumeServiceAlarm"),
+        (fake) => ({ kind: "unary", run: (request) => fake.alarms.resume(request) }),
+    ],
+    [
+        workloadMethod("runServiceAlarmNow"),
+        (fake) => ({ kind: "unary", run: (request) => fake.alarms.runNow(request) }),
+    ],
 ];
 /** The procedures the state machine answers. The coverage test holds it against the API. */
 export const answeredProcedures = builtinTable.map(([method]) => method);
@@ -122,6 +151,8 @@ class FakeToshi {
     nextSandbox = 0;
     executions = new Map();
     nextExecution = 0;
+    /** The service alarms the fake holds; `builtinTable` answers from it. */
+    alarms = new AlarmStore();
     constructor() {
         for (const [method, make] of builtinTable) {
             this.builtin.set(procedurePath(method), make(this));

package/dist/test/index.d.ts

@@ -19,8 +19,8 @@
  * # 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.
+ * with what the test set. It knows the job and the sandbox lifecycle and a
+ * service's alarms, 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
@@ -46,6 +46,16 @@
  * - 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.
+ * - SetServiceAlarm, GetServiceAlarm, ListServiceAlarms, DeleteServiceAlarm,
+ *   PauseServiceAlarm, ResumeServiceAlarm and RunServiceAlarmNow keep alarms
+ *   for any service ID: the fake holds no services. A set creates an alarm at
+ *   generation 1, or replaces it at the next generation and resumes it.
+ *   RunServiceAlarmNow records a manual occurrence, which GetServiceAlarm
+ *   returns newest first; a run whose request key the fake has already
+ *   answered returns the same occurrence. With no clock an alarm publishes
+ *   nothing on its own, a cron alarm has no next instant, and the fake sets no
+ *   time of its own: an alarm set at an instant has that instant as its next
+ *   one. An unknown alarm is NOT_FOUND.
  *
  * Every other procedure is hook-only. An unhooked procedure the state machine
  * does not cover answers UNIMPLEMENTED, naming the procedure and the `on` call

package/dist/test/index.js

@@ -19,8 +19,8 @@
  * # 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.
+ * with what the test set. It knows the job and the sandbox lifecycle and a
+ * service's alarms, 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
@@ -46,6 +46,16 @@
  * - 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.
+ * - SetServiceAlarm, GetServiceAlarm, ListServiceAlarms, DeleteServiceAlarm,
+ *   PauseServiceAlarm, ResumeServiceAlarm and RunServiceAlarmNow keep alarms
+ *   for any service ID: the fake holds no services. A set creates an alarm at
+ *   generation 1, or replaces it at the next generation and resumes it.
+ *   RunServiceAlarmNow records a manual occurrence, which GetServiceAlarm
+ *   returns newest first; a run whose request key the fake has already
+ *   answered returns the same occurrence. With no clock an alarm publishes
+ *   nothing on its own, a cron alarm has no next instant, and the fake sets no
+ *   time of its own: an alarm set at an instant has that instant as its next
+ *   one. An unknown alarm is NOT_FOUND.
  *
  * Every other procedure is hook-only. An unhooked procedure the state machine
  * does not cover answers UNIMPLEMENTED, naming the procedure and the `on` call

package/dist/test/procedures.js

@@ -1,10 +1,15 @@
+import { AccountService } from "../gen/toshi/workspace/v1/account_pb.js";
 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 { DomainService } from "../gen/toshi/workspace/v1/domains_pb.js";
 import { FillerService } from "../gen/toshi/workspace/v1/fillers_pb.js";
+import { GrantService } from "../gen/toshi/workspace/v1/grants_pb.js";
 import { HostJobService } from "../gen/toshi/workspace/v1/hostjobs_pb.js";
 import { HostService } from "../gen/toshi/workspace/v1/hosts_pb.js";
+import { ImageService } from "../gen/toshi/workspace/v1/images_pb.js";
+import { ProductService } from "../gen/toshi/workspace/v1/products_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";
@@ -30,11 +35,16 @@ export const apiServices = [
     ArtifactUploadService,
     AuditEventService,
     FillerService,
+    GrantService,
     HostJobService,
     HostService,
     TokenService,
     StorageProviderService,
     WorkspaceService,
+    AccountService,
+    ImageService,
+    ProductService,
+    DomainService,
 ];
 /** The path a client calls a method by, for example `/toshi.workspace.v1.WorkloadService/CreateJob`. */
 export function procedurePath(method) {
@@ -62,17 +72,39 @@ export function isApiMethod(method) {
  * neither, so a new method is a decision and not a surprise at a caller.
  */
 export const hookOnly = [
+    // AccountService
+    AccountService.method.getAccount,
+    AccountService.method.listIdentities,
+    AccountService.method.unlinkIdentity,
+    // ImageService
+    ImageService.method.createImage,
+    ImageService.method.buildImage,
+    ImageService.method.getImage,
+    ImageService.method.listImages,
+    ImageService.method.deleteImage,
+    ImageService.method.updateImage,
+    // ProductService
+    ProductService.method.listProducts,
+    ProductService.method.updateProduct,
     // WorkloadService
     WorkloadService.method.updateJob,
     WorkloadService.method.deleteJob,
     WorkloadService.method.updateSandbox,
     WorkloadService.method.deleteSandbox,
+    WorkloadService.method.stopSandbox,
+    WorkloadService.method.startSandbox,
     WorkloadService.method.cancelExecution,
+    WorkloadService.method.exportEvents,
     WorkloadService.method.watchTelemetry,
     WorkloadService.method.watchGuestLog,
     WorkloadService.method.createPreviewShareLink,
     WorkloadService.method.listPreviewShareLinks,
     WorkloadService.method.revokePreviewShareLink,
+    WorkloadService.method.createServiceShareLink,
+    WorkloadService.method.listServiceShareLinks,
+    WorkloadService.method.revokeServiceShareLink,
+    WorkloadService.method.executeCommand,
+    WorkloadService.method.answerPrompt,
     WorkloadService.method.createService,
     WorkloadService.method.getService,
     WorkloadService.method.listServices,
@@ -84,13 +116,28 @@ export const hookOnly = [
     WorkloadService.method.stopService,
     WorkloadService.method.setServiceMode,
     WorkloadService.method.wakeService,
+    // The fake holds no workloads: the operator's holds are answered by hooks.
+    WorkloadService.method.holdWorkload,
+    WorkloadService.method.releaseWorkload,
     WorkloadService.method.holdService,
     WorkloadService.method.releaseService,
+    WorkloadService.method.listServiceRevisions,
+    WorkloadService.method.getServiceRevision,
+    WorkloadService.method.rollbackService,
+    WorkloadService.method.listServiceActivations,
     WorkloadService.method.listServiceRuns,
     WorkloadService.method.listEvents,
     WorkloadService.method.watchEvents,
     WorkloadService.method.getOperation,
     WorkloadService.method.waitOperation,
+    // The fake holds no services: their sign-ins are answered by hooks.
+    WorkloadService.method.startServiceSignIn,
+    WorkloadService.method.answerServiceSignIn,
+    WorkloadService.method.cancelServiceSignIn,
+    WorkloadService.method.getServiceSignInStatus,
+    // The fake keeps no event log: listEvents and watchEvents are hook-only, so
+    // an emitted event would be one no call can read back.
+    WorkloadService.method.emitWorkloadEvent,
     // SecretService
     SecretService.method.createSecretSet,
     SecretService.method.listSecretSets,
@@ -102,8 +149,11 @@ export const hookOnly = [
     SecretService.method.grantSecretSet,
     SecretService.method.revokeSecretSet,
     SecretService.method.listSecretSetGrants,
+    // The fake holds no secret sets.
+    SecretService.method.updateSecretSet,
     // ProjectService
     ProjectService.method.listProjects,
+    ProjectService.method.updateProject,
     ProjectService.method.getProject,
     ProjectService.method.listRepositories,
     ProjectService.method.createProject,
@@ -115,6 +165,15 @@ export const hookOnly = [
     ProjectService.method.createEmbedToken,
     ProjectService.method.listEmbedTokens,
     ProjectService.method.revokeEmbedToken,
+    ProjectService.method.getProjectNetwork,
+    ProjectService.method.setProjectNetwork,
+    ProjectService.method.getEnvironmentNetwork,
+    ProjectService.method.setEnvironmentNetwork,
+    // The fake holds no projects or environments.
+    ProjectService.method.updateEnvironment,
+    ProjectService.method.getEnvironmentRetention,
+    ProjectService.method.setEnvironmentRetention,
+    ProjectService.method.setEnvironmentVolumes,
     // WebhookService
     WebhookService.method.createWebhookEndpoint,
     WebhookService.method.getWebhookEndpoint,
@@ -147,6 +206,9 @@ export const hookOnly = [
     ChannelService.method.deleteChannel,
     ChannelService.method.listForwards,
     ChannelService.method.getLink,
+    ChannelService.method.sendChannelMessage,
+    ChannelService.method.tailChannelMessages,
+    ChannelService.method.replayChannelMessage,
     // RecordingService
     RecordingService.method.listRecordings,
     RecordingService.method.getRecording,
@@ -155,8 +217,15 @@ export const hookOnly = [
     RecordingService.method.revokeRecordingShareLink,
     // VolumeService
     VolumeService.method.listVolumes,
+    VolumeService.method.getVolume,
     VolumeService.method.attachVolume,
     VolumeService.method.detachVolume,
+    VolumeService.method.listVolumeVersions,
+    VolumeService.method.restoreVolume,
+    // The fake holds no volumes.
+    VolumeService.method.createVolume,
+    VolumeService.method.updateVolume,
+    VolumeService.method.deleteVolume,
     // ArtifactService
     ArtifactService.method.listArtifacts,
     ArtifactService.method.getArtifact,
@@ -166,12 +235,22 @@ export const hookOnly = [
     ArtifactUploadService.method.completeUpload,
     // AuditEventService
     AuditEventService.method.listAuditEvents,
+    AuditEventService.method.exportAuditEvents,
     // FillerService
     FillerService.method.listFillers,
     FillerService.method.putFiller,
     FillerService.method.deleteFiller,
     FillerService.method.setFillerEnabled,
     FillerService.method.listFillerRuns,
+    // GrantService
+    GrantService.method.createGrant,
+    GrantService.method.getGrant,
+    GrantService.method.listGrants,
+    GrantService.method.acceptGrant,
+    GrantService.method.declineGrant,
+    GrantService.method.updateGrant,
+    GrantService.method.revokeGrant,
+    GrantService.method.leaveGrant,
     // HostJobService
     HostJobService.method.listHostJobs,
     HostJobService.method.getHostJob,
@@ -193,6 +272,8 @@ export const hookOnly = [
     TokenService.method.listTokens,
     TokenService.method.createWorkspaceToken,
     TokenService.method.revokeToken,
+    TokenService.method.rollWorkspaceToken,
+    TokenService.method.updateToken,
     // StorageProviderService
     StorageProviderService.method.listStorageProviders,
     StorageProviderService.method.createStorageProvider,
@@ -200,14 +281,11 @@ export const hookOnly = [
     StorageProviderService.method.deleteStorageProvider,
     // WorkspaceService
     WorkspaceService.method.getWorkspace,
+    WorkspaceService.method.updateWorkspace,
     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.getWorkspaceUpcomingInvoice,
     WorkspaceService.method.listEgressIPs,
     WorkspaceService.method.getUsage,
     WorkspaceService.method.getQueueTimes,
@@ -216,4 +294,17 @@ export const hookOnly = [
     WorkspaceService.method.createCheckoutSession,
     WorkspaceService.method.createBillingPortalSession,
     WorkspaceService.method.getVersion,
+    WorkspaceService.method.listSeats,
+    WorkspaceService.method.assignSeat,
+    WorkspaceService.method.removeSeat,
+    // The fake holds no workspace record: getWorkspace is hook-only too.
+    WorkspaceService.method.deleteWorkspace,
+    WorkspaceService.method.cancelWorkspaceDeletion,
+    // DomainService
+    DomainService.method.createDomain,
+    DomainService.method.getDomain,
+    DomainService.method.listDomains,
+    DomainService.method.verifyDomain,
+    DomainService.method.issueDomain,
+    DomainService.method.deleteDomain,
 ];

package/dist/version.d.ts

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

package/dist/version.js

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

package/dist/wait.d.ts

@@ -3,6 +3,10 @@ import type { CallOptions } from "./client.js";
 import type { WorkloadService } from "./gen/toshi/workspace/v1/workloads_pb.js";
 import type { WaitJobRequest, WaitJobResponse, WaitSandboxRequest, WaitSandboxResponse, WaitServiceRequest, WaitServiceResponse } from "./gen/toshi/workspace/v1/workloads_pb.js";
 import type { Operation, WaitOperationRequest } from "./gen/toshi/workspace/v1/workspace_pb.js";
+/** The shortest time between the start of one Wait call and the start of the next, in milliseconds. */
+export declare const waitMinInterval = 1000;
+/** The most added to waitMinInterval, at random and inclusive. */
+export declare const waitMaxJitter: number;
 /** Asks again while the job is not in a state it waits for, and returns the answer when it is. */
 export declare function waitJob(service: Client<typeof WorkloadService>, req: WaitJobRequest, opts?: CallOptions): Promise<WaitJobResponse>;
 /** Asks again while the sandbox is not in a state it waits for. */

package/dist/wait.js

@@ -1,5 +1,11 @@
-import { abortReason } from "./retry.js";
+import { abortReason, sleep } from "./retry.js";
 import { runWithDeadline } from "./timeout.js";
+// wait.go:13-17: one Wait call starts no sooner than waitMinInterval plus up
+// to waitMaxJitter after the start of the one before.
+/** The shortest time between the start of one Wait call and the start of the next, in milliseconds. */
+export const waitMinInterval = 1_000;
+/** The most added to waitMinInterval, at random and inclusive. */
+export const waitMaxJitter = waitMinInterval / 5;
 /** 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 runWithDeadline(opts, (callOpts) => waitReached((o) => service.waitJob(req, o), callOpts));
@@ -17,11 +23,13 @@ export function waitOperation(service, req, opts) {
     return runWithDeadline(opts, async (callOpts) => {
         for (;;) {
             throwIfAborted(callOpts);
+            const started = Date.now();
             const resp = await service.waitOperation(req, callOpts);
             const op = resp.operation;
             if (op !== undefined && op.done) {
                 return op;
             }
+            await pauseWait(started, callOpts);
         }
     });
 }
@@ -29,12 +37,27 @@ export function waitOperation(service, req, opts) {
 async function waitReached(call, opts) {
     for (;;) {
         throwIfAborted(opts);
+        const started = Date.now();
         const resp = await call(opts);
         if (resp.reached) {
             return resp;
         }
+        await pauseWait(started, opts);
     }
 }
+/**
+ * Leaves at least waitMinInterval plus up to waitMaxJitter between the start
+ * of the call at started and the start of the next one: it pauses for the
+ * difference, at once when the call already took that long, and ends with the
+ * caller's own error when its signal aborts (wait.go:27-40).
+ */
+async function pauseWait(started, opts) {
+    const paused = waitMinInterval + Math.floor(Math.random() * (waitMaxJitter + 1)) - (Date.now() - started);
+    if (paused <= 0) {
+        return;
+    }
+    await sleep(paused, opts?.signal);
+}
 // wait.go:16-18: the caller's context ends the loop with its own error.
 function throwIfAborted(opts) {
     const signal = opts?.signal;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toshicloud/sdk",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "TypeScript client for the Toshi Workspace API",
   "license": "Apache-2.0",
   "packageManager": "pnpm@12.15.0+sha512.b3951d6d6ff4a9f13dc7cf56cd28d2b8eb37dbcc9c68e52e1e1191873ea9f82a017287ab50baadc5ccc494f036c67c0e47eb13608c2fa36f47711b61ea128e61",
@@ -58,7 +58,8 @@
     }
   },
   "devDependencies": {
-    "@bufbuild/protobuf": "^2.16.0",
+    "@bufbuild/protobuf": "2.16.0",
+    "@bufbuild/protoc-gen-es": "2.16.0",
     "@connectrpc/connect": "^2.2.0",
     "@connectrpc/connect-node": "2.2.0",
     "@connectrpc/connect-web": "2.2.0",