refactor: drop per-record serialization overrides from static dump

`serializeDumpError` already flattens the common rich-error shape
(`message`, `name`, recursive `cause`) into a JSON-safe object, so
`jsonSerializable: true` functions that throw ordinary errors round-trip
through strict JSON without any per-record promotion.

The edge case — an error with non-JSON own properties (e.g. a `Map`
attached to the thrown error) — now surfaces as `DF0020` at build time,
consistent with the rest of the `jsonSerializable: true` contract.

Author: antfu

packages/devframe/src/client/static-rpc.ts

@@ -18,15 +18,6 @@ export interface StaticRpcManifestQueryEntry {
   fallback?: string
   /** Encoder used when each record/fallback file was written. Default: `'json'`. */
   serialization?: StaticRpcSerialization
-  /**
-   * Per-record encoder override. When a record file was written with a
-   * different serializer than {@link serialization} (e.g. an error-bearing
-   * record promoted to `'structured-clone'` for a `jsonSerializable: true`
-   * function), the override is recorded here.
-   */
-  recordSerializations?: Record<string, StaticRpcSerialization>
-  /** Encoder override for the fallback shard. */
-  fallbackSerialization?: StaticRpcSerialization
 }
 
 export type StaticRpcManifestEntry
@@ -129,14 +120,12 @@ export function createStaticRpcCaller(
       const recordPath = entry.records[argsHash]
 
       if (recordPath) {
-        const recordSerialization = entry.recordSerializations?.[argsHash] ?? entry.serialization
-        const record = await loadQueryRecord(recordPath, recordSerialization)
+        const record = await loadQueryRecord(recordPath, entry.serialization)
         return resolveRecordOutput(record)
       }
 
       if (entry.fallback) {
-        const fallbackSerialization = entry.fallbackSerialization ?? entry.serialization
-        const fallback = await loadQueryRecord(entry.fallback, fallbackSerialization)
+        const fallback = await loadQueryRecord(entry.fallback, entry.serialization)
         return resolveRecordOutput(fallback)
       }
 

packages/devframe/src/node/__tests__/static-dump.test.ts

@@ -218,109 +218,104 @@ describe('collectStaticRpcDump', () => {
   })
 
   describe('error-bearing records', () => {
-    it('promotes error-bearing query records to structured-clone for jsonSerializable: true', async () => {
+    it('writes JSON-safe error shape (message + name + cause) for jsonSerializable: true', async () => {
       const flaky = defineRpcFunction({
         name: 'test:flaky',
         type: 'query',
         jsonSerializable: true,
-        handler: (id: string) => {
-          if (id === 'bad')
-            throw new Error('boom')
-          return { id }
+        handler: () => {
+          throw new TypeError('boom', { cause: new Error('inner') })
         },
         dump: {
-          inputs: [['good'], ['bad']],
+          inputs: [[]] as [][],
         },
       })
 
       const result = await collectStaticRpcDump([flaky], {})
       const entry = result.manifest['test:flaky'] as {
-        type: 'query'
         records: Record<string, string>
         serialization: 'json'
-        recordSerializations?: Record<string, 'json' | 'structured-clone'>
       }
 
       expect(entry.serialization).toBe('json')
-      expect(entry.recordSerializations).toBeDefined()
 
-      const erroredKeys = Object.keys(entry.recordSerializations!)
-      expect(erroredKeys).toHaveLength(1)
-
-      const erroredPath = entry.records[erroredKeys[0]!]!
-      expect(result.files[erroredPath]!.serialization).toBe('structured-clone')
+      const recordPath = Object.values(entry.records)[0]!
+      const file = result.files[recordPath]!
+      expect(file.serialization).toBe('json')
 
-      const goodPath = entry.records[Object.keys(entry.records).find(k => k !== erroredKeys[0])!]!
-      expect(result.files[goodPath]!.serialization).toBe('json')
+      // serializeDumpError flattens Error.cause into a plain object, so
+      // strict-JSON encoding succeeds without any per-record promotion.
+      const wireText = strictJsonStringify(file.data, file.fnName)
+      const parsed = JSON.parse(wireText) as {
+        error: { name: string, message: string, cause: { name: string, message: string } }
+      }
+      expect(parsed.error.name).toBe('TypeError')
+      expect(parsed.error.message).toBe('boom')
+      expect(parsed.error.cause.name).toBe('Error')
+      expect(parsed.error.cause.message).toBe('inner')
     })
 
-    it('keeps the entry serialization on error-bearing records when default is structured-clone', async () => {
+    it('preserves rich error info end-to-end for default (structured-clone) entries', async () => {
+      const tags = new Map<string, number>([['a', 1]])
       const flaky = defineRpcFunction({
-        name: 'test:flaky-sc',
+        name: 'test:flaky-roundtrip',
         type: 'query',
         // default jsonSerializable: false → structured-clone shards
-        handler: (id: string) => {
-          if (id === 'bad')
-            throw new Error('boom')
-          return { id }
+        handler: () => {
+          const err = new TypeError('boom', { cause: new Error('inner') }) as Error & { tags?: unknown }
+          err.tags = tags
+          throw err
         },
         dump: {
-          inputs: [['good'], ['bad']],
+          inputs: [[]] as [][],
         },
       })
 
       const result = await collectStaticRpcDump([flaky], {})
-      const entry = result.manifest['test:flaky-sc'] as {
-        serialization: 'json' | 'structured-clone'
-        recordSerializations?: Record<string, 'json' | 'structured-clone'>
+      const entry = result.manifest['test:flaky-roundtrip'] as {
+        records: Record<string, string>
+        serialization: 'structured-clone'
       }
-
       expect(entry.serialization).toBe('structured-clone')
-      // No overrides — everything is already SC.
-      expect(entry.recordSerializations).toBeUndefined()
+
+      const recordPath = Object.values(entry.records)[0]!
+      const file = result.files[recordPath]!
+      const revived = structuredCloneDeserialize(JSON.parse(structuredCloneStringify(file.data))) as {
+        error: { name: string, message: string, cause: { message: string }, tags: Map<string, number> }
+      }
+      expect(revived.error.name).toBe('TypeError')
+      expect(revived.error.message).toBe('boom')
+      expect(revived.error.cause.message).toBe('inner')
+      expect(revived.error.tags).toBeInstanceOf(Map)
+      expect(revived.error.tags.get('a')).toBe(1)
     })
 
-    it('preserves rich error info (cause + custom props) through a full read round-trip', async () => {
-      const tags = new Map<string, number>([['a', 1]])
+    it('throws DF0020 when a jsonSerializable: true function attaches non-JSON to an error', async () => {
       const flaky = defineRpcFunction({
-        name: 'test:flaky-roundtrip',
+        name: 'test:flaky-non-json',
         type: 'query',
         jsonSerializable: true,
-        handler: (id: string) => {
-          if (id === 'bad') {
-            const err = new TypeError('boom', { cause: new Error('inner') }) as Error & { tags?: unknown }
-            err.tags = tags
-            throw err
-          }
-          return { id }
+        handler: () => {
+          const err = new Error('boom') as Error & { tags?: unknown }
+          err.tags = new Map([['a', 1]])
+          throw err
         },
         dump: {
-          inputs: [['bad']],
+          inputs: [[]] as [][],
         },
       })
 
       const result = await collectStaticRpcDump([flaky], {})
-      const entry = result.manifest['test:flaky-roundtrip'] as {
-        records: Record<string, string>
-        recordSerializations?: Record<string, 'json' | 'structured-clone'>
-      }
-
-      const recordKey = Object.keys(entry.records)[0]!
-      const recordPath = entry.records[recordKey]!
+      const recordPath = Object.values(
+        (result.manifest['test:flaky-non-json'] as { records: Record<string, string> }).records,
+      )[0]!
       const file = result.files[recordPath]!
 
-      // The shard was promoted to structured-clone — verify the Error
-      // (and its Map property) round-trips losslessly through the wire format.
-      expect(file.serialization).toBe('structured-clone')
-      const wireText = structuredCloneStringify(file.data)
-      const revived = structuredCloneDeserialize(JSON.parse(wireText)) as {
-        error: { name: string, message: string, cause: { message: string }, tags: Map<string, number> }
-      }
-      expect(revived.error.name).toBe('TypeError')
-      expect(revived.error.message).toBe('boom')
-      expect(revived.error.cause.message).toBe('inner')
-      expect(revived.error.tags).toBeInstanceOf(Map)
-      expect(revived.error.tags.get('a')).toBe(1)
+      // Attaching a Map to the thrown Error violates the `jsonSerializable: true`
+      // contract; the strict serializer surfaces this at build time, same as
+      // if the function had returned a Map.
+      expect(() => strictJsonStringify(file.data, file.fnName))
+        .toThrowError(/jsonSerializable: true.*is a Map/)
     })
   })
 })

packages/devframe/src/node/static-dump.ts

@@ -19,16 +19,6 @@ export interface StaticRpcDumpManifestQueryEntry {
   fallback?: string
   /** Encoder used when each record/fallback file was written. Default: `'json'`. */
   serialization?: StaticRpcDumpSerialization
-  /**
-   * Per-record encoder override. When a record file is written with a
-   * different serializer than {@link serialization} (e.g. an error-bearing
-   * record promoted to `'structured-clone'` for a `jsonSerializable: true`
-   * function), the override is recorded here so the client picks the
-   * right decoder.
-   */
-  recordSerializations?: Record<string, StaticRpcDumpSerialization>
-  /** Encoder override for the fallback shard, with the same semantics as {@link recordSerializations}. */
-  fallbackSerialization?: StaticRpcDumpSerialization
 }
 
 export type StaticRpcDumpManifestValue
@@ -125,29 +115,15 @@ export async function collectStaticRpcDump(
       const key = recordKey.slice(prefix.length)
       const record = await resolveRecord(recordOrGetter)
 
-      // Error-bearing records can contain non-JSON values (e.g. an
-      // `Error.cause` chain, or a `Map` attached to the thrown error).
-      // For `jsonSerializable: true` functions, promote just this one
-      // file to structured-clone so the rich error round-trips losslessly.
-      const recordSerialization: StaticRpcDumpSerialization
-        = record.error !== undefined && serialization === 'json'
-          ? 'structured-clone'
-          : serialization
-
       if (key === 'fallback') {
         const path = makeQueryFallbackPath(definition.name)
-        files[path] = { serialization: recordSerialization, fnName: definition.name, data: record }
+        files[path] = { serialization, fnName: definition.name, data: record }
         queryEntry.fallback = path
-        if (recordSerialization !== serialization)
-          queryEntry.fallbackSerialization = recordSerialization
       }
       else {
         const path = makeQueryRecordPath(definition.name, key)
-        files[path] = { serialization: recordSerialization, fnName: definition.name, data: record }
+        files[path] = { serialization, fnName: definition.name, data: record }
         queryEntry.records[key] = path
-        if (recordSerialization !== serialization) {
-          ;(queryEntry.recordSerializations ??= {})[key] = recordSerialization
-        }
       }
     }
 

tests/__snapshots__/tsnapi/devframe/node.snapshot.d.ts

@@ -36,8 +36,6 @@ export interface StaticRpcDumpManifestQueryEntry {
   records: Record<string, string>;
   fallback?: string;
   serialization?: StaticRpcDumpSerialization;
-  recordSerializations?: Record<string, StaticRpcDumpSerialization>;
-  fallbackSerialization?: StaticRpcDumpSerialization;
 }
 export interface StaticRpcDumpManifestStaticEntry {
   type: 'static';