@honch/react-native-relay 0.1.0

package/src/durableStore.ts

@@ -0,0 +1,122 @@
+import type { StoredRelayMessage } from "./relayQueue";
+import type { RelayRetryState } from "./relayQueue";
+
+export type DurableRelayChunk = {
+  deviceId: string;
+  sourceType: number;
+  sequence: string;
+  offset: number;
+  frameBytes: Uint8Array;
+  payload: Uint8Array;
+  finalEnd?: number;
+};
+
+export interface RelayDurableStore {
+  putChunk(chunk: DurableRelayChunk): Promise<void>;
+  chunks(deviceId: string, sequence: string): Promise<DurableRelayChunk[]>;
+  putCompleteMessage(message: StoredRelayMessage): Promise<void>;
+  completeMessages(): Promise<StoredRelayMessage[]>;
+  markRetry(deviceId: string, sequence: string, retry: RelayRetryState): Promise<void>;
+  deleteMessage(deviceId: string, sequence: string): Promise<void>;
+}
+
+export type MemoryDurableStoreOptions = {
+  // Upper bounds on retained complete messages and partial-reassembly chunks.
+  // When exceeded, the oldest entries are evicted (drop-oldest), matching the
+  // core SDK's bounded RAM-queue policy so the in-memory store cannot grow
+  // without bound when uploads stall. Defaults match the MMKV store.
+  maxCompleteMessages?: number;
+  maxChunks?: number;
+};
+
+const DEFAULT_MAX_CHUNKS = 4096;
+const DEFAULT_MAX_COMPLETE_MESSAGES = 1024;
+
+export function createMemoryDurableStore(options?: MemoryDurableStoreOptions): RelayDurableStore {
+  const maxMessages = options?.maxCompleteMessages ?? DEFAULT_MAX_COMPLETE_MESSAGES;
+  const maxChunks = options?.maxChunks ?? DEFAULT_MAX_CHUNKS;
+  const chunks: DurableRelayChunk[] = [];
+  const messages: StoredRelayMessage[] = [];
+
+  return {
+    async putChunk(chunk) {
+      const existing = chunks.find(
+        (entry) =>
+          entry.deviceId === chunk.deviceId &&
+          entry.sequence === chunk.sequence &&
+          entry.offset === chunk.offset
+      );
+      if (existing !== undefined) {
+        Object.assign(existing, cloneChunk(chunk));
+        return;
+      }
+      chunks.push(cloneChunk(chunk));
+      while (chunks.length > maxChunks) {
+        chunks.shift();
+      }
+    },
+
+    async chunks(deviceId, sequence) {
+      return chunks
+        .filter((chunk) => chunk.deviceId === deviceId && chunk.sequence === sequence)
+        .map(cloneChunk);
+    },
+
+    async putCompleteMessage(message) {
+      const existing = messages.find(
+        (entry) => entry.deviceId === message.deviceId && entry.sequence === message.sequence
+      );
+      if (existing !== undefined) {
+        existing.body = new Uint8Array(message.body);
+        existing.sourceType = message.sourceType;
+        return;
+      }
+      messages.push(cloneMessage(message));
+      while (messages.length > maxMessages) {
+        messages.shift();
+      }
+    },
+
+    async completeMessages() {
+      return messages.map(cloneMessage);
+    },
+
+    async markRetry(deviceId, sequence, retry) {
+      const message = messages.find(
+        (entry) => entry.deviceId === deviceId && entry.sequence === sequence
+      );
+      if (message !== undefined) {
+        message.retryAttempt = retry.attempt;
+        message.nextAttemptAtMs = retry.nextAttemptAtMs;
+      }
+    },
+
+    async deleteMessage(deviceId, sequence) {
+      for (let i = messages.length - 1; i >= 0; i -= 1) {
+        if (messages[i].deviceId === deviceId && messages[i].sequence === sequence) {
+          messages.splice(i, 1);
+        }
+      }
+      for (let i = chunks.length - 1; i >= 0; i -= 1) {
+        if (chunks[i].deviceId === deviceId && chunks[i].sequence === sequence) {
+          chunks.splice(i, 1);
+        }
+      }
+    }
+  };
+}
+
+function cloneChunk(chunk: DurableRelayChunk): DurableRelayChunk {
+  return {
+    ...chunk,
+    frameBytes: new Uint8Array(chunk.frameBytes),
+    payload: new Uint8Array(chunk.payload)
+  };
+}
+
+function cloneMessage(message: StoredRelayMessage): StoredRelayMessage {
+  return {
+    ...message,
+    body: new Uint8Array(message.body)
+  };
+}

