@phpsandbox/sdk 0.0.68 → 0.1.2

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

@@ -109,11 +109,122 @@ var Filesystem = class {
       }
     });
   }
-  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,
@@ -192,53 +303,38 @@ var Filesystem = class {
     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));
@@ -267,17 +363,17 @@ var Filesystem = class {
   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 });
@@ -289,6 +385,28 @@ var Filesystem = class {
     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 {
@@ -334,33 +452,35 @@ var once = (fn) => {
 // 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);
@@ -386,31 +506,6 @@ var Terminal = class {
       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;
@@ -436,7 +531,7 @@ var Terminal = class {
       }
       const input2 = pendingInput;
       pendingInput = "";
-      void this.input(id, input2);
+      void this.okra.send("terminal.input", { id, input: input2 });
     };
     const scheduleInputFlush = () => {
       if (inputFlushTimer) {
@@ -444,7 +539,8 @@ var Terminal = class {
       }
       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();
@@ -466,7 +562,7 @@ var Terminal = class {
       start: (_controller) => {
         controller = _controller;
         disposables.add(
-          this.listen(`terminal.output.${id}`, (data) => {
+          this.okra.listen(`terminal.output.${id}`, (data) => {
             controller?.enqueue(data.output);
           })
         );
@@ -476,9 +572,9 @@ var Terminal = class {
         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();
@@ -505,7 +601,7 @@ var Terminal = class {
     }
     return {
       process: {
-        exit,
+        wait: () => completion,
         input,
         output,
         kill,
@@ -543,37 +639,9 @@ var Container = class {
   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
@@ -581,9 +649,6 @@ var Auth = class {
   constructor(okra) {
     this.okra = okra;
   }
-  logout() {
-    this.okra.dispose();
-  }
   login(runtimeUrl) {
     const runtimeTicket = new URL(runtimeUrl).searchParams.get("ticket");
     if (runtimeTicket === null || runtimeTicket === "") {
@@ -663,61 +728,376 @@ var LspConnection = class _LspConnection {
   }
 };
 
+// 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);
   }
 };
 
@@ -735,9 +1115,6 @@ var Repl = class {
   stop() {
     return this.okra.invoke("repl.stop");
   }
-  start() {
-    return this.okra.invoke("repl.start");
-  }
   resize(cols, rows) {
     return this.okra.invoke("repl.resize", { cols, rows });
   }
@@ -749,117 +1126,6 @@ var Repl = class {
   }
 };
 
-// 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];
@@ -879,12 +1145,6 @@ var Services = class {
   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);
@@ -937,11 +1197,11 @@ var Services = class {
       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);
           })
         );
@@ -955,10 +1215,9 @@ var Services = class {
         });
       },
       cancel: () => {
-        void stop();
+        return stop().then(() => void 0);
       }
     });
-    return { id, output, stop };
   }
 };
 
@@ -3780,878 +4039,152 @@ function mitt_default(n) {
 }
 
 // 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 = {};
@@ -19167,13 +18700,13 @@ function date4(params) {
 // node_modules/zod/v4/classic/external.js
 config(en_default());
 
-// src/schemas/deployments.ts
-var DeploymentTargetProviderSchema = external_exports.enum([
-  "okraCloudflareContainer",
-  "okraSshAgent",
-  "okraLaravelCloud"
+// src/schemas/publications.ts
+var PublicationProviderNameSchema = external_exports.enum([
+  "cloudflare-containers",
+  "ssh-server",
+  "laravel-cloud"
 ]);
-var DeploymentStatusSchema = external_exports.enum([
+var PublicationStatusSchema = external_exports.enum([
   "pending",
   "queued",
   "building",
@@ -19185,7 +18718,7 @@ var DeploymentStatusSchema = external_exports.enum([
   "deleted",
   "delete_failed"
 ]);
-var DeploymentBuildStatusSchema = external_exports.enum([
+var PublicationBuildStatusSchema = external_exports.enum([
   "pending",
   "queued",
   "running",
@@ -19193,8 +18726,8 @@ var DeploymentBuildStatusSchema = external_exports.enum([
   "failed",
   "cancelled"
 ]);
-var DeploymentReleaseStatusSchema = external_exports.enum(["created", "ready", "deleted"]);
-var DeploymentSizeSchema = external_exports.enum([
+var PublicationReleaseStatusSchema = external_exports.enum(["created", "ready", "deleted"]);
+var PublicationSizeSchema = external_exports.enum([
   "nano",
   "small",
   "medium",
@@ -19204,7 +18737,7 @@ var DeploymentSizeSchema = external_exports.enum([
   "standard-1",
   "standard-2"
 ]);
-var DeploymentRegionSchema = external_exports.enum([
+var PublicationRegionSchema = external_exports.enum([
   "ENAM",
   "WNAM",
   "EEUR",
@@ -19215,103 +18748,103 @@ var DeploymentRegionSchema = external_exports.enum([
   "OC",
   "AFR"
 ]);
-var DeploymentJurisdictionSchema = external_exports.enum(["eu", "fedramp"]);
-var DeploymentDomainDnsRecordTypeSchema = external_exports.enum(["CNAME", "ALIAS", "ANAME"]);
-var DeploymentProtectionModeSchema = external_exports.enum(["none", "password"]);
-var DeploymentLogStreamSchema = external_exports.enum(["build", "runtime"]);
-var DeployStreamLogStreamSchema = external_exports.enum(["build", "deploy", "runtime"]);
-var DeploymentEventDataSchema = external_exports.object({
+var PublicationJurisdictionSchema = external_exports.enum(["eu", "fedramp"]);
+var PublicationDomainDnsRecordTypeSchema = external_exports.enum(["CNAME", "ALIAS", "ANAME"]);
+var PublicationProtectionModeSchema = external_exports.enum(["none", "password"]);
+var PublicationLogStreamSchema = external_exports.enum(["build", "runtime"]);
+var PublishStreamLogStreamSchema = external_exports.enum(["build", "publish", "runtime"]);
+var PublicationEventDataSchema = external_exports.object({
   id: external_exports.union([external_exports.number(), external_exports.string()]).optional(),
   sequence: external_exports.number(),
   type: external_exports.string(),
   payload: external_exports.record(external_exports.string(), external_exports.unknown()),
   createdAt: external_exports.string().nullable()
 }).passthrough();
-var DeploymentLogChunkDataSchema = external_exports.object({
+var PublicationLogChunkDataSchema = external_exports.object({
   sequence: external_exports.number(),
-  stream: DeploymentLogStreamSchema,
+  stream: PublicationLogStreamSchema,
   content: external_exports.string(),
   createdAt: external_exports.string().nullable()
 }).passthrough();
-var DeployStreamPhaseSchema = external_exports.object({
+var PublishStreamPhaseSchema = external_exports.object({
   name: external_exports.string(),
   status: external_exports.enum(["running", "completed", "failed"]).optional(),
   data: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
 }).strict();
-var DeployStreamLogSchema = external_exports.object({
-  stream: DeployStreamLogStreamSchema,
+var PublishStreamLogSchema = external_exports.object({
+  stream: PublishStreamLogStreamSchema,
   content: external_exports.string()
 }).strict();
-var DeployStreamResultSchema = external_exports.object({
+var PublishStreamResultSchema = external_exports.object({
   success: external_exports.boolean(),
-  deploymentId: external_exports.string(),
+  publicationId: external_exports.string(),
   buildId: external_exports.string(),
   releaseId: external_exports.string(),
-  status: DeploymentStatusSchema
+  status: PublicationStatusSchema
 }).strict();
-var DeployStreamPhaseEventSchema = DeployStreamPhaseSchema.extend({
+var PublishStreamPhaseEventSchema = PublishStreamPhaseSchema.extend({
   type: external_exports.literal("phase")
 }).strict();
-var DeployStreamLogEventSchema = DeployStreamLogSchema.extend({
+var PublishStreamLogEventSchema = PublishStreamLogSchema.extend({
   type: external_exports.literal("log")
 }).strict();
-var DeployStreamResultEventSchema = DeployStreamResultSchema.extend({
+var PublishStreamResultEventSchema = PublishStreamResultSchema.extend({
   type: external_exports.literal("result")
 }).strict();
-var DeployStreamEventSchema = external_exports.discriminatedUnion("type", [
-  DeployStreamPhaseEventSchema,
-  DeployStreamLogEventSchema,
-  DeployStreamResultEventSchema
+var PublishStreamEventSchema = external_exports.discriminatedUnion("type", [
+  PublishStreamPhaseEventSchema,
+  PublishStreamLogEventSchema,
+  PublishStreamResultEventSchema
 ]);
-var DeployStreamErrorSchema = external_exports.object({
+var PublishStreamErrorSchema = external_exports.object({
   message: external_exports.string().optional()
 }).passthrough();
-var DeployStreamSseEventNameSchema = external_exports.enum(["phase", "log", "done", "result", "error"]);
-var DeployStreamSsePhaseEventSchema = external_exports.object({
+var PublishStreamSseEventNameSchema = external_exports.enum(["phase", "log", "done", "result", "error"]);
+var PublishStreamSsePhaseEventSchema = external_exports.object({
   event: external_exports.literal("phase"),
-  data: DeployStreamPhaseSchema
+  data: PublishStreamPhaseSchema
 }).strict();
-var DeployStreamSseLogEventSchema = external_exports.object({
+var PublishStreamSseLogEventSchema = external_exports.object({
   event: external_exports.literal("log"),
-  data: DeployStreamLogSchema
+  data: PublishStreamLogSchema
 }).strict();
-var DeployStreamSseDoneEventSchema = external_exports.object({
+var PublishStreamSseDoneEventSchema = external_exports.object({
   event: external_exports.literal("done"),
-  data: DeployStreamResultSchema
+  data: PublishStreamResultSchema
 }).strict();
-var DeployStreamSseResultEventSchema = external_exports.object({
+var PublishStreamSseResultEventSchema = external_exports.object({
   event: external_exports.literal("result"),
-  data: DeployStreamResultSchema
+  data: PublishStreamResultSchema
 }).strict();
-var DeployStreamSseErrorEventSchema = external_exports.object({
+var PublishStreamSseErrorEventSchema = external_exports.object({
   event: external_exports.literal("error"),
-  data: DeployStreamErrorSchema
+  data: PublishStreamErrorSchema
 }).strict();
-var DeployStreamSseEventSchema = external_exports.discriminatedUnion("event", [
-  DeployStreamSsePhaseEventSchema,
-  DeployStreamSseLogEventSchema,
-  DeployStreamSseDoneEventSchema,
-  DeployStreamSseResultEventSchema,
-  DeployStreamSseErrorEventSchema
+var PublishStreamSseEventSchema = external_exports.discriminatedUnion("event", [
+  PublishStreamSsePhaseEventSchema,
+  PublishStreamSseLogEventSchema,
+  PublishStreamSseDoneEventSchema,
+  PublishStreamSseResultEventSchema,
+  PublishStreamSseErrorEventSchema
 ]).transform((event) => {
   if (event.event === "error") {
-    throw new Error(event.data.message ?? "Deploy failed");
+    throw new Error(event.data.message ?? "Publish failed");
   }
   const type = event.event === "done" ? "result" : event.event;
-  return DeployStreamEventSchema.parse({ type, ...event.data });
+  return PublishStreamEventSchema.parse({ type, ...event.data });
 });
 
-// src/deployments.ts
-var NotebookDeploymentApi = class {
+// src/publications.ts
+var NotebookPublicationApi = class {
   constructor(client) {
     this.client = client;
   }
   async current(notebookId) {
     try {
       const response = await this.client.get(
-        `/notebook/${notebookId}/deployment`
+        `/notebook/${notebookId}/publication`
       );
-      return new DeploymentInstance(response.data, this.client, notebookId);
+      return new PublicationInstance(response.data, this.client, notebookId);
     } catch (error51) {
       if (error51 instanceof ApiError && error51.status === 404) {
         return null;
@@ -19321,89 +18854,82 @@ var NotebookDeploymentApi = class {
   }
   async publish(notebookId, input) {
     const response = await this.client.post(
-      `/notebook/${notebookId}/deployment/publish`,
+      `/notebook/${notebookId}/publication`,
       input
     );
-    const run = new DeploymentRun(new DeploymentInstance(response.data, this.client, notebookId), this.client);
+    const run = new PublicationRun(new PublicationInstance(response.data, this.client, notebookId), this.client);
     run.start();
     return run;
   }
-  async slugAvailability(id, slug) {
-    const query = new URLSearchParams({ slug }).toString();
-    const response = await this.client.get(
-      `/notebook/${id}/deployment/slug-availability?${query}`
-    );
-    return response.data;
-  }
 };
-var DeploymentApi = class {
+var PublicationApi = class {
   constructor(client) {
     this.client = client;
   }
   async get(id) {
-    const response = await this.client.get(`/deployments/${id}`);
-    return new DeploymentInstance(response.data, this.client);
+    const response = await this.client.get(`/publications/${id}`);
+    return new PublicationInstance(response.data, this.client);
   }
-  async delete(id) {
-    await this.client.delete(`/deployments/${id}`);
+  async destroy(id) {
+    await this.client.delete(`/publications/${id}`);
   }
   async setProtection(id, input) {
-    const response = await this.client.put(`/deployments/${id}/protection`, input);
-    return new DeploymentInstance(response.data, this.client);
+    const response = await this.client.put(`/publications/${id}/protection`, input);
+    return new PublicationInstance(response.data, this.client);
   }
   async protection(id) {
-    const response = await this.client.get(`/deployments/${id}/protection`);
+    const response = await this.client.get(`/publications/${id}/protection`);
     return response.data;
   }
   async createProtectionSession(id) {
-    const response = await this.client.post(`/deployments/${id}/protection/session`);
+    const response = await this.client.post(`/publications/${id}/protection/session`);
     return response.data;
   }
   async disableProtection(id) {
-    const response = await this.client.delete(`/deployments/${id}/protection`);
-    return new DeploymentInstance(response.data, this.client);
+    const response = await this.client.delete(`/publications/${id}/protection`);
+    return new PublicationInstance(response.data, this.client);
   }
   async setFeedback(id, input) {
-    const response = await this.client.put(`/deployments/${id}/feedback`, input);
-    return new DeploymentInstance(response.data, this.client);
+    const response = await this.client.put(`/publications/${id}/feedback`, input);
+    return new PublicationInstance(response.data, this.client);
   }
   async listDomains(id) {
     const response = await this.client.get(
-      `/deployments/${id}/domains`
+      `/publications/${id}/domains`
     );
-    return unwrapDeploymentDomainCollection(response.data);
+    return unwrapPublicationDomainCollection(response.data);
   }
   async createDomain(id, input) {
-    const response = await this.client.post(`/deployments/${id}/domains`, input);
+    const response = await this.client.post(`/publications/${id}/domains`, input);
     return response.data;
   }
   async refreshDomain(id, domainId) {
-    const response = await this.client.post(`/deployments/${id}/domains/${domainId}/refresh`);
+    const response = await this.client.post(`/publications/${id}/domains/${domainId}/refresh`);
     return response.data;
   }
   async deleteDomain(id, domainId) {
-    await this.client.delete(`/deployments/${id}/domains/${domainId}`);
+    await this.client.delete(`/publications/${id}/domains/${domainId}`);
   }
   async events(id) {
     return parseNdjsonStream(
-      await this.client.stream(`/deployments/${id}/events/stream`),
-      DeploymentEventDataSchema
+      await this.client.stream(`/publications/${id}/events/stream`),
+      PublicationEventDataSchema
     );
   }
   async buildLogs(id, buildId) {
     return parseNdjsonStream(
-      await this.client.stream(`/deployments/${id}/builds/${buildId}/logs/stream`),
-      DeploymentLogChunkDataSchema
+      await this.client.stream(`/publications/${id}/builds/${buildId}/logs/stream`),
+      PublicationLogChunkDataSchema
     );
   }
   async logs(id) {
     return parseNdjsonStream(
-      await this.client.stream(`/deployments/${id}/logs/stream`),
-      DeploymentLogChunkDataSchema
+      await this.client.stream(`/publications/${id}/logs/stream`),
+      PublicationLogChunkDataSchema
     );
   }
 };
-var DeploymentRun = class {
+var PublicationRun = class {
   constructor(initial, client) {
     this.initial = initial;
     this.client = client;
@@ -19433,7 +18959,7 @@ var DeploymentRun = class {
     this.start();
     return this.resultPromise;
   }
-  async deployment() {
+  async publication() {
     await this.result();
     return this.initial.refresh();
   }
@@ -19443,7 +18969,7 @@ var DeploymentRun = class {
     }
     const eventStreamUrl = this.initial.data.eventStreamUrl;
     if (!eventStreamUrl) {
-      throw new Error(`Deployment ${this.initial.data.id} has no eventStreamUrl for SSE streaming`);
+      throw new Error(`Publication ${this.initial.data.id} has no eventStreamUrl for SSE streaming`);
     }
     this.started = true;
     this.resultPromise = new Promise((resolve, reject) => {
@@ -19455,7 +18981,7 @@ var DeploymentRun = class {
     return this;
   }
   subscribe() {
-    const queue = new AsyncDeployEventQueue();
+    const queue = new AsyncPublishEventQueue();
     for (const event of this.bufferedEvents) {
       queue.push(event);
     }
@@ -19471,7 +18997,7 @@ var DeploymentRun = class {
   async consumeStream(eventStreamUrl) {
     try {
       const stream = await this.client.sse(eventStreamUrl);
-      for await (const event of readDeployStreamEvents(stream)) {
+      for await (const event of readPublishStreamEvents(stream)) {
         this.publish(event);
         if (event.type === "result") {
           const { type: _, ...result } = event;
@@ -19480,7 +19006,7 @@ var DeploymentRun = class {
         }
       }
       if (!this.finalResult) {
-        throw new Error("Deploy stream ended without result");
+        throw new Error("Publish stream ended without result");
       }
       this.closeSubscribers();
     } catch (err) {
@@ -19510,33 +19036,33 @@ var DeploymentRun = class {
     this.subscribers.clear();
   }
 };
-var DeploymentInstance = class _DeploymentInstance {
+var PublicationInstance = class _PublicationInstance {
   constructor(data, client, notebookId) {
     this.data = data;
     this.client = client;
     this.notebookId = notebookId;
   }
   async refresh() {
-    const response = await this.client.get(`/deployments/${this.data.id}`);
-    return new _DeploymentInstance(response.data, this.client, this.notebookId);
+    const response = await this.client.get(`/publications/${this.data.id}`);
+    return new _PublicationInstance(response.data, this.client, this.notebookId);
   }
   publish() {
     if (!this.notebookId) {
-      return Promise.reject(new Error("Deployment publish requires a notebook-scoped deployment instance."));
+      return Promise.reject(new Error("Publishing requires a notebook-scoped publication instance."));
     }
-    return this.client.notebook.deployment.publish(this.notebookId);
+    return this.client.notebook.publication.publish(this.notebookId);
   }
-  delete() {
-    return this.client.deployments.delete(this.data.id);
+  destroy() {
+    return this.client.publications.destroy(this.data.id);
   }
   async wait(options = {}) {
     const intervalMs = options.intervalMs ?? 1e3;
     const timeoutMs = options.timeoutMs ?? 3e5;
     const startedAt = Date.now();
     let current = this;
-    while (!deploymentStatusIsTerminal(current.data.status)) {
+    while (!publicationStatusIsTerminal(current.data.status)) {
       if (Date.now() - startedAt > timeoutMs) {
-        throw new Error(`Timed out waiting for deployment ${this.data.id}`);
+        throw new Error(`Timed out waiting for publication ${this.data.id}`);
       }
       await delay(intervalMs);
       current = await current.refresh();
@@ -19544,58 +19070,58 @@ var DeploymentInstance = class _DeploymentInstance {
     return current;
   }
   events() {
-    return this.client.deployments.events(this.data.id);
+    return this.client.publications.events(this.data.id);
   }
   buildLogs(buildId = this.data.latestBuild?.id ?? "") {
     if (buildId === "") {
-      return Promise.reject(new Error("Deployment has no latest build id"));
+      return Promise.reject(new Error("Publication has no latest build id"));
     }
-    return this.client.deployments.buildLogs(this.data.id, buildId);
+    return this.client.publications.buildLogs(this.data.id, buildId);
   }
   logs() {
-    return this.client.deployments.logs(this.data.id);
+    return this.client.publications.logs(this.data.id);
   }
   setProtection(input) {
-    return this.client.deployments.setProtection(this.data.id, input);
+    return this.client.publications.setProtection(this.data.id, input);
   }
   protection() {
-    return this.client.deployments.protection(this.data.id);
+    return this.client.publications.protection(this.data.id);
   }
   createProtectionSession() {
-    return this.client.deployments.createProtectionSession(this.data.id);
+    return this.client.publications.createProtectionSession(this.data.id);
   }
   disableProtection() {
-    return this.client.deployments.disableProtection(this.data.id);
+    return this.client.publications.disableProtection(this.data.id);
   }
   setFeedback(input) {
-    return this.client.deployments.setFeedback(this.data.id, input);
+    return this.client.publications.setFeedback(this.data.id, input);
   }
   domains() {
-    return this.client.deployments.listDomains(this.data.id);
+    return this.client.publications.listDomains(this.data.id);
   }
   addDomain(input) {
-    return this.client.deployments.createDomain(this.data.id, input);
+    return this.client.publications.createDomain(this.data.id, input);
   }
   refreshDomain(domainId) {
-    return this.client.deployments.refreshDomain(this.data.id, domainId);
+    return this.client.publications.refreshDomain(this.data.id, domainId);
   }
   deleteDomain(domainId) {
-    return this.client.deployments.deleteDomain(this.data.id, domainId);
+    return this.client.publications.deleteDomain(this.data.id, domainId);
   }
 };
-function deploymentStatusIsTerminal(status) {
+function publicationStatusIsTerminal(status) {
   return ["healthy", "failed", "stopped", "deleted", "delete_failed"].includes(status);
 }
 function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function unwrapDeploymentDomainCollection(input) {
+function unwrapPublicationDomainCollection(input) {
   if (Array.isArray(input)) {
     return input;
   }
   return Array.isArray(input.data) ? input.data : [];
 }
-var AsyncDeployEventQueue = class {
+var AsyncPublishEventQueue = class {
   constructor() {
     this.values = [];
     this.pending = [];
@@ -19657,7 +19183,7 @@ var AsyncDeployEventQueue = class {
     });
   }
 };
-async function* readDeployStreamEvents(stream) {
+async function* readPublishStreamEvents(stream) {
   const reader = parseSSEStream(stream).getReader();
   try {
     while (true) {
@@ -19665,7 +19191,7 @@ async function* readDeployStreamEvents(stream) {
       if (done) {
         return;
       }
-      const event = parseDeployStreamEvent(value);
+      const event = parsePublishStreamEvent(value);
       if (event) {
         yield event;
       }
@@ -19674,11 +19200,11 @@ async function* readDeployStreamEvents(stream) {
     reader.releaseLock();
   }
 }
-function parseDeployStreamEvent(event) {
-  if (!DeployStreamSseEventNameSchema.safeParse(event.event).success) {
+function parsePublishStreamEvent(event) {
+  if (!PublishStreamSseEventNameSchema.safeParse(event.event).success) {
     return null;
   }
-  return DeployStreamSseEventSchema.parse(event);
+  return PublishStreamSseEventSchema.parse(event);
 }
 function parseSSEStream(input) {
   const decoder = new TextDecoder();
@@ -19819,6 +19345,7 @@ var restActionRoutes = {
   "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" },
@@ -19844,10 +19371,6 @@ var restActionRoutes = {
   "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" },
@@ -20087,11 +19610,11 @@ var NotebookApi = class {
     this.composerCredentials = new NotebookComposerCredentialApi(client);
     this.preview = new NotebookPreviewApi(client);
     this.mail = new NotebookMailApi(client);
-    this.deployment = new NotebookDeploymentApi(client);
+    this.publication = new NotebookPublicationApi(client);
   }
   async create(template, input = {}, init = true) {
     const response = await this.client.post("/notebook", { template, ...input });
-    const instance = new NotebookInstance2(response.data, this.client);
+    const instance = new NotebookInstance(response.data, this.client);
     if (!init) {
       return instance;
     }
@@ -20099,29 +19622,25 @@ var NotebookApi = class {
   }
   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();
@@ -20136,11 +19655,11 @@ function normalizeApiBaseUrl(url2) {
   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);
@@ -20220,7 +19739,7 @@ var Client2 = class {
     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);
   }
@@ -20328,7 +19847,7 @@ var NotebookMailApi = class {
   }
 };
 var _initPromise, _NotebookInstance_instances, init_fn;
-var NotebookInstance2 = class {
+var NotebookInstance = class {
   constructor(data, client) {
     this.data = data;
     this.client = client;
@@ -20363,18 +19882,20 @@ var NotebookInstance2 = class {
       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);
@@ -20406,17 +19927,29 @@ var NotebookInstance2 = class {
   fork(input = {}) {
     return this.client.notebook.fork(this.data.id, input);
   }
-  deployment() {
-    return this.client.notebook.deployment.current(this.data.id);
+  publication() {
+    return this.client.notebook.publication.current(this.data.id);
   }
   publish(input) {
-    return this.client.notebook.deployment.publish(this.data.id, input);
+    return this.client.notebook.publication.publish(this.data.id, input);
+  }
+  run(command, argsOrOpts = [], opts) {
+    if (Array.isArray(argsOrOpts)) {
+      return this.shell.run(command, argsOrOpts, opts);
+    }
+    return this.shell.run(command, argsOrOpts);
+  }
+  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 }));
     });
   }
@@ -20502,9 +20035,6 @@ var NotebookInstance2 = class {
     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");
@@ -20563,11 +20093,6 @@ var NotebookInstance2 = class {
     __privateMethod(this, _NotebookInstance_instances, init_fn).call(this);
     return this.ready().then(() => this);
   }
-  async beacon(iframe, options) {
-    const result = await this.ready();
-    iframe.src = result.data.previewUrl;
-    return createBeacon(iframe, options);
-  }
   realtimeSocket() {
     if (this.socket === null) {
       throw new UnsupportedRuntimeTransportError("This operation requires the realtime transport.");
@@ -20686,44 +20211,9 @@ function formatQueryString(params) {
 }
 export {
   ApiError,
-  Beacon,
-  BeaconConnectionError,
-  BeaconError,
-  BeaconTimeoutError,
-  Client2 as Client,
+  Client,
   CommandError,
   ComposerCredentials,
-  DeployStreamErrorSchema,
-  DeployStreamEventSchema,
-  DeployStreamLogEventSchema,
-  DeployStreamLogSchema,
-  DeployStreamLogStreamSchema,
-  DeployStreamPhaseEventSchema,
-  DeployStreamPhaseSchema,
-  DeployStreamResultEventSchema,
-  DeployStreamResultSchema,
-  DeployStreamSseDoneEventSchema,
-  DeployStreamSseErrorEventSchema,
-  DeployStreamSseEventNameSchema,
-  DeployStreamSseEventSchema,
-  DeployStreamSseLogEventSchema,
-  DeployStreamSsePhaseEventSchema,
-  DeployStreamSseResultEventSchema,
-  DeploymentApi,
-  DeploymentBuildStatusSchema,
-  DeploymentDomainDnsRecordTypeSchema,
-  DeploymentEventDataSchema,
-  DeploymentInstance,
-  DeploymentJurisdictionSchema,
-  DeploymentLogChunkDataSchema,
-  DeploymentLogStreamSchema,
-  DeploymentProtectionModeSchema,
-  DeploymentRegionSchema,
-  DeploymentReleaseStatusSchema,
-  DeploymentRun,
-  DeploymentSizeSchema,
-  DeploymentStatusSchema,
-  DeploymentTargetProviderSchema,
   ErrorEvent,
   FileChangeFilter,
   FileChangeType,
@@ -20732,35 +20222,67 @@ export {
   FilesystemError,
   FilesystemErrorType,
   LspConnection,
-  Navigator,
   NotebookApi,
   NotebookComposerCredentialApi,
-  NotebookDeploymentApi,
   NotebookInitError,
-  NotebookInstance2 as NotebookInstance,
+  NotebookInstance,
   NotebookMail,
   NotebookMailApi,
   NotebookPreview,
   NotebookPreviewApi,
+  NotebookPublicationApi,
   NotebookSecretApi,
   NotebookSecrets,
   NotebookState,
   NotebookUnavailableError,
   PHPSandbox,
   PHPSandboxError,
+  ProcessReadable,
+  ProcessResult,
   PromiseTimeoutError,
+  PublicationApi,
+  PublicationBuildStatusSchema,
+  PublicationDomainDnsRecordTypeSchema,
+  PublicationEventDataSchema,
+  PublicationInstance,
+  PublicationJurisdictionSchema,
+  PublicationLogChunkDataSchema,
+  PublicationLogStreamSchema,
+  PublicationProtectionModeSchema,
+  PublicationProviderNameSchema,
+  PublicationRegionSchema,
+  PublicationReleaseStatusSchema,
+  PublicationRun,
+  PublicationSizeSchema,
+  PublicationStatusSchema,
+  PublishStreamErrorSchema,
+  PublishStreamEventSchema,
+  PublishStreamLogEventSchema,
+  PublishStreamLogSchema,
+  PublishStreamLogStreamSchema,
+  PublishStreamPhaseEventSchema,
+  PublishStreamPhaseSchema,
+  PublishStreamResultEventSchema,
+  PublishStreamResultSchema,
+  PublishStreamSseDoneEventSchema,
+  PublishStreamSseErrorEventSchema,
+  PublishStreamSseEventNameSchema,
+  PublishStreamSseEventSchema,
+  PublishStreamSseLogEventSchema,
+  PublishStreamSsePhaseEventSchema,
+  PublishStreamSseResultEventSchema,
   RateLimitError,
+  RuntimeTelemetry,
   SendTimeoutError,
   ServerApi,
   ServerInstance,
-  Transport,
+  ShellProcess,
   UnsupportedRuntimeTransportError,
-  createBeacon,
-  isBeaconSupported,
   notebookBuiltinServices,
   notebookKnownServices,
   once,
-  timeout
+  timeout,
+  watchRuntimeTelemetry
 };
 /*! Bundled license information: