@phpsandbox/sdk 0.0.68 → 0.1.2

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,
+    Client: () => Client,
     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,35 +40,67 @@ var PHPSandbox = (() => {
     FilesystemError: () => FilesystemError,
     FilesystemErrorType: () => FilesystemErrorType,
     LspConnection: () => LspConnection,
-    Navigator: () => Navigator,
     NotebookApi: () => NotebookApi,
     NotebookComposerCredentialApi: () => NotebookComposerCredentialApi,
-    NotebookDeploymentApi: () => NotebookDeploymentApi,
     NotebookInitError: () => NotebookInitError,
-    NotebookInstance: () => NotebookInstance2,
+    NotebookInstance: () => NotebookInstance,
     NotebookMail: () => NotebookMail,
     NotebookMailApi: () => NotebookMailApi,
     NotebookPreview: () => NotebookPreview,
     NotebookPreviewApi: () => NotebookPreviewApi,
+    NotebookPublicationApi: () => NotebookPublicationApi,
     NotebookSecretApi: () => NotebookSecretApi,
     NotebookSecrets: () => NotebookSecrets,
     NotebookState: () => NotebookState,
     NotebookUnavailableError: () => NotebookUnavailableError,
     PHPSandbox: () => PHPSandbox,
     PHPSandboxError: () => PHPSandboxError,
+    ProcessReadable: () => ProcessReadable,
+    ProcessResult: () => ProcessResult,
     PromiseTimeoutError: () => PromiseTimeoutError,
+    PublicationApi: () => PublicationApi,
+    PublicationBuildStatusSchema: () => PublicationBuildStatusSchema,
+    PublicationDomainDnsRecordTypeSchema: () => PublicationDomainDnsRecordTypeSchema,
+    PublicationEventDataSchema: () => PublicationEventDataSchema,
+    PublicationInstance: () => PublicationInstance,
+    PublicationJurisdictionSchema: () => PublicationJurisdictionSchema,
+    PublicationLogChunkDataSchema: () => PublicationLogChunkDataSchema,
+    PublicationLogStreamSchema: () => PublicationLogStreamSchema,
+    PublicationProtectionModeSchema: () => PublicationProtectionModeSchema,
+    PublicationProviderNameSchema: () => PublicationProviderNameSchema,
+    PublicationRegionSchema: () => PublicationRegionSchema,
+    PublicationReleaseStatusSchema: () => PublicationReleaseStatusSchema,
+    PublicationRun: () => PublicationRun,
+    PublicationSizeSchema: () => PublicationSizeSchema,
+    PublicationStatusSchema: () => PublicationStatusSchema,
+    PublishStreamErrorSchema: () => PublishStreamErrorSchema,
+    PublishStreamEventSchema: () => PublishStreamEventSchema,
+    PublishStreamLogEventSchema: () => PublishStreamLogEventSchema,
+    PublishStreamLogSchema: () => PublishStreamLogSchema,
+    PublishStreamLogStreamSchema: () => PublishStreamLogStreamSchema,
+    PublishStreamPhaseEventSchema: () => PublishStreamPhaseEventSchema,
+    PublishStreamPhaseSchema: () => PublishStreamPhaseSchema,
+    PublishStreamResultEventSchema: () => PublishStreamResultEventSchema,
+    PublishStreamResultSchema: () => PublishStreamResultSchema,
+    PublishStreamSseDoneEventSchema: () => PublishStreamSseDoneEventSchema,
+    PublishStreamSseErrorEventSchema: () => PublishStreamSseErrorEventSchema,
+    PublishStreamSseEventNameSchema: () => PublishStreamSseEventNameSchema,
+    PublishStreamSseEventSchema: () => PublishStreamSseEventSchema,
+    PublishStreamSseLogEventSchema: () => PublishStreamSseLogEventSchema,
+    PublishStreamSsePhaseEventSchema: () => PublishStreamSsePhaseEventSchema,
+    PublishStreamSseResultEventSchema: () => PublishStreamSseResultEventSchema,
     RateLimitError: () => RateLimitError,
+    RuntimeTelemetry: () => RuntimeTelemetry,
     SendTimeoutError: () => SendTimeoutError,
     ServerApi: () => ServerApi,
     ServerInstance: () => ServerInstance,
-    Transport: () => Transport,
+    ShellProcess: () => ShellProcess,
     UnsupportedRuntimeTransportError: () => UnsupportedRuntimeTransportError,
-    createBeacon: () => createBeacon,
-    isBeaconSupported: () => isBeaconSupported,
     notebookBuiltinServices: () => notebookBuiltinServices,
     notebookKnownServices: () => notebookKnownServices,
     once: () => once,
-    timeout: () => timeout
+    timeout: () => timeout,
+    watchRuntimeTelemetry: () => watchRuntimeTelemetry
   });
 
   // src/types.ts
@@ -203,11 +200,122 @@ var PHPSandbox = (() => {
         }
       });
     }
