@trainstar/synchro-react-native 0.1.2 → 0.3.2

package/src/digest.ts

@@ -0,0 +1,93 @@
+/** Return the SHA-256 digest of a string as lowercase hexadecimal. */
+export function sha256Hex(value: string): string {
+  const bytes = utf8(value);
+  const bitLength = bytes.length * 8;
+  bytes.push(0x80);
+  while ((bytes.length + 8) % 64 !== 0) {
+    bytes.push(0);
+  }
+  for (let shift = 56; shift >= 0; shift -= 8) {
+    bytes.push(Math.floor(bitLength / 2 ** shift) & 0xff);
+  }
+  const hash = [
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+    0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+  ];
+  const constants = [
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+  ];
+  for (let offset = 0; offset < bytes.length; offset += 64) {
+    const words = new Array<number>(64).fill(0);
+    for (let index = 0; index < 16; index += 1) {
+      words[index] = ((bytes[offset + index * 4] << 24) | (bytes[offset + index * 4 + 1] << 16) | (bytes[offset + index * 4 + 2] << 8) | bytes[offset + index * 4 + 3]) >>> 0;
+    }
+    for (let index = 16; index < 64; index += 1) {
+      const a = words[index - 15];
+      const b = words[index - 2];
+      const s0 = rotateRight(a, 7) ^ rotateRight(a, 18) ^ (a >>> 3);
+      const s1 = rotateRight(b, 17) ^ rotateRight(b, 19) ^ (b >>> 10);
+      words[index] = (words[index - 16] + s0 + words[index - 7] + s1) >>> 0;
+    }
+    let [a, b, c, d, e, f, g, h] = hash;
+    for (let index = 0; index < 64; index += 1) {
+      const s1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
+      const choice = (e & f) ^ (~e & g);
+      const temp1 = (h + s1 + choice + constants[index] + words[index]) >>> 0;
+      const s0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
+      const majority = (a & b) ^ (a & c) ^ (b & c);
+      const temp2 = (s0 + majority) >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = (d + temp1) >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = (temp1 + temp2) >>> 0;
+    }
+    hash[0] = (hash[0] + a) >>> 0;
+    hash[1] = (hash[1] + b) >>> 0;
+    hash[2] = (hash[2] + c) >>> 0;
+    hash[3] = (hash[3] + d) >>> 0;
+    hash[4] = (hash[4] + e) >>> 0;
+    hash[5] = (hash[5] + f) >>> 0;
+    hash[6] = (hash[6] + g) >>> 0;
+    hash[7] = (hash[7] + h) >>> 0;
+  }
+  return hash.map((word) => word.toString(16).padStart(8, '0')).join('');
+}
+
+function rotateRight(value: number, shift: number): number {
+  return (value >>> shift) | (value << (32 - shift));
+}
+
+function utf8(value: string): number[] {
+  const bytes: number[] = [];
+  for (let index = 0; index < value.length; index += 1) {
+    let code = value.charCodeAt(index);
+    if (code >= 0xd800 && code <= 0xdbff && index + 1 < value.length) {
+      const low = value.charCodeAt(index + 1);
+      if (low >= 0xdc00 && low <= 0xdfff) {
+        code = 0x10000 + ((code - 0xd800) << 10) + low - 0xdc00;
+        index += 1;
+      }
+    }
+    if (code < 0x80) {
+      bytes.push(code);
+    } else if (code < 0x800) {
+      bytes.push(0xc0 | (code >> 6), 0x80 | (code & 0x3f));
+    } else if (code < 0x10000) {
+      bytes.push(0xe0 | (code >> 12), 0x80 | ((code >> 6) & 0x3f), 0x80 | (code & 0x3f));
+    } else {
+      bytes.push(0xf0 | (code >> 18), 0x80 | ((code >> 12) & 0x3f), 0x80 | ((code >> 6) & 0x3f), 0x80 | (code & 0x3f));
+    }
+  }
+  return bytes;
+}

package/src/errors.ts

