@boatdev/sdk 1.7.0 → 1.8.0

package/src/apis/BoatApi.ts

@@ -228,6 +228,11 @@ import {
     PromptRunResponseFromJSON,
     PromptRunResponseToJSON,
 } from '../models/PromptRunResponse';
+import {
+    type Recover200Response,
+    Recover200ResponseFromJSON,
+    Recover200ResponseToJSON,
+} from '../models/Recover200Response';
 import {
     type RepoSelectionRequest,
     RepoSelectionRequestFromJSON,
@@ -348,6 +353,11 @@ import {
     SteerResponseFromJSON,
     SteerResponseToJSON,
 } from '../models/SteerResponse';
+import {
+    type StopOperationResponse,
+    StopOperationResponseFromJSON,
+    StopOperationResponseToJSON,
+} from '../models/StopOperationResponse';
 import {
     type StopRequest,
     StopRequestFromJSON,
@@ -545,6 +555,11 @@ export interface GetSnapshotTreeRequest {
     snapshotId: string;
 }
 
+export interface GetStopRequest {
+    sandboxId: string;
+    stopId: string;
+}
+
 export interface GetWebhookRequest {
     webhookId: string;
 }
@@ -594,6 +609,10 @@ export interface ReadFileRequest {
     encoding?: ReadFileEncodingEnum;
 }
 
+export interface RecoverRequest {
+    sandboxId: string;
+}
+
 export interface ReposRequest {
     sync?: boolean;
     limit?: number;
@@ -931,6 +950,7 @@ export class BoatApi extends runtime.BaseAPI {
     }
 
     /**
+     * Downloads one file of up to 50 MiB, under /home/user or /tmp, as raw bytes.
      * Download a sandbox artifact
      */
     async artifactRaw(requestParameters: ArtifactRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Blob>> {
@@ -941,6 +961,7 @@ export class BoatApi extends runtime.BaseAPI {
     }
 
     /**
+     * Downloads one file of up to 50 MiB, under /home/user or /tmp, as raw bytes.
      * Download a sandbox artifact
      */
     async artifact(requestParameters: ArtifactRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Blob> {
@@ -2612,6 +2633,69 @@ export class BoatApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Creates request options for getStop without sending the request
+     */
+    async getStopRequestOpts(requestParameters: GetStopRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['sandboxId'] == null) {
+            throw new runtime.RequiredError(
+                'sandboxId',
+                'Required parameter "sandboxId" was null or undefined when calling getStop().'
+            );
+        }
+
+        if (requestParameters['stopId'] == null) {
+            throw new runtime.RequiredError(
+                'stopId',
+                'Required parameter "stopId" was null or undefined when calling getStop().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("BoatBearerAuth", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+
+        let urlPath = `/sandboxes/{sandboxId}/stops/{stopId}`;
+        urlPath = urlPath.replace('{sandboxId}', encodeURIComponent(String(requestParameters['sandboxId'])));
+        urlPath = urlPath.replace('{stopId}', encodeURIComponent(String(requestParameters['stopId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Returns one stop of this sandbox by the id that `POST /sandboxes/{sandboxId}/stop` returned. Old stops stay readable after a resume or a later stop. Returns 404 when the id is unknown or belongs to another sandbox.
+     * Get a stop by id
+     */
+    async getStopRaw(requestParameters: GetStopRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<StopOperationResponse>> {
+        const requestOptions = await this.getStopRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => StopOperationResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Returns one stop of this sandbox by the id that `POST /sandboxes/{sandboxId}/stop` returned. Old stops stay readable after a resume or a later stop. Returns 404 when the id is unknown or belongs to another sandbox.
+     * Get a stop by id
+     */
+    async getStop(requestParameters: GetStopRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<StopOperationResponse> {
+        const response = await this.getStopRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for getWebhook without sending the request
      */
@@ -3345,6 +3429,7 @@ export class BoatApi extends runtime.BaseAPI {
     }
 
     /**
+     * Files up to 5 MiB. Use `GET /sandboxes/{sandboxId}/artifacts` for files up to 50 MiB, and SCP over SSH for larger ones.
      * Read a file from a sandbox
      */
     async readFileRaw(requestParameters: ReadFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FileReadResponse>> {
@@ -3355,6 +3440,7 @@ export class BoatApi extends runtime.BaseAPI {
     }
 
     /**
+     * Files up to 5 MiB. Use `GET /sandboxes/{sandboxId}/artifacts` for files up to 50 MiB, and SCP over SSH for larger ones.
      * Read a file from a sandbox
      */
     async readFile(requestParameters: ReadFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FileReadResponse> {
@@ -3362,6 +3448,61 @@ export class BoatApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Creates request options for recover without sending the request
+     */
+    async recoverRequestOpts(requestParameters: RecoverRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['sandboxId'] == null) {
+            throw new runtime.RequiredError(
+                'sandboxId',
+                'Required parameter "sandboxId" was null or undefined when calling recover().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("BoatBearerAuth", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+
+        let urlPath = `/sandboxes/{sandboxId}/recover`;
+        urlPath = urlPath.replace('{sandboxId}', encodeURIComponent(String(requestParameters['sandboxId'])));
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Power-cycle the machine of a sandbox that stopped answering. The disk is not touched. The sandbox usually answers again within 1-2 minutes and then saves your work by itself; `sandbox.recovered` fires when it does.  Refused with `409`: - `sandbox_is_reachable`: the sandbox answers normally. - `too_soon`: a recover started less than 10 minutes ago. - `no_machine`: the sandbox has no machine. Resume it instead. - `recover_unsupported`: its machine cannot be power-cycled. Wait for it to   answer, or resume it from its last snapshot. - `reset_failed`: the power-cycle failed. Reply to the incident email. 
+     * Recover a sandbox that stopped responding
+     */
+    async recoverRaw(requestParameters: RecoverRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Recover200Response>> {
+        const requestOptions = await this.recoverRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => Recover200ResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Power-cycle the machine of a sandbox that stopped answering. The disk is not touched. The sandbox usually answers again within 1-2 minutes and then saves your work by itself; `sandbox.recovered` fires when it does.  Refused with `409`: - `sandbox_is_reachable`: the sandbox answers normally. - `too_soon`: a recover started less than 10 minutes ago. - `no_machine`: the sandbox has no machine. Resume it instead. - `recover_unsupported`: its machine cannot be power-cycled. Wait for it to   answer, or resume it from its last snapshot. - `reset_failed`: the power-cycle failed. Reply to the incident email. 
+     * Recover a sandbox that stopped responding
+     */
+    async recover(requestParameters: RecoverRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Recover200Response> {
+        const response = await this.recoverRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for repos without sending the request
      */
@@ -4259,7 +4400,7 @@ export class BoatApi extends runtime.BaseAPI {
     }
 
     /**
-     * Send a new message to a turn that is already running, without losing what the agent is doing. This is what typing into a coding agent while it works does: the instruction is taken into account and the work continues.  Where the harness has a native mid-turn primitive (Claude Code, Codex, pi, Prime Agent) nothing is interrupted and the response has `native: true`. Where it does not (OpenCode), Boat interrupts that turn and immediately continues the SAME conversation with the instruction, keeping the session and its memory, and the response has `native: false`.  Refused with **409 `no_running_turn`** when the conversation has nothing in flight; queue work with `POST /prompt` instead. The steer shows up in `GET /events` as a `steer` event. See [Integrated agents](/integrated-agents).
+     * Send a new message to a turn that is already running, without losing what the agent is doing. This is what typing into a coding agent while it works does: the instruction is taken into account and the work continues.  Where the harness has a native mid-turn primitive (Claude Code, Codex, pi, Prime Agent) nothing is interrupted and the response has `native: true`. Where it does not (OpenCode), Boat interrupts that turn and immediately continues the SAME conversation with the instruction, keeping the session and its memory, and the response has `native: false`.  Refused with **409 `no_running_turn`** when the conversation has nothing in flight; queue work with `POST /prompt` instead. `error.details.reason` says why: `turn_ended` (with `error.details.lastTurn.status` and `.error` of the newest turn), `turn_not_started` (the turn is starting; retry in a moment), `no_turn`, `not_running` (the sandbox is not running) or `delivery_failed` (the sandbox did not accept the steer; check the turn before sending more work). The steer shows up in `GET /events` as a `steer` event. See [Integrated agents](/integrated-agents).
      * Steer a running turn
      */
     async steerRaw(requestParameters: SteerOperationRequest | runtime.FlatBody<SteerOperationRequest, 'steerRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SteerResponse>> {
@@ -4270,7 +4411,7 @@ export class BoatApi extends runtime.BaseAPI {
     }
 
     /**
-     * Send a new message to a turn that is already running, without losing what the agent is doing. This is what typing into a coding agent while it works does: the instruction is taken into account and the work continues.  Where the harness has a native mid-turn primitive (Claude Code, Codex, pi, Prime Agent) nothing is interrupted and the response has `native: true`. Where it does not (OpenCode), Boat interrupts that turn and immediately continues the SAME conversation with the instruction, keeping the session and its memory, and the response has `native: false`.  Refused with **409 `no_running_turn`** when the conversation has nothing in flight; queue work with `POST /prompt` instead. The steer shows up in `GET /events` as a `steer` event. See [Integrated agents](/integrated-agents).
+     * Send a new message to a turn that is already running, without losing what the agent is doing. This is what typing into a coding agent while it works does: the instruction is taken into account and the work continues.  Where the harness has a native mid-turn primitive (Claude Code, Codex, pi, Prime Agent) nothing is interrupted and the response has `native: true`. Where it does not (OpenCode), Boat interrupts that turn and immediately continues the SAME conversation with the instruction, keeping the session and its memory, and the response has `native: false`.  Refused with **409 `no_running_turn`** when the conversation has nothing in flight; queue work with `POST /prompt` instead. `error.details.reason` says why: `turn_ended` (with `error.details.lastTurn.status` and `.error` of the newest turn), `turn_not_started` (the turn is starting; retry in a moment), `no_turn`, `not_running` (the sandbox is not running) or `delivery_failed` (the sandbox did not accept the steer; check the turn before sending more work). The steer shows up in `GET /events` as a `steer` event. See [Integrated agents](/integrated-agents).
      * Steer a running turn
      */
     async steer(requestParameters: SteerOperationRequest | runtime.FlatBody<SteerOperationRequest, 'steerRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SteerResponse> {
@@ -4318,7 +4459,7 @@ export class BoatApi extends runtime.BaseAPI {
     }
 
     /**
-     * Stop active work and archive/snapshot the sandbox for later resume or fork.  A stop always saves the sandbox\'s disk first. If that save is failing, the stop is refused and the sandbox keeps running so your work is not discarded, we retry automatically and email you. You are not billed for time spent in that state.  The stop is an operation: the response and the sandbox carry it as `stop`, with an `id` and a `status`. Poll `GET /sandboxes/{sandboxId}` until `stop.status` is `completed`. A failed attempt shows `failing` with its `error` and is retried until the sandbox archives; commands and prompts you send meanwhile do not cancel it. Only a resume ends it early (`superseded`). Calling stop again while one is pending returns the same `id`.  Set `force: true` to stop anyway, accepting the loss of everything written since the last successful snapshot. This is irreversible; only reach for it after a stop has already failed. 
+     * Stop active work and archive/snapshot the sandbox for later resume or fork.  A stop always saves the sandbox\'s disk first. If that save is failing, the stop is refused and the sandbox keeps running so your work is not discarded, we retry automatically and email you. You are not billed for time spent in that state.  The stop is an operation: the response and the sandbox carry it as `stop`, with an `id` and a `status`. Poll `GET /sandboxes/{sandboxId}` until `stop.status` is `completed`. A failed attempt shows `failing` with its `error` and is retried until the sandbox archives; commands and prompts you send meanwhile do not cancel it. Only a resume ends it early (`superseded`). Calling stop again while one is pending returns the same `id`.  Set `force: true` to stop anyway, keeping the last successful snapshot and losing everything written since then. This is irreversible; only reach for it after a stop has already failed. A force on a stop that is already pending escalates that stop. 
      * Stop and archive sandbox
      */
     async stopRaw(requestParameters: StopOperationRequest | runtime.FlatBody<StopOperationRequest, 'stopRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SandboxActionResponse>> {
@@ -4329,7 +4470,7 @@ export class BoatApi extends runtime.BaseAPI {
     }
 
     /**
-     * Stop active work and archive/snapshot the sandbox for later resume or fork.  A stop always saves the sandbox\'s disk first. If that save is failing, the stop is refused and the sandbox keeps running so your work is not discarded, we retry automatically and email you. You are not billed for time spent in that state.  The stop is an operation: the response and the sandbox carry it as `stop`, with an `id` and a `status`. Poll `GET /sandboxes/{sandboxId}` until `stop.status` is `completed`. A failed attempt shows `failing` with its `error` and is retried until the sandbox archives; commands and prompts you send meanwhile do not cancel it. Only a resume ends it early (`superseded`). Calling stop again while one is pending returns the same `id`.  Set `force: true` to stop anyway, accepting the loss of everything written since the last successful snapshot. This is irreversible; only reach for it after a stop has already failed. 
+     * Stop active work and archive/snapshot the sandbox for later resume or fork.  A stop always saves the sandbox\'s disk first. If that save is failing, the stop is refused and the sandbox keeps running so your work is not discarded, we retry automatically and email you. You are not billed for time spent in that state.  The stop is an operation: the response and the sandbox carry it as `stop`, with an `id` and a `status`. Poll `GET /sandboxes/{sandboxId}` until `stop.status` is `completed`. A failed attempt shows `failing` with its `error` and is retried until the sandbox archives; commands and prompts you send meanwhile do not cancel it. Only a resume ends it early (`superseded`). Calling stop again while one is pending returns the same `id`.  Set `force: true` to stop anyway, keeping the last successful snapshot and losing everything written since then. This is irreversible; only reach for it after a stop has already failed. A force on a stop that is already pending escalates that stop. 
      * Stop and archive sandbox
      */
     async stop(requestParameters: StopOperationRequest | runtime.FlatBody<StopOperationRequest, 'stopRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SandboxActionResponse> {
@@ -4816,6 +4957,7 @@ export class BoatApi extends runtime.BaseAPI {
     }
 
     /**
+     * Files up to 5 MiB after decoding. Use SCP over SSH for larger files.
      * Write a file in a sandbox
      */
     async writeFileRaw(requestParameters: WriteFileRequest | runtime.FlatBody<WriteFileRequest, 'fileWriteRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FileWriteResponse>> {
@@ -4826,6 +4968,7 @@ export class BoatApi extends runtime.BaseAPI {
     }
 
     /**
+     * Files up to 5 MiB after decoding. Use SCP over SSH for larger files.
      * Write a file in a sandbox
      */
     async writeFile(requestParameters: WriteFileRequest | runtime.FlatBody<WriteFileRequest, 'fileWriteRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FileWriteResponse> {

package/src/http2-fetch.ts

@@ -0,0 +1,179 @@
+// The SDK's default fetch. On Node it sends every request to an https origin over
+// ONE shared HTTP/2 connection. Node's global fetch speaks HTTP/1.1 only, so N
+// concurrent calls opened N TLS connections: a burst of 200 calls from a laptop
+// made 200 handshakes (measured 2026-10-08), and 250 creates arrived at the API
+// over 8-14 s. Elsewhere (browsers, Deno, Bun, an origin without HTTP/2), and for
+// any body this does not handle, it is the global fetch.
+// Pass `fetchApi` in the Configuration to use your own fetch instead.
+
+type Session = {
+  closed: boolean;
+  destroyed: boolean;
+  request(headers: Record<string, string>, options?: { endStream?: boolean }): any;
+  on(event: string, cb: (...args: any[]) => void): void;
+  unref(): void;
+  ref(): void;
+};
+
+const sessions = new Map<string, Promise<Session | null>>();
+const http1Only = new Set<string>();
+const slots = new WeakMap<Session, { active: number; waiting: Array<() => void> }>();
+
+// A server caps the streams open at once on a connection (boat.dev: 250; this uses
+// at most 100). A stream past the cap is refused, so the excess waits here. Requests open
+// or waiting keep the process alive; an idle shared connection does not.
+async function streamSlot(s: Session, signal?: AbortSignal | null): Promise<() => void> {
+  let st = slots.get(s);
+  if (!st) { st = { active: 0, waiting: [] }; slots.set(s, st); }
+  const state = st;
+  const cap = Math.max(1, Math.min(Number((s as any).remoteSettings?.maxConcurrentStreams) || 100, 100));
+  // Already aborted: take no stream, never queue (an abort listener added now never fires).
+  if (signal?.aborted) return () => {};
+  if (state.active === 0 && state.waiting.length === 0) s.ref();
+  if (state.active >= cap) {
+    const turn = await new Promise<boolean>((wake) => {
+      const w = () => wake(true);
+      state.waiting.push(w);
+      // An aborted waiter leaves the queue without a stream; the caller rejects it.
+      signal?.addEventListener('abort', () => {
+        const i = state.waiting.indexOf(w);
+        if (i !== -1) { state.waiting.splice(i, 1); wake(false); }
+      }, { once: true });
+    });
+    if (!turn) return () => {};
+  }
+  state.active++;
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    state.active--;
+    const next = state.waiting.shift();
+    if (next) next();
+    else if (state.active === 0) s.unref();
+  };
+}
+let nodeHttp2: Promise<any | null> | undefined;
+
+function loadNode(): Promise<any | null> {
+  if (!nodeHttp2) {
+    const versions = (globalThis as any).process?.versions;
+    const isNode = !!versions?.node && !versions.bun && typeof (globalThis as any).Deno === 'undefined';
+    // A variable, not a literal: a browser bundler must not try to resolve it.
+    const h2 = 'node:http2';
+    nodeHttp2 = isNode
+      ? import(/* webpackIgnore: true */ /* @vite-ignore */ h2).catch(() => null)
+      : Promise.resolve(null);
+  }
+  return nodeHttp2;
+}
+
+function session(origin: string, http2: any): Promise<Session | null> {
+  const open = sessions.get(origin);
+  if (open) return open;
+  const pending = new Promise<Session | null>((resolve) => {
+    let s: any;
+    try {
+      s = http2.connect(origin);
+    } catch {
+      resolve(null);
+      return;
+    }
+    const drop = () => { if (sessions.get(origin) === pending) sessions.delete(origin); };
+    s.once('connect', () => {
+      // An origin that answered without h2 never gets here: the TLS layer fails the connect.
+      s.unref(); // an idle shared connection must not keep the process alive
+      resolve(s);
+    });
+    // `on`, not `once`: a session can emit more than one error, and an unhandled one kills the process.
+    s.on('error', () => { drop(); resolve(null); });
+    s.once('close', drop);
+    s.once('goaway', drop);
+  });
+  sessions.set(origin, pending);
+  return pending;
+}
+
+function sendableBody(body: unknown): string | Uint8Array | null | undefined {
+  if (body == null) return null;
+  if (typeof body === 'string') return body;
+  if (body instanceof Uint8Array) return body;
+  if (body instanceof ArrayBuffer) return new Uint8Array(body);
+  if (typeof URLSearchParams !== 'undefined' && body instanceof URLSearchParams) return body.toString();
+  return undefined; // FormData, Blob, streams: the global fetch encodes these
+}
+
+const HOP_BY_HOP = new Set(['connection', 'host', 'keep-alive', 'proxy-connection', 'transfer-encoding', 'upgrade']);
+
+async function http2Fetch(input: RequestInfo | URL, init: RequestInit = {}): Promise<Response> {
+    const url = new URL(typeof input === 'string' ? input : input instanceof URL ? input.href : input.url);
+    const body = sendableBody(init.body);
+    const node = await loadNode();
+    const isRequest = typeof input !== 'string' && !(input instanceof URL);
+    if (!node || isRequest || body === undefined || url.protocol !== 'https:' || http1Only.has(url.origin)) {
+      return fetch(input as any, init);
+    }
+    const s = await session(url.origin, node);
+    if (!s || s.closed || s.destroyed) {
+      if (!s) http1Only.add(url.origin);
+      return fetch(input as any, init);
+    }
+    const headers: Record<string, string> = { ':method': (init.method || 'GET').toUpperCase(), ':path': url.pathname + url.search };
+    new Headers(init.headers).forEach((value, key) => { if (!HOP_BY_HOP.has(key)) headers[key] = value; });
+    const signal = init.signal;
+    const aborted = () => signal!.reason ?? new DOMException('This operation was aborted', 'AbortError');
+    const release = await streamSlot(s, signal);
+    return new Promise<Response>((resolve, reject) => {
+      if (signal?.aborted) { release(); reject(aborted()); return; }
+      let req: any;
+      try {
+        req = s.request(headers, { endStream: body === null });
+      } catch (e) {
+        // The connection closed (GOAWAY) while this call waited for a stream.
+        release();
+        reject(e);
+        return;
+      }
+      const onAbort = () => { req.close(); reject(aborted()); };
+      signal?.addEventListener('abort', onAbort, { once: true });
+      req.once('close', () => { release(); signal?.removeEventListener('abort', onAbort); });
+      req.on('error', reject); // after the response this errors its body stream; a no-op here
+      req.once('response', (h: Record<string, string | string[]>) => {
+        const status = Number(h[':status']);
+        const out = new Headers();
+        for (const [k, v] of Object.entries(h)) {
+          if (k.startsWith(':') || v === undefined) continue;
+          for (const one of Array.isArray(v) ? v : [v]) out.append(k, String(one));
+        }
+        const empty = status === 204 || status === 205 || status === 304 || headers[':method'] === 'HEAD';
+        if (empty) req.resume();
+        // Fed from 'data' events, not Readable.toWeb: an HTTP/2 stream the server has
+        // already closed is destroyed with its unread data, and toWeb's backpressure
+        // turned that into "Premature close" on 25 of 250 calls (prod, 2026-10-08).
+        // A slow reader (streamCommand between frames) must not let a fast command
+        // fill memory: past 4 MiB unread the stream pauses until the reader pulls.
+        const bodyStream = empty ? null : new ReadableStream<Uint8Array>({
+          start(controller) {
+            req.on('data', (chunk: Uint8Array) => {
+              controller.enqueue(new Uint8Array(chunk));
+              if ((controller.desiredSize ?? 1) <= 0) req.pause();
+            });
+            req.once('end', () => controller.close());
+            req.once('error', (e: unknown) => controller.error(e));
+            req.once('close', () => {
+              if (!req.readableEnded) { try { controller.error(new Error(`HTTP/2 stream closed before its end (code ${req.rstCode})`)); } catch {} }
+            });
+          },
+          pull() { if (req.isPaused()) req.resume(); },
+          cancel() { req.close(); },
+        }, { highWaterMark: 4 * 1024 * 1024, size: (chunk) => chunk?.byteLength ?? 0 });
+        const response = new Response(bodyStream, { status, headers: out });
+        // Response.url is read-only; the generated client never reads it, but keep it right.
+        Object.defineProperty(response, 'url', { value: url.href });
+        resolve(response);
+      });
+      if (body !== null) req.end(body);
+    });
+}
+
+export const defaultFetch = http2Fetch as typeof fetch;

package/src/models/CreateSandboxRequest.ts

@@ -20,7 +20,7 @@ import { mapValues } from '../runtime';
  */
 export interface CreateSandboxRequest {
     /**
-     * Machine size. `small` consumes machine time at half rate and `large` at twice the default rate (see the Billing guide). A fork inherits the source sandbox's type unless the fork request passes its own, and resume and fork can move a sandbox between sizes.
+     * Machine size. `small` consumes machine time at half rate and `large` at twice the default rate (see the Billing guide). `xlarge` needs the $100/month plan or higher; lower plans get a 403 `machine_class_plan_required` on create, resume and fork. A fork inherits the source sandbox's type unless the fork request passes its own, and resume and fork can move a sandbox between sizes.
      * @type {CreateSandboxRequestTypeEnum}
      * @memberof CreateSandboxRequest
      */
@@ -62,7 +62,7 @@ export interface CreateSandboxRequest {
      */
     failFast?: boolean;
     /**
-     * Shell script that runs on the sandbox after it is ready. Ready means "ready to accept the user", not "setup done": the script starts in the background once provisioning completes and never blocks the sandbox becoming usable. It runs as the sandbox user via `bash`, with the sandbox's environment applied, and its output goes to a log file on the sandbox. Observe the outcome as `setupStatus` (pending/running/done/failed) and `setupError` on the sandbox. Rejected with a 400 `invalid_setup_script` error when it is not a string or exceeds 64KB.
+     * Shell script that runs on the sandbox after it is ready. Ready means "ready to accept the user", not "setup done": the script starts in the background once provisioning completes and never blocks the sandbox becoming usable. It runs as the sandbox user (`user`, not root; `sudo` needs no password) via `bash`, with the sandbox's environment applied, and its output goes to a log file on the sandbox. Observe the outcome as `setupStatus` (pending/running/done/failed) and `setupError` on the sandbox. Rejected with a 400 `invalid_setup_script` error when it is not a string or exceeds 64KB.
      * @type {string}
      * @memberof CreateSandboxRequest
      */
@@ -94,7 +94,8 @@ export interface CreateSandboxRequest {
 export const CreateSandboxRequestTypeEnum = {
     Small: 'small',
     Default: 'default',
-    Large: 'large'
+    Large: 'large',
+    Xlarge: 'xlarge'
 } as const;
 export type CreateSandboxRequestTypeEnum = typeof CreateSandboxRequestTypeEnum[keyof typeof CreateSandboxRequestTypeEnum];
 

package/src/models/ForkRequest.ts

@@ -44,7 +44,7 @@ export interface ForkRequest {
      */
     noEnv?: boolean;
     /**
-     * Machine size for the fork. Omit to inherit the source sandbox's type. The source sandbox is never modified. Shrinking is rejected with `type_too_small` when the source's data would not fit the smaller disk.
+     * Machine size for the fork. Omit to inherit the source sandbox's type. `xlarge` needs the $100/month plan or higher (403 `machine_class_plan_required`). The source sandbox is never modified. Shrinking is rejected with `type_too_small` when the source's data would not fit the smaller disk.
      * @type {ForkRequestTypeEnum}
      * @memberof ForkRequest
      */
@@ -64,7 +64,8 @@ export interface ForkRequest {
 export const ForkRequestTypeEnum = {
     Small: 'small',
     Default: 'default',
-    Large: 'large'
+    Large: 'large',
+    Xlarge: 'xlarge'
 } as const;
 export type ForkRequestTypeEnum = typeof ForkRequestTypeEnum[keyof typeof ForkRequestTypeEnum];
 

package/src/models/Recover200Response.ts

@@ -0,0 +1,99 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Boat Public API v1
+ * Public JSON API for creating, operating, prompting, observing, and exposing sandboxes from backend services, CI jobs, hosted workers, and Boat automation products.  The v1 reference intentionally documents the developer integration surface only. Dashboard billing actions are not part of v1. 
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface Recover200Response
+ */
+export interface Recover200Response {
+    /**
+     * 
+     * @type {boolean}
+     * @memberof Recover200Response
+     */
+    ok?: boolean;
+    /**
+     * 
+     * @type {string}
+     * @memberof Recover200Response
+     */
+    type?: string;
+    /**
+     * 
+     * @type {Recover200ResponseStatusEnum}
+     * @memberof Recover200Response
+     */
+    status?: Recover200ResponseStatusEnum;
+    /**
+     * 
+     * @type {string}
+     * @memberof Recover200Response
+     */
+    message?: string;
+}
+
+
+/**
+ * @export
+ */
+export const Recover200ResponseStatusEnum = {
+    Recovering: 'recovering'
+} as const;
+export type Recover200ResponseStatusEnum = typeof Recover200ResponseStatusEnum[keyof typeof Recover200ResponseStatusEnum];
+
+
+/**
+ * Check if a given object implements the Recover200Response interface.
+ */
+export function instanceOfRecover200Response(value: object): value is Recover200Response {
+    return true;
+}
+
+export function Recover200ResponseFromJSON(json: any): Recover200Response {
+    return Recover200ResponseFromJSONTyped(json, false);
+}
+
+export function Recover200ResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): Recover200Response {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'ok': json['ok'] == null ? undefined : json['ok'],
+        'type': json['type'] == null ? undefined : json['type'],
+        'status': json['status'] == null ? undefined : json['status'],
+        'message': json['message'] == null ? undefined : json['message'],
+    };
+}
+
+export function Recover200ResponseToJSON(json: any): Recover200Response {
+    return Recover200ResponseToJSONTyped(json, false);
+}
+
+export function Recover200ResponseToJSONTyped(value?: Recover200Response | null, ignoreDiscriminator: boolean = false): any {
+    if (value == null) {
+        return value;
+    }
+
+    return {
+        
+        'ok': value['ok'],
+        'type': value['type'],
+        'status': value['status'],
+        'message': value['message'],
+    };
+}
+

package/src/models/ResumeRequest.ts

@@ -26,7 +26,7 @@ export interface 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.
+     * Resume onto a different machine size. Omit to keep the sandbox's current type. `xlarge` needs the $100/month plan or higher (403 `machine_class_plan_required`). 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}
      * @memberof ResumeRequest
      */
@@ -64,7 +64,8 @@ export interface ResumeRequest {
 export const ResumeRequestTypeEnum = {
     Small: 'small',
     Default: 'default',
-    Large: 'large'
+    Large: 'large',
+    Xlarge: 'xlarge'
 } as const;
 export type ResumeRequestTypeEnum = typeof ResumeRequestTypeEnum[keyof typeof ResumeRequestTypeEnum];
 

package/src/models/Sandbox.ts

@@ -107,7 +107,7 @@ export interface Sandbox {
      */
     memoryGB?: number;
     /**
-     * Rate at which this sandbox consumes machine time. 0.5 for `small`, 1 for `default`, and 2 for `large`.
+     * Rate at which this sandbox consumes machine time. 0.5 for `small`, 1 for `default`, 2 for `large`, and 50/9 (about 5.56) for `xlarge`.
      * @type {number}
      * @memberof Sandbox
      */
@@ -310,7 +310,8 @@ export type SandboxHealthEnum = typeof SandboxHealthEnum[keyof typeof SandboxHea
 export const SandboxTypeEnum = {
     Small: 'small',
     Default: 'default',
-    Large: 'large'
+    Large: 'large',
+    Xlarge: 'xlarge'
 } as const;
 export type SandboxTypeEnum = typeof SandboxTypeEnum[keyof typeof SandboxTypeEnum];
 

package/src/models/SandboxUsageResponse.ts

@@ -44,7 +44,7 @@ export interface SandboxUsageResponse {
      */
     sandboxType: SandboxUsageResponseSandboxTypeEnum;
     /**
-     * Rate at which this sandbox consumes machine time. 0.5 for `small`, 1 for `default`, and 2 for `large`.
+     * Rate at which this sandbox consumes machine time. 0.5 for `small`, 1 for `default`, 2 for `large`, and 50/9 (about 5.56) for `xlarge`.
      * @type {number}
      * @memberof SandboxUsageResponse
      */
@@ -94,7 +94,8 @@ export interface SandboxUsageResponse {
 export const SandboxUsageResponseSandboxTypeEnum = {
     Small: 'small',
     Default: 'default',
-    Large: 'large'
+    Large: 'large',
+    Xlarge: 'xlarge'
 } as const;
 export type SandboxUsageResponseSandboxTypeEnum = typeof SandboxUsageResponseSandboxTypeEnum[keyof typeof SandboxUsageResponseSandboxTypeEnum];
 

package/src/models/StopOperation.ts

@@ -32,7 +32,7 @@ export interface StopOperation {
      */
     status: StopOperationStatusEnum;
     /**
-     * When the stop was accepted. Null once it has ended.
+     * When the stop was accepted. On the sandbox, null once it has ended. Read by id (`GET /sandboxes/{sandboxId}/stops/{stopId}`), it is kept.
      * @type {Date}
      * @memberof StopOperation
      */