@trpc/server 11.0.0-rc.417 → 11.0.0-rc.421

package/dist/unstable-core-do-not-import/http/resolveResponse.mjs

@@ -1,18 +1,40 @@
+import { isObservable, observableToAsyncIterable } from '../../observable/observable.mjs';
 import { getErrorShape } from '../error/getErrorShape.mjs';
 import { TRPCError, getTRPCErrorFromUnknown } from '../error/TRPCError.mjs';
-import { callProcedure } from '../router.mjs';
-import { isPromise, jsonlStreamProducer } from '../stream/stream.mjs';
+import { jsonlStreamProducer, isPromise } from '../stream/jsonl.mjs';
+import { sseStreamProducer, sseHeaders } from '../stream/sse.mjs';
 import { transformTRPCResponse } from '../transformer.mjs';
-import { isObject } from '../utils.mjs';
+import { isAsyncIterable, isObject } from '../utils.mjs';
 import { getRequestInfo } from './contentType.mjs';
 import { getHTTPStatusCode } from './getHTTPStatusCode.mjs';
 
-const HTTP_METHOD_PROCEDURE_TYPE_MAP = {
-    GET: 'query',
-    POST: 'mutation'
+const TYPE_ACCEPTED_METHOD_MAP = {
+    mutation: [
+        'POST'
+    ],
+    query: [
+        'GET'
+    ],
+    subscription: [
+        'GET'
+    ]
+};
+const TYPE_ACCEPTED_METHOD_MAP_WITH_METHOD_OVERRIDE = {
+    // never allow GET to do a mutation
+    mutation: [
+        'POST'
+    ],
+    query: [
+        'GET',
+        'POST'
+    ],
+    subscription: [
+        'GET',
+        'POST'
+    ]
 };
 function initResponse(initOpts) {
-    const { ctx , info , type , responseMeta , untransformedJSON , errors =[] , headers ,  } = initOpts;
+    const { ctx , info , responseMeta , untransformedJSON , errors =[] , headers ,  } = initOpts;
     let status = untransformedJSON ? getHTTPStatusCode(untransformedJSON) : 200;
     const eagerGeneration = !untransformedJSON;
     const data = eagerGeneration ? [] : Array.isArray(untransformedJSON) ? untransformedJSON : [
@@ -22,10 +44,10 @@ function initResponse(initOpts) {
         ctx,
         info,
         paths: info?.calls.map((call)=>call.path),
-        type,
         data,
         errors,
-        eagerGeneration
+        eagerGeneration,
+        type: info?.calls.find((call)=>call.procedure?._def.type)?.procedure?._def.type ?? 'unknown'
     }) ?? {};
     if (meta.headers) {
         if (meta.headers instanceof Headers) {
@@ -82,6 +104,19 @@ function caughtErrorToData(cause, errorOpts) {
         body
     };
 }
+/**
+ * Check if a value is a stream-like object
+ * - if it's an async iterable
+ * - if it's an object with async iterables or promises
+ */ function isDataStream(v) {
+    if (!isObject(v)) {
+        return false;
+    }
+    if (isAsyncIterable(v)) {
+        return true;
+    }
+    return Object.values(v).some(isPromise) || Object.values(v).some(isAsyncIterable);
+}
 async function resolveResponse(opts) {
     const { router , req  } = opts;
     const headers = new Headers([
@@ -100,17 +135,21 @@ async function resolveResponse(opts) {
     }
     const allowBatching = opts.allowBatching ?? opts.batching?.enabled ?? true;
     const allowMethodOverride = (opts.allowMethodOverride ?? false) && req.method === 'POST';
-    const type = HTTP_METHOD_PROCEDURE_TYPE_MAP[req.method] ?? 'unknown';
     let ctx = undefined;
     let info = undefined;
-    const isStreamCall = req.headers.get('trpc-accept') === 'application/jsonl';
-    const experimentalIterablesAndDeferreds = config.experimental?.iterablesAndDeferreds ?? false;
+    const methodMapper = allowMethodOverride ? TYPE_ACCEPTED_METHOD_MAP_WITH_METHOD_OVERRIDE : TYPE_ACCEPTED_METHOD_MAP;
+    /**
+   * @deprecated
+   */ const isStreamCall = req.headers.get('trpc-accept') === 'application/jsonl';
+    const experimentalIterablesAndDeferreds = router._def._config.experimental?.iterablesAndDeferreds ?? true;
+    const experimentalSSE = router._def._config.experimental?.sseSubscriptions?.enabled ?? true;
     try {
         info = getRequestInfo({
             req,
             path: decodeURIComponent(opts.path),
-            config: config,
-            searchParams: url.searchParams
+            router,
+            searchParams: url.searchParams,
+            headers: opts.req.headers
         });
         // we create context early so that error handlers may access context information
         ctx = await opts.createContext({
@@ -125,166 +164,281 @@ async function resolveResponse(opts) {
                 message: `Batching is not enabled on the server`
             });
         }
-        if (type === 'unknown') {
+        /* istanbul ignore if -- @preserve */ if (isStreamCall && !info.isBatchCall) {
             throw new TRPCError({
-                message: `Unexpected request method ${req.method}`,
-                code: 'METHOD_NOT_SUPPORTED'
+                message: `Streaming requests must be batched (you can do a batch of 1)`,
+                code: 'BAD_REQUEST'
             });
         }
-        const errors = [];
-        const promises = info.calls.map(async (call)=>{
+        const rpcCalls = info.calls.map(async (call)=>{
+            const proc = call.procedure;
             try {
-                const data = await callProcedure({
-                    procedures: opts.router._def.procedures,
+                if (!proc) {
+                    throw new TRPCError({
+                        code: 'NOT_FOUND',
+                        message: `No procedure found on path "${call.path}"`
+                    });
+                }
+                if (!methodMapper[proc._def.type].includes(req.method)) {
+                    throw new TRPCError({
+                        code: 'METHOD_NOT_SUPPORTED',
+                        message: `Unsupported ${req.method}-request to ${proc._def.type} procedure at path "${call.path}"`
+                    });
+                }
+                /* istanbul ignore if -- @preserve */ if (proc._def.type === 'subscription' && info.isBatchCall) {
+                    throw new TRPCError({
+                        code: 'BAD_REQUEST',
+                        message: `Cannot batch subscription calls`
+                    });
+                }
+                const data = await proc({
                     path: call.path,
                     getRawInput: call.getRawInput,
                     ctx,
-                    type,
-                    allowMethodOverride
+                    type: proc._def.type
                 });
-                if ((!isStreamCall || !experimentalIterablesAndDeferreds) && isObject(data) && (Symbol.asyncIterator in data || Object.values(data).some(isPromise))) {
-                    if (!isStreamCall) {
-                        throw new TRPCError({
-                            code: 'UNSUPPORTED_MEDIA_TYPE',
-                            message: 'Cannot return async iterable or nested promises in non-streaming response'
-                        });
-                    }
-                    if (!experimentalIterablesAndDeferreds) {
-                        throw new TRPCError({
-                            code: 'INTERNAL_SERVER_ERROR',
-                            message: 'Missing experimental flag "iterablesAndDeferreds"'
-                        });
-                    }
-                }
-                return {
-                    result: {
-                        data
-                    }
-                };
+                return [
+                    data
+                ];
             } catch (cause) {
                 const error = getTRPCErrorFromUnknown(cause);
-                errors.push(error);
                 const input = call.result();
                 opts.onError?.({
                     error,
                     path: call.path,
                     input,
                     ctx,
-                    type: type,
+                    type: call.procedure?._def.type ?? 'unknown',
                     req: opts.req
                 });
-                return {
-                    error: getErrorShape({
-                        config,
-                        error,
-                        type,
-                        path: call.path,
-                        input,
-                        ctx
-                    })
-                };
+                return [
+                    null,
+                    error
+                ];
             }
         });
-        if (!isStreamCall) {
+        // ----------- response handlers -----------
+        if (!info.isBatchCall) {
+            const [call] = info.calls;
+            const [data, error] = await rpcCalls[0];
+            switch(info.type){
+                case 'unknown':
+                case 'mutation':
+                case 'query':
+                    {
+                        // httpLink
+                        headers.set('content-type', 'application/json');
+                        if (isDataStream(data)) {
+                            throw new TRPCError({
+                                code: 'UNSUPPORTED_MEDIA_TYPE',
+                                message: 'Cannot use stream-like response in non-streaming request - use httpBatchStreamLink'
+                            });
+                        }
+                        const res = error ? {
+                            error: getErrorShape({
+                                config,
+                                ctx,
+                                error,
+                                input: call.result(),
+                                path: call.path,
+                                type: info.type
+                            })
+                        } : {
+                            result: {
+                                data
+                            }
+                        };
+                        const headResponse = initResponse({
+                            ctx,
+                            info,
+                            responseMeta: opts.responseMeta,
+                            errors: error ? [
+                                error
+                            ] : [],
+                            headers,
+                            untransformedJSON: [
+                                res
+                            ]
+                        });
+                        return new Response(JSON.stringify(transformTRPCResponse(config, res)), {
+                            status: headResponse.status,
+                            headers
+                        });
+                    }
+                case 'subscription':
+                    {
+                        // httpSubscriptionLink
+                        if (!experimentalSSE) {
+                            throw new TRPCError({
+                                code: 'METHOD_NOT_SUPPORTED',
+                                message: 'Missing experimental flag "sseSubscriptions"'
+                            });
+                        }
+                        if (!isObservable(data) && !isAsyncIterable(data)) {
+                            throw new TRPCError({
+                                message: `Subscription ${call.path} did not return an observable or a AsyncGenerator`,
+                                code: 'INTERNAL_SERVER_ERROR'
+                            });
+                        }
+                        const dataAsIterable = isObservable(data) ? observableToAsyncIterable(data) : data;
+                        const stream = sseStreamProducer({
+                            data: dataAsIterable,
+                            serialize: (v)=>config.transformer.output.serialize(v)
+                        });
+                        for (const [key, value] of Object.entries(sseHeaders)){
+                            headers.set(key, value);
+                        }
+                        const headResponse1 = initResponse({
+                            ctx,
+                            info,
+                            responseMeta: opts.responseMeta,
+                            errors: [],
+                            headers,
+                            untransformedJSON: null
+                        });
+                        return new Response(stream, {
+                            headers,
+                            status: headResponse1.status
+                        });
+                    }
+            }
+        }
+        // batch response handlers
+        if (info.accept === 'application/jsonl') {
+            // httpBatchStreamLink
             headers.set('content-type', 'application/json');
-            /**
-       * 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 errors1 = untransformedJSON.flatMap((response)=>'error' in response ? [
-                    response.error
-                ] : []);
-            const headResponse = initResponse({
+            headers.set('transfer-encoding', 'chunked');
+            const headResponse2 = initResponse({
                 ctx,
                 info,
-                type,
                 responseMeta: opts.responseMeta,
-                untransformedJSON,
-                errors: errors1,
-                headers
+                errors: [],
+                headers,
+                untransformedJSON: null
             });
-            // return body stuff
-            const result = info.isBatchCall ? untransformedJSON : untransformedJSON[0];
-            const transformedJSON = transformTRPCResponse(router._def._config, result);
-            const body = JSON.stringify(transformedJSON);
-            return new Response(body, {
-                status: headResponse.status,
-                headers
-            });
-        }
-        headers.set('content-type', 'application/json');
-        headers.set('transfer-encoding', 'chunked');
-        /**
-     * 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 headResponse1 = initResponse({
-            ctx,
-            info,
-            type,
-            responseMeta: opts.responseMeta,
-            errors: [],
-            headers
-        });
-        const stream = jsonlStreamProducer({
-            /**
-       * Example structure for `maxDepth: 4`:
-       * {
-       *   // 1
-       *   0: {
-       *     // 2
-       *     result: {
-       *       // 3
-       *       data: // 4
-       *     }
-       *   }
-       * }
-       */ maxDepth: experimentalIterablesAndDeferreds ? 4 : 3,
-            formatError (errorOpts) {
-                const call = info?.calls[errorOpts.path[0]];
-                return getErrorShape({
-                    config,
-                    ctx,
-                    error: getTRPCErrorFromUnknown(errorOpts.error),
-                    input: call?.result(),
-                    path: call?.path,
-                    type
-                });
-            },
-            data: promises.map(async (it)=>{
-                const response = await it;
-                if ('result' in response) {
+            const stream1 = jsonlStreamProducer({
+                /**
+         * Example structure for `maxDepth: 4`:
+         * {
+         *   // 1
+         *   0: {
+         *     // 2
+         *     result: {
+         *       // 3
+         *       data: // 4
+         *     }
+         *   }
+         * }
+         */ maxDepth: experimentalIterablesAndDeferreds ? 4 : 3,
+                data: rpcCalls.map(async (res)=>{
+                    const [result, error] = await res;
+                    const call = info.calls[0];
+                    if (error) {
+                        return {
+                            error: getErrorShape({
+                                config,
+                                ctx,
+                                error,
+                                input: call.result(),
+                                path: call.path,
+                                type: call.procedure?._def.type ?? 'unknown'
+                            })
+                        };
+                    }
                     /**
            * Not very pretty, but we need to wrap nested data in promises
            * Our stream producer will only resolve top-level async values or async values that are directly nested in another async value
-           */ return {
-                        ...response,
+           */ const data = isObservable(result) ? observableToAsyncIterable(result) : Promise.resolve(result);
+                    return {
                         result: Promise.resolve({
-                            ...response.result,
-                            data: Promise.resolve(response.result.data)
+                            data
                         })
                     };
+                }),
+                serialize: config.transformer.output.serialize,
+                onError: (cause)=>{
+                    opts.onError?.({
+                        error: getTRPCErrorFromUnknown(cause),
+                        path: undefined,
+                        input: undefined,
+                        ctx,
+                        req: opts.req,
+                        type: info?.type ?? 'unknown'
+                    });
+                },
+                formatError (errorOpts) {
+                    const call = info?.calls[errorOpts.path[0]];
+                    const shape = getErrorShape({
+                        config,
+                        ctx,
+                        error: getTRPCErrorFromUnknown(errorOpts.error),
+                        input: call?.result(),
+                        path: call?.path,
+                        type: call?.procedure?._def.type ?? 'unknown'
+                    });
+                    return shape;
                 }
-                return response;
-            }),
-            serialize: config.transformer.output.serialize,
-            onError: (cause)=>{
-                opts.onError?.({
-                    error: getTRPCErrorFromUnknown(cause),
-                    path: undefined,
-                    input: undefined,
-                    ctx,
-                    type,
-                    req: opts.req
-                });
+            });
+            return new Response(stream1, {
+                headers,
+                status: headResponse2.status
+            });
+        }
+        // httpBatchLink
+        /**
+     * Non-streaming response:
+     * - await all responses in parallel, blocking on the slowest one
+     * - create headers with known response body
+     * - return a complete HTTPResponse
+     */ headers.set('content-type', 'application/json');
+        const results = (await Promise.all(rpcCalls)).map((res)=>{
+            const [data, error] = res;
+            if (error) {
+                return res;
             }
+            if (isDataStream(data)) {
+                return [
+                    null,
+                    new TRPCError({
+                        code: 'UNSUPPORTED_MEDIA_TYPE',
+                        message: 'Cannot use stream-like response in non-streaming request - use httpBatchStreamLink'
+                    })
+                ];
+            }
+            return res;
         });
-        return new Response(stream, {
-            headers,
-            status: headResponse1.status
+        const resultAsRPCResponse = results.map(([data, error], index)=>{
+            const call = info.calls[index];
+            if (error) {
+                return {
+                    error: getErrorShape({
+                        config,
+                        ctx,
+                        error,
+                        input: call.result(),
+                        path: call.path,
+                        type: call.procedure?._def.type ?? 'unknown'
+                    })
+                };
+            }
+            return {
+                result: {
+                    data
+                }
+            };
+        });
+        const errors = results.map(([_, error])=>error).filter(Boolean);
+        const headResponse3 = initResponse({
+            ctx,
+            info,
+            responseMeta: opts.responseMeta,
+            untransformedJSON: resultAsRPCResponse,
+            errors,
+            headers
+        });
+        return new Response(JSON.stringify(transformTRPCResponse(config, resultAsRPCResponse)), {
+            status: headResponse3.status,
+            headers
         });
     } catch (cause) {
         // we get here if
@@ -294,24 +448,23 @@ async function resolveResponse(opts) {
         // - post body is too large
         // - input deserialization fails
         // - `errorFormatter` return value is malformed
-        const { error , untransformedJSON: untransformedJSON1 , body: body1  } = caughtErrorToData(cause, {
+        const { error: error1 , untransformedJSON , body  } = caughtErrorToData(cause, {
             opts,
             ctx,
-            type
+            type: info?.type ?? 'unknown'
         });
-        const headResponse2 = initResponse({
+        const headResponse4 = initResponse({
             ctx,
             info,
-            type,
             responseMeta: opts.responseMeta,
-            untransformedJSON: untransformedJSON1,
+            untransformedJSON,
             errors: [
-                error
+                error1
             ],
             headers
         });
-        return new Response(body1, {
-            status: headResponse2.status,
+        return new Response(body, {
+            status: headResponse4.status,
             headers
         });
     }

package/dist/unstable-core-do-not-import/http/types.d.ts

@@ -1,5 +1,5 @@
 import type { TRPCError } from '../error/TRPCError';
-import type { ErrorHandlerOptions, ProcedureType } from '../procedure';
+import type { AnyProcedure, ErrorHandlerOptions, ProcedureType } from '../procedure';
 import type { AnyRouter, inferRouterContext, inferRouterError } from '../router';
 import type { TRPCResponse } from '../rpc';
 import type { Dict } from '../types';
@@ -41,6 +41,7 @@ export interface HTTPBaseHandlerOptions<TRouter extends AnyRouter, TRequest> ext
      */
     responseMeta?: ResponseMetaFn<TRouter>;
 }
+export type TRPCAcceptHeader = 'application/jsonl';
 interface TRPCRequestInfoProcedureCall {
     path: string;
     /**
@@ -51,15 +52,43 @@ interface TRPCRequestInfoProcedureCall {
      * Get already parsed inputs - won't trigger reading the body or parsing the inputs
      */
     result: () => unknown;
+    /**
+     * The procedure being called, `null` if not found
+     * @internal
+     */
+    procedure: AnyProcedure | null;
+}
+export interface TRPCRequestInfoBase {
+    /**
+     * The `trpc-accept` header
+     */
+    accept: TRPCAcceptHeader | null;
+    /**
+     * The type of the request
+     */
+    type: ProcedureType | 'unknown';
+    /**
+     * If the content type handler has detected that this is a batch call
+     */
+    isBatchCall: boolean;
+    /**
+     * The calls being made
+     */
+    calls: TRPCRequestInfoProcedureCall[];
+}
+interface TRPCRequestInfoBatchCall extends TRPCRequestInfoBase {
+    isBatchCall: true;
+    calls: TRPCRequestInfoProcedureCall[];
+}
+interface TRPCRequestInfoSingleCall extends TRPCRequestInfoBase {
+    isBatchCall: false;
+    calls: [TRPCRequestInfoProcedureCall];
 }
 /**
  * Information about the incoming request
  * @public
  */
-export interface TRPCRequestInfo {
-    isBatchCall: boolean;
-    calls: TRPCRequestInfoProcedureCall[];
-}
+export type TRPCRequestInfo = TRPCRequestInfoBatchCall | TRPCRequestInfoSingleCall;
 /**
  * Inner createContext function for `resolveResponse` used to forward `TRPCRequestInfo` to `createContext`
  * @internal

package/dist/unstable-core-do-not-import/http/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/unstable-core-do-not-import/http/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AACvE,OAAO,KAAK,EACV,SAAS,EACT,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAC3C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAErC;;GAEG;AACH,KAAK,WAAW,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,MAAM,CAAC,CAAC;AAE3C,MAAM,WAAW,YAAY;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,GAAG,WAAW,CAAC;CACjC;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,CAAC,OAAO,SAAS,SAAS,IAAI,CAAC,IAAI,EAAE;IAC7D,IAAI,EAAE,YAAY,CAAC,OAAO,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC;IACzD,GAAG,CAAC,EAAE,kBAAkB,CAAC,OAAO,CAAC,CAAC;IAClC;;;QAGI;IACJ,KAAK,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IAC5B,IAAI,EAAE,eAAe,GAAG,SAAS,CAAC;IAClC,IAAI,EAAE,aAAa,GAAG,SAAS,CAAC;IAChC,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB;;OAEG;IACH,eAAe,EAAE,OAAO,CAAC;CAC1B,KAAK,YAAY,CAAC;AAEnB;;GAEG;AACH,MAAM,WAAW,sBAAsB,CAAC,OAAO,SAAS,SAAS,EAAE,QAAQ,CACzE,SAAQ,kBAAkB,CAAC,OAAO,EAAE,QAAQ,CAAC;IAC7C;;;;OAIG;IACH,YAAY,CAAC,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC;CACxC;AAED,UAAU,4BAA4B;IACpC,IAAI,EAAE,MAAM,CAAC;IACb;;OAEG;IACH,WAAW,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IACpC;;OAEG;IACH,MAAM,EAAE,MAAM,OAAO,CAAC;CACvB;AAED;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,WAAW,EAAE,OAAO,CAAC;IACrB,KAAK,EAAE,4BAA4B,EAAE,CAAC;CACvC;AAED;;;GAGG;AACH,MAAM,MAAM,kCAAkC,CAAC,OAAO,SAAS,SAAS,IACtE,CAAC,IAAI,EAAE;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,KAAK,OAAO,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,CAAC;AAE5E,UAAU,uBAAuB,CAAC,OAAO,SAAS,SAAS,EAAE,QAAQ,CACnE,SAAQ,mBAAmB,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC;IACxD,GAAG,EAAE,QAAQ,CAAC;CACf;AACD;;GAEG;AACH,MAAM,MAAM,gBAAgB,CAAC,OAAO,SAAS,SAAS,EAAE,QAAQ,IAAI,CAClE,IAAI,EAAE,uBAAuB,CAAC,OAAO,EAAE,QAAQ,CAAC,KAC7C,IAAI,CAAC;AAEV;;;GAGG;AACH,MAAM,WAAW,kBAAkB,CAAC,OAAO,SAAS,SAAS,EAAE,QAAQ;IACrE,OAAO,CAAC,EAAE,gBAAgB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC9C;;OAEG;IACH,QAAQ,CAAC,EAAE;QACT;;WAEG;QACH,OAAO,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,MAAM,EAAE,OAAO,CAAC;IAChB;;;OAGG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/unstable-core-do-not-import/http/types.ts"],"names":[],"mappings":"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"}