@onekeyfe/hd-transport 1.2.0-alpha.9 → 1.2.0-alpha.91

package/src/protocols/v2/session.ts

@@ -1,12 +1,18 @@
-import { PROTOCOL_V2_PACKET_SRC_COMMAND } from '../../constants';
+import {
+  PROTOCOL_V2_DEFAULT_RESPONSE_TIMEOUT_MS,
+  PROTOCOL_V2_PACKET_SRC_COMMAND,
+} from '../../constants';
 import { ProtocolV2FrameAssembler, concatUint8Arrays } from './frame-assembler';
 import { ProtocolV2SequenceCursor } from './sequence-cursor';
+import { ProtocolV2LinkError } from './errors';
 import { ProtocolV2 } from '..';
 import * as check from '../../utils/highlevel-checks';
 import { LogBlockCommand } from '../../utils/logBlockCommand';
 
 import type { Root } from 'protobufjs/light';
-import type { MessageFromOneKey } from '../../types';
+import type { MessageFromOneKey, TransportWriteMetrics } from '../../types';
+
+export * from './errors';
 
 export type ProtocolV2Schemas = {
   protocolV1: Root;
@@ -16,8 +22,10 @@ export type ProtocolV2Schemas = {
 export type ProtocolV2CallContext = {
   messageName: string;
   timeoutMs?: number;
-  highVolume: boolean;
+  highThroughput: boolean;
+  writeWithResponse?: boolean;
   generation: number;
+  signal: AbortSignal;
 };
 
 type ProtocolLogger = {
@@ -45,6 +53,8 @@ export type ProtocolV2CallOptions = {
   expectedTypes?: string[];
   intermediateTypes?: string[];
   onIntermediateResponse?: (response: MessageFromOneKey) => void;
+  onWriteCompleted?: (metrics: TransportWriteMetrics) => void;
+  writeWithResponse?: boolean;
 };
 
 export { concatUint8Arrays, ProtocolV2FrameAssembler };
@@ -71,16 +81,7 @@ export function bytesToHex(bytes: Uint8Array): string {
     .join('');
 }
 
-// Frame header bytes worth logging: SOF, len lo/hi, header CRC, router, attr, seq.
-// The rest of the frame is protobuf payload and may contain sensitive fields
-// (mnemonic words via WordAck, PINs, seeds via LoadDevice, ...), so raw frame
-// hex logs must never include it.
-const PROTOCOL_V2_DEBUG_HEADER_BYTES = 7;
-const PROTOCOL_V2_DEBUG_ARRAY_ITEMS_LIMIT = 20;
-const PROTOCOL_V2_DEBUG_OBJECT_KEYS_LIMIT = 40;
-const PROTOCOL_V2_DEBUG_STRING_LIMIT = 512;
-const PROTOCOL_V2_DEBUG_DEPTH_LIMIT = 4;
-const HIGH_VOLUME_PROTOCOL_V2_CALLS = new Set([
+const REDUCED_DEBUG_PROTOCOL_V2_CALLS = new Set([
   ...LogBlockCommand,
   'FilesystemFileRead',
   'FileRead',
@@ -88,103 +89,22 @@ const HIGH_VOLUME_PROTOCOL_V2_CALLS = new Set([
 ]);
 
 function shouldReduceProtocolV2Debug(name: string) {
-  return HIGH_VOLUME_PROTOCOL_V2_CALLS.has(name);
-}
-
-function frameHeaderDebugHex(frame: Uint8Array): string {
-  // Only the frame header is dumped as hex; the payload is logged separately
-  // in sanitized/structured form (sanitizeProtocolV2DebugPayload).
-  return bytesToHex(frame.slice(0, PROTOCOL_V2_DEBUG_HEADER_BYTES));
+  return REDUCED_DEBUG_PROTOCOL_V2_CALLS.has(name);
 }
 
-function getBinaryByteLength(value: unknown): number | undefined {
-  if (value instanceof ArrayBuffer) {
-    return value.byteLength;
-  }
-
-  if (ArrayBuffer.isView(value)) {
-    return value.byteLength;
-  }
-
-  if (typeof Blob !== 'undefined' && value instanceof Blob) {
-    return value.size;
-  }
-
-  return undefined;
-}
-
-function summarizeRedactedData(value: unknown): string {
-  const byteLength = getBinaryByteLength(value);
-  if (byteLength !== undefined) {
-    return `[redacted data: ${byteLength} bytes]`;
-  }
-
-  if (typeof value === 'string') {
-    return `[redacted data: string length=${value.length}]`;
-  }
-
-  if (Array.isArray(value)) {
-    return `[redacted data: array length=${value.length}]`;
-  }
-
-  if (value && typeof value === 'object') {
-    return `[redacted data: object keys=${Object.keys(value).length}]`;
-  }
-
-  return `[redacted data: ${typeof value}]`;
-}
-
-function sanitizeProtocolV2DebugPayload(value: unknown, key = '', depth = 0): unknown {
-  if (/^(data|payload)$/i.test(key) && value !== null && value !== undefined) {
-    return summarizeRedactedData(value);
-  }
-
-  if (/(passphrase|pin|mnemonic|seed|private)/i.test(key)) {
-    return '[redacted sensitive value]';
-  }
-
-  const byteLength = getBinaryByteLength(value);
-  if (byteLength !== undefined) {
-    return `[binary: ${byteLength} bytes]`;
-  }
-
-  if (typeof value === 'string') {
-    return value.length > PROTOCOL_V2_DEBUG_STRING_LIMIT
-      ? `${value.slice(0, PROTOCOL_V2_DEBUG_STRING_LIMIT)}... (len=${value.length})`
-      : value;
-  }
-
-  if (!value || typeof value !== 'object') {
-    return value;
-  }
-
-  if (depth >= PROTOCOL_V2_DEBUG_DEPTH_LIMIT) {
-    return Array.isArray(value)
-      ? `[array length=${value.length}]`
-      : `[object keys=${Object.keys(value).length}]`;
-  }
-
-  if (Array.isArray(value)) {
-    const items = value
-      .slice(0, PROTOCOL_V2_DEBUG_ARRAY_ITEMS_LIMIT)
-      .map(item => sanitizeProtocolV2DebugPayload(item, key, depth + 1));
-    if (value.length > PROTOCOL_V2_DEBUG_ARRAY_ITEMS_LIMIT) {
-      items.push(`... (${value.length - PROTOCOL_V2_DEBUG_ARRAY_ITEMS_LIMIT} more)`);
-    }
-    return items;
-  }
+const HIGH_THROUGHPUT_PROTOCOL_V2_CALLS = new Set([
+  'FilesystemFileWrite',
+  'FileWrite',
+  'EmmcFileWrite',
+  'FirmwareUpload',
+  'ResourceAck',
+  'FilesystemFileRead',
+  'FileRead',
+  'EmmcFileRead',
+]);
 
-  const entries = Object.entries(value).slice(0, PROTOCOL_V2_DEBUG_OBJECT_KEYS_LIMIT);
-  const sanitized: Record<string, unknown> = {};
-  entries.forEach(([entryKey, entryValue]) => {
-    sanitized[entryKey] = sanitizeProtocolV2DebugPayload(entryValue, entryKey, depth + 1);
-  });
-  if (Object.keys(value).length > PROTOCOL_V2_DEBUG_OBJECT_KEYS_LIMIT) {
-    sanitized.__truncated__ = `${
-      Object.keys(value).length - PROTOCOL_V2_DEBUG_OBJECT_KEYS_LIMIT
-    } more keys`;
-  }
-  return sanitized;
+export function isProtocolV2HighThroughputCall(name: string) {
+  return HIGH_THROUGHPUT_PROTOCOL_V2_CALLS.has(name);
 }
 
 const COMMON_TERMINAL_RESPONSE_TYPES = new Set([
@@ -219,11 +139,13 @@ export async function withProtocolTimeout<T>(
   promise: Promise<T>,
   timeoutMs: number | undefined,
   createTimeoutError: () => Error,
-  onTimeout?: () => void
+  onTimeout?: () => void,
+  abortSignal?: AbortSignal
 ): Promise<T> {
   if (!timeoutMs) return promise;
 
   let timer: ReturnType<typeof setTimeout> | undefined;
+  let abortHandler: (() => void) | undefined;
   try {
     return await Promise.race([
       promise,
@@ -235,17 +157,29 @@ export async function withProtocolTimeout<T>(
           reject(createTimeoutError());
         }, timeoutMs);
       }),
+      ...(abortSignal
+        ? [
+            new Promise<never>((_, reject) => {
+              abortHandler = () => {
+                reject(new Error('Protocol V2 operation aborted'));
+              };
+              if (abortSignal.aborted) {
+                abortHandler();
+              } else {
+                abortSignal.addEventListener('abort', abortHandler, { once: true });
+              }
+            }),
+          ]
+        : []),
     ]);
   } finally {
     if (timer) clearTimeout(timer);
+    if (abortHandler) {
+      abortSignal?.removeEventListener('abort', abortHandler);
+    }
   }
 }
 
-// Write completion is owned by the concrete transport. A Promise.race watchdog
-// here can return while libusb/WebUSB is still flushing a large Protocol V2
-// frame, which desynchronizes later request/response pairs.
-export const PROTOCOL_V2_WRITE_WATCHDOG_TIMEOUT_MS = 0;
-
 export class ProtocolV2Session {
   private readonly options: ProtocolV2SessionOptions;
 
@@ -255,6 +189,8 @@ export class ProtocolV2Session {
   // in-flight calls on the same session would steal each other's responses.
   private pendingCall: Promise<unknown> = Promise.resolve();
 
+  private lastResponseSequence?: number;
+
   constructor(options: ProtocolV2SessionOptions) {
     this.options = options;
     this.sequenceCursor = options.sequenceCursor ?? new ProtocolV2SequenceCursor();
@@ -273,7 +209,7 @@ export class ProtocolV2Session {
     return result;
   }
 
-  private async executeCall(
+  private executeCall(
     name: string,
     data: Record<string, unknown>,
     callOptions: ProtocolV2CallOptions
@@ -291,104 +227,117 @@ export class ProtocolV2Session {
       createTimeoutError,
       generation = 0,
     } = this.options;
+    const timeoutMs =
+      callOptions.timeoutMs && callOptions.timeoutMs > 0
+        ? callOptions.timeoutMs
+        : PROTOCOL_V2_DEFAULT_RESPONSE_TIMEOUT_MS;
+    const abortController = new AbortController();
 
     const shouldReduceDebug = shouldReduceProtocolV2Debug(name);
-    const callContext: ProtocolV2CallContext = {
+    const baseCallContext: ProtocolV2CallContext = {
       messageName: name,
-      timeoutMs: callOptions.timeoutMs,
-      highVolume: shouldReduceDebug,
+      timeoutMs,
+      highThroughput: isProtocolV2HighThroughputCall(name),
+      ...(callOptions.writeWithResponse === undefined
+        ? {}
+        : { writeWithResponse: callOptions.writeWithResponse }),
       generation,
+      signal: abortController.signal,
     };
-    await prepareCall?.(callContext);
-    const protoSeq = this.sequenceCursor.next();
-    const frame = ProtocolV2.encodeFrame(schemas, name, data, {
-      packetSrc,
-      router,
-      seq: protoSeq,
-      logger: shouldReduceDebug ? undefined : logger,
-      logPrefix,
-      context: `tx:${name}`,
-    });
-    const expectedSeq = frame[6];
-
-    if (maxFrameBytes !== undefined && frame.length > maxFrameBytes) {
-      throw new Error(
-        `Protocol V2 frame too large for transport: ${frame.length} > ${maxFrameBytes}`
-      );
-    }
 
-    if (!shouldReduceDebug) {
-      logger?.debug?.(
-        `[${logPrefix}] TX payload name=${name}`,
-        sanitizeProtocolV2DebugPayload(data)
-      );
-      logger?.debug?.(
-        `[${logPrefix}] TX frame name=${name} len=${frame.length} router=${frame[4]} attr=${
-          frame[5]
-        } seq=${expectedSeq} headerHex=${frameHeaderDebugHex(frame)}`
-      );
-    }
-
-    // Lenient watchdog on the write phase only — see
-    // PROTOCOL_V2_WRITE_WATCHDOG_TIMEOUT_MS for the rationale.
-    await withProtocolTimeout(
-      writeFrame(frame, callContext),
-      PROTOCOL_V2_WRITE_WATCHDOG_TIMEOUT_MS,
-      () =>
-        new Error(
-          `Protocol V2 write timeout after ${PROTOCOL_V2_WRITE_WATCHDOG_TIMEOUT_MS}ms for ${name}`
-        )
-    );
+    const runCall = async (): Promise<MessageFromOneKey> => {
+      await prepareCall?.(baseCallContext);
+      const protoSeq = this.sequenceCursor.next();
+      const frame = ProtocolV2.encodeFrame(schemas, name, data, {
+        packetSrc,
+        router,
+        seq: protoSeq,
+      });
+
+      if (maxFrameBytes !== undefined && frame.length > maxFrameBytes) {
+        throw new Error(
+          `Protocol V2 frame too large for transport: ${frame.length} > ${maxFrameBytes}`
+        );
+      }
 
-    // Cancellation flag for the read loop: when the response timeout fires,
-    // Promise.race alone would leave this loop running as a zombie that keeps
-    // consuming frames meant for the next call. The timeout callback flips the
-    // flag so the loop exits and discards any late frame.
-    const cancellation = { cancelled: false };
+      const writeStartedAt = Date.now();
+      await writeFrame(frame, baseCallContext);
+      try {
+        callOptions.onWriteCompleted?.({
+          elapsedMs: Math.max(Date.now() - writeStartedAt, 0),
+          frameBytes: frame.byteLength,
+        });
+      } catch (error) {
+        logger?.error?.(`${logPrefix} write metrics callback failed: ${String(error)}`);
+      }
 
-    const readResponse = async (): Promise<MessageFromOneKey> => {
       // Some Protocol V2 operations emit progress notifications before the
       // terminal response. Consume those frames here so callers still see a
       // request/terminal-response shaped API.
-      while (!cancellation.cancelled) {
-        const rxFrame = await readFrame(callContext);
-        if (cancellation.cancelled) {
-          // Timed out while waiting: drop the late frame and stop reading.
-          break;
+      while (!abortController.signal.aborted) {
+        const rxFrame = await readFrame(baseCallContext);
+        if (abortController.signal.aborted) break;
+
+        let header: ReturnType<typeof ProtocolV2.inspectFrameHeader>;
+        try {
+          header = ProtocolV2.inspectFrameHeader(rxFrame);
+        } catch (cause) {
+          throw new ProtocolV2LinkError(
+            'frame',
+            `Protocol V2 frame validation failed: ${getErrorMessage(cause)}`,
+            cause
+          );
         }
-        if (!shouldReduceDebug) {
-          logger?.debug?.(
-            `[${logPrefix}] RX frame len=${rxFrame.length} router=${rxFrame[4]} attr=${
-              rxFrame[5]
-            } seq=${rxFrame[6]} headerHex=${frameHeaderDebugHex(rxFrame)}`
+        if (header.router !== router) {
+          throw new ProtocolV2LinkError(
+            'router',
+            `Protocol V2 router mismatch: expected ${router}, got ${header.router}`
           );
         }
-        const isAck = ProtocolV2.isAckFrame(rxFrame);
-        if (isAck) {
-          if (!shouldReduceDebug) {
-            logger?.debug?.(`[${logPrefix}] skip Proto Link ACK seq=${rxFrame[6]}`);
-          }
+        if (header.packetSrc !== packetSrc) {
+          throw new ProtocolV2LinkError(
+            'packet-source',
+            `Protocol V2 packet source mismatch: expected ${packetSrc}, got ${header.packetSrc}`
+          );
         }
-        if (!isAck) {
-          const decoded = ProtocolV2.decodeFrame(schemas, rxFrame, {
-            logger: shouldReduceDebug ? undefined : logger,
-            logPrefix,
-            context: `rx:${name}`,
-          });
-          if (!shouldReduceDebug && decoded.seq !== expectedSeq) {
-            logger?.debug?.(
-              `[${logPrefix}] seq differs for ${name}: tx=${expectedSeq}, rx=${decoded.seq}`
+
+        let isAck: boolean;
+        try {
+          isAck = ProtocolV2.isAckFrame(rxFrame);
+        } catch (cause) {
+          throw new ProtocolV2LinkError(
+            'frame',
+            `Protocol V2 ACK validation failed: ${getErrorMessage(cause)}`,
+            cause
+          );
+        }
+        if (isAck) {
+          if (header.seq !== protoSeq) {
+            throw new ProtocolV2LinkError(
+              'ack-sequence',
+              `Protocol V2 ACK sequence mismatch: expected ${protoSeq}, got ${header.seq}`
             );
           }
-          if (!shouldReduceDebug) {
-            logger?.debug?.(
-              `[${logPrefix}] TX name=${name} seq=${expectedSeq} | RX seq=${decoded.seq} messageTypeId=${decoded.messageTypeId} pbPayload=${decoded.pbPayload.length}B`
+        } else {
+          let decoded: ReturnType<typeof ProtocolV2.decodeFrame>;
+          try {
+            decoded = ProtocolV2.decodeFrame(schemas, rxFrame);
+          } catch (cause) {
+            throw new ProtocolV2LinkError(
+              'frame',
+              `Protocol V2 frame decode failed: ${getErrorMessage(cause)}`,
+              cause
             );
-            logger?.debug?.(
-              `[${logPrefix}] RX payload type=${decoded.type} messageTypeId=${decoded.messageTypeId}`,
-              sanitizeProtocolV2DebugPayload(decoded.message)
+          }
+          // Firmware owns one TX sequence across all channels and packet sources,
+          // so frames routed elsewhere create valid gaps in this session.
+          if (this.lastResponseSequence === decoded.seq) {
+            throw new ProtocolV2LinkError(
+              'response-sequence',
+              `Protocol V2 duplicate response sequence: ${decoded.seq}`
             );
           }
+          this.lastResponseSequence = decoded.seq;
 
           const response = check.call(decoded);
           if (callOptions.intermediateTypes?.includes(response.type)) {
@@ -404,20 +353,19 @@ export class ProtocolV2Session {
           }
         }
       }
-      // Only reachable after cancellation; the outer promise has already been
-      // rejected by the timeout, so this rejection is consumed by the race.
+
       throw new Error(`Protocol V2 read loop cancelled after timeout for ${name}`);
     };
 
     return withProtocolTimeout(
-      readResponse(),
-      callOptions.timeoutMs,
+      runCall(),
+      timeoutMs,
       () =>
         createTimeoutError
-          ? createTimeoutError(name, callOptions.timeoutMs ?? 0)
-          : new Error(`Protocol V2 response timeout after ${callOptions.timeoutMs}ms for ${name}`),
+          ? createTimeoutError(name, timeoutMs)
+          : new Error(`Protocol V2 response timeout after ${timeoutMs}ms for ${name}`),
       () => {
-        cancellation.cancelled = true;
+        abortController.abort();
       }
     );
   }
@@ -448,7 +396,10 @@ export async function probeProtocolV2({
     const response = await call(
       'Ping',
       { message: 'protocol-v2-probe' },
-      { timeoutMs, expectedTypes: ['Success'] }
+      {
+        timeoutMs,
+        expectedTypes: ['Success'],
+      }
     );
     if (response.type === 'Success') {
       return true;

package/src/protocols/v2/usb-transport-base.ts

@@ -1,5 +1,7 @@
 import { ProtocolV2FrameAssembler } from './frame-assembler';
+import { ProtocolV2LinkError, isProtocolV2LinkError } from './errors';
 import { ProtocolV2LinkManager } from './link-manager';
+import { getErrorMessage } from './session';
 
 import type { MessageFromOneKey, TransportCallOptions } from '../../types';
 import type { ProtocolV2CallContext, ProtocolV2Schemas, ProtocolV2SessionOptions } from './session';
@@ -32,7 +34,7 @@ export abstract class ProtocolV2UsbTransportBase<Key> {
     this.protocolV2UsbOptions = options;
     this.protocolV2UsbLinks = new ProtocolV2LinkManager<Key>({
       getSchemas: () => this.getProtocolV2UsbSchemas(),
-      classifyError: () => 'link-fatal',
+      classifyError: error => (isProtocolV2LinkError(error) ? 'link-fatal' : 'recoverable'),
       onLinkInvalidated: async (key, reason) => {
         this.protocolV2UsbAssemblers.get(key)?.reset();
         await this.resetProtocolV2UsbNativeLink(key, reason);
@@ -61,7 +63,7 @@ export abstract class ProtocolV2UsbTransportBase<Key> {
   protected abstract createProtocolV2UsbTimeoutError(name: string, timeoutMs: number): Error;
 
   protected onProtocolV2UsbLinkInvalidated(_key: Key, _reason: string): Promise<void> | void {
-    // 子类按需清理协议缓存或记录平台日志。
+    // Subclasses may clear protocol caches or emit platform-specific diagnostics.
   }
 
   protected async rotateProtocolV2UsbGeneration(key: Key, reason: string): Promise<number> {
@@ -118,10 +120,13 @@ export abstract class ProtocolV2UsbTransportBase<Key> {
 
     const assertCurrentGeneration = () => {
       if (cancellation.reason) {
-        throw new Error(cancellation.reason);
+        throw new ProtocolV2LinkError('generation', cancellation.reason);
       }
       if (this.protocolV2UsbGenerations.get(key) !== generation) {
-        throw new Error('Protocol V2 USB connection generation changed');
+        throw new ProtocolV2LinkError(
+          'generation',
+          'Protocol V2 USB connection generation changed'
+        );
       }
     };
 
@@ -131,11 +136,14 @@ export abstract class ProtocolV2UsbTransportBase<Key> {
       generation,
       prepareCall: () => {
         assertCurrentGeneration();
-        this.getProtocolV2UsbAssembler(key).reset();
       },
       writeFrame: async (frame: Uint8Array, context: ProtocolV2CallContext) => {
         assertCurrentGeneration();
-        await this.writeProtocolV2UsbPacket(key, frame, context);
+        try {
+          await this.writeProtocolV2UsbPacket(key, frame, context);
+        } catch (error) {
+          throw this.createProtocolV2UsbIoError('write', error);
+        }
         assertCurrentGeneration();
       },
       readFrame: async (context: ProtocolV2CallContext) => {
@@ -143,13 +151,15 @@ export abstract class ProtocolV2UsbTransportBase<Key> {
         const assembler = this.getProtocolV2UsbAssembler(key);
         let frame = assembler.push(new Uint8Array(0));
         while (!frame) {
-          const packetRead = this.readProtocolV2UsbPacket(key, context).then(packet => ({
-            packet,
-          }));
+          const packetRead = this.readProtocolV2UsbPacket(key, context)
+            .then(packet => ({ packet }))
+            .catch(error => {
+              throw this.createProtocolV2UsbIoError('read', error);
+            });
           const cancelled = cancellation.promise.then(reason => ({ reason }));
           const result = await Promise.race([packetRead, cancelled]);
           if ('reason' in result) {
-            throw new Error(result.reason);
+            throw new ProtocolV2LinkError('generation', result.reason);
           }
           assertCurrentGeneration();
           frame = assembler.push(result.packet);
@@ -191,4 +201,13 @@ export abstract class ProtocolV2UsbTransportBase<Key> {
     };
     return cancellation;
   }
+
+  private createProtocolV2UsbIoError(operation: 'read' | 'write', error: unknown) {
+    if (isProtocolV2LinkError(error)) return error;
+    return new ProtocolV2LinkError(
+      'io',
+      `Protocol V2 USB ${operation} failed: ${getErrorMessage(error) || 'unknown error'}`,
+      error
+    );
+  }
 }

package/src/serialization/protobuf/decode.ts

@@ -70,7 +70,10 @@ function messageToJSON(Message: Message<Record<string, unknown>>, fields: Type['
     }
     // message type
     else if (field.resolvedType!.fields) {
-      res[key] = messageToJSON(value, field.resolvedType!.fields);
+      // [compatibility]: absent optional sub-messages are not own properties
+      // of the decoded instance, so value is undefined here; decode them to
+      // null, matching the optional primitive-field convention above.
+      res[key] = value == null ? null : messageToJSON(value, (field.resolvedType as Type).fields);
     } else {
       throw new Error(`case not handled: ${key}`);
     }

package/src/serialization/protobuf/encode.ts

@@ -1,5 +1,6 @@
 import { Buffer } from 'buffer';
 import ByteBuffer from 'bytebuffer';
+import { Enum } from 'protobufjs/light';
 
 import { isPrimitiveField } from '../../utils/protobuf';
 
@@ -49,7 +50,10 @@ export function patch(Message: Type, payload: any) {
     // repeated
     if (field.repeated) {
       const RefMessage = Message.lookupTypeOrEnum(field.type);
-      patched[key] = value.map((v: any) => patch(RefMessage, v));
+      patched[key] =
+        RefMessage instanceof Enum
+          ? value.map((v: any) => transform(field.type, v))
+          : value.map((v: any) => patch(RefMessage, v));
     }
     // message type
     else if (typeof value === 'object' && value !== null) {