@kwik-id/sdk-react-native 0.0.0-stage → 0.1.0-alpha.0

package/src/i18n/fr.ts

@@ -0,0 +1,325 @@
+/**
+ * French message catalog for the React Native KYC flow. Must cover the same keys
+ * as `en.ts` (enforced by the i18n parity test). Missing keys fall back to English.
+ */
+export const fr: Record<string, string> = {
+    "branding.builtBy": "Conçu par {name}",
+    "branding.poweredBy": "Vérification d'identité propulsée par",
+    "branding.secureCompliant": "Sécurisé • Conforme WCAG 2.1",
+    "camera.accessError":
+        "Impossible d'accéder à la caméra. Vérifiez les autorisations ou importez un fichier.",
+    "camera.accessRequiredTitle": "Accès à la caméra requis",
+    "camera.adjust": "Ajustez",
+    "camera.adjusting": "Ajustement…",
+    "camera.captureFailedMobile": "Impossible de prendre la photo. Veuillez réessayer.",
+    "camera.errorImageType": "Veuillez sélectionner un fichier image",
+    "camera.finalStep": "Dernière étape",
+    "camera.initializing": "Initialisation de la caméra…",
+    "camera.instructionBack": "Alignez le verso de votre document dans le cadre",
+    "camera.instructionBackMobile": "Capturez le verso de votre document",
+    "camera.instructionFront": "Alignez le recto de votre document dans le cadre",
+    "camera.instructionFrontMobile": "Capturez le recto de votre document",
+    "camera.instructionSelfie": "Placez votre visage au centre du cadre",
+    "camera.instructionSelfieMobile": "Centrez votre visage et capturez un selfie",
+    "camera.openSettingsMobile": "Ouvrir les réglages",
+    "camera.permissionBodyMobile":
+        "Autorisez l'accès à la caméra dans les réglages pour poursuivre la vérification.",
+    "camera.permissionTitleMobile": "Accès à la caméra nécessaire",
+    "camera.ready": "Prêt",
+    "camera.readyToCapture": "Parfait ! Prêt à capturer",
+    "camera.tooBlurry": "Trop flou",
+    "camera.tooBlurryHint": "Restez stable et gardez l'objectif propre",
+    "camera.tooBright": "Trop lumineux",
+    "camera.tooBrightHint": "Réduisez l'éclairage ou éloignez-vous de la lumière",
+    "camera.tooDark": "Trop sombre",
+    "camera.tooDarkHint": "Déplacez-vous vers un endroit plus lumineux",
+    "common.back": "Retour",
+    "common.backSide": "Verso",
+    "common.cancel": "Annuler",
+    "common.capturePhoto": "Prendre la photo",
+    "common.close": "Fermer",
+    "common.continue": "Continuer",
+    "common.done": "Terminé",
+    "common.frontSide": "Recto",
+    "common.goBack": "Retour",
+    "common.goodLighting": "Bon éclairage",
+    "common.identityVerification": "Vérification d'identité",
+    "common.imReady": "Je suis prêt",
+    "common.or": "ou",
+    "common.retake": "Reprendre",
+    "common.selfie": "Selfie",
+    "common.step1of2": "1 sur 2",
+    "common.step2of2": "2 sur 2",
+    "common.stepOf": "Étape {current} sur {total}",
+    "common.uploadFromDevice": "Importer depuis l'appareil",
+    "confirm.backTitle": "Vérifiez le verso",
+    "confirm.checklistDesc":
+        "Si la photo ne respecte pas ces critères, reprenez-la pour de meilleurs résultats",
+    "confirm.checklistTitle": "Liste de vérification qualité",
+    "confirm.confirmContinue": "Confirmer et continuer",
+    "confirm.docCheck1": "Tous les coins sont visibles",
+    "confirm.docCheck2": "Le texte est net et lisible",
+    "confirm.docCheck3": "Aucun reflet ni éblouissement",
+    "confirm.docCheck4": "La photo n'est pas floue",
+    "confirm.frontTitle": "Vérifiez le recto",
+    "confirm.looksGood": "C'est bon",
+    "confirm.looksGoodTitle": "Cela vous convient ?",
+    "confirm.selfieCheck1": "Votre visage est bien visible",
+    "confirm.selfieCheck2": "Bon éclairage sans ombres",
+    "confirm.selfieCheck3": "Les yeux sont ouverts et regardent la caméra",
+    "confirm.selfieDisclaimer":
+        "En confirmant, vous attestez que les informations fournies sont exactes et vous appartiennent",
+    "confirm.selfieReview": "Vérifiez votre selfie et confirmez s'il vous convient",
+    "confirm.selfieTitle": "Est-ce que cela vous convient ?",
+    "confirm.subtitle": "Assurez-vous que tout est net et visible",
+    "confirm.useThisPhoto": "Utiliser cette photo",
+    "consent.agreePrivacySuffix":
+        "et je consens à ce que {appName} traite mes données à des fins de vérification",
+    "consent.agreeTerms1": "J'accepte les",
+    "consent.docsRequired": "Documents requis",
+    "consent.docsRequiredDesc":
+        "Pièce d'identité officielle valide (passeport, carte nationale d'identité ou permis de conduire)",
+    "consent.errorPrivacy": "Vous devez accepter la politique de confidentialité",
+    "consent.errorTerms": "Vous devez accepter les conditions générales",
+    "consent.privacyDesc":
+        "Vos données sont chiffrées et stockées en toute sécurité. Nous ne partageons jamais vos informations sans consentement.",
+    "consent.privacyLink": "Politique de confidentialité",
+    "consent.privacyTitle": "Votre confidentialité",
+    "consent.securityNote":
+        "🔒 Vos informations sont protégées par un chiffrement de niveau bancaire",
+    "consent.subtitle":
+        "Nous devons vérifier votre identité pour respecter la réglementation et garantir la sécurité de votre compte.",
+    "consent.termsLink": "Conditions générales",
+    "documentType.chooseTitle": "Choisissez votre document",
+    "documentType.driversLicense": "Permis de conduire",
+    "documentType.driversLicenseDesc": "Permis de conduire valide",
+    "documentType.idCard": "Carte nationale d'identité",
+    "documentType.idCardDesc": "Carte d'identité officielle",
+    "documentType.note":
+        "Assurez-vous que votre document est valide et non expiré. Nous devrons capturer le recto et le verso (le cas échéant).",
+    "documentType.passport": "Passeport",
+    "documentType.passportDesc": "Document de voyage international",
+    "documentType.residencePermit": "Titre de séjour",
+    "documentType.subtitle": "Choisissez le type de pièce d'identité à vérifier",
+    "documentType.title": "Sélectionnez le type de document",
+    "documentType.votersCard": "Carte d'électeur",
+    "documentType.votersCardDesc": "Carte d'identification électorale",
+    "errors.sessionExpiredShort": "Votre session de vérification a expiré. Fermez et recommencez.",
+    "errors.unexpected": "Une erreur inattendue s'est produite.",
+    "handoff.abandonedDesc":
+        "La vérification sur votre téléphone a été interrompue. Réessayez ou continuez ici.",
+    "handoff.abandonedTitle": "Téléphone déconnecté",
+    "handoff.chooseSubtitle":
+        "Pour de meilleurs résultats, nous recommandons d'utiliser votre téléphone — les caméras mobiles capturent des images plus nettes des documents.",
+    "handoff.chooseTitle": "Comment souhaitez-vous vérifier ?",
+    "handoff.completeDesc": "Identité vérifiée sur votre téléphone. Vous pouvez continuer.",
+    "handoff.completeTitle": "Vérification terminée !",
+    "handoff.connected": "Connecté à votre téléphone",
+    "handoff.connectedDesc":
+        "Votre téléphone est connecté. Terminez les étapes sur votre téléphone pour continuer.",
+    "handoff.continueDesktop": "Continuer sur cet appareil",
+    "handoff.continueDesktopDesc": "Utilisez votre webcam pour capturer les documents",
+    "handoff.continueInstead": "Continuer sur cet appareil à la place",
+    "handoff.copied": "Copié !",
+    "handoff.copyLink": "Copier le lien à la place",
+    "handoff.expiredDesc": "Générez un nouveau code pour continuer.",
+    "handoff.expiredTitle": "Code QR expiré",
+    "handoff.expiresIn": "Expire dans {time}",
+    "handoff.generateNew": "Générer un nouveau code",
+    "handoff.inProgress": "Vérification en cours",
+    "handoff.inProgressDesc": "Votre téléphone capture et traite vos documents…",
+    "handoff.qrAlt": "Scannez ce code QR avec votre téléphone",
+    "handoff.recommended": "Recommandé",
+    "handoff.scanDesc":
+        "Ouvrez l'appareil photo de votre téléphone et pointez-le vers le code QR pour continuer sur votre téléphone.",
+    "handoff.scanTitle": "Scannez avec votre téléphone",
+    "handoff.startError":
+        "Impossible de démarrer le transfert mobile. Réessayez ou continuez sur cet appareil.",
+    "handoff.tryAgain": "Réessayer",
+    "handoff.usePhone": "Utilisez votre téléphone",
+    "handoff.usePhoneDesc": "Scannez un code QR et terminez sur votre téléphone",
+    "handoff.waitingCompletion": "En attente de la fin…",
+    "intro.bodyMobile":
+        "Vous photographierez votre pièce d'identité et prendrez un selfie. Cela prend environ une minute.",
+    "intro.getStarted": "Commencer",
+    "intro.govIdDesc": "Passeport, permis de conduire ou carte nationale d'identité",
+    "intro.govIdTitle": "Pièce d'identité officielle",
+    "intro.orgUsesKwikID": "{orgName} utilise KwikID pour vérifier votre identité.",
+    "intro.privacyNote":
+        "Vos données sont chiffrées et traitées en toute sécurité. Nous respectons votre vie privée et appliquons des normes strictes de protection des données.",
+    "intro.selfieDesc": "Nous utiliserons la caméra de votre appareil",
+    "intro.selfieTitle": "Un selfie",
+    "intro.subtitle":
+        "Nous devons vérifier votre identité pour sécuriser votre compte et respecter la réglementation",
+    "intro.timeDesc": "Le processus est rapide et sécurisé",
+    "intro.timeTitle": "Environ 2 à 3 minutes",
+    "intro.tipFlat": "Placez les documents à plat sur une surface stable",
+    "intro.tipLighting": "Utilisez un bon éclairage sans reflets",
+    "intro.tipText": "Assurez-vous que le texte est net et lisible",
+    "intro.tipsTitle": "Conseils pour de meilleurs résultats",
+    "intro.title": "Vérifiez votre identité",
+    "intro.whatYouNeed": "Ce dont vous aurez besoin",
+    "prepareBack.almostDone": "Presque terminé !",
+    "prepareBack.almostDoneDesc":
+        "Après le verso, nous prendrons un rapide selfie pour terminer la vérification.",
+    "prepareBack.bodyMobile":
+        "Retournez maintenant le document et capturez le verso de la même manière.",
+    "prepareBack.standardsTitle": "Mêmes critères de qualité",
+    "prepareBack.subtitle": "Retournez votre {document} et préparez-vous à capturer le verso",
+    "prepareBack.tipClear": "Assurez-vous que toutes les informations sont nettes et lisibles",
+    "prepareBack.tipFlat": "Gardez le document à plat et stable",
+    "prepareBack.tipFlip": "Retournez votre document pour montrer le verso",
+    "prepareBack.tipLighting": "Utilisez le même bon éclairage qu'avant",
+    "prepareBack.title": "Maintenant le verso",
+    "prepareBack.titleMobile": "Verso du document",
+    "prepareFront.bodyMobile":
+        "Placez le recto de votre document sur une surface plane et bien éclairée, et faites-le tenir dans le cadre.",
+    "prepareFront.subtitle":
+        "Préparez votre document {document}. Nous capturerons d'abord le recto.",
+    "prepareFront.tipClearDesc":
+        "Assurez-vous que le texte, la photo et les détails sont bien visibles.",
+    "prepareFront.tipClearTitle": "Net et lisible",
+    "prepareFront.tipFlatDesc": "Placez votre document sur une surface plane et contrastée.",
+    "prepareFront.tipFlatTitle": "Surface plane",
+    "prepareFront.tipLightingDesc":
+        "Utilisez la lumière naturelle ou une pièce bien éclairée. Évitez les reflets et les ombres.",
+    "prepareFront.tipsTitle": "Conseils pour une bonne photo",
+    "prepareFront.title": "Préparez votre {document}",
+    "prepareFront.titleMobile": "Recto du document",
+    "prepareSelfie.bodyMobile":
+        "Placez votre visage dans le cadre avec un bon éclairage, puis capturez.",
+    "prepareSelfie.privacyNote":
+        "Votre selfie est utilisé uniquement pour la vérification et stocké en toute sécurité",
+    "prepareSelfie.subtitle":
+        "Prenez un selfie pour que nous puissions le comparer à la photo de votre pièce d'identité.",
+    "prepareSelfie.takeSelfie": "Prendre un selfie",
+    "prepareSelfie.tipClearDesc":
+        "Retirez lunettes, chapeaux ou masques qui pourraient masquer votre visage",
+    "prepareSelfie.tipClearTitle": "Bonne visibilité",
+    "prepareSelfie.tipFaceDesc": "Placez votre visage au centre et regardez directement la caméra",
+    "prepareSelfie.tipFaceTitle": "Regardez la caméra",
+    "prepareSelfie.tipLightingDesc":
+        "Assurez-vous que votre visage est bien éclairé, sans ombres marquées",
+    "prepareSelfie.tipsTitle": "Conseils pour votre selfie",
+    "prepareSelfie.title": "Vérifions maintenant que c'est bien vous",
+    "prepareSelfie.titleMobile": "Prenez un selfie",
+    "processing.pleaseWait": "Veuillez patienter pendant l'envoi de vos informations…",
+    "processing.preliminaryChecks": "Vérifications préliminaires…",
+    "processing.submitting": "Envoi…",
+    "processing.title": "Envoi de vos documents",
+    "processing.uploadBack": "Envoi du document (verso)",
+    "processing.uploadFront": "Envoi du document (recto)",
+    "processing.uploadSelfie": "Envoi du selfie",
+    "processing.uploadingBack": "Envoi du verso…",
+    "processing.uploadingFront": "Envoi du recto…",
+    "processing.uploadingSelfie": "Envoi du selfie…",
+    "processing.working": "Traitement…",
+    "result.commonIssues": "Problèmes courants :",
+    "result.couldNotComplete": "La vérification n'a pas pu être effectuée.",
+    "result.docFailedMessage": "Le document ({side}) a échoué : {message}",
+    "result.docFailedQuality": "Le document ({side}) a échoué au contrôle qualité",
+    "result.documentsSubmitted": "Documents soumis",
+    "result.failedTitle": "Échec de la soumission",
+    "result.identityDocument": "Pièce d'identité",
+    "result.issue1": "Assurez-vous que votre document est net et non flou",
+    "result.issue2": "Assurez-vous que votre visage est bien éclairé sur le selfie",
+    "result.issue3": "Vérifiez que toutes les informations de votre document sont visibles",
+    "result.issue4": "Utilisez une pièce d'identité officielle valide et non expirée",
+    "result.nextStep1":
+        "La vérification prend généralement quelques minutes, mais peut aller jusqu'à quelques heures dans de rares cas",
+    "result.nextStep2": "Vous recevrez une notification par e-mail une fois vérifié",
+    "result.nextStep3": "Consultez vos e-mails pour les mises à jour et instructions",
+    "result.selfiePhoto": "Photo selfie",
+    "result.sessionExpiredMessage":
+        "Votre session de vérification a expiré. Fermez et démarrez une nouvelle vérification.",
+    "result.sessionExpiredTitle": "Session expirée",
+    "result.sideBack": "verso",
+    "result.sideFront": "recto",
+    "result.somethingWrong": "Un problème est survenu",
+    "result.submissionError": "Une erreur s'est produite lors de la soumission",
+    "result.submittedFromPhone": "Vos documents ont été soumis depuis votre téléphone !",
+    "result.submittedMessage": "Vos documents ont été soumis pour vérification !",
+    "result.submittedMessageMobile": "Vos documents ont été soumis pour vérification.",
+    "result.submittedShort": "Soumis",
+    "result.successBody":
+        "Contrôles préliminaires réussis. Vos documents ont été soumis pour examen complet — nous vous préviendrons une fois terminé.",
+    "result.successTitle": "Soumis pour examen",
+    "result.tryAgain": "Réessayer",
+    "result.whatNext": "Et ensuite ?",
+    "selfie.beforeBegin": "Avant de commencer :",
+    "selfie.brightTip1": "Éloignez-vous de la lumière directe du soleil ou des lumières vives",
+    "selfie.brightTip2": "Ajustez l'éclairage pour réduire les reflets",
+    "selfie.brightTip3": "Tournez le dos aux fenêtres ou éteignez quelques lumières",
+    "selfie.captureSelfie": "Capturer le selfie",
+    "selfie.darkTip1": "Déplacez-vous vers un endroit plus lumineux ou allumez plus de lumières",
+    "selfie.darkTip2": "Faites face à une fenêtre ou une source de lumière",
+    "selfie.darkTip3": "Évitez le contre-jour (lumière derrière vous)",
+    "selfie.deniedDesc":
+        "Activez les autorisations de la caméra dans les paramètres de votre navigateur, puis réessayez",
+    "selfie.deniedTitle": "Accès à la caméra refusé",
+    "selfie.errorCapture": "Veuillez capturer votre selfie pour continuer",
+    "selfie.errorDenied":
+        "Accès à la caméra refusé. Autorisez la caméra dans les paramètres de votre navigateur.",
+    "selfie.errorGeneric": "Impossible d'accéder à la caméra. Veuillez réessayer.",
+    "selfie.errorInUse": "La caméra est déjà utilisée par une autre application.",
+    "selfie.errorNoCamera": "Aucune caméra détectée. Connectez une caméra et réessayez.",
+    "selfie.errorNoTracks": "Aucun flux vidéo disponible",
+    "selfie.errorNotSupported": "Caméra non prise en charge sur cet appareil",
+    "selfie.errorStartStream": "Impossible de démarrer le flux vidéo",
+    "selfie.errorTrackInactive": "Le flux de la caméra n'est pas actif",
+    "selfie.errorUnknown": "Une erreur inconnue s'est produite lors de l'accès à la caméra.",
+    "selfie.improveLighting": "Améliorez l'éclairage",
+    "selfie.improveToContinue": "Améliorez l'éclairage pour continuer",
+    "selfie.lightExcellent": "Excellent éclairage",
+    "selfie.lightPoor": "Éclairage insuffisant – améliorez-le",
+    "selfie.lightTooBright": "Trop lumineux – réduisez la lumière",
+    "selfie.lightTooDark": "Trop sombre – ajoutez de la lumière",
+    "selfie.livenessBlink": "Clignez des yeux deux fois lentement",
+    "selfie.livenessCenter": "Placez votre visage au centre",
+    "selfie.livenessComplete": "Parfait ! Traitement…",
+    "selfie.livenessLeft": "Tournez légèrement la tête vers la gauche",
+    "selfie.livenessRight": "Tournez légèrement la tête vers la droite",
+    "selfie.permissionDenied": "Autorisation refusée",
+    "selfie.pleaseAllow": "Veuillez autoriser l'accès à la caméra dans votre navigateur",
+    "selfie.poorTip1": "Ajoutez des sources de lumière face à vous",
+    "selfie.poorTip2": "Assurez-vous que votre visage est uniformément éclairé",
+    "selfie.poorTip3": "Évitez les ombres sur votre visage",
+    "selfie.requesting": "Demande d'accès à la caméra…",
+    "selfie.requiredDesc":
+        "Nous avons besoin d'accéder à votre caméra pour vérifier votre identité",
+    "selfie.requiredTitle": "Accès à la caméra requis",
+    "selfie.startCamera": "Démarrer la caméra",
+    "selfie.subtitle":
+        "Nous vérifierons que vous êtes une personne réelle en capturant une photo en direct",
+    "selfie.tip1": "Assurez-vous que votre visage est bien éclairé et visible",
+    "selfie.tip2": "Retirez lunettes, chapeaux ou masques",
+    "selfie.tip3": "Placez votre visage dans le repère ovale",
+    "selfie.tip4": "Suivez attentivement les instructions à l'écran",
+    "selfie.title": "Prenez un selfie",
+    "upload.alignCorners": "Alignez tous les coins dans le cadre",
+    "upload.alignInstruction":
+        "Alignez votre document dans le cadre. Assurez-vous que tous les coins sont visibles et que le texte est net.",
+    "upload.backOfDocument": "Verso du document",
+    "upload.cameraActive": "Caméra active",
+    "upload.cameraFailed":
+        "Impossible d'accéder à la caméra. Veuillez importer un fichier à la place.",
+    "upload.errorBack": "Veuillez importer le verso de votre document",
+    "upload.errorFileSize": "La taille du fichier doit être inférieure à 10 Mo",
+    "upload.errorFront": "Veuillez importer le recto de votre document",
+    "upload.errorImageType": "Veuillez importer un fichier image",
+    "upload.errorSelectType": "Veuillez sélectionner un type de document",
+    "upload.frontOfDocument": "Recto du document",
+    "upload.positionDocument": "Placez le document dans le cadre",
+    "upload.subtitle": "Prenez une photo nette de votre pièce d'identité officielle",
+    "upload.takePhotoOfBack": "Photographier le verso",
+    "upload.takePhotoOfFront": "Photographier le recto",
+    "upload.tapToOpenCamera": "Touchez pour ouvrir la caméra",
+    "upload.tipFit": "Faites tenir tout le document dans les repères du cadre",
+    "upload.tipFlat": "Placez le document sur une surface plane et contrastée",
+    "upload.tipLighting": "Utilisez un bon éclairage, évitez les reflets et les ombres",
+    "upload.tipSteady": "Tenez votre téléphone stable lors de la capture",
+    "upload.tipsTitle": "📸 Conseils pour de bonnes photos :",
+    "upload.title": "Photographiez votre document",
+    "upload.uploadFromDeviceLabel": "Importer depuis l'appareil",
+    "uploadLabel.documentTypeLabel": "Type de document",
+};

