@tanstack/router-core 1.168.9 → 1.168.11

package/src/router.ts

@@ -799,7 +799,9 @@ export interface ServerSsr {
   setRenderFinished: () => void
   cleanup: () => void
   onSerializationFinished: (listener: () => void) => void
-  dehydrate: () => Promise<void>
+  dehydrate: (opts?: {
+    requestAssets?: Array<RouterManagedTag>
+  }) => Promise<void>
   takeBufferedScripts: () => RouterManagedTag | undefined
   /**
    * Takes any buffered HTML that was injected.
@@ -1167,7 +1169,7 @@ export class RouterCore<
     }
 
     if (needsLocationUpdate && this.stores) {
-      this.stores.location.setState(() => this.latestLocation)
+      this.stores.location.set(this.latestLocation)
     }
 
     if (
@@ -1182,7 +1184,7 @@ export class RouterCore<
   }
 
   get state(): RouterState<TRouteTree> {
-    return this.stores.__store.state
+    return this.stores.__store.get()
   }
 
   updateLatestLocation = () => {
@@ -1418,9 +1420,9 @@ export class RouterCore<
     // Snapshot of active match state keyed by routeId, used to stabilise
     // params/search across navigations.
     const previousActiveMatchesByRouteId = new Map<string, AnyRouteMatch>()
-    for (const store of this.stores.activeMatchStoresById.values()) {
+    for (const store of this.stores.matchStores.values()) {
       if (store.routeId) {
-        previousActiveMatchesByRouteId.set(store.routeId, store.state)
+        previousActiveMatchesByRouteId.set(store.routeId, store.get())
       }
     }
 
@@ -1713,10 +1715,9 @@ export class RouterCore<
     }
 
     // Determine params: reuse from state if possible, otherwise parse
-    const lastStateMatchId = last(this.stores.matchesId.state)
+    const lastStateMatchId = last(this.stores.matchesId.get())
     const lastStateMatch =
-      lastStateMatchId &&
-      this.stores.activeMatchStoresById.get(lastStateMatchId)?.state
+      lastStateMatchId && this.stores.matchStores.get(lastStateMatchId)?.get()
     const canReuseParams =
       lastStateMatch &&
       lastStateMatch.routeId === lastRoute.id &&
@@ -1765,16 +1766,16 @@ export class RouterCore<
   }
 
   cancelMatches = () => {
-    this.stores.pendingMatchesId.state.forEach((matchId) => {
+    this.stores.pendingIds.get().forEach((matchId) => {
       this.cancelMatch(matchId)
     })
 
-    this.stores.matchesId.state.forEach((matchId) => {
-      if (this.stores.pendingMatchStoresById.has(matchId)) {
+    this.stores.matchesId.get().forEach((matchId) => {
+      if (this.stores.pendingMatchStores.has(matchId)) {
         return
       }
 
-      const match = this.stores.activeMatchStoresById.get(matchId)?.state
+      const match = this.stores.matchStores.get(matchId)?.get()
       if (!match) {
         return
       }
@@ -2354,19 +2355,19 @@ export class RouterCore<
     // Match the routes
     const pendingMatches = this.matchRoutes(this.latestLocation)
 
-    const nextCachedMatches = this.stores.cachedMatchesSnapshot.state.filter(
-      (d) => !pendingMatches.some((e) => e.id === d.id),
-    )
+    const nextCachedMatches = this.stores.cachedMatches
+      .get()
+      .filter((d) => !pendingMatches.some((e) => e.id === d.id))
 
     // Ingest the new matches
     this.batch(() => {
-      this.stores.status.setState(() => 'pending')
-      this.stores.statusCode.setState(() => 200)
-      this.stores.isLoading.setState(() => true)
-      this.stores.location.setState(() => this.latestLocation)
-      this.stores.setPendingMatches(pendingMatches)
+      this.stores.status.set('pending')
+      this.stores.statusCode.set(200)
+      this.stores.isLoading.set(true)
+      this.stores.location.set(this.latestLocation)
+      this.stores.setPending(pendingMatches)
       // If a cached match moved to pending matches, remove it from cached matches
-      this.stores.setCachedMatches(nextCachedMatches)
+      this.stores.setCached(nextCachedMatches)
     })
   }
 
@@ -2375,7 +2376,7 @@ export class RouterCore<
     let notFound: NotFoundError | undefined
     let loadPromise: Promise<void>
     const previousLocation =
-      this.stores.resolvedLocation.state ?? this.stores.location.state
+      this.stores.resolvedLocation.get() ?? this.stores.location.get()
 
     // eslint-disable-next-line prefer-const
     loadPromise = new Promise<void>((resolve) => {
@@ -2383,10 +2384,10 @@ export class RouterCore<
         try {
           this.beforeLoad()
           const next = this.latestLocation
-          const prevLocation = this.stores.resolvedLocation.state
+          const prevLocation = this.stores.resolvedLocation.get()
           const locationChangeInfo = getLocationChangeInfo(next, prevLocation)
 
-          if (!this.stores.redirect.state) {
+          if (!this.stores.redirect.get()) {
             this.emit({
               type: 'onBeforeNavigate',
               ...locationChangeInfo,
@@ -2402,7 +2403,7 @@ export class RouterCore<
             router: this,
             sync: opts?.sync,
             forceStaleReload: previousLocation.href === next.href,
-            matches: this.stores.pendingMatchesSnapshot.state,
+            matches: this.stores.pendingMatches.get(),
             location: next,
             updateMatch: this.updateMatch,
             // eslint-disable-next-line @typescript-eslint/require-await
@@ -2426,27 +2427,25 @@ export class RouterCore<
                   let hookStayingMatches: Array<AnyRouteMatch> | null = null
 
                   this.batch(() => {
-                    const pendingMatches =
-                      this.stores.pendingMatchesSnapshot.state
+                    const pendingMatches = this.stores.pendingMatches.get()
                     const mountPending = pendingMatches.length
-                    const currentMatches =
-                      this.stores.activeMatchesSnapshot.state
+                    const currentMatches = this.stores.matches.get()
 
                     exitingMatches = mountPending
                       ? currentMatches.filter(
                           (match) =>
-                            !this.stores.pendingMatchStoresById.has(match.id),
+                            !this.stores.pendingMatchStores.has(match.id),
                         )
                       : null
 
                     // Lifecycle-hook identity: routeId only (route presence in tree)
                     // Build routeId sets from pools to avoid derived stores.
                     const pendingRouteIds = new Set<string>()
-                    for (const s of this.stores.pendingMatchStoresById.values()) {
+                    for (const s of this.stores.pendingMatchStores.values()) {
                       if (s.routeId) pendingRouteIds.add(s.routeId)
                     }
                     const activeRouteIds = new Set<string>()
-                    for (const s of this.stores.activeMatchStoresById.values()) {
+                    for (const s of this.stores.matchStores.values()) {
                       if (s.routeId) activeRouteIds.add(s.routeId)
                     }
 
@@ -2466,8 +2465,8 @@ export class RouterCore<
                         )
                       : currentMatches
 
-                    this.stores.isLoading.setState(() => false)
-                    this.stores.loadedAt.setState(() => Date.now())
+                    this.stores.isLoading.set(false)
+                    this.stores.loadedAt.set(Date.now())
                     /**
                      * When committing new matches, cache any exiting matches that are still usable.
                      * Routes that resolved with `status: 'error'` or `status: 'notFound'` are
@@ -2475,10 +2474,10 @@ export class RouterCore<
                      * or reloads re-run their loaders instead of reusing the failed/not-found data.
                      */
                     if (mountPending) {
-                      this.stores.setActiveMatches(pendingMatches)
-                      this.stores.setPendingMatches([])
-                      this.stores.setCachedMatches([
-                        ...this.stores.cachedMatchesSnapshot.state,
+                      this.stores.setMatches(pendingMatches)
+                      this.stores.setPending([])
+                      this.stores.setCached([
+                        ...this.stores.cachedMatches.get(),
                         ...exitingMatches!.filter(
                           (d) =>
                             d.status !== 'error' &&
@@ -2525,15 +2524,13 @@ export class RouterCore<
             ? redirect.status
             : notFound
               ? 404
-              : this.stores.activeMatchesSnapshot.state.some(
-                    (d) => d.status === 'error',
-                  )
+              : this.stores.matches.get().some((d) => d.status === 'error')
                 ? 500
                 : 200
 
           this.batch(() => {
-            this.stores.statusCode.setState(() => nextStatusCode)
-            this.stores.redirect.setState(() => redirect)
+            this.stores.statusCode.set(nextStatusCode)
+            this.stores.redirect.set(redirect)
           })
         }
 
@@ -2561,13 +2558,11 @@ export class RouterCore<
     let newStatusCode: number | undefined = undefined
     if (this.hasNotFoundMatch()) {
       newStatusCode = 404
-    } else if (
-      this.stores.activeMatchesSnapshot.state.some((d) => d.status === 'error')
-    ) {
+    } else if (this.stores.matches.get().some((d) => d.status === 'error')) {
       newStatusCode = 500
     }
     if (newStatusCode !== undefined) {
-      this.stores.statusCode.setState(() => newStatusCode)
+      this.stores.statusCode.set(newStatusCode)
     }
   }
 
@@ -2596,7 +2591,7 @@ export class RouterCore<
         this.isViewTransitionTypesSupported
       ) {
         const next = this.latestLocation
-        const prevLocation = this.stores.resolvedLocation.state
+        const prevLocation = this.stores.resolvedLocation.get()
 
         const resolvedViewTransitionTypes =
           typeof shouldViewTransition.types === 'function'
@@ -2626,30 +2621,30 @@ export class RouterCore<
 
   updateMatch: UpdateMatchFn = (id, updater) => {
     this.startTransition(() => {
-      const pendingMatch = this.stores.pendingMatchStoresById.get(id)
+      const pendingMatch = this.stores.pendingMatchStores.get(id)
       if (pendingMatch) {
-        pendingMatch.setState(updater)
+        pendingMatch.set(updater)
         return
       }
 
-      const activeMatch = this.stores.activeMatchStoresById.get(id)
+      const activeMatch = this.stores.matchStores.get(id)
       if (activeMatch) {
-        activeMatch.setState(updater)
+        activeMatch.set(updater)
         return
       }
 
-      const cachedMatch = this.stores.cachedMatchStoresById.get(id)
+      const cachedMatch = this.stores.cachedMatchStores.get(id)
       if (cachedMatch) {
-        const next = updater(cachedMatch.state)
+        const next = updater(cachedMatch.get())
         if (next.status === 'redirected') {
-          const deleted = this.stores.cachedMatchStoresById.delete(id)
+          const deleted = this.stores.cachedMatchStores.delete(id)
           if (deleted) {
-            this.stores.cachedMatchesId.setState((prev) =>
+            this.stores.cachedIds.set((prev) =>
               prev.filter((matchId) => matchId !== id),
             )
           }
         } else {
-          cachedMatch.setState(() => next)
+          cachedMatch.set(next)
         }
       }
     })
@@ -2657,9 +2652,9 @@ export class RouterCore<
 
   getMatch: GetMatchFn = (matchId: string): AnyRouteMatch | undefined => {
     return (
-      this.stores.cachedMatchStoresById.get(matchId)?.state ??
-      this.stores.pendingMatchStoresById.get(matchId)?.state ??
-      this.stores.activeMatchStoresById.get(matchId)?.state
+      this.stores.cachedMatchStores.get(matchId)?.get() ??
+      this.stores.pendingMatchStores.get(matchId)?.get() ??
+      this.stores.matchStores.get(matchId)?.get()
     )
   }
 
@@ -2696,15 +2691,9 @@ export class RouterCore<
     }
 
     this.batch(() => {
-      this.stores.setActiveMatches(
-        this.stores.activeMatchesSnapshot.state.map(invalidate),
-      )
-      this.stores.setCachedMatches(
-        this.stores.cachedMatchesSnapshot.state.map(invalidate),
-      )
-      this.stores.setPendingMatches(
-        this.stores.pendingMatchesSnapshot.state.map(invalidate),
-      )
+      this.stores.setMatches(this.stores.matches.get().map(invalidate))
+      this.stores.setCached(this.stores.cachedMatches.get().map(invalidate))
+      this.stores.setPending(this.stores.pendingMatches.get().map(invalidate))
     })
 
     this.shouldViewTransition = false
@@ -2762,13 +2751,13 @@ export class RouterCore<
   clearCache: ClearCacheFn<this> = (opts) => {
     const filter = opts?.filter
     if (filter !== undefined) {
-      this.stores.setCachedMatches(
-        this.stores.cachedMatchesSnapshot.state.filter(
-          (m) => !filter(m as MakeRouteMatchUnion<this>),
-        ),
+      this.stores.setCached(
+        this.stores.cachedMatches
+          .get()
+          .filter((m) => !filter(m as MakeRouteMatchUnion<this>)),
       )
     } else {
-      this.stores.setCachedMatches([])
+      this.stores.setCached([])
     }
   }
 
@@ -2816,13 +2805,13 @@ export class RouterCore<
     })
 
     const activeMatchIds = new Set([
-      ...this.stores.matchesId.state,
-      ...this.stores.pendingMatchesId.state,
+      ...this.stores.matchesId.get(),
+      ...this.stores.pendingIds.get(),
     ])
 
     const loadedMatchIds = new Set([
       ...activeMatchIds,
-      ...this.stores.cachedMatchesId.state,
+      ...this.stores.cachedIds.get(),
     ])
 
     // If the matches are already loaded, we need to add them to the cached matches.
@@ -2830,8 +2819,8 @@ export class RouterCore<
       (match) => !loadedMatchIds.has(match.id),
     )
     if (matchesToCache.length) {
-      const cachedMatches = this.stores.cachedMatchesSnapshot.state
-      this.stores.setCachedMatches([...cachedMatches, ...matchesToCache])
+      const cachedMatches = this.stores.cachedMatches.get()
+      this.stores.setCached([...cachedMatches, ...matchesToCache])
     }
 
     try {
@@ -2886,16 +2875,16 @@ export class RouterCore<
     }
     const next = this.buildLocation(matchLocation as any)
 
-    if (opts?.pending && this.stores.status.state !== 'pending') {
+    if (opts?.pending && this.stores.status.get() !== 'pending') {
       return false
     }
 
     const pending =
-      opts?.pending === undefined ? !this.stores.isLoading.state : opts.pending
+      opts?.pending === undefined ? !this.stores.isLoading.get() : opts.pending
 
     const baseLocation = pending
       ? this.latestLocation
-      : this.stores.resolvedLocation.state || this.stores.location.state
+      : this.stores.resolvedLocation.get() || this.stores.location.get()
 
     const match = findSingleMatch(
       next.pathname,
@@ -2931,9 +2920,9 @@ export class RouterCore<
   serverSsr?: ServerSsr
 
   hasNotFoundMatch = () => {
-    return this.stores.activeMatchesSnapshot.state.some(
-      (d) => d.status === 'notFound' || d.globalNotFound,
-    )
+    return this.stores.matches
+      .get()
+      .some((d) => d.status === 'notFound' || d.globalNotFound)
   }
 }
 

package/src/scroll-restoration.ts

@@ -233,7 +233,7 @@ export function setupScrollRestoration(router: AnyRouter, force?: boolean) {
   window.addEventListener('pagehide', () => {
     snapshotCurrentScrollTargets(
       getKey(
-        router.stores.resolvedLocation.state ?? router.stores.location.state,
+        router.stores.resolvedLocation.get() ?? router.stores.location.get(),
       ),
     )
     cache.persist()

package/src/ssr/createRequestHandler.ts

@@ -78,13 +78,12 @@ export function createRequestHandler<TRouter extends AnyRouter>({
 }
 
 function getRequestHeaders(opts: { router: AnyRouter }): Headers {
-  const matchHeaders =
-    opts.router.stores.activeMatchesSnapshot.state.map<AnyHeaders>(
-      (match) => match.headers,
-    )
+  const matchHeaders = opts.router.stores.matches
+    .get()
+    .map<AnyHeaders>((match) => match.headers)
 
   // Handle Redirects
-  const redirect = opts.router.stores.redirect.state
+  const redirect = opts.router.stores.redirect.get()
   if (redirect) {
     matchHeaders.push(redirect.headers)
   }

package/src/ssr/serializer/RawStream.ts

@@ -1,5 +1,5 @@
 import { createPlugin, createStream } from 'seroval'
-import type { Plugin } from 'seroval'
+import type { PluginData, PluginInfo, SerovalNode } from 'seroval'
 
 /**
  * Hint for RawStream encoding strategy during SSR serialization.
@@ -240,61 +240,71 @@ function toTextStream(readable: ReadableStream<Uint8Array>) {
 }
 
 // Factory plugin for binary mode
-const RawStreamFactoryBinaryPlugin = createPlugin<
+const RawStreamFactoryBinaryPlugin = /* @__PURE__ */ createPlugin<
   Record<string, never>,
-  undefined
+  PluginInfo
 >({
   tag: 'tss/RawStreamFactory',
   test(value) {
     return value === RAW_STREAM_FACTORY_BINARY
   },
   parse: {
-    sync() {
-      return undefined
+    sync(_value, _ctx, _data) {
+      return {}
     },
-    async() {
-      return Promise.resolve(undefined)
+    async async(_value, _ctx, _data) {
+      return {}
     },
-    stream() {
-      return undefined
+    stream(_value, _ctx, _data) {
+      return {}
     },
   },
-  serialize() {
+  serialize(_node, _ctx, _data) {
     return FACTORY_BINARY
   },
-  deserialize() {
+  deserialize(_node, _ctx, _data) {
     return RAW_STREAM_FACTORY_BINARY
   },
 })
 
 // Factory plugin for text mode
-const RawStreamFactoryTextPlugin = createPlugin<
+const RawStreamFactoryTextPlugin = /* @__PURE__ */ createPlugin<
   Record<string, never>,
-  undefined
+  PluginInfo
 >({
   tag: 'tss/RawStreamFactoryText',
   test(value) {
     return value === RAW_STREAM_FACTORY_TEXT
   },
   parse: {
-    sync() {
-      return undefined
+    sync(_value, _ctx, _data) {
+      return {}
     },
-    async() {
-      return Promise.resolve(undefined)
+    async async(_value, _ctx, _data) {
+      return {}
     },
-    stream() {
-      return undefined
+    stream(_value, _ctx, _data) {
+      return {}
     },
   },
-  serialize() {
+  serialize(_node, _ctx, _data) {
     return FACTORY_TEXT
   },
-  deserialize() {
+  deserialize(_node, _ctx, _data) {
     return RAW_STREAM_FACTORY_TEXT
   },
 })
 
+export interface RawStreamSSRNode extends PluginInfo {
+  hint: SerovalNode
+  factory: SerovalNode
+  stream: SerovalNode
+}
+
+export interface RawStreamRPCNode extends PluginInfo {
+  streamId: SerovalNode
+}
+
 /**
  * SSR Plugin - uses base64 or UTF-8+base64 encoding for chunks, delegates to seroval's stream mechanism.
  * Used during SSR when serializing to JavaScript code for HTML injection.
@@ -303,7 +313,10 @@ const RawStreamFactoryTextPlugin = createPlugin<
  * - 'binary': Always base64 encode (default)
  * - 'text': Try UTF-8 first, fallback to base64 for invalid UTF-8
  */
-export const RawStreamSSRPlugin: Plugin<any, any> = createPlugin({
+export const RawStreamSSRPlugin = /* @__PURE__ */ createPlugin<
+  RawStream,
+  RawStreamSSRNode
+>({
   tag: 'tss/RawStream',
   extends: [RawStreamFactoryBinaryPlugin, RawStreamFactoryTextPlugin],
 
@@ -312,19 +325,19 @@ export const RawStreamSSRPlugin: Plugin<any, any> = createPlugin({
   },
 
   parse: {
-    sync(value: RawStream, ctx) {
+    sync(value: RawStream, ctx, _data) {
       // Sync parse not really supported for streams, return empty stream
       const factory =
         value.hint === 'text'
           ? RAW_STREAM_FACTORY_TEXT
           : RAW_STREAM_FACTORY_BINARY
       return {
-        hint: value.hint,
+        hint: ctx.parse(value.hint),
         factory: ctx.parse(factory),
         stream: ctx.parse(createStream()),
       }
     },
-    async async(value: RawStream, ctx) {
+    async async(value: RawStream, ctx, _data) {
       const factory =
         value.hint === 'text'
           ? RAW_STREAM_FACTORY_TEXT
@@ -334,12 +347,12 @@ export const RawStreamSSRPlugin: Plugin<any, any> = createPlugin({
           ? toTextStream(value.stream)
           : toBinaryStream(value.stream)
       return {
-        hint: value.hint,
+        hint: await ctx.parse(value.hint),
         factory: await ctx.parse(factory),
         stream: await ctx.parse(encodedStream),
       }
     },
-    stream(value: RawStream, ctx) {
+    stream(value: RawStream, ctx, _data) {
       const factory =
         value.hint === 'text'
           ? RAW_STREAM_FACTORY_TEXT
@@ -349,14 +362,14 @@ export const RawStreamSSRPlugin: Plugin<any, any> = createPlugin({
           ? toTextStream(value.stream)
           : toBinaryStream(value.stream)
       return {
-        hint: value.hint,
+        hint: ctx.parse(value.hint),
         factory: ctx.parse(factory),
         stream: ctx.parse(encodedStream),
       }
     },
   },
 
-  serialize(node: { hint: RawStreamHint; factory: any; stream: any }, ctx) {
+  serialize(node: RawStreamSSRNode, ctx, _data) {
     return (
       '(' +
       ctx.serialize(node.factory) +
@@ -366,23 +379,14 @@ export const RawStreamSSRPlugin: Plugin<any, any> = createPlugin({
     )
   },
 
-  deserialize(
-    node: { hint: RawStreamHint; factory: any; stream: any },
-    ctx,
-  ): any {
+  deserialize(node: RawStreamSSRNode, ctx, _data): any {
     const stream: ReturnType<typeof createStream> = ctx.deserialize(node.stream)
-    return node.hint === 'text'
+    const hint = ctx.deserialize(node.hint)
+    return hint === 'text'
       ? RAW_STREAM_FACTORY_CONSTRUCTOR_TEXT(stream)
       : RAW_STREAM_FACTORY_CONSTRUCTOR_BINARY(stream)
   },
-}) as Plugin<any, any>
-
-/**
- * Node type for RPC plugin serialization
- */
-interface RawStreamRPCNode {
-  streamId: number
-}
+})
 
 /**
  * Creates an RPC plugin instance that registers raw streams with a multiplexer.
@@ -391,13 +395,12 @@ interface RawStreamRPCNode {
  *
  * @param onRawStream Callback invoked when a RawStream is encountered during serialization
  */
-export function createRawStreamRPCPlugin(
-  onRawStream: OnRawStreamCallback,
-): Plugin<any, any> {
+/* @__NO_SIDE_EFFECTS__ */
+export function createRawStreamRPCPlugin(onRawStream: OnRawStreamCallback) {
   // Own stream counter - sequential IDs starting at 1, independent of seroval internals
   let nextStreamId = 1
 
-  return createPlugin({
+  return /* @__PURE__ */ createPlugin<RawStream, RawStreamRPCNode>({
     tag: 'tss/RawStream',
 
     test(value: unknown) {
@@ -405,15 +408,15 @@ export function createRawStreamRPCPlugin(
     },
 
     parse: {
-      async(value: RawStream) {
+      async async(value: RawStream, ctx, _data: PluginData) {
         const streamId = nextStreamId++
         onRawStream(streamId, value.stream)
-        return Promise.resolve({ streamId })
+        return { streamId: await ctx.parse(streamId) }
       },
-      stream(value: RawStream) {
+      stream(value: RawStream, ctx, _data: PluginData) {
         const streamId = nextStreamId++
         onRawStream(streamId, value.stream)
-        return { streamId }
+        return { streamId: ctx.parse(streamId) }
       },
     },
 
@@ -431,7 +434,7 @@ export function createRawStreamRPCPlugin(
         'RawStreamRPCPlugin.deserialize should not be called. Use createRawStreamDeserializePlugin on client.',
       )
     },
-  }) as Plugin<any, any>
+  })
 }
 
 /**
@@ -442,8 +445,8 @@ export function createRawStreamRPCPlugin(
  */
 export function createRawStreamDeserializePlugin(
   getOrCreateStream: (id: number) => ReadableStream<Uint8Array>,
-): Plugin<any, any> {
-  return createPlugin({
+) {
+  return /* @__PURE__ */ createPlugin<any, RawStreamRPCNode>({
     tag: 'tss/RawStream',
 
     test: () => false, // Client never serializes RawStream
@@ -457,8 +460,14 @@ export function createRawStreamDeserializePlugin(
       )
     },
 
-    deserialize(node: RawStreamRPCNode) {
-      return getOrCreateStream(node.streamId)
+    deserialize(node, ctx, _data) {
+      // In normal seroval usage, ctx.deserialize exists.
+      // Some unit tests call plugin.deserialize directly with a minimal ctx.
+      const id =
+        typeof (ctx as any)?.deserialize === 'function'
+          ? (ctx as any).deserialize(node.streamId)
+          : (node as any).streamId
+      return getOrCreateStream(id as number)
     },
-  }) as Plugin<any, any>
+  })
 }