@cloudflare/sandbox 0.13.0-next.681.1 → 0.13.0-next.709.1

package/dist/{errors-ewgSNicb.js → errors-QYlSkVGz.js}

@@ -1,10 +1,6 @@
-import { i as ErrorCode } from "./errors-k3B8orjH.js";
+import { i as ErrorCode, r as getHttpStatus } from "./errors-CXR0xBpw.js";
 
-//#region src/errors/classes.ts
-/**
-* Base SDK error that wraps ErrorResponse
-* Preserves all error information from container
-*/
+//#region src/errors/classes/base.ts
 var SandboxError = class extends Error {
 	constructor(errorResponse, options) {
 		super(errorResponse.message, options);
@@ -47,279 +43,249 @@ var SandboxError = class extends Error {
 		};
 	}
 };
+
+//#endregion
+//#region src/errors/classes/backup-terminal-lifecycle.ts
 /**
-* Error thrown when a file or directory is not found
+* Error thrown when a backup is not found in R2
 */
-var FileNotFoundError = class extends SandboxError {
+var BackupNotFoundError = class extends SandboxError {
 	constructor(errorResponse) {
 		super(errorResponse);
-		this.name = "FileNotFoundError";
+		this.name = "BackupNotFoundError";
 	}
-	get path() {
-		return this.context.path;
+	get backupId() {
+		return this.context.backupId;
 	}
 };
 /**
-* Error thrown when a file already exists
+* Error thrown when a backup has expired (past its TTL)
 */
-var FileExistsError = class extends SandboxError {
+var BackupExpiredError = class extends SandboxError {
 	constructor(errorResponse) {
 		super(errorResponse);
-		this.name = "FileExistsError";
+		this.name = "BackupExpiredError";
 	}
-	get path() {
-		return this.context.path;
+	get backupId() {
+		return this.context.backupId;
+	}
+	get expiredAt() {
+		return this.context.expiredAt;
 	}
 };
 /**
-* Error thrown when a file is too large
+* Error thrown when backup configuration or inputs are invalid
 */
-var FileTooLargeError = class extends SandboxError {
+var InvalidBackupConfigError = class extends SandboxError {
 	constructor(errorResponse) {
 		super(errorResponse);
-		this.name = "FileTooLargeError";
+		this.name = "InvalidBackupConfigError";
 	}
-	get path() {
-		return this.context.path;
+	get reason() {
+		return this.context.reason;
 	}
 };
 /**
-* Generic file system error (permissions, disk full, etc.)
+* Error thrown when backup creation fails
 */
-var FileSystemError = class extends SandboxError {
+var BackupCreateError = class extends SandboxError {
 	constructor(errorResponse) {
 		super(errorResponse);
-		this.name = "FileSystemError";
-	}
-	get path() {
-		return this.context.path;
+		this.name = "BackupCreateError";
 	}
-	get stderr() {
-		return this.context.stderr;
+	get dir() {
+		return this.context.dir;
 	}
-	get exitCode() {
-		return this.context.exitCode;
+	get backupId() {
+		return this.context.backupId;
 	}
 };
 /**
-* Error thrown when permission is denied
+* Error thrown when backup restoration fails
 */
-var PermissionDeniedError = class extends SandboxError {
+var BackupRestoreError = class extends SandboxError {
 	constructor(errorResponse) {
 		super(errorResponse);
-		this.name = "PermissionDeniedError";
+		this.name = "BackupRestoreError";
 	}
-	get path() {
-		return this.context.path;
+	get dir() {
+		return this.context.dir;
+	}
+	get backupId() {
+		return this.context.backupId;
 	}
 };
-/**
-* Error thrown when a command is not found
-*/
-var CommandNotFoundError = class extends SandboxError {
+var TerminalNotFoundError = class extends SandboxError {
 	constructor(errorResponse) {
 		super(errorResponse);
-		this.name = "CommandNotFoundError";
+		this.name = "TerminalNotFoundError";
 	}
-	get command() {
-		return this.context.command;
+	get terminalId() {
+		return this.context.terminalId;
 	}
 };
-/**
-* Generic command execution error
-*/
-var CommandError = class extends SandboxError {
+var InvalidTerminalCwdError = class extends SandboxError {
 	constructor(errorResponse) {
 		super(errorResponse);
-		this.name = "CommandError";
-	}
-	get command() {
-		return this.context.command;
-	}
-	get exitCode() {
-		return this.context.exitCode;
+		this.name = "InvalidTerminalCwdError";
 	}
-	get stdout() {
-		return this.context.stdout;
+	get terminalId() {
+		return this.context.terminalId;
 	}
-	get stderr() {
-		return this.context.stderr;
+	get cwd() {
+		return this.context.cwd;
 	}
 };
-/**
-* Error thrown when a process is not found
-*/
-var ProcessNotFoundError = class extends SandboxError {
+var InvalidTerminalCursorError = class extends SandboxError {
 	constructor(errorResponse) {
 		super(errorResponse);
-		this.name = "ProcessNotFoundError";
+		this.name = "InvalidTerminalCursorError";
 	}
-	get processId() {
-		return this.context.processId;
+	get terminalId() {
+		return this.context.terminalId;
 	}
 };
-/**
-* Generic process error
-*/
-var ProcessError = class extends SandboxError {
+var TerminalControlError = class extends SandboxError {
 	constructor(errorResponse) {
 		super(errorResponse);
-		this.name = "ProcessError";
-	}
-	get processId() {
-		return this.context.processId;
+		this.name = "TerminalControlError";
 	}
-	get pid() {
-		return this.context.pid;
-	}
-	get exitCode() {
-		return this.context.exitCode;
+	get terminalId() {
+		return this.context.terminalId;
 	}
-	get stderr() {
-		return this.context.stderr;
+	get operationName() {
+		return this.context.operation;
 	}
 };
-/**
-* Error thrown when a session already exists
-*/
-var SessionAlreadyExistsError = class extends SandboxError {
+var StaleTerminalHandleError = class extends SandboxError {
 	constructor(errorResponse) {
 		super(errorResponse);
-		this.name = "SessionAlreadyExistsError";
+		this.name = "StaleTerminalHandleError";
 	}
-	get sessionId() {
-		return this.context.sessionId;
+	get terminalId() {
+		return this.context.terminalId;
 	}
-	get containerPlacementId() {
-		return this.context.containerPlacementId;
+	get operation() {
+		return this.context.operation;
 	}
 };
-/**
-* Error thrown when a session was destroyed while a command was executing
-*/
-var SessionDestroyedError = class extends SandboxError {
+var ContainerUnavailableError = class extends SandboxError {
 	constructor(errorResponse) {
 		super(errorResponse);
-		this.name = "SessionDestroyedError";
-	}
-	get sessionId() {
-		return this.context.sessionId;
+		this.name = "ContainerUnavailableError";
 	}
 };
-/**
-* Error thrown when a session's underlying shell exited without an explicit
-* `destroy()` call (user ran `exit`, the shell crashed, or a child process
-* took the shell down). The session-local state is gone, but the next call
-* with the same sessionId will transparently start a fresh session.
-*/
-var SessionTerminatedError = class extends SandboxError {
+var OperationInterruptedError = class extends SandboxError {
 	constructor(errorResponse) {
 		super(errorResponse);
-		this.name = "SessionTerminatedError";
-	}
-	get sessionId() {
-		return this.context.sessionId;
-	}
-	get exitCode() {
-		return this.context.exitCode;
+		this.name = "OperationInterruptedError";
 	}
-};
-/**
-* Compatibility error for legacy port exposure registry responses.
-*/
-var PortAlreadyExposedError = class extends SandboxError {
-	constructor(errorResponse) {
-		super(errorResponse);
-		this.name = "PortAlreadyExposedError";
+	get reason() {
+		return this.context.reason;
 	}
-	get port() {
-		return this.context.port;
+	get retryable() {
+		return this.context.retryable;
 	}
-	get portName() {
-		return this.context.portName;
+	get operationName() {
+		return this.context.operation;
 	}
 };
 /**
-* Compatibility error for legacy port exposure registry responses.
+* Raised when the capnweb WebSocket session itself fails on the SDK side.
+* Unlike the rest of the SandboxError tree, the container never produces
+* this error — it is synthesised by `translateRPCError` from the plain
+* Errors capnweb / DeferredTransport raise when the connection dies.
+*
+* `kind` distinguishes the failure mode (peer close, upgrade failed, etc.)
+* so callers can branch on a structured code instead of substring-matching
+* on the message.
+*
+* Always retryable: the SDK opens a fresh connection on the next call.
 */
-var PortNotExposedError = class extends SandboxError {
-	constructor(errorResponse) {
-		super(errorResponse);
-		this.name = "PortNotExposedError";
+var RPCTransportError = class extends SandboxError {
+	constructor(errorResponse, options) {
+		super(errorResponse, options);
+		this.name = "RPCTransportError";
 	}
-	get port() {
-		return this.context.port;
+	get kind() {
+		return this.errorResponse.context.kind;
+	}
+	get originalMessage() {
+		return this.errorResponse.context.originalMessage;
 	}
 };
+
+//#endregion
+//#region src/errors/classes/filesystem.ts
 /**
-* Error thrown when a port number is invalid
+* Error thrown when a file or directory is not found
 */
-var InvalidPortError = class extends SandboxError {
+var FileNotFoundError = class extends SandboxError {
 	constructor(errorResponse) {
 		super(errorResponse);
-		this.name = "InvalidPortError";
-	}
-	get port() {
-		return this.context.port;
+		this.name = "FileNotFoundError";
 	}
-	get reason() {
-		return this.context.reason;
+	get path() {
+		return this.context.path;
 	}
 };
 /**
-* Error thrown when a service on a port is not responding
+* Error thrown when a file already exists
 */
-var ServiceNotRespondingError = class extends SandboxError {
+var FileExistsError = class extends SandboxError {
 	constructor(errorResponse) {
 		super(errorResponse);
-		this.name = "ServiceNotRespondingError";
-	}
-	get port() {
-		return this.context.port;
+		this.name = "FileExistsError";
 	}
-	get portName() {
-		return this.context.portName;
+	get path() {
+		return this.context.path;
 	}
 };
 /**
-* Error thrown when a port is already in use
+* Error thrown when a file is too large
 */
-var PortInUseError = class extends SandboxError {
+var FileTooLargeError = class extends SandboxError {
 	constructor(errorResponse) {
 		super(errorResponse);
-		this.name = "PortInUseError";
+		this.name = "FileTooLargeError";
 	}
-	get port() {
-		return this.context.port;
+	get path() {
+		return this.context.path;
 	}
 };
 /**
-* Generic port operation error
+* Generic file system error (permissions, disk full, etc.)
 */
-var PortError = class extends SandboxError {
+var FileSystemError = class extends SandboxError {
 	constructor(errorResponse) {
 		super(errorResponse);
-		this.name = "PortError";
-	}
-	get port() {
-		return this.context.port;
+		this.name = "FileSystemError";
 	}
-	get portName() {
-		return this.context.portName;
+	get path() {
+		return this.context.path;
 	}
 	get stderr() {
 		return this.context.stderr;
 	}
+	get exitCode() {
+		return this.context.exitCode;
+	}
 };
 /**
-* Error thrown when port exposure requires a custom domain
+* Error thrown when permission is denied
 */
-var CustomDomainRequiredError = class extends SandboxError {
+var PermissionDeniedError = class extends SandboxError {
 	constructor(errorResponse) {
 		super(errorResponse);
-		this.name = "CustomDomainRequiredError";
+		this.name = "PermissionDeniedError";
+	}
+	get path() {
+		return this.context.path;
 	}
 };
+
+//#endregion
+//#region src/errors/classes/git-code.ts
 /**
 * Error thrown when a git repository is not found
 */
@@ -512,165 +478,334 @@ var ValidationFailedError = class extends SandboxError {
 		return this.context.validationErrors;
 	}
 };
+
+//#endregion
+//#region src/errors/classes/port.ts
 /**
-* Error thrown when a process does not become ready within the timeout period
+* Error thrown when exposing a port that is already exposed.
 */
-var ProcessReadyTimeoutError = class extends SandboxError {
+var PortAlreadyExposedError = class extends SandboxError {
 	constructor(errorResponse) {
 		super(errorResponse);
-		this.name = "ProcessReadyTimeoutError";
-	}
-	get processId() {
-		return this.context.processId;
+		this.name = "PortAlreadyExposedError";
 	}
-	get command() {
-		return this.context.command;
+	get port() {
+		return this.context.port;
 	}
-	get condition() {
-		return this.context.condition;
+	get portName() {
+		return this.context.portName;
 	}
-	get timeout() {
-		return this.context.timeout;
+};
+/**
+* Error thrown when operating on a port that has not been exposed.
+*/
+var PortNotExposedError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "PortNotExposedError";
+	}
+	get port() {
+		return this.context.port;
 	}
 };
 /**
-* Error thrown when a process exits before becoming ready
+* Error thrown when a port number is invalid
 */
-var ProcessExitedBeforeReadyError = class extends SandboxError {
+var InvalidPortError = class extends SandboxError {
 	constructor(errorResponse) {
 		super(errorResponse);
-		this.name = "ProcessExitedBeforeReadyError";
+		this.name = "InvalidPortError";
 	}
-	get processId() {
-		return this.context.processId;
+	get port() {
+		return this.context.port;
 	}
-	get command() {
-		return this.context.command;
+	get reason() {
+		return this.context.reason;
 	}
-	get condition() {
-		return this.context.condition;
+};
+/**
+* Error thrown when a service on a port is not responding
+*/
+var ServiceNotRespondingError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "ServiceNotRespondingError";
 	}
-	get exitCode() {
-		return this.context.exitCode;
+	get port() {
+		return this.context.port;
+	}
+	get portName() {
+		return this.context.portName;
 	}
 };
 /**
-* Error thrown when a backup is not found in R2
+* Error thrown when a port is already in use
 */
-var BackupNotFoundError = class extends SandboxError {
+var PortInUseError = class extends SandboxError {
 	constructor(errorResponse) {
 		super(errorResponse);
-		this.name = "BackupNotFoundError";
+		this.name = "PortInUseError";
 	}
-	get backupId() {
-		return this.context.backupId;
+	get port() {
+		return this.context.port;
 	}
 };
 /**
-* Error thrown when a backup has expired (past its TTL)
+* Generic port operation error
 */
-var BackupExpiredError = class extends SandboxError {
+var PortError = class extends SandboxError {
 	constructor(errorResponse) {
 		super(errorResponse);
-		this.name = "BackupExpiredError";
+		this.name = "PortError";
 	}
-	get backupId() {
-		return this.context.backupId;
+	get port() {
+		return this.context.port;
 	}
-	get expiredAt() {
-		return this.context.expiredAt;
+	get portName() {
+		return this.context.portName;
+	}
+	get stderr() {
+		return this.context.stderr;
 	}
 };
 /**
-* Error thrown when backup configuration or inputs are invalid
+* Error thrown when port exposure requires a custom domain
 */
-var InvalidBackupConfigError = class extends SandboxError {
+var CustomDomainRequiredError = class extends SandboxError {
 	constructor(errorResponse) {
 		super(errorResponse);
-		this.name = "InvalidBackupConfigError";
+		this.name = "CustomDomainRequiredError";
 	}
-	get reason() {
-		return this.context.reason;
+};
+
+//#endregion
+//#region src/errors/classes/process.ts
+/**
+* Error thrown when a command is not found
+*/
+var CommandNotFoundError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "CommandNotFoundError";
+	}
+	get command() {
+		return this.context.command;
 	}
 };
 /**
-* Error thrown when backup creation fails
+* Generic command execution error
 */
-var BackupCreateError = class extends SandboxError {
+var CommandError = class extends SandboxError {
 	constructor(errorResponse) {
 		super(errorResponse);
-		this.name = "BackupCreateError";
+		this.name = "CommandError";
 	}
-	get dir() {
-		return this.context.dir;
+	get command() {
+		return this.context.command;
 	}
-	get backupId() {
-		return this.context.backupId;
+	get exitCode() {
+		return this.context.exitCode;
+	}
+	get stdout() {
+		return this.context.stdout;
+	}
+	get stderr() {
+		return this.context.stderr;
+	}
+};
+var InvalidProcessCwdError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "InvalidProcessCwdError";
+	}
+};
+var InvalidProcessEnvironmentError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "InvalidProcessEnvironmentError";
+	}
+};
+var InvalidProcessCursorError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "InvalidProcessCursorError";
+	}
+};
+var ProcessSpawnFailedError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "ProcessSpawnFailedError";
 	}
 };
 /**
-* Error thrown when backup restoration fails
+* Error thrown when a process is not found
 */
-var BackupRestoreError = class extends SandboxError {
+var ProcessNotFoundError = class extends SandboxError {
 	constructor(errorResponse) {
 		super(errorResponse);
-		this.name = "BackupRestoreError";
+		this.name = "ProcessNotFoundError";
 	}
-	get dir() {
-		return this.context.dir;
+	get processId() {
+		return this.context.processId;
 	}
-	get backupId() {
-		return this.context.backupId;
+};
+/**
+* Generic process error
+*/
+var ProcessError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "ProcessError";
+	}
+	get processId() {
+		return this.context.processId;
+	}
+	get pid() {
+		return this.context.pid;
+	}
+	get exitCode() {
+		return this.context.exitCode;
+	}
+	get stderr() {
+		return this.context.stderr;
 	}
 };
-var ContainerUnavailableError = class extends SandboxError {
+var StaleProcessHandleError = class extends SandboxError {
 	constructor(errorResponse) {
 		super(errorResponse);
-		this.name = "ContainerUnavailableError";
+		this.name = "StaleProcessHandleError";
+	}
+	get processId() {
+		return this.context.processId;
+	}
+	get pid() {
+		return this.context.pid;
+	}
+	get operation() {
+		return this.context.operation;
 	}
 };
-var OperationInterruptedError = class extends SandboxError {
+var ProcessWaitTimeoutError = class extends SandboxError {
 	constructor(errorResponse) {
 		super(errorResponse);
-		this.name = "OperationInterruptedError";
+		this.name = "ProcessWaitTimeoutError";
 	}
-	get reason() {
-		return this.context.reason;
+	get processId() {
+		return this.context.processId;
 	}
-	get retryable() {
-		return this.context.retryable;
+	get operation() {
+		return this.context.operation;
 	}
-	get operationName() {
+	get timeout() {
+		return this.context.timeout;
+	}
+};
+var ProcessAbortedError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "ProcessAbortedError";
+	}
+	get processId() {
+		return this.context.processId;
+	}
+	get operation() {
 		return this.context.operation;
 	}
 };
-/**
-* Raised when the capnweb WebSocket session itself fails on the SDK side.
-* Unlike the rest of the SandboxError tree, the container never produces
-* this error — it is synthesised by `translateRPCError` from the plain
-* Errors capnweb / DeferredTransport raise when the connection dies.
-*
-* `kind` distinguishes the failure mode (peer close, upgrade failed, etc.)
-* so callers can branch on a structured code instead of substring-matching
-* on the message.
-*
-* Always retryable: the SDK opens a fresh connection on the next call.
-*/
-var RPCTransportError = class extends SandboxError {
-	constructor(errorResponse, options) {
-		super(errorResponse, options);
-		this.name = "RPCTransportError";
+var ProcessReadyTimeoutError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "ProcessReadyTimeoutError";
 	}
-	get kind() {
-		return this.errorResponse.context.kind;
+	get processId() {
+		return this.context.processId;
 	}
-	get originalMessage() {
-		return this.errorResponse.context.originalMessage;
+	get command() {
+		return this.context.command;
+	}
+	get condition() {
+		return this.context.condition;
+	}
+	get timeout() {
+		return this.context.timeout;
+	}
+};
+var ProcessExitedBeforeLogError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "ProcessExitedBeforeLogError";
+	}
+	get processId() {
+		return this.context.processId;
+	}
+	get pid() {
+		return this.context.pid;
+	}
+	get exit() {
+		return this.context.exit;
+	}
+};
+var ProcessExitedBeforeReadyError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "ProcessExitedBeforeReadyError";
+	}
+	get processId() {
+		return this.context.processId;
+	}
+	get command() {
+		return this.context.command;
+	}
+	get condition() {
+		return this.context.condition;
+	}
+	get exitCode() {
+		return this.context.exitCode;
+	}
+};
+
+//#endregion
+//#region src/errors/classes/runtime-control-protocol.ts
+var RuntimeControlProtocolError = class extends SandboxError {
+	constructor(message, context, options) {
+		super({
+			code: ErrorCode.INTERNAL_ERROR,
+			message,
+			context,
+			httpStatus: getHttpStatus(ErrorCode.INTERNAL_ERROR),
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		}, options);
+		this.name = "RuntimeControlProtocolError";
+	}
+};
+
+//#endregion
+//#region src/errors/classes/runtime-inactive.ts
+var RuntimeIdentityInactiveError = class extends Error {
+	constructor() {
+		super("Runtime identity is no longer active");
+		this.name = "RuntimeIdentityInactiveError";
 	}
 };
 
 //#endregion
 //#region src/errors/adapter.ts
+function isStaleProcessHandleResponse(errorResponse) {
+	const { context } = errorResponse;
+	return errorResponse.code === ErrorCode.STALE_PROCESS_HANDLE && "processId" in context && typeof context.processId === "string" && "pid" in context && typeof context.pid === "number" && "operation" in context && typeof context.operation === "string";
+}
+function isStaleTerminalHandleResponse(errorResponse) {
+	const { context } = errorResponse;
+	return errorResponse.code === ErrorCode.STALE_TERMINAL_HANDLE && "terminalId" in context && typeof context.terminalId === "string" && "operation" in context && typeof context.operation === "string";
+}
+function isProcessWaitTimeoutResponse(errorResponse) {
+	const { context } = errorResponse;
+	return errorResponse.code === ErrorCode.PROCESS_WAIT_TIMEOUT && "processId" in context && typeof context.processId === "string" && "operation" in context && (context.operation === "output" || context.operation === "waitForExit" || context.operation === "waitForLog") && "timeout" in context && typeof context.timeout === "number";
+}
+function isProcessAbortedResponse(errorResponse) {
+	const { context } = errorResponse;
+	return errorResponse.code === ErrorCode.PROCESS_ABORTED && "processId" in context && typeof context.processId === "string" && "operation" in context && typeof context.operation === "string";
+}
 /**
 * Convert ErrorResponse to appropriate Error class
 * Simple switch statement - we trust the container sends correct context
@@ -695,12 +830,29 @@ function createErrorFromResponse(errorResponse, options) {
 		case ErrorCode.COMMAND_EXECUTION_ERROR:
 		case ErrorCode.INVALID_COMMAND:
 		case ErrorCode.STREAM_START_ERROR: return new CommandError(errorResponse);
+		case ErrorCode.INVALID_PROCESS_CWD: return new InvalidProcessCwdError(errorResponse);
+		case ErrorCode.INVALID_PROCESS_ENVIRONMENT: return new InvalidProcessEnvironmentError(errorResponse);
+		case ErrorCode.INVALID_PROCESS_CURSOR: return new InvalidProcessCursorError(errorResponse);
+		case ErrorCode.PROCESS_SPAWN_FAILED: return new ProcessSpawnFailedError(errorResponse);
 		case ErrorCode.PROCESS_NOT_FOUND: return new ProcessNotFoundError(errorResponse);
+		case ErrorCode.STALE_PROCESS_HANDLE:
+			if (isStaleProcessHandleResponse(errorResponse)) return new StaleProcessHandleError(errorResponse);
+			return new SandboxError(errorResponse);
+		case ErrorCode.STALE_TERMINAL_HANDLE:
+			if (isStaleTerminalHandleResponse(errorResponse)) return new StaleTerminalHandleError(errorResponse);
+			return new SandboxError(errorResponse);
+		case ErrorCode.PROCESS_WAIT_TIMEOUT:
+			if (isProcessWaitTimeoutResponse(errorResponse)) return new ProcessWaitTimeoutError(errorResponse);
+			return new SandboxError(errorResponse);
+		case ErrorCode.PROCESS_ABORTED:
+			if (isProcessAbortedResponse(errorResponse)) return new ProcessAbortedError(errorResponse);
+			return new SandboxError(errorResponse);
+		case ErrorCode.TERMINAL_NOT_FOUND: return new TerminalNotFoundError(errorResponse);
+		case ErrorCode.INVALID_TERMINAL_CWD: return new InvalidTerminalCwdError(errorResponse);
+		case ErrorCode.INVALID_TERMINAL_CURSOR: return new InvalidTerminalCursorError(errorResponse);
+		case ErrorCode.TERMINAL_CONTROL_ERROR: return new TerminalControlError(errorResponse);
 		case ErrorCode.PROCESS_PERMISSION_DENIED:
 		case ErrorCode.PROCESS_ERROR: return new ProcessError(errorResponse);
-		case ErrorCode.SESSION_ALREADY_EXISTS: return new SessionAlreadyExistsError(errorResponse);
-		case ErrorCode.SESSION_DESTROYED: return new SessionDestroyedError(errorResponse);
-		case ErrorCode.SESSION_TERMINATED: return new SessionTerminatedError(errorResponse);
 		case ErrorCode.PORT_ALREADY_EXPOSED: return new PortAlreadyExposedError(errorResponse);
 		case ErrorCode.PORT_NOT_EXPOSED: return new PortNotExposedError(errorResponse);
 		case ErrorCode.INVALID_PORT_NUMBER:
@@ -737,5 +889,5 @@ function createErrorFromResponse(errorResponse, options) {
 }
 
 //#endregion
-export { PortError as A, SessionAlreadyExistsError as B, InterpreterNotReadyError as C, OperationInterruptedError as D, InvalidPortError as E, ProcessNotFoundError as F, SessionTerminatedError as H, ProcessReadyTimeoutError as I, RPCTransportError as L, PortNotExposedError as M, ProcessError as N, PermissionDeniedError as O, ProcessExitedBeforeReadyError as P, SandboxError as R, GitRepositoryNotFoundError as S, InvalidGitUrlError as T, ValidationFailedError as U, SessionDestroyedError as V, GitBranchNotFoundError as _, BackupRestoreError as a, GitError as b, CommandNotFoundError as c, CustomDomainRequiredError as d, FileExistsError as f, GitAuthenticationError as g, FileTooLargeError as h, BackupNotFoundError as i, PortInUseError as j, PortAlreadyExposedError as k, ContainerUnavailableError as l, FileSystemError as m, BackupCreateError as n, CodeExecutionError as o, FileNotFoundError as p, BackupExpiredError as r, CommandError as s, createErrorFromResponse as t, ContextNotFoundError as u, GitCheckoutError as v, InvalidBackupConfigError as w, GitNetworkError as x, GitCloneError as y, ServiceNotRespondingError as z };
-//# sourceMappingURL=errors-ewgSNicb.js.map
+export { TerminalControlError as $, GitCloneError as A, FileTooLargeError as B, PortNotExposedError as C, GitAuthenticationError as D, ContextNotFoundError as E, InvalidGitUrlError as F, BackupRestoreError as G, BackupCreateError as H, ValidationFailedError as I, InvalidTerminalCursorError as J, ContainerUnavailableError as K, FileExistsError as L, GitNetworkError as M, GitRepositoryNotFoundError as N, GitBranchNotFoundError as O, InterpreterNotReadyError as P, StaleTerminalHandleError as Q, FileNotFoundError as R, PortInUseError as S, CodeExecutionError as T, BackupExpiredError as U, PermissionDeniedError as V, BackupNotFoundError as W, OperationInterruptedError as X, InvalidTerminalCwdError as Y, RPCTransportError as Z, StaleProcessHandleError as _, CommandNotFoundError as a, PortAlreadyExposedError as b, InvalidProcessEnvironmentError as c, ProcessExitedBeforeLogError as d, TerminalNotFoundError as et, ProcessExitedBeforeReadyError as f, ProcessWaitTimeoutError as g, ProcessSpawnFailedError as h, CommandError as i, GitError as j, GitCheckoutError as k, ProcessAbortedError as l, ProcessReadyTimeoutError as m, RuntimeIdentityInactiveError as n, InvalidProcessCursorError as o, ProcessNotFoundError as p, InvalidBackupConfigError as q, RuntimeControlProtocolError as r, InvalidProcessCwdError as s, createErrorFromResponse as t, SandboxError as tt, ProcessError as u, CustomDomainRequiredError as v, ServiceNotRespondingError as w, PortError as x, InvalidPortError as y, FileSystemError as z };
+//# sourceMappingURL=errors-QYlSkVGz.js.map