package/src/frame.ts

@@ -0,0 +1,94 @@
+export type RelayFrame = {
+  version: number;
+  sourceType: number;
+  first: boolean;
+  final: boolean;
+  sequence: bigint;
+  offset: number;
+  payload: Uint8Array;
+};
+
+const RELAY_FRAME_HEADER_SIZE = 20;
+const RELAY_FRAME_CRC_OFFSET = 18;
+const RELAY_FRAME_SOURCE_TYPE_EVENTS = 1;
+const RELAY_FRAME_CRC_INITIAL = 0xffff;
+const RELAY_FRAME_CRC_POLYNOMIAL = 0x1021;
+
+export function decodeRelayFrame(bytes: Uint8Array): RelayFrame {
+  if (bytes.length < RELAY_FRAME_HEADER_SIZE) {
+    throw new Error("relay frame too short");
+  }
+
+  const version = bytes[0];
+  if (version !== 1) {
+    throw new Error("unsupported relay frame version");
+  }
+  if (bytes[1] !== RELAY_FRAME_SOURCE_TYPE_EVENTS) {
+    throw new Error("unsupported relay frame source type");
+  }
+  if (bytes[3] !== 0) {
+    throw new Error("relay frame reserved byte must be zero");
+  }
+  if ((bytes[2] & ~0x03) !== 0) {
+    throw new Error("relay frame unknown flag bits");
+  }
+
+  const payloadLength = (bytes[16] << 8) | bytes[17];
+  if (bytes.length !== RELAY_FRAME_HEADER_SIZE + payloadLength) {
+    throw new Error("relay frame payload length mismatch");
+  }
+
+  const expectedCrc = readU16(bytes, RELAY_FRAME_CRC_OFFSET);
+  const actualCrc = relayFrameCrc16(bytes.slice(0, 18), bytes.slice(RELAY_FRAME_HEADER_SIZE));
+  if (actualCrc !== expectedCrc) {
+    throw new Error("relay frame crc mismatch");
+  }
+
+  let sequence = 0n;
+  for (let i = 4; i < 12; i += 1) {
+    sequence = (sequence << 8n) | BigInt(bytes[i]);
+  }
+
+  const offset = ((bytes[12] << 24) | (bytes[13] << 16) | (bytes[14] << 8) | bytes[15]) >>> 0;
+  const first = (bytes[2] & 1) !== 0;
+  // bit 0 marks the first chunk (spec relay-chunks.md), which is the frame at
+  // offset 0. Validate the flag instead of decoding it into a field nothing
+  // checks: it must be set exactly when offset is zero.
+  if (first !== (offset === 0)) {
+    throw new Error("relay frame first flag must be set iff offset is zero");
+  }
+  return {
+    version,
+    sourceType: bytes[1],
+    first,
+    final: (bytes[2] & 2) !== 0,
+    sequence,
+    offset,
+    payload: bytes.slice(RELAY_FRAME_HEADER_SIZE)
+  };
+}
+
+function readU16(bytes: Uint8Array, offset: number): number {
+  return (bytes[offset] << 8) | bytes[offset + 1];
+}
+
+function relayFrameCrc16(headerWithoutCrc: Uint8Array, payload: Uint8Array): number {
+  let crc = crc16Update(RELAY_FRAME_CRC_INITIAL, headerWithoutCrc);
+  crc = crc16Update(crc, payload);
+  return crc;
+}
+
+function crc16Update(initialCrc: number, bytes: Uint8Array): number {
+  let crc = initialCrc;
+  for (const byte of bytes) {
+    crc ^= byte << 8;
+    for (let bit = 0; bit < 8; bit += 1) {
+      if ((crc & 0x8000) !== 0) {
+        crc = ((crc << 1) ^ RELAY_FRAME_CRC_POLYNOMIAL) & 0xffff;
+      } else {
+        crc = (crc << 1) & 0xffff;
+      }
+    }
+  }
+  return crc;
+}

package/src/index.ts

