@phpsandbox/sdk 0.1.9 → 0.1.11

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

@@ -13,46 +13,133 @@ var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 
 // 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
@@ -88,21 +175,6 @@ var FileChangeType = /* @__PURE__ */ ((FileChangeType2) => {
   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;
@@ -256,7 +328,7 @@ var Filesystem = class {
     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."));
         }
       });
     }
@@ -476,9 +548,6 @@ var Filesystem = class {
     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;
   }
 };
@@ -683,38 +752,6 @@ var Terminals = class {
   }
 };
 
-// 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) {
@@ -762,7 +799,7 @@ var Lsp = class {
     return LspConnection.create(id, this);
   }
   whenSocketConnected() {
-    return this.okra.whenConnected();
+    return this.okra.connected();
   }
 };
 var LspConnection = class _LspConnection {
@@ -808,26 +845,6 @@ function resolveRunInput(command, argsOrOpts = [], opts) {
     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;
@@ -915,7 +932,7 @@ var ShellProcess = class {
       { abortSignal }
     ).then((result) => {
       finish();
-      return new ProcessResult(result.output, result.stdout, result.stderr, result.exitCode);
+      return result;
     }).catch((error51) => {
       fail(error51);
       throw error51;
@@ -940,6 +957,24 @@ var Shell = class {
 };
 
 // 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;
@@ -977,7 +1012,7 @@ var ComposerProcess = class {
     };
     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;
@@ -998,21 +1033,6 @@ var Composer = class {
   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");
   }
@@ -1172,6 +1192,50 @@ var Ports = class {
   }
 };
 
+// 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) {
@@ -2059,24 +2123,24 @@ var CachedKeyDecoder = class {
   }
   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) {
@@ -2826,17 +2890,17 @@ var Event = (
     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 = (
@@ -3261,7 +3325,7 @@ var ReconnectingWebSocket = (
     };
     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) {
@@ -3348,12 +3412,12 @@ var extractNestedErrorMessage = (value) => {
   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) => {
@@ -3366,29 +3430,29 @@ var describeWebSocketEvent = (event) => {
   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)}`);
@@ -3438,25 +3502,36 @@ var NamedDisposable = class {
 };
 
 // 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 {
@@ -3483,7 +3558,6 @@ var Transport = class {
     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,
@@ -3491,7 +3565,7 @@ var Transport = class {
       minReconnectionDelay: 200,
       maxEnqueuedMessages: 0,
       maxRetries: options.maxRetries ?? 50,
-      startClosed
+      startClosed: true
     });
     this.log("debug", "Transport initialized", {
       url: this.url === null ? "dynamic" : transportLogUrl(this.url),
@@ -3522,8 +3596,10 @@ var Transport = class {
   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}`);
     }
   }
   /**
@@ -3646,10 +3722,12 @@ var Transport = class {
       }
       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;
@@ -3792,12 +3870,16 @@ var Transport = class {
       });
       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);
@@ -3810,7 +3892,7 @@ var Transport = class {
         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 () => {
@@ -3863,7 +3945,7 @@ var Transport = class {
         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
@@ -3932,7 +4014,7 @@ var Transport = class {
   }
   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()
@@ -4080,6 +4162,15 @@ startPeriodicPing_fn = function() {
     };
   });
 };
+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 = "";
@@ -4204,8 +4295,9 @@ var Git = class {
   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 });
@@ -4265,15 +4357,8 @@ var GitTargetApi = class {
     );
     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;
@@ -4282,8 +4367,12 @@ var GitTarget = class {
   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) {
@@ -4487,7 +4576,7 @@ __export(external_exports, {
   promise: () => promise,
   property: () => _property,
   readonly: () => readonly,
-  record: () => record,
+  record: () => record2,
   refine: () => refine,
   regex: () => _regex,
   regexes: () => regexes_exports,
@@ -16825,7 +16914,7 @@ __export(schemas_exports2, {
   preprocess: () => preprocess,
   promise: () => promise,
   readonly: () => readonly,
-  record: () => record,
+  record: () => record2,
   refine: () => refine,
   set: () => set,
   strictObject: () => strictObject,
@@ -17794,7 +17883,7 @@ var ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
   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",
@@ -18261,7 +18350,7 @@ var stringbool = (...args) => _stringbool({
 }, ...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;
 }
@@ -18856,7 +18945,6 @@ var PublicationRegionSchema = external_exports.enum([
   "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"]);
@@ -18947,33 +19035,6 @@ var PublishStreamSseEventSchema = external_exports.discriminatedUnion("event", [
 });
 
 // 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;
@@ -18982,60 +19043,6 @@ var PublicationApi = class {
     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) {
@@ -19154,14 +19161,22 @@ var PublicationInstance = class _PublicationInstance {
     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;
@@ -19177,41 +19192,44 @@ var PublicationInstance = class _PublicationInstance {
     }
     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);
+    return this.client.stream(`/publications/${this.data.id}/builds/${buildId}/logs/stream`).then((stream) => parseNdjsonStream(stream, PublicationLogChunkDataSchema));
   }
-  protection() {
-    return this.client.publications.protection(this.data.id);
-  }
-  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) {
@@ -19220,12 +19238,6 @@ function publicationStatusIsTerminal(status) {
 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 = [];
@@ -19392,9 +19404,9 @@ var ServerApi = class {
   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);
@@ -19404,9 +19416,6 @@ var ServerApi = class {
     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) {
@@ -19416,8 +19425,8 @@ var ServerInstance = class {
   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;
@@ -19437,15 +19446,20 @@ var ServerInstance = class {
   }
 };
 
+// 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" },
@@ -19498,10 +19512,14 @@ var RestRuntimeInvoker = class {
     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 = "";
@@ -19517,27 +19535,28 @@ var RestRuntimeInvoker = class {
     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();
     }
@@ -19545,7 +19564,7 @@ var RestRuntimeInvoker = class {
   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;
@@ -19554,7 +19573,7 @@ var RestRuntimeInvoker = class {
       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,
@@ -19572,18 +19591,31 @@ var RestRuntimeInvoker = class {
     }
   }
 };
+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) {
@@ -19677,10 +19709,9 @@ var Feedback = class {
     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)}`));
@@ -19712,18 +19743,8 @@ var IntegrationApi = class {
     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;
@@ -19737,11 +19758,15 @@ var Integration = class {
   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) {
@@ -19769,16 +19794,6 @@ var SandboxIntegrationApi = class {
     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`;
   }
@@ -19786,7 +19801,7 @@ var SandboxIntegrationApi = class {
     return `${this.path()}/${encodeURIComponent(sandboxIntegrationId(integration))}`;
   }
 };
-var SandboxIntegration = class {
+var SandboxIntegration = class _SandboxIntegration {
   constructor(data, notebookId, client) {
     this.data = data;
     this.notebookId = notebookId;
@@ -19801,11 +19816,18 @@ var SandboxIntegration = class {
   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) {
@@ -19822,87 +19844,20 @@ function normalizeNotebookSecretInputs(input) {
     ...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) {
@@ -19913,15 +19868,15 @@ function normalizeApiBaseUrl(url2) {
   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;
@@ -19951,23 +19906,23 @@ var Client = class {
     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,
@@ -19976,140 +19931,89 @@ var Client = class {
       })
     );
     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;
@@ -20138,7 +20042,6 @@ var NotebookInstance = class {
       };
       this.socket = new Transport(connectionUrl, this.emitter, {
         debug: client.options.debug,
-        startClosed: client.options.startClosed,
         webSocket: client.options.webSocket
       });
       this.watchConnection();
@@ -20152,12 +20055,8 @@ var NotebookInstance = class {
     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);
@@ -20181,21 +20080,33 @@ var NotebookInstance = class {
       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)) {
@@ -20209,19 +20120,20 @@ var NotebookInstance = class {
     }
     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) {
@@ -20238,9 +20150,6 @@ var NotebookInstance = class {
     }
     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);
@@ -20255,9 +20164,6 @@ var NotebookInstance = class {
   connected() {
     return this.waitForSocketConnection({ rejectOnClose: true });
   }
-  whenConnected() {
-    return this.waitForSocketConnection({ rejectOnClose: false });
-  }
   waitForSocketConnection(options) {
     const socket = this.realtimeSocket();
     const terminalError = socket.getTerminalError();
@@ -20329,7 +20235,7 @@ var NotebookInstance = class {
   }
   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) => {
@@ -20342,15 +20248,12 @@ var NotebookInstance = class {
     }
     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;
@@ -20359,7 +20262,7 @@ var NotebookInstance = class {
   }
   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;
   }
@@ -20373,7 +20276,12 @@ init_fn = function() {
       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);
@@ -20388,34 +20296,39 @@ init_fn = function() {
   });
   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 {
@@ -20423,20 +20336,31 @@ var NotebookPreview = class {
     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 {
@@ -20444,23 +20368,30 @@ var NotebookMail = class {
     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) {
@@ -20474,88 +20405,17 @@ function formatQueryString(params) {
   return query === "" ? "" : `?${query}`;
 }
 export {
-  ApiError,
-  Client,
-  CommandError,
-  ComposerCredentials,
-  ErrorEvent,
-  Feedback,
   FileChangeFilter,
   FileChangeType,
   FileType,
-  Filesystem,
-  FilesystemError,
-  FilesystemErrorType,
-  GitTarget,
-  GitTargetApi,
-  Integration,
-  IntegrationApi,
   LspConnection,
-  NotebookApi,
-  NotebookComposerCredentialApi,
-  NotebookInitError,
   NotebookInstance,
-  NotebookMail,
-  NotebookMailApi,
-  NotebookPreview,
-  NotebookPreviewApi,
-  NotebookPublicationApi,
-  NotebookSecretApi,
-  NotebookSecrets,
-  NotebookState,
-  NotebookUnavailableError,
   PHPSandbox,
   PHPSandboxError,
-  ProcessReadable,
-  ProcessResult,
-  PromiseTimeoutError,
-  PublicationApi,
-  PublicationBuildStatusSchema,
-  PublicationDomainDnsRecordTypeSchema,
-  PublicationEventDataSchema,
-  PublicationInstance,
-  PublicationJurisdictionSchema,
-  PublicationLogChunkDataSchema,
-  PublicationLogStreamSchema,
-  PublicationProtectionModeSchema,
-  PublicationProviderNameSchema,
-  PublicationRegionSchema,
-  PublicationReleaseStatusSchema,
-  PublicationRun,
-  PublicationSizeSchema,
-  PublicationStatusSchema,
-  PublishStreamErrorSchema,
-  PublishStreamEventSchema,
-  PublishStreamLogEventSchema,
-  PublishStreamLogSchema,
-  PublishStreamLogStreamSchema,
-  PublishStreamPhaseEventSchema,
-  PublishStreamPhaseSchema,
-  PublishStreamResultEventSchema,
-  PublishStreamResultSchema,
-  PublishStreamSseDoneEventSchema,
-  PublishStreamSseErrorEventSchema,
-  PublishStreamSseEventNameSchema,
-  PublishStreamSseEventSchema,
-  PublishStreamSseLogEventSchema,
-  PublishStreamSsePhaseEventSchema,
-  PublishStreamSseResultEventSchema,
-  RateLimitError,
-  RuntimeTelemetry,
-  SandboxIntegration,
-  SandboxIntegrationApi,
-  SendTimeoutError,
-  ServerApi,
-  ServerInstance,
-  ShellProcess,
-  UnsupportedRuntimeTransportError,
-  integrationId,
+  RemoteError,
+  TransportError,
   notebookBuiltinServices,
-  notebookKnownServices,
-  once,
-  sandboxIntegrationId,
-  timeout,
-  watchRuntimeTelemetry
+  notebookKnownServices
 };
 /*! Bundled license information: