@trpc/server 11.0.0-alpha-tmp-export-from-main-nuke-core.240 → 11.0.0-alpha-tmp-export-from-main.222

package/dist/adapters/node-http/index.mjs

@@ -1 +1,107 @@
-export { nodeHTTPRequestHandler } from './nodeHTTPRequestHandler.mjs';
+import { resolveHTTPResponse, getBatchStreamFormatter } from '@trpc/server/http';
+import { nodeHTTPJSONContentTypeHandler } from '@trpc/server/adapters/node-http/content-type/json';
+
+/**
+ * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
+ *
+ * Do **not** import from `@trpc/core`
+ * @example
+ * ```ts
+ * import type { AnyTRPCRouter } from '@trpc/server'
+ * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
+ * ```
+ */ /* eslint-disable @typescript-eslint/no-non-null-assertion */ // @trpc/server
+const defaultJSONContentTypeHandler = nodeHTTPJSONContentTypeHandler();
+async function nodeHTTPRequestHandler(opts) {
+    const handleViaMiddleware = opts.middleware ?? ((_req, _res, next)=>next());
+    return handleViaMiddleware(opts.req, opts.res, async (err)=>{
+        if (err) throw err;
+        //
+        // Build tRPC dependencies
+        const createContext = async (innerOpts)=>{
+            return await opts.createContext?.({
+                ...opts,
+                ...innerOpts
+            });
+        };
+        const query = opts.req.query ? new URLSearchParams(opts.req.query) : new URLSearchParams(opts.req.url.split('?')[1]);
+        const jsonContentTypeHandler = defaultJSONContentTypeHandler;
+        const contentTypeHandlers = opts.experimental_contentTypeHandlers ?? [
+            jsonContentTypeHandler
+        ];
+        const contentTypeHandler = contentTypeHandlers.find((handler)=>handler.isMatch({
+                ...opts,
+                query
+            })) ?? // fallback to json
+        jsonContentTypeHandler;
+        const bodyResult = await contentTypeHandler.getBody({
+            ...opts,
+            query
+        });
+        const req = {
+            method: opts.req.method,
+            headers: opts.req.headers,
+            query,
+            body: bodyResult.ok ? bodyResult.data : undefined
+        };
+        let isStream = false;
+        let formatter;
+        const unstable_onHead = (head, isStreaming)=>{
+            if ('status' in head && (!opts.res.statusCode || opts.res.statusCode === 200)) {
+                opts.res.statusCode = head.status;
+            }
+            for (const [key, value] of Object.entries(head.headers ?? {})){
+                /* istanbul ignore if -- @preserve */ if (typeof value === 'undefined') {
+                    continue;
+                }
+                opts.res.setHeader(key, value);
+            }
+            if (isStreaming) {
+                opts.res.setHeader('Transfer-Encoding', 'chunked');
+                const vary = opts.res.getHeader('Vary');
+                opts.res.setHeader('Vary', vary ? 'trpc-batch-mode, ' + vary : 'trpc-batch-mode');
+                isStream = true;
+                formatter = getBatchStreamFormatter();
+                opts.res.flushHeaders();
+            }
+        };
+        const unstable_onChunk = ([index, string])=>{
+            if (index === -1) {
+                /**
+         * Full response, no streaming. This can happen
+         * - if the response is an error
+         * - if response is empty (HEAD request)
+         */ opts.res.end(string);
+            } else {
+                opts.res.write(formatter(index, string));
+                opts.res.flush?.();
+            }
+        };
+        await resolveHTTPResponse({
+            batching: opts.batching,
+            responseMeta: opts.responseMeta,
+            path: opts.path,
+            createContext,
+            router: opts.router,
+            req,
+            error: bodyResult.ok ? null : bodyResult.error,
+            preprocessedBody: bodyResult.ok ? bodyResult.preprocessed : false,
+            onError (o) {
+                opts?.onError?.({
+                    ...o,
+                    req: opts.req
+                });
+            },
+            contentTypeHandler,
+            unstable_onHead,
+            unstable_onChunk
+        });
+        if (isStream) {
+            opts.res.write(formatter.end());
+            opts.res.end();
+        }
+        return opts.res;
+    });
+}
+
+export { nodeHTTPRequestHandler };