package/src/i18n/index.ts

@@ -0,0 +1,9 @@
+/**
+ * RN KYC-flow i18n (EN + FR). Locale is supplied by the host app via SDK config
+ * and threaded to screens as a `t` prop.
+ */
+export { en } from "./en";
+export { fr } from "./fr";
+export { getDeviceLocale } from "./locale";
+export { createTranslator } from "./translator";
+export type { MessageKey, Translate, TranslateParams } from "./translator";

package/src/i18n/locale.ts

@@ -0,0 +1,15 @@
+/**
+ * Device-locale detection for the default UI language.
+ */
+import { getLocales } from "expo-localization";
+
+import type { Locale } from "../types";
+
+/** 'fr' when the device's preferred language is French, otherwise 'en'. */
+export function getDeviceLocale(): Locale {
+    try {
+        return getLocales()[0]?.languageCode === "fr" ? "fr" : "en";
+    } catch {
+        return "en";
+    }
+}

package/src/i18n/translator.ts

@@ -0,0 +1,37 @@
+/**
+ * Tiny dependency-free translator for the RN KYC flow (mirrors the web SDK's).
+ * The host app supplies the locale via SDK config; missing keys fall back to English.
+ */
+import type { Locale } from "../types";
+import { en } from "./en";
+import { fr } from "./fr";
+
+/** All message keys, derived from the English catalog (the source of truth). */
+export type MessageKey = keyof typeof en;
+
+/** Interpolation values for `{placeholder}` tokens in a message. */
+export type TranslateParams = Record<string, string | number>;
+
+/** Translate a key to the active locale, interpolating any `{param}` tokens. */
+export type Translate = (key: MessageKey, params?: TranslateParams) => string;
+
+const catalogs: Record<Locale, Partial<Record<MessageKey, string>>> = {
+    en,
+    fr,
+};
+
+function interpolate(template: string, params?: TranslateParams): string {
+    if (!params) return template;
+    return template.replace(/\{(\w+)\}/g, (match, name: string) =>
+        name in params ? String(params[name]) : match
+    );
+}
+
+/** Build a translator bound to a locale, falling back to English then the raw key. */
+export function createTranslator(locale: Locale = "en"): Translate {
+    const table = catalogs[locale] ?? en;
+    return (key, params) => {
+        const template = table[key] ?? en[key] ?? key;
+        return interpolate(template, params);
+    };
+}

