@highstate/designer 0.1.0 → 0.2.1

package/.output/server/node_modules/@trpc/server/dist/index.mjs

@@ -1,871 +1,11 @@
-import { c as createRouterFactory, d as defaultFormatter, a as defaultTransformer, g as getDataTransformer$1, i as isServerDefault, b as createCallerFactory } from './config-d5fdbd39.mjs';
-export { e as callProcedure, b as createCallerFactory, a as defaultTransformer, g as getDataTransformer, p as procedureTypes } from './config-d5fdbd39.mjs';
-import { T as TRPCError, g as getTRPCErrorFromUnknown } from './TRPCError-98d44758.mjs';
-export { T as TRPCError, g as getTRPCErrorFromUnknown } from './TRPCError-98d44758.mjs';
-import { g as getHTTPStatusCodeFromError, c as createFlatProxy } from './index-f91d720c.mjs';
-import { T as TRPC_ERROR_CODES_BY_KEY } from './codes-c924c3db.mjs';
-import './getCauseFromUnknown-2d66414a.mjs';
-
-/**
- * @deprecated
- */ const middlewareMarker$1 = 'middlewareMarker';
-
-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 {
-    _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({
-                code: 'BAD_REQUEST',
-                cause
-            });
-        }
-    }
-    async parseOutput(rawOutput) {
-        try {
-            return await this.parseOutputFn(rawOutput);
-        } catch (cause) {
-            throw new TRPCError({
-                code: 'INTERNAL_SERVER_ERROR',
-                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 {
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                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: getTRPCErrorFromUnknown(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({
-                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;
-    }
-    constructor(opts){
-        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;
-    }
-}
-function createProcedure(opts) {
-    const inputParser = 'input' in opts ? opts.input : (input)=>{
-        if (input != null) {
-            throw new 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') {
-        // 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');
-}
-/**
- * @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
- */ 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;
-}
-const experimental_standaloneMiddleware = ()=>({
-        create: createMiddlewareFactory()
-    });
-function isPlainObject(obj) {
-    return obj && typeof obj === 'object' && !Array.isArray(obj);
-}
-/**
- * @internal
- * Please note, `trpc-openapi` uses this function.
- */ function createInputMiddleware(parse) {
-    const inputMiddleware = async ({ next , rawInput , input ,  })=>{
-        let parsedInput;
-        try {
-            parsedInput = await parse(rawInput);
-        } catch (cause) {
-            throw new TRPCError({
-                code: 'BAD_REQUEST',
-                cause
-            });
-        }
-        // Multiple input parsers
-        const combinedInput = isPlainObject(input) && isPlainObject(parsedInput) ? {
-            ...input,
-            ...parsedInput
-        } : parsedInput;
-        // TODO fix this typing?
-        return next({
-            input: combinedInput
-        });
-    };
-    inputMiddleware._type = 'input';
-    return inputMiddleware;
-}
-/**
- * @internal
- */ function createOutputMiddleware(parse) {
-    const outputMiddleware = async ({ 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;
-}
-
-/**
- * @internal
- */ const middlewareMarker = 'middlewareMarker';
-
-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 = {
-        inputs: [],
-        middlewares: [],
-        ...initDef
-    };
-    return {
-        _def,
-        input (input) {
-            const parser = getParseFn(input);
-            return createNewBuilder(_def, {
-                inputs: [
-                    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
-     * This functionality is deprecated and will be removed in the next major version.
-     */ unstable_concat (builder) {
-            return createNewBuilder(_def, builder._def);
-        },
-        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,
-                query: true
-            }, resolver);
-        },
-        mutation (resolver) {
-            return createResolver({
-                ..._def,
-                mutation: true
-            }, resolver);
-        },
-        subscription (resolver) {
-            return createResolver({
-                ..._def,
-                subscription: true
-            }, resolver);
-        }
-    };
-}
-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/server/server-side-calls
-`.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: callOpts.rawInput ?? opts.rawInput,
-                    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,
-                            rawInput: nextOpts && 'rawInput' in nextOpts ? nextOpts.rawInput : callOpts.rawInput
-                        });
-                    }
-                });
-                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;
-    procedure.meta = _def.meta;
-    return procedure;
-}
-
-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({
-        inputs: [
-            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 [name1, procedure1] of Object.entries(oldRouter._def.mutations)){
-        mutations[name1] = migrateProcedure(procedure1, 'mutation');
-    }
-    for (const [name2, procedure2] of Object.entries(oldRouter._def.subscriptions)){
-        subscriptions[name2] = migrateProcedure(procedure2, 'subscription');
-    }
-    const procedures = mergeWithoutOverrides(queries, mutations, subscriptions);
-    const newRouter = createRouterFactory({
-        transformer,
-        errorFormatter,
-        isDev: process.env.NODE_ENV !== 'production'
-    })(procedures);
-    return newRouter;
-}
-
-function getDataTransformer(transformer) {
-    if ('input' in transformer) {
-        return transformer;
-    }
-    return {
-        input: transformer,
-        output: transformer
-    };
-}
-const PROCEDURE_DEFINITION_MAP = {
-    query: 'queries',
-    mutation: 'mutations',
-    subscription: 'subscriptions'
-};
-function safeObject(...args) {
-    return Object.assign(Object.create(null), ...args);
-}
-/**
- * @internal The type signature of this class may change without warning.
- * @deprecated
- */ class Router {
-    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);
-    }
-    subscription(path, procedure) {
-        const router = new Router({
-            subscriptions: safeObject({
-                [path]: createProcedure(procedure)
-            })
-        });
-        return this.merge(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;
-        } 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({
-                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: TRPC_ERROR_CODES_BY_KEY[code],
-            data: {
-                code,
-                httpStatus: getHTTPStatusCodeFromError(error)
-            }
-        };
-        if (globalThis.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);
-    }
-    constructor(def){
-        this._def = {
-            queries: def?.queries ?? safeObject(),
-            mutations: def?.mutations ?? safeObject(),
-            subscriptions: def?.subscriptions ?? safeObject(),
-            middlewares: def?.middlewares ?? [],
-            errorFormatter: def?.errorFormatter ?? defaultFormatter,
-            transformer: def?.transformer ?? defaultTransformer
-        };
-    }
-}
-/**
- * @deprecated
- */ function router() {
-    return new Router();
-}
-
-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 {
-    context() {
-        return new TRPCBuilder();
-    }
-    meta() {
-        return new TRPCBuilder();
-    }
-    create(options) {
-        return createTRPCInner()(options);
-    }
-}
-/**
- * Initialize tRPC - done exactly once per backend
- */ const initTRPC = new TRPCBuilder();
-function createTRPCInner() {
-    return function initTRPCInner(runtime) {
-        const errorFormatter = runtime?.errorFormatter ?? defaultFormatter;
-        const transformer = getDataTransformer$1(runtime?.transformer ?? defaultTransformer);
-        const config = {
-            transformer,
-            isDev: runtime?.isDev ?? 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
-       * @see https://trpc.io/docs/server/procedures
-       */ procedure: createBuilder({
-                meta: runtime?.defaultMeta
-            }),
-            /**
-       * Create reusable middlewares
-       * @see https://trpc.io/docs/server/middlewares
-       */ middleware: createMiddlewareFactory(),
-            /**
-       * Create a router
-       * @see https://trpc.io/docs/server/routers
-       */ router: createRouterFactory(config),
-            /**
-       * Merge Routers
-       * @see https://trpc.io/docs/server/merging-routers
-       */ mergeRouters,
-            /**
-       * Create a server-side caller for a router
-       * @see https://trpc.io/docs/server/server-side-calls
-       */ createCallerFactory: createCallerFactory()
-        };
-    };
-}
-
-export { createInputMiddleware, createOutputMiddleware, experimental_standaloneMiddleware, initTRPC, router };
+export { createFlatProxy as createTRPCFlatProxy } from './unstable-core-do-not-import/createProxy.mjs';
+export { getErrorShape } from './unstable-core-do-not-import/error/getErrorShape.mjs';
+export { TRPCError, getTRPCErrorFromUnknown } from './unstable-core-do-not-import/error/TRPCError.mjs';
+import './vendor/unpromise/unpromise.mjs';
+import './unstable-core-do-not-import/stream/utils/disposable.mjs';
+export { isTrackedEnvelope, sse, tracked } from './unstable-core-do-not-import/stream/tracked.mjs';
+export { transformTRPCResponse } from './unstable-core-do-not-import/transformer.mjs';
+export { initTRPC } from './unstable-core-do-not-import/initTRPC.mjs';
+export { experimental_standaloneMiddleware, experimental_standaloneMiddleware as experimental_trpcMiddleware } from './unstable-core-do-not-import/middleware.mjs';
+import './unstable-core-do-not-import/rootConfig.mjs';
+export { callProcedure, callProcedure as callTRPCProcedure } from './unstable-core-do-not-import/router.mjs';