@@ -0,0 +1,28 @@
+export { decodeRelayFrame } from "./frame";
+export type { RelayFrame } from "./frame";
+export { createInMemoryRelayQueue } from "./relayQueue";
+export { createDurableRelayQueue } from "./relayQueue";
+export type { RelayQueue, StoredRelayMessage } from "./relayQueue";
+export { createMemoryDurableStore } from "./durableStore";
+export type { DurableRelayChunk, RelayDurableStore } from "./durableStore";
+export { createMmkvRelayStore } from "./storage/mmkvStore";
+export type { MmkvRelayStoreOptions } from "./storage/mmkvStore";
+export { buildRelayUploadBuffer, uploadRelayMessage, uploadRelayMessageOutcome } from "./uploader";
+export type { RelayUploaderConfig, RelayUploadOutcome } from "./uploader";
+export { drainRelayQueue } from "./drain";
+export type { DrainRelayQueueOptions } from "./drain";
+export { nextBackoffDelayMs } from "./retry";
+export { buildRelayAck, createRelayFrameReceiver } from "./relayFrameReceiver";
+export type {
+  RelayFrameAcknowledgement,
+  RelayFrameAcknowledger,
+  RelayFrameReceipt,
+  RelayFrameReceiverOptions,
+  RelayReceiveFrameOptions
+} from "./relayFrameReceiver";
+export { createRelayUploadScheduler } from "./scheduler";
+export type { RelayUploadSchedulerNative, RelayUploadSchedulerOptions } from "./scheduler";
+export { createMobileRelay } from "./mobileRelay";
+export type { MobileRelayOptions } from "./mobileRelay";
+export { createRelayNativeBindings } from "./nativeModule";
+export type { RelayNativeBindings, RelayNativeModule } from "./nativeModule";

package/src/mobileRelay.ts

@@ -0,0 +1,73 @@
+import { drainRelayQueue } from "./drain";
+import { createRelayFrameReceiver, type RelayReceiveFrameOptions } from "./relayFrameReceiver";
+import { createDurableRelayQueue, type StoredRelayMessage } from "./relayQueue";
+import { createRelayUploadScheduler } from "./scheduler";
+import { uploadRelayMessageOutcome, type RelayUploaderConfig } from "./uploader";
+import type { RelayDurableStore } from "./durableStore";
+import type { RelayUploadSchedulerNative } from "./scheduler";
+
+export type MobileRelayOptions = {
+  durableStore: RelayDurableStore;
+  uploaderConfig: Partial<RelayUploaderConfig> & Pick<RelayUploaderConfig, 'projectKey' | 'relayId' | 'relaySdkVersion' | 'streamId' | 'messageId'>;
+  schedulerNative?: RelayUploadSchedulerNative;
+  random?: () => number;
+};
+
+export function createMobileRelay(options: MobileRelayOptions) {
+  const uploaderConfig: RelayUploaderConfig = {
+    endpointUrl: "https://i.honch.io",
+    relaySdkPlatform: "ios",
+    ...options.uploaderConfig,
+  };
+
+  const queue = createDurableRelayQueue(options.durableStore);
+  const receiver = createRelayFrameReceiver({ queue });
+  const scheduler =
+    options.schedulerNative === undefined
+      ? undefined
+      : createRelayUploadScheduler({ native: options.schedulerNative });
+
+  return {
+    receiveFrame(deviceId: string, frameBytes: Uint8Array, receiveOptions?: RelayReceiveFrameOptions) {
+      return receiver.receiveFrame(deviceId, frameBytes, receiveOptions);
+    },
+
+    pending(): Promise<StoredRelayMessage[]> {
+      return queue.pending();
+    },
+
+    async startUploadScheduler(): Promise<void> {
+      if (scheduler === undefined) {
+        await this.drainUploads();
+        return;
+      }
+      await scheduler.schedule(0);
+      await this.drainUploads();
+    },
+
+    async stopUploadScheduler(): Promise<void> {
+      if (scheduler === undefined) {
+        return;
+      }
+      await scheduler.cancel();
+    },
+
+    drainUploads(): Promise<void> {
+      const drainStartedAtMs = Date.now();
+      return drainRelayQueue({
+        queue,
+        upload: (message) => uploadRelayMessageOutcome(uploaderConfig, message),
+        now: () => drainStartedAtMs,
+        random: options.random
+      }).then(async () => {
+        const pending = await queue.pending();
+        const dueTimes = pending
+          .map((message) => message.nextAttemptAtMs)
+          .filter((value): value is number => value !== undefined);
+        if (dueTimes.length > 0) {
+          await scheduler?.schedule(Math.max(0, Math.min(...dueTimes) - drainStartedAtMs));
+        }
+      });
+    }
+  };
+}

