@shardflux/sdk 0.13.0 → 0.14.0

package/dist/progress.js

@@ -1,3 +1,5 @@
+/** Every {@link ColdBootReason} this version knows (0.14.0+). */
+export const COLD_BOOT_REASONS = ['runtime_changed', 'host_lost', 'runtime_retired'];
 const DURABILITY_STATES = new Set(['pending', 'durable', 'lost']);
 /**
  * The durable copy of a suspend or fork operation (0.12.0+): `result.durability` camelCased, or null when the result has
@@ -40,6 +42,22 @@ export function lostSuspendOf(op) {
         stateAsOf: str(r.state_as_of),
     };
 }
+/**
+ * An operation's `result.host_lost` camelCased (0.13.1+), or null: on a resume or open that restored a workspace whose
+ * machine failed, and on a suspend that found it so (`detectedAt` only).
+ */
+export function hostLostOf(op) {
+    const h = op.result?.host_lost;
+    if (typeof h !== 'object' || h === null || Array.isArray(h))
+        return null;
+    const r = h;
+    return {
+        detectedAt: str(r.detected_at),
+        restoredFrom: r.restored_from === 'disk' || r.restored_from === 'checkpoint' ? r.restored_from : null,
+        restoredCheckpointId: str(r.restored_checkpoint_id),
+        stateAsOf: str(r.state_as_of),
+    };
+}
 /**
  * Whether a suspend or fork operation's capture is in durable storage (0.12.0+): `result.durable`, else `true` for a
  * succeeded suspend or fork whose result predates the field, else null.
@@ -122,6 +140,7 @@ export function serverTiming(op) {
         suspendPath: str(r.suspend_path),
         durability: durabilityOf(op),
         lostSuspend: lostSuspendOf(op),
+        hostLost: hostLostOf(op),
         bootToReadyMs: num(r.boot_to_ready_ms),
         hostTimingsMs,
     };
@@ -275,6 +294,19 @@ export async function traced(trace, fn) {
     }
 }
 const fmt = (ms) => (ms === null ? '?' : ms < 1000 ? `${Math.round(ms)} ms` : `${(ms / 1000).toFixed(2)} s`);
+/**
+ * The server-line part of `result.host_lost` (0.13.1+): the checkpoint a resume restored, or a suspend's detection time.
+ * A resume from the disk says nothing more here: its cold boot reads `processes restarted (host_lost)`.
+ */
+function hostLostText(h) {
+    if (!h)
+        return null;
+    if (h.restoredFrom === 'checkpoint')
+        return `restored checkpoint ${h.restoredCheckpointId ?? '?'} (host_lost; state as of ${h.stateAsOf ?? '?'})`;
+    if (h.restoredFrom === null)
+        return `host_lost${h.detectedAt ? ` (detected ${h.detectedAt})` : ''}`;
+    return null;
+}
 /**
  * A human-readable account of a timing, for logs and bug reports. A resume in production:
  *
@@ -285,7 +317,10 @@ const fmt = (ms) => (ms === null ? '?' : ms < 1000 ? `${Math.round(ms)} ms` : `$
  *
  * A call that retried a request adds `retries: <n> (<request>, <cause>, after <delay>)`.
  * A resume that booted the workspace instead of restoring its memory (0.11.0+) says so in the server line:
- * `resume from cold_boot: processes restarted (runtime_changed)`.
+ * `resume from cold_boot: processes restarted (runtime_changed)`, or `(host_lost)` (0.13.1+) when the machine the
+ * workspace ran on failed and it booted from its disk. A resume that restored the newest checkpoint after such a
+ * failure adds `restored checkpoint <id> (host_lost; state as of <time>)`; a suspend that found the machine failed
+ * adds `host_lost (detected <time>)`.
  */
 export function formatTiming(t) {
     const ids = [t.workspaceId ? `workspace ${t.workspaceId}` : null, t.operationId ? `operation ${t.operationId}` : null].filter(Boolean).join(', ');
@@ -308,6 +343,7 @@ export function formatTiming(t) {
             s.startPath ? `start ${s.startPath}${s.warmFallback ? ` (warm fallback: ${s.warmFallback})` : ''}` : null,
             s.resumePath ? `resume from ${s.resumePath}${s.memoryRestored === false ? `: processes restarted${s.coldBootReason ? ` (${s.coldBootReason})` : ''}` : ''}` : null,
             s.lostSuspend ? `restored ${s.lostSuspend.restoredCheckpointId ?? 'no checkpoint'} (latest suspend ${s.lostSuspend.checkpointId} ${s.lostSuspend.reason ?? 'lost'})` : null,
+            hostLostText(s.hostLost),
             s.suspendPath === 'local_commit' ? 'sealed on host' : null,
             s.durability?.state === 'durable' ? `durable${s.durability.localCommitToDurableMs !== null ? ` ${fmt(s.durability.localCommitToDurableMs)} later` : ''}` : s.durability ? `durable copy ${s.durability.state}` : null,
             s.bootToReadyMs !== null ? `boot to ready ${fmt(s.bootToReadyMs)}` : null,

package/dist/tools.d.ts

@@ -33,6 +33,8 @@ export interface WorkspaceTool<A extends Record<string, unknown> = Record<string
     };
     /** Which workspace tool permission the call needs (exec, files, pty, process, git, browser). */
     permission: ToolName;
+    /** Opt-in input-start hook (0.14.0+): call when the model starts this tool's input. Returns immediately. */
+    onInputStart?: () => void;
     /** `toolCallId` (0.7.0+): the model's call id, recorded by tool-call capture (executeToolCall passes it). */
     execute(args: A, options?: {
         signal?: AbortSignal;
@@ -74,6 +76,12 @@ export interface WorkspaceToolsOptions {
      * suspended workspace (or restore a hibernated one) that the read does not need.
      */
     hint?: boolean;
+    /**
+     * Add `onInputStart` hooks (0.14.0+) to tools that need the VM. Invoke the matching hook when the model starts
+     * streaming that tool's input, ahead of execute. Default false: no hook, timer or request is installed.
+     * Offline file reads and file-first workspaces have no hook.
+     */
+    prewake?: boolean;
     /**
      * The mode to build the tools for (0.9.0+; default `workspace.mode`). Given, the workspace is not touched until a tool
      * runs, so definitions can be built without one (e.g. to publish them before any workspace exists).

package/dist/tools.js

@@ -87,6 +87,13 @@ const ALL = ['exec', 'files', 'pty', 'process', 'git', 'browser'];
 const FILE_FIRST_TOOLS = ['exec', 'files'];
 /** Changed paths returned to the model per execution (the rest is flagged `changed_truncated`). */
 const MAX_CHANGED_LISTED = 200;
+/** The processful exec's memory hint (0.14.0; RunOptions.resourceHint). Sent only when the model sets it. */
+const RESOURCE_HINT_SCHEMA = {
+    type: 'string',
+    enum: ['auto', 'light', 'heavy'],
+    description: 'heavy: give this command more memory before it starts (a build, a test suite, a package install, a training run); light: start it at once. Default auto: decided from the command.',
+};
+const RESOURCE_HINTS = new Set(['auto', 'light', 'heavy']);
 /** Tools served from a sleeping workspace's disk without waking it: the runner sends no hint. */
 const DISK_READS = new Set(['read_file', 'list_files', 'search_files']);
 const obj = (properties, required = []) => ({ type: 'object', properties, required, additionalProperties: false });
@@ -267,6 +274,7 @@ export function workspaceTools(workspace, opts = {}) {
             type: 'boolean',
             description: 'Start the command and return its session_id at once instead of waiting for it to exit (default false). Use it for anything that may run longer than a few minutes, such as a build, a test suite, a training run or a server. Keep using the other tools meanwhile, read it with exec_read and stop it with exec_cancel. Set timeout_ms to the longest it may run: the workspace stays awake until the command ends or that time passes (1 hour when unset).',
         },
+        resource_hint: RESOURCE_HINT_SCHEMA,
         ...(opts.burst
             ? {
                 burst: {
@@ -330,6 +338,7 @@ export function workspaceTools(workspace, opts = {}) {
                     const burst = opts.burst && (a.burst === 'always' || a.burst === 'never') ? a.burst : undefined;
                     const burstVcpus = opts.burst && typeof a.burst_vcpus === 'number' ? a.burst_vcpus : undefined;
                     const burstMemoryMib = opts.burst && typeof a.burst_memory_mib === 'number' ? a.burst_memory_mib : undefined;
+                    const resourceHint = RESOURCE_HINTS.has(a.resource_hint) ? a.resource_hint : undefined;
                     const cwd = typeof a.cwd === 'string' ? a.cwd : opts.defaultCwd;
                     if (a.background === true) {
                         // A session of its own: the start answers at once, and exec_read / exec_cancel find it by session_id.
@@ -339,6 +348,7 @@ export function workspaceTools(workspace, opts = {}) {
                             ...(cwd !== undefined ? { cwd } : {}),
                             ...(typeof a.timeout_ms === 'number' ? { timeout_ms: a.timeout_ms } : {}),
                             ...(typeof a.stdin === 'string' ? { stdin: Buffer.from(a.stdin, 'utf8').toString('base64') } : {}),
+                            ...(resourceHint !== undefined ? { resource_hint: resourceHint } : {}),
                             ...(burst !== undefined ? { burst } : {}),
                             ...(burstVcpus !== undefined ? { burst_vcpus: burstVcpus } : {}),
                             ...(burstMemoryMib !== undefined ? { burst_memory_mib: burstMemoryMib } : {}),
@@ -353,6 +363,7 @@ export function workspaceTools(workspace, opts = {}) {
                             ...(cwd !== undefined ? { cwd } : {}),
                             timeoutMs: typeof a.timeout_ms === 'number' ? a.timeout_ms : 600_000,
                             ...(typeof a.stdin === 'string' ? { stdin: a.stdin } : {}),
+                            ...(resourceHint !== undefined ? { resourceHint } : {}),
                             ...(burst !== undefined ? { burst } : {}),
                             ...(burstVcpus !== undefined ? { burstVcpus } : {}),
                             ...(burstMemoryMib !== undefined ? { burstMemoryMib } : {}),
@@ -698,6 +709,15 @@ export function workspaceTools(workspace, opts = {}) {
         description: d.description,
         parameters: d.parameters,
         permission: d.permission,
+        ...(opts.prewake === true && !fileFirst && !DISK_READS.has(d.name) ? {
+            onInputStart: () => {
+                workspace.hint({
+                    ...(opts.agentLabel !== undefined ? { agentLabel: opts.agentLabel } : {}),
+                    wake: opts.wake ?? null,
+                    ...(opts.transitionTimeoutMs !== undefined ? { wakeTimeoutMs: opts.transitionTimeoutMs } : {}),
+                }).catch(() => undefined);
+            },
+        } : {}),
         execute: async (args, options = {}) => {
             const issues = validateArgs(d.parameters, args);
             if (issues.length === 0 && d.refuse)

package/dist/usage.d.ts

@@ -56,7 +56,9 @@ export declare class UsageApi {
     constructor(ctx: () => ClientContext);
     /**
      * Current-period usage per meter, allowances with enforcement and cap state (`overage` while opt-in overage covers
-     * usage past a CPU-hours or RAM GiB-hours allowance), measurement freshness, `exhausted_reason` (the 402
+     * usage past a CPU-hours or RAM GiB-hours allowance; `storage_blocked` (0.14.0+, enforcement `storage_block`) while
+     * the Retained state allowance is used up: opening a new key and forking are refused with 403 `quota_exceeded`,
+     * details.limit `retained_state`), measurement freshness, `exhausted_reason` (the 402
      * allowance_exhausted reason while starts are refused: `allowance_used`, `overage_paused`, `spend_cap_reached`) and
      * `spend_cap` (0.10.0).
      */

package/dist/usage.js

@@ -9,7 +9,9 @@ export class UsageApi {
     }
     /**
      * Current-period usage per meter, allowances with enforcement and cap state (`overage` while opt-in overage covers
-     * usage past a CPU-hours or RAM GiB-hours allowance), measurement freshness, `exhausted_reason` (the 402
+     * usage past a CPU-hours or RAM GiB-hours allowance; `storage_blocked` (0.14.0+, enforcement `storage_block`) while
+     * the Retained state allowance is used up: opening a new key and forking are refused with 403 `quota_exceeded`,
+     * details.limit `retained_state`), measurement freshness, `exhausted_reason` (the 402
      * allowance_exhausted reason while starts are refused: `allowance_used`, `overage_paused`, `spend_cap_reached`) and
      * `spend_cap` (0.10.0).
      */

package/dist/workspace.d.ts

@@ -2,7 +2,7 @@
  * A workspace handle: the latest view from the application API plus managed
  * tool tokens and cell clients (one per agent label / tool set).
  */
-import type { AllocationMode, ClientContext, IdlePolicy, DiskLayout, ForkTarget, Operation, SuspendRequest, SuspendWhenIdleOptions, SuspendWhenIdleResult, WaitOptions, WorkspaceLifetime, WorkspaceMemory, WorkspaceOrigin, WorkspacePurpose, WorkspaceView } from './client.js';
+import type { AllocationMode, ClientContext, IdlePolicy, DiskLayout, ForkTarget, Operation, ResizeParams, ResizeResult, SuspendRequest, SuspendWhenIdleOptions, SuspendWhenIdleResult, WaitOptions, WorkspaceLifetime, WorkspaceMemory, WorkspaceOrigin, WorkspacePurpose, WorkspaceView } from './client.js';
 import { CAPTURE_BARRIER, CellClient } from './cell.js';
 import { ToolCallCapture } from './capture.js';
 import type { ToolCallCaptureOptions } from './capture.js';
@@ -10,6 +10,7 @@ import type { WorkspaceMode } from './errors.js';
 import type { FinishedOperation, ForkOptions, LifecycleOptions, ResumeOptions, SuspendOptions, WaitedForkOptions, WaitedLifecycleOptions, WaitedResumeOptions, WaitedSuspendOptions } from './lifecycle.js';
 import { Trace } from './progress.js';
 import type { LifecycleTiming, ProgressListener } from './progress.js';
+import { WorkspacePorts } from './ports.js';
 import { WorkspaceSecrets } from './secrets.js';
 import type { CellClientOptions, Residency, WorkspaceChangesPage, WorkspaceChangesParams } from './cell.js';
 import type { SaveAsTemplateParams, SaveAsTemplateResponse, WorkspaceStartup } from './templates.js';
@@ -67,7 +68,9 @@ export declare class Workspace {
      * woke the workspace), or a lifecycle call with `wait`. Null for handles from get()/list() until such a call.
      * `formatTiming(workspace.lastTiming)` prints it. After a resume or wake, `server.memoryRestored === false` (0.11.0+)
      * means the workspace booted from its saved disk instead of restoring its memory (`server.resumePath` `cold_boot`,
-     * reason in `server.coldBootReason`): files are as of the suspend, running processes were restarted.
+     * reason in `server.coldBootReason`): files are as of the suspend, running processes were restarted. Reason
+     * `host_lost` (0.13.1+): the machine the workspace ran on failed and it booted from its disk, files kept;
+     * `server.hostLost` says what the resume restored (`hostLostOf(op)` on the operation).
      */
     get lastTiming(): LifecycleTiming | null;
     get id(): string;
@@ -148,6 +151,15 @@ export declare class Workspace {
     get executions(): CellClient['executions'];
     /** Secret names bound to this workspace (injected into every exec/PTY start): `get()`, `set(names)`. */
     get secrets(): WorkspaceSecrets;
+    /**
+     * Inbound ports (0.14.0): serve a TCP port of the workspace at its own private HTTPS URL. A request wakes a parked or
+     * suspended workspace and is served once it runs.
+     *
+     *   const { url } = await workspace.ports.expose(3000);       // the server listens on 0.0.0.0:3000
+     *   const { token } = await workspace.ports.token(3000);      // Authorization: Bearer <token>
+     *   const link = await workspace.ports.link(3000);            // open link.url in a browser
+     */
+    get ports(): WorkspacePorts;
     /** The workspace's text inputs `{NAME: value}` (0.7.0; secret inputs are bound secrets, never listed here). */
     inputs(): Promise<Record<string, string>>;
     get labels(): Record<string, string>;
@@ -174,6 +186,8 @@ export declare class Workspace {
      * resolve once it has FINISHED, with `workspace.state` then `suspended`. That is as soon as the workspace is sealed on
      * its host, typically in a few hundred ms. `result.durable` (also `lastTiming.server.durable`, 0.12.0+) turns true
      * when the copy lands in durable storage, typically within a second; `{ durable: true }` resolves only then.
+     * A suspend that finds the machine the workspace ran on failed succeeds at once (0.13.1+): `result.durable` is true
+     * and `result.host_lost` (`hostLostOf(op)`) has `detectedAt`; the next resume restores the workspace.
      *
      *   await workspace.suspend({ wait: true });
      *   await workspace.suspend({ durable: true }); // 0.12.0+: also wait for the durable copy
@@ -196,6 +210,21 @@ export declare class Workspace {
      * A suspend the request already started is not undone (it shows as `activeOperation`).
      */
     cancelSuspendWhenIdle(): Promise<this>;
+    /**
+     * Resizes this workspace (0.14.0): memory, the held floor, the allocation mode, CPU and disk, whether it is running or
+     * suspended, fixed or elastic, without a restart or a fork. Memory changes live on a running workspace (a shrink gives
+     * back what the guest frees: `memory.converged`); a suspended one gets its new size when it resumes, before its first
+     * call. CPU changes live up to the vCPUs the workspace booted with, beyond that at its next start. Disks grow online.
+     * The new caps are stored, so every later start uses them. Resolves once the resize has finished, with per resource
+     * when it applies (`now`, `resume` or `next_start` with the `reason`); the handle's view is refreshed. See
+     * WorkspacesApi.resize for the errors. A file-first workspace (no VM to resize) is refused locally with
+     * NotSupportedForModeError.
+     *
+     *   const r = await workspace.resize({ memoryMib: 6144, cpuMillis: 4000 });
+     *   r.memory?.applies_at; // 'now'
+     *   r.cpu?.applies_at;    // 'next_start' (reason 'boot_vcpus': more vCPUs than it booted with)
+     */
+    resize(params: ResizeParams): Promise<ResizeResult>;
     /**
      * Resumes a suspended workspace. Resolves when the resume is REQUESTED; with `{ wait: true }`, once the workspace runs.
      * Tool calls wake a suspended workspace by themselves, so this is rarely needed. With `wait` (0.9.0) it is one held
@@ -205,11 +234,16 @@ export declare class Workspace {
      * (also `lastTiming.server.memoryRestored`, 0.11.0+) is false when the resume booted the saved disk instead
      * (`resume_path` `cold_boot`): files kept, processes restarted. `result.lost_suspend` (also
      * `lastTiming.server.lostSuspend`, `lostSuspendOf(op)`, 0.12.0+) names a suspend this resume could not restore and the
-     * checkpoint it restored instead (see the lifecycle reference).
+     * checkpoint it restored instead (see the lifecycle reference). `result.host_lost` (also `lastTiming.server.hostLost`,
+     * `hostLostOf(op)`, 0.13.1+): the machine the workspace ran on failed and this resume restored it, from its disk
+     * (`cold_boot_reason` `host_lost`) or from its newest checkpoint (`state_as_of`).
      */
     resume(opts: WaitedResumeOptions): Promise<FinishedOperation>;
     resume(opts?: ResumeOptions): Promise<Operation>;
-    /** Takes a snapshot. Resolves when it is REQUESTED; with `{ wait: true }`, once it is taken. */
+    /**
+     * Takes a snapshot. Resolves when it is REQUESTED; with `{ wait: true }`, once it is taken. After the machine the
+     * workspace ran on failed, resume it first: until then the snapshot fails `resume_required` (0.13.1+).
+     */
     snapshot(opts: WaitedLifecycleOptions & {
         label?: string;
     }): Promise<FinishedOperation>;
@@ -218,7 +252,8 @@ export declare class Workspace {
     }): Promise<Operation>;
     /**
      * Forks into a new key. Resolves when the fork is REQUESTED (the copy's handle is returned at once); with
-     * `{ wait: true }`, once the copy exists, with its handle refreshed.
+     * `{ wait: true }`, once the copy exists, with its handle refreshed. After the machine the workspace ran on failed,
+     * resume it first: until then the fork fails `resume_required` (0.13.1+).
      */
     fork(target: ForkTarget, opts: WaitedForkOptions): Promise<{
         operation: FinishedOperation;
@@ -301,8 +336,9 @@ export declare class Workspace {
      * that does not hold the request answers at once; the wake then waits for the operation and reads the view.
      *
      * A wake whose resume could not restore the workspace's memory (0.11.0+; the platform's VM runtime changed after the
-     * suspend) still resolves `true`: the workspace runs from its saved disk, with every process restarted. `lastTiming`
-     * and the `done` progress event say so (`server.memoryRestored === false`, `server.resumePath` `cold_boot`).
+     * suspend, or, 0.13.1+, the machine the workspace ran on failed) still resolves `true`: the workspace runs from its
+     * saved disk, with every process restarted. `lastTiming` and the `done` progress event say so
+     * (`server.memoryRestored === false`, `server.resumePath` `cold_boot`, `server.coldBootReason`).
      */
     wake(opts?: WakeOptions): Promise<boolean>;
     /**

package/dist/workspace.js

@@ -4,6 +4,7 @@ import { NotSupportedForModeError, OperationFailedError, ShardfluxApiError } fro
 import { SERVER_WAIT_MAX_S, defaultSleep, randomId } from "./http.js";
 import { AFTER_WAIT, HELD_RESUME, TRACE } from "./lifecycle.js";
 import { Trace, combineListeners, traced } from "./progress.js";
+import { WorkspacePorts } from "./ports.js";
 import { WorkspaceSecrets } from "./secrets.js";
 import { ToolTokenManager } from "./tokens.js";
 const notRunning = (e) => e instanceof ShardfluxApiError && (e.code === 'workspace_not_running' || (e.code === 'conflict' && e.reason === 'workspace_not_running'));
@@ -44,7 +45,9 @@ export class Workspace {
      * woke the workspace), or a lifecycle call with `wait`. Null for handles from get()/list() until such a call.
      * `formatTiming(workspace.lastTiming)` prints it. After a resume or wake, `server.memoryRestored === false` (0.11.0+)
      * means the workspace booted from its saved disk instead of restoring its memory (`server.resumePath` `cold_boot`,
-     * reason in `server.coldBootReason`): files are as of the suspend, running processes were restarted.
+     * reason in `server.coldBootReason`): files are as of the suspend, running processes were restarted. Reason
+     * `host_lost` (0.13.1+): the machine the workspace ran on failed and it booted from its disk, files kept;
+     * `server.hostLost` says what the resume restored (`hostLostOf(op)` on the operation).
      */
     get lastTiming() {
         return this.#lastTiming ?? this.#openTrace?.finished ?? null;
@@ -198,6 +201,17 @@ export class Workspace {
     get secrets() {
         return new WorkspaceSecrets(this.#ctx, this.id);
     }
+    /**
+     * Inbound ports (0.14.0): serve a TCP port of the workspace at its own private HTTPS URL. A request wakes a parked or
+     * suspended workspace and is served once it runs.
+     *
+     *   const { url } = await workspace.ports.expose(3000);       // the server listens on 0.0.0.0:3000
+     *   const { token } = await workspace.ports.token(3000);      // Authorization: Bearer <token>
+     *   const link = await workspace.ports.link(3000);            // open link.url in a browser
+     */
+    get ports() {
+        return new WorkspacePorts(this.#ctx, this.id);
+    }
     /** The workspace's text inputs `{NAME: value}` (0.7.0; secret inputs are bound secrets, never listed here). */
     inputs() {
         return this.#ctx.workspaces.inputs(this.id);
@@ -272,6 +286,29 @@ export class Workspace {
         this.#view = (await this.#ctx.workspaces.cancelSuspendWhenIdle(this.id)).data;
         return this;
     }
+    /**
+     * Resizes this workspace (0.14.0): memory, the held floor, the allocation mode, CPU and disk, whether it is running or
+     * suspended, fixed or elastic, without a restart or a fork. Memory changes live on a running workspace (a shrink gives
+     * back what the guest frees: `memory.converged`); a suspended one gets its new size when it resumes, before its first
+     * call. CPU changes live up to the vCPUs the workspace booted with, beyond that at its next start. Disks grow online.
+     * The new caps are stored, so every later start uses them. Resolves once the resize has finished, with per resource
+     * when it applies (`now`, `resume` or `next_start` with the `reason`); the handle's view is refreshed. See
+     * WorkspacesApi.resize for the errors. A file-first workspace (no VM to resize) is refused locally with
+     * NotSupportedForModeError.
+     *
+     *   const r = await workspace.resize({ memoryMib: 6144, cpuMillis: 4000 });
+     *   r.memory?.applies_at; // 'now'
+     *   r.cpu?.applies_at;    // 'next_start' (reason 'boot_vcpus': more vCPUs than it booted with)
+     */
+    async resize(params) {
+        const refusal = this.#needsVm('resize');
+        if (refusal)
+            throw refusal;
+        const out = await this.#ctx.workspaces.resize(this.id, this.#tracked(params));
+        // The resize has happened: a failed view read leaves the old view (the next refresh() reads it again).
+        await this.refresh().catch(() => undefined);
+        return out;
+    }
     resume(opts = {}) {
         const refusal = this.#needsVm('resume');
         if (refusal)
@@ -438,8 +475,9 @@ export class Workspace {
      * that does not hold the request answers at once; the wake then waits for the operation and reads the view.
      *
      * A wake whose resume could not restore the workspace's memory (0.11.0+; the platform's VM runtime changed after the
-     * suspend) still resolves `true`: the workspace runs from its saved disk, with every process restarted. `lastTiming`
-     * and the `done` progress event say so (`server.memoryRestored === false`, `server.resumePath` `cold_boot`).
+     * suspend, or, 0.13.1+, the machine the workspace ran on failed) still resolves `true`: the workspace runs from its
+     * saved disk, with every process restarted. `lastTiming` and the `done` progress event say so
+     * (`server.memoryRestored === false`, `server.resumePath` `cold_boot`, `server.coldBootReason`).
      */
     async wake(opts = {}) {
         // A file-first workspace runs from creation and is never suspended: nothing to wake.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shardflux/sdk",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "type": "module",
   "description": "Shardflux TypeScript SDK: open persistent agent workspaces by key and give your agent workspace tools (exec, files, processes, PTY, git, browser).",
   "license": "Apache-2.0",