@trpc/server 11.0.0-alpha-tmp-subscription-connection-state.488 → 11.0.0-alpha-tmp-subscription-connection-state.489

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

@@ -34,6 +34,7 @@ export * from './unstable-core-do-not-import/router';
 export * from './unstable-core-do-not-import/rpc';
 export * from './unstable-core-do-not-import/stream/jsonl';
 export * from './unstable-core-do-not-import/stream/sse';
+export * from './unstable-core-do-not-import/stream/tracked';
 export * from './unstable-core-do-not-import/stream/utils/createDeferred';
 export * from './unstable-core-do-not-import/transformer';
 export * from './unstable-core-do-not-import/types';

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

@@ -1 +1 @@
-{"version":3,"file":"unstable-core-do-not-import.d.ts","sourceRoot":"","sources":["../src/unstable-core-do-not-import.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,cAAc,mDAAmD,CAAC;AAClE,cAAc,oDAAoD,CAAC;AACnE,cAAc,mDAAmD,CAAC;AAClE,cAAc,2CAA2C,CAAC;AAC1D,cAAc,+CAA+C,CAAC;AAC9D,cAAc,mDAAmD,CAAC;AAClE,cAAc,+CAA+C,CAAC;AAC9D,cAAc,yDAAyD,CAAC;AACxE,cAAc,gDAAgD,CAAC;AAC/D,cAAc,uDAAuD,CAAC;AACtE,cAAc,qDAAqD,CAAC;AACpE,cAAc,sDAAsD,CAAC;AACrE,cAAc,0DAA0D,CAAC;AACzE,cAAc,oDAAoD,CAAC;AACnE,cAAc,0CAA0C,CAAC;AACzD,cAAc,0CAA0C,CAAC;AACzD,cAAc,wCAAwC,CAAC;AACvD,cAAc,0CAA0C,CAAC;AACzD,cAAc,sCAAsC,CAAC;AACrD,cAAc,yCAAyC,CAAC;AACxD,cAAc,gDAAgD,CAAC;AAC/D,cAAc,0CAA0C,CAAC;AACzD,cAAc,sCAAsC,CAAC;AACrD,cAAc,mCAAmC,CAAC;AAClD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,0CAA0C,CAAC;AACzD,cAAc,2DAA2D,CAAC;AAC1E,cAAc,2CAA2C,CAAC;AAC1D,cAAc,qCAAqC,CAAC;AACpD,cAAc,qCAAqC,CAAC"}
+{"version":3,"file":"unstable-core-do-not-import.d.ts","sourceRoot":"","sources":["../src/unstable-core-do-not-import.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,cAAc,mDAAmD,CAAC;AAClE,cAAc,oDAAoD,CAAC;AACnE,cAAc,mDAAmD,CAAC;AAClE,cAAc,2CAA2C,CAAC;AAC1D,cAAc,+CAA+C,CAAC;AAC9D,cAAc,mDAAmD,CAAC;AAClE,cAAc,+CAA+C,CAAC;AAC9D,cAAc,yDAAyD,CAAC;AACxE,cAAc,gDAAgD,CAAC;AAC/D,cAAc,uDAAuD,CAAC;AACtE,cAAc,qDAAqD,CAAC;AACpE,cAAc,sDAAsD,CAAC;AACrE,cAAc,0DAA0D,CAAC;AACzE,cAAc,oDAAoD,CAAC;AACnE,cAAc,0CAA0C,CAAC;AACzD,cAAc,0CAA0C,CAAC;AACzD,cAAc,wCAAwC,CAAC;AACvD,cAAc,0CAA0C,CAAC;AACzD,cAAc,sCAAsC,CAAC;AACrD,cAAc,yCAAyC,CAAC;AACxD,cAAc,gDAAgD,CAAC;AAC/D,cAAc,0CAA0C,CAAC;AACzD,cAAc,sCAAsC,CAAC;AACrD,cAAc,mCAAmC,CAAC;AAClD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,0CAA0C,CAAC;AACzD,cAAc,8CAA8C,CAAC;AAC7D,cAAc,2DAA2D,CAAC;AAC1E,cAAc,2CAA2C,CAAC;AAC1D,cAAc,qCAAqC,CAAC;AACpD,cAAc,qCAAqC,CAAC"}

package/dist/unstable-core-do-not-import.js

@@ -23,6 +23,7 @@ var codes = require('./unstable-core-do-not-import/rpc/codes.js');
 var parseTRPCMessage = require('./unstable-core-do-not-import/rpc/parseTRPCMessage.js');
 var jsonl = require('./unstable-core-do-not-import/stream/jsonl.js');
 var sse = require('./unstable-core-do-not-import/stream/sse.js');
+var tracked = require('./unstable-core-do-not-import/stream/tracked.js');
 var createDeferred = require('./unstable-core-do-not-import/stream/utils/createDeferred.js');
 var transformer = require('./unstable-core-do-not-import/transformer.js');
 var types = require('./unstable-core-do-not-import/types.js');
@@ -67,11 +68,12 @@ exports.parseTRPCMessage = parseTRPCMessage.parseTRPCMessage;
 exports.isPromise = jsonl.isPromise;
 exports.jsonlStreamConsumer = jsonl.jsonlStreamConsumer;
 exports.jsonlStreamProducer = jsonl.jsonlStreamProducer;
-exports.isSSEMessageEnvelope = sse.isSSEMessageEnvelope;
-exports.sse = sse.sse;
 exports.sseHeaders = sse.sseHeaders;
 exports.sseStreamConsumer = sse.sseStreamConsumer;
 exports.sseStreamProducer = sse.sseStreamProducer;
+exports.isTrackedEnvelope = tracked.isTrackedEnvelope;
+exports.sse = tracked.sse;
+exports.tracked = tracked.tracked;
 exports.createDeferred = createDeferred.createDeferred;
 exports.createTimeoutPromise = createDeferred.createTimeoutPromise;
 exports.defaultTransformer = transformer.defaultTransformer;

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

@@ -20,7 +20,8 @@ export { callProcedure, createCallerFactory, createRouterFactory, mergeRouters }
 export { TRPC_ERROR_CODES_BY_KEY, TRPC_ERROR_CODES_BY_NUMBER } from './unstable-core-do-not-import/rpc/codes.mjs';
 export { parseTRPCMessage } from './unstable-core-do-not-import/rpc/parseTRPCMessage.mjs';
 export { isPromise, jsonlStreamConsumer, jsonlStreamProducer } from './unstable-core-do-not-import/stream/jsonl.mjs';
-export { isSSEMessageEnvelope, sse, sseHeaders, sseStreamConsumer, sseStreamProducer } from './unstable-core-do-not-import/stream/sse.mjs';
+export { sseHeaders, sseStreamConsumer, sseStreamProducer } from './unstable-core-do-not-import/stream/sse.mjs';
+export { isTrackedEnvelope, sse, tracked } from './unstable-core-do-not-import/stream/tracked.mjs';
 export { createDeferred, createTimeoutPromise } from './unstable-core-do-not-import/stream/utils/createDeferred.mjs';
 export { defaultTransformer, getDataTransformer, transformResult, transformTRPCResponse } from './unstable-core-do-not-import/transformer.mjs';
 export { ERROR_SYMBOL } from './unstable-core-do-not-import/types.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/server",
-  "version": "11.0.0-alpha-tmp-subscription-connection-state.488+70f6f6f44",
+  "version": "11.0.0-alpha-tmp-subscription-connection-state.489+04c141d1b",
   "description": "The tRPC server library",
   "author": "KATT",
   "license": "MIT",
@@ -117,7 +117,7 @@
   },
   "devDependencies": {
     "@fastify/websocket": "^10.0.1",
-    "@tanstack/react-query": "^5.49.2",
+    "@tanstack/react-query": "^5.51.11",
     "@types/aws-lambda": "^8.10.137",
     "@types/express": "^4.17.17",
     "@types/hash-sum": "^1.0.0",
@@ -126,13 +126,13 @@
     "@types/react-dom": "^18.3.0",
     "@types/ws": "^8.2.0",
     "devalue": "^5.0.0",
-    "eslint": "^8.56.0",
+    "eslint": "^8.57.0",
     "express": "^4.17.1",
     "fastify": "^4.16.0",
     "fastify-plugin": "^4.5.0",
     "hash-sum": "^2.0.0",
     "myzod": "^1.3.1",
-    "next": "^14.1.4",
+    "next": "^14.2.5",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "rollup": "^4.9.5",
@@ -140,8 +140,8 @@
     "superstruct": "^2.0.0",
     "tslib": "^2.5.0",
     "tsx": "^4.0.0",
-    "typescript": "^5.5.0",
-    "valibot": "^0.36.0",
+    "typescript": "^5.5.3",
+    "valibot": "^0.37.0",
     "ws": "^8.0.0",
     "yup": "^1.0.0",
     "zod": "^3.0.0"
@@ -149,5 +149,5 @@
   "funding": [
     "https://trpc.io/sponsor"
   ],
-  "gitHead": "70f6f6f44439bcb258420096517570e8369b3d69"
+  "gitHead": "04c141d1b4bb50631826aa956a874ba1d363f492"
 }

package/src/@trpc/server/index.ts

@@ -37,7 +37,11 @@ export {
   type QueryProcedure as TRPCQueryProcedure,
   type SubscriptionProcedure as TRPCSubscriptionProcedure,
   type TRPCBuilder,
+  /**
+   * @deprecated use `tracked(id, data)` instead
+   */
   sse,
+  tracked,
 } from '../../unstable-core-do-not-import';
 
 export type {

package/src/adapters/ws.ts

@@ -21,6 +21,7 @@ import type {
   TRPCConnectionParamsMessage,
   TRPCReconnectNotification,
   TRPCResponseMessage,
+  TRPCResultMessage,
 } from '../@trpc/server/rpc';
 import { parseConnectionParamsFromUnknown } from '../http';
 import { isObservable } from '../observable';
@@ -29,6 +30,7 @@ import { observableToAsyncIterable } from '../observable/observable';
 import {
   isAsyncIterable,
   isObject,
+  isTrackedEnvelope,
   run,
   type MaybePromise,
 } from '../unstable-core-do-not-import';
@@ -171,6 +173,7 @@ export function getWSConnectionHandler<TRouter extends AnyRouter>(
 
     async function handleRequest(msg: TRPCClientOutgoingMessage) {
       const { id, jsonrpc } = msg;
+
       /* istanbul ignore next -- @preserve */
       if (id === null) {
         throw new TRPCError({
@@ -182,9 +185,22 @@ export function getWSConnectionHandler<TRouter extends AnyRouter>(
         clientSubscriptions.get(id)?.abort();
         return;
       }
-      const { path, input } = msg.params;
+      const { path, lastEventId } = msg.params;
+      let { input } = msg.params;
       const type = msg.method;
       try {
+        if (lastEventId !== undefined) {
+          if (isObject(input)) {
+            input = {
+              ...input,
+              lastEventId: lastEventId,
+            };
+          } else {
+            input ??= {
+              lastEventId: lastEventId,
+            };
+          }
+        }
         await ctxPromise; // asserts context has been set
 
         const result = await callProcedure({
@@ -195,7 +211,16 @@ export function getWSConnectionHandler<TRouter extends AnyRouter>(
           type,
         });
 
+        const isIterableResult =
+          isAsyncIterable(result) || isObservable(result);
+
         if (type !== 'subscription') {
+          if (isIterableResult) {
+            throw new TRPCError({
+              code: 'UNSUPPORTED_MEDIA_TYPE',
+              message: `Cannot return an async iterable or observable from a ${type} procedure with WebSockets`,
+            });
+          }
           // send the value as data if the method is not a subscription
           respond({
             id,
@@ -208,7 +233,7 @@ export function getWSConnectionHandler<TRouter extends AnyRouter>(
           return;
         }
 
-        if (!isObservable(result) && !isAsyncIterable(result)) {
+        if (!isIterableResult) {
           throw new TRPCError({
             message: `Subscription ${path} did not return an observable or a AsyncGenerator`,
             code: 'INTERNAL_SERVER_ERROR',
@@ -277,13 +302,24 @@ export function getWSConnectionHandler<TRouter extends AnyRouter>(
               break;
             }
 
+            const result: TRPCResultMessage<unknown>['result'] = {
+              type: 'data',
+              data: next.value,
+            };
+
+            if (isTrackedEnvelope(next.value)) {
+              const [id, data] = next.value;
+              result.id = id;
+              result.data = {
+                id,
+                data,
+              };
+            }
+
             respond({
               id,
               jsonrpc,
-              result: {
-                type: 'data',
-                data: next.value,
-              },
+              result,
             });
           }
 

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

@@ -26,7 +26,7 @@ type IsRecord<T extends object> = keyof WithoutIndexSignature<T> extends never
 export type Serialize<T> =
   IsAny<T> extends true ? any :
   unknown extends T ? unknown :
-  T extends AsyncIterable<infer U> ? AsyncIterable<Serialize<U>> :
+  T extends AsyncGenerator<infer $T, infer $Return, infer $Next> ? AsyncGenerator<Serialize<$T>, Serialize<$Return>, Serialize<$Next>> :
   T extends JsonReturnable ? T :
   T extends Map<any, any> | Set<any> ? object :
   T extends NonJsonPrimitive ? never :

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

@@ -380,9 +380,21 @@ export async function resolveResponse<TRouter extends AnyRouter>(
             ? observableToAsyncIterable(data)
             : data;
           const stream = sseStreamProducer({
-            ...router._def._config.experimental?.sseSubscriptions,
+            ...config.experimental?.sseSubscriptions,
             data: dataAsIterable,
             serialize: (v) => config.transformer.output.serialize(v),
+            formatError(errorOpts) {
+              const shape = getErrorShape({
+                config,
+                ctx,
+                error: getTRPCErrorFromUnknown(errorOpts.error),
+                input: call?.result(),
+                path: call?.path,
+                type: call?.procedure?._def.type ?? 'unknown',
+              });
+
+              return shape;
+            },
           });
           for (const [key, value] of Object.entries(sseHeaders)) {
             headers.set(key, value);

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

@@ -23,7 +23,7 @@ import type {
   QueryProcedure,
   SubscriptionProcedure,
 } from './procedure';
-import type { inferSSEOutput } from './stream/sse';
+import type { inferTrackedOutput } from './stream/tracked';
 import type {
   GetRawInputFn,
   MaybePromise,
@@ -47,7 +47,7 @@ type DefaultValue<TValue, TFallback> = TValue extends UnsetMarker
 type inferSubscriptionOutput<TOutput> = TOutput extends AsyncIterable<
   infer $Output
 >
-  ? inferSSEOutput<$Output>
+  ? inferTrackedOutput<$Output>
   : inferObservableValue<TOutput>;
 
 export type CallerOverride<TContext> = (opts: {

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

@@ -80,7 +80,10 @@ export interface RootConfig<TTypes extends RootTypes> {
        * @default true
        */
       enabled?: boolean;
-    } & Omit<SSEStreamProducerOptions, 'maxDepth' | 'data' | 'serialize'>;
+    } & Pick<
+      SSEStreamProducerOptions,
+      'ping' | 'emitAndEndImmediately' | 'maxDurationMs'
+    >;
   };
 }
 

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

@@ -49,7 +49,17 @@ export namespace JSONRPC2 {
 /////////////////////////// HTTP envelopes ///////////////////////
 
 export interface TRPCRequest
-  extends JSONRPC2.Request<ProcedureType, { path: string; input: unknown }> {}
+  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;
@@ -101,7 +111,13 @@ export interface TRPCResultMessage<TData>
   extends JSONRPC2.ResultResponse<
     | { type: 'started'; data?: never }
     | { type: 'stopped'; data?: never }
-    | (TRPCResult<TData> & { type: 'data' })
+    | (TRPCResult<TData> & {
+        type: 'data';
+        /**
+         * The id of the message to keep track of in case of a reconnect
+         */
+        id?: string;
+      })
   > {}
 
 export type TRPCResponseMessage<

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

@@ -67,9 +67,12 @@ export function parseTRPCMessage(
   }
   assertIsProcedureType(method);
   assertIsObject(params);
-  const { input: rawInput, path } = params;
+  const { input: rawInput, path, lastEventId } = params;
 
   assertIsString(path);
+  if (lastEventId !== undefined) {
+    assertIsString(lastEventId);
+  }
 
   const input = transformer.input.deserialize(rawInput);
 
@@ -80,6 +83,7 @@ export function parseTRPCMessage(
     params: {
       input,
       path,
+      lastEventId,
     },
   };
 }

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

@@ -30,8 +30,8 @@ type PROMISE_STATUS_FULFILLED = typeof PROMISE_STATUS_FULFILLED;
 const PROMISE_STATUS_REJECTED = 1;
 type PROMISE_STATUS_REJECTED = typeof PROMISE_STATUS_REJECTED;
 
-const ASYNC_ITERABLE_STATUS_DONE = 0;
-type ASYNC_ITERABLE_STATUS_DONE = typeof ASYNC_ITERABLE_STATUS_DONE;
+const ASYNC_ITERABLE_STATUS_RETURN = 0;
+type ASYNC_ITERABLE_STATUS_RETURN = typeof ASYNC_ITERABLE_STATUS_RETURN;
 const ASYNC_ITERABLE_STATUS_VALUE = 1;
 type ASYNC_ITERABLE_STATUS_VALUE = typeof ASYNC_ITERABLE_STATUS_VALUE;
 const ASYNC_ITERABLE_STATUS_ERROR = 2;
@@ -70,7 +70,11 @@ type PromiseChunk =
     ]
   | [chunkIndex: ChunkIndex, status: PROMISE_STATUS_REJECTED, error: unknown];
 type IterableChunk =
-  | [chunkIndex: ChunkIndex, status: ASYNC_ITERABLE_STATUS_DONE]
+  | [
+      chunkIndex: ChunkIndex,
+      status: ASYNC_ITERABLE_STATUS_RETURN,
+      value: DehydratedValue,
+    ]
   | [
       chunkIndex: ChunkIndex,
       status: ASYNC_ITERABLE_STATUS_VALUE,
@@ -204,7 +208,11 @@ function createBatchStreamProducer(opts: ProducerOptions) {
           break;
         }
         if (next.done) {
-          stream.controller.enqueue([idx, ASYNC_ITERABLE_STATUS_DONE]);
+          stream.controller.enqueue([
+            idx,
+            ASYNC_ITERABLE_STATUS_RETURN,
+            dehydrate(next.value, path),
+          ]);
           break;
         }
         stream.controller.enqueue([
@@ -541,12 +549,12 @@ export async function jsonlStreamConsumer<THead>(opts: {
                       done: false,
                       value: hydrate(data),
                     };
-                  case ASYNC_ITERABLE_STATUS_DONE:
+                  case ASYNC_ITERABLE_STATUS_RETURN:
                     controllers.delete(chunkId);
                     maybeAbort();
                     return {
                       done: true,
-                      value: undefined,
+                      value: hydrate(data),
                     };
                   case ASYNC_ITERABLE_STATUS_ERROR:
                     controllers.delete(chunkId);

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

@@ -1,59 +1,14 @@
 import { getTRPCErrorFromUnknown } from '../error/TRPCError';
-import type { ValidateShape } from '../types';
 import { run } from '../utils';
 import type { ConsumerOnError } from './jsonl';
+import type { inferTrackedOutput } from './tracked';
+import { isTrackedEnvelope } from './tracked';
 import { createTimeoutPromise } from './utils/createDeferred';
 import { createReadableStream } from './utils/createReadableStream';
 
 type Serialize = (value: any) => any;
 type Deserialize = (value: any) => any;
 
-/**
- * Server-sent Event Message
- * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
- * @public
- */
-export interface SSEMessage {
-  /**
-   * The data field of the message - this can be anything
-   */
-  data: unknown;
-  /**
-   * The id for this message
-   * Passing this id will allow the client to resume the connection from this point if the connection is lost
-   * @see https://html.spec.whatwg.org/multipage/server-sent-events.html#the-last-event-id-header
-   */
-  id: string;
-}
-
-const sseSymbol = Symbol('SSEMessageEnvelope');
-export type SSEMessageEnvelope<TData> = [typeof sseSymbol, TData];
-
-/**
- * Produce a typed server-sent event message
- */
-export function sse<TData extends SSEMessage>(
-  event: ValidateShape<TData, SSEMessage>,
-): SSEMessageEnvelope<TData> {
-  if (event.id === '') {
-    // This could be removed by using different event names for `yield sse(x)`-emitted events and `yield y`-emitted events
-    throw new Error(
-      '`id` must not be an empty string as empty string is the same as not setting the id at all',
-    );
-  }
-  return [sseSymbol, event as TData];
-}
-
-export function isSSEMessageEnvelope<TData extends SSEMessage>(
-  value: unknown,
-): value is SSEMessageEnvelope<TData> {
-  return Array.isArray(value) && value[0] === sseSymbol;
-}
-
-export type SerializedSSEvent = Omit<SSEMessage, 'data'> & {
-  data?: string;
-};
-
 /**
  * @internal
  */
@@ -87,14 +42,17 @@ export interface SSEStreamProducerOptions {
    * @default false
    */
   emitAndEndImmediately?: boolean;
+  formatError?: (opts: { error: unknown }) => unknown;
 }
 
-type SSEvent = Partial<
-  SSEMessage & {
-    comment: string;
-    event: string;
-  }
->;
+const SERIALIZED_ERROR_EVENT = 'serialized-error';
+
+type SSEvent = Partial<{
+  id: string;
+  data: unknown;
+  comment: string;
+  event: string;
+}>;
 /**
  *
  * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
@@ -151,7 +109,13 @@ export function sseStreamProducer(opts: SSEStreamProducerOptions) {
       }
 
       if (next instanceof Error) {
-        stream.controller.error(next);
+        const data = opts.formatError
+          ? opts.formatError({ error: next })
+          : null;
+        stream.controller.enqueue({
+          event: SERIALIZED_ERROR_EVENT,
+          data: JSON.stringify(serialize(data)),
+        });
         break;
       }
       if (next.done) {
@@ -160,8 +124,11 @@ export function sseStreamProducer(opts: SSEStreamProducerOptions) {
 
       const value = next.value;
 
-      const chunk: SSEvent = isSSEMessageEnvelope(value)
-        ? { ...value[1] }
+      const chunk: SSEvent = isTrackedEnvelope(value)
+        ? {
+            id: value[0],
+            data: value[1],
+          }
         : {
             data: value,
           };
@@ -207,41 +174,65 @@ export function sseStreamProducer(opts: SSEStreamProducerOptions) {
     }),
   );
 }
-export type inferSSEOutput<TData> = TData extends SSEMessageEnvelope<
-  infer $Data
->
-  ? $Data
-  : TData;
+
+type ConsumerStreamResult<TData> =
+  | {
+      ok: true;
+      data: inferTrackedOutput<TData>;
+    }
+  | {
+      ok: false;
+      error: unknown;
+    };
+
 /**
  * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
  */
-
 export function sseStreamConsumer<TData>(opts: {
   from: EventSource;
   onError?: ConsumerOnError;
   deserialize?: Deserialize;
-}): AsyncIterable<inferSSEOutput<TData>> {
+}): AsyncIterable<ConsumerStreamResult<TData>> {
   const { deserialize = (v) => v } = opts;
   const eventSource = opts.from;
 
   const stream = createReadableStream<MessageEvent>();
 
-  const transform = new TransformStream<MessageEvent, inferSSEOutput<TData>>({
+  const transform = new TransformStream<
+    MessageEvent,
+    ConsumerStreamResult<TData>
+  >({
     async transform(chunk, controller) {
-      const def: Partial<SSEMessage> = {
-        data: deserialize(JSON.parse(chunk.data)),
+      const data = deserialize(JSON.parse(chunk.data));
+      if (chunk.type === SERIALIZED_ERROR_EVENT) {
+        controller.enqueue({
+          ok: false,
+          error: data,
+        });
+        return;
+      }
+      // console.debug('transforming', chunk.type, chunk.data);
+      const def: SSEvent = {
+        data,
       };
 
       if (chunk.lastEventId) {
         def.id = chunk.lastEventId;
       }
-      controller.enqueue(def as inferSSEOutput<TData>);
+
+      controller.enqueue({
+        ok: true,
+        data: def as inferTrackedOutput<TData>,
+      });
     },
   });
 
   eventSource.addEventListener('message', (msg) => {
     stream.controller.enqueue(msg);
   });
+  eventSource.addEventListener(SERIALIZED_ERROR_EVENT, (msg) => {
+    stream.controller.enqueue(msg);
+  });
   eventSource.addEventListener('error', (cause) => {
     if (eventSource.readyState === EventSource.CLOSED) {
       stream.controller.error(cause);
@@ -253,7 +244,7 @@ export function sseStreamConsumer<TData>(opts: {
     [Symbol.asyncIterator]() {
       const reader = readable.getReader();
 
-      const iterator: AsyncIterator<inferSSEOutput<TData>> = {
+      const iterator: AsyncIterator<ConsumerStreamResult<TData>> = {
         async next() {
           const value = await reader.read();
           if (value.done) {

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

@@ -0,0 +1,55 @@
+const trackedSymbol = Symbol('TrackedEnvelope');
+
+type TrackedId = string & {
+  __brand: 'TrackedId';
+};
+export type TrackedEnvelope<TData> = [TrackedId, TData, typeof trackedSymbol];
+
+type Tracked<TData> = {
+  /**
+   * The id of the message to keep track of in case the connection gets lost
+   */
+  id: string;
+  /**
+   * The data field of the message - this can be anything
+   */
+  data: TData;
+};
+/**
+ * Produce a typed server-sent event message
+ * @deprecated use `tracked(id, data)` instead
+ */
+export function sse<TData>(event: {
+  id: string;
+  data: TData;
+}): TrackedEnvelope<TData> {
+  return tracked(event.id, event.data);
+}
+
+export function isTrackedEnvelope<TData>(
+  value: unknown,
+): value is TrackedEnvelope<TData> {
+  return Array.isArray(value) && value[2] === trackedSymbol;
+}
+
+/**
+ * Automatically track an event so that it can be resumed from a given id if the connection is lost
+ */
+export function tracked<TData>(
+  id: string,
+  data: TData,
+): TrackedEnvelope<TData> {
+  if (id === '') {
+    // This limitation could be removed by using different SSE event names / channels for tracked event and non-tracked event
+    throw new Error(
+      '`id` must not be an empty string as empty string is the same as not setting the id at all',
+    );
+  }
+  return [id as TrackedId, data, trackedSymbol];
+}
+
+export type inferTrackedOutput<TData> = TData extends TrackedEnvelope<
+  infer $Data
+>
+  ? Tracked<$Data>
+  : TData;

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

@@ -34,6 +34,7 @@ export * from './unstable-core-do-not-import/router';
 export * from './unstable-core-do-not-import/rpc';
 export * from './unstable-core-do-not-import/stream/jsonl';
 export * from './unstable-core-do-not-import/stream/sse';
+export * from './unstable-core-do-not-import/stream/tracked';
 export * from './unstable-core-do-not-import/stream/utils/createDeferred';
 export * from './unstable-core-do-not-import/transformer';
 export * from './unstable-core-do-not-import/types';