package/src/nativeModule.ts

@@ -0,0 +1,29 @@
+import type { RelayUploadSchedulerNative } from "./scheduler";
+
+export type RelayNativeModule = RelayUploadSchedulerNative;
+
+export type RelayNativeBindings = {
+  schedulerNative: RelayUploadSchedulerNative;
+};
+
+const requiredMethods = [
+  "scheduleUpload",
+  "cancelUpload"
+] as const;
+
+export function createRelayNativeBindings(nativeModule: unknown): RelayNativeBindings {
+  const module = nativeModule as Partial<Record<(typeof requiredMethods)[number], unknown>>;
+  for (const method of requiredMethods) {
+    if (typeof module[method] !== "function") {
+      throw new Error(`missing native relay method: ${method}`);
+    }
+  }
+
+  const typedModule = nativeModule as RelayNativeModule;
+  return {
+    schedulerNative: {
+      scheduleUpload: (delayMs) => typedModule.scheduleUpload(delayMs),
+      cancelUpload: () => typedModule.cancelUpload()
+    }
+  };
+}

package/src/relayFrameReceiver.ts

@@ -0,0 +1,67 @@
+import type { RelayQueue, StoredRelayMessage } from "./relayQueue";
+
+export type RelayFrameAcknowledgement = {
+  deviceId: string;
+  sequence: string;
+  ackBytes: Uint8Array;
+  message: StoredRelayMessage;
+};
+
+export type RelayFrameAcknowledger = (
+  acknowledgement: RelayFrameAcknowledgement
+) => Promise<void> | void;
+
+export type RelayFrameReceipt = {
+  complete: boolean;
+  message?: StoredRelayMessage;
+  ackBytes?: Uint8Array;
+};
+
+export type RelayFrameReceiverOptions = {
+  queue: RelayQueue;
+};
+
+export type RelayReceiveFrameOptions = {
+  acknowledge?: RelayFrameAcknowledger;
+};
+
+export function buildRelayAck(sequence: string | number | bigint): Uint8Array {
+  let value = BigInt(sequence);
+  if (value < 0n || value > 0xffff_ffff_ffff_ffffn) {
+    throw new Error("relay ACK sequence out of uint64 range");
+  }
+
+  const ackBytes = new Uint8Array(9);
+  ackBytes[0] = 1;
+  for (let index = 8; index >= 1; index -= 1) {
+    ackBytes[index] = Number(value & 0xffn);
+    value >>= 8n;
+  }
+  return ackBytes;
+}
+
+export function createRelayFrameReceiver(options: RelayFrameReceiverOptions) {
+  return {
+    async receiveFrame(
+      deviceId: string,
+      frameBytes: Uint8Array,
+      receiveOptions: RelayReceiveFrameOptions = {}
+    ): Promise<RelayFrameReceipt> {
+      const result = await options.queue.putChunk(deviceId, frameBytes);
+      if (!result.complete || result.message === undefined) {
+        return { complete: false };
+      }
+
+      const ackBytes = buildRelayAck(result.message.sequence);
+      if (receiveOptions.acknowledge !== undefined) {
+        await receiveOptions.acknowledge({
+          deviceId,
+          sequence: result.message.sequence,
+          ackBytes,
+          message: result.message
+        });
+      }
+      return { complete: true, message: result.message, ackBytes };
+    }
+  };
+}

package/src/relayQueue.ts