package/src/index.ts

@@ -0,0 +1,102 @@
+/**
+ * @kwik-id/sdk-react-native — public API.
+ *
+ * Phase 1: on-device document + selfie capture, upload, and submit, plus the
+ * headless protocol foundation. On-device liveness (passive + active challenges)
+ * lands in Phase 2.
+ *
+ * @packageDocumentation
+ */
+
+// ---- UI (primary integration) ----
+export { useKwikVerification, KwikIDVerificationModal, KwikIDProvider, useKwikID } from "./ui";
+export type {
+    UseKwikVerification,
+    UseKwikVerificationOptions,
+    KwikIDVerificationModalProps,
+    KwikIDProviderProps,
+    KwikIDContextValue,
+} from "./ui";
+
+// ---- Camera ----
+export { CameraView, compressCapture } from "./camera";
+export type { CameraViewProps, RawPhoto } from "./camera";
+
+// ---- Headless orchestrator ----
+export { KwikIdRNSDK } from "./lib/kwik-id-rn-sdk";
+export type { KwikIdRNSDKOptions } from "./lib/kwik-id-rn-sdk";
+
+// ---- API ----
+export { ApiClient, ApiError, DEFAULT_BASE_URL, uploadMultipart } from "./api";
+export type {
+    ApiClientConfig,
+    UploadResponse,
+    SubmitResponse,
+    StatusResponse,
+    HandoffValidateResponse,
+    HandoffRedeemResponse,
+    Uploader,
+    UploadResult,
+} from "./api";
+
+// ---- i18n (EN + FR) ----
+export { createTranslator, getDeviceLocale, en as messagesEn, fr as messagesFr } from "./i18n";
+export type { MessageKey, Translate, TranslateParams } from "./i18n";
+
+// ---- Crypto / session ----
+export {
+    SessionManager,
+    generateFingerprint,
+    hmacSha256Hex,
+    sha256Hex,
+    generateNonce,
+} from "./crypto";
+
+// ---- Headless orchestration primitives ----
+export {
+    EventEmitter,
+    reducer,
+    initialState,
+    needsBackImage,
+    getStepProgress,
+    computeUploadProgress,
+    isExpoGo,
+    assertSupportedRuntime,
+    isRealDevice,
+} from "./lib";
+export type { MachineState, MachineContext, MachineEvent, MachineOptions } from "./lib";
+
+// ---- Types ----
+export type {
+    KwikIdConfig,
+    KwikIdTheme,
+    Locale,
+    LivenessMode,
+    DocumentType,
+    CaptureType,
+    CaptureAsset,
+    CaptureMetadata,
+    CaptureSlot,
+    QualityResult,
+    QualityGuidance,
+    QualityCheckResult,
+    FacePose,
+    FaceSignals,
+    ChallengeType,
+    Challenge,
+    ChallengeResult,
+    PassiveLivenessResult,
+    LivenessResult,
+    DeviceFingerprint,
+    Session,
+    SecurePayload,
+    VerificationScores,
+    ExtractedData,
+    VerificationResult,
+    VerificationOutcome,
+    SessionInfo,
+    VerificationSubStep,
+    KwikIdEvents,
+    KwikIdEventName,
+    KwikIdEventHandler,
+} from "./types";

