@trpc/server 10.0.0-alpha.41 → 10.0.0-alpha.44

package/dist/index.js

@@ -2,1109 +2,18 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var resolveHTTPResponse = require('./resolveHTTPResponse-fcc8f644.js');
-var envelopes = require('./envelopes-b6dd0367.js');
+var resolveHTTPResponse = require('./resolveHTTPResponse-5d90abc5.js');
+var router = require('./router-4e50a6ac.js');
 var TRPCError = require('./TRPCError-9050a68d.js');
-var index = require('./index-1a25ccbd.js');
 require('./transformTRPCResponse-0c261655.js');
-
-resolveHTTPResponse.assertNotBrowser();
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-/**
- * @public
- */
-
-/**
- * @public
- */
-
-/**
- * @public
- */
-
-/**
- * @public
- */
-
-/**
- * @public
- */
-
-/**
- * @internal
- */
-function getDataTransformer$1(transformer) {
-  if ('input' in transformer) {
-    return transformer;
-  }
-
-  return {
-    input: transformer,
-    output: transformer
-  };
-}
-/**
- * @internal
- */
-
-/**
- * @internal
- */
-const defaultTransformer = {
-  _default: true,
-  input: {
-    serialize: obj => obj,
-    deserialize: obj => obj
-  },
-  output: {
-    serialize: obj => obj,
-    deserialize: obj => obj
-  }
-};
-
-/**
- * @internal
- */
-
-/**
- * @internal
- */
-
-/**
- * @internal
- */
-const defaultFormatter = ({
-  shape
-}) => {
-  return shape;
-};
-
-/**
- * @deprecated
- */
-const middlewareMarker$1 = 'middlewareMarker';
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-resolveHTTPResponse.assertNotBrowser();
-
-function getParseFn$1(procedureParser) {
-  const parser = procedureParser;
-
-  if (typeof parser === 'function') {
-    // ProcedureParserCustomValidatorEsque
-    return parser;
-  }
-
-  if (typeof parser.parseAsync === 'function') {
-    // ProcedureParserZodEsque
-    return parser.parseAsync.bind(parser);
-  }
-
-  if (typeof parser.parse === 'function') {
-    // ProcedureParserZodEsque
-    return parser.parse.bind(parser);
-  }
-
-  if (typeof parser.validateSync === 'function') {
-    // ProcedureParserYupEsque
-    return parser.validateSync.bind(parser);
-  }
-
-  if (typeof parser.create === 'function') {
-    // ProcedureParserSuperstructEsque
-    return parser.create.bind(parser);
-  }
-
-  throw new Error('Could not find a validator fn');
-}
-/**
- * @internal
- * @deprecated
- */
-
-
-class Procedure {
-  constructor(opts) {
-    this.middlewares = void 0;
-    this.resolver = void 0;
-    this.inputParser = void 0;
-    this.parseInputFn = void 0;
-    this.outputParser = void 0;
-    this.parseOutputFn = void 0;
-    this.meta = void 0;
-    this.middlewares = opts.middlewares;
-    this.resolver = opts.resolver;
-    this.inputParser = opts.inputParser;
-    this.parseInputFn = getParseFn$1(this.inputParser);
-    this.outputParser = opts.outputParser;
-    this.parseOutputFn = getParseFn$1(this.outputParser);
-    this.meta = opts.meta;
-  }
-
-  _def() {
-    return {
-      middlewares: this.middlewares,
-      resolver: this.resolver,
-      inputParser: this.inputParser,
-      outputParser: this.outputParser,
-      meta: this.meta
-    };
-  }
-
-  async parseInput(rawInput) {
-    try {
-      return await this.parseInputFn(rawInput);
-    } catch (cause) {
-      throw new TRPCError.TRPCError({
-        code: 'BAD_REQUEST',
-        cause: TRPCError.getCauseFromUnknown(cause)
-      });
-    }
-  }
-
-  async parseOutput(rawOutput) {
-    try {
-      return await this.parseOutputFn(rawOutput);
-    } catch (cause) {
-      throw new TRPCError.TRPCError({
-        code: 'INTERNAL_SERVER_ERROR',
-        cause: TRPCError.getCauseFromUnknown(cause),
-        message: 'Output validation failed'
-      });
-    }
-  }
-  /**
-   * Trigger middlewares in order, parse raw input, call resolver & parse raw output
-   * @internal
-   */
-
-
-  async call(opts) {
-    // wrap the actual resolver and treat as the last "middleware"
-    const middlewaresWithResolver = this.middlewares.concat([async ({
-      ctx
-    }) => {
-      const input = await this.parseInput(opts.rawInput);
-      const rawOutput = await this.resolver({ ...opts,
-        ctx,
-        input
-      });
-      const data = await this.parseOutput(rawOutput);
-      return {
-        marker: middlewareMarker$1,
-        ok: true,
-        data,
-        ctx
-      };
-    }]); // run the middlewares recursively with the resolver as the last one
-
-    const callRecursive = async (callOpts = {
-      index: 0,
-      ctx: opts.ctx
-    }) => {
-      try {
-        const result = await middlewaresWithResolver[callOpts.index]({
-          ctx: callOpts.ctx,
-          type: opts.type,
-          path: opts.path,
-          rawInput: opts.rawInput,
-          meta: this.meta,
-          next: async nextOpts => {
-            return await callRecursive({
-              index: callOpts.index + 1,
-              ctx: nextOpts ? nextOpts.ctx : callOpts.ctx
-            });
-          }
-        });
-        return result;
-      } catch (cause) {
-        return {
-          ctx: callOpts.ctx,
-          ok: false,
-          error: TRPCError.getErrorFromUnknown(cause),
-          marker: middlewareMarker$1
-        };
-      }
-    }; // there's always at least one "next" since we wrap this.resolver in a middleware
-
-
-    const result = await callRecursive();
-
-    if (!result) {
-      throw new TRPCError.TRPCError({
-        code: 'INTERNAL_SERVER_ERROR',
-        message: 'No result from middlewares - did you forget to `return next()`?'
-      });
-    }
-
-    if (!result.ok) {
-      // re-throw original error
-      throw result.error;
-    }
-
-    return result.data;
-  }
-  /**
-   * Create new procedure with passed middlewares
-   * @param middlewares
-   */
-
-
-  inheritMiddlewares(middlewares) {
-    const Constructor = this.constructor;
-    const instance = new Constructor({
-      middlewares: [...middlewares, ...this.middlewares],
-      resolver: this.resolver,
-      inputParser: this.inputParser,
-      outputParser: this.outputParser,
-      meta: this.meta
-    });
-    return instance;
-  }
-
-}
-function createProcedure(opts) {
-  const inputParser = 'input' in opts ? opts.input : input => {
-    if (input != null) {
-      throw new TRPCError.TRPCError({
-        code: 'BAD_REQUEST',
-        message: 'No input expected'
-      });
-    }
-
-    return undefined;
-  };
-  const outputParser = 'output' in opts && opts.output ? opts.output : output => output;
-  return new Procedure({
-    inputParser: inputParser,
-    resolver: opts.resolve,
-    middlewares: [],
-    outputParser: outputParser,
-    meta: opts.meta
-  });
-}
-
-function getParseFn(procedureParser) {
-  const parser = procedureParser;
-
-  if (typeof parser === 'function') {
-    // ProcedureParserCustomValidatorEsque
-    return parser;
-  }
-
-  if (typeof parser.parseAsync === 'function') {
-    // ProcedureParserZodEsque
-    return parser.parseAsync.bind(parser);
-  }
-
-  if (typeof parser.parse === 'function') {
-    // ProcedureParserZodEsque
-    return parser.parse.bind(parser);
-  }
-
-  if (typeof parser.validateSync === 'function') {
-    // ProcedureParserYupEsque
-    return parser.validateSync.bind(parser);
-  }
-
-  if (typeof parser.create === 'function') {
-    // ProcedureParserSuperstructEsque
-    return parser.create.bind(parser);
-  }
-
-  throw new Error('Could not find a validator fn');
-}
-/**
- * @deprecated only for backwards compat
- * @internal
- */
-
-function getParseFnOrPassThrough(procedureParser) {
-  if (!procedureParser) {
-    return v => v;
-  }
-
-  return getParseFn(procedureParser);
-}
-
-/**
- * Ensures there are no duplicate keys when building a procedure.
- */
-function mergeWithoutOverrides(obj1, ...objs) {
-  const newObj = Object.assign(Object.create(null), 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;
-}
-
-/**
- * @internal
- */
-
-/**
- * @internal
- */
-
-/**
- * @internal
- */
-const middlewareMarker = 'middlewareMarker';
-/**
- * @internal
- */
-
-function createNewBuilder(def1, def2) {
-  const {
-    middlewares = [],
-    ...rest
-  } = def2; // TODO: maybe have a fn here to warn about calls
-
-  return createBuilder({ ...mergeWithoutOverrides(def1, rest),
-    middlewares: [...def1.middlewares, ...middlewares]
-  });
-}
-
-function createBuilder(initDef) {
-  const _def = initDef || {
-    middlewares: []
-  };
-
-  return {
-    _def,
-
-    input(input) {
-      const parser = getParseFn(input);
-      return createNewBuilder(_def, {
-        input,
-        middlewares: [createInputMiddleware(parser)]
-      });
-    },
-
-    output(output) {
-      const parseOutput = getParseFn(output);
-      return createNewBuilder(_def, {
-        output,
-        middlewares: [createOutputMiddleware(parseOutput)]
-      });
-    },
-
-    meta(meta) {
-      return createNewBuilder(_def, {
-        meta: meta
-      });
-    },
-
-    /** @deprecated **/
-    resolve(resolver) {
-      return createResolver(_def, resolver);
-    },
-
-    unstable_concat(builder) {
-      return createNewBuilder(_def, builder._def);
-    },
-
-    use(middleware) {
-      return createNewBuilder(_def, {
-        middlewares: [middleware]
-      });
-    },
-
-    query(resolver) {
-      return createResolver({ ..._def,
-        query: true
-      }, resolver);
-    },
-
-    mutation(resolver) {
-      return createResolver({ ..._def,
-        mutation: true
-      }, resolver);
-    },
-
-    subscription(resolver) {
-      return createResolver({ ..._def,
-        subscription: true
-      }, resolver);
-    }
-
-  };
-}
-function createInputMiddleware(parse) {
-  return async function inputMiddleware({
-    next,
-    rawInput
-  }) {
-    let input;
-
-    try {
-      input = await parse(rawInput);
-    } catch (cause) {
-      throw new TRPCError.TRPCError({
-        code: 'BAD_REQUEST',
-        cause: TRPCError.getCauseFromUnknown(cause)
-      });
-    } // TODO fix this typing?
-
-
-    return next({
-      input
-    });
-  };
-}
-function createOutputMiddleware(parse) {
-  return async function outputMiddleware({
-    next
-  }) {
-    const result = await next();
-
-    if (!result.ok) {
-      // pass through failures without validating
-      return result;
-    }
-
-    try {
-      const data = await parse(result.data);
-      return { ...result,
-        data
-      };
-    } catch (cause) {
-      throw new TRPCError.TRPCError({
-        message: 'Output validation failed',
-        code: 'INTERNAL_SERVER_ERROR',
-        cause: TRPCError.getCauseFromUnknown(cause)
-      });
-    }
-  };
-}
-
-function createResolver(_def, resolver) {
-  const finalBuilder = createNewBuilder(_def, {
-    resolver,
-    middlewares: [async function resolveMiddleware(opts) {
-      const data = await resolver(opts);
-      return {
-        marker: middlewareMarker,
-        ok: true,
-        data,
-        ctx: opts.ctx
-      };
-    }]
-  });
-  return createProcedureCaller(finalBuilder._def);
-}
-/**
- * @internal
- */
-
-
-const codeblock = /*#__PURE__*/`
-If you want to call this function on the server, you do the following:
-This is a client-only function.
-
-const caller = appRouter.createCaller({
-  /* ... your context */
-});
-
-const result = await caller.call('myProcedure', input);
-`.trim();
-
-function createProcedureCaller(_def) {
-  const procedure = async function resolve(opts) {
-    // is direct server-side call
-    if (!opts || !('rawInput' in opts)) {
-      throw new Error(codeblock);
-    } // run the middlewares recursively with the resolver as the last one
-
-
-    const callRecursive = async (callOpts = {
-      index: 0,
-      ctx: opts.ctx
-    }) => {
-      try {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const middleware = _def.middlewares[callOpts.index];
-        const result = await middleware({
-          ctx: callOpts.ctx,
-          type: opts.type,
-          path: opts.path,
-          rawInput: opts.rawInput,
-          meta: _def.meta,
-          input: callOpts.input,
-          next: async nextOpts => {
-            return await callRecursive({
-              index: callOpts.index + 1,
-              ctx: nextOpts && 'ctx' in nextOpts ? { ...callOpts.ctx,
-                ...nextOpts.ctx
-              } : callOpts.ctx,
-              input: nextOpts && 'input' in nextOpts ? nextOpts.input : callOpts.input
-            });
-          }
-        });
-        return result;
-      } catch (cause) {
-        return {
-          ok: false,
-          error: TRPCError.getErrorFromUnknown(cause),
-          marker: middlewareMarker
-        };
-      }
-    }; // there's always at least one "next" since we wrap this.resolver in a middleware
-
-
-    const result = await callRecursive();
-
-    if (!result) {
-      throw new TRPCError.TRPCError({
-        code: 'INTERNAL_SERVER_ERROR',
-        message: 'No result from middlewares - did you forget to `return next()`?'
-      });
-    }
-
-    if (!result.ok) {
-      // re-throw original error
-      throw result.error;
-    }
-
-    return result.data;
-  };
-
-  procedure._def = _def;
-  procedure.meta = _def.meta;
-  return procedure;
-}
-
-/**
- * Create an object without inheriting anything from `Object.prototype`
- * @internal
- */
-function omitPrototype(obj1) {
-  return Object.assign(Object.create(null), obj1);
-}
-
-const procedureTypes = ['query', 'mutation', 'subscription'];
-/**
- * @public
- */
-
-/* eslint-disable @typescript-eslint/ban-types */
-
-function isRouter(procedureOrRouter) {
-  return 'router' in procedureOrRouter._def;
-}
-
-const emptyRouter = {
-  _ctx: null,
-  _errorShape: null,
-  _meta: null,
-  queries: {},
-  mutations: {},
-  subscriptions: {},
-  errorFormatter: defaultFormatter,
-  transformer: defaultTransformer
-};
-/**
- *
- * @internal
- */
-
-function createRouterFactory(defaults) {
-  return function createRouterInner(opts) {
-    var _defaults$transformer, _defaults$errorFormat;
-
-    const routerProcedures = omitPrototype({});
-
-    function recursiveGetPaths(procedures, path = '') {
-      for (const [key, procedureOrRouter] of Object.entries(procedures !== null && procedures !== void 0 ? procedures : {})) {
-        const newPath = `${path}${key}`;
-
-        if (isRouter(procedureOrRouter)) {
-          recursiveGetPaths(procedureOrRouter._def.procedures, `${newPath}.`);
-          continue;
-        }
-
-        routerProcedures[newPath] = procedureOrRouter;
-      }
-    }
-
-    recursiveGetPaths(opts);
-    const result = mergeWithoutOverrides({
-      transformer: (_defaults$transformer = defaults === null || defaults === void 0 ? void 0 : defaults.transformer) !== null && _defaults$transformer !== void 0 ? _defaults$transformer : defaultTransformer,
-      errorFormatter: (_defaults$errorFormat = defaults === null || defaults === void 0 ? void 0 : defaults.errorFormatter) !== null && _defaults$errorFormat !== void 0 ? _defaults$errorFormat : defaultFormatter
-    }, {
-      procedures: routerProcedures
-    });
-    const _def = {
-      router: true,
-      procedures: {},
-      ...emptyRouter,
-      ...result,
-      record: opts,
-      queries: Object.entries(result.procedures || {}).filter(pair => pair[1]._def.query).reduce((acc, [key, val]) => ({ ...acc,
-        [key]: val
-      }), {}),
-      mutations: Object.entries(result.procedures || {}).filter(pair => pair[1]._def.mutation).reduce((acc, [key, val]) => ({ ...acc,
-        [key]: val
-      }), {}),
-      subscriptions: Object.entries(result.procedures || {}).filter(pair => pair[1]._def.subscription).reduce((acc, [key, val]) => ({ ...acc,
-        [key]: val
-      }), {}),
-      routers: Object.entries(result.procedures || {}).filter(pair => pair[1]._def._router).reduce((acc, [key, val]) => ({ ...acc,
-        [key]: val
-      }), {})
-    };
-    const router = { ...opts,
-      _def,
-      transformer: _def.transformer,
-      errorFormatter: _def.errorFormatter,
-
-      createCaller(ctx) {
-        const proxy = index.createProxy(({
-          path,
-          args
-        }) => {
-          // interop mode
-          if (path.length === 1 && procedureTypes.includes(path[0])) {
-            return callProcedure({
-              procedures: _def.procedures,
-              path: args[0],
-              rawInput: args[1],
-              ctx,
-              type: path[0]
-            });
-          }
-
-          const fullPath = path.join('.');
-          const procedure = _def.procedures[fullPath];
-          let type = 'query';
-
-          if (procedure._def.mutation) {
-            type = 'mutation';
-          } else if (procedure._def.subscription) {
-            type = 'subscription';
-          }
-
-          return procedure({
-            path: fullPath,
-            rawInput: args[0],
-            ctx,
-            type
-          });
-        });
-        return proxy;
-      },
-
-      getErrorShape(opts) {
-        const {
-          path,
-          error
-        } = opts;
-        const {
-          code
-        } = opts.error;
-        const shape = {
-          message: error.message,
-          code: envelopes.TRPC_ERROR_CODES_BY_KEY[code],
-          data: {
-            code,
-            httpStatus: resolveHTTPResponse.getHTTPStatusCodeFromError(error)
-          }
-        };
-
-        if (process.env.NODE_ENV !== 'production' && typeof opts.error.stack === 'string') {
-          shape.data.stack = opts.error.stack;
-        }
-
-        if (typeof path === 'string') {
-          shape.data.path = path;
-        }
-
-        return this._def.errorFormatter({ ...opts,
-          shape
-        });
-      }
-
-    };
-    return router;
-  };
-}
-/**
- * @internal
- */
-
-function callProcedure(opts) {
-  var _opts$procedures$path;
-
-  const {
-    type,
-    path
-  } = opts;
-
-  if (!(path in opts.procedures) || !((_opts$procedures$path = opts.procedures[path]) !== null && _opts$procedures$path !== void 0 && _opts$procedures$path._def[type])) {
-    throw new TRPCError.TRPCError({
-      code: 'NOT_FOUND',
-      message: `No "${type}"-procedure on path "${path}"`
-    });
-  }
-
-  const procedure = opts.procedures[path];
-  return procedure(opts);
-}
-
-function migrateProcedure(oldProc, type) {
-  const def = oldProc._def();
-
-  const inputParser = getParseFnOrPassThrough(def.inputParser);
-  const outputParser = getParseFnOrPassThrough(def.outputParser);
-  const inputMiddleware = createInputMiddleware(inputParser);
-  const builder = createBuilder({
-    input: def.inputParser,
-    middlewares: [...def.middlewares, inputMiddleware, createOutputMiddleware(outputParser)],
-    meta: def.meta,
-    output: def.outputParser,
-    mutation: type === 'mutation',
-    query: type === 'query',
-    subscription: type === 'subscription'
-  });
-  const proc = builder[type](opts => def.resolver(opts));
-  return proc;
-}
-
-function migrateRouter(oldRouter) {
-  const errorFormatter = oldRouter._def.errorFormatter;
-  const transformer = oldRouter._def.transformer;
-  const queries = {};
-  const mutations = {};
-  const subscriptions = {};
-
-  for (const [name, procedure] of Object.entries(oldRouter._def.queries)) {
-    queries[name] = migrateProcedure(procedure, 'query');
-  }
-
-  for (const [name, procedure] of Object.entries(oldRouter._def.mutations)) {
-    mutations[name] = migrateProcedure(procedure, 'mutation');
-  }
-
-  for (const [name, procedure] of Object.entries(oldRouter._def.subscriptions)) {
-    subscriptions[name] = migrateProcedure(procedure, 'subscription');
-  }
-
-  const procedures = mergeWithoutOverrides(queries, mutations, subscriptions);
-  const newRouter = createRouterFactory({
-    transformer,
-    errorFormatter
-  })(procedures);
-  return newRouter;
-}
-
-/* eslint-disable @typescript-eslint/ban-types */
-resolveHTTPResponse.assertNotBrowser();
-
-function getDataTransformer(transformer) {
-  if ('input' in transformer) {
-    return transformer;
-  }
-
-  return {
-    input: transformer,
-    output: transformer
-  };
-}
-/**
- * @internal
- * @deprecated
- */
-
-
-const PROCEDURE_DEFINITION_MAP = {
-  query: 'queries',
-  mutation: 'mutations',
-  subscription: 'subscriptions'
-};
-/**
- * @internal
- * @deprecated
- */
-
-function safeObject(...args) {
-  return Object.assign(Object.create(null), ...args);
-}
-
-/**
- * @internal The type signature of this class may change without warning.
- * @deprecated
- */
-class Router {
-  constructor(def) {
-    var _def$queries, _def$mutations, _def$subscriptions, _def$middlewares, _def$errorFormatter, _def$transformer;
-
-    this._def = void 0;
-    this._def = {
-      queries: (_def$queries = def === null || def === void 0 ? void 0 : def.queries) !== null && _def$queries !== void 0 ? _def$queries : safeObject(),
-      mutations: (_def$mutations = def === null || def === void 0 ? void 0 : def.mutations) !== null && _def$mutations !== void 0 ? _def$mutations : safeObject(),
-      subscriptions: (_def$subscriptions = def === null || def === void 0 ? void 0 : def.subscriptions) !== null && _def$subscriptions !== void 0 ? _def$subscriptions : safeObject(),
-      middlewares: (_def$middlewares = def === null || def === void 0 ? void 0 : def.middlewares) !== null && _def$middlewares !== void 0 ? _def$middlewares : [],
-      errorFormatter: (_def$errorFormatter = def === null || def === void 0 ? void 0 : def.errorFormatter) !== null && _def$errorFormatter !== void 0 ? _def$errorFormatter : defaultFormatter,
-      transformer: (_def$transformer = def === null || def === void 0 ? void 0 : def.transformer) !== null && _def$transformer !== void 0 ? _def$transformer : defaultTransformer
-    };
-  }
-
-  static prefixProcedures(procedures, prefix) {
-    const eps = safeObject();
-
-    for (const [key, procedure] of Object.entries(procedures)) {
-      eps[prefix + key] = procedure;
-    }
-
-    return eps;
-  }
-
-  query(path, procedure) {
-    const router = new Router({
-      queries: safeObject({
-        [path]: createProcedure(procedure)
-      })
-    });
-    return this.merge(router);
-  }
-
-  mutation(path, procedure) {
-    const router = new Router({
-      mutations: safeObject({
-        [path]: createProcedure(procedure)
-      })
-    });
-    return this.merge(router);
-  }
-  /**
-   * @beta Might change without a major version bump
-   */
-
-
-  subscription(path, procedure) {
-    const router = new Router({
-      subscriptions: safeObject({
-        [path]: createProcedure(procedure)
-      })
-    });
-    return this.merge(router);
-  }
-  /**
-   * Merge router with other router
-   * @param router
-   */
-
-
-  merge(prefixOrRouter, maybeRouter) {
-    let prefix = '';
-    let childRouter;
-
-    if (typeof prefixOrRouter === 'string' && maybeRouter instanceof Router) {
-      prefix = prefixOrRouter;
-      childRouter = maybeRouter;
-    } else if (prefixOrRouter instanceof Router) {
-      childRouter = prefixOrRouter;
-    }
-    /* istanbul ignore next */
-    else {
-      throw new Error('Invalid args');
-    }
-
-    const duplicateQueries = Object.keys(childRouter._def.queries).filter(key => !!this._def['queries'][prefix + key]);
-    const duplicateMutations = Object.keys(childRouter._def.mutations).filter(key => !!this._def['mutations'][prefix + key]);
-    const duplicateSubscriptions = Object.keys(childRouter._def.subscriptions).filter(key => !!this._def['subscriptions'][prefix + key]);
-    const duplicates = [...duplicateQueries, ...duplicateMutations, ...duplicateSubscriptions];
-
-    if (duplicates.length) {
-      throw new Error(`Duplicate endpoint(s): ${duplicates.join(', ')}`);
-    }
-
-    const mergeProcedures = defs => {
-      const newDefs = safeObject();
-
-      for (const [key, procedure] of Object.entries(defs)) {
-        const newProcedure = procedure.inheritMiddlewares(this._def.middlewares);
-        newDefs[key] = newProcedure;
-      }
-
-      return Router.prefixProcedures(newDefs, prefix);
-    };
-
-    return new Router({ ...this._def,
-      queries: safeObject(this._def.queries, mergeProcedures(childRouter._def.queries)),
-      mutations: safeObject(this._def.mutations, mergeProcedures(childRouter._def.mutations)),
-      subscriptions: safeObject(this._def.subscriptions, mergeProcedures(childRouter._def.subscriptions))
-    });
-  }
-  /**
-   * Invoke procedure. Only for internal use within library.
-   */
-
-
-  async call(opts) {
-    const {
-      type,
-      path
-    } = opts;
-    const defTarget = PROCEDURE_DEFINITION_MAP[type];
-    const defs = this._def[defTarget];
-    const procedure = defs[path];
-
-    if (!procedure) {
-      throw new TRPCError.TRPCError({
-        code: 'NOT_FOUND',
-        message: `No "${type}"-procedure on path "${path}"`
-      });
-    }
-
-    return procedure.call(opts);
-  }
-
-  createCaller(ctx) {
-    return {
-      query: (path, ...args) => {
-        return this.call({
-          type: 'query',
-          ctx,
-          path,
-          rawInput: args[0]
-        });
-      },
-      mutation: (path, ...args) => {
-        return this.call({
-          type: 'mutation',
-          ctx,
-          path,
-          rawInput: args[0]
-        });
-      },
-      subscription: (path, ...args) => {
-        return this.call({
-          type: 'subscription',
-          ctx,
-          path,
-          rawInput: args[0]
-        });
-      }
-    };
-  }
-  /**
-   * Function to be called before any procedure is invoked
-   * @link https://trpc.io/docs/middlewares
-   */
-
-
-  middleware(middleware) {
-    return new Router({ ...this._def,
-      middlewares: [...this._def.middlewares, middleware]
-    });
-  }
-  /**
-   * Format errors
-   * @link https://trpc.io/docs/error-formatting
-   */
-
-
-  formatError(errorFormatter) {
-    if (this._def.errorFormatter !== defaultFormatter) {
-      throw new Error('You seem to have double `formatError()`-calls in your router tree');
-    }
-
-    return new Router({ ...this._def,
-      errorFormatter: errorFormatter
-    });
-  }
-
-  getErrorShape(opts) {
-    const {
-      path,
-      error
-    } = opts;
-    const {
-      code
-    } = opts.error;
-    const shape = {
-      message: error.message,
-      code: envelopes.TRPC_ERROR_CODES_BY_KEY[code],
-      data: {
-        code,
-        httpStatus: resolveHTTPResponse.getHTTPStatusCodeFromError(error)
-      }
-    };
-
-    if (process.env.NODE_ENV !== 'production' && typeof opts.error.stack === 'string') {
-      shape.data.stack = opts.error.stack;
-    }
-
-    if (typeof path === 'string') {
-      shape.data.path = path;
-    }
-
-    return this._def.errorFormatter({ ...opts,
-      shape
-    });
-  }
-  /**
-   * Add data transformer to serialize/deserialize input args + output
-   * @link https://trpc.io/docs/data-transformers
-   */
-
-
-  transformer(_transformer) {
-    const transformer = getDataTransformer(_transformer);
-
-    if (this._def.transformer !== defaultTransformer) {
-      throw new Error('You seem to have double `transformer()`-calls in your router tree');
-    }
-
-    return new Router({ ...this._def,
-      transformer
-    });
-  }
-  /**
-   * Flattens the generics of TQueries/TMutations/TSubscriptions.
-   * ⚠️ Experimental - might disappear. ⚠️
-   *
-   * @alpha
-   */
-
-
-  flat() {
-    return this;
-  }
-  /**
-   * Interop mode for v9.x -> v10.x
-   */
-
-
-  interop() {
-    return migrateRouter(this);
-  }
-
-}
-/**
- * @deprecated
- */
-
-function router() {
-  return new Router();
-}
+require('./envelopes-2ae27c9f.js');
+require('./index-1a25ccbd.js');
 
 function mergeRouters(...routerList) {
-  const record = mergeWithoutOverrides({}, ...routerList.map(r => r._def.record));
+  const record = router.mergeWithoutOverrides({}, ...routerList.map(r => r._def.record));
   const errorFormatter = routerList.reduce((currentErrorFormatter, nextRouter) => {
-    if (nextRouter.errorFormatter && nextRouter.errorFormatter !== defaultFormatter) {
-      if (currentErrorFormatter !== defaultFormatter && currentErrorFormatter !== nextRouter.errorFormatter) {
+    if (nextRouter.errorFormatter && nextRouter.errorFormatter !== router.defaultFormatter) {
+      if (currentErrorFormatter !== router.defaultFormatter && currentErrorFormatter !== nextRouter.errorFormatter) {
         throw new Error('You seem to have several error formatters');
       }
 
@@ -1112,10 +21,10 @@ function mergeRouters(...routerList) {
     }
 
     return currentErrorFormatter;
-  }, defaultFormatter);
+  }, router.defaultFormatter);
   const transformer = routerList.reduce((prev, current) => {
-    if (current.transformer && current.transformer !== defaultTransformer) {
-      if (prev !== defaultTransformer && prev !== current.transformer) {
+    if (current.transformer && current.transformer !== router.defaultTransformer) {
+      if (prev !== router.defaultTransformer && prev !== current.transformer) {
         throw new Error('You seem to have several transformers');
       }
 
@@ -1123,12 +32,12 @@ function mergeRouters(...routerList) {
     }
 
     return prev;
-  }, defaultTransformer);
-  const router = createRouterFactory({
+  }, router.defaultTransformer);
+  const router$1 = router.createRouterFactory({
     errorFormatter,
     transformer
   })(record);
-  return router;
+  return router$1;
 }
 
 function mergeRoutersGeneric(...args) {
@@ -1165,13 +74,12 @@ function createMiddlewareFactory() {
   };
 }
 
-/* eslint-disable @typescript-eslint/ban-types */
 function initTRPC() {
   return function initTRPCInner(options) {
     var _options$errorFormatt, _options$transformer;
 
-    const errorFormatter = (_options$errorFormatt = options === null || options === void 0 ? void 0 : options.errorFormatter) !== null && _options$errorFormatt !== void 0 ? _options$errorFormatt : defaultFormatter;
-    const transformer = getDataTransformer$1((_options$transformer = options === null || options === void 0 ? void 0 : options.transformer) !== null && _options$transformer !== void 0 ? _options$transformer : defaultTransformer);
+    const errorFormatter = (_options$errorFormatt = options === null || options === void 0 ? void 0 : options.errorFormatter) !== null && _options$errorFormatt !== void 0 ? _options$errorFormatt : router.defaultFormatter;
+    const transformer = router.getDataTransformer((_options$transformer = options === null || options === void 0 ? void 0 : options.transformer) !== null && _options$transformer !== void 0 ? _options$transformer : router.defaultTransformer);
     const _config = {
       transformer,
       errorShape: null,
@@ -1188,7 +96,7 @@ function initTRPC() {
       /**
        * Builder object for creating procedures
        */
-      procedure: createBuilder(),
+      procedure: router.createBuilder(),
 
       /**
        * Create reusable middlewares
@@ -1198,7 +106,7 @@ function initTRPC() {
       /**
        * Create a router
        */
-      router: createRouterFactory({
+      router: router.createRouterFactory({
         errorFormatter,
         transformer
       }),
@@ -1213,10 +121,10 @@ function initTRPC() {
 
 exports.assertNotBrowser = resolveHTTPResponse.assertNotBrowser;
 exports.resolveHTTPResponse = resolveHTTPResponse.resolveHTTPResponse;
+exports.callProcedure = router.callProcedure;
+exports.defaultTransformer = router.defaultTransformer;
+exports.getDataTransformer = router.getDataTransformer;
+exports.procedureTypes = router.procedureTypes;
+exports.router = router.router;
 exports.TRPCError = TRPCError.TRPCError;
-exports.callProcedure = callProcedure;
-exports.defaultTransformer = defaultTransformer;
-exports.getDataTransformer = getDataTransformer$1;
 exports.initTRPC = initTRPC;
-exports.procedureTypes = procedureTypes;
-exports.router = router;