@trpc/server 11.0.0-alpha-tmp-export-from-main.221 → 11.0.0-alpha-tmp-export-from-main.222

package/dist/unstableDontImportMe.js

@@ -1,142 +1,1549 @@
-'use strict';
-
-var core = require('@trpc/core');
-
-
-
-Object.defineProperty(exports, "TRPCError", {
-  enumerable: true,
-  get: function () { return core.TRPCError; }
-});
-Object.defineProperty(exports, "TRPC_ERROR_CODES_BY_KEY", {
-  enumerable: true,
-  get: function () { return core.TRPC_ERROR_CODES_BY_KEY; }
-});
-Object.defineProperty(exports, "TRPC_ERROR_CODES_BY_NUMBER", {
-  enumerable: true,
-  get: function () { return core.TRPC_ERROR_CODES_BY_NUMBER; }
-});
-Object.defineProperty(exports, "callProcedure", {
-  enumerable: true,
-  get: function () { return core.callProcedure; }
-});
-Object.defineProperty(exports, "createBuilder", {
-  enumerable: true,
-  get: function () { return core.createBuilder; }
-});
-Object.defineProperty(exports, "createFlatProxy", {
-  enumerable: true,
-  get: function () { return core.createFlatProxy; }
-});
-Object.defineProperty(exports, "createInputMiddleware", {
-  enumerable: true,
-  get: function () { return core.createInputMiddleware; }
-});
-Object.defineProperty(exports, "createOutputMiddleware", {
-  enumerable: true,
-  get: function () { return core.createOutputMiddleware; }
-});
-Object.defineProperty(exports, "createRecursiveProxy", {
-  enumerable: true,
-  get: function () { return core.createRecursiveProxy; }
-});
-Object.defineProperty(exports, "createRouterFactory", {
-  enumerable: true,
-  get: function () { return core.createRouterFactory; }
-});
-Object.defineProperty(exports, "experimental_standaloneMiddleware", {
-  enumerable: true,
-  get: function () { return core.experimental_standaloneMiddleware; }
-});
-Object.defineProperty(exports, "getBatchStreamFormatter", {
-  enumerable: true,
-  get: function () { return core.getBatchStreamFormatter; }
-});
-Object.defineProperty(exports, "getCauseFromUnknown", {
-  enumerable: true,
-  get: function () { return core.getCauseFromUnknown; }
-});
-Object.defineProperty(exports, "getErrorShape", {
-  enumerable: true,
-  get: function () { return core.getErrorShape; }
-});
-Object.defineProperty(exports, "getHTTPStatusCode", {
-  enumerable: true,
-  get: function () { return core.getHTTPStatusCode; }
-});
-Object.defineProperty(exports, "getHTTPStatusCodeFromError", {
-  enumerable: true,
-  get: function () { return core.getHTTPStatusCodeFromError; }
-});
-Object.defineProperty(exports, "getJsonContentTypeInputs", {
-  enumerable: true,
-  get: function () { return core.getJsonContentTypeInputs; }
-});
-Object.defineProperty(exports, "getTRPCErrorFromUnknown", {
-  enumerable: true,
-  get: function () { return core.getTRPCErrorFromUnknown; }
-});
-Object.defineProperty(exports, "initTRPC", {
-  enumerable: true,
-  get: function () { return core.initTRPC; }
-});
-Object.defineProperty(exports, "isObject", {
-  enumerable: true,
-  get: function () { return core.isObject; }
-});
-Object.defineProperty(exports, "isObservable", {
-  enumerable: true,
-  get: function () { return core.isObservable; }
-});
-Object.defineProperty(exports, "map", {
-  enumerable: true,
-  get: function () { return core.map; }
-});
-Object.defineProperty(exports, "mergeRouters", {
-  enumerable: true,
-  get: function () { return core.mergeRouters; }
-});
-Object.defineProperty(exports, "middlewareMarker", {
-  enumerable: true,
-  get: function () { return core.middlewareMarker; }
-});
-Object.defineProperty(exports, "observable", {
-  enumerable: true,
-  get: function () { return core.observable; }
-});
-Object.defineProperty(exports, "observableToPromise", {
-  enumerable: true,
-  get: function () { return core.observableToPromise; }
-});
-Object.defineProperty(exports, "parseTRPCMessage", {
-  enumerable: true,
-  get: function () { return core.parseTRPCMessage; }
-});
-Object.defineProperty(exports, "procedureTypes", {
-  enumerable: true,
-  get: function () { return core.procedureTypes; }
-});
-Object.defineProperty(exports, "resolveHTTPResponse", {
-  enumerable: true,
-  get: function () { return core.resolveHTTPResponse; }
-});
-Object.defineProperty(exports, "share", {
-  enumerable: true,
-  get: function () { return core.share; }
-});
-Object.defineProperty(exports, "tap", {
-  enumerable: true,
-  get: function () { return core.tap; }
-});
-Object.defineProperty(exports, "transformResult", {
-  enumerable: true,
-  get: function () { return core.transformResult; }
-});
-Object.defineProperty(exports, "transformTRPCResponse", {
-  enumerable: true,
-  get: function () { return core.transformTRPCResponse; }
-});
-Object.defineProperty(exports, "unsetMarker", {
-  enumerable: true,
-  get: function () { return core.unsetMarker; }
-});
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * @internal
+ */ function invert(obj) {
+    const newObj = Object.create(null);
+    for(const key in obj){
+        const v = obj[key];
+        newObj[v] = key;
+    }
+    return newObj;
+}
+/**
+ * Ensures there are no duplicate keys when building a procedure.
+ * @internal
+ */ 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;
+}
+/**
+ * Check that value is object
+ * @internal
+ */ function isObject(value) {
+    return !!value && !Array.isArray(value) && typeof value === 'object';
+}
+/**
+ * Create an object without inheriting anything from `Object.prototype`
+ * @internal
+ */ function omitPrototype(obj) {
+    return Object.assign(Object.create(null), obj);
+}
+/**
+ * @internal
+ */ function identity(x) {
+    return x;
+}
+
+// reference: https://www.jsonrpc.org/specification
+/**
+ * JSON-RPC 2.0 Error codes
+ *
+ * `-32000` to `-32099` are reserved for implementation-defined server-errors.
+ * For tRPC we're copying the last digits of HTTP 4XX errors.
+ */ const TRPC_ERROR_CODES_BY_KEY = {
+    /**
+   * Invalid JSON was received by the server.
+   * An error occurred on the server while parsing the JSON text.
+   */ PARSE_ERROR: -32700,
+    /**
+   * The JSON sent is not a valid Request object.
+   */ BAD_REQUEST: -32600,
+    // Internal JSON-RPC error
+    INTERNAL_SERVER_ERROR: -32603,
+    NOT_IMPLEMENTED: -32603,
+    // Implementation specific errors
+    UNAUTHORIZED: -32001,
+    FORBIDDEN: -32003,
+    NOT_FOUND: -32004,
+    METHOD_NOT_SUPPORTED: -32005,
+    TIMEOUT: -32008,
+    CONFLICT: -32009,
+    PRECONDITION_FAILED: -32012,
+    PAYLOAD_TOO_LARGE: -32013,
+    UNPROCESSABLE_CONTENT: -32022,
+    TOO_MANY_REQUESTS: -32029,
+    CLIENT_CLOSED_REQUEST: -32099
+};
+const TRPC_ERROR_CODES_BY_NUMBER = invert(TRPC_ERROR_CODES_BY_KEY);
+
+const procedureTypes = [
+    'query',
+    'mutation',
+    'subscription'
+];
+
+/* istanbul ignore next -- @preserve */ function assertIsObject(obj) {
+    if (!isObject(obj)) {
+        throw new Error('Not an object');
+    }
+}
+/* istanbul ignore next -- @preserve */ function assertIsProcedureType(obj) {
+    if (!procedureTypes.includes(obj)) {
+        throw new Error('Invalid procedure type');
+    }
+}
+/* istanbul ignore next -- @preserve */ function assertIsRequestId(obj) {
+    if (obj !== null && typeof obj === 'number' && isNaN(obj) && typeof obj !== 'string') {
+        throw new Error('Invalid request id');
+    }
+}
+/* istanbul ignore next -- @preserve */ function assertIsString(obj) {
+    if (typeof obj !== 'string') {
+        throw new Error('Invalid string');
+    }
+}
+/* istanbul ignore next -- @preserve */ function assertIsJSONRPC2OrUndefined(obj) {
+    if (typeof obj !== 'undefined' && obj !== '2.0') {
+        throw new Error('Must be JSONRPC 2.0');
+    }
+}
+/** @public */ function parseTRPCMessage(obj, transformer) {
+    assertIsObject(obj);
+    const { id, jsonrpc, method, params } = obj;
+    assertIsRequestId(id);
+    assertIsJSONRPC2OrUndefined(jsonrpc);
+    if (method === 'subscription.stop') {
+        return {
+            id,
+            jsonrpc,
+            method
+        };
+    }
+    assertIsProcedureType(method);
+    assertIsObject(params);
+    const { input: rawInput, path } = params;
+    assertIsString(path);
+    const input = transformer.input.deserialize(rawInput);
+    return {
+        id,
+        jsonrpc,
+        method,
+        params: {
+            input,
+            path
+        }
+    };
+}
+
+const JSONRPC2_TO_HTTP_CODE = {
+    PARSE_ERROR: 400,
+    BAD_REQUEST: 400,
+    UNAUTHORIZED: 401,
+    NOT_FOUND: 404,
+    FORBIDDEN: 403,
+    METHOD_NOT_SUPPORTED: 405,
+    TIMEOUT: 408,
+    CONFLICT: 409,
+    PRECONDITION_FAILED: 412,
+    PAYLOAD_TOO_LARGE: 413,
+    UNPROCESSABLE_CONTENT: 422,
+    TOO_MANY_REQUESTS: 429,
+    CLIENT_CLOSED_REQUEST: 499,
+    INTERNAL_SERVER_ERROR: 500,
+    NOT_IMPLEMENTED: 501
+};
+function getStatusCodeFromKey(code) {
+    return JSONRPC2_TO_HTTP_CODE[code] ?? 500;
+}
+function getHTTPStatusCode(json) {
+    const arr = Array.isArray(json) ? json : [
+        json
+    ];
+    const httpStatuses = new Set(arr.map((res)=>{
+        if ('error' in res) {
+            const data = res.error.data;
+            if (typeof data['httpStatus'] === 'number') {
+                return data['httpStatus'];
+            }
+            const code = TRPC_ERROR_CODES_BY_NUMBER[res.error.code];
+            return getStatusCodeFromKey(code);
+        }
+        return 200;
+    }));
+    if (httpStatuses.size !== 1) {
+        return 207;
+    }
+    const httpStatus = httpStatuses.values().next().value;
+    return httpStatus;
+}
+function getHTTPStatusCodeFromError(error) {
+    return getStatusCodeFromKey(error.code);
+}
+
+/**
+ * @internal
+ */ 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({
+        ...opts,
+        shape
+    });
+}
+
+class UnknownCauseError extends Error {
+}
+function getCauseFromUnknown(cause) {
+    if (cause instanceof Error) {
+        return cause;
+    }
+    const type = typeof cause;
+    if (type === 'undefined' || type === 'function' || cause === null) {
+        return undefined;
+    }
+    // Primitive types just get wrapped in an error
+    if (type !== 'object') {
+        return new Error(String(cause));
+    }
+    // If it's an object, we'll create a synthetic error
+    if (isObject(cause)) {
+        const err = new UnknownCauseError();
+        for(const key in cause){
+            err[key] = cause[key];
+        }
+        return err;
+    }
+    return undefined;
+}
+function getTRPCErrorFromUnknown(cause) {
+    if (cause instanceof TRPCError) {
+        return cause;
+    }
+    if (cause instanceof Error && cause.name === 'TRPCError') {
+        // https://github.com/trpc/trpc/pull/4848
+        return cause;
+    }
+    const trpcError = new TRPCError({
+        code: 'INTERNAL_SERVER_ERROR',
+        cause
+    });
+    // Inherit stack from error
+    if (cause instanceof Error && cause.stack) {
+        trpcError.stack = cause.stack;
+    }
+    return trpcError;
+}
+class TRPCError extends Error {
+    constructor(opts){
+        const cause = getCauseFromUnknown(opts.cause);
+        const message = opts.message ?? cause?.message ?? opts.code;
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore https://github.com/tc39/proposal-error-cause
+        super(message, {
+            cause
+        });
+        this.code = opts.code;
+        this.name = 'TRPCError';
+        if (!this.cause) {
+            // < ES2022 / < Node 16.9.0 compatability
+            this.cause = cause;
+        }
+    }
+}
+
+const noop = ()=>{
+// noop
+};
+function createInnerProxy(callback, path) {
+    const proxy = new Proxy(noop, {
+        get (_obj, key) {
+            if (typeof key !== 'string' || key === 'then') {
+                // special case for if the proxy is accidentally treated
+                // like a PromiseLike (like in `Promise.resolve(proxy)`)
+                return undefined;
+            }
+            return createInnerProxy(callback, [
+                ...path,
+                key
+            ]);
+        },
+        apply (_1, _2, args) {
+            const isApply = path[path.length - 1] === 'apply';
+            return callback({
+                args: isApply ? args.length >= 2 ? args[1] : [] : args,
+                path: isApply ? path.slice(0, -1) : path
+            });
+        }
+    });
+    return proxy;
+}
+/**
+ * Creates a proxy that calls the callback with the path and arguments
+ *
+ * @internal
+ */ const createRecursiveProxy = (callback)=>createInnerProxy(callback, []);
+/**
+ * Used in place of `new Proxy` where each handler will map 1 level deep to another value.
+ *
+ * @internal
+ */ const createFlatProxy = (callback)=>{
+    return new Proxy(noop, {
+        get (_obj, name) {
+            if (typeof name !== 'string' || name === 'then') {
+                // special case for if the proxy is accidentally treated
+                // like a PromiseLike (like in `Promise.resolve(proxy)`)
+                return undefined;
+            }
+            return callback(name);
+        }
+    });
+};
+
+const defaultFormatter = ({ shape })=>{
+    return shape;
+};
+
+/** @internal */ const middlewareMarker = 'middlewareMarker';
+/**
+ * @internal
+ */ 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;
+}
+/**
+ * Create a standalone middleware
+ * @link https://trpc.io/docs/v11/server/middlewares#experimental-standalone-middlewares
+ */ const experimental_standaloneMiddleware = ()=>({
+        create: createMiddlewareFactory()
+    });
+/**
+ * @internal
+ * Please note, `trpc-openapi` uses this function.
+ */ 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
+            });
+        }
+        // Multiple input parsers
+        const combinedInput = isObject(opts.input) && isObject(parsedInput) ? {
+            ...opts.input,
+            ...parsedInput
+        } : parsedInput;
+        return opts.next({
+            input: combinedInput
+        });
+    };
+    inputMiddleware._type = 'input';
+    return inputMiddleware;
+}
+/**
+ * @internal
+ */ function createOutputMiddleware(parse) {
+    const outputMiddleware = async function outputValidatorMiddleware({ 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({
+                message: 'Output validation failed',
+                code: 'INTERNAL_SERVER_ERROR',
+                cause
+            });
+        }
+    };
+    outputMiddleware._type = 'output';
+    return outputMiddleware;
+}
+
+// zod / @decs/typeschema
+function getParseFn(procedureParser) {
+    const parser = procedureParser;
+    if (typeof parser === 'function') {
+        // ParserCustomValidatorEsque
+        return parser;
+    }
+    if (typeof parser.parseAsync === 'function') {
+        // ParserZodEsque
+        return parser.parseAsync.bind(parser);
+    }
+    if (typeof parser.parse === 'function') {
+        // ParserZodEsque
+        // ParserValibotEsque (<= v0.12.X)
+        return parser.parse.bind(parser);
+    }
+    if (typeof parser.validateSync === 'function') {
+        // ParserYupEsque
+        return parser.validateSync.bind(parser);
+    }
+    if (typeof parser.create === 'function') {
+        // ParserSuperstructEsque
+        return parser.create.bind(parser);
+    }
+    if (typeof parser.assert === 'function') {
+        // ParserScaleEsque
+        return (value)=>{
+            parser.assert(value);
+            return value;
+        };
+    }
+    throw new Error('Could not find a validator fn');
+}
+
+/** @internal */ const unsetMarker = Symbol('unsetMarker');
+function createNewBuilder(def1, def2) {
+    const { middlewares = [], inputs, meta, ...rest } = def2;
+    // TODO: maybe have a fn here to warn about calls
+    return createBuilder({
+        ...mergeWithoutOverrides(def1, rest),
+        inputs: [
+            ...def1.inputs,
+            ...inputs ?? []
+        ],
+        middlewares: [
+            ...def1.middlewares,
+            ...middlewares
+        ],
+        meta: def1.meta && meta ? {
+            ...def1.meta,
+            ...meta
+        } : meta ?? def1.meta
+    });
+}
+function createBuilder(initDef = {}) {
+    const _def = {
+        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) {
+            // Distinguish between a middleware builder and a middleware function
+            const middlewares = '_middlewares' in middlewareBuilderOrFn ? middlewareBuilderOrFn._middlewares : [
+                middlewareBuilderOrFn
+            ];
+            return createNewBuilder(_def, {
+                middlewares: middlewares
+            });
+        },
+        query (resolver) {
+            return createResolver({
+                ..._def,
+                type: 'query'
+            }, resolver);
+        },
+        mutation (resolver) {
+            return createResolver({
+                ..._def,
+                type: 'mutation'
+            }, resolver);
+        },
+        subscription (resolver) {
+            return createResolver({
+                ..._def,
+                type: 'subscription'
+            }, resolver);
+        }
+    };
+    return builder;
+}
+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);
+}
+const 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();
+function createProcedureCaller(_def) {
+    async function procedure(opts) {
+        // is direct server-side call
+        if (!opts || !('getRawInput' in opts)) {
+            throw new Error(codeblock);
+        }
+        // run the middlewares recursively with the resolver as the last one
+        async function callRecursive(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,
+                    getRawInput: callOpts.getRawInput ?? opts.getRawInput,
+                    meta: _def.meta,
+                    input: callOpts.input,
+                    next (_nextOpts) {
+                        const nextOpts = _nextOpts;
+                        return 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,
+                            getRawInput: nextOpts && 'getRawInput' in nextOpts ? nextOpts.getRawInput : callOpts.getRawInput
+                        });
+                    }
+                });
+                return result;
+            } catch (cause) {
+                return {
+                    ok: false,
+                    error: getTRPCErrorFromUnknown(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({
+                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;
+    // FIXME typecast shouldn't be needed - fixittt
+    return procedure;
+}
+
+/**
+ * The default check to see if we're in a server
+ */ const isServerDefault = typeof window === 'undefined' || 'Deno' in window || // eslint-disable-next-line @typescript-eslint/dot-notation
+globalThis.process?.env?.['NODE_ENV'] === 'test' || !!globalThis.process?.env?.['JEST_WORKER_ID'] || !!globalThis.process?.env?.['VITEST_WORKER_ID'];
+
+/**
+ * @internal
+ */ function getDataTransformer(transformer) {
+    if ('input' in transformer) {
+        return transformer;
+    }
+    return {
+        input: transformer,
+        output: transformer
+    };
+}
+/**
+ * @internal
+ */ const defaultTransformer = {
+    _default: true,
+    input: {
+        serialize: (obj)=>obj,
+        deserialize: (obj)=>obj
+    },
+    output: {
+        serialize: (obj)=>obj,
+        deserialize: (obj)=>obj
+    }
+};
+function transformTRPCResponseItem(config, item) {
+    if ('error' in item) {
+        return {
+            ...item,
+            error: config.transformer.output.serialize(item.error)
+        };
+    }
+    if ('data' in item.result) {
+        return {
+            ...item,
+            result: {
+                ...item.result,
+                data: config.transformer.output.serialize(item.result.data)
+            }
+        };
+    }
+    return item;
+}
+/**
+ * Takes a unserialized `TRPCResponse` and serializes it with the router's transformers
+ **/ function transformTRPCResponse(config, itemOrItems) {
+    return Array.isArray(itemOrItems) ? itemOrItems.map((item)=>transformTRPCResponseItem(config, item)) : transformTRPCResponseItem(config, itemOrItems);
+}
+// FIXME:
+// - the generics here are probably unnecessary
+// - the RPC-spec could probably be simplified to combine HTTP + WS
+/** @internal */ function transformResultInner(response, transformer) {
+    if ('error' in response) {
+        const error = transformer.deserialize(response.error);
+        return {
+            ok: false,
+            error: {
+                ...response,
+                error
+            }
+        };
+    }
+    const result = {
+        ...response.result,
+        ...(!response.result.type || response.result.type === 'data') && {
+            type: 'data',
+            data: transformer.deserialize(response.result.data)
+        }
+    };
+    return {
+        ok: true,
+        result
+    };
+}
+class TransformResultError extends Error {
+    constructor(){
+        super('Unable to transform response from server');
+    }
+}
+/**
+ * Transforms and validates that the result is a valid TRPCResponse
+ * @internal
+ */ function transformResult(response, transformer) {
+    let result;
+    try {
+        // Use the data transformers on the JSON-response
+        result = transformResultInner(response, transformer);
+    } catch (err) {
+        throw new TransformResultError();
+    }
+    // check that output of the transformers is a valid TRPCResponse
+    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;
+}
+
+function isRouter(procedureOrRouter) {
+    return 'router' in procedureOrRouter._def;
+}
+const emptyRouter = {
+    _ctx: null,
+    _errorShape: null,
+    _meta: null,
+    queries: {},
+    mutations: {},
+    subscriptions: {},
+    errorFormatter: defaultFormatter,
+    transformer: defaultTransformer
+};
+/**
+ * Reserved words that can't be used as router or procedure names
+ */ const reservedWords = [
+    /**
+   * Then is a reserved word because otherwise we can't return a promise that returns a Proxy
+   * since JS will think that `.then` is something that exists
+   */ 'then'
+];
+/**
+ * @internal
+ */ function createRouterFactory(config) {
+    return function createRouterInner(procedures) {
+        const reservedWordsUsed = new Set(Object.keys(procedures).filter((v)=>reservedWords.includes(v)));
+        if (reservedWordsUsed.size > 0) {
+            throw new Error('Reserved words used in `router({})` call: ' + Array.from(reservedWordsUsed).join(', '));
+        }
+        const routerProcedures = omitPrototype({});
+        function recursiveGetPaths(procedures, path = '') {
+            for (const [key, procedureOrRouter] of Object.entries(procedures ?? {})){
+                const newPath = `${path}${key}`;
+                if (isRouter(procedureOrRouter)) {
+                    recursiveGetPaths(procedureOrRouter._def.procedures, `${newPath}.`);
+                    continue;
+                }
+                if (routerProcedures[newPath]) {
+                    throw new Error(`Duplicate key: ${newPath}`);
+                }
+                routerProcedures[newPath] = procedureOrRouter;
+            }
+        }
+        recursiveGetPaths(procedures);
+        const _def = {
+            _config: config,
+            router: true,
+            procedures: routerProcedures,
+            ...emptyRouter,
+            record: procedures
+        };
+        const router = {
+            ...procedures,
+            _def,
+            createCaller (ctx) {
+                const proxy = createRecursiveProxy(({ path, args })=>{
+                    const fullPath = path.join('.');
+                    const procedure = _def.procedures[fullPath];
+                    return procedure({
+                        path: fullPath,
+                        getRawInput: async ()=>args[0],
+                        ctx,
+                        type: procedure._def.type
+                    });
+                });
+                return proxy;
+            }
+        };
+        return router;
+    };
+}
+function isProcedure(procedureOrRouter) {
+    return !!procedureOrRouter._def.procedure;
+}
+/**
+ * @internal
+ */ function callProcedure(opts) {
+    const { type, path } = opts;
+    const proc = opts.procedures[path];
+    if (!proc || !isProcedure(proc) || proc._def.type !== type) {
+        throw new TRPCError({
+            code: 'NOT_FOUND',
+            message: `No "${type}"-procedure on path "${path}"`
+        });
+    }
+    return proc(opts);
+}
+function createCallerFactory() {
+    return function createCallerInner(router) {
+        const _def = router._def;
+        return function createCaller(maybeContext) {
+            const proxy = createRecursiveProxy(({ path, args })=>{
+                const fullPath = path.join('.');
+                const procedure = _def.procedures[fullPath];
+                const callProc = (ctx)=>procedure({
+                        path: fullPath,
+                        getRawInput: async ()=>args[0],
+                        ctx,
+                        type: procedure._def.type
+                    });
+                if (typeof maybeContext === 'function') {
+                    const context = maybeContext();
+                    if (context instanceof Promise) {
+                        return context.then(callProc);
+                    }
+                    return callProc(context);
+                }
+                return callProc(maybeContext);
+            });
+            return proxy;
+        };
+    };
+}
+function mergeRouters(...routerList) {
+    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.some((r)=>r._def._config.isDev),
+        allowOutsideOfServer: routerList.some((r)=>r._def._config.allowOutsideOfServer),
+        isServer: routerList.some((r)=>r._def._config.isServer),
+        $types: routerList[0]?._def._config.$types
+    })(record);
+    return router;
+}
+
+/**
+ * TODO: This can be improved:
+ * - We should be able to chain `.meta()`/`.context()` only once
+ * - Simplify typings
+ * - Doesn't need to be a class but it doesn't really hurt either
+ */ class TRPCBuilder {
+    /**
+   * Add a context shape as a generic to the root object
+   * @link https://trpc.io/docs/v11/server/context
+   */ context() {
+        return new TRPCBuilder();
+    }
+    /**
+   * Add a meta shape as a generic to the root object
+   * @link https://trpc.io/docs/v11/quickstart
+   */ meta() {
+        return new TRPCBuilder();
+    }
+    /**
+   * Create the root object
+   * @link https://trpc.io/docs/v11/server/routers#initialize-trpc
+   */ create(options) {
+        return createTRPCInner()(options);
+    }
+}
+/**
+ * Builder to initialize the tRPC root object - use this exactly once per backend
+ * @link https://trpc.io/docs/v11/quickstart
+ */ const initTRPC = new TRPCBuilder();
+function createTRPCInner() {
+    return function initTRPCInner(runtime) {
+        const errorFormatter = runtime?.errorFormatter ?? defaultFormatter;
+        const transformer = getDataTransformer(runtime?.transformer ?? defaultTransformer);
+        const config = {
+            transformer,
+            isDev: runtime?.isDev ?? // eslint-disable-next-line @typescript-eslint/dot-notation
+            globalThis.process?.env?.['NODE_ENV'] !== 'production',
+            allowOutsideOfServer: runtime?.allowOutsideOfServer ?? false,
+            errorFormatter,
+            isServer: runtime?.isServer ?? isServerDefault,
+            /**
+       * @internal
+       */ $types: createFlatProxy((key)=>{
+                throw new Error(`Tried to access "$types.${key}" which is not available at runtime`);
+            })
+        };
+        {
+            // Server check
+            const isServer = runtime?.isServer ?? isServerDefault;
+            if (!isServer && runtime?.allowOutsideOfServer !== true) {
+                throw new Error(`You're trying to use @trpc/server in a non-server environment. This is not supported by default.`);
+            }
+        }
+        return {
+            /**
+       * These are just types, they can't be used
+       * @internal
+       */ _config: config,
+            /**
+       * Builder object for creating procedures
+       * @link https://trpc.io/docs/v11/server/procedures
+       */ procedure: createBuilder({
+                meta: runtime?.defaultMeta
+            }),
+            /**
+       * Create reusable middlewares
+       * @link https://trpc.io/docs/v11/server/middlewares
+       */ middleware: createMiddlewareFactory(),
+            /**
+       * Create a router
+       * @link https://trpc.io/docs/v11/server/routers
+       */ router: createRouterFactory(config),
+            /**
+       * Merge Routers
+       * @link https://trpc.io/docs/v11/server/merging-routers
+       */ mergeRouters,
+            /**
+       * Create a server-side caller for a router
+       * @link https://trpc.io/docs/v11/server/server-side-calls
+       */ createCallerFactory: createCallerFactory()
+        };
+    };
+}
+
+/** @public */ function isObservable(x) {
+    return typeof x === 'object' && x !== null && 'subscribe' in x;
+}
+/** @public */ 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) {
+                    if (isDone) {
+                        return;
+                    }
+                    observer.next?.(value);
+                },
+                error (err) {
+                    if (isDone) {
+                        return;
+                    }
+                    isDone = true;
+                    observer.error?.(err);
+                    unsubscribe();
+                },
+                complete () {
+                    if (isDone) {
+                        return;
+                    }
+                    isDone = true;
+                    observer.complete?.();
+                    unsubscribe();
+                }
+            });
+            if (teardownImmediately) {
+                unsubscribe();
+            }
+            return {
+                unsubscribe
+            };
+        },
+        pipe (...operations) {
+            return pipeFromArray(operations)(self);
+        }
+    };
+    return self;
+}
+function pipeFromArray(fns) {
+    if (fns.length === 0) {
+        return identity;
+    }
+    if (fns.length === 1) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return fns[0];
+    }
+    return function piped(input) {
+        return fns.reduce((prev, fn)=>fn(prev), input);
+    };
+}
+class ObservableAbortError extends Error {
+    constructor(message){
+        super(message);
+        this.name = 'ObservableAbortError';
+        Object.setPrototypeOf(this, ObservableAbortError.prototype);
+    }
+}
+/** @internal */ function observableToPromise(observable) {
+    let abort;
+    const promise = new Promise((resolve, reject)=>{
+        let isDone = false;
+        function onDone() {
+            if (isDone) {
+                return;
+            }
+            isDone = true;
+            reject(new ObservableAbortError('This operation was aborted.'));
+            obs$.unsubscribe();
+        }
+        const obs$ = observable.subscribe({
+            next (data) {
+                isDone = true;
+                resolve(data);
+                onDone();
+            },
+            error (data) {
+                isDone = true;
+                reject(data);
+                onDone();
+            },
+            complete () {
+                isDone = true;
+                onDone();
+            }
+        });
+        abort = onDone;
+    });
+    return {
+        promise,
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        abort: abort
+    };
+}
+
+function map(project) {
+    return (originalObserver)=>{
+        return {
+            subscribe (observer) {
+                let index = 0;
+                const subscription = originalObserver.subscribe({
+                    next (value) {
+                        observer.next?.(project(value, index++));
+                    },
+                    error (error) {
+                        observer.error?.(error);
+                    },
+                    complete () {
+                        observer.complete?.();
+                    }
+                });
+                return subscription;
+            }
+        };
+    };
+}
+function share(_opts) {
+    return (originalObserver)=>{
+        let refCount = 0;
+        let subscription = null;
+        const observers = [];
+        function startIfNeeded() {
+            if (subscription) {
+                return;
+            }
+            subscription = originalObserver.subscribe({
+                next (value) {
+                    for (const observer of observers){
+                        observer.next?.(value);
+                    }
+                },
+                error (error) {
+                    for (const observer of observers){
+                        observer.error?.(error);
+                    }
+                },
+                complete () {
+                    for (const observer of observers){
+                        observer.complete?.();
+                    }
+                }
+            });
+        }
+        function resetIfNeeded() {
+            // "resetOnRefCountZero"
+            if (refCount === 0 && subscription) {
+                const _sub = subscription;
+                subscription = null;
+                _sub.unsubscribe();
+            }
+        }
+        return {
+            subscribe (observer) {
+                refCount++;
+                observers.push(observer);
+                startIfNeeded();
+                return {
+                    unsubscribe () {
+                        refCount--;
+                        resetIfNeeded();
+                        const index = observers.findIndex((v)=>v === observer);
+                        if (index > -1) {
+                            observers.splice(index, 1);
+                        }
+                    }
+                };
+            }
+        };
+    };
+}
+function tap(observer) {
+    return (originalObserver)=>{
+        return {
+            subscribe (observer2) {
+                return originalObserver.subscribe({
+                    next (v) {
+                        observer.next?.(v);
+                        observer2.next?.(v);
+                    },
+                    error (v) {
+                        observer.error?.(v);
+                        observer2.error?.(v);
+                    },
+                    complete () {
+                        observer.complete?.();
+                        observer2.complete?.();
+                    }
+                });
+            }
+        };
+    };
+}
+
+function getRawProcedureInputOrThrow(opts) {
+    const { req } = opts;
+    try {
+        if (req.method === 'GET') {
+            if (!req.query.has('input')) {
+                return undefined;
+            }
+            const raw = req.query.get('input');
+            return JSON.parse(raw);
+        }
+        if (!opts.preprocessedBody && typeof req.body === 'string') {
+            // A mutation with no inputs will have req.body === ''
+            return req.body.length === 0 ? undefined : JSON.parse(req.body);
+        }
+        return req.body;
+    } catch (cause) {
+        throw new TRPCError({
+            code: 'PARSE_ERROR',
+            cause
+        });
+    }
+}
+const deserializeInputValue = (rawValue, transformer)=>{
+    return typeof rawValue !== 'undefined' ? transformer.input.deserialize(rawValue) : rawValue;
+};
+const getJsonContentTypeInputs = (opts)=>{
+    const rawInput = getRawProcedureInputOrThrow(opts);
+    const transformer = opts.router._def._config.transformer;
+    if (!opts.isBatchCall) {
+        return {
+            0: deserializeInputValue(rawInput, transformer)
+        };
+    }
+    /* istanbul ignore if  */ if (rawInput == null || typeof rawInput !== 'object' || Array.isArray(rawInput)) {
+        throw new TRPCError({
+            code: 'BAD_REQUEST',
+            message: '"input" needs to be an object when doing a batch call'
+        });
+    }
+    const input = {};
+    for(const key in rawInput){
+        const k = key;
+        const rawValue = rawInput[k];
+        const value = deserializeInputValue(rawValue, transformer);
+        input[k] = value;
+    }
+    return input;
+};
+
+const HTTP_METHOD_PROCEDURE_TYPE_MAP = {
+    GET: 'query',
+    POST: 'mutation'
+};
+const fallbackContentTypeHandler = {
+    getInputs: getJsonContentTypeInputs
+};
+function initResponse(initOpts) {
+    const { ctx, paths, type, responseMeta, untransformedJSON, errors = [] } = initOpts;
+    let status = untransformedJSON ? getHTTPStatusCode(untransformedJSON) : 200;
+    const headers = {
+        'Content-Type': 'application/json'
+    };
+    const eagerGeneration = !untransformedJSON;
+    const data = eagerGeneration ? [] : Array.isArray(untransformedJSON) ? untransformedJSON : [
+        untransformedJSON
+    ];
+    const meta = responseMeta?.({
+        ctx,
+        paths,
+        type,
+        data,
+        errors,
+        eagerGeneration
+    }) ?? {};
+    for (const [key, value] of Object.entries(meta.headers ?? {})){
+        headers[key] = value;
+    }
+    if (meta.status) {
+        status = meta.status;
+    }
+    return {
+        status,
+        headers
+    };
+}
+async function inputToProcedureCall(procedureOpts) {
+    const { opts, ctx, type, input, path } = procedureOpts;
+    try {
+        const data = await callProcedure({
+            procedures: opts.router._def.procedures,
+            path,
+            getRawInput: async ()=>input,
+            ctx,
+            type
+        });
+        return {
+            result: {
+                data
+            }
+        };
+    } catch (cause) {
+        const error = getTRPCErrorFromUnknown(cause);
+        opts.onError?.({
+            error,
+            path,
+            input,
+            ctx,
+            type: type,
+            req: opts.req
+        });
+        return {
+            error: getErrorShape({
+                config: opts.router._def._config,
+                error,
+                type,
+                path,
+                input,
+                ctx
+            })
+        };
+    }
+}
+function caughtErrorToData(cause, errorOpts) {
+    const { router, req, onError } = errorOpts.opts;
+    const error = getTRPCErrorFromUnknown(cause);
+    onError?.({
+        error,
+        path: errorOpts.path,
+        input: errorOpts.input,
+        ctx: errorOpts.ctx,
+        type: errorOpts.type,
+        req
+    });
+    const untransformedJSON = {
+        error: getErrorShape({
+            config: router._def._config,
+            error,
+            type: errorOpts.type,
+            path: errorOpts.path,
+            input: errorOpts.input,
+            ctx: errorOpts.ctx
+        })
+    };
+    const transformedJSON = transformTRPCResponse(router._def._config, untransformedJSON);
+    const body = JSON.stringify(transformedJSON);
+    return {
+        error,
+        untransformedJSON,
+        body
+    };
+}
+// implementation
+async function resolveHTTPResponse(opts) {
+    const { router, req, unstable_onHead, unstable_onChunk } = opts;
+    if (req.method === 'HEAD') {
+        // can be used for lambda warmup
+        const headResponse = {
+            status: 204
+        };
+        unstable_onHead?.(headResponse, false);
+        unstable_onChunk?.([
+            -1,
+            ''
+        ]);
+        return headResponse;
+    }
+    const contentTypeHandler = opts.contentTypeHandler ?? fallbackContentTypeHandler;
+    const batchingEnabled = opts.batching?.enabled ?? true;
+    const type = HTTP_METHOD_PROCEDURE_TYPE_MAP[req.method] ?? 'unknown';
+    let ctx = undefined;
+    let paths;
+    const isBatchCall = !!req.query.get('batch');
+    const isStreamCall = isBatchCall && unstable_onHead && unstable_onChunk && req.headers['trpc-batch-mode'] === 'stream';
+    try {
+        if (opts.error) {
+            throw opts.error;
+        }
+        if (isBatchCall && !batchingEnabled) {
+            throw new Error(`Batching is not enabled on the server`);
+        }
+        /* istanbul ignore if -- @preserve */ if (type === 'subscription') {
+            throw new TRPCError({
+                message: 'Subscriptions should use wsLink',
+                code: 'METHOD_NOT_SUPPORTED'
+            });
+        }
+        if (type === 'unknown') {
+            throw new TRPCError({
+                message: `Unexpected request method ${req.method}`,
+                code: 'METHOD_NOT_SUPPORTED'
+            });
+        }
+        const inputs = await contentTypeHandler.getInputs({
+            isBatchCall,
+            req,
+            router,
+            preprocessedBody: opts.preprocessedBody ?? false
+        });
+        paths = isBatchCall ? decodeURIComponent(opts.path).split(',') : [
+            opts.path
+        ];
+        const info = {
+            isBatchCall,
+            calls: paths.map((path, idx)=>({
+                    path,
+                    type,
+                    input: inputs[idx] ?? undefined
+                }))
+        };
+        ctx = await opts.createContext({
+            info
+        });
+        const promises = paths.map((path, index)=>inputToProcedureCall({
+                opts,
+                ctx,
+                type,
+                input: inputs[index],
+                path
+            }));
+        if (!isStreamCall) {
+            /**
+       * Non-streaming response:
+       * - await all responses in parallel, blocking on the slowest one
+       * - create headers with known response body
+       * - return a complete HTTPResponse
+       */ const untransformedJSON = await Promise.all(promises);
+            const errors = untransformedJSON.flatMap((response)=>'error' in response ? [
+                    response.error
+                ] : []);
+            const headResponse = initResponse({
+                ctx,
+                paths,
+                type,
+                responseMeta: opts.responseMeta,
+                untransformedJSON,
+                errors
+            });
+            unstable_onHead?.(headResponse, false);
+            // return body stuff
+            const result = isBatchCall ? untransformedJSON : untransformedJSON[0]; // eslint-disable-line @typescript-eslint/no-non-null-assertion -- `untransformedJSON` should be the length of `paths` which should be at least 1 otherwise there wouldn't be a request at all
+            const transformedJSON = transformTRPCResponse(router._def._config, result);
+            const body = JSON.stringify(transformedJSON);
+            unstable_onChunk?.([
+                -1,
+                body
+            ]);
+            return {
+                status: headResponse.status,
+                headers: headResponse.headers,
+                body
+            };
+        }
+        /**
+     * Streaming response:
+     * - block on none, call `onChunk` as soon as each response is ready
+     * - create headers with minimal data (cannot know the response body in advance)
+     * - return void
+     */ const headResponse = initResponse({
+            ctx,
+            paths,
+            type,
+            responseMeta: opts.responseMeta
+        });
+        unstable_onHead(headResponse, true);
+        const indexedPromises = new Map(promises.map((promise, index)=>[
+                index,
+                promise.then((r)=>[
+                        index,
+                        r
+                    ])
+            ]));
+        for (const _ of paths){
+            const [index, untransformedJSON] = await Promise.race(indexedPromises.values());
+            indexedPromises.delete(index);
+            try {
+                const transformedJSON = transformTRPCResponse(router._def._config, untransformedJSON);
+                const body = JSON.stringify(transformedJSON);
+                unstable_onChunk([
+                    index,
+                    body
+                ]);
+            } catch (cause) {
+                const path = paths[index];
+                const input = inputs[index];
+                const { body } = caughtErrorToData(cause, {
+                    opts,
+                    ctx,
+                    type,
+                    path,
+                    input
+                });
+                unstable_onChunk([
+                    index,
+                    body
+                ]);
+            }
+        }
+        return;
+    } catch (cause) {
+        // we get here if
+        // - batching is called when it's not enabled
+        // - `createContext()` throws
+        // - `router._def._config.transformer.output.serialize()` throws
+        // - post body is too large
+        // - input deserialization fails
+        // - `errorFormatter` return value is malformed
+        const { error, untransformedJSON, body } = caughtErrorToData(cause, {
+            opts,
+            ctx,
+            type
+        });
+        const headResponse = initResponse({
+            ctx,
+            paths,
+            type,
+            responseMeta: opts.responseMeta,
+            untransformedJSON,
+            errors: [
+                error
+            ]
+        });
+        unstable_onHead?.(headResponse, false);
+        unstable_onChunk?.([
+            -1,
+            body
+        ]);
+        return {
+            status: headResponse.status,
+            headers: headResponse.headers,
+            body
+        };
+    }
+}
+
+/**
+ * Format a batch response as a line-delimited JSON stream
+ * that the `unstable_httpBatchStreamLink` can parse:
+ *
+ * @example
+ * ```ts
+ * const formatter = getBatchStreamFormatter();
+ * res.send(formatter(1, 'response #2'));
+ * res.send(formatter(0, 'response #1'));
+ * res.send(formatter.end());
+ * ```
+ *
+ * Expected format:
+ * ```json
+ * {"1":"response #2"
+ * ,"0":"response #1"
+ * }
+ * ```
+ */ function getBatchStreamFormatter() {
+    let first = true;
+    function format(index, string) {
+        const prefix = first ? '{' : ',';
+        first = false;
+        return `${prefix}"${index}":${string}\n`;
+    }
+    format.end = ()=>'}';
+    return format;
+}
+
+exports.TRPCError = TRPCError;
+exports.TRPC_ERROR_CODES_BY_KEY = TRPC_ERROR_CODES_BY_KEY;
+exports.TRPC_ERROR_CODES_BY_NUMBER = TRPC_ERROR_CODES_BY_NUMBER;
+exports.callProcedure = callProcedure;
+exports.createBuilder = createBuilder;
+exports.createFlatProxy = createFlatProxy;
+exports.createInputMiddleware = createInputMiddleware;
+exports.createOutputMiddleware = createOutputMiddleware;
+exports.createRecursiveProxy = createRecursiveProxy;
+exports.createRouterFactory = createRouterFactory;
+exports.experimental_standaloneMiddleware = experimental_standaloneMiddleware;
+exports.getBatchStreamFormatter = getBatchStreamFormatter;
+exports.getCauseFromUnknown = getCauseFromUnknown;
+exports.getErrorShape = getErrorShape;
+exports.getHTTPStatusCode = getHTTPStatusCode;
+exports.getHTTPStatusCodeFromError = getHTTPStatusCodeFromError;
+exports.getJsonContentTypeInputs = getJsonContentTypeInputs;
+exports.getTRPCErrorFromUnknown = getTRPCErrorFromUnknown;
+exports.initTRPC = initTRPC;
+exports.isObject = isObject;
+exports.isObservable = isObservable;
+exports.map = map;
+exports.mergeRouters = mergeRouters;
+exports.middlewareMarker = middlewareMarker;
+exports.observable = observable;
+exports.observableToPromise = observableToPromise;
+exports.parseTRPCMessage = parseTRPCMessage;
+exports.procedureTypes = procedureTypes;
+exports.resolveHTTPResponse = resolveHTTPResponse;
+exports.share = share;
+exports.tap = tap;
+exports.transformResult = transformResult;
+exports.transformTRPCResponse = transformTRPCResponse;
+exports.unsetMarker = unsetMarker;