@smileid/usesmileid_testing 0.0.0-stage → 12.3.1-SNAPSHOT.71

package/CHANGELOG.md

@@ -0,0 +1,5 @@
+Full release notes: [Smile ID docs](https://docs.usesmileid.com/developer-resources/sdks/mobile/release-notes/react-native-expo).
+
+## Unreleased
+
+First release: the native SDKs' test server, for your own tests, and `UseSmileIDTest`, which scripts the selfie on Android and iOS. See the repository CHANGELOG.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Smile ID
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,91 @@
-# Temporary Holding Version
+# `@smileid/usesmileid_testing`
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Test doubles for the UseSmileID React Native (Expo) SDK: the Android and iOS SDKs' in-process
+test server (`com.usesmileid:testing`, `UseSmileIDTesting`), so your E2E tests run a whole flow
+with no Smile ID backend.
+
+## Installation
+
+```sh
+pnpm add -D @smileid/usesmileid_testing
+```
+
+Apply its config plugin only in the app config you test with. On iOS it links the
+`UseSmileIDTesting` product in every build configuration (the server throws outside a Debug
+build), so it must not reach the config you ship. For example, in `app.config.js`:
+
+```js
+module.exports = ({ config }) => ({
+  ...config,
+  plugins: [
+    ...(config.plugins ?? []),
+    // Your E2E build only.
+    ...(process.env.EXPO_PUBLIC_E2E === "1"
+      ? ["@smileid/usesmileid_testing"]
+      : []),
+  ],
+});
+```
+
+The server runs only in a debug build. On Android a release build gets a stub that refuses to
+start, so the test doubles never reach a shipped app, and the plugin lets the debug build's native
+network client reach the server on loopback: it adds `127.0.0.1` and `localhost` to your network
+security config in the debug source set only, or writes a debug-only config when your app names
+none. On iOS, an app built without the plugin gets a module that refuses to start a server.
+
+## Use
+
+```ts
+import {
+  UseSmileIDTestServer,
+  UseSmileIDTestResponse,
+  testToken,
+} from "@smileid/usesmileid_testing";
+
+const server = await UseSmileIDTestServer.start();
+
+// In the flow's network block:
+//   n.config((c) => { c.token = testToken(); ... })
+//   n.interceptors((i) => i.testRoute(server))
+
+// After the flow:
+expect(server.submissions().map((request) => request.path)).toEqual([
+  "/v3/registration",
+]);
+server.close();
+```
+
+Every request the flow makes goes to the server, whatever host the configuration names, after the
+native network client has signed it. `respond(path, response)`
+scripts `UseSmileIDTestResponse.status(code, body)`, `tokenExpired` (a `401`, so your
+`onTokenExpired` runs) or `connectionDropped`. Once closed, the flow's requests fail rather than
+reach Smile ID.
+
+## A whole flow, with no one in front of the camera
+
+`UseSmileIDTest` adds a scripted person to the server: one of the shared scenarios every Smile ID
+SDK runs (`UseSmileIDTestScenario.selfieHappyPath`, `enhancedSelfieHeadTurns`, `selfieTimeout`,
+`skipSubmission` and the document ones) or your own, `UseSmileIDTestScenario.fromJson(text)`.
+`UseSmileIDTestScenario.named("selfie-happy-path")` finds one of them by the name its JSON gives it,
+or returns null.
+
+```ts
+const test = await UseSmileIDTest.create(
+  UseSmileIDTestScenario.selfieHappyPath,
+);
+
+// In the flow's blocks:
+//   n.config((c) => { c.token = test.token; ... })
+//   n.interceptors((i) => test.install(i))
+//   m.analyzers((a) => {
+//     a.forCaptureType(CaptureType.selfie, (face) => face.add(useSmileIDMlkitFace));
+//     test.install(a);
+//   })
+
+test.close();
+```
+
+The scenario answers in place of your selfie analyzer, inside that analyzer's own native session,
+so the capture, the files it writes and the submission are the real ones; any camera frames will
+do, an emulator's included. On iOS that means a phone, since a simulator has no camera. A document
+scenario's `install` throws.

package/android/build.gradle

@@ -0,0 +1,51 @@
+// Expo Module — the native SDK's test server (`com.usesmileid:testing`) for React Native tests.
+// It is a debug-only dependency: a release build gets the stub in src/release, which refuses to
+// start a server, so the test doubles and their dependencies never reach a shipped app. An E2E
+// release build (an app's minified test build, never one it ships) opts in with
+// `-PsmileidTestingInRelease=true` and gets the real server instead.
+
+plugins {
+  id 'com.android.library'
+  id 'expo-module-gradle-plugin'
+}
+
+def testServerInRelease = (findProperty('smileidTestingInRelease') ?: 'false').toBoolean()
+
+group = 'com.usesmileid.testing.rn'
+version = '12.3.0'
+
+android {
+  namespace 'com.usesmileid.testing.rn'
+
+  defaultConfig {
+    versionCode 1
+    versionName '12.3.0'
+    consumerProguardFiles 'consumer-rules.pro'
+  }
+
+  sourceSets {
+    release {
+      java.srcDirs = testServerInRelease ? ['src/debug/java'] : ['src/release/java']
+    }
+  }
+}
+
+dependencies {
+  def testServer = [
+    'com.usesmileid:testing:12.3.0-20261026.002955-236',
+    // The bridge build the testing artifact runs against, from the same publish: a snapshot names
+    // the moving x.y.z-SNAPSHOT bridge, so the build is pinned here as each provider pins it.
+    'com.usesmileid:bridge:12.3.0-20261026.002955-290',
+  ]
+  testServer.each { debugImplementation it }
+  if (testServerInRelease) testServer.each { releaseImplementation it }
+}
+
+def smileIdPackageVersion = { File packageDir -> new groovy.json.JsonSlurper().parse(new File(packageDir, 'package.json')).version }
+def bridgeVersion = smileIdPackageVersion(project(':smileid-usesmileid_bridge').projectDir.parentFile)
+def testingVersion = smileIdPackageVersion(projectDir.parentFile)
+if (bridgeVersion != testingVersion) {
+  throw new GradleException(
+    "@smileid/usesmileid_bridge is $bridgeVersion but ${project.name} is $testingVersion: install every @smileid package at one version."
+  )
+}

package/android/consumer-rules.pro

@@ -0,0 +1,4 @@
+# The Expo module entry point is found by name through autolinking.
+-keep class com.usesmileid.testing.rn.UseSmileIDTestingModule { *; }
+# An E2E release build (-PsmileidTestingInRelease=true) minifies the test server it links.
+-keep class com.usesmileid.testing.** { *; }

package/android/src/debug/java/com/usesmileid/testing/rn/UseSmileIDTestingModule.kt

@@ -0,0 +1,127 @@
+package com.usesmileid.testing.rn
+
+import com.usesmileid.bridge.model.CaptureType
+import com.usesmileid.bridge.registry.FaceAnalyzerFactoryRegistry
+import com.usesmileid.core.models.UseSmileIDResult
+import com.usesmileid.presentation.flow.dsl.UseSmileIDFlowBuilder
+import com.usesmileid.testing.UseSmileIDTest
+import com.usesmileid.testing.UseSmileIDTestPart
+import com.usesmileid.testing.UseSmileIDTestResponse
+import com.usesmileid.testing.UseSmileIDTestScenario
+import com.usesmileid.testing.UseSmileIDTestServer
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicInteger
+import kotlinx.coroutines.runBlocking
+import org.json.JSONArray
+import org.json.JSONObject
+
+/** The native SDK's test servers by port, and its scripted selfie analyzers by key, for `@smileid/usesmileid_testing`. Debug builds only. */
+class UseSmileIDTestingModule : Module() {
+    private val servers = ConcurrentHashMap<Int, UseSmileIDTestServer>()
+    private val scriptedFaces = ConcurrentHashMap.newKeySet<String>()
+    private val scriptedFaceCount = AtomicInteger()
+
+    override fun definition() = ModuleDefinition {
+        Name("UseSmileIDTesting")
+
+        AsyncFunction("start") {
+            val server = UseSmileIDTestServer()
+            servers[server.port] = server
+            server.port
+        }
+
+        Function("requests") { port: Int -> requestsJson(server(port)) }
+
+        Function("respond") { port: Int, path: String, response: String -> server(port).respond(path, parseResponse(response)) }
+
+        Function("close") { port: Int -> servers.remove(port)?.close() }
+
+        AsyncFunction("startTest") { name: String, json: String? ->
+            val test = UseSmileIDTest(json?.let(UseSmileIDTestScenario::fromJson) ?: bundledScenario(name))
+            val selfie = try {
+                selfieAnalyzer(test)
+            } catch (failure: Exception) {
+                test.close()
+                throw failure
+            }
+            val key = "$SCRIPTED_FACE_KEY-${scriptedFaceCount.incrementAndGet()}"
+            FaceAnalyzerFactoryRegistry.register(key) { checkNotNull(runBlocking { selfie.newInstance() }) }
+            scriptedFaces += key
+            servers[test.server.port] = test.server
+            mapOf("port" to test.server.port, "faceKey" to key)
+        }
+
+        Function("unscriptFace") { key: String ->
+            if (scriptedFaces.remove(key)) FaceAnalyzerFactoryRegistry.unregister(key)
+        }
+
+        // A reloaded runtime leaves no server listening and no scripted analyzer registered.
+        OnDestroy {
+            servers.values.forEach(UseSmileIDTestServer::close)
+            servers.clear()
+            scriptedFaces.forEach(FaceAnalyzerFactoryRegistry::unregister)
+            scriptedFaces.clear()
+        }
+    }
+
+    private fun server(port: Int): UseSmileIDTestServer = servers[port] ?: throw IllegalStateException("No test server on port $port: it was closed or never started")
+
+    internal companion object {
+        const val SCRIPTED_FACE_KEY = "usesmileid-testing-face"
+
+        private val bundledScenarios = listOf(
+            UseSmileIDTestScenario.selfieHappyPath,
+            UseSmileIDTestScenario.enhancedSelfieHeadTurns,
+            UseSmileIDTestScenario.documentFront,
+            UseSmileIDTestScenario.documentFrontAndBack,
+            UseSmileIDTestScenario.documentVisa,
+            UseSmileIDTestScenario.selfieTimeout,
+            UseSmileIDTestScenario.skipSubmission,
+        )
+
+        fun bundledScenario(name: String): UseSmileIDTestScenario =
+            bundledScenarios.firstOrNull { it.name == name } ?: throw IllegalArgumentException("No bundled test scenario named $name")
+
+        /** The selfie analyzer [test] installs, read back through the public `ml { }` block it installs into. */
+        fun selfieAnalyzer(test: UseSmileIDTest) =
+            when (val registry = UseSmileIDFlowBuilder().ml { analyzers { test.install(into = this) } }) {
+                is UseSmileIDResult.Success -> registry.value.getAnalyzersFor(CaptureType.SELFIE).first()
+                is UseSmileIDResult.Failure -> throw registry.error
+                else -> throw IllegalStateException("The scenario's analyzers didn't install: $registry")
+            }
+
+        fun requestsJson(server: UseSmileIDTestServer): String = JSONArray(
+            server.requests.map { request ->
+                JSONObject()
+                    .put("path", request.path)
+                    .put("headers", JSONObject(request.headers))
+                    .put(
+                        "parts",
+                        JSONObject().apply {
+                            request.parts.forEach { (name, part) ->
+                                put(
+                                    name,
+                                    when (part) {
+                                        is UseSmileIDTestPart.Text -> JSONObject().put("text", part.value)
+                                        is UseSmileIDTestPart.File -> JSONObject().put("fileName", part.fileName).put("size", part.size)
+                                    },
+                                )
+                            }
+                        },
+                    )
+            },
+        ).toString()
+
+        fun parseResponse(json: String): UseSmileIDTestResponse {
+            val response = JSONObject(json)
+            return when (val kind = response.getString("kind")) {
+                "status" -> UseSmileIDTestResponse.status(response.getInt("code"), response.optString("body", "{}"))
+                "tokenExpired" -> UseSmileIDTestResponse.tokenExpired
+                "connectionDropped" -> UseSmileIDTestResponse.connectionDropped
+                else -> throw IllegalArgumentException("Unknown test response: $kind")
+            }
+        }
+    }
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" />

package/android/src/release/java/com/usesmileid/testing/rn/UseSmileIDTestingModule.kt

@@ -0,0 +1,24 @@
+package com.usesmileid.testing.rn
+
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+
+/**
+ * A release build's stand-in: the test server is a debug-only dependency, so a shipped app can't
+ * start one, and the test doubles never reach it.
+ */
+class UseSmileIDTestingModule : Module() {
+    override fun definition() = ModuleDefinition {
+        Name("UseSmileIDTesting")
+
+        AsyncFunction("start") { -> refuse<Int>() }
+        Function("requests") { _: Int -> refuse<String>() }
+        Function("respond") { _: Int, _: String, _: String -> refuse<Unit>() }
+        Function("close") { _: Int -> }
+        AsyncFunction("startTest") { _: String, _: String? -> refuse<Map<String, Any>>() }
+        Function("unscriptFace") { _: String -> }
+    }
+
+    /** Typed, because Expo can't register a function whose body only throws. */
+    private fun <T> refuse(): T = throw UnsupportedOperationException("UseSmileIDTestServer runs only in a debug build")
+}

package/app.plugin.js

@@ -0,0 +1,3 @@
+// Entry point Expo discovers when an app references this package in
+// `expo.plugins`. The compiled plugin lives at `plugin/build/index.js`.
+module.exports = require("./plugin/build");

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { UseSmileIDTestResponse, UseSmileIDTestServer, testToken, type UseSmileIDTestPart, type UseSmileIDTestRequest, type UseSmileIDTestingNativeModule, } from "./use_smile_id_test_server";
+export { UseSmileIDTest } from "./use_smile_id_test";
+export { UseSmileIDTestScenario } from "./use_smile_id_test_scenario";

package/dist/index.js

@@ -0,0 +1 @@
+"use strict";export{UseSmileIDTestResponse,UseSmileIDTestServer,testToken}from"./use_smile_id_test_server";export{UseSmileIDTest}from"./use_smile_id_test";export{UseSmileIDTestScenario}from"./use_smile_id_test_scenario";

package/dist/use_smile_id_test.d.ts

@@ -0,0 +1,23 @@
+import { type AnalyzerRegistryBuilder, type InterceptorConfigBuilder } from "@smileid/usesmileid";
+import { UseSmileIDTestServer, type UseSmileIDTestingNativeModule } from "./use_smile_id_test_server";
+import { UseSmileIDTestScenario } from "./use_smile_id_test_scenario";
+/** A flow under test with no Smile ID backend and no person in front of the camera; debug builds only. */
+export declare class UseSmileIDTest {
+    /** The person in front of the camera. */
+    readonly scenario: UseSmileIDTestScenario;
+    /** The backend, in process. */
+    readonly server: UseSmileIDTestServer;
+    private readonly native;
+    private readonly faceKey;
+    /** A structurally valid token for the flow's `token`; the test server is the only one that sees it. */
+    readonly token: string;
+    private constructor();
+    /** Starts the native test, its server and its scripted selfie (`selfieHappyPath` for a document scenario). */
+    static create(scenario: UseSmileIDTestScenario, native?: UseSmileIDTestingNativeModule): Promise<UseSmileIDTest>;
+    /** Routes every request the flow makes to `server`, inside `n.interceptors((i) => …)`. */
+    install(into: InterceptorConfigBuilder): void;
+    /** Runs the scenario in the selfie analyzer you registered, inside `m.analyzers((a) => …)` after your own; a document scenario throws. */
+    install(into: AnalyzerRegistryBuilder): void;
+    /** Stops the server, so requests after this are refused, and drops the scripted analyzer. */
+    close(): void;
+}

package/dist/use_smile_id_test.js

@@ -0,0 +1 @@
+"use strict";import{requireNativeModule as n}from"expo-modules-core";import{AnalyzerFactoryKey as i,faceConfigSchema as o}from"@smileid/usesmileid_bridge";import{CaptureType as c}from"@smileid/usesmileid";import{UseSmileIDTestServer as l,testToken as f}from"./use_smile_id_test_server";const u={[i.MLKitFace]:"UseSmileIDMlkitFace",[i.HuaweiFace]:"UseSmileIDHuaweiFace",[i.VisionFace]:"UseSmileIDVisionFace"};export class UseSmileIDTest{scenario;server;native;faceKey;token=f();constructor(s,e,r,a){this.scenario=s,this.server=e,this.native=r,this.faceKey=a}static async create(s,e=n("UseSmileIDTesting")){const{port:r,faceKey:a}=await e.startTest(s.name,s.script??null);return new UseSmileIDTest(s,l.attach(e,r),e,a)}install(s){if("testRoute"in s){s.testRoute(this.server);return}if(this.scenario.isDocument)throw new Error(`${this.scenario.name}: React Native can't script a document capture yet, only a selfie`);const e=s.build().selfie;if(!e)throw new Error("Register your selfie analyzer before installing the test: the scenario runs in its native session");s.forCaptureType(c.selfie,r=>r.add(m(e,this.faceKey)))}close(){this.server.close(),this.native.unscriptFace(this.faceKey)}}function m(t,s){const e=n(u[t.key]);return{kind:"face",key:t.key,frameProcessorPluginName:t.frameProcessorPluginName,configure:r=>e.configure({...o.parse(r),analyzerFactoryKey:s}),analyzeKameraFrame:r=>e.analyzeKameraFrame(r),reset:()=>e.reset(),flush:()=>e.flush(),close:()=>e.close()}}

package/dist/use_smile_id_test_scenario.d.ts

@@ -0,0 +1,30 @@
+/** The person in front of the camera, scripted from the shared scenarios every Smile ID SDK runs; any camera frames will do. */
+export declare class UseSmileIDTestScenario {
+    /** The scenario's name, as its JSON gives it. */
+    readonly name: string;
+    private readonly captureType;
+    /** @internal A scenario of your own's JSON; undefined for a bundled one, which the native test doubles carry. */
+    readonly script?: string | undefined;
+    private constructor();
+    /** A selfie: hold still, then smile, then the capture completes. */
+    static readonly selfieHappyPath: UseSmileIDTestScenario;
+    /** An Enhanced SmartSelfie: the head turns, each held, then the capture completes. */
+    static readonly enhancedSelfieHeadTurns: UseSmileIDTestScenario;
+    /** One side of a document, found and held steady. */
+    static readonly documentFront: UseSmileIDTestScenario;
+    /** Both sides of a document. */
+    static readonly documentFrontAndBack: UseSmileIDTestScenario;
+    /** A passport, then the visa page a residency job reads. */
+    static readonly documentVisa: UseSmileIDTestScenario;
+    /** A selfie that never satisfies the capture, so the flow times out. */
+    static readonly selfieTimeout: UseSmileIDTestScenario;
+    /** A selfie for a flow with `skipApiSubmission`, which hands the job back instead of submitting it. */
+    static readonly skipSubmission: UseSmileIDTestScenario;
+    /** The one of the scenarios above whose JSON gives it `name`, such as `selfie-happy-path`, or null. */
+    static named(name: string): UseSmileIDTestScenario | null;
+    /** A scenario of your own, in the shared schema; throws when `text` isn't one. */
+    static fromJson(text: string): UseSmileIDTestScenario;
+    /** @internal */
+    get isDocument(): boolean;
+    toString(): string;
+}

package/dist/use_smile_id_test_scenario.js

@@ -0,0 +1 @@
+"use strict";import{z as e}from"zod";const a=e.object({name:e.string().min(1),captureType:e.enum(["selfie","document"]),steps:e.array(e.object({emit:e.string().min(1),holdFrames:e.number().int().positive().optional()})).min(1)});export class UseSmileIDTestScenario{name;captureType;script;constructor(n,t,s){this.name=n,this.captureType=t,this.script=s}static selfieHappyPath=new UseSmileIDTestScenario("selfie-happy-path","selfie");static enhancedSelfieHeadTurns=new UseSmileIDTestScenario("ess-head-turn-happy-path","selfie");static documentFront=new UseSmileIDTestScenario("document-happy-path","document");static documentFrontAndBack=new UseSmileIDTestScenario("document-back-side","document");static documentVisa=new UseSmileIDTestScenario("document-visa","document");static selfieTimeout=new UseSmileIDTestScenario("selfie-timeout","selfie");static skipSubmission=new UseSmileIDTestScenario("selfie-skip-submission","selfie");static named(n){return Object.values(UseSmileIDTestScenario).filter(t=>t instanceof UseSmileIDTestScenario).find(t=>t.name===n)??null}static fromJson(n){const t=a.safeParse(JSON.parse(n));if(!t.success)throw new Error(`Not a test scenario: ${t.error.message}`);return new UseSmileIDTestScenario(t.data.name,t.data.captureType,n)}get isDocument(){return this.captureType==="document"}toString(){return`UseSmileIDTestScenario(${this.name})`}}

package/dist/use_smile_id_test_server.d.ts

@@ -0,0 +1,86 @@
+import { z } from "zod";
+import type { UseSmileIDTestRoute } from "@smileid/usesmileid_bridge/internal";
+declare const testPart: z.ZodUnion<readonly [z.ZodObject<{
+    text: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    fileName: z.ZodString;
+    size: z.ZodNumber;
+}, z.core.$strict>]>;
+declare const testRequests: z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    headers: z.ZodRecord<z.ZodString, z.ZodString>;
+    parts: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        text: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        fileName: z.ZodString;
+        size: z.ZodNumber;
+    }, z.core.$strict>]>>;
+}, z.core.$strip>>;
+/** One part of a request: text, or a file by its name and size. A file's bytes are never kept. */
+export type UseSmileIDTestPart = Readonly<z.infer<typeof testPart>>;
+/** One request the flow made, with a multipart body's parts or a JSON body's top-level fields decoded. */
+export type UseSmileIDTestRequest = Readonly<z.infer<typeof testRequests>[number]>;
+/** What `UseSmileIDTestServer.respond` makes a path answer. */
+export type UseSmileIDTestResponse = {
+    readonly kind: "status";
+    readonly code: number;
+    readonly body: string;
+} | {
+    readonly kind: "tokenExpired";
+} | {
+    readonly kind: "connectionDropped";
+};
+export declare const UseSmileIDTestResponse: {
+    /** An HTTP `code` with `body`, in the API's error shape when it's an error. */
+    readonly status: (code: number, body?: string) => UseSmileIDTestResponse;
+    /** A `401`, which makes the SDK ask your `onTokenExpired` for a new token. */
+    readonly tokenExpired: UseSmileIDTestResponse;
+    /** The connection drops before an answer. */
+    readonly connectionDropped: UseSmileIDTestResponse;
+};
+/** The native module: Android's `com.usesmileid:testing` and iOS's `UseSmileIDTesting` servers. */
+export type UseSmileIDTestingNativeModule = {
+    start(): Promise<number>;
+    requests(port: number): string;
+    respond(port: number, path: string, response: string): void;
+    close(port: number): void;
+    /** Starts the native test of the named bundled scenario, or `json`'s: its server's port, and the key its selfie analyzer is under. */
+    startTest(name: string, json: string | null): Promise<{
+        port: number;
+        faceKey: string;
+    }>;
+    unscriptFace(key: string): void;
+};
+/**
+ * The Smile ID backend, in process, for a flow under test. Every `/v3` job endpoint answers the
+ * canonical accepted-job payload unless a test scripts something else with `respond`, and every
+ * request is recorded, decoded, in `requests()`. It listens on `127.0.0.1` only, in a debug build.
+ * Install it with `n.interceptors((i) => i.testRoute(server))` and close it when the test ends.
+ */
+export declare class UseSmileIDTestServer implements UseSmileIDTestRoute {
+    private readonly native;
+    /** The port the server listens on, on `127.0.0.1`. */
+    readonly port: number;
+    private closed;
+    private constructor();
+    /** Starts a server. Fails outside a debug build. */
+    static start(native?: UseSmileIDTestingNativeModule): Promise<UseSmileIDTestServer>;
+    /** @internal The server a native test already started on `port`. */
+    static attach(native: UseSmileIDTestingNativeModule, port: number): UseSmileIDTestServer;
+    /** The route the SDK reads: this server's port, or undefined once it is closed. */
+    testRoutePort(): number | undefined;
+    /** Every request the flow made, in order. */
+    requests(): readonly UseSmileIDTestRequest[];
+    /** The requests to the `/v3` job endpoints: the job submissions. */
+    submissions(): readonly UseSmileIDTestRequest[];
+    /** Makes `path` answer `response` from now on, instead of what it answers by default. */
+    respond(path: string, response: UseSmileIDTestResponse): void;
+    /** Stops listening. Requests after this are refused before they leave the process. */
+    close(): void;
+}
+/**
+ * A structurally valid, far-future token for the flow's `token`; the SDK never checks its signature.
+ * A `payload` is the claim binding user details and consent, which the server then injects.
+ */
+export declare function testToken(payload?: Readonly<Record<string, unknown>>): string;
+export {};