@@ -0,0 +1,282 @@
+import { decodeRelayFrame } from "./frame";
+import type { DurableRelayChunk, RelayDurableStore } from "./durableStore";
+
+export type StoredRelayMessage = {
+  deviceId: string;
+  sourceType: number;
+  sequence: string;
+  body: Uint8Array;
+  retryAttempt?: number;
+  nextAttemptAtMs?: number;
+};
+
+export type RelayRetryState = {
+  attempt: number;
+  nextAttemptAtMs: number;
+};
+
+export interface RelayQueue {
+  putChunk(
+    deviceId: string,
+    frameBytes: Uint8Array
+  ): Promise<{ complete: boolean; message?: StoredRelayMessage }>;
+  markUploaded(deviceId: string, sequence: string): Promise<void>;
+  markDropped(deviceId: string, sequence: string): Promise<void>;
+  markRetry(deviceId: string, sequence: string, retry: RelayRetryState): Promise<void>;
+  pending(): Promise<StoredRelayMessage[]>;
+}
+
+type StoredChunk = {
+  offset: number;
+  bytes: Uint8Array;
+  payload: Uint8Array;
+};
+
+type Assembly = {
+  deviceId: string;
+  sourceType: number;
+  sequence: string;
+  chunks: StoredChunk[];
+  finalEnd?: number;
+  message?: StoredRelayMessage;
+};
+
+export function createInMemoryRelayQueue(): RelayQueue {
+  const assemblies = new Map<string, Assembly>();
+  const completeMessages: StoredRelayMessage[] = [];
+
+  function key(deviceId: string, sequence: string): string {
+    return `${deviceId}\0${sequence}`;
+  }
+
+  function findChunk(assembly: Assembly, offset: number): StoredChunk | undefined {
+    return assembly.chunks.find((chunk) => chunk.offset === offset);
+  }
+
+  function completeMessage(assembly: Assembly): StoredRelayMessage | undefined {
+    if (assembly.finalEnd === undefined) {
+      return undefined;
+    }
+
+    const chunks = [...assembly.chunks].sort((left, right) => left.offset - right.offset);
+    let cursor = 0;
+    for (const chunk of chunks) {
+      if (chunk.offset !== cursor) {
+        return undefined;
+      }
+      cursor += chunk.payload.length;
+    }
+    if (cursor !== assembly.finalEnd) {
+      return undefined;
+    }
+
+    const body = new Uint8Array(cursor);
+    for (const chunk of chunks) {
+      body.set(chunk.payload, chunk.offset);
+    }
+    return {
+      deviceId: assembly.deviceId,
+      sourceType: assembly.sourceType,
+      sequence: assembly.sequence,
+      body
+    };
+  }
+
+  return {
+    async putChunk(deviceId, frameBytes) {
+      const frame = decodeRelayFrame(frameBytes);
+      const sequence = frame.sequence.toString();
+      const assemblyKey = key(deviceId, sequence);
+      let assembly = assemblies.get(assemblyKey);
+      if (assembly === undefined) {
+        assembly = {
+          deviceId,
+          sourceType: frame.sourceType,
+          sequence,
+          chunks: []
+        };
+        assemblies.set(assemblyKey, assembly);
+      } else if (assembly.sourceType !== frame.sourceType) {
+        throw new Error("relay frame source type mismatch");
+      }
+
+      const existing = findChunk(assembly, frame.offset);
+      if (existing !== undefined) {
+        if (!bytesEqual(existing.bytes, frameBytes)) {
+          throw new Error("relay duplicate chunk mismatch");
+        }
+        return { complete: assembly.message !== undefined, message: assembly.message };
+      }
+
+      if (frame.final) {
+        const finalEnd = frame.offset + frame.payload.length;
+        if (assembly.finalEnd !== undefined && assembly.finalEnd !== finalEnd) {
+          throw new Error("relay final chunk length mismatch");
+        }
+        assembly.finalEnd = finalEnd;
+      }
+      assembly.chunks.push({
+        offset: frame.offset,
+        bytes: new Uint8Array(frameBytes),
+        payload: new Uint8Array(frame.payload)
+      });
+
+      const message = completeMessage(assembly);
+      if (message === undefined) {
+        return { complete: false };
+      }
+
+      assembly.message = message;
+      if (!completeMessages.some((entry) => entry.deviceId === deviceId && entry.sequence === sequence)) {
+        completeMessages.push(message);
+      }
+      return { complete: true, message };
+    },
+
+    async markUploaded(deviceId, sequence) {
+      const assemblyKey = key(deviceId, sequence);
+      assemblies.delete(assemblyKey);
+      const index = completeMessages.findIndex(
+        (message) => message.deviceId === deviceId && message.sequence === sequence
+      );
+      if (index >= 0) {
+        completeMessages.splice(index, 1);
+      }
+    },
+
+    async markDropped(deviceId, sequence) {
+      await this.markUploaded(deviceId, sequence);
+    },
+
+    async markRetry(deviceId, sequence, retry) {
+      const message = completeMessages.find(
+        (entry) => entry.deviceId === deviceId && entry.sequence === sequence
+      );
+      if (message !== undefined) {
+        message.retryAttempt = retry.attempt;
+        message.nextAttemptAtMs = retry.nextAttemptAtMs;
+      }
+    },
+
+    async pending() {
+      return completeMessages.map((message) => ({
+        ...message,
+        body: new Uint8Array(message.body)
+      }));
+    }
+  };
+}
+
+export function createDurableRelayQueue(store: RelayDurableStore): RelayQueue {
+  return {
+    async putChunk(deviceId, frameBytes) {
+      const frame = decodeRelayFrame(frameBytes);
+      const sequence = frame.sequence.toString();
+      const existingChunks = await store.chunks(deviceId, sequence);
+      const existing = existingChunks.find((chunk) => chunk.offset === frame.offset);
+      if (existing !== undefined) {
+        if (!bytesEqual(existing.frameBytes, frameBytes)) {
+          throw new Error("relay duplicate chunk mismatch");
+        }
+        const existingMessage = (await store.completeMessages()).find(
+          (message) => message.deviceId === deviceId && message.sequence === sequence
+        );
+        return { complete: existingMessage !== undefined, message: existingMessage };
+      }
+
+      if (
+        existingChunks.length > 0 &&
+        existingChunks.some((chunk) => chunk.sourceType !== frame.sourceType)
+      ) {
+        throw new Error("relay frame source type mismatch");
+      }
+
+      const chunk: DurableRelayChunk = {
+        deviceId,
+        sourceType: frame.sourceType,
+        sequence,
+        offset: frame.offset,
+        frameBytes: new Uint8Array(frameBytes),
+        payload: new Uint8Array(frame.payload)
+      };
+      if (frame.final) {
+        const finalEnd = frame.offset + frame.payload.length;
+        const existingFinalEnd = existingChunks.find((entry) => entry.finalEnd !== undefined)?.finalEnd;
+        if (existingFinalEnd !== undefined && existingFinalEnd !== finalEnd) {
+          throw new Error("relay final chunk length mismatch");
+        }
+        chunk.finalEnd = finalEnd;
+      }
+      await store.putChunk(chunk);
+
+      const message = completeMessageFromChunks(deviceId, frame.sourceType, sequence, [
+        ...existingChunks,
+        chunk
+      ]);
+      if (message === undefined) {
+        return { complete: false };
+      }
+
+      await store.putCompleteMessage(message);
+      return { complete: true, message };
+    },
+
+    async markUploaded(deviceId, sequence) {
+      await store.deleteMessage(deviceId, sequence);
+    },
+
+    async markDropped(deviceId, sequence) {
+      await store.deleteMessage(deviceId, sequence);
+    },
+
+    async markRetry(deviceId, sequence, retry) {
+      await store.markRetry(deviceId, sequence, retry);
+    },
+
+    async pending() {
+      return store.completeMessages();
+    }
+  };
+}
+
+function completeMessageFromChunks(
+  deviceId: string,
+  sourceType: number,
+  sequence: string,
+  chunks: DurableRelayChunk[]
+): StoredRelayMessage | undefined {
+  const finalEnd = chunks.find((chunk) => chunk.finalEnd !== undefined)?.finalEnd;
+  if (finalEnd === undefined) {
+    return undefined;
+  }
+
+  const sorted = [...chunks].sort((left, right) => left.offset - right.offset);
+  let cursor = 0;
+  for (const chunk of sorted) {
+    if (chunk.offset !== cursor) {
+      return undefined;
+    }
+    cursor += chunk.payload.length;
+  }
+  if (cursor !== finalEnd) {
+    return undefined;
+  }
+
+  const body = new Uint8Array(cursor);
+  for (const chunk of sorted) {
+    body.set(chunk.payload, chunk.offset);
+  }
+  return { deviceId, sourceType, sequence, body };
+}
+
+function bytesEqual(left: Uint8Array, right: Uint8Array): boolean {
+  if (left.length !== right.length) {
+    return false;
+  }
+  for (let i = 0; i < left.length; i += 1) {
+    if (left[i] !== right[i]) {
+      return false;
+    }
+  }
+  return true;
+}