@trpc/server 11.0.0-alpha-tmp-subscription-connection-state.489 → 11.0.0-alpha-tmp-12-06-react.665

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

@@ -13,6 +13,11 @@ export type ParserValibotEsque<TInput, TParsedInput> = {
   };
 };
 
+export type ParserArkTypeEsque<TInput, TParsedInput> = {
+  inferIn: TInput;
+  infer: TParsedInput;
+};
+
 export type ParserMyZodEsque<TInput> = {
   parse: (input: any) => TInput;
 };
@@ -42,7 +47,8 @@ export type ParserWithoutInput<TInput> =
 
 export type ParserWithInputOutput<TInput, TParsedInput> =
   | ParserZodEsque<TInput, TParsedInput>
-  | ParserValibotEsque<TInput, TParsedInput>;
+  | ParserValibotEsque<TInput, TParsedInput>
+  | ParserArkTypeEsque<TInput, TParsedInput>;
 
 export type Parser = ParserWithInputOutput<any, any> | ParserWithoutInput<any>;
 
@@ -53,17 +59,22 @@ export type inferParser<TParser extends Parser> =
         out: $TOut;
       }
     : TParser extends ParserWithoutInput<infer $InOut>
-    ? {
-        in: $InOut;
-        out: $InOut;
-      }
-    : never;
+      ? {
+          in: $InOut;
+          out: $InOut;
+        }
+      : never;
 
 export type ParseFn<TType> = (value: unknown) => Promise<TType> | TType;
 
 export function getParseFn<TType>(procedureParser: Parser): ParseFn<TType> {
   const parser = procedureParser as any;
 
+  if (typeof parser === 'function' && typeof parser.assert === 'function') {
+    // ParserArkTypeEsque - arktype schemas shouldn't be called as a function because they return a union type instead of throwing
+    return parser.assert.bind(parser);
+  }
+
   if (typeof parser === 'function') {
     // ParserValibotEsque (>= v0.31.0)
     // ParserCustomValidatorEsque

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

@@ -66,10 +66,25 @@ export interface MutationProcedure<TDef extends BuiltProcedureDef>
 export interface SubscriptionProcedure<TDef extends BuiltProcedureDef>
   extends Procedure<'subscription', TDef> {}
 
+/**
+ * @deprecated
+ */
+export interface LegacyObservableSubscriptionProcedure<
+  TDef extends BuiltProcedureDef,
+> extends SubscriptionProcedure<TDef> {
+  _observable: true;
+}
+
 export type AnyQueryProcedure = QueryProcedure<any>;
 export type AnyMutationProcedure = MutationProcedure<any>;
-export type AnySubscriptionProcedure = SubscriptionProcedure<any>;
-export type AnyProcedure = Procedure<ProcedureType, any>;
+export type AnySubscriptionProcedure =
+  | SubscriptionProcedure<any>
+  | LegacyObservableSubscriptionProcedure<any>;
+
+export type AnyProcedure =
+  | AnyQueryProcedure
+  | AnyMutationProcedure
+  | AnySubscriptionProcedure;
 
 export type inferProcedureInput<TProcedure extends AnyProcedure> =
   undefined extends inferProcedureParams<TProcedure>['$types']['input']

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

@@ -1,4 +1,4 @@
-import type { inferObservableValue } from '../observable';
+import type { inferObservableValue, Observable } from '../observable';
 import { getTRPCErrorFromUnknown, TRPCError } from './error/TRPCError';
 import type {
   AnyMiddlewareFunction,
@@ -17,7 +17,7 @@ import type {
   AnyMutationProcedure,
   AnyProcedure,
   AnyQueryProcedure,
-  AnySubscriptionProcedure,
+  LegacyObservableSubscriptionProcedure,
   MutationProcedure,
   ProcedureType,
   QueryProcedure,
@@ -37,18 +37,29 @@ import { mergeWithoutOverrides } from './utils';
 type IntersectIfDefined<TType, TWith> = TType extends UnsetMarker
   ? TWith
   : TWith extends UnsetMarker
-  ? TType
-  : Simplify<TType & TWith>;
-``;
+    ? TType
+    : Simplify<TType & TWith>;
+
 type DefaultValue<TValue, TFallback> = TValue extends UnsetMarker
   ? TFallback
   : TValue;
 
-type inferSubscriptionOutput<TOutput> = TOutput extends AsyncIterable<
-  infer $Output
->
-  ? inferTrackedOutput<$Output>
-  : inferObservableValue<TOutput>;
+type inferAsyncIterable<TOutput> =
+  TOutput extends AsyncIterable<infer $Yield, infer $Return, infer $Next>
+    ? {
+        yield: $Yield;
+        return: $Return;
+        next: $Next;
+      }
+    : never;
+type inferSubscriptionOutput<TOutput> =
+  TOutput extends AsyncIterable<any>
+    ? AsyncIterable<
+        inferTrackedOutput<inferAsyncIterable<TOutput>['yield']>,
+        inferAsyncIterable<TOutput>['return'],
+        inferAsyncIterable<TOutput>['next']
+      >
+    : TypeError<'Subscription output could not be inferred'>;
 
 export type CallerOverride<TContext> = (opts: {
   args: unknown[];
@@ -92,6 +103,10 @@ export interface ProcedureResolverOptions<
 > {
   ctx: Simplify<Overwrite<TContext, TContextOverridesIn>>;
   input: TInputOut extends UnsetMarker ? undefined : TInputOut;
+  /**
+   * The AbortSignal of the request
+   */
+  signal: AbortSignal | undefined;
 }
 
 /**
@@ -129,35 +144,36 @@ export type AnyProcedureBuilder = ProcedureBuilder<
  */
 export type inferProcedureBuilderResolverOptions<
   TProcedureBuilder extends AnyProcedureBuilder,
-> = TProcedureBuilder extends ProcedureBuilder<
-  infer TContext,
-  infer TMeta,
-  infer TContextOverrides,
-  infer _TInputIn,
-  infer TInputOut,
-  infer _TOutputIn,
-  infer _TOutputOut,
-  infer _TCaller
->
-  ? ProcedureResolverOptions<
-      TContext,
-      TMeta,
-      TContextOverrides,
-      TInputOut extends UnsetMarker
-        ? // if input is not set, we don't want to infer it as `undefined` since a procedure further down the chain might have set an input
-          unknown
-        : TInputOut extends object
-        ? Simplify<
-            TInputOut & {
-              /**
-               * Extra input params might have been added by a `.input()` further down the chain
-               */
-              [keyAddedByInputCallFurtherDown: string]: unknown;
-            }
-          >
-        : TInputOut
-    >
-  : never;
+> =
+  TProcedureBuilder extends ProcedureBuilder<
+    infer TContext,
+    infer TMeta,
+    infer TContextOverrides,
+    infer _TInputIn,
+    infer TInputOut,
+    infer _TOutputIn,
+    infer _TOutputOut,
+    infer _TCaller
+  >
+    ? ProcedureResolverOptions<
+        TContext,
+        TMeta,
+        TContextOverrides,
+        TInputOut extends UnsetMarker
+          ? // if input is not set, we don't want to infer it as `undefined` since a procedure further down the chain might have set an input
+            unknown
+          : TInputOut extends object
+            ? Simplify<
+                TInputOut & {
+                  /**
+                   * Extra input params might have been added by a `.input()` further down the chain
+                   */
+                  [keyAddedByInputCallFurtherDown: string]: unknown;
+                }
+              >
+            : TInputOut
+      >
+    : never;
 
 export interface ProcedureBuilder<
   TContext,
@@ -171,20 +187,20 @@ export interface ProcedureBuilder<
 > {
   /**
    * Add an input parser to the procedure.
-   * @link https://trpc.io/docs/v11/server/validators
+   * @see https://trpc.io/docs/v11/server/validators
    */
   input<$Parser extends Parser>(
     schema: TInputOut extends UnsetMarker
       ? $Parser
       : inferParser<$Parser>['out'] extends Record<string, unknown> | undefined
-      ? TInputOut extends Record<string, unknown> | undefined
-        ? undefined extends inferParser<$Parser>['out'] // if current is optional the previous must be too
-          ? undefined extends TInputOut
-            ? $Parser
-            : TypeError<'Cannot chain an optional parser to a required parser'>
-          : $Parser
-        : TypeError<'All input parsers did not resolve to an object'>
-      : TypeError<'All input parsers did not resolve to an object'>,
+        ? TInputOut extends Record<string, unknown> | undefined
+          ? undefined extends inferParser<$Parser>['out'] // if current is optional the previous must be too
+            ? undefined extends TInputOut
+              ? $Parser
+              : TypeError<'Cannot chain an optional parser to a required parser'>
+            : $Parser
+          : TypeError<'All input parsers did not resolve to an object'>
+        : TypeError<'All input parsers did not resolve to an object'>,
   ): ProcedureBuilder<
     TContext,
     TMeta,
@@ -197,7 +213,7 @@ export interface ProcedureBuilder<
   >;
   /**
    * Add an output parser to the procedure.
-   * @link https://trpc.io/docs/v11/server/validators
+   * @see https://trpc.io/docs/v11/server/validators
    */
   output<$Parser extends Parser>(
     schema: $Parser,
@@ -213,7 +229,7 @@ export interface ProcedureBuilder<
   >;
   /**
    * Add a meta data to the procedure.
-   * @link https://trpc.io/docs/v11/server/metadata
+   * @see https://trpc.io/docs/v11/server/metadata
    */
   meta(
     meta: TMeta,
@@ -229,7 +245,7 @@ export interface ProcedureBuilder<
   >;
   /**
    * Add a middleware to the procedure.
-   * @link https://trpc.io/docs/v11/server/middlewares
+   * @see https://trpc.io/docs/v11/server/middlewares
    */
   use<$ContextOverridesOut>(
     fn:
@@ -295,7 +311,7 @@ export interface ProcedureBuilder<
   >;
   /**
    * Query procedure
-   * @link https://trpc.io/docs/v11/concepts#vocabulary
+   * @see https://trpc.io/docs/v11/concepts#vocabulary
    */
   query<$Output>(
     resolver: ProcedureResolver<
@@ -317,7 +333,7 @@ export interface ProcedureBuilder<
 
   /**
    * Mutation procedure
-   * @link https://trpc.io/docs/v11/concepts#vocabulary
+   * @see https://trpc.io/docs/v11/concepts#vocabulary
    */
   mutation<$Output>(
     resolver: ProcedureResolver<
@@ -339,9 +355,9 @@ export interface ProcedureBuilder<
 
   /**
    * Subscription procedure
-   * @link https://trpc.io/docs/v11/concepts#vocabulary
+   * @see https://trpc.io/docs/v11/server/subscriptions
    */
-  subscription<$Output>(
+  subscription<$Output extends AsyncIterable<any, void, any>>(
     resolver: ProcedureResolver<
       TContext,
       TMeta,
@@ -354,9 +370,28 @@ export interface ProcedureBuilder<
     ? TypeError<'Not implemented'>
     : SubscriptionProcedure<{
         input: DefaultValue<TInputIn, void>;
-        output: DefaultValue<TOutputOut, inferSubscriptionOutput<$Output>>;
+        output: inferSubscriptionOutput<DefaultValue<TOutputOut, $Output>>;
+      }>;
+  /**
+   * @deprecated Using subscriptions with an observable is deprecated. Use an async generator instead.
+   * This feature will be removed in v12 of tRPC.
+   * @see https://trpc.io/docs/v11/server/subscriptions
+   */
+  subscription<$Output extends Observable<any, any>>(
+    resolver: ProcedureResolver<
+      TContext,
+      TMeta,
+      TContextOverrides,
+      TInputOut,
+      TOutputIn,
+      $Output
+    >,
+  ): TCaller extends true
+    ? TypeError<'Not implemented'>
+    : LegacyObservableSubscriptionProcedure<{
+        input: DefaultValue<TInputIn, void>;
+        output: inferObservableValue<DefaultValue<TOutputOut, $Output>>;
       }>;
-
   /**
    * Overrides the way a procedure is invoked
    * Do not use this unless you know what you're doing - this is an experimental API
@@ -394,7 +429,7 @@ function createNewBuilder(
     ...mergeWithoutOverrides(def1, rest),
     inputs: [...def1.inputs, ...(inputs ?? [])],
     middlewares: [...def1.middlewares, ...middlewares],
-    meta: def1.meta && meta ? { ...def1.meta, ...meta } : meta ?? def1.meta,
+    meta: def1.meta && meta ? { ...def1.meta, ...meta } : (meta ?? def1.meta),
   });
 }
 
@@ -464,11 +499,8 @@ export function createBuilder<TContext, TMeta>(
         resolver,
       ) as AnyMutationProcedure;
     },
-    subscription(resolver) {
-      return createResolver(
-        { ..._def, type: 'subscription' },
-        resolver,
-      ) as AnySubscriptionProcedure;
+    subscription(resolver: ProcedureResolver<any, any, any, any, any, any>) {
+      return createResolver({ ..._def, type: 'subscription' }, resolver) as any;
     },
     experimental_caller(caller) {
       return createNewBuilder(_def, {
@@ -532,6 +564,7 @@ export interface ProcedureCallOptions<TContext> {
   input?: unknown;
   path: string;
   type: ProcedureType;
+  signal: AbortSignal | undefined;
 }
 
 const codeblock = `
@@ -539,6 +572,46 @@ This is a client-only function.
 If you want to call this function on the server, see https://trpc.io/docs/v11/server/server-side-calls
 `.trim();
 
+// run the middlewares recursively with the resolver as the last one
+async function callRecursive(
+  index: number,
+  _def: AnyProcedureBuilderDef,
+  opts: ProcedureCallOptions<any>,
+): Promise<MiddlewareResult<any>> {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const middleware = _def.middlewares[index]!;
+    const result = await middleware({
+      ...opts,
+      meta: _def.meta,
+      input: opts.input,
+      next(_nextOpts?: any) {
+        const nextOpts = _nextOpts as
+          | {
+              ctx?: Record<string, unknown>;
+              input?: unknown;
+              getRawInput?: GetRawInputFn;
+            }
+          | undefined;
+
+        return callRecursive(index + 1, _def, {
+          ...opts,
+          ctx: nextOpts?.ctx ? { ...opts.ctx, ...nextOpts.ctx } : opts.ctx,
+          input: nextOpts && 'input' in nextOpts ? nextOpts.input : opts.input,
+          getRawInput: nextOpts?.getRawInput ?? opts.getRawInput,
+        });
+      },
+    });
+    return result;
+  } catch (cause) {
+    return {
+      ok: false,
+      error: getTRPCErrorFromUnknown(cause),
+      marker: middlewareMarker,
+    };
+  }
+}
+
 function createProcedureCaller(_def: AnyProcedureBuilderDef): AnyProcedure {
   async function procedure(opts: ProcedureCallOptions<unknown>) {
     // is direct server-side call
@@ -546,66 +619,8 @@ function createProcedureCaller(_def: AnyProcedureBuilderDef): AnyProcedure {
       throw new Error(codeblock);
     }
 
-    // run the middlewares recursively with the resolver as the last one
-    async function callRecursive(
-      callOpts: {
-        ctx: any;
-        index: number;
-        input?: unknown;
-        getRawInput?: GetRawInputFn;
-      } = {
-        index: 0,
-        ctx: opts.ctx,
-      },
-    ): Promise<MiddlewareResult<any>> {
-      try {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const middleware = _def.middlewares[callOpts.index]!;
-        const result = await middleware({
-          ctx: callOpts.ctx,
-          type: opts.type,
-          path: opts.path,
-          getRawInput: callOpts.getRawInput ?? opts.getRawInput,
-          meta: _def.meta,
-          input: callOpts.input,
-          next(_nextOpts?: any) {
-            const nextOpts = _nextOpts as
-              | {
-                  ctx?: Record<string, unknown>;
-                  input?: unknown;
-                  getRawInput?: GetRawInputFn;
-                }
-              | undefined;
-
-            return callRecursive({
-              index: callOpts.index + 1,
-              ctx:
-                nextOpts && 'ctx' in nextOpts
-                  ? { ...callOpts.ctx, ...nextOpts.ctx }
-                  : callOpts.ctx,
-              input:
-                nextOpts && 'input' in nextOpts
-                  ? nextOpts.input
-                  : callOpts.input,
-              getRawInput:
-                nextOpts && 'getRawInput' in nextOpts
-                  ? nextOpts.getRawInput
-                  : callOpts.getRawInput,
-            });
-          },
-        });
-        return result;
-      } catch (cause) {
-        return {
-          ok: false,
-          error: getTRPCErrorFromUnknown(cause),
-          marker: middlewareMarker,
-        };
-      }
-    }
-
     // there's always at least one "next" since we wrap this.resolver in a middleware
-    const result = await callRecursive();
+    const result = await callRecursive(0, _def, opts);
 
     if (!result) {
       throw new TRPCError({

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

@@ -36,12 +36,12 @@ export interface RootConfig<TTypes extends RootTypes> {
   $types: TTypes;
   /**
    * Use a data transformer
-   * @link https://trpc.io/docs/v11/data-transformers
+   * @see https://trpc.io/docs/v11/data-transformers
    */
   transformer: CombinedDataTransformer;
   /**
    * Use custom error formatting
-   * @link https://trpc.io/docs/v11/error-formatting
+   * @see https://trpc.io/docs/v11/error-formatting
    */
   errorFormatter: ErrorFormatter<TTypes['ctx'], TTypes['errorShape']>;
   /**
@@ -65,26 +65,26 @@ export interface RootConfig<TTypes extends RootTypes> {
 
   defaultMeta?: TTypes['meta'] extends object ? TTypes['meta'] : never;
 
-  experimental?: {
+  /**
+   * Enable support for returning async iterables and returning deferred promises when using `httpBatchStreamLink`
+   * @default true
+   */
+  iterablesAndDeferreds?: boolean;
+  /**
+   * Options for server-sent events (SSE) subscriptions
+   * @see https://trpc.io/docs/client/links/httpSubscriptionLink
+   */
+  sse?: {
     /**
-     * Enable support for returning async iterables and returning deferred promises when using `httpBatchStreamLink`
+     * Enable server-sent events (SSE) subscriptions
      * @default true
      */
-    iterablesAndDeferreds?: boolean;
-    /**
-     * Enable support for server-sent events (SSE) subscriptions
-     */
-    sseSubscriptions?: {
-      /**
-       * Enable server-sent events (SSE) subscriptions
-       * @default true
-       */
-      enabled?: boolean;
-    } & Pick<
-      SSEStreamProducerOptions,
-      'ping' | 'emitAndEndImmediately' | 'maxDurationMs'
-    >;
-  };
+    enabled?: boolean;
+  } & Pick<
+    SSEStreamProducerOptions,
+    'ping' | 'emitAndEndImmediately' | 'maxDurationMs' | 'client'
+  >;
+  experimental?: {};
 }
 
 /**
@@ -114,7 +114,7 @@ export type CreateContextCallback<
   object extends TContext ? true : false,
   {
     /**
-     * @link https://trpc.io/docs/v11/context
+     * @see https://trpc.io/docs/v11/context
      **/
     createContext: TFunction;
   }

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

@@ -7,6 +7,7 @@ import type {
   ErrorHandlerOptions,
   inferProcedureInput,
   inferProcedureOutput,
+  LegacyObservableSubscriptionProcedure,
 } from './procedure';
 import type { ProcedureCallOptions } from './procedureBuilder';
 import type { AnyRootTypes, RootConfig } from './rootConfig';
@@ -22,7 +23,9 @@ type DecorateProcedure<TProcedure extends AnyProcedure> = (
   input: inferProcedureInput<TProcedure>,
 ) => Promise<
   TProcedure['_def']['type'] extends 'subscription'
-    ? Observable<inferProcedureOutput<TProcedure>, TRPCError>
+    ? TProcedure extends LegacyObservableSubscriptionProcedure<any>
+      ? Observable<inferProcedureOutput<TProcedure>, TRPCError>
+      : inferProcedureOutput<TProcedure>
     : inferProcedureOutput<TProcedure>
 >;
 
@@ -33,8 +36,8 @@ export type DecorateRouterRecord<TRecord extends RouterRecord> = {
   [TKey in keyof TRecord]: TRecord[TKey] extends AnyProcedure
     ? DecorateProcedure<TRecord[TKey]>
     : TRecord[TKey] extends RouterRecord
-    ? DecorateRouterRecord<TRecord[TKey]>
-    : never;
+      ? DecorateRouterRecord<TRecord[TKey]>
+      : never;
 };
 
 /**
@@ -60,6 +63,7 @@ export type RouterCaller<
   ctx: TRoot['ctx'] | (() => MaybePromise<TRoot['ctx']>),
   options?: {
     onError?: RouterCallerErrorHandler<TRoot['ctx']>;
+    signal?: AbortSignal;
   },
 ) => DecorateRouterRecord<TRecord>;
 
@@ -76,7 +80,7 @@ export interface Router<
   };
   /**
    * @deprecated use `t.createCallerFactory(router)` instead
-   * @link https://trpc.io/docs/v11/server/server-side-calls
+   * @see https://trpc.io/docs/v11/server/server-side-calls
    */
   createCaller: RouterCaller<TRoot, TRecord>;
 }
@@ -142,10 +146,10 @@ export type DecorateCreateRouterOptions<
     ? $Value extends AnyProcedure
       ? $Value
       : $Value extends Router<any, infer TRecord>
-      ? TRecord
-      : $Value extends CreateRouterOptions
-      ? DecorateCreateRouterOptions<$Value>
-      : never
+        ? TRecord
+        : $Value extends CreateRouterOptions
+          ? DecorateCreateRouterOptions<$Value>
+          : never
     : never;
 };
 
@@ -270,12 +274,7 @@ export function createCallerFactory<TRoot extends AnyRootTypes>() {
     const _def = router._def;
     type Context = TRoot['ctx'];
 
-    return function createCaller(
-      ctxOrCallback,
-      options?: {
-        onError?: RouterCallerErrorHandler<Context>;
-      },
-    ) {
+    return function createCaller(ctxOrCallback, opts) {
       return createRecursiveProxy<ReturnType<RouterCaller<any, any>>>(
         async ({ path, args }) => {
           const fullPath = path.join('.');
@@ -297,9 +296,10 @@ export function createCallerFactory<TRoot extends AnyRootTypes>() {
               getRawInput: async () => args[0],
               ctx,
               type: procedure._def.type,
+              signal: opts?.signal,
             });
           } catch (cause) {
-            options?.onError?.({
+            opts?.onError?.({
               ctx,
               error: getTRPCErrorFromUnknown(cause),
               input: args[0],
@@ -318,7 +318,6 @@ export function createCallerFactory<TRoot extends AnyRootTypes>() {
 type MergeRouters<
   TRouters extends AnyRouter[],
   TRoot extends AnyRootTypes = TRouters[0]['_def']['_config']['$types'],
-  // eslint-disable-next-line @typescript-eslint/ban-types
   TRecord extends RouterRecord = {},
 > = TRouters extends [
   infer Head extends AnyRouter,

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

@@ -1,4 +1,4 @@
-import type { ValueOf } from '../types';
+import type { InvertKeyValue, ValueOf } from '../types';
 
 // reference: https://www.jsonrpc.org/specification
 
@@ -41,16 +41,8 @@ export const TRPC_ERROR_CODES_BY_KEY = {
   CLIENT_CLOSED_REQUEST: -32099, // 499
 } as const;
 
-type KeyFromValue<TValue, TType extends Record<PropertyKey, PropertyKey>> = {
-  [K in keyof TType]: TValue extends TType[K] ? K : never;
-}[keyof TType];
-
-type Invert<TType extends Record<PropertyKey, PropertyKey>> = {
-  [TValue in TType[keyof TType]]: KeyFromValue<TValue, TType>;
-};
-
 // pure
-export const TRPC_ERROR_CODES_BY_NUMBER: Invert<
+export const TRPC_ERROR_CODES_BY_NUMBER: InvertKeyValue<
   typeof TRPC_ERROR_CODES_BY_KEY
 > = {
   [-32700]: 'PARSE_ERROR',

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

@@ -63,14 +63,15 @@ export interface TRPCRequest
 
 export interface TRPCResult<TData = unknown> {
   data: TData;
+  type?: 'data';
+  /**
+   * The id of the message to keep track of in case of a reconnect
+   */
+  id?: string;
 }
 
 export interface TRPCSuccessResponse<TData>
-  extends JSONRPC2.ResultResponse<
-    TRPCResult<TData> & {
-      type?: 'data';
-    }
-  > {}
+  extends JSONRPC2.ResultResponse<TRPCResult<TData>> {}
 
 export interface TRPCErrorResponse<
   TError extends TRPCErrorShape = TRPCErrorShape,
@@ -111,13 +112,7 @@ export interface TRPCResultMessage<TData>
   extends JSONRPC2.ResultResponse<
     | { type: 'started'; data?: never }
     | { type: 'stopped'; data?: never }
-    | (TRPCResult<TData> & {
-        type: 'data';
-        /**
-         * The id of the message to keep track of in case of a reconnect
-         */
-        id?: string;
-      })
+    | TRPCResult<TData>
   > {}
 
 export type TRPCResponseMessage<