@@ -1,7 +1,47 @@
+import {
+  PROTOCOL_ERROR_CODES,
+  SYNC_FAILURE_CODES,
+  SYNC_OPERATION_KINDS,
+  SYNC_RECOVERY_ACTIONS,
+  SYNC_STATUS_TYPES,
+} from './types';
+import type {
+  ProtocolErrorCode,
+  Row,
+  SyncFailure,
+  SyncStatusType,
+} from './types';
+
+export const NATIVE_ERROR_CODES = [
+  'NOT_CONNECTED',
+  'SCHEMA_NOT_LOADED',
+  'TABLE_NOT_SYNCED',
+  'UPGRADE_REQUIRED',
+  'SCHEMA_MISMATCH',
+  'PUSH_REJECTED',
+  'NETWORK_ERROR',
+  'SERVER_ERROR',
+  'PROTOCOL_ERROR',
+  'DATABASE_ERROR',
+  'INVALID_RESPONSE',
+  'INVALID_SEED',
+  'SYNC_BLOCKED',
+  'UNSUPPORTED_SCHEMA',
+  'INVALID_STATE_TRANSITION',
+  'ALREADY_STARTED',
+  'NOT_STARTED',
+  'TRANSACTION_TIMEOUT',
+  'INVALID_CONFIG',
+  'CLIENT_ALREADY_ACTIVE',
+  'UNKNOWN',
+] as const;
+
+export type NativeErrorCode = (typeof NATIVE_ERROR_CODES)[number];
+
 export class SynchroError extends Error {
-  readonly code: string;
+  readonly code: NativeErrorCode;
 
-  constructor(code: string, message: string) {
+  constructor(code: NativeErrorCode, message: string) {
     super(message);
     this.code = code;
     this.name = 'SynchroError';
@@ -62,25 +102,22 @@ export class SchemaMismatchError extends SynchroError {
   }
 }
 
-export class SnapshotRequiredError extends SynchroError {
-  constructor() {
-    super('SNAPSHOT_REQUIRED', 'Full snapshot required');
-    this.name = 'SnapshotRequiredError';
-  }
-}
-
-export interface PushResultItem {
-  recordID: string;
+export interface PushRejectedMutation {
+  mutationID: string;
   table: string;
+  pk: Row;
   status: string;
+  code: string;
   message?: string;
+  serverRow?: Row | null;
+  serverVersion?: string | null;
 }
 
 export class PushRejectedError extends SynchroError {
-  readonly results: PushResultItem[];
+  readonly results: PushRejectedMutation[];
 
-  constructor(results: PushResultItem[]) {
-    super('PUSH_REJECTED', `Push rejected: ${results.length} record(s)`);
+  constructor(results: PushRejectedMutation[]) {
+    super('PUSH_REJECTED', `Push rejected: ${results.length} mutation(s)`);
     this.name = 'PushRejectedError';
     this.results = results;
   }
@@ -117,6 +154,64 @@ export class InvalidResponseError extends SynchroError {
   }
 }
 
+export const SCHEMA_UNSUPPORTED_REASONS = [
+  'unknown_schema_lineage',
+  'incompatible_schema_transition',
+] as const;
+
+export type SchemaUnsupportedReason = (typeof SCHEMA_UNSUPPORTED_REASONS)[number];
+
+export class ProtocolError extends SynchroError {
+  readonly status: number;
+  readonly protocolCode: ProtocolErrorCode;
+
+  constructor(status: number, protocolCode: ProtocolErrorCode, message: string) {
+    super('PROTOCOL_ERROR', `Protocol error ${status} ${protocolCode}: ${message}`);
+    this.name = 'ProtocolError';
+    this.status = status;
+    this.protocolCode = protocolCode;
+  }
+}
+
+export class SyncBlockedError extends SynchroError {
+  readonly failure: SyncFailure;
+
+  constructor(failure: SyncFailure) {
+    super('SYNC_BLOCKED', failure.message);
+    this.name = 'SyncBlockedError';
+    this.failure = failure;
+  }
+}
+
+export class UnsupportedSchemaError extends SynchroError {
+  readonly reason: SchemaUnsupportedReason;
+
+  constructor(reason: SchemaUnsupportedReason) {
+    super('UNSUPPORTED_SCHEMA', `Schema recovery is required: ${reason}`);
+    this.name = 'UnsupportedSchemaError';
+    this.reason = reason;
+  }
+}
+
+export class InvalidStateTransitionError extends SynchroError {
+  readonly from: SyncStatusType;
+  readonly to: SyncStatusType;
+
+  constructor(from: SyncStatusType, to: SyncStatusType) {
+    super('INVALID_STATE_TRANSITION', `Invalid sync state transition from ${from} to ${to}`);
+    this.name = 'InvalidStateTransitionError';
+    this.from = from;
+    this.to = to;
+  }
+}
+
+export class InvalidSeedError extends SynchroError {
+  constructor() {
+    super('INVALID_SEED', 'Seed database failed validation');
+    this.name = 'InvalidSeedError';
+  }
+}
+
 export class AlreadyStartedError extends SynchroError {
   constructor() {
     super('ALREADY_STARTED', 'Sync has already been started');
@@ -141,7 +236,104 @@ export class TransactionTimeoutError extends SynchroError {
 interface NativeErrorLike {
   code?: string;
   message?: string;
-  userInfo?: Record<string, string>;
+  userInfo?: Record<string, unknown>;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function parseJSONValue(value: unknown, name: string): unknown {
+  if (typeof value !== 'string') {
+    return value;
+  }
+  try {
+    return JSON.parse(value) as unknown;
+  } catch {
+    throw new InvalidResponseError(`Native bridge returned invalid ${name}`);
+  }
+}
+
+function requiredString(value: unknown, name: string): string {
+  if (typeof value !== 'string' || value.length === 0) {
+    throw new InvalidResponseError(`Native bridge returned an invalid ${name}`);
+  }
+  return value;
+}
+
+function requiredBoolean(value: unknown, name: string): boolean {
+  if (typeof value === 'boolean') {
+    return value;
+  }
+  if (value === 'true') {
+    return true;
+  }
+  if (value === 'false') {
+    return false;
+  }
+  throw new InvalidResponseError(`Native bridge returned an invalid ${name}`);
+}
+
+function optionalString(value: unknown): string {
+  return typeof value === 'string' ? value : '';
+}
+
+function requiredEnum<T extends string>(value: unknown, values: readonly T[], name: string): T {
+  if (typeof value === 'string' && values.includes(value as T)) {
+    return value as T;
+  }
+  throw new InvalidResponseError(`Native bridge returned an invalid ${name}`);
+}
+
+export function parseSyncFailure(value: unknown): SyncFailure {
+  const parsed = parseJSONValue(value, 'sync failure');
+  if (!isRecord(parsed)) {
+    throw new InvalidResponseError('Native bridge returned an invalid sync failure');
+  }
+
+  const message = requiredString(parsed.message, 'sync failure message');
+  if (message.length > 256) {
+    throw new InvalidResponseError('Native bridge returned an invalid sync failure message');
+  }
+
+  const metadataValue = parsed.metadata == null ? {} : parseJSONValue(parsed.metadata, 'sync failure metadata');
+  if (!isRecord(metadataValue) || Object.keys(metadataValue).length > 8) {
+    throw new InvalidResponseError('Native bridge returned invalid sync failure metadata');
+  }
+  const metadata: Record<string, string> = {};
+  Object.entries(metadataValue).forEach(([key, item]) => {
+    if (key.length === 0 || key.length > 64 || typeof item !== 'string' || item.length > 128) {
+      throw new InvalidResponseError('Native bridge returned invalid sync failure metadata');
+    }
+    metadata[key] = item;
+  });
+
+  return {
+    operation: requiredEnum(parsed.operation, SYNC_OPERATION_KINDS, 'sync failure operation'),
+    code: requiredEnum(parsed.code, SYNC_FAILURE_CODES, 'sync failure code'),
+    retryable: requiredBoolean(parsed.retryable, 'sync failure retry flag'),
+    message,
+    recoveryAction: requiredEnum(
+      parsed.recoveryAction,
+      SYNC_RECOVERY_ACTIONS,
+      'sync failure recovery action'
+    ),
+    metadata,
+  };
+}
+
+function syncFailureFromUserInfo(userInfo: Record<string, unknown>, fallbackMessage: string): SyncFailure {
+  if (userInfo.failure != null) {
+    return parseSyncFailure(userInfo.failure);
+  }
+  return parseSyncFailure({
+    operation: userInfo.failureOperation,
+    code: userInfo.failureCode,
+    retryable: userInfo.failureRetryable,
+    message: userInfo.failureMessage ?? fallbackMessage,
+    recoveryAction: userInfo.failureRecoveryAction,
+    metadata: userInfo.failureMetadata ?? {},
+  });
 }
 
 export function mapNativeError(error: unknown): SynchroError {
@@ -160,46 +352,94 @@ export function mapNativeError(error: unknown): SynchroError {
     case 'SCHEMA_NOT_LOADED':
       return new SchemaNotLoadedError();
     case 'TABLE_NOT_SYNCED':
-      return new TableNotSyncedError(userInfo.table ?? '');
+      return new TableNotSyncedError(optionalString(userInfo.table));
     case 'UPGRADE_REQUIRED':
       return new UpgradeRequiredError(
-        userInfo.currentVersion ?? '',
-        userInfo.minimumVersion ?? ''
+        optionalString(userInfo.currentVersion),
+        optionalString(userInfo.minimumVersion)
       );
     case 'SCHEMA_MISMATCH':
       return new SchemaMismatchError(
-        parseInt(userInfo.serverVersion ?? '0', 10),
-        userInfo.serverHash ?? ''
+        parseInt(optionalString(userInfo.serverVersion), 10),
+        optionalString(userInfo.serverHash)
       );
-    case 'SNAPSHOT_REQUIRED':
-      return new SnapshotRequiredError();
     case 'PUSH_REJECTED': {
-      let results: PushResultItem[] = [];
       try {
-        results = JSON.parse(userInfo.results ?? '[]');
-      } catch {
-        // leave empty
+        const parsed = parseJSONValue(userInfo.results ?? [], 'push rejection results');
+        if (!Array.isArray(parsed)) {
+          return new InvalidResponseError('Native bridge returned invalid push rejection results');
+        }
+        return new PushRejectedError(parsed as PushRejectedMutation[]);
+      } catch (parseError) {
+        return parseError instanceof SynchroError
+          ? parseError
+          : new InvalidResponseError('Native bridge returned invalid push rejection results');
       }
-      return new PushRejectedError(results);
     }
     case 'NETWORK_ERROR':
-      return new NetworkError(userInfo.message ?? message);
+      return new NetworkError(typeof userInfo.message === 'string' ? userInfo.message : message);
     case 'SERVER_ERROR':
       return new ServerError(
-        parseInt(userInfo.status ?? '0', 10),
-        userInfo.message ?? message
+        Number.parseInt(String(userInfo.status ?? '0'), 10),
+        typeof userInfo.message === 'string' ? userInfo.message : message
+      );
+    case 'PROTOCOL_ERROR': {
+      const status = Number.parseInt(String(userInfo.status ?? '0'), 10);
+      const protocolCode = requiredEnum(
+        userInfo.protocolCode,
+        PROTOCOL_ERROR_CODES,
+        'protocol error code'
       );
+      return new ProtocolError(
+        status,
+        protocolCode,
+        typeof userInfo.message === 'string' ? userInfo.message : message
+      );
+    }
     case 'DATABASE_ERROR':
-      return new DatabaseError(userInfo.message ?? message);
+      return new DatabaseError(typeof userInfo.message === 'string' ? userInfo.message : message);
     case 'INVALID_RESPONSE':
-      return new InvalidResponseError(userInfo.message ?? message);
+      return new InvalidResponseError(typeof userInfo.message === 'string' ? userInfo.message : message);
+    case 'INVALID_SEED':
+      return new InvalidSeedError();
+    case 'SYNC_BLOCKED':
+      try {
+        return new SyncBlockedError(syncFailureFromUserInfo(userInfo, message));
+      } catch (parseError) {
+        return parseError instanceof SynchroError
+          ? parseError
+          : new InvalidResponseError('Native bridge returned invalid blocking failure details');
+      }
+    case 'UNSUPPORTED_SCHEMA':
+      try {
+        return new UnsupportedSchemaError(
+          requiredEnum(userInfo.reason, SCHEMA_UNSUPPORTED_REASONS, 'unsupported schema reason')
+        );
+      } catch (parseError) {
+        return parseError instanceof SynchroError
+          ? parseError
+          : new InvalidResponseError('Native bridge returned invalid unsupported schema details');
+      }
+    case 'INVALID_STATE_TRANSITION':
+      try {
+        return new InvalidStateTransitionError(
+          requiredEnum(userInfo.from, SYNC_STATUS_TYPES, 'state transition source'),
+          requiredEnum(userInfo.to, SYNC_STATUS_TYPES, 'state transition target')
+        );
+      } catch (parseError) {
+        return parseError instanceof SynchroError
+          ? parseError
+          : new InvalidResponseError('Native bridge returned invalid state transition details');
+      }
     case 'ALREADY_STARTED':
       return new AlreadyStartedError();
     case 'NOT_STARTED':
       return new NotStartedError();
     case 'TRANSACTION_TIMEOUT':
       return new TransactionTimeoutError();
+    case 'INVALID_CONFIG':
+      return new SynchroError('INVALID_CONFIG', message);
     default:
-      return new SynchroError(code ?? 'UNKNOWN', message);
+      return new SynchroError('UNKNOWN', message);
   }
 }

package/src/hooks/useQuery.ts

@@ -1,6 +1,6 @@
 import { useState, useEffect, useCallback, useRef } from 'react';
 import type { SynchroClient } from '../SynchroClient';
-import type { Row } from '../types';
+import type { AsyncUnsubscribe, Row, SQLiteBindValue } from '../types';
 import type { SynchroError } from '../errors';
 
 interface UseQueryResult {
@@ -10,20 +10,41 @@ interface UseQueryResult {
   refresh: () => void;
 }
 
-function arraysEqual<T>(
-  a?: readonly T[],
-  b?: readonly T[]
+function arraysEqual(
+  a?: readonly SQLiteBindValue[],
+  b?: readonly SQLiteBindValue[]
 ): boolean {
   if (a === b) return true;
   if (!a || !b) return !a && !b;
   if (a.length !== b.length) return false;
   for (let i = 0; i < a.length; i += 1) {
-    if (a[i] !== b[i]) return false;
+    const left = a[i];
+    const right = b[i];
+    if (left === right) continue;
+    if (
+      typeof left !== 'object' || left === null ||
+      typeof right !== 'object' || right === null
+    ) return false;
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    if (
+      leftKeys.length !== 2 || rightKeys.length !== 2 ||
+      !leftKeys.includes('type') || !rightKeys.includes('type')
+    ) return false;
+    if (left.type === 'int64' && right.type === 'int64') {
+      if (!leftKeys.includes('value') || !rightKeys.includes('value')) return false;
+      if (typeof left.value !== 'string' || left.value !== right.value) return false;
+    } else if (left.type === 'bytes' && right.type === 'bytes') {
+      if (!leftKeys.includes('base64') || !rightKeys.includes('base64')) return false;
+      if (typeof left.base64 !== 'string' || left.base64 !== right.base64) return false;
+    } else {
+      return false;
+    }
   }
   return true;
 }
 
-function useStableArray<T>(value?: readonly T[]): readonly T[] | undefined {
+function useStableArray<T extends SQLiteBindValue>(value?: readonly T[]): readonly T[] | undefined {
   const ref = useRef<readonly T[] | undefined>(value);
   if (!arraysEqual(ref.current, value)) {
     ref.current = value ? [...value] : value;
@@ -34,7 +55,7 @@ function useStableArray<T>(value?: readonly T[]): readonly T[] | undefined {
 export function useQuery(
   client: SynchroClient,
   sql: string,
-  params?: unknown[],
+  params?: SQLiteBindValue[],
   tables?: string[]
 ): UseQueryResult {
   const [data, setData] = useState<Row[]>([]);
@@ -55,21 +76,43 @@ export function useQuery(
       // Reactive mode: use watch()
       setLoading(true);
       let firstResult = true;
-      const unsubscribe = client.watch(sql, stableParams as unknown[] | undefined, stableTables as string[], (rows) => {
-        setData(rows);
-        setError(null);
-        if (firstResult) {
-          setLoading(false);
-          firstResult = false;
+      let disposed = false;
+      let unsubscribe: AsyncUnsubscribe | null = null;
+      client
+        .watch(sql, stableParams, stableTables as string[], (rows) => {
+          if (disposed) return;
+          setData(rows);
+          setError(null);
+          if (firstResult) {
+            setLoading(false);
+            firstResult = false;
+          }
+        })
+        .then((remove) => {
+          if (disposed) {
+            void remove().catch(() => {});
+          } else {
+            unsubscribe = remove;
+          }
+        })
+        .catch((err) => {
+          if (!disposed) {
+            setError(err);
+            setLoading(false);
+          }
+        });
+      return () => {
+        disposed = true;
+        if (unsubscribe) {
+          void unsubscribe().catch(() => {});
         }
-      });
-      return unsubscribe;
+      };
     } else {
       // One-shot mode: use query()
       let cancelled = false;
       setLoading(true);
       client
-        .query(sql, stableParams as unknown[] | undefined)
+        .query(sql, stableParams)
         .then((rows) => {
           if (!cancelled) {
             setData(rows);

package/src/hooks/useSyncStatus.ts

@@ -1,17 +1,50 @@
 import { useState, useEffect } from 'react';
 import type { SynchroClient } from '../SynchroClient';
 import type { SyncStatus } from '../types';
+import { mapNativeError, type SynchroError } from '../errors';
+
+const uninitialized: SyncStatus = {
+  status: 'uninitialized',
+  retryAt: null,
+  operation: null,
+  failure: null,
+};
 
 export function useSyncStatus(client: SynchroClient): SyncStatus {
-  const [status, setStatus] = useState<SyncStatus>({
-    status: 'idle',
-    retryAt: null,
-  });
+  const [snapshot, setSnapshot] = useState<{
+    client: SynchroClient;
+    status: SyncStatus;
+    error: SynchroError | null;
+  }>({ client, status: uninitialized, error: null });
 
   useEffect(() => {
-    const unsubscribe = client.onStatusChange(setStatus);
-    return unsubscribe;
+    let active = true;
+    let receivedEvent = false;
+    setSnapshot({ client, status: uninitialized, error: null });
+    const unsubscribe = client.onStatusChange((status) => {
+      if (!active) return;
+      receivedEvent = true;
+      setSnapshot({ client, status, error: null });
+    });
+    client.getSyncStatus().then(
+      (status) => {
+        if (active && !receivedEvent) {
+          setSnapshot({ client, status, error: null });
+        }
+      },
+      (error: unknown) => {
+        if (active && !receivedEvent) {
+          setSnapshot({ client, status: uninitialized, error: mapNativeError(error) });
+        }
+      }
+    );
+    return () => {
+      active = false;
+      unsubscribe();
+    };
   }, [client]);
 
-  return status;
+  if (snapshot.client !== client) return uninitialized;
+  if (snapshot.error) throw snapshot.error;
+  return snapshot.status;
 }