@boatdev/sdk 1.3.0 → 1.4.0

package/dist/apis/BoatApi.d.ts

@@ -387,12 +387,12 @@ export declare class BoatApi extends runtime.BaseAPI {
      */
     commandRequestOpts(input: CommandOperationRequest | runtime.FlatBody<CommandOperationRequest, 'commandRequest'>): Promise<runtime.RequestOpts>;
     /**
-     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
+     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. A sandbox that is not starting (`error`, `stopped`) returns 409 sandbox_not_ready with `retryable: false` and its `state` at once: resume or recover it first. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
      * Execute a command in a sandbox
      */
     commandRaw(requestParameters: CommandOperationRequest | runtime.FlatBody<CommandOperationRequest, 'commandRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Command200Response>>;
     /**
-     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
+     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. A sandbox that is not starting (`error`, `stopped`) returns 409 sandbox_not_ready with `retryable: false` and its `state` at once: resume or recover it first. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
      * Execute a command in a sandbox
      */
     command(requestParameters: CommandOperationRequest | runtime.FlatBody<CommandOperationRequest, 'commandRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Command200Response>;

package/dist/apis/BoatApi.js

@@ -331,7 +331,7 @@ class BoatApi extends runtime.BaseAPI {
         };
     }
     /**
-     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
+     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. A sandbox that is not starting (`error`, `stopped`) returns 409 sandbox_not_ready with `retryable: false` and its `state` at once: resume or recover it first. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
      * Execute a command in a sandbox
      */
     async commandRaw(requestParameters, initOverrides) {
@@ -340,7 +340,7 @@ class BoatApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => (0, Command200Response_1.Command200ResponseFromJSON)(jsonValue));
     }
     /**
-     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
+     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. A sandbox that is not starting (`error`, `stopped`) returns 409 sandbox_not_ready with `retryable: false` and its `state` at once: resume or recover it first. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
      * Execute a command in a sandbox
      */
     async command(requestParameters, initOverrides) {

package/dist/esm/apis/BoatApi.d.ts

@@ -387,12 +387,12 @@ export declare class BoatApi extends runtime.BaseAPI {
      */
     commandRequestOpts(input: CommandOperationRequest | runtime.FlatBody<CommandOperationRequest, 'commandRequest'>): Promise<runtime.RequestOpts>;
     /**
-     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
+     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. A sandbox that is not starting (`error`, `stopped`) returns 409 sandbox_not_ready with `retryable: false` and its `state` at once: resume or recover it first. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
      * Execute a command in a sandbox
      */
     commandRaw(requestParameters: CommandOperationRequest | runtime.FlatBody<CommandOperationRequest, 'commandRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Command200Response>>;
     /**
-     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
+     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. A sandbox that is not starting (`error`, `stopped`) returns 409 sandbox_not_ready with `retryable: false` and its `state` at once: resume or recover it first. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
      * Execute a command in a sandbox
      */
     command(requestParameters: CommandOperationRequest | runtime.FlatBody<CommandOperationRequest, 'commandRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Command200Response>;

package/dist/esm/apis/BoatApi.js

@@ -295,7 +295,7 @@ export class BoatApi extends runtime.BaseAPI {
         };
     }
     /**
-     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
+     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. A sandbox that is not starting (`error`, `stopped`) returns 409 sandbox_not_ready with `retryable: false` and its `state` at once: resume or recover it first. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
      * Execute a command in a sandbox
      */
     async commandRaw(requestParameters, initOverrides) {
@@ -304,7 +304,7 @@ export class BoatApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => Command200ResponseFromJSON(jsonValue));
     }
     /**
-     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
+     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. A sandbox that is not starting (`error`, `stopped`) returns 409 sandbox_not_ready with `retryable: false` and its `state` at once: resume or recover it first. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
      * Execute a command in a sandbox
      */
     async command(requestParameters, initOverrides) {

package/dist/esm/models/CreateSandboxRequest.d.ts

@@ -54,7 +54,7 @@ export interface CreateSandboxRequest {
      */
     snapshots?: boolean;
     /**
-     * Pass `true` to get a sandbox only if a machine of this type is ready right now. The call answers within about 1.5 s: either the usual `202` with the sandbox, or `503` `no_ready_machine` with nothing created, billed, or counted against your start limits, so you can retry or fall back at once. Without it, a create waits for a machine to be built when none is ready. Not combinable with `from`.
+     * Pass `true` to get a sandbox only if a machine of this type is ready right now. The call answers within about 1.5 s: either the usual `202` with the sandbox, or `503` `no_ready_machine` with nothing created, billed, or counted against your start limits, so you can retry or fall back at once. Without it, a create waits for a machine to be built when none is ready. Works with `from`; fork and resume take it too.
      * @type {boolean}
      * @memberof CreateSandboxRequest
      */

package/dist/esm/models/ForkRequest.d.ts

@@ -15,6 +15,12 @@
  * @interface ForkRequest
  */
 export interface ForkRequest {
+    /**
+     * Pass `true` to fork only if a machine is ready right now. Within about 1.5 s you get the usual `202`, or `503` `no_ready_machine` with no fork created and nothing counted against your start limits.
+     * @type {boolean}
+     * @memberof ForkRequest
+     */
+    failFast?: boolean;
     /**
      * Replaces the env the fork would otherwise inherit from the source sandbox. Same validation rules as `CreateSandboxRequest.env`.
      * @type {{ [key: string]: string; }}

package/dist/esm/models/ForkRequest.js

@@ -33,6 +33,7 @@ export function ForkRequestFromJSONTyped(json, ignoreDiscriminator) {
         return json;
     }
     return {
+        'failFast': json['failFast'] == null ? undefined : json['failFast'],
         'env': json['env'] == null ? undefined : json['env'],
         'environment': json['environment'] == null ? undefined : json['environment'],
         'noEnv': json['noEnv'] == null ? undefined : json['noEnv'],
@@ -48,6 +49,7 @@ export function ForkRequestToJSONTyped(value, ignoreDiscriminator = false) {
         return value;
     }
     return {
+        'failFast': value['failFast'],
         'env': value['env'],
         'environment': value['environment'],
         'noEnv': value['noEnv'],

package/dist/esm/models/ResumeRequest.d.ts

@@ -15,6 +15,12 @@
  * @interface ResumeRequest
  */
 export interface ResumeRequest {
+    /**
+     * Pass `true` to resume only if a machine is ready right now. Within about 1.5 s you get the usual `202`, or `503` `no_ready_machine` with the sandbox left stopped and nothing counted against your start limits.
+     * @type {boolean}
+     * @memberof ResumeRequest
+     */
+    failFast?: boolean;
     /**
      * Resume onto a different machine size. Omit to keep the sandbox's current type. A resume already restores onto a fresh machine, so changing size costs nothing extra. Shrinking is rejected with `type_too_small` when the sandbox's data would not fit the smaller disk.
      * @type {ResumeRequestTypeEnum}

package/dist/esm/models/ResumeRequest.js

@@ -33,6 +33,7 @@ export function ResumeRequestFromJSONTyped(json, ignoreDiscriminator) {
         return json;
     }
     return {
+        'failFast': json['failFast'] == null ? undefined : json['failFast'],
         'type': json['type'] == null ? undefined : json['type'],
         'env': json['env'] == null ? undefined : json['env'],
         'environment': json['environment'] == null ? undefined : json['environment'],
@@ -48,6 +49,7 @@ export function ResumeRequestToJSONTyped(value, ignoreDiscriminator = false) {
         return value;
     }
     return {
+        'failFast': value['failFast'],
         'type': value['type'],
         'env': value['env'],
         'environment': value['environment'],

package/dist/esm/models/Sandbox.d.ts

@@ -40,6 +40,24 @@ export interface Sandbox {
      * @memberof Sandbox
      */
     error?: string | null;
+    /**
+     * `degraded` when the machine is alive but Boat cannot fully reach it (for example a firewall rule inside the sandbox blocks the tunnel). The sandbox keeps running.
+     * @type {SandboxHealthEnum}
+     * @memberof Sandbox
+     */
+    health?: SandboxHealthEnum;
+    /**
+     * Why the sandbox is degraded, or null.
+     * @type {string}
+     * @memberof Sandbox
+     */
+    healthReason?: string | null;
+    /**
+     * When the sandbox became degraded, or null.
+     * @type {Date}
+     * @memberof Sandbox
+     */
+    degradedSince?: Date | null;
     /**
      * Current machine size: what the sandbox was created with, or the size it was last resumed or forked onto.
      * @type {SandboxTypeEnum}
@@ -208,6 +226,14 @@ export declare const SandboxStateEnum: {
     readonly Cancelled: 'cancelled';
 };
 export type SandboxStateEnum = typeof SandboxStateEnum[keyof typeof SandboxStateEnum];
+/**
+ * @export
+ */
+export declare const SandboxHealthEnum: {
+    readonly Ok: 'ok';
+    readonly Degraded: 'degraded';
+};
+export type SandboxHealthEnum = typeof SandboxHealthEnum[keyof typeof SandboxHealthEnum];
 /**
  * @export
  */

package/dist/esm/models/Sandbox.js

@@ -28,6 +28,13 @@ export const SandboxStateEnum = {
     Error: 'error',
     Cancelled: 'cancelled'
 };
+/**
+ * @export
+ */
+export const SandboxHealthEnum = {
+    Ok: 'ok',
+    Degraded: 'degraded'
+};
 /**
  * @export
  */
@@ -90,6 +97,9 @@ export function SandboxFromJSONTyped(json, ignoreDiscriminator) {
         'name': json['name'],
         'state': json['state'],
         'error': json['error'] == null ? undefined : json['error'],
+        'health': json['health'] == null ? undefined : json['health'],
+        'healthReason': json['healthReason'] == null ? undefined : json['healthReason'],
+        'degradedSince': json['degradedSince'] == null ? undefined : (new Date(json['degradedSince'])),
         'type': json['type'] == null ? undefined : json['type'],
         'vcpu': json['vcpu'] == null ? undefined : json['vcpu'],
         'memoryGB': json['memoryGB'] == null ? undefined : json['memoryGB'],
@@ -129,6 +139,9 @@ export function SandboxToJSONTyped(value, ignoreDiscriminator = false) {
         'name': value['name'],
         'state': value['state'],
         'error': value['error'],
+        'health': value['health'],
+        'healthReason': value['healthReason'],
+        'degradedSince': value['degradedSince'] == null ? value['degradedSince'] : value['degradedSince'].toISOString(),
         'type': value['type'],
         'vcpu': value['vcpu'],
         'memoryGB': value['memoryGB'],

package/dist/esm/models/WebhookEventData.d.ts

@@ -23,17 +23,23 @@ export interface WebhookEventData {
      */
     sandbox: WebhookEventDataSandbox;
     /**
-     *
+     * On sandbox.ready, sandbox.error and sandbox.archived only.
      * @type {string}
      * @memberof WebhookEventData
      */
-    previousState: string;
+    previousState?: string;
     /**
-     *
+     * Absent on sandbox.hydrated.
+     * @type {string}
+     * @memberof WebhookEventData
+     */
+    state?: string;
+    /**
+     * On sandbox.degraded and sandbox.recovered. Why the sandbox is degraded (null on recovered).
      * @type {string}
      * @memberof WebhookEventData
      */
-    state: string;
+    reason?: string | null;
 }
 /**
  * Check if a given object implements the WebhookEventData interface.

package/dist/esm/models/WebhookEventData.js

@@ -18,10 +18,6 @@ import { WebhookEventDataSandboxFromJSON, WebhookEventDataSandboxToJSON, } from
 export function instanceOfWebhookEventData(value) {
     if (!('sandbox' in value) || value['sandbox'] === undefined)
         return false;
-    if (!('previousState' in value) || value['previousState'] === undefined)
-        return false;
-    if (!('state' in value) || value['state'] === undefined)
-        return false;
     return true;
 }
 export function WebhookEventDataFromJSON(json) {
@@ -33,8 +29,9 @@ export function WebhookEventDataFromJSONTyped(json, ignoreDiscriminator) {
     }
     return {
         'sandbox': WebhookEventDataSandboxFromJSON(json['sandbox']),
-        'previousState': json['previousState'],
-        'state': json['state'],
+        'previousState': json['previousState'] == null ? undefined : json['previousState'],
+        'state': json['state'] == null ? undefined : json['state'],
+        'reason': json['reason'] == null ? undefined : json['reason'],
     };
 }
 export function WebhookEventDataToJSON(json) {
@@ -48,5 +45,6 @@ export function WebhookEventDataToJSONTyped(value, ignoreDiscriminator = false)
         'sandbox': WebhookEventDataSandboxToJSON(value['sandbox']),
         'previousState': value['previousState'],
         'state': value['state'],
+        'reason': value['reason'],
     };
 }

package/dist/esm/models/WebhookEventType.d.ts

@@ -18,6 +18,8 @@ export declare const WebhookEventType: {
     readonly SandboxError: 'sandbox.error';
     readonly SandboxArchived: 'sandbox.archived';
     readonly SandboxHydrated: 'sandbox.hydrated';
+    readonly SandboxDegraded: 'sandbox.degraded';
+    readonly SandboxRecovered: 'sandbox.recovered';
 };
 export type WebhookEventType = typeof WebhookEventType[keyof typeof WebhookEventType];
 export declare function instanceOfWebhookEventType(value: any): boolean;

package/dist/esm/models/WebhookEventType.js

@@ -19,7 +19,9 @@ export const WebhookEventType = {
     SandboxReady: 'sandbox.ready',
     SandboxError: 'sandbox.error',
     SandboxArchived: 'sandbox.archived',
-    SandboxHydrated: 'sandbox.hydrated'
+    SandboxHydrated: 'sandbox.hydrated',
+    SandboxDegraded: 'sandbox.degraded',
+    SandboxRecovered: 'sandbox.recovered'
 };
 export function instanceOfWebhookEventType(value) {
     for (const key in WebhookEventType) {

package/dist/models/CreateSandboxRequest.d.ts

@@ -54,7 +54,7 @@ export interface CreateSandboxRequest {
      */
     snapshots?: boolean;
     /**
-     * Pass `true` to get a sandbox only if a machine of this type is ready right now. The call answers within about 1.5 s: either the usual `202` with the sandbox, or `503` `no_ready_machine` with nothing created, billed, or counted against your start limits, so you can retry or fall back at once. Without it, a create waits for a machine to be built when none is ready. Not combinable with `from`.
+     * Pass `true` to get a sandbox only if a machine of this type is ready right now. The call answers within about 1.5 s: either the usual `202` with the sandbox, or `503` `no_ready_machine` with nothing created, billed, or counted against your start limits, so you can retry or fall back at once. Without it, a create waits for a machine to be built when none is ready. Works with `from`; fork and resume take it too.
      * @type {boolean}
      * @memberof CreateSandboxRequest
      */

package/dist/models/ForkRequest.d.ts

@@ -15,6 +15,12 @@
  * @interface ForkRequest
  */
 export interface ForkRequest {
+    /**
+     * Pass `true` to fork only if a machine is ready right now. Within about 1.5 s you get the usual `202`, or `503` `no_ready_machine` with no fork created and nothing counted against your start limits.
+     * @type {boolean}
+     * @memberof ForkRequest
+     */
+    failFast?: boolean;
     /**
      * Replaces the env the fork would otherwise inherit from the source sandbox. Same validation rules as `CreateSandboxRequest.env`.
      * @type {{ [key: string]: string; }}

package/dist/models/ForkRequest.js

@@ -41,6 +41,7 @@ function ForkRequestFromJSONTyped(json, ignoreDiscriminator) {
         return json;
     }
     return {
+        'failFast': json['failFast'] == null ? undefined : json['failFast'],
         'env': json['env'] == null ? undefined : json['env'],
         'environment': json['environment'] == null ? undefined : json['environment'],
         'noEnv': json['noEnv'] == null ? undefined : json['noEnv'],
@@ -56,6 +57,7 @@ function ForkRequestToJSONTyped(value, ignoreDiscriminator = false) {
         return value;
     }
     return {
+        'failFast': value['failFast'],
         'env': value['env'],
         'environment': value['environment'],
         'noEnv': value['noEnv'],

package/dist/models/ResumeRequest.d.ts

@@ -15,6 +15,12 @@
  * @interface ResumeRequest
  */
 export interface ResumeRequest {
+    /**
+     * Pass `true` to resume only if a machine is ready right now. Within about 1.5 s you get the usual `202`, or `503` `no_ready_machine` with the sandbox left stopped and nothing counted against your start limits.
+     * @type {boolean}
+     * @memberof ResumeRequest
+     */
+    failFast?: boolean;
     /**
      * Resume onto a different machine size. Omit to keep the sandbox's current type. A resume already restores onto a fresh machine, so changing size costs nothing extra. Shrinking is rejected with `type_too_small` when the sandbox's data would not fit the smaller disk.
      * @type {ResumeRequestTypeEnum}

package/dist/models/ResumeRequest.js

@@ -41,6 +41,7 @@ function ResumeRequestFromJSONTyped(json, ignoreDiscriminator) {
         return json;
     }
     return {
+        'failFast': json['failFast'] == null ? undefined : json['failFast'],
         'type': json['type'] == null ? undefined : json['type'],
         'env': json['env'] == null ? undefined : json['env'],
         'environment': json['environment'] == null ? undefined : json['environment'],
@@ -56,6 +57,7 @@ function ResumeRequestToJSONTyped(value, ignoreDiscriminator = false) {
         return value;
     }
     return {
+        'failFast': value['failFast'],
         'type': value['type'],
         'env': value['env'],
         'environment': value['environment'],

package/dist/models/Sandbox.d.ts

@@ -40,6 +40,24 @@ export interface Sandbox {
      * @memberof Sandbox
      */
     error?: string | null;
+    /**
+     * `degraded` when the machine is alive but Boat cannot fully reach it (for example a firewall rule inside the sandbox blocks the tunnel). The sandbox keeps running.
+     * @type {SandboxHealthEnum}
+     * @memberof Sandbox
+     */
+    health?: SandboxHealthEnum;
+    /**
+     * Why the sandbox is degraded, or null.
+     * @type {string}
+     * @memberof Sandbox
+     */
+    healthReason?: string | null;
+    /**
+     * When the sandbox became degraded, or null.
+     * @type {Date}
+     * @memberof Sandbox
+     */
+    degradedSince?: Date | null;
     /**
      * Current machine size: what the sandbox was created with, or the size it was last resumed or forked onto.
      * @type {SandboxTypeEnum}
@@ -208,6 +226,14 @@ export declare const SandboxStateEnum: {
     readonly Cancelled: 'cancelled';
 };
 export type SandboxStateEnum = typeof SandboxStateEnum[keyof typeof SandboxStateEnum];
+/**
+ * @export
+ */
+export declare const SandboxHealthEnum: {
+    readonly Ok: 'ok';
+    readonly Degraded: 'degraded';
+};
+export type SandboxHealthEnum = typeof SandboxHealthEnum[keyof typeof SandboxHealthEnum];
 /**
  * @export
  */

package/dist/models/Sandbox.js

@@ -13,7 +13,7 @@
  * Do not edit the class manually.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SandboxSetupStatusEnum = exports.SandboxLastSnapshotStatusEnum = exports.SandboxMachineProviderEnum = exports.SandboxTypeEnum = exports.SandboxStateEnum = void 0;
+exports.SandboxSetupStatusEnum = exports.SandboxLastSnapshotStatusEnum = exports.SandboxMachineProviderEnum = exports.SandboxTypeEnum = exports.SandboxHealthEnum = exports.SandboxStateEnum = void 0;
 exports.instanceOfSandbox = instanceOfSandbox;
 exports.SandboxFromJSON = SandboxFromJSON;
 exports.SandboxFromJSONTyped = SandboxFromJSONTyped;
@@ -36,6 +36,13 @@ exports.SandboxStateEnum = {
     Error: 'error',
     Cancelled: 'cancelled'
 };
+/**
+ * @export
+ */
+exports.SandboxHealthEnum = {
+    Ok: 'ok',
+    Degraded: 'degraded'
+};
 /**
  * @export
  */
@@ -98,6 +105,9 @@ function SandboxFromJSONTyped(json, ignoreDiscriminator) {
         'name': json['name'],
         'state': json['state'],
         'error': json['error'] == null ? undefined : json['error'],
+        'health': json['health'] == null ? undefined : json['health'],
+        'healthReason': json['healthReason'] == null ? undefined : json['healthReason'],
+        'degradedSince': json['degradedSince'] == null ? undefined : (new Date(json['degradedSince'])),
         'type': json['type'] == null ? undefined : json['type'],
         'vcpu': json['vcpu'] == null ? undefined : json['vcpu'],
         'memoryGB': json['memoryGB'] == null ? undefined : json['memoryGB'],
@@ -137,6 +147,9 @@ function SandboxToJSONTyped(value, ignoreDiscriminator = false) {
         'name': value['name'],
         'state': value['state'],
         'error': value['error'],
+        'health': value['health'],
+        'healthReason': value['healthReason'],
+        'degradedSince': value['degradedSince'] == null ? value['degradedSince'] : value['degradedSince'].toISOString(),
         'type': value['type'],
         'vcpu': value['vcpu'],
         'memoryGB': value['memoryGB'],

package/dist/models/WebhookEventData.d.ts

@@ -23,17 +23,23 @@ export interface WebhookEventData {
      */
     sandbox: WebhookEventDataSandbox;
     /**
-     *
+     * On sandbox.ready, sandbox.error and sandbox.archived only.
      * @type {string}
      * @memberof WebhookEventData
      */
-    previousState: string;
+    previousState?: string;
     /**
-     *
+     * Absent on sandbox.hydrated.
+     * @type {string}
+     * @memberof WebhookEventData
+     */
+    state?: string;
+    /**
+     * On sandbox.degraded and sandbox.recovered. Why the sandbox is degraded (null on recovered).
      * @type {string}
      * @memberof WebhookEventData
      */
-    state: string;
+    reason?: string | null;
 }
 /**
  * Check if a given object implements the WebhookEventData interface.

package/dist/models/WebhookEventData.js

@@ -25,10 +25,6 @@ const WebhookEventDataSandbox_1 = require("./WebhookEventDataSandbox");
 function instanceOfWebhookEventData(value) {
     if (!('sandbox' in value) || value['sandbox'] === undefined)
         return false;
-    if (!('previousState' in value) || value['previousState'] === undefined)
-        return false;
-    if (!('state' in value) || value['state'] === undefined)
-        return false;
     return true;
 }
 function WebhookEventDataFromJSON(json) {
@@ -40,8 +36,9 @@ function WebhookEventDataFromJSONTyped(json, ignoreDiscriminator) {
     }
     return {
         'sandbox': (0, WebhookEventDataSandbox_1.WebhookEventDataSandboxFromJSON)(json['sandbox']),
-        'previousState': json['previousState'],
-        'state': json['state'],
+        'previousState': json['previousState'] == null ? undefined : json['previousState'],
+        'state': json['state'] == null ? undefined : json['state'],
+        'reason': json['reason'] == null ? undefined : json['reason'],
     };
 }
 function WebhookEventDataToJSON(json) {
@@ -55,5 +52,6 @@ function WebhookEventDataToJSONTyped(value, ignoreDiscriminator = false) {
         'sandbox': (0, WebhookEventDataSandbox_1.WebhookEventDataSandboxToJSON)(value['sandbox']),
         'previousState': value['previousState'],
         'state': value['state'],
+        'reason': value['reason'],
     };
 }

package/dist/models/WebhookEventType.d.ts

@@ -18,6 +18,8 @@ export declare const WebhookEventType: {
     readonly SandboxError: 'sandbox.error';
     readonly SandboxArchived: 'sandbox.archived';
     readonly SandboxHydrated: 'sandbox.hydrated';
+    readonly SandboxDegraded: 'sandbox.degraded';
+    readonly SandboxRecovered: 'sandbox.recovered';
 };
 export type WebhookEventType = typeof WebhookEventType[keyof typeof WebhookEventType];
 export declare function instanceOfWebhookEventType(value: any): boolean;

package/dist/models/WebhookEventType.js

@@ -27,7 +27,9 @@ exports.WebhookEventType = {
     SandboxReady: 'sandbox.ready',
     SandboxError: 'sandbox.error',
     SandboxArchived: 'sandbox.archived',
-    SandboxHydrated: 'sandbox.hydrated'
+    SandboxHydrated: 'sandbox.hydrated',
+    SandboxDegraded: 'sandbox.degraded',
+    SandboxRecovered: 'sandbox.recovered'
 };
 function instanceOfWebhookEventType(value) {
     for (const key in exports.WebhookEventType) {

package/docs/BoatApi.md

@@ -368,7 +368,7 @@ example().catch(console.error);
 
 Execute a command in a sandbox
 
-Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
+Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. A sandbox that is not starting (`error`, `stopped`) returns 409 sandbox_not_ready with `retryable: false` and its `state` at once: resume or recover it first. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
 
 ### Example
 
@@ -672,7 +672,7 @@ example().catch(console.error);
 | **402** | Account cannot currently create or operate sandboxes. The error body may include a dashboard billing URL, but billing actions are not part of the v1 API. |  -  |
 | **409** | Request conflicts with current account or sandbox state. |  -  |
 | **429** | Machine start or concurrent-sandbox limit reached. Create, fork and resume each count as one machine start against your plan\'s start limits (see the Billing guide; `rate_limited`, naming the window you hit). A sandbox that would exceed your plan\'s concurrent-sandbox cap is refused with `limit_reached`, or `member_limit_reached` when an organization owner has capped you below the plan. |  -  |
-| **503** | No capacity. `no_ready_machine`: a `failFast` create found no ready machine of that type; nothing was created, billed, or counted. `out_of_capacity`: creates are paused until the provisioning queue drains. |  -  |
+| **503** | No capacity. `no_ready_machine`: a `failFast` create, fork or resume found no ready machine of that type; nothing was started, billed, or counted, and a resumed sandbox stays stopped. `out_of_capacity`: creates and forks are paused until the provisioning queue drains. |  -  |
 
 [[Back to top]](#) [[Back to API list]](../README.md#api-endpoints) [[Back to Model list]](../README.md#models) [[Back to README]](../README.md)
 
@@ -1898,6 +1898,7 @@ example().catch(console.error);
 | **404** | Resource not found. |  -  |
 | **409** | Request conflicts with current account or sandbox state. |  -  |
 | **429** | Machine start or concurrent-sandbox limit reached. Create, fork and resume each count as one machine start against your plan\'s start limits (see the Billing guide; `rate_limited`, naming the window you hit). A sandbox that would exceed your plan\'s concurrent-sandbox cap is refused with `limit_reached`, or `member_limit_reached` when an organization owner has capped you below the plan. |  -  |
+| **503** | No capacity. `no_ready_machine`: a `failFast` create, fork or resume found no ready machine of that type; nothing was started, billed, or counted, and a resumed sandbox stays stopped. `out_of_capacity`: creates and forks are paused until the provisioning queue drains. |  -  |
 
 [[Back to top]](#) [[Back to API list]](../README.md#api-endpoints) [[Back to Model list]](../README.md#models) [[Back to README]](../README.md)
 
@@ -3597,6 +3598,7 @@ example().catch(console.error);
 | **404** | Resource not found. |  -  |
 | **409** | Request conflicts with current account or sandbox state. |  -  |
 | **429** | Machine start or concurrent-sandbox limit reached. Create, fork and resume each count as one machine start against your plan\'s start limits (see the Billing guide; `rate_limited`, naming the window you hit). A sandbox that would exceed your plan\'s concurrent-sandbox cap is refused with `limit_reached`, or `member_limit_reached` when an organization owner has capped you below the plan. |  -  |
+| **503** | No capacity. `no_ready_machine`: a `failFast` create, fork or resume found no ready machine of that type; nothing was started, billed, or counted, and a resumed sandbox stays stopped. `out_of_capacity`: creates and forks are paused until the provisioning queue drains. |  -  |
 
 [[Back to top]](#) [[Back to API list]](../README.md#api-endpoints) [[Back to Model list]](../README.md#models) [[Back to README]](../README.md)
 

package/docs/ForkRequest.md

@@ -6,6 +6,7 @@
 
 Name | Type
 ------------ | -------------
+`failFast` | boolean
 `env` | { [key: string]: string; }
 `environment` | string
 `noEnv` | boolean
@@ -19,6 +20,7 @@ import type { ForkRequest } from '@boatdev/sdk'
 
 // TODO: Update the object below with actual values
 const example = {
+  "failFast": null,
   "env": null,
   "environment": null,
   "noEnv": null,

package/docs/ResumeRequest.md

@@ -7,6 +7,7 @@ Options for resuming a stopped sandbox.
 
 Name | Type
 ------------ | -------------
+`failFast` | boolean
 `type` | string
 `env` | { [key: string]: string; }
 `environment` | string
@@ -20,6 +21,7 @@ import type { ResumeRequest } from '@boatdev/sdk'
 
 // TODO: Update the object below with actual values
 const example = {
+  "failFast": null,
   "type": null,
   "env": null,
   "environment": null,

package/docs/Sandbox.md

@@ -10,6 +10,9 @@ Name | Type
 `name` | string
 `state` | string
 `error` | string
+`health` | string
+`healthReason` | string
+`degradedSince` | Date
 `type` | string
 `vcpu` | number
 `memoryGB` | number
@@ -47,6 +50,9 @@ const example = {
   "name": null,
   "state": null,
   "error": null,
+  "health": null,
+  "healthReason": null,
+  "degradedSince": null,
   "type": null,
   "vcpu": null,
   "memoryGB": null,

package/docs/WebhookEventData.md

@@ -9,6 +9,7 @@ Name | Type
 `sandbox` | [WebhookEventDataSandbox](WebhookEventDataSandbox.md)
 `previousState` | string
 `state` | string
+`reason` | string
 
 ## Example
 
@@ -20,6 +21,7 @@ const example = {
   "sandbox": null,
   "previousState": null,
   "state": null,
+  "reason": null,
 } satisfies WebhookEventData
 
 console.log(example)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boatdev/sdk",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "OpenAPI client for @boatdev/sdk",
   "author": "OpenAPI-Generator",
   "license": "MIT",

package/src/apis/BoatApi.ts

@@ -984,7 +984,7 @@ export class BoatApi extends runtime.BaseAPI {
     }
 
     /**
-     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
+     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. A sandbox that is not starting (`error`, `stopped`) returns 409 sandbox_not_ready with `retryable: false` and its `state` at once: resume or recover it first. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
      * Execute a command in a sandbox
      */
     async commandRaw(requestParameters: CommandOperationRequest | runtime.FlatBody<CommandOperationRequest, 'commandRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Command200Response>> {
@@ -995,7 +995,7 @@ export class BoatApi extends runtime.BaseAPI {
     }
 
     /**
-     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
+     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. A sandbox that is not starting (`error`, `stopped`) returns 409 sandbox_not_ready with `retryable: false` and its `state` at once: resume or recover it first. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
      * Execute a command in a sandbox
      */
     async command(requestParameters: CommandOperationRequest | runtime.FlatBody<CommandOperationRequest, 'commandRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Command200Response> {

package/src/models/CreateSandboxRequest.ts

@@ -56,7 +56,7 @@ export interface CreateSandboxRequest {
      */
     snapshots?: boolean;
     /**
-     * Pass `true` to get a sandbox only if a machine of this type is ready right now. The call answers within about 1.5 s: either the usual `202` with the sandbox, or `503` `no_ready_machine` with nothing created, billed, or counted against your start limits, so you can retry or fall back at once. Without it, a create waits for a machine to be built when none is ready. Not combinable with `from`.
+     * Pass `true` to get a sandbox only if a machine of this type is ready right now. The call answers within about 1.5 s: either the usual `202` with the sandbox, or `503` `no_ready_machine` with nothing created, billed, or counted against your start limits, so you can retry or fall back at once. Without it, a create waits for a machine to be built when none is ready. Works with `from`; fork and resume take it too.
      * @type {boolean}
      * @memberof CreateSandboxRequest
      */

package/src/models/ForkRequest.ts

@@ -19,6 +19,12 @@ import { mapValues } from '../runtime';
  * @interface ForkRequest
  */
 export interface ForkRequest {
+    /**
+     * Pass `true` to fork only if a machine is ready right now. Within about 1.5 s you get the usual `202`, or `503` `no_ready_machine` with no fork created and nothing counted against your start limits.
+     * @type {boolean}
+     * @memberof ForkRequest
+     */
+    failFast?: boolean;
     /**
      * Replaces the env the fork would otherwise inherit from the source sandbox. Same validation rules as `CreateSandboxRequest.env`.
      * @type {{ [key: string]: string; }}
@@ -80,6 +86,7 @@ export function ForkRequestFromJSONTyped(json: any, ignoreDiscriminator: boolean
     }
     return {
         
+        'failFast': json['failFast'] == null ? undefined : json['failFast'],
         'env': json['env'] == null ? undefined : json['env'],
         'environment': json['environment'] == null ? undefined : json['environment'],
         'noEnv': json['noEnv'] == null ? undefined : json['noEnv'],
@@ -99,6 +106,7 @@ export function ForkRequestToJSONTyped(value?: ForkRequest | null, ignoreDiscrim
 
     return {
         
+        'failFast': value['failFast'],
         'env': value['env'],
         'environment': value['environment'],
         'noEnv': value['noEnv'],

package/src/models/ResumeRequest.ts

@@ -19,6 +19,12 @@ import { mapValues } from '../runtime';
  * @interface ResumeRequest
  */
 export interface ResumeRequest {
+    /**
+     * Pass `true` to resume only if a machine is ready right now. Within about 1.5 s you get the usual `202`, or `503` `no_ready_machine` with the sandbox left stopped and nothing counted against your start limits.
+     * @type {boolean}
+     * @memberof ResumeRequest
+     */
+    failFast?: boolean;
     /**
      * Resume onto a different machine size. Omit to keep the sandbox's current type. A resume already restores onto a fresh machine, so changing size costs nothing extra. Shrinking is rejected with `type_too_small` when the sandbox's data would not fit the smaller disk.
      * @type {ResumeRequestTypeEnum}
@@ -80,6 +86,7 @@ export function ResumeRequestFromJSONTyped(json: any, ignoreDiscriminator: boole
     }
     return {
         
+        'failFast': json['failFast'] == null ? undefined : json['failFast'],
         'type': json['type'] == null ? undefined : json['type'],
         'env': json['env'] == null ? undefined : json['env'],
         'environment': json['environment'] == null ? undefined : json['environment'],
@@ -99,6 +106,7 @@ export function ResumeRequestToJSONTyped(value?: ResumeRequest | null, ignoreDis
 
     return {
         
+        'failFast': value['failFast'],
         'type': value['type'],
         'env': value['env'],
         'environment': value['environment'],

package/src/models/Sandbox.ts

@@ -51,6 +51,24 @@ export interface Sandbox {
      * @memberof Sandbox
      */
     error?: string | null;
+    /**
+     * `degraded` when the machine is alive but Boat cannot fully reach it (for example a firewall rule inside the sandbox blocks the tunnel). The sandbox keeps running.
+     * @type {SandboxHealthEnum}
+     * @memberof Sandbox
+     */
+    health?: SandboxHealthEnum;
+    /**
+     * Why the sandbox is degraded, or null.
+     * @type {string}
+     * @memberof Sandbox
+     */
+    healthReason?: string | null;
+    /**
+     * When the sandbox became degraded, or null.
+     * @type {Date}
+     * @memberof Sandbox
+     */
+    degradedSince?: Date | null;
     /**
      * Current machine size: what the sandbox was created with, or the size it was last resumed or forked onto.
      * @type {SandboxTypeEnum}
@@ -222,6 +240,15 @@ export const SandboxStateEnum = {
 } as const;
 export type SandboxStateEnum = typeof SandboxStateEnum[keyof typeof SandboxStateEnum];
 
+/**
+ * @export
+ */
+export const SandboxHealthEnum = {
+    Ok: 'ok',
+    Degraded: 'degraded'
+} as const;
+export type SandboxHealthEnum = typeof SandboxHealthEnum[keyof typeof SandboxHealthEnum];
+
 /**
  * @export
  */
@@ -291,6 +318,9 @@ export function SandboxFromJSONTyped(json: any, ignoreDiscriminator: boolean): S
         'name': json['name'],
         'state': json['state'],
         'error': json['error'] == null ? undefined : json['error'],
+        'health': json['health'] == null ? undefined : json['health'],
+        'healthReason': json['healthReason'] == null ? undefined : json['healthReason'],
+        'degradedSince': json['degradedSince'] == null ? undefined : (new Date(json['degradedSince'])),
         'type': json['type'] == null ? undefined : json['type'],
         'vcpu': json['vcpu'] == null ? undefined : json['vcpu'],
         'memoryGB': json['memoryGB'] == null ? undefined : json['memoryGB'],
@@ -334,6 +364,9 @@ export function SandboxToJSONTyped(value?: Sandbox | null, ignoreDiscriminator:
         'name': value['name'],
         'state': value['state'],
         'error': value['error'],
+        'health': value['health'],
+        'healthReason': value['healthReason'],
+        'degradedSince': value['degradedSince'] == null ? value['degradedSince'] : value['degradedSince'].toISOString(),
         'type': value['type'],
         'vcpu': value['vcpu'],
         'memoryGB': value['memoryGB'],

package/src/models/WebhookEventData.ts

@@ -34,17 +34,23 @@ export interface WebhookEventData {
      */
     sandbox: WebhookEventDataSandbox;
     /**
-     * 
+     * On sandbox.ready, sandbox.error and sandbox.archived only.
      * @type {string}
      * @memberof WebhookEventData
      */
-    previousState: string;
+    previousState?: string;
     /**
-     * 
+     * Absent on sandbox.hydrated.
+     * @type {string}
+     * @memberof WebhookEventData
+     */
+    state?: string;
+    /**
+     * On sandbox.degraded and sandbox.recovered. Why the sandbox is degraded (null on recovered).
      * @type {string}
      * @memberof WebhookEventData
      */
-    state: string;
+    reason?: string | null;
 }
 
 /**
@@ -52,8 +58,6 @@ export interface WebhookEventData {
  */
 export function instanceOfWebhookEventData(value: object): value is WebhookEventData {
     if (!('sandbox' in value) || value['sandbox'] === undefined) return false;
-    if (!('previousState' in value) || value['previousState'] === undefined) return false;
-    if (!('state' in value) || value['state'] === undefined) return false;
     return true;
 }
 
@@ -68,8 +72,9 @@ export function WebhookEventDataFromJSONTyped(json: any, ignoreDiscriminator: bo
     return {
         
         'sandbox': WebhookEventDataSandboxFromJSON(json['sandbox']),
-        'previousState': json['previousState'],
-        'state': json['state'],
+        'previousState': json['previousState'] == null ? undefined : json['previousState'],
+        'state': json['state'] == null ? undefined : json['state'],
+        'reason': json['reason'] == null ? undefined : json['reason'],
     };
 }
 
@@ -87,6 +92,7 @@ export function WebhookEventDataToJSONTyped(value?: WebhookEventData | null, ign
         'sandbox': WebhookEventDataSandboxToJSON(value['sandbox']),
         'previousState': value['previousState'],
         'state': value['state'],
+        'reason': value['reason'],
     };
 }
 

package/src/models/WebhookEventType.ts

@@ -21,7 +21,9 @@ export const WebhookEventType = {
     SandboxReady: 'sandbox.ready',
     SandboxError: 'sandbox.error',
     SandboxArchived: 'sandbox.archived',
-    SandboxHydrated: 'sandbox.hydrated'
+    SandboxHydrated: 'sandbox.hydrated',
+    SandboxDegraded: 'sandbox.degraded',
+    SandboxRecovered: 'sandbox.recovered'
 } as const;
 export type WebhookEventType = typeof WebhookEventType[keyof typeof WebhookEventType];