@swiftpatch/react-native 2.0.0

package/src/SwiftPatchCore.ts

@@ -0,0 +1,148 @@
+import NativeSwiftPatch from './native/NativeSwiftPatch';
+import { reportInstallStatus } from './utils/api';
+import { logger } from './utils/logger';
+import { UpdateChecker } from './core/UpdateChecker';
+import { Downloader } from './core/Downloader';
+import { Installer } from './core/Installer';
+import { Rollback as RollbackModule } from './core/Rollback';
+import type {
+  SwiftPatchConfig,
+  ReleaseInfo,
+  BundleInfo,
+} from './types';
+import { DEFAULT_CONFIG } from './constants';
+
+/**
+ * Imperative API for SwiftPatch (non-React usage).
+ *
+ * Use this when you need to interact with SwiftPatch outside of
+ * React components, such as in native module callbacks or background tasks.
+ *
+ * @example
+ * ```ts
+ * import { SwiftPatch } from '@orbitplus/react-native';
+ *
+ * const sp = new SwiftPatch({ deploymentKey: 'your-key' });
+ * await sp.init();
+ * const update = await sp.checkForUpdate();
+ * if (update) {
+ *   await sp.downloadAndInstall(update);
+ * }
+ * ```
+ */
+export class SwiftPatch {
+  private config: Required<Omit<SwiftPatchConfig, 'customHeaders' | 'publicKey'>> & {
+    customHeaders: Record<string, string>;
+    publicKey: string | null;
+  };
+
+  private updateChecker!: UpdateChecker;
+  private downloader!: Downloader;
+  private installer!: Installer;
+  private rollbackModule!: RollbackModule;
+
+  constructor(userConfig: SwiftPatchConfig) {
+    this.config = { ...DEFAULT_CONFIG, ...userConfig } as typeof this.config;
+  }
+
+  /**
+   * Initialize the native module
+   */
+  async init(): Promise<void> {
+    await NativeSwiftPatch.initialize({
+      deploymentKey: this.config.deploymentKey,
+      serverUrl: this.config.serverUrl,
+      publicKey: this.config.publicKey,
+    });
+    NativeSwiftPatch.setDebugMode(this.config.debug);
+    logger.setDebug(this.config.debug);
+
+    // Initialize core modules
+    this.updateChecker = new UpdateChecker({
+      serverUrl: this.config.serverUrl,
+      deploymentKey: this.config.deploymentKey,
+      customHeaders: this.config.customHeaders,
+    });
+    this.downloader = new Downloader();
+    this.installer = new Installer();
+    this.rollbackModule = new RollbackModule();
+
+    logger.info('SwiftPatch initialized (imperative)');
+  }
+
+  /**
+   * Check for an available update
+   */
+  async checkForUpdate(): Promise<ReleaseInfo | null> {
+    const result = await this.updateChecker.check();
+
+    if (result.updateAvailable && result.release) {
+      return result.release;
+    }
+    return null;
+  }
+
+  /**
+   * Download an update
+   */
+  async download(release: ReleaseInfo): Promise<void> {
+    await this.downloader.downloadRelease(release);
+
+    await reportInstallStatus({
+      serverUrl: this.config.serverUrl,
+      releaseId: release.id,
+      status: 'downloaded',
+      deploymentKey: this.config.deploymentKey,
+    });
+  }
+
+  /**
+   * Install a downloaded update
+   */
+  async install(release: ReleaseInfo): Promise<void> {
+    await this.installer.install(release.bundleHash);
+
+    await reportInstallStatus({
+      serverUrl: this.config.serverUrl,
+      releaseId: release.id,
+      status: 'installed',
+      deploymentKey: this.config.deploymentKey,
+    });
+  }
+
+  /**
+   * Download and install an update in one call
+   */
+  async downloadAndInstall(release: ReleaseInfo): Promise<void> {
+    await this.download(release);
+    await this.install(release);
+  }
+
+  /**
+   * Restart the app to apply the update
+   */
+  restart(): void {
+    NativeSwiftPatch.restart();
+  }
+
+  /**
+   * Rollback to the previous bundle
+   */
+  async rollback(): Promise<void> {
+    await this.rollbackModule.rollback();
+  }
+
+  /**
+   * Get current bundle info
+   */
+  async getCurrentBundle(): Promise<BundleInfo | null> {
+    return NativeSwiftPatch.getCurrentBundle();
+  }
+
+  /**
+   * Clear any pending update
+   */
+  async clearPendingUpdate(): Promise<void> {
+    await this.rollbackModule.clearPending();
+  }
+}

