@lobehub/cli 0.0.1-canary.3 → 0.0.1-canary.4

package/dist/index.js

@@ -12,7 +12,7 @@ import path4 from "path";
 import { randomUUID } from "crypto";
 import { EventEmitter } from "events";
 import os from "os";
-import WebSocket from "ws";
+import WebSocket2 from "ws";
 var DEFAULT_GATEWAY_URL = "https://device-gateway.lobehub.com";
 var HEARTBEAT_INTERVAL = 3e4;
 var INITIAL_RECONNECT_DELAY = 1e3;
@@ -93,7 +93,7 @@ var GatewayClient = class extends EventEmitter {
     try {
       const wsUrl = this.buildWsUrl();
       this.logger.debug(`Connecting to: ${wsUrl}`);
-      const ws = new WebSocket(wsUrl);
+      const ws = new WebSocket2(wsUrl);
       ws.on("open", this.handleOpen);
       ws.on("message", this.handleMessage);
       ws.on("close", this.handleClose);
@@ -229,14 +229,14 @@ var GatewayClient = class extends EventEmitter {
   }
   // ─── Helpers ───
   sendMessage(data) {
-    if (this.ws?.readyState === WebSocket.OPEN) {
+    if (this.ws?.readyState === WebSocket2.OPEN) {
       this.ws.send(JSON.stringify(data));
     }
   }
   closeWebSocket() {
     if (this.ws) {
       this.ws.removeAllListeners();
-      if (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) {
+      if (this.ws.readyState === WebSocket2.OPEN || this.ws.readyState === WebSocket2.CONNECTING) {
         this.ws.close(1e3, "Client disconnect");
       }
       this.ws = null;
@@ -1249,6 +1249,2208 @@ function collectSystemInfo() {
   };
 }
 
+// src/commands/doc.ts
+import fs4 from "fs";
+import readline from "readline";
+import pc2 from "picocolors";
+
+// node_modules/.pnpm/@trpc+client@11.12.0_@trpc+server@11.12.0_typescript@5.9.3__typescript@5.9.3/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 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+      return typeof o$1;
+    } : function(o$1) {
+      return o$1 && "function" == typeof Symbol && 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 ("object" != _typeof$1(t) || !t) return t;
+    var e = t[Symbol.toPrimitive];
+    if (void 0 !== e) {
+      var i = e.call(t, r || "default");
+      if ("object" != _typeof$1(i)) return i;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return ("string" === r ? 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 "symbol" == _typeof(i) ? 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 = null != arguments[r] ? 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/.pnpm/@trpc+server@11.12.0_typescript@5.9.3/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 === void 0 || _observer$next.call(observer, value);
+        },
+        error(err) {
+          var _observer$error;
+          if (isDone) return;
+          isDone = true;
+          (_observer$error = observer.error) === null || _observer$error === void 0 || _observer$error.call(observer, err);
+          unsubscribe();
+        },
+        complete() {
+          var _observer$complete;
+          if (isDone) return;
+          isDone = true;
+          (_observer$complete = observer.complete) === null || _observer$complete === void 0 || _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/.pnpm/@trpc+server@11.12.0_typescript@5.9.3/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 === void 0 || _observer$next.call(observer, value);
+          }
+        },
+        error(error) {
+          for (const observer of observers) {
+            var _observer$error;
+            (_observer$error = observer.error) === null || _observer$error === void 0 || _observer$error.call(observer, error);
+          }
+        },
+        complete() {
+          for (const observer of observers) {
+            var _observer$complete;
+            (_observer$complete = observer.complete) === null || _observer$complete === void 0 || _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);
+      } };
+    });
+  };
+}
+function behaviorSubject(initialValue) {
+  let value = initialValue;
+  const observerList = [];
+  const addObserver = (observer) => {
+    if (value !== void 0) 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/.pnpm/@trpc+client@11.12.0_@trpc+server@11.12.0_typescript@5.9.3__typescript@5.9.3/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);
+  });
+}
+
+// node_modules/.pnpm/@trpc+server@11.12.0_typescript@5.9.3/node_modules/@trpc/server/dist/codes-DagpWZLc.mjs
+function isObject(value) {
+  return !!value && !Array.isArray(value) && typeof value === "object";
+}
+function emptyObject() {
+  return /* @__PURE__ */ Object.create(null);
+}
+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/.pnpm/@trpc+server@11.12.0_typescript@5.9.3/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, path5, memo) {
+  var _memo$cacheKey;
+  const cacheKey = path5.join(".");
+  (_memo$cacheKey = memo[cacheKey]) !== null && _memo$cacheKey !== void 0 || (memo[cacheKey] = new Proxy(noop, {
+    get(_obj, key) {
+      if (typeof key !== "string" || key === "then") return void 0;
+      return createInnerProxy(callback, [...path5, key], memo);
+    },
+    apply(_1, _2, args) {
+      const lastOfPath = path5[path5.length - 1];
+      let opts = {
+        args,
+        path: path5
+      };
+      if (lastOfPath === "call") opts = {
+        args: args.length >= 2 ? [args[1]] : [],
+        path: path5.slice(0, -1)
+      };
+      else if (lastOfPath === "apply") opts = {
+        args: args.length >= 2 ? args[1] : [],
+        path: path5.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 void 0;
+    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 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+      return typeof o$1;
+    } : function(o$1) {
+      return o$1 && "function" == typeof Symbol && 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 ("object" != _typeof$1(t) || !t) return t;
+    var e = t[Symbol.toPrimitive];
+    if (void 0 !== e) {
+      var i = e.call(t, r || "default");
+      if ("object" != _typeof$1(i)) return i;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return ("string" === r ? 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 "symbol" == _typeof(i) ? 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 = null != arguments[r] ? 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/.pnpm/@trpc+server@11.12.0_typescript@5.9.3/node_modules/@trpc/server/dist/tracked-Bjtgv3wJ.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);
+
+// node_modules/.pnpm/@trpc+client@11.12.0_@trpc+server@11.12.0_typescript@5.9.3__typescript@5.9.3/node_modules/@trpc/client/dist/TRPCClientError-apv8gw59.mjs
+var import_defineProperty2 = __toESM(require_defineProperty(), 1);
+var import_objectSpread23 = __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 TRPCClientError2 extends Error {
+  constructor(message, opts) {
+    var _opts$result, _opts$result2;
+    const cause = opts === null || opts === void 0 ? void 0 : opts.cause;
+    super(message, { cause });
+    (0, import_defineProperty2.default)(this, "cause", void 0);
+    (0, import_defineProperty2.default)(this, "shape", void 0);
+    (0, import_defineProperty2.default)(this, "data", void 0);
+    (0, import_defineProperty2.default)(this, "meta", void 0);
+    this.meta = opts === null || opts === void 0 ? void 0 : opts.meta;
+    this.cause = cause;
+    this.shape = opts === null || opts === void 0 || (_opts$result = opts.result) === null || _opts$result === void 0 ? void 0 : _opts$result.error;
+    this.data = opts === null || opts === void 0 || (_opts$result2 = opts.result) === null || _opts$result2 === void 0 ? void 0 : _opts$result2.error.data;
+    this.name = "TRPCClientError";
+    Object.setPrototypeOf(this, TRPCClientError2.prototype);
+  }
+  static from(_cause, opts = {}) {
+    const cause = _cause;
+    if (isTRPCClientError(cause)) {
+      if (opts.meta) cause.meta = (0, import_objectSpread23.default)((0, import_objectSpread23.default)({}, cause.meta), opts.meta);
+      return cause;
+    }
+    if (isTRPCErrorResponse(cause)) return new TRPCClientError2(cause.error.message, (0, import_objectSpread23.default)((0, import_objectSpread23.default)({}, opts), {}, {
+      result: cause,
+      cause: opts.cause
+    }));
+    return new TRPCClientError2(getMessageFromUnknownError(cause, "Unknown error"), (0, import_objectSpread23.default)((0, import_objectSpread23.default)({}, opts), {}, { cause }));
+  }
+};
+
+// node_modules/.pnpm/@trpc+client@11.12.0_@trpc+server@11.12.0_typescript@5.9.3__typescript@5.9.3/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/.pnpm/@trpc+client@11.12.0_@trpc+server@11.12.0_typescript@5.9.3__typescript@5.9.3/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_objectSpread24 = __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 !== void 0 && 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 void 0;
+  const input = getInput(opts);
+  return input !== void 0 ? JSON.stringify(input) : void 0;
+};
+var jsonHttpRequester = (opts) => {
+  return httpRequest((0, import_objectSpread24.default)((0, import_objectSpread24.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 === void 0 ? void 0 : signal.aborted)) return;
+  (_signal$throwIfAborte = signal.throwIfAborted) === null || _signal$throwIfAborte === void 0 || _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 !== void 0 ? _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_objectSpread24.default)((0, import_objectSpread24.default)((0, import_objectSpread24.default)({}, opts.contentTypeHeader && method !== "GET" ? { "content-type": opts.contentTypeHeader } : {}), opts.trpcAcceptHeader ? { "trpc-accept": opts.trpcAcceptHeader } : void 0), 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/.pnpm/@trpc+client@11.12.0_@trpc+server@11.12.0_typescript@5.9.3__typescript@5.9.3/node_modules/@trpc/client/dist/httpLink-Cz9h1Qgh.mjs
+function isOctetType(input) {
+  return input instanceof Uint8Array || input instanceof Blob;
+}
+function isFormData(input) {
+  return input instanceof FormData;
+}
+var import_objectSpread25 = __toESM(require_objectSpread2(), 1);
+var universalRequester = (opts) => {
+  if ("input" in opts) {
+    const { input } = opts;
+    if (isFormData(input)) {
+      if (opts.type !== "mutation" && opts.methodOverride !== "POST") throw new Error("FormData is only supported for mutations");
+      return httpRequest((0, import_objectSpread25.default)((0, import_objectSpread25.default)({}, opts), {}, {
+        contentTypeHeader: void 0,
+        getUrl,
+        getBody: () => input
+      }));
+    }
+    if (isOctetType(input)) {
+      if (opts.type !== "mutation" && opts.methodOverride !== "POST") throw new Error("Octet type input is only supported for mutations");
+      return httpRequest((0, import_objectSpread25.default)((0, import_objectSpread25.default)({}, opts), {}, {
+        contentTypeHeader: "application/octet-stream",
+        getUrl,
+        getBody: () => input
+      }));
+    }
+  }
+  return jsonHttpRequester(opts);
+};
+function httpLink(opts) {
+  const resolvedOpts = resolveHTTPLinkOptions(opts);
+  return () => {
+    return (operationOpts) => {
+      const { op } = operationOpts;
+      return observable((observer) => {
+        const { path: path5, input, type } = op;
+        if (type === "subscription") throw new Error("Subscriptions are unsupported by `httpLink` - use `httpSubscriptionLink` or `wsLink`");
+        const request = universalRequester((0, import_objectSpread25.default)((0, import_objectSpread25.default)({}, resolvedOpts), {}, {
+          type,
+          path: path5,
+          input,
+          signal: op.signal,
+          headers() {
+            if (!opts.headers) return {};
+            if (typeof opts.headers === "function") return opts.headers({ op });
+            return opts.headers;
+          }
+        }));
+        let meta = void 0;
+        request.then((res) => {
+          meta = res.meta;
+          const transformed = transformResult(res.json, resolvedOpts.transformer.output);
+          if (!transformed.ok) {
+            observer.error(TRPCClientError.from(transformed.error, { meta }));
+            return;
+          }
+          observer.next({
+            context: res.meta,
+            result: transformed.result
+          });
+          observer.complete();
+        }).catch((cause) => {
+          observer.error(TRPCClientError.from(cause, { meta }));
+        });
+        return () => {
+        };
+      });
+    };
+  };
+}
+
+// node_modules/.pnpm/@trpc+client@11.12.0_@trpc+server@11.12.0_typescript@5.9.3__typescript@5.9.3/node_modules/@trpc/client/dist/httpBatchLink-fQ1NAi-e.mjs
+var import_objectSpread26 = __toESM(require_objectSpread2(), 1);
+
+// node_modules/.pnpm/@trpc+client@11.12.0_@trpc+server@11.12.0_typescript@5.9.3__typescript@5.9.3/node_modules/@trpc/client/dist/loggerLink-ineCN1PO.mjs
+var import_objectSpread27 = __toESM(require_objectSpread2(), 1);
+
+// node_modules/.pnpm/@trpc+client@11.12.0_@trpc+server@11.12.0_typescript@5.9.3__typescript@5.9.3/node_modules/@trpc/client/dist/wsLink-DSf4KOdW.mjs
+var resultOf = (value, ...args) => {
+  return typeof value === "function" ? value(...args) : value;
+};
+var import_defineProperty$3 = __toESM(require_defineProperty(), 1);
+function withResolvers() {
+  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, encoder) {
+  const message = {
+    method: "connectionParams",
+    data: await resultOf(connectionParams)
+  };
+  return encoder.encode(message);
+}
+var import_defineProperty$2 = __toESM(require_defineProperty(), 1);
+var import_defineProperty$1 = __toESM(require_defineProperty(), 1);
+function asyncWsOpen(ws) {
+  const { promise, resolve, reject } = withResolvers();
+  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 WsConnection2 {
+  constructor(opts) {
+    var _opts$WebSocketPonyfi;
+    (0, import_defineProperty$1.default)(this, "id", ++WsConnection2.connectCount);
+    (0, import_defineProperty$1.default)(this, "WebSocketPonyfill", void 0);
+    (0, import_defineProperty$1.default)(this, "urlOptions", void 0);
+    (0, import_defineProperty$1.default)(this, "keepAliveOpts", void 0);
+    (0, import_defineProperty$1.default)(this, "encoder", void 0);
+    (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 !== void 0 ? _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;
+    this.encoder = opts.encoder;
+  }
+  get ws() {
+    return this.wsObservable.get();
+  }
+  set ws(ws) {
+    this.wsObservable.next(ws);
+  }
+  /**
+  * Checks if the WebSocket connection is open and ready to communicate.
+  */
+  isOpen() {
+    return !!this.ws && this.ws.readyState === this.WebSocketPonyfill.OPEN && !this.openPromise;
+  }
+  /**
+  * Checks if the WebSocket connection is closed or in the process of closing.
+  */
+  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 = ++WsConnection2.connectCount;
+    const wsPromise = prepareUrl(_this.urlOptions).then((url) => new _this.WebSocketPonyfill(url));
+    _this.openPromise = wsPromise.then(async (ws) => {
+      _this.ws = ws;
+      ws.binaryType = "arraybuffer";
+      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, _this.encoder));
+    });
+    try {
+      await _this.openPromise;
+    } finally {
+      _this.openPromise = null;
+    }
+  }
+  /**
+  * Closes the WebSocket connection gracefully.
+  * Waits for any ongoing open operation to complete before closing.
+  */
+  async close() {
+    var _this2 = this;
+    try {
+      await _this2.openPromise;
+    } finally {
+      var _this$ws;
+      (_this$ws = _this2.ws) === null || _this$ws === void 0 || _this$ws.close();
+    }
+  }
+};
+(0, import_defineProperty$1.default)(WsConnection, "connectCount", 0);
+var import_defineProperty3 = __toESM(require_defineProperty(), 1);
+var import_objectSpread28 = __toESM(require_objectSpread2(), 1);
+
+// node_modules/.pnpm/@trpc+client@11.12.0_@trpc+server@11.12.0_typescript@5.9.3__typescript@5.9.3/node_modules/@trpc/client/dist/index.mjs
+var import_defineProperty4 = __toESM(require_defineProperty(), 1);
+var import_objectSpread2$4 = __toESM(require_objectSpread2(), 1);
+var TRPCUntypedClient = class {
+  constructor(opts) {
+    (0, import_defineProperty4.default)(this, "links", void 0);
+    (0, import_defineProperty4.default)(this, "runtime", void 0);
+    (0, import_defineProperty4.default)(this, "requestId", void 0);
+    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 !== void 0 ? _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(path5, input, opts) {
+    return this.requestAsPromise({
+      type: "query",
+      path: path5,
+      input,
+      context: opts === null || opts === void 0 ? void 0 : opts.context,
+      signal: opts === null || opts === void 0 ? void 0 : opts.signal
+    });
+  }
+  mutation(path5, input, opts) {
+    return this.requestAsPromise({
+      type: "mutation",
+      path: path5,
+      input,
+      context: opts === null || opts === void 0 ? void 0 : opts.context,
+      signal: opts === null || opts === void 0 ? void 0 : opts.signal
+    });
+  }
+  subscription(path5, input, opts) {
+    const observable$ = this.$request({
+      type: "subscription",
+      path: path5,
+      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 === void 0 || _opts$onConnectionSta.call(opts, envelope.result);
+            break;
+          }
+          case "started": {
+            var _opts$onStarted;
+            (_opts$onStarted = opts.onStarted) === null || _opts$onStarted === void 0 || _opts$onStarted.call(opts, { context: envelope.context });
+            break;
+          }
+          case "stopped": {
+            var _opts$onStopped;
+            (_opts$onStopped = opts.onStopped) === null || _opts$onStopped === void 0 || _opts$onStopped.call(opts);
+            break;
+          }
+          case "data":
+          case void 0: {
+            var _opts$onData;
+            (_opts$onData = opts.onData) === null || _opts$onData === void 0 || _opts$onData.call(opts, envelope.result.data);
+            break;
+          }
+        }
+      },
+      error(err) {
+        var _opts$onError;
+        (_opts$onError = opts.onError) === null || _opts$onError === void 0 || _opts$onError.call(opts, err);
+      },
+      complete() {
+        var _opts$onComplete;
+        (_opts$onComplete = opts.onComplete) === null || _opts$onComplete === void 0 || _opts$onComplete.call(opts);
+      }
+    });
+  }
+};
+var untypedClientSymbol = /* @__PURE__ */ 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: path5, args }) => {
+    const pathCopy = [...path5];
+    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);
+var require_asyncIterator = __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 ("undefined" != typeof Symbol && (t = Symbol.asyncIterator, o = Symbol.iterator); e--; ) {
+      if (t && null != (n = r[t])) return n.call(r);
+      if (o && null != (n = r[o])) 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 void 0 === n ? Promise.resolve({
+          value: r$1,
+          done: true
+        }) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments));
+      },
+      "throw": function _throw(r$1) {
+        var n = this.s["return"];
+        return void 0 === n ? 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_asyncIterator = __toESM(require_asyncIterator(), 1);
+var import_objectSpread2$12 = __toESM(require_objectSpread2(), 1);
+var require_usingCtx = __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 = "function" == typeof SuppressedError ? 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 (null != e$1) {
+        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 (void 0 === o && (o = e$1[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r$1)) var t = o;
+        if ("function" != typeof o) 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 && 1 === s) 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 (1 === s) 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 = __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_awaitAsyncGenerator = __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_OverloadYield();
+  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_wrapAsyncGenerator = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/wrapAsyncGenerator.js"(exports, module) {
+  var OverloadYield = require_OverloadYield();
+  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 = "return" === r$1 ? "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));
+      });
+    }, "function" != typeof e["return"] && (this["return"] = void 0);
+  }
+  AsyncGenerator.prototype["function" == typeof Symbol && 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_usingCtx = __toESM(require_usingCtx(), 1);
+var import_awaitAsyncGenerator = __toESM(require_awaitAsyncGenerator(), 1);
+var import_wrapAsyncGenerator = __toESM(require_wrapAsyncGenerator(), 1);
+var import_objectSpread29 = __toESM(require_objectSpread2(), 1);
+
+// node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/double-indexed-kv.js
+var DoubleIndexedKV = class {
+  constructor() {
+    this.keyToValue = /* @__PURE__ */ new Map();
+    this.valueToKey = /* @__PURE__ */ new Map();
+  }
+  set(key, value) {
+    this.keyToValue.set(key, value);
+    this.valueToKey.set(value, key);
+  }
+  getByKey(key) {
+    return this.keyToValue.get(key);
+  }
+  getByValue(value) {
+    return this.valueToKey.get(value);
+  }
+  clear() {
+    this.keyToValue.clear();
+    this.valueToKey.clear();
+  }
+};
+
+// node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/registry.js
+var Registry = class {
+  constructor(generateIdentifier) {
+    this.generateIdentifier = generateIdentifier;
+    this.kv = new DoubleIndexedKV();
+  }
+  register(value, identifier) {
+    if (this.kv.getByValue(value)) {
+      return;
+    }
+    if (!identifier) {
+      identifier = this.generateIdentifier(value);
+    }
+    this.kv.set(identifier, value);
+  }
+  clear() {
+    this.kv.clear();
+  }
+  getIdentifier(value) {
+    return this.kv.getByValue(value);
+  }
+  getValue(identifier) {
+    return this.kv.getByKey(identifier);
+  }
+};
+
+// node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/class-registry.js
+var ClassRegistry = class extends Registry {
+  constructor() {
+    super((c) => c.name);
+    this.classToAllowedProps = /* @__PURE__ */ new Map();
+  }
+  register(value, options) {
+    if (typeof options === "object") {
+      if (options.allowProps) {
+        this.classToAllowedProps.set(value, options.allowProps);
+      }
+      super.register(value, options.identifier);
+    } else {
+      super.register(value, options);
+    }
+  }
+  getAllowedProps(value) {
+    return this.classToAllowedProps.get(value);
+  }
+};
+
+// node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/util.js
+function valuesOfObj(record) {
+  if ("values" in Object) {
+    return Object.values(record);
+  }
+  const values = [];
+  for (const key in record) {
+    if (record.hasOwnProperty(key)) {
+      values.push(record[key]);
+    }
+  }
+  return values;
+}
+function find(record, predicate) {
+  const values = valuesOfObj(record);
+  if ("find" in values) {
+    return values.find(predicate);
+  }
+  const valuesNotNever = values;
+  for (let i = 0; i < valuesNotNever.length; i++) {
+    const value = valuesNotNever[i];
+    if (predicate(value)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function forEach(record, run2) {
+  Object.entries(record).forEach(([key, value]) => run2(value, key));
+}
+function includes(arr, value) {
+  return arr.indexOf(value) !== -1;
+}
+function findArr(record, predicate) {
+  for (let i = 0; i < record.length; i++) {
+    const value = record[i];
+    if (predicate(value)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+
+// node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/custom-transformer-registry.js
+var CustomTransformerRegistry = class {
+  constructor() {
+    this.transfomers = {};
+  }
+  register(transformer) {
+    this.transfomers[transformer.name] = transformer;
+  }
+  findApplicable(v) {
+    return find(this.transfomers, (transformer) => transformer.isApplicable(v));
+  }
+  findByName(name) {
+    return this.transfomers[name];
+  }
+};
+
+// node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/is.js
+var getType = (payload) => Object.prototype.toString.call(payload).slice(8, -1);
+var isUndefined = (payload) => typeof payload === "undefined";
+var isNull = (payload) => payload === null;
+var isPlainObject = (payload) => {
+  if (typeof payload !== "object" || payload === null)
+    return false;
+  if (payload === Object.prototype)
+    return false;
+  if (Object.getPrototypeOf(payload) === null)
+    return true;
+  return Object.getPrototypeOf(payload) === Object.prototype;
+};
+var isEmptyObject = (payload) => isPlainObject(payload) && Object.keys(payload).length === 0;
+var isArray = (payload) => Array.isArray(payload);
+var isString = (payload) => typeof payload === "string";
+var isNumber = (payload) => typeof payload === "number" && !isNaN(payload);
+var isBoolean = (payload) => typeof payload === "boolean";
+var isRegExp = (payload) => payload instanceof RegExp;
+var isMap = (payload) => payload instanceof Map;
+var isSet = (payload) => payload instanceof Set;
+var isSymbol = (payload) => getType(payload) === "Symbol";
+var isDate = (payload) => payload instanceof Date && !isNaN(payload.valueOf());
+var isError = (payload) => payload instanceof Error;
+var isNaNValue = (payload) => typeof payload === "number" && isNaN(payload);
+var isPrimitive = (payload) => isBoolean(payload) || isNull(payload) || isUndefined(payload) || isNumber(payload) || isString(payload) || isSymbol(payload);
+var isBigint = (payload) => typeof payload === "bigint";
+var isInfinite = (payload) => payload === Infinity || payload === -Infinity;
+var isTypedArray = (payload) => ArrayBuffer.isView(payload) && !(payload instanceof DataView);
+var isURL = (payload) => payload instanceof URL;
+
+// node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/pathstringifier.js
+var escapeKey = (key) => key.replace(/\\/g, "\\\\").replace(/\./g, "\\.");
+var stringifyPath = (path5) => path5.map(String).map(escapeKey).join(".");
+var parsePath = (string, legacyPaths) => {
+  const result = [];
+  let segment = "";
+  for (let i = 0; i < string.length; i++) {
+    let char = string.charAt(i);
+    if (!legacyPaths && char === "\\") {
+      const escaped = string.charAt(i + 1);
+      if (escaped === "\\") {
+        segment += "\\";
+        i++;
+        continue;
+      } else if (escaped !== ".") {
+        throw Error("invalid path");
+      }
+    }
+    const isEscapedDot = char === "\\" && string.charAt(i + 1) === ".";
+    if (isEscapedDot) {
+      segment += ".";
+      i++;
+      continue;
+    }
+    const isEndOfSegment = char === ".";
+    if (isEndOfSegment) {
+      result.push(segment);
+      segment = "";
+      continue;
+    }
+    segment += char;
+  }
+  const lastSegment = segment;
+  result.push(lastSegment);
+  return result;
+};
+
+// node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/transformer.js
+function simpleTransformation(isApplicable, annotation, transform, untransform) {
+  return {
+    isApplicable,
+    annotation,
+    transform,
+    untransform
+  };
+}
+var simpleRules = [
+  simpleTransformation(isUndefined, "undefined", () => null, () => void 0),
+  simpleTransformation(isBigint, "bigint", (v) => v.toString(), (v) => {
+    if (typeof BigInt !== "undefined") {
+      return BigInt(v);
+    }
+    console.error("Please add a BigInt polyfill.");
+    return v;
+  }),
+  simpleTransformation(isDate, "Date", (v) => v.toISOString(), (v) => new Date(v)),
+  simpleTransformation(isError, "Error", (v, superJson) => {
+    const baseError = {
+      name: v.name,
+      message: v.message
+    };
+    if ("cause" in v) {
+      baseError.cause = v.cause;
+    }
+    superJson.allowedErrorProps.forEach((prop) => {
+      baseError[prop] = v[prop];
+    });
+    return baseError;
+  }, (v, superJson) => {
+    const e = new Error(v.message, { cause: v.cause });
+    e.name = v.name;
+    e.stack = v.stack;
+    superJson.allowedErrorProps.forEach((prop) => {
+      e[prop] = v[prop];
+    });
+    return e;
+  }),
+  simpleTransformation(isRegExp, "regexp", (v) => "" + v, (regex) => {
+    const body = regex.slice(1, regex.lastIndexOf("/"));
+    const flags = regex.slice(regex.lastIndexOf("/") + 1);
+    return new RegExp(body, flags);
+  }),
+  simpleTransformation(
+    isSet,
+    "set",
+    // (sets only exist in es6+)
+    // eslint-disable-next-line es5/no-es6-methods
+    (v) => [...v.values()],
+    (v) => new Set(v)
+  ),
+  simpleTransformation(isMap, "map", (v) => [...v.entries()], (v) => new Map(v)),
+  simpleTransformation((v) => isNaNValue(v) || isInfinite(v), "number", (v) => {
+    if (isNaNValue(v)) {
+      return "NaN";
+    }
+    if (v > 0) {
+      return "Infinity";
+    } else {
+      return "-Infinity";
+    }
+  }, Number),
+  simpleTransformation((v) => v === 0 && 1 / v === -Infinity, "number", () => {
+    return "-0";
+  }, Number),
+  simpleTransformation(isURL, "URL", (v) => v.toString(), (v) => new URL(v))
+];
+function compositeTransformation(isApplicable, annotation, transform, untransform) {
+  return {
+    isApplicable,
+    annotation,
+    transform,
+    untransform
+  };
+}
+var symbolRule = compositeTransformation((s, superJson) => {
+  if (isSymbol(s)) {
+    const isRegistered = !!superJson.symbolRegistry.getIdentifier(s);
+    return isRegistered;
+  }
+  return false;
+}, (s, superJson) => {
+  const identifier = superJson.symbolRegistry.getIdentifier(s);
+  return ["symbol", identifier];
+}, (v) => v.description, (_, a, superJson) => {
+  const value = superJson.symbolRegistry.getValue(a[1]);
+  if (!value) {
+    throw new Error("Trying to deserialize unknown symbol");
+  }
+  return value;
+});
+var constructorToName = [
+  Int8Array,
+  Uint8Array,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array,
+  Uint8ClampedArray
+].reduce((obj, ctor) => {
+  obj[ctor.name] = ctor;
+  return obj;
+}, {});
+var typedArrayRule = compositeTransformation(isTypedArray, (v) => ["typed-array", v.constructor.name], (v) => [...v], (v, a) => {
+  const ctor = constructorToName[a[1]];
+  if (!ctor) {
+    throw new Error("Trying to deserialize unknown typed array");
+  }
+  return new ctor(v);
+});
+function isInstanceOfRegisteredClass(potentialClass, superJson) {
+  if (potentialClass?.constructor) {
+    const isRegistered = !!superJson.classRegistry.getIdentifier(potentialClass.constructor);
+    return isRegistered;
+  }
+  return false;
+}
+var classRule = compositeTransformation(isInstanceOfRegisteredClass, (clazz, superJson) => {
+  const identifier = superJson.classRegistry.getIdentifier(clazz.constructor);
+  return ["class", identifier];
+}, (clazz, superJson) => {
+  const allowedProps = superJson.classRegistry.getAllowedProps(clazz.constructor);
+  if (!allowedProps) {
+    return { ...clazz };
+  }
+  const result = {};
+  allowedProps.forEach((prop) => {
+    result[prop] = clazz[prop];
+  });
+  return result;
+}, (v, a, superJson) => {
+  const clazz = superJson.classRegistry.getValue(a[1]);
+  if (!clazz) {
+    throw new Error(`Trying to deserialize unknown class '${a[1]}' - check https://github.com/blitz-js/superjson/issues/116#issuecomment-773996564`);
+  }
+  return Object.assign(Object.create(clazz.prototype), v);
+});
+var customRule = compositeTransformation((value, superJson) => {
+  return !!superJson.customTransformerRegistry.findApplicable(value);
+}, (value, superJson) => {
+  const transformer = superJson.customTransformerRegistry.findApplicable(value);
+  return ["custom", transformer.name];
+}, (value, superJson) => {
+  const transformer = superJson.customTransformerRegistry.findApplicable(value);
+  return transformer.serialize(value);
+}, (v, a, superJson) => {
+  const transformer = superJson.customTransformerRegistry.findByName(a[1]);
+  if (!transformer) {
+    throw new Error("Trying to deserialize unknown custom value");
+  }
+  return transformer.deserialize(v);
+});
+var compositeRules = [classRule, symbolRule, customRule, typedArrayRule];
+var transformValue = (value, superJson) => {
+  const applicableCompositeRule = findArr(compositeRules, (rule) => rule.isApplicable(value, superJson));
+  if (applicableCompositeRule) {
+    return {
+      value: applicableCompositeRule.transform(value, superJson),
+      type: applicableCompositeRule.annotation(value, superJson)
+    };
+  }
+  const applicableSimpleRule = findArr(simpleRules, (rule) => rule.isApplicable(value, superJson));
+  if (applicableSimpleRule) {
+    return {
+      value: applicableSimpleRule.transform(value, superJson),
+      type: applicableSimpleRule.annotation
+    };
+  }
+  return void 0;
+};
+var simpleRulesByAnnotation = {};
+simpleRules.forEach((rule) => {
+  simpleRulesByAnnotation[rule.annotation] = rule;
+});
+var untransformValue = (json, type, superJson) => {
+  if (isArray(type)) {
+    switch (type[0]) {
+      case "symbol":
+        return symbolRule.untransform(json, type, superJson);
+      case "class":
+        return classRule.untransform(json, type, superJson);
+      case "custom":
+        return customRule.untransform(json, type, superJson);
+      case "typed-array":
+        return typedArrayRule.untransform(json, type, superJson);
+      default:
+        throw new Error("Unknown transformation: " + type);
+    }
+  } else {
+    const transformation = simpleRulesByAnnotation[type];
+    if (!transformation) {
+      throw new Error("Unknown transformation: " + type);
+    }
+    return transformation.untransform(json, superJson);
+  }
+};
+
+// node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/accessDeep.js
+var getNthKey = (value, n) => {
+  if (n > value.size)
+    throw new Error("index out of bounds");
+  const keys = value.keys();
+  while (n > 0) {
+    keys.next();
+    n--;
+  }
+  return keys.next().value;
+};
+function validatePath(path5) {
+  if (includes(path5, "__proto__")) {
+    throw new Error("__proto__ is not allowed as a property");
+  }
+  if (includes(path5, "prototype")) {
+    throw new Error("prototype is not allowed as a property");
+  }
+  if (includes(path5, "constructor")) {
+    throw new Error("constructor is not allowed as a property");
+  }
+}
+var getDeep = (object, path5) => {
+  validatePath(path5);
+  for (let i = 0; i < path5.length; i++) {
+    const key = path5[i];
+    if (isSet(object)) {
+      object = getNthKey(object, +key);
+    } else if (isMap(object)) {
+      const row = +key;
+      const type = +path5[++i] === 0 ? "key" : "value";
+      const keyOfRow = getNthKey(object, row);
+      switch (type) {
+        case "key":
+          object = keyOfRow;
+          break;
+        case "value":
+          object = object.get(keyOfRow);
+          break;
+      }
+    } else {
+      object = object[key];
+    }
+  }
+  return object;
+};
+var setDeep = (object, path5, mapper) => {
+  validatePath(path5);
+  if (path5.length === 0) {
+    return mapper(object);
+  }
+  let parent = object;
+  for (let i = 0; i < path5.length - 1; i++) {
+    const key = path5[i];
+    if (isArray(parent)) {
+      const index = +key;
+      parent = parent[index];
+    } else if (isPlainObject(parent)) {
+      parent = parent[key];
+    } else if (isSet(parent)) {
+      const row = +key;
+      parent = getNthKey(parent, row);
+    } else if (isMap(parent)) {
+      const isEnd = i === path5.length - 2;
+      if (isEnd) {
+        break;
+      }
+      const row = +key;
+      const type = +path5[++i] === 0 ? "key" : "value";
+      const keyOfRow = getNthKey(parent, row);
+      switch (type) {
+        case "key":
+          parent = keyOfRow;
+          break;
+        case "value":
+          parent = parent.get(keyOfRow);
+          break;
+      }
+    }
+  }
+  const lastKey = path5[path5.length - 1];
+  if (isArray(parent)) {
+    parent[+lastKey] = mapper(parent[+lastKey]);
+  } else if (isPlainObject(parent)) {
+    parent[lastKey] = mapper(parent[lastKey]);
+  }
+  if (isSet(parent)) {
+    const oldValue = getNthKey(parent, +lastKey);
+    const newValue = mapper(oldValue);
+    if (oldValue !== newValue) {
+      parent.delete(oldValue);
+      parent.add(newValue);
+    }
+  }
+  if (isMap(parent)) {
+    const row = +path5[path5.length - 2];
+    const keyToRow = getNthKey(parent, row);
+    const type = +lastKey === 0 ? "key" : "value";
+    switch (type) {
+      case "key": {
+        const newKey = mapper(keyToRow);
+        parent.set(newKey, parent.get(keyToRow));
+        if (newKey !== keyToRow) {
+          parent.delete(keyToRow);
+        }
+        break;
+      }
+      case "value": {
+        parent.set(keyToRow, mapper(parent.get(keyToRow)));
+        break;
+      }
+    }
+  }
+  return object;
+};
+
+// node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/plainer.js
+var enableLegacyPaths = (version) => version < 1;
+function traverse(tree, walker2, version, origin = []) {
+  if (!tree) {
+    return;
+  }
+  const legacyPaths = enableLegacyPaths(version);
+  if (!isArray(tree)) {
+    forEach(tree, (subtree, key) => traverse(subtree, walker2, version, [
+      ...origin,
+      ...parsePath(key, legacyPaths)
+    ]));
+    return;
+  }
+  const [nodeValue, children] = tree;
+  if (children) {
+    forEach(children, (child, key) => {
+      traverse(child, walker2, version, [
+        ...origin,
+        ...parsePath(key, legacyPaths)
+      ]);
+    });
+  }
+  walker2(nodeValue, origin);
+}
+function applyValueAnnotations(plain, annotations, version, superJson) {
+  traverse(annotations, (type, path5) => {
+    plain = setDeep(plain, path5, (v) => untransformValue(v, type, superJson));
+  }, version);
+  return plain;
+}
+function applyReferentialEqualityAnnotations(plain, annotations, version) {
+  const legacyPaths = enableLegacyPaths(version);
+  function apply(identicalPaths, path5) {
+    const object = getDeep(plain, parsePath(path5, legacyPaths));
+    identicalPaths.map((path6) => parsePath(path6, legacyPaths)).forEach((identicalObjectPath) => {
+      plain = setDeep(plain, identicalObjectPath, () => object);
+    });
+  }
+  if (isArray(annotations)) {
+    const [root, other] = annotations;
+    root.forEach((identicalPath) => {
+      plain = setDeep(plain, parsePath(identicalPath, legacyPaths), () => plain);
+    });
+    if (other) {
+      forEach(other, apply);
+    }
+  } else {
+    forEach(annotations, apply);
+  }
+  return plain;
+}
+var isDeep = (object, superJson) => isPlainObject(object) || isArray(object) || isMap(object) || isSet(object) || isError(object) || isInstanceOfRegisteredClass(object, superJson);
+function addIdentity(object, path5, identities) {
+  const existingSet = identities.get(object);
+  if (existingSet) {
+    existingSet.push(path5);
+  } else {
+    identities.set(object, [path5]);
+  }
+}
+function generateReferentialEqualityAnnotations(identitites, dedupe) {
+  const result = {};
+  let rootEqualityPaths = void 0;
+  identitites.forEach((paths) => {
+    if (paths.length <= 1) {
+      return;
+    }
+    if (!dedupe) {
+      paths = paths.map((path5) => path5.map(String)).sort((a, b) => a.length - b.length);
+    }
+    const [representativePath, ...identicalPaths] = paths;
+    if (representativePath.length === 0) {
+      rootEqualityPaths = identicalPaths.map(stringifyPath);
+    } else {
+      result[stringifyPath(representativePath)] = identicalPaths.map(stringifyPath);
+    }
+  });
+  if (rootEqualityPaths) {
+    if (isEmptyObject(result)) {
+      return [rootEqualityPaths];
+    } else {
+      return [rootEqualityPaths, result];
+    }
+  } else {
+    return isEmptyObject(result) ? void 0 : result;
+  }
+}
+var walker = (object, identities, superJson, dedupe, path5 = [], objectsInThisPath = [], seenObjects = /* @__PURE__ */ new Map()) => {
+  const primitive = isPrimitive(object);
+  if (!primitive) {
+    addIdentity(object, path5, identities);
+    const seen = seenObjects.get(object);
+    if (seen) {
+      return dedupe ? {
+        transformedValue: null
+      } : seen;
+    }
+  }
+  if (!isDeep(object, superJson)) {
+    const transformed2 = transformValue(object, superJson);
+    const result2 = transformed2 ? {
+      transformedValue: transformed2.value,
+      annotations: [transformed2.type]
+    } : {
+      transformedValue: object
+    };
+    if (!primitive) {
+      seenObjects.set(object, result2);
+    }
+    return result2;
+  }
+  if (includes(objectsInThisPath, object)) {
+    return {
+      transformedValue: null
+    };
+  }
+  const transformationResult = transformValue(object, superJson);
+  const transformed = transformationResult?.value ?? object;
+  const transformedValue = isArray(transformed) ? [] : {};
+  const innerAnnotations = {};
+  forEach(transformed, (value, index) => {
+    if (index === "__proto__" || index === "constructor" || index === "prototype") {
+      throw new Error(`Detected property ${index}. This is a prototype pollution risk, please remove it from your object.`);
+    }
+    const recursiveResult = walker(value, identities, superJson, dedupe, [...path5, index], [...objectsInThisPath, object], seenObjects);
+    transformedValue[index] = recursiveResult.transformedValue;
+    if (isArray(recursiveResult.annotations)) {
+      innerAnnotations[escapeKey(index)] = recursiveResult.annotations;
+    } else if (isPlainObject(recursiveResult.annotations)) {
+      forEach(recursiveResult.annotations, (tree, key) => {
+        innerAnnotations[escapeKey(index) + "." + key] = tree;
+      });
+    }
+  });
+  const result = isEmptyObject(innerAnnotations) ? {
+    transformedValue,
+    annotations: !!transformationResult ? [transformationResult.type] : void 0
+  } : {
+    transformedValue,
+    annotations: !!transformationResult ? [transformationResult.type, innerAnnotations] : innerAnnotations
+  };
+  if (!primitive) {
+    seenObjects.set(object, result);
+  }
+  return result;
+};
+
+// node_modules/.pnpm/is-what@5.5.0/node_modules/is-what/dist/getType.js
+function getType2(payload) {
+  return Object.prototype.toString.call(payload).slice(8, -1);
+}
+
+// node_modules/.pnpm/is-what@5.5.0/node_modules/is-what/dist/isArray.js
+function isArray2(payload) {
+  return getType2(payload) === "Array";
+}
+
+// node_modules/.pnpm/is-what@5.5.0/node_modules/is-what/dist/isPlainObject.js
+function isPlainObject2(payload) {
+  if (getType2(payload) !== "Object")
+    return false;
+  const prototype = Object.getPrototypeOf(payload);
+  return !!prototype && prototype.constructor === Object && prototype === Object.prototype;
+}
+
+// node_modules/.pnpm/copy-anything@4.0.5/node_modules/copy-anything/dist/index.js
+function assignProp(carry, key, newVal, originalObject, includeNonenumerable) {
+  const propType = {}.propertyIsEnumerable.call(originalObject, key) ? "enumerable" : "nonenumerable";
+  if (propType === "enumerable")
+    carry[key] = newVal;
+  if (includeNonenumerable && propType === "nonenumerable") {
+    Object.defineProperty(carry, key, {
+      value: newVal,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    });
+  }
+}
+function copy(target, options = {}) {
+  if (isArray2(target)) {
+    return target.map((item) => copy(item, options));
+  }
+  if (!isPlainObject2(target)) {
+    return target;
+  }
+  const props = Object.getOwnPropertyNames(target);
+  const symbols = Object.getOwnPropertySymbols(target);
+  return [...props, ...symbols].reduce((carry, key) => {
+    if (key === "__proto__")
+      return carry;
+    if (isArray2(options.props) && !options.props.includes(key)) {
+      return carry;
+    }
+    const val = target[key];
+    const newVal = copy(val, options);
+    assignProp(carry, key, newVal, target, options.nonenumerable);
+    return carry;
+  }, {});
+}
+
+// node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/index.js
+var SuperJSON = class {
+  /**
+   * @param dedupeReferentialEqualities  If true, SuperJSON will make sure only one instance of referentially equal objects are serialized and the rest are replaced with `null`.
+   */
+  constructor({ dedupe = false } = {}) {
+    this.classRegistry = new ClassRegistry();
+    this.symbolRegistry = new Registry((s) => s.description ?? "");
+    this.customTransformerRegistry = new CustomTransformerRegistry();
+    this.allowedErrorProps = [];
+    this.dedupe = dedupe;
+  }
+  serialize(object) {
+    const identities = /* @__PURE__ */ new Map();
+    const output = walker(object, identities, this, this.dedupe);
+    const res = {
+      json: output.transformedValue
+    };
+    if (output.annotations) {
+      res.meta = {
+        ...res.meta,
+        values: output.annotations
+      };
+    }
+    const equalityAnnotations = generateReferentialEqualityAnnotations(identities, this.dedupe);
+    if (equalityAnnotations) {
+      res.meta = {
+        ...res.meta,
+        referentialEqualities: equalityAnnotations
+      };
+    }
+    if (res.meta)
+      res.meta.v = 1;
+    return res;
+  }
+  deserialize(payload, options) {
+    const { json, meta } = payload;
+    let result = options?.inPlace ? json : copy(json);
+    if (meta?.values) {
+      result = applyValueAnnotations(result, meta.values, meta.v ?? 0, this);
+    }
+    if (meta?.referentialEqualities) {
+      result = applyReferentialEqualityAnnotations(result, meta.referentialEqualities, meta.v ?? 0);
+    }
+    return result;
+  }
+  stringify(object) {
+    return JSON.stringify(this.serialize(object));
+  }
+  parse(string) {
+    return this.deserialize(JSON.parse(string), { inPlace: true });
+  }
+  registerClass(v, options) {
+    this.classRegistry.register(v, options);
+  }
+  registerSymbol(v, identifier) {
+    this.symbolRegistry.register(v, identifier);
+  }
+  registerCustom(transformer, name) {
+    this.customTransformerRegistry.register({
+      name,
+      ...transformer
+    });
+  }
+  allowErrorProps(...props) {
+    this.allowedErrorProps.push(...props);
+  }
+};
+SuperJSON.defaultInstance = new SuperJSON();
+SuperJSON.serialize = SuperJSON.defaultInstance.serialize.bind(SuperJSON.defaultInstance);
+SuperJSON.deserialize = SuperJSON.defaultInstance.deserialize.bind(SuperJSON.defaultInstance);
+SuperJSON.stringify = SuperJSON.defaultInstance.stringify.bind(SuperJSON.defaultInstance);
+SuperJSON.parse = SuperJSON.defaultInstance.parse.bind(SuperJSON.defaultInstance);
+SuperJSON.registerClass = SuperJSON.defaultInstance.registerClass.bind(SuperJSON.defaultInstance);
+SuperJSON.registerSymbol = SuperJSON.defaultInstance.registerSymbol.bind(SuperJSON.defaultInstance);
+SuperJSON.registerCustom = SuperJSON.defaultInstance.registerCustom.bind(SuperJSON.defaultInstance);
+SuperJSON.allowErrorProps = SuperJSON.defaultInstance.allowErrorProps.bind(SuperJSON.defaultInstance);
+var dist_default = SuperJSON;
+var serialize = SuperJSON.serialize;
+var deserialize = SuperJSON.deserialize;
+var stringify = SuperJSON.stringify;
+var parse = SuperJSON.parse;
+var registerClass = SuperJSON.registerClass;
+var registerCustom = SuperJSON.registerCustom;
+var registerSymbol = SuperJSON.registerSymbol;
+var allowErrorProps = SuperJSON.allowErrorProps;
+
+// src/api/client.ts
+var _client;
+async function getTrpcClient() {
+  if (_client) return _client;
+  const result = await getValidToken();
+  if (!result) {
+    log.error("No authentication found. Run 'lh login' first.");
+    process.exit(1);
+  }
+  const { serverUrl, accessToken } = result.credentials;
+  _client = createTRPCClient({
+    links: [
+      httpLink({
+        headers: {
+          "Oidc-Auth": accessToken
+        },
+        transformer: dist_default,
+        url: `${serverUrl.replace(/\/$/, "")}/trpc/lambda`
+      })
+    ]
+  });
+  return _client;
+}
+
+// src/commands/doc.ts
+function timeAgo(date) {
+  const diff = Date.now() - new Date(date).getTime();
+  const seconds = Math.floor(diff / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (days > 0) return `${days}d ago`;
+  if (hours > 0) return `${hours}h ago`;
+  if (minutes > 0) return `${minutes}m ago`;
+  return `${seconds}s ago`;
+}
+function truncate(str, len) {
+  if (str.length <= len) return str;
+  return str.slice(0, len - 1) + "\u2026";
+}
+function printTable(rows, header) {
+  const allRows = [header, ...rows];
+  const colWidths = header.map((_, i) => Math.max(...allRows.map((r) => (r[i] || "").length)));
+  const headerLine = header.map((h, i) => h.padEnd(colWidths[i])).join("  ");
+  console.log(pc2.bold(headerLine));
+  for (const row of rows) {
+    const line = row.map((cell, i) => (cell || "").padEnd(colWidths[i])).join("  ");
+    console.log(line);
+  }
+}
+function pickFields(obj, fields) {
+  const result = {};
+  for (const f of fields) {
+    if (f in obj) result[f] = obj[f];
+  }
+  return result;
+}
+function outputJson(data, fields) {
+  if (fields) {
+    const fieldList = fields.split(",").map((f) => f.trim());
+    if (Array.isArray(data)) {
+      console.log(
+        JSON.stringify(
+          data.map((item) => pickFields(item, fieldList)),
+          null,
+          2
+        )
+      );
+    } else if (data && typeof data === "object") {
+      console.log(JSON.stringify(pickFields(data, fieldList), null, 2));
+    }
+  } else {
+    console.log(JSON.stringify(data, null, 2));
+  }
+}
+function readBodyContent(options) {
+  if (options.bodyFile) {
+    if (!fs4.existsSync(options.bodyFile)) {
+      log.error(`File not found: ${options.bodyFile}`);
+      process.exit(1);
+    }
+    return fs4.readFileSync(options.bodyFile, "utf8");
+  }
+  return options.body;
+}
+async function confirm(message) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => {
+    rl.question(`${message} (y/N) `, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y");
+    });
+  });
+}
+function registerDocCommand(program2) {
+  const doc = program2.command("doc").description("Manage documents");
+  doc.command("list").description("List documents").option("-L, --limit <n>", "Maximum number of items to fetch", "30").option("--file-type <type>", "Filter by file type").option("--json [fields]", "Output JSON, optionally specify fields (comma-separated)").action(async (options) => {
+    const client = await getTrpcClient();
+    const pageSize = Number.parseInt(options.limit || "30", 10);
+    const query = { pageSize };
+    if (options.fileType) query.fileTypes = [options.fileType];
+    const result = await client.document.queryDocuments.query(query);
+    const docs = Array.isArray(result) ? result : result.items ?? [];
+    if (options.json !== void 0) {
+      const fields = typeof options.json === "string" ? options.json : void 0;
+      outputJson(docs, fields);
+      return;
+    }
+    if (docs.length === 0) {
+      console.log("No documents found.");
+      return;
+    }
+    const rows = docs.map((d) => [
+      d.id,
+      truncate(d.title || d.filename || "Untitled", 120),
+      d.fileType || "",
+      d.updatedAt ? timeAgo(d.updatedAt) : ""
+    ]);
+    printTable(rows, ["ID", "TITLE", "TYPE", "UPDATED"]);
+  });
+  doc.command("view <id>").description("View a document").option("--json [fields]", "Output JSON, optionally specify fields (comma-separated)").action(async (id, options) => {
+    const client = await getTrpcClient();
+    const document = await client.document.getDocumentById.query({ id });
+    if (!document) {
+      log.error(`Document not found: ${id}`);
+      process.exit(1);
+      return;
+    }
+    if (options.json !== void 0) {
+      const fields = typeof options.json === "string" ? options.json : void 0;
+      outputJson(document, fields);
+      return;
+    }
+    console.log(pc2.bold(document.title || "Untitled"));
+    const meta = [];
+    if (document.fileType) meta.push(document.fileType);
+    if (document.updatedAt) meta.push(`Updated ${timeAgo(document.updatedAt)}`);
+    if (meta.length > 0) console.log(pc2.dim(meta.join(" \xB7 ")));
+    console.log();
+    if (document.content) {
+      console.log(document.content);
+    } else {
+      console.log(pc2.dim("(no content)"));
+    }
+  });
+  doc.command("create").description("Create a new document").requiredOption("-t, --title <title>", "Document title").option("-b, --body <content>", "Document content").option("-F, --body-file <path>", "Read content from file").option("--parent <id>", "Parent document or folder ID").option("--slug <slug>", "Custom slug").action(
+    async (options) => {
+      const content = readBodyContent(options);
+      const client = await getTrpcClient();
+      const result = await client.document.createDocument.mutate({
+        content,
+        editorData: JSON.stringify({ content: content || "", type: "doc" }),
+        parentId: options.parent,
+        slug: options.slug,
+        title: options.title
+      });
+      console.log(`${pc2.green("\u2713")} Created document ${pc2.bold(result.id)}`);
+    }
+  );
+  doc.command("edit <id>").description("Edit a document").option("-t, --title <title>", "New title").option("-b, --body <content>", "New content").option("-F, --body-file <path>", "Read new content from file").option("--parent <id>", "Move to parent document (empty string for root)").action(
+    async (id, options) => {
+      const content = readBodyContent(options);
+      if (!options.title && !content && options.parent === void 0) {
+        log.error("No changes specified. Use --title, --body, --body-file, or --parent.");
+        process.exit(1);
+      }
+      const client = await getTrpcClient();
+      const params = { id };
+      if (options.title) params.title = options.title;
+      if (content !== void 0) {
+        params.content = content;
+        params.editorData = JSON.stringify({ content, type: "doc" });
+      }
+      if (options.parent !== void 0) {
+        params.parentId = options.parent || null;
+      }
+      await client.document.updateDocument.mutate(params);
+      console.log(`${pc2.green("\u2713")} Updated document ${pc2.bold(id)}`);
+    }
+  );
+  doc.command("delete <ids...>").description("Delete one or more documents").option("--yes", "Skip confirmation prompt").action(async (ids, options) => {
+    if (!options.yes) {
+      const confirmed = await confirm(
+        `Are you sure you want to delete ${ids.length} document(s)?`
+      );
+      if (!confirmed) {
+        console.log("Cancelled.");
+        return;
+      }
+    }
+    const client = await getTrpcClient();
+    if (ids.length === 1) {
+      await client.document.deleteDocument.mutate({ id: ids[0] });
+    } else {
+      await client.document.deleteDocuments.mutate({ ids });
+    }
+    console.log(`${pc2.green("\u2713")} Deleted ${ids.length} document(s)`);
+  });
+}
+
 // src/commands/login.ts
 import { execFile } from "child_process";
 var CLIENT_ID2 = "lobehub-cli";
@@ -1292,7 +3494,7 @@ function registerLoginCommand(program2) {
     const expiresAt = Date.now() + deviceAuth.expires_in * 1e3;
     let pollInterval = interval;
     while (Date.now() < expiresAt) {
-      await sleep(pollInterval);
+      await sleep2(pollInterval);
       try {
         const res = await fetch(`${serverUrl}/oidc/token`, {
           body: new URLSearchParams({
@@ -1345,7 +3547,7 @@ function registerLoginCommand(program2) {
     process.exit(1);
   });
 }
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function openBrowser(url) {
@@ -1431,4 +3633,10 @@ registerLoginCommand(program);
 registerLogoutCommand(program);
 registerConnectCommand(program);
 registerStatusCommand(program);
+registerDocCommand(program);
 program.parse();
+/*! Bundled license information:
+
+@trpc/client/dist/httpLink-Cz9h1Qgh.mjs:
+  (* istanbul ignore if -- @preserve *)
+*/