package/dist/use_smile_id_test_server.js

@@ -0,0 +1 @@
+"use strict";import{requireNativeModule as u}from"expo-modules-core";import{z as e}from"zod";const h=e.union([e.object({text:e.string()}).strict(),e.object({fileName:e.string(),size:e.number().int().nonnegative()}).strict()]),l=e.array(e.object({path:e.string(),headers:e.record(e.string(),e.string()),parts:e.record(e.string(),h)}));export const UseSmileIDTestResponse={status:(r,t="{}")=>({kind:"status",code:r,body:t}),tokenExpired:{kind:"tokenExpired"},connectionDropped:{kind:"connectionDropped"}};const v=["/v3/enhanced_kyc","/v3/registration","/v3/authentication","/v3/biometric_kyc","/v3/document_verification","/v3/enhanced_document_verification","/v3/residency_document_verification"];export class UseSmileIDTestServer{native;port;closed=!1;constructor(t,s){this.native=t,this.port=s}static async start(t=u("UseSmileIDTesting")){return new UseSmileIDTestServer(t,await t.start())}static attach(t,s){return new UseSmileIDTestServer(t,s)}testRoutePort(){return this.closed?void 0:this.port}requests(){const t=l.safeParse(JSON.parse(this.native.requests(this.port)));if(!t.success)throw new Error(`The test server answered requests in a shape it never sends: ${t.error.message}`);return t.data}submissions(){return this.requests().filter(t=>v.some(s=>t.path.startsWith(s)))}respond(t,s){this.native.respond(this.port,t,JSON.stringify(s))}close(){this.closed||(this.closed=!0,this.native.close(this.port))}}export function testToken(r){return[i('{"alg":"HS256","typ":"JWT"}'),i(JSON.stringify({partner_id:"test-partner",exp:4102444800,...r&&{payload:r}})),i("test-signature")].join(".")}const g="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";function i(r){let t="";for(let s=0;s<r.length;s+=3){const[o,a,c]=[0,1,2].map(n=>r.charCodeAt(s+n)),d=o<<16|(a||0)<<8|(c||0),p=s+2<r.length?4:s+1<r.length?3:2;for(let n=0;n<p;n+=1)t+=g[d>>18-6*n&63]}return t}