package/src/SwiftPatchProvider.tsx

@@ -0,0 +1,514 @@
+import React, {
+  createContext,
+  useContext,
+  useEffect,
+  useReducer,
+  useCallback,
+  useRef,
+  type ReactNode,
+} from 'react';
+import { AppState, type AppStateStatus } from 'react-native';
+import type {
+  SwiftPatchConfig,
+  SwiftPatchState,
+  SwiftPatchActions,
+  ReleaseInfo,
+  UpdateStatus,
+  SwiftPatchError,
+  DownloadProgress,
+  SlotMetadata,
+  BundleInfo,
+} from './types';
+import {
+  UpdateStatus as Status,
+  InstallMode,
+  SwiftPatchErrorCode,
+  EnvironmentMode,
+} from './types';
+import { DEFAULT_CONFIG, EVENT_POLL_INTERVAL_MS } from './constants';
+import NativeSwiftPatch, {
+  onDownloadProgress,
+  onRollback,
+  onVersionChanged,
+} from './native/NativeSwiftPatch';
+import { reportInstallStatus, logBulkEvents } from './utils/api';
+import { logger } from './utils/logger';
+import { UpdateChecker } from './core/UpdateChecker';
+import { Downloader } from './core/Downloader';
+import { Installer } from './core/Installer';
+import { Rollback as RollbackModule } from './core/Rollback';
+
+// Context
+interface SwiftPatchContextValue extends SwiftPatchState, SwiftPatchActions {}
+
+const SwiftPatchContext = createContext<SwiftPatchContextValue | null>(null);
+
+// State reducer
+type Action =
+  | { type: 'SET_STATUS'; payload: UpdateStatus }
+  | { type: 'SET_DOWNLOAD_PROGRESS'; payload: DownloadProgress | null }
+  | { type: 'SET_AVAILABLE_UPDATE'; payload: ReleaseInfo | null }
+  | { type: 'SET_ERROR'; payload: SwiftPatchError | null }
+  | { type: 'SET_RESTART_REQUIRED'; payload: boolean }
+  | { type: 'SET_LAST_CHECKED'; payload: Date }
+  | { type: 'SET_CURRENT_BUNDLE'; payload: BundleInfo | null }
+  | { type: 'SET_SLOT_METADATA'; payload: SlotMetadata | null }
+  | { type: 'SET_ENVIRONMENT'; payload: EnvironmentMode };
+
+function reducer(state: SwiftPatchState, action: Action): SwiftPatchState {
+  switch (action.type) {
+    case 'SET_STATUS':
+      return { ...state, status: action.payload };
+    case 'SET_DOWNLOAD_PROGRESS':
+      return { ...state, downloadProgress: action.payload };
+    case 'SET_AVAILABLE_UPDATE':
+      return { ...state, availableUpdate: action.payload };
+    case 'SET_ERROR':
+      return {
+        ...state,
+        error: action.payload,
+        status: action.payload ? Status.ERROR : state.status,
+      };
+    case 'SET_RESTART_REQUIRED':
+      return { ...state, isRestartRequired: action.payload };
+    case 'SET_LAST_CHECKED':
+      return { ...state, lastCheckedAt: action.payload };
+    case 'SET_CURRENT_BUNDLE':
+      return { ...state, currentBundle: action.payload };
+    case 'SET_SLOT_METADATA':
+      return { ...state, slotMetadata: action.payload };
+    case 'SET_ENVIRONMENT':
+      return { ...state, environment: action.payload };
+    default:
+      return state;
+  }
+}
+
+const initialState: SwiftPatchState = {
+  status: Status.UP_TO_DATE,
+  downloadProgress: null,
+  currentBundle: null,
+  availableUpdate: null,
+  isRestartRequired: false,
+  error: null,
+  lastCheckedAt: null,
+  slotMetadata: null,
+  environment: EnvironmentMode.PRODUCTION,
+};
+
+// Provider Props
+interface SwiftPatchProviderProps {
+  config: SwiftPatchConfig;
+  children: ReactNode;
+}
+
+/**
+ * SwiftPatch Provider Component
+ *
+ * Wrap your app with this provider to enable OTA updates
+ * with dual-slot architecture, crash detection, and event analytics.
+ */
+export function SwiftPatchProvider({
+  config,
+  children,
+}: SwiftPatchProviderProps) {
+  const mergedConfig = { ...DEFAULT_CONFIG, ...config };
+  const [state, dispatch] = useReducer(reducer, initialState);
+  const lastCheckRef = useRef<number>(0);
+  const isCheckingRef = useRef<boolean>(false);
+  const configRef = useRef(mergedConfig);
+  configRef.current = mergedConfig;
+
+  // Core modules refs
+  const updateCheckerRef = useRef<UpdateChecker | null>(null);
+  const downloaderRef = useRef<Downloader | null>(null);
+  const installerRef = useRef<Installer | null>(null);
+  const rollbackModuleRef = useRef<RollbackModule | null>(null);
+  const eventPollIntervalRef = useRef<ReturnType<typeof setInterval> | null>(null);
+
+  // Initialize native module and core modules
+  useEffect(() => {
+    const init = async () => {
+      try {
+        await NativeSwiftPatch.initialize({
+          deploymentKey: mergedConfig.deploymentKey,
+          serverUrl: mergedConfig.serverUrl!,
+          publicKey: mergedConfig.publicKey || null,
+        });
+
+        NativeSwiftPatch.setDebugMode(mergedConfig.debug || false);
+        logger.setDebug(mergedConfig.debug || false);
+
+        // Mark app as mounted (for signal crash detection)
+        await NativeSwiftPatch.markMounted();
+
+        // Initialize core modules
+        updateCheckerRef.current = new UpdateChecker({
+          serverUrl: mergedConfig.serverUrl!,
+          deploymentKey: mergedConfig.deploymentKey,
+          customHeaders: mergedConfig.customHeaders,
+        });
+        downloaderRef.current = new Downloader();
+        installerRef.current = new Installer();
+        rollbackModuleRef.current = new RollbackModule();
+
+        // Get current bundle info
+        const currentBundle = await NativeSwiftPatch.getCurrentBundle();
+        if (currentBundle) {
+          dispatch({ type: 'SET_CURRENT_BUNDLE', payload: currentBundle });
+          dispatch({ type: 'SET_STATUS', payload: Status.UP_TO_DATE });
+        }
+
+        // Get slot metadata
+        const metadata = await NativeSwiftPatch.getSlotMetadata();
+        dispatch({ type: 'SET_SLOT_METADATA', payload: metadata });
+        dispatch({
+          type: 'SET_ENVIRONMENT',
+          payload: metadata.environment,
+        });
+
+        // Check for pending install (temp hash set)
+        const hasPending = await NativeSwiftPatch.hasPendingInstall();
+        if (hasPending) {
+          dispatch({ type: 'SET_RESTART_REQUIRED', payload: true });
+          dispatch({ type: 'SET_STATUS', payload: Status.RESTART_REQUIRED });
+        }
+
+        // Record successful launch & auto-stabilize
+        if (currentBundle && !currentBundle.isOriginal) {
+          const launchCount = await NativeSwiftPatch.recordSuccessfulLaunch(currentBundle.hash);
+          const autoStabilizeThreshold = mergedConfig.autoStabilizeAfterLaunches || 0;
+          if (autoStabilizeThreshold > 0 && launchCount >= autoStabilizeThreshold) {
+            if (metadata.prod.currentSlot === 'NEW_SLOT') {
+              try {
+                await NativeSwiftPatch.stabilize();
+                const updatedMeta = await NativeSwiftPatch.getSlotMetadata();
+                dispatch({ type: 'SET_SLOT_METADATA', payload: updatedMeta });
+                logger.info('Auto-stabilized after', launchCount, 'successful launches');
+              } catch (_e) {
+                logger.warn('Auto-stabilization failed');
+              }
+            }
+          }
+        }
+
+        logger.info('SwiftPatch initialized (v2.0.0 with dual-slot architecture)');
+      } catch (error: unknown) {
+        const message = error instanceof Error ? error.message : 'Unknown initialization error';
+        logger.error('Failed to initialize SwiftPatch', error);
+        dispatch({
+          type: 'SET_ERROR',
+          payload: { code: SwiftPatchErrorCode.CONFIG_ERROR, message },
+        });
+      }
+    };
+
+    init();
+
+    // Cleanup mount state on unmount
+    return () => {
+      NativeSwiftPatch.markUnmounted().catch(() => {});
+    };
+  }, [mergedConfig.deploymentKey, mergedConfig.serverUrl, mergedConfig.publicKey, mergedConfig.debug, mergedConfig.autoStabilizeAfterLaunches]);
+
+  // Event queue polling
+  useEffect(() => {
+    const pollEvents = async () => {
+      try {
+        const events = await NativeSwiftPatch.popEvents();
+        if (events && events.length > 0) {
+          const deviceId = await NativeSwiftPatch.getDeviceId();
+          const cfg = configRef.current;
+
+          const result = await logBulkEvents({
+            serverUrl: cfg.serverUrl!,
+            deploymentKey: cfg.deploymentKey,
+            deviceId,
+            events: events as any,
+            customHeaders: cfg.customHeaders,
+          });
+
+          if (result.acknowledged.length > 0) {
+            await NativeSwiftPatch.acknowledgeEvents(
+              JSON.stringify(result.acknowledged)
+            );
+          }
+        }
+      } catch (_e) {
+        // Silent - event polling is non-critical
+      }
+    };
+
+    eventPollIntervalRef.current = setInterval(pollEvents, EVENT_POLL_INTERVAL_MS);
+
+    return () => {
+      if (eventPollIntervalRef.current) {
+        clearInterval(eventPollIntervalRef.current);
+      }
+    };
+  }, []);
+
+  // Subscribe to download progress
+  useEffect(() => {
+    const unsubscribe = onDownloadProgress((progress) => {
+      dispatch({ type: 'SET_DOWNLOAD_PROGRESS', payload: progress });
+    });
+    return unsubscribe;
+  }, []);
+
+  // Subscribe to rollback events
+  useEffect(() => {
+    const unsubscribe = onRollback((reason) => {
+      logger.warn('Rollback occurred:', reason);
+      dispatch({ type: 'SET_STATUS', payload: Status.UP_TO_DATE });
+      dispatch({ type: 'SET_AVAILABLE_UPDATE', payload: null });
+      dispatch({ type: 'SET_RESTART_REQUIRED', payload: false });
+      // Refresh metadata
+      NativeSwiftPatch.getSlotMetadata().then((meta) => {
+        dispatch({ type: 'SET_SLOT_METADATA', payload: meta });
+      }).catch(() => {});
+    });
+    return unsubscribe;
+  }, []);
+
+  // Subscribe to version change events
+  useEffect(() => {
+    const unsubscribe = onVersionChanged((reason) => {
+      logger.info('Version changed:', reason);
+      dispatch({ type: 'SET_STATUS', payload: Status.UP_TO_DATE });
+      dispatch({ type: 'SET_AVAILABLE_UPDATE', payload: null });
+      dispatch({ type: 'SET_RESTART_REQUIRED', payload: false });
+      NativeSwiftPatch.getSlotMetadata().then((meta) => {
+        dispatch({ type: 'SET_SLOT_METADATA', payload: meta });
+      }).catch(() => {});
+    });
+    return unsubscribe;
+  }, []);
+
+  // Check for update
+  const checkForUpdate = useCallback(async (): Promise<ReleaseInfo | null> => {
+    if (isCheckingRef.current) return null;
+    if (!updateCheckerRef.current) return null;
+
+    isCheckingRef.current = true;
+    dispatch({ type: 'SET_STATUS', payload: Status.CHECKING });
+    dispatch({ type: 'SET_ERROR', payload: null });
+
+    try {
+      const result = await updateCheckerRef.current.check();
+      lastCheckRef.current = Date.now();
+      dispatch({ type: 'SET_LAST_CHECKED', payload: new Date() });
+
+      if (result.updateAvailable && result.release) {
+        dispatch({ type: 'SET_AVAILABLE_UPDATE', payload: result.release });
+        dispatch({ type: 'SET_STATUS', payload: Status.UPDATE_AVAILABLE });
+        return result.release;
+      } else {
+        dispatch({ type: 'SET_STATUS', payload: Status.UP_TO_DATE });
+        return null;
+      }
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : 'Failed to check for update';
+      dispatch({
+        type: 'SET_ERROR',
+        payload: { code: SwiftPatchErrorCode.NETWORK_ERROR, message },
+      });
+      return null;
+    } finally {
+      isCheckingRef.current = false;
+    }
+  }, []);
+
+  // Check on resume
+  useEffect(() => {
+    if (!mergedConfig.checkOnResume) return;
+
+    const handleAppStateChange = (nextState: AppStateStatus) => {
+      if (nextState === 'active') {
+        const now = Date.now();
+        if (now - lastCheckRef.current >= (mergedConfig.checkInterval ?? 60_000)) {
+          checkForUpdate();
+        }
+      }
+    };
+
+    const subscription = AppState.addEventListener('change', handleAppStateChange);
+    return () => subscription.remove();
+  }, [mergedConfig.checkOnResume, mergedConfig.checkInterval, checkForUpdate]);
+
+  // Restart
+  const restart = useCallback((): void => {
+    NativeSwiftPatch.restart();
+  }, []);
+
+  // Install update
+  const installUpdate = useCallback(async (): Promise<void> => {
+    const update = state.availableUpdate;
+    if (!update) throw new Error('No update available to install');
+
+    dispatch({ type: 'SET_STATUS', payload: Status.INSTALLING });
+
+    try {
+      await NativeSwiftPatch.installUpdate(update.bundleHash);
+
+      dispatch({ type: 'SET_STATUS', payload: Status.RESTART_REQUIRED });
+      dispatch({ type: 'SET_RESTART_REQUIRED', payload: true });
+
+      const cfg = configRef.current;
+      await reportInstallStatus({
+        serverUrl: cfg.serverUrl!,
+        releaseId: update.id,
+        status: 'installed',
+        deploymentKey: cfg.deploymentKey,
+      });
+
+      // Auto-restart for immediate install mode
+      if (
+        (update.isMandatory && cfg.mandatoryInstallMode === InstallMode.IMMEDIATE) ||
+        (!update.isMandatory && cfg.installMode === InstallMode.IMMEDIATE)
+      ) {
+        restart();
+      }
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : 'Failed to install update';
+      dispatch({
+        type: 'SET_ERROR',
+        payload: { code: SwiftPatchErrorCode.INSTALL_ERROR, message },
+      });
+    }
+  }, [state.availableUpdate, restart]);
+
+  // Download update
+  const downloadUpdate = useCallback(async (): Promise<void> => {
+    const update = state.availableUpdate;
+    if (!update) throw new Error('No update available to download');
+    if (!downloaderRef.current) throw new Error('Downloader not initialized');
+
+    dispatch({ type: 'SET_STATUS', payload: Status.DOWNLOADING });
+    dispatch({
+      type: 'SET_DOWNLOAD_PROGRESS',
+      payload: { downloadedBytes: 0, totalBytes: update.downloadSize, percentage: 0 },
+    });
+
+    try {
+      await downloaderRef.current.downloadRelease(update);
+
+      dispatch({ type: 'SET_STATUS', payload: Status.READY_TO_INSTALL });
+      dispatch({ type: 'SET_DOWNLOAD_PROGRESS', payload: null });
+
+      const cfg = configRef.current;
+      await reportInstallStatus({
+        serverUrl: cfg.serverUrl!,
+        releaseId: update.id,
+        status: 'downloaded',
+        deploymentKey: cfg.deploymentKey,
+      });
+
+      // Auto-install for mandatory updates
+      if (update.isMandatory && cfg.mandatoryInstallMode === InstallMode.IMMEDIATE) {
+        await installUpdate();
+      }
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : 'Failed to download update';
+      dispatch({
+        type: 'SET_ERROR',
+        payload: { code: SwiftPatchErrorCode.DOWNLOAD_ERROR, message },
+      });
+      dispatch({ type: 'SET_DOWNLOAD_PROGRESS', payload: null });
+    }
+  }, [state.availableUpdate, installUpdate]);
+
+  // Rollback
+  const rollback = useCallback(async (): Promise<void> => {
+    await NativeSwiftPatch.rollback();
+    dispatch({ type: 'SET_STATUS', payload: Status.UP_TO_DATE });
+    dispatch({ type: 'SET_AVAILABLE_UPDATE', payload: null });
+    dispatch({ type: 'SET_RESTART_REQUIRED', payload: false });
+    const meta = await NativeSwiftPatch.getSlotMetadata();
+    dispatch({ type: 'SET_SLOT_METADATA', payload: meta });
+  }, []);
+
+  // Clear pending
+  const clearPendingUpdate = useCallback(async (): Promise<void> => {
+    await NativeSwiftPatch.clearPendingUpdate();
+    dispatch({ type: 'SET_STATUS', payload: Status.UP_TO_DATE });
+    dispatch({ type: 'SET_AVAILABLE_UPDATE', payload: null });
+    dispatch({ type: 'SET_RESTART_REQUIRED', payload: false });
+  }, []);
+
+  // Get current bundle
+  const getCurrentBundle = useCallback(async () => {
+    return NativeSwiftPatch.getCurrentBundle();
+  }, []);
+
+  // Stabilize (promote NEW → STABLE)
+  const stabilize = useCallback(async (): Promise<SlotMetadata> => {
+    const meta = await NativeSwiftPatch.stabilize();
+    dispatch({ type: 'SET_SLOT_METADATA', payload: meta });
+    return meta;
+  }, []);
+
+  // Switch environment
+  const switchEnvironment = useCallback(async (env: EnvironmentMode): Promise<SlotMetadata> => {
+    const meta = await NativeSwiftPatch.switchEnvironment(env);
+    dispatch({ type: 'SET_ENVIRONMENT', payload: env });
+    dispatch({ type: 'SET_SLOT_METADATA', payload: meta });
+    // Refresh current bundle info for the new environment
+    const bundle = await NativeSwiftPatch.getCurrentBundle();
+    dispatch({ type: 'SET_CURRENT_BUNDLE', payload: bundle });
+    return meta;
+  }, []);
+
+  // Get slot metadata
+  const getSlotMetadata = useCallback(async (): Promise<SlotMetadata> => {
+    const meta = await NativeSwiftPatch.getSlotMetadata();
+    dispatch({ type: 'SET_SLOT_METADATA', payload: meta });
+    return meta;
+  }, []);
+
+  // Mark mounted
+  const markMounted = useCallback((): void => {
+    NativeSwiftPatch.markMounted().catch(() => {});
+  }, []);
+
+  // Download stage bundle
+  const downloadStageBundle = useCallback(async (url: string, hash: string): Promise<void> => {
+    await NativeSwiftPatch.downloadStageBundle(url, hash);
+    const meta = await NativeSwiftPatch.getSlotMetadata();
+    dispatch({ type: 'SET_SLOT_METADATA', payload: meta });
+  }, []);
+
+  const contextValue: SwiftPatchContextValue = {
+    ...state,
+    checkForUpdate,
+    downloadUpdate,
+    installUpdate,
+    restart,
+    rollback,
+    clearPendingUpdate,
+    getCurrentBundle,
+    stabilize,
+    switchEnvironment,
+    getSlotMetadata,
+    markMounted,
+    downloadStageBundle,
+  };
+
+  return (
+    <SwiftPatchContext.Provider value={contextValue}>
+      {children}
+    </SwiftPatchContext.Provider>
+  );
+}
+
+/**
+ * Hook to access SwiftPatch context.
+ * Must be used within SwiftPatchProvider.
+ */
+export function useSwiftPatchContext(): SwiftPatchContextValue {
+  const context = useContext(SwiftPatchContext);
+  if (!context) {
+    throw new Error('useSwiftPatch must be used within a SwiftPatchProvider');
+  }
+  return context;
+}