package/src/lib/device-detector.ts

@@ -0,0 +1,32 @@
+/**
+ * Device / runtime environment detection.
+ *
+ * Replaces the web SDK's emulator + automation heuristics. The most important
+ * check is Expo Go detection: vision-camera frame processors are native and
+ * cannot run in Expo Go, so the SDK fails fast with an actionable message.
+ */
+import Constants, { AppOwnership, ExecutionEnvironment } from "expo-constants";
+import * as Device from "expo-device";
+
+export function isExpoGo(): boolean {
+    return (
+        Constants.appOwnership === AppOwnership.Expo ||
+        Constants.executionEnvironment === ExecutionEnvironment.StoreClient
+    );
+}
+
+/** Throws an actionable error when running in an unsupported runtime. */
+export function assertSupportedRuntime(): void {
+    if (isExpoGo()) {
+        throw new Error(
+            "[KwikID] This SDK requires a custom dev build or EAS build and cannot run in Expo Go. " +
+                "Run `expo prebuild` and build a development client (or `eas build`). " +
+                "See https://docs.expo.dev/develop/development-builds/introduction/"
+        );
+    }
+}
+
+export function isRealDevice(): boolean {
+    // false on iOS Simulator / Android emulator.
+    return Device.isDevice === true;
+}

package/src/lib/event-emitter.ts

