@phpsandbox/sdk 0.0.2

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

@@ -0,0 +1,4755 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// node_modules/retry/lib/retry_operation.js
+var require_retry_operation = __commonJS({
+  "node_modules/retry/lib/retry_operation.js"(exports, module) {
+    function RetryOperation(timeouts, options) {
+      if (typeof options === "boolean") {
+        options = { forever: options };
+      }
+      this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
+      this._timeouts = timeouts;
+      this._options = options || {};
+      this._maxRetryTime = options && options.maxRetryTime || Infinity;
+      this._fn = null;
+      this._errors = [];
+      this._attempts = 1;
+      this._operationTimeout = null;
+      this._operationTimeoutCb = null;
+      this._timeout = null;
+      this._operationStart = null;
+      this._timer = null;
+      if (this._options.forever) {
+        this._cachedTimeouts = this._timeouts.slice(0);
+      }
+    }
+    module.exports = RetryOperation;
+    RetryOperation.prototype.reset = function() {
+      this._attempts = 1;
+      this._timeouts = this._originalTimeouts.slice(0);
+    };
+    RetryOperation.prototype.stop = function() {
+      if (this._timeout) {
+        clearTimeout(this._timeout);
+      }
+      if (this._timer) {
+        clearTimeout(this._timer);
+      }
+      this._timeouts = [];
+      this._cachedTimeouts = null;
+    };
+    RetryOperation.prototype.retry = function(err) {
+      if (this._timeout) {
+        clearTimeout(this._timeout);
+      }
+      if (!err) {
+        return false;
+      }
+      var currentTime = (/* @__PURE__ */ new Date()).getTime();
+      if (err && currentTime - this._operationStart >= this._maxRetryTime) {
+        this._errors.push(err);
+        this._errors.unshift(new Error("RetryOperation timeout occurred"));
+        return false;
+      }
+      this._errors.push(err);
+      var timeout2 = this._timeouts.shift();
+      if (timeout2 === void 0) {
+        if (this._cachedTimeouts) {
+          this._errors.splice(0, this._errors.length - 1);
+          timeout2 = this._cachedTimeouts.slice(-1);
+        } else {
+          return false;
+        }
+      }
+      var self2 = this;
+      this._timer = setTimeout(function() {
+        self2._attempts++;
+        if (self2._operationTimeoutCb) {
+          self2._timeout = setTimeout(function() {
+            self2._operationTimeoutCb(self2._attempts);
+          }, self2._operationTimeout);
+          if (self2._options.unref) {
+            self2._timeout.unref();
+          }
+        }
+        self2._fn(self2._attempts);
+      }, timeout2);
+      if (this._options.unref) {
+        this._timer.unref();
+      }
+      return true;
+    };
+    RetryOperation.prototype.attempt = function(fn, timeoutOps) {
+      this._fn = fn;
+      if (timeoutOps) {
+        if (timeoutOps.timeout) {
+          this._operationTimeout = timeoutOps.timeout;
+        }
+        if (timeoutOps.cb) {
+          this._operationTimeoutCb = timeoutOps.cb;
+        }
+      }
+      var self2 = this;
+      if (this._operationTimeoutCb) {
+        this._timeout = setTimeout(function() {
+          self2._operationTimeoutCb();
+        }, self2._operationTimeout);
+      }
+      this._operationStart = (/* @__PURE__ */ new Date()).getTime();
+      this._fn(this._attempts);
+    };
+    RetryOperation.prototype.try = function(fn) {
+      console.log("Using RetryOperation.try() is deprecated");
+      this.attempt(fn);
+    };
+    RetryOperation.prototype.start = function(fn) {
+      console.log("Using RetryOperation.start() is deprecated");
+      this.attempt(fn);
+    };
+    RetryOperation.prototype.start = RetryOperation.prototype.try;
+    RetryOperation.prototype.errors = function() {
+      return this._errors;
+    };
+    RetryOperation.prototype.attempts = function() {
+      return this._attempts;
+    };
+    RetryOperation.prototype.mainError = function() {
+      if (this._errors.length === 0) {
+        return null;
+      }
+      var counts = {};
+      var mainError = null;
+      var mainErrorCount = 0;
+      for (var i = 0; i < this._errors.length; i++) {
+        var error = this._errors[i];
+        var message = error.message;
+        var count = (counts[message] || 0) + 1;
+        counts[message] = count;
+        if (count >= mainErrorCount) {
+          mainError = error;
+          mainErrorCount = count;
+        }
+      }
+      return mainError;
+    };
+  }
+});
+
+// node_modules/retry/lib/retry.js
+var require_retry = __commonJS({
+  "node_modules/retry/lib/retry.js"(exports) {
+    var RetryOperation = require_retry_operation();
+    exports.operation = function(options) {
+      var timeouts = exports.timeouts(options);
+      return new RetryOperation(timeouts, {
+        forever: options && (options.forever || options.retries === Infinity),
+        unref: options && options.unref,
+        maxRetryTime: options && options.maxRetryTime
+      });
+    };
+    exports.timeouts = function(options) {
+      if (options instanceof Array) {
+        return [].concat(options);
+      }
+      var opts = {
+        retries: 10,
+        factor: 2,
+        minTimeout: 1 * 1e3,
+        maxTimeout: Infinity,
+        randomize: false
+      };
+      for (var key in options) {
+        opts[key] = options[key];
+      }
+      if (opts.minTimeout > opts.maxTimeout) {
+        throw new Error("minTimeout is greater than maxTimeout");
+      }
+      var timeouts = [];
+      for (var i = 0; i < opts.retries; i++) {
+        timeouts.push(this.createTimeout(i, opts));
+      }
+      if (options && options.forever && !timeouts.length) {
+        timeouts.push(this.createTimeout(i, opts));
+      }
+      timeouts.sort(function(a, b) {
+        return a - b;
+      });
+      return timeouts;
+    };
+    exports.createTimeout = function(attempt, opts) {
+      var random = opts.randomize ? Math.random() + 1 : 1;
+      var timeout2 = Math.round(random * Math.max(opts.minTimeout, 1) * Math.pow(opts.factor, attempt));
+      timeout2 = Math.min(timeout2, opts.maxTimeout);
+      return timeout2;
+    };
+    exports.wrap = function(obj, options, methods) {
+      if (options instanceof Array) {
+        methods = options;
+        options = null;
+      }
+      if (!methods) {
+        methods = [];
+        for (var key in obj) {
+          if (typeof obj[key] === "function") {
+            methods.push(key);
+          }
+        }
+      }
+      for (var i = 0; i < methods.length; i++) {
+        var method = methods[i];
+        var original = obj[method];
+        obj[method] = function retryWrapper(original2) {
+          var op = exports.operation(options);
+          var args = Array.prototype.slice.call(arguments, 1);
+          var callback = args.pop();
+          args.push(function(err) {
+            if (op.retry(err)) {
+              return;
+            }
+            if (err) {
+              arguments[0] = op.mainError();
+            }
+            callback.apply(this, arguments);
+          });
+          op.attempt(function() {
+            original2.apply(obj, args);
+          });
+        }.bind(obj, original);
+        obj[method].options = options;
+      }
+    };
+  }
+});
+
+// node_modules/retry/index.js
+var require_retry2 = __commonJS({
+  "node_modules/retry/index.js"(exports, module) {
+    module.exports = require_retry();
+  }
+});
+
+// node_modules/async-retry/lib/index.js
+var require_lib = __commonJS({
+  "node_modules/async-retry/lib/index.js"(exports, module) {
+    var retrier = require_retry2();
+    function retry3(fn, opts) {
+      function run(resolve, reject) {
+        var options = opts || {};
+        var op;
+        if (!("randomize" in options)) {
+          options.randomize = true;
+        }
+        op = retrier.operation(options);
+        function bail(err) {
+          reject(err || new Error("Aborted"));
+        }
+        function onError(err, num) {
+          if (err.bail) {
+            bail(err);
+            return;
+          }
+          if (!op.retry(err)) {
+            reject(op.mainError());
+          } else if (options.onRetry) {
+            options.onRetry(err, num);
+          }
+        }
+        function runAttempt(num) {
+          var val;
+          try {
+            val = fn(bail, num);
+          } catch (err) {
+            onError(err, num);
+            return;
+          }
+          Promise.resolve(val).then(resolve).catch(function catchIt(err) {
+            onError(err, num);
+          });
+        }
+        op.attempt(runAttempt);
+      }
+      return new Promise(run);
+    }
+    module.exports = retry3;
+  }
+});
+
+// src/types.ts
+var ErrorEvent = class extends Error {
+  constructor(code, message, raw = {}) {
+    super(message);
+    this.code = code;
+    this.message = message;
+    this.raw = raw;
+  }
+};
+var RateLimitError = class extends ErrorEvent {
+  constructor(message, raw = {}) {
+    super(429, message, raw);
+  }
+};
+var PHPSandboxError = class extends ErrorEvent {
+};
+
+// node_modules/nanoid/url-alphabet/index.js
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+
+// node_modules/nanoid/index.browser.js
+var nanoid = (size = 21) => {
+  let id = "";
+  let bytes = crypto.getRandomValues(new Uint8Array(size |= 0));
+  while (size--) {
+    id += urlAlphabet[bytes[size] & 63];
+  }
+  return id;
+};
+
+// src/filesystem.ts
+var FileType = /* @__PURE__ */ ((FileType2) => {
+  FileType2[FileType2["Unknown"] = 0] = "Unknown";
+  FileType2[FileType2["File"] = 1] = "File";
+  FileType2[FileType2["Directory"] = 2] = "Directory";
+  FileType2[FileType2["SymbolicLink"] = 64] = "SymbolicLink";
+  return FileType2;
+})(FileType || {});
+var FileChangeType = /* @__PURE__ */ ((FileChangeType2) => {
+  FileChangeType2[FileChangeType2["UPDATED"] = 1] = "UPDATED";
+  FileChangeType2[FileChangeType2["ADDED"] = 2] = "ADDED";
+  FileChangeType2[FileChangeType2["DELETED"] = 3] = "DELETED";
+  return FileChangeType2;
+})(FileChangeType || {});
+var FilesystemErrorType = /* @__PURE__ */ ((FilesystemErrorType2) => {
+  FilesystemErrorType2["Unavailable"] = "Unavailable";
+  FilesystemErrorType2["NoPermissions"] = "NoPermissions";
+  FilesystemErrorType2["FileExists"] = "FileExists";
+  FilesystemErrorType2["FileNotFound"] = "FileNotFound";
+  FilesystemErrorType2["FileIsADirectory"] = "FileIsADirectory";
+  FilesystemErrorType2["FileNotADirectory"] = "FileNotADirectory";
+  return FilesystemErrorType2;
+})(FilesystemErrorType || {});
+var FilesystemError = class extends ErrorEvent {
+  constructor(inner, name) {
+    super(inner.code, inner.message);
+    this.name = name;
+  }
+};
+var FilesystemSubscription = class {
+  constructor(path, okra, disposable) {
+    this.path = path;
+    this.okra = okra;
+    this.disposable = disposable;
+  }
+  dispose() {
+    this.okra.invoke("fs.unwatch", { path: this.path });
+    this.disposable.dispose();
+  }
+};
+var Filesystem = class {
+  constructor(okra) {
+    this.okra = okra;
+    this.watches = /* @__PURE__ */ new Map();
+    this.watchOkraConnection();
+  }
+  watchOkraConnection() {
+    this.okra.onDidConnect(() => {
+      for (const { path, options, onDidChange } of this.watches.values()) {
+        this.watch(path, options, onDidChange);
+      }
+    });
+  }
+  info(path) {
+    return this.okra.invoke("fs.info", { path });
+  }
+  write(path, contents) {
+    return this.okra.invoke("fs.write", { path, contents });
+  }
+  find(query, options = {
+    useIgnoreFiles: false,
+    followSymlinks: false,
+    useGlobalIgnoreFiles: false,
+    useParentIgnoreFiles: false
+  }) {
+    return this.okra.invoke("fs.find", {
+      query,
+      options: Object.assign(options, {
+        includes: [],
+        excludes: [
+          "**/storage",
+          "**/vendor",
+          "**/node_modules",
+          "**/.git",
+          "**/.svn",
+          "**/.hg",
+          "**/CVS",
+          "**/.DS_Store",
+          "**/Thumbs.db",
+          "**/*.crswap"
+        ],
+        useIgnoreFiles: false,
+        followSymlinks: false,
+        useGlobalIgnoreFiles: false,
+        useParentIgnoreFiles: false
+      })
+    });
+  }
+  search(query, options, onMatch) {
+    if (!query.id) {
+      query.id = nanoid();
+    }
+    const defaultOptions = {
+      maxResults: 5,
+      afterContext: 2,
+      beforeContext: 2,
+      includes: [],
+      excludes: [
+        "**/.git",
+        "**/.svn",
+        "**/.hg",
+        "**/CVS",
+        "**/.DS_Store",
+        "**/Thumbs.db",
+        "**/*.crswap",
+        "**/node_modules",
+        "**/vendor",
+        "**/bower_components",
+        "**/*.code-search"
+      ],
+      useIgnoreFiles: true,
+      followSymlinks: true,
+      useGlobalIgnoreFiles: true,
+      useParentIgnoreFiles: true,
+      encoding: "utf-8",
+      previewOptions: {
+        matchLines: 5,
+        charsPerLine: 1e3
+      }
+    };
+    const sid = query.id;
+    const localOnMatch = async (result) => {
+      if (result === false) {
+        disposable.dispose();
+      }
+      if (onMatch) {
+        const ret = await Promise.resolve(onMatch(result));
+        if (ret === false) {
+          disposable.dispose();
+        }
+      }
+    };
+    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));
+  }
+  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));
+  }
+  delete(path, options) {
+    return this.okra.invoke("fs.delete", { path, options }).catch((e) => this.handleError(e));
+  }
+  copy(source, destination, options) {
+    return this.okra.invoke("fs.copy", { source, destination, options }).catch((e) => this.handleError(e));
+  }
+  readDirectory(path, include = [], exclude = []) {
+    return this.okra.invoke("fs.readDirectory", { path, include, exclude }).catch((e) => this.handleError(e));
+  }
+  createDirectory(path) {
+    return this.okra.invoke("fs.createDirectory", { path }).catch((e) => this.handleError(e));
+  }
+  watch(path, options, onDidChange) {
+    const disposable = this.okra.listen(`fs.watch.${path}`, onDidChange);
+    const wrappedDisposable = {
+      dispose: () => {
+        disposable.dispose();
+        this.okra.invoke("fs.unwatch", { path });
+      }
+    };
+    const subscription = new FilesystemSubscription(path, this.okra, wrappedDisposable);
+    this.watches.set(path, { options, path, onDidChange });
+    this.okra.invoke("fs.watch", { path, options });
+    return subscription;
+  }
+  exists(path) {
+    return this.stat(path).then(() => true).catch(() => false);
+  }
+  async download(chunk, exclude, include) {
+    const id = nanoid();
+    const stream = !!chunk;
+    const chunks = [];
+    this.okra.listen(
+      `fs.download.${id}`,
+      stream ? chunk : (data) => {
+        chunks.push(data);
+      }
+    );
+    return this.okra.invoke("fs.download", { id, exclude, include }).then(() => new Blob(chunks, { type: "application/octet-stream" }));
+  }
+  tree(path = "/") {
+    return this.okra.invoke("fs.tree", { path });
+  }
+  handleError(e) {
+    if (e instanceof ErrorEvent && "name" in e.raw) {
+      throw new FilesystemError(e, e.raw.name);
+    }
+    throw e;
+  }
+};
+
+// src/terminal.ts
+var Terminal = 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) {
+    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) {
+    this.okra.listen(`terminal.output.${id}`, handler);
+  }
+  input(id, input) {
+    return this.okra.invoke("terminal.input", { id, input });
+  }
+  listen(event, handler) {
+    return this.okra.listen(event, handler);
+  }
+  async spawn(command, args, opts) {
+    const id = opts?.id || nanoid();
+    const disposables = /* @__PURE__ */ new Set();
+    const dispose = () => {
+      for (const disposable of disposables) {
+        disposable.dispose();
+      }
+      disposables.clear();
+    };
+    const input = new WritableStream({
+      write: (chunk) => {
+        this.input(id, chunk);
+      },
+      close: dispose
+    });
+    const output = new ReadableStream({
+      start: (controller) => {
+        disposables.add(
+          this.listen(`terminal.output.${id}`, (data) => {
+            controller.enqueue(data.output);
+          })
+        );
+      },
+      cancel: dispose
+    });
+    const exit = new Promise((resolve) => {
+      disposables.add(
+        this.listen(`terminal.close.${id}`, (data) => {
+          dispose();
+          resolve(data.exitCode);
+        })
+      );
+    });
+    const kill = () => {
+      dispose();
+      return this.okra.invoke("terminal.close", { id });
+    };
+    const resize = (dimensions) => {
+      this.okra.invoke("terminal.resize", { id, width: dimensions.cols, height: dimensions.rows });
+    };
+    const { abortSignal, ...otherOpts } = opts ?? {};
+    if (abortSignal) {
+      abortSignal.addEventListener("abort", kill);
+    }
+    const result = await this.okra.invoke(
+      "terminal.spawn",
+      {
+        command: [command, ...args],
+        opts: {
+          id,
+          ...otherOpts
+        }
+      },
+      { abortSignal }
+    );
+    return {
+      exit,
+      input,
+      output,
+      kill,
+      resize,
+      ...result
+    };
+  }
+};
+
+// src/container.ts
+var NotebookState = /* @__PURE__ */ ((NotebookState2) => {
+  NotebookState2["RUNNING"] = "running";
+  NotebookState2["STOPPED"] = "stopped";
+  NotebookState2["STARTING"] = "starting";
+  NotebookState2["STOPPING"] = "stopping";
+  NotebookState2["KILLED"] = "killed";
+  NotebookState2["ERROR"] = "error";
+  NotebookState2["PROVISIONING"] = "provisioning";
+  return NotebookState2;
+})(NotebookState || {});
+var Container = class {
+  constructor(okra) {
+    this.okra = okra;
+  }
+  start() {
+    return this.okra.invoke("container.start");
+  }
+  stop() {
+    return this.okra.invoke("container.stop");
+  }
+  state() {
+    return this.okra.invoke("container.state");
+  }
+  openedPorts() {
+    return this.okra.invoke("container.opened-ports");
+  }
+  setPhp(version) {
+    return this.okra.invoke("container.set-php", { version });
+  }
+  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
+var Auth = class {
+  constructor(okra) {
+    this.okra = okra;
+  }
+  logout() {
+    return this.okra.invoke("auth.logout");
+  }
+  login(newConnectionData) {
+    return this.okra.invoke("auth.login", { newConnectionData });
+  }
+};
+
+// src/lsp.ts
+var Lsp = class {
+  constructor(okra) {
+    this.okra = okra;
+  }
+  message(id, message) {
+    return this.okra.invoke("lsp.message", { id, message });
+  }
+  listen(id, event, cb) {
+    this.okra.listen(`${event}.${id}`, (e) => cb(e));
+  }
+  onClose(id, cb) {
+    this.listen(id, "lsp.closed", (e) => cb(e.code, e.reason));
+  }
+  onError(id, cb) {
+    this.listen(id, "lsp.error", (e) => cb(e.message));
+  }
+  onClientDisconnect(cb) {
+    this.okra.onDidDisconnect(() => cb(1e3, "OKRA DISCONNECTED"));
+  }
+  onResponse(id, cb) {
+    this.listen(id, "lsp.response", (e) => cb(JSON.stringify(e)));
+  }
+  close(id) {
+    return this.okra.invoke("lsp.close", { id });
+  }
+  start(id) {
+    return this.okra.invoke("lsp.start", { id });
+  }
+  connection(id) {
+    return LspConnection.create(id, this);
+  }
+  whenSocketConnected() {
+    return this.okra.whenConnected();
+  }
+};
+var LspConnection = class _LspConnection {
+  constructor(id, lsp) {
+    this.id = id;
+    this.lsp = lsp;
+  }
+  send(content) {
+    return this.lsp.message(this.id, content);
+  }
+  onMessage(cb) {
+    this.lsp.onResponse(this.id, cb);
+  }
+  onError(cb) {
+    this.lsp.onError(this.id, cb);
+  }
+  onClose(cb) {
+    this.lsp.onClose(this.id, cb);
+  }
+  dispose() {
+    this.lsp.close(this.id);
+  }
+  start() {
+    this.lsp.start(this.id);
+  }
+  onClientDisconnect(cb) {
+    this.lsp.onClientDisconnect(cb);
+  }
+  whenSocketConnected() {
+    return this.lsp.whenSocketConnected();
+  }
+  static create(id, lsp) {
+    return new _LspConnection(id, lsp);
+  }
+};
+
+// src/composer.ts
+var Composer = class {
+  constructor(okra) {
+    this.okra = okra;
+  }
+  invoke(command, args = {}, options = {}) {
+    return this.okra.invoke("composer.invoke", { command, args, options });
+  }
+  dumpAutoload() {
+    return this.okra.invoke("composer.dump-autoload");
+  }
+  install(options = {}) {
+    return this.invoke("install", {}, options);
+  }
+  update(args, options = {}) {
+    return this.invoke("update", args, options);
+  }
+  require(packages, options = {}) {
+    return this.invoke("require", packages, options);
+  }
+  remove(args, options = {}) {
+    return this.invoke("remove", args, options);
+  }
+  stream(fn) {
+    return this.okra.listen("composer.log", fn);
+  }
+  packages() {
+    return this.okra.invoke("composer.packages");
+  }
+};
+
+// src/log.ts
+var Log = class {
+  constructor(okra) {
+    this.okra = okra;
+  }
+  stream(fn) {
+    return this.okra.listen("notebook.log", fn);
+  }
+  listen(event, handler) {
+    this.okra.listen(event, handler);
+  }
+};
+
+// src/laravel.ts
+var Lravel = class {
+  constructor(okra) {
+    this.okra = okra;
+  }
+  maintenanceInfo() {
+    return this.okra.invoke("laravel.maintenance.info", {});
+  }
+  toggleMaintenance(down) {
+    return this.okra.invoke("laravel.maintenance.toggle", down);
+  }
+};
+
+// src/repl.ts
+var Repl = class {
+  constructor(okra) {
+    this.okra = okra;
+  }
+  eval(code, args = "", repl = { prependWith: "", appendWith: "" }) {
+    return this.okra.invoke("repl.eval", { code, args, repl });
+  }
+  write(input) {
+    return this.okra.invoke("repl.write", { input });
+  }
+  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 });
+  }
+  listen(event, handler) {
+    this.okra.listen(event, handler);
+  }
+  onOutput(handler) {
+    this.okra.listen("repl.output", handler);
+  }
+};
+
+// src/shell.ts
+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;
+  }
+  async exec(command) {
+    const result = await this.okra.invoke("shell.exec", { command });
+    return new Result(result.output, result.exitCode);
+  }
+};
+
+// node_modules/@msgpack/msgpack/dist.esm/utils/utf8.mjs
+function utf8Count(str) {
+  const strLength = str.length;
+  let byteLength = 0;
+  let pos = 0;
+  while (pos < strLength) {
+    let value = str.charCodeAt(pos++);
+    if ((value & 4294967168) === 0) {
+      byteLength++;
+      continue;
+    } else if ((value & 4294965248) === 0) {
+      byteLength += 2;
+    } else {
+      if (value >= 55296 && value <= 56319) {
+        if (pos < strLength) {
+          const extra = str.charCodeAt(pos);
+          if ((extra & 64512) === 56320) {
+            ++pos;
+            value = ((value & 1023) << 10) + (extra & 1023) + 65536;
+          }
+        }
+      }
+      if ((value & 4294901760) === 0) {
+        byteLength += 3;
+      } else {
+        byteLength += 4;
+      }
+    }
+  }
+  return byteLength;
+}
+function utf8EncodeJs(str, output, outputOffset) {
+  const strLength = str.length;
+  let offset = outputOffset;
+  let pos = 0;
+  while (pos < strLength) {
+    let value = str.charCodeAt(pos++);
+    if ((value & 4294967168) === 0) {
+      output[offset++] = value;
+      continue;
+    } else if ((value & 4294965248) === 0) {
+      output[offset++] = value >> 6 & 31 | 192;
+    } else {
+      if (value >= 55296 && value <= 56319) {
+        if (pos < strLength) {
+          const extra = str.charCodeAt(pos);
+          if ((extra & 64512) === 56320) {
+            ++pos;
+            value = ((value & 1023) << 10) + (extra & 1023) + 65536;
+          }
+        }
+      }
+      if ((value & 4294901760) === 0) {
+        output[offset++] = value >> 12 & 15 | 224;
+        output[offset++] = value >> 6 & 63 | 128;
+      } else {
+        output[offset++] = value >> 18 & 7 | 240;
+        output[offset++] = value >> 12 & 63 | 128;
+        output[offset++] = value >> 6 & 63 | 128;
+      }
+    }
+    output[offset++] = value & 63 | 128;
+  }
+}
+var sharedTextEncoder = new TextEncoder();
+var TEXT_ENCODER_THRESHOLD = 50;
+function utf8EncodeTE(str, output, outputOffset) {
+  sharedTextEncoder.encodeInto(str, output.subarray(outputOffset));
+}
+function utf8Encode(str, output, outputOffset) {
+  if (str.length > TEXT_ENCODER_THRESHOLD) {
+    utf8EncodeTE(str, output, outputOffset);
+  } else {
+    utf8EncodeJs(str, output, outputOffset);
+  }
+}
+var CHUNK_SIZE = 4096;
+function utf8DecodeJs(bytes, inputOffset, byteLength) {
+  let offset = inputOffset;
+  const end = offset + byteLength;
+  const units = [];
+  let result = "";
+  while (offset < end) {
+    const byte1 = bytes[offset++];
+    if ((byte1 & 128) === 0) {
+      units.push(byte1);
+    } else if ((byte1 & 224) === 192) {
+      const byte2 = bytes[offset++] & 63;
+      units.push((byte1 & 31) << 6 | byte2);
+    } else if ((byte1 & 240) === 224) {
+      const byte2 = bytes[offset++] & 63;
+      const byte3 = bytes[offset++] & 63;
+      units.push((byte1 & 31) << 12 | byte2 << 6 | byte3);
+    } else if ((byte1 & 248) === 240) {
+      const byte2 = bytes[offset++] & 63;
+      const byte3 = bytes[offset++] & 63;
+      const byte4 = bytes[offset++] & 63;
+      let unit = (byte1 & 7) << 18 | byte2 << 12 | byte3 << 6 | byte4;
+      if (unit > 65535) {
+        unit -= 65536;
+        units.push(unit >>> 10 & 1023 | 55296);
+        unit = 56320 | unit & 1023;
+      }
+      units.push(unit);
+    } else {
+      units.push(byte1);
+    }
+    if (units.length >= CHUNK_SIZE) {
+      result += String.fromCharCode(...units);
+      units.length = 0;
+    }
+  }
+  if (units.length > 0) {
+    result += String.fromCharCode(...units);
+  }
+  return result;
+}
+var sharedTextDecoder = new TextDecoder();
+var TEXT_DECODER_THRESHOLD = 200;
+function utf8DecodeTD(bytes, inputOffset, byteLength) {
+  const stringBytes = bytes.subarray(inputOffset, inputOffset + byteLength);
+  return sharedTextDecoder.decode(stringBytes);
+}
+function utf8Decode(bytes, inputOffset, byteLength) {
+  if (byteLength > TEXT_DECODER_THRESHOLD) {
+    return utf8DecodeTD(bytes, inputOffset, byteLength);
+  } else {
+    return utf8DecodeJs(bytes, inputOffset, byteLength);
+  }
+}
+
+// node_modules/@msgpack/msgpack/dist.esm/ExtData.mjs
+var ExtData = class {
+  constructor(type, data) {
+    this.type = type;
+    this.data = data;
+  }
+};
+
+// node_modules/@msgpack/msgpack/dist.esm/DecodeError.mjs
+var DecodeError = class _DecodeError extends Error {
+  constructor(message) {
+    super(message);
+    const proto = Object.create(_DecodeError.prototype);
+    Object.setPrototypeOf(this, proto);
+    Object.defineProperty(this, "name", {
+      configurable: true,
+      enumerable: false,
+      value: _DecodeError.name
+    });
+  }
+};
+
+// node_modules/@msgpack/msgpack/dist.esm/utils/int.mjs
+var UINT32_MAX = 4294967295;
+function setUint64(view, offset, value) {
+  const high = value / 4294967296;
+  const low = value;
+  view.setUint32(offset, high);
+  view.setUint32(offset + 4, low);
+}
+function setInt64(view, offset, value) {
+  const high = Math.floor(value / 4294967296);
+  const low = value;
+  view.setUint32(offset, high);
+  view.setUint32(offset + 4, low);
+}
+function getInt64(view, offset) {
+  const high = view.getInt32(offset);
+  const low = view.getUint32(offset + 4);
+  return high * 4294967296 + low;
+}
+function getUint64(view, offset) {
+  const high = view.getUint32(offset);
+  const low = view.getUint32(offset + 4);
+  return high * 4294967296 + low;
+}
+
+// node_modules/@msgpack/msgpack/dist.esm/timestamp.mjs
+var EXT_TIMESTAMP = -1;
+var TIMESTAMP32_MAX_SEC = 4294967296 - 1;
+var TIMESTAMP64_MAX_SEC = 17179869184 - 1;
+function encodeTimeSpecToTimestamp({ sec, nsec }) {
+  if (sec >= 0 && nsec >= 0 && sec <= TIMESTAMP64_MAX_SEC) {
+    if (nsec === 0 && sec <= TIMESTAMP32_MAX_SEC) {
+      const rv = new Uint8Array(4);
+      const view = new DataView(rv.buffer);
+      view.setUint32(0, sec);
+      return rv;
+    } else {
+      const secHigh = sec / 4294967296;
+      const secLow = sec & 4294967295;
+      const rv = new Uint8Array(8);
+      const view = new DataView(rv.buffer);
+      view.setUint32(0, nsec << 2 | secHigh & 3);
+      view.setUint32(4, secLow);
+      return rv;
+    }
+  } else {
+    const rv = new Uint8Array(12);
+    const view = new DataView(rv.buffer);
+    view.setUint32(0, nsec);
+    setInt64(view, 4, sec);
+    return rv;
+  }
+}
+function encodeDateToTimeSpec(date) {
+  const msec = date.getTime();
+  const sec = Math.floor(msec / 1e3);
+  const nsec = (msec - sec * 1e3) * 1e6;
+  const nsecInSec = Math.floor(nsec / 1e9);
+  return {
+    sec: sec + nsecInSec,
+    nsec: nsec - nsecInSec * 1e9
+  };
+}
+function encodeTimestampExtension(object) {
+  if (object instanceof Date) {
+    const timeSpec = encodeDateToTimeSpec(object);
+    return encodeTimeSpecToTimestamp(timeSpec);
+  } else {
+    return null;
+  }
+}
+function decodeTimestampToTimeSpec(data) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  switch (data.byteLength) {
+    case 4: {
+      const sec = view.getUint32(0);
+      const nsec = 0;
+      return { sec, nsec };
+    }
+    case 8: {
+      const nsec30AndSecHigh2 = view.getUint32(0);
+      const secLow32 = view.getUint32(4);
+      const sec = (nsec30AndSecHigh2 & 3) * 4294967296 + secLow32;
+      const nsec = nsec30AndSecHigh2 >>> 2;
+      return { sec, nsec };
+    }
+    case 12: {
+      const sec = getInt64(view, 4);
+      const nsec = view.getUint32(0);
+      return { sec, nsec };
+    }
+    default:
+      throw new DecodeError(`Unrecognized data size for timestamp (expected 4, 8, or 12): ${data.length}`);
+  }
+}
+function decodeTimestampExtension(data) {
+  const timeSpec = decodeTimestampToTimeSpec(data);
+  return new Date(timeSpec.sec * 1e3 + timeSpec.nsec / 1e6);
+}
+var timestampExtension = {
+  type: EXT_TIMESTAMP,
+  encode: encodeTimestampExtension,
+  decode: decodeTimestampExtension
+};
+
+// node_modules/@msgpack/msgpack/dist.esm/ExtensionCodec.mjs
+var ExtensionCodec = class {
+  constructor() {
+    this.builtInEncoders = [];
+    this.builtInDecoders = [];
+    this.encoders = [];
+    this.decoders = [];
+    this.register(timestampExtension);
+  }
+  register({ type, encode: encode2, decode: decode2 }) {
+    if (type >= 0) {
+      this.encoders[type] = encode2;
+      this.decoders[type] = decode2;
+    } else {
+      const index = -1 - type;
+      this.builtInEncoders[index] = encode2;
+      this.builtInDecoders[index] = decode2;
+    }
+  }
+  tryToEncode(object, context) {
+    for (let i = 0; i < this.builtInEncoders.length; i++) {
+      const encodeExt = this.builtInEncoders[i];
+      if (encodeExt != null) {
+        const data = encodeExt(object, context);
+        if (data != null) {
+          const type = -1 - i;
+          return new ExtData(type, data);
+        }
+      }
+    }
+    for (let i = 0; i < this.encoders.length; i++) {
+      const encodeExt = this.encoders[i];
+      if (encodeExt != null) {
+        const data = encodeExt(object, context);
+        if (data != null) {
+          const type = i;
+          return new ExtData(type, data);
+        }
+      }
+    }
+    if (object instanceof ExtData) {
+      return object;
+    }
+    return null;
+  }
+  decode(data, type, context) {
+    const decodeExt = type < 0 ? this.builtInDecoders[-1 - type] : this.decoders[type];
+    if (decodeExt) {
+      return decodeExt(data, type, context);
+    } else {
+      return new ExtData(type, data);
+    }
+  }
+};
+ExtensionCodec.defaultCodec = new ExtensionCodec();
+
+// node_modules/@msgpack/msgpack/dist.esm/utils/typedArrays.mjs
+function isArrayBufferLike(buffer) {
+  return buffer instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && buffer instanceof SharedArrayBuffer;
+}
+function ensureUint8Array(buffer) {
+  if (buffer instanceof Uint8Array) {
+    return buffer;
+  } else if (ArrayBuffer.isView(buffer)) {
+    return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  } else if (isArrayBufferLike(buffer)) {
+    return new Uint8Array(buffer);
+  } else {
+    return Uint8Array.from(buffer);
+  }
+}
+
+// node_modules/@msgpack/msgpack/dist.esm/Encoder.mjs
+var DEFAULT_MAX_DEPTH = 100;
+var DEFAULT_INITIAL_BUFFER_SIZE = 2048;
+var Encoder = class _Encoder {
+  constructor(options) {
+    this.entered = false;
+    this.extensionCodec = options?.extensionCodec ?? ExtensionCodec.defaultCodec;
+    this.context = options?.context;
+    this.useBigInt64 = options?.useBigInt64 ?? false;
+    this.maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
+    this.initialBufferSize = options?.initialBufferSize ?? DEFAULT_INITIAL_BUFFER_SIZE;
+    this.sortKeys = options?.sortKeys ?? false;
+    this.forceFloat32 = options?.forceFloat32 ?? false;
+    this.ignoreUndefined = options?.ignoreUndefined ?? false;
+    this.forceIntegerToFloat = options?.forceIntegerToFloat ?? false;
+    this.pos = 0;
+    this.view = new DataView(new ArrayBuffer(this.initialBufferSize));
+    this.bytes = new Uint8Array(this.view.buffer);
+  }
+  clone() {
+    return new _Encoder({
+      extensionCodec: this.extensionCodec,
+      context: this.context,
+      useBigInt64: this.useBigInt64,
+      maxDepth: this.maxDepth,
+      initialBufferSize: this.initialBufferSize,
+      sortKeys: this.sortKeys,
+      forceFloat32: this.forceFloat32,
+      ignoreUndefined: this.ignoreUndefined,
+      forceIntegerToFloat: this.forceIntegerToFloat
+    });
+  }
+  reinitializeState() {
+    this.pos = 0;
+  }
+  /**
+   * This is almost equivalent to {@link Encoder#encode}, but it returns an reference of the encoder's internal buffer and thus much faster than {@link Encoder#encode}.
+   *
+   * @returns Encodes the object and returns a shared reference the encoder's internal buffer.
+   */
+  encodeSharedRef(object) {
+    if (this.entered) {
+      const instance = this.clone();
+      return instance.encodeSharedRef(object);
+    }
+    try {
+      this.entered = true;
+      this.reinitializeState();
+      this.doEncode(object, 1);
+      return this.bytes.subarray(0, this.pos);
+    } finally {
+      this.entered = false;
+    }
+  }
+  /**
+   * @returns Encodes the object and returns a copy of the encoder's internal buffer.
+   */
+  encode(object) {
+    if (this.entered) {
+      const instance = this.clone();
+      return instance.encode(object);
+    }
+    try {
+      this.entered = true;
+      this.reinitializeState();
+      this.doEncode(object, 1);
+      return this.bytes.slice(0, this.pos);
+    } finally {
+      this.entered = false;
+    }
+  }
+  doEncode(object, depth) {
+    if (depth > this.maxDepth) {
+      throw new Error(`Too deep objects in depth ${depth}`);
+    }
+    if (object == null) {
+      this.encodeNil();
+    } else if (typeof object === "boolean") {
+      this.encodeBoolean(object);
+    } else if (typeof object === "number") {
+      if (!this.forceIntegerToFloat) {
+        this.encodeNumber(object);
+      } else {
+        this.encodeNumberAsFloat(object);
+      }
+    } else if (typeof object === "string") {
+      this.encodeString(object);
+    } else if (this.useBigInt64 && typeof object === "bigint") {
+      this.encodeBigInt64(object);
+    } else {
+      this.encodeObject(object, depth);
+    }
+  }
+  ensureBufferSizeToWrite(sizeToWrite) {
+    const requiredSize = this.pos + sizeToWrite;
+    if (this.view.byteLength < requiredSize) {
+      this.resizeBuffer(requiredSize * 2);
+    }
+  }
+  resizeBuffer(newSize) {
+    const newBuffer = new ArrayBuffer(newSize);
+    const newBytes = new Uint8Array(newBuffer);
+    const newView = new DataView(newBuffer);
+    newBytes.set(this.bytes);
+    this.view = newView;
+    this.bytes = newBytes;
+  }
+  encodeNil() {
+    this.writeU8(192);
+  }
+  encodeBoolean(object) {
+    if (object === false) {
+      this.writeU8(194);
+    } else {
+      this.writeU8(195);
+    }
+  }
+  encodeNumber(object) {
+    if (!this.forceIntegerToFloat && Number.isSafeInteger(object)) {
+      if (object >= 0) {
+        if (object < 128) {
+          this.writeU8(object);
+        } else if (object < 256) {
+          this.writeU8(204);
+          this.writeU8(object);
+        } else if (object < 65536) {
+          this.writeU8(205);
+          this.writeU16(object);
+        } else if (object < 4294967296) {
+          this.writeU8(206);
+          this.writeU32(object);
+        } else if (!this.useBigInt64) {
+          this.writeU8(207);
+          this.writeU64(object);
+        } else {
+          this.encodeNumberAsFloat(object);
+        }
+      } else {
+        if (object >= -32) {
+          this.writeU8(224 | object + 32);
+        } else if (object >= -128) {
+          this.writeU8(208);
+          this.writeI8(object);
+        } else if (object >= -32768) {
+          this.writeU8(209);
+          this.writeI16(object);
+        } else if (object >= -2147483648) {
+          this.writeU8(210);
+          this.writeI32(object);
+        } else if (!this.useBigInt64) {
+          this.writeU8(211);
+          this.writeI64(object);
+        } else {
+          this.encodeNumberAsFloat(object);
+        }
+      }
+    } else {
+      this.encodeNumberAsFloat(object);
+    }
+  }
+  encodeNumberAsFloat(object) {
+    if (this.forceFloat32) {
+      this.writeU8(202);
+      this.writeF32(object);
+    } else {
+      this.writeU8(203);
+      this.writeF64(object);
+    }
+  }
+  encodeBigInt64(object) {
+    if (object >= BigInt(0)) {
+      this.writeU8(207);
+      this.writeBigUint64(object);
+    } else {
+      this.writeU8(211);
+      this.writeBigInt64(object);
+    }
+  }
+  writeStringHeader(byteLength) {
+    if (byteLength < 32) {
+      this.writeU8(160 + byteLength);
+    } else if (byteLength < 256) {
+      this.writeU8(217);
+      this.writeU8(byteLength);
+    } else if (byteLength < 65536) {
+      this.writeU8(218);
+      this.writeU16(byteLength);
+    } else if (byteLength < 4294967296) {
+      this.writeU8(219);
+      this.writeU32(byteLength);
+    } else {
+      throw new Error(`Too long string: ${byteLength} bytes in UTF-8`);
+    }
+  }
+  encodeString(object) {
+    const maxHeaderSize = 1 + 4;
+    const byteLength = utf8Count(object);
+    this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);
+    this.writeStringHeader(byteLength);
+    utf8Encode(object, this.bytes, this.pos);
+    this.pos += byteLength;
+  }
+  encodeObject(object, depth) {
+    const ext = this.extensionCodec.tryToEncode(object, this.context);
+    if (ext != null) {
+      this.encodeExtension(ext);
+    } else if (Array.isArray(object)) {
+      this.encodeArray(object, depth);
+    } else if (ArrayBuffer.isView(object)) {
+      this.encodeBinary(object);
+    } else if (typeof object === "object") {
+      this.encodeMap(object, depth);
+    } else {
+      throw new Error(`Unrecognized object: ${Object.prototype.toString.apply(object)}`);
+    }
+  }
+  encodeBinary(object) {
+    const size = object.byteLength;
+    if (size < 256) {
+      this.writeU8(196);
+      this.writeU8(size);
+    } else if (size < 65536) {
+      this.writeU8(197);
+      this.writeU16(size);
+    } else if (size < 4294967296) {
+      this.writeU8(198);
+      this.writeU32(size);
+    } else {
+      throw new Error(`Too large binary: ${size}`);
+    }
+    const bytes = ensureUint8Array(object);
+    this.writeU8a(bytes);
+  }
+  encodeArray(object, depth) {
+    const size = object.length;
+    if (size < 16) {
+      this.writeU8(144 + size);
+    } else if (size < 65536) {
+      this.writeU8(220);
+      this.writeU16(size);
+    } else if (size < 4294967296) {
+      this.writeU8(221);
+      this.writeU32(size);
+    } else {
+      throw new Error(`Too large array: ${size}`);
+    }
+    for (const item of object) {
+      this.doEncode(item, depth + 1);
+    }
+  }
+  countWithoutUndefined(object, keys) {
+    let count = 0;
+    for (const key of keys) {
+      if (object[key] !== void 0) {
+        count++;
+      }
+    }
+    return count;
+  }
+  encodeMap(object, depth) {
+    const keys = Object.keys(object);
+    if (this.sortKeys) {
+      keys.sort();
+    }
+    const size = this.ignoreUndefined ? this.countWithoutUndefined(object, keys) : keys.length;
+    if (size < 16) {
+      this.writeU8(128 + size);
+    } else if (size < 65536) {
+      this.writeU8(222);
+      this.writeU16(size);
+    } else if (size < 4294967296) {
+      this.writeU8(223);
+      this.writeU32(size);
+    } else {
+      throw new Error(`Too large map object: ${size}`);
+    }
+    for (const key of keys) {
+      const value = object[key];
+      if (!(this.ignoreUndefined && value === void 0)) {
+        this.encodeString(key);
+        this.doEncode(value, depth + 1);
+      }
+    }
+  }
+  encodeExtension(ext) {
+    if (typeof ext.data === "function") {
+      const data = ext.data(this.pos + 6);
+      const size2 = data.length;
+      if (size2 >= 4294967296) {
+        throw new Error(`Too large extension object: ${size2}`);
+      }
+      this.writeU8(201);
+      this.writeU32(size2);
+      this.writeI8(ext.type);
+      this.writeU8a(data);
+      return;
+    }
+    const size = ext.data.length;
+    if (size === 1) {
+      this.writeU8(212);
+    } else if (size === 2) {
+      this.writeU8(213);
+    } else if (size === 4) {
+      this.writeU8(214);
+    } else if (size === 8) {
+      this.writeU8(215);
+    } else if (size === 16) {
+      this.writeU8(216);
+    } else if (size < 256) {
+      this.writeU8(199);
+      this.writeU8(size);
+    } else if (size < 65536) {
+      this.writeU8(200);
+      this.writeU16(size);
+    } else if (size < 4294967296) {
+      this.writeU8(201);
+      this.writeU32(size);
+    } else {
+      throw new Error(`Too large extension object: ${size}`);
+    }
+    this.writeI8(ext.type);
+    this.writeU8a(ext.data);
+  }
+  writeU8(value) {
+    this.ensureBufferSizeToWrite(1);
+    this.view.setUint8(this.pos, value);
+    this.pos++;
+  }
+  writeU8a(values) {
+    const size = values.length;
+    this.ensureBufferSizeToWrite(size);
+    this.bytes.set(values, this.pos);
+    this.pos += size;
+  }
+  writeI8(value) {
+    this.ensureBufferSizeToWrite(1);
+    this.view.setInt8(this.pos, value);
+    this.pos++;
+  }
+  writeU16(value) {
+    this.ensureBufferSizeToWrite(2);
+    this.view.setUint16(this.pos, value);
+    this.pos += 2;
+  }
+  writeI16(value) {
+    this.ensureBufferSizeToWrite(2);
+    this.view.setInt16(this.pos, value);
+    this.pos += 2;
+  }
+  writeU32(value) {
+    this.ensureBufferSizeToWrite(4);
+    this.view.setUint32(this.pos, value);
+    this.pos += 4;
+  }
+  writeI32(value) {
+    this.ensureBufferSizeToWrite(4);
+    this.view.setInt32(this.pos, value);
+    this.pos += 4;
+  }
+  writeF32(value) {
+    this.ensureBufferSizeToWrite(4);
+    this.view.setFloat32(this.pos, value);
+    this.pos += 4;
+  }
+  writeF64(value) {
+    this.ensureBufferSizeToWrite(8);
+    this.view.setFloat64(this.pos, value);
+    this.pos += 8;
+  }
+  writeU64(value) {
+    this.ensureBufferSizeToWrite(8);
+    setUint64(this.view, this.pos, value);
+    this.pos += 8;
+  }
+  writeI64(value) {
+    this.ensureBufferSizeToWrite(8);
+    setInt64(this.view, this.pos, value);
+    this.pos += 8;
+  }
+  writeBigUint64(value) {
+    this.ensureBufferSizeToWrite(8);
+    this.view.setBigUint64(this.pos, value);
+    this.pos += 8;
+  }
+  writeBigInt64(value) {
+    this.ensureBufferSizeToWrite(8);
+    this.view.setBigInt64(this.pos, value);
+    this.pos += 8;
+  }
+};
+
+// node_modules/@msgpack/msgpack/dist.esm/encode.mjs
+function encode(value, options) {
+  const encoder = new Encoder(options);
+  return encoder.encodeSharedRef(value);
+}
+
+// node_modules/@msgpack/msgpack/dist.esm/utils/prettyByte.mjs
+function prettyByte(byte) {
+  return `${byte < 0 ? "-" : ""}0x${Math.abs(byte).toString(16).padStart(2, "0")}`;
+}
+
+// node_modules/@msgpack/msgpack/dist.esm/CachedKeyDecoder.mjs
+var DEFAULT_MAX_KEY_LENGTH = 16;
+var DEFAULT_MAX_LENGTH_PER_KEY = 16;
+var CachedKeyDecoder = class {
+  constructor(maxKeyLength = DEFAULT_MAX_KEY_LENGTH, maxLengthPerKey = DEFAULT_MAX_LENGTH_PER_KEY) {
+    this.hit = 0;
+    this.miss = 0;
+    this.maxKeyLength = maxKeyLength;
+    this.maxLengthPerKey = maxLengthPerKey;
+    this.caches = [];
+    for (let i = 0; i < this.maxKeyLength; i++) {
+      this.caches.push([]);
+    }
+  }
+  canBeCached(byteLength) {
+    return byteLength > 0 && byteLength <= this.maxKeyLength;
+  }
+  find(bytes, inputOffset, byteLength) {
+    const records = this.caches[byteLength - 1];
+    FIND_CHUNK: for (const record of records) {
+      const recordBytes = record.bytes;
+      for (let j = 0; j < byteLength; j++) {
+        if (recordBytes[j] !== bytes[inputOffset + j]) {
+          continue FIND_CHUNK;
+        }
+      }
+      return record.str;
+    }
+    return null;
+  }
+  store(bytes, value) {
+    const records = this.caches[bytes.length - 1];
+    const record = { bytes, str: value };
+    if (records.length >= this.maxLengthPerKey) {
+      records[Math.random() * records.length | 0] = record;
+    } else {
+      records.push(record);
+    }
+  }
+  decode(bytes, inputOffset, byteLength) {
+    const cachedValue = this.find(bytes, inputOffset, byteLength);
+    if (cachedValue != null) {
+      this.hit++;
+      return cachedValue;
+    }
+    this.miss++;
+    const str = utf8DecodeJs(bytes, inputOffset, byteLength);
+    const slicedCopyOfBytes = Uint8Array.prototype.slice.call(bytes, inputOffset, inputOffset + byteLength);
+    this.store(slicedCopyOfBytes, str);
+    return str;
+  }
+};
+
+// node_modules/@msgpack/msgpack/dist.esm/Decoder.mjs
+var STATE_ARRAY = "array";
+var STATE_MAP_KEY = "map_key";
+var STATE_MAP_VALUE = "map_value";
+var mapKeyConverter = (key) => {
+  if (typeof key === "string" || typeof key === "number") {
+    return key;
+  }
+  throw new DecodeError("The type of key must be string or number but " + typeof key);
+};
+var StackPool = class {
+  constructor() {
+    this.stack = [];
+    this.stackHeadPosition = -1;
+  }
+  get length() {
+    return this.stackHeadPosition + 1;
+  }
+  top() {
+    return this.stack[this.stackHeadPosition];
+  }
+  pushArrayState(size) {
+    const state = this.getUninitializedStateFromPool();
+    state.type = STATE_ARRAY;
+    state.position = 0;
+    state.size = size;
+    state.array = new Array(size);
+  }
+  pushMapState(size) {
+    const state = this.getUninitializedStateFromPool();
+    state.type = STATE_MAP_KEY;
+    state.readCount = 0;
+    state.size = size;
+    state.map = {};
+  }
+  getUninitializedStateFromPool() {
+    this.stackHeadPosition++;
+    if (this.stackHeadPosition === this.stack.length) {
+      const partialState = {
+        type: void 0,
+        size: 0,
+        array: void 0,
+        position: 0,
+        readCount: 0,
+        map: void 0,
+        key: null
+      };
+      this.stack.push(partialState);
+    }
+    return this.stack[this.stackHeadPosition];
+  }
+  release(state) {
+    const topStackState = this.stack[this.stackHeadPosition];
+    if (topStackState !== state) {
+      throw new Error("Invalid stack state. Released state is not on top of the stack.");
+    }
+    if (state.type === STATE_ARRAY) {
+      const partialState = state;
+      partialState.size = 0;
+      partialState.array = void 0;
+      partialState.position = 0;
+      partialState.type = void 0;
+    }
+    if (state.type === STATE_MAP_KEY || state.type === STATE_MAP_VALUE) {
+      const partialState = state;
+      partialState.size = 0;
+      partialState.map = void 0;
+      partialState.readCount = 0;
+      partialState.type = void 0;
+    }
+    this.stackHeadPosition--;
+  }
+  reset() {
+    this.stack.length = 0;
+    this.stackHeadPosition = -1;
+  }
+};
+var HEAD_BYTE_REQUIRED = -1;
+var EMPTY_VIEW = new DataView(new ArrayBuffer(0));
+var EMPTY_BYTES = new Uint8Array(EMPTY_VIEW.buffer);
+try {
+  EMPTY_VIEW.getInt8(0);
+} catch (e) {
+  if (!(e instanceof RangeError)) {
+    throw new Error("This module is not supported in the current JavaScript engine because DataView does not throw RangeError on out-of-bounds access");
+  }
+}
+var MORE_DATA = new RangeError("Insufficient data");
+var sharedCachedKeyDecoder = new CachedKeyDecoder();
+var Decoder = class _Decoder {
+  constructor(options) {
+    this.totalPos = 0;
+    this.pos = 0;
+    this.view = EMPTY_VIEW;
+    this.bytes = EMPTY_BYTES;
+    this.headByte = HEAD_BYTE_REQUIRED;
+    this.stack = new StackPool();
+    this.entered = false;
+    this.extensionCodec = options?.extensionCodec ?? ExtensionCodec.defaultCodec;
+    this.context = options?.context;
+    this.useBigInt64 = options?.useBigInt64 ?? false;
+    this.rawStrings = options?.rawStrings ?? false;
+    this.maxStrLength = options?.maxStrLength ?? UINT32_MAX;
+    this.maxBinLength = options?.maxBinLength ?? UINT32_MAX;
+    this.maxArrayLength = options?.maxArrayLength ?? UINT32_MAX;
+    this.maxMapLength = options?.maxMapLength ?? UINT32_MAX;
+    this.maxExtLength = options?.maxExtLength ?? UINT32_MAX;
+    this.keyDecoder = options?.keyDecoder !== void 0 ? options.keyDecoder : sharedCachedKeyDecoder;
+    this.mapKeyConverter = options?.mapKeyConverter ?? mapKeyConverter;
+  }
+  clone() {
+    return new _Decoder({
+      extensionCodec: this.extensionCodec,
+      context: this.context,
+      useBigInt64: this.useBigInt64,
+      rawStrings: this.rawStrings,
+      maxStrLength: this.maxStrLength,
+      maxBinLength: this.maxBinLength,
+      maxArrayLength: this.maxArrayLength,
+      maxMapLength: this.maxMapLength,
+      maxExtLength: this.maxExtLength,
+      keyDecoder: this.keyDecoder
+    });
+  }
+  reinitializeState() {
+    this.totalPos = 0;
+    this.headByte = HEAD_BYTE_REQUIRED;
+    this.stack.reset();
+  }
+  setBuffer(buffer) {
+    const bytes = ensureUint8Array(buffer);
+    this.bytes = bytes;
+    this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    this.pos = 0;
+  }
+  appendBuffer(buffer) {
+    if (this.headByte === HEAD_BYTE_REQUIRED && !this.hasRemaining(1)) {
+      this.setBuffer(buffer);
+    } else {
+      const remainingData = this.bytes.subarray(this.pos);
+      const newData = ensureUint8Array(buffer);
+      const newBuffer = new Uint8Array(remainingData.length + newData.length);
+      newBuffer.set(remainingData);
+      newBuffer.set(newData, remainingData.length);
+      this.setBuffer(newBuffer);
+    }
+  }
+  hasRemaining(size) {
+    return this.view.byteLength - this.pos >= size;
+  }
+  createExtraByteError(posToShow) {
+    const { view, pos } = this;
+    return new RangeError(`Extra ${view.byteLength - pos} of ${view.byteLength} byte(s) found at buffer[${posToShow}]`);
+  }
+  /**
+   * @throws {@link DecodeError}
+   * @throws {@link RangeError}
+   */
+  decode(buffer) {
+    if (this.entered) {
+      const instance = this.clone();
+      return instance.decode(buffer);
+    }
+    try {
+      this.entered = true;
+      this.reinitializeState();
+      this.setBuffer(buffer);
+      const object = this.doDecodeSync();
+      if (this.hasRemaining(1)) {
+        throw this.createExtraByteError(this.pos);
+      }
+      return object;
+    } finally {
+      this.entered = false;
+    }
+  }
+  *decodeMulti(buffer) {
+    if (this.entered) {
+      const instance = this.clone();
+      yield* instance.decodeMulti(buffer);
+      return;
+    }
+    try {
+      this.entered = true;
+      this.reinitializeState();
+      this.setBuffer(buffer);
+      while (this.hasRemaining(1)) {
+        yield this.doDecodeSync();
+      }
+    } finally {
+      this.entered = false;
+    }
+  }
+  async decodeAsync(stream) {
+    if (this.entered) {
+      const instance = this.clone();
+      return instance.decodeAsync(stream);
+    }
+    try {
+      this.entered = true;
+      let decoded = false;
+      let object;
+      for await (const buffer of stream) {
+        if (decoded) {
+          this.entered = false;
+          throw this.createExtraByteError(this.totalPos);
+        }
+        this.appendBuffer(buffer);
+        try {
+          object = this.doDecodeSync();
+          decoded = true;
+        } catch (e) {
+          if (!(e instanceof RangeError)) {
+            throw e;
+          }
+        }
+        this.totalPos += this.pos;
+      }
+      if (decoded) {
+        if (this.hasRemaining(1)) {
+          throw this.createExtraByteError(this.totalPos);
+        }
+        return object;
+      }
+      const { headByte, pos, totalPos } = this;
+      throw new RangeError(`Insufficient data in parsing ${prettyByte(headByte)} at ${totalPos} (${pos} in the current buffer)`);
+    } finally {
+      this.entered = false;
+    }
+  }
+  decodeArrayStream(stream) {
+    return this.decodeMultiAsync(stream, true);
+  }
+  decodeStream(stream) {
+    return this.decodeMultiAsync(stream, false);
+  }
+  async *decodeMultiAsync(stream, isArray) {
+    if (this.entered) {
+      const instance = this.clone();
+      yield* instance.decodeMultiAsync(stream, isArray);
+      return;
+    }
+    try {
+      this.entered = true;
+      let isArrayHeaderRequired = isArray;
+      let arrayItemsLeft = -1;
+      for await (const buffer of stream) {
+        if (isArray && arrayItemsLeft === 0) {
+          throw this.createExtraByteError(this.totalPos);
+        }
+        this.appendBuffer(buffer);
+        if (isArrayHeaderRequired) {
+          arrayItemsLeft = this.readArraySize();
+          isArrayHeaderRequired = false;
+          this.complete();
+        }
+        try {
+          while (true) {
+            yield this.doDecodeSync();
+            if (--arrayItemsLeft === 0) {
+              break;
+            }
+          }
+        } catch (e) {
+          if (!(e instanceof RangeError)) {
+            throw e;
+          }
+        }
+        this.totalPos += this.pos;
+      }
+    } finally {
+      this.entered = false;
+    }
+  }
+  doDecodeSync() {
+    DECODE: while (true) {
+      const headByte = this.readHeadByte();
+      let object;
+      if (headByte >= 224) {
+        object = headByte - 256;
+      } else if (headByte < 192) {
+        if (headByte < 128) {
+          object = headByte;
+        } else if (headByte < 144) {
+          const size = headByte - 128;
+          if (size !== 0) {
+            this.pushMapState(size);
+            this.complete();
+            continue DECODE;
+          } else {
+            object = {};
+          }
+        } else if (headByte < 160) {
+          const size = headByte - 144;
+          if (size !== 0) {
+            this.pushArrayState(size);
+            this.complete();
+            continue DECODE;
+          } else {
+            object = [];
+          }
+        } else {
+          const byteLength = headByte - 160;
+          object = this.decodeString(byteLength, 0);
+        }
+      } else if (headByte === 192) {
+        object = null;
+      } else if (headByte === 194) {
+        object = false;
+      } else if (headByte === 195) {
+        object = true;
+      } else if (headByte === 202) {
+        object = this.readF32();
+      } else if (headByte === 203) {
+        object = this.readF64();
+      } else if (headByte === 204) {
+        object = this.readU8();
+      } else if (headByte === 205) {
+        object = this.readU16();
+      } else if (headByte === 206) {
+        object = this.readU32();
+      } else if (headByte === 207) {
+        if (this.useBigInt64) {
+          object = this.readU64AsBigInt();
+        } else {
+          object = this.readU64();
+        }
+      } else if (headByte === 208) {
+        object = this.readI8();
+      } else if (headByte === 209) {
+        object = this.readI16();
+      } else if (headByte === 210) {
+        object = this.readI32();
+      } else if (headByte === 211) {
+        if (this.useBigInt64) {
+          object = this.readI64AsBigInt();
+        } else {
+          object = this.readI64();
+        }
+      } else if (headByte === 217) {
+        const byteLength = this.lookU8();
+        object = this.decodeString(byteLength, 1);
+      } else if (headByte === 218) {
+        const byteLength = this.lookU16();
+        object = this.decodeString(byteLength, 2);
+      } else if (headByte === 219) {
+        const byteLength = this.lookU32();
+        object = this.decodeString(byteLength, 4);
+      } else if (headByte === 220) {
+        const size = this.readU16();
+        if (size !== 0) {
+          this.pushArrayState(size);
+          this.complete();
+          continue DECODE;
+        } else {
+          object = [];
+        }
+      } else if (headByte === 221) {
+        const size = this.readU32();
+        if (size !== 0) {
+          this.pushArrayState(size);
+          this.complete();
+          continue DECODE;
+        } else {
+          object = [];
+        }
+      } else if (headByte === 222) {
+        const size = this.readU16();
+        if (size !== 0) {
+          this.pushMapState(size);
+          this.complete();
+          continue DECODE;
+        } else {
+          object = {};
+        }
+      } else if (headByte === 223) {
+        const size = this.readU32();
+        if (size !== 0) {
+          this.pushMapState(size);
+          this.complete();
+          continue DECODE;
+        } else {
+          object = {};
+        }
+      } else if (headByte === 196) {
+        const size = this.lookU8();
+        object = this.decodeBinary(size, 1);
+      } else if (headByte === 197) {
+        const size = this.lookU16();
+        object = this.decodeBinary(size, 2);
+      } else if (headByte === 198) {
+        const size = this.lookU32();
+        object = this.decodeBinary(size, 4);
+      } else if (headByte === 212) {
+        object = this.decodeExtension(1, 0);
+      } else if (headByte === 213) {
+        object = this.decodeExtension(2, 0);
+      } else if (headByte === 214) {
+        object = this.decodeExtension(4, 0);
+      } else if (headByte === 215) {
+        object = this.decodeExtension(8, 0);
+      } else if (headByte === 216) {
+        object = this.decodeExtension(16, 0);
+      } else if (headByte === 199) {
+        const size = this.lookU8();
+        object = this.decodeExtension(size, 1);
+      } else if (headByte === 200) {
+        const size = this.lookU16();
+        object = this.decodeExtension(size, 2);
+      } else if (headByte === 201) {
+        const size = this.lookU32();
+        object = this.decodeExtension(size, 4);
+      } else {
+        throw new DecodeError(`Unrecognized type byte: ${prettyByte(headByte)}`);
+      }
+      this.complete();
+      const stack = this.stack;
+      while (stack.length > 0) {
+        const state = stack.top();
+        if (state.type === STATE_ARRAY) {
+          state.array[state.position] = object;
+          state.position++;
+          if (state.position === state.size) {
+            object = state.array;
+            stack.release(state);
+          } else {
+            continue DECODE;
+          }
+        } else if (state.type === STATE_MAP_KEY) {
+          if (object === "__proto__") {
+            throw new DecodeError("The key __proto__ is not allowed");
+          }
+          state.key = this.mapKeyConverter(object);
+          state.type = STATE_MAP_VALUE;
+          continue DECODE;
+        } else {
+          state.map[state.key] = object;
+          state.readCount++;
+          if (state.readCount === state.size) {
+            object = state.map;
+            stack.release(state);
+          } else {
+            state.key = null;
+            state.type = STATE_MAP_KEY;
+            continue DECODE;
+          }
+        }
+      }
+      return object;
+    }
+  }
+  readHeadByte() {
+    if (this.headByte === HEAD_BYTE_REQUIRED) {
+      this.headByte = this.readU8();
+    }
+    return this.headByte;
+  }
+  complete() {
+    this.headByte = HEAD_BYTE_REQUIRED;
+  }
+  readArraySize() {
+    const headByte = this.readHeadByte();
+    switch (headByte) {
+      case 220:
+        return this.readU16();
+      case 221:
+        return this.readU32();
+      default: {
+        if (headByte < 160) {
+          return headByte - 144;
+        } else {
+          throw new DecodeError(`Unrecognized array type byte: ${prettyByte(headByte)}`);
+        }
+      }
+    }
+  }
+  pushMapState(size) {
+    if (size > this.maxMapLength) {
+      throw new DecodeError(`Max length exceeded: map length (${size}) > maxMapLengthLength (${this.maxMapLength})`);
+    }
+    this.stack.pushMapState(size);
+  }
+  pushArrayState(size) {
+    if (size > this.maxArrayLength) {
+      throw new DecodeError(`Max length exceeded: array length (${size}) > maxArrayLength (${this.maxArrayLength})`);
+    }
+    this.stack.pushArrayState(size);
+  }
+  decodeString(byteLength, headerOffset) {
+    if (!this.rawStrings || this.stateIsMapKey()) {
+      return this.decodeUtf8String(byteLength, headerOffset);
+    }
+    return this.decodeBinary(byteLength, headerOffset);
+  }
+  /**
+   * @throws {@link RangeError}
+   */
+  decodeUtf8String(byteLength, headerOffset) {
+    if (byteLength > this.maxStrLength) {
+      throw new DecodeError(`Max length exceeded: UTF-8 byte length (${byteLength}) > maxStrLength (${this.maxStrLength})`);
+    }
+    if (this.bytes.byteLength < this.pos + headerOffset + byteLength) {
+      throw MORE_DATA;
+    }
+    const offset = this.pos + headerOffset;
+    let object;
+    if (this.stateIsMapKey() && this.keyDecoder?.canBeCached(byteLength)) {
+      object = this.keyDecoder.decode(this.bytes, offset, byteLength);
+    } else {
+      object = utf8Decode(this.bytes, offset, byteLength);
+    }
+    this.pos += headerOffset + byteLength;
+    return object;
+  }
+  stateIsMapKey() {
+    if (this.stack.length > 0) {
+      const state = this.stack.top();
+      return state.type === STATE_MAP_KEY;
+    }
+    return false;
+  }
+  /**
+   * @throws {@link RangeError}
+   */
+  decodeBinary(byteLength, headOffset) {
+    if (byteLength > this.maxBinLength) {
+      throw new DecodeError(`Max length exceeded: bin length (${byteLength}) > maxBinLength (${this.maxBinLength})`);
+    }
+    if (!this.hasRemaining(byteLength + headOffset)) {
+      throw MORE_DATA;
+    }
+    const offset = this.pos + headOffset;
+    const object = this.bytes.subarray(offset, offset + byteLength);
+    this.pos += headOffset + byteLength;
+    return object;
+  }
+  decodeExtension(size, headOffset) {
+    if (size > this.maxExtLength) {
+      throw new DecodeError(`Max length exceeded: ext length (${size}) > maxExtLength (${this.maxExtLength})`);
+    }
+    const extType = this.view.getInt8(this.pos + headOffset);
+    const data = this.decodeBinary(
+      size,
+      headOffset + 1
+      /* extType */
+    );
+    return this.extensionCodec.decode(data, extType, this.context);
+  }
+  lookU8() {
+    return this.view.getUint8(this.pos);
+  }
+  lookU16() {
+    return this.view.getUint16(this.pos);
+  }
+  lookU32() {
+    return this.view.getUint32(this.pos);
+  }
+  readU8() {
+    const value = this.view.getUint8(this.pos);
+    this.pos++;
+    return value;
+  }
+  readI8() {
+    const value = this.view.getInt8(this.pos);
+    this.pos++;
+    return value;
+  }
+  readU16() {
+    const value = this.view.getUint16(this.pos);
+    this.pos += 2;
+    return value;
+  }
+  readI16() {
+    const value = this.view.getInt16(this.pos);
+    this.pos += 2;
+    return value;
+  }
+  readU32() {
+    const value = this.view.getUint32(this.pos);
+    this.pos += 4;
+    return value;
+  }
+  readI32() {
+    const value = this.view.getInt32(this.pos);
+    this.pos += 4;
+    return value;
+  }
+  readU64() {
+    const value = getUint64(this.view, this.pos);
+    this.pos += 8;
+    return value;
+  }
+  readI64() {
+    const value = getInt64(this.view, this.pos);
+    this.pos += 8;
+    return value;
+  }
+  readU64AsBigInt() {
+    const value = this.view.getBigUint64(this.pos);
+    this.pos += 8;
+    return value;
+  }
+  readI64AsBigInt() {
+    const value = this.view.getBigInt64(this.pos);
+    this.pos += 8;
+    return value;
+  }
+  readF32() {
+    const value = this.view.getFloat32(this.pos);
+    this.pos += 4;
+    return value;
+  }
+  readF64() {
+    const value = this.view.getFloat64(this.pos);
+    this.pos += 8;
+    return value;
+  }
+};
+
+// node_modules/@msgpack/msgpack/dist.esm/decode.mjs
+function decode(buffer, options) {
+  const decoder = new Decoder(options);
+  return decoder.decode(buffer);
+}
+
+// src/socket/index.ts
+var import_async_retry = __toESM(require_lib(), 1);
+
+// node_modules/reconnecting-websocket/dist/reconnecting-websocket-mjs.js
+var extendStatics = function(d, b) {
+  extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+    d2.__proto__ = b2;
+  } || function(d2, b2) {
+    for (var p in b2) if (b2.hasOwnProperty(p)) d2[p] = b2[p];
+  };
+  return extendStatics(d, b);
+};
+function __extends(d, b) {
+  extendStatics(d, b);
+  function __() {
+    this.constructor = d;
+  }
+  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+function __values(o) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+  if (m) return m.call(o);
+  return {
+    next: function() {
+      if (o && i >= o.length) o = void 0;
+      return { value: o && o[i++], done: !o };
+    }
+  };
+}
+function __read(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+  return ar;
+}
+function __spread() {
+  for (var ar = [], i = 0; i < arguments.length; i++)
+    ar = ar.concat(__read(arguments[i]));
+  return ar;
+}
+var Event = (
+  /** @class */
+  /* @__PURE__ */ (function() {
+    function Event2(type, target) {
+      this.target = target;
+      this.type = type;
+    }
+    return Event2;
+  })()
+);
+var ErrorEvent2 = (
+  /** @class */
+  (function(_super) {
+    __extends(ErrorEvent3, _super);
+    function ErrorEvent3(error, target) {
+      var _this = _super.call(this, "error", target) || this;
+      _this.message = error.message;
+      _this.error = error;
+      return _this;
+    }
+    return ErrorEvent3;
+  })(Event)
+);
+var CloseEvent = (
+  /** @class */
+  (function(_super) {
+    __extends(CloseEvent2, _super);
+    function CloseEvent2(code, reason, target) {
+      if (code === void 0) {
+        code = 1e3;
+      }
+      if (reason === void 0) {
+        reason = "";
+      }
+      var _this = _super.call(this, "close", target) || this;
+      _this.wasClean = true;
+      _this.code = code;
+      _this.reason = reason;
+      return _this;
+    }
+    return CloseEvent2;
+  })(Event)
+);
+var getGlobalWebSocket = function() {
+  if (typeof WebSocket !== "undefined") {
+    return WebSocket;
+  }
+};
+var isWebSocket = function(w) {
+  return typeof w !== "undefined" && !!w && w.CLOSING === 2;
+};
+var DEFAULT = {
+  maxReconnectionDelay: 1e4,
+  minReconnectionDelay: 1e3 + Math.random() * 4e3,
+  minUptime: 5e3,
+  reconnectionDelayGrowFactor: 1.3,
+  connectionTimeout: 4e3,
+  maxRetries: Infinity,
+  maxEnqueuedMessages: Infinity,
+  startClosed: false,
+  debug: false
+};
+var ReconnectingWebSocket = (
+  /** @class */
+  (function() {
+    function ReconnectingWebSocket2(url, protocols, options) {
+      var _this = this;
+      if (options === void 0) {
+        options = {};
+      }
+      this._listeners = {
+        error: [],
+        message: [],
+        open: [],
+        close: []
+      };
+      this._retryCount = -1;
+      this._shouldReconnect = true;
+      this._connectLock = false;
+      this._binaryType = "blob";
+      this._closeCalled = false;
+      this._messageQueue = [];
+      this.onclose = null;
+      this.onerror = null;
+      this.onmessage = null;
+      this.onopen = null;
+      this._handleOpen = function(event) {
+        _this._debug("open event");
+        var _a = _this._options.minUptime, minUptime = _a === void 0 ? DEFAULT.minUptime : _a;
+        clearTimeout(_this._connectTimeout);
+        _this._uptimeTimeout = setTimeout(function() {
+          return _this._acceptOpen();
+        }, minUptime);
+        _this._ws.binaryType = _this._binaryType;
+        _this._messageQueue.forEach(function(message) {
+          return _this._ws.send(message);
+        });
+        _this._messageQueue = [];
+        if (_this.onopen) {
+          _this.onopen(event);
+        }
+        _this._listeners.open.forEach(function(listener) {
+          return _this._callEventListener(event, listener);
+        });
+      };
+      this._handleMessage = function(event) {
+        _this._debug("message event");
+        if (_this.onmessage) {
+          _this.onmessage(event);
+        }
+        _this._listeners.message.forEach(function(listener) {
+          return _this._callEventListener(event, listener);
+        });
+      };
+      this._handleError = function(event) {
+        _this._debug("error event", event.message);
+        _this._disconnect(void 0, event.message === "TIMEOUT" ? "timeout" : void 0);
+        if (_this.onerror) {
+          _this.onerror(event);
+        }
+        _this._debug("exec error listeners");
+        _this._listeners.error.forEach(function(listener) {
+          return _this._callEventListener(event, listener);
+        });
+        _this._connect();
+      };
+      this._handleClose = function(event) {
+        _this._debug("close event");
+        _this._clearTimeouts();
+        if (_this._shouldReconnect) {
+          _this._connect();
+        }
+        if (_this.onclose) {
+          _this.onclose(event);
+        }
+        _this._listeners.close.forEach(function(listener) {
+          return _this._callEventListener(event, listener);
+        });
+      };
+      this._url = url;
+      this._protocols = protocols;
+      this._options = options;
+      if (this._options.startClosed) {
+        this._shouldReconnect = false;
+      }
+      this._connect();
+    }
+    Object.defineProperty(ReconnectingWebSocket2, "CONNECTING", {
+      get: function() {
+        return 0;
+      },
+      enumerable: true,
+      configurable: true
+    });
+    Object.defineProperty(ReconnectingWebSocket2, "OPEN", {
+      get: function() {
+        return 1;
+      },
+      enumerable: true,
+      configurable: true
+    });
+    Object.defineProperty(ReconnectingWebSocket2, "CLOSING", {
+      get: function() {
+        return 2;
+      },
+      enumerable: true,
+      configurable: true
+    });
+    Object.defineProperty(ReconnectingWebSocket2, "CLOSED", {
+      get: function() {
+        return 3;
+      },
+      enumerable: true,
+      configurable: true
+    });
+    Object.defineProperty(ReconnectingWebSocket2.prototype, "CONNECTING", {
+      get: function() {
+        return ReconnectingWebSocket2.CONNECTING;
+      },
+      enumerable: true,
+      configurable: true
+    });
+    Object.defineProperty(ReconnectingWebSocket2.prototype, "OPEN", {
+      get: function() {
+        return ReconnectingWebSocket2.OPEN;
+      },
+      enumerable: true,
+      configurable: true
+    });
+    Object.defineProperty(ReconnectingWebSocket2.prototype, "CLOSING", {
+      get: function() {
+        return ReconnectingWebSocket2.CLOSING;
+      },
+      enumerable: true,
+      configurable: true
+    });
+    Object.defineProperty(ReconnectingWebSocket2.prototype, "CLOSED", {
+      get: function() {
+        return ReconnectingWebSocket2.CLOSED;
+      },
+      enumerable: true,
+      configurable: true
+    });
+    Object.defineProperty(ReconnectingWebSocket2.prototype, "binaryType", {
+      get: function() {
+        return this._ws ? this._ws.binaryType : this._binaryType;
+      },
+      set: function(value) {
+        this._binaryType = value;
+        if (this._ws) {
+          this._ws.binaryType = value;
+        }
+      },
+      enumerable: true,
+      configurable: true
+    });
+    Object.defineProperty(ReconnectingWebSocket2.prototype, "retryCount", {
+      /**
+       * Returns the number or connection retries
+       */
+      get: function() {
+        return Math.max(this._retryCount, 0);
+      },
+      enumerable: true,
+      configurable: true
+    });
+    Object.defineProperty(ReconnectingWebSocket2.prototype, "bufferedAmount", {
+      /**
+       * The number of bytes of data that have been queued using calls to send() but not yet
+       * transmitted to the network. This value resets to zero once all queued data has been sent.
+       * This value does not reset to zero when the connection is closed; if you keep calling send(),
+       * this will continue to climb. Read only
+       */
+      get: function() {
+        var bytes = this._messageQueue.reduce(function(acc, message) {
+          if (typeof message === "string") {
+            acc += message.length;
+          } else if (message instanceof Blob) {
+            acc += message.size;
+          } else {
+            acc += message.byteLength;
+          }
+          return acc;
+        }, 0);
+        return bytes + (this._ws ? this._ws.bufferedAmount : 0);
+      },
+      enumerable: true,
+      configurable: true
+    });
+    Object.defineProperty(ReconnectingWebSocket2.prototype, "extensions", {
+      /**
+       * The extensions selected by the server. This is currently only the empty string or a list of
+       * extensions as negotiated by the connection
+       */
+      get: function() {
+        return this._ws ? this._ws.extensions : "";
+      },
+      enumerable: true,
+      configurable: true
+    });
+    Object.defineProperty(ReconnectingWebSocket2.prototype, "protocol", {
+      /**
+       * A string indicating the name of the sub-protocol the server selected;
+       * this will be one of the strings specified in the protocols parameter when creating the
+       * WebSocket object
+       */
+      get: function() {
+        return this._ws ? this._ws.protocol : "";
+      },
+      enumerable: true,
+      configurable: true
+    });
+    Object.defineProperty(ReconnectingWebSocket2.prototype, "readyState", {
+      /**
+       * The current state of the connection; this is one of the Ready state constants
+       */
+      get: function() {
+        if (this._ws) {
+          return this._ws.readyState;
+        }
+        return this._options.startClosed ? ReconnectingWebSocket2.CLOSED : ReconnectingWebSocket2.CONNECTING;
+      },
+      enumerable: true,
+      configurable: true
+    });
+    Object.defineProperty(ReconnectingWebSocket2.prototype, "url", {
+      /**
+       * The URL as resolved by the constructor
+       */
+      get: function() {
+        return this._ws ? this._ws.url : "";
+      },
+      enumerable: true,
+      configurable: true
+    });
+    ReconnectingWebSocket2.prototype.close = function(code, reason) {
+      if (code === void 0) {
+        code = 1e3;
+      }
+      this._closeCalled = true;
+      this._shouldReconnect = false;
+      this._clearTimeouts();
+      if (!this._ws) {
+        this._debug("close enqueued: no ws instance");
+        return;
+      }
+      if (this._ws.readyState === this.CLOSED) {
+        this._debug("close: already closed");
+        return;
+      }
+      this._ws.close(code, reason);
+    };
+    ReconnectingWebSocket2.prototype.reconnect = function(code, reason) {
+      this._shouldReconnect = true;
+      this._closeCalled = false;
+      this._retryCount = -1;
+      if (!this._ws || this._ws.readyState === this.CLOSED) {
+        this._connect();
+      } else {
+        this._disconnect(code, reason);
+        this._connect();
+      }
+    };
+    ReconnectingWebSocket2.prototype.send = function(data) {
+      if (this._ws && this._ws.readyState === this.OPEN) {
+        this._debug("send", data);
+        this._ws.send(data);
+      } else {
+        var _a = this._options.maxEnqueuedMessages, maxEnqueuedMessages = _a === void 0 ? DEFAULT.maxEnqueuedMessages : _a;
+        if (this._messageQueue.length < maxEnqueuedMessages) {
+          this._debug("enqueue", data);
+          this._messageQueue.push(data);
+        }
+      }
+    };
+    ReconnectingWebSocket2.prototype.addEventListener = function(type, listener) {
+      if (this._listeners[type]) {
+        this._listeners[type].push(listener);
+      }
+    };
+    ReconnectingWebSocket2.prototype.dispatchEvent = function(event) {
+      var e_1, _a;
+      var listeners = this._listeners[event.type];
+      if (listeners) {
+        try {
+          for (var listeners_1 = __values(listeners), listeners_1_1 = listeners_1.next(); !listeners_1_1.done; listeners_1_1 = listeners_1.next()) {
+            var listener = listeners_1_1.value;
+            this._callEventListener(event, listener);
+          }
+        } catch (e_1_1) {
+          e_1 = { error: e_1_1 };
+        } finally {
+          try {
+            if (listeners_1_1 && !listeners_1_1.done && (_a = listeners_1.return)) _a.call(listeners_1);
+          } finally {
+            if (e_1) throw e_1.error;
+          }
+        }
+      }
+      return true;
+    };
+    ReconnectingWebSocket2.prototype.removeEventListener = function(type, listener) {
+      if (this._listeners[type]) {
+        this._listeners[type] = this._listeners[type].filter(function(l) {
+          return l !== listener;
+        });
+      }
+    };
+    ReconnectingWebSocket2.prototype._debug = function() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+      }
+      if (this._options.debug) {
+        console.log.apply(console, __spread(["RWS>"], args));
+      }
+    };
+    ReconnectingWebSocket2.prototype._getNextDelay = function() {
+      var _a = this._options, _b = _a.reconnectionDelayGrowFactor, reconnectionDelayGrowFactor = _b === void 0 ? DEFAULT.reconnectionDelayGrowFactor : _b, _c = _a.minReconnectionDelay, minReconnectionDelay = _c === void 0 ? DEFAULT.minReconnectionDelay : _c, _d = _a.maxReconnectionDelay, maxReconnectionDelay = _d === void 0 ? DEFAULT.maxReconnectionDelay : _d;
+      var delay = 0;
+      if (this._retryCount > 0) {
+        delay = minReconnectionDelay * Math.pow(reconnectionDelayGrowFactor, this._retryCount - 1);
+        if (delay > maxReconnectionDelay) {
+          delay = maxReconnectionDelay;
+        }
+      }
+      this._debug("next delay", delay);
+      return delay;
+    };
+    ReconnectingWebSocket2.prototype._wait = function() {
+      var _this = this;
+      return new Promise(function(resolve) {
+        setTimeout(resolve, _this._getNextDelay());
+      });
+    };
+    ReconnectingWebSocket2.prototype._getNextUrl = function(urlProvider) {
+      if (typeof urlProvider === "string") {
+        return Promise.resolve(urlProvider);
+      }
+      if (typeof urlProvider === "function") {
+        var url = urlProvider();
+        if (typeof url === "string") {
+          return Promise.resolve(url);
+        }
+        if (!!url.then) {
+          return url;
+        }
+      }
+      throw Error("Invalid URL");
+    };
+    ReconnectingWebSocket2.prototype._connect = function() {
+      var _this = this;
+      if (this._connectLock || !this._shouldReconnect) {
+        return;
+      }
+      this._connectLock = true;
+      var _a = this._options, _b = _a.maxRetries, maxRetries = _b === void 0 ? DEFAULT.maxRetries : _b, _c = _a.connectionTimeout, connectionTimeout = _c === void 0 ? DEFAULT.connectionTimeout : _c, _d = _a.WebSocket, WebSocket2 = _d === void 0 ? getGlobalWebSocket() : _d;
+      if (this._retryCount >= maxRetries) {
+        this._debug("max retries reached", this._retryCount, ">=", maxRetries);
+        return;
+      }
+      this._retryCount++;
+      this._debug("connect", this._retryCount);
+      this._removeListeners();
+      if (!isWebSocket(WebSocket2)) {
+        throw Error("No valid WebSocket class provided");
+      }
+      this._wait().then(function() {
+        return _this._getNextUrl(_this._url);
+      }).then(function(url) {
+        if (_this._closeCalled) {
+          return;
+        }
+        _this._debug("connect", { url, protocols: _this._protocols });
+        _this._ws = _this._protocols ? new WebSocket2(url, _this._protocols) : new WebSocket2(url);
+        _this._ws.binaryType = _this._binaryType;
+        _this._connectLock = false;
+        _this._addListeners();
+        _this._connectTimeout = setTimeout(function() {
+          return _this._handleTimeout();
+        }, connectionTimeout);
+      });
+    };
+    ReconnectingWebSocket2.prototype._handleTimeout = function() {
+      this._debug("timeout event");
+      this._handleError(new ErrorEvent2(Error("TIMEOUT"), this));
+    };
+    ReconnectingWebSocket2.prototype._disconnect = function(code, reason) {
+      if (code === void 0) {
+        code = 1e3;
+      }
+      this._clearTimeouts();
+      if (!this._ws) {
+        return;
+      }
+      this._removeListeners();
+      try {
+        this._ws.close(code, reason);
+        this._handleClose(new CloseEvent(code, reason, this));
+      } catch (error) {
+      }
+    };
+    ReconnectingWebSocket2.prototype._acceptOpen = function() {
+      this._debug("accept open");
+      this._retryCount = 0;
+    };
+    ReconnectingWebSocket2.prototype._callEventListener = function(event, listener) {
+      if ("handleEvent" in listener) {
+        listener.handleEvent(event);
+      } else {
+        listener(event);
+      }
+    };
+    ReconnectingWebSocket2.prototype._removeListeners = function() {
+      if (!this._ws) {
+        return;
+      }
+      this._debug("removeListeners");
+      this._ws.removeEventListener("open", this._handleOpen);
+      this._ws.removeEventListener("close", this._handleClose);
+      this._ws.removeEventListener("message", this._handleMessage);
+      this._ws.removeEventListener("error", this._handleError);
+    };
+    ReconnectingWebSocket2.prototype._addListeners = function() {
+      if (!this._ws) {
+        return;
+      }
+      this._debug("addListeners");
+      this._ws.addEventListener("open", this._handleOpen);
+      this._ws.addEventListener("close", this._handleClose);
+      this._ws.addEventListener("message", this._handleMessage);
+      this._ws.addEventListener("error", this._handleError);
+    };
+    ReconnectingWebSocket2.prototype._clearTimeouts = function() {
+      clearTimeout(this._connectTimeout);
+      clearTimeout(this._uptimeTimeout);
+    };
+    return ReconnectingWebSocket2;
+  })()
+);
+var reconnecting_websocket_mjs_default = ReconnectingWebSocket;
+
+// src/utils/promise.ts
+var PromiseTimeoutError = class extends Error {
+  constructor(message, time) {
+    super(message);
+    this.time = time;
+  }
+};
+var timeout = (prom, time) => {
+  let timer;
+  return Promise.race([
+    prom,
+    new Promise(
+      (_r, rej) => timer = setTimeout(rej, time, new PromiseTimeoutError("Timeout before promise can resolve", time))
+    )
+  ]).finally(() => clearTimeout(timer));
+};
+
+// node_modules/isomorphic-ws/browser.js
+var ws = null;
+if (typeof WebSocket !== "undefined") {
+  ws = WebSocket;
+} else if (typeof MozWebSocket !== "undefined") {
+  ws = MozWebSocket;
+} else if (typeof global !== "undefined") {
+  ws = global.WebSocket || global.MozWebSocket;
+} else if (typeof window !== "undefined") {
+  ws = window.WebSocket || window.MozWebSocket;
+} else if (typeof self !== "undefined") {
+  ws = self.WebSocket || self.MozWebSocket;
+}
+var browser_default = ws;
+
+// src/utils/disposable.ts
+var NamedDisposable = class {
+  constructor() {
+    this.disposables = /* @__PURE__ */ new Map();
+  }
+  add(key, disposable) {
+    if (this.disposables.has(key)) {
+      console.warn(`Disposable with key "${key}" already exists. Disposing the old one.`);
+      this.disposables.get(key)?.dispose();
+    }
+    if (typeof disposable === "function") {
+      disposable = disposable();
+    }
+    this.disposables.set(key, disposable);
+  }
+  dispose() {
+    this.disposables.forEach((disposable) => disposable.dispose());
+    this.disposables.clear();
+  }
+};
+
+// src/socket/index.ts
+var InvalidMessageError = class extends Error {
+  constructor(message, data) {
+    super(message);
+    this.data = data;
+    this.name = "InvalidMessageError";
+  }
+};
+var InvalidConfigurationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidConfigurationError";
+  }
+};
+var _Transport_instances, connect_fn, startPeriodicPing_fn;
+var Transport = class {
+  constructor(url, eventEmitter, options = {}) {
+    this.eventEmitter = eventEmitter;
+    this.options = options;
+    __privateAdd(this, _Transport_instances);
+    this.clientId = "";
+    this.closed = false;
+    this.disposables = new NamedDisposable();
+    this.connectPromise = null;
+    // Connection health monitoring
+    this.connectionStats = {
+      connectTime: 0,
+      reconnectCount: 0,
+      lastPingTime: 0,
+      lastPongTime: 0,
+      avgResponseTime: 0,
+      totalMessages: 0,
+      totalErrors: 0,
+      connectionStartTime: 0
+    };
+    // Message queue for disconnection handling
+    this.messageQueue = [];
+    this.MAX_QUEUE_SIZE = 100;
+    this.QUEUE_TIMEOUT = 3e4;
+    // 30 seconds
+    // Rate limiting
+    this.rateLimiter = {
+      requests: [],
+      maxRequests: 50,
+      windowMs: 1e3
+      // 1 second
+    };
+    this.validateConfiguration(options);
+    this.url = new URL(url);
+    this.url.searchParams.set("sdk_version", "0.0.1");
+    this.PING_INTERVAL = options.pingInterval ?? 3e4;
+    this.connectionStats.connectionStartTime = Date.now();
+    const startClosed = options.startClosed !== false;
+    this.rws = new reconnecting_websocket_mjs_default(this.url.toString(), [], {
+      WebSocket: globalThis.WebSocket ?? browser_default,
+      connectionTimeout: options.connectionTimeout ?? 1e3,
+      maxReconnectionDelay: 2e3,
+      minReconnectionDelay: 200,
+      maxEnqueuedMessages: 0,
+      maxRetries: options.maxRetries ?? 50,
+      startClosed
+    });
+    this.log("debug", "Transport initialized", {
+      url: this.url.toString(),
+      options
+    });
+    this.registerWatchers();
+    this.setupConnectionHealthMonitoring();
+    this.startPeriodicMaintenance();
+  }
+  /**
+   * Validate configuration options
+   */
+  validateConfiguration(options) {
+    if (options.pingInterval !== void 0 && (options.pingInterval < 1e3 || options.pingInterval > 3e5)) {
+      throw new InvalidConfigurationError("pingInterval must be between 1000ms and 300000ms");
+    }
+    if (options.connectionTimeout !== void 0 && (options.connectionTimeout < 100 || options.connectionTimeout > 3e4)) {
+      throw new InvalidConfigurationError("connectionTimeout must be between 100ms and 30000ms");
+    }
+    if (options.maxRetries !== void 0 && (options.maxRetries < 0 || options.maxRetries > 100)) {
+      throw new InvalidConfigurationError("maxRetries must be between 0 and 100");
+    }
+  }
+  /**
+   * Internal logging utility for debugging
+   */
+  log(level, message, data) {
+    if (this.options.debug) {
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const logData = data ? JSON.stringify(data, null, 2) : "";
+      console[level](`[Transport ${timestamp}] ${message}${logData ? "\n" + logData : ""}`);
+    }
+  }
+  id() {
+    return this.clientId;
+  }
+  async registerWatchers() {
+    const onMessage = (ev) => {
+      if (!(ev.data instanceof Blob)) {
+        throw new Error("Unexpected message type: " + typeof ev.data);
+      }
+      ev.data.arrayBuffer().then((buffer) => {
+        this.handleRawMessage(decode(buffer));
+      });
+    };
+    this.rws.addEventListener("message", onMessage);
+    this.disposables.add("message", {
+      dispose: () => {
+        this.rws.removeEventListener("message", onMessage);
+      }
+    });
+  }
+  async handleRawMessage(ev) {
+    if (typeof ev !== "object" || ev === null) {
+      this.log("debug", "Received invalid message format", { ev });
+      return;
+    }
+    try {
+      const { data, event, as } = ev;
+      if (!event || typeof event !== "string") {
+        throw new InvalidMessageError("Message missing event field", ev);
+      }
+      this.log("debug", "Processing message", { event, hasData: !!data });
+      if (event === "App.Actions.GetClientId" /* ClientId */) {
+        this.clientId = data.id;
+        this.log("info", "Client ID received", { clientId: this.clientId });
+        return;
+      }
+      if (event === "Events.BootError" /* BootError */) {
+        this.log("error", "Boot error received", { data });
+        return;
+      }
+      if (event === "response" /* Response */) {
+        const { responseEvent, data: responseData } = data;
+        if (!responseEvent) {
+          throw new InvalidMessageError("Response message missing responseEvent", ev);
+        }
+        this.log("debug", "Response message received", { responseEvent });
+        await this.handleMessage(responseEvent, responseData);
+        return;
+      }
+      if (event === "error" /* Error */) {
+        const { errorEvent, data: responseData } = data;
+        if (!errorEvent) {
+          throw new InvalidMessageError("Error message missing errorEvent", ev);
+        }
+        this.log("debug", "Error message received", {
+          errorEvent,
+          errorData: responseData
+        });
+        await this.handleMessage(errorEvent, responseData);
+        return;
+      }
+      await this.handleMessage(event, data, as);
+    } catch (e) {
+      this.connectionStats.totalErrors++;
+      if (e instanceof InvalidMessageError) {
+        this.log("error", "Invalid message format", {
+          error: e.message,
+          data: e.data,
+          totalErrors: this.connectionStats.totalErrors
+        });
+      } else {
+        this.log("error", "Failed to parse message", {
+          ev,
+          error: e instanceof Error ? e.message : String(e),
+          totalErrors: this.connectionStats.totalErrors
+        });
+      }
+      this.eventEmitter.emit("transport.error", {
+        type: "message_parse_error",
+        error: e,
+        rawMessage: ev,
+        timestamp: Date.now()
+      });
+    }
+  }
+  async handleMessage(event, data, as) {
+    if (event === "App.Actions.GetClientId" /* ClientId */) {
+      this.clientId = data.id;
+      this.eventEmitter.emit(event, data.id);
+      return;
+    }
+    event && this.eventEmitter.emit(as || event, data);
+  }
+  listen(event, listener, _context) {
+    return this.eventEmitter.listen(event, listener);
+  }
+  removeListener(event, listener) {
+    this.eventEmitter.removeListener(event, listener);
+  }
+  listenOnce(event, listener, context) {
+    this.eventEmitter.once(event, listener, context);
+  }
+  emit(event, ...data) {
+    this.eventEmitter.emit(event, ...data);
+  }
+  get isConnected() {
+    return this.status === "OPEN";
+  }
+  get isConnecting() {
+    return this.status === "CONNECTING";
+  }
+  get isDisconnected() {
+    return this.status === "CLOSED";
+  }
+  get isClosed() {
+    return this.closed;
+  }
+  get status() {
+    return {
+      0: "CONNECTING",
+      1: "OPEN",
+      2: "CLOSING",
+      3: "CLOSED"
+    }[this.rws.readyState];
+  }
+  async call(action, data = {}, options = {}) {
+    if (this.isRateLimited()) {
+      throw new RateLimitError("Rate limit exceeded - too many requests");
+    }
+    this.clearOldQueuedMessages();
+    const responseEvent = options.responseEvent || `${action}_${nanoid()}_response`;
+    const errorEvent = `${responseEvent}_error`;
+    let closeHandler;
+    const removeListeners = () => {
+      if (closeHandler) {
+        this.rws.removeEventListener("close", closeHandler);
+        this.rws.removeEventListener("error", closeHandler);
+      }
+      this.eventEmitter.removeListener(responseEvent);
+      this.eventEmitter.removeListener(errorEvent);
+    };
+    const handler = async (resolve, reject) => {
+      const abortError = new DOMException("Request aborted", "AbortError");
+      if (options.abortSignal?.aborted) {
+        reject(abortError);
+      }
+      if (options.abortSignal) {
+        options.abortSignal.addEventListener("abort", () => {
+          reject(abortError);
+        });
+      }
+      if (!this.isConnected && !this.isClosed) {
+        this.log("debug", "Connection not available, queuing message", {
+          action
+        });
+        if (this.messageQueue.length >= this.MAX_QUEUE_SIZE) {
+          const oldestMessage = this.messageQueue.shift();
+          if (oldestMessage) {
+            oldestMessage.reject(new Error("Message queue full, oldest message dropped"));
+          }
+        }
+        this.messageQueue.push({
+          action,
+          data,
+          options,
+          resolve,
+          reject,
+          timestamp: Date.now()
+        });
+        return;
+      }
+      const startTime = Date.now();
+      this.listenOnce(responseEvent, (response) => {
+        const responseTime = Date.now() - startTime;
+        this.connectionStats.avgResponseTime = (this.connectionStats.avgResponseTime + responseTime) / 2;
+        this.connectionStats.totalMessages++;
+        this.log("debug", "Message response received", {
+          action,
+          responseTime,
+          avgResponseTime: this.connectionStats.avgResponseTime
+        });
+        resolve(response);
+      });
+      this.listenOnce(errorEvent, (e) => {
+        this.connectionStats.totalErrors++;
+        this.log("error", "Message error received", { action, error: e });
+        reject(new ErrorEvent(e.code, e.message, e));
+      });
+      closeHandler = (_ev) => {
+        if (_ev.code === 1008 && (_ev.reason || "").includes("rate limit")) {
+          reject(new RateLimitError(_ev.reason || "Rate limit exceeded", _ev));
+          return;
+        }
+        reject(new Error(`Connection lost to the notebook during request: ${_ev.reason || "Unknown reason"}`));
+      };
+      this.rws.addEventListener("close", closeHandler);
+      this.rws.addEventListener("error", closeHandler);
+      try {
+        this.rws.send(this.pack({ action, data, errorEvent, responseEvent }));
+        this.log("debug", "Message sent", { action, data });
+      } catch (error) {
+        this.log("error", "Failed to send message", { action, error });
+        throw error;
+      }
+    };
+    const send = async () => {
+      await __privateMethod(this, _Transport_instances, connect_fn).call(this);
+      const promise = new Promise(handler).finally(removeListeners);
+      if (!options.timeout) {
+        return promise;
+      }
+      return timeout(promise, options.timeout).finally(removeListeners);
+    };
+    return this.sendWithRetry(async () => await send(), options.retries || 10);
+  }
+  pack(data) {
+    return new Blob([encode(data)]);
+  }
+  sendWithRetry(sender, retries = 10) {
+    return (0, import_async_retry.default)(
+      async (bail, attempt) => {
+        try {
+          return await sender();
+        } catch (e) {
+          if (e instanceof ErrorEvent || e instanceof RateLimitError || e instanceof InvalidConfigurationError || e instanceof InvalidMessageError || e instanceof DOMException) {
+            this.log("debug", "Non-retryable error, bailing", {
+              error: e.message,
+              attempt
+            });
+            bail(e);
+            return;
+          }
+          this.log("debug", "Retrying send operation", {
+            attempt,
+            error: e instanceof Error ? e.message : String(e),
+            nextDelay: this.getBackoffDelay(attempt - 1)
+          });
+          throw e;
+        }
+      },
+      {
+        retries,
+        onRetry: (e, attempt) => {
+          this.log("warn", "Send operation retry", {
+            attempt,
+            maxRetries: retries,
+            error: e instanceof Error ? e.message : String(e)
+          });
+        },
+        // Use exponential backoff with jitter
+        minTimeout: 1e3,
+        factor: 2,
+        maxTimeout: 3e4,
+        randomize: true
+      }
+    );
+  }
+  invoke(action, data = {}, options = {}) {
+    if (!options.responseEvent) {
+      options.responseEvent = `${action}_${nanoid()}`;
+    }
+    return this.call("invoke", { action, data }, options);
+  }
+  disconnect() {
+    if (this.closed) {
+      console.trace("Transport is already closed, cannot disconnect again");
+      return;
+    }
+    this.close();
+  }
+  close(code, reason) {
+    if (this.closed) {
+      return;
+    }
+    this.log("info", "Closing transport connection", { code, reason });
+    this.connectPromise = null;
+    const queuedCount = this.messageQueue.length;
+    this.messageQueue.forEach((msg) => {
+      console.log("Rejecting queued message due to connection close");
+      msg.reject(new Error("Connection closed while message was queued"));
+    });
+    this.messageQueue = [];
+    if (queuedCount > 0) {
+      this.log("debug", `Rejected ${queuedCount} queued messages due to connection close`);
+    }
+    this.rateLimiter.requests = [];
+    this.disposables.dispose();
+    try {
+      this.rws.close(code, reason);
+    } catch (error) {
+      this.log("error", "Error closing WebSocket", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+    this.eventEmitter.emit("transport.closed", {
+      code,
+      reason,
+      metrics: this.getConnectionMetrics(),
+      timestamp: Date.now()
+    });
+    this.eventEmitter.removeListener("*");
+    this.closed = true;
+    this.log("info", "Transport connection closed successfully");
+  }
+  onDidConnect(listener) {
+    this.rws.addEventListener("open", listener);
+    this.disposables.add("connect", {
+      dispose: () => {
+        this.rws.removeEventListener("open", listener);
+      }
+    });
+  }
+  onDidClose(listener) {
+    this.rws.addEventListener("close", listener);
+    this.disposables.add("close", {
+      dispose: () => {
+        this.rws.removeEventListener("close", listener);
+      }
+    });
+  }
+  /**
+   * Setup connection health monitoring
+   */
+  setupConnectionHealthMonitoring() {
+    this.rws.addEventListener("open", () => {
+      this.connectionStats.connectTime = Date.now();
+      this.connectionStats.reconnectCount++;
+      this.log("info", "Connection established", {
+        reconnectCount: this.connectionStats.reconnectCount,
+        timeSinceStart: Date.now() - this.connectionStats.connectionStartTime
+      });
+      this.processMessageQueue();
+    });
+    this.rws.addEventListener("close", (event) => {
+      this.log("warn", "Connection closed", {
+        code: event.code,
+        reason: event.reason,
+        wasClean: event.wasClean
+      });
+      this.handleConnectionClose(event.code);
+    });
+    this.rws.addEventListener("error", (event) => {
+      this.connectionStats.totalErrors++;
+      this.log("error", "Connection error", {
+        error: event,
+        totalErrors: this.connectionStats.totalErrors
+      });
+    });
+  }
+  /**
+   * Handle different WebSocket close codes appropriately
+   */
+  handleConnectionClose(code) {
+    switch (code) {
+      case 1e3:
+        this.log("info", "Normal connection closure");
+        return "stop";
+      case 1001:
+        this.log("info", "Connection going away, will reconnect");
+        return "reconnect";
+      case 1006:
+        this.log("warn", "Abnormal connection closure, will retry");
+        return "retry";
+      case 1008:
+        this.log("error", "Connection closed due to policy violation");
+        this.clearOldQueuedMessages();
+        return "stop";
+      default:
+        this.log("warn", `Unknown close code: ${code}, will reconnect`);
+        return "reconnect";
+    }
+  }
+  /**
+   * Process queued messages when connection is restored
+   */
+  processMessageQueue() {
+    if (this.messageQueue.length === 0) {
+      return;
+    }
+    this.log("debug", `Processing ${this.messageQueue.length} queued messages`);
+    const queue = [...this.messageQueue];
+    this.messageQueue = [];
+    for (const queuedMessage of queue) {
+      if (Date.now() - queuedMessage.timestamp > this.QUEUE_TIMEOUT) {
+        queuedMessage.reject(new Error("Queued message timed out"));
+        continue;
+      }
+      this.call(queuedMessage.action, queuedMessage.data, queuedMessage.options).then(queuedMessage.resolve).catch(queuedMessage.reject);
+    }
+  }
+  /**
+   * Clear old queued messages to prevent memory leaks
+   */
+  clearOldQueuedMessages() {
+    const now = Date.now();
+    const originalLength = this.messageQueue.length;
+    this.messageQueue = this.messageQueue.filter((msg) => {
+      const isExpired = now - msg.timestamp > this.QUEUE_TIMEOUT;
+      if (isExpired) {
+        msg.reject(new Error("Queued message expired"));
+      }
+      return !isExpired;
+    });
+    if (originalLength !== this.messageQueue.length) {
+      this.log("debug", `Cleared ${originalLength - this.messageQueue.length} expired messages`);
+    }
+  }
+  /**
+   * Rate limiting check
+   */
+  isRateLimited() {
+    const now = Date.now();
+    this.rateLimiter.requests = this.rateLimiter.requests.filter((timestamp) => now - timestamp < this.rateLimiter.windowMs);
+    if (this.rateLimiter.requests.length >= this.rateLimiter.maxRequests) {
+      return true;
+    }
+    this.rateLimiter.requests.push(now);
+    return false;
+  }
+  /**
+   * Calculate exponential backoff delay
+   */
+  getBackoffDelay(retryCount) {
+    const baseDelay = 1e3;
+    const maxDelay = 3e4;
+    const delay = Math.min(baseDelay * Math.pow(2, retryCount), maxDelay);
+    return delay + Math.random() * 1e3;
+  }
+  /**
+   * Get comprehensive connection metrics
+   */
+  getConnectionMetrics() {
+    const now = Date.now();
+    const connectionDuration = this.connectionStats.connectTime > 0 ? now - this.connectionStats.connectTime : 0;
+    return {
+      status: this.status,
+      clientId: this.clientId,
+      isConnected: this.isConnected,
+      isConnecting: this.isConnecting,
+      connectionStats: {
+        ...this.connectionStats,
+        connectionDuration,
+        uptime: now - this.connectionStats.connectionStartTime,
+        messagesPerSecond: connectionDuration > 0 ? (this.connectionStats.totalMessages / (connectionDuration / 1e3)).toFixed(2) : "0",
+        errorRate: this.connectionStats.totalMessages > 0 ? (this.connectionStats.totalErrors / this.connectionStats.totalMessages * 100).toFixed(2) + "%" : "0%",
+        timeSinceLastPing: this.connectionStats.lastPingTime > 0 ? now - this.connectionStats.lastPingTime : 0,
+        timeSinceLastPong: this.connectionStats.lastPongTime > 0 ? now - this.connectionStats.lastPongTime : 0
+      },
+      messageQueue: {
+        length: this.messageQueue.length,
+        maxSize: this.MAX_QUEUE_SIZE,
+        oldestMessageAge: this.messageQueue.length > 0 ? now - Math.min(...this.messageQueue.map((m) => m.timestamp)) : 0
+      },
+      rateLimiter: {
+        currentRequests: this.rateLimiter.requests.length,
+        maxRequests: this.rateLimiter.maxRequests,
+        windowMs: this.rateLimiter.windowMs,
+        isLimited: this.isRateLimited()
+      },
+      config: {
+        pingInterval: this.PING_INTERVAL,
+        queueTimeout: this.QUEUE_TIMEOUT,
+        url: this.url.toString()
+      }
+    };
+  }
+  /**
+   * Get connection health status
+   */
+  getHealthStatus() {
+    const metrics = this.getConnectionMetrics();
+    const stats = metrics.connectionStats;
+    if (!this.isConnected || stats.timeSinceLastPong > this.PING_INTERVAL * 2 || Number.parseFloat(stats.errorRate) > 50) {
+      return "unhealthy";
+    }
+    if (stats.avgResponseTime > 5e3 || Number.parseFloat(stats.errorRate) > 10 || stats.timeSinceLastPong > this.PING_INTERVAL * 1.5) {
+      return "degraded";
+    }
+    return "healthy";
+  }
+  /**
+   * Reset connection statistics
+   */
+  resetStats() {
+    this.connectionStats = {
+      connectTime: Date.now(),
+      reconnectCount: 0,
+      lastPingTime: 0,
+      lastPongTime: 0,
+      avgResponseTime: 0,
+      totalMessages: 0,
+      totalErrors: 0,
+      connectionStartTime: Date.now()
+    };
+    this.log("debug", "Connection statistics reset");
+  }
+  /**
+   * Run connection diagnostics
+   */
+  async runDiagnostics() {
+    const metrics = this.getConnectionMetrics();
+    const status = this.getHealthStatus();
+    const issues = [];
+    const recommendations = [];
+    if (!this.isConnected) {
+      issues.push("Connection is not established");
+      recommendations.push("Check network connectivity and server availability");
+    }
+    if (metrics.connectionStats.timeSinceLastPong > this.PING_INTERVAL * 2) {
+      issues.push("No pong received recently - connection may be stale");
+      recommendations.push("Consider forcing a reconnection");
+    }
+    if (Number.parseFloat(metrics.connectionStats.errorRate) > 10) {
+      issues.push(`High error rate: ${metrics.connectionStats.errorRate}`);
+      recommendations.push("Check server logs and network stability");
+    }
+    if (metrics.messageQueue.length > this.MAX_QUEUE_SIZE * 0.8) {
+      issues.push("Message queue is nearly full");
+      recommendations.push("Check connection stability and consider reducing message frequency");
+    }
+    if (metrics.connectionStats.avgResponseTime > 5e3) {
+      issues.push("High average response time");
+      recommendations.push("Check network latency and server performance");
+    }
+    if (metrics.rateLimiter.isLimited) {
+      issues.push("Rate limiting is active");
+      recommendations.push("Reduce request frequency or increase rate limit");
+    }
+    this.log("info", "Connection diagnostics completed", {
+      status,
+      issueCount: issues.length,
+      recommendationCount: recommendations.length
+    });
+    return {
+      status,
+      metrics,
+      issues,
+      recommendations
+    };
+  }
+  /**
+   * Periodic maintenance - clean up old data, run health checks
+   */
+  startPeriodicMaintenance() {
+    this.disposables.add("maintenance", () => {
+      const maintenanceInterval = setInterval(
+        () => {
+          this.clearOldQueuedMessages();
+          const now = Date.now();
+          this.rateLimiter.requests = this.rateLimiter.requests.filter(
+            (timestamp) => now - timestamp < this.rateLimiter.windowMs
+          );
+          if (this.options.debug) {
+            const health = this.getHealthStatus();
+            const metrics = this.getConnectionMetrics();
+            this.log("debug", "Periodic health check", {
+              health,
+              messageCount: metrics.connectionStats.totalMessages,
+              errorCount: metrics.connectionStats.totalErrors,
+              queueLength: metrics.messageQueue.length
+            });
+          }
+        },
+        5 * 60 * 1e3
+      );
+      return {
+        dispose: () => {
+          clearInterval(maintenanceInterval);
+        }
+      };
+    });
+  }
+};
+_Transport_instances = new WeakSet();
+/**
+ * Explicitly connect to the websocket if not already connected
+ * Used for lazy initialization
+ *
+ * This method ensures only one connection attempt happens at a time
+ * by caching the connection promise.
+ */
+connect_fn = function() {
+  if (this.isConnected) {
+    return Promise.resolve();
+  }
+  if (this.connectPromise) {
+    return this.connectPromise;
+  }
+  this.connectPromise = new Promise((resolve, reject) => {
+    if (this.isConnected) {
+      resolve();
+      __privateMethod(this, _Transport_instances, startPeriodicPing_fn).call(this);
+      return;
+    }
+    if (this.rws.readyState === 3) {
+      this.rws.reconnect();
+    }
+    let timeoutId;
+    const openHandler = () => {
+      this.rws.removeEventListener("open", openHandler);
+      this.rws.removeEventListener("error", errorHandler);
+      clearTimeout(timeoutId);
+      this.connectPromise = null;
+      resolve();
+      __privateMethod(this, _Transport_instances, startPeriodicPing_fn).call(this);
+    };
+    const errorHandler = (error) => {
+      this.rws.removeEventListener("open", openHandler);
+      this.rws.removeEventListener("error", errorHandler);
+      clearTimeout(timeoutId);
+      this.connectPromise = null;
+      reject(new Error(`WebSocket connection failed: ${error}`));
+    };
+    timeoutId = setTimeout(() => {
+      this.rws.removeEventListener("open", openHandler);
+      this.rws.removeEventListener("error", errorHandler);
+      this.connectPromise = null;
+      reject(new Error("WebSocket connection timeout"));
+    }, 1e4);
+    this.rws.addEventListener("open", openHandler);
+    this.rws.addEventListener("error", errorHandler);
+  });
+  return this.connectPromise;
+};
+startPeriodicPing_fn = function() {
+  this.disposables.add("pingInterval", () => {
+    const interval = setInterval(async () => {
+      try {
+        this.connectionStats.lastPingTime = Date.now();
+        this.log("debug", "Sending periodic ping");
+        const startTime = Date.now();
+        await this.invoke("ping");
+        this.connectionStats.lastPongTime = Date.now();
+        const pingTime = this.connectionStats.lastPongTime - startTime;
+        this.log("debug", `Ping successful`, { pingTime });
+      } catch (error) {
+        this.log("error", "Ping failed", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+        if (Date.now() - this.connectionStats.lastPongTime > this.PING_INTERVAL * 3) {
+          this.log("warn", "Connection appears dead, forcing reconnection");
+          this.rws.reconnect();
+        }
+      }
+    }, this.PING_INTERVAL);
+    return {
+      dispose: () => {
+        clearInterval(interval);
+      }
+    };
+  });
+};
+
+// node_modules/mitt/dist/mitt.mjs
+function mitt_default(n) {
+  return { all: n = n || /* @__PURE__ */ new Map(), on: function(t, e) {
+    var i = n.get(t);
+    i ? i.push(e) : n.set(t, [e]);
+  }, off: function(t, e) {
+    var i = n.get(t);
+    i && (e ? i.splice(i.indexOf(e) >>> 0, 1) : n.set(t, []));
+  }, emit: function(t, e) {
+    var i = n.get(t);
+    i && i.slice().map(function(n2) {
+      n2(e);
+    }), (i = n.get("*")) && i.slice().map(function(n2) {
+      n2(t, e);
+    });
+  } };
+}
+
+// src/events/index.ts
+function mittWithOnce(all) {
+  const inst = mitt_default(all);
+  inst.once = (type, fn) => {
+    inst.on(type, fn);
+    inst.on(type, inst.off.bind(inst, type, fn));
+  };
+  return inst;
+}
+var EE = mittWithOnce();
+var EventManager = class _EventManager {
+  listen(event, callback) {
+    const dispose = () => {
+      this.removeListener(event, callback);
+    };
+    EE.on(event, callback);
+    return { dispose };
+  }
+  emit(event, data) {
+    EE.emit(event, data);
+  }
+  once(event, callback) {
+    EE.once(event, callback);
+  }
+  static make() {
+    return _EventManager.instance || (_EventManager.instance = new _EventManager());
+  }
+  static refresh() {
+    EE.all.clear();
+    EE = mittWithOnce();
+    return _EventManager.instance = new _EventManager();
+  }
+  removeListener(event, callbackSignature) {
+    EE.off(event, callbackSignature);
+  }
+  static createInstance() {
+    EE = mittWithOnce();
+    _EventManager.instance = new _EventManager();
+    return _EventManager.instance;
+  }
+  inspect() {
+    return EE.all;
+  }
+};
+
+// src/git.ts
+var Git = class {
+  constructor(okra) {
+    this.okra = okra;
+  }
+  checkpoint(author, message, branch = "main") {
+    return this.okra.invoke("git.checkpoint", { author, message, branch });
+  }
+  sync(url, author, ref = "main", token, direction = "both", force = false) {
+    return this.okra.invoke("git.sync", { url, author, ref, token, direction, force });
+  }
+  log(ref = "main") {
+    return this.okra.invoke("git.log", { ref });
+  }
+  restore(ref) {
+    return this.okra.invoke("git.restore", { ref });
+  }
+};
+
+// src/beacon/index.ts
+var import_async_retry2 = __toESM(require_lib(), 1);
+
+// 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(url) {
+    if (!this.beacon) {
+      throw new Error("Beacon reference not set");
+    }
+    this.beacon.navigate(url);
+    if (this.currentIndex < this.urlHistory.length - 1) {
+      this.urlHistory = this.urlHistory.slice(0, this.currentIndex + 1);
+    }
+    this.urlHistory.push(url);
+    this.currentIndex = this.urlHistory.length - 1;
+    this.updateNavigationState();
+    this.emitHistoryChange(url, "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(url) {
+    if (this.currentIndex < this.urlHistory.length - 1) {
+      this.urlHistory = this.urlHistory.slice(0, this.currentIndex + 1);
+    }
+    this.urlHistory.push(url);
+    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 url = this.urlHistory[this.currentIndex];
+    if (!this.beacon) {
+      return { success: false, error: "Beacon reference not set" };
+    }
+    this.beacon.navigate(url);
+    this.emitHistoryChange(url, "back");
+    return { success: true, url };
+  }
+  /**
+   * 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 url = this.urlHistory[this.currentIndex];
+    if (!this.beacon) {
+      return { success: false, error: "Beacon reference not set" };
+    }
+    this.beacon.navigate(url);
+    this.emitHistoryChange(url, "forward");
+    return { success: true, url };
+  }
+  /**
+   * 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(url, direction) {
+    if (this.beacon && this.beacon.emit) {
+      this.beacon.emit("historyChange", {
+        url,
+        state: null,
+        direction,
+        timestamp: Date.now()
+      });
+    }
+  }
+  /**
+   * Push a new state to internal history (legacy method for compatibility)
+   */
+  async pushState(url) {
+    this.visit(url);
+  }
+  /**
+   * Replace current state in internal history (legacy method for compatibility)
+   */
+  async replaceState(url) {
+    if (this.currentIndex >= 0 && this.currentIndex < this.urlHistory.length) {
+      this.urlHistory[this.currentIndex] = url;
+      if (!this.beacon) {
+        throw new Error("Beacon reference not set");
+      }
+      this.beacon.navigate(url);
+      this.emitHistoryChange(url, "replace");
+    } else {
+      this.visit(url);
+    }
+  }
+  /**
+   * 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((error) => {
+            if (this.options.debug) {
+              console.error("[Beacon SDK] Channel establishment failed:", error);
+            }
+          });
+        }
+        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 (error) {
+        if (this.options.debug) {
+          console.error("[Beacon SDK] Message parsing error:", error);
+        }
+      }
+    };
+    window.addEventListener("message", readyHandler);
+    this.disposables.push({
+      dispose: () => window.removeEventListener("message", readyHandler)
+    });
+  }
+  /**
+   * Establish MessagePort communication channel
+   */
+  async establishChannel() {
+    if (!this.iframe.contentWindow) {
+      throw new BeaconConnectionError("Iframe contentWindow not available");
+    }
+    this.messageChannel = new MessageChannel();
+    this.port = this.messageChannel.port1;
+    this.port.onmessage = (event) => {
+      this.handleBeaconMessage(event.data);
+    };
+    this.port.onmessageerror = (event) => {
+      if (this.options.debug) {
+        console.error("[Beacon SDK] Port message error:", event);
+      }
+    };
+    this.port.start();
+    const establishMessage = {
+      type: "beacon:establish-channel",
+      timestamp: Date.now(),
+      id: this.generateId()
+    };
+    this.iframe.contentWindow.postMessage(
+      establishMessage,
+      "*",
+      // Safe for channel establishment
+      [this.messageChannel.port2]
+      // Transfer the port
+    );
+    if (this.options.debug) {
+      console.log("[Beacon SDK] Channel establishment message sent");
+    }
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        reject(new BeaconConnectionError("Channel establishment timeout"));
+      }, this.options.timeout);
+      const checkReady = () => {
+        if (this.channelEstablished && this.isBeaconReady) {
+          clearTimeout(timeoutId);
+          resolve();
+        } else {
+          setTimeout(checkReady, 100);
+        }
+      };
+      checkReady();
+    });
+  }
+  /**
+   * Handle incoming beacon messages
+   */
+  handleBeaconMessage(message) {
+    if (this.options.debug) {
+      console.log("[Beacon SDK] Received message:", message.type, message.payload);
+    }
+    const eventType = message.type.replace("beacon:", "");
+    this.emit(eventType, message.payload);
+    const handlers = this.messageHandlers.get(message.type);
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(message.payload);
+        } catch (error) {
+          if (this.options.debug) {
+            console.error("[Beacon SDK] Message handler error:", error);
+          }
+        }
+      });
+    }
+  }
+  /**
+   * Wait for beacon to be ready - simplified approach
+   */
+  waitForBeaconReady() {
+    return (0, import_async_retry2.default)(
+      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: (error, attempt) => {
+          if (this.options.debug) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.warn(`[Beacon SDK] Beacon ready retry attempt ${attempt}:`, errorMessage);
+          }
+          this.isBeaconReady = false;
+          this.channelEstablished = false;
+        }
+      }
+    );
+  }
+  /**
+   * Send a message to the beacon via MessagePort
+   */
+  sendMessage(type, payload = {}) {
+    if (!this.port) {
+      throw new BeaconConnectionError("MessagePort not available - channel not established");
+    }
+    const message = {
+      type: `beacon:${type}`,
+      payload,
+      timestamp: Date.now(),
+      source: "parent",
+      id: this.generateId()
+    };
+    try {
+      this.port.postMessage(message);
+      if (this.options.debug) {
+        console.log("[Beacon SDK] Sent message via port:", message.type, message.payload);
+      }
+    } catch (error) {
+      throw new BeaconConnectionError(
+        `Failed to send message via port: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Send a message and wait for a specific response with retry logic
+   */
+  async sendAndWaitFor(sendType, responseType, payload = {}, timeoutMs) {
+    await this.ready();
+    return (0, import_async_retry2.default)(
+      async (bail) => {
+        return new Promise((resolve, reject) => {
+          const actualTimeout = timeoutMs || this.options.timeout;
+          const timeoutId = setTimeout(() => {
+            unsubscribe.dispose();
+            const error = new BeaconTimeoutError(sendType, actualTimeout);
+            reject(error);
+          }, actualTimeout);
+          const unsubscribe = this.eventEmitter.listen(responseType, (data) => {
+            clearTimeout(timeoutId);
+            unsubscribe.dispose();
+            resolve(data);
+          });
+          try {
+            this.sendMessage(sendType, payload);
+          } catch (error) {
+            clearTimeout(timeoutId);
+            unsubscribe.dispose();
+            if (error instanceof BeaconConnectionError) {
+              reject(error);
+            } else {
+              bail(error);
+            }
+          }
+        });
+      },
+      {
+        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: (error, attempt) => {
+          if (this.options.debug) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.warn(`[Beacon SDK] Retry attempt ${attempt} for ${sendType}:`, errorMessage);
+          }
+        }
+      }
+    );
+  }
+  /**
+   * Generate a unique ID for messages
+   */
+  generateId() {
+    return `sdk_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+  }
+  /**
+   * Event emitter methods (both private and public for navigator access)
+   */
+  emit(event, payload) {
+    this.eventEmitter.emit(event, payload);
+  }
+  /**
+   * Start the beacon initialization process
+   */
+  start() {
+    if (this.isStarted) {
+      return this.readyPromise || Promise.resolve();
+    }
+    this.isStarted = true;
+    this.readyPromise = this.waitForBeaconReady();
+    return this.readyPromise;
+  }
+  /**
+   * Wait for the beacon to be ready
+   */
+  async ready() {
+    if (!this.isStarted) {
+      throw new BeaconError("Beacon has not been started. Call start() first.");
+    }
+    if (!this.readyPromise) {
+      throw new BeaconError("Beacon ready promise is not available");
+    }
+    return timeout(this.readyPromise, this.options.timeout);
+  }
+  /**
+   * Check if beacon is ready
+   */
+  get isReady() {
+    return this.isBeaconReady;
+  }
+  /**
+   * Listen for beacon events
+   */
+  on(event, handler) {
+    return this.eventEmitter.listen(event, handler);
+  }
+  /**
+   * Listen for beacon events (one-time)
+   */
+  once(event, handler) {
+    this.eventEmitter.once(event, handler);
+  }
+  /**
+   * Ping the beacon to check if it's responsive
+   */
+  async ping() {
+    try {
+      await this.sendAndWaitFor("ping", "pong", { timestamp: Date.now() });
+      return true;
+    } catch (error) {
+      if (this.options.debug) {
+        console.warn("[Beacon SDK] Ping failed:", error);
+      }
+      return false;
+    }
+  }
+  /**
+   * Get debug information from the beacon
+   */
+  async getDebugInfo() {
+    return this.sendAndWaitFor("getDebugInfo", "debugInfo");
+  }
+  /**
+   * Get console events from the beacon
+   */
+  async getConsoleEvents() {
+    return this.sendAndWaitFor("getConsoleEvents", "consoleEvents");
+  }
+  /**
+   * Get error events from the beacon
+   */
+  async getErrorEvents() {
+    return this.sendAndWaitFor("getErrorEvents", "errorEvents");
+  }
+  /**
+   * Clear console events in the beacon
+   */
+  async clearConsole() {
+    await this.ready();
+    this.sendMessage("clearConsole");
+  }
+  /**
+   * Clear error events in the beacon
+   */
+  async clearErrors() {
+    await this.ready();
+    this.sendMessage("clearErrors");
+  }
+  /**
+   * Execute code in the beacon context
+   */
+  async executeCode(code) {
+    return this.sendAndWaitFor("executeCode", "codeExecutionResult", { code });
+  }
+  /**
+   * Inspect an element in the beacon context
+   */
+  async inspectElement(selector) {
+    return this.sendAndWaitFor("inspectElement", "elementInspectionResult", { selector });
+  }
+  /**
+   * Fetch a URL in the beacon context
+   */
+  async fetch(request) {
+    return this.sendAndWaitFor("fetch", "fetchResult", request);
+  }
+  /**
+   * Debug a page (navigate and capture debug information). It loads
+   * the page fresh in the IFRAME so that we can capture the latest state.
+   */
+  async debug(request, waitSeconds) {
+    const targetUrl = new URL(request.path, this.iframe.src || window.location.origin).href;
+    if (this.iframe.src !== targetUrl) {
+      this.navigator.visit(targetUrl);
+      await this.ready();
+    }
+    waitSeconds && await this.wait(waitSeconds);
+    const timeoutMs = (request.options?.timeout || 3e4) + 5e3;
+    return this.sendAndWaitFor("debug", "debugResult", request, timeoutMs);
+  }
+  async wait(forSeconds) {
+    return new Promise((resolve) => setTimeout(resolve, forSeconds * 1e3));
+  }
+  /**
+   * Navigate the iframe to a new URL
+   */
+  navigate(url) {
+    if (!this.iframe) {
+      throw new BeaconConnectionError("Iframe not available");
+    }
+    try {
+      const targetUrl = new URL(url, 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 (error) {
+      throw new BeaconConnectionError(`Invalid URL: ${url}`);
+    }
+  }
+  /**
+   * Get current iframe URL
+   */
+  get url() {
+    return this.iframe.src;
+  }
+  /**
+   * Get the iframe element
+   */
+  get element() {
+    return this.iframe;
+  }
+  /**
+   * Dispose of all resources
+   */
+  dispose() {
+    if (this.port) {
+      this.port.close();
+      this.port = null;
+    }
+    if (this.messageChannel) {
+      this.messageChannel = null;
+    }
+    this.disposables.forEach((disposable) => disposable.dispose());
+    this.disposables = [];
+    this.messageHandlers.clear();
+    this.isBeaconReady = false;
+    this.channelEstablished = false;
+    this.isStarted = false;
+    this.readyPromise = null;
+  }
+};
+function createBeacon(iframe, options) {
+  return new Beacon(iframe, options);
+}
+function isBeaconSupported() {
+  try {
+    ensureBrowserEnvironment();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/index.ts
+var NotebookInitError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.message = message;
+  }
+};
+var ApiError = class extends Error {
+  constructor(response, body) {
+    super(`PHPSandbox API Error: ${response.status} ${response.statusText} - ${body}`);
+    this.response = response;
+    this.body = body;
+    this.status = response.status;
+  }
+};
+var NotebookApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async create(template, input = {}, init = true) {
+    const response = await this.client.post("/notebook", { template, ...input });
+    const instance = new NotebookInstance(response.data, this.client);
+    if (!init) {
+      return instance;
+    }
+    return this.init(instance);
+  }
+  async get(id) {
+    const response = await this.client.get(`/notebook/${id}`);
+    return new NotebookInstance(response.data, this.client);
+  }
+  async fork(id) {
+    const response = await this.client.post(`/notebook/${id}/fork`);
+    return this.init(new NotebookInstance(response.data, this.client));
+  }
+  async open(id) {
+    const response = await this.client.get(`/notebook/${id}`);
+    return new NotebookInstance(response.data, this.client);
+  }
+  openFromData(data) {
+    return this.init(new NotebookInstance(data, this.client));
+  }
+  async init(instance) {
+    await instance.ready();
+    return instance;
+  }
+};
+var Client = class {
+  constructor(token, url = "https://api.phpsandbox.io/v1", options = {}) {
+    this.fetch = globalThis.fetch;
+    this.notebook = new NotebookApi(this);
+    this.options = Object.assign({ startClosed: true }, options);
+    this.baseUrl = url;
+    if (options.fetch) {
+      this.fetch = options.fetch;
+    }
+    this.headers = {
+      "Accept": "application/json",
+      "Authorization": `Bearer ${token}`,
+      "Content-Type": "application/json"
+    };
+  }
+  get(path) {
+    return this.makeRequest("GET", path);
+  }
+  post(path, body) {
+    return this.makeRequest("POST", path, { body: body ? JSON.stringify(body) : void 0 });
+  }
+  async makeRequest(method, path, init) {
+    const response = await this.fetch(
+      new Request(new URL(`v1/${path.replace(/^\//, "")}`, this.baseUrl), {
+        method,
+        ...init,
+        headers: this.headers
+      })
+    );
+    if (!response.ok) {
+      throw new ApiError(response, await response.text());
+    }
+    return { data: await response.json() };
+  }
+};
+var PHPSandbox = class extends Client {
+};
+var _initPromise, _NotebookInstance_instances, init_fn;
+var _NotebookInstance = class _NotebookInstance {
+  constructor(data, client) {
+    this.data = data;
+    this.client = client;
+    __privateAdd(this, _NotebookInstance_instances);
+    this.initialized = false;
+    __privateAdd(this, _initPromise);
+    this.disposables = [];
+    this.emitter = EventManager.createInstance();
+    this.socket = new Transport(data.okraUrl, this.emitter, {
+      debug: client.options.debug,
+      startClosed: client.options.startClosed
+    });
+    this.watchConnection();
+    __privateSet(this, _initPromise, __privateMethod(this, _NotebookInstance_instances, init_fn).call(this));
+    this.file = new Filesystem(this);
+    this.terminal = new Terminal(this);
+    this.auth = new Auth(this);
+    this.lsp = new Lsp(this);
+    this.composer = new Composer(this);
+    this.log = new Log(this);
+    this.repl = new Repl(this);
+    this.container = new Container(this);
+    this.laravel = new Lravel(this);
+    this.shell = new Shell(this);
+    this.git = new Git(this);
+  }
+  async ready() {
+    const ready = async () => {
+      if (this.client.options.startClosed && !this.socket.isConnected) {
+        await this.socket.invoke("ping");
+      }
+      return __privateGet(this, _initPromise);
+    };
+    return ready();
+  }
+  fork() {
+    return this.client.notebook.fork(this.data.id);
+  }
+  stop() {
+    return this.container.stop();
+  }
+  restart() {
+    return this.container.start();
+  }
+  invoke(action, data = {}, options = {}) {
+    return this.socket.invoke(action, data || {}, options);
+  }
+  ping() {
+    return this.invoke("ping");
+  }
+  listen(event, handler) {
+    return this.emitter.listen(event, handler);
+  }
+  dispose() {
+    this.disposables.forEach((d) => d.dispose());
+    !this.socket.isClosed && this.socket.disconnect();
+  }
+  connected() {
+    if (this.socket.isConnected) {
+      return Promise.resolve(this);
+    }
+    return new Promise((resolve, reject) => {
+      try {
+        this.socket.onDidConnect(() => resolve(this));
+        this.socket.onDidClose(() => reject(new Error("Connection closed")));
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+  whenConnected() {
+    if (this.socket.isConnected) {
+      return Promise.resolve(this);
+    }
+    return new Promise((resolve, reject) => {
+      try {
+        this.socket.onDidConnect(() => resolve(this));
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+  watchConnection() {
+    this.socket.onDidConnect(() => {
+      this.socket.emit("okra.connected");
+      if (this.client.options.telemetry) {
+        this.container.enableTelemetry(this.client.options.telemetry);
+      }
+    });
+    this.socket.onDidClose(() => {
+      this.socket.emit("okra.disconnected");
+      this.initialized = false;
+    });
+  }
+  onDidConnect(handler) {
+    this.socket.removeListener("okra.connected", handler);
+    const disposable = this.socket.listen("okra.connected", handler);
+    this.disposables.push(disposable);
+    return disposable;
+  }
+  onDidDisconnect(handler) {
+    const disposable = this.socket.listen("okra.disconnected", handler);
+    this.disposables.push(disposable);
+    return disposable;
+  }
+  update() {
+    return this.invoke("notebook.update");
+  }
+  onDidInitialize(handler) {
+    const disposable = this.listen("notebook.initialized", handler);
+    this.disposables.push(disposable);
+    return disposable;
+  }
+  reconnect() {
+    this.dispose();
+    return new _NotebookInstance(this.data, this.client);
+  }
+  async beacon(iframe, options) {
+    const result = await this.ready();
+    iframe.src = result.data.previewUrl;
+    return createBeacon(iframe, options);
+  }
+};
+_initPromise = new WeakMap();
+_NotebookInstance_instances = new WeakSet();
+init_fn = function() {
+  return new Promise((resolve, reject) => {
+    this.onDidInitialize((result) => {
+      this.initialized = result;
+      if (result.type === "error") {
+        reject(new NotebookInitError(result.message));
+      }
+      resolve(result);
+    });
+  });
+};
+var NotebookInstance = _NotebookInstance;
+export {
+  ApiError,
+  Beacon,
+  BeaconConnectionError,
+  BeaconError,
+  BeaconTimeoutError,
+  Client,
+  CommandError,
+  ErrorEvent,
+  FileChangeType,
+  FileType,
+  Filesystem,
+  FilesystemError,
+  FilesystemErrorType,
+  LspConnection,
+  Navigator,
+  NotebookApi,
+  NotebookInitError,
+  NotebookInstance,
+  NotebookState,
+  PHPSandbox,
+  PHPSandboxError,
+  PromiseTimeoutError,
+  RateLimitError,
+  Transport,
+  createBeacon,
+  isBeaconSupported,
+  timeout
+};
+/*! Bundled license information:
+
+reconnecting-websocket/dist/reconnecting-websocket-mjs.js:
+  (*! *****************************************************************************
+  Copyright (c) Microsoft Corporation. All rights reserved.
+  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+  this file except in compliance with the License. You may obtain a copy of the
+  License at http://www.apache.org/licenses/LICENSE-2.0
+  
+  THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+  WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+  MERCHANTABLITY OR NON-INFRINGEMENT.
+  
+  See the Apache Version 2.0 License for specific language governing permissions
+  and limitations under the License.
+  ***************************************************************************** *)
+  (*!
+   * Reconnecting WebSocket
+   * by Pedro Ladaria <pedro.ladaria@gmail.com>
+   * https://github.com/pladaria/reconnecting-websocket
+   * License MIT
+   *)
+*/
+//# sourceMappingURL=phpsandbox-sdk.esm.js.map