package/src/constants.ts

@@ -0,0 +1,49 @@
+import { InstallMode } from './types';
+import type { SwiftPatchConfig } from './types';
+
+/**
+ * Default SDK configuration values
+ */
+export const DEFAULT_CONFIG: Required<Omit<SwiftPatchConfig, 'deploymentKey' | 'customHeaders' | 'publicKey' | 'sdkPin'>> & {
+  customHeaders: Record<string, string>;
+  publicKey: string | null;
+  sdkPin: string | null;
+} = {
+  serverUrl: 'https://orbitplus.hyperbrainlabs.com/api/v1',
+  checkOnResume: true,
+  checkInterval: 60_000,
+  installMode: InstallMode.ON_NEXT_RESTART,
+  mandatoryInstallMode: InstallMode.IMMEDIATE,
+  debug: false,
+  customHeaders: {},
+  publicKey: null,
+  autoStabilizeAfterLaunches: 0,
+  sdkPin: null,
+};
+
+/**
+ * Native event names emitted from native modules
+ */
+export const NativeEvents = {
+  DOWNLOAD_PROGRESS: 'SwiftPatch:downloadProgress',
+  INSTALL_COMPLETE: 'SwiftPatch:installComplete',
+  ROLLBACK_OCCURRED: 'SwiftPatch:rollbackOccurred',
+  ERROR: 'SwiftPatch:error',
+  VERSION_CHANGED: 'SwiftPatch:versionChanged',
+  NATIVE_EVENT: 'SwiftPatch:event',
+} as const;
+
+/**
+ * SDK version identifier
+ */
+export const SDK_VERSION = '2.0.0';
+
+/**
+ * Crash detection window in milliseconds
+ */
+export const CRASH_DETECTION_WINDOW_MS = 10_000;
+
+/**
+ * Event polling interval (ms)
+ */
+export const EVENT_POLL_INTERVAL_MS = 3_000;