@phpsandbox/sdk 0.1.9 → 0.1.11

package/dist/browser/phpsandbox-sdk.iife.js

@@ -28,131 +28,147 @@ var PHPSandbox = (() => {
   // src/index.ts
   var index_exports = {};
   __export(index_exports, {
-    ApiError: () => ApiError,
-    Client: () => Client,
-    CommandError: () => CommandError,
-    ComposerCredentials: () => ComposerCredentials,
-    ErrorEvent: () => ErrorEvent,
-    Feedback: () => Feedback,
     FileChangeFilter: () => FileChangeFilter,
     FileChangeType: () => FileChangeType,
     FileType: () => FileType,
-    Filesystem: () => Filesystem,
-    FilesystemError: () => FilesystemError,
-    FilesystemErrorType: () => FilesystemErrorType,
-    GitTarget: () => GitTarget,
-    GitTargetApi: () => GitTargetApi,
-    Integration: () => Integration,
-    IntegrationApi: () => IntegrationApi,
     LspConnection: () => LspConnection,
-    NotebookApi: () => NotebookApi,
-    NotebookComposerCredentialApi: () => NotebookComposerCredentialApi,
-    NotebookInitError: () => NotebookInitError,
     NotebookInstance: () => NotebookInstance,
-    NotebookMail: () => NotebookMail,
-    NotebookMailApi: () => NotebookMailApi,
-    NotebookPreview: () => NotebookPreview,
-    NotebookPreviewApi: () => NotebookPreviewApi,
-    NotebookPublicationApi: () => NotebookPublicationApi,
-    NotebookSecretApi: () => NotebookSecretApi,
-    NotebookSecrets: () => NotebookSecrets,
-    NotebookState: () => NotebookState,
-    NotebookUnavailableError: () => NotebookUnavailableError,
     PHPSandbox: () => PHPSandbox,
     PHPSandboxError: () => PHPSandboxError,
-    ProcessReadable: () => ProcessReadable,
-    ProcessResult: () => ProcessResult,
-    PromiseTimeoutError: () => PromiseTimeoutError,
-    PublicationApi: () => PublicationApi,
-    PublicationBuildStatusSchema: () => PublicationBuildStatusSchema,
-    PublicationDomainDnsRecordTypeSchema: () => PublicationDomainDnsRecordTypeSchema,
-    PublicationEventDataSchema: () => PublicationEventDataSchema,
-    PublicationInstance: () => PublicationInstance,
-    PublicationJurisdictionSchema: () => PublicationJurisdictionSchema,
-    PublicationLogChunkDataSchema: () => PublicationLogChunkDataSchema,
-    PublicationLogStreamSchema: () => PublicationLogStreamSchema,
-    PublicationProtectionModeSchema: () => PublicationProtectionModeSchema,
-    PublicationProviderNameSchema: () => PublicationProviderNameSchema,
-    PublicationRegionSchema: () => PublicationRegionSchema,
-    PublicationReleaseStatusSchema: () => PublicationReleaseStatusSchema,
-    PublicationRun: () => PublicationRun,
-    PublicationSizeSchema: () => PublicationSizeSchema,
-    PublicationStatusSchema: () => PublicationStatusSchema,
-    PublishStreamErrorSchema: () => PublishStreamErrorSchema,
-    PublishStreamEventSchema: () => PublishStreamEventSchema,
-    PublishStreamLogEventSchema: () => PublishStreamLogEventSchema,
-    PublishStreamLogSchema: () => PublishStreamLogSchema,
-    PublishStreamLogStreamSchema: () => PublishStreamLogStreamSchema,
-    PublishStreamPhaseEventSchema: () => PublishStreamPhaseEventSchema,
-    PublishStreamPhaseSchema: () => PublishStreamPhaseSchema,
-    PublishStreamResultEventSchema: () => PublishStreamResultEventSchema,
-    PublishStreamResultSchema: () => PublishStreamResultSchema,
-    PublishStreamSseDoneEventSchema: () => PublishStreamSseDoneEventSchema,
-    PublishStreamSseErrorEventSchema: () => PublishStreamSseErrorEventSchema,
-    PublishStreamSseEventNameSchema: () => PublishStreamSseEventNameSchema,
-    PublishStreamSseEventSchema: () => PublishStreamSseEventSchema,
-    PublishStreamSseLogEventSchema: () => PublishStreamSseLogEventSchema,
-    PublishStreamSsePhaseEventSchema: () => PublishStreamSsePhaseEventSchema,
-    PublishStreamSseResultEventSchema: () => PublishStreamSseResultEventSchema,
-    RateLimitError: () => RateLimitError,
-    RuntimeTelemetry: () => RuntimeTelemetry,
-    SandboxIntegration: () => SandboxIntegration,
-    SandboxIntegrationApi: () => SandboxIntegrationApi,
-    SendTimeoutError: () => SendTimeoutError,
-    ServerApi: () => ServerApi,
-    ServerInstance: () => ServerInstance,
-    ShellProcess: () => ShellProcess,
-    UnsupportedRuntimeTransportError: () => UnsupportedRuntimeTransportError,
-    integrationId: () => integrationId,
+    RemoteError: () => RemoteError,
+    TransportError: () => TransportError,
     notebookBuiltinServices: () => notebookBuiltinServices,
-    notebookKnownServices: () => notebookKnownServices,
-    once: () => once,
-    sandboxIntegrationId: () => sandboxIntegrationId,
-    timeout: () => timeout,
-    watchRuntimeTelemetry: () => watchRuntimeTelemetry
+    notebookKnownServices: () => notebookKnownServices
   });
 
   // src/errors/index.ts
-  var PromiseTimeoutError = class extends Error {
-    constructor(message, time3) {
+  var remoteErrorCodes = [
+    "ActionNotFound",
+    "AuthenticationRequired",
+    "BadGateway",
+    "BadRequest",
+    "Conflict",
+    "FileAlreadyExists",
+    "FileIsDirectory",
+    "FileNotDirectory",
+    "FileNotFound",
+    "FilesystemUnavailable",
+    "InternalError",
+    "InvalidArgument",
+    "InvalidConfiguration",
+    "InvalidRequest",
+    "InvalidResponse",
+    "InvalidServiceCommand",
+    "MethodNotAllowed",
+    "NotebookInitializationFailed",
+    "NotebookUnavailable",
+    "NotFound",
+    "PayloadTooLarge",
+    "PermissionDenied",
+    "RateLimited",
+    "RequestFailed",
+    "RuntimeOperationFailed",
+    "ServiceNotFound",
+    "ServiceUnavailable",
+    "UnprocessableEntity",
+    "ValidationFailed",
+    "WorkspaceUnavailable"
+  ];
+  var PHPSandboxError = class extends Error {
+    constructor(message, cause) {
       super(message);
-      this.time = time3;
+      this.name = new.target.name;
+      this.cause = cause;
     }
   };
-  var SendTimeoutError = class _SendTimeoutError extends PromiseTimeoutError {
-    static fromPromiseTimeoutError(error51) {
-      return new _SendTimeoutError(error51.message, error51.time);
+  var RemoteError = class _RemoteError extends PHPSandboxError {
+    constructor(message, options) {
+      super(message, options.cause);
+      this.source = options.source;
+      this.status = options.status;
+      this.code = options.code;
+      this.details = options.details;
     }
-  };
-  var NotebookUnavailableError = class extends Error {
-    constructor(message = "Notebook is no longer available", raw = {}) {
-      super(message);
-      this.raw = raw;
-      this.name = "NotebookUnavailableError";
+    static is(error51, code) {
+      return error51 instanceof _RemoteError && (code === void 0 || error51.code === code);
     }
-  };
-  var UnsupportedRuntimeTransportError = class extends Error {
-    constructor(message) {
-      super(message);
-      this.name = "UnsupportedRuntimeTransportError";
+    static isValidation(error51) {
+      return _RemoteError.is(error51, "ValidationFailed") && validationDetails(error51.details) !== void 0;
+    }
+    is(code) {
+      return this.code === code;
     }
   };
-
-  // src/types.ts
-  var ErrorEvent = class extends Error {
-    constructor(code, message, raw = {}) {
-      super(message);
+  var TransportError = class _TransportError extends PHPSandboxError {
+    constructor(message, code, cause) {
+      super(message, cause);
       this.code = code;
-      this.message = message;
-      this.raw = raw;
+    }
+    static is(error51, code) {
+      return error51 instanceof _TransportError && (code === void 0 || error51.code === code);
+    }
+    is(code) {
+      return this.code === code;
     }
   };
-  var RateLimitError = class extends ErrorEvent {
-    constructor(message, raw = {}) {
-      super(429, message, raw);
+  function remoteError(source, payload, cause) {
+    const error51 = record(payload);
+    const status = positiveInteger(error51?.status);
+    const code = nonEmptyString(error51?.code);
+    const message = nonEmptyString(error51?.message);
+    if (status === void 0 || !isRemoteErrorCode(code) || message === void 0) {
+      throw new TransportError("PHPSandbox returned an invalid error response.", "InvalidResponse", cause ?? payload);
+    }
+    return new RemoteError(message, {
+      source,
+      status,
+      code,
+      details: error51?.details,
+      cause
+    });
+  }
+  function isRemoteErrorCode(value) {
+    return typeof value === "string" && remoteErrorCodes.includes(value);
+  }
+  function positiveInteger(value) {
+    return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : void 0;
+  }
+  function nonEmptyString(value) {
+    return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+  }
+  function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+  }
+  function stringArrayRecord(value) {
+    const candidate = record(value);
+    if (candidate === void 0) {
+      return void 0;
+    }
+    const entries = Object.entries(candidate);
+    if (!entries.every(([, messages]) => Array.isArray(messages) && messages.every((message) => typeof message === "string"))) {
+      return void 0;
+    }
+    return Object.fromEntries(entries);
+  }
+  function validationDetails(value) {
+    const details = record(value);
+    const errors = stringArrayRecord(details?.errors);
+    return errors === void 0 ? void 0 : { errors };
+  }
+  var PromiseTimeoutError = class extends Error {
+    constructor(message, time3) {
+      super(message);
+      this.time = time3;
     }
   };
-  var PHPSandboxError = class extends ErrorEvent {
+  var SendTimeoutError = class _SendTimeoutError extends TransportError {
+    constructor(message, time3, cause) {
+      super(message, "SendTimeout", cause);
+      this.time = time3;
+    }
+    static fromPromiseTimeoutError(error51) {
+      return new _SendTimeoutError(error51.message, error51.time, error51);
+    }
   };
 
   // node_modules/nanoid/url-alphabet/index.js
@@ -188,21 +204,6 @@ var PHPSandbox = (() => {
     FileChangeType2[FileChangeType2["DELETED"] = 3] = "DELETED";
     return FileChangeType2;
   })(FileChangeType || {});
-  var FilesystemErrorType = /* @__PURE__ */ ((FilesystemErrorType2) => {
-    FilesystemErrorType2["Unavailable"] = "Unavailable";
-    FilesystemErrorType2["NoPermissions"] = "NoPermissions";
-    FilesystemErrorType2["FileExists"] = "FileExists";
-    FilesystemErrorType2["FileNotFound"] = "FileNotFound";
-    FilesystemErrorType2["FileIsADirectory"] = "FileIsADirectory";
-    FilesystemErrorType2["FileNotADirectory"] = "FileNotADirectory";
-    return FilesystemErrorType2;
-  })(FilesystemErrorType || {});
-  var FilesystemError = class extends ErrorEvent {
-    constructor(inner, name) {
-      super(inner.code, inner.message);
-      this.name = name;
-    }
-  };
   var FilesystemSubscription = class {
     constructor(disposable, onDispose) {
       this.disposable = disposable;
@@ -356,7 +357,7 @@ var PHPSandbox = (() => {
       if (this.okra.runtimeTransport === "rest") {
         return new ReadableStream({
           start(controller) {
-            controller.error(new UnsupportedRuntimeTransportError("Following files requires the realtime transport."));
+            controller.error(new PHPSandboxError("Following files requires the realtime transport."));
           }
         });
       }
@@ -576,9 +577,6 @@ var PHPSandbox = (() => {
       return this.okra.invoke("fs.tree", { path });
     }
     handleError(e) {
-      if (e instanceof ErrorEvent && "name" in e.raw) {
-        throw new FilesystemError(e, e.raw.name);
-      }
       throw e;
     }
   };
@@ -783,38 +781,6 @@ var PHPSandbox = (() => {
     }
   };
 
-  // src/container.ts
-  var NotebookState = /* @__PURE__ */ ((NotebookState2) => {
-    NotebookState2["RUNNING"] = "running";
-    NotebookState2["STOPPED"] = "stopped";
-    NotebookState2["STARTING"] = "starting";
-    NotebookState2["STOPPING"] = "stopping";
-    NotebookState2["KILLED"] = "killed";
-    NotebookState2["ERROR"] = "error";
-    NotebookState2["PROVISIONING"] = "provisioning";
-    return NotebookState2;
-  })(NotebookState || {});
-  var Container = class {
-    constructor(okra) {
-      this.okra = okra;
-    }
-    start() {
-      return this.okra.invoke("container.start");
-    }
-    restart() {
-      return this.okra.invoke("container.restart");
-    }
-    stop() {
-      return this.okra.invoke("container.stop");
-    }
-    state() {
-      return this.okra.invoke("container.state");
-    }
-    setPhp(version2) {
-      return this.okra.invoke("container.set-php", { version: version2 });
-    }
-  };
-
   // src/auth.ts
   var Auth = class {
     constructor(okra) {
@@ -862,7 +828,7 @@ var PHPSandbox = (() => {
       return LspConnection.create(id, this);
     }
     whenSocketConnected() {
-      return this.okra.whenConnected();
+      return this.okra.connected();
     }
   };
   var LspConnection = class _LspConnection {
@@ -908,26 +874,6 @@ var PHPSandbox = (() => {
       opts: { tty: false, ...resolvedOpts }
     };
   }
-  var CommandError = class extends Error {
-    constructor(result) {
-      super(result.output);
-      this.result = result;
-    }
-  };
-  var ProcessResult = class {
-    constructor(output, stdout, stderr, exitCode) {
-      this.output = output;
-      this.stdout = stdout;
-      this.stderr = stderr;
-      this.exitCode = exitCode;
-    }
-    throw() {
-      if (this.exitCode !== 0) {
-        throw new CommandError(this);
-      }
-      return this;
-    }
-  };
   var ProcessReadable = class {
     constructor() {
       this.controller = null;
@@ -1015,7 +961,7 @@ var PHPSandbox = (() => {
         { abortSignal }
       ).then((result) => {
         finish();
-        return new ProcessResult(result.output, result.stdout, result.stderr, result.exitCode);
+        return result;
       }).catch((error51) => {
         fail(error51);
         throw error51;
@@ -1040,6 +986,24 @@ var PHPSandbox = (() => {
   };
 
   // src/composer.ts
+  var ComposerCredentials = class {
+    constructor(client, notebookId) {
+      this.client = client;
+      this.notebookId = notebookId;
+    }
+    async set(input) {
+      const response = await this.client.put(
+        `/notebook/${this.notebookId}/composer/credentials`,
+        input
+      );
+      return response.data;
+    }
+    async remove(type, url2) {
+      const params = new URLSearchParams({ type });
+      if (url2) params.set("url", url2);
+      await this.client.delete(`/notebook/${this.notebookId}/composer/credentials?${params.toString()}`);
+    }
+  };
   var ComposerProcess = class {
     constructor(id, okra, command, args, options) {
       this.id = id;
@@ -1077,7 +1041,7 @@ var PHPSandbox = (() => {
       };
       this.completion = this.okra.invoke("composer.invoke", { id, command, args, options }).then((result) => {
         finish();
-        return new ProcessResult(result.output, result.stdout, result.stderr, result.exitCode);
+        return result;
       }).catch((error51) => {
         fail(error51);
         throw error51;
@@ -1098,21 +1062,6 @@ var PHPSandbox = (() => {
     run(command, args = {}, options = {}) {
       return new ComposerProcess(nanoid(), this.okra, command, args, options);
     }
-    dumpAutoload(options = {}) {
-      return this.run("dump-autoload", {}, options);
-    }
-    install(options = {}) {
-      return this.run("install", {}, options);
-    }
-    update(args, options = {}) {
-      return this.run("update", args, options);
-    }
-    require(packages, options = {}) {
-      return this.run("require", packages, options);
-    }
-    remove(args, options = {}) {
-      return this.run("remove", args, options);
-    }
     packages() {
       return this.okra.invoke("composer.packages");
     }
@@ -1272,6 +1221,50 @@ var PHPSandbox = (() => {
     }
   };
 
+  // src/runtime.ts
+  var RuntimeMetrics = class {
+    constructor(metrics) {
+      this.metrics = metrics;
+    }
+    current() {
+      return this.metrics.current();
+    }
+    watch(options = {}) {
+      return this.metrics.watch(options);
+    }
+  };
+  var RuntimeLogs = class {
+    constructor(logs) {
+      this.logs = logs;
+    }
+    follow(options = {}) {
+      return this.logs.follow(options);
+    }
+  };
+  var RuntimePorts = class {
+    constructor(ports) {
+      this.ports = ports;
+    }
+    list() {
+      return this.ports.list();
+    }
+    watch(options = {}) {
+      return this.ports.watch(options);
+    }
+  };
+  var Runtime = class {
+    constructor(notebook) {
+      this.notebook = notebook;
+      const telemetry = new RuntimeTelemetry(notebook);
+      this.metrics = new RuntimeMetrics(new Metrics(notebook, telemetry));
+      this.logs = new RuntimeLogs(new Logs(notebook, telemetry));
+      this.ports = new RuntimePorts(new Ports(notebook, telemetry));
+    }
+    setPhpVersion(version2) {
+      return this.notebook.invoke("container.set-php", { version: version2 });
+    }
+  };
+
   // src/repl.ts
   var Repl = class {
     constructor(okra) {
@@ -2159,24 +2152,24 @@ var PHPSandbox = (() => {
     }
     find(bytes, inputOffset, byteLength) {
       const records = this.caches[byteLength - 1];
-      FIND_CHUNK: for (const record2 of records) {
-        const recordBytes = record2.bytes;
+      FIND_CHUNK: for (const record3 of records) {
+        const recordBytes = record3.bytes;
         for (let j = 0; j < byteLength; j++) {
           if (recordBytes[j] !== bytes[inputOffset + j]) {
             continue FIND_CHUNK;
           }
         }
-        return record2.str;
+        return record3.str;
       }
       return null;
     }
     store(bytes, value) {
       const records = this.caches[bytes.length - 1];
-      const record2 = { bytes, str: value };
+      const record3 = { bytes, str: value };
       if (records.length >= this.maxLengthPerKey) {
-        records[Math.random() * records.length | 0] = record2;
+        records[Math.random() * records.length | 0] = record3;
       } else {
-        records.push(record2);
+        records.push(record3);
       }
     }
     decode(bytes, inputOffset, byteLength) {
@@ -2926,17 +2919,17 @@ var PHPSandbox = (() => {
       return Event2;
     })()
   );
-  var ErrorEvent2 = (
+  var ErrorEvent = (
     /** @class */
     (function(_super) {
-      __extends(ErrorEvent3, _super);
-      function ErrorEvent3(error51, target) {
+      __extends(ErrorEvent2, _super);
+      function ErrorEvent2(error51, target) {
         var _this = _super.call(this, "error", target) || this;
         _this.message = error51.message;
         _this.error = error51;
         return _this;
       }
-      return ErrorEvent3;
+      return ErrorEvent2;
     })(Event)
   );
   var CloseEvent = (
@@ -3361,7 +3354,7 @@ var PHPSandbox = (() => {
       };
       ReconnectingWebSocket3.prototype._handleTimeout = function() {
         this._debug("timeout event");
-        this._handleError(new ErrorEvent2(Error("TIMEOUT"), this));
+        this._handleError(new ErrorEvent(Error("TIMEOUT"), this));
       };
       ReconnectingWebSocket3.prototype._disconnect = function(code, reason) {
         if (code === void 0) {
@@ -3448,12 +3441,12 @@ var PHPSandbox = (() => {
     if (!value || typeof value !== "object") {
       return void 0;
     }
-    const record2 = value;
-    const message = typeof record2.message === "string" && record2.message ? record2.message : typeof record2.reason === "string" && record2.reason ? record2.reason : void 0;
+    const record3 = value;
+    const message = typeof record3.message === "string" && record3.message ? record3.message : typeof record3.reason === "string" && record3.reason ? record3.reason : void 0;
     if (!message) {
       return void 0;
     }
-    const name = typeof record2.name === "string" && record2.name ? record2.name : void 0;
+    const name = typeof record3.name === "string" && record3.name ? record3.name : void 0;
     return name ? `${name}: ${message}` : message;
   };
   var describeWebSocketEvent = (event) => {
@@ -3466,29 +3459,29 @@ var PHPSandbox = (() => {
     if (!event || typeof event !== "object") {
       return String(event);
     }
-    const record2 = event;
+    const record3 = event;
     const parts = [];
-    const topLevelMessage = extractNestedErrorMessage(record2);
+    const topLevelMessage = extractNestedErrorMessage(record3);
     if (topLevelMessage) {
       parts.push(topLevelMessage);
     }
-    const nestedErrorMessage = extractNestedErrorMessage(record2.error);
+    const nestedErrorMessage = extractNestedErrorMessage(record3.error);
     if (nestedErrorMessage && nestedErrorMessage !== topLevelMessage) {
       parts.push(`error=${nestedErrorMessage}`);
     }
-    if (typeof record2.type === "string" && record2.type) {
-      parts.push(`type=${record2.type}`);
+    if (typeof record3.type === "string" && record3.type) {
+      parts.push(`type=${record3.type}`);
     }
-    if (typeof record2.code === "number") {
-      parts.push(`code=${record2.code}`);
+    if (typeof record3.code === "number") {
+      parts.push(`code=${record3.code}`);
     }
-    if (typeof record2.reason === "string" && record2.reason && record2.reason !== topLevelMessage) {
-      parts.push(`reason=${record2.reason}`);
+    if (typeof record3.reason === "string" && record3.reason && record3.reason !== topLevelMessage) {
+      parts.push(`reason=${record3.reason}`);
     }
-    if (typeof record2.wasClean === "boolean") {
-      parts.push(`wasClean=${record2.wasClean}`);
+    if (typeof record3.wasClean === "boolean") {
+      parts.push(`wasClean=${record3.wasClean}`);
     }
-    const target = record2.target ?? record2.currentTarget;
+    const target = record3.target ?? record3.currentTarget;
     if (target && typeof target === "object") {
       if (typeof target.url === "string" && target.url) {
         parts.push(`url=${sanitizeWebSocketUrl(target.url)}`);
@@ -3538,25 +3531,36 @@ var PHPSandbox = (() => {
   };
 
   // src/socket/index.ts
+  var SAFE_DEBUG_METADATA_KEYS = /* @__PURE__ */ new Set([
+    "url",
+    "action",
+    "event",
+    "responseEvent",
+    "errorEvent",
+    "hasData",
+    "code",
+    "attempt",
+    "maxRetries",
+    "timeout",
+    "errorCount",
+    "byteLength"
+  ]);
   var ReconnectingWebSocket2 = reconnecting_websocket_mjs_default ?? reconnecting_websocket_mjs_exports;
-  var ConnectionTimeoutError = class extends Error {
+  var ConnectionTimeoutError = class extends TransportError {
     constructor(message = "WebSocket connection timeout") {
-      super(message);
-      this.name = "ConnectionTimeoutError";
+      super(message, "ConnectionTimeout");
     }
   };
-  var ConnectionFailedError = class extends Error {
+  var ConnectionFailedError = class extends TransportError {
     constructor(message, originalError) {
-      super(message);
+      super(message, "ConnectionFailed", originalError);
       this.originalError = originalError;
-      this.name = "ConnectionFailedError";
     }
   };
-  var InvalidMessageError = class extends Error {
+  var InvalidMessageError = class extends TransportError {
     constructor(message, data) {
-      super(message);
+      super(message, "InvalidResponse", data);
       this.data = data;
-      this.name = "InvalidMessageError";
     }
   };
   var InvalidConfigurationError = class extends Error {
@@ -3583,7 +3587,6 @@ var PHPSandbox = (() => {
       const urlProvider = typeof url2 === "string" ? this.url.toString() : async () => new URL(await url2()).toString();
       this.PING_INTERVAL = options.pingInterval ?? 3e4;
       this.CONNECT_WAIT_TIMEOUT = options.connectWaitTimeout ?? 3e4;
-      const startClosed = options.startClosed !== false;
       this.rws = new ReconnectingWebSocket2(urlProvider, [], {
         WebSocket: options.webSocket ?? globalThis.WebSocket ?? browser_default,
         connectionTimeout: options.connectionTimeout,
@@ -3591,7 +3594,7 @@ var PHPSandbox = (() => {
         minReconnectionDelay: 200,
         maxEnqueuedMessages: 0,
         maxRetries: options.maxRetries ?? 50,
-        startClosed
+        startClosed: true
       });
       this.log("debug", "Transport initialized", {
         url: this.url === null ? "dynamic" : transportLogUrl(this.url),
@@ -3622,8 +3625,10 @@ var PHPSandbox = (() => {
     log(level, message, data) {
       if (this.options.debug) {
         const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-        const logData = data ? JSON.stringify(data, null, 2) : "";
-        console[level](`[Transport ${timestamp}] ${message}${logData ? "\n" + logData : ""}`);
+        const metadata = safeDebugMetadata(data);
+        const logData = metadata ? `
+${JSON.stringify(metadata, null, 2)}` : "";
+        console[level](`[Transport ${timestamp}] ${message}${logData}`);
       }
     }
     /**
@@ -3746,10 +3751,12 @@ var PHPSandbox = (() => {
         }
         if (event === "Events.BootError" /* BootError */) {
           const errorData = data;
-          const error51 = new NotebookUnavailableError(
-            errorData?.message || "Notebook is no longer available",
-            errorData || {}
-          );
+          const error51 = new RemoteError(errorData?.message || "Notebook is no longer available", {
+            source: "runtime",
+            status: 503,
+            code: "NotebookUnavailable",
+            details: errorData || {}
+          });
           this.log("error", "Boot error received", { data });
           this.terminate(error51, 4e3, error51.message);
           return;
@@ -3892,12 +3899,16 @@ var PHPSandbox = (() => {
         });
         this.listenOnce(errorEvent, (e) => {
           this.log("error", "Message error received", { action, error: e });
-          const error51 = e;
-          reject(new ErrorEvent(error51.code, error51.message, error51));
+          reject(remoteError("runtime", e));
         });
         closeHandler = (_ev) => {
           if (_ev.code === 1008 && (_ev.reason || "").includes("rate limit")) {
-            reject(new RateLimitError(_ev.reason || "Rate limit exceeded", _ev));
+            reject(new RemoteError(_ev.reason || "Rate limit exceeded", {
+              source: "runtime",
+              status: 429,
+              code: "RateLimited",
+              cause: _ev
+            }));
             return;
           }
           const detail = describeWebSocketEvent(_ev);
@@ -3910,7 +3921,7 @@ var PHPSandbox = (() => {
           this.log("debug", "Message sent", { action, data });
         } catch (error51) {
           this.log("error", "Failed to send message", { action, error: error51 });
-          reject(error51);
+          reject(new ConnectionFailedError(`Failed to send runtime action ${action}.`, error51));
         }
       };
       const send = async () => {
@@ -3963,7 +3974,7 @@ var PHPSandbox = (() => {
           try {
             return await sender();
           } catch (e) {
-            if (e instanceof ErrorEvent || e instanceof RateLimitError || e instanceof InvalidConfigurationError || e instanceof InvalidMessageError || e instanceof NotebookUnavailableError || e instanceof DOMException) {
+            if (e instanceof RemoteError || e instanceof InvalidConfigurationError || e instanceof InvalidMessageError || e instanceof DOMException) {
               this.log("debug", "Non-retryable error, bailing", {
                 error: e.message,
                 attempt
@@ -4032,7 +4043,7 @@ var PHPSandbox = (() => {
     }
     terminate(error51, code = 4e3, reason = error51.message) {
       this.terminalError = error51;
-      if (error51 instanceof NotebookUnavailableError) {
+      if (RemoteError.is(error51, "NotebookUnavailable")) {
         this.eventEmitter.emit("transport.boot_error", {
           error: error51,
           timestamp: Date.now()
@@ -4180,6 +4191,15 @@ var PHPSandbox = (() => {
       };
     });
   };
+  function safeDebugMetadata(data) {
+    if (data === null || typeof data !== "object") {
+      return null;
+    }
+    const metadata = Object.entries(data).filter(
+      ([key, value]) => SAFE_DEBUG_METADATA_KEYS.has(key) && ["string", "number", "boolean"].includes(typeof value)
+    );
+    return metadata.length > 0 ? Object.fromEntries(metadata) : null;
+  }
   function transportLogUrl(url2) {
     const safeUrl = new URL(url2);
     safeUrl.search = "";
@@ -4304,8 +4324,9 @@ var PHPSandbox = (() => {
     revert(input) {
       return this.okra.invoke("git.revert", input);
     }
-    credentials() {
-      return this.okra.gitCredentials();
+    async credentials() {
+      const response = await this.client.post(`/notebook/${this.okra.data.id}/git/credentials`);
+      return response.data;
     }
     restore(ref) {
       return this.okra.invoke("git.restore", { ref });
@@ -4365,15 +4386,8 @@ var PHPSandbox = (() => {
       );
       return new GitTarget(response.data, this.notebookId, this.client);
     }
-    async sync(target, input = {}) {
-      const response = await this.client.post(
-        `/notebook/${this.notebookId}/git/targets/${encodeURIComponent(gitTargetId(target))}/sync`,
-        omitUndefined({ ...input })
-      );
-      return new GitTarget(response.data, this.notebookId, this.client);
-    }
   };
-  var GitTarget = class {
+  var GitTarget = class _GitTarget {
     constructor(data, notebookId, client) {
       this.data = data;
       this.notebookId = notebookId;
@@ -4382,8 +4396,12 @@ var PHPSandbox = (() => {
     get id() {
       return this.data.id;
     }
-    sync(input = {}) {
-      return new GitTargetApi(this.notebookId, this.client).sync(this, input);
+    async sync(input = {}) {
+      const response = await this.client.post(
+        `/notebook/${this.notebookId}/git/targets/${encodeURIComponent(this.id)}/sync`,
+        omitUndefined({ ...input })
+      );
+      return new _GitTarget(response.data, this.notebookId, this.client);
     }
   };
   function gitTargetId(target) {
@@ -4587,7 +4605,7 @@ var PHPSandbox = (() => {
     promise: () => promise,
     property: () => _property,
     readonly: () => readonly,
-    record: () => record,
+    record: () => record2,
     refine: () => refine,
     regex: () => _regex,
     regexes: () => regexes_exports,
@@ -16925,7 +16943,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     preprocess: () => preprocess,
     promise: () => promise,
     readonly: () => readonly,
-    record: () => record,
+    record: () => record2,
     refine: () => refine,
     set: () => set,
     strictObject: () => strictObject,
@@ -17894,7 +17912,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     inst.keyType = def.keyType;
     inst.valueType = def.valueType;
   });
-  function record(keyType, valueType, params) {
+  function record2(keyType, valueType, params) {
     if (!valueType || !valueType._zod) {
       return new ZodRecord({
         type: "record",
@@ -18361,7 +18379,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   }, ...args);
   function json(params) {
     const jsonSchema = lazy(() => {
-      return union([string2(params), number2(), boolean2(), _null3(), array(jsonSchema), record(string2(), jsonSchema)]);
+      return union([string2(params), number2(), boolean2(), _null3(), array(jsonSchema), record2(string2(), jsonSchema)]);
     });
     return jsonSchema;
   }
@@ -18956,7 +18974,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     "AFR"
   ]);
   var PublicationJurisdictionSchema = external_exports.enum(["eu", "fedramp"]);
-  var PublicationDomainDnsRecordTypeSchema = external_exports.enum(["CNAME", "ALIAS", "ANAME"]);
   var PublicationProtectionModeSchema = external_exports.enum(["none", "password"]);
   var PublicationLogStreamSchema = external_exports.enum(["build", "runtime"]);
   var PublishStreamLogStreamSchema = external_exports.enum(["build", "publish", "runtime"]);
@@ -19047,33 +19064,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   });
 
   // src/publications.ts
-  var NotebookPublicationApi = class {
-    constructor(client) {
-      this.client = client;
-    }
-    async current(notebookId) {
-      try {
-        const response = await this.client.get(
-          `/notebook/${notebookId}/publication`
-        );
-        return new PublicationInstance(response.data, this.client, notebookId);
-      } catch (error51) {
-        if (error51 instanceof ApiError && error51.status === 404) {
-          return null;
-        }
-        throw error51;
-      }
-    }
-    async publish(notebookId, input) {
-      const response = await this.client.post(
-        `/notebook/${notebookId}/publication`,
-        input
-      );
-      const run = new PublicationRun(new PublicationInstance(response.data, this.client, notebookId), this.client);
-      run.start();
-      return run;
-    }
-  };
   var PublicationApi = class {
     constructor(client) {
       this.client = client;
@@ -19082,60 +19072,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       const response = await this.client.get(`/publications/${id}`);
       return new PublicationInstance(response.data, this.client);
     }
-    async destroy(id) {
-      await this.client.delete(`/publications/${id}`);
-    }
-    async setProtection(id, input) {
-      const response = await this.client.put(`/publications/${id}/protection`, input);
-      return new PublicationInstance(response.data, this.client);
-    }
-    async protection(id) {
-      const response = await this.client.get(`/publications/${id}/protection`);
-      return response.data;
-    }
-    async createProtectionSession(id) {
-      const response = await this.client.post(`/publications/${id}/protection/session`);
-      return response.data;
-    }
-    async disableProtection(id) {
-      const response = await this.client.delete(`/publications/${id}/protection`);
-      return new PublicationInstance(response.data, this.client);
-    }
-    async listDomains(id) {
-      const response = await this.client.get(
-        `/publications/${id}/domains`
-      );
-      return unwrapPublicationDomainCollection(response.data);
-    }
-    async createDomain(id, input) {
-      const response = await this.client.post(`/publications/${id}/domains`, input);
-      return response.data;
-    }
-    async refreshDomain(id, domainId) {
-      const response = await this.client.post(`/publications/${id}/domains/${domainId}/refresh`);
-      return response.data;
-    }
-    async deleteDomain(id, domainId) {
-      await this.client.delete(`/publications/${id}/domains/${domainId}`);
-    }
-    async events(id) {
-      return parseNdjsonStream(
-        await this.client.stream(`/publications/${id}/events/stream`),
-        PublicationEventDataSchema
-      );
-    }
-    async buildLogs(id, buildId) {
-      return parseNdjsonStream(
-        await this.client.stream(`/publications/${id}/builds/${buildId}/logs/stream`),
-        PublicationLogChunkDataSchema
-      );
-    }
-    async logs(id) {
-      return parseNdjsonStream(
-        await this.client.stream(`/publications/${id}/logs/stream`),
-        PublicationLogChunkDataSchema
-      );
-    }
   };
   var PublicationRun = class {
     constructor(initial, client) {
@@ -19254,14 +19190,22 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       const response = await this.client.get(`/publications/${this.data.id}`);
       return new _PublicationInstance(response.data, this.client, this.notebookId);
     }
-    publish() {
+    async publish() {
       if (!this.notebookId) {
         return Promise.reject(new Error("Publishing requires a notebook-scoped publication instance."));
       }
-      return this.client.notebook.publication.publish(this.notebookId);
+      const response = await this.client.post(
+        `/notebook/${this.notebookId}/publication`
+      );
+      const run = new PublicationRun(
+        new _PublicationInstance(response.data, this.client, this.notebookId),
+        this.client
+      );
+      run.start();
+      return run;
     }
-    destroy() {
-      return this.client.publications.destroy(this.data.id);
+    async destroy() {
+      await this.client.delete(`/publications/${this.data.id}`);
     }
     async wait(options = {}) {
       const intervalMs = options.intervalMs ?? 1e3;
@@ -19277,41 +19221,44 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       }
       return current;
     }
-    events() {
-      return this.client.publications.events(this.data.id);
+    async events() {
+      return parseNdjsonStream(
+        await this.client.stream(`/publications/${this.data.id}/events/stream`),
+        PublicationEventDataSchema
+      );
     }
     buildLogs(buildId = this.data.latestBuild?.id ?? "") {
       if (buildId === "") {
         return Promise.reject(new Error("Publication has no latest build id"));
       }
-      return this.client.publications.buildLogs(this.data.id, buildId);
-    }
-    logs() {
-      return this.client.publications.logs(this.data.id);
-    }
-    setProtection(input) {
-      return this.client.publications.setProtection(this.data.id, input);
-    }
-    protection() {
-      return this.client.publications.protection(this.data.id);
+      return this.client.stream(`/publications/${this.data.id}/builds/${buildId}/logs/stream`).then((stream) => parseNdjsonStream(stream, PublicationLogChunkDataSchema));
     }
-    createProtectionSession() {
-      return this.client.publications.createProtectionSession(this.data.id);
-    }
-    disableProtection() {
-      return this.client.publications.disableProtection(this.data.id);
+    async logs() {
+      return parseNdjsonStream(
+        await this.client.stream(`/publications/${this.data.id}/logs/stream`),
+        PublicationLogChunkDataSchema
+      );
     }
-    domains() {
-      return this.client.publications.listDomains(this.data.id);
+    async setProtection(input) {
+      const response = await this.client.put(
+        `/publications/${this.data.id}/protection`,
+        input
+      );
+      return new _PublicationInstance(response.data, this.client, this.notebookId);
     }
-    addDomain(input) {
-      return this.client.publications.createDomain(this.data.id, input);
+    async protection() {
+      const response = await this.client.get(`/publications/${this.data.id}/protection`);
+      return response.data;
     }
-    refreshDomain(domainId) {
-      return this.client.publications.refreshDomain(this.data.id, domainId);
+    async createProtectionSession() {
+      const response = await this.client.post(
+        `/publications/${this.data.id}/protection/session`
+      );
+      return response.data;
     }
-    deleteDomain(domainId) {
-      return this.client.publications.deleteDomain(this.data.id, domainId);
+    async disableProtection() {
+      const response = await this.client.delete(`/publications/${this.data.id}/protection`);
+      return new _PublicationInstance(response.data, this.client, this.notebookId);
     }
   };
   function publicationStatusIsTerminal(status) {
@@ -19320,12 +19267,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
-  function unwrapPublicationDomainCollection(input) {
-    if (Array.isArray(input)) {
-      return input;
-    }
-    return Array.isArray(input.data) ? input.data : [];
-  }
   var AsyncPublishEventQueue = class {
     constructor() {
       this.values = [];
@@ -19492,9 +19433,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     constructor(client) {
       this.client = client;
     }
-    async list() {
-      const response = await this.client.get("/servers");
-      return response.data;
+    async list(options = {}) {
+      const query = options.page === void 0 ? "" : `?${new URLSearchParams({ page: String(options.page) }).toString()}`;
+      return this.client.get(`/servers${query}`);
     }
     async create(input) {
       const response = await this.client.post("/servers", input);
@@ -19504,9 +19445,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       const response = await this.client.get(`/servers/${id}`);
       return new ServerInstance(response.data, this.client);
     }
-    async delete(id) {
-      await this.client.delete(`/servers/${id}`);
-    }
   };
   var ServerInstance = class {
     constructor(data, client) {
@@ -19516,8 +19454,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     refresh() {
       return this.client.servers.get(this.data.id);
     }
-    delete() {
-      return this.client.servers.delete(this.data.id);
+    async delete() {
+      await this.client.delete(`/servers/${this.data.id}`);
     }
     async waitReady(options) {
       const timeout2 = options?.timeout ?? 3e5;
@@ -19537,15 +19475,20 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
   };
 
+  // src/http.ts
+  function authenticatedRequest(input, init) {
+    return new Request(input, {
+      ...init,
+      redirect: "manual"
+    });
+  }
+
   // src/runtime/rest.ts
   var restActionRoutes = {
     "runtime.ready": { method: "GET", path: "/runtime" },
-    ping: { method: "GET", path: "/runtime/ping" },
     "config.get": { method: "GET", path: "/runtime/config" },
     "config.update": { method: "PATCH", path: "/runtime/config" },
     "config.set-ports": { method: "PUT", path: "/runtime/config/ports" },
-    "container.state": { method: "GET", path: "/runtime/container" },
-    "container.start": { method: "POST", path: "/runtime/container/start" },
     "container.restart": { method: "POST", path: "/runtime/container/restart" },
     "container.stop": { method: "POST", path: "/runtime/container/stop" },
     "container.set-php": { method: "PUT", path: "/runtime/container/php" },
@@ -19598,10 +19541,14 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       const actionUrl = new URL(runtimeUrl);
       const ticket = actionUrl.searchParams.get("ticket") ?? "";
       if (ticket === "") {
-        throw new UnsupportedRuntimeTransportError("The notebook connection does not contain a runtime ticket.");
+        throw new PHPSandboxError("The notebook connection does not contain a runtime ticket.");
       }
       this.ticket = ticket;
-      actionUrl.protocol = actionUrl.protocol === "wss:" ? "https:" : "http:";
+      if (actionUrl.protocol === "wss:") {
+        actionUrl.protocol = "https:";
+      } else if (actionUrl.protocol === "ws:") {
+        actionUrl.protocol = "http:";
+      }
       actionUrl.pathname = `/api/v1/notebooks/${encodeURIComponent(this.notebookId)}`;
       actionUrl.searchParams.delete("ticket");
       actionUrl.hash = "";
@@ -19617,27 +19564,28 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       return this.invokeRaw(action, data ?? {}, options);
     }
     send() {
-      throw new UnsupportedRuntimeTransportError("Fire-and-forget actions require the realtime transport.");
+      throw new PHPSandboxError("Fire-and-forget actions require the realtime transport.");
     }
     async invokeRaw(action, data, options) {
       const abort = runtimeAbort(options);
       try {
         for (let attempt = 0; attempt < 2; attempt += 1) {
-          const response = await this.fetch(this.request(action, data, abort.signal));
+          const response = await runtimeFetch(this.fetch, this.request(action, data, abort.signal));
           if (response.status === 401 && attempt === 0 && this.refresh !== void 0) {
             await this.refreshAuthorization();
             continue;
           }
           const payload = await runtimeActionResponse(response);
           if (!response.ok || payload.error !== void 0) {
-            const error51 = payload.error ?? payload;
-            const message = typeof error51.message === "string" ? error51.message : `Runtime action ${action} failed.`;
-            const code = typeof error51.code === "number" ? error51.code : response.status;
-            throw new ErrorEvent(code, message, error51);
+            throw remoteError("runtime", payload.error, response);
           }
           return payload.data;
         }
-        throw new ErrorEvent(401, `Runtime action ${action} could not be authorized.`, {});
+        throw new RemoteError(`Runtime action ${action} could not be authorized.`, {
+          source: "runtime",
+          status: 401,
+          code: "AuthenticationRequired"
+        });
       } finally {
         abort.dispose();
       }
@@ -19645,7 +19593,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     request(action, data, signal) {
       const route = restActionRoutes[action];
       if (route === void 0) {
-        throw new UnsupportedRuntimeTransportError(`Runtime action ${action} requires the realtime transport.`);
+        throw new PHPSandboxError(`Runtime action ${action} requires the realtime transport.`);
       }
       const url2 = new URL(this.actionUrl);
       url2.pathname += route.path;
@@ -19654,7 +19602,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         Authorization: `Bearer ${this.ticket}`
       };
       const body = runtimeActionRequestBody(action, data, url2, headers);
-      return new Request(url2, {
+      return authenticatedRequest(url2, {
         method: route.method,
         headers,
         body: route.method === "GET" ? void 0 : body,
@@ -19672,18 +19620,31 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       }
     }
   };
+  async function runtimeFetch(fetch, request) {
+    try {
+      return await fetch(request);
+    } catch (error51) {
+      if (error51 instanceof DOMException && error51.name === "AbortError") {
+        throw error51;
+      }
+      throw new TransportError("Unable to reach the PHPSandbox runtime.", "ConnectionFailed", error51);
+    }
+  }
   async function runtimeActionResponse(response) {
     if (response.ok && response.headers.get("content-type")?.toLowerCase().startsWith("application/octet-stream")) {
       return { data: new Uint8Array(await response.arrayBuffer()) };
     }
     const body = await response.text();
     if (body === "") {
+      if (response.ok) {
+        throw new TransportError("PHPSandbox runtime returned an empty response.", "InvalidResponse", response);
+      }
       return {};
     }
     try {
       return JSON.parse(body);
-    } catch {
-      return { error: { code: response.status, message: body } };
+    } catch (error51) {
+      throw new TransportError("PHPSandbox runtime returned an invalid JSON response.", "InvalidResponse", error51);
     }
   }
   function runtimeActionRequestBody(action, data, url2, headers) {
@@ -19777,10 +19738,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       for (const [name, value] of Object.entries(options)) {
         if (value !== void 0) query.set(name, String(value));
       }
-      const response = await this.client.get(
+      return this.client.get(
         `${this.path()}${query.size === 0 ? "" : `?${query.toString()}`}`
       );
-      return response.data;
     }
     async get(id) {
       const response = await this.client.get(this.path(`/${encodeURIComponent(id)}`));
@@ -19812,18 +19772,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       const response = await this.client.get(`/integrations/${encodeURIComponent(integrationId(integration))}`);
       return new Integration(response.data, this.client);
     }
-    async update(integration, input) {
-      const response = await this.client.patch(
-        `/integrations/${encodeURIComponent(integrationId(integration))}`,
-        input
-      );
-      return new Integration(response.data, this.client);
-    }
-    async unlink(integration) {
-      await this.client.delete(`/integrations/${encodeURIComponent(integrationId(integration))}`);
-    }
   };
-  var Integration = class {
+  var Integration = class _Integration {
     constructor(data, client) {
       this.data = data;
       this.client = client;
@@ -19837,11 +19787,15 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     get label() {
       return this.data.label;
     }
-    update(input) {
-      return new IntegrationApi(this.client).update(this, input);
+    async update(input) {
+      const response = await this.client.patch(
+        `/integrations/${encodeURIComponent(this.id)}`,
+        input
+      );
+      return new _Integration(response.data, this.client);
     }
-    unlink() {
-      return new IntegrationApi(this.client).unlink(this);
+    async unlink() {
+      await this.client.delete(`/integrations/${encodeURIComponent(this.id)}`);
     }
   };
   function integrationId(integration) {
@@ -19869,16 +19823,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       const response = await this.client.get(this.bindingPath(integration));
       return new SandboxIntegration(response.data, this.notebookId, this.client);
     }
-    async update(integration, input) {
-      const response = await this.client.patch(this.bindingPath(integration), {
-        ...input,
-        integration: input.integration === void 0 ? void 0 : integrationId(input.integration)
-      });
-      return new SandboxIntegration(response.data, this.notebookId, this.client);
-    }
-    async detach(integration) {
-      await this.client.delete(this.bindingPath(integration));
-    }
     path() {
       return `/notebook/${this.notebookId}/integrations`;
     }
@@ -19886,7 +19830,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       return `${this.path()}/${encodeURIComponent(sandboxIntegrationId(integration))}`;
     }
   };
-  var SandboxIntegration = class {
+  var SandboxIntegration = class _SandboxIntegration {
     constructor(data, notebookId, client) {
       this.data = data;
       this.notebookId = notebookId;
@@ -19901,11 +19845,18 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     get effects() {
       return this.data.effects;
     }
-    update(input) {
-      return new SandboxIntegrationApi(this.notebookId, this.client).update(this, input);
+    async update(input) {
+      const response = await this.client.patch(this.path(), {
+        ...input,
+        integration: input.integration === void 0 ? void 0 : integrationId(input.integration)
+      });
+      return new _SandboxIntegration(response.data, this.notebookId, this.client);
+    }
+    async detach() {
+      await this.client.delete(this.path());
     }
-    detach() {
-      return new SandboxIntegrationApi(this.notebookId, this.client).detach(this);
+    path() {
+      return `/notebook/${this.notebookId}/integrations/${encodeURIComponent(this.id)}`;
     }
   };
   function sandboxIntegrationId(integration) {
@@ -19922,87 +19873,20 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       ...typeof value === "string" ? { value } : value
     }));
   }
-  var NotebookInitError = class extends Error {
-    constructor(message, data = {}) {
-      super(message);
-      this.message = message;
-      this.data = data;
-      this.name = "NotebookInitError";
-    }
-  };
-  var ApiError = class extends Error {
-    constructor(response, body) {
-      const data = parseApiErrorBody(body);
-      const apiMessage = apiErrorMessage(data, body);
-      super(`PHPSandbox API Error: ${response.status} ${response.statusText}${apiMessage === "" ? "" : ` - ${apiMessage}`}`);
-      this.response = response;
-      this.body = body;
-      this.status = response.status;
-      this.data = data;
-      this.apiMessage = apiMessage === "" ? void 0 : apiMessage;
-    }
-  };
-  function parseApiErrorBody(body) {
-    try {
-      return JSON.parse(body);
-    } catch {
-      return null;
-    }
-  }
-  function apiErrorMessage(data, fallback) {
-    if (data !== null && typeof data === "object") {
-      const record2 = data;
-      if (typeof record2.message === "string" && record2.message.trim() !== "") {
-        return record2.message.trim();
-      }
-      if (record2.error !== void 0) {
-        return typeof record2.error === "string" ? record2.error.trim() : JSON.stringify(record2.error);
-      }
-    }
-    return fallback.trim();
-  }
   var NotebookApi = class {
     constructor(client) {
       this.client = client;
-      this.secrets = new NotebookSecretApi(client);
-      this.composerCredentials = new NotebookComposerCredentialApi(client);
-      this.preview = new NotebookPreviewApi(client);
-      this.mail = new NotebookMailApi(client);
-      this.publication = new NotebookPublicationApi(client);
     }
-    async create(template, input = {}, init = true) {
+    async create(template, input = {}) {
       const response = await this.client.post("/notebook", { template, ...input });
-      const instance = new NotebookInstance(response.data, this.client);
-      if (!init) {
-        return instance;
-      }
-      return this.init(instance);
+      return new NotebookInstance(response.data, this.client);
     }
     async get(id) {
       const response = await this.client.get(`/notebook/${id}`);
       return new NotebookInstance(response.data, this.client);
     }
-    async update(id, input = {}) {
-      const response = await this.client.put(`/notebook/${id}`, input);
-      return new NotebookInstance(response.data, this.client);
-    }
-    async destroy(id) {
-      await this.client.delete(`/notebook/${id}`);
-    }
-    async fork(id, input = {}) {
-      const response = await this.client.post(`/notebook/${id}/fork`, input);
-      return new NotebookInstance(response.data, this.client);
-    }
-    async gitCredentials(id) {
-      const response = await this.client.post(`/notebook/${id}/git/credentials`);
-      return response.data;
-    }
-    openFromData(data) {
-      return this.init(new NotebookInstance(data, this.client));
-    }
-    async init(instance) {
-      await instance.ready();
-      return instance;
+    open(data) {
+      return new NotebookInstance(data, this.client);
     }
   };
   function normalizeApiBaseUrl(url2) {
@@ -20013,15 +19897,15 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     baseUrl.hash = "";
     return baseUrl.toString();
   }
-  var Client = class {
-    constructor(token, url2 = "https://api.phpsandbox.io/v1", options = {}) {
-      this.runtimeTransportValue = "realtime";
+  var ClientImplementation = class {
+    constructor(token, url2 = "https://api.phpsandbox.io/v1", options = {}, runtimeTransport = "realtime") {
       this.fetch = globalThis.fetch;
       this.publications = new PublicationApi(this);
       this.notebook = new NotebookApi(this);
       this.servers = new ServerApi(this);
       this.integrations = new IntegrationApi(this);
-      this.options = Object.assign({ startClosed: true }, options);
+      this.options = { ...options };
+      this.runtimeTransportValue = runtimeTransport;
       this.baseUrl = normalizeApiBaseUrl(url2);
       if (options.fetch) {
         this.fetch = options.fetch;
@@ -20051,23 +19935,23 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       return this.makeRequest("PATCH", path, { body: body === void 0 ? void 0 : JSON.stringify(body) });
     }
     async stream(path) {
-      const response = await this.fetch(
-        new Request(new URL(path.replace(/^\//, ""), this.baseUrl), {
+      const response = await this.fetchResponse(
+        authenticatedRequest(new URL(path.replace(/^\//, ""), this.baseUrl), {
           method: "GET",
           headers: this.headers
         })
       );
       if (!response.ok) {
-        throw new ApiError(response, await response.text());
+        throw remoteError("core", errorPayload(await responsePayload(response)), response);
       }
       if (!response.body) {
-        throw new Error("PHPSandbox API Error: response body is not readable");
+        throw new TransportError("PHPSandbox API response body is not readable.", "InvalidResponse", response);
       }
       return response.body;
     }
     async sse(url2) {
-      const response = await this.fetch(
-        new Request(url2, {
+      const response = await this.fetchResponse(
+        authenticatedRequest(url2, {
           method: "GET",
           headers: {
             ...this.headers,
@@ -20076,140 +19960,89 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         })
       );
       if (!response.ok) {
-        throw new ApiError(response, await response.text());
+        throw remoteError("core", errorPayload(await responsePayload(response)), response);
       }
       if (!response.body) {
-        throw new Error("PHPSandbox API Error: SSE response body is not readable");
+        throw new TransportError("PHPSandbox API SSE response body is not readable.", "InvalidResponse", response);
       }
       return response.body;
     }
     async makeRequest(method, path, init) {
-      const response = await this.fetch(
-        new Request(new URL(path.replace(/^\//, ""), this.baseUrl), {
+      const response = await this.fetchResponse(
+        authenticatedRequest(new URL(path.replace(/^\//, ""), this.baseUrl), {
           method,
           ...init,
           headers: this.headers
         })
       );
       if (!response.ok) {
-        throw new ApiError(response, await response.text());
+        throw remoteError("core", errorPayload(await responsePayload(response)), response);
       }
       if (response.status === 204) {
         return { data: void 0 };
       }
       const body = await response.text();
-      return { data: body === "" ? void 0 : JSON.parse(body) };
-    }
-  };
-  var PHPSandbox = class _PHPSandbox extends Client {
-    static realtime(token, url2 = "https://api.phpsandbox.io/v1", options = {}) {
-      return new _PHPSandbox(token, url2, options);
-    }
-    static rest(token, url2 = "https://api.phpsandbox.io/v1", options = {}) {
-      const client = new _PHPSandbox(token, url2, options);
-      client.runtimeTransportValue = "rest";
-      return client;
-    }
-  };
-  var NotebookSecretApi = class {
-    constructor(client) {
-      this.client = client;
-    }
-    async list(id, options) {
-      const params = new URLSearchParams();
-      if (options?.environment) params.set("environment", options.environment);
-      const query = params.toString();
-      const response = await this.client.get(`/notebook/${id}/secrets${query ? `?${query}` : ""}`);
-      return response.data;
-    }
-    async set(id, name, input) {
-      const payload = typeof input === "string" ? { name, value: input } : { name, ...input };
-      const response = await this.client.put(`/notebook/${id}/secrets`, payload);
-      return response.data;
-    }
-    async setMany(id, input) {
-      const response = await this.client.put(`/notebook/${id}/secrets`, {
-        secrets: normalizeNotebookSecretInputs(input)
-      });
-      return response.data;
-    }
-    async delete(id, name, options) {
-      const params = new URLSearchParams();
-      if (options?.environment) params.set("environment", options.environment);
-      const query = params.toString();
-      await this.client.delete(`/notebook/${id}/secrets/${encodeURIComponent(name)}${query ? `?${query}` : ""}`);
-    }
-  };
-  var NotebookComposerCredentialApi = class {
-    constructor(client) {
-      this.client = client;
-    }
-    async set(id, input) {
-      const response = await this.client.put(`/notebook/${id}/composer/credentials`, input);
-      return response.data;
+      if (body === "") {
+        throw new TransportError("PHPSandbox API returned an empty response.", "InvalidResponse", response);
+      }
+      try {
+        const payload = JSON.parse(body);
+        if (payload === null || typeof payload !== "object" || Array.isArray(payload) || !Object.prototype.hasOwnProperty.call(payload, "data")) {
+          throw new TransportError("PHPSandbox API returned an invalid success response.", "InvalidResponse", response);
+        }
+        return payload;
+      } catch (error51) {
+        if (TransportError.is(error51)) {
+          throw error51;
+        }
+        throw new TransportError("PHPSandbox API returned an invalid JSON response.", "InvalidResponse", error51);
+      }
     }
-    async remove(id, type, url2) {
-      const params = new URLSearchParams({ type });
-      if (url2) params.set("url", url2);
-      await this.client.delete(`/notebook/${id}/composer/credentials?${params.toString()}`);
+    async fetchResponse(request) {
+      try {
+        return await this.fetch(request);
+      } catch (error51) {
+        if (error51 instanceof DOMException && error51.name === "AbortError") {
+          throw error51;
+        }
+        throw new TransportError("Unable to reach the PHPSandbox API.", "ConnectionFailed", error51);
+      }
     }
   };
-  var NotebookPreviewApi = class {
-    constructor(client) {
-      this.client = client;
-    }
-    async get(id, url2) {
-      const query = url2 === void 0 ? "" : `?${new URLSearchParams({ url: url2 }).toString()}`;
-      const response = await this.client.get(`/notebook/${id}/preview${query}`);
-      return response.data;
-    }
-    async setPassword(id, input) {
-      const response = await this.client.put(`/notebook/${id}/preview`, input);
-      return response.data;
-    }
-    async disable(id) {
-      await this.client.delete(`/notebook/${id}/preview`);
-    }
-    async createSession(id, input) {
-      const response = await this.client.post(`/notebook/${id}/preview/session`, input);
-      return response.data;
+  async function responsePayload(response) {
+    const body = await response.text();
+    if (body === "") {
+      return void 0;
     }
-    async createHandoff(id, input) {
-      const response = await this.client.post(`/notebook/${id}/preview/handoff`, input);
-      return response.data;
+    try {
+      return JSON.parse(body);
+    } catch (error51) {
+      throw new TransportError("PHPSandbox API returned an invalid JSON response.", "InvalidResponse", error51);
     }
-  };
-  var NotebookMailApi = class {
+  }
+  function errorPayload(payload) {
+    return payload !== null && typeof payload === "object" && !Array.isArray(payload) ? payload.error : void 0;
+  }
+  var PHPSandbox = class _PHPSandbox {
     constructor(client) {
       this.client = client;
+      this.notebook = client.notebook;
+      this.publications = client.publications;
+      this.servers = client.servers;
+      this.integrations = client.integrations;
     }
-    async status(id) {
-      const response = await this.client.get(`/notebook/${id}/mail`);
-      return response.data;
-    }
-    async enable(id) {
-      const response = await this.client.put(`/notebook/${id}/mail`);
-      return response.data;
-    }
-    async disable(id) {
-      await this.client.delete(`/notebook/${id}/mail`);
-    }
-    async list(id, options = {}) {
-      const response = await this.client.get(
-        `/notebook/${id}/mails${formatQueryString(options)}`
-      );
-      return response.data;
+    get runtimeTransport() {
+      return this.client.runtimeTransport;
     }
-    async get(id, hash2) {
-      const response = await this.client.get(`/notebook/${id}/mails/${encodeURIComponent(hash2)}`);
-      return response.data;
+    static realtime(token, url2 = "https://api.phpsandbox.io/v1", options = {}) {
+      return new _PHPSandbox(new ClientImplementation(token, url2, options));
     }
-    async delete(id, hash2) {
-      await this.client.delete(`/notebook/${id}/mails/${encodeURIComponent(hash2)}`);
+    static rest(token, url2 = "https://api.phpsandbox.io/v1", options = {}) {
+      return new _PHPSandbox(new ClientImplementation(token, url2, options, "rest"));
     }
   };
   var _initPromise, _NotebookInstance_instances, init_fn;
-  var NotebookInstance = class {
+  var _NotebookInstance = class _NotebookInstance {
     constructor(data, client) {
       this.data = data;
       this.client = client;
@@ -20238,7 +20071,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         };
         this.socket = new Transport(connectionUrl, this.emitter, {
           debug: client.options.debug,
-          startClosed: client.options.startClosed,
           webSocket: client.options.webSocket
         });
         this.watchConnection();
@@ -20252,12 +20084,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       this.auth = new Auth(this);
       this.lsp = new Lsp(this);
       this.composer = new Composer(this, client);
-      const telemetry = new RuntimeTelemetry(this);
-      this.logs = new Logs(this, telemetry);
-      this.metrics = new Metrics(this, telemetry);
-      this.ports = new Ports(this, telemetry);
+      this.runtime = new Runtime(this);
       this.repl = new Repl(this);
-      this.container = new Container(this);
       this.shell = new Shell(this);
       this.git = new Git(this, client);
       this.services = new Services(this);
@@ -20281,21 +20109,33 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         throw terminalError;
       }
       const ready = async () => {
-        if (this.client.options.startClosed && !socket.isConnected) {
+        if (!socket.isConnected) {
           await socket.connect();
         }
         return __privateGet(this, _initPromise);
       };
       return ready();
     }
-    fork(input = {}) {
-      return this.client.notebook.fork(this.data.id, input);
+    async fork(input = {}) {
+      const response = await this.client.post(`/notebook/${this.data.id}/fork`, input);
+      return new _NotebookInstance(response.data, this.client);
     }
-    publication() {
-      return this.client.notebook.publication.current(this.data.id);
+    async publication() {
+      try {
+        const response = await this.client.get(`/notebook/${this.data.id}/publication`);
+        return new PublicationInstance(response.data, this.client, this.data.id);
+      } catch (error51) {
+        if (RemoteError.is(error51) && error51.status === 404) {
+          return null;
+        }
+        throw error51;
+      }
     }
-    publish(input) {
-      return this.client.notebook.publication.publish(this.data.id, input);
+    async publish(input) {
+      const response = await this.client.post(`/notebook/${this.data.id}/publication`, input);
+      const run = new PublicationRun(new PublicationInstance(response.data, this.client, this.data.id), this.client);
+      run.start();
+      return run;
     }
     run(command, argsOrOpts = [], opts) {
       if (Array.isArray(argsOrOpts)) {
@@ -20309,19 +20149,20 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       }
       return this.run(command, argsOrOpts).wait();
     }
-    gitCredentials() {
-      return this.client.notebook.gitCredentials(this.data.id);
+    async destroy() {
+      await this.client.delete(`/notebook/${this.data.id}`);
+      this.socket?.terminate(new RemoteError("Notebook has been deleted.", {
+        source: "runtime",
+        status: 503,
+        code: "NotebookUnavailable",
+        details: { id: this.data.id }
+      }));
     }
-    destroy() {
-      return this.client.notebook.destroy(this.data.id).then(() => {
-        this.socket?.terminate(new NotebookUnavailableError("Notebook has been deleted.", { id: this.data.id }));
-      });
+    restart() {
+      return this.invoke("container.restart");
     }
     stop() {
-      return this.container.stop();
-    }
-    restart() {
-      return this.container.restart();
+      return this.invoke("container.stop");
     }
     invoke(action, data = {}, options = {}) {
       if (this.restInvoker !== null) {
@@ -20338,9 +20179,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       }
       return this.realtimeSocket().send(action, data || {});
     }
-    ping() {
-      return this.invoke("ping");
-    }
     listen(event, handler) {
       const disposable = this.emitter.listen(event, handler);
       this.disposables.push(disposable);
@@ -20355,9 +20193,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     connected() {
       return this.waitForSocketConnection({ rejectOnClose: true });
     }
-    whenConnected() {
-      return this.waitForSocketConnection({ rejectOnClose: false });
-    }
     waitForSocketConnection(options) {
       const socket = this.realtimeSocket();
       const terminalError = socket.getTerminalError();
@@ -20429,7 +20264,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
     restInitialization() {
       if (this.restInvoker === null) {
-        throw new UnsupportedRuntimeTransportError("This operation requires the REST transport.");
+        throw new PHPSandboxError("This operation requires the REST transport.");
       }
       if (__privateGet(this, _initPromise) === null) {
         __privateSet(this, _initPromise, this.restInvoker.ready().then((result) => {
@@ -20442,15 +20277,12 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       }
       return __privateGet(this, _initPromise);
     }
-    update(input) {
-      return this.client.notebook.update(this.data.id, input);
-    }
     onDidInitialize(handler) {
       return this.listen("notebook.initialized", handler);
     }
     async reconnect() {
       const socket = this.realtimeSocket();
-      const whenConnected = this.whenConnected();
+      const whenConnected = this.waitForSocketConnection({ rejectOnClose: false });
       socket.reconnect();
       this.initialized = false;
       await whenConnected;
@@ -20459,7 +20291,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
     realtimeSocket() {
       if (this.socket === null) {
-        throw new UnsupportedRuntimeTransportError("This operation requires the realtime transport.");
+        throw new PHPSandboxError("This operation requires the realtime transport.");
       }
       return this.socket;
     }
@@ -20473,7 +20305,12 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         initializationListener.dispose();
         this.initialized = result;
         if (result.type === "error") {
-          reject(new NotebookInitError(result.message, result.data));
+          reject(new RemoteError(result.message, {
+            source: "runtime",
+            status: 503,
+            code: "NotebookInitializationFailed",
+            details: result.data
+          }));
           return;
         }
         resolve(result);
@@ -20488,34 +20325,39 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     });
     return __privateGet(this, _initPromise);
   };
+  var NotebookInstance = _NotebookInstance;
   var NotebookSecrets = class {
     constructor(client, notebookId) {
       this.client = client;
       this.notebookId = notebookId;
     }
-    list(options) {
-      return this.client.notebook.secrets.list(this.notebookId, options);
-    }
-    set(name, input) {
-      return this.client.notebook.secrets.set(this.notebookId, name, input);
-    }
-    setMany(input) {
-      return this.client.notebook.secrets.setMany(this.notebookId, input);
-    }
-    delete(name, options) {
-      return this.client.notebook.secrets.delete(this.notebookId, name, options);
+    async list(options) {
+      const params = new URLSearchParams();
+      if (options?.environment) params.set("environment", options.environment);
+      const query = params.toString();
+      const response = await this.client.get(
+        `/notebook/${this.notebookId}/secrets${query ? `?${query}` : ""}`
+      );
+      return response.data;
     }
-  };
-  var ComposerCredentials = class {
-    constructor(client, notebookId) {
-      this.client = client;
-      this.notebookId = notebookId;
+    async set(name, input) {
+      const payload = typeof input === "string" ? { name, value: input } : { name, ...input };
+      const response = await this.client.put(`/notebook/${this.notebookId}/secrets`, payload);
+      return response.data;
     }
-    set(input) {
-      return this.client.notebook.composerCredentials.set(this.notebookId, input);
+    async setMany(input) {
+      const response = await this.client.put(`/notebook/${this.notebookId}/secrets`, {
+        secrets: normalizeNotebookSecretInputs(input)
+      });
+      return response.data;
     }
-    remove(type, url2) {
-      return this.client.notebook.composerCredentials.remove(this.notebookId, type, url2);
+    async delete(name, options) {
+      const params = new URLSearchParams();
+      if (options?.environment) params.set("environment", options.environment);
+      const query = params.toString();
+      await this.client.delete(
+        `/notebook/${this.notebookId}/secrets/${encodeURIComponent(name)}${query ? `?${query}` : ""}`
+      );
     }
   };
   var NotebookPreview = class {
@@ -20523,20 +20365,31 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       this.client = client;
       this.notebookId = notebookId;
     }
-    get(url2) {
-      return this.client.notebook.preview.get(this.notebookId, url2);
+    async get(url2) {
+      const query = url2 === void 0 ? "" : `?${new URLSearchParams({ url: url2 }).toString()}`;
+      const response = await this.client.get(`/notebook/${this.notebookId}/preview${query}`);
+      return response.data;
     }
-    setPassword(input) {
-      return this.client.notebook.preview.setPassword(this.notebookId, input);
+    async setPassword(input) {
+      const response = await this.client.put(`/notebook/${this.notebookId}/preview`, input);
+      return response.data;
     }
-    disable() {
-      return this.client.notebook.preview.disable(this.notebookId);
+    async disable() {
+      await this.client.delete(`/notebook/${this.notebookId}/preview`);
     }
-    createSession(input) {
-      return this.client.notebook.preview.createSession(this.notebookId, input);
+    async createSession(input) {
+      const response = await this.client.post(
+        `/notebook/${this.notebookId}/preview/session`,
+        input
+      );
+      return response.data;
     }
-    createHandoff(input) {
-      return this.client.notebook.preview.createHandoff(this.notebookId, input);
+    async createHandoff(input) {
+      const response = await this.client.post(
+        `/notebook/${this.notebookId}/preview/handoff`,
+        input
+      );
+      return response.data;
     }
   };
   var NotebookMail = class {
@@ -20544,23 +20397,30 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       this.client = client;
       this.notebookId = notebookId;
     }
-    status() {
-      return this.client.notebook.mail.status(this.notebookId);
+    async status() {
+      const response = await this.client.get(`/notebook/${this.notebookId}/mail`);
+      return response.data;
     }
-    enable() {
-      return this.client.notebook.mail.enable(this.notebookId);
+    async enable() {
+      const response = await this.client.put(`/notebook/${this.notebookId}/mail`);
+      return response.data;
     }
-    disable() {
-      return this.client.notebook.mail.disable(this.notebookId);
+    async disable() {
+      await this.client.delete(`/notebook/${this.notebookId}/mail`);
     }
-    list(options = {}) {
-      return this.client.notebook.mail.list(this.notebookId, options);
+    async list(options = {}) {
+      return this.client.get(
+        `/notebook/${this.notebookId}/mails${formatQueryString(options)}`
+      );
     }
-    get(hash2) {
-      return this.client.notebook.mail.get(this.notebookId, hash2);
+    async get(hash2) {
+      const response = await this.client.get(
+        `/notebook/${this.notebookId}/mails/${encodeURIComponent(hash2)}`
+      );
+      return response.data;
     }
-    delete(hash2) {
-      return this.client.notebook.mail.delete(this.notebookId, hash2);
+    async delete(hash2) {
+      await this.client.delete(`/notebook/${this.notebookId}/mails/${encodeURIComponent(hash2)}`);
     }
   };
   function formatQueryString(params) {