@trpc/server 11.18.1-canary.9 → 11.19.0

package/src/adapters/ws.ts

@@ -406,6 +406,7 @@ export function getWSConnectionHandler<TRouter extends AnyRouter>(
           });
           clientSubscriptions.delete(id);
         }).catch((cause) => {
+          clientSubscriptions.delete(id);
           const error = getTRPCErrorFromUnknown(cause);
           opts.onError?.({ error, path, type, ctx, req, input });
           respond({
@@ -585,13 +586,13 @@ export function handleKeepAlive(
     const scheduleTimeout = () => {
       timeout = setTimeout(() => {
         client.terminate();
-      }, pongWaitMs) as any;
+      }, pongWaitMs);
     };
     ping = setTimeout(() => {
       client.send('PING');
 
       scheduleTimeout();
-    }, pingMs) as any;
+    }, pingMs);
   };
 
   const onMessage = () => {

package/src/adapters/wsEncoder.ts

@@ -12,7 +12,7 @@
  */
 export interface Encoder {
   /** Encode data for transmission over the wire */
-  encode(data: unknown): string | Uint8Array;
+  encode(data: unknown): string | Uint8Array<ArrayBuffer>;
   /** Decode data received from the wire */
   decode(data: string | ArrayBuffer | Uint8Array): unknown;
 }

package/src/observable/behaviorSubject.ts

@@ -7,8 +7,10 @@ export interface BehaviorSubject<TValue> extends Observable<TValue, never> {
   get: () => TValue;
 }
 
-export interface ReadonlyBehaviorSubject<TValue>
-  extends Omit<BehaviorSubject<TValue>, 'next'> {}
+export interface ReadonlyBehaviorSubject<TValue> extends Omit<
+  BehaviorSubject<TValue>,
+  'next'
+> {}
 
 /**
  * @internal

package/src/observable/types.ts

@@ -5,8 +5,10 @@ export type UnsubscribeFn = () => void;
 interface Subscribable<TValue, TError> {
   subscribe(observer: Partial<Observer<TValue, TError>>): Unsubscribable;
 }
-export interface Observable<TValue, TError>
-  extends Subscribable<TValue, TError> {
+export interface Observable<TValue, TError> extends Subscribable<
+  TValue,
+  TError
+> {
   pipe(): Observable<TValue, TError>;
   pipe<TValue1, TError1>(
     op1: OperatorFunction<TValue, TError, TValue1, TError1>,

package/src/unstable-core-do-not-import/clientish/inferrable.ts

@@ -29,10 +29,7 @@ type RootConfigLike = {
  * Anything that can be inferred to the root config types needed for a TRPC client
  */
 export type InferrableClientTypes =
-  | RouterLike
-  | InitLike
-  | RootConfigLike
-  | AnyClientTypes;
+  RouterLike | InitLike | RootConfigLike | AnyClientTypes;
 
 type PickTypes<T extends AnyClientTypes> = {
   transformer: T['transformer'];

package/src/unstable-core-do-not-import/http/contentType.ts

@@ -12,7 +12,7 @@ export function getAcceptHeader(headers: Headers): TRPCAcceptHeader | null {
       .get('accept')
       ?.split(',')
       .some((t) => t.trim() === 'application/jsonl')
-      ? ('application/jsonl' as TRPCAcceptHeader)
+      ? 'application/jsonl'
       : null)
   );
 }

package/src/unstable-core-do-not-import/http/resolveResponse.ts

@@ -35,13 +35,7 @@ function errorToAsyncIterable(err: TRPCError): AsyncIterable<never> {
   });
 }
 type HTTPMethods =
-  | 'GET'
-  | 'POST'
-  | 'HEAD'
-  | 'OPTIONS'
-  | 'PUT'
-  | 'DELETE'
-  | 'PATCH';
+  'GET' | 'POST' | 'HEAD' | 'OPTIONS' | 'PUT' | 'DELETE' | 'PATCH';
 
 function combinedAbortController(signal: AbortSignal) {
   const controller = new AbortController();
@@ -67,8 +61,9 @@ const TYPE_ACCEPTED_METHOD_MAP_WITH_METHOD_OVERRIDE: Record<
   subscription: ['GET', 'POST'],
 };
 