package/expo-module.config.json

@@ -0,0 +1,9 @@
+{
+  "platforms": ["android", "apple"],
+  "android": {
+    "modules": ["com.usesmileid.testing.rn.UseSmileIDTestingModule"]
+  },
+  "apple": {
+    "modules": ["UseSmileIDTestingModule"]
+  }
+}

package/ios/UseSmileIDTestingExpo.podspec

@@ -0,0 +1,58 @@
+require 'json'
+
+# Reads the package's package.json so version stays in sync with the
+# JS-side package version. Mirrors the convention used by every Expo
+# Module in this workspace.
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  # Pod name is intentionally distinct from the SPM product
+  # `UseSmileIDTesting` (declared in `expo-module.config.json`)
+  # to avoid a name collision between the CocoaPods bridge target
+  # and the Swift Package product it imports.
+  s.name           = 'UseSmileIDTestingExpo'
+  s.version        = package['version']
+  s.summary        = 'The native test server for UseSmileID v12 tests (Expo Module bridge).'
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = package['author']
+  s.homepage       = package['homepage']
+  s.platforms      = { :ios => '15.0' }
+  s.swift_version  = '5.9'
+  s.source         = { git: 'https://github.com/usesmileid/react-native-expo.git', tag: "v#{s.version}" }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+
+  # The Smile ID native deps (`UseSmileIDTesting` / `UseSmileIDBridge`)
+  # are SPM-only — declared in `expo-module.config.json` under
+  # `apple.dependencies`. Expo Modules autolinking surfaces the SPM
+  # products to this target at compile time. Do NOT add a
+  # `s.dependency` for them here; that would require shipping a
+  # CocoaPods podspec for the binary, which we don't.
+
+  # Swift flags consistent with Expo Modules' Kotlin/Swift compiler-flag
+  # plumbing — toggled by the consuming app's Podfile when it runs in
+  # debug mode.
+  s.pod_target_xcconfig = {
+    # UseSmileIDTesting is an SPM source target whose module no pod searches for; without this, `canImport` is false.
+    'SWIFT_INCLUDE_PATHS' => '$(inherited) "${PODS_CONFIGURATION_BUILD_DIR}"',
+    'DEFINES_MODULE' => 'YES',
+    'SWIFT_COMPILATION_MODE' => 'wholemodule',
+    # Hardening — mirrors the native iOS frameworks' Release-config
+    # build settings. Dead code is stripped, install-path metadata is
+    # removed at link time, debug symbols (DWARF / line tables) are
+    # stripped via STRIP_STYLE = 'debugging', and Swift's field-name
+    # reflection metadata is dropped so class-dump / Hopper cannot
+    # recover Swift property names. STRIP_STYLE must stay 'debugging'
+    # (not 'all') — dynamic frameworks need their dyld-visible symbol
+    # table intact for consumers to link against. 'all' is for apps.
+    'DEAD_CODE_STRIPPING' => 'YES',
+    'DEPLOYMENT_POSTPROCESSING' => 'YES',
+    'STRIP_INSTALLED_PRODUCT' => 'YES',
+    'STRIP_STYLE' => 'debugging',
+    'SWIFT_REFLECTION_METADATA_LEVEL' => 'without-names'
+  }
+
+  s.source_files = 'UseSmileIDTestingModule/**/*.{h,m,mm,swift,hpp,cpp}'
+end