-    info(path) {
-      return this.okra.invoke("fs.info", { path });
+    async write(path, contents, options = {}) {
+      const resolvedOptions = {
+        overwrite: true,
+        create: true,
+        unlock: false,
+        atomic: false,
+        ...options
+      };
+      const source = typeof contents === "string" ? new TextEncoder().encode(contents) : contents;
+      if (this.okra.runtimeTransport === "rest") {
+        const bytes = source instanceof Uint8Array ? source : await collectBytes(source);
+        await this.okra.invoke("fs.writeFile", {
+          path,
+          contents: bytes,
+          options: resolvedOptions
+        }).catch((error51) => this.handleError(error51));
+        return;
+      }
+      const id = nanoid();
+      const completion = this.okra.invoke("fs.writeStream", { id, path, options: resolvedOptions });
+      void completion.catch(() => {
+      });
+      try {
+        for await (const chunk of toAsyncIterable(source)) {
+          const written = await this.okra.invoke("fs.writeChunk", { id, contents: chunk });
+          if (!written) {
+            throw new Error(`File write stream ${id} is not available`);
+          }
+        }
+        const ended = await this.okra.invoke("fs.endWrite", { id });
+        if (!ended) {
+          throw new Error(`File write stream ${id} could not be completed`);
+        }
+        await completion;
+      } catch (error51) {
+        await this.okra.invoke("fs.abortWrite", { id }).catch(() => false);
+        await completion.catch(() => false);
+        throw error51;
+      }
+    }
+    async read(path) {
+      try {
+        const content = await this.okra.invoke("fs.readFile", { path });
+        return content instanceof Uint8Array ? content : new TextEncoder().encode(content);
+      } catch (error51) {
+        this.handleError(error51);
+      }
+    }
+    async readText(path) {
+      return new TextDecoder().decode(await this.read(path));
+    }
+    async readLines(path, range) {
+      try {
+        const result = await this.okra.invoke("fs.readFile", {
+          path,
+          lineRange: {
+            lineStart: range.start,
+            lineEnd: range.end
+          }
+        });
+        if (typeof result === "string" || result instanceof Uint8Array) {
+          throw new Error(`Unexpected ranged file response for ${path}`);
+        }
+        return {
+          start: result.lineStart,
+          end: result.lineEnd,
+          content: result.content,
+          ...result.error === null ? {} : { warning: result.error }
+        };
+      } catch (error51) {
+        this.handleError(error51);
+      }
     }
-    write(path, contents) {
-      return this.okra.invoke("fs.write", { path, contents });
+    readStream(path) {
+      if (this.okra.runtimeTransport === "rest") {
+        return new ReadableStream({
+          start: async (controller) => {
+            try {
+              controller.enqueue(await this.read(path));
+              controller.close();
+            } catch (error51) {
+              controller.error(error51);
+            }
+          }
+        });
+      }
+      const id = nanoid();
+      let disposable = null;
+      let closed = false;
+      return new ReadableStream({
+        start: (controller) => {
+          disposable = this.okra.listen(`fs.read.${id}`, (event) => {
+            controller.enqueue(event.data);
+          });
+          void this.okra.invoke("fs.readStream", { id, path }).then(() => {
+            if (!closed) {
+              closed = true;
+              disposable?.dispose();
+              controller.close();
+            }
+          }).catch((error51) => {
+            if (!closed) {
+              closed = true;
+              disposable?.dispose();
+              controller.error(error51);
+            }
+          });
+        },
+        cancel: async () => {
+          if (!closed) {
+            closed = true;
+            disposable?.dispose();
+            await this.okra.invoke("fs.cancelRead", { id }).catch(() => false);
+          }
+        }
+      });
     }
     find(query, options = {
       useIgnoreFiles: false,
@@ -286,53 +394,38 @@ var PHPSandbox = (() => {
       const disposable = this.okra.listen(`fs.text.search.${sid}`, localOnMatch);
       return this.okra.invoke("fs.textSearch", { query, options: { ...defaultOptions, ...options } }).finally(() => disposable.dispose());
     }
-    mkdir(path) {
-      return this.okra.invoke("fs.mkdir", { path });
-    }
-    move(from, to) {
-      return this.okra.invoke("fs.move", { from, to });
-    }
-    remove(path, type) {
-      return this.okra.invoke("fs.remove", { path, type });
-    }
-    async readFile(path, lineRange) {
-      try {
-        const content = await this.okra.invoke("fs.readFile", { path, lineRange });
-        if (content instanceof Uint8Array) {
-          return content;
-        }
-        if (typeof content === "string") {
-          return new TextEncoder().encode(content);
-        }
-        return content;
-      } catch (e) {
-        this.handleError(e);
-      }
-    }
-    tail(path, lines = 10) {
-      return this.okra.invoke("fs.tail", { path, lines }).catch((e) => this.handleError(e));
-    }
-    writeFile(path, contents, options) {
-      return this.okra.invoke("fs.writeFile", {
-        path,
-        contents,
-        options
-      }).catch((e) => this.handleError(e));
+    tail(path, options = {}) {
+      return this.okra.invoke("fs.tail", { path, lines: options.lines ?? 10 }).catch((e) => this.handleError(e));
     }
     stat(path) {
       return this.okra.invoke("fs.stat", { path }).catch((e) => this.handleError(e));
     }
-    rename(from, to, options) {
-      return this.okra.invoke("fs.rename", { from, to, options }).catch((e) => this.handleError(e));
+    move(from, to, options = {}) {
+      return this.okra.invoke("fs.rename", {
+        from,
+        to,
+        options: { overwrite: false, ...options }
+      }).catch((e) => this.handleError(e));
     }
-    delete(path, options) {
-      return this.okra.invoke("fs.delete", { path, options }).catch((e) => this.handleError(e));
+    remove(path, options = {}) {
+      return this.okra.invoke("fs.delete", {
+        path,
+        options: { recursive: false, useTrash: false, atomic: false, ...options }
+      }).catch((e) => this.handleError(e));
     }
-    copy(source, destination, options) {
-      return this.okra.invoke("fs.copy", { source, destination, options }).catch((e) => this.handleError(e));
+    copy(source, destination, options = {}) {
+      return this.okra.invoke("fs.copy", {
+        source,
+        destination,
+        options: { overwrite: false, ...options }
+      }).catch((e) => this.handleError(e));
     }
-    readDirectory(path, include = [], exclude = []) {
-      return this.okra.invoke("fs.readDirectory", { path, include, exclude }).catch((e) => this.handleError(e));
+    list(path, options = {}) {
+      return this.okra.invoke("fs.readDirectory", {
+        path,
+        include: options.include ?? [],
+        exclude: options.exclude ?? []
+      }).catch((e) => this.handleError(e));
     }
     createDirectory(path) {
       return this.okra.invoke("fs.createDirectory", { path }).catch((e) => this.handleError(e));
@@ -361,17 +454,17 @@ var PHPSandbox = (() => {
     exists(path) {
       return this.stat(path).then(() => true).catch(() => false);
     }
-    async download(chunk, exclude, include) {
+    async download(options = {}) {
       const id = nanoid();
-      const stream = !!chunk;
+      const stream = !!options.onChunk;
       const chunks = [];
       const disposable = this.okra.listen(
         `fs.download.${id}`,
-        stream ? chunk : (data) => {
+        stream ? options.onChunk : (data) => {
           chunks.push(data);
         }
       );
-      return this.okra.invoke("fs.download", { id, exclude, include }).then(() => new Blob(chunks, { type: "application/octet-stream" })).finally(() => disposable.dispose());
+      return this.okra.invoke("fs.download", { id, exclude: options.exclude, include: options.include }).then(() => new Blob(chunks, { type: "application/octet-stream" })).finally(() => disposable.dispose());
     }
     tree(path = "/") {
       return this.okra.invoke("fs.tree", { path });
@@ -383,6 +476,28 @@ var PHPSandbox = (() => {
       throw e;
     }
   };
+  async function* toAsyncIterable(contents) {
+    if (contents instanceof Uint8Array) {
+      yield contents;
+      return;
+    }
+    yield* contents;
+  }
+  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 {
@@ -428,33 +543,35 @@ var PHPSandbox = (() => {
   // src/terminal.ts
   var TERMINAL_INPUT_FLUSH_DELAY_MS = 8;
   var terminalInputFlushPattern = /[\x00-\x1f\x7f]/;
-  var Terminal = class {
+  var Terminals = class {
     constructor(okra) {
       this.okra = okra;
     }
     list() {
       return this.okra.invoke("terminal.list");
     }
-    start() {
-      return this.okra.invoke("terminal.start");
-    }
-    create(input) {
-      return this.okra.invoke("terminal.create", input);
-    }
-    onStarted(handler) {
-      return this.okra.listen("terminal.started", handler);
-    }
-    resize(id, size) {
-      return this.okra.invoke("terminal.resize", { id, width: size[0], height: size[1] });
-    }
-    onOutput(id, handler) {
-      return this.okra.listen(`terminal.output.${id}`, handler);
-    }
-    input(id, input) {
-      return Promise.resolve(this.okra.send("terminal.input", { id, input }));
-    }
-    listen(event, handler) {
-      return this.okra.listen(event, handler);
+    async create(options = {}) {
+      const id = options.id ?? nanoid();
+      const handle = this.processHandle(id, options.abortSignal);
+      const command = typeof options.command === "string" && options.args?.length ? [options.command, ...options.args] : options.command;
+      const { abortSignal, args: _args, ...input } = options;
+      try {
+        const task = await this.okra.invoke(
+          "terminal.create",
+          {
+            ...input,
+            id,
+            kind: options.kind ?? "bash",
+            size: options.size ?? [80, 24],
+            command
+          },
+          { abortSignal }
+        );
+        return { ...handle.process, ...task };
+      } catch (error51) {
+        handle.dispose();
+        throw error51;
+      }
     }
     async attach(id, opts) {
       const handle = this.processHandle(id, opts?.abortSignal);
@@ -480,31 +597,6 @@ var PHPSandbox = (() => {
         throw error51;
       }
     }
-    async spawn(command, args, opts) {
-      const id = opts?.id || nanoid();
-      const handle = this.processHandle(id, opts?.abortSignal);
-      const { abortSignal, ...otherOpts } = opts ?? {};
-      try {
-        const result = await this.okra.invoke(
-          "terminal.spawn",
-          {
-            command: [command, ...args],
-            opts: {
-              id,
-              ...otherOpts
-            }
-          },
-          { abortSignal }
-        );
-        return {
-          ...handle.process,
-          ...result
-        };
-      } catch (error51) {
-        handle.dispose();
-        throw error51;
-      }
-    }
     processHandle(id, abortSignal) {
       const disposables = /* @__PURE__ */ new Set();
       let abortHandler;
@@ -530,7 +622,7 @@ var PHPSandbox = (() => {
         }
         const input2 = pendingInput;
         pendingInput = "";
-        void this.input(id, input2);
+        void this.okra.send("terminal.input", { id, input: input2 });
       };
       const scheduleInputFlush = () => {
         if (inputFlushTimer) {
@@ -538,7 +630,8 @@ var PHPSandbox = (() => {
         }
         inputFlushTimer = setTimeout(flushInput, TERMINAL_INPUT_FLUSH_DELAY_MS);
       };
-      const queueInput = (chunk) => {
+      const queueInput = (value) => {
+        const chunk = typeof value === "string" ? value : new TextDecoder().decode(value);
         pendingInput += chunk;
         if (terminalInputFlushPattern.test(chunk)) {
           flushInput();
@@ -560,7 +653,7 @@ var PHPSandbox = (() => {
         start: (_controller) => {
           controller = _controller;
           disposables.add(
-            this.listen(`terminal.output.${id}`, (data) => {
+            this.okra.listen(`terminal.output.${id}`, (data) => {
               controller?.enqueue(data.output);
             })
           );
@@ -570,9 +663,9 @@ var PHPSandbox = (() => {
           disposeInput();
         }
       });
-      const exit = new Promise((resolve) => {
+      const completion = new Promise((resolve) => {
         disposables.add(
-          this.listen(`terminal.close.${id}`, (data) => {
+          this.okra.listen(`terminal.close.${id}`, (data) => {
             if (controller) {
               try {
                 controller.close();
@@ -599,7 +692,7 @@ var PHPSandbox = (() => {
       }
       return {
         process: {
-          exit,
+          wait: () => completion,
           input,
           output,
           kill,
@@ -637,37 +730,9 @@ var PHPSandbox = (() => {
     state() {
       return this.okra.invoke("container.state");
     }
-    openedPorts() {
-      return this.okra.invoke("container.opened-ports");
-    }
     setPhp(version2) {
       return this.okra.invoke("container.set-php", { version: version2 });
     }
-    enableTelemetry(features) {
-      return this.okra.invoke("container.stream-telemetry", { features: Array.from(features) });
-    }
-    stopTelemetry() {
-      return this.okra.invoke("container.stop-telemetry");
-    }
-    listen(event, handler) {
-      return this.okra.listen(event, handler);
-    }
-    onPort(handler) {
-      let ports = [];
-      return this.listen("container.ports", (newPorts) => {
-        for (const port of newPorts) {
-          if (!ports.some((p) => p.port === port.port)) {
-            handler(port, "open");
-          }
-        }
-        for (const port of ports) {
-          if (!newPorts.some((p) => p.port === port.port)) {
-            handler(port, "close");
-          }
-        }
-        ports = newPorts;
-      });
-    }
   };
 
   // src/auth.ts
@@ -675,9 +740,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 === "") {
@@ -757,61 +819,376 @@ var PHPSandbox = (() => {
     }
   };
 
+  // src/shell.ts
+  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: { tty: false, ...resolvedOpts }
+    };
+  }
+  var CommandError = class extends Error {
+    constructor(result) {
+      super(result.output);
+      this.result = result;
+    }
+  };
+  var ProcessResult = class {
+    constructor(output, stdout, stderr, exitCode) {
+      this.output = output;
+      this.stdout = stdout;
+      this.stderr = stderr;
+      this.exitCode = exitCode;
+    }
+    throw() {
+      if (this.exitCode !== 0) {
+        throw new CommandError(this);
+      }
+      return this;
+    }
+  };
+  var ProcessReadable = class {
+    constructor() {
+      this.controller = null;
+      this.closed = false;
+      this.stream = new ReadableStream({
+        start: (controller) => {
+          this.controller = controller;
+        },
+        cancel: () => {
+          this.closed = true;
+          this.controller = null;
+        }
+      });
+    }
+    enqueue(value) {
+      if (!this.closed) {
+        this.controller?.enqueue(value);
+      }
+    }
+    close() {
+      if (this.closed) {
+        return;
+      }
+      this.closed = true;
+      this.controller?.close();
+      this.controller = null;
+    }
+    fail(error51) {
+      if (this.closed) {
+        return;
+      }
+      this.closed = true;
+      this.controller?.error(error51);
+      this.controller = null;
+    }
+  };
+  var ShellProcess = class {
+    constructor(id, okra, command, opts) {
+      this.id = id;
+      this.okra = okra;
+      const output = new ProcessReadable();
+      const stdout = new ProcessReadable();
+      const stderr = new ProcessReadable();
+      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) => {
+        subscription?.dispose();
+        subscription = null;
+        output.fail(error51);
+        stdout.fail(error51);
+        stderr.fail(error51);
+      };
+      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;
+      });
+    }
+    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 });
+    }
+  };
+
   // src/composer.ts
+  var ComposerProcess = class {
+    constructor(id, okra, command, args, options) {
+      this.id = id;
+      this.okra = okra;
+      const output = new ProcessReadable();
+      const stdout = new ProcessReadable();
+      const stderr = new ProcessReadable();
+      this.output = output.stream;
+      this.stdout = stdout.stream;
+      this.stderr = stderr.stream;
+      const encoder = new TextEncoder();
+      let subscription = this.okra.listen(`composer.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) => {
+        subscription?.dispose();
+        subscription = null;
+        output.fail(error51);
+        stdout.fail(error51);
+        stderr.fail(error51);
+      };
+      this.completion = this.okra.invoke("composer.invoke", { id, command, args, options }).then((result) => {
+        finish();
+        return new ProcessResult(result.output, result.stdout, result.stderr, result.exitCode);
+      }).catch((error51) => {
+        fail(error51);
+        throw error51;
+      });
+    }
+    wait() {
+      return this.completion;
+    }
+    async kill() {
+      await this.okra.invoke("composer.kill", { id: this.id });
+    }
+  };
   var Composer = class {
     constructor(okra, client) {
       this.okra = okra;
       this.credentials = new ComposerCredentials(client, okra.data.id);
     }
-    invoke(command, args = {}, options = {}) {
-      return this.okra.invoke("composer.invoke", { command, args, options });
+    run(command, args = {}, options = {}) {
+      return new ComposerProcess(nanoid(), this.okra, command, args, options);
     }
-    dumpAutoload() {
-      return this.okra.invoke("composer.dump-autoload");
+    dumpAutoload(options = {}) {
+      return this.run("dump-autoload", {}, options);
     }
     install(options = {}) {
-      return this.invoke("install", {}, options);
+      return this.run("install", {}, options);
     }
     update(args, options = {}) {
-      return this.invoke("update", args, options);
+      return this.run("update", args, options);
     }
     require(packages, options = {}) {
-      return this.invoke("require", packages, options);
+      return this.run("require", packages, options);
     }
     remove(args, options = {}) {
-      return this.invoke("remove", args, options);
-    }
-    stream(fn) {
-      return this.okra.listen("composer.log", fn);
+      return this.run("remove", args, options);
     }
     packages() {
       return this.okra.invoke("composer.packages");
     }
   };
 
-  // src/log.ts
-  var Log = class {
+  // src/runtime-telemetry.ts
+  var RuntimeTelemetry = class {
     constructor(okra) {
       this.okra = okra;
+      this.references = /* @__PURE__ */ new Map();
+      this.synchronization = Promise.resolve();
+      if (okra.runtimeTransport === "realtime") {
+        okra.onDidConnect(() => {
+          if (this.references.size > 0) {
+            void this.synchronize();
+          }
+        });
+      }
     }
-    stream(fn) {
-      return this.okra.listen("notebook.log", fn);
+    async acquire(feature) {
+      this.references.set(feature, (this.references.get(feature) ?? 0) + 1);
+      try {
+        await this.synchronize();
+      } catch (error51) {
+        this.removeReference(feature);
+        throw error51;
+      }
+      let released = false;
+      return async () => {
+        if (released) {
+          return;
+        }
+        released = true;
+        this.removeReference(feature);
+        await this.synchronize();
+      };
     }
-    listen(event, handler) {
-      return this.okra.listen(event, handler);
+    removeReference(feature) {
+      const references = this.references.get(feature) ?? 0;
+      if (references <= 1) {
+        this.references.delete(feature);
+      } else {
+        this.references.set(feature, references - 1);
+      }
+    }
+    synchronize() {
+      this.synchronization = this.synchronization.catch(() => {
+      }).then(async () => {
+        const features = Array.from(this.references.keys());
+        if (features.length === 0) {
+          await this.okra.invoke("container.stop-telemetry");
+        } else {
+          await this.okra.invoke("container.stream-telemetry", { features });
+        }
+      });
+      return this.synchronization;
+    }
+  };
+  function watchRuntimeTelemetry(okra, telemetry, feature, event, transform2, options = {}) {
+    let subscription = null;
+    let release = null;
+    let closed = false;
+    let abort = null;
+    const stop = async () => {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      subscription?.dispose();
+      subscription = null;
+      if (abort && options.signal) {
+        options.signal.removeEventListener("abort", abort);
+      }
+      abort = null;
+      await release?.();
+      release = null;
+    };
+    return new ReadableStream({
+      start(controller) {
+        subscription = okra.listen(event, (data) => {
+          if (!closed) {
+            controller.enqueue(transform2(data));
+          }
+        });
+        if (options.signal) {
+          abort = () => {
+            void stop().finally(() => controller.error(options.signal?.reason ?? new Error("Aborted")));
+          };
+          if (options.signal.aborted) {
+            abort();
+            return;
+          }
+          options.signal.addEventListener("abort", abort, { once: true });
+        }
+        void telemetry.acquire(feature).then(async (releaseTelemetry) => {
+          if (closed) {
+            await releaseTelemetry();
+            return;
+          }
+          release = releaseTelemetry;
+        }).catch((error51) => {
+          if (!closed) {
+            closed = true;
+            subscription?.dispose();
+            if (abort && options.signal) {
+              options.signal.removeEventListener("abort", abort);
+            }
+            abort = null;
+            controller.error(error51);
+          }
+        });
+      },
+      cancel: stop
+    });
+  }
+
+  // src/log.ts
+  var Logs = class {
+    constructor(okra, telemetry) {
+      this.okra = okra;
+      this.telemetry = telemetry;
+    }
+    follow(options = {}) {
+      return watchRuntimeTelemetry(this.okra, this.telemetry, "logs", "notebook.log", (message) => ({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        source: "runtime",
+        message
+      }), options);
     }
   };
 
-  // src/laravel.ts
-  var Laravel = class {
-    constructor(okra) {
+  // src/metrics.ts
+  var Metrics = class {
+    constructor(okra, telemetry) {
       this.okra = okra;
+      this.telemetry = telemetry;
     }
-    maintenanceInfo() {
-      return this.okra.invoke("laravel.maintenance.info", {});
+    current() {
+      return this.okra.invoke("container.stats");
+    }
+    watch(options = {}) {
+      return watchRuntimeTelemetry(this.okra, this.telemetry, "stats", "container.stats", (stats) => stats, options);
+    }
+  };
+
+  // src/ports.ts
+  var Ports = class {
+    constructor(okra, telemetry) {
+      this.okra = okra;
+      this.telemetry = telemetry;
+    }
+    list() {
+      return this.okra.invoke("container.opened-ports");
     }
-    toggleMaintenance(down) {
-      return this.okra.invoke("laravel.maintenance.toggle", down);
+    watch(options = {}) {
+      return watchRuntimeTelemetry(this.okra, this.telemetry, "ports", "container.ports", (ports) => ports, options);
     }
   };
 
@@ -829,9 +1206,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 });
     }
@@ -843,117 +1217,6 @@ var PHPSandbox = (() => {
     }
   };
 
-  // src/shell.ts
-  function resolveExecInput(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
-    };
-  }
-  var CommandError = class extends Error {
-    constructor(output, exitCode) {
-      super(output);
-      this.output = output;
-      this.exitCode = exitCode;
-    }
-  };
-  var Result = class {
-    constructor(output, exitCode) {
-      this.output = output;
-      this.exitCode = exitCode;
-    }
-    throw() {
-      if (this.exitCode !== 0) {
-        throw new CommandError(this.output, this.exitCode);
-      }
-      return this;
-    }
-  };
-  var Shell = class {
-    constructor(okra) {
-      this.okra = okra;
-    }
-    onOutput(id, handler) {
-      return this.okra.listen(`shell.output.${id}`, handler);
-    }
-    listen(event, handler) {
-      return this.okra.listen(event, handler);
-    }
-    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);
-    }
-    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 {
-          }
-        }
-      };
-      const fail = (error51) => {
-        if (closed) {
-          return;
-        }
-        closed = true;
-        dispose();
-        if (controller) {
-          controller.error(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;
-      }).catch((error51) => {
-        fail(error51);
-        throw error51;
-      });
-      return { output, result };
-    }
-  };
-
   // src/services.ts
   var notebookBuiltinServices = ["redis"];
   var notebookKnownServices = ["start", "nginx", ...notebookBuiltinServices];
@@ -973,12 +1236,6 @@ var PHPSandbox = (() => {
     stop(name) {
       return this.okra.invoke("service.stop", { name });
     }
-    onLog(id, handler) {
-      return this.okra.listen(`service.log.${id}`, handler);
-    }
-    listen(event, handler) {
-      return this.okra.listen(event, handler);
-    }
     logs(name, options = {}) {
       if (options.follow) {
         return this.followLogs(name, options);
@@ -1031,11 +1288,11 @@ var PHPSandbox = (() => {
         close();
         return this.okra.invoke("service.stop-logs", { id });
       });
-      const output = new ReadableStream({
+      return new ReadableStream({
         start: (_controller) => {
           controller = _controller;
           disposables.add(
-            this.onLog(id, (data) => {
+            this.okra.listen(`service.log.${id}`, (data) => {
               controller?.enqueue(data.output);
             })
           );
@@ -1049,10 +1306,9 @@ var PHPSandbox = (() => {
           });
         },
         cancel: () => {
-          void stop();
+          return stop().then(() => void 0);
         }
       });
-      return { id, output, stop };
     }
   };
 
@@ -3874,878 +4130,152 @@ var PHPSandbox = (() => {
   }
 
   // src/events/index.ts
-  var createMitt = mitt_default ?? mitt_exports;
-  function mittWithOnce(all) {
-    const inst = createMitt(all);
-    inst.once = (type, fn) => {
-      const onceHandler = (event) => {
-        inst.off(type, onceHandler);
-        fn(event);
-      };
-      inst.on(type, onceHandler);
-      return {
-        dispose: () => {
-          inst.off(type, onceHandler);
-        }
-      };
-    };
-    return inst;
-  }
-  var EventManager = class _EventManager {
-    constructor() {
-      this.emitter = mittWithOnce();
-    }
-    listen(event, callback) {
-      const dispose = () => {
-        this.removeListener(event, callback);
-      };
-      this.emitter.on(event, callback);
-      return { dispose };
-    }
-    emit(event, ...data) {
-      this.emitter.emit(event, data.length > 1 ? data : data[0]);
-    }
-    once(event, callback) {
-      return this.emitter.once(event, callback);
-    }
-    static make() {
-      return new _EventManager();
-    }
-    static refresh() {
-      return new _EventManager();
-    }
-    removeListener(event, callbackSignature) {
-      this.emitter.off(event, callbackSignature);
-    }
-    static createInstance() {
-      return new _EventManager();
-    }
-    inspect() {
-      return this.emitter.all;
-    }
-  };
-
-  // src/git.ts
-  var Git = class {
-    constructor(okra, client) {
-      this.okra = okra;
-      this.client = client;
-    }
-    checkpoint(author, message, branch = "main", allowEmpty = false) {
-      return this.okra.invoke("git.checkpoint", { author, message, branch, allowEmpty });
-    }
-    checkout(branch, create = true) {
-      return this.okra.invoke("git.checkout", { branch, create });
-    }
-    async sync(input) {
-      const response = await this.client.post(
-        `/notebook/${this.okra.data.id}/git/sync-targets`,
-        this.omitUndefined({ ...input })
-      );
-      return response.data;
-    }
-    async syncTargets() {
-      const response = await this.client.get(`/notebook/${this.okra.data.id}/git/sync-targets`);
-      return response.data;
-    }
-    log(ref = "main") {
-      return this.okra.invoke("git.log", { ref });
-    }
-    diff(input) {
-      return this.okra.invoke("git.diff", this.normalizeRemoteInput(input));
-    }
-    merge(input) {
-      return this.okra.invoke("git.merge", this.normalizeRemoteInput(input));
-    }
-    conflicts() {
-      return this.okra.invoke("git.conflicts", {});
-    }
-    abortMerge() {
-      return this.okra.invoke("git.resolve", { action: "abort" });
-    }
-    continueMerge(author, message) {
-      return this.okra.invoke("git.resolve", { action: "continue", author, message });
-    }
-    review() {
-      return this.okra.invoke("git.review", {});
-    }
-    stage(input = { all: true }) {
-      return this.okra.invoke("git.stage", input);
-    }
-    unstage(input = { all: true }) {
-      return this.okra.invoke("git.unstage", input);
-    }
-    revert(input) {
-      return this.okra.invoke("git.revert", input);
-    }
-    credentials() {
-      return this.okra.gitCredentials();
-    }
-    restore(ref) {
-      return this.okra.invoke("git.restore", { ref });
-    }
-    status() {
-      return this.okra.invoke("git.status", {});
-    }
-    normalizeRemoteInput(input) {
-      if (input.notebookId === void 0) {
-        return input;
-      }
-      const notebookId = input.notebookId.trim();
-      if (!notebookId) {
-        throw new Error("'notebookId' cannot be empty.");
-      }
-      if (input.url?.trim()) {
-        throw new Error("Pass either 'url' or 'notebookId', not both.");
-      }
-      if (input.target?.trim()) {
-        throw new Error("Pass either 'target' or 'notebookId', not both.");
-      }
-      const { notebookId: _notebookId, ...payload } = input;
-      return {
-        ...payload,
-        url: this.gitUrlForNotebook(notebookId)
-      };
-    }
-    gitUrlForNotebook(notebookId) {
-      const url2 = new URL(this.okra.data.gitUrl);
-      url2.username = "";
-      url2.password = "";
-      url2.pathname = `/${encodeURIComponent(notebookId)}.git`;
-      url2.search = "";
-      url2.hash = "";
-      return url2.toString();
-    }
-    omitUndefined(input) {
-      return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0));
-    }
-  };
-
-  // 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);
+  var createMitt = mitt_default ?? mitt_exports;
+  function mittWithOnce(all) {
+    const inst = createMitt(all);
+    inst.once = (type, fn) => {
+      const onceHandler = (event) => {
+        inst.off(type, onceHandler);
+        fn(event);
       };
-      this.port.onmessageerror = (event) => {
-        if (this.options.debug) {
-          console.error("[Beacon SDK] Port message error:", event);
+      inst.on(type, onceHandler);
+      return {
+        dispose: () => {
+          inst.off(type, onceHandler);
         }
       };
-      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();
-      });
+    };
+    return inst;
+  }
+  var EventManager = class _EventManager {
+    constructor() {
+      this.emitter = mittWithOnce();
     }
-    /**
-     * 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);
-            }
-          }
-        });
-      }
+    listen(event, callback) {
+      const dispose = () => {
+        this.removeListener(event, callback);
+      };
+      this.emitter.on(event, callback);
+      return { dispose };
     }
-    /**
-     * 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;
-          }
-        }
-      );
+    emit(event, ...data) {
+      this.emitter.emit(event, data.length > 1 ? data : data[0]);
     }
-    /**
-     * 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)}`
-        );
-      }
+    once(event, callback) {
+      return this.emitter.once(event, callback);
     }
-    /**
-     * 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);
-            }
-          }
-        }
-      );
+    static make() {
+      return new _EventManager();
     }
-    /**
-     * Generate a unique ID for messages
-     */
-    generateId() {
-      return `sdk_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    static refresh() {
+      return new _EventManager();
     }
-    /**
-     * Event emitter methods (both private and public for navigator access)
-     */
-    emit(event, payload) {
-      this.eventEmitter.emit(event, payload);
+    removeListener(event, callbackSignature) {
+      this.emitter.off(event, callbackSignature);
     }
-    /**
-     * Start the beacon initialization process
-     */
-    start() {
-      if (this.isStarted) {
-        return this.readyPromise || Promise.resolve();
-      }
-      this.isStarted = true;
-      this.readyPromise = this.waitForBeaconReady();
-      return this.readyPromise;
+    static createInstance() {
+      return new _EventManager();
     }
-    /**
-     * 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);
+    inspect() {
+      return this.emitter.all;
     }
-    /**
-     * Check if beacon is ready
-     */
-    get isReady() {
-      return this.isBeaconReady;
+  };
+
+  // src/git.ts
+  var Git = class {
+    constructor(okra, client) {
+      this.okra = okra;
+      this.client = client;
     }
-    /**
-     * Listen for beacon events
-     */
-    on(event, handler) {
-      return this.eventEmitter.listen(event, handler);
+    checkpoint(author, message, branch = "main", allowEmpty = false) {
+      return this.okra.invoke("git.checkpoint", { author, message, branch, allowEmpty });
     }
-    /**
-     * Listen for beacon events (one-time)
-     */
-    once(event, handler) {
-      return this.eventEmitter.once(event, handler);
+    checkout(branch, create = true) {
+      return this.okra.invoke("git.checkout", { branch, create });
     }
-    /**
-     * 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;
-      }
+    async sync(input) {
+      const response = await this.client.post(
+        `/notebook/${this.okra.data.id}/git/sync-targets`,
+        this.omitUndefined({ ...input })
+      );
+      return response.data;
     }
-    /**
-     * Get debug information from the beacon
-     */
-    async getDebugInfo() {
-      return this.sendAndWaitFor("getDebugInfo", "debugInfo");
+    async syncTargets() {
+      const response = await this.client.get(`/notebook/${this.okra.data.id}/git/sync-targets`);
+      return response.data;
     }
-    /**
-     * Get console events from the beacon
-     */
-    async getConsoleEvents() {
-      return this.sendAndWaitFor("getConsoleEvents", "consoleEvents");
+    log(ref = "main") {
+      return this.okra.invoke("git.log", { ref });
     }
-    /**
-     * Get error events from the beacon
-     */
-    async getErrorEvents() {
-      return this.sendAndWaitFor("getErrorEvents", "errorEvents");
+    diff(input) {
+      return this.okra.invoke("git.diff", this.normalizeRemoteInput(input));
     }
-    /**
-     * Clear console events in the beacon
-     */
-    async clearConsole() {
-      await this.ready();
-      this.sendMessage("clearConsole");
+    merge(input) {
+      return this.okra.invoke("git.merge", this.normalizeRemoteInput(input));
     }
-    /**
-     * Clear error events in the beacon
-     */
-    async clearErrors() {
-      await this.ready();
-      this.sendMessage("clearErrors");
+    conflicts() {
+      return this.okra.invoke("git.conflicts", {});
     }
-    /**
-     * Execute code in the beacon context
-     */
-    async executeCode(code) {
-      return this.sendAndWaitFor("executeCode", "codeExecutionResult", { code });
+    abortMerge() {
+      return this.okra.invoke("git.resolve", { action: "abort" });
     }
-    /**
-     * Inspect an element in the beacon context
-     */
-    async inspectElement(selector) {
-      return this.sendAndWaitFor("inspectElement", "elementInspectionResult", { selector });
+    continueMerge(author, message) {
+      return this.okra.invoke("git.resolve", { action: "continue", author, message });
     }
-    /**
-     * Fetch a URL in the beacon context
-     */
-    async fetch(request) {
-      return this.sendAndWaitFor("fetch", "fetchResult", request);
+    review() {
+      return this.okra.invoke("git.review", {});
     }
-    /**
-     * 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);
+    stage(input = { all: true }) {
+      return this.okra.invoke("git.stage", input);
     }
-    /**
-     * 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);
+    unstage(input = { all: true }) {
+      return this.okra.invoke("git.unstage", input);
     }
-    async wait(forSeconds) {
-      return new Promise((resolve) => setTimeout(resolve, forSeconds * 1e3));
+    revert(input) {
+      return this.okra.invoke("git.revert", input);
     }
-    /**
-     * 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}`);
-      }
+    credentials() {
+      return this.okra.gitCredentials();
     }
-    /**
-     * Get current iframe URL
-     */
-    get url() {
-      return this.iframe.src;
+    restore(ref) {
+      return this.okra.invoke("git.restore", { ref });
     }
-    /**
-     * Get the iframe element
-     */
-    get element() {
-      return this.iframe;
+    status() {
+      return this.okra.invoke("git.status", {});
     }
-    /**
-     * Dispose of all resources
-     */
-    dispose() {
-      if (this.port) {
-        this.port.close();
-        this.port = null;
+    normalizeRemoteInput(input) {
+      if (input.notebookId === void 0) {
+        return input;
+      }
+      const notebookId = input.notebookId.trim();
+      if (!notebookId) {
+        throw new Error("'notebookId' cannot be empty.");
       }
-      if (this.messageChannel) {
-        this.messageChannel = null;
+      if (input.url?.trim()) {
+        throw new Error("Pass either 'url' or 'notebookId', not both.");
       }
-      this.disposables.forEach((disposable) => disposable.dispose());
-      this.disposables = [];
-      this.messageHandlers.clear();
-      this.isBeaconReady = false;
-      this.channelEstablished = false;
-      this.isStarted = false;
-      this.readyPromise = null;
+      if (input.target?.trim()) {
+        throw new Error("Pass either 'target' or 'notebookId', not both.");
+      }
+      const { notebookId: _notebookId, ...payload } = input;
+      return {
+        ...payload,
+        url: this.gitUrlForNotebook(notebookId)
+      };
     }
-  };
-  function createBeacon(iframe, options) {
-    return new Beacon(iframe, options);
-  }
-  function isBeaconSupported() {
-    try {
-      ensureBrowserEnvironment();
-      return true;
-    } catch {
-      return false;
+    gitUrlForNotebook(notebookId) {
+      const url2 = new URL(this.okra.data.gitUrl);
+      url2.username = "";
+      url2.password = "";
+      url2.pathname = `/${encodeURIComponent(notebookId)}.git`;
+      url2.search = "";
+      url2.hash = "";
+      return url2.toString();
     }
-  }
+    omitUndefined(input) {
+      return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0));
+    }
+  };
 
   // node_modules/zod/v4/classic/external.js
   var external_exports = {};
@@ -19261,13 +18791,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 +18809,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 +18817,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 +18828,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 +18839,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 +18945,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 +19050,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 +19060,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 +19072,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 +19088,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 +19097,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 +19127,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 +19161,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 +19274,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 +19282,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 +19291,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();
@@ -19913,6 +19436,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     "container.stop": { method: "POST", path: "/runtime/container/stop" },
     "container.set-php": { method: "PUT", path: "/runtime/container/php" },
     "container.opened-ports": { method: "GET", path: "/runtime/container/ports" },
+    "container.stats": { method: "GET", path: "/runtime/container/stats" },
     "terminal.list": { method: "GET", path: "/runtime/terminals" },
     "shell.exec": { method: "POST", path: "/runtime/executions" },
     "fs.info": { method: "POST", path: "/runtime/files/info" },
@@ -19938,10 +19462,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     "service.logs": { method: "POST", path: "/runtime/services/logs" },
     "composer.invoke": { method: "POST", path: "/runtime/composer/executions" },
     "composer.packages": { method: "GET", path: "/runtime/composer/packages" },
-    "composer.dump-autoload": {
-      method: "POST",
-      path: "/runtime/composer/autoload"
-    },
     "git.checkpoint": { method: "POST", path: "/runtime/git/checkpoints" },
     "git.checkout": { method: "POST", path: "/runtime/git/checkouts" },
     "git.log": { method: "POST", path: "/runtime/git/log" },
@@ -20181,11 +19701,11 @@ 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 });
-      const instance = new NotebookInstance2(response.data, this.client);
+      const instance = new NotebookInstance(response.data, this.client);
       if (!init) {
         return instance;
       }
@@ -20193,29 +19713,25 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
     async get(id) {
       const response = await this.client.get(`/notebook/${id}`);
-      return new NotebookInstance2(response.data, this.client);
+      return new NotebookInstance(response.data, this.client);
     }
     async update(id, input = {}) {
       const response = await this.client.put(`/notebook/${id}`, input);
-      return new NotebookInstance2(response.data, this.client);
+      return new NotebookInstance(response.data, this.client);
     }
-    async delete(id) {
+    async destroy(id) {
       await this.client.delete(`/notebook/${id}`);
     }
     async fork(id, input = {}) {
       const response = await this.client.post(`/notebook/${id}/fork`, input);
-      return new NotebookInstance2(response.data, this.client);
+      return new NotebookInstance(response.data, this.client);
     }
     async gitCredentials(id) {
       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));
+      return this.init(new NotebookInstance(data, this.client));
     }
     async init(instance) {
       await instance.ready();
@@ -20230,11 +19746,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     baseUrl.hash = "";
     return baseUrl.toString();
   }
-  var Client2 = class {
+  var Client = 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);
@@ -20314,7 +19830,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       return { data: body === "" ? void 0 : JSON.parse(body) };
     }
   };
-  var PHPSandbox = class _PHPSandbox extends Client2 {
+  var PHPSandbox = class _PHPSandbox extends Client {
     static realtime(token, url2 = "https://api.phpsandbox.io/v1", options = {}) {
       return new _PHPSandbox(token, url2, options);
     }
@@ -20422,7 +19938,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
   };
   var _initPromise, _NotebookInstance_instances, init_fn;
-  var NotebookInstance2 = class {
+  var NotebookInstance = class {
     constructor(data, client) {
       this.data = data;
       this.client = client;
@@ -20457,18 +19973,20 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         this.watchConnection();
         __privateSet(this, _initPromise, __privateMethod(this, _NotebookInstance_instances, init_fn).call(this));
       }
-      this.file = new Filesystem(
+      this.files = new Filesystem(
         this,
         this.socket === null ? null : (handler) => this.onDidConnect(handler)
       );
-      this.terminal = new Terminal(this);
+      this.terminals = new Terminals(this);
       this.auth = new Auth(this);
       this.lsp = new Lsp(this);
       this.composer = new Composer(this, client);
-      this.log = new Log(this);
+      const telemetry = new RuntimeTelemetry(this);
+      this.logs = new Logs(this, telemetry);
+      this.metrics = new Metrics(this, telemetry);
+      this.ports = new Ports(this, telemetry);
       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 +20018,29 @@ 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);
+    }
+    exec(command, argsOrOpts = [], opts) {
+      if (Array.isArray(argsOrOpts)) {
+        return this.run(command, argsOrOpts, opts).wait();
+      }
+      return this.run(command, argsOrOpts).wait();
     }
     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 }));
       });
     }
@@ -20596,9 +20126,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       const socket = this.realtimeSocket();
       socket.onDidConnect(() => {
         socket.emit("okra.connected");
-        if (this.client.options.telemetry) {
-          this.container.enableTelemetry(this.client.options.telemetry);
-        }
       });
       socket.onDidClose(() => {
         socket.emit("okra.disconnected");
@@ -20657,11 +20184,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.");