-interface ResolveHTTPRequestOptions<TRouter extends AnyRouter>
-  extends HTTPBaseHandlerOptions<TRouter, Request> {
+interface ResolveHTTPRequestOptions<
+  TRouter extends AnyRouter,
+> extends HTTPBaseHandlerOptions<TRouter, Request> {
   createContext: ResolveHTTPRequestOptionsContextFn<TRouter>;
   req: Request;
   path: string;

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

@@ -45,8 +45,10 @@ export type ResponseMetaFn<TRouter extends AnyRouter> = (opts: {
 /**
  * Base interface for anything using HTTP
  */
-export interface HTTPBaseHandlerOptions<TRouter extends AnyRouter, TRequest>
-  extends BaseHandlerOptions<TRouter, TRequest> {
+export interface HTTPBaseHandlerOptions<
+  TRouter extends AnyRouter,
+  TRequest,
+> extends BaseHandlerOptions<TRouter, TRequest> {
   /**
    * Add handler to be called before response is sent to the user
    * Useful for setting cache headers
@@ -121,8 +123,10 @@ export interface TRPCRequestInfo {
 export type ResolveHTTPRequestOptionsContextFn<TRouter extends AnyRouter> =
   (opts: { info: TRPCRequestInfo }) => Promise<inferRouterContext<TRouter>>;
 
-interface HTTPErrorHandlerOptions<TRouter extends AnyRouter, TRequest>
-  extends ErrorHandlerOptions<inferRouterContext<TRouter>> {
+interface HTTPErrorHandlerOptions<
+  TRouter extends AnyRouter,
+  TRequest,
+> extends ErrorHandlerOptions<inferRouterContext<TRouter>> {
   req: TRequest;
 }
 /**

package/src/unstable-core-do-not-import/initTRPC.ts

@@ -32,16 +32,16 @@ export interface RuntimeConfigOptions<
   TContext extends object,
   TMeta extends object,
 > extends Partial<
-    Omit<
-      RootConfig<{
-        ctx: TContext;
-        meta: TMeta;
-        errorShape: any;
-        transformer: any;
-      }>,
-      '$types' | 'transformer'
-    >
-  > {
+  Omit<
+    RootConfig<{
+      ctx: TContext;
+      meta: TMeta;
+      errorShape: any;
+      transformer: any;
+    }>,
+    '$types' | 'transformer'
+  >
+> {
   /**
    * Use a data transformer
    * @see https://trpc.io/docs/v11/data-transformers

package/src/unstable-core-do-not-import/middleware.ts

@@ -24,8 +24,9 @@ interface MiddlewareOKResult<_TContextOverride> extends MiddlewareResultBase {
   // this could be extended with `input`/`rawInput` later
 }
 
-interface MiddlewareErrorResult<_TContextOverride>
-  extends MiddlewareResultBase {
+interface MiddlewareErrorResult<
+  _TContextOverride,
+> extends MiddlewareResultBase {
   ok: false;
   error: TRPCError;
 }

package/src/unstable-core-do-not-import/procedure.ts

@@ -52,14 +52,17 @@ export interface Procedure<
   (opts: ProcedureCallOptions<unknown>): Promise<TDef['output']>;
 }
 
-export interface QueryProcedure<TDef extends BuiltProcedureDef>
-  extends Procedure<'query', TDef> {}
+export interface QueryProcedure<
+  TDef extends BuiltProcedureDef,
+> extends Procedure<'query', TDef> {}
 
-export interface MutationProcedure<TDef extends BuiltProcedureDef>
-  extends Procedure<'mutation', TDef> {}
+export interface MutationProcedure<
+  TDef extends BuiltProcedureDef,
+> extends Procedure<'mutation', TDef> {}
 
-export interface SubscriptionProcedure<TDef extends BuiltProcedureDef>
-  extends Procedure<'subscription', TDef> {}
+export interface SubscriptionProcedure<
+  TDef extends BuiltProcedureDef,
+> extends Procedure<'subscription', TDef> {}
 
 /**
  * @deprecated
@@ -73,13 +76,10 @@ export interface LegacyObservableSubscriptionProcedure<
 export type AnyQueryProcedure = QueryProcedure<any>;
 export type AnyMutationProcedure = MutationProcedure<any>;
 export type AnySubscriptionProcedure =
-  | SubscriptionProcedure<any>
-  | LegacyObservableSubscriptionProcedure<any>;
+  SubscriptionProcedure<any> | LegacyObservableSubscriptionProcedure<any>;
 
 export type AnyProcedure =
-  | AnyQueryProcedure
-  | AnyMutationProcedure
-  | AnySubscriptionProcedure;
+  AnyQueryProcedure | AnyMutationProcedure | AnySubscriptionProcedure;
 
 export type inferProcedureInput<TProcedure extends AnyProcedure> =
   undefined extends inferProcedureParams<TProcedure>['$types']['input']

package/src/unstable-core-do-not-import/router.ts

@@ -223,10 +223,7 @@ const reservedWords = [
 /** @internal */
 export type CreateRouterOptions = {
   [key: string]:
-    | AnyProcedure
-    | AnyRouter
-    | CreateRouterOptions
-    | Lazy<AnyRouter>;
+    AnyProcedure | AnyRouter | CreateRouterOptions | Lazy<AnyRouter>;
 };
 
 /** @internal */
@@ -378,7 +375,9 @@ export async function getProcedureAtPath(
   let procedure = _def.procedures[path];
 
   while (!procedure) {
-    const key = Object.keys(_def.lazy).find((key) => path.startsWith(key));
+    const key = Object.keys(_def.lazy).find(
+      (key) => path === key || path.startsWith(key + '.'),
+    );
     // console.log(`found lazy: ${key ?? 'NOPE'} (fullPath: ${fullPath})`);
 
     if (!key) {

package/src/unstable-core-do-not-import/rpc/envelopes.ts

@@ -26,13 +26,16 @@ export namespace JSONRPC2 {
     jsonrpc?: '2.0';
   }
 
-  export interface BaseRequest<TMethod extends string = string>
-    extends BaseEnvelope {
+  export interface BaseRequest<
+    TMethod extends string = string,
+  > extends BaseEnvelope {
     method: TMethod;
   }
 
-  export interface Request<TMethod extends string = string, TParams = unknown>
-    extends BaseRequest<TMethod> {
+  export interface Request<
+    TMethod extends string = string,
+    TParams = unknown,
+  > extends BaseRequest<TMethod> {
     params: TParams;
   }
 
@@ -40,26 +43,26 @@ export namespace JSONRPC2 {
     result: TResult;
   }
 
-  export interface ErrorResponse<TError extends TRPCErrorShape = TRPCErrorShape>
-    extends BaseEnvelope {
+  export interface ErrorResponse<
+    TError extends TRPCErrorShape = TRPCErrorShape,
+  > extends BaseEnvelope {
     error: TError;
   }
 }
 
 /////////////////////////// HTTP envelopes ///////////////////////
 
-export interface TRPCRequest
-  extends JSONRPC2.Request<
-    ProcedureType,
-    {
-      path: string;
-      input: unknown;
-      /**
-       * The last event id that the client received
-       */
-      lastEventId?: string;
-    }
-  > {}
+export interface TRPCRequest extends JSONRPC2.Request<
+  ProcedureType,
+  {
+    path: string;
+    input: unknown;
+    /**
+     * The last event id that the client received
+     */
+    lastEventId?: string;
+  }
+> {}
 
 export interface TRPCResult<TData = unknown> {
   data: TData;
@@ -70,8 +73,9 @@ export interface TRPCResult<TData = unknown> {
   id?: string;
 }
 
-export interface TRPCSuccessResponse<TData>
-  extends JSONRPC2.ResultResponse<TRPCResult<TData>> {}
+export interface TRPCSuccessResponse<TData> extends JSONRPC2.ResultResponse<
+  TRPCResult<TData>
+> {}
 
 export interface TRPCErrorResponse<
   TError extends TRPCErrorShape = TRPCErrorShape,
@@ -91,8 +95,7 @@ export type TRPCRequestMessage = TRPCRequest & {
 /**
  * The client asked the server to unsubscribe
  */
-export interface TRPCSubscriptionStopNotification
-  extends JSONRPC2.BaseRequest<'subscription.stop'> {
+export interface TRPCSubscriptionStopNotification extends JSONRPC2.BaseRequest<'subscription.stop'> {
   id: null;
 }
 
@@ -108,26 +111,23 @@ export type TRPCClientOutgoingMessage =
   | TRPCRequestMessage
   | (JSONRPC2.BaseRequest<'subscription.stop'> & { id: JSONRPC2.RequestId });
 
-export interface TRPCResultMessage<TData>
-  extends JSONRPC2.ResultResponse<
-    | { type: 'started'; data?: never }
-    | { type: 'stopped'; data?: never }
-    | TRPCResult<TData>
-  > {}
+export interface TRPCResultMessage<TData> extends JSONRPC2.ResultResponse<
+  | { type: 'started'; data?: never }
+  | { type: 'stopped'; data?: never }
+  | TRPCResult<TData>
+> {}
 
 export type TRPCResponseMessage<
   TData = unknown,
   TError extends TRPCErrorShape = TRPCErrorShape,
 > = { id: JSONRPC2.RequestId } & (
-  | TRPCErrorResponse<TError>
-  | TRPCResultMessage<TData>
+  TRPCErrorResponse<TError> | TRPCResultMessage<TData>
 );
 
 /**
  * The server asked the client to reconnect - useful when restarting/redeploying service
  */
-export interface TRPCReconnectNotification
-  extends JSONRPC2.BaseRequest<'reconnect'> {
+export interface TRPCReconnectNotification extends JSONRPC2.BaseRequest<'reconnect'> {
   id: JSONRPC2.RequestId;
 }
 
@@ -147,7 +147,6 @@ export type TRPCClientIncomingMessage<
 /**
  * The client sends connection params - always sent as the first message
  */
-export interface TRPCConnectionParamsMessage
-  extends JSONRPC2.BaseRequest<'connectionParams'> {
+export interface TRPCConnectionParamsMessage extends JSONRPC2.BaseRequest<'connectionParams'> {
   data: TRPCRequestInfo['connectionParams'];
 }

package/src/unstable-core-do-not-import/stream/jsonl.ts

@@ -57,8 +57,7 @@ type ChunkDefinitionKey =
 
 type ChunkIndex = number & { __chunkIndex: true };
 type ChunkValueType =
-  | CHUNK_VALUE_TYPE_PROMISE
-  | CHUNK_VALUE_TYPE_ASYNC_ITERABLE;
+  CHUNK_VALUE_TYPE_PROMISE | CHUNK_VALUE_TYPE_ASYNC_ITERABLE;
 type ChunkDefinition = [
   key: ChunkDefinitionKey,
   type: ChunkValueType,

package/src/unstable-core-do-not-import/stream/sse.ts

@@ -202,35 +202,41 @@ interface ConsumerStreamResultBase<TConfig extends ConsumerConfig> {
   eventSource: InstanceType<TConfig['EventSource']> | null;
 }
 
-interface ConsumerStreamResultData<TConfig extends ConsumerConfig>
-  extends ConsumerStreamResultBase<TConfig> {
+interface ConsumerStreamResultData<
+  TConfig extends ConsumerConfig,
+> extends ConsumerStreamResultBase<TConfig> {
   type: 'data';
   data: inferTrackedOutput<TConfig['data']>;
 }
 
-interface ConsumerStreamResultError<TConfig extends ConsumerConfig>
-  extends ConsumerStreamResultBase<TConfig> {
+interface ConsumerStreamResultError<
+  TConfig extends ConsumerConfig,
+> extends ConsumerStreamResultBase<TConfig> {
   type: 'serialized-error';
   error: TConfig['error'];
 }
 
-interface ConsumerStreamResultConnecting<TConfig extends ConsumerConfig>
-  extends ConsumerStreamResultBase<TConfig> {
+interface ConsumerStreamResultConnecting<
+  TConfig extends ConsumerConfig,
+> extends ConsumerStreamResultBase<TConfig> {
   type: 'connecting';
   event: EventSourceLike.EventOf<TConfig['EventSource']> | null;
 }
-interface ConsumerStreamResultTimeout<TConfig extends ConsumerConfig>
-  extends ConsumerStreamResultBase<TConfig> {
+interface ConsumerStreamResultTimeout<
+  TConfig extends ConsumerConfig,
+> extends ConsumerStreamResultBase<TConfig> {
   type: 'timeout';
   ms: number;
 }
-interface ConsumerStreamResultPing<TConfig extends ConsumerConfig>
-  extends ConsumerStreamResultBase<TConfig> {
+interface ConsumerStreamResultPing<
+  TConfig extends ConsumerConfig,
+> extends ConsumerStreamResultBase<TConfig> {
   type: 'ping';
 }
 
-interface ConsumerStreamResultConnected<TConfig extends ConsumerConfig>
-  extends ConsumerStreamResultBase<TConfig> {
+interface ConsumerStreamResultConnected<
+  TConfig extends ConsumerConfig,
+> extends ConsumerStreamResultBase<TConfig> {
   type: 'connected';
   options: SSEClientOptions;
 }

package/src/unstable-core-do-not-import/stream/utils/mergeAsyncIterables.ts

@@ -55,8 +55,11 @@ type ManagedIterator<TYield, TReturn> = ReturnType<
   typeof createManagedIterator<TYield, TReturn>
 >;
 
-interface MergedAsyncIterables<TYield>
-  extends AsyncIterable<TYield, void, unknown> {
+interface MergedAsyncIterables<TYield> extends AsyncIterable<
+  TYield,
+  void,
+  unknown
+> {
   add(iterable: AsyncIterable<TYield>): void;
 }
 

package/src/unstable-core-do-not-import/stream/utils/withPing.ts

@@ -16,9 +16,7 @@ export async function* withPing<TValue>(
 
   // declaration outside the loop for garbage collection reasons
   let result:
-    | null
-    | IteratorResult<TValue>
-    | typeof disposablePromiseTimerResult;
+    null | IteratorResult<TValue> | typeof disposablePromiseTimerResult;
 
   let nextPromise = iterator.next();
 

package/src/unstable-core-do-not-import/transformer.ts

@@ -112,10 +112,7 @@ function transformTRPCResponseItem<
  **/
 export function transformTRPCResponse<
   TResponse extends
-    | TRPCResponse
-    | TRPCResponse[]
-    | TRPCResponseMessage
-    | TRPCResponseMessage[],
+    TRPCResponse | TRPCResponse[] | TRPCResponseMessage | TRPCResponseMessage[],
 >(config: RootConfig<AnyRootTypes>, itemOrItems: TResponse) {
   return Array.isArray(itemOrItems)
     ? itemOrItems.map((item) => transformTRPCResponseItem(config, item))

package/src/unstable-core-do-not-import/types.ts

@@ -35,8 +35,7 @@ export type FilterKeys<TObj extends object, TFilter> = {
  * @internal
  */
 export type Result<TType, TErr = unknown> =
-  | { ok: true; value: TType }
-  | { ok: false; error: TErr };
+  { ok: true; value: TType } | { ok: false; error: TErr };
 
 /**
  * @internal
@@ -80,11 +79,9 @@ export type DistributiveOmit<TObj, TKey extends keyof any> = TObj extends any
  * @internal
  */
 export type WithoutIndexSignature<TObj> = {
-  [K in keyof TObj as string extends K
-    ? never
-    : number extends K
-      ? never
-      : K]: TObj[K];
+  [
+    K in keyof TObj as string extends K ? never : number extends K ? never : K
+  ]: TObj[K];
 };
 
 /**
@@ -96,9 +93,11 @@ export type WithoutIndexSignature<TObj> = {
 export type Overwrite<TType, TWith> = TWith extends any
   ? TType extends object
     ? {
-        [K in  // Exclude index signature from keys
-          | keyof WithoutIndexSignature<TType>
-          | keyof WithoutIndexSignature<TWith>]: K extends keyof TWith
+        [
+          K in  // Exclude index signature from keys
+            | keyof WithoutIndexSignature<TType>
+            | keyof WithoutIndexSignature<TWith>
+        ]: K extends keyof TWith
           ? TWith[K]
           : K extends keyof TType
             ? TType[K]

package/dist/codes-DagpWZLc.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"codes-DagpWZLc.mjs","names":["obj1: TType","newObj: TType","value: unknown","fn: unknown","fn: () => TValue","it: T","condition: boolean","signals: AbortSignal[]","TRPC_ERROR_CODES_BY_NUMBER: InvertKeyValue<\n  typeof TRPC_ERROR_CODES_BY_KEY\n>","retryableRpcCodes: TRPC_ERROR_CODE_NUMBER[]"],"sources":["../src/unstable-core-do-not-import/utils.ts","../src/unstable-core-do-not-import/rpc/codes.ts"],"sourcesContent":["/** @internal */\nexport type UnsetMarker = 'unsetMarker' & {\n  __brand: 'unsetMarker';\n};\n\n/**\n * Ensures there are no duplicate keys when building a procedure.\n * @internal\n */\nexport function mergeWithoutOverrides<TType extends Record<string, unknown>>(\n  obj1: TType,\n  ...objs: Partial<TType>[]\n): TType {\n  const newObj: TType = Object.assign(emptyObject(), obj1);\n\n  for (const overrides of objs) {\n    for (const key in overrides) {\n      if (key in newObj && newObj[key] !== overrides[key]) {\n        throw new Error(`Duplicate key ${key}`);\n      }\n      newObj[key as keyof TType] = overrides[key] as TType[keyof TType];\n    }\n  }\n  return newObj;\n}\n\n/**\n * Check that value is object\n * @internal\n */\nexport function isObject(value: unknown): value is Record<string, unknown> {\n  return !!value && !Array.isArray(value) && typeof value === 'object';\n}\n\ntype AnyFn = ((...args: any[]) => unknown) & Record<keyof any, unknown>;\nexport function isFunction(fn: unknown): fn is AnyFn {\n  return typeof fn === 'function';\n}\n\n/**\n * Create an object without inheriting anything from `Object.prototype`\n * @internal\n */\nexport function emptyObject<TObj extends Record<string, unknown>>(): TObj {\n  return Object.create(null);\n}\n\nconst asyncIteratorsSupported =\n  typeof Symbol === 'function' && !!Symbol.asyncIterator;\n\nexport function isAsyncIterable<TValue>(\n  value: unknown,\n): value is AsyncIterable<TValue> {\n  return (\n    asyncIteratorsSupported && isObject(value) && Symbol.asyncIterator in value\n  );\n}\n\n/**\n * Run an IIFE\n */\nexport const run = <TValue>(fn: () => TValue): TValue => fn();\n\n// eslint-disable-next-line @typescript-eslint/no-empty-function\nexport function noop(): void {}\n\nexport function identity<T>(it: T): T {\n  return it;\n}\n\n/**\n * Generic runtime assertion function. Throws, if the condition is not `true`.\n *\n * Can be used as a slightly less dangerous variant of type assertions. Code\n * mistakes would be revealed at runtime then (hopefully during testing).\n */\nexport function assert(\n  condition: boolean,\n  msg = 'no additional info',\n): asserts condition {\n  if (!condition) {\n    throw new Error(`AssertionError: ${msg}`);\n  }\n}\n\nexport function sleep(ms = 0): Promise<void> {\n  return new Promise<void>((res) => setTimeout(res, ms));\n}\n\n/**\n * Ponyfill for\n * [`AbortSignal.any`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/any_static).\n */\nexport function abortSignalsAnyPonyfill(signals: AbortSignal[]): AbortSignal {\n  if (typeof AbortSignal.any === 'function') {\n    return AbortSignal.any(signals);\n  }\n\n  const ac = new AbortController();\n\n  for (const signal of signals) {\n    if (signal.aborted) {\n      trigger();\n      break;\n    }\n    signal.addEventListener('abort', trigger, { once: true });\n  }\n\n  return ac.signal;\n\n  function trigger() {\n    ac.abort();\n    for (const signal of signals) {\n      signal.removeEventListener('abort', trigger);\n    }\n  }\n}\n","import type { InvertKeyValue, ValueOf } from '../types';\n\n// reference: https://www.jsonrpc.org/specification\n\n/**\n * JSON-RPC 2.0 Error codes\n *\n * `-32000` to `-32099` are reserved for implementation-defined server-errors.\n * For tRPC we're copying the last digits of HTTP 4XX errors.\n */\nexport const TRPC_ERROR_CODES_BY_KEY = {\n  /**\n   * Invalid JSON was received by the server.\n   * An error occurred on the server while parsing the JSON text.\n   */\n  PARSE_ERROR: -32700,\n  /**\n   * The JSON sent is not a valid Request object.\n   */\n  BAD_REQUEST: -32600, // 400\n\n  // Internal JSON-RPC error\n  INTERNAL_SERVER_ERROR: -32603, // 500\n  NOT_IMPLEMENTED: -32603, // 501\n  BAD_GATEWAY: -32603, // 502\n  SERVICE_UNAVAILABLE: -32603, // 503\n  GATEWAY_TIMEOUT: -32603, // 504\n\n  // Implementation specific errors\n  UNAUTHORIZED: -32001, // 401\n  PAYMENT_REQUIRED: -32002, // 402\n  FORBIDDEN: -32003, // 403\n  NOT_FOUND: -32004, // 404\n  METHOD_NOT_SUPPORTED: -32005, // 405\n  TIMEOUT: -32008, // 408\n  CONFLICT: -32009, // 409\n  PRECONDITION_FAILED: -32012, // 412\n  PAYLOAD_TOO_LARGE: -32013, // 413\n  UNSUPPORTED_MEDIA_TYPE: -32015, // 415\n  UNPROCESSABLE_CONTENT: -32022, // 422\n  PRECONDITION_REQUIRED: -32028, // 428\n  TOO_MANY_REQUESTS: -32029, // 429\n  CLIENT_CLOSED_REQUEST: -32099, // 499\n} as const;\n\n// pure\nexport const TRPC_ERROR_CODES_BY_NUMBER: InvertKeyValue<\n  typeof TRPC_ERROR_CODES_BY_KEY\n> = {\n  [-32700]: 'PARSE_ERROR',\n  [-32600]: 'BAD_REQUEST',\n  [-32603]: 'INTERNAL_SERVER_ERROR',\n  [-32001]: 'UNAUTHORIZED',\n  [-32002]: 'PAYMENT_REQUIRED',\n  [-32003]: 'FORBIDDEN',\n  [-32004]: 'NOT_FOUND',\n  [-32005]: 'METHOD_NOT_SUPPORTED',\n  [-32008]: 'TIMEOUT',\n  [-32009]: 'CONFLICT',\n  [-32012]: 'PRECONDITION_FAILED',\n  [-32013]: 'PAYLOAD_TOO_LARGE',\n  [-32015]: 'UNSUPPORTED_MEDIA_TYPE',\n  [-32022]: 'UNPROCESSABLE_CONTENT',\n  [-32028]: 'PRECONDITION_REQUIRED',\n  [-32029]: 'TOO_MANY_REQUESTS',\n  [-32099]: 'CLIENT_CLOSED_REQUEST',\n};\n\nexport type TRPC_ERROR_CODE_NUMBER = ValueOf<typeof TRPC_ERROR_CODES_BY_KEY>;\nexport type TRPC_ERROR_CODE_KEY = keyof typeof TRPC_ERROR_CODES_BY_KEY;\n\n/**\n * tRPC error codes that are considered retryable\n * With out of the box SSE, the client will reconnect when these errors are encountered\n */\nexport const retryableRpcCodes: TRPC_ERROR_CODE_NUMBER[] = [\n  TRPC_ERROR_CODES_BY_KEY.BAD_GATEWAY,\n  TRPC_ERROR_CODES_BY_KEY.SERVICE_UNAVAILABLE,\n  TRPC_ERROR_CODES_BY_KEY.GATEWAY_TIMEOUT,\n  TRPC_ERROR_CODES_BY_KEY.INTERNAL_SERVER_ERROR,\n];\n"],"mappings":";;;;;AASA,SAAgB,sBACdA,MACA,GAAG,MACI;CACP,MAAMC,SAAgB,OAAO,OAAO,aAAa,EAAE,KAAK;AAExD,MAAK,MAAM,aAAa,KACtB,MAAK,MAAM,OAAO,WAAW;AAC3B,MAAI,OAAO,UAAU,OAAO,SAAS,UAAU,KAC7C,OAAM,IAAI,OAAO,gBAAgB,IAAI;AAEvC,SAAO,OAAsB,UAAU;CACxC;AAEH,QAAO;AACR;;;;;AAMD,SAAgB,SAASC,OAAkD;AACzE,UAAS,UAAU,MAAM,QAAQ,MAAM,WAAW,UAAU;AAC7D;AAGD,SAAgB,WAAWC,IAA0B;AACnD,eAAc,OAAO;AACtB;;;;;AAMD,SAAgB,cAA0D;AACxE,QAAO,OAAO,OAAO,KAAK;AAC3B;AAED,MAAM,iCACG,WAAW,gBAAgB,OAAO;AAE3C,SAAgB,gBACdD,OACgC;AAChC,QACE,2BAA2B,SAAS,MAAM,IAAI,OAAO,iBAAiB;AAEzE;;;;AAKD,MAAa,MAAM,CAASE,OAA6B,IAAI;AAG7D,SAAgB,OAAa,CAAE;AAE/B,SAAgB,SAAYC,IAAU;AACpC,QAAO;AACR;;;;;;;AAQD,SAAgB,OACdC,WACA,MAAM,sBACa;AACnB,MAAK,UACH,OAAM,IAAI,OAAO,kBAAkB,IAAI;AAE1C;AAED,SAAgB,MAAM,KAAK,GAAkB;AAC3C,QAAO,IAAI,QAAc,CAAC,QAAQ,WAAW,KAAK,GAAG;AACtD;;;;;AAMD,SAAgB,wBAAwBC,SAAqC;AAC3E,YAAW,YAAY,QAAQ,WAC7B,QAAO,YAAY,IAAI,QAAQ;CAGjC,MAAM,KAAK,IAAI;AAEf,MAAK,MAAM,UAAU,SAAS;AAC5B,MAAI,OAAO,SAAS;AAClB,YAAS;AACT;EACD;AACD,SAAO,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAM,EAAC;CAC1D;AAED,QAAO,GAAG;CAEV,SAAS,UAAU;AACjB,KAAG,OAAO;AACV,OAAK,MAAM,UAAU,QACnB,QAAO,oBAAoB,SAAS,QAAQ;CAE/C;AACF;;;;;;;;;;AC1GD,MAAa,0BAA0B;CAKrC,aAAa;CAIb,aAAa;CAGb,uBAAuB;CACvB,iBAAiB;CACjB,aAAa;CACb,qBAAqB;CACrB,iBAAiB;CAGjB,cAAc;CACd,kBAAkB;CAClB,WAAW;CACX,WAAW;CACX,sBAAsB;CACtB,SAAS;CACT,UAAU;CACV,qBAAqB;CACrB,mBAAmB;CACnB,wBAAwB;CACxB,uBAAuB;CACvB,uBAAuB;CACvB,mBAAmB;CACnB,uBAAuB;AACxB;AAGD,MAAaC,6BAET;EACD,SAAS;EACT,SAAS;EACT,SAAS;EACT,SAAS;EACT,SAAS;EACT,SAAS;EACT,SAAS;EACT,SAAS;EACT,SAAS;EACT,SAAS;EACT,SAAS;EACT,SAAS;EACT,SAAS;EACT,SAAS;EACT,SAAS;EACT,SAAS;EACT,SAAS;AACX;;;;;AASD,MAAaC,oBAA8C;CACzD,wBAAwB;CACxB,wBAAwB;CACxB,wBAAwB;CACxB,wBAAwB;AACzB"}

package/dist/contentTypeParsers-SN4WL9ze.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"contentTypeParsers-SN4WL9ze.mjs","names":["octetInputParser: UtilityParser<OctetInput, ReadableStream>"],"sources":["../src/unstable-core-do-not-import/http/contentTypeParsers.ts"],"sourcesContent":["import type { ParserZodEsque } from '../parser';\n\n/**\n * @internal\n */\nexport type UtilityParser<TInput, TOutput> = ParserZodEsque<TInput, TOutput> & {\n  parse: (input: unknown) => TOutput;\n};\n\n// Should be the same possible types as packages/client/src/links/internals/contentTypes.ts isOctetType\n\n/**\n * @internal\n *\n * File is only available from Node19+ but it always extends Blob so we can use that as a type until we eventually drop Node18\n */\nexport interface FileLike extends Blob {\n  readonly name: string;\n}\n\n/**\n * @internal\n */\nexport type OctetInput = Blob | Uint8Array | FileLike;\n\nexport const octetInputParser: UtilityParser<OctetInput, ReadableStream> = {\n  _input: null as any as OctetInput,\n  _output: null as any as ReadableStream,\n  parse(input) {\n    if (input instanceof ReadableStream) {\n      return input;\n    }\n\n    throw new Error(\n      `Parsed input was expected to be a ReadableStream but was: ${typeof input}`,\n    );\n  },\n};\n"],"mappings":";AAyBA,MAAaA,mBAA8D;CACzE,QAAQ;CACR,SAAS;CACT,MAAM,OAAO;AACX,MAAI,iBAAiB,eACnB,QAAO;AAGT,QAAM,IAAI,OACP,mEAAmE,MAAM;CAE7E;AACF"}