package/ios/UseSmileIDTestingModule/UseSmileIDTestingModule.swift

@@ -0,0 +1,191 @@
+import ExpoModulesCore
+import Foundation
+#if canImport(UseSmileIDTesting)
+    import UseSmileID
+    import UseSmileIDBridge
+    import UseSmileIDTesting
+#endif
+
+#if canImport(UseSmileIDTesting)
+    /// The native SDK's test servers by port and scripted selfie analyzers by key, for `@smileid/usesmileid_testing`; Debug builds only.
+    public final class UseSmileIDTestingModule: Module {
+        static let scriptedFaceKey = "usesmileid-testing-face"
+
+        private let lock = NSLock()
+        private var servers: [Int: UseSmileIDTestServer] = [:]
+        private var scriptedFaces: Set<String> = []
+        private var scriptedFaceCount = 0
+
+        public func definition() -> ModuleDefinition {
+            Name("UseSmileIDTesting")
+
+            AsyncFunction("start") { () async throws -> Int in
+                let server = try UseSmileIDTestServer()
+                guard let port = await server.port() else {
+                    server.close()
+                    throw TestServerError.didNotStart
+                }
+                self.lock.withLock { self.servers[Int(port)] = server }
+                return Int(port)
+            }
+
+            Function("requests") { (port: Int) throws -> String in
+                try Self.requestsJSON(self.server(port).requests)
+            }
+
+            Function("respond") { (port: Int, path: String, response: String) throws in
+                try self.server(port).respond(path, with: Self.response(from: response))
+            }
+
+            Function("close") { (port: Int) in
+                self.lock.withLock { self.servers.removeValue(forKey: port) }?.close()
+            }
+
+            AsyncFunction("startTest") { (name: String, json: String?) async throws -> [String: Any] in
+                let test = try UseSmileIDTest(scenario: json.map(UseSmileIDTestScenario.fromJSON) ?? Self.bundledScenario(name))
+                guard let port = await test.server.port() else {
+                    test.close()
+                    throw TestServerError.didNotStart
+                }
+                guard let selfie = test.analyzers.first(where: { $0.captureType == .selfie })?.factories.first else {
+                    test.close()
+                    throw TestServerError.noScriptedFace
+                }
+                let key = self.lock.withLock { () -> String in
+                    self.scriptedFaceCount += 1
+                    let key = "\(Self.scriptedFaceKey)-\(self.scriptedFaceCount)"
+                    self.scriptedFaces.insert(key)
+                    self.servers[Int(port)] = test.server
+                    return key
+                }
+                FaceAnalyzerFactoryRegistry.shared.register(key: key) { ScriptedFace(factory: selfie).analyzeFrame }
+                return ["port": Int(port), "faceKey": key]
+            }
+
+            Function("unscriptFace") { (key: String) in
+                if self.lock.withLock({ self.scriptedFaces.remove(key) }) != nil {
+                    FaceAnalyzerFactoryRegistry.shared.unregister(key: key)
+                }
+            }
+
+            // A reloaded runtime leaves no server listening and no scripted analyzer registered.
+            OnDestroy {
+                let (all, keys) = self.lock.withLock { () -> ([UseSmileIDTestServer], Set<String>) in
+                    defer {
+                        self.servers.removeAll()
+                        self.scriptedFaces.removeAll()
+                    }
+                    return (Array(self.servers.values), self.scriptedFaces)
+                }
+                all.forEach { $0.close() }
+                keys.forEach { FaceAnalyzerFactoryRegistry.shared.unregister(key: $0) }
+            }
+        }
+
+        static func bundledScenario(_ name: String) throws -> UseSmileIDTestScenario {
+            let bundled: [UseSmileIDTestScenario] = [
+                .selfieHappyPath, .enhancedSelfieHeadTurns, .documentFront, .documentFrontAndBack,
+                .documentVisa, .selfieTimeout, .skipSubmission,
+            ]
+            guard let scenario = bundled.first(where: { $0.name == name }) else { throw TestServerError.noScenario(name) }
+            return scenario
+        }
+
+        private func server(_ port: Int) throws -> UseSmileIDTestServer {
+            guard let server = lock.withLock({ servers[port] }) else { throw TestServerError.noServer(port) }
+            return server
+        }
+
+        static func requestsJSON(_ requests: [UseSmileIDTestRequest]) throws -> String {
+            let json: [[String: Any]] = requests.map { request in
+                [
+                    "path": request.path,
+                    "headers": request.headers,
+                    "parts": request.parts.mapValues { part -> [String: Any] in
+                        switch part {
+                        case let .text(text): ["text": text]
+                        case let .file(fileName, size): ["fileName": fileName, "size": size]
+                        }
+                    },
+                ]
+            }
+            return try String(decoding: JSONSerialization.data(withJSONObject: json), as: UTF8.self)
+        }
+
+        static func response(from json: String) throws -> UseSmileIDTestResponse {
+            guard let object = try JSONSerialization.jsonObject(with: Data(json.utf8)) as? [String: Any] else {
+                throw TestServerError.unknownResponse(json)
+            }
+            switch object["kind"] as? String {
+            case "status":
+                guard let code = object["code"] as? Int else { throw TestServerError.unknownResponse(json) }
+                return .status(code: code, body: object["body"] as? String ?? "{}")
+            case "tokenExpired": return .tokenExpired
+            case "connectionDropped": return .connectionDropped
+            default: throw TestServerError.unknownResponse(json)
+            }
+        }
+    }
+
+    /// One capture session's scripted selfie analyzer, made on its first frame: the registry's provider is synchronous.
+    private actor ScriptedFace {
+        private let factory: BaseAnalyzerFactory
+        private var analyzer: BaseAnalyzer?
+
+        init(factory: BaseAnalyzerFactory) {
+            self.factory = factory
+        }
+
+        nonisolated var analyzeFrame: FaceAnalyzerFactoryRegistry.FaceAnalyzeFrame {
+            { input, state in await self.analyze(input, state) }
+        }
+
+        private func analyze(_ input: AnalyzerInput, _ state: IdentityScanState) async -> AnalyzerOutput {
+            if analyzer == nil {
+                do {
+                    analyzer = try await factory.newInstance()
+                } catch {
+                    preconditionFailure("The scenario's scripted selfie analyzer didn't start: \(error)")
+                }
+                guard analyzer != nil else { preconditionFailure("The scenario's scripted selfie analyzer didn't start") }
+            }
+            return (try? await analyzer?.analyze(data: input, state: state)) ?? FaceDetectorOutput(faces: [])
+        }
+    }
+
+#else
+    /// An app built without this package's config plugin has no test server to start: the plugin is
+    /// applied only in the app config you test with.
+    public final class UseSmileIDTestingModule: Module {
+        public func definition() -> ModuleDefinition {
+            Name("UseSmileIDTesting")
+
+            AsyncFunction("start") { () async throws -> Int in throw TestServerError.notLinked }
+            Function("requests") { (_: Int) throws -> String in throw TestServerError.notLinked }
+            Function("respond") { (_: Int, _: String, _: String) throws in throw TestServerError.notLinked }
+            Function("close") { (_: Int) in }
+            AsyncFunction("startTest") { (_: String, _: String?) async throws -> [String: Any] in throw TestServerError.notLinked }
+            Function("unscriptFace") { (_: String) in }
+        }
+    }
+#endif
+
+enum TestServerError: Error, CustomStringConvertible {
+    case didNotStart
+    case noServer(Int)
+    case unknownResponse(String)
+    case notLinked
+    case noScriptedFace
+    case noScenario(String)
+
+    var description: String {
+        switch self {
+        case .notLinked: "This app is built without @smileid/usesmileid_testing's config plugin, so it has no test server"
+        case .noScriptedFace: "The scenario's scripted selfie analyzer didn't install"
+        case let .noScenario(name): "No bundled test scenario named \(name)"
+        case .didNotStart: "The test server didn't start"
+        case let .noServer(port): "No test server on port \(port): it was closed or never started"
+        case let .unknownResponse(json): "Unknown test response: \(json)"
+        }
+    }
+}