package/dist/adapters/standalone.d.mts

@@ -0,0 +1,21 @@
+import http from 'http';
+import { AnyRouter } from '@trpc/server';
+import { NodeHTTPHandlerOptions, NodeHTTPCreateContextFnOptions } from '@trpc/server/adapters/node-http';
+
+/**
+ * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
+ *
+ * Do **not** import from `@trpc/core`
+ * @example
+ * ```ts
+ * import type { AnyTRPCRouter } from '@trpc/server'
+ * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
+ * ```
+ */
+
+type CreateHTTPHandlerOptions<TRouter extends AnyRouter> = NodeHTTPHandlerOptions<TRouter, http.IncomingMessage, http.ServerResponse>;
+type CreateHTTPContextOptions = NodeHTTPCreateContextFnOptions<http.IncomingMessage, http.ServerResponse>;
+declare function createHTTPHandler<TRouter extends AnyRouter>(opts: CreateHTTPHandlerOptions<TRouter>): (req: http.IncomingMessage, res: http.ServerResponse) => Promise<void>;
+declare function createHTTPServer<TRouter extends AnyRouter>(opts: CreateHTTPHandlerOptions<TRouter>): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+
+export { type CreateHTTPContextOptions, type CreateHTTPHandlerOptions, createHTTPHandler, createHTTPServer };

package/dist/adapters/standalone.d.ts

@@ -1,18 +1,21 @@
-/// <reference types="node" />
+import http from 'http';
+import { AnyRouter } from '@trpc/server';
+import { NodeHTTPHandlerOptions, NodeHTTPCreateContextFnOptions } from '@trpc/server/adapters/node-http';
+
 /**
  * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
  *
+ * Do **not** import from `@trpc/core`
  * @example
  * ```ts
  * import type { AnyTRPCRouter } from '@trpc/server'
  * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
  * ```
  */
-import http from 'http';
-import type { AnyRouter } from '../@trpc/server';
-import type { NodeHTTPCreateContextFnOptions, NodeHTTPHandlerOptions } from './node-http';
-export type CreateHTTPHandlerOptions<TRouter extends AnyRouter> = NodeHTTPHandlerOptions<TRouter, http.IncomingMessage, http.ServerResponse>;
-export type CreateHTTPContextOptions = NodeHTTPCreateContextFnOptions<http.IncomingMessage, http.ServerResponse>;
-export declare function createHTTPHandler<TRouter extends AnyRouter>(opts: CreateHTTPHandlerOptions<TRouter>): (req: http.IncomingMessage, res: http.ServerResponse) => Promise<void>;
-export declare function createHTTPServer<TRouter extends AnyRouter>(opts: CreateHTTPHandlerOptions<TRouter>): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
-//# sourceMappingURL=standalone.d.ts.map
+
+type CreateHTTPHandlerOptions<TRouter extends AnyRouter> = NodeHTTPHandlerOptions<TRouter, http.IncomingMessage, http.ServerResponse>;
+type CreateHTTPContextOptions = NodeHTTPCreateContextFnOptions<http.IncomingMessage, http.ServerResponse>;
+declare function createHTTPHandler<TRouter extends AnyRouter>(opts: CreateHTTPHandlerOptions<TRouter>): (req: http.IncomingMessage, res: http.ServerResponse) => Promise<void>;
+declare function createHTTPServer<TRouter extends AnyRouter>(opts: CreateHTTPHandlerOptions<TRouter>): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+
+export { type CreateHTTPContextOptions, type CreateHTTPHandlerOptions, createHTTPHandler, createHTTPServer };

package/dist/adapters/standalone.js

@@ -1,17 +1,20 @@
-'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
 
