@phpsandbox/sdk 0.0.68 → 0.1.1

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

@@ -29,44 +29,9 @@ var PHPSandbox = (() => {
   var index_exports = {};
   __export(index_exports, {
     ApiError: () => ApiError,
-    Beacon: () => Beacon,
-    BeaconConnectionError: () => BeaconConnectionError,
-    BeaconError: () => BeaconError,
-    BeaconTimeoutError: () => BeaconTimeoutError,
     Client: () => Client2,
     CommandError: () => CommandError,
     ComposerCredentials: () => ComposerCredentials,
-    DeployStreamErrorSchema: () => DeployStreamErrorSchema,
-    DeployStreamEventSchema: () => DeployStreamEventSchema,
-    DeployStreamLogEventSchema: () => DeployStreamLogEventSchema,
-    DeployStreamLogSchema: () => DeployStreamLogSchema,
-    DeployStreamLogStreamSchema: () => DeployStreamLogStreamSchema,
-    DeployStreamPhaseEventSchema: () => DeployStreamPhaseEventSchema,
-    DeployStreamPhaseSchema: () => DeployStreamPhaseSchema,
-    DeployStreamResultEventSchema: () => DeployStreamResultEventSchema,
-    DeployStreamResultSchema: () => DeployStreamResultSchema,
-    DeployStreamSseDoneEventSchema: () => DeployStreamSseDoneEventSchema,
-    DeployStreamSseErrorEventSchema: () => DeployStreamSseErrorEventSchema,
-    DeployStreamSseEventNameSchema: () => DeployStreamSseEventNameSchema,
-    DeployStreamSseEventSchema: () => DeployStreamSseEventSchema,
-    DeployStreamSseLogEventSchema: () => DeployStreamSseLogEventSchema,
-    DeployStreamSsePhaseEventSchema: () => DeployStreamSsePhaseEventSchema,
-    DeployStreamSseResultEventSchema: () => DeployStreamSseResultEventSchema,
-    DeploymentApi: () => DeploymentApi,
-    DeploymentBuildStatusSchema: () => DeploymentBuildStatusSchema,
-    DeploymentDomainDnsRecordTypeSchema: () => DeploymentDomainDnsRecordTypeSchema,
-    DeploymentEventDataSchema: () => DeploymentEventDataSchema,
-    DeploymentInstance: () => DeploymentInstance,
-    DeploymentJurisdictionSchema: () => DeploymentJurisdictionSchema,
-    DeploymentLogChunkDataSchema: () => DeploymentLogChunkDataSchema,
-    DeploymentLogStreamSchema: () => DeploymentLogStreamSchema,
-    DeploymentProtectionModeSchema: () => DeploymentProtectionModeSchema,
-    DeploymentRegionSchema: () => DeploymentRegionSchema,
-    DeploymentReleaseStatusSchema: () => DeploymentReleaseStatusSchema,
-    DeploymentRun: () => DeploymentRun,
-    DeploymentSizeSchema: () => DeploymentSizeSchema,
-    DeploymentStatusSchema: () => DeploymentStatusSchema,
-    DeploymentTargetProviderSchema: () => DeploymentTargetProviderSchema,
     ErrorEvent: () => ErrorEvent,
     FileChangeFilter: () => FileChangeFilter,
     FileChangeType: () => FileChangeType,
@@ -75,31 +40,60 @@ var PHPSandbox = (() => {
     FilesystemError: () => FilesystemError,
     FilesystemErrorType: () => FilesystemErrorType,
     LspConnection: () => LspConnection,
-    Navigator: () => Navigator,
     NotebookApi: () => NotebookApi,
     NotebookComposerCredentialApi: () => NotebookComposerCredentialApi,
-    NotebookDeploymentApi: () => NotebookDeploymentApi,
     NotebookInitError: () => NotebookInitError,
     NotebookInstance: () => NotebookInstance2,
     NotebookMail: () => NotebookMail,
     NotebookMailApi: () => NotebookMailApi,
     NotebookPreview: () => NotebookPreview,
     NotebookPreviewApi: () => NotebookPreviewApi,
+    NotebookPublicationApi: () => NotebookPublicationApi,
     NotebookSecretApi: () => NotebookSecretApi,
     NotebookSecrets: () => NotebookSecrets,
     NotebookState: () => NotebookState,
     NotebookUnavailableError: () => NotebookUnavailableError,
     PHPSandbox: () => PHPSandbox,
     PHPSandboxError: () => PHPSandboxError,
+    ProcessResult: () => ProcessResult,
     PromiseTimeoutError: () => PromiseTimeoutError,
+    PublicationApi: () => PublicationApi,
+    PublicationBuildStatusSchema: () => PublicationBuildStatusSchema,
+    PublicationDomainDnsRecordTypeSchema: () => PublicationDomainDnsRecordTypeSchema,
+    PublicationEventDataSchema: () => PublicationEventDataSchema,
+    PublicationInstance: () => PublicationInstance,
+    PublicationJurisdictionSchema: () => PublicationJurisdictionSchema,
+    PublicationLogChunkDataSchema: () => PublicationLogChunkDataSchema,
+    PublicationLogStreamSchema: () => PublicationLogStreamSchema,
+    PublicationProtectionModeSchema: () => PublicationProtectionModeSchema,
+    PublicationProviderNameSchema: () => PublicationProviderNameSchema,
+    PublicationRegionSchema: () => PublicationRegionSchema,
+    PublicationReleaseStatusSchema: () => PublicationReleaseStatusSchema,
+    PublicationRun: () => PublicationRun,
+    PublicationSizeSchema: () => PublicationSizeSchema,
+    PublicationStatusSchema: () => PublicationStatusSchema,
+    PublishStreamErrorSchema: () => PublishStreamErrorSchema,
+    PublishStreamEventSchema: () => PublishStreamEventSchema,
+    PublishStreamLogEventSchema: () => PublishStreamLogEventSchema,
+    PublishStreamLogSchema: () => PublishStreamLogSchema,
+    PublishStreamLogStreamSchema: () => PublishStreamLogStreamSchema,
+    PublishStreamPhaseEventSchema: () => PublishStreamPhaseEventSchema,
+    PublishStreamPhaseSchema: () => PublishStreamPhaseSchema,
+    PublishStreamResultEventSchema: () => PublishStreamResultEventSchema,
+    PublishStreamResultSchema: () => PublishStreamResultSchema,
+    PublishStreamSseDoneEventSchema: () => PublishStreamSseDoneEventSchema,
+    PublishStreamSseErrorEventSchema: () => PublishStreamSseErrorEventSchema,
+    PublishStreamSseEventNameSchema: () => PublishStreamSseEventNameSchema,
+    PublishStreamSseEventSchema: () => PublishStreamSseEventSchema,
+    PublishStreamSseLogEventSchema: () => PublishStreamSseLogEventSchema,
+    PublishStreamSsePhaseEventSchema: () => PublishStreamSsePhaseEventSchema,
+    PublishStreamSseResultEventSchema: () => PublishStreamSseResultEventSchema,
     RateLimitError: () => RateLimitError,
     SendTimeoutError: () => SendTimeoutError,
     ServerApi: () => ServerApi,
     ServerInstance: () => ServerInstance,
-    Transport: () => Transport,
+    ShellProcess: () => ShellProcess,
     UnsupportedRuntimeTransportError: () => UnsupportedRuntimeTransportError,
-    createBeacon: () => createBeacon,
-    isBeaconSupported: () => isBeaconSupported,
     notebookBuiltinServices: () => notebookBuiltinServices,
     notebookKnownServices: () => notebookKnownServices,
     once: () => once,
@@ -206,8 +200,25 @@ var PHPSandbox = (() => {
     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,
@@ -383,6 +394,21 @@ var PHPSandbox = (() => {
       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 {
@@ -435,9 +461,6 @@ var PHPSandbox = (() => {
     list() {
       return this.okra.invoke("terminal.list");
     }
-    start() {
-      return this.okra.invoke("terminal.start");
-    }
     create(input) {
       return this.okra.invoke("terminal.create", input);
     }
@@ -570,7 +593,7 @@ var PHPSandbox = (() => {
           disposeInput();
         }
       });
-      const exit = new Promise((resolve) => {
+      const completion = new Promise((resolve) => {
         disposables.add(
           this.listen(`terminal.close.${id}`, (data) => {
             if (controller) {
@@ -599,7 +622,7 @@ var PHPSandbox = (() => {
       }
       return {
         process: {
-          exit,
+          wait: () => completion,
           input,
           output,
           kill,
@@ -675,9 +698,6 @@ var PHPSandbox = (() => {
     constructor(okra) {
       this.okra = okra;
     }
-    logout() {
-      this.okra.dispose();
-    }
     login(runtimeUrl) {
       const runtimeTicket = new URL(runtimeUrl).searchParams.get("ticket");
       if (runtimeTicket === null || runtimeTicket === "") {
@@ -802,19 +822,6 @@ var PHPSandbox = (() => {
     }
   };
 
-  // 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) {
@@ -829,9 +836,6 @@ var PHPSandbox = (() => {
     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 });
     }
@@ -844,113 +848,142 @@ var PHPSandbox = (() => {
   };
 
   // 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 });
     }
   };
 
@@ -4021,732 +4054,6 @@ var PHPSandbox = (() => {
     }
   };
 
-  // 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, {
@@ -19261,13 +18568,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   // 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",
@@ -19279,7 +18586,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     "deleted",
     "delete_failed"
   ]);
-  var DeploymentBuildStatusSchema = external_exports.enum([
+  var PublicationBuildStatusSchema = external_exports.enum([
     "pending",
     "queued",
     "running",
@@ -19287,8 +18594,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     "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",
@@ -19298,7 +18605,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     "standard-1",
     "standard-2"
   ]);
-  var DeploymentRegionSchema = external_exports.enum([
+  var PublicationRegionSchema = external_exports.enum([
     "ENAM",
     "WNAM",
     "EEUR",
@@ -19309,103 +18616,103 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     "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;
@@ -19415,89 +18722,82 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
     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;
@@ -19527,7 +18827,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       this.start();
       return this.resultPromise;
     }
-    async deployment() {
+    async publication() {
       await this.result();
       return this.initial.refresh();
     }
@@ -19537,7 +18837,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       }
       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) => {
@@ -19549,7 +18849,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       return this;
     }
     subscribe() {
-      const queue = new AsyncDeployEventQueue();
+      const queue = new AsyncPublishEventQueue();
       for (const event of this.bufferedEvents) {
         queue.push(event);
       }
@@ -19565,7 +18865,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     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;
@@ -19574,7 +18874,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           }
         }
         if (!this.finalResult) {
-          throw new Error("Deploy stream ended without result");
+          throw new Error("Publish stream ended without result");
         }
         this.closeSubscribers();
       } catch (err) {
@@ -19604,33 +18904,33 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       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();
@@ -19638,58 +18938,58 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       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 = [];
@@ -19751,7 +19051,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       });
     }
   };
-  async function* readDeployStreamEvents(stream) {
+  async function* readPublishStreamEvents(stream) {
     const reader = parseSSEStream(stream).getReader();
     try {
       while (true) {
@@ -19759,7 +19059,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         if (done) {
           return;
         }
-        const event = parseDeployStreamEvent(value);
+        const event = parsePublishStreamEvent(value);
         if (event) {
           yield event;
         }
@@ -19768,11 +19068,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       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();
@@ -20181,7 +19481,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       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 });
@@ -20199,7 +19499,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       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 = {}) {
@@ -20210,10 +19510,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       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));
     }
@@ -20234,7 +19530,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     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);
@@ -20468,7 +19764,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       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);
@@ -20500,17 +19795,23 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     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 }));
       });
     }
@@ -20657,11 +19958,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       __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.");