@phpsandbox/sdk 0.0.65 → 0.0.67

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

@@ -97,6 +97,7 @@ var PHPSandbox = (() => {
     ServerApi: () => ServerApi,
     ServerInstance: () => ServerInstance,
     Transport: () => Transport,
+    UnsupportedRuntimeTransportError: () => UnsupportedRuntimeTransportError,
     createBeacon: () => createBeacon,
     isBeaconSupported: () => isBeaconSupported,
     notebookBuiltinServices: () => notebookBuiltinServices,
@@ -186,13 +187,16 @@ var PHPSandbox = (() => {
     }
   };
   var Filesystem = class {
-    constructor(okra) {
+    constructor(okra, registerReconnect = (handler) => okra.onDidConnect(handler)) {
       this.okra = okra;
       this.watches = /* @__PURE__ */ new Map();
-      this.watchOkraConnection();
+      this.registerReconnectHandler(registerReconnect);
     }
-    watchOkraConnection() {
-      this.okra.onDidConnect(() => {
+    registerReconnectHandler(registerReconnect) {
+      if (registerReconnect === null) {
+        return;
+      }
+      registerReconnect(() => {
         for (const { path, options } of this.watches.values()) {
           void this.okra.invoke("fs.watch", { path, options }).catch(() => {
           });
@@ -399,6 +403,12 @@ var PHPSandbox = (() => {
       this.name = "NotebookUnavailableError";
     }
   };
+  var UnsupportedRuntimeTransportError = class extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "UnsupportedRuntimeTransportError";
+    }
+  };
 
   // src/utils/promise.ts
   var timeout = (prom, time3) => {
@@ -666,10 +676,14 @@ var PHPSandbox = (() => {
       this.okra = okra;
     }
     logout() {
-      return this.okra.invoke("auth.logout");
+      this.okra.dispose();
     }
-    login(newConnectionData) {
-      return this.okra.invoke("auth.login", { newConnectionData });
+    login(runtimeUrl) {
+      const runtimeTicket = new URL(runtimeUrl).searchParams.get("ticket");
+      if (runtimeTicket === null || runtimeTicket === "") {
+        throw new TypeError("The notebook connection does not contain a runtime ticket.");
+      }
+      return this.okra.invoke("auth.login", { runtimeTicket });
     }
   };
 
@@ -3229,11 +3243,12 @@ var PHPSandbox = (() => {
       this.pingIntervalStarted = false;
       this.incomingMessageChain = Promise.resolve();
       this.validateConfiguration(options);
-      this.url = new URL(url2);
+      this.url = typeof url2 === "string" ? new URL(url2) : null;
+      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(this.url.toString(), [], {
+      this.rws = new ReconnectingWebSocket2(urlProvider, [], {
         WebSocket: options.webSocket ?? globalThis.WebSocket ?? browser_default,
         connectionTimeout: options.connectionTimeout,
         maxReconnectionDelay: 2e3,
@@ -3243,7 +3258,7 @@ var PHPSandbox = (() => {
         startClosed
       });
       this.log("debug", "Transport initialized", {
-        url: this.url.toString(),
+        url: this.url === null ? "dynamic" : transportLogUrl(this.url),
         options
       });
       this.registerWatchers();
@@ -3829,6 +3844,12 @@ var PHPSandbox = (() => {
       };
     });
   };
+  function transportLogUrl(url2) {
+    const safeUrl = new URL(url2);
+    safeUrl.search = "";
+    safeUrl.hash = "";
+    return safeUrl.toString();
+  }
 
   // node_modules/mitt/dist/mitt.mjs
   var mitt_exports = {};
@@ -19514,8 +19535,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       if (this.started) {
         return this;
       }
-      if (!this.initial.data.okraUrl) {
-        throw new Error(`Deployment ${this.initial.data.id} has no okraUrl for SSE streaming`);
+      const eventStreamUrl = this.initial.data.eventStreamUrl ?? this.initial.data.okraUrl;
+      if (!eventStreamUrl) {
+        throw new Error(`Deployment ${this.initial.data.id} has no eventStreamUrl for SSE streaming`);
       }
       this.started = true;
       this.resultPromise = new Promise((resolve, reject) => {
@@ -19523,7 +19545,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         this.rejectResult = reject;
       });
       this.resultPromise.catch(() => void 0);
-      void this.consumeStream(this.initial.data.okraUrl);
+      void this.consumeStream(eventStreamUrl);
       return this;
     }
     subscribe() {
@@ -19540,9 +19562,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       }
       return queue;
     }
-    async consumeStream(okraUrl) {
+    async consumeStream(eventStreamUrl) {
       try {
-        const stream = await this.client.sse(okraUrl);
+        const stream = await this.client.sse(eventStreamUrl);
         for await (const event of readDeployStreamEvents(stream)) {
           this.publish(event);
           if (event.type === "result") {
@@ -19878,6 +19900,231 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
   };
 
+  // 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" },
+    "container.opened-ports": { method: "GET", path: "/runtime/container/ports" },
+    "terminal.list": { method: "GET", path: "/runtime/terminals" },
+    "shell.exec": { method: "POST", path: "/runtime/executions" },
+    "fs.info": { method: "POST", path: "/runtime/files/info" },
+    "fs.readFile": { method: "GET", path: "/runtime/files/content" },
+    "fs.writeFile": { method: "PUT", path: "/runtime/files/content" },
+    "fs.write": { method: "PUT", path: "/runtime/files/text" },
+    "fs.mkdir": { method: "POST", path: "/runtime/directories" },
+    "fs.createDirectory": { method: "PUT", path: "/runtime/directories" },
+    "fs.readDirectory": { method: "POST", path: "/runtime/directories/read" },
+    "fs.stat": { method: "POST", path: "/runtime/files/stat" },
+    "fs.move": { method: "POST", path: "/runtime/files/move" },
+    "fs.rename": { method: "POST", path: "/runtime/files/rename" },
+    "fs.copy": { method: "POST", path: "/runtime/files/copy" },
+    "fs.remove": { method: "POST", path: "/runtime/files/remove" },
+    "fs.delete": { method: "DELETE", path: "/runtime/files" },
+    "fs.tail": { method: "POST", path: "/runtime/files/tail" },
+    "fs.find": { method: "POST", path: "/runtime/files/find" },
+    "fs.textSearch": { method: "POST", path: "/runtime/files/search" },
+    "fs.tree": { method: "POST", path: "/runtime/files/tree" },
+    "service.list": { method: "GET", path: "/runtime/services" },
+    "service.run": { method: "POST", path: "/runtime/services/run" },
+    "service.stop": { method: "POST", path: "/runtime/services/stop" },
+    "service.logs": { method: "POST", path: "/runtime/services/logs" },
+    "composer.invoke": { method: "POST", path: "/runtime/composer/executions" },
+    "composer.packages": { method: "GET", path: "/runtime/composer/packages" },
+    "composer.dump-autoload": {
+      method: "POST",
+      path: "/runtime/composer/autoload"
+    },
+    "git.checkpoint": { method: "POST", path: "/runtime/git/checkpoints" },
+    "git.checkout": { method: "POST", path: "/runtime/git/checkouts" },
+    "git.log": { method: "POST", path: "/runtime/git/log" },
+    "git.sync": { method: "POST", path: "/runtime/git/sync" },
+    "git.diff": { method: "POST", path: "/runtime/git/diff" },
+    "git.merge": { method: "POST", path: "/runtime/git/merge" },
+    "git.conflicts": { method: "GET", path: "/runtime/git/conflicts" },
+    "git.resolve": { method: "POST", path: "/runtime/git/conflicts/resolve" },
+    "git.restore": { method: "POST", path: "/runtime/git/restore" },
+    "git.status": { method: "GET", path: "/runtime/git/status" },
+    "git.review": { method: "GET", path: "/runtime/git/review" },
+    "git.stage": { method: "POST", path: "/runtime/git/stage" },
+    "git.unstage": { method: "POST", path: "/runtime/git/unstage" },
+    "git.revert": { method: "POST", path: "/runtime/git/revert" }
+  };
+  var RestRuntimeInvoker = class {
+    constructor(data, fetch, refresh) {
+      this.fetch = fetch;
+      this.refresh = refresh;
+      this.refreshPromise = null;
+      this.notebookId = data.id;
+      this.configure(data.runtimeUrl ?? data.okraUrl);
+    }
+    configure(runtimeUrl) {
+      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.");
+      }
+      this.ticket = ticket;
+      actionUrl.protocol = actionUrl.protocol === "wss:" ? "https:" : "http:";
+      actionUrl.pathname = `/api/v1/notebooks/${encodeURIComponent(this.notebookId)}`;
+      actionUrl.searchParams.delete("ticket");
+      actionUrl.hash = "";
+      this.actionUrl = actionUrl;
+    }
+    ready() {
+      return this.invokeRaw("runtime.ready", {}, {});
+    }
+    supports(action) {
+      return action in restActionRoutes;
+    }
+    invoke(action, data = {}, options = {}) {
+      return this.invokeRaw(action, data ?? {}, options);
+    }
+    send() {
+      throw new UnsupportedRuntimeTransportError("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));
+          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);
+          }
+          return payload.data;
+        }
+        throw new ErrorEvent(401, `Runtime action ${action} could not be authorized.`, {});
+      } finally {
+        abort.dispose();
+      }
+    }
+    request(action, data, signal) {
+      const route = restActionRoutes[action];
+      if (route === void 0) {
+        throw new UnsupportedRuntimeTransportError(`Runtime action ${action} requires the realtime transport.`);
+      }
+      const url2 = new URL(this.actionUrl);
+      url2.pathname += route.path;
+      const headers = {
+        Accept: "application/json, application/octet-stream",
+        Authorization: `Bearer ${this.ticket}`
+      };
+      const body = runtimeActionRequestBody(action, data, url2, headers);
+      return new Request(url2, {
+        method: route.method,
+        headers,
+        body: route.method === "GET" ? void 0 : body,
+        signal
+      });
+    }
+    async refreshAuthorization() {
+      if (this.refreshPromise === null) {
+        this.refreshPromise = this.refresh().then((runtimeUrl) => this.configure(runtimeUrl));
+      }
+      try {
+        await this.refreshPromise;
+      } finally {
+        this.refreshPromise = null;
+      }
+    }
+  };
+  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 === "") {
+      return {};
+    }
+    try {
+      return JSON.parse(body);
+    } catch {
+      return { error: { code: response.status, message: body } };
+    }
+  }
+  function runtimeActionRequestBody(action, data, url2, headers) {
+    const payload = runtimeActionRecord(data);
+    if (action === "fs.readFile") {
+      setRequiredRuntimeQuery(url2, "path", payload.path);
+      const lineRange = runtimeActionRecord(payload.lineRange);
+      if (lineRange.lineStart !== void 0 || lineRange.lineEnd !== void 0) {
+        setRequiredRuntimeQuery(url2, "lineStart", lineRange.lineStart);
+        setRequiredRuntimeQuery(url2, "lineEnd", lineRange.lineEnd);
+      }
+      return void 0;
+    }
+    if (action === "fs.writeFile") {
+      setRequiredRuntimeQuery(url2, "path", payload.path);
+      const options = runtimeActionRecord(payload.options);
+      setBooleanRuntimeQuery(url2, "overwrite", options.overwrite);
+      setBooleanRuntimeQuery(url2, "create", options.create);
+      setBooleanRuntimeQuery(url2, "unlock", options.unlock);
+      const atomic = runtimeActionRecord(options.atomic);
+      if (typeof atomic.postfix === "string" && atomic.postfix !== "") {
+        url2.searchParams.set("atomicPostfix", atomic.postfix);
+      }
+      if (!ArrayBuffer.isView(payload.contents)) {
+        throw new TypeError("Runtime file contents must be binary data.");
+      }
+      headers["Content-Type"] = "application/octet-stream";
+      return Uint8Array.from(
+        new Uint8Array(payload.contents.buffer, payload.contents.byteOffset, payload.contents.byteLength)
+      ).buffer;
+    }
+    headers["Content-Type"] = "application/json";
+    return JSON.stringify(data);
+  }
+  function runtimeActionRecord(value) {
+    return value !== null && typeof value === "object" ? value : {};
+  }
+  function setRequiredRuntimeQuery(url2, name, value) {
+    if (typeof value !== "string" && typeof value !== "number" || String(value) === "") {
+      throw new TypeError(`Runtime file ${name} is required.`);
+    }
+    url2.searchParams.set(name, String(value));
+  }
+  function setBooleanRuntimeQuery(url2, name, value) {
+    url2.searchParams.set(name, value === true ? "true" : "false");
+  }
+  function runtimeAbort(options) {
+    if (options.timeout === void 0 && options.abortSignal === void 0) {
+      return { signal: new AbortController().signal, dispose: () => void 0 };
+    }
+    const controller = new AbortController();
+    const abortFromCaller = () => controller.abort(options.abortSignal?.reason);
+    options.abortSignal?.addEventListener("abort", abortFromCaller, {
+      once: true
+    });
+    if (options.abortSignal?.aborted) {
+      abortFromCaller();
+    }
+    const timeout2 = options.timeout === void 0 ? void 0 : setTimeout(() => controller.abort(), options.timeout);
+    return {
+      signal: controller.signal,
+      dispose: () => {
+        options.abortSignal?.removeEventListener("abort", abortFromCaller);
+        if (timeout2 !== void 0) {
+          clearTimeout(timeout2);
+        }
+      }
+    };
+  }
+
   // src/index.ts
   function normalizeNotebookSecretInputs(input) {
     if (Array.isArray(input)) {
@@ -19985,6 +20232,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   }
   var Client2 = class {
     constructor(token, url2 = "https://api.phpsandbox.io/v1", options = {}) {
+      this.runtimeTransportValue = "realtime";
       this.fetch = globalThis.fetch;
       this.deployments = new DeploymentApi(this);
       this.notebook = new NotebookApi(this);
@@ -20000,6 +20248,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         "Content-Type": "application/json"
       };
     }
+    get runtimeTransport() {
+      return this.runtimeTransportValue;
+    }
     get(path) {
       return this.makeRequest("GET", path);
     }
@@ -20063,7 +20314,15 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       return { data: body === "" ? void 0 : JSON.parse(body) };
     }
   };
-  var PHPSandbox = class extends Client2 {
+  var PHPSandbox = class _PHPSandbox extends Client2 {
+    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) {
@@ -20169,17 +20428,40 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       this.client = client;
       __privateAdd(this, _NotebookInstance_instances);
       this.initialized = false;
-      __privateAdd(this, _initPromise);
+      __privateAdd(this, _initPromise, null);
       this.disposables = [];
+      const runtimeUrl = data.runtimeUrl ?? data.okraUrl;
+      const runtimeUrlProvider = client.options.runtimeUrlProvider ?? client.options.okraUrlProvider;
       this.emitter = EventManager.createInstance();
-      this.socket = new Transport(data.okraUrl, this.emitter, {
-        debug: client.options.debug,
-        startClosed: client.options.startClosed,
-        webSocket: client.options.webSocket
-      });
-      this.watchConnection();
-      __privateSet(this, _initPromise, __privateMethod(this, _NotebookInstance_instances, init_fn).call(this));
-      this.file = new Filesystem(this);
+      if (client.runtimeTransport === "rest") {
+        this.socket = null;
+        this.restInvoker = new RestRuntimeInvoker(
+          data,
+          client.options.fetch ?? globalThis.fetch,
+          runtimeUrlProvider === void 0 ? void 0 : () => runtimeUrlProvider(data.id)
+        );
+      } else {
+        this.restInvoker = null;
+        let initialConnection = true;
+        const connectionUrl = runtimeUrlProvider === void 0 ? runtimeUrl : async () => {
+          if (initialConnection) {
+            initialConnection = false;
+            return runtimeUrl;
+          }
+          return runtimeUrlProvider(data.id);
+        };
+        this.socket = new Transport(connectionUrl, this.emitter, {
+          debug: client.options.debug,
+          startClosed: client.options.startClosed,
+          webSocket: client.options.webSocket
+        });
+        this.watchConnection();
+        __privateSet(this, _initPromise, __privateMethod(this, _NotebookInstance_instances, init_fn).call(this));
+      }
+      this.file = new Filesystem(
+        this,
+        this.socket === null ? null : (handler) => this.onDidConnect(handler)
+      );
       this.terminal = new Terminal(this);
       this.auth = new Auth(this);
       this.lsp = new Lsp(this);
@@ -20196,14 +20478,21 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       this.preview = new NotebookPreview(client, this.data.id);
       this.mail = new NotebookMail(client, this.data.id);
     }
+    get runtimeTransport() {
+      return this.client.runtimeTransport;
+    }
     async ready() {
-      const terminalError = this.socket.getTerminalError();
+      if (this.restInvoker !== null) {
+        return this.restInitialization();
+      }
+      const socket = this.realtimeSocket();
+      const terminalError = socket.getTerminalError();
       if (terminalError) {
         throw terminalError;
       }
       const ready = async () => {
-        if (this.client.options.startClosed && !this.socket.isConnected) {
-          await this.socket.connect();
+        if (this.client.options.startClosed && !socket.isConnected) {
+          await socket.connect();
         }
         return __privateGet(this, _initPromise);
       };
@@ -20223,7 +20512,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
     delete() {
       return this.client.notebook.delete(this.data.id).then(() => {
-        this.socket.terminate(new NotebookUnavailableError("Notebook has been deleted.", { id: this.data.id }));
+        this.socket?.terminate(new NotebookUnavailableError("Notebook has been deleted.", { id: this.data.id }));
       });
     }
     stop() {
@@ -20233,10 +20522,19 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       return this.container.restart();
     }
     invoke(action, data = {}, options = {}) {
-      return this.socket.invoke(action, data || {}, options);
+      if (this.restInvoker !== null) {
+        if (this.restInvoker.supports(String(action))) {
+          void this.restInitialization();
+        }
+        return this.restInvoker.invoke(action, data || {}, options);
+      }
+      return this.realtimeSocket().invoke(action, data || {}, options);
     }
     send(action, data = {}) {
-      return this.socket.send(action, data || {});
+      if (this.restInvoker !== null) {
+        return this.restInvoker.send();
+      }
+      return this.realtimeSocket().send(action, data || {});
     }
     ping() {
       return this.invoke("ping");
@@ -20248,7 +20546,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
     dispose() {
       this.disposables.forEach((d) => d.dispose());
-      !this.socket.isClosed && this.socket.disconnect();
+      if (this.socket !== null && !this.socket.isClosed) {
+        this.socket.disconnect();
+      }
     }
     connected() {
       return this.waitForSocketConnection({ rejectOnClose: true });
@@ -20257,11 +20557,12 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       return this.waitForSocketConnection({ rejectOnClose: false });
     }
     waitForSocketConnection(options) {
-      const terminalError = this.socket.getTerminalError();
+      const socket = this.realtimeSocket();
+      const terminalError = socket.getTerminalError();
       if (terminalError) {
         return Promise.reject(terminalError);
       }
-      if (this.socket.isConnected) {
+      if (socket.isConnected) {
         return Promise.resolve(this);
       }
       return new Promise((resolve, reject) => {
@@ -20282,49 +20583,66 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           callback();
         };
         try {
-          disposables.push(this.socket.onDidConnect(() => settle(() => resolve(this))));
+          disposables.push(socket.onDidConnect(() => settle(() => resolve(this))));
           if (options.rejectOnClose) {
-            disposables.push(this.socket.onDidClose(() => settle(() => reject(new Error("Connection closed")))));
+            disposables.push(socket.onDidClose(() => settle(() => reject(new Error("Connection closed")))));
           }
-          disposables.push(this.socket.onDidBootError((error51) => settle(() => reject(error51))));
+          disposables.push(socket.onDidBootError((error51) => settle(() => reject(error51))));
         } catch (e) {
           settle(() => reject(e));
         }
       });
     }
     watchConnection() {
-      this.socket.onDidConnect(() => {
-        this.socket.emit("okra.connected");
+      const socket = this.realtimeSocket();
+      socket.onDidConnect(() => {
+        socket.emit("okra.connected");
         if (this.client.options.telemetry) {
           this.container.enableTelemetry(this.client.options.telemetry);
         }
       });
-      this.socket.onDidClose(() => {
-        this.socket.emit("okra.disconnected");
+      socket.onDidClose(() => {
+        socket.emit("okra.disconnected");
         this.initialized = false;
       });
-      this.socket.onDidBootError((error51) => {
-        this.socket.emit("okra.boot_error", error51);
-        this.socket.emit("okra.disconnected");
+      socket.onDidBootError((error51) => {
+        socket.emit("okra.boot_error", error51);
+        socket.emit("okra.disconnected");
         this.initialized = false;
       });
     }
     onDidConnect(handler) {
-      this.socket.removeListener("okra.connected", handler);
-      const disposable = this.socket.listen("okra.connected", handler);
+      const socket = this.realtimeSocket();
+      socket.removeListener("okra.connected", handler);
+      const disposable = socket.listen("okra.connected", handler);
       this.disposables.push(disposable);
       return disposable;
     }
     onDidDisconnect(handler) {
-      const disposable = this.socket.listen("okra.disconnected", handler);
+      const disposable = this.realtimeSocket().listen("okra.disconnected", handler);
       this.disposables.push(disposable);
       return disposable;
     }
     onDidBootError(handler) {
-      const disposable = this.socket.listen("okra.boot_error", handler);
+      const disposable = this.realtimeSocket().listen("okra.boot_error", handler);
       this.disposables.push(disposable);
       return disposable;
     }
+    restInitialization() {
+      if (this.restInvoker === null) {
+        throw new UnsupportedRuntimeTransportError("This operation requires the REST transport.");
+      }
+      if (__privateGet(this, _initPromise) === null) {
+        __privateSet(this, _initPromise, this.restInvoker.ready().then((result) => {
+          this.initialized = result;
+          this.emitter.emit("notebook.initialized", result);
+          return result;
+        }));
+        void __privateGet(this, _initPromise).catch(() => {
+        });
+      }
+      return __privateGet(this, _initPromise);
+    }
     update(input) {
       return this.client.notebook.update(this.data.id, input);
     }
@@ -20332,8 +20650,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       return this.listen("notebook.initialized", handler);
     }
     async reconnect() {
+      const socket = this.realtimeSocket();
       const whenConnected = this.whenConnected();
-      this.socket.reconnect();
+      socket.reconnect();
       this.initialized = false;
       await whenConnected;
       __privateMethod(this, _NotebookInstance_instances, init_fn).call(this);
@@ -20344,6 +20663,12 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       iframe.src = result.data.previewUrl;
       return createBeacon(iframe, options);
     }
+    realtimeSocket() {
+      if (this.socket === null) {
+        throw new UnsupportedRuntimeTransportError("This operation requires the realtime transport.");
+      }
+      return this.socket;
+    }
   };
   _initPromise = new WeakMap();
   _NotebookInstance_instances = new WeakSet();