@gitterm/opencode-cloud 0.0.0-stage → 0.1.3

package/dist/index.js

@@ -0,0 +1,4192 @@
+// @bun
+// src/index.ts
+import { Plugin } from "@opencode/plugin";
+import { OpenCode as OpenCode2 } from "@opencode/client";
+import { Service } from "@opencode/client/service";
+
+// ../../node_modules/.bun/@trpc+client@11.8.1+56fb0e3277503e89/node_modules/@trpc/client/dist/objectSpread2-BvkFp-_Y.mjs
+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 __commonJS = (cb, mod) => function() {
+  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 (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key;i < n; i++) {
+      key = keys[i];
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, {
+          get: ((k) => from[k]).bind(null, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+    }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var require_typeof = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/typeof.js"(exports, module) {
+  function _typeof$2(o) {
+    "@babel/helpers - typeof";
+    return module.exports = _typeof$2 = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(o$1) {
+      return typeof o$1;
+    } : function(o$1) {
+      return o$1 && typeof Symbol == "function" && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+    }, module.exports.__esModule = true, module.exports["default"] = module.exports, _typeof$2(o);
+  }
+  module.exports = _typeof$2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_toPrimitive = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/toPrimitive.js"(exports, module) {
+  var _typeof$1 = require_typeof()["default"];
+  function toPrimitive$1(t, r) {
+    if (_typeof$1(t) != "object" || !t)
+      return t;
+    var e = t[Symbol.toPrimitive];
+    if (e !== undefined) {
+      var i = e.call(t, r || "default");
+      if (_typeof$1(i) != "object")
+        return i;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (r === "string" ? String : Number)(t);
+  }
+  module.exports = toPrimitive$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_toPropertyKey = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/toPropertyKey.js"(exports, module) {
+  var _typeof = require_typeof()["default"];
+  var toPrimitive = require_toPrimitive();
+  function toPropertyKey$1(t) {
+    var i = toPrimitive(t, "string");
+    return _typeof(i) == "symbol" ? i : i + "";
+  }
+  module.exports = toPropertyKey$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_defineProperty = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/defineProperty.js"(exports, module) {
+  var toPropertyKey = require_toPropertyKey();
+  function _defineProperty(e, r, t) {
+    return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+      value: t,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    }) : e[r] = t, e;
+  }
+  module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_objectSpread2 = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/objectSpread2.js"(exports, module) {
+  var defineProperty = require_defineProperty();
+  function ownKeys(e, r) {
+    var t = Object.keys(e);
+    if (Object.getOwnPropertySymbols) {
+      var o = Object.getOwnPropertySymbols(e);
+      r && (o = o.filter(function(r$1) {
+        return Object.getOwnPropertyDescriptor(e, r$1).enumerable;
+      })), t.push.apply(t, o);
+    }
+    return t;
+  }
+  function _objectSpread2(e) {
+    for (var r = 1;r < arguments.length; r++) {
+      var t = arguments[r] != null ? arguments[r] : {};
+      r % 2 ? ownKeys(Object(t), true).forEach(function(r$1) {
+        defineProperty(e, r$1, t[r$1]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r$1) {
+        Object.defineProperty(e, r$1, Object.getOwnPropertyDescriptor(t, r$1));
+      });
+    }
+    return e;
+  }
+  module.exports = _objectSpread2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+
+// ../../node_modules/.bun/@trpc+server@11.8.1+1fb4c65d43e298b9/node_modules/@trpc/server/dist/observable-UMO3vUa_.mjs
+function observable(subscribe) {
+  const self = {
+    subscribe(observer) {
+      let teardownRef = null;
+      let isDone = false;
+      let unsubscribed = false;
+      let teardownImmediately = false;
+      function unsubscribe() {
+        if (teardownRef === null) {
+          teardownImmediately = true;
+          return;
+        }
+        if (unsubscribed)
+          return;
+        unsubscribed = true;
+        if (typeof teardownRef === "function")
+          teardownRef();
+        else if (teardownRef)
+          teardownRef.unsubscribe();
+      }
+      teardownRef = subscribe({
+        next(value) {
+          var _observer$next;
+          if (isDone)
+            return;
+          (_observer$next = observer.next) === null || _observer$next === undefined || _observer$next.call(observer, value);
+        },
+        error(err) {
+          var _observer$error;
+          if (isDone)
+            return;
+          isDone = true;
+          (_observer$error = observer.error) === null || _observer$error === undefined || _observer$error.call(observer, err);
+          unsubscribe();
+        },
+        complete() {
+          var _observer$complete;
+          if (isDone)
+            return;
+          isDone = true;
+          (_observer$complete = observer.complete) === null || _observer$complete === undefined || _observer$complete.call(observer);
+          unsubscribe();
+        }
+      });
+      if (teardownImmediately)
+        unsubscribe();
+      return { unsubscribe };
+    },
+    pipe(...operations) {
+      return operations.reduce(pipeReducer, self);
+    }
+  };
+  return self;
+}
+function pipeReducer(prev, fn) {
+  return fn(prev);
+}
+function observableToPromise(observable$1) {
+  const ac = new AbortController;
+  const promise = new Promise((resolve, reject) => {
+    let isDone = false;
+    function onDone() {
+      if (isDone)
+        return;
+      isDone = true;
+      obs$.unsubscribe();
+    }
+    ac.signal.addEventListener("abort", () => {
+      reject(ac.signal.reason);
+    });
+    const obs$ = observable$1.subscribe({
+      next(data) {
+        isDone = true;
+        resolve(data);
+        onDone();
+      },
+      error(data) {
+        reject(data);
+      },
+      complete() {
+        ac.abort();
+        onDone();
+      }
+    });
+  });
+  return promise;
+}
+
+// ../../node_modules/.bun/@trpc+server@11.8.1+1fb4c65d43e298b9/node_modules/@trpc/server/dist/observable-CUiPknO-.mjs
+function share(_opts) {
+  return (source) => {
+    let refCount = 0;
+    let subscription = null;
+    const observers = [];
+    function startIfNeeded() {
+      if (subscription)
+        return;
+      subscription = source.subscribe({
+        next(value) {
+          for (const observer of observers) {
+            var _observer$next;
+            (_observer$next = observer.next) === null || _observer$next === undefined || _observer$next.call(observer, value);
+          }
+        },
+        error(error) {
+          for (const observer of observers) {
+            var _observer$error;
+            (_observer$error = observer.error) === null || _observer$error === undefined || _observer$error.call(observer, error);
+          }
+        },
+        complete() {
+          for (const observer of observers) {
+            var _observer$complete;
+            (_observer$complete = observer.complete) === null || _observer$complete === undefined || _observer$complete.call(observer);
+          }
+        }
+      });
+    }
+    function resetIfNeeded() {
+      if (refCount === 0 && subscription) {
+        const _sub = subscription;
+        subscription = null;
+        _sub.unsubscribe();
+      }
+    }
+    return observable((subscriber) => {
+      refCount++;
+      observers.push(subscriber);
+      startIfNeeded();
+      return { unsubscribe() {
+        refCount--;
+        resetIfNeeded();
+        const index = observers.findIndex((v) => v === subscriber);
+        if (index > -1)
+          observers.splice(index, 1);
+      } };
+    });
+  };
+}
+var distinctUnsetMarker = Symbol();
+function behaviorSubject(initialValue) {
+  let value = initialValue;
+  const observerList = [];
+  const addObserver = (observer) => {
+    if (value !== undefined)
+      observer.next(value);
+    observerList.push(observer);
+  };
+  const removeObserver = (observer) => {
+    observerList.splice(observerList.indexOf(observer), 1);
+  };
+  const obs = observable((observer) => {
+    addObserver(observer);
+    return () => {
+      removeObserver(observer);
+    };
+  });
+  obs.next = (nextValue) => {
+    if (value === nextValue)
+      return;
+    value = nextValue;
+    for (const observer of observerList)
+      observer.next(nextValue);
+  };
+  obs.get = () => value;
+  return obs;
+}
+
+// ../../node_modules/.bun/@trpc+client@11.8.1+56fb0e3277503e89/node_modules/@trpc/client/dist/splitLink-B7Cuf2c_.mjs
+function createChain(opts) {
+  return observable((observer) => {
+    function execute(index = 0, op = opts.op) {
+      const next = opts.links[index];
+      if (!next)
+        throw new Error("No more links to execute - did you forget to add an ending link?");
+      const subscription = next({
+        op,
+        next(nextOp) {
+          const nextObserver = execute(index + 1, nextOp);
+          return nextObserver;
+        }
+      });
+      return subscription;
+    }
+    const obs$ = execute();
+    return obs$.subscribe(observer);
+  });
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+function splitLink(opts) {
+  return (runtime) => {
+    const yes = asArray(opts.true).map((link) => link(runtime));
+    const no = asArray(opts.false).map((link) => link(runtime));
+    return (props) => {
+      return observable((observer) => {
+        const links = opts.condition(props.op) ? yes : no;
+        return createChain({
+          op: props.op,
+          links
+        }).subscribe(observer);
+      });
+    };
+  };
+}
+
+// ../../node_modules/.bun/@trpc+server@11.8.1+1fb4c65d43e298b9/node_modules/@trpc/server/dist/codes-DagpWZLc.mjs
+function isObject(value) {
+  return !!value && !Array.isArray(value) && typeof value === "object";
+}
+function emptyObject() {
+  return Object.create(null);
+}
+var run = (fn) => fn();
+var TRPC_ERROR_CODES_BY_KEY = {
+  PARSE_ERROR: -32700,
+  BAD_REQUEST: -32600,
+  INTERNAL_SERVER_ERROR: -32603,
+  NOT_IMPLEMENTED: -32603,
+  BAD_GATEWAY: -32603,
+  SERVICE_UNAVAILABLE: -32603,
+  GATEWAY_TIMEOUT: -32603,
+  UNAUTHORIZED: -32001,
+  PAYMENT_REQUIRED: -32002,
+  FORBIDDEN: -32003,
+  NOT_FOUND: -32004,
+  METHOD_NOT_SUPPORTED: -32005,
+  TIMEOUT: -32008,
+  CONFLICT: -32009,
+  PRECONDITION_FAILED: -32012,
+  PAYLOAD_TOO_LARGE: -32013,
+  UNSUPPORTED_MEDIA_TYPE: -32015,
+  UNPROCESSABLE_CONTENT: -32022,
+  PRECONDITION_REQUIRED: -32028,
+  TOO_MANY_REQUESTS: -32029,
+  CLIENT_CLOSED_REQUEST: -32099
+};
+var retryableRpcCodes = [
+  TRPC_ERROR_CODES_BY_KEY.BAD_GATEWAY,
+  TRPC_ERROR_CODES_BY_KEY.SERVICE_UNAVAILABLE,
+  TRPC_ERROR_CODES_BY_KEY.GATEWAY_TIMEOUT,
+  TRPC_ERROR_CODES_BY_KEY.INTERNAL_SERVER_ERROR
+];
+
+// ../../node_modules/.bun/@trpc+server@11.8.1+1fb4c65d43e298b9/node_modules/@trpc/server/dist/getErrorShape-vC8mUXJD.mjs
+var __create2 = Object.create;
+var __defProp2 = Object.defineProperty;
+var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames2 = Object.getOwnPropertyNames;
+var __getProtoOf2 = Object.getPrototypeOf;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __commonJS2 = (cb, mod) => function() {
+  return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps2 = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function")
+    for (var keys = __getOwnPropNames2(from), i = 0, n = keys.length, key;i < n; i++) {
+      key = keys[i];
+      if (!__hasOwnProp2.call(to, key) && key !== except)
+        __defProp2(to, key, {
+          get: ((k) => from[k]).bind(null, key),
+          enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable
+        });
+    }
+  return to;
+};
+var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var noop = () => {};
+var freezeIfAvailable = (obj) => {
+  if (Object.freeze)
+    Object.freeze(obj);
+};
+function createInnerProxy(callback, path, memo) {
+  var _memo$cacheKey;
+  const cacheKey = path.join(".");
+  (_memo$cacheKey = memo[cacheKey]) !== null && _memo$cacheKey !== undefined || (memo[cacheKey] = new Proxy(noop, {
+    get(_obj, key) {
+      if (typeof key !== "string" || key === "then")
+        return;
+      return createInnerProxy(callback, [...path, key], memo);
+    },
+    apply(_1, _2, args) {
+      const lastOfPath = path[path.length - 1];
+      let opts = {
+        args,
+        path
+      };
+      if (lastOfPath === "call")
+        opts = {
+          args: args.length >= 2 ? [args[1]] : [],
+          path: path.slice(0, -1)
+        };
+      else if (lastOfPath === "apply")
+        opts = {
+          args: args.length >= 2 ? args[1] : [],
+          path: path.slice(0, -1)
+        };
+      freezeIfAvailable(opts.args);
+      freezeIfAvailable(opts.path);
+      return callback(opts);
+    }
+  }));
+  return memo[cacheKey];
+}
+var createRecursiveProxy = (callback) => createInnerProxy(callback, [], emptyObject());
+var createFlatProxy = (callback) => {
+  return new Proxy(noop, { get(_obj, name) {
+    if (name === "then")
+      return;
+    return callback(name);
+  } });
+};
+var require_typeof2 = __commonJS2({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/typeof.js"(exports, module) {
+  function _typeof$2(o) {
+    "@babel/helpers - typeof";
+    return module.exports = _typeof$2 = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(o$1) {
+      return typeof o$1;
+    } : function(o$1) {
+      return o$1 && typeof Symbol == "function" && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+    }, module.exports.__esModule = true, module.exports["default"] = module.exports, _typeof$2(o);
+  }
+  module.exports = _typeof$2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_toPrimitive2 = __commonJS2({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/toPrimitive.js"(exports, module) {
+  var _typeof$1 = require_typeof2()["default"];
+  function toPrimitive$1(t, r) {
+    if (_typeof$1(t) != "object" || !t)
+      return t;
+    var e = t[Symbol.toPrimitive];
+    if (e !== undefined) {
+      var i = e.call(t, r || "default");
+      if (_typeof$1(i) != "object")
+        return i;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (r === "string" ? String : Number)(t);
+  }
+  module.exports = toPrimitive$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_toPropertyKey2 = __commonJS2({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/toPropertyKey.js"(exports, module) {
+  var _typeof = require_typeof2()["default"];
+  var toPrimitive = require_toPrimitive2();
+  function toPropertyKey$1(t) {
+    var i = toPrimitive(t, "string");
+    return _typeof(i) == "symbol" ? i : i + "";
+  }
+  module.exports = toPropertyKey$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_defineProperty2 = __commonJS2({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/defineProperty.js"(exports, module) {
+  var toPropertyKey = require_toPropertyKey2();
+  function _defineProperty(e, r, t) {
+    return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+      value: t,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    }) : e[r] = t, e;
+  }
+  module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_objectSpread22 = __commonJS2({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/objectSpread2.js"(exports, module) {
+  var defineProperty = require_defineProperty2();
+  function ownKeys(e, r) {
+    var t = Object.keys(e);
+    if (Object.getOwnPropertySymbols) {
+      var o = Object.getOwnPropertySymbols(e);
+      r && (o = o.filter(function(r$1) {
+        return Object.getOwnPropertyDescriptor(e, r$1).enumerable;
+      })), t.push.apply(t, o);
+    }
+    return t;
+  }
+  function _objectSpread2(e) {
+    for (var r = 1;r < arguments.length; r++) {
+      var t = arguments[r] != null ? arguments[r] : {};
+      r % 2 ? ownKeys(Object(t), true).forEach(function(r$1) {
+        defineProperty(e, r$1, t[r$1]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r$1) {
+        Object.defineProperty(e, r$1, Object.getOwnPropertyDescriptor(t, r$1));
+      });
+    }
+    return e;
+  }
+  module.exports = _objectSpread2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var import_objectSpread2 = __toESM2(require_objectSpread22(), 1);
+
+// ../../node_modules/.bun/@trpc+server@11.8.1+1fb4c65d43e298b9/node_modules/@trpc/server/dist/tracked-D4V22yc5.mjs
+var import_defineProperty = __toESM2(require_defineProperty2(), 1);
+var import_objectSpread2$1 = __toESM2(require_objectSpread22(), 1);
+function transformResultInner(response, transformer) {
+  if ("error" in response) {
+    const error = transformer.deserialize(response.error);
+    return {
+      ok: false,
+      error: (0, import_objectSpread2$1.default)((0, import_objectSpread2$1.default)({}, response), {}, { error })
+    };
+  }
+  const result = (0, import_objectSpread2$1.default)((0, import_objectSpread2$1.default)({}, response.result), (!response.result.type || response.result.type === "data") && {
+    type: "data",
+    data: transformer.deserialize(response.result.data)
+  });
+  return {
+    ok: true,
+    result
+  };
+}
+var TransformResultError = class extends Error {
+  constructor() {
+    super("Unable to transform response from server");
+  }
+};
+function transformResult(response, transformer) {
+  let result;
+  try {
+    result = transformResultInner(response, transformer);
+  } catch (_unused) {
+    throw new TransformResultError;
+  }
+  if (!result.ok && (!isObject(result.error.error) || typeof result.error.error["code"] !== "number"))
+    throw new TransformResultError;
+  if (result.ok && !isObject(result.result))
+    throw new TransformResultError;
+  return result;
+}
+var import_objectSpread22 = __toESM2(require_objectSpread22(), 1);
+var trackedSymbol = Symbol();
+// ../../node_modules/.bun/@trpc+server@11.8.1+1fb4c65d43e298b9/node_modules/@trpc/server/dist/resolveResponse-C7AcnFLN.mjs
+var import_objectSpread2$12 = __toESM2(require_objectSpread22(), 1);
+/*!
+* is-plain-object <https://github.com/jonschlinkert/is-plain-object>
+*
+* Copyright (c) 2014-2017, Jon Schlinkert.
+* Released under the MIT License.
+*/
+var import_defineProperty2 = __toESM2(require_defineProperty2(), 1);
+var _Symbol$toStringTag;
+var subscribableCache = /* @__PURE__ */ new WeakMap;
+var NOOP = () => {};
+_Symbol$toStringTag = Symbol.toStringTag;
+var Unpromise = class Unpromise {
+  constructor(arg) {
+    (0, import_defineProperty2.default)(this, "promise", undefined);
+    (0, import_defineProperty2.default)(this, "subscribers", []);
+    (0, import_defineProperty2.default)(this, "settlement", null);
+    (0, import_defineProperty2.default)(this, _Symbol$toStringTag, "Unpromise");
+    if (typeof arg === "function")
+      this.promise = new Promise(arg);
+    else
+      this.promise = arg;
+    const thenReturn = this.promise.then((value) => {
+      const { subscribers } = this;
+      this.subscribers = null;
+      this.settlement = {
+        status: "fulfilled",
+        value
+      };
+      subscribers === null || subscribers === undefined || subscribers.forEach(({ resolve }) => {
+        resolve(value);
+      });
+    });
+    if ("catch" in thenReturn)
+      thenReturn.catch((reason) => {
+        const { subscribers } = this;
+        this.subscribers = null;
+        this.settlement = {
+          status: "rejected",
+          reason
+        };
+        subscribers === null || subscribers === undefined || subscribers.forEach(({ reject }) => {
+          reject(reason);
+        });
+      });
+  }
+  subscribe() {
+    let promise;
+    let unsubscribe;
+    const { settlement } = this;
+    if (settlement === null) {
+      if (this.subscribers === null)
+        throw new Error("Unpromise settled but still has subscribers");
+      const subscriber = withResolvers();
+      this.subscribers = listWithMember(this.subscribers, subscriber);
+      promise = subscriber.promise;
+      unsubscribe = () => {
+        if (this.subscribers !== null)
+          this.subscribers = listWithoutMember(this.subscribers, subscriber);
+      };
+    } else {
+      const { status } = settlement;
+      if (status === "fulfilled")
+        promise = Promise.resolve(settlement.value);
+      else
+        promise = Promise.reject(settlement.reason);
+      unsubscribe = NOOP;
+    }
+    return Object.assign(promise, { unsubscribe });
+  }
+  then(onfulfilled, onrejected) {
+    const subscribed = this.subscribe();
+    const { unsubscribe } = subscribed;
+    return Object.assign(subscribed.then(onfulfilled, onrejected), { unsubscribe });
+  }
+  catch(onrejected) {
+    const subscribed = this.subscribe();
+    const { unsubscribe } = subscribed;
+    return Object.assign(subscribed.catch(onrejected), { unsubscribe });
+  }
+  finally(onfinally) {
+    const subscribed = this.subscribe();
+    const { unsubscribe } = subscribed;
+    return Object.assign(subscribed.finally(onfinally), { unsubscribe });
+  }
+  static proxy(promise) {
+    const cached = Unpromise.getSubscribablePromise(promise);
+    return typeof cached !== "undefined" ? cached : Unpromise.createSubscribablePromise(promise);
+  }
+  static createSubscribablePromise(promise) {
+    const created = new Unpromise(promise);
+    subscribableCache.set(promise, created);
+    subscribableCache.set(created, created);
+    return created;
+  }
+  static getSubscribablePromise(promise) {
+    return subscribableCache.get(promise);
+  }
+  static resolve(value) {
+    const promise = typeof value === "object" && value !== null && "then" in value && typeof value.then === "function" ? value : Promise.resolve(value);
+    return Unpromise.proxy(promise).subscribe();
+  }
+  static async any(values) {
+    const valuesArray = Array.isArray(values) ? values : [...values];
+    const subscribedPromises = valuesArray.map(Unpromise.resolve);
+    try {
+      return await Promise.any(subscribedPromises);
+    } finally {
+      subscribedPromises.forEach(({ unsubscribe }) => {
+        unsubscribe();
+      });
+    }
+  }
+  static async race(values) {
+    const valuesArray = Array.isArray(values) ? values : [...values];
+    const subscribedPromises = valuesArray.map(Unpromise.resolve);
+    try {
+      return await Promise.race(subscribedPromises);
+    } finally {
+      subscribedPromises.forEach(({ unsubscribe }) => {
+        unsubscribe();
+      });
+    }
+  }
+  static async raceReferences(promises) {
+    const selfPromises = promises.map(resolveSelfTuple);
+    try {
+      return await Promise.race(selfPromises);
+    } finally {
+      for (const promise of selfPromises)
+        promise.unsubscribe();
+    }
+  }
+};
+function resolveSelfTuple(promise) {
+  return Unpromise.proxy(promise).then(() => [promise]);
+}
+function withResolvers() {
+  let resolve;
+  let reject;
+  const promise = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  return {
+    promise,
+    resolve,
+    reject
+  };
+}
+function listWithMember(arr, member) {
+  return [...arr, member];
+}
+function listWithoutIndex(arr, index) {
+  return [...arr.slice(0, index), ...arr.slice(index + 1)];
+}
+function listWithoutMember(arr, member) {
+  const index = arr.indexOf(member);
+  if (index !== -1)
+    return listWithoutIndex(arr, index);
+  return arr;
+}
+var _Symbol;
+var _Symbol$dispose;
+var _Symbol2;
+var _Symbol2$asyncDispose;
+(_Symbol$dispose = (_Symbol = Symbol).dispose) !== null && _Symbol$dispose !== undefined || (_Symbol.dispose = Symbol());
+(_Symbol2$asyncDispose = (_Symbol2 = Symbol).asyncDispose) !== null && _Symbol2$asyncDispose !== undefined || (_Symbol2.asyncDispose = Symbol());
+function makeResource(thing, dispose) {
+  const it = thing;
+  const existing = it[Symbol.dispose];
+  it[Symbol.dispose] = () => {
+    dispose();
+    existing === null || existing === undefined || existing();
+  };
+  return it;
+}
+function makeAsyncResource(thing, dispose) {
+  const it = thing;
+  const existing = it[Symbol.asyncDispose];
+  it[Symbol.asyncDispose] = async () => {
+    await dispose();
+    await (existing === null || existing === undefined ? undefined : existing());
+  };
+  return it;
+}
+var disposablePromiseTimerResult = Symbol();
+function timerResource(ms) {
+  let timer = null;
+  return makeResource({ start() {
+    if (timer)
+      throw new Error("Timer already started");
+    const promise = new Promise((resolve) => {
+      timer = setTimeout(() => resolve(disposablePromiseTimerResult), ms);
+    });
+    return promise;
+  } }, () => {
+    if (timer)
+      clearTimeout(timer);
+  });
+}
+var require_usingCtx = __commonJS2({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/usingCtx.js"(exports, module) {
+  function _usingCtx() {
+    var r = typeof SuppressedError == "function" ? SuppressedError : function(r$1, e$1) {
+      var n$1 = Error();
+      return n$1.name = "SuppressedError", n$1.error = r$1, n$1.suppressed = e$1, n$1;
+    }, e = {}, n = [];
+    function using(r$1, e$1) {
+      if (e$1 != null) {
+        if (Object(e$1) !== e$1)
+          throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+        if (r$1)
+          var o = e$1[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+        if (o === undefined && (o = e$1[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r$1))
+          var t = o;
+        if (typeof o != "function")
+          throw new TypeError("Object is not disposable.");
+        t && (o = function o$1() {
+          try {
+            t.call(e$1);
+          } catch (r$2) {
+            return Promise.reject(r$2);
+          }
+        }), n.push({
+          v: e$1,
+          d: o,
+          a: r$1
+        });
+      } else
+        r$1 && n.push({
+          d: e$1,
+          a: r$1
+        });
+      return e$1;
+    }
+    return {
+      e,
+      u: using.bind(null, false),
+      a: using.bind(null, true),
+      d: function d() {
+        var o, t = this.e, s = 0;
+        function next() {
+          for (;o = n.pop(); )
+            try {
+              if (!o.a && s === 1)
+                return s = 0, n.push(o), Promise.resolve().then(next);
+              if (o.d) {
+                var r$1 = o.d.call(o.v);
+                if (o.a)
+                  return s |= 2, Promise.resolve(r$1).then(next, err);
+              } else
+                s |= 1;
+            } catch (r$2) {
+              return err(r$2);
+            }
+          if (s === 1)
+            return t !== e ? Promise.reject(t) : Promise.resolve();
+          if (t !== e)
+            throw t;
+        }
+        function err(n$1) {
+          return t = t !== e ? new r(n$1, t) : n$1, next();
+        }
+        return next();
+      }
+    };
+  }
+  module.exports = _usingCtx, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_OverloadYield = __commonJS2({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/OverloadYield.js"(exports, module) {
+  function _OverloadYield(e, d) {
+    this.v = e, this.k = d;
+  }
+  module.exports = _OverloadYield, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_awaitAsyncGenerator = __commonJS2({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/awaitAsyncGenerator.js"(exports, module) {
+  var OverloadYield$2 = require_OverloadYield();
+  function _awaitAsyncGenerator$5(e) {
+    return new OverloadYield$2(e, 0);
+  }
+  module.exports = _awaitAsyncGenerator$5, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_wrapAsyncGenerator = __commonJS2({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/wrapAsyncGenerator.js"(exports, module) {
+  var OverloadYield$1 = require_OverloadYield();
+  function _wrapAsyncGenerator$6(e) {
+    return function() {
+      return new AsyncGenerator(e.apply(this, arguments));
+    };
+  }
+  function AsyncGenerator(e) {
+    var r, t;
+    function resume(r$1, t$1) {
+      try {
+        var n = e[r$1](t$1), o = n.value, u = o instanceof OverloadYield$1;
+        Promise.resolve(u ? o.v : o).then(function(t$2) {
+          if (u) {
+            var i = r$1 === "return" ? "return" : "next";
+            if (!o.k || t$2.done)
+              return resume(i, t$2);
+            t$2 = e[i](t$2).value;
+          }
+          settle(n.done ? "return" : "normal", t$2);
+        }, function(e$1) {
+          resume("throw", e$1);
+        });
+      } catch (e$1) {
+        settle("throw", e$1);
+      }
+    }
+    function settle(e$1, n) {
+      switch (e$1) {
+        case "return":
+          r.resolve({
+            value: n,
+            done: true
+          });
+          break;
+        case "throw":
+          r.reject(n);
+          break;
+        default:
+          r.resolve({
+            value: n,
+            done: false
+          });
+      }
+      (r = r.next) ? resume(r.key, r.arg) : t = null;
+    }
+    this._invoke = function(e$1, n) {
+      return new Promise(function(o, u) {
+        var i = {
+          key: e$1,
+          arg: n,
+          resolve: o,
+          reject: u,
+          next: null
+        };
+        t ? t = t.next = i : (r = t = i, resume(e$1, n));
+      });
+    }, typeof e["return"] != "function" && (this["return"] = undefined);
+  }
+  AsyncGenerator.prototype[typeof Symbol == "function" && Symbol.asyncIterator || "@@asyncIterator"] = function() {
+    return this;
+  }, AsyncGenerator.prototype.next = function(e) {
+    return this._invoke("next", e);
+  }, AsyncGenerator.prototype["throw"] = function(e) {
+    return this._invoke("throw", e);
+  }, AsyncGenerator.prototype["return"] = function(e) {
+    return this._invoke("return", e);
+  };
+  module.exports = _wrapAsyncGenerator$6, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var import_usingCtx$4 = __toESM2(require_usingCtx(), 1);
+var import_awaitAsyncGenerator$4 = __toESM2(require_awaitAsyncGenerator(), 1);
+var import_wrapAsyncGenerator$5 = __toESM2(require_wrapAsyncGenerator(), 1);
+var import_usingCtx$3 = __toESM2(require_usingCtx(), 1);
+var import_awaitAsyncGenerator$3 = __toESM2(require_awaitAsyncGenerator(), 1);
+var import_wrapAsyncGenerator$4 = __toESM2(require_wrapAsyncGenerator(), 1);
+var import_usingCtx$2 = __toESM2(require_usingCtx(), 1);
+var import_awaitAsyncGenerator$2 = __toESM2(require_awaitAsyncGenerator(), 1);
+var import_wrapAsyncGenerator$3 = __toESM2(require_wrapAsyncGenerator(), 1);
+var PING_SYM = Symbol("ping");
+var require_asyncIterator = __commonJS2({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/asyncIterator.js"(exports, module) {
+  function _asyncIterator$2(r) {
+    var n, t, o, e = 2;
+    for (typeof Symbol != "undefined" && (t = Symbol.asyncIterator, o = Symbol.iterator);e--; ) {
+      if (t && (n = r[t]) != null)
+        return n.call(r);
+      if (o && (n = r[o]) != null)
+        return new AsyncFromSyncIterator(n.call(r));
+      t = "@@asyncIterator", o = "@@iterator";
+    }
+    throw new TypeError("Object is not async iterable");
+  }
+  function AsyncFromSyncIterator(r) {
+    function AsyncFromSyncIteratorContinuation(r$1) {
+      if (Object(r$1) !== r$1)
+        return Promise.reject(new TypeError(r$1 + " is not an object."));
+      var n = r$1.done;
+      return Promise.resolve(r$1.value).then(function(r$2) {
+        return {
+          value: r$2,
+          done: n
+        };
+      });
+    }
+    return AsyncFromSyncIterator = function AsyncFromSyncIterator$1(r$1) {
+      this.s = r$1, this.n = r$1.next;
+    }, AsyncFromSyncIterator.prototype = {
+      s: null,
+      n: null,
+      next: function next() {
+        return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
+      },
+      return: function _return(r$1) {
+        var n = this.s["return"];
+        return n === undefined ? Promise.resolve({
+          value: r$1,
+          done: true
+        }) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments));
+      },
+      throw: function _throw(r$1) {
+        var n = this.s["return"];
+        return n === undefined ? Promise.reject(r$1) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments));
+      }
+    }, new AsyncFromSyncIterator(r);
+  }
+  module.exports = _asyncIterator$2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var import_awaitAsyncGenerator$1 = __toESM2(require_awaitAsyncGenerator(), 1);
+var import_wrapAsyncGenerator$2 = __toESM2(require_wrapAsyncGenerator(), 1);
+var import_usingCtx$1 = __toESM2(require_usingCtx(), 1);
+var import_asyncIterator$1 = __toESM2(require_asyncIterator(), 1);
+var require_asyncGeneratorDelegate = __commonJS2({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/asyncGeneratorDelegate.js"(exports, module) {
+  var OverloadYield = require_OverloadYield();
+  function _asyncGeneratorDelegate$1(t) {
+    var e = {}, n = false;
+    function pump(e$1, r) {
+      return n = true, r = new Promise(function(n$1) {
+        n$1(t[e$1](r));
+      }), {
+        done: false,
+        value: new OverloadYield(r, 1)
+      };
+    }
+    return e[typeof Symbol != "undefined" && Symbol.iterator || "@@iterator"] = function() {
+      return this;
+    }, e.next = function(t$1) {
+      return n ? (n = false, t$1) : pump("next", t$1);
+    }, typeof t["throw"] == "function" && (e["throw"] = function(t$1) {
+      if (n)
+        throw n = false, t$1;
+      return pump("throw", t$1);
+    }), typeof t["return"] == "function" && (e["return"] = function(t$1) {
+      return n ? (n = false, t$1) : pump("return", t$1);
+    }), e;
+  }
+  module.exports = _asyncGeneratorDelegate$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var import_asyncIterator = __toESM2(require_asyncIterator(), 1);
+var import_awaitAsyncGenerator = __toESM2(require_awaitAsyncGenerator(), 1);
+var import_wrapAsyncGenerator$1 = __toESM2(require_wrapAsyncGenerator(), 1);
+var import_asyncGeneratorDelegate = __toESM2(require_asyncGeneratorDelegate(), 1);
+var import_usingCtx = __toESM2(require_usingCtx(), 1);
+var PING_EVENT = "ping";
+var SERIALIZED_ERROR_EVENT = "serialized-error";
+var CONNECTED_EVENT = "connected";
+var RETURN_EVENT = "return";
+async function withTimeout(opts) {
+  try {
+    var _usingCtx$1 = (0, import_usingCtx.default)();
+    const timeoutPromise = _usingCtx$1.u(timerResource(opts.timeoutMs));
+    const res = await Unpromise.race([opts.promise, timeoutPromise.start()]);
+    if (res === disposablePromiseTimerResult)
+      return await opts.onTimeout();
+    return res;
+  } catch (_) {
+    _usingCtx$1.e = _;
+  } finally {
+    _usingCtx$1.d();
+  }
+}
+function sseStreamConsumer(opts) {
+  const { deserialize = (v) => v } = opts;
+  let clientOptions = emptyObject();
+  const signal = opts.signal;
+  let _es = null;
+  const createStream = () => new ReadableStream({
+    async start(controller) {
+      const [url, init] = await Promise.all([opts.url(), opts.init()]);
+      const eventSource = _es = new opts.EventSource(url, init);
+      controller.enqueue({
+        type: "connecting",
+        eventSource: _es,
+        event: null
+      });
+      eventSource.addEventListener(CONNECTED_EVENT, (_msg) => {
+        const msg = _msg;
+        const options = JSON.parse(msg.data);
+        clientOptions = options;
+        controller.enqueue({
+          type: "connected",
+          options,
+          eventSource
+        });
+      });
+      eventSource.addEventListener(SERIALIZED_ERROR_EVENT, (_msg) => {
+        const msg = _msg;
+        controller.enqueue({
+          type: "serialized-error",
+          error: deserialize(JSON.parse(msg.data)),
+          eventSource
+        });
+      });
+      eventSource.addEventListener(PING_EVENT, () => {
+        controller.enqueue({
+          type: "ping",
+          eventSource
+        });
+      });
+      eventSource.addEventListener(RETURN_EVENT, () => {
+        eventSource.close();
+        controller.close();
+        _es = null;
+      });
+      eventSource.addEventListener("error", (event) => {
+        if (eventSource.readyState === eventSource.CLOSED)
+          controller.error(event);
+        else
+          controller.enqueue({
+            type: "connecting",
+            eventSource,
+            event
+          });
+      });
+      eventSource.addEventListener("message", (_msg) => {
+        const msg = _msg;
+        const chunk = deserialize(JSON.parse(msg.data));
+        const def = { data: chunk };
+        if (msg.lastEventId)
+          def.id = msg.lastEventId;
+        controller.enqueue({
+          type: "data",
+          data: def,
+          eventSource
+        });
+      });
+      const onAbort = () => {
+        try {
+          eventSource.close();
+          controller.close();
+        } catch (_unused) {}
+      };
+      if (signal.aborted)
+        onAbort();
+      else
+        signal.addEventListener("abort", onAbort);
+    },
+    cancel() {
+      _es === null || _es === undefined || _es.close();
+    }
+  });
+  const getStreamResource = () => {
+    let stream = createStream();
+    let reader = stream.getReader();
+    async function dispose() {
+      await reader.cancel();
+      _es = null;
+    }
+    return makeAsyncResource({
+      read() {
+        return reader.read();
+      },
+      async recreate() {
+        await dispose();
+        stream = createStream();
+        reader = stream.getReader();
+      }
+    }, dispose);
+  };
+  return run((0, import_wrapAsyncGenerator$1.default)(function* () {
+    try {
+      var _usingCtx3 = (0, import_usingCtx.default)();
+      const stream = _usingCtx3.a(getStreamResource());
+      while (true) {
+        let promise = stream.read();
+        const timeoutMs = clientOptions.reconnectAfterInactivityMs;
+        if (timeoutMs)
+          promise = withTimeout({
+            promise,
+            timeoutMs,
+            onTimeout: async () => {
+              const res = {
+                value: {
+                  type: "timeout",
+                  ms: timeoutMs,
+                  eventSource: _es
+                },
+                done: false
+              };
+              await stream.recreate();
+              return res;
+            }
+          });
+        const result = yield (0, import_awaitAsyncGenerator.default)(promise);
+        if (result.done)
+          return result.value;
+        yield result.value;
+      }
+    } catch (_) {
+      _usingCtx3.e = _;
+    } finally {
+      yield (0, import_awaitAsyncGenerator.default)(_usingCtx3.d());
+    }
+  }));
+}
+var import_wrapAsyncGenerator = __toESM2(require_wrapAsyncGenerator(), 1);
+var import_objectSpread23 = __toESM2(require_objectSpread22(), 1);
+// ../../node_modules/.bun/@trpc+client@11.8.1+56fb0e3277503e89/node_modules/@trpc/client/dist/TRPCClientError-CjKyS10w.mjs
+var import_defineProperty3 = __toESM(require_defineProperty(), 1);
+var import_objectSpread24 = __toESM(require_objectSpread2(), 1);
+function isTRPCClientError(cause) {
+  return cause instanceof TRPCClientError;
+}
+function isTRPCErrorResponse(obj) {
+  return isObject(obj) && isObject(obj["error"]) && typeof obj["error"]["code"] === "number" && typeof obj["error"]["message"] === "string";
+}
+function getMessageFromUnknownError(err, fallback) {
+  if (typeof err === "string")
+    return err;
+  if (isObject(err) && typeof err["message"] === "string")
+    return err["message"];
+  return fallback;
+}
+var TRPCClientError = class TRPCClientError extends Error {
+  constructor(message, opts) {
+    var _opts$result, _opts$result2;
+    const cause = opts === null || opts === undefined ? undefined : opts.cause;
+    super(message, { cause });
+    (0, import_defineProperty3.default)(this, "cause", undefined);
+    (0, import_defineProperty3.default)(this, "shape", undefined);
+    (0, import_defineProperty3.default)(this, "data", undefined);
+    (0, import_defineProperty3.default)(this, "meta", undefined);
+    this.meta = opts === null || opts === undefined ? undefined : opts.meta;
+    this.cause = cause;
+    this.shape = opts === null || opts === undefined || (_opts$result = opts.result) === null || _opts$result === undefined ? undefined : _opts$result.error;
+    this.data = opts === null || opts === undefined || (_opts$result2 = opts.result) === null || _opts$result2 === undefined ? undefined : _opts$result2.error.data;
+    this.name = "TRPCClientError";
+    Object.setPrototypeOf(this, TRPCClientError.prototype);
+  }
+  static from(_cause, opts = {}) {
+    const cause = _cause;
+    if (isTRPCClientError(cause)) {
+      if (opts.meta)
+        cause.meta = (0, import_objectSpread24.default)((0, import_objectSpread24.default)({}, cause.meta), opts.meta);
+      return cause;
+    }
+    if (isTRPCErrorResponse(cause))
+      return new TRPCClientError(cause.error.message, (0, import_objectSpread24.default)((0, import_objectSpread24.default)({}, opts), {}, { result: cause }));
+    return new TRPCClientError(getMessageFromUnknownError(cause, "Unknown error"), (0, import_objectSpread24.default)((0, import_objectSpread24.default)({}, opts), {}, { cause }));
+  }
+};
+
+// ../../node_modules/.bun/@trpc+client@11.8.1+56fb0e3277503e89/node_modules/@trpc/client/dist/unstable-internals-Bg7n9BBj.mjs
+function getTransformer(transformer) {
+  const _transformer = transformer;
+  if (!_transformer)
+    return {
+      input: {
+        serialize: (data) => data,
+        deserialize: (data) => data
+      },
+      output: {
+        serialize: (data) => data,
+        deserialize: (data) => data
+      }
+    };
+  if ("input" in _transformer)
+    return _transformer;
+  return {
+    input: _transformer,
+    output: _transformer
+  };
+}
+
+// ../../node_modules/.bun/@trpc+client@11.8.1+56fb0e3277503e89/node_modules/@trpc/client/dist/httpUtils-Dv57hbOd.mjs
+var isFunction2 = (fn) => typeof fn === "function";
+function getFetch(customFetchImpl) {
+  if (customFetchImpl)
+    return customFetchImpl;
+  if (typeof window !== "undefined" && isFunction2(window.fetch))
+    return window.fetch;
+  if (typeof globalThis !== "undefined" && isFunction2(globalThis.fetch))
+    return globalThis.fetch;
+  throw new Error("No fetch implementation found");
+}
+var import_objectSpread25 = __toESM(require_objectSpread2(), 1);
+function resolveHTTPLinkOptions(opts) {
+  return {
+    url: opts.url.toString(),
+    fetch: opts.fetch,
+    transformer: getTransformer(opts.transformer),
+    methodOverride: opts.methodOverride
+  };
+}
+function arrayToDict(array) {
+  const dict = {};
+  for (let index = 0;index < array.length; index++) {
+    const element = array[index];
+    dict[index] = element;
+  }
+  return dict;
+}
+var METHOD = {
+  query: "GET",
+  mutation: "POST",
+  subscription: "PATCH"
+};
+function getInput(opts) {
+  return "input" in opts ? opts.transformer.input.serialize(opts.input) : arrayToDict(opts.inputs.map((_input) => opts.transformer.input.serialize(_input)));
+}
+var getUrl = (opts) => {
+  const parts = opts.url.split("?");
+  const base = parts[0].replace(/\/$/, "");
+  let url = base + "/" + opts.path;
+  const queryParts = [];
+  if (parts[1])
+    queryParts.push(parts[1]);
+  if ("inputs" in opts)
+    queryParts.push("batch=1");
+  if (opts.type === "query" || opts.type === "subscription") {
+    const input = getInput(opts);
+    if (input !== undefined && opts.methodOverride !== "POST")
+      queryParts.push(`input=${encodeURIComponent(JSON.stringify(input))}`);
+  }
+  if (queryParts.length)
+    url += "?" + queryParts.join("&");
+  return url;
+};
+var getBody = (opts) => {
+  if (opts.type === "query" && opts.methodOverride !== "POST")
+    return;
+  const input = getInput(opts);
+  return input !== undefined ? JSON.stringify(input) : undefined;
+};
+var jsonHttpRequester = (opts) => {
+  return httpRequest((0, import_objectSpread25.default)((0, import_objectSpread25.default)({}, opts), {}, {
+    contentTypeHeader: "application/json",
+    getUrl,
+    getBody
+  }));
+};
+var AbortError = class extends Error {
+  constructor() {
+    const name = "AbortError";
+    super(name);
+    this.name = name;
+    this.message = name;
+  }
+};
+var throwIfAborted = (signal) => {
+  var _signal$throwIfAborte;
+  if (!(signal === null || signal === undefined ? undefined : signal.aborted))
+    return;
+  (_signal$throwIfAborte = signal.throwIfAborted) === null || _signal$throwIfAborte === undefined || _signal$throwIfAborte.call(signal);
+  if (typeof DOMException !== "undefined")
+    throw new DOMException("AbortError", "AbortError");
+  throw new AbortError;
+};
+async function fetchHTTPResponse(opts) {
+  var _opts$methodOverride;
+  throwIfAborted(opts.signal);
+  const url = opts.getUrl(opts);
+  const body = opts.getBody(opts);
+  const method = (_opts$methodOverride = opts.methodOverride) !== null && _opts$methodOverride !== undefined ? _opts$methodOverride : METHOD[opts.type];
+  const resolvedHeaders = await (async () => {
+    const heads = await opts.headers();
+    if (Symbol.iterator in heads)
+      return Object.fromEntries(heads);
+    return heads;
+  })();
+  const headers = (0, import_objectSpread25.default)((0, import_objectSpread25.default)((0, import_objectSpread25.default)({}, opts.contentTypeHeader && method !== "GET" ? { "content-type": opts.contentTypeHeader } : {}), opts.trpcAcceptHeader ? { "trpc-accept": opts.trpcAcceptHeader } : undefined), resolvedHeaders);
+  return getFetch(opts.fetch)(url, {
+    method,
+    signal: opts.signal,
+    body,
+    headers
+  });
+}
+async function httpRequest(opts) {
+  const meta = {};
+  const res = await fetchHTTPResponse(opts);
+  meta.response = res;
+  const json = await res.json();
+  meta.responseJSON = json;
+  return {
+    json,
+    meta
+  };
+}
+
+// ../../node_modules/.bun/@trpc+client@11.8.1+56fb0e3277503e89/node_modules/@trpc/client/dist/httpLink-DCFpUmZF.mjs
+var import_objectSpread26 = __toESM(require_objectSpread2(), 1);
+
+// ../../node_modules/.bun/@trpc+client@11.8.1+56fb0e3277503e89/node_modules/@trpc/client/dist/httpBatchLink-BOe5aCcR.mjs
+var throwFatalError = () => {
+  throw new Error("Something went wrong. Please submit an issue at https://github.com/trpc/trpc/issues/new");
+};
+function dataLoader(batchLoader) {
+  let pendingItems = null;
+  let dispatchTimer = null;
+  const destroyTimerAndPendingItems = () => {
+    clearTimeout(dispatchTimer);
+    dispatchTimer = null;
+    pendingItems = null;
+  };
+  function groupItems(items) {
+    const groupedItems = [[]];
+    let index = 0;
+    while (true) {
+      const item = items[index];
+      if (!item)
+        break;
+      const lastGroup = groupedItems[groupedItems.length - 1];
+      if (item.aborted) {
+        var _item$reject;
+        (_item$reject = item.reject) === null || _item$reject === undefined || _item$reject.call(item, new Error("Aborted"));
+        index++;
+        continue;
+      }
+      const isValid = batchLoader.validate(lastGroup.concat(item).map((it) => it.key));
+      if (isValid) {
+        lastGroup.push(item);
+        index++;
+        continue;
+      }
+      if (lastGroup.length === 0) {
+        var _item$reject2;
+        (_item$reject2 = item.reject) === null || _item$reject2 === undefined || _item$reject2.call(item, new Error("Input is too big for a single dispatch"));
+        index++;
+        continue;
+      }
+      groupedItems.push([]);
+    }
+    return groupedItems;
+  }
+  function dispatch() {
+    const groupedItems = groupItems(pendingItems);
+    destroyTimerAndPendingItems();
+    for (const items of groupedItems) {
+      if (!items.length)
+        continue;
+      const batch = { items };
+      for (const item of items)
+        item.batch = batch;
+      const promise = batchLoader.fetch(batch.items.map((_item) => _item.key));
+      promise.then(async (result) => {
+        await Promise.all(result.map(async (valueOrPromise, index) => {
+          const item = batch.items[index];
+          try {
+            var _item$resolve;
+            const value = await Promise.resolve(valueOrPromise);
+            (_item$resolve = item.resolve) === null || _item$resolve === undefined || _item$resolve.call(item, value);
+          } catch (cause) {
+            var _item$reject3;
+            (_item$reject3 = item.reject) === null || _item$reject3 === undefined || _item$reject3.call(item, cause);
+          }
+          item.batch = null;
+          item.reject = null;
+          item.resolve = null;
+        }));
+        for (const item of batch.items) {
+          var _item$reject4;
+          (_item$reject4 = item.reject) === null || _item$reject4 === undefined || _item$reject4.call(item, new Error("Missing result"));
+          item.batch = null;
+        }
+      }).catch((cause) => {
+        for (const item of batch.items) {
+          var _item$reject5;
+          (_item$reject5 = item.reject) === null || _item$reject5 === undefined || _item$reject5.call(item, cause);
+          item.batch = null;
+        }
+      });
+    }
+  }
+  function load(key) {
+    var _dispatchTimer;
+    const item = {
+      aborted: false,
+      key,
+      batch: null,
+      resolve: throwFatalError,
+      reject: throwFatalError
+    };
+    const promise = new Promise((resolve, reject) => {
+      var _pendingItems;
+      item.reject = reject;
+      item.resolve = resolve;
+      (_pendingItems = pendingItems) !== null && _pendingItems !== undefined || (pendingItems = []);
+      pendingItems.push(item);
+    });
+    (_dispatchTimer = dispatchTimer) !== null && _dispatchTimer !== undefined || (dispatchTimer = setTimeout(dispatch));
+    return promise;
+  }
+  return { load };
+}
+function allAbortSignals(...signals) {
+  const ac = new AbortController;
+  const count = signals.length;
+  let abortedCount = 0;
+  const onAbort = () => {
+    if (++abortedCount === count)
+      ac.abort();
+  };
+  for (const signal of signals)
+    if (signal === null || signal === undefined ? undefined : signal.aborted)
+      onAbort();
+    else
+      signal === null || signal === undefined || signal.addEventListener("abort", onAbort, { once: true });
+  return ac.signal;
+}
+function raceAbortSignals(...signals) {
+  const ac = new AbortController;
+  for (const signal of signals)
+    if (signal === null || signal === undefined ? undefined : signal.aborted)
+      ac.abort();
+    else
+      signal === null || signal === undefined || signal.addEventListener("abort", () => ac.abort(), { once: true });
+  return ac.signal;
+}
+var import_objectSpread27 = __toESM(require_objectSpread2(), 1);
+function httpBatchLink(opts) {
+  var _opts$maxURLLength, _opts$maxItems;
+  const resolvedOpts = resolveHTTPLinkOptions(opts);
+  const maxURLLength = (_opts$maxURLLength = opts.maxURLLength) !== null && _opts$maxURLLength !== undefined ? _opts$maxURLLength : Infinity;
+  const maxItems = (_opts$maxItems = opts.maxItems) !== null && _opts$maxItems !== undefined ? _opts$maxItems : Infinity;
+  return () => {
+    const batchLoader = (type) => {
+      return {
+        validate(batchOps) {
+          if (maxURLLength === Infinity && maxItems === Infinity)
+            return true;
+          if (batchOps.length > maxItems)
+            return false;
+          const path = batchOps.map((op) => op.path).join(",");
+          const inputs = batchOps.map((op) => op.input);
+          const url = getUrl((0, import_objectSpread27.default)((0, import_objectSpread27.default)({}, resolvedOpts), {}, {
+            type,
+            path,
+            inputs,
+            signal: null
+          }));
+          return url.length <= maxURLLength;
+        },
+        async fetch(batchOps) {
+          const path = batchOps.map((op) => op.path).join(",");
+          const inputs = batchOps.map((op) => op.input);
+          const signal = allAbortSignals(...batchOps.map((op) => op.signal));
+          const res = await jsonHttpRequester((0, import_objectSpread27.default)((0, import_objectSpread27.default)({}, resolvedOpts), {}, {
+            path,
+            inputs,
+            type,
+            headers() {
+              if (!opts.headers)
+                return {};
+              if (typeof opts.headers === "function")
+                return opts.headers({ opList: batchOps });
+              return opts.headers;
+            },
+            signal
+          }));
+          const resJSON = Array.isArray(res.json) ? res.json : batchOps.map(() => res.json);
+          const result = resJSON.map((item) => ({
+            meta: res.meta,
+            json: item
+          }));
+          return result;
+        }
+      };
+    };
+    const query = dataLoader(batchLoader("query"));
+    const mutation = dataLoader(batchLoader("mutation"));
+    const loaders = {
+      query,
+      mutation
+    };
+    return ({ op }) => {
+      return observable((observer) => {
+        if (op.type === "subscription")
+          throw new Error("Subscriptions are unsupported by `httpLink` - use `httpSubscriptionLink` or `wsLink`");
+        const loader = loaders[op.type];
+        const promise = loader.load(op);
+        let _res = undefined;
+        promise.then((res) => {
+          _res = res;
+          const transformed = transformResult(res.json, resolvedOpts.transformer.output);
+          if (!transformed.ok) {
+            observer.error(TRPCClientError.from(transformed.error, { meta: res.meta }));
+            return;
+          }
+          observer.next({
+            context: res.meta,
+            result: transformed.result
+          });
+          observer.complete();
+        }).catch((err) => {
+          observer.error(TRPCClientError.from(err, { meta: _res === null || _res === undefined ? undefined : _res.meta }));
+        });
+        return () => {};
+      });
+    };
+  };
+}
+
+// ../../node_modules/.bun/@trpc+client@11.8.1+56fb0e3277503e89/node_modules/@trpc/client/dist/loggerLink-ineCN1PO.mjs
+var import_objectSpread28 = __toESM(require_objectSpread2(), 1);
+
+// ../../node_modules/.bun/@trpc+client@11.8.1+56fb0e3277503e89/node_modules/@trpc/client/dist/wsLink-CatceK3c.mjs
+var resultOf = (value, ...args) => {
+  return typeof value === "function" ? value(...args) : value;
+};
+var import_defineProperty$3 = __toESM(require_defineProperty(), 1);
+function withResolvers2() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return {
+    promise,
+    resolve,
+    reject
+  };
+}
+async function prepareUrl(urlOptions) {
+  const url = await resultOf(urlOptions.url);
+  if (!urlOptions.connectionParams)
+    return url;
+  const prefix = url.includes("?") ? "&" : "?";
+  const connectionParams = `${prefix}connectionParams=1`;
+  return url + connectionParams;
+}
+async function buildConnectionMessage(connectionParams) {
+  const message = {
+    method: "connectionParams",
+    data: await resultOf(connectionParams)
+  };
+  return JSON.stringify(message);
+}
+var import_defineProperty$2 = __toESM(require_defineProperty(), 1);
+var import_defineProperty$1 = __toESM(require_defineProperty(), 1);
+function asyncWsOpen(ws) {
+  const { promise, resolve, reject } = withResolvers2();
+  ws.addEventListener("open", () => {
+    ws.removeEventListener("error", reject);
+    resolve();
+  });
+  ws.addEventListener("error", reject);
+  return promise;
+}
+function setupPingInterval(ws, { intervalMs, pongTimeoutMs }) {
+  let pingTimeout;
+  let pongTimeout;
+  function start() {
+    pingTimeout = setTimeout(() => {
+      ws.send("PING");
+      pongTimeout = setTimeout(() => {
+        ws.close();
+      }, pongTimeoutMs);
+    }, intervalMs);
+  }
+  function reset() {
+    clearTimeout(pingTimeout);
+    start();
+  }
+  function pong() {
+    clearTimeout(pongTimeout);
+    reset();
+  }
+  ws.addEventListener("open", start);
+  ws.addEventListener("message", ({ data }) => {
+    clearTimeout(pingTimeout);
+    start();
+    if (data === "PONG")
+      pong();
+  });
+  ws.addEventListener("close", () => {
+    clearTimeout(pingTimeout);
+    clearTimeout(pongTimeout);
+  });
+}
+var WsConnection = class WsConnection {
+  constructor(opts) {
+    var _opts$WebSocketPonyfi;
+    (0, import_defineProperty$1.default)(this, "id", ++WsConnection.connectCount);
+    (0, import_defineProperty$1.default)(this, "WebSocketPonyfill", undefined);
+    (0, import_defineProperty$1.default)(this, "urlOptions", undefined);
+    (0, import_defineProperty$1.default)(this, "keepAliveOpts", undefined);
+    (0, import_defineProperty$1.default)(this, "wsObservable", behaviorSubject(null));
+    (0, import_defineProperty$1.default)(this, "openPromise", null);
+    this.WebSocketPonyfill = (_opts$WebSocketPonyfi = opts.WebSocketPonyfill) !== null && _opts$WebSocketPonyfi !== undefined ? _opts$WebSocketPonyfi : WebSocket;
+    if (!this.WebSocketPonyfill)
+      throw new Error("No WebSocket implementation found - you probably don't want to use this on the server, but if you do you need to pass a `WebSocket`-ponyfill");
+    this.urlOptions = opts.urlOptions;
+    this.keepAliveOpts = opts.keepAlive;
+  }
+  get ws() {
+    return this.wsObservable.get();
+  }
+  set ws(ws) {
+    this.wsObservable.next(ws);
+  }
+  isOpen() {
+    return !!this.ws && this.ws.readyState === this.WebSocketPonyfill.OPEN && !this.openPromise;
+  }
+  isClosed() {
+    return !!this.ws && (this.ws.readyState === this.WebSocketPonyfill.CLOSING || this.ws.readyState === this.WebSocketPonyfill.CLOSED);
+  }
+  async open() {
+    var _this = this;
+    if (_this.openPromise)
+      return _this.openPromise;
+    _this.id = ++WsConnection.connectCount;
+    const wsPromise = prepareUrl(_this.urlOptions).then((url) => new _this.WebSocketPonyfill(url));
+    _this.openPromise = wsPromise.then(async (ws) => {
+      _this.ws = ws;
+      ws.addEventListener("message", function({ data }) {
+        if (data === "PING")
+          this.send("PONG");
+      });
+      if (_this.keepAliveOpts.enabled)
+        setupPingInterval(ws, _this.keepAliveOpts);
+      ws.addEventListener("close", () => {
+        if (_this.ws === ws)
+          _this.ws = null;
+      });
+      await asyncWsOpen(ws);
+      if (_this.urlOptions.connectionParams)
+        ws.send(await buildConnectionMessage(_this.urlOptions.connectionParams));
+    });
+    try {
+      await _this.openPromise;
+    } finally {
+      _this.openPromise = null;
+    }
+  }
+  async close() {
+    var _this2 = this;
+    try {
+      await _this2.openPromise;
+    } finally {
+      var _this$ws;
+      (_this$ws = _this2.ws) === null || _this$ws === undefined || _this$ws.close();
+    }
+  }
+};
+(0, import_defineProperty$1.default)(WsConnection, "connectCount", 0);
+var import_defineProperty4 = __toESM(require_defineProperty(), 1);
+var import_objectSpread29 = __toESM(require_objectSpread2(), 1);
+
+// ../../node_modules/.bun/@trpc+client@11.8.1+56fb0e3277503e89/node_modules/@trpc/client/dist/index.mjs
+var import_defineProperty5 = __toESM(require_defineProperty(), 1);
+var import_objectSpread2$4 = __toESM(require_objectSpread2(), 1);
+var TRPCUntypedClient = class {
+  constructor(opts) {
+    (0, import_defineProperty5.default)(this, "links", undefined);
+    (0, import_defineProperty5.default)(this, "runtime", undefined);
+    (0, import_defineProperty5.default)(this, "requestId", undefined);
+    this.requestId = 0;
+    this.runtime = {};
+    this.links = opts.links.map((link) => link(this.runtime));
+  }
+  $request(opts) {
+    var _opts$context;
+    const chain$ = createChain({
+      links: this.links,
+      op: (0, import_objectSpread2$4.default)((0, import_objectSpread2$4.default)({}, opts), {}, {
+        context: (_opts$context = opts.context) !== null && _opts$context !== undefined ? _opts$context : {},
+        id: ++this.requestId
+      })
+    });
+    return chain$.pipe(share());
+  }
+  async requestAsPromise(opts) {
+    var _this = this;
+    try {
+      const req$ = _this.$request(opts);
+      const envelope = await observableToPromise(req$);
+      const data = envelope.result.data;
+      return data;
+    } catch (err) {
+      throw TRPCClientError.from(err);
+    }
+  }
+  query(path, input, opts) {
+    return this.requestAsPromise({
+      type: "query",
+      path,
+      input,
+      context: opts === null || opts === undefined ? undefined : opts.context,
+      signal: opts === null || opts === undefined ? undefined : opts.signal
+    });
+  }
+  mutation(path, input, opts) {
+    return this.requestAsPromise({
+      type: "mutation",
+      path,
+      input,
+      context: opts === null || opts === undefined ? undefined : opts.context,
+      signal: opts === null || opts === undefined ? undefined : opts.signal
+    });
+  }
+  subscription(path, input, opts) {
+    const observable$ = this.$request({
+      type: "subscription",
+      path,
+      input,
+      context: opts.context,
+      signal: opts.signal
+    });
+    return observable$.subscribe({
+      next(envelope) {
+        switch (envelope.result.type) {
+          case "state": {
+            var _opts$onConnectionSta;
+            (_opts$onConnectionSta = opts.onConnectionStateChange) === null || _opts$onConnectionSta === undefined || _opts$onConnectionSta.call(opts, envelope.result);
+            break;
+          }
+          case "started": {
+            var _opts$onStarted;
+            (_opts$onStarted = opts.onStarted) === null || _opts$onStarted === undefined || _opts$onStarted.call(opts, { context: envelope.context });
+            break;
+          }
+          case "stopped": {
+            var _opts$onStopped;
+            (_opts$onStopped = opts.onStopped) === null || _opts$onStopped === undefined || _opts$onStopped.call(opts);
+            break;
+          }
+          case "data":
+          case undefined: {
+            var _opts$onData;
+            (_opts$onData = opts.onData) === null || _opts$onData === undefined || _opts$onData.call(opts, envelope.result.data);
+            break;
+          }
+        }
+      },
+      error(err) {
+        var _opts$onError;
+        (_opts$onError = opts.onError) === null || _opts$onError === undefined || _opts$onError.call(opts, err);
+      },
+      complete() {
+        var _opts$onComplete;
+        (_opts$onComplete = opts.onComplete) === null || _opts$onComplete === undefined || _opts$onComplete.call(opts);
+      }
+    });
+  }
+};
+var untypedClientSymbol = Symbol.for("trpc_untypedClient");
+var clientCallTypeMap = {
+  query: "query",
+  mutate: "mutation",
+  subscribe: "subscription"
+};
+var clientCallTypeToProcedureType = (clientCallType) => {
+  return clientCallTypeMap[clientCallType];
+};
+function createTRPCClientProxy(client) {
+  const proxy = createRecursiveProxy(({ path, args }) => {
+    const pathCopy = [...path];
+    const procedureType = clientCallTypeToProcedureType(pathCopy.pop());
+    const fullPath = pathCopy.join(".");
+    return client[procedureType](fullPath, ...args);
+  });
+  return createFlatProxy((key) => {
+    if (key === untypedClientSymbol)
+      return client;
+    return proxy[key];
+  });
+}
+function createTRPCClient(opts) {
+  const client = new TRPCUntypedClient(opts);
+  const proxy = createTRPCClientProxy(client);
+  return proxy;
+}
+var import_objectSpread2$3 = __toESM(require_objectSpread2(), 1);
+var import_objectSpread2$2 = __toESM(require_objectSpread2(), 1);
+function inputWithTrackedEventId(input, lastEventId) {
+  if (!lastEventId)
+    return input;
+  if (input != null && typeof input !== "object")
+    return input;
+  return (0, import_objectSpread2$2.default)((0, import_objectSpread2$2.default)({}, input !== null && input !== undefined ? input : {}), {}, { lastEventId });
+}
+var require_asyncIterator2 = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/asyncIterator.js"(exports, module) {
+  function _asyncIterator$1(r) {
+    var n, t, o, e = 2;
+    for (typeof Symbol != "undefined" && (t = Symbol.asyncIterator, o = Symbol.iterator);e--; ) {
+      if (t && (n = r[t]) != null)
+        return n.call(r);
+      if (o && (n = r[o]) != null)
+        return new AsyncFromSyncIterator(n.call(r));
+      t = "@@asyncIterator", o = "@@iterator";
+    }
+    throw new TypeError("Object is not async iterable");
+  }
+  function AsyncFromSyncIterator(r) {
+    function AsyncFromSyncIteratorContinuation(r$1) {
+      if (Object(r$1) !== r$1)
+        return Promise.reject(new TypeError(r$1 + " is not an object."));
+      var n = r$1.done;
+      return Promise.resolve(r$1.value).then(function(r$2) {
+        return {
+          value: r$2,
+          done: n
+        };
+      });
+    }
+    return AsyncFromSyncIterator = function AsyncFromSyncIterator$1(r$1) {
+      this.s = r$1, this.n = r$1.next;
+    }, AsyncFromSyncIterator.prototype = {
+      s: null,
+      n: null,
+      next: function next() {
+        return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
+      },
+      return: function _return(r$1) {
+        var n = this.s["return"];
+        return n === undefined ? Promise.resolve({
+          value: r$1,
+          done: true
+        }) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments));
+      },
+      throw: function _throw(r$1) {
+        var n = this.s["return"];
+        return n === undefined ? Promise.reject(r$1) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments));
+      }
+    }, new AsyncFromSyncIterator(r);
+  }
+  module.exports = _asyncIterator$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var import_asyncIterator2 = __toESM(require_asyncIterator2(), 1);
+async function urlWithConnectionParams(opts) {
+  let url = await resultOf(opts.url);
+  if (opts.connectionParams) {
+    const params = await resultOf(opts.connectionParams);
+    const prefix = url.includes("?") ? "&" : "?";
+    url += prefix + "connectionParams=" + encodeURIComponent(JSON.stringify(params));
+  }
+  return url;
+}
+function httpSubscriptionLink(opts) {
+  const transformer = getTransformer(opts.transformer);
+  return () => {
+    return ({ op }) => {
+      return observable((observer) => {
+        var _opts$EventSource;
+        const { type, path, input } = op;
+        if (type !== "subscription")
+          throw new Error("httpSubscriptionLink only supports subscriptions");
+        let lastEventId = undefined;
+        const ac = new AbortController;
+        const signal = raceAbortSignals(op.signal, ac.signal);
+        const eventSourceStream = sseStreamConsumer({
+          url: async () => getUrl({
+            transformer,
+            url: await urlWithConnectionParams(opts),
+            input: inputWithTrackedEventId(input, lastEventId),
+            path,
+            type,
+            signal: null
+          }),
+          init: () => resultOf(opts.eventSourceOptions, { op }),
+          signal,
+          deserialize: (data) => transformer.output.deserialize(data),
+          EventSource: (_opts$EventSource = opts.EventSource) !== null && _opts$EventSource !== undefined ? _opts$EventSource : globalThis.EventSource
+        });
+        const connectionState = behaviorSubject({
+          type: "state",
+          state: "connecting",
+          error: null
+        });
+        const connectionSub = connectionState.subscribe({ next(state) {
+          observer.next({ result: state });
+        } });
+        run(async () => {
+          var _iteratorAbruptCompletion = false;
+          var _didIteratorError = false;
+          var _iteratorError;
+          try {
+            for (var _iterator = (0, import_asyncIterator2.default)(eventSourceStream), _step;_iteratorAbruptCompletion = !(_step = await _iterator.next()).done; _iteratorAbruptCompletion = false) {
+              const chunk = _step.value;
+              switch (chunk.type) {
+                case "ping":
+                  break;
+                case "data":
+                  const chunkData = chunk.data;
+                  let result;
+                  if (chunkData.id) {
+                    lastEventId = chunkData.id;
+                    result = {
+                      id: chunkData.id,
+                      data: chunkData
+                    };
+                  } else
+                    result = { data: chunkData.data };
+                  observer.next({
+                    result,
+                    context: { eventSource: chunk.eventSource }
+                  });
+                  break;
+                case "connected": {
+                  observer.next({
+                    result: { type: "started" },
+                    context: { eventSource: chunk.eventSource }
+                  });
+                  connectionState.next({
+                    type: "state",
+                    state: "pending",
+                    error: null
+                  });
+                  break;
+                }
+                case "serialized-error": {
+                  const error = TRPCClientError.from({ error: chunk.error });
+                  if (retryableRpcCodes.includes(chunk.error.code)) {
+                    connectionState.next({
+                      type: "state",
+                      state: "connecting",
+                      error
+                    });
+                    break;
+                  }
+                  throw error;
+                }
+                case "connecting": {
+                  const lastState = connectionState.get();
+                  const error = chunk.event && TRPCClientError.from(chunk.event);
+                  if (!error && lastState.state === "connecting")
+                    break;
+                  connectionState.next({
+                    type: "state",
+                    state: "connecting",
+                    error
+                  });
+                  break;
+                }
+                case "timeout":
+                  connectionState.next({
+                    type: "state",
+                    state: "connecting",
+                    error: new TRPCClientError(`Timeout of ${chunk.ms}ms reached while waiting for a response`)
+                  });
+              }
+            }
+          } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+          } finally {
+            try {
+              if (_iteratorAbruptCompletion && _iterator.return != null)
+                await _iterator.return();
+            } finally {
+              if (_didIteratorError)
+                throw _iteratorError;
+            }
+          }
+          observer.next({ result: { type: "stopped" } });
+          connectionState.next({
+            type: "state",
+            state: "idle",
+            error: null
+          });
+          observer.complete();
+        }).catch((error) => {
+          observer.error(TRPCClientError.from(error));
+        });
+        return () => {
+          observer.complete();
+          ac.abort();
+          connectionSub.unsubscribe();
+        };
+      });
+    };
+  };
+}
+var import_objectSpread2$13 = __toESM(require_objectSpread2(), 1);
+var require_usingCtx2 = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/usingCtx.js"(exports, module) {
+  function _usingCtx() {
+    var r = typeof SuppressedError == "function" ? SuppressedError : function(r$1, e$1) {
+      var n$1 = Error();
+      return n$1.name = "SuppressedError", n$1.error = r$1, n$1.suppressed = e$1, n$1;
+    }, e = {}, n = [];
+    function using(r$1, e$1) {
+      if (e$1 != null) {
+        if (Object(e$1) !== e$1)
+          throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+        if (r$1)
+          var o = e$1[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+        if (o === undefined && (o = e$1[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r$1))
+          var t = o;
+        if (typeof o != "function")
+          throw new TypeError("Object is not disposable.");
+        t && (o = function o$1() {
+          try {
+            t.call(e$1);
+          } catch (r$2) {
+            return Promise.reject(r$2);
+          }
+        }), n.push({
+          v: e$1,
+          d: o,
+          a: r$1
+        });
+      } else
+        r$1 && n.push({
+          d: e$1,
+          a: r$1
+        });
+      return e$1;
+    }
+    return {
+      e,
+      u: using.bind(null, false),
+      a: using.bind(null, true),
+      d: function d() {
+        var o, t = this.e, s = 0;
+        function next() {
+          for (;o = n.pop(); )
+            try {
+              if (!o.a && s === 1)
+                return s = 0, n.push(o), Promise.resolve().then(next);
+              if (o.d) {
+                var r$1 = o.d.call(o.v);
+                if (o.a)
+                  return s |= 2, Promise.resolve(r$1).then(next, err);
+              } else
+                s |= 1;
+            } catch (r$2) {
+              return err(r$2);
+            }
+          if (s === 1)
+            return t !== e ? Promise.reject(t) : Promise.resolve();
+          if (t !== e)
+            throw t;
+        }
+        function err(n$1) {
+          return t = t !== e ? new r(n$1, t) : n$1, next();
+        }
+        return next();
+      }
+    };
+  }
+  module.exports = _usingCtx, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_OverloadYield2 = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/OverloadYield.js"(exports, module) {
+  function _OverloadYield(e, d) {
+    this.v = e, this.k = d;
+  }
+  module.exports = _OverloadYield, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_awaitAsyncGenerator2 = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/awaitAsyncGenerator.js"(exports, module) {
+  var OverloadYield$1 = require_OverloadYield2();
+  function _awaitAsyncGenerator$1(e) {
+    return new OverloadYield$1(e, 0);
+  }
+  module.exports = _awaitAsyncGenerator$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_wrapAsyncGenerator2 = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/wrapAsyncGenerator.js"(exports, module) {
+  var OverloadYield = require_OverloadYield2();
+  function _wrapAsyncGenerator$1(e) {
+    return function() {
+      return new AsyncGenerator(e.apply(this, arguments));
+    };
+  }
+  function AsyncGenerator(e) {
+    var r, t;
+    function resume(r$1, t$1) {
+      try {
+        var n = e[r$1](t$1), o = n.value, u = o instanceof OverloadYield;
+        Promise.resolve(u ? o.v : o).then(function(t$2) {
+          if (u) {
+            var i = r$1 === "return" ? "return" : "next";
+            if (!o.k || t$2.done)
+              return resume(i, t$2);
+            t$2 = e[i](t$2).value;
+          }
+          settle(n.done ? "return" : "normal", t$2);
+        }, function(e$1) {
+          resume("throw", e$1);
+        });
+      } catch (e$1) {
+        settle("throw", e$1);
+      }
+    }
+    function settle(e$1, n) {
+      switch (e$1) {
+        case "return":
+          r.resolve({
+            value: n,
+            done: true
+          });
+          break;
+        case "throw":
+          r.reject(n);
+          break;
+        default:
+          r.resolve({
+            value: n,
+            done: false
+          });
+      }
+      (r = r.next) ? resume(r.key, r.arg) : t = null;
+    }
+    this._invoke = function(e$1, n) {
+      return new Promise(function(o, u) {
+        var i = {
+          key: e$1,
+          arg: n,
+          resolve: o,
+          reject: u,
+          next: null
+        };
+        t ? t = t.next = i : (r = t = i, resume(e$1, n));
+      });
+    }, typeof e["return"] != "function" && (this["return"] = undefined);
+  }
+  AsyncGenerator.prototype[typeof Symbol == "function" && Symbol.asyncIterator || "@@asyncIterator"] = function() {
+    return this;
+  }, AsyncGenerator.prototype.next = function(e) {
+    return this._invoke("next", e);
+  }, AsyncGenerator.prototype["throw"] = function(e) {
+    return this._invoke("throw", e);
+  }, AsyncGenerator.prototype["return"] = function(e) {
+    return this._invoke("return", e);
+  };
+  module.exports = _wrapAsyncGenerator$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var import_usingCtx2 = __toESM(require_usingCtx2(), 1);
+var import_awaitAsyncGenerator2 = __toESM(require_awaitAsyncGenerator2(), 1);
+var import_wrapAsyncGenerator2 = __toESM(require_wrapAsyncGenerator2(), 1);
+var import_objectSpread210 = __toESM(require_objectSpread2(), 1);
+// ../../node_modules/.bun/eventsource-parser@4.1.0/node_modules/eventsource-parser/dist/errors.js
+class ParseError extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "ParseError";
+    this.type = options.type;
+    this.field = options.field;
+    this.value = options.value;
+    this.line = options.line;
+  }
+}
+
+// ../../node_modules/.bun/eventsource-parser@4.1.0/node_modules/eventsource-parser/dist/parse.js
+var LF = 10;
+var CR = 13;
+var SPACE = 32;
+var MAX_FIELD_PREFIX_LENGTH = 6;
+function createParser(config) {
+  if (typeof config === "function") {
+    throw new TypeError("`config` must be an object, got a function instead. Did you mean `createParser({onEvent: fn})`?");
+  }
+  const { maxBufferSize, onComment, onError, onEvent, onId, onRetry } = config;
+  const pendingFragments = [];
+  let pendingFragmentsLength = 0;
+  let isFirstChunk = true;
+  let id;
+  let data = "";
+  let dataLines = 0;
+  let eventType;
+  let terminated = false;
+  let skippingLine = false;
+  let skipNextLineFeed = false;
+  function feed(chunk) {
+    if (terminated) {
+      throw new Error("Cannot feed parser: it was terminated after exceeding the configured max buffer size. Call `reset()` to resume parsing.");
+    }
+    if (isFirstChunk) {
+      isFirstChunk = false;
+      if (chunk.charCodeAt(0) === 65279) {
+        chunk = chunk.slice(1);
+      } else if (chunk.charCodeAt(0) === 239 && chunk.charCodeAt(1) === 187 && chunk.charCodeAt(2) === 191) {
+        chunk = chunk.slice(3);
+      }
+    }
+    if (skippingLine || skipNextLineFeed) {
+      chunk = resumeAfterSkip(chunk);
+      if (!chunk) {
+        return;
+      }
+    }
+    if (!pendingFragments.length) {
+      const trailing = processLines(chunk);
+      if (trailing !== "") {
+        storeTrailing(trailing);
+      }
+      checkBufferSize();
+      return;
+    }
+    if (chunk.indexOf(`
+`) === -1 && chunk.indexOf("\r") === -1) {
+      if (pendingFragmentsLength < MAX_FIELD_PREFIX_LENGTH) {
+        const head = pendingFragments.join("") + chunk.slice(0, MAX_FIELD_PREFIX_LENGTH - pendingFragmentsLength);
+        if (!shouldBufferTrailing(head)) {
+          pendingFragments.length = 0;
+          pendingFragmentsLength = 0;
+          skippingLine = true;
+          return;
+        }
+      }
+      pendingFragments.push(chunk);
+      pendingFragmentsLength += chunk.length;
+      checkBufferSize();
+      return;
+    }
+    pendingFragments.push(chunk);
+    const input = pendingFragments.join("");
+    pendingFragments.length = 0;
+    pendingFragmentsLength = 0;
+    storeTrailing(processLines(input));
+    checkBufferSize();
+  }
+  function resumeAfterSkip(chunk) {
+    if (chunk.length === 0) {
+      return chunk;
+    }
+    if (skipNextLineFeed) {
+      skipNextLineFeed = false;
+      return chunk.charCodeAt(0) === LF ? chunk.slice(1) : chunk;
+    }
+    const crIndex = chunk.indexOf("\r");
+    const lfIndex = chunk.indexOf(`
+`);
+    const lineEnd = crIndex === -1 ? lfIndex : lfIndex === -1 ? crIndex : crIndex < lfIndex ? crIndex : lfIndex;
+    if (lineEnd === -1) {
+      return "";
+    }
+    if (lineEnd === chunk.length - 1 && chunk.charCodeAt(lineEnd) === CR) {
+      skippingLine = false;
+      skipNextLineFeed = true;
+      return "";
+    }
+    skippingLine = false;
+    return chunk.slice(lineEnd + (chunk.charCodeAt(lineEnd) === CR && chunk.charCodeAt(lineEnd + 1) === LF ? 2 : 1));
+  }
+  function storeTrailing(trailing) {
+    if (!trailing)
+      return;
+    if (trailing.charCodeAt(trailing.length - 1) === CR) {
+      parseLine(trailing, 0, trailing.length - 1);
+      skipNextLineFeed = true;
+      return;
+    }
+    if (shouldBufferTrailing(trailing)) {
+      pendingFragments.push(trailing);
+      pendingFragmentsLength = trailing.length;
+      return;
+    }
+    skippingLine = true;
+  }
+  function shouldBufferTrailing(trailing) {
+    const firstCharCode = trailing.charCodeAt(0);
+    return firstCharCode === 58 && !!onComment || firstCharCode === 100 && isPotentialField(trailing, "data") || firstCharCode === 101 && isPotentialField(trailing, "event") || firstCharCode === 105 && isPotentialField(trailing, "id") || firstCharCode === 114 && isPotentialField(trailing, "retry");
+  }
+  function checkBufferSize() {
+    if (maxBufferSize === undefined)
+      return;
+    if (pendingFragmentsLength + data.length <= maxBufferSize)
+      return;
+    terminated = true;
+    pendingFragments.length = 0;
+    pendingFragmentsLength = 0;
+    id = undefined;
+    data = "";
+    dataLines = 0;
+    eventType = undefined;
+    skippingLine = false;
+    skipNextLineFeed = false;
+    onError === null || onError === undefined || onError(new ParseError(`Buffered data exceeded max buffer size of ${maxBufferSize} characters`, {
+      type: "max-buffer-size-exceeded"
+    }));
+  }
+  function processLines(chunk) {
+    let searchIndex = 0;
+    if (chunk.indexOf("\r") === -1) {
+      let lfIndex = chunk.indexOf(`
+`, searchIndex);
+      while (lfIndex !== -1) {
+        if (searchIndex === lfIndex) {
+          if (id !== undefined) {
+            onId === null || onId === undefined || onId(id);
+          }
+          if (dataLines > 0) {
+            onEvent === null || onEvent === undefined || onEvent({ id, event: eventType, data });
+          }
+          id = undefined;
+          data = "";
+          dataLines = 0;
+          eventType = undefined;
+          searchIndex = lfIndex + 1;
+          lfIndex = chunk.indexOf(`
+`, searchIndex);
+          continue;
+        }
+        const firstCharCode = chunk.charCodeAt(searchIndex);
+        if (isDataPrefix(chunk, searchIndex, firstCharCode)) {
+          const valueStart = chunk.charCodeAt(searchIndex + 5) === SPACE ? searchIndex + 6 : searchIndex + 5;
+          const value = chunk.slice(valueStart, lfIndex);
+          if (dataLines === 0 && chunk.charCodeAt(lfIndex + 1) === LF) {
+            if (id !== undefined) {
+              onId === null || onId === undefined || onId(id);
+            }
+            onEvent === null || onEvent === undefined || onEvent({ id, event: eventType, data: value });
+            id = undefined;
+            data = "";
+            eventType = undefined;
+            searchIndex = lfIndex + 2;
+            lfIndex = chunk.indexOf(`
+`, searchIndex);
+            continue;
+          }
+          data = dataLines === 0 ? value : `${data}
+${value}`;
+          dataLines++;
+        } else if (isEventPrefix(chunk, searchIndex, firstCharCode)) {
+          eventType = chunk.slice(chunk.charCodeAt(searchIndex + 6) === SPACE ? searchIndex + 7 : searchIndex + 6, lfIndex) || undefined;
+        } else {
+          parseLine(chunk, searchIndex, lfIndex);
+        }
+        searchIndex = lfIndex + 1;
+        lfIndex = chunk.indexOf(`
+`, searchIndex);
+      }
+      return chunk.slice(searchIndex);
+    }
+    while (searchIndex < chunk.length) {
+      const crIndex = chunk.indexOf("\r", searchIndex);
+      const lfIndex = chunk.indexOf(`
+`, searchIndex);
+      let lineEnd = -1;
+      if (crIndex !== -1 && lfIndex !== -1) {
+        lineEnd = crIndex < lfIndex ? crIndex : lfIndex;
+      } else if (crIndex !== -1) {
+        if (crIndex === chunk.length - 1) {
+          lineEnd = -1;
+        } else {
+          lineEnd = crIndex;
+        }
+      } else if (lfIndex !== -1) {
+        lineEnd = lfIndex;
+      }
+      if (lineEnd === -1) {
+        break;
+      }
+      parseLine(chunk, searchIndex, lineEnd);
+      searchIndex = lineEnd + 1;
+      if (chunk.charCodeAt(searchIndex - 1) === CR && chunk.charCodeAt(searchIndex) === LF) {
+        searchIndex++;
+      }
+    }
+    return chunk.slice(searchIndex);
+  }
+  function parseLine(chunk, start, end) {
+    if (start === end) {
+      dispatchEvent();
+      return;
+    }
+    const firstCharCode = chunk.charCodeAt(start);
+    if (isDataPrefix(chunk, start, firstCharCode)) {
+      const valueStart = chunk.charCodeAt(start + 5) === SPACE ? start + 6 : start + 5;
+      const value = chunk.slice(valueStart, end);
+      data = dataLines === 0 ? value : `${data}
+${value}`;
+      dataLines++;
+      return;
+    }
+    if (isEventPrefix(chunk, start, firstCharCode)) {
+      eventType = chunk.slice(chunk.charCodeAt(start + 6) === SPACE ? start + 7 : start + 6, end) || undefined;
+      return;
+    }
+    if (firstCharCode === 105 && chunk.charCodeAt(start + 1) === 100 && chunk.charCodeAt(start + 2) === 58) {
+      const value = chunk.slice(chunk.charCodeAt(start + 3) === SPACE ? start + 4 : start + 3, end);
+      if (!value.includes("\x00"))
+        id = value;
+      return;
+    }
+    if (firstCharCode === 58) {
+      if (onComment) {
+        const line = chunk.slice(start, end);
+        onComment(line.slice(chunk.charCodeAt(start + 1) === SPACE ? 2 : 1));
+      }
+      return;
+    }
+    const line = chunk.slice(start, end);
+    const fieldSeparatorIndex = line.indexOf(":");
+    if (fieldSeparatorIndex === -1) {
+      processField(line, "", line);
+      return;
+    }
+    const field = line.slice(0, fieldSeparatorIndex);
+    const offset = line.charCodeAt(fieldSeparatorIndex + 1) === SPACE ? 2 : 1;
+    const value = line.slice(fieldSeparatorIndex + offset);
+    processField(field, value, line);
+  }
+  function processField(field, value, line) {
+    switch (field) {
+      case "event":
+        eventType = value || undefined;
+        break;
+      case "data":
+        data = dataLines === 0 ? value : `${data}
+${value}`;
+        dataLines++;
+        break;
+      case "id":
+        if (!value.includes("\x00"))
+          id = value;
+        break;
+      case "retry":
+        if (/^\d+$/.test(value)) {
+          onRetry === null || onRetry === undefined || onRetry(parseInt(value, 10));
+        } else {
+          onError === null || onError === undefined || onError(new ParseError(`Invalid \`retry\` value: "${value}"`, {
+            type: "invalid-retry",
+            value,
+            line
+          }));
+        }
+        break;
+      default:
+        onError === null || onError === undefined || onError(new ParseError(`Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`, { type: "unknown-field", field, value, line }));
+        break;
+    }
+  }
+  function dispatchEvent() {
+    if (id !== undefined) {
+      onId === null || onId === undefined || onId(id);
+    }
+    if (dataLines > 0) {
+      onEvent === null || onEvent === undefined || onEvent({
+        id,
+        event: eventType,
+        data
+      });
+    }
+    id = undefined;
+    data = "";
+    dataLines = 0;
+    eventType = undefined;
+  }
+  function reset(options = {}) {
+    if (options.consume && pendingFragments.length > 0) {
+      const incompleteLine = pendingFragments.join("");
+      parseLine(incompleteLine, 0, incompleteLine.length);
+    }
+    isFirstChunk = true;
+    id = undefined;
+    data = "";
+    dataLines = 0;
+    eventType = undefined;
+    pendingFragments.length = 0;
+    pendingFragmentsLength = 0;
+    terminated = false;
+    skippingLine = false;
+    skipNextLineFeed = false;
+  }
+  return { feed, reset };
+}
+function isDataPrefix(chunk, i, firstCharCode) {
+  return firstCharCode === 100 && chunk.charCodeAt(i + 1) === 97 && chunk.charCodeAt(i + 2) === 116 && chunk.charCodeAt(i + 3) === 97 && chunk.charCodeAt(i + 4) === 58;
+}
+function isEventPrefix(chunk, i, firstCharCode) {
+  return firstCharCode === 101 && chunk.charCodeAt(i + 1) === 118 && chunk.charCodeAt(i + 2) === 101 && chunk.charCodeAt(i + 3) === 110 && chunk.charCodeAt(i + 4) === 116 && chunk.charCodeAt(i + 5) === 58;
+}
+function isPotentialField(line, field) {
+  let i = 1;
+  while (i < line.length && i < field.length) {
+    if (line.charCodeAt(i) !== field.charCodeAt(i)) {
+      return false;
+    }
+    i++;
+  }
+  return line.length <= field.length || line.charCodeAt(field.length) === 58;
+}
+// ../../node_modules/.bun/eventsource@5.1.1/node_modules/eventsource/dist/errors.js
+class ErrorEvent extends Event {
+  code;
+  message;
+  constructor(type, errorEventInitDict) {
+    super(type);
+    this.code = errorEventInitDict?.code ?? undefined;
+    this.message = errorEventInitDict?.message ?? undefined;
+  }
+  [Symbol.for("nodejs.util.inspect.custom")](_depth, options, inspect) {
+    return inspect(inspectableError(this), options);
+  }
+  [Symbol.for("Deno.customInspect")](inspect, options) {
+    return inspect(inspectableError(this), options);
+  }
+}
+function syntaxError(message) {
+  const DomException = globalThis.DOMException;
+  if (typeof DomException === "function") {
+    return new DomException(message, "SyntaxError");
+  }
+  return new SyntaxError(message);
+}
+function flattenError(err) {
+  if (!(err instanceof Error)) {
+    return `${err}`;
+  }
+  if ("errors" in err && Array.isArray(err.errors)) {
+    return err.errors.map(flattenError).join(", ");
+  }
+  if ("cause" in err && err.cause instanceof Error) {
+    return `${err}: ${flattenError(err.cause)}`;
+  }
+  return err.message;
+}
+function inspectableError(err) {
+  return {
+    type: err.type,
+    message: err.message,
+    code: err.code,
+    defaultPrevented: err.defaultPrevented,
+    cancelable: err.cancelable,
+    timeStamp: err.timeStamp
+  };
+}
+
+// ../../node_modules/.bun/eventsource@5.1.1/node_modules/eventsource/dist/EventSource.js
+var DEFAULT_MAX_BUFFER_SIZE = 100 * 1024 * 1024;
+
+class EventSourceImpl extends EventTarget {
+  static CONNECTING = 0;
+  static OPEN = 1;
+  static CLOSED = 2;
+  CONNECTING = 0;
+  OPEN = 1;
+  CLOSED = 2;
+  get readyState() {
+    return this.#readyState;
+  }
+  get url() {
+    return this.#url.href;
+  }
+  get withCredentials() {
+    return this.#withCredentials;
+  }
+  get onerror() {
+    return this.#onError;
+  }
+  set onerror(value) {
+    if (this.#onError) {
+      this.removeEventListener("error", this.#onError);
+    }
+    this.#onError = value;
+    if (value) {
+      this.addEventListener("error", value);
+    }
+  }
+  get onmessage() {
+    return this.#onMessage;
+  }
+  set onmessage(value) {
+    if (this.#onMessage) {
+      this.removeEventListener("message", this.#onMessage);
+    }
+    this.#onMessage = value;
+    if (value) {
+      this.addEventListener("message", value);
+    }
+  }
+  get onopen() {
+    return this.#onOpen;
+  }
+  set onopen(value) {
+    if (this.#onOpen) {
+      this.removeEventListener("open", this.#onOpen);
+    }
+    this.#onOpen = value;
+    if (value) {
+      this.addEventListener("open", value);
+    }
+  }
+  addEventListener(type, listener, options) {
+    const listen = listener;
+    super.addEventListener(type, listen, options);
+  }
+  removeEventListener(type, listener, options) {
+    const listen = listener;
+    super.removeEventListener(type, listen, options);
+  }
+  constructor(url, eventSourceInitDict) {
+    super();
+    try {
+      if (url instanceof URL) {
+        this.#url = url;
+      } else if (typeof url === "string") {
+        this.#url = new URL(url, getBaseURL());
+      } else {
+        throw new Error("Invalid URL");
+      }
+    } catch {
+      throw syntaxError("An invalid or illegal string was specified");
+    }
+    this.#parser = createParser({
+      maxBufferSize: eventSourceInitDict?.maxBufferSize ?? DEFAULT_MAX_BUFFER_SIZE,
+      onEvent: this.#onEvent,
+      onError: this.#onParseError,
+      onId: this.#onIdChange,
+      onRetry: this.#onRetryChange
+    });
+    this.#readyState = this.CONNECTING;
+    this.#reconnectInterval = 3000;
+    this.#fetch = eventSourceInitDict?.fetch ?? globalThis.fetch;
+    this.#withCredentials = eventSourceInitDict?.withCredentials ?? false;
+    this.#connect();
+  }
+  close() {
+    if (this.#reconnectTimer)
+      clearTimeout(this.#reconnectTimer);
+    if (this.#readyState === this.CLOSED)
+      return;
+    if (this.#controller)
+      this.#controller.abort();
+    this.#readyState = this.CLOSED;
+    this.#controller = undefined;
+  }
+  #readyState;
+  #url;
+  #redirectUrl;
+  #withCredentials;
+  #fetch;
+  #reconnectInterval;
+  #reconnectTimer;
+  #lastEventId = null;
+  #controller;
+  #parser;
+  #onError = null;
+  #onMessage = null;
+  #onOpen = null;
+  #connect() {
+    this.#readyState = this.CONNECTING;
+    this.#controller = new AbortController;
+    const fetch2 = this.#fetch;
+    fetch2(this.#url, this.#getRequestOptions()).then(this.#onFetchResponse).catch(this.#onFetchError);
+  }
+  #onFetchResponse = async (response) => {
+    this.#parser.reset();
+    const { body, redirected, status, headers } = response;
+    if (status === 204) {
+      this.#failConnection("Server sent HTTP 204, not reconnecting", 204);
+      this.close();
+      return;
+    }
+    if (redirected) {
+      this.#redirectUrl = new URL(response.url);
+    } else {
+      this.#redirectUrl = undefined;
+    }
+    if (status !== 200) {
+      this.#failConnection(`Non-200 status code (${status})`, status);
+      return;
+    }
+    const contentType = headers.get("content-type") || "";
+    if (!contentType.startsWith("text/event-stream")) {
+      this.#failConnection('Invalid content type, expected "text/event-stream"', status);
+      return;
+    }
+    if (this.#readyState === this.CLOSED) {
+      return;
+    }
+    this.#readyState = this.OPEN;
+    const openEvent = new Event("open");
+    this.dispatchEvent(openEvent);
+    if (typeof body !== "object" || !body || !("getReader" in body)) {
+      this.#failConnection("Invalid response body, expected a web ReadableStream", status);
+      this.close();
+      return;
+    }
+    const decoder = new TextDecoder;
+    const reader = body.getReader();
+    let open = true;
+    do {
+      const { done, value } = await reader.read();
+      if (this.#readyState === this.CLOSED) {
+        open = false;
+        break;
+      }
+      if (value) {
+        this.#parser.feed(decoder.decode(value, { stream: !done }));
+      }
+      if (!done) {
+        continue;
+      }
+      open = false;
+      this.#parser.reset();
+      this.#scheduleReconnect();
+    } while (open);
+  };
+  #onFetchError = (err) => {
+    this.#controller = undefined;
+    if (err.name === "AbortError" || err.type === "aborted") {
+      return;
+    }
+    this.#scheduleReconnect(flattenError(err));
+  };
+  #getRequestOptions() {
+    const lastEvent = this.#lastEventId ? { "Last-Event-ID": this.#lastEventId } : undefined;
+    const init = {
+      mode: "cors",
+      redirect: "follow",
+      headers: { Accept: "text/event-stream", ...lastEvent },
+      cache: "no-store",
+      signal: this.#controller?.signal
+    };
+    if ("window" in globalThis) {
+      init.credentials = this.withCredentials ? "include" : "same-origin";
+    }
+    return init;
+  }
+  #onIdChange = (value) => {
+    this.#lastEventId = value;
+  };
+  #onEvent = (event) => {
+    const origin = this.#redirectUrl ? this.#redirectUrl.origin : this.#url.origin;
+    const lastEventId = this.#lastEventId ?? "";
+    const messageEvent = new MessageEvent(event.event || "message", {
+      data: event.data,
+      origin,
+      lastEventId
+    });
+    if (messageEvent.origin !== origin) {
+      defineEventProperty(messageEvent, "origin", origin);
+    }
+    if (messageEvent.lastEventId !== lastEventId) {
+      defineEventProperty(messageEvent, "lastEventId", lastEventId);
+    }
+    this.dispatchEvent(messageEvent);
+  };
+  #onRetryChange = (value) => {
+    this.#reconnectInterval = value;
+  };
+  #onParseError = (error) => {
+    if (error.type !== "max-buffer-size-exceeded") {
+      return;
+    }
+    this.close();
+    this.#failConnection(error.message);
+  };
+  #failConnection(message, code) {
+    if (this.#readyState !== this.CLOSED) {
+      this.#readyState = this.CLOSED;
+    }
+    const errorEvent = new ErrorEvent("error", { code, message });
+    this.dispatchEvent(errorEvent);
+  }
+  #scheduleReconnect(message, code) {
+    if (this.#readyState === this.CLOSED) {
+      return;
+    }
+    this.#readyState = this.CONNECTING;
+    const errorEvent = new ErrorEvent("error", { code, message });
+    this.dispatchEvent(errorEvent);
+    const timer = setTimeout(this.#reconnect, this.#reconnectInterval);
+    if (typeof timer === "object" && timer !== null && "unref" in timer) {
+      timer.unref();
+    }
+    this.#reconnectTimer = timer;
+  }
+  #reconnect = () => {
+    this.#reconnectTimer = undefined;
+    if (this.#readyState !== this.CONNECTING) {
+      return;
+    }
+    this.#connect();
+  };
+}
+Object.defineProperty(EventSourceImpl, "name", { value: "EventSource" });
+Object.defineProperty(EventSourceImpl, Symbol.for("eventsource.supports-fetch-override"), {
+  value: true,
+  writable: false,
+  configurable: false,
+  enumerable: false
+});
+var EventSource = EventSourceImpl;
+function getBaseURL() {
+  const doc = "document" in globalThis ? globalThis.document : undefined;
+  return doc && typeof doc === "object" && "baseURI" in doc && typeof doc.baseURI === "string" ? doc.baseURI : undefined;
+}
+function defineEventProperty(event, property, value) {
+  Object.defineProperty(event, property, {
+    value,
+    enumerable: true,
+    configurable: true
+  });
+}
+// ../sdk/dist/index.js
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var DEFAULT_GITTERM_SERVER_URL = "https://api.gitterm.dev";
+function getConfigPath(configPath) {
+  return configPath ?? join(homedir(), ".config", "gitterm", "cli.json");
+}
+function parseConfig(text) {
+  const parsed = JSON.parse(text);
+  if (!parsed.token || !parsed.serverUrl)
+    return null;
+  return {
+    serverUrl: parsed.serverUrl,
+    token: parsed.token,
+    createdAt: parsed.createdAt ?? Date.now()
+  };
+}
+function loadConfigSync(configPath) {
+  try {
+    const text = readFileSync(getConfigPath(configPath), "utf-8");
+    return parseConfig(text);
+  } catch {
+    return null;
+  }
+}
+var WORKSPACE_LIFECYCLE_ERROR_CODES = [
+  "WORKSPACE_NOT_RUNNING",
+  "WORKSPACE_TERMINATED",
+  "WORKSPACE_NON_RECOVERABLE",
+  "WORKSPACE_START_TIMEOUT",
+  "WORKSPACE_RESTART_FAILED"
+];
+
+class GittermError extends Error {
+  code;
+  status;
+  constructor(code, message, options = {}) {
+    super(message, "cause" in options ? { cause: options.cause } : undefined);
+    this.name = "GittermError";
+    this.code = code;
+    this.status = options.status;
+  }
+}
+
+class WorkspaceLifecycleError extends GittermError {
+  constructor(code, message, options = {}) {
+    super(code, message, options);
+    this.name = "WorkspaceLifecycleError";
+  }
+}
+
+class AgentRunError extends GittermError {
+  run;
+  constructor(run, code) {
+    super(code, run.error ?? (code === "INPUT_REQUIRED" ? "The agent needs input; supply a handler or use runs.respond()" : `Agent run ${run.status}`));
+    this.run = run;
+    this.name = "AgentRunError";
+  }
+}
+var LOOPBACK_HOSTS = new Set(["localhost", "127.0.0.1", "[::1]", "::1"]);
+function normalizeServerUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error(`Invalid GitTerm server URL: ${value}`);
+  }
+  if (url.username || url.password) {
+    throw new Error("GitTerm server URL must not contain credentials");
+  }
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && LOOPBACK_HOSTS.has(url.hostname))) {
+    throw new Error("GitTerm server URL must use HTTPS (HTTP is allowed only for loopback)");
+  }
+  url.hash = "";
+  url.search = "";
+  return url.toString().replace(/\/$/, "");
+}
+function withPath(serverUrl, pathname) {
+  const url = new URL(serverUrl);
+  url.pathname = pathname;
+  return url.toString();
+}
+function basePath(serverUrl) {
+  return new URL(serverUrl).pathname.replace(/\/+$/, "");
+}
+function trpcEndpoint(serverUrl) {
+  const base = basePath(serverUrl);
+  return withPath(serverUrl, base.endsWith("/trpc") ? base : `${base}/trpc`);
+}
+function createNoRedirectFetch(fetchImpl = fetch) {
+  return async (input, init) => {
+    const response = await fetchImpl(input, { ...init, redirect: "manual" });
+    if (response.status >= 300 && response.status < 400) {
+      const location = response.headers.get("location");
+      throw new Error(location ? `GitTerm server redirects are not allowed: ${location}` : "GitTerm server redirects are not allowed");
+    }
+    return response;
+  };
+}
+function terminal(status) {
+  return status === "completed" || status === "failed" || status === "cancelled";
+}
+function aborted(signal) {
+  if (signal?.aborted)
+    throw new GittermError("ABORTED", "Run observation was aborted; the agent was not cancelled");
+}
+async function abortable(operation, signal) {
+  if (signal.aborted)
+    operation.catch(() => {});
+  aborted(signal);
+  let onAbort;
+  try {
+    return await Promise.race([
+      operation,
+      new Promise((_, reject) => {
+        onAbort = () => reject(new GittermError("ABORTED", "Run observation was aborted; the agent was not cancelled"));
+        signal.addEventListener("abort", onAbort, { once: true });
+      })
+    ]);
+  } finally {
+    if (onAbort)
+      signal.removeEventListener("abort", onAbort);
+  }
+}
+async function deadline(options, operation) {
+  aborted(options?.signal);
+  const timeoutMs = options?.timeoutMs ?? 30 * 60000;
+  if (!Number.isFinite(timeoutMs) || timeoutMs < 0)
+    throw new GittermError("BAD_REQUEST", "timeoutMs must be finite and non-negative");
+  const controller = new AbortController;
+  const onAbort = () => controller.abort();
+  options?.signal?.addEventListener("abort", onAbort, { once: true });
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    controller.abort();
+  }, timeoutMs);
+  try {
+    return await operation(controller.signal);
+  } catch (error) {
+    if (timedOut)
+      throw new GittermError("TIMEOUT", "Run observation timed out; the agent was not cancelled", {
+        cause: error
+      });
+    aborted(options?.signal);
+    throw error;
+  } finally {
+    clearTimeout(timer);
+    options?.signal?.removeEventListener("abort", onAbort);
+    controller.abort();
+  }
+}
+async function* runEvents(states) {
+  const seen = new Set;
+  let pending = new Set;
+  let status;
+  for await (const run of states) {
+    if (run.status !== status) {
+      status = run.status;
+      yield { type: "run.status", run };
+    }
+    const current = new Set(run.pendingInputs.map((request) => request.id));
+    for (const requestId of pending) {
+      if (!current.has(requestId))
+        yield { type: "input.resolved", run, requestId };
+    }
+    pending = current;
+    for (const request of run.pendingInputs) {
+      if (seen.has(request.id))
+        continue;
+      seen.add(request.id);
+      yield { type: "input.required", run, request };
+    }
+    if (run.status === "completed" || run.status === "failed" || run.status === "cancelled") {
+      yield { type: `run.${run.status}`, run };
+      return;
+    }
+  }
+}
+function runHelpers(operations) {
+  return {
+    events: (ref, options) => runEvents(operations.watch(ref, options)),
+    wait: (ref, options) => deadline(options, async (signal) => {
+      for await (const run of operations.watch(ref, { signal })) {
+        if (terminal(run.status) || run.status === "awaiting_input" && options?.until !== "terminal")
+          return run;
+      }
+      throw new GittermError("NETWORK", "Run stream ended before a terminal state");
+    }),
+    result: (ref, options) => deadline(options, async (signal) => {
+      for await (const event of runEvents(operations.watch(ref, { signal }))) {
+        aborted(signal);
+        if (event.type === "run.completed")
+          return event.run;
+        if (event.type === "run.failed")
+          throw new AgentRunError(event.run, "RUN_FAILED");
+        if (event.type === "run.cancelled")
+          throw new AgentRunError(event.run, "RUN_CANCELLED");
+        if (event.type !== "input.required")
+          continue;
+        const { request } = event;
+        let reply;
+        if (request.kind === "permission") {
+          if (!options?.onPermission)
+            throw new AgentRunError(event.run, "INPUT_REQUIRED");
+          reply = {
+            type: "permission",
+            response: await abortable(Promise.resolve(options.onPermission(request, { signal })), signal)
+          };
+        } else {
+          if (!options?.onQuestion)
+            throw new AgentRunError(event.run, "INPUT_REQUIRED");
+          reply = {
+            type: "question",
+            ...await abortable(Promise.resolve(options.onQuestion(request, { signal })), signal)
+          };
+        }
+        aborted(signal);
+        try {
+          await abortable(operations.respond(ref, { requestId: request.id, reply }), signal);
+        } catch (error) {
+          if (!(error instanceof GittermError) || error.code !== "INPUT_NOT_PENDING")
+            throw error;
+        }
+      }
+      throw new GittermError("NETWORK", "Run stream ended before a terminal state");
+    })
+  };
+}
+function toConnection(connection) {
+  const details = connection.details;
+  return {
+    ...connection,
+    connectedAt: toIso(connection.connectedAt),
+    details: "lastCheckedAt" in details ? { ...details, lastCheckedAt: toIso(details.lastCheckedAt) } : details
+  };
+}
+function envValue(name) {
+  const value = typeof process !== "undefined" ? process.env[name] : undefined;
+  return value && value.trim() ? value : undefined;
+}
+function resolveCredentials(options) {
+  const config = !options.serverUrl || !options.token ? loadConfigSync(options.configPath) : null;
+  const serverUrl = options.serverUrl ?? envValue("GITTERM_SERVER_URL") ?? config?.serverUrl ?? DEFAULT_GITTERM_SERVER_URL;
+  const token = options.token ?? envValue("GITTERM_API_TOKEN") ?? config?.token;
+  if (!serverUrl || !token) {
+    throw new GittermError("NOT_LOGGED_IN", "Not logged in. Run: gitterm login");
+  }
+  return { serverUrl: normalizeServerUrl(serverUrl), token };
+}
+function toIso(value) {
+  if (!value)
+    return null;
+  return value instanceof Date ? value.toISOString() : value;
+}
+function normalizeBaseCommit(value) {
+  if (value == null)
+    return null;
+  const trimmed = value.trim();
+  if (!trimmed)
+    return null;
+  return /^[0-9a-f]{40}([0-9a-f]{24})?$/i.test(trimmed) ? trimmed.toLowerCase() : trimmed;
+}
+function workspaceIdOf(ref) {
+  return typeof ref === "string" ? ref : ref.id;
+}
+function runTargetOf(ref) {
+  return { workspaceId: ref.workspaceId, runId: ref.id };
+}
+function throwIfAborted2(signal, what) {
+  if (signal?.aborted)
+    throw new GittermError("ABORTED", `Aborted while ${what}`);
+}
+function sleep2(ms, signal, what) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new GittermError("ABORTED", `Aborted while ${what}`));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function normalizeWorkspace(workspace) {
+  if (!workspace)
+    return null;
+  return {
+    id: workspace.id,
+    name: workspace.name,
+    status: workspace.status,
+    repositoryUrl: workspace.repositoryUrl,
+    repositoryBranch: workspace.repositoryBranch,
+    baseCommit: normalizeBaseCommit(workspace.baseCommit ?? workspace.repositoryBaseCommit ?? null),
+    checkoutRef: workspace.checkoutRef ?? workspace.repositoryCheckoutRef ?? null,
+    domain: workspace.domain,
+    subdomain: workspace.subdomain,
+    persistent: workspace.persistent,
+    hostingType: workspace.hostingType,
+    serverOnly: workspace.serverOnly,
+    workspaceProfile: workspace.workspaceProfile,
+    cloudProviderId: workspace.cloudProviderId,
+    agentType: workspace.image?.agentType ? {
+      id: workspace.image.agentType.id,
+      name: workspace.image.agentType.name,
+      description: workspace.image.agentType.description
+    } : null,
+    image: workspace.image ? {
+      id: workspace.image.id,
+      name: workspace.image.name,
+      imageId: workspace.image.imageId
+    } : null,
+    metadata: workspace.metadata ?? {},
+    autoTerminateAt: toIso(workspace.autoTerminateAt),
+    customImage: workspace.customImage ?? null,
+    startedAt: toIso(workspace.startedAt),
+    pausedAt: toIso(workspace.pausedAt),
+    terminatedAt: toIso(workspace.terminatedAt),
+    lastActiveAt: toIso(workspace.lastActiveAt),
+    updatedAt: toIso(workspace.updatedAt)
+  };
+}
+function normalizeRuntime(runtime) {
+  return {
+    workspaceId: runtime.workspaceId,
+    status: runtime.status,
+    url: runtime.url,
+    headers: runtime.headers,
+    password: runtime.password,
+    directory: runtime.directory,
+    repo: runtime.repo,
+    branch: runtime.branch,
+    baseCommit: normalizeBaseCommit(runtime.baseCommit),
+    checkoutRef: runtime.checkoutRef,
+    persistent: runtime.persistent,
+    recoverable: runtime.recoverable,
+    providerKey: runtime.providerKey
+  };
+}
+function mapTrpcCode(code) {
+  switch (code) {
+    case "UNAUTHORIZED":
+      return "UNAUTHORIZED";
+    case "NOT_FOUND":
+      return "NOT_FOUND";
+    case "FORBIDDEN":
+      return "FORBIDDEN";
+    case "BAD_REQUEST":
+      return "BAD_REQUEST";
+    case "CONFLICT":
+      return "CONFLICT";
+    case "TIMEOUT":
+      return "TIMEOUT";
+    default:
+      return "SERVER_ERROR";
+  }
+}
+function credentialErrorCode(message) {
+  const match = /^(MODEL_CREDENTIAL_(?:UNAVAILABLE|DUPLICATE_PROVIDER|INVALID|REQUIRED)):\s*/.exec(message);
+  return match?.[1];
+}
+function toGittermError(serverUrl, error) {
+  if (error instanceof GittermError)
+    return error;
+  if (error instanceof TRPCClientError) {
+    const data = error.data;
+    if (!data) {
+      return new GittermError("NETWORK", `Could not reach the GitTerm server at ${serverUrl}`, {
+        cause: error.cause ?? error
+      });
+    }
+    const status = { status: data.httpStatus };
+    const structuredLifecycleCode = WORKSPACE_LIFECYCLE_ERROR_CODES.find((candidate) => candidate === data.workspaceLifecycleCode);
+    if (structuredLifecycleCode) {
+      return new WorkspaceLifecycleError(structuredLifecycleCode, error.message, status);
+    }
+    if (error.message.startsWith("INPUT_NOT_PENDING:"))
+      return new GittermError("INPUT_NOT_PENDING", error.message, status);
+    const credentialCode = credentialErrorCode(error.message);
+    if (credentialCode)
+      return new GittermError(credentialCode, error.message, status);
+    const lifecycleCode = WORKSPACE_LIFECYCLE_ERROR_CODES.find((candidate) => error.message.startsWith(`${candidate}:`));
+    if (lifecycleCode)
+      return new WorkspaceLifecycleError(lifecycleCode, error.message, status);
+    const code = mapTrpcCode(data.code);
+    return new GittermError(code, code === "UNAUTHORIZED" ? `${error.message}. Check your GitTerm API token, or create a new one in the dashboard.` : error.message, status);
+  }
+  return new GittermError("NETWORK", error instanceof Error ? error.message : "Network request failed", { cause: error });
+}
+async function runWithServer(serverUrl, operation) {
+  try {
+    return await operation();
+  } catch (error) {
+    throw toGittermError(serverUrl, error);
+  }
+}
+function isTerminalRun(status) {
+  return status === "completed" || status === "failed" || status === "cancelled";
+}
+async function* watchRun(trpc, serverUrl, target, options) {
+  const what = `watching run ${target.runId}`;
+  throwIfAborted2(options?.signal, what);
+  const queue = [];
+  let wake;
+  const push = (item) => {
+    queue.push(item);
+    wake?.();
+    wake = undefined;
+  };
+  const onAbort = () => push({ error: new GittermError("ABORTED", `Aborted while ${what}`) });
+  options?.signal?.addEventListener("abort", onAbort, { once: true });
+  let last;
+  const subscription = trpc.run.lifecycle.subscribe(target, {
+    onData: (event) => {
+      last = event.run;
+      push({ run: last });
+    },
+    onError: (error) => push({ error }),
+    onComplete: () => push(last && isTerminalRun(last.status) ? { done: true } : {
+      error: new GittermError("NETWORK", `Run ${target.runId} event stream ended unexpectedly`)
+    })
+  });
+  try {
+    while (true) {
+      throwIfAborted2(options?.signal, what);
+      if (queue.length === 0)
+        await new Promise((resolve) => wake = resolve);
+      const item = queue.shift();
+      if ("done" in item)
+        return;
+      if ("error" in item)
+        throw toGittermError(serverUrl, item.error);
+      yield item.run;
+      if (isTerminalRun(item.run.status))
+        return;
+    }
+  } finally {
+    options?.signal?.removeEventListener("abort", onAbort);
+    subscription.unsubscribe();
+  }
+}
+function createGittermClient(options = {}) {
+  const credentials = resolveCredentials(options);
+  const fetchImpl = createNoRedirectFetch(options.fetch);
+  const authorization = `Bearer ${credentials.token}`;
+  const trpc = createTRPCClient({
+    links: [
+      splitLink({
+        condition: (operation) => operation.type === "subscription",
+        true: httpSubscriptionLink({
+          url: trpcEndpoint(credentials.serverUrl),
+          EventSource,
+          eventSourceOptions: {
+            fetch: (url, init) => fetchImpl(url, { ...init, headers: { ...init.headers, authorization } })
+          }
+        }),
+        false: httpBatchLink({
+          url: trpcEndpoint(credentials.serverUrl),
+          fetch: fetchImpl,
+          headers: () => ({ authorization })
+        })
+      })
+    ]
+  });
+  const run = (operation) => runWithServer(credentials.serverUrl, operation);
+  const watch = (ref, watchOptions) => watchRun(trpc, credentials.serverUrl, runTargetOf(ref), watchOptions);
+  const respond = (ref, input) => run(async () => trpc.run.respond.mutate({ ...runTargetOf(ref), ...input }));
+  const normalizeCreateResult = (result) => {
+    const workspace = normalizeWorkspace(result.workspace);
+    if (!workspace)
+      throw new GittermError("SERVER_ERROR", "Workspace creation failed");
+    const runtime = result.runtime ? normalizeRuntime(result.runtime) : {
+      workspaceId: workspace.id,
+      status: workspace.status,
+      url: null,
+      directory: "/workspace",
+      repo: workspace.repositoryUrl,
+      branch: workspace.repositoryBranch,
+      baseCommit: workspace.baseCommit,
+      checkoutRef: workspace.checkoutRef,
+      persistent: workspace.persistent,
+      recoverable: workspace.status !== "terminated",
+      providerKey: null
+    };
+    return { workspace, runtime };
+  };
+  const createWorkspace = (input) => run(async () => {
+    const result = await trpc.workspace.createWorkspace.mutate(input);
+    return normalizeCreateResult(result);
+  });
+  const waitForWorkspaceSetup = async (workspaceId, waitOptions) => {
+    const timeoutMs = waitOptions?.timeoutMs ?? 10 * 60000;
+    const pollIntervalMs = waitOptions?.pollIntervalMs ?? 2000;
+    const signal = waitOptions?.signal;
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+      throwIfAborted2(signal, "waiting for workspace setup");
+      const result = await trpc.workspace.getSetupStatus.query({ workspaceId }, { signal });
+      if (result.status === "not_requested" || result.status === "succeeded")
+        return result;
+      if (result.status === "failed") {
+        const log = result.log?.trim();
+        throw new GittermError("BAD_REQUEST", `Workspace setup failed${result.exitCode === null ? "" : ` with exit code ${result.exitCode}`}${log ? `
+${log}` : ""}`);
+      }
+      if (Date.now() >= deadline) {
+        const log = result.log?.trim();
+        throw new GittermError("TIMEOUT", `Timed out waiting for workspace ${workspaceId} setup (last status: ${result.status})${log ? `
+${log}` : ""}`);
+      }
+      await sleep2(pollIntervalMs, signal, "waiting for workspace setup");
+    }
+  };
+  return {
+    serverUrl: credentials.serverUrl,
+    auth: {
+      status: () => run(async () => {
+        const me = await trpc.agent.me.query();
+        return {
+          loggedIn: true,
+          userId: me.userId,
+          email: me.email,
+          name: me.name,
+          plan: me.plan ?? "free",
+          authMethod: me.authMethod
+        };
+      })
+    },
+    workspaces: {
+      list: (input) => run(async () => {
+        const result = await trpc.workspace.listWorkspaces.query(input);
+        return {
+          workspaces: result.workspaces.map(normalizeWorkspace).filter((workspace) => workspace !== null),
+          pagination: result.pagination
+        };
+      }),
+      get: (ref) => run(async () => {
+        const result = await trpc.workspace.getWorkspace.query({
+          workspaceId: workspaceIdOf(ref)
+        });
+        const workspace = normalizeWorkspace(result.workspace);
+        if (!workspace)
+          throw new GittermError("NOT_FOUND", "Workspace not found");
+        return workspace;
+      }),
+      getRuntimeAccess: (ref) => run(async () => {
+        const result = await trpc.workspace.getRuntimeAccess.query({
+          workspaceId: workspaceIdOf(ref)
+        });
+        return normalizeRuntime(result);
+      }),
+      ensureRunning: (ref, waitOptions) => run(async () => {
+        throwIfAborted2(waitOptions?.signal, "ensuring the workspace is running");
+        const result = await trpc.workspace.ensureRunning.mutate({
+          workspaceId: workspaceIdOf(ref),
+          timeoutMs: waitOptions?.timeoutMs,
+          pollIntervalMs: waitOptions?.pollIntervalMs
+        }, { signal: waitOptions?.signal });
+        const workspace = normalizeWorkspace(result.workspace);
+        if (!workspace)
+          throw new GittermError("SERVER_ERROR", "ensureRunning failed");
+        return {
+          workspace,
+          runtime: normalizeRuntime(result.runtime)
+        };
+      }),
+      pause: (ref) => run(async () => {
+        const result = await trpc.workspace.pauseWorkspace.mutate({
+          workspaceId: workspaceIdOf(ref)
+        });
+        return { durationMinutes: result.durationMinutes };
+      }),
+      restart: (ref) => run(async () => {
+        const result = await trpc.workspace.restartWorkspace.mutate({
+          workspaceId: workspaceIdOf(ref)
+        });
+        return { status: result.status };
+      }),
+      terminate: (ref) => run(async () => {
+        const result = await trpc.workspace.deleteWorkspace.mutate({
+          workspaceId: workspaceIdOf(ref)
+        });
+        return {
+          workspace: normalizeWorkspace(result.workspace),
+          cleanupInBackground: result.cleanupInBackground
+        };
+      }),
+      create: createWorkspace,
+      models: (ref) => run(() => trpc.workspace.getModelAccess.query({ workspaceId: workspaceIdOf(ref) })),
+      setupStatus: (ref) => run(async () => trpc.workspace.getSetupStatus.query({ workspaceId: workspaceIdOf(ref) })),
+      waitForSetup: (ref, waitOptions) => run(() => waitForWorkspaceSetup(workspaceIdOf(ref), waitOptions))
+    },
+    sandboxes: {
+      create: (input) => run(() => trpc.sandbox.create.mutate(input)),
+      list: (input) => run(() => trpc.sandbox.list.query(input)),
+      get: (sandboxId) => run(() => trpc.sandbox.get.query({ sandboxId })),
+      run: (sandboxId, command, options) => run(async () => {
+        const result = await trpc.sandbox.run.mutate({ sandboxId, command, ...options });
+        if (!result)
+          throw new GittermError("SERVER_ERROR", "Sandbox command returned no result");
+        return result;
+      }),
+      writeFile: (sandboxId, path, data) => run(async () => {
+        await trpc.sandbox.writeFile.mutate({
+          sandboxId,
+          path,
+          contentBase64: Buffer.from(data).toString("base64")
+        });
+      }),
+      readFile: (sandboxId, path) => run(async () => {
+        const result = await trpc.sandbox.readFile.mutate({ sandboxId, path });
+        return new Uint8Array(Buffer.from(result?.contentBase64 ?? "", "base64"));
+      }),
+      preview: (sandboxId, port, options) => run(async () => {
+        const result = await trpc.sandbox.preview.mutate({
+          sandboxId,
+          port,
+          public: options?.public
+        });
+        if (!result)
+          throw new GittermError("SERVER_ERROR", "Sandbox preview returned no result");
+        return result;
+      }),
+      resume: (sandboxId) => run(async () => {
+        await trpc.workspace.restartWorkspace.mutate({ workspaceId: sandboxId });
+      }),
+      terminate: (sandboxId) => run(async () => {
+        await trpc.sandbox.terminate.mutate({ sandboxId });
+      }),
+      saveSnapshot: (sandboxId, label) => run(() => trpc.sandbox.saveSnapshot.mutate({ sandboxId, label: label.slice(0, 120) })),
+      listSnapshots: () => run(() => trpc.sandbox.snapshots.query()),
+      deleteSnapshot: (snapshotId) => run(async () => {
+        await trpc.sandbox.deleteSnapshot.mutate({ snapshotId });
+      }),
+      onJobFinished: (listener) => {
+        const subscription = trpc.sandbox.jobEvents.subscribe(undefined, {
+          onData: (event) => listener(event),
+          onError: () => {}
+        });
+        return () => subscription.unsubscribe();
+      }
+    },
+    runs: {
+      create: (input) => run(async () => {
+        const { signal, workspace, ...rest } = input;
+        const request = {
+          ...rest,
+          workspaceId: workspaceIdOf(workspace),
+          context: rest.context?.type === "continue" ? { type: "continue", runId: rest.context.run.id } : rest.context
+        };
+        if (request.waitForSetup) {
+          await waitForWorkspaceSetup(request.workspaceId, {
+            timeoutMs: request.setupTimeoutMs,
+            signal
+          });
+        }
+        throwIfAborted2(signal, "creating the run");
+        return trpc.run.create.mutate({ ...request, idempotencyKey: request.idempotencyKey ?? crypto.randomUUID() }, { signal });
+      }),
+      list: (ref, listOptions) => run(async () => trpc.run.list.query({
+        workspaceId: workspaceIdOf(ref),
+        ...listOptions
+      })),
+      get: (ref) => run(async () => trpc.run.get.query(runTargetOf(ref))),
+      messages: (ref) => run(async () => {
+        const messages = await trpc.run.messages.query(runTargetOf(ref));
+        return messages.map((message) => ({ ...message, parts: message.parts ?? [] }));
+      }),
+      cancel: (ref) => run(async () => trpc.run.cancel.mutate(runTargetOf(ref))),
+      respond,
+      watch,
+      ...runHelpers({ watch, respond })
+    },
+    catalog: {
+      agentTypes: (input) => run(async () => {
+        const result = await trpc.workspace.listAgentTypes.query(input);
+        return result.agentTypes;
+      }),
+      cloudProviders: (input) => run(async () => {
+        const result = await trpc.workspace.listCloudProviders.query(input);
+        return result.cloudProviders;
+      }),
+      workspaceOptions: () => run(async () => trpc.workspace.getWorkspaceCatalog.query())
+    },
+    integrations: {
+      catalog: () => run(async () => trpc.integrations.catalog.query()),
+      connections: {
+        list: (filter) => run(async () => {
+          const result = await trpc.integrations.connections.list.query(filter);
+          return result.map(toConnection);
+        }),
+        get: (id) => run(async () => toConnection(await trpc.integrations.connections.get.query({ id }))),
+        resolve: (references, options) => run(async () => {
+          const result = await trpc.integrations.connections.resolve.query({
+            references,
+            ...options?.repo ? { repo: options.repo } : {}
+          });
+          return result.map(toConnection);
+        }),
+        create: (input) => run(async () => {
+          const result = await trpc.integrations.connections.create.mutate(input);
+          return result.status !== "pending" ? { ...result, connection: toConnection(result.connection) } : result;
+        }),
+        remove: (id) => run(async () => {
+          await trpc.integrations.connections.remove.mutate({ id });
+        }),
+        waitFor: ({
+          integration,
+          since,
+          connectionId,
+          timeoutMs = 5 * 60000,
+          intervalMs = 3000
+        }) => run(async () => {
+          const sinceMs = since ? new Date(since).getTime() : 0;
+          const deadline = Date.now() + timeoutMs;
+          while (Date.now() < deadline) {
+            const result = await trpc.integrations.connections.list.query({
+              integration,
+              kind: "personal"
+            });
+            const match = result.map(toConnection).filter((c) => c.status === "connected" && (connectionId ? c.id === connectionId : new Date(c.connectedAt).getTime() >= sinceMs)).sort((a, b) => b.connectedAt.localeCompare(a.connectedAt))[0];
+            if (match)
+              return match;
+            await new Promise((resolve) => setTimeout(resolve, intervalMs));
+          }
+          throw new Error(`Timed out waiting for a ${integration} connection`);
+        })
+      },
+      github: {
+        repositories: (connectionId) => run(async () => trpc.integrations.github.repositories.query({ connectionId })),
+        branches: (connectionId, owner, repo) => run(async () => trpc.integrations.github.branches.query({ connectionId, owner, repo }))
+      },
+      google: {
+        setup: () => run(async () => trpc.integrations.google.setup.query())
+      },
+      mcp: {
+        test: (id) => run(async () => {
+          const result = await trpc.integrations.mcp.test.mutate({ id });
+          return { ...result, connection: toConnection(result.connection) };
+        }),
+        update: (input) => run(async () => toConnection(await trpc.integrations.mcp.update.mutate(input)))
+      }
+    },
+    bots: {
+      acquireLease: (leaseId) => run(() => trpc.bots.acquireLease.mutate({ leaseId })),
+      releaseLease: (leaseId) => run(() => trpc.bots.releaseLease.mutate({ leaseId })),
+      self: () => run(async () => trpc.bots.self.query())
+    },
+    credentials: {
+      list: () => run(async () => {
+        const result = await trpc.modelCredentials.listMyCredentials.query();
+        return result.credentials.map((credential) => ({
+          ...credential,
+          lastUsedAt: toIso(credential.lastUsedAt),
+          oauthExpiresAt: toIso(credential.oauthExpiresAt),
+          createdAt: toIso(credential.createdAt),
+          updatedAt: toIso(credential.updatedAt)
+        }));
+      }),
+      listProviders: () => run(async () => {
+        const result = await trpc.modelCredentials.listProviders.query();
+        return result.providers.map((provider) => ({
+          id: provider.id,
+          name: provider.name,
+          logicalProviderKey: provider.logicalProviderKey,
+          displayName: provider.displayName,
+          authType: provider.authType,
+          isRecommended: provider.isRecommended
+        }));
+      })
+    }
+  };
+}
+
+// src/handoff.ts
+import { randomUUID } from "crypto";
+import { realpath as realpath2 } from "fs/promises";
+import path2 from "path";
+import { setTimeout as delay } from "timers/promises";
+import { OpenCode } from "@opencode/client";
+
+// src/snapshot.ts
+import { createHash } from "crypto";
+import { execFile } from "child_process";
+import { lstat, mkdtemp, readFile, realpath, rm, stat } from "fs/promises";
+import { tmpdir } from "os";
+import path from "path";
+var MAX_SNAPSHOT_BYTES = 25 * 1024 * 1024;
+var DIFF_ARGS = [
+  "--binary",
+  "--full-index",
+  "--no-ext-diff",
+  "--no-textconv",
+  "--no-renames",
+  "--no-color",
+  "--unified=3",
+  "--inter-hunk-context=0",
+  "--diff-algorithm=myers",
+  "--no-indent-heuristic",
+  "--src-prefix=a/",
+  "--dst-prefix=b/"
+];
+async function git(directory, args, maxBytes = MAX_SNAPSHOT_BYTES) {
+  return new Promise((resolve, reject) => {
+    execFile("git", ["-c", "core.quotePath=true", ...args], {
+      cwd: directory,
+      encoding: "buffer",
+      maxBuffer: maxBytes,
+      timeout: 60000,
+      env: { ...process.env, GIT_OPTIONAL_LOCKS: "0", GIT_TERMINAL_PROMPT: "0" }
+    }, (error, stdout) => {
+      if (error)
+        reject(new Error("Git snapshot operation failed. Check repository access, unresolved conflicts, and snapshot size."));
+      else
+        resolve(stdout);
+    });
+  });
+}
+async function checkoutRoot(directory) {
+  return realpath((await git(directory, ["rev-parse", "--show-toplevel"])).toString().trim());
+}
+var PRIVATE_KEY = /-----BEGIN (?:[A-Z0-9]+ )*PRIVATE KEY-----(?:\r?\n[+\- ]?|(?:\\r)?\\n)(?:[A-Za-z-]+: [^\r\n]*(?:\r?\n[+\- ]?|(?:\\r)?\\n))*(?:\r?\n[+\- ]?|(?:\\r)?\\n)?[A-Za-z0-9+/]{16}/;
+function safeRelativePath(file) {
+  return Boolean(file) && !file.includes("\\") && !file.includes("\x00") && !path.posix.isAbsolute(file) && file.split("/").every((part) => part !== "" && part !== "." && part !== ".." && part.toLowerCase() !== ".git");
+}
+function sensitivePath(file) {
+  return /(^|\/)(\.env($|\.(?!(?:[^/]*\.)?(?:example|sample|template)$))|id_(rsa|ed25519|ecdsa)($|\.)|credentials(?:\.json)?$)|\.(pem|p12|pfx|key)$/i.test(file);
+}
+var nulList = (buffer) => {
+  if (!Buffer.from(buffer.toString()).equals(buffer))
+    throw new Error("Non-UTF-8 filenames are not supported by cloud handoff.");
+  return buffer.toString().split("\x00").filter(Boolean);
+};
+var stateDigest = (state) => createHash("sha256").update(JSON.stringify(state)).digest("hex");
+async function readWorkingState(root, includeChanges) {
+  const head = (await git(root, ["rev-parse", "HEAD"])).toString().trim();
+  if ((await git(root, ["ls-files", "--unmerged", "-z"])).length) {
+    throw new Error("Resolve merge conflicts before continuing in the cloud.");
+  }
+  if ((await git(root, ["ls-files", "--stage"])).toString().split(`
+`).some((line) => line.startsWith("160000 "))) {
+    throw new Error("Cloud handoff does not support submodules yet.");
+  }
+  if (!includeChanges)
+    return { head, staged: "", unstaged: "", files: [], changedPaths: [] };
+  if ((await git(root, ["diff", "--name-only", "--diff-filter=A", "--"])).length) {
+    throw new Error("Stage or unstage intent-to-add files before cloud handoff.");
+  }
+  const stagedBytes = await git(root, ["diff", ...DIFF_ARGS, "--cached", "HEAD", "--"]);
+  const unstagedBytes = await git(root, ["diff", ...DIFF_ARGS, "--"]);
+  if (PRIVATE_KEY.test(stagedBytes.toString() + unstagedBytes.toString())) {
+    throw new Error("Private key material detected in changed files. Remove it before uploading.");
+  }
+  const staged = stagedBytes.toString("base64");
+  const unstaged = unstagedBytes.toString("base64");
+  const untracked = nulList(await git(root, ["ls-files", "--others", "--exclude-standard", "-z"])).toSorted();
+  const changedPaths = [
+    ...new Set([
+      ...nulList(await git(root, ["diff", "--name-only", "-z", "--no-renames", "HEAD", "--"])),
+      ...nulList(await git(root, ["diff", "--name-only", "-z", "--cached", "HEAD", "--"])),
+      ...untracked
+    ])
+  ].toSorted();
+  for (const file of changedPaths) {
+    if (!safeRelativePath(file))
+      throw new Error("The checkout contains a path that cannot be transferred safely.");
+    if (sensitivePath(file))
+      throw new Error(`Potential secret file ${JSON.stringify(file)} is changed. Exclude it or continue without uncommitted changes.`);
+  }
+  let bytes = stagedBytes.length + unstagedBytes.length;
+  const files = [];
+  for (const file of untracked) {
+    const full = path.join(root, file);
+    const info = await lstat(full);
+    if (!info.isFile() || await realpath(full) !== full) {
+      throw new Error("Untracked symlinks, nested repositories, and special files are not supported.");
+    }
+    bytes += info.size;
+    if (bytes > MAX_SNAPSHOT_BYTES)
+      throw new Error("Uncommitted changes exceed the 25 MiB handoff limit.");
+    const content = await readFile(full);
+    if (PRIVATE_KEY.test(content.toString("latin1"))) {
+      throw new Error(`Private key material detected in ${JSON.stringify(file)}. Remove it before uploading.`);
+    }
+    files.push({
+      path: file,
+      data: content.toString("base64"),
+      executable: Boolean(info.mode & 73)
+    });
+  }
+  return { head, staged, unstaged, files, changedPaths };
+}
+async function captureSnapshot(directory, includeChanges) {
+  const root = await checkoutRoot(directory);
+  const temporary = await mkdtemp(path.join(tmpdir(), "gitterm-handoff-"));
+  try {
+    const before = await readWorkingState(root, includeChanges);
+    const bundlePath = path.join(temporary, "checkout.bundle");
+    await git(root, ["bundle", "create", bundlePath, "HEAD"]);
+    const bundleSize = (await stat(bundlePath)).size;
+    if (bundleSize > MAX_SNAPSHOT_BYTES)
+      throw new Error("Repository history exceeds the 25 MiB handoff limit.");
+    const bundle = (await readFile(bundlePath)).toString("base64");
+    const after = await readWorkingState(root, includeChanges);
+    const digest = stateDigest(before);
+    if (digest !== stateDigest(after))
+      throw new Error("The checkout changed during capture. Pause writers and retry.");
+    const bytes = bundleSize + Buffer.from(before.staged, "base64").length + Buffer.from(before.unstaged, "base64").length + before.files.reduce((sum, file) => sum + Buffer.from(file.data, "base64").length, 0);
+    if (bytes > MAX_SNAPSHOT_BYTES)
+      throw new Error("Checkout snapshot exceeds the 25 MiB handoff limit.");
+    return { version: 1, ...before, bundle, digest, bytes };
+  } finally {
+    await rm(temporary, { recursive: true, force: true });
+  }
+}
+async function repositoryUrl(root) {
+  const url = (await git(root, ["remote", "get-url", "origin"])).toString().trim();
+  if (/^https:\/\//i.test(url)) {
+    const parsed = new URL(url);
+    if (parsed.username || parsed.password || parsed.search || parsed.hash)
+      throw new Error("Use a credential-free origin URL and a GitTerm repository connection.");
+    return parsed.href;
+  }
+  const ssh = /^(?:git@github\.com:|ssh:\/\/git@github\.com\/)([^\s]+)$/.exec(url);
+  if (ssh?.[1])
+    return `https://github.com/${ssh[1]}`;
+  throw new Error("Cloud handoff needs an HTTPS origin (or a GitHub SSH origin). Configure repository access in GitTerm.");
+}
+async function sharedCheckoutSessions(root, sessionID, sessions) {
+  const matches = [];
+  for (const session of sessions) {
+    if (session.id === sessionID)
+      continue;
+    try {
+      if (await checkoutRoot(session.location.directory) === root)
+        matches.push(session.id);
+    } catch {}
+  }
+  return matches;
+}
+
+// src/restore.ts
+var RESTORE_SCRIPT = String.raw`
+const fs = require("node:fs");
+const path = require("node:path");
+const cp = require("node:child_process");
+const crypto = require("node:crypto");
+const stage = process.argv[1];
+if (!/^\.gitterm-handoff-[a-f0-9-]+$/.test(stage)) throw new Error("Invalid staging directory");
+const diffArgs = ${JSON.stringify(DIFF_ARGS)};
+const git = (...args) => cp.execFileSync("git", ["-c", "core.hooksPath=/dev/null", "-c", "core.quotePath=true", ...args], { maxBuffer: 64 * 1024 * 1024, stdio: ["ignore", "pipe", "pipe"] });
+const safePath = file => typeof file === "string" && file.length > 0 && !file.includes("\\") && !file.includes("\0") && !path.posix.isAbsolute(file) && file.split("/").every(part => part && part !== "." && part !== ".." && part.toLowerCase() !== ".git");
+try {
+  const snapshot = JSON.parse(fs.readFileSync(path.join(stage, "snapshot.json"), "utf8"));
+  if (snapshot.version !== 1 || !/^[a-f0-9]{40}([a-f0-9]{24})?$/.test(snapshot.head)) throw new Error("Invalid snapshot");
+  const untracked = git("ls-files", "--others", "--exclude-standard", "-z").toString().split("\0").filter(Boolean);
+  if (git("diff", "HEAD", "--").length || git("diff", "--cached", "HEAD", "--").length || untracked.some(file => !file.startsWith(stage + "/"))) throw new Error("Cloud checkout has existing changes");
+  const bundle = path.join(stage, "checkout.bundle");
+  fs.writeFileSync(bundle, Buffer.from(snapshot.bundle, "base64"), { mode: 0o600 });
+  git("bundle", "verify", bundle);
+  git("fetch", "--no-tags", "./" + bundle, "HEAD");
+  if (git("rev-parse", "FETCH_HEAD").toString().trim() !== snapshot.head) throw new Error("Bundle revision mismatch");
+  git("checkout", "--no-overwrite-ignore", "-b", "gitterm/" + stage.slice(".gitterm-handoff-".length), "FETCH_HEAD");
+  if (snapshot.staged) {
+    const patch = path.join(stage, "staged.patch");
+    fs.writeFileSync(patch, Buffer.from(snapshot.staged, "base64"));
+    git("apply", "--index", "--binary", "--whitespace=nowarn", patch);
+  }
+  if (snapshot.unstaged) {
+    const patch = path.join(stage, "unstaged.patch");
+    fs.writeFileSync(patch, Buffer.from(snapshot.unstaged, "base64"));
+    git("apply", "--binary", "--whitespace=nowarn", patch);
+  }
+  for (const file of snapshot.files) {
+    if (!safePath(file.path)) throw new Error("Unsafe file path");
+    const pieces = file.path.split("/");
+    let directory = process.cwd();
+    for (const piece of pieces.slice(0, -1)) {
+      directory = path.join(directory, piece);
+      if (!fs.existsSync(directory)) fs.mkdirSync(directory);
+      if (!fs.lstatSync(directory).isDirectory() || fs.lstatSync(directory).isSymbolicLink()) throw new Error("Unsafe parent directory");
+    }
+    fs.writeFileSync(file.path, Buffer.from(file.data, "base64"), { flag: "wx", mode: file.executable ? 0o755 : 0o644 });
+  }
+  fs.rmSync(stage, { recursive: true });
+  const restoredUntracked = git("ls-files", "--others", "--exclude-standard", "-z").toString().split("\0").filter(Boolean).sort();
+  const expectedUntracked = snapshot.files.map(file => file.path).sort();
+  if (JSON.stringify(restoredUntracked) !== JSON.stringify(expectedUntracked)) throw new Error("Untracked file inventory mismatch");
+  const files = snapshot.files.map(file => ({ path: file.path, data: fs.readFileSync(file.path).toString("base64"), executable: Boolean(fs.statSync(file.path).mode & 0o111) }));
+  const state = { head: git("rev-parse", "HEAD").toString().trim(), staged: git("diff", ...diffArgs, "--cached", "HEAD", "--").toString("base64"), unstaged: git("diff", ...diffArgs, "--").toString("base64"), files, changedPaths: snapshot.changedPaths };
+  const digest = crypto.createHash("sha256").update(JSON.stringify(state)).digest("hex");
+  if (digest !== snapshot.digest) throw new Error("Restored checkout verification failed");
+  process.stdout.write("GITTERM_HANDOFF_VERIFIED");
+} catch {
+  // Never print patches, files, credentials, or upstream command output.
+  process.stderr.write("GitTerm checkout restoration failed. Local files are unchanged.\n");
+  process.exitCode = 1;
+} finally {
+  fs.rmSync(stage, { recursive: true, force: true });
+}
+`;
+var shellQuote = (value) => `'${value.replaceAll("'", `'"'"'`)}'`;
+
+// src/handoff.ts
+var STEPS = {
+  creating: "creating the cloud workspace",
+  restoring: "restoring your checkout in the cloud",
+  importing: "importing this session into the cloud",
+  ready: "finishing",
+  failed: "finishing"
+};
+
+class HandoffCancelled extends Error {
+  constructor() {
+    super("Cloud handoff cancelled. Local files and sessions are unchanged.");
+  }
+}
+function changePrompt(sharedCount) {
+  return [
+    "Copies this checkout's tracked edits and non-ignored untracked files. Local files remain unchanged.",
+    sharedCount > 0 ? `${sharedCount} other active session(s) use this checkout. Their changes may be included too.` : "",
+    "Other OpenCode servers, editors, and background writers cannot all be detected. Pause writers for a consistent snapshot."
+  ].filter(Boolean).join(`
+`);
+}
+async function askForm(client, sessionID, title, fields, signal) {
+  const form = await client.session.form.create({ sessionID, title, fields }, { signal });
+  const deadline = Date.now() + 10 * 60000;
+  try {
+    while (Date.now() < deadline) {
+      const detail = await client.session.form.get({ sessionID, formID: form.id }, { signal });
+      if (detail.state.status === "cancelled")
+        throw new HandoffCancelled;
+      if (detail.state.status === "answered")
+        return detail.state.answer;
+      await delay(400, undefined, { signal });
+    }
+    throw new HandoffCancelled;
+  } finally {
+    await client.session.form.cancel({ sessionID, formID: form.id }, { signal: AbortSignal.timeout(5000) }).catch(() => {});
+  }
+}
+async function assertIdle(client, sessionID, signal) {
+  if ((await client.session.active({ signal }))[sessionID]) {
+    throw new Error("Stop this session's running agent before continuing in the cloud. Other sessions will not be interrupted.");
+  }
+  if ((await client.session.inbox.list({ sessionID }, { signal })).length > 0) {
+    throw new Error("This session has pending input. Finish or cancel it before continuing in the cloud.");
+  }
+}
+function runtimeClient(runtime) {
+  if (!runtime.url)
+    throw new Error("The workspace does not have an OpenCode server URL.");
+  const url = new URL(runtime.url);
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname))) {
+    throw new Error("Cloud handoff requires HTTPS (or a loopback development server).");
+  }
+  const headers = new Headers(runtime.headers);
+  if (runtime.password)
+    headers.set("Authorization", `Basic ${Buffer.from(`opencode:${runtime.password}`).toString("base64")}`);
+  if (!headers.has("Authorization"))
+    throw new Error("The workspace did not return an OpenCode access credential.");
+  return OpenCode.make({
+    baseUrl: runtime.url,
+    headers,
+    fetch: (input, init) => fetch(input, { ...init, redirect: "error" })
+  });
+}
+async function runRemoteShell(remote, directory, command, signal) {
+  const location = { directory };
+  let shell = (await remote.shell.create({ location, cwd: directory, command, timeout: 120000 }, { signal })).data;
+  try {
+    while (shell.status === "running") {
+      await delay(300, undefined, { signal });
+      shell = (await remote.shell.get({ id: shell.id, location }, { signal })).data;
+    }
+    if (shell.status !== "exited" || shell.exit !== 0) {
+      throw new Error("Cloud checkout restoration failed. The workspace is retained for inspection; local files are unchanged.");
+    }
+  } finally {
+    if (shell.status === "running")
+      await remote.shell.remove({ id: shell.id, location }, { signal: AbortSignal.timeout(5000) }).catch(() => {});
+  }
+}
+function importPayload(data, directory) {
+  const {
+    parentID: _parent,
+    fork: _fork,
+    revert: _revert,
+    permissions: _permissions,
+    ...info
+  } = data.info;
+  return {
+    info: { ...info, location: { directory } },
+    messages: data.messages,
+    location: { directory }
+  };
+}
+async function handoffSession(sessionID, deps) {
+  const { local, gitterm, options, signal } = deps;
+  await assertIdle(local, sessionID, signal);
+  const session = await local.session.get({ sessionID }, { signal });
+  const sourceDirectory = await realpath2(session.location.directory);
+  const root = await checkoutRoot(sourceDirectory);
+  const repo = await repositoryUrl(root);
+  const active = await local.session.active({ signal });
+  const activeSessions = await Promise.all(Object.keys(active).filter((id) => id !== sessionID).map((id) => local.session.get({ sessionID: id }, { signal }).catch(() => {
+    return;
+  })));
+  const shared = await sharedCheckoutSessions(root, sessionID, activeSessions.filter((item) => item !== undefined));
+  const choice = await askForm(local, sessionID, "Continue in GitTerm", [
+    {
+      key: "changes",
+      type: "boolean",
+      title: "Include uncommitted changes?",
+      description: changePrompt(shared.length),
+      default: false,
+      required: true
+    }
+  ], signal);
+  const includeChanges = choice.changes === true;
+  await assertIdle(local, sessionID, signal);
+  const snapshot = await captureSnapshot(root, includeChanges);
+  const manifest = snapshot.changedPaths.slice(0, 100).map((file) => JSON.stringify(file)).join(`
+`);
+  const confirmation = await askForm(local, sessionID, "Create cloud workspace?", [
+    {
+      key: "create",
+      type: "boolean",
+      title: "Upload this snapshot and start billable cloud compute?",
+      required: true,
+      default: false,
+      description: [
+        `Repository: ${repo}
+Commit: ${snapshot.head}
+Snapshot: ${(snapshot.bytes / 1024 / 1024).toFixed(2)} MiB`,
+        includeChanges ? `${snapshot.changedPaths.length} changed paths${manifest ? `:
+${manifest}` : ""}${snapshot.changedPaths.length > 100 ? `
+(additional paths omitted)` : ""}` : "Uncommitted changes are excluded.",
+        "Uploads this conversation (which may contain secrets) and Git history, including unpublished commits. Ignored files are not separately uploaded; tracked history can contain secrets. Review before approving.",
+        "Uses your GitTerm model/repository connections, not separately copied local credential stores. Cloud compute may incur charges until paused or terminated in GitTerm. Local work remains untouched; later local edits will not sync."
+      ].join(`
+
+`)
+    }
+  ], signal);
+  if (confirmation.create !== true)
+    throw new HandoffCancelled;
+  await assertIdle(local, sessionID, signal);
+  const exported = await local.session.export({ sessionID }, { signal });
+  await assertIdle(local, sessionID, signal);
+  if (exported.info.location.directory !== session.location.directory || exported.info.time.updated !== session.time.updated) {
+    throw new Error("The session changed during handoff preparation. Retry after it is idle.");
+  }
+  if (Buffer.byteLength(JSON.stringify(exported)) > 25 * 1024 * 1024)
+    throw new Error("Session history exceeds the 25 MiB handoff limit.");
+  const record = {
+    attemptID: randomUUID(),
+    sessionID,
+    phase: "creating",
+    sourceDirectory: root,
+    head: snapshot.head,
+    includeChanges,
+    sharedSessions: shared.length,
+    createdAt: new Date().toISOString()
+  };
+  await deps.save(record);
+  try {
+    await deps.progress("Creating a GitTerm workspace. Your local checkout and sessions remain unchanged.");
+    const created = await gitterm.workspaces.create({
+      idempotencyKey: `opencode-handoff:${record.attemptID}`,
+      name: options.name ?? session.title ?? "OpenCode cloud handoff",
+      repo,
+      agent: "opencode",
+      provider: options.provider,
+      persistent: options.persistent,
+      connections: options.connections,
+      metadata: { "opencode.handoff": record.attemptID, "opencode.session": sessionID }
+    });
+    record.workspaceID = created.workspace.id;
+    record.phase = "restoring";
+    await deps.save(record);
+    await gitterm.workspaces.ensureRunning(record.workspaceID, { signal });
+    const runtime = await gitterm.workspaces.getRuntimeAccess(record.workspaceID);
+    const remote = runtimeClient(runtime);
+    await remote.server.info({ signal });
+    const stage = `.gitterm-handoff-${record.attemptID}`;
+    await deps.progress("Restoring and verifying the captured checkout in the cloud.");
+    await runRemoteShell(remote, runtime.directory, `node -e ${shellQuote('require("node:fs").mkdirSync(process.argv[1], { mode: 0o700 })')} ${shellQuote(stage)}`, signal);
+    try {
+      await remote.file.write({
+        location: { directory: runtime.directory },
+        path: `${stage}/snapshot.json`,
+        payload: Buffer.from(JSON.stringify(snapshot))
+      }, { signal });
+      await runRemoteShell(remote, runtime.directory, `node -e ${shellQuote(RESTORE_SCRIPT)} ${shellQuote(stage)}`, signal);
+    } finally {
+      await runRemoteShell(remote, runtime.directory, `node -e ${shellQuote('require("node:fs").rmSync(process.argv[1], { recursive: true, force: true })')} ${shellQuote(stage)}`, AbortSignal.timeout(1e4)).catch(() => {});
+    }
+    const subpath = path2.relative(root, sourceDirectory).split(path2.sep).join("/");
+    if (subpath.startsWith("../") || path2.isAbsolute(subpath))
+      throw new Error("The session moved outside its source checkout.");
+    const directory = path2.posix.join(runtime.directory, subpath);
+    await runRemoteShell(remote, runtime.directory, `node -e ${shellQuote('require("node:fs").mkdirSync(process.argv[1], { recursive: true })')} ${shellQuote(directory)}`, signal);
+    record.phase = "importing";
+    await deps.save(record);
+    const imported = await remote.session.import(importPayload(exported, directory), { signal });
+    if (imported.id !== sessionID || imported.location.directory !== directory)
+      throw new Error("Cloud session verification failed.");
+    await remote.session.synthetic({
+      sessionID,
+      resume: false,
+      text: [
+        `Continued from local checkout ${root}. The current cloud working directory is ${directory}.`,
+        includeChanges ? "The captured checkout includes uncommitted changes, potentially from other sessions." : "Uncommitted local changes were excluded; do not assume edits described in history exist here.",
+        "Historical absolute paths refer to the old machine. Use the cloud checkout. Local processes, separately ignored files, credential stores, and global plugins/configuration were not migrated. Repository-owned configuration travels with the checkout. Select an available cloud model/agent if needed."
+      ].join(`
+`)
+    }, { signal });
+    record.phase = "ready";
+    await deps.save(record);
+    return record;
+  } catch (error) {
+    const step = STEPS[record.phase];
+    record.phase = "failed";
+    await deps.save(record);
+    console.error("GitTerm cloud handoff failed while", step, error);
+    const reason = error instanceof GittermError ? ` ${error.message}` : "";
+    throw new Error(`Cloud handoff failed while ${step}${record.workspaceID ? ` for workspace ${record.workspaceID}` : ` (attempt ${record.attemptID})`}.${reason} Check GitTerm before retrying; a workspace may still be running and incurring charges. Local files and sessions are unchanged.`);
+  }
+}
+async function showConnection(local, gitterm, record, signal) {
+  if (record.phase !== "ready" || !record.workspaceID) {
+    throw new Error(`The last cloud handoff is ${record.phase}. ${record.workspaceID ? `Inspect workspace ${record.workspaceID} in GitTerm.` : `Look for attempt ${record.attemptID} in GitTerm.`} Local work is unchanged.`);
+  }
+  await gitterm.workspaces.ensureRunning(record.workspaceID, { signal });
+  const runtime = await gitterm.workspaces.getRuntimeAccess(record.workspaceID);
+  const remote = runtimeClient(runtime);
+  let connection = runtime.url;
+  let paired = false;
+  if (new URL(connection).pathname === "/") {
+    try {
+      const pairing = await remote.server.pair({ signal });
+      connection = `${connection.replace(/\/$/, "")}/auth/connect/${encodeURIComponent(pairing.code)}`;
+      paired = true;
+    } catch {}
+  }
+  await askForm(local, record.sessionID, "Your cloud session is ready", [
+    {
+      key: "open",
+      type: "external",
+      url: connection,
+      title: "Open cloud OpenCode",
+      description: paired ? "One-time link; expires in five minutes. Alternatively paste into desktop Connect server." : "Sign in using the workspace credential from your GitTerm dashboard."
+    },
+    {
+      key: "done",
+      type: "boolean",
+      title: "Done",
+      default: true,
+      description: `Open session ${record.sessionID}. Workspace: ${record.workspaceID}. Run /cloud for a fresh connection to this same workspace. Later local changes are not synced. Local work is unchanged.`,
+      required: true
+    }
+  ], signal);
+}
+
+// src/index.ts
+var sessionKey = (sessionID) => `handoff/session/${sessionID}`;
+async function localClient(options) {
+  const explicit = options.localServerUrl ?? process.env.GITTERM_OPENCODE_LOCAL_SERVER_URL;
+  if (explicit) {
+    const url = new URL(explicit);
+    if (!["http:", "https:"].includes(url.protocol) || !["localhost", "127.0.0.1", "[::1]"].includes(url.hostname) || url.username || url.password) {
+      throw new Error("localServerUrl must be a loopback OpenCode server URL without embedded credentials.");
+    }
+    const password = options.localServerPassword ?? process.env.GITTERM_OPENCODE_LOCAL_SERVER_PASSWORD;
+    return OpenCode2.make({
+      baseUrl: explicit,
+      headers: password ? { Authorization: `Basic ${Buffer.from(`opencode:${password}`).toString("base64")}` } : {},
+      fetch: (input, init) => fetch(input, { ...init, redirect: "error" })
+    });
+  }
+  const endpoint = await Service.discover();
+  if (!endpoint)
+    throw new Error("Cannot discover this OpenCode service. For standalone/custom servers, set localServerUrl and the optional localServerPassword plugin options.");
+  return OpenCode2.make({
+    baseUrl: endpoint.url,
+    headers: Service.headers(endpoint),
+    fetch: (input, init) => fetch(input, { ...init, redirect: "error" })
+  });
+}
+var GittermCloudPlugin = Plugin.define({
+  id: "gitterm.cloud",
+  async setup(ctx) {
+    const options = ctx.options;
+    const controller = new AbortController;
+    const busy = new Set;
+    const load = async (sessionID) => await ctx.storage.get(sessionKey(sessionID));
+    const save = async (record) => {
+      await ctx.storage.set(`handoff/attempt/${record.attemptID}`, { ...record });
+      await ctx.storage.set(sessionKey(record.sessionID), { ...record });
+    };
+    const gitterm = () => createGittermClient({ serverUrl: options.serverUrl, token: options.token });
+    await ctx.command.transform((editor) => {
+      editor.add({
+        name: "cloud",
+        description: "Continue in GitTerm, or reconnect to this session's existing cloud workspace",
+        async execute({ sessionID }) {
+          if (busy.has(sessionID))
+            throw new Error("A cloud handoff is already in progress for this session.");
+          busy.add(sessionID);
+          try {
+            if (process.env.WORKSPACE_ID)
+              throw new Error("This session is already running in a GitTerm workspace.");
+            const local = await localClient(options);
+            const source = await ctx.session.get({ sessionID });
+            const connected = await local.session.get({ sessionID }, { signal: controller.signal });
+            if (connected.location.directory !== source.location.directory || connected.time.created !== source.time.created) {
+              throw new Error("/cloud can't reach the OpenCode server holding this session (opencode --standalone uses a private one). Run `opencode serve --port 4096`, open it with `opencode --server http://127.0.0.1:4096`, and set the plugin's localServerUrl to that address.");
+            }
+            const client = gitterm();
+            const previous = await load(sessionID);
+            if (previous?.phase === "ready") {
+              await showConnection(local, client, previous, controller.signal);
+              return;
+            }
+            if (previous) {
+              const answer = await askForm(local, sessionID, "Previous cloud handoff is incomplete", [
+                {
+                  key: "retry",
+                  type: "boolean",
+                  title: "Start a new cloud handoff?",
+                  default: false,
+                  required: true,
+                  description: `Previous attempt: ${previous.attemptID}${previous.workspaceID ? `; workspace: ${previous.workspaceID}` : ""}. Check GitTerm first: that workspace may still be running. It will NOT be deleted by retrying, and another workspace may incur additional charges.`
+                }
+              ], controller.signal);
+              if (answer.retry !== true)
+                throw new HandoffCancelled;
+            }
+            await client.auth.status();
+            const record = await handoffSession(sessionID, {
+              local,
+              gitterm: client,
+              options,
+              signal: controller.signal,
+              save,
+              progress: async (text) => {
+                console.info(`GitTerm: ${text}`);
+              }
+            });
+            await showConnection(local, client, record, controller.signal);
+          } catch (error) {
+            if (!(error instanceof HandoffCancelled))
+              throw error;
+          } finally {
+            busy.delete(sessionID);
+          }
+        }
+      });
+    });
+    return async () => {
+      controller.abort();
+    };
+  }
+});
+var src_default = GittermCloudPlugin;
+export {
+  GittermCloudPlugin,
+  src_default as default
+};