-var http = require('node:http');
-var nodeHTTPRequestHandler = require('./node-http/nodeHTTPRequestHandler.js');
+var http = require('http');
+var nodeHttp = require('@trpc/server/adapters/node-http');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var http__default = /*#__PURE__*/_interopDefault(http);
 
 function createHTTPHandler(opts) {
     return async (req, res)=>{
         // Get procedure path and remove the leading slash, `/procedure -> procedure`
         // Use dummy hostname if one is not provided.
         const path = new URL(req.url, 'http://127.0.0.1').pathname.slice(1);
-        await nodeHTTPRequestHandler.nodeHTTPRequestHandler({
+        await nodeHttp.nodeHTTPRequestHandler({
             // FIXME: no typecasting should be needed here
             ...opts,
-            ...opts,
             req,
             res,
             path
@@ -20,7 +23,7 @@ function createHTTPHandler(opts) {
 }
 function createHTTPServer(opts) {
     const handler = createHTTPHandler(opts);
-    return http.createServer(handler);
+    return http__default.default.createServer(handler);
 }
 
 exports.createHTTPHandler = createHTTPHandler;

package/dist/adapters/standalone.mjs

@@ -1,5 +1,5 @@
-import http from 'node:http';
-import { nodeHTTPRequestHandler } from './node-http/nodeHTTPRequestHandler.mjs';
+import http from 'http';
+import { nodeHTTPRequestHandler } from '@trpc/server/adapters/node-http';
 
 function createHTTPHandler(opts) {
     return async (req, res)=>{
@@ -9,7 +9,6 @@ function createHTTPHandler(opts) {
         await nodeHTTPRequestHandler({
             // FIXME: no typecasting should be needed here
             ...opts,
-            ...opts,
             req,
             res,
             path

package/dist/adapters/ws.d.mts

@@ -0,0 +1,36 @@
+import { IncomingMessage } from 'http';
+import { MaybePromise, BaseHandlerOptions } from '@trpc/core';
+import ws from 'ws';
+import { AnyRouter, inferRouterContext } from '@trpc/server';
+import { NodeHTTPCreateContextFnOptions } from '@trpc/server/adapters/node-http';
+
+/**
+ * @public
+ */
+type CreateWSSContextFnOptions = Omit<NodeHTTPCreateContextFnOptions<IncomingMessage, ws.WebSocket>, 'info'>;
+/**
+ * @public
+ */
+type CreateWSSContextFn<TRouter extends AnyRouter> = (opts: CreateWSSContextFnOptions) => MaybePromise<inferRouterContext<TRouter>>;
+/**
+ * Web socket server handler
+ */
+type WSSHandlerOptions<TRouter extends AnyRouter> = BaseHandlerOptions<TRouter, IncomingMessage> & (object extends inferRouterContext<TRouter> ? {
+    /**
+     * @link https://trpc.io/docs/v11/context
+     **/
+    createContext?: CreateWSSContextFn<TRouter>;
+} : {
+    /**
+     * @link https://trpc.io/docs/v11/context
+     **/
+    createContext: CreateWSSContextFn<TRouter>;
+}) & {
+    wss: ws.WebSocketServer;
+    process?: NodeJS.Process;
+};
+declare function applyWSSHandler<TRouter extends AnyRouter>(opts: WSSHandlerOptions<TRouter>): {
+    broadcastReconnectNotification: () => void;
+};
+
+export { type CreateWSSContextFn, type CreateWSSContextFnOptions, type WSSHandlerOptions, applyWSSHandler };

package/dist/adapters/ws.d.ts

@@ -1,24 +1,21 @@
-/// <reference types="node" />
-/// <reference types="./types/global" />
-/// <reference types="node" />
-import type { IncomingMessage } from 'http';
-import type ws from 'ws';
-import type { AnyRouter, inferRouterContext } from '../@trpc/server';
-import type { BaseHandlerOptions } from '../@trpc/server/http';
-import type { MaybePromise } from '../unstable-core-do-not-import';
-import type { NodeHTTPCreateContextFnOptions } from './node-http';
+import { IncomingMessage } from 'http';
+import { MaybePromise, BaseHandlerOptions } from '@trpc/core';
+import ws from 'ws';
+import { AnyRouter, inferRouterContext } from '@trpc/server';
+import { NodeHTTPCreateContextFnOptions } from '@trpc/server/adapters/node-http';
+
 /**
  * @public
  */
-export type CreateWSSContextFnOptions = Omit<NodeHTTPCreateContextFnOptions<IncomingMessage, ws.WebSocket>, 'info'>;
+type CreateWSSContextFnOptions = Omit<NodeHTTPCreateContextFnOptions<IncomingMessage, ws.WebSocket>, 'info'>;
 /**
  * @public
  */
-export type CreateWSSContextFn<TRouter extends AnyRouter> = (opts: CreateWSSContextFnOptions) => MaybePromise<inferRouterContext<TRouter>>;
+type CreateWSSContextFn<TRouter extends AnyRouter> = (opts: CreateWSSContextFnOptions) => MaybePromise<inferRouterContext<TRouter>>;
 /**
  * Web socket server handler
  */
-export type WSSHandlerOptions<TRouter extends AnyRouter> = BaseHandlerOptions<TRouter, IncomingMessage> & (object extends inferRouterContext<TRouter> ? {
+type WSSHandlerOptions<TRouter extends AnyRouter> = BaseHandlerOptions<TRouter, IncomingMessage> & (object extends inferRouterContext<TRouter> ? {
     /**
      * @link https://trpc.io/docs/v11/context
      **/
@@ -32,7 +29,8 @@ export type WSSHandlerOptions<TRouter extends AnyRouter> = BaseHandlerOptions<TR
     wss: ws.WebSocketServer;
     process?: NodeJS.Process;
 };
-export declare function applyWSSHandler<TRouter extends AnyRouter>(opts: WSSHandlerOptions<TRouter>): {
+declare function applyWSSHandler<TRouter extends AnyRouter>(opts: WSSHandlerOptions<TRouter>): {
     broadcastReconnectNotification: () => void;
 };
-//# sourceMappingURL=ws.d.ts.map
+
+export { type CreateWSSContextFn, type CreateWSSContextFnOptions, type WSSHandlerOptions, applyWSSHandler };

package/dist/adapters/ws.js

@@ -1,27 +1,22 @@
-'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
 
-var getErrorShape = require('../unstable-core-do-not-import/error/getErrorShape.js');
-var TRPCError = require('../unstable-core-do-not-import/error/TRPCError.js');
-require('../unstable-core-do-not-import/rootConfig.js');
-var router = require('../unstable-core-do-not-import/router.js');
-var transformer = require('../unstable-core-do-not-import/transformer.js');
-require('../unstable-core-do-not-import/rpc/codes.js');
-var parseTRPCMessage = require('../unstable-core-do-not-import/rpc/parseTRPCMessage.js');
-var observable = require('../observable/observable.js');
+var server = require('@trpc/server');
+var observable = require('@trpc/server/observable');
+var rpc = require('@trpc/server/rpc');
 
 /**
  * Importing ws causes a build error
  * @link https://github.com/trpc/trpc/pull/5279
  */ const WEBSOCKET_OPEN = 1; /* ws.WebSocket.OPEN */ 
 function applyWSSHandler(opts) {
-    const { wss , createContext , router: router$1  } = opts;
-    const { transformer: transformer$1  } = router$1._def._config;
+    const { wss, createContext, router } = opts;
+    const { transformer } = router._def._config;
     wss.on('connection', async (client, req)=>{
         const clientSubscriptions = new Map();
         function respond(untransformedJSON) {
-            client.send(JSON.stringify(transformer.transformTRPCResponse(router$1._def._config, untransformedJSON)));
+            client.send(JSON.stringify(server.transformTRPCResponse(router._def._config, untransformedJSON)));
         }
-        function stopSubscription(subscription, { id , jsonrpc  }) {
+        function stopSubscription(subscription, { id, jsonrpc }) {
             subscription.unsubscribe();
             respond({
                 id,
@@ -37,9 +32,9 @@ function applyWSSHandler(opts) {
         });
         let ctx = undefined;
         async function handleRequest(msg) {
-            const { id , jsonrpc  } = msg;
+            const { id, jsonrpc } = msg;
             /* istanbul ignore next -- @preserve */ if (id === null) {
-                throw new TRPCError.TRPCError({
+                throw new server.TRPCError({
                     code: 'BAD_REQUEST',
                     message: '`id` is required'
                 });
@@ -55,12 +50,12 @@ function applyWSSHandler(opts) {
                 clientSubscriptions.delete(id);
                 return;
             }
-            const { path , input  } = msg.params;
+            const { path, input } = msg.params;
             const type = msg.method;
             try {
                 await ctxPromise; // asserts context has been set
-                const result = await router.callProcedure({
-                    procedures: router$1._def.procedures,
+                const result = await server.callProcedure({
+                    procedures: router._def.procedures,
                     path,
                     getRawInput: async ()=>input,
                     ctx,
@@ -68,7 +63,7 @@ function applyWSSHandler(opts) {
                 });
                 if (type === 'subscription') {
                     if (!observable.isObservable(result)) {
-                        throw new TRPCError.TRPCError({
+                        throw new server.TRPCError({
                             message: `Subscription ${path} did not return an observable`,
                             code: 'INTERNAL_SERVER_ERROR'
                         });
@@ -86,7 +81,7 @@ function applyWSSHandler(opts) {
                     return;
                 }
                 const observable$1 = result;
-                const sub1 = observable$1.subscribe({
+                const sub = observable$1.subscribe({
                     next (data) {
                         respond({
                             id,
@@ -98,7 +93,7 @@ function applyWSSHandler(opts) {
                         });
                     },
                     error (err) {
-                        const error = TRPCError.getTRPCErrorFromUnknown(err);
+                        const error = server.getTRPCErrorFromUnknown(err);
                         opts.onError?.({
                             error,
                             path,
@@ -110,8 +105,8 @@ function applyWSSHandler(opts) {
                         respond({
                             id,
                             jsonrpc,
-                            error: getErrorShape.getErrorShape({
-                                config: router$1._def._config,
+                            error: server.getErrorShape({
+                                config: router._def._config,
                                 error,
                                 type,
                                 path,
@@ -133,21 +128,21 @@ function applyWSSHandler(opts) {
                 /* istanbul ignore next -- @preserve */ if (client.readyState !== WEBSOCKET_OPEN) {
                     // if the client got disconnected whilst initializing the subscription
                     // no need to send stopped message if the client is disconnected
-                    sub1.unsubscribe();
+                    sub.unsubscribe();
                     return;
                 }
                 /* istanbul ignore next -- @preserve */ if (clientSubscriptions.has(id)) {
                     // duplicate request ids for client
-                    stopSubscription(sub1, {
+                    stopSubscription(sub, {
                         id,
                         jsonrpc
                     });
-                    throw new TRPCError.TRPCError({
+                    throw new server.TRPCError({
                         message: `Duplicate id ${id}`,
                         code: 'BAD_REQUEST'
                     });
                 }
-                clientSubscriptions.set(id, sub1);
+                clientSubscriptions.set(id, sub);
                 respond({
                     id,
                     jsonrpc,
@@ -157,7 +152,7 @@ function applyWSSHandler(opts) {
                 });
             } catch (cause) /* istanbul ignore next -- @preserve */ {
                 // procedure threw an error
-                const error = TRPCError.getTRPCErrorFromUnknown(cause);
+                const error = server.getTRPCErrorFromUnknown(cause);
                 opts.onError?.({
                     error,
                     path,
@@ -169,8 +164,8 @@ function applyWSSHandler(opts) {
                 respond({
                     id,
                     jsonrpc,
-                    error: getErrorShape.getErrorShape({
-                        config: router$1._def._config,
+                    error: server.getErrorShape({
+                        config: router._def._config,
                         error,
                         type,
                         path,
@@ -187,17 +182,17 @@ function applyWSSHandler(opts) {
                 const msgs = Array.isArray(msgJSON) ? msgJSON : [
                     msgJSON
                 ];
-                const promises = msgs.map((raw)=>parseTRPCMessage.parseTRPCMessage(raw, transformer$1)).map(handleRequest);
+                const promises = msgs.map((raw)=>rpc.parseTRPCMessage(raw, transformer)).map(handleRequest);
                 await Promise.all(promises);
             } catch (cause) {
-                const error = new TRPCError.TRPCError({
+                const error = new server.TRPCError({
                     code: 'PARSE_ERROR',
                     cause
                 });
                 respond({
                     id: null,
-                    error: getErrorShape.getErrorShape({
-                        config: router$1._def._config,
+                    error: server.getErrorShape({
+                        config: router._def._config,
                         error,
                         type: 'unknown',
                         path: undefined,
@@ -214,7 +209,7 @@ function applyWSSHandler(opts) {
         client.on('error', (cause)=>{
             opts.onError?.({
                 ctx,
-                error: TRPCError.getTRPCErrorFromUnknown(cause),
+                error: server.getTRPCErrorFromUnknown(cause),
                 input: undefined,
                 path: undefined,
                 type: 'unknown',
@@ -231,7 +226,7 @@ function applyWSSHandler(opts) {
             try {
                 ctx = await ctxPromise;
             } catch (cause) {
-                const error = TRPCError.getTRPCErrorFromUnknown(cause);
+                const error = server.getTRPCErrorFromUnknown(cause);
                 opts.onError?.({
                     error,
                     path: undefined,
@@ -242,8 +237,8 @@ function applyWSSHandler(opts) {
                 });
                 respond({
                     id: null,
-                    error: getErrorShape.getErrorShape({
-                        config: router$1._def._config,
+                    error: server.getErrorShape({
+                        config: router._def._config,
                         error,
                         type: 'unknown',
                         path: undefined,

package/dist/adapters/ws.mjs

@@ -1,25 +1,20 @@
-import { getErrorShape } from '../unstable-core-do-not-import/error/getErrorShape.mjs';
-import { TRPCError, getTRPCErrorFromUnknown } from '../unstable-core-do-not-import/error/TRPCError.mjs';
-import '../unstable-core-do-not-import/rootConfig.mjs';
-import { callProcedure } from '../unstable-core-do-not-import/router.mjs';
-import { transformTRPCResponse } from '../unstable-core-do-not-import/transformer.mjs';
-import '../unstable-core-do-not-import/rpc/codes.mjs';
-import { parseTRPCMessage } from '../unstable-core-do-not-import/rpc/parseTRPCMessage.mjs';
-import { isObservable } from '../observable/observable.mjs';
+import { TRPCError, getErrorShape, getTRPCErrorFromUnknown, transformTRPCResponse, callProcedure } from '@trpc/server';
+import { isObservable } from '@trpc/server/observable';
+import { parseTRPCMessage } from '@trpc/server/rpc';
 
 /**
  * Importing ws causes a build error
  * @link https://github.com/trpc/trpc/pull/5279
  */ const WEBSOCKET_OPEN = 1; /* ws.WebSocket.OPEN */ 
 function applyWSSHandler(opts) {
-    const { wss , createContext , router  } = opts;
-    const { transformer  } = router._def._config;
+    const { wss, createContext, router } = opts;
+    const { transformer } = router._def._config;
     wss.on('connection', async (client, req)=>{
         const clientSubscriptions = new Map();
         function respond(untransformedJSON) {
             client.send(JSON.stringify(transformTRPCResponse(router._def._config, untransformedJSON)));
         }
-        function stopSubscription(subscription, { id , jsonrpc  }) {
+        function stopSubscription(subscription, { id, jsonrpc }) {
             subscription.unsubscribe();
             respond({
                 id,
@@ -35,7 +30,7 @@ function applyWSSHandler(opts) {
         });
         let ctx = undefined;
         async function handleRequest(msg) {
-            const { id , jsonrpc  } = msg;
+            const { id, jsonrpc } = msg;
             /* istanbul ignore next -- @preserve */ if (id === null) {
                 throw new TRPCError({
                     code: 'BAD_REQUEST',
@@ -53,7 +48,7 @@ function applyWSSHandler(opts) {
                 clientSubscriptions.delete(id);
                 return;
             }
-            const { path , input  } = msg.params;
+            const { path, input } = msg.params;
             const type = msg.method;
             try {
                 await ctxPromise; // asserts context has been set
@@ -84,7 +79,7 @@ function applyWSSHandler(opts) {
                     return;
                 }
                 const observable = result;
-                const sub1 = observable.subscribe({
+                const sub = observable.subscribe({
                     next (data) {
                         respond({
                             id,
@@ -131,12 +126,12 @@ function applyWSSHandler(opts) {
                 /* istanbul ignore next -- @preserve */ if (client.readyState !== WEBSOCKET_OPEN) {
                     // if the client got disconnected whilst initializing the subscription
                     // no need to send stopped message if the client is disconnected
-                    sub1.unsubscribe();
+                    sub.unsubscribe();
                     return;
                 }
                 /* istanbul ignore next -- @preserve */ if (clientSubscriptions.has(id)) {
                     // duplicate request ids for client
-                    stopSubscription(sub1, {
+                    stopSubscription(sub, {
                         id,
                         jsonrpc
                     });
@@ -145,7 +140,7 @@ function applyWSSHandler(opts) {
                         code: 'BAD_REQUEST'
                     });
                 }
-                clientSubscriptions.set(id, sub1);
+                clientSubscriptions.set(id, sub);
                 respond({
                     id,
                     jsonrpc,

package/dist/http.d.mts

@@ -0,0 +1 @@
+export { BaseContentTypeHandler, BaseHandlerOptions, BodyResult, HTTPBaseHandlerOptions, HTTPHeaders, HTTPRequest, HTTPResponse, OnErrorFunction, ProcedureCall, ResolveHTTPRequestOptionsContextFn, ResponseChunk, ResponseMeta, ResponseMetaFn, TRPCRequestInfo, getBatchStreamFormatter, getHTTPStatusCode, getHTTPStatusCodeFromError, getJsonContentTypeInputs, resolveHTTPResponse } from '@trpc/server/unstableDontImportMe';

package/dist/http.d.ts

@@ -1,2 +1 @@
-export * from './@trpc/server/http';
-//# sourceMappingURL=http.d.ts.map
+export { BaseContentTypeHandler, BaseHandlerOptions, BodyResult, HTTPBaseHandlerOptions, HTTPHeaders, HTTPRequest, HTTPResponse, OnErrorFunction, ProcedureCall, ResolveHTTPRequestOptionsContextFn, ResponseChunk, ResponseMeta, ResponseMetaFn, TRPCRequestInfo, getBatchStreamFormatter, getHTTPStatusCode, getHTTPStatusCodeFromError, getJsonContentTypeInputs, resolveHTTPResponse } from '@trpc/server/unstableDontImportMe';

package/dist/http.js

@@ -1,16 +1,26 @@
-'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
 
-var getHTTPStatusCode = require('./unstable-core-do-not-import/http/getHTTPStatusCode.js');
-require('./unstable-core-do-not-import/rpc/codes.js');
-require('./unstable-core-do-not-import/rootConfig.js');
-var resolveHTTPResponse = require('./unstable-core-do-not-import/http/resolveHTTPResponse.js');
-var batchStreamFormatter = require('./unstable-core-do-not-import/http/batchStreamFormatter.js');
-var contentType = require('./unstable-core-do-not-import/http/contentType.js');
+var unstableDontImportMe = require('@trpc/server/unstableDontImportMe');
 
 
 
-exports.getHTTPStatusCode = getHTTPStatusCode.getHTTPStatusCode;
-exports.getHTTPStatusCodeFromError = getHTTPStatusCode.getHTTPStatusCodeFromError;
-exports.resolveHTTPResponse = resolveHTTPResponse.resolveHTTPResponse;
-exports.getBatchStreamFormatter = batchStreamFormatter.getBatchStreamFormatter;
-exports.getJsonContentTypeInputs = contentType.getJsonContentTypeInputs;
+Object.defineProperty(exports, "getBatchStreamFormatter", {
+  enumerable: true,
+  get: function () { return unstableDontImportMe.getBatchStreamFormatter; }
+});
+Object.defineProperty(exports, "getHTTPStatusCode", {
+  enumerable: true,
+  get: function () { return unstableDontImportMe.getHTTPStatusCode; }
+});
+Object.defineProperty(exports, "getHTTPStatusCodeFromError", {
+  enumerable: true,
+  get: function () { return unstableDontImportMe.getHTTPStatusCodeFromError; }
+});
+Object.defineProperty(exports, "getJsonContentTypeInputs", {
+  enumerable: true,
+  get: function () { return unstableDontImportMe.getJsonContentTypeInputs; }
+});
+Object.defineProperty(exports, "resolveHTTPResponse", {
+  enumerable: true,
+  get: function () { return unstableDontImportMe.resolveHTTPResponse; }
+});

package/dist/http.mjs

@@ -1,6 +1 @@
-export { getHTTPStatusCode, getHTTPStatusCodeFromError } from './unstable-core-do-not-import/http/getHTTPStatusCode.mjs';
-import './unstable-core-do-not-import/rpc/codes.mjs';
-import './unstable-core-do-not-import/rootConfig.mjs';
-export { resolveHTTPResponse } from './unstable-core-do-not-import/http/resolveHTTPResponse.mjs';
-export { getBatchStreamFormatter } from './unstable-core-do-not-import/http/batchStreamFormatter.mjs';
-export { getJsonContentTypeInputs } from './unstable-core-do-not-import/http/contentType.mjs';
+export { getBatchStreamFormatter, getHTTPStatusCode, getHTTPStatusCodeFromError, getJsonContentTypeInputs, resolveHTTPResponse } from '@trpc/server/unstableDontImportMe';

package/dist/index.d.mts

@@ -0,0 +1,9 @@
+export { AnyMiddlewareFunction, AnyMutationProcedure, AnyProcedure, AnyQueryProcedure, AnyRouter, AnySubscriptionProcedure, AnyMiddlewareFunction as AnyTRPCMiddlewareFunction, AnyMutationProcedure as AnyTRPCMutationProcedure, AnyProcedure as AnyTRPCProcedure, AnyQueryProcedure as AnyTRPCQueryProcedure, AnyRouter as AnyTRPCRouter, AnySubscriptionProcedure as AnyTRPCSubscriptionProcedure, CombinedDataTransformer, DeepPartial, Dict, ProcedureArgs, ProcedureRouterRecord, ProcedureType, CombinedDataTransformer as TRPCCombinedDataTransformer, TRPCError, ProcedureArgs as TRPCProcedureArgs, ProcedureRouterRecord as TRPCProcedureRouterRecord, ProcedureType as TRPCProcedureType, callProcedure, callProcedure as callTRPCProcedure, createFlatProxy as createTRPCFlatProxy, experimental_standaloneMiddleware, experimental_standaloneMiddleware as experimental_trpcMiddleware, getErrorShape, getTRPCErrorFromUnknown, inferProcedureInput, inferProcedureOutput, inferRouterContext, inferRouterError, inferRouterInputs, inferRouterOutputs, inferTransformedProcedureOutput, inferTransformedSubscriptionOutput, initTRPC, transformTRPCResponse } from '@trpc/core';
+
+/**
+ * @deprecated
+ * Use `Awaited<ReturnType<typeof myFunction>>` instead
+ */
+type inferAsyncReturnType<TFunction extends (...args: any[]) => any> = Awaited<ReturnType<TFunction>>;
+
+export type { inferAsyncReturnType };