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

package/dist/errors-QYlSkVGz.js

@@ -0,0 +1,893 @@
+import { i as ErrorCode, r as getHttpStatus } from "./errors-CXR0xBpw.js";
+
+//#region src/errors/classes/base.ts
+var SandboxError = class extends Error {
+	constructor(errorResponse, options) {
+		super(errorResponse.message, options);
+		this.errorResponse = errorResponse;
+		this.name = "SandboxError";
+	}
+	get code() {
+		return this.errorResponse.code;
+	}
+	get context() {
+		return this.errorResponse.context;
+	}
+	get httpStatus() {
+		return this.errorResponse.httpStatus;
+	}
+	get operation() {
+		return this.errorResponse.operation;
+	}
+	get suggestion() {
+		return this.errorResponse.suggestion;
+	}
+	get timestamp() {
+		return this.errorResponse.timestamp;
+	}
+	get documentation() {
+		return this.errorResponse.documentation;
+	}
+	toJSON() {
+		return {
+			name: this.name,
+			message: this.message,
+			code: this.code,
+			context: this.context,
+			httpStatus: this.httpStatus,
+			operation: this.operation,
+			suggestion: this.suggestion,
+			timestamp: this.timestamp,
+			documentation: this.documentation,
+			stack: this.stack
+		};
+	}
+};
+
+//#endregion
+//#region src/errors/classes/backup-terminal-lifecycle.ts
+/**
+* Error thrown when a backup is not found in R2
+*/
+var BackupNotFoundError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "BackupNotFoundError";
+	}
+	get backupId() {
+		return this.context.backupId;
+	}
+};
+/**
+* Error thrown when a backup has expired (past its TTL)
+*/
+var BackupExpiredError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "BackupExpiredError";
+	}
+	get backupId() {
+		return this.context.backupId;
+	}
+	get expiredAt() {
+		return this.context.expiredAt;
+	}
+};
+/**
+* Error thrown when backup configuration or inputs are invalid
+*/
+var InvalidBackupConfigError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "InvalidBackupConfigError";
+	}
+	get reason() {
+		return this.context.reason;
+	}
+};
+/**
+* Error thrown when backup creation fails
+*/
+var BackupCreateError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "BackupCreateError";
+	}
+	get dir() {
+		return this.context.dir;
+	}
+	get backupId() {
+		return this.context.backupId;
+	}
+};
+/**
+* Error thrown when backup restoration fails
+*/
+var BackupRestoreError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "BackupRestoreError";
+	}
+	get dir() {
+		return this.context.dir;
+	}
+	get backupId() {
+		return this.context.backupId;
+	}
+};
+var TerminalNotFoundError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "TerminalNotFoundError";
+	}
+	get terminalId() {
+		return this.context.terminalId;
+	}
+};
+var InvalidTerminalCwdError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "InvalidTerminalCwdError";
+	}
+	get terminalId() {
+		return this.context.terminalId;
+	}
+	get cwd() {
+		return this.context.cwd;
+	}
+};
+var InvalidTerminalCursorError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "InvalidTerminalCursorError";
+	}
+	get terminalId() {
+		return this.context.terminalId;
+	}
+};
+var TerminalControlError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "TerminalControlError";
+	}
+	get terminalId() {
+		return this.context.terminalId;
+	}
+	get operationName() {
+		return this.context.operation;
+	}
+};
+var StaleTerminalHandleError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "StaleTerminalHandleError";
+	}
+	get terminalId() {
+		return this.context.terminalId;
+	}
+	get operation() {
+		return this.context.operation;
+	}
+};
+var ContainerUnavailableError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "ContainerUnavailableError";
+	}
+};
+var OperationInterruptedError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "OperationInterruptedError";
+	}
+	get reason() {
+		return this.context.reason;
+	}
+	get retryable() {
+		return this.context.retryable;
+	}
+	get operationName() {
+		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";
+	}
+	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 file or directory is not found
+*/
+var FileNotFoundError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "FileNotFoundError";
+	}
+	get path() {
+		return this.context.path;
+	}
+};
+/**
+* Error thrown when a file already exists
+*/
+var FileExistsError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "FileExistsError";
+	}
+	get path() {
+		return this.context.path;
+	}
+};
+/**
+* Error thrown when a file is too large
+*/
+var FileTooLargeError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "FileTooLargeError";
+	}
+	get path() {
+		return this.context.path;
+	}
+};
+/**
+* Generic file system error (permissions, disk full, etc.)
+*/
+var FileSystemError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "FileSystemError";
+	}
+	get path() {
+		return this.context.path;
+	}
+	get stderr() {
+		return this.context.stderr;
+	}
+	get exitCode() {
+		return this.context.exitCode;
+	}
+};
+/**
+* Error thrown when permission is denied
+*/
+var PermissionDeniedError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		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
+*/
+var GitRepositoryNotFoundError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "GitRepositoryNotFoundError";
+	}
+	get repository() {
+		return this.context.repository;
+	}
+};
+/**
+* Error thrown when git authentication fails
+*/
+var GitAuthenticationError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "GitAuthenticationError";
+	}
+	get repository() {
+		return this.context.repository;
+	}
+};
+/**
+* Error thrown when a git branch is not found
+*/
+var GitBranchNotFoundError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "GitBranchNotFoundError";
+	}
+	get branch() {
+		return this.context.branch;
+	}
+	get repository() {
+		return this.context.repository;
+	}
+};
+/**
+* Error thrown when a git network operation fails
+*/
+var GitNetworkError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "GitNetworkError";
+	}
+	get repository() {
+		return this.context.repository;
+	}
+	get branch() {
+		return this.context.branch;
+	}
+	get targetDir() {
+		return this.context.targetDir;
+	}
+};
+/**
+* Error thrown when git clone fails
+*/
+var GitCloneError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "GitCloneError";
+	}
+	get repository() {
+		return this.context.repository;
+	}
+	get targetDir() {
+		return this.context.targetDir;
+	}
+	get stderr() {
+		return this.context.stderr;
+	}
+	get exitCode() {
+		return this.context.exitCode;
+	}
+};
+/**
+* Error thrown when git checkout fails
+*/
+var GitCheckoutError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "GitCheckoutError";
+	}
+	get branch() {
+		return this.context.branch;
+	}
+	get repository() {
+		return this.context.repository;
+	}
+	get stderr() {
+		return this.context.stderr;
+	}
+};
+/**
+* Error thrown when a git URL is invalid
+*/
+var InvalidGitUrlError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "InvalidGitUrlError";
+	}
+	get validationErrors() {
+		return this.context.validationErrors;
+	}
+};
+/**
+* Generic git operation error
+*/
+var GitError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "GitError";
+	}
+	get repository() {
+		return this.context.repository;
+	}
+	get branch() {
+		return this.context.branch;
+	}
+	get targetDir() {
+		return this.context.targetDir;
+	}
+	get stderr() {
+		return this.context.stderr;
+	}
+	get exitCode() {
+		return this.context.exitCode;
+	}
+};
+/**
+* Error thrown when interpreter is not ready
+*/
+var InterpreterNotReadyError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "InterpreterNotReadyError";
+	}
+	get retryAfter() {
+		return this.context.retryAfter;
+	}
+	get progress() {
+		return this.context.progress;
+	}
+};
+/**
+* Error thrown when a context is not found
+*/
+var ContextNotFoundError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "ContextNotFoundError";
+	}
+	get contextId() {
+		return this.context.contextId;
+	}
+};
+/**
+* Error thrown when code execution fails
+*/
+var CodeExecutionError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "CodeExecutionError";
+	}
+	get contextId() {
+		return this.context.contextId;
+	}
+	get ename() {
+		return this.context.ename;
+	}
+	get evalue() {
+		return this.context.evalue;
+	}
+	get traceback() {
+		return this.context.traceback;
+	}
+};
+/**
+* Error thrown when validation fails
+*/
+var ValidationFailedError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "ValidationFailedError";
+	}
+	get validationErrors() {
+		return this.context.validationErrors;
+	}
+};
+
+//#endregion
+//#region src/errors/classes/port.ts
+/**
+* Error thrown when exposing a port that is already exposed.
+*/
+var PortAlreadyExposedError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "PortAlreadyExposedError";
+	}
+	get port() {
+		return this.context.port;
+	}
+	get portName() {
+		return this.context.portName;
+	}
+};
+/**
+* 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 port number is invalid
+*/
+var InvalidPortError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "InvalidPortError";
+	}
+	get port() {
+		return this.context.port;
+	}
+	get reason() {
+		return this.context.reason;
+	}
+};
+/**
+* Error thrown when a service on a port is not responding
+*/
+var ServiceNotRespondingError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "ServiceNotRespondingError";
+	}
+	get port() {
+		return this.context.port;
+	}
+	get portName() {
+		return this.context.portName;
+	}
+};
+/**
+* Error thrown when a port is already in use
+*/
+var PortInUseError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "PortInUseError";
+	}
+	get port() {
+		return this.context.port;
+	}
+};
+/**
+* Generic port operation error
+*/
+var PortError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "PortError";
+	}
+	get port() {
+		return this.context.port;
+	}
+	get portName() {
+		return this.context.portName;
+	}
+	get stderr() {
+		return this.context.stderr;
+	}
+};
+/**
+* Error thrown when port exposure requires a custom domain
+*/
+var CustomDomainRequiredError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "CustomDomainRequiredError";
+	}
+};
+
+//#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;
+	}
+};
+/**
+* Generic command execution error
+*/
+var CommandError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "CommandError";
+	}
+	get command() {
+		return this.context.command;
+	}
+	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 a process is not found
+*/
+var ProcessNotFoundError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "ProcessNotFoundError";
+	}
+	get processId() {
+		return this.context.processId;
+	}
+};
+/**
+* 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 StaleProcessHandleError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "StaleProcessHandleError";
+	}
+	get processId() {
+		return this.context.processId;
+	}
+	get pid() {
+		return this.context.pid;
+	}
+	get operation() {
+		return this.context.operation;
+	}
+};
+var ProcessWaitTimeoutError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "ProcessWaitTimeoutError";
+	}
+	get processId() {
+		return this.context.processId;
+	}
+	get operation() {
+		return this.context.operation;
+	}
+	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;
+	}
+};
+var ProcessReadyTimeoutError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "ProcessReadyTimeoutError";
+	}
+	get processId() {
+		return this.context.processId;
+	}
+	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
+*/
+function createErrorFromResponse(errorResponse, options) {
+	switch (errorResponse.code) {
+		case ErrorCode.FILE_NOT_FOUND: return new FileNotFoundError(errorResponse);
+		case ErrorCode.FILE_EXISTS: return new FileExistsError(errorResponse);
+		case ErrorCode.FILE_TOO_LARGE: return new FileTooLargeError(errorResponse);
+		case ErrorCode.PERMISSION_DENIED: return new PermissionDeniedError(errorResponse);
+		case ErrorCode.IS_DIRECTORY:
+		case ErrorCode.NOT_DIRECTORY:
+		case ErrorCode.NO_SPACE:
+		case ErrorCode.TOO_MANY_FILES:
+		case ErrorCode.RESOURCE_BUSY:
+		case ErrorCode.READ_ONLY:
+		case ErrorCode.NAME_TOO_LONG:
+		case ErrorCode.TOO_MANY_LINKS:
+		case ErrorCode.FILESYSTEM_ERROR: return new FileSystemError(errorResponse);
+		case ErrorCode.COMMAND_NOT_FOUND: return new CommandNotFoundError(errorResponse);
+		case ErrorCode.COMMAND_PERMISSION_DENIED:
+		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.PORT_ALREADY_EXPOSED: return new PortAlreadyExposedError(errorResponse);
+		case ErrorCode.PORT_NOT_EXPOSED: return new PortNotExposedError(errorResponse);
+		case ErrorCode.INVALID_PORT_NUMBER:
+		case ErrorCode.INVALID_PORT: return new InvalidPortError(errorResponse);
+		case ErrorCode.SERVICE_NOT_RESPONDING: return new ServiceNotRespondingError(errorResponse);
+		case ErrorCode.PORT_IN_USE: return new PortInUseError(errorResponse);
+		case ErrorCode.PORT_OPERATION_ERROR: return new PortError(errorResponse);
+		case ErrorCode.CUSTOM_DOMAIN_REQUIRED: return new CustomDomainRequiredError(errorResponse);
+		case ErrorCode.GIT_REPOSITORY_NOT_FOUND: return new GitRepositoryNotFoundError(errorResponse);
+		case ErrorCode.GIT_AUTH_FAILED: return new GitAuthenticationError(errorResponse);
+		case ErrorCode.GIT_BRANCH_NOT_FOUND: return new GitBranchNotFoundError(errorResponse);
+		case ErrorCode.GIT_NETWORK_ERROR: return new GitNetworkError(errorResponse);
+		case ErrorCode.GIT_CLONE_FAILED: return new GitCloneError(errorResponse);
+		case ErrorCode.GIT_CHECKOUT_FAILED: return new GitCheckoutError(errorResponse);
+		case ErrorCode.INVALID_GIT_URL: return new InvalidGitUrlError(errorResponse);
+		case ErrorCode.GIT_OPERATION_FAILED: return new GitError(errorResponse);
+		case ErrorCode.BACKUP_NOT_FOUND: return new BackupNotFoundError(errorResponse);
+		case ErrorCode.BACKUP_EXPIRED: return new BackupExpiredError(errorResponse);
+		case ErrorCode.INVALID_BACKUP_CONFIG: return new InvalidBackupConfigError(errorResponse);
+		case ErrorCode.BACKUP_CREATE_FAILED: return new BackupCreateError(errorResponse);
+		case ErrorCode.BACKUP_RESTORE_FAILED: return new BackupRestoreError(errorResponse);
+		case ErrorCode.INTERPRETER_NOT_READY: return new InterpreterNotReadyError(errorResponse);
+		case ErrorCode.CONTEXT_NOT_FOUND: return new ContextNotFoundError(errorResponse);
+		case ErrorCode.CODE_EXECUTION_ERROR: return new CodeExecutionError(errorResponse);
+		case ErrorCode.CONTAINER_UNAVAILABLE: return new ContainerUnavailableError(errorResponse);
+		case ErrorCode.OPERATION_INTERRUPTED: return new OperationInterruptedError(errorResponse);
+		case ErrorCode.RPC_TRANSPORT_ERROR: return new RPCTransportError(errorResponse, options);
+		case ErrorCode.VALIDATION_FAILED: return new ValidationFailedError(errorResponse);
+		case ErrorCode.INVALID_JSON_RESPONSE:
+		case ErrorCode.UNKNOWN_ERROR:
+		case ErrorCode.INTERNAL_ERROR: return new SandboxError(errorResponse);
+		default: return new SandboxError(errorResponse);
+	}
+}
+
+//#endregion
+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