@@ -0,0 +1,90 @@
+/**
+ * Type-safe event emitter (ported from @kwik-id/sdk-core, framework-agnostic).
+ */
+import type { KwikIdEventHandler, KwikIdEventName, KwikIdEvents } from "../types";
+
+type WildcardHandler = (event: KwikIdEventName, data: unknown) => void;
+
+export class EventEmitter {
+    private listeners: Map<KwikIdEventName, Set<KwikIdEventHandler<KwikIdEventName>>> = new Map();
+    private wildcardListeners: Set<WildcardHandler> = new Set();
+    private onceListeners: Map<KwikIdEventName, Set<KwikIdEventHandler<KwikIdEventName>>> =
+        new Map();
+
+    on<T extends KwikIdEventName>(event: T, handler: KwikIdEventHandler<T>): () => void {
+        if (!this.listeners.has(event)) {
+            this.listeners.set(event, new Set());
+        }
+        this.listeners.get(event)!.add(handler as KwikIdEventHandler<KwikIdEventName>);
+        return () => this.off(event, handler);
+    }
+
+    once<T extends KwikIdEventName>(event: T, handler: KwikIdEventHandler<T>): () => void {
+        if (!this.onceListeners.has(event)) {
+            this.onceListeners.set(event, new Set());
+        }
+        this.onceListeners.get(event)!.add(handler as KwikIdEventHandler<KwikIdEventName>);
+        return () => {
+            this.onceListeners.get(event)?.delete(handler as KwikIdEventHandler<KwikIdEventName>);
+        };
+    }
+
+    onAny(handler: WildcardHandler): () => void {
+        this.wildcardListeners.add(handler);
+        return () => this.wildcardListeners.delete(handler);
+    }
+
+    off<T extends KwikIdEventName>(event: T, handler: KwikIdEventHandler<T>): void {
+        this.listeners.get(event)?.delete(handler as KwikIdEventHandler<KwikIdEventName>);
+    }
+
+    emit<T extends KwikIdEventName>(event: T, data: KwikIdEvents[T]): void {
+        const handlers = this.listeners.get(event);
+        if (handlers) {
+            handlers.forEach((handler) => {
+                try {
+                    handler(data);
+                } catch (error) {
+                    console.error(`Error in event handler for ${event}:`, error);
+                }
+            });
+        }
+
+        const onceHandlers = this.onceListeners.get(event);
+        if (onceHandlers) {
+            onceHandlers.forEach((handler) => {
+                try {
+                    handler(data);
+                } catch (error) {
+                    console.error(`Error in once handler for ${event}:`, error);
+                }
+            });
+            this.onceListeners.delete(event);
+        }
+
+        this.wildcardListeners.forEach((handler) => {
+            try {
+                handler(event, data);
+            } catch (error) {
+                console.error(`Error in wildcard handler for ${event}:`, error);
+            }
+        });
+    }
+
+    removeAllListeners(event?: KwikIdEventName): void {
+        if (event) {
+            this.listeners.delete(event);
+            this.onceListeners.delete(event);
+        } else {
+            this.listeners.clear();
+            this.onceListeners.clear();
+            this.wildcardListeners.clear();
+        }
+    }
+
+    listenerCount(event: KwikIdEventName): number {
+        const regularCount = this.listeners.get(event)?.size || 0;
+        const onceCount = this.onceListeners.get(event)?.size || 0;
+        return regularCount + onceCount;
+    }
+}

package/src/lib/index.ts

@@ -0,0 +1,15 @@
+export { EventEmitter } from "./event-emitter";
+export {
+    reducer,
+    initialState,
+    needsBackImage,
+    getStepProgress,
+    computeUploadProgress,
+} from "./verification-machine";
+export type {
+    MachineState,
+    MachineContext,
+    MachineEvent,
+    MachineOptions,
+} from "./verification-machine";
+export { isExpoGo, assertSupportedRuntime, isRealDevice } from "./device-detector";