package/package.json

@@ -1,6 +1,77 @@
 {
   "name": "@smileid/usesmileid_testing",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "12.3.1-SNAPSHOT.71",
+  "description": "Test doubles for the UseSmileID React Native (Expo) SDK: the native SDKs' in-process test server, for your own E2E tests.",
+  "homepage": "https://usesmileid.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/smileidentity/react-native-expo.git",
+    "directory": "usesmileid_testing"
+  },
+  "bugs": {
+    "url": "https://github.com/smileidentity/react-native-expo/issues"
+  },
+  "license": "MIT",
+  "author": "Smile Identity <hello@usesmileid.com>",
+  "keywords": [
+    "react-native",
+    "expo",
+    "expo-module",
+    "testing",
+    "smile-id"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    },
+    "./app.plugin.js": "./app.plugin.js"
+  },
+  "files": [
+    "dist",
+    "android/build.gradle",
+    "android/consumer-rules.pro",
+    "android/src",
+    "ios/UseSmileIDTestingExpo.podspec",
+    "ios/UseSmileIDTestingModule",
+    "plugin/build",
+    "app.plugin.js",
+    "expo-module.config.json",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "dependencies": {
+    "zod": "^4.6.7",
+    "@smileid/usesmileid_bridge": "12.3.1-SNAPSHOT.71"
+  },
+  "peerDependencies": {
+    "expo": ">=56.0.0",
+    "expo-modules-core": ">=56.0.0",
+    "react-native": ">=0.83.0",
+    "@smileid/usesmileid": "12.3.1-SNAPSHOT.71"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.4",
+    "expo": "~57.0.26",
+    "expo-modules-core": "^57.0.23",
+    "react-native": "^0.86.3",
+    "typescript": "^6.0.3",
+    "@smileid/usesmileid": "12.3.1-SNAPSHOT.71"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "pnpm run build:lib && pnpm run build:plugin && node ../Scripts/copy-assets.mjs",
+    "build:lib": "tsc -p tsconfig.json",
+    "build:plugin": "tsc -p plugin/tsconfig.json",
+    "typecheck": "tsc -b && tsc -p plugin/tsconfig.json --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clean": "rm -rf dist plugin/build .turbo coverage tsconfig.tsbuildinfo"
+  }
 }

package/plugin/build/android_loopback.d.ts

@@ -0,0 +1,31 @@
+import { type ConfigPlugin } from "expo/config-plugins";
+/** The debug-only config this plugin writes when the app names none of its own. */
+export declare const DEBUG_CONFIG_NAME = "smileid_test_network_security";
+/**
+ * `config` (a network security config's XML) with cleartext allowed to loopback. A config that
+ * already allows both names is returned as it is.
+ */
+export declare function allowLoopback(config: string): string;
+/** The XML resource a `@xml/name` reference names, or undefined for anything else. */
+export declare function xmlResourceName(reference: string | undefined): string | undefined;
+/**
+ * Writes the debug build's network security config, on every prebuild, so it follows the app's own: the app's own (from `src/main`) plus
+ * loopback, under the same name so the debug source set overrides it, or this plugin's own when
+ * the app names none, which the debug manifest then points at. Answers the name written.
+ */
+export declare function writeDebugConfig(appDirectory: string, ownName: string | undefined, buildType?: string): string;
+/**
+ * Points the debug manifest at `name` when the app's own manifest names no network security
+ * config, creating the debug manifest if the app has none.
+ */
+export declare function writeDebugManifest(appDirectory: string, name: string, buildType?: string): void;
+/**
+ * Removes the debug manifest's pointer to this plugin's own config, left by a prebuild from before
+ * the app named a config of its own; the debug override of the app's config replaces it.
+ */
+export declare function forgetDebugManifest(appDirectory: string, buildType?: string): void;
+/** The Android build types that reach the test server: `debug` unless the app names others. */
+export type AndroidLoopbackOptions = {
+    readonly androidBuildTypes?: readonly string[];
+};
+export declare const withAndroidLoopback: ConfigPlugin<AndroidLoopbackOptions | void>;

package/plugin/build/android_loopback.js

@@ -0,0 +1,14 @@
+"use strict";var __createBinding=this&&this.__createBinding||(Object.create?(function(n,t,i,e){e===void 0&&(e=i);var r=Object.getOwnPropertyDescriptor(t,i);(!r||("get"in r?!t.__esModule:r.writable||r.configurable))&&(r={enumerable:!0,get:function(){return t[i]}}),Object.defineProperty(n,e,r)}):(function(n,t,i,e){e===void 0&&(e=i),n[e]=t[i]})),__setModuleDefault=this&&this.__setModuleDefault||(Object.create?(function(n,t){Object.defineProperty(n,"default",{enumerable:!0,value:t})}):function(n,t){n.default=t}),__importStar=this&&this.__importStar||(function(){var n=function(t){return n=Object.getOwnPropertyNames||function(i){var e=[];for(var r in i)Object.prototype.hasOwnProperty.call(i,r)&&(e[e.length]=r);return e},n(t)};return function(t){if(t&&t.__esModule)return t;var i={};if(t!=null)for(var e=n(t),r=0;r<e.length;r++)e[r]!=="default"&&__createBinding(i,t,e[r]);return __setModuleDefault(i,t),i}})();Object.defineProperty(exports,"__esModule",{value:!0}),exports.withAndroidLoopback=exports.DEBUG_CONFIG_NAME=void 0,exports.allowLoopback=allowLoopback,exports.xmlResourceName=xmlResourceName,exports.writeDebugConfig=writeDebugConfig,exports.writeDebugManifest=writeDebugManifest,exports.forgetDebugManifest=forgetDebugManifest;const config_plugins_1=require("expo/config-plugins"),fs=__importStar(require("fs")),path=__importStar(require("path"));exports.DEBUG_CONFIG_NAME="smileid_test_network_security";const LOOPBACK=["127.0.0.1","localhost"],DEBUG_ONLY_CONFIG=`<?xml version="1.0" encoding="utf-8"?>
+<network-security-config>
+    <base-config cleartextTrafficPermitted="true" />
+</network-security-config>
+`,LOOPBACK_ONLY_CONFIG=`<?xml version="1.0" encoding="utf-8"?>
+<network-security-config>
+</network-security-config>
+`;function allowLoopback(n){const t=LOOPBACK.filter(e=>!cleartextHosts(n).includes(e));if(t.length===0)return n;const i=['    <domain-config cleartextTrafficPermitted="true">',...t.map(e=>`        <domain includeSubdomains="false">${e}</domain>`),"    </domain-config>"].join(`
+`);if(!n.includes("</network-security-config>"))throw new Error("[usesmileid_testing] The app's network security config has no closing tag.");return n.replace("</network-security-config>",`${i}
+</network-security-config>`)}function cleartextHosts(n){const t=[];for(const i of n.matchAll(/<domain-config\b([^>]*)>([\s\S]*?)<\/domain-config>/g))if(/cleartextTrafficPermitted="true"/.test(i[1]??""))for(const e of(i[2]??"").matchAll(/<domain\b[^>]*>\s*([^<\s]+)\s*<\/domain>/g))t.push(e[1]);return t}function xmlResourceName(n){return n?.match(/^@xml\/([A-Za-z0-9_]+)$/)?.[1]}function writeDebugConfig(n,t,i="debug"){const e=t??exports.DEBUG_CONFIG_NAME,r=path.join(n,"src","main","res","xml",`${e}.xml`);if(t!==void 0&&!fs.existsSync(r))throw new Error(`[usesmileid_testing] The app names @xml/${e}, but ${r} isn't there to extend. List @smileid/usesmileid_testing after the plugin that writes it, or keep the file in src/main/res/xml.`);const o=t!==void 0?fs.readFileSync(r,"utf-8"):i==="debug"?DEBUG_ONLY_CONFIG:LOOPBACK_ONLY_CONFIG,s=path.join(n,"src",i,"res","xml");return fs.mkdirSync(s,{recursive:!0}),fs.writeFileSync(path.join(s,`${e}.xml`),allowLoopback(o)),e}function writeDebugManifest(n,t,i="debug"){const e=path.join(n,"src",i,"AndroidManifest.xml"),r=`android:networkSecurityConfig="@xml/${t}"`;if(!fs.existsSync(e)){fs.mkdirSync(path.dirname(e),{recursive:!0}),fs.writeFileSync(e,`<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <application ${r} />
+</manifest>
+`);return}const o=fs.readFileSync(e,"utf-8"),s=o.match(/android:networkSecurityConfig="([^"]*)"/)?.[1];if(s===`@xml/${t}`)return;if(s!==void 0)throw new Error(`[usesmileid_testing] ${e} already names ${s}; add 127.0.0.1 and localhost to it rather than have this plugin replace it.`);const c=/<application\b/.test(o)?o.replace(/<application\b/,`<application ${r}`):o.replace("</manifest>",`    <application ${r} />
+</manifest>`);if(c===o)throw new Error(`[usesmileid_testing] ${e} has neither an <application> element nor a closing </manifest> tag to add one before.`);fs.writeFileSync(e,c)}function forgetDebugManifest(n,t="debug"){const i=path.join(n,"src",t,"AndroidManifest.xml");if(!fs.existsSync(i))return;const e=fs.readFileSync(i,"utf-8"),r=e.replace(` android:networkSecurityConfig="@xml/${exports.DEBUG_CONFIG_NAME}"`,"");r!==e&&fs.writeFileSync(i,r)}const withAndroidLoopback=(n,t)=>(0,config_plugins_1.withAndroidManifest)(n,i=>{if(i.modRequest.introspect)return i;const e=config_plugins_1.AndroidConfig.Manifest.getMainApplicationOrThrow(i.modResults),r=xmlResourceName(e.$["android:networkSecurityConfig"]),o=path.join(i.modRequest.platformProjectRoot,"app");for(const s of t?.androidBuildTypes??["debug"]){const c=writeDebugConfig(o,r,s);r===void 0?writeDebugManifest(o,c,s):forgetDebugManifest(o,s)}return i});exports.withAndroidLoopback=withAndroidLoopback;

package/plugin/build/index.d.ts

@@ -0,0 +1,7 @@
+import type { ConfigPlugin } from "expo/config-plugins";
+import { type SmileIDSpmOptions } from "@smileid/usesmileid_bridge/plugin";
+import { type AndroidLoopbackOptions } from "./android_loopback";
+export type TestingOptions = SmileIDSpmOptions & AndroidLoopbackOptions;
+export declare const SPM_PRODUCTS: readonly ["UseSmileIDTesting"];
+declare const withTesting: ConfigPlugin<TestingOptions | void>;
+export default withTesting;

package/plugin/build/index.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.SPM_PRODUCTS=void 0;const plugin_1=require("@smileid/usesmileid_bridge/plugin"),android_loopback_1=require("./android_loopback");exports.SPM_PRODUCTS=["UseSmileIDTesting"];const withIosTesting=(0,plugin_1.withSmileIDSpm)({packageName:"usesmileid_testing",podTarget:"UseSmileIDTestingExpo",products:exports.SPM_PRODUCTS}),withTesting=(i,e)=>(0,android_loopback_1.withAndroidLoopback)(withIosTesting(i,e),e);exports.default=withTesting;