camstack 1.2.14 → 1.2.16

package/dist/dist-RV3V7TEU.js

@@ -0,0 +1,902 @@
+#!/usr/bin/env node
+import {
+  __esm
+} from "./chunk-LMMQX4CK.js";
+
+// ../../node_modules/@trpc/server/dist/codes-DagpWZLc.mjs
+function mergeWithoutOverrides(obj1, ...objs) {
+  const newObj = Object.assign(emptyObject(), obj1);
+  for (const overrides of objs) for (const key in overrides) {
+    if (key in newObj && newObj[key] !== overrides[key]) throw new Error(`Duplicate key ${key}`);
+    newObj[key] = overrides[key];
+  }
+  return newObj;
+}
+function isObject(value) {
+  return !!value && !Array.isArray(value) && typeof value === "object";
+}
+function isFunction(fn) {
+  return typeof fn === "function";
+}
+function emptyObject() {
+  return /* @__PURE__ */ Object.create(null);
+}
+var TRPC_ERROR_CODES_BY_KEY, retryableRpcCodes;
+var init_codes_DagpWZLc = __esm({
+  "../../node_modules/@trpc/server/dist/codes-DagpWZLc.mjs"() {
+    "use strict";
+    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
+    };
+    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/@trpc/server/dist/getErrorShape-BPSzUA7W.mjs
+function createInnerProxy(callback, path, memo) {
+  var _memo$cacheKey;
+  const cacheKey = path.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, [...path, key], memo);
+    },
+    apply(_1, _2, args) {
+      const lastOfPath = path[path.length - 1];
+      if (lastOfPath === "valueOf" || lastOfPath === "toString" || lastOfPath === "toJSON") {
+        const debugPath = path.slice(0, -1).join(".");
+        return `tRPC.proxy(${debugPath})`;
+      }
+      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];
+}
+function getStatusCodeFromKey(code) {
+  var _JSONRPC2_TO_HTTP_COD;
+  return (_JSONRPC2_TO_HTTP_COD = JSONRPC2_TO_HTTP_CODE[code]) !== null && _JSONRPC2_TO_HTTP_COD !== void 0 ? _JSONRPC2_TO_HTTP_COD : 500;
+}
+function getHTTPStatusCodeFromError(error) {
+  return getStatusCodeFromKey(error.code);
+}
+function getErrorShape(opts) {
+  const { path, error, config } = opts;
+  const { code } = opts.error;
+  const shape = {
+    message: error.message,
+    code: TRPC_ERROR_CODES_BY_KEY[code],
+    data: {
+      code,
+      httpStatus: getHTTPStatusCodeFromError(error)
+    }
+  };
+  if (config.isDev && typeof opts.error.stack === "string") shape.data.stack = opts.error.stack;
+  if (typeof path === "string") shape.data.path = path;
+  return config.errorFormatter((0, import_objectSpread2.default)((0, import_objectSpread2.default)({}, opts), {}, { shape }));
+}
+var __create, __defProp, __getOwnPropDesc, __getOwnPropNames, __getProtoOf, __hasOwnProp, __commonJS, __copyProps, __toESM, noop, freezeIfAvailable, createRecursiveProxy, createFlatProxy, JSONRPC2_TO_HTTP_CODE, require_typeof, require_toPrimitive, require_toPropertyKey, require_defineProperty, require_objectSpread2, import_objectSpread2;
+var init_getErrorShape_BPSzUA7W = __esm({
+  "../../node_modules/@trpc/server/dist/getErrorShape-BPSzUA7W.mjs"() {
+    "use strict";
+    init_codes_DagpWZLc();
+    __create = Object.create;
+    __defProp = Object.defineProperty;
+    __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+    __getOwnPropNames = Object.getOwnPropertyNames;
+    __getProtoOf = Object.getPrototypeOf;
+    __hasOwnProp = Object.prototype.hasOwnProperty;
+    __commonJS = (cb, mod) => function() {
+      return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+    };
+    __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;
+    };
+    __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+      value: mod,
+      enumerable: true
+    }) : target, mod));
+    noop = () => {
+    };
+    freezeIfAvailable = (obj) => {
+      if (Object.freeze) Object.freeze(obj);
+    };
+    createRecursiveProxy = (callback) => createInnerProxy(callback, [], emptyObject());
+    createFlatProxy = (callback) => {
+      return new Proxy(noop, { get(_obj, name) {
+        if (name === "then") return void 0;
+        return callback(name);
+      } });
+    };
+    JSONRPC2_TO_HTTP_CODE = {
+      PARSE_ERROR: 400,
+      BAD_REQUEST: 400,
+      UNAUTHORIZED: 401,
+      PAYMENT_REQUIRED: 402,
+      FORBIDDEN: 403,
+      NOT_FOUND: 404,
+      METHOD_NOT_SUPPORTED: 405,
+      TIMEOUT: 408,
+      CONFLICT: 409,
+      PRECONDITION_FAILED: 412,
+      PAYLOAD_TOO_LARGE: 413,
+      UNSUPPORTED_MEDIA_TYPE: 415,
+      UNPROCESSABLE_CONTENT: 422,
+      PRECONDITION_REQUIRED: 428,
+      TOO_MANY_REQUESTS: 429,
+      CLIENT_CLOSED_REQUEST: 499,
+      INTERNAL_SERVER_ERROR: 500,
+      NOT_IMPLEMENTED: 501,
+      BAD_GATEWAY: 502,
+      SERVICE_UNAVAILABLE: 503,
+      GATEWAY_TIMEOUT: 504
+    };
+    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;
+    } });
+    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;
+    } });
+    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;
+    } });
+    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;
+    } });
+    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;
+    } });
+    import_objectSpread2 = __toESM(require_objectSpread2(), 1);
+  }
+});
+
+// ../../node_modules/@trpc/server/dist/tracked-DWInO6EQ.mjs
+function getMessage(cause) {
+  if ("message" in cause) return String(cause.message);
+  return void 0;
+}
+function getCauseFromUnknown(cause) {
+  if (cause instanceof Error) return cause;
+  const type = typeof cause;
+  if (type === "undefined" || type === "function" || cause === null) return void 0;
+  if (type !== "object") return new Error(String(cause));
+  if (isObject(cause)) return new UnknownCauseError(cause);
+  return void 0;
+}
+function getTRPCErrorFromUnknown(cause) {
+  if (cause instanceof TRPCError) return cause;
+  if (cause instanceof Error && cause.name === "TRPCError") return cause;
+  const trpcError = new TRPCError({
+    code: "INTERNAL_SERVER_ERROR",
+    cause
+  });
+  if (cause instanceof Error && cause.stack) trpcError.stack = cause.stack;
+  return trpcError;
+}
+function getDataTransformer(transformer) {
+  if ("input" in transformer) return transformer;
+  return {
+    input: transformer,
+    output: transformer
+  };
+}
+function transformTRPCResponseItem(config, item) {
+  if ("error" in item) return (0, import_objectSpread2$1.default)((0, import_objectSpread2$1.default)({}, item), {}, { error: config.transformer.output.serialize(item.error) });
+  if ("data" in item.result) return (0, import_objectSpread2$1.default)((0, import_objectSpread2$1.default)({}, item), {}, { result: (0, import_objectSpread2$1.default)((0, import_objectSpread2$1.default)({}, item.result), {}, { data: config.transformer.output.serialize(item.result.data) }) });
+  return item;
+}
+function transformTRPCResponse(config, itemOrItems) {
+  return Array.isArray(itemOrItems) ? itemOrItems.map((item) => transformTRPCResponseItem(config, item)) : transformTRPCResponseItem(config, itemOrItems);
+}
+function once(fn) {
+  const uncalled = /* @__PURE__ */ Symbol();
+  let result = uncalled;
+  return () => {
+    if (result === uncalled) result = fn();
+    return result;
+  };
+}
+function lazy(importRouter) {
+  async function resolve() {
+    const mod = await importRouter();
+    if (isRouter(mod)) return mod;
+    const routers = Object.values(mod);
+    if (routers.length !== 1 || !isRouter(routers[0])) throw new Error("Invalid router module - either define exactly 1 export or return the router directly.\nExample: `lazy(() => import('./slow.js').then((m) => m.slowRouter))`");
+    return routers[0];
+  }
+  resolve[lazyMarker] = true;
+  return resolve;
+}
+function isLazy(input) {
+  return typeof input === "function" && lazyMarker in input;
+}
+function isRouter(value) {
+  return isObject(value) && isObject(value["_def"]) && "router" in value["_def"];
+}
+function createRouterFactory(config) {
+  function createRouterInner(input) {
+    const reservedWordsUsed = new Set(Object.keys(input).filter((v) => reservedWords.includes(v)));
+    if (reservedWordsUsed.size > 0) throw new Error("Reserved words used in `router({})` call: " + Array.from(reservedWordsUsed).join(", "));
+    const procedures = emptyObject();
+    const lazy$1 = emptyObject();
+    function createLazyLoader(opts) {
+      return {
+        ref: opts.ref,
+        load: once(async () => {
+          const router$1 = await opts.ref();
+          const lazyPath = [...opts.path, opts.key];
+          const lazyKey = lazyPath.join(".");
+          opts.aggregate[opts.key] = step(router$1._def.record, lazyPath);
+          delete lazy$1[lazyKey];
+          for (const [nestedKey, nestedItem] of Object.entries(router$1._def.lazy)) {
+            const nestedRouterKey = [...lazyPath, nestedKey].join(".");
+            lazy$1[nestedRouterKey] = createLazyLoader({
+              ref: nestedItem.ref,
+              path: lazyPath,
+              key: nestedKey,
+              aggregate: opts.aggregate[opts.key]
+            });
+          }
+        })
+      };
+    }
+    function step(from, path = []) {
+      const aggregate = emptyObject();
+      for (const [key, item] of Object.entries(from !== null && from !== void 0 ? from : {})) {
+        if (isLazy(item)) {
+          lazy$1[[...path, key].join(".")] = createLazyLoader({
+            path,
+            ref: item,
+            key,
+            aggregate
+          });
+          continue;
+        }
+        if (isRouter(item)) {
+          aggregate[key] = step(item._def.record, [...path, key]);
+          continue;
+        }
+        if (!isProcedure(item)) {
+          aggregate[key] = step(item, [...path, key]);
+          continue;
+        }
+        const newPath = [...path, key].join(".");
+        if (procedures[newPath]) throw new Error(`Duplicate key: ${newPath}`);
+        procedures[newPath] = item;
+        aggregate[key] = item;
+      }
+      return aggregate;
+    }
+    const record = step(input);
+    const _def = (0, import_objectSpread22.default)((0, import_objectSpread22.default)({
+      _config: config,
+      router: true,
+      procedures,
+      lazy: lazy$1
+    }, emptyRouter), {}, { record });
+    const router = (0, import_objectSpread22.default)((0, import_objectSpread22.default)({}, record), {}, {
+      _def,
+      createCaller: createCallerFactory()({ _def })
+    });
+    return router;
+  }
+  return createRouterInner;
+}
+function isProcedure(procedureOrRouter) {
+  return typeof procedureOrRouter === "function";
+}
+async function getProcedureAtPath(router, path) {
+  const { _def } = router;
+  let procedure = _def.procedures[path];
+  while (!procedure) {
+    const key = Object.keys(_def.lazy).find((key$1) => path.startsWith(key$1));
+    if (!key) return null;
+    const lazyRouter = _def.lazy[key];
+    await lazyRouter.load();
+    procedure = _def.procedures[path];
+  }
+  return procedure;
+}
+async function callProcedure(opts) {
+  const { type, path } = opts;
+  const proc = await getProcedureAtPath(opts.router, path);
+  if (!proc || !isProcedure(proc) || proc._def.type !== type && !opts.allowMethodOverride) throw new TRPCError({
+    code: "NOT_FOUND",
+    message: `No "${type}"-procedure on path "${path}"`
+  });
+  if (proc._def.type !== type && opts.allowMethodOverride && proc._def.type === "subscription") throw new TRPCError({
+    code: "METHOD_NOT_SUPPORTED",
+    message: `Method override is not supported for subscriptions`
+  });
+  return proc(opts);
+}
+function createCallerFactory() {
+  return function createCallerInner(router) {
+    const { _def } = router;
+    return function createCaller(ctxOrCallback, opts) {
+      return createRecursiveProxy(async (innerOpts) => {
+        const { path, args } = innerOpts;
+        const fullPath = path.join(".");
+        if (path.length === 1 && path[0] === "_def") return _def;
+        const procedure = await getProcedureAtPath(router, fullPath);
+        let ctx = void 0;
+        try {
+          if (!procedure) throw new TRPCError({
+            code: "NOT_FOUND",
+            message: `No procedure found on path "${path}"`
+          });
+          ctx = isFunction(ctxOrCallback) ? await Promise.resolve(ctxOrCallback()) : ctxOrCallback;
+          return await procedure({
+            path: fullPath,
+            getRawInput: async () => args[0],
+            ctx,
+            type: procedure._def.type,
+            signal: opts === null || opts === void 0 ? void 0 : opts.signal,
+            batchIndex: 0
+          });
+        } catch (cause) {
+          var _opts$onError, _procedure$_def$type;
+          opts === null || opts === void 0 || (_opts$onError = opts.onError) === null || _opts$onError === void 0 || _opts$onError.call(opts, {
+            ctx,
+            error: getTRPCErrorFromUnknown(cause),
+            input: args[0],
+            path: fullPath,
+            type: (_procedure$_def$type = procedure === null || procedure === void 0 ? void 0 : procedure._def.type) !== null && _procedure$_def$type !== void 0 ? _procedure$_def$type : "unknown"
+          });
+          throw cause;
+        }
+      });
+    };
+  };
+}
+function mergeRouters(...routerList) {
+  var _routerList$, _routerList$2;
+  const record = mergeWithoutOverrides({}, ...routerList.map((r) => r._def.record));
+  const errorFormatter = routerList.reduce((currentErrorFormatter, nextRouter) => {
+    if (nextRouter._def._config.errorFormatter && nextRouter._def._config.errorFormatter !== defaultFormatter) {
+      if (currentErrorFormatter !== defaultFormatter && currentErrorFormatter !== nextRouter._def._config.errorFormatter) throw new Error("You seem to have several error formatters");
+      return nextRouter._def._config.errorFormatter;
+    }
+    return currentErrorFormatter;
+  }, defaultFormatter);
+  const transformer = routerList.reduce((prev, current) => {
+    if (current._def._config.transformer && current._def._config.transformer !== defaultTransformer) {
+      if (prev !== defaultTransformer && prev !== current._def._config.transformer) throw new Error("You seem to have several transformers");
+      return current._def._config.transformer;
+    }
+    return prev;
+  }, defaultTransformer);
+  const router = createRouterFactory({
+    errorFormatter,
+    transformer,
+    isDev: routerList.every((r) => r._def._config.isDev),
+    allowOutsideOfServer: routerList.every((r) => r._def._config.allowOutsideOfServer),
+    isServer: routerList.every((r) => r._def._config.isServer),
+    $types: (_routerList$ = routerList[0]) === null || _routerList$ === void 0 ? void 0 : _routerList$._def._config.$types,
+    sse: (_routerList$2 = routerList[0]) === null || _routerList$2 === void 0 ? void 0 : _routerList$2._def._config.sse
+  })(record);
+  return router;
+}
+function sse(event) {
+  return tracked(event.id, event.data);
+}
+function isTrackedEnvelope(value) {
+  return Array.isArray(value) && value[2] === trackedSymbol;
+}
+function tracked(id, data) {
+  if (id === "") throw new Error("`id` must not be an empty string as empty string is the same as not setting the id at all");
+  return [
+    id,
+    data,
+    trackedSymbol
+  ];
+}
+var defaultFormatter, import_defineProperty, UnknownCauseError, TRPCError, import_objectSpread2$1, defaultTransformer, import_objectSpread22, lazyMarker, emptyRouter, reservedWords, trackedSymbol;
+var init_tracked_DWInO6EQ = __esm({
+  "../../node_modules/@trpc/server/dist/tracked-DWInO6EQ.mjs"() {
+    "use strict";
+    init_getErrorShape_BPSzUA7W();
+    init_codes_DagpWZLc();
+    defaultFormatter = ({ shape }) => {
+      return shape;
+    };
+    import_defineProperty = __toESM(require_defineProperty(), 1);
+    UnknownCauseError = class extends Error {
+      constructor(cause) {
+        super(getMessage(cause));
+        Object.assign(this, cause);
+      }
+    };
+    TRPCError = class extends Error {
+      constructor(opts) {
+        var _ref, _opts$message, _this$cause;
+        const cause = getCauseFromUnknown(opts.cause);
+        const message = (_ref = (_opts$message = opts.message) !== null && _opts$message !== void 0 ? _opts$message : cause === null || cause === void 0 ? void 0 : cause.message) !== null && _ref !== void 0 ? _ref : opts.code;
+        super(message, { cause });
+        (0, import_defineProperty.default)(this, "cause", void 0);
+        (0, import_defineProperty.default)(this, "code", void 0);
+        this.code = opts.code;
+        this.name = "TRPCError";
+        (_this$cause = this.cause) !== null && _this$cause !== void 0 || (this.cause = cause);
+      }
+    };
+    import_objectSpread2$1 = __toESM(require_objectSpread2(), 1);
+    defaultTransformer = {
+      input: {
+        serialize: (obj) => obj,
+        deserialize: (obj) => obj
+      },
+      output: {
+        serialize: (obj) => obj,
+        deserialize: (obj) => obj
+      }
+    };
+    import_objectSpread22 = __toESM(require_objectSpread2(), 1);
+    lazyMarker = "lazyMarker";
+    emptyRouter = {
+      _ctx: null,
+      _errorShape: null,
+      _meta: null,
+      queries: {},
+      mutations: {},
+      subscriptions: {},
+      errorFormatter: defaultFormatter,
+      transformer: defaultTransformer
+    };
+    reservedWords = [
+      "then",
+      "call",
+      "apply"
+    ];
+    trackedSymbol = /* @__PURE__ */ Symbol();
+  }
+});
+
+// ../../node_modules/@trpc/server/dist/initTRPC-BRf4imah.mjs
+function createMiddlewareFactory() {
+  function createMiddlewareInner(middlewares) {
+    return {
+      _middlewares: middlewares,
+      unstable_pipe(middlewareBuilderOrFn) {
+        const pipedMiddleware = "_middlewares" in middlewareBuilderOrFn ? middlewareBuilderOrFn._middlewares : [middlewareBuilderOrFn];
+        return createMiddlewareInner([...middlewares, ...pipedMiddleware]);
+      }
+    };
+  }
+  function createMiddleware(fn) {
+    return createMiddlewareInner([fn]);
+  }
+  return createMiddleware;
+}
+function createInputMiddleware(parse) {
+  const inputMiddleware = async function inputValidatorMiddleware(opts) {
+    let parsedInput;
+    const rawInput = await opts.getRawInput();
+    try {
+      parsedInput = await parse(rawInput);
+    } catch (cause) {
+      throw new TRPCError({
+        code: "BAD_REQUEST",
+        cause
+      });
+    }
+    const combinedInput = isObject(opts.input) && isObject(parsedInput) ? (0, import_objectSpread2$2.default)((0, import_objectSpread2$2.default)({}, opts.input), parsedInput) : parsedInput;
+    return opts.next({ input: combinedInput });
+  };
+  inputMiddleware._type = "input";
+  return inputMiddleware;
+}
+function createOutputMiddleware(parse) {
+  const outputMiddleware = async function outputValidatorMiddleware({ next }) {
+    const result = await next();
+    if (!result.ok) return result;
+    try {
+      const data = await parse(result.data);
+      return (0, import_objectSpread2$2.default)((0, import_objectSpread2$2.default)({}, result), {}, { data });
+    } catch (cause) {
+      throw new TRPCError({
+        message: "Output validation failed",
+        code: "INTERNAL_SERVER_ERROR",
+        cause
+      });
+    }
+  };
+  outputMiddleware._type = "output";
+  return outputMiddleware;
+}
+function getParseFn(procedureParser) {
+  const parser = procedureParser;
+  const isStandardSchema = "~standard" in parser;
+  if (typeof parser === "function" && typeof parser.assert === "function") return parser.assert.bind(parser);
+  if (typeof parser === "function" && !isStandardSchema) return parser;
+  if (typeof parser.parseAsync === "function") return parser.parseAsync.bind(parser);
+  if (typeof parser.parse === "function") return parser.parse.bind(parser);
+  if (typeof parser.validateSync === "function") return parser.validateSync.bind(parser);
+  if (typeof parser.create === "function") return parser.create.bind(parser);
+  if (typeof parser.assert === "function") return (value) => {
+    parser.assert(value);
+    return value;
+  };
+  if (isStandardSchema) return async (value) => {
+    const result = await parser["~standard"].validate(value);
+    if (result.issues) throw new StandardSchemaV1Error(result.issues);
+    return result.value;
+  };
+  throw new Error("Could not find a validator fn");
+}
+function createNewBuilder(def1, def2) {
+  const { middlewares = [], inputs, meta } = def2, rest = (0, import_objectWithoutProperties.default)(def2, _excluded);
+  return createBuilder((0, import_objectSpread2$12.default)((0, import_objectSpread2$12.default)({}, mergeWithoutOverrides(def1, rest)), {}, {
+    inputs: [...def1.inputs, ...inputs !== null && inputs !== void 0 ? inputs : []],
+    middlewares: [...def1.middlewares, ...middlewares],
+    meta: def1.meta && meta ? (0, import_objectSpread2$12.default)((0, import_objectSpread2$12.default)({}, def1.meta), meta) : meta !== null && meta !== void 0 ? meta : def1.meta
+  }));
+}
+function createBuilder(initDef = {}) {
+  const _def = (0, import_objectSpread2$12.default)({
+    procedure: true,
+    inputs: [],
+    middlewares: []
+  }, initDef);
+  const builder = {
+    _def,
+    input(input) {
+      const parser = getParseFn(input);
+      return createNewBuilder(_def, {
+        inputs: [input],
+        middlewares: [createInputMiddleware(parser)]
+      });
+    },
+    output(output) {
+      const parser = getParseFn(output);
+      return createNewBuilder(_def, {
+        output,
+        middlewares: [createOutputMiddleware(parser)]
+      });
+    },
+    meta(meta) {
+      return createNewBuilder(_def, { meta });
+    },
+    use(middlewareBuilderOrFn) {
+      const middlewares = "_middlewares" in middlewareBuilderOrFn ? middlewareBuilderOrFn._middlewares : [middlewareBuilderOrFn];
+      return createNewBuilder(_def, { middlewares });
+    },
+    unstable_concat(builder$1) {
+      return createNewBuilder(_def, builder$1._def);
+    },
+    concat(builder$1) {
+      return createNewBuilder(_def, builder$1._def);
+    },
+    query(resolver) {
+      return createResolver((0, import_objectSpread2$12.default)((0, import_objectSpread2$12.default)({}, _def), {}, { type: "query" }), resolver);
+    },
+    mutation(resolver) {
+      return createResolver((0, import_objectSpread2$12.default)((0, import_objectSpread2$12.default)({}, _def), {}, { type: "mutation" }), resolver);
+    },
+    subscription(resolver) {
+      return createResolver((0, import_objectSpread2$12.default)((0, import_objectSpread2$12.default)({}, _def), {}, { type: "subscription" }), resolver);
+    },
+    experimental_caller(caller) {
+      return createNewBuilder(_def, { caller });
+    }
+  };
+  return builder;
+}
+function createResolver(_defIn, resolver) {
+  const finalBuilder = createNewBuilder(_defIn, {
+    resolver,
+    middlewares: [async function resolveMiddleware(opts) {
+      const data = await resolver(opts);
+      return {
+        marker: middlewareMarker,
+        ok: true,
+        data,
+        ctx: opts.ctx
+      };
+    }]
+  });
+  const _def = (0, import_objectSpread2$12.default)((0, import_objectSpread2$12.default)({}, finalBuilder._def), {}, {
+    type: _defIn.type,
+    experimental_caller: Boolean(finalBuilder._def.caller),
+    meta: finalBuilder._def.meta,
+    $types: null
+  });
+  const invoke = createProcedureCaller(finalBuilder._def);
+  const callerOverride = finalBuilder._def.caller;
+  if (!callerOverride) return invoke;
+  const callerWrapper = async (...args) => {
+    return await callerOverride({
+      args,
+      invoke,
+      _def
+    });
+  };
+  callerWrapper._def = _def;
+  return callerWrapper;
+}
+async function callRecursive(index, _def, opts) {
+  try {
+    const middleware = _def.middlewares[index];
+    const result = await middleware((0, import_objectSpread2$12.default)((0, import_objectSpread2$12.default)({}, opts), {}, {
+      meta: _def.meta,
+      input: opts.input,
+      next(_nextOpts) {
+        var _nextOpts$getRawInput;
+        const nextOpts = _nextOpts;
+        return callRecursive(index + 1, _def, (0, import_objectSpread2$12.default)((0, import_objectSpread2$12.default)({}, opts), {}, {
+          ctx: (nextOpts === null || nextOpts === void 0 ? void 0 : nextOpts.ctx) ? (0, import_objectSpread2$12.default)((0, import_objectSpread2$12.default)({}, opts.ctx), nextOpts.ctx) : opts.ctx,
+          input: nextOpts && "input" in nextOpts ? nextOpts.input : opts.input,
+          getRawInput: (_nextOpts$getRawInput = nextOpts === null || nextOpts === void 0 ? void 0 : nextOpts.getRawInput) !== null && _nextOpts$getRawInput !== void 0 ? _nextOpts$getRawInput : opts.getRawInput
+        }));
+      }
+    }));
+    return result;
+  } catch (cause) {
+    return {
+      ok: false,
+      error: getTRPCErrorFromUnknown(cause),
+      marker: middlewareMarker
+    };
+  }
+}
+function createProcedureCaller(_def) {
+  async function procedure(opts) {
+    if (!opts || !("getRawInput" in opts)) throw new Error(codeblock);
+    const result = await callRecursive(0, _def, opts);
+    if (!result) throw new TRPCError({
+      code: "INTERNAL_SERVER_ERROR",
+      message: "No result from middlewares - did you forget to `return next()`?"
+    });
+    if (!result.ok) throw result.error;
+    return result.data;
+  }
+  procedure._def = _def;
+  procedure.procedure = true;
+  procedure.meta = _def.meta;
+  return procedure;
+}
+var import_objectSpread2$2, middlewareMarker, experimental_standaloneMiddleware, import_defineProperty2, StandardSchemaV1Error, require_objectWithoutPropertiesLoose, require_objectWithoutProperties, import_objectWithoutProperties, import_objectSpread2$12, _excluded, codeblock, _globalThis$process, _globalThis$process2, _globalThis$process3, isServerDefault, import_objectSpread23, TRPCBuilder, initTRPC;
+var init_initTRPC_BRf4imah = __esm({
+  "../../node_modules/@trpc/server/dist/initTRPC-BRf4imah.mjs"() {
+    "use strict";
+    init_getErrorShape_BPSzUA7W();
+    init_codes_DagpWZLc();
+    init_tracked_DWInO6EQ();
+    import_objectSpread2$2 = __toESM(require_objectSpread2(), 1);
+    middlewareMarker = "middlewareMarker";
+    experimental_standaloneMiddleware = () => ({ create: createMiddlewareFactory() });
+    import_defineProperty2 = __toESM(require_defineProperty(), 1);
+    StandardSchemaV1Error = class extends Error {
+      /**
+      * Creates a schema error with useful information.
+      *
+      * @param issues The schema issues.
+      */
+      constructor(issues) {
+        var _issues$;
+        super((_issues$ = issues[0]) === null || _issues$ === void 0 ? void 0 : _issues$.message);
+        (0, import_defineProperty2.default)(this, "issues", void 0);
+        this.name = "SchemaError";
+        this.issues = issues;
+      }
+    };
+    require_objectWithoutPropertiesLoose = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/objectWithoutPropertiesLoose.js"(exports, module) {
+      function _objectWithoutPropertiesLoose(r, e) {
+        if (null == r) return {};
+        var t = {};
+        for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+          if (e.includes(n)) continue;
+          t[n] = r[n];
+        }
+        return t;
+      }
+      module.exports = _objectWithoutPropertiesLoose, module.exports.__esModule = true, module.exports["default"] = module.exports;
+    } });
+    require_objectWithoutProperties = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/objectWithoutProperties.js"(exports, module) {
+      var objectWithoutPropertiesLoose = require_objectWithoutPropertiesLoose();
+      function _objectWithoutProperties$1(e, t) {
+        if (null == e) return {};
+        var o, r, i = objectWithoutPropertiesLoose(e, t);
+        if (Object.getOwnPropertySymbols) {
+          var s = Object.getOwnPropertySymbols(e);
+          for (r = 0; r < s.length; r++) o = s[r], t.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+        }
+        return i;
+      }
+      module.exports = _objectWithoutProperties$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+    } });
+    import_objectWithoutProperties = __toESM(require_objectWithoutProperties(), 1);
+    import_objectSpread2$12 = __toESM(require_objectSpread2(), 1);
+    _excluded = [
+      "middlewares",
+      "inputs",
+      "meta"
+    ];
+    codeblock = `
+This is a client-only function.
+If you want to call this function on the server, see https://trpc.io/docs/v11/server/server-side-calls
+`.trim();
+    isServerDefault = typeof window === "undefined" || "Deno" in window || ((_globalThis$process = globalThis.process) === null || _globalThis$process === void 0 || (_globalThis$process = _globalThis$process.env) === null || _globalThis$process === void 0 ? void 0 : _globalThis$process["NODE_ENV"]) === "test" || !!((_globalThis$process2 = globalThis.process) === null || _globalThis$process2 === void 0 || (_globalThis$process2 = _globalThis$process2.env) === null || _globalThis$process2 === void 0 ? void 0 : _globalThis$process2["JEST_WORKER_ID"]) || !!((_globalThis$process3 = globalThis.process) === null || _globalThis$process3 === void 0 || (_globalThis$process3 = _globalThis$process3.env) === null || _globalThis$process3 === void 0 ? void 0 : _globalThis$process3["VITEST_WORKER_ID"]);
+    import_objectSpread23 = __toESM(require_objectSpread2(), 1);
+    TRPCBuilder = class TRPCBuilder2 {
+      /**
+      * Add a context shape as a generic to the root object
+      * @see https://trpc.io/docs/v11/server/context
+      */
+      context() {
+        return new TRPCBuilder2();
+      }
+      /**
+      * Add a meta shape as a generic to the root object
+      * @see https://trpc.io/docs/v11/quickstart
+      */
+      meta() {
+        return new TRPCBuilder2();
+      }
+      /**
+      * Create the root object
+      * @see https://trpc.io/docs/v11/server/routers#initialize-trpc
+      */
+      create(opts) {
+        var _opts$transformer, _opts$isDev, _globalThis$process$1, _opts$allowOutsideOfS, _opts$errorFormatter, _opts$isServer;
+        const config = (0, import_objectSpread23.default)((0, import_objectSpread23.default)({}, opts), {}, {
+          transformer: getDataTransformer((_opts$transformer = opts === null || opts === void 0 ? void 0 : opts.transformer) !== null && _opts$transformer !== void 0 ? _opts$transformer : defaultTransformer),
+          isDev: (_opts$isDev = opts === null || opts === void 0 ? void 0 : opts.isDev) !== null && _opts$isDev !== void 0 ? _opts$isDev : ((_globalThis$process$1 = globalThis.process) === null || _globalThis$process$1 === void 0 ? void 0 : _globalThis$process$1.env["NODE_ENV"]) !== "production",
+          allowOutsideOfServer: (_opts$allowOutsideOfS = opts === null || opts === void 0 ? void 0 : opts.allowOutsideOfServer) !== null && _opts$allowOutsideOfS !== void 0 ? _opts$allowOutsideOfS : false,
+          errorFormatter: (_opts$errorFormatter = opts === null || opts === void 0 ? void 0 : opts.errorFormatter) !== null && _opts$errorFormatter !== void 0 ? _opts$errorFormatter : defaultFormatter,
+          isServer: (_opts$isServer = opts === null || opts === void 0 ? void 0 : opts.isServer) !== null && _opts$isServer !== void 0 ? _opts$isServer : isServerDefault,
+          $types: null
+        });
+        {
+          var _opts$isServer2;
+          const isServer = (_opts$isServer2 = opts === null || opts === void 0 ? void 0 : opts.isServer) !== null && _opts$isServer2 !== void 0 ? _opts$isServer2 : isServerDefault;
+          if (!isServer && (opts === null || opts === void 0 ? void 0 : opts.allowOutsideOfServer) !== true) throw new Error(`You're trying to use @trpc/server in a non-server environment. This is not supported by default.`);
+        }
+        return {
+          _config: config,
+          procedure: createBuilder({ meta: opts === null || opts === void 0 ? void 0 : opts.defaultMeta }),
+          middleware: createMiddlewareFactory(),
+          router: createRouterFactory(config),
+          mergeRouters,
+          createCallerFactory: createCallerFactory()
+        };
+      }
+    };
+    initTRPC = new TRPCBuilder();
+  }
+});
+
+// ../../node_modules/@trpc/server/dist/index.mjs
+var init_dist = __esm({
+  "../../node_modules/@trpc/server/dist/index.mjs"() {
+    init_getErrorShape_BPSzUA7W();
+    init_tracked_DWInO6EQ();
+    init_initTRPC_BRf4imah();
+  }
+});
+init_dist();
+export {
+  StandardSchemaV1Error,
+  TRPCError,
+  callProcedure as callTRPCProcedure,
+  createFlatProxy as createTRPCFlatProxy,
+  createRecursiveProxy as createTRPCRecursiveProxy,
+  lazy as experimental_lazy,
+  experimental_standaloneMiddleware,
+  experimental_standaloneMiddleware as experimental_trpcMiddleware,
+  getErrorShape,
+  getTRPCErrorFromUnknown,
+  getErrorShape as getTRPCErrorShape,
+  initTRPC,
+  isTrackedEnvelope,
+  lazy,
+  sse,
+  tracked,
+  transformTRPCResponse
+};
+/*! Bundled license information:
+
+@trpc/server/dist/tracked-DWInO6EQ.mjs:
+  (* istanbul ignore if -- @preserve *)
+*/