@phpsandbox/sdk 0.0.68 → 0.1.1

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

@@ -112,8 +112,25 @@ var Filesystem = class {
   info(path) {
     return this.okra.invoke("fs.info", { path });
   }
-  write(path, contents) {
-    return this.okra.invoke("fs.write", { path, contents });
+  async write(path, contents, options = { overwrite: true, create: true, unlock: false, atomic: false }) {
+    if (typeof contents === "string") {
+      return this.okra.invoke("fs.write", { path, contents });
+    }
+    const bytes = contents instanceof Uint8Array ? contents : await collectBytes(contents);
+    await this.writeFile(path, bytes, options);
+    return true;
+  }
+  read(path) {
+    return new ReadableStream({
+      start: async (controller) => {
+        try {
+          controller.enqueue(await this.readFile(path));
+          controller.close();
+        } catch (error51) {
+          controller.error(error51);
+        }
+      }
+    });
   }
   find(query, options = {
     useIgnoreFiles: false,
@@ -289,6 +306,21 @@ var Filesystem = class {
     throw e;
   }
 };
+async function collectBytes(stream) {
+  const chunks = [];
+  let length = 0;
+  for await (const chunk of stream) {
+    chunks.push(chunk);
+    length += chunk.byteLength;
+  }
+  const output = new Uint8Array(length);
+  let offset = 0;
+  for (const chunk of chunks) {
+    output.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return output;
+}
 
 // src/errors/index.ts
 var PromiseTimeoutError = class extends Error {
@@ -341,9 +373,6 @@ var Terminal = class {
   list() {
     return this.okra.invoke("terminal.list");
   }
-  start() {
-    return this.okra.invoke("terminal.start");
-  }
   create(input) {
     return this.okra.invoke("terminal.create", input);
   }
@@ -476,7 +505,7 @@ var Terminal = class {
         disposeInput();
       }
     });
-    const exit = new Promise((resolve) => {
+    const completion = new Promise((resolve) => {
       disposables.add(
         this.listen(`terminal.close.${id}`, (data) => {
           if (controller) {
@@ -505,7 +534,7 @@ var Terminal = class {
     }
     return {
       process: {
-        exit,
+        wait: () => completion,
         input,
         output,
         kill,
@@ -581,9 +610,6 @@ var Auth = class {
   constructor(okra) {
     this.okra = okra;
   }
-  logout() {
-    this.okra.dispose();
-  }
   login(runtimeUrl) {
     const runtimeTicket = new URL(runtimeUrl).searchParams.get("ticket");
     if (runtimeTicket === null || runtimeTicket === "") {
@@ -708,19 +734,6 @@ var Log = class {
   }
 };
 
-// src/laravel.ts
-var Laravel = class {
-  constructor(okra) {
-    this.okra = okra;
-  }
-  maintenanceInfo() {
-    return this.okra.invoke("laravel.maintenance.info", {});
-  }
-  toggleMaintenance(down) {
-    return this.okra.invoke("laravel.maintenance.toggle", down);
-  }
-};
-
 // src/repl.ts
 var Repl = class {
   constructor(okra) {
@@ -735,9 +748,6 @@ var Repl = class {
   stop() {
     return this.okra.invoke("repl.stop");
   }
-  start() {
-    return this.okra.invoke("repl.start");
-  }
   resize(cols, rows) {
     return this.okra.invoke("repl.resize", { cols, rows });
   }
@@ -750,113 +760,142 @@ var Repl = class {
 };
 
 // src/shell.ts
-function resolveExecInput(command, argsOrOpts = [], opts) {
+function resolveRunInput(command, argsOrOpts = [], opts) {
   const args = Array.isArray(argsOrOpts) ? argsOrOpts : [];
   const resolvedOpts = Array.isArray(argsOrOpts) ? opts : argsOrOpts;
   return {
     command: Array.isArray(command) ? command : args.length > 0 ? [command, ...args] : command,
-    opts: resolvedOpts
+    opts: { tty: false, ...resolvedOpts }
   };
 }
 var CommandError = class extends Error {
-  constructor(output, exitCode) {
-    super(output);
-    this.output = output;
-    this.exitCode = exitCode;
+  constructor(result) {
+    super(result.output);
+    this.result = result;
   }
 };
-var Result = class {
-  constructor(output, exitCode) {
+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.output, this.exitCode);
+      throw new CommandError(this);
     }
     return this;
   }
 };
-var Shell = class {
-  constructor(okra) {
-    this.okra = okra;
+var OutputStream = class {
+  constructor() {
+    this.controller = null;
+    this.closed = false;
+    this.stream = new ReadableStream({
+      start: (controller) => {
+        this.controller = controller;
+      },
+      cancel: () => {
+        this.closed = true;
+        this.controller = null;
+      }
+    });
   }
-  onOutput(id, handler) {
-    return this.okra.listen(`shell.output.${id}`, handler);
+  enqueue(value) {
+    if (!this.closed) {
+      this.controller?.enqueue(value);
+    }
   }
-  listen(event, handler) {
-    return this.okra.listen(event, handler);
+  close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    this.controller?.close();
+    this.controller = null;
   }
-  async exec(command, argsOrOpts = [], opts) {
-    const input = resolveExecInput(command, argsOrOpts, opts);
-    const { abortSignal, ...payloadOpts } = input.opts ?? {};
-    const result = await this.okra.invoke(
-      "shell.exec",
-      {
-        command: input.command,
-        opts: Object.keys(payloadOpts).length > 0 ? payloadOpts : void 0
-      },
-      { abortSignal }
-    );
-    return new Result(result.output, result.exitCode);
+  fail(error51) {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    this.controller?.error(error51);
+    this.controller = null;
   }
-  execStream(command, argsOrOpts = [], opts) {
-    const input = resolveExecInput(command, argsOrOpts, opts);
-    const id = input.opts?.id || nanoid();
-    const disposables = /* @__PURE__ */ new Set();
-    let controller = null;
-    let closed = false;
-    const dispose = () => {
-      for (const disposable of disposables) {
-        disposable.dispose();
-      }
-      disposables.clear();
-    };
-    const close = () => {
-      if (closed) {
-        return;
-      }
-      closed = true;
-      dispose();
-      if (controller) {
-        try {
-          controller.close();
-        } catch {
+};
+var ShellProcess = class {
+  constructor(id, okra, command, opts) {
+    this.id = id;
+    this.okra = okra;
+    const output = new OutputStream();
+    const stdout = new OutputStream();
+    const stderr = new OutputStream();
+    this.output = output.stream;
+    this.stdout = stdout.stream;
+    this.stderr = stderr.stream;
+    this.stdin = new WritableStream({
+      write: async (chunk) => {
+        const input = typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
+        const written = await this.okra.invoke("shell.input", { id: this.id, input });
+        if (!written) {
+          throw new Error(`Process ${this.id} is not accepting input`);
         }
       }
+    });
+    const encoder = new TextEncoder();
+    let subscription = this.okra.listen(`shell.output.${this.id}`, (event) => {
+      const data = encoder.encode(event.output);
+      const source = event.source ?? "output";
+      output.enqueue({ source, data });
+      if (source === "stderr") {
+        stderr.enqueue(data);
+      } else {
+        stdout.enqueue(data);
+      }
+    });
+    const finish = () => {
+      subscription?.dispose();
+      subscription = null;
+      output.close();
+      stdout.close();
+      stderr.close();
     };
     const fail = (error51) => {
-      if (closed) {
-        return;
-      }
-      closed = true;
-      dispose();
-      if (controller) {
-        controller.error(error51);
-      }
+      subscription?.dispose();
+      subscription = null;
+      output.fail(error51);
+      stdout.fail(error51);
+      stderr.fail(error51);
     };
-    const output = new ReadableStream({
-      start: (_controller) => {
-        controller = _controller;
-        disposables.add(
-          this.listen(`shell.output.${id}`, (data) => {
-            controller?.enqueue(data.output);
-          })
-        );
-      },
-      cancel: () => {
-        closed = true;
-        dispose();
-      }
-    });
-    const result = this.exec(input.command, { ...input.opts, id }).then((response) => {
-      close();
-      return response;
+    const { abortSignal, ...payloadOpts } = opts;
+    this.completion = this.okra.invoke(
+      "shell.exec",
+      { command, opts: { ...payloadOpts, id: this.id } },
+      { abortSignal }
+    ).then((result) => {
+      finish();
+      return new ProcessResult(result.output, result.stdout, result.stderr, result.exitCode);
     }).catch((error51) => {
       fail(error51);
       throw error51;
     });
-    return { output, result };
+  }
+  wait() {
+    return this.completion;
+  }
+  async kill() {
+    await this.okra.invoke("shell.kill", { id: this.id });
+  }
+};
+var Shell = class {
+  constructor(okra) {
+    this.okra = okra;
+  }
+  run(command, argsOrOpts = [], opts) {
+    const input = resolveRunInput(command, argsOrOpts, opts);
+    const id = input.opts?.id ?? nanoid();
+    return new ShellProcess(id, this.okra, input.command, { ...input.opts, id });
   }
 };
 
@@ -3927,732 +3966,6 @@ var Git = class {
   }
 };
 
-// src/beacon/navigator.ts
-var Navigator = class {
-  constructor(onEvent, onceEvent, beacon) {
-    this.onEvent = onEvent;
-    this.onceEvent = onceEvent;
-    this.beacon = beacon;
-    this.urlHistory = [];
-    this.currentIndex = 0;
-    this._canGoBack = false;
-    this._canGoForward = false;
-    this.beacon = beacon;
-    this.setupUrlChangeListener();
-    this.urlHistory.push(beacon.iframe.src);
-    this.updateNavigationState();
-  }
-  /**
-   * Navigate to a URL using internal history management
-   */
-  visit(url2) {
-    if (!this.beacon) {
-      throw new Error("Beacon reference not set");
-    }
-    this.beacon.navigate(url2);
-    if (this.currentIndex < this.urlHistory.length - 1) {
-      this.urlHistory = this.urlHistory.slice(0, this.currentIndex + 1);
-    }
-    this.urlHistory.push(url2);
-    this.currentIndex = this.urlHistory.length - 1;
-    this.updateNavigationState();
-    this.emitHistoryChange(url2, "push");
-  }
-  /**
-   * Set up listener for URL change events from the beacon
-   */
-  setupUrlChangeListener() {
-    this.beacon.on("urlChange", (payload) => {
-      this.addToHistory(payload.newUrl);
-    });
-  }
-  /**
-   * Add URL to internal history
-   */
-  addToHistory(url2) {
-    if (this.currentIndex < this.urlHistory.length - 1) {
-      this.urlHistory = this.urlHistory.slice(0, this.currentIndex + 1);
-    }
-    this.urlHistory.push(url2);
-    this.currentIndex = this.urlHistory.length - 1;
-    this.updateNavigationState();
-  }
-  /**
-   * Update internal navigation state and emit changes
-   */
-  updateNavigationState() {
-    const previousCanGoBack = this._canGoBack;
-    const previousCanGoForward = this._canGoForward;
-    this._canGoBack = this.currentIndex > 0;
-    this._canGoForward = this.currentIndex < this.urlHistory.length - 1;
-    if (previousCanGoBack !== this._canGoBack || previousCanGoForward !== this._canGoForward) {
-      this.emitNavigationStateChange();
-    }
-  }
-  /**
-   * Emit navigation state change event
-   */
-  emitNavigationStateChange() {
-    if (this.beacon && this.beacon.emit) {
-      this.beacon.emit("navigationStateChange", {
-        canGoBack: this._canGoBack,
-        canGoForward: this._canGoForward,
-        currentIndex: this.currentIndex,
-        historyLength: this.urlHistory.length,
-        timestamp: Date.now()
-      });
-    }
-  }
-  get canGoBack() {
-    return this._canGoBack;
-  }
-  get canGoForward() {
-    return this._canGoForward;
-  }
-  async goBack() {
-    if (!this.canGoBack) {
-      return { success: false, error: "Cannot go back - no previous history" };
-    }
-    this.currentIndex--;
-    this.updateNavigationState();
-    const url2 = this.urlHistory[this.currentIndex];
-    if (!this.beacon) {
-      return { success: false, error: "Beacon reference not set" };
-    }
-    this.beacon.navigate(url2);
-    this.emitHistoryChange(url2, "back");
-    return { success: true, url: url2 };
-  }
-  /**
-   * Navigate forward in internal history
-   */
-  async goForward() {
-    if (!this.canGoForward) {
-      return { success: false, error: "Cannot go forward - no forward history" };
-    }
-    this.currentIndex++;
-    this.updateNavigationState();
-    const url2 = this.urlHistory[this.currentIndex];
-    if (!this.beacon) {
-      return { success: false, error: "Beacon reference not set" };
-    }
-    this.beacon.navigate(url2);
-    this.emitHistoryChange(url2, "forward");
-    return { success: true, url: url2 };
-  }
-  /**
-   * Reload the current page
-   */
-  async reload() {
-    if (this.currentIndex >= 0 && this.currentIndex < this.urlHistory.length) {
-      const currentUrl = this.urlHistory[this.currentIndex];
-      if (!this.beacon) {
-        throw new Error("Beacon reference not set");
-      }
-      this.beacon.navigate(currentUrl);
-      this.emitHistoryChange(currentUrl, "reload");
-    }
-  }
-  /**
-   * Get current URL from internal history
-   */
-  getCurrentUrl() {
-    if (this.currentIndex >= 0 && this.currentIndex < this.urlHistory.length) {
-      return new URL(this.urlHistory[this.currentIndex]);
-    }
-    return new URL("about:blank");
-  }
-  /**
-   * Get the complete history array
-   */
-  getHistory() {
-    return [...this.urlHistory];
-  }
-  /**
-   * Get current history index
-   */
-  getCurrentIndex() {
-    return this.currentIndex;
-  }
-  /**
-   * Check if can go back synchronously
-   */
-  canGoBackSync() {
-    return this.currentIndex > 0;
-  }
-  /**
-   * Check if can go forward synchronously
-   */
-  canGoForwardSync() {
-    return this.currentIndex < this.urlHistory.length - 1;
-  }
-  /**
-   * Emit history change event
-   */
-  emitHistoryChange(url2, direction) {
-    if (this.beacon && this.beacon.emit) {
-      this.beacon.emit("historyChange", {
-        url: url2,
-        state: null,
-        direction,
-        timestamp: Date.now()
-      });
-    }
-  }
-  /**
-   * Push a new state to internal history (legacy method for compatibility)
-   */
-  async pushState(url2) {
-    this.visit(url2);
-  }
-  /**
-   * Replace current state in internal history (legacy method for compatibility)
-   */
-  async replaceState(url2) {
-    if (this.currentIndex >= 0 && this.currentIndex < this.urlHistory.length) {
-      this.urlHistory[this.currentIndex] = url2;
-      if (!this.beacon) {
-        throw new Error("Beacon reference not set");
-      }
-      this.beacon.navigate(url2);
-      this.emitHistoryChange(url2, "replace");
-    } else {
-      this.visit(url2);
-    }
-  }
-  /**
-   * Get the current history length
-   */
-  async getHistoryLength() {
-    return this.urlHistory.length;
-  }
-  /**
-   * Get the current history state (always null since we don't store state)
-   */
-  async getHistoryState() {
-    return null;
-  }
-  /**
-   * Get comprehensive history information
-   */
-  async getHistoryInfo() {
-    return {
-      length: this.urlHistory.length,
-      state: null,
-      url: this.urlHistory[this.currentIndex] || "",
-      canGoBack: this.canGoBack,
-      canGoForward: this.canGoForward
-    };
-  }
-  /**
-   * Listen for navigator events
-   */
-  on(event, handler) {
-    return this.onEvent(event, handler);
-  }
-  /**
-   * Listen for navigator events (once)
-   */
-  once(event, handler) {
-    this.onceEvent(event, handler);
-  }
-};
-
-// src/beacon/index.ts
-function ensureBrowserEnvironment() {
-  if (typeof window === "undefined") {
-    throw new Error("Beacon SDK can only be used in a browser environment");
-  }
-}
-var BeaconError = class extends Error {
-  constructor(message, code) {
-    super(message);
-    this.code = code;
-    this.name = "BeaconError";
-  }
-};
-var BeaconTimeoutError = class extends BeaconError {
-  constructor(operation, timeoutMs) {
-    super(`Beacon operation '${operation}' timed out after ${timeoutMs}ms`);
-    this.code = "TIMEOUT";
-  }
-};
-var BeaconConnectionError = class extends BeaconError {
-  constructor(message) {
-    super(`Beacon connection error: ${message}`);
-    this.code = "CONNECTION_ERROR";
-  }
-};
-var Beacon = class {
-  constructor(iframe, options = {}) {
-    this.messageHandlers = /* @__PURE__ */ new Map();
-    this.isBeaconReady = false;
-    this.readyPromise = null;
-    this.isStarted = false;
-    this.disposables = [];
-    // MessagePort communication
-    this.messageChannel = null;
-    this.port = null;
-    this.channelEstablished = false;
-    ensureBrowserEnvironment();
-    this.iframe = iframe;
-    const defaultRetryOptions = {
-      retries: 3,
-      minTimeout: 1e3,
-      maxTimeout: 5e3,
-      factor: 2,
-      randomize: true
-    };
-    this.options = {
-      timeout: 1e4,
-      targetOrigin: "*",
-      debug: false,
-      retry: {
-        ...defaultRetryOptions,
-        ...options.retry
-      },
-      ...options
-    };
-    this.eventEmitter = EventManager.make();
-    this.setupMessageChannel();
-    this.navigator = new Navigator(
-      this.eventEmitter.listen.bind(this.eventEmitter),
-      this.eventEmitter.once.bind(this.eventEmitter),
-      this
-    );
-  }
-  /**
-   * Setup communication channel using MessagePort
-   */
-  setupMessageChannel() {
-    const readyHandler = (event) => {
-      try {
-        if (event.source !== this.iframe.contentWindow) {
-          return;
-        }
-        const message = event.data;
-        if (!message || typeof message !== "object" || !message.type) {
-          return;
-        }
-        if (message.type === "beacon:ready-for-channel") {
-          this.establishChannel().catch((error51) => {
-            if (this.options.debug) {
-              console.error("[Beacon SDK] Channel establishment failed:", error51);
-            }
-          });
-        }
-        if (message.type === "beacon:channel-established") {
-          this.channelEstablished = true;
-          this.isBeaconReady = true;
-          this.emit("ready", message.payload);
-          if (this.options.debug) {
-            console.log("[Beacon SDK] Channel established and beacon ready");
-          }
-        }
-      } catch (error51) {
-        if (this.options.debug) {
-          console.error("[Beacon SDK] Message parsing error:", error51);
-        }
-      }
-    };
-    window.addEventListener("message", readyHandler);
-    this.disposables.push({
-      dispose: () => window.removeEventListener("message", readyHandler)
-    });
-  }
-  /**
-   * Establish MessagePort communication channel
-   */
-  async establishChannel() {
-    if (!this.iframe.contentWindow) {
-      throw new BeaconConnectionError("Iframe contentWindow not available");
-    }
-    this.messageChannel = new MessageChannel();
-    this.port = this.messageChannel.port1;
-    this.port.onmessage = (event) => {
-      this.handleBeaconMessage(event.data);
-    };
-    this.port.onmessageerror = (event) => {
-      if (this.options.debug) {
-        console.error("[Beacon SDK] Port message error:", event);
-      }
-    };
-    this.port.start();
-    const establishMessage = {
-      type: "beacon:establish-channel",
-      timestamp: Date.now(),
-      id: this.generateId()
-    };
-    this.iframe.contentWindow.postMessage(
-      establishMessage,
-      "*",
-      // Safe for channel establishment
-      [this.messageChannel.port2]
-      // Transfer the port
-    );
-    if (this.options.debug) {
-      console.log("[Beacon SDK] Channel establishment message sent");
-    }
-    return new Promise((resolve, reject) => {
-      const timeoutId = setTimeout(() => {
-        reject(new BeaconConnectionError("Channel establishment timeout"));
-      }, this.options.timeout);
-      const checkReady = () => {
-        if (this.channelEstablished && this.isBeaconReady) {
-          clearTimeout(timeoutId);
-          resolve();
-        } else {
-          setTimeout(checkReady, 100);
-        }
-      };
-      checkReady();
-    });
-  }
-  /**
-   * Handle incoming beacon messages
-   */
-  handleBeaconMessage(message) {
-    if (this.options.debug) {
-      console.log("[Beacon SDK] Received message:", message.type, message.payload);
-    }
-    const eventType = message.type.replace("beacon:", "");
-    this.emit(eventType, message.payload);
-    const handlers = this.messageHandlers.get(message.type);
-    if (handlers) {
-      handlers.forEach((handler) => {
-        try {
-          handler(message.payload);
-        } catch (error51) {
-          if (this.options.debug) {
-            console.error("[Beacon SDK] Message handler error:", error51);
-          }
-        }
-      });
-    }
-  }
-  /**
-   * Wait for beacon to be ready - simplified approach
-   */
-  waitForBeaconReady() {
-    return retry(
-      async () => {
-        return new Promise((resolve, reject) => {
-          if (this.isBeaconReady && this.channelEstablished) {
-            resolve();
-            return;
-          }
-          const timeoutMs = this.options.timeout;
-          const timeoutId = setTimeout(() => {
-            reject(new BeaconTimeoutError("beacon ready", timeoutMs));
-          }, timeoutMs);
-          const unsubscribe = this.on("ready", () => {
-            clearTimeout(timeoutId);
-            unsubscribe.dispose();
-            resolve();
-          });
-        });
-      },
-      {
-        retries: this.options.retry?.retries ?? 3,
-        minTimeout: this.options.retry?.minTimeout ?? 1e3,
-        maxTimeout: this.options.retry?.maxTimeout ?? 5e3,
-        factor: this.options.retry?.factor ?? 2,
-        randomize: this.options.retry?.randomize ?? true,
-        onRetry: (error51, attempt) => {
-          if (this.options.debug) {
-            const errorMessage = error51 instanceof Error ? error51.message : String(error51);
-            console.warn(`[Beacon SDK] Beacon ready retry attempt ${attempt}:`, errorMessage);
-          }
-          this.isBeaconReady = false;
-          this.channelEstablished = false;
-        }
-      }
-    );
-  }
-  /**
-   * Send a message to the beacon via MessagePort
-   */
-  sendMessage(type, payload = {}) {
-    if (!this.port) {
-      throw new BeaconConnectionError("MessagePort not available - channel not established");
-    }
-    const message = {
-      type: `beacon:${type}`,
-      payload,
-      timestamp: Date.now(),
-      source: "parent",
-      id: this.generateId()
-    };
-    try {
-      this.port.postMessage(message);
-      if (this.options.debug) {
-        console.log("[Beacon SDK] Sent message via port:", message.type, message.payload);
-      }
-    } catch (error51) {
-      throw new BeaconConnectionError(
-        `Failed to send message via port: ${error51 instanceof Error ? error51.message : String(error51)}`
-      );
-    }
-  }
-  /**
-   * Send a message and wait for a specific response with retry logic
-   */
-  async sendAndWaitFor(sendType, responseType, payload = {}, timeoutMs) {
-    await this.ready();
-    return retry(
-      async (bail) => {
-        return new Promise((resolve, reject) => {
-          const actualTimeout = timeoutMs || this.options.timeout;
-          const timeoutId = setTimeout(() => {
-            unsubscribe.dispose();
-            const error51 = new BeaconTimeoutError(sendType, actualTimeout);
-            reject(error51);
-          }, actualTimeout);
-          const unsubscribe = this.eventEmitter.listen(responseType, (data) => {
-            clearTimeout(timeoutId);
-            unsubscribe.dispose();
-            resolve(data);
-          });
-          try {
-            this.sendMessage(sendType, payload);
-          } catch (error51) {
-            clearTimeout(timeoutId);
-            unsubscribe.dispose();
-            if (error51 instanceof BeaconConnectionError) {
-              reject(error51);
-            } else {
-              bail(error51);
-            }
-          }
-        });
-      },
-      {
-        retries: this.options.retry?.retries ?? 3,
-        minTimeout: this.options.retry?.minTimeout ?? 1e3,
-        maxTimeout: this.options.retry?.maxTimeout ?? 5e3,
-        factor: this.options.retry?.factor ?? 2,
-        randomize: this.options.retry?.randomize ?? true,
-        onRetry: (error51, attempt) => {
-          if (this.options.debug) {
-            const errorMessage = error51 instanceof Error ? error51.message : String(error51);
-            console.warn(`[Beacon SDK] Retry attempt ${attempt} for ${sendType}:`, errorMessage);
-          }
-        }
-      }
-    );
-  }
-  /**
-   * Generate a unique ID for messages
-   */
-  generateId() {
-    return `sdk_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-  }
-  /**
-   * Event emitter methods (both private and public for navigator access)
-   */
-  emit(event, payload) {
-    this.eventEmitter.emit(event, payload);
-  }
-  /**
-   * Start the beacon initialization process
-   */
-  start() {
-    if (this.isStarted) {
-      return this.readyPromise || Promise.resolve();
-    }
-    this.isStarted = true;
-    this.readyPromise = this.waitForBeaconReady();
-    return this.readyPromise;
-  }
-  /**
-   * Wait for the beacon to be ready
-   */
-  async ready() {
-    if (!this.isStarted) {
-      throw new BeaconError("Beacon has not been started. Call start() first.");
-    }
-    if (!this.readyPromise) {
-      throw new BeaconError("Beacon ready promise is not available");
-    }
-    return timeout(this.readyPromise, this.options.timeout);
-  }
-  /**
-   * Check if beacon is ready
-   */
-  get isReady() {
-    return this.isBeaconReady;
-  }
-  /**
-   * Listen for beacon events
-   */
-  on(event, handler) {
-    return this.eventEmitter.listen(event, handler);
-  }
-  /**
-   * Listen for beacon events (one-time)
-   */
-  once(event, handler) {
-    return this.eventEmitter.once(event, handler);
-  }
-  /**
-   * Ping the beacon to check if it's responsive
-   */
-  async ping() {
-    try {
-      await this.sendAndWaitFor("ping", "pong", { timestamp: Date.now() });
-      return true;
-    } catch (error51) {
-      if (this.options.debug) {
-        console.warn("[Beacon SDK] Ping failed:", error51);
-      }
-      return false;
-    }
-  }
-  /**
-   * Get debug information from the beacon
-   */
-  async getDebugInfo() {
-    return this.sendAndWaitFor("getDebugInfo", "debugInfo");
-  }
-  /**
-   * Get console events from the beacon
-   */
-  async getConsoleEvents() {
-    return this.sendAndWaitFor("getConsoleEvents", "consoleEvents");
-  }
-  /**
-   * Get error events from the beacon
-   */
-  async getErrorEvents() {
-    return this.sendAndWaitFor("getErrorEvents", "errorEvents");
-  }
-  /**
-   * Clear console events in the beacon
-   */
-  async clearConsole() {
-    await this.ready();
-    this.sendMessage("clearConsole");
-  }
-  /**
-   * Clear error events in the beacon
-   */
-  async clearErrors() {
-    await this.ready();
-    this.sendMessage("clearErrors");
-  }
-  /**
-   * Execute code in the beacon context
-   */
-  async executeCode(code) {
-    return this.sendAndWaitFor("executeCode", "codeExecutionResult", { code });
-  }
-  /**
-   * Inspect an element in the beacon context
-   */
-  async inspectElement(selector) {
-    return this.sendAndWaitFor("inspectElement", "elementInspectionResult", { selector });
-  }
-  /**
-   * Fetch a URL in the beacon context
-   */
-  async fetch(request) {
-    return this.sendAndWaitFor("fetch", "fetchResult", request);
-  }
-  /**
-   * Capture the current beacon document, optionally clipped to a viewport or document rectangle.
-   */
-  async captureScreenshot(request = {}) {
-    const mediaTimeoutMs = request.mediaTimeoutMs ?? request.timeout ?? 3e4;
-    const timeoutMs = request.transportTimeoutMs ?? mediaTimeoutMs + 5e3;
-    return this.sendAndWaitFor("captureScreenshot", "screenshotResult", request, timeoutMs);
-  }
-  /**
-   * Debug a page (navigate and capture debug information). It loads
-   * the page fresh in the IFRAME so that we can capture the latest state.
-   */
-  async debug(request, waitSeconds) {
-    const targetUrl = new URL(request.path, this.iframe.src || window.location.origin).href;
-    if (this.iframe.src !== targetUrl) {
-      this.navigator.visit(targetUrl);
-      await this.ready();
-    }
-    waitSeconds && await this.wait(waitSeconds);
-    const timeoutMs = (request.options?.timeout || 3e4) + 5e3;
-    return this.sendAndWaitFor("debug", "debugResult", request, timeoutMs);
-  }
-  async wait(forSeconds) {
-    return new Promise((resolve) => setTimeout(resolve, forSeconds * 1e3));
-  }
-  /**
-   * Navigate the iframe to a new URL
-   */
-  navigate(url2) {
-    if (!this.iframe) {
-      throw new BeaconConnectionError("Iframe not available");
-    }
-    try {
-      const targetUrl = new URL(url2, this.iframe.src || window.location.origin);
-      this.iframe.src = targetUrl.href;
-      this.isBeaconReady = false;
-      this.channelEstablished = false;
-      if (this.port) {
-        this.port.close();
-        this.port = null;
-      }
-      if (this.messageChannel) {
-        this.messageChannel = null;
-      }
-      if (this.isStarted) {
-        this.readyPromise = this.waitForBeaconReady();
-      }
-    } catch (error51) {
-      throw new BeaconConnectionError(`Invalid URL: ${url2}`);
-    }
-  }
-  /**
-   * Get current iframe URL
-   */
-  get url() {
-    return this.iframe.src;
-  }
-  /**
-   * Get the iframe element
-   */
-  get element() {
-    return this.iframe;
-  }
-  /**
-   * Dispose of all resources
-   */
-  dispose() {
-    if (this.port) {
-      this.port.close();
-      this.port = null;
-    }
-    if (this.messageChannel) {
-      this.messageChannel = null;
-    }
-    this.disposables.forEach((disposable) => disposable.dispose());
-    this.disposables = [];
-    this.messageHandlers.clear();
-    this.isBeaconReady = false;
-    this.channelEstablished = false;
-    this.isStarted = false;
-    this.readyPromise = null;
-  }
-};
-function createBeacon(iframe, options) {
-  return new Beacon(iframe, options);
-}
-function isBeaconSupported() {
-  try {
-    ensureBrowserEnvironment();
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 // node_modules/zod/v4/classic/external.js
 var external_exports = {};
 __export(external_exports, {
@@ -19167,13 +18480,13 @@ function date4(params) {
 // node_modules/zod/v4/classic/external.js
 config(en_default());
 
-// src/schemas/deployments.ts
-var DeploymentTargetProviderSchema = external_exports.enum([
-  "okraCloudflareContainer",
-  "okraSshAgent",
-  "okraLaravelCloud"
+// src/schemas/publications.ts
+var PublicationProviderNameSchema = external_exports.enum([
+  "cloudflare-containers",
+  "ssh-server",
+  "laravel-cloud"
 ]);
-var DeploymentStatusSchema = external_exports.enum([
+var PublicationStatusSchema = external_exports.enum([
   "pending",
   "queued",
   "building",
@@ -19185,7 +18498,7 @@ var DeploymentStatusSchema = external_exports.enum([
   "deleted",
   "delete_failed"
 ]);
-var DeploymentBuildStatusSchema = external_exports.enum([
+var PublicationBuildStatusSchema = external_exports.enum([
   "pending",
   "queued",
   "running",
@@ -19193,8 +18506,8 @@ var DeploymentBuildStatusSchema = external_exports.enum([
   "failed",
   "cancelled"
 ]);
-var DeploymentReleaseStatusSchema = external_exports.enum(["created", "ready", "deleted"]);
-var DeploymentSizeSchema = external_exports.enum([
+var PublicationReleaseStatusSchema = external_exports.enum(["created", "ready", "deleted"]);
+var PublicationSizeSchema = external_exports.enum([
   "nano",
   "small",
   "medium",
@@ -19204,7 +18517,7 @@ var DeploymentSizeSchema = external_exports.enum([
   "standard-1",
   "standard-2"
 ]);
-var DeploymentRegionSchema = external_exports.enum([
+var PublicationRegionSchema = external_exports.enum([
   "ENAM",
   "WNAM",
   "EEUR",
@@ -19215,103 +18528,103 @@ var DeploymentRegionSchema = external_exports.enum([
   "OC",
   "AFR"
 ]);
-var DeploymentJurisdictionSchema = external_exports.enum(["eu", "fedramp"]);
-var DeploymentDomainDnsRecordTypeSchema = external_exports.enum(["CNAME", "ALIAS", "ANAME"]);
-var DeploymentProtectionModeSchema = external_exports.enum(["none", "password"]);
-var DeploymentLogStreamSchema = external_exports.enum(["build", "runtime"]);
-var DeployStreamLogStreamSchema = external_exports.enum(["build", "deploy", "runtime"]);
-var DeploymentEventDataSchema = external_exports.object({
+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"]);
+var PublicationEventDataSchema = external_exports.object({
   id: external_exports.union([external_exports.number(), external_exports.string()]).optional(),
   sequence: external_exports.number(),
   type: external_exports.string(),
   payload: external_exports.record(external_exports.string(), external_exports.unknown()),
   createdAt: external_exports.string().nullable()
 }).passthrough();
-var DeploymentLogChunkDataSchema = external_exports.object({
+var PublicationLogChunkDataSchema = external_exports.object({
   sequence: external_exports.number(),
-  stream: DeploymentLogStreamSchema,
+  stream: PublicationLogStreamSchema,
   content: external_exports.string(),
   createdAt: external_exports.string().nullable()
 }).passthrough();
-var DeployStreamPhaseSchema = external_exports.object({
+var PublishStreamPhaseSchema = external_exports.object({
   name: external_exports.string(),
   status: external_exports.enum(["running", "completed", "failed"]).optional(),
   data: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
 }).strict();
-var DeployStreamLogSchema = external_exports.object({
-  stream: DeployStreamLogStreamSchema,
+var PublishStreamLogSchema = external_exports.object({
+  stream: PublishStreamLogStreamSchema,
   content: external_exports.string()
 }).strict();
-var DeployStreamResultSchema = external_exports.object({
+var PublishStreamResultSchema = external_exports.object({
   success: external_exports.boolean(),
-  deploymentId: external_exports.string(),
+  publicationId: external_exports.string(),
   buildId: external_exports.string(),
   releaseId: external_exports.string(),
-  status: DeploymentStatusSchema
+  status: PublicationStatusSchema
 }).strict();
-var DeployStreamPhaseEventSchema = DeployStreamPhaseSchema.extend({
+var PublishStreamPhaseEventSchema = PublishStreamPhaseSchema.extend({
   type: external_exports.literal("phase")
 }).strict();
-var DeployStreamLogEventSchema = DeployStreamLogSchema.extend({
+var PublishStreamLogEventSchema = PublishStreamLogSchema.extend({
   type: external_exports.literal("log")
 }).strict();
-var DeployStreamResultEventSchema = DeployStreamResultSchema.extend({
+var PublishStreamResultEventSchema = PublishStreamResultSchema.extend({
   type: external_exports.literal("result")
 }).strict();
-var DeployStreamEventSchema = external_exports.discriminatedUnion("type", [
-  DeployStreamPhaseEventSchema,
-  DeployStreamLogEventSchema,
-  DeployStreamResultEventSchema
+var PublishStreamEventSchema = external_exports.discriminatedUnion("type", [
+  PublishStreamPhaseEventSchema,
+  PublishStreamLogEventSchema,
+  PublishStreamResultEventSchema
 ]);
-var DeployStreamErrorSchema = external_exports.object({
+var PublishStreamErrorSchema = external_exports.object({
   message: external_exports.string().optional()
 }).passthrough();
-var DeployStreamSseEventNameSchema = external_exports.enum(["phase", "log", "done", "result", "error"]);
-var DeployStreamSsePhaseEventSchema = external_exports.object({
+var PublishStreamSseEventNameSchema = external_exports.enum(["phase", "log", "done", "result", "error"]);
+var PublishStreamSsePhaseEventSchema = external_exports.object({
   event: external_exports.literal("phase"),
-  data: DeployStreamPhaseSchema
+  data: PublishStreamPhaseSchema
 }).strict();
-var DeployStreamSseLogEventSchema = external_exports.object({
+var PublishStreamSseLogEventSchema = external_exports.object({
   event: external_exports.literal("log"),
-  data: DeployStreamLogSchema
+  data: PublishStreamLogSchema
 }).strict();
-var DeployStreamSseDoneEventSchema = external_exports.object({
+var PublishStreamSseDoneEventSchema = external_exports.object({
   event: external_exports.literal("done"),
-  data: DeployStreamResultSchema
+  data: PublishStreamResultSchema
 }).strict();
-var DeployStreamSseResultEventSchema = external_exports.object({
+var PublishStreamSseResultEventSchema = external_exports.object({
   event: external_exports.literal("result"),
-  data: DeployStreamResultSchema
+  data: PublishStreamResultSchema
 }).strict();
-var DeployStreamSseErrorEventSchema = external_exports.object({
+var PublishStreamSseErrorEventSchema = external_exports.object({
   event: external_exports.literal("error"),
-  data: DeployStreamErrorSchema
+  data: PublishStreamErrorSchema
 }).strict();
-var DeployStreamSseEventSchema = external_exports.discriminatedUnion("event", [
-  DeployStreamSsePhaseEventSchema,
-  DeployStreamSseLogEventSchema,
-  DeployStreamSseDoneEventSchema,
-  DeployStreamSseResultEventSchema,
-  DeployStreamSseErrorEventSchema
+var PublishStreamSseEventSchema = external_exports.discriminatedUnion("event", [
+  PublishStreamSsePhaseEventSchema,
+  PublishStreamSseLogEventSchema,
+  PublishStreamSseDoneEventSchema,
+  PublishStreamSseResultEventSchema,
+  PublishStreamSseErrorEventSchema
 ]).transform((event) => {
   if (event.event === "error") {
-    throw new Error(event.data.message ?? "Deploy failed");
+    throw new Error(event.data.message ?? "Publish failed");
   }
   const type = event.event === "done" ? "result" : event.event;
-  return DeployStreamEventSchema.parse({ type, ...event.data });
+  return PublishStreamEventSchema.parse({ type, ...event.data });
 });
 
-// src/deployments.ts
-var NotebookDeploymentApi = class {
+// src/publications.ts
+var NotebookPublicationApi = class {
   constructor(client) {
     this.client = client;
   }
   async current(notebookId) {
     try {
       const response = await this.client.get(
-        `/notebook/${notebookId}/deployment`
+        `/notebook/${notebookId}/publication`
       );
-      return new DeploymentInstance(response.data, this.client, notebookId);
+      return new PublicationInstance(response.data, this.client, notebookId);
     } catch (error51) {
       if (error51 instanceof ApiError && error51.status === 404) {
         return null;
@@ -19321,89 +18634,82 @@ var NotebookDeploymentApi = class {
   }
   async publish(notebookId, input) {
     const response = await this.client.post(
-      `/notebook/${notebookId}/deployment/publish`,
+      `/notebook/${notebookId}/publication`,
       input
     );
-    const run = new DeploymentRun(new DeploymentInstance(response.data, this.client, notebookId), this.client);
+    const run = new PublicationRun(new PublicationInstance(response.data, this.client, notebookId), this.client);
     run.start();
     return run;
   }
-  async slugAvailability(id, slug) {
-    const query = new URLSearchParams({ slug }).toString();
-    const response = await this.client.get(
-      `/notebook/${id}/deployment/slug-availability?${query}`
-    );
-    return response.data;
-  }
 };
-var DeploymentApi = class {
+var PublicationApi = class {
   constructor(client) {
     this.client = client;
   }
   async get(id) {
-    const response = await this.client.get(`/deployments/${id}`);
-    return new DeploymentInstance(response.data, this.client);
+    const response = await this.client.get(`/publications/${id}`);
+    return new PublicationInstance(response.data, this.client);
   }
-  async delete(id) {
-    await this.client.delete(`/deployments/${id}`);
+  async destroy(id) {
+    await this.client.delete(`/publications/${id}`);
   }
   async setProtection(id, input) {
-    const response = await this.client.put(`/deployments/${id}/protection`, input);
-    return new DeploymentInstance(response.data, this.client);
+    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(`/deployments/${id}/protection`);
+    const response = await this.client.get(`/publications/${id}/protection`);
     return response.data;
   }
   async createProtectionSession(id) {
-    const response = await this.client.post(`/deployments/${id}/protection/session`);
+    const response = await this.client.post(`/publications/${id}/protection/session`);
     return response.data;
   }
   async disableProtection(id) {
-    const response = await this.client.delete(`/deployments/${id}/protection`);
-    return new DeploymentInstance(response.data, this.client);
+    const response = await this.client.delete(`/publications/${id}/protection`);
+    return new PublicationInstance(response.data, this.client);
   }
   async setFeedback(id, input) {
-    const response = await this.client.put(`/deployments/${id}/feedback`, input);
-    return new DeploymentInstance(response.data, this.client);
+    const response = await this.client.put(`/publications/${id}/feedback`, input);
+    return new PublicationInstance(response.data, this.client);
   }
   async listDomains(id) {
     const response = await this.client.get(
-      `/deployments/${id}/domains`
+      `/publications/${id}/domains`
     );
-    return unwrapDeploymentDomainCollection(response.data);
+    return unwrapPublicationDomainCollection(response.data);
   }
   async createDomain(id, input) {
-    const response = await this.client.post(`/deployments/${id}/domains`, input);
+    const response = await this.client.post(`/publications/${id}/domains`, input);
     return response.data;
   }
   async refreshDomain(id, domainId) {
-    const response = await this.client.post(`/deployments/${id}/domains/${domainId}/refresh`);
+    const response = await this.client.post(`/publications/${id}/domains/${domainId}/refresh`);
     return response.data;
   }
   async deleteDomain(id, domainId) {
-    await this.client.delete(`/deployments/${id}/domains/${domainId}`);
+    await this.client.delete(`/publications/${id}/domains/${domainId}`);
   }
   async events(id) {
     return parseNdjsonStream(
-      await this.client.stream(`/deployments/${id}/events/stream`),
-      DeploymentEventDataSchema
+      await this.client.stream(`/publications/${id}/events/stream`),
+      PublicationEventDataSchema
     );
   }
   async buildLogs(id, buildId) {
     return parseNdjsonStream(
-      await this.client.stream(`/deployments/${id}/builds/${buildId}/logs/stream`),
-      DeploymentLogChunkDataSchema
+      await this.client.stream(`/publications/${id}/builds/${buildId}/logs/stream`),
+      PublicationLogChunkDataSchema
     );
   }
   async logs(id) {
     return parseNdjsonStream(
-      await this.client.stream(`/deployments/${id}/logs/stream`),
-      DeploymentLogChunkDataSchema
+      await this.client.stream(`/publications/${id}/logs/stream`),
+      PublicationLogChunkDataSchema
     );
   }
 };
-var DeploymentRun = class {
+var PublicationRun = class {
   constructor(initial, client) {
     this.initial = initial;
     this.client = client;
@@ -19433,7 +18739,7 @@ var DeploymentRun = class {
     this.start();
     return this.resultPromise;
   }
-  async deployment() {
+  async publication() {
     await this.result();
     return this.initial.refresh();
   }
@@ -19443,7 +18749,7 @@ var DeploymentRun = class {
     }
     const eventStreamUrl = this.initial.data.eventStreamUrl;
     if (!eventStreamUrl) {
-      throw new Error(`Deployment ${this.initial.data.id} has no eventStreamUrl for SSE streaming`);
+      throw new Error(`Publication ${this.initial.data.id} has no eventStreamUrl for SSE streaming`);
     }
     this.started = true;
     this.resultPromise = new Promise((resolve, reject) => {
@@ -19455,7 +18761,7 @@ var DeploymentRun = class {
     return this;
   }
   subscribe() {
-    const queue = new AsyncDeployEventQueue();
+    const queue = new AsyncPublishEventQueue();
     for (const event of this.bufferedEvents) {
       queue.push(event);
     }
@@ -19471,7 +18777,7 @@ var DeploymentRun = class {
   async consumeStream(eventStreamUrl) {
     try {
       const stream = await this.client.sse(eventStreamUrl);
-      for await (const event of readDeployStreamEvents(stream)) {
+      for await (const event of readPublishStreamEvents(stream)) {
         this.publish(event);
         if (event.type === "result") {
           const { type: _, ...result } = event;
@@ -19480,7 +18786,7 @@ var DeploymentRun = class {
         }
       }
       if (!this.finalResult) {
-        throw new Error("Deploy stream ended without result");
+        throw new Error("Publish stream ended without result");
       }
       this.closeSubscribers();
     } catch (err) {
@@ -19510,33 +18816,33 @@ var DeploymentRun = class {
     this.subscribers.clear();
   }
 };
-var DeploymentInstance = class _DeploymentInstance {
+var PublicationInstance = class _PublicationInstance {
   constructor(data, client, notebookId) {
     this.data = data;
     this.client = client;
     this.notebookId = notebookId;
   }
   async refresh() {
-    const response = await this.client.get(`/deployments/${this.data.id}`);
-    return new _DeploymentInstance(response.data, this.client, this.notebookId);
+    const response = await this.client.get(`/publications/${this.data.id}`);
+    return new _PublicationInstance(response.data, this.client, this.notebookId);
   }
   publish() {
     if (!this.notebookId) {
-      return Promise.reject(new Error("Deployment publish requires a notebook-scoped deployment instance."));
+      return Promise.reject(new Error("Publishing requires a notebook-scoped publication instance."));
     }
-    return this.client.notebook.deployment.publish(this.notebookId);
+    return this.client.notebook.publication.publish(this.notebookId);
   }
-  delete() {
-    return this.client.deployments.delete(this.data.id);
+  destroy() {
+    return this.client.publications.destroy(this.data.id);
   }
   async wait(options = {}) {
     const intervalMs = options.intervalMs ?? 1e3;
     const timeoutMs = options.timeoutMs ?? 3e5;
     const startedAt = Date.now();
     let current = this;
-    while (!deploymentStatusIsTerminal(current.data.status)) {
+    while (!publicationStatusIsTerminal(current.data.status)) {
       if (Date.now() - startedAt > timeoutMs) {
-        throw new Error(`Timed out waiting for deployment ${this.data.id}`);
+        throw new Error(`Timed out waiting for publication ${this.data.id}`);
       }
       await delay(intervalMs);
       current = await current.refresh();
@@ -19544,58 +18850,58 @@ var DeploymentInstance = class _DeploymentInstance {
     return current;
   }
   events() {
-    return this.client.deployments.events(this.data.id);
+    return this.client.publications.events(this.data.id);
   }
   buildLogs(buildId = this.data.latestBuild?.id ?? "") {
     if (buildId === "") {
-      return Promise.reject(new Error("Deployment has no latest build id"));
+      return Promise.reject(new Error("Publication has no latest build id"));
     }
-    return this.client.deployments.buildLogs(this.data.id, buildId);
+    return this.client.publications.buildLogs(this.data.id, buildId);
   }
   logs() {
-    return this.client.deployments.logs(this.data.id);
+    return this.client.publications.logs(this.data.id);
   }
   setProtection(input) {
-    return this.client.deployments.setProtection(this.data.id, input);
+    return this.client.publications.setProtection(this.data.id, input);
   }
   protection() {
-    return this.client.deployments.protection(this.data.id);
+    return this.client.publications.protection(this.data.id);
   }
   createProtectionSession() {
-    return this.client.deployments.createProtectionSession(this.data.id);
+    return this.client.publications.createProtectionSession(this.data.id);
   }
   disableProtection() {
-    return this.client.deployments.disableProtection(this.data.id);
+    return this.client.publications.disableProtection(this.data.id);
   }
   setFeedback(input) {
-    return this.client.deployments.setFeedback(this.data.id, input);
+    return this.client.publications.setFeedback(this.data.id, input);
   }
   domains() {
-    return this.client.deployments.listDomains(this.data.id);
+    return this.client.publications.listDomains(this.data.id);
   }
   addDomain(input) {
-    return this.client.deployments.createDomain(this.data.id, input);
+    return this.client.publications.createDomain(this.data.id, input);
   }
   refreshDomain(domainId) {
-    return this.client.deployments.refreshDomain(this.data.id, domainId);
+    return this.client.publications.refreshDomain(this.data.id, domainId);
   }
   deleteDomain(domainId) {
-    return this.client.deployments.deleteDomain(this.data.id, domainId);
+    return this.client.publications.deleteDomain(this.data.id, domainId);
   }
 };
-function deploymentStatusIsTerminal(status) {
+function publicationStatusIsTerminal(status) {
   return ["healthy", "failed", "stopped", "deleted", "delete_failed"].includes(status);
 }
 function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function unwrapDeploymentDomainCollection(input) {
+function unwrapPublicationDomainCollection(input) {
   if (Array.isArray(input)) {
     return input;
   }
   return Array.isArray(input.data) ? input.data : [];
 }
-var AsyncDeployEventQueue = class {
+var AsyncPublishEventQueue = class {
   constructor() {
     this.values = [];
     this.pending = [];
@@ -19657,7 +18963,7 @@ var AsyncDeployEventQueue = class {
     });
   }
 };
-async function* readDeployStreamEvents(stream) {
+async function* readPublishStreamEvents(stream) {
   const reader = parseSSEStream(stream).getReader();
   try {
     while (true) {
@@ -19665,7 +18971,7 @@ async function* readDeployStreamEvents(stream) {
       if (done) {
         return;
       }
-      const event = parseDeployStreamEvent(value);
+      const event = parsePublishStreamEvent(value);
       if (event) {
         yield event;
       }
@@ -19674,11 +18980,11 @@ async function* readDeployStreamEvents(stream) {
     reader.releaseLock();
   }
 }
-function parseDeployStreamEvent(event) {
-  if (!DeployStreamSseEventNameSchema.safeParse(event.event).success) {
+function parsePublishStreamEvent(event) {
+  if (!PublishStreamSseEventNameSchema.safeParse(event.event).success) {
     return null;
   }
-  return DeployStreamSseEventSchema.parse(event);
+  return PublishStreamSseEventSchema.parse(event);
 }
 function parseSSEStream(input) {
   const decoder = new TextDecoder();
@@ -20087,7 +19393,7 @@ var NotebookApi = class {
     this.composerCredentials = new NotebookComposerCredentialApi(client);
     this.preview = new NotebookPreviewApi(client);
     this.mail = new NotebookMailApi(client);
-    this.deployment = new NotebookDeploymentApi(client);
+    this.publication = new NotebookPublicationApi(client);
   }
   async create(template, input = {}, init = true) {
     const response = await this.client.post("/notebook", { template, ...input });
@@ -20105,7 +19411,7 @@ var NotebookApi = class {
     const response = await this.client.put(`/notebook/${id}`, input);
     return new NotebookInstance2(response.data, this.client);
   }
-  async delete(id) {
+  async destroy(id) {
     await this.client.delete(`/notebook/${id}`);
   }
   async fork(id, input = {}) {
@@ -20116,10 +19422,6 @@ var NotebookApi = class {
     const response = await this.client.post(`/notebook/${id}/git/credentials`);
     return response.data;
   }
-  async open(id) {
-    const response = await this.client.get(`/notebook/${id}`);
-    return new NotebookInstance2(response.data, this.client);
-  }
   openFromData(data) {
     return this.init(new NotebookInstance2(data, this.client));
   }
@@ -20140,7 +19442,7 @@ 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.publications = new PublicationApi(this);
     this.notebook = new NotebookApi(this);
     this.servers = new ServerApi(this);
     this.options = Object.assign({ startClosed: true }, options);
@@ -20374,7 +19676,6 @@ var NotebookInstance2 = class {
     this.log = new Log(this);
     this.repl = new Repl(this);
     this.container = new Container(this);
-    this.laravel = new Laravel(this);
     this.shell = new Shell(this);
     this.git = new Git(this, client);
     this.services = new Services(this);
@@ -20406,17 +19707,23 @@ var NotebookInstance2 = class {
   fork(input = {}) {
     return this.client.notebook.fork(this.data.id, input);
   }
-  deployment() {
-    return this.client.notebook.deployment.current(this.data.id);
+  publication() {
+    return this.client.notebook.publication.current(this.data.id);
   }
   publish(input) {
-    return this.client.notebook.deployment.publish(this.data.id, input);
+    return this.client.notebook.publication.publish(this.data.id, input);
+  }
+  run(command, argsOrOpts = [], opts) {
+    if (Array.isArray(argsOrOpts)) {
+      return this.shell.run(command, argsOrOpts, opts);
+    }
+    return this.shell.run(command, argsOrOpts);
   }
   gitCredentials() {
     return this.client.notebook.gitCredentials(this.data.id);
   }
-  delete() {
-    return this.client.notebook.delete(this.data.id).then(() => {
+  destroy() {
+    return this.client.notebook.destroy(this.data.id).then(() => {
       this.socket?.terminate(new NotebookUnavailableError("Notebook has been deleted.", { id: this.data.id }));
     });
   }
@@ -20563,11 +19870,6 @@ var NotebookInstance2 = class {
     __privateMethod(this, _NotebookInstance_instances, init_fn).call(this);
     return this.ready().then(() => this);
   }
-  async beacon(iframe, options) {
-    const result = await this.ready();
-    iframe.src = result.data.previewUrl;
-    return createBeacon(iframe, options);
-  }
   realtimeSocket() {
     if (this.socket === null) {
       throw new UnsupportedRuntimeTransportError("This operation requires the realtime transport.");
@@ -20686,44 +19988,9 @@ function formatQueryString(params) {
 }
 export {
   ApiError,
-  Beacon,
-  BeaconConnectionError,
-  BeaconError,
-  BeaconTimeoutError,
   Client2 as Client,
   CommandError,
   ComposerCredentials,
-  DeployStreamErrorSchema,
-  DeployStreamEventSchema,
-  DeployStreamLogEventSchema,
-  DeployStreamLogSchema,
-  DeployStreamLogStreamSchema,
-  DeployStreamPhaseEventSchema,
-  DeployStreamPhaseSchema,
-  DeployStreamResultEventSchema,
-  DeployStreamResultSchema,
-  DeployStreamSseDoneEventSchema,
-  DeployStreamSseErrorEventSchema,
-  DeployStreamSseEventNameSchema,
-  DeployStreamSseEventSchema,
-  DeployStreamSseLogEventSchema,
-  DeployStreamSsePhaseEventSchema,
-  DeployStreamSseResultEventSchema,
-  DeploymentApi,
-  DeploymentBuildStatusSchema,
-  DeploymentDomainDnsRecordTypeSchema,
-  DeploymentEventDataSchema,
-  DeploymentInstance,
-  DeploymentJurisdictionSchema,
-  DeploymentLogChunkDataSchema,
-  DeploymentLogStreamSchema,
-  DeploymentProtectionModeSchema,
-  DeploymentRegionSchema,
-  DeploymentReleaseStatusSchema,
-  DeploymentRun,
-  DeploymentSizeSchema,
-  DeploymentStatusSchema,
-  DeploymentTargetProviderSchema,
   ErrorEvent,
   FileChangeFilter,
   FileChangeType,
@@ -20732,31 +19999,60 @@ export {
   FilesystemError,
   FilesystemErrorType,
   LspConnection,
-  Navigator,
   NotebookApi,
   NotebookComposerCredentialApi,
-  NotebookDeploymentApi,
   NotebookInitError,
   NotebookInstance2 as NotebookInstance,
   NotebookMail,
   NotebookMailApi,
   NotebookPreview,
   NotebookPreviewApi,
+  NotebookPublicationApi,
   NotebookSecretApi,
   NotebookSecrets,
   NotebookState,
   NotebookUnavailableError,
   PHPSandbox,
   PHPSandboxError,
+  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,
   SendTimeoutError,
   ServerApi,
   ServerInstance,
-  Transport,
+  ShellProcess,
   UnsupportedRuntimeTransportError,
-  createBeacon,
-  isBeaconSupported,
   notebookBuiltinServices,
   notebookKnownServices,
   once,