@burnt-labs/expo-satya-attest 3.0.0 → 3.1.0

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## Unreleased
+
+## 3.1.0 - 2026-07-31
+
+### Added
+
+- **Provider-selective partial endpoints (BUR-150).** Apps opt in exact providers
+  with `initSatyaAttest({ partialEndpointProviderIds: ['provider.id'] })`. Authenticated
+  readiness starts the bounded window when received; otherwise the first accepted capture does.
+  The SDK attempts the full plan; at the deadline it retains every confirmed
+  2xx endpoint and fails if none succeeded. Provider config and policy hashing
+  are unchanged.
+- Schema `2.2.0` binds an explicit partial-completion mode and exact ordered endpoint subset
+  into the device-signed statement, semantic hash, aggregate exchange root, and a new
+  proof-challenge domain. The verifier validates the subset directly against the current full
+  registry proof plan, including policy hash, order, membership, and account-binding
+  compatibility. Schemas
+  `2.0.0` and strict-all app-bound `2.1.0` remain unchanged.
+- The managed component and public low-level client always verify partial-endpoint artifacts
+  online because only the backend has the trusted full provider plan. Strict-all flows continue
+  to honor the component's `verifyBackend` setting. Native/local verification returns
+  `backend-required` for schema `2.2.0`. Verifier results expose completed and omitted endpoint
+  ids plus `planComplete`; relying parties that require the full plan must require
+  `planComplete: true`.
+- A stable `no-endpoints-captured` outcome when no endpoint succeeds, plus
+  `unconfirmedEndpointIds` diagnostics.
+
 ## 3.0.0 - 2026-07-28
 
 Multi-tenant app gating (BREAKING). Verification is now gated per app: every

package/PROVIDER_CONFIG.md

@@ -425,9 +425,9 @@ accepting an artifact.
 ## 8.1 `proofPlans[]` (optional — composite proofs)
 
 A **proof plan** gathers claims from several governed endpoints in one authenticated
-provider session as a single all-or-nothing artifact (schema v2). The app selects a plan
-by id (`proofPlanId`), never by URL or an arbitrary endpoint list — every endpoint the
-plan replays is a pre-approved `endpoints[]` entry.
+provider session as a single artifact (schema v2). The plan always declares the full
+attempt set. The app selects a plan by id (`proofPlanId`), never by URL or an arbitrary
+endpoint list — every endpoint the plan replays is a pre-approved `endpoints[]` entry.
 
 ```json
 "proofPlans": [
@@ -443,10 +443,32 @@ plan replays is a pre-approved `endpoints[]` entry.
 | Field | Req? | Type | Description |
 |---|---|---|---|
 | `id` | yes | `string` | Plan id. Same character rule as endpoint `id` (starts with a letter; letters/digits/`_`/`-`). Unique per provider. Selected via the `proofPlanId` prop, which is **mutually exclusive** with `endpointId`. |
-| `endpointIds` | yes | `string[]` | Ordered, unique set of **1–8** required endpoint ids, each present in `endpoints[]`. Order is order-sensitive and participates in `policyHash`. |
-| `maxDurationMs` | yes | `int` | Composite window bound, integer in `[1000, 120000]`. The window starts at the first required-endpoint capture (interactive login before it is excluded) and ends when the challenge is prepared. |
+| `endpointIds` | yes | `string[]` | Ordered, unique set of **1–8** endpoint ids, each present in `endpoints[]`. Order is order-sensitive and participates in `policyHash`. Strict-all requires every endpoint. |
+| `maxDurationMs` | yes | `int` | Composite window bound, integer in `[1000, 120000]`. For partial-enabled sessions, authenticated `__satyaReady` starts the window when received; otherwise the first accepted capture starts it. |
 | `accountBinding` | yes | `object` | How the artifact proves the endpoints belong to one account. `shared-session` (all endpoints replayed under one proof-local cookie jar) or `claim-equality` (named claims must be equal across endpoints). |
 
+**SDK partial completion (BUR-150) — no provider change**
+
+Partial completion is enabled for exact provider ids with
+`initSatyaAttest({ partialEndpointProviderIds: ['provider.id'] })`. Do not add
+`completionPolicy`, endpoint permutations, minimum counts, or any other partial-completion
+field to the provider. There is no corresponding Devtool, Provider Registry, or verifier
+configuration. An empty SDK list leaves the provider strict-all.
+
+The capture layer attempts every plan endpoint through `maxDurationMs`. If the complete plan
+succeeds, native replay follows the existing strict-all path. Otherwise, when the window expires,
+it passes every endpoint with a confirmed 2xx response to native replay and fails if none
+succeeded. Native replay may further omit an availability, timeout, non-2xx, or missing-claim
+failure while preserving fatal TLS/SPKI/origin/policy failures. Schema `2.2.0` signs the explicit
+`partial-endpoint-subset` mode and binds the exact ordered successful endpoints through the
+semantic hash, exchange root, and platform proof challenge.
+
+The verifier validates the non-empty proper subset directly against the current full registry
+proof plan. Unknown, duplicate, reordered, full-sized partial, and account-binding-breaking
+subsets are rejected. Relying parties that require the complete plan must require
+`planComplete: true`; `ok: true` alone means the presented subset is valid, not that every
+configured endpoint completed.
+
 **`accountBinding` modes**
 
 ```json
@@ -471,11 +493,11 @@ rejected after alias resolution.
 
 **Policy hash.** The Provider Registry backend canonicalizes the complete plan object
 into `policyHash`: the plan `id`, the **ordered** `endpointIds`, each referenced endpoint's
-complete policy, `maxDurationMs`, and
-the `accountBinding` rule. The byte/count/time caps are fixed by the schema-v2 compatibility
+complete policy, `maxDurationMs`, and the `accountBinding` rule. Partial completion adds no
+provider field or policy-hash input. The byte/count/time caps are fixed by the schema-v2 compatibility
 profile and are not part of the plan object. The verifier recomputes the policy hash, loads
 the same plan independently, and rejects the whole artifact if the hash or any exchange,
-binding rule, or aggregate invariant fails.
+binding rule, subset constraint, or aggregate invariant fails.
 
 > Composite proofs are a signed, bounded **sequential** observation, not an atomic snapshot
 > of the provider's database. Per-exchange completion times remain visible to verifier
@@ -515,10 +537,10 @@ whether naturally observed or triggered. Enable it when a logged-out response co
 match the endpoint rules.
 
 The WebView readiness flag is document-scoped: injection must emit `__satyaReady` on each
-authenticated document instead of persisting it across navigation. For composite plans, login
-remains unbounded; `proofPlans[].maxDurationMs` starts at the first accepted endpoint capture.
-The SDK then waits through that full interval for all remaining endpoints before failing the
-unresolved plan.
+authenticated document instead of persisting it across navigation. In a partial-enabled session,
+the signal starts the bounded window; without it, the first accepted ungated endpoint capture does.
+Expiry retains every confirmed 2xx endpoint or fails with `no-endpoints-captured` when none
+succeeded (§8.1). Strict-all retains its first-capture window behavior.
 
 **Provider concealment after login.** Once the SDK receives the `__satyaReady` login signal it
 covers the provider WebView with a verification screen automatically: the user sees the login
@@ -598,6 +620,8 @@ console.log(body.match(/octolytics-actor-login" content="(.*?)"/)?.[1]);
 - `capture` (when present) is a non-empty object whose only keys are `trigger`, `headers`,
   `nativeReplayHeaders`, `requestBody`, `landingUrl`, `pollMs`, `maxAttempts`,
   `requireLoginSignal`, with the bounds in §6,
+- unsupported proof-plan fields such as `completionPolicy` are rejected; partial completion
+  is an SDK/verifier session option (§8.1),
 - `injection` is a non-empty string / non-empty string array when present; `login.injection`
   and endpoint `injection` are rejected,
 - raw `allowedRequestHeaders`, `allowedResponseBodyJsonPaths`, and `privacyPolicy` are

package/README.md

@@ -80,7 +80,7 @@ New SDK artifacts also include envelope metadata:
   "attestationIdVersion": "statement-sha256-96-v1",
   "producer": {
     "sdk": "@burnt-labs/expo-satya-attest",
-    "sdkVersion": "3.0.0",
+    "sdkVersion": "3.1.0",
     "artifactSchemaVersion": "1.1.0",
     "coreVersion": "0.1.0"
   }
@@ -227,7 +227,7 @@ is a release tarball produced by `npm pack`, because it contains the same files
 would publish:
 
 ```bash
-npm install https://github.com/<owner>/<repo>/releases/download/expo-satya-attest-v2.1.0/burnt-labs-expo-satya-attest-2.1.0.tgz
+npm install https://github.com/<owner>/<repo>/releases/download/expo-satya-attest-v3.1.0/burnt-labs-expo-satya-attest-3.1.0.tgz
 npx expo install react-native-webview react-native-safe-area-context
 ```
 
@@ -235,8 +235,8 @@ Installing from a Git ref also works when that ref has the SDK package at the re
 root, such as a dedicated SDK repo or a subtree/split branch:
 
 ```bash
-npm install github:<owner>/<sdk-repo>#v2.1.0
-npm install git+https://github.com/<owner>/<sdk-repo>.git#v2.1.0
+npm install github:<owner>/<sdk-repo>#v3.1.0
+npm install git+https://github.com/<owner>/<sdk-repo>.git#v3.1.0
 npx expo install react-native-webview react-native-safe-area-context
 ```
 
@@ -491,19 +491,66 @@ effect, then render the hidden launcher:
 ## Composite Proofs
 
 A **composite proof** attests claims from several governed endpoints gathered in **one**
-authenticated provider session, bound into a single all-or-nothing artifact (schema
-`2.0.0`). Instead of a single `endpointId`, the app passes a `proofPlanId` — a
+authenticated provider session. Strict-all artifacts are schema `2.0.0` (legacy) or
+app-bound `2.1.0`; signed partial-endpoint artifacts use `2.2.0`. Instead of a
+single `endpointId`, the app passes a `proofPlanId` — a
 registry-defined **proof plan** that selects an ordered set of **1–8** required endpoint
 ids. The app never supplies URLs or an endpoint list; every endpoint the plan replays is a
 pre-approved `endpoints[]` entry, and the plan is folded into the provider `policyHash`.
 
+### Provider-selective partial endpoints
+
+Some providers cannot guarantee that every proof-plan endpoint fires in every session. An app
+may opt exact provider ids into partial completion without changing provider or proof-plan config:
+
+```ts
+initSatyaAttest({
+  partialEndpointProviderIds: ['provider.identity.v1'],
+});
+```
+
+Matching is exact and case-sensitive; entries are never treated as patterns. An empty or
+omitted list keeps every provider strict-all. There is no matching Provider Registry, Devtool,
+or verifier setting. The SDK list is an app availability preference; the backend remains the
+security authority.
+
+An authenticated `__satyaReady` signal starts the capture window and releases
+readiness-gated endpoints. Without it, the first accepted ungated capture starts the window.
+The capture layer attempts the full plan until `maxDurationMs`. Full capture success stays on the
+existing strict-all path. Otherwise, it sends the confirmed 2xx request subset to native replay,
+which requires at least one successful exchange and may further omit availability, timeout,
+non-2xx, or missing-claim failures. TLS trust, SPKI, origin, request-policy, and binding failures
+remain fatal.
+
+- the signed set must be a non-empty proper subset in proof-plan order;
+- every claim-equality account-binding endpoint must be present in the final subset;
+- schema `2.2.0` signs `completionMode: "partial-endpoint-subset"`; the semantic hash,
+  exchange root, and domain-separated proof challenge bind the exact ordered endpoint IDs;
+- schemas `2.0.0` and `2.1.0` have no completion mode and remain strict-all;
+- the verifier directly compares the signed subset with the current full registry proof plan
+  and fully verifies every included exchange;
+- both the managed component and public `SatyaMobileClient` API require successful backend
+  verification for schema `2.2.0`, even when `verifyBackend` is false;
+- native/local `verifyArtifact*` returns `backend-required` for schema `2.2.0` and is not an
+  acceptance verdict;
+- the verifier verdict always distinguishes `strict-all` from `partial-endpoint-subset` and
+  returns `endpointIds`, `omittedEndpointIds`, and `planComplete`;
+- relying parties that require full completion must require `planComplete: true` (equivalently,
+  `completionMode: "strict-all"` and an empty `omittedEndpointIds`).
+
+The verifier proves that every presented exchange is valid and belongs to the configured plan.
+It cannot prove that the omitted endpoints were actually attempted; that is SDK execution
+behavior, not a property recoverable from a subset proof.
+
+If the window expires without a successful endpoint, capture fails with
+`no-endpoints-captured`. Timeout diagnostics list `unconfirmedEndpointIds`.
+
 `proofPlanId` is **mutually exclusive** with `endpointId` — pass exactly one. It works on
 the same `SatyaProviderAttestButton` and low-level client:
 
-Providers without `proofPlans[]` remain single-endpoint compatible: the SDK treats the
-plan id as a hint and selects the first entry in `endpoints[]`. If the provider defines
-plans, an unknown `proofPlanId` is rejected instead of silently changing the requested
-policy.
+Providers without `proofPlans[]` remain single-endpoint compatible when no plan is requested.
+Requesting a `proofPlanId` from a provider with no plans, or requesting an unknown plan id, is
+rejected instead of silently changing the requested policy.
 
 ```tsx
 <SatyaProviderAttestButton
@@ -532,14 +579,15 @@ disabled and only 2xx responses accepted. `onProgress` reports `proofPlanId`, `e
 - **1–8 endpoints** per plan, ordered; the order is order-sensitive and participates in
   `policyHash`.
 - **Per-response 8 MiB** and **aggregate 16 MiB** response-byte caps across the plan.
-- The whole plan must complete within the plan's `maxDurationMs` (an integer in
-  `[1000, 120000]` ms). The window starts at the first required-endpoint capture — the
-  interactive login before it is excluded.
+- Capture selection runs for at most the plan's `maxDurationMs` (an integer in
+  `[1000, 120000]` ms). A readiness signal starts the window when received; otherwise the
+  first accepted capture starts it. Later readiness never resets an earlier start.
 
 ### What a v2 artifact contains
 
-The Rust core emits a schema-`2.0.0` artifact (`attestationIdVersion`
-`statement-sha256-96-v2`) with, per witnessed exchange, its own TLS/handshake commitments,
+The Rust core emits schema `2.0.0` for legacy strict-all, `2.1.0` for app-bound strict-all,
+or `2.2.0` for a signed endpoint subset. Each artifact carries, per witnessed
+exchange, its own TLS/handshake commitments,
 request/response commitments, record-log evidence, and endpoint-scoped disclosed claims
 (the same alias may repeat across different endpoint scopes; endpoint provenance is
 preserved). All exchanges are bound by **one** domain-separated, order- and count-bound
@@ -581,10 +629,11 @@ the preserved single-artifact profile for SDK 1–3, and schema 2 selects
 `expo-sdk-2-composite` for SDK 2–3. The backend loads the provider, plan, endpoints, reveal allowlists,
 SNI, pins, freshness, and revocation policy **independently from the registry** (never from
 the artifact), recomputes the provider's canonical `policyHash`, requires the artifact's
-exact hash, and returns a typed verdict with `proofPlanId`, `exchangeCount`, and
-`accountBindingAssurance`. Verification is all-or-nothing: any missing, duplicated, unknown,
-reordered, failed, or policy-mismatched exchange — or an account-binding, platform-assertion,
-freshness, or aggregate-invariant failure — produces **no** artifact.
+exact hash, and returns a typed verdict with `proofPlanId`, `completionMode`, `endpointIds`,
+`omittedEndpointIds`, `planComplete`, `exchangeCount`, and `accountBindingAssurance`.
+Strict-all verification rejects any missing, duplicated, unknown, reordered, failed, or
+policy-mismatched exchange. Partial mode applies the same checks to every endpoint in the
+exact signed subset and validates that subset against the registry's full proof plan.
 
 ### Tier and activation gate
 

package/android/build.gradle

@@ -4,13 +4,13 @@ plugins {
 }
 
 group = 'expo.modules.satyaattest'
-version = '3.0.0'
+version = '3.1.0'
 
 android {
   namespace "expo.modules.satyaattest"
   defaultConfig {
     versionCode 1
-    versionName "3.0.0"
+    versionName "3.1.0"
     // StrongBox key attestation needs API 28+; basic Keystore attestation API 24+.
     minSdkVersion 24
   }

package/android/src/main/java/expo/modules/satyaattest/SatyaAttestModule.kt

@@ -40,8 +40,11 @@ import java.security.spec.ECGenParameterSpec
 import java.security.cert.X509Certificate
 import java.security.KeyStore
 import java.net.URL
+import java.io.IOException
 import java.util.concurrent.TimeUnit
 import javax.net.ssl.SSLContext
+import javax.net.ssl.SSLHandshakeException
+import javax.net.ssl.SSLPeerUnverifiedException
 import javax.net.ssl.TrustManager
 import javax.net.ssl.TrustManagerFactory
 import javax.net.ssl.X509TrustManager
@@ -78,6 +81,9 @@ private const val PLAY_INTEGRITY_COMPOSITE_BIND_DOMAIN = "satya-w-playintegrity-
 
 class SatyaAttestModule : Module() {
   private data class BoundedResponseBody(val bytes: ByteArray, val text: String)
+  private data class PartialEndpointSelection(
+    val endpointIds: List<String>,
+  )
 
   @Volatile private var transportConfigJson: String = "{}"
 
@@ -184,13 +190,20 @@ class SatyaAttestModule : Module() {
     // exchanges in one attested session, then bind them together with a
     // device-bound proof challenge. Mirrors attestNativeReplay's shape.
     AsyncFunction("attestNativeReplayBundle") {
-      providerTemplateJson: String, capturedRequestsJson: String, promise: Promise ->
+      providerTemplateJson: String,
+      capturedRequestsJson: String,
+      partialEndpointSelectionJson: String?,
+      promise: Promise ->
       try {
         require(providerTemplateJson.isNotEmpty()) {
           "attestNativeReplayBundle requires provider template JSON"
         }
         val replayBundleJson =
-          buildCompositeReplayBundle(providerTemplateJson, capturedRequestsJson)
+          buildCompositeReplayBundle(
+            providerTemplateJson,
+            capturedRequestsJson,
+            partialEndpointSelectionJson,
+          )
         // Prepare fixes the session id / nonce / issuance window and returns the
         // exact proof challenge the platform attestation must bind to.
         val preparedJson = prepareNativeReplayBundle(replayBundleJson)
@@ -480,6 +493,7 @@ class SatyaAttestModule : Module() {
   private fun buildCompositeReplayBundle(
     providerTemplateJson: String,
     capturedRequestsJson: String,
+    partialEndpointSelectionJson: String?,
   ): String {
     val template = JSONObject(providerTemplateJson)
     val providerId = template.getString("providerId")
@@ -536,12 +550,23 @@ class SatyaAttestModule : Module() {
       )
     }
 
-    // Trusted-order resolution; throws for missing/extra BEFORE any network.
+    val partialSelection = compositePartialEndpointSelection(partialEndpointSelectionJson)
+    require(partialSelection == null || configuredAppId() != null) {
+      "partial-endpoint replay requires a configured appId"
+    }
+
+    // The SDK may opt this provider into partial completion. Without an
+    // explicit selection, strict-all requires the complete proof plan.
+    val effectiveEndpointIds = CompositeCompletion.effectiveEndpointIds(
+      planEndpointIds = planEndpointIds,
+      capturedEndpointIds = capturedRequests.keys,
+      partialEndpointIds = partialSelection?.endpointIds,
+    )
     val orderedRequests =
-      CompositeReplayPlan(proofPlanId, planEndpointIds).orderedRequests(capturedRequests)
+      CompositeReplayPlan(proofPlanId, effectiveEndpointIds).orderedRequests(capturedRequests)
 
     // Seed the proof-local jar for every governed replay path.
-    val cookieSeedUrls = planEndpointIds.map { endpointId ->
+    val cookieSeedUrls = effectiveEndpointIds.map { endpointId ->
       val endpoint = endpointsById[endpointId]
         ?: error("composite plan endpoint has no template config: $endpointId")
       val templateUrl = endpoint.optString("url").trim()
@@ -568,9 +593,10 @@ class SatyaAttestModule : Module() {
       "composite replay start plan=$proofPlanId endpoints=${orderedRequests.size}",
     )
     var totalResponseBytes = 0L
-    val observations =
-      try {
-        CompositeOrchestration.replaySequentially(orderedRequests) { exchangeRequest ->
+    val observations = ArrayList<CompositeExchangeObservation>(orderedRequests.size)
+    try {
+      for (exchangeRequest in orderedRequests) {
+        try {
           val endpoint = endpointsById[exchangeRequest.endpointId]
             ?: error("composite plan endpoint has no template config: ${exchangeRequest.endpointId}")
           val observation = replayCompositeExchange(
@@ -589,18 +615,33 @@ class SatyaAttestModule : Module() {
           )
           totalResponseBytes =
             CompositeByteBudget.accumulate(totalResponseBytes, observation.responseByteCount)
-          observation
+          observations.add(observation)
+        } catch (t: PartialEndpointUnavailableException) {
+          if (partialSelection == null) throw t
+          Log.i("SatyaComposite", "omitting unavailable endpoint ${exchangeRequest.endpointId}")
         }
-      } catch (t: Throwable) {
-        // Any failed exchange aborts the bundle.
-        Log.e("SatyaComposite", "composite replay ABORTED plan=$proofPlanId: ${t.message}")
-        throw t
       }
+    } catch (t: Throwable) {
+      Log.e("SatyaComposite", "composite replay ABORTED plan=$proofPlanId: ${t.message}")
+      throw t
+    }
     val completedAtUtc = iso8601UtcNow()
     val elapsedMs = SystemClock.elapsedRealtime() - startedAtMonotonicMs
-    if (maxDurationMs > 0 && elapsedMs > maxDurationMs) {
+    if (partialSelection == null && maxDurationMs > 0 && elapsedMs > maxDurationMs) {
       error("composite replay exceeded plan maxDurationMs ($elapsedMs > $maxDurationMs)")
     }
+    require(observations.isNotEmpty()) {
+      "partial-endpoint replay requires at least one successful endpoint"
+    }
+    val completedEndpointIds = observations.map { it.endpointId }.toSet()
+    if (observations.size < planEndpointIds.size && accountBinding.optString("mode") == "claim-equality") {
+      val references = accountBinding.optJSONArray("claimReferences") ?: JSONArray()
+      for (index in 0 until references.length()) {
+        require(completedEndpointIds.contains(references.getJSONObject(index).getString("endpointId"))) {
+          "partial-endpoint replay omitted an account-binding endpoint"
+        }
+      }
+    }
     Log.i(
       "SatyaComposite",
       "composite replay complete plan=$proofPlanId exchanges=${observations.size} bytes=$totalResponseBytes",
@@ -613,10 +654,14 @@ class SatyaAttestModule : Module() {
       put("providerId", providerId)
       put("policyHash", policyHash)
       put("proofPlanId", proofPlanId)
-      put("endpointIds", JSONArray(planEndpointIds))
+      // Exact replay set, bound by the signed statement and verifier.
+      put("endpointIds", JSONArray(observations.map { it.endpointId }))
+      if (observations.size < planEndpointIds.size) {
+        put("completionMode", "partial-endpoint-subset")
+      }
       put("accountBinding", accountBinding)
       put("startedAtUtc", startedAtUtc)
-      put("completedAtUtc", completedAtUtc)
+      put("completedAtUtc", observations.lastOrNull()?.completedAtUtc ?: completedAtUtc)
       put("maxDurationMs", maxDurationMs)
       put("totalResponseBytes", totalResponseBytes)
       put("exchanges", exchangesJson)
@@ -716,18 +761,36 @@ class SatyaAttestModule : Module() {
     requestBuilder.method(method, body)
 
     val remainingMs = deadlineAtMonotonicMs - SystemClock.elapsedRealtime()
-    require(remainingMs > 0) {
-      "composite replay exceeded plan maxDurationMs before ${exchangeRequest.endpointId}"
+    if (remainingMs <= 0) {
+      throw PartialEndpointUnavailableException(
+        "composite replay exceeded plan maxDurationMs before ${exchangeRequest.endpointId}",
+      )
     }
     Log.i("SatyaComposite", "replaying endpoint ${exchangeRequest.endpointId}")
     val call = client.newCall(requestBuilder.build())
     call.timeout().timeout(minOf(remainingMs, 45_000L), TimeUnit.MILLISECONDS)
-    call.execute().use { response ->
-      require(SystemClock.elapsedRealtime() <= deadlineAtMonotonicMs) {
-        "composite replay exceeded plan maxDurationMs during ${exchangeRequest.endpointId}"
+    val response = try {
+      call.execute()
+    } catch (t: SSLPeerUnverifiedException) {
+      throw t
+    } catch (t: SSLHandshakeException) {
+      throw t
+    } catch (t: IOException) {
+      throw PartialEndpointUnavailableException(
+        "composite replay transport unavailable: ${exchangeRequest.endpointId}",
+        t,
+      )
+    }
+    response.use {
+      if (SystemClock.elapsedRealtime() > deadlineAtMonotonicMs) {
+        throw PartialEndpointUnavailableException(
+          "composite replay exceeded plan maxDurationMs during ${exchangeRequest.endpointId}",
+        )
       }
-      require(response.code in 200..299) {
-        "composite replay returned HTTP ${response.code}: ${exchangeRequest.endpointId}"
+      if (response.code !in 200..299) {
+        throw PartialEndpointUnavailableException(
+          "composite replay returned HTTP ${response.code}: ${exchangeRequest.endpointId}",
+        )
       }
       require(response.request.url.host == expectedSni) {
         "composite replay final host does not match expectedSni: ${exchangeRequest.endpointId}"
@@ -765,8 +828,10 @@ class SatyaAttestModule : Module() {
           value = claim.opt("value"),
         )
       }
-      require(claims.isNotEmpty()) {
-        "composite replay response had no allowed claim value: ${exchangeRequest.endpointId}"
+      if (claims.isEmpty()) {
+        throw PartialEndpointUnavailableException(
+          "composite replay response had no allowed claim value: ${exchangeRequest.endpointId}",
+        )
       }
       Log.i("SatyaComposite", "endpoint ${exchangeRequest.endpointId} replayed bytes=$byteCount")
 
@@ -863,6 +928,20 @@ class SatyaAttestModule : Module() {
     }
   }
 
+  /** Validates the untrusted SDK-to-native partial-mode selection. */
+  private fun compositePartialEndpointSelection(
+    rawJson: String?,
+  ): PartialEndpointSelection? {
+    if (rawJson.isNullOrBlank()) return null
+    val selection = JSONObject(rawJson)
+    require(selection.getString("mode") == "partial-endpoint-subset") {
+      "partial endpoint selection mode is invalid"
+    }
+    val endpointIds = stringList(selection.optJSONArray("endpointIds"))
+    require(endpointIds.isNotEmpty()) { "partial endpoint selection must not be empty" }
+    return PartialEndpointSelection(endpointIds = endpointIds)
+  }
+
   private fun compositeRevealRules(endpoint: JSONObject): JSONArray {
     val rules = endpoint.optJSONArray("revealRules") ?: JSONArray()
     val reveals = JSONArray()

package/android/src/main/java/expo/modules/satyaattest/SatyaCompositeReplay.kt

@@ -5,6 +5,10 @@ import okhttp3.CookieJar
 import okhttp3.HttpUrl
 import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
 
+/** Availability/data failure that partial mode may omit without weakening TLS checks. */
+class PartialEndpointUnavailableException(message: String, cause: Throwable? = null) :
+  Exception(message, cause)
+
 // Pure, JVM-only types for the sequential composite (schema-v2) replay.
 //
 // This file deliberately imports ONLY okhttp3 (a plain JVM library) and the
@@ -89,6 +93,41 @@ class CompositeReplayPlan(
   }
 }
 
+/** Pure partial-endpoint resolution, unit-testable without the Expo runtime. */
+object CompositeCompletion {
+  /**
+   * Resolves an exact candidate replay set. No selection means strict-all.
+   * Partial mode may start with a subset or the full plan so native replay can
+   * sign only the successful endpoints.
+   */
+  fun effectiveEndpointIds(
+    planEndpointIds: List<String>,
+    capturedEndpointIds: Set<String>,
+    partialEndpointIds: List<String>?,
+  ): List<String> {
+    if (partialEndpointIds == null) {
+      require(capturedEndpointIds == planEndpointIds.toSet()) {
+        "strict-all replay requires every proof-plan endpoint"
+      }
+      return planEndpointIds
+    }
+    require(partialEndpointIds.isNotEmpty() && partialEndpointIds.size <= planEndpointIds.size) {
+      "selected endpoints must be a non-empty proof-plan subset"
+    }
+    val partialSet = partialEndpointIds.toSet()
+    require(partialSet.size == partialEndpointIds.size && partialEndpointIds.all(planEndpointIds.toSet()::contains)) {
+      "selected endpoints must be unique proof-plan endpoints"
+    }
+    require(partialEndpointIds == planEndpointIds.filter(partialSet::contains)) {
+      "selected endpoints must follow proof-plan order"
+    }
+    require(capturedEndpointIds == partialSet) {
+      "captured endpoints do not exactly match the selected subset"
+    }
+    return partialEndpointIds
+  }
+}
+
 /** Endpoint-scoped disclosed claim, mirroring the Rust `NativeReplayBundleClaim`. */
 data class CompositeClaim(
   val name: String,

package/build/SatyaAttestModule.d.ts

@@ -3,7 +3,7 @@ import { VerifyResult } from './types';
 declare class SatyaAttestModule extends NativeModule<Record<string, never>> {
     satyaCoreVersion(): string;
     attestNativeReplay(providerTemplateJson: string, capturedRequestJson?: string | null): Promise<string>;
-    attestNativeReplayBundle(providerTemplateJson: string, capturedRequestsJson: string): Promise<string>;
+    attestNativeReplayBundle(providerTemplateJson: string, capturedRequestsJson: string, partialEndpointSelectionJson?: string | null): Promise<string>;
     verifyArtifact(artifactJson: string): Promise<boolean>;
     verifyArtifactDetailed(artifactJson: string): Promise<VerifyResult>;
     initialize(configJson: string): Promise<void>;

package/build/SatyaAttestModule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SatyaAttestModule.d.ts","sourceRoot":"","sources":["../src/SatyaAttestModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAuB,MAAM,MAAM,CAAC;AAEzD,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEvC,OAAO,OAAO,iBAAkB,SAAQ,YAAY,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACzE,gBAAgB,IAAI,MAAM;IAE1B,kBAAkB,CAChB,oBAAoB,EAAE,MAAM,EAC5B,mBAAmB,CAAC,EAAE,MAAM,GAAG,IAAI,GAClC,OAAO,CAAC,MAAM,CAAC;IAElB,wBAAwB,CACtB,oBAAoB,EAAE,MAAM,EAC5B,oBAAoB,EAAE,MAAM,GAC3B,OAAO,CAAC,MAAM,CAAC;IAElB,cAAc,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IACtD,sBAAsB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAEnE,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAC7C,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IACxB,iCAAiC,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;IAC3F,sBAAsB,CACpB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,OAAO,EAChB,kBAAkB,EAAE,OAAO,GAC1B,OAAO,CAAC,OAAO,CAAC;IACnB,qFAAqF;IACrF,wBAAwB,CAAC,CAAC,SAAS,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAC/D,iBAAiB,IAAI,OAAO,CAAC,OAAO,CAAC;CACtC;;AAED,wBAAqE"}
+{"version":3,"file":"SatyaAttestModule.d.ts","sourceRoot":"","sources":["../src/SatyaAttestModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAuB,MAAM,MAAM,CAAC;AAEzD,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEvC,OAAO,OAAO,iBAAkB,SAAQ,YAAY,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACzE,gBAAgB,IAAI,MAAM;IAE1B,kBAAkB,CAChB,oBAAoB,EAAE,MAAM,EAC5B,mBAAmB,CAAC,EAAE,MAAM,GAAG,IAAI,GAClC,OAAO,CAAC,MAAM,CAAC;IAElB,wBAAwB,CACtB,oBAAoB,EAAE,MAAM,EAC5B,oBAAoB,EAAE,MAAM,EAC5B,4BAA4B,CAAC,EAAE,MAAM,GAAG,IAAI,GAC3C,OAAO,CAAC,MAAM,CAAC;IAElB,cAAc,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IACtD,sBAAsB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAEnE,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAC7C,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IACxB,iCAAiC,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;IAC3F,sBAAsB,CACpB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,OAAO,EAChB,kBAAkB,EAAE,OAAO,GAC1B,OAAO,CAAC,OAAO,CAAC;IACnB,qFAAqF;IACrF,wBAAwB,CAAC,CAAC,SAAS,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAC/D,iBAAiB,IAAI,OAAO,CAAC,OAAO,CAAC;CACtC;;AAED,wBAAqE"}

package/build/SatyaAttestModule.js.map

@@ -1 +1 @@
-{"version":3,"file":"SatyaAttestModule.js","sourceRoot":"","sources":["../src/SatyaAttestModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,mBAAmB,EAAE,MAAM,MAAM,CAAC;AAiCzD,eAAe,mBAAmB,CAAoB,aAAa,CAAC,CAAC","sourcesContent":["import { NativeModule, requireNativeModule } from 'expo';\n\nimport { VerifyResult } from './types';\n\ndeclare class SatyaAttestModule extends NativeModule<Record<string, never>> {\n  satyaCoreVersion(): string;\n\n  attestNativeReplay(\n    providerTemplateJson: string,\n    capturedRequestJson?: string | null\n  ): Promise<string>;\n\n  attestNativeReplayBundle(\n    providerTemplateJson: string,\n    capturedRequestsJson: string\n  ): Promise<string>;\n\n  verifyArtifact(artifactJson: string): Promise<boolean>;\n  verifyArtifactDetailed(artifactJson: string): Promise<VerifyResult>;\n\n  initialize(configJson: string): Promise<void>;\n  dispose(): Promise<void>;\n  installWebViewDocumentStartScript(viewTag: number, script: string): Promise<boolean | null>;\n  setPopupWindowsEnabled(\n    viewTag: number,\n    enabled: boolean,\n    geolocationEnabled: boolean\n  ): Promise<boolean>;\n  /** Optional for compatibility with native binaries predating privacy concealment. */\n  setPopupWindowsConcealed?(concealed: boolean): Promise<boolean>;\n  closePopupWindows(): Promise<boolean>;\n}\n\nexport default requireNativeModule<SatyaAttestModule>('SatyaAttest');\n"]}
+{"version":3,"file":"SatyaAttestModule.js","sourceRoot":"","sources":["../src/SatyaAttestModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,mBAAmB,EAAE,MAAM,MAAM,CAAC;AAkCzD,eAAe,mBAAmB,CAAoB,aAAa,CAAC,CAAC","sourcesContent":["import { NativeModule, requireNativeModule } from 'expo';\n\nimport { VerifyResult } from './types';\n\ndeclare class SatyaAttestModule extends NativeModule<Record<string, never>> {\n  satyaCoreVersion(): string;\n\n  attestNativeReplay(\n    providerTemplateJson: string,\n    capturedRequestJson?: string | null\n  ): Promise<string>;\n\n  attestNativeReplayBundle(\n    providerTemplateJson: string,\n    capturedRequestsJson: string,\n    partialEndpointSelectionJson?: string | null\n  ): Promise<string>;\n\n  verifyArtifact(artifactJson: string): Promise<boolean>;\n  verifyArtifactDetailed(artifactJson: string): Promise<VerifyResult>;\n\n  initialize(configJson: string): Promise<void>;\n  dispose(): Promise<void>;\n  installWebViewDocumentStartScript(viewTag: number, script: string): Promise<boolean | null>;\n  setPopupWindowsEnabled(\n    viewTag: number,\n    enabled: boolean,\n    geolocationEnabled: boolean\n  ): Promise<boolean>;\n  /** Optional for compatibility with native binaries predating privacy concealment. */\n  setPopupWindowsConcealed?(concealed: boolean): Promise<boolean>;\n  closePopupWindows(): Promise<boolean>;\n}\n\nexport default requireNativeModule<SatyaAttestModule>('SatyaAttest');\n"]}

package/build/SatyaAttestModule.web.d.ts

@@ -3,7 +3,7 @@ import { VerifyResult } from './types';
 declare class SatyaAttestModule extends NativeModule<Record<string, never>> {
     satyaCoreVersion(): string;
     attestNativeReplay(_providerTemplateJson: string, _capturedRequestJson?: string | null): Promise<string>;
-    attestNativeReplayBundle(_providerTemplateJson: string, _capturedRequestsJson: string): Promise<string>;
+    attestNativeReplayBundle(_providerTemplateJson: string, _capturedRequestsJson: string, _partialEndpointSelectionJson?: string | null): Promise<string>;
     verifyArtifact(_artifactJson: string): Promise<boolean>;
     verifyArtifactDetailed(_artifactJson: string): Promise<VerifyResult>;
     initialize(_configJson: string): Promise<void>;

package/build/SatyaAttestModule.web.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SatyaAttestModule.web.d.ts","sourceRoot":"","sources":["../src/SatyaAttestModule.web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,YAAY,EAAE,MAAM,MAAM,CAAC;AAEvD,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAMvC,cAAM,iBAAkB,SAAQ,YAAY,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACjE,gBAAgB,IAAI,MAAM;IAGpB,kBAAkB,CACtB,qBAAqB,EAAE,MAAM,EAC7B,oBAAoB,CAAC,EAAE,MAAM,GAAG,IAAI,GACnC,OAAO,CAAC,MAAM,CAAC;IAGZ,wBAAwB,CAC5B,qBAAqB,EAAE,MAAM,EAC7B,qBAAqB,EAAE,MAAM,GAC5B,OAAO,CAAC,MAAM,CAAC;IAGZ,cAAc,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAGvD,sBAAsB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAGpE,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAG9C,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAG/B;;AAMD,wBAAyE"}
+{"version":3,"file":"SatyaAttestModule.web.d.ts","sourceRoot":"","sources":["../src/SatyaAttestModule.web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,YAAY,EAAE,MAAM,MAAM,CAAC;AAEvD,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAMvC,cAAM,iBAAkB,SAAQ,YAAY,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACjE,gBAAgB,IAAI,MAAM;IAGpB,kBAAkB,CACtB,qBAAqB,EAAE,MAAM,EAC7B,oBAAoB,CAAC,EAAE,MAAM,GAAG,IAAI,GACnC,OAAO,CAAC,MAAM,CAAC;IAGZ,wBAAwB,CAC5B,qBAAqB,EAAE,MAAM,EAC7B,qBAAqB,EAAE,MAAM,EAC7B,6BAA6B,CAAC,EAAE,MAAM,GAAG,IAAI,GAC5C,OAAO,CAAC,MAAM,CAAC;IAGZ,cAAc,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAGvD,sBAAsB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAGpE,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAG9C,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAG/B;;AAMD,wBAAyE"}

package/build/SatyaAttestModule.web.js

@@ -8,7 +8,7 @@ class SatyaAttestModule extends NativeModule {
     async attestNativeReplay(_providerTemplateJson, _capturedRequestJson) {
         throw unsupportedPlatformError();
     }
-    async attestNativeReplayBundle(_providerTemplateJson, _capturedRequestsJson) {
+    async attestNativeReplayBundle(_providerTemplateJson, _capturedRequestsJson, _partialEndpointSelectionJson) {
         throw unsupportedPlatformError();
     }
     async verifyArtifact(_artifactJson) {

package/build/SatyaAttestModule.web.js.map

@@ -1 +1 @@
-{"version":3,"file":"SatyaAttestModule.web.js","sourceRoot":"","sources":["../src/SatyaAttestModule.web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAGvD,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEjE,MAAM,WAAW,GACf,uFAAuF,CAAC;AAE1F,MAAM,iBAAkB,SAAQ,YAAmC;IACjE,gBAAgB;QACd,MAAM,wBAAwB,EAAE,CAAC;IACnC,CAAC;IACD,KAAK,CAAC,kBAAkB,CACtB,qBAA6B,EAC7B,oBAAoC;QAEpC,MAAM,wBAAwB,EAAE,CAAC;IACnC,CAAC;IACD,KAAK,CAAC,wBAAwB,CAC5B,qBAA6B,EAC7B,qBAA6B;QAE7B,MAAM,wBAAwB,EAAE,CAAC;IACnC,CAAC;IACD,KAAK,CAAC,cAAc,CAAC,aAAqB;QACxC,MAAM,wBAAwB,EAAE,CAAC;IACnC,CAAC;IACD,KAAK,CAAC,sBAAsB,CAAC,aAAqB;QAChD,MAAM,wBAAwB,EAAE,CAAC;IACnC,CAAC;IACD,KAAK,CAAC,UAAU,CAAC,WAAmB;QAClC,MAAM,wBAAwB,EAAE,CAAC;IACnC,CAAC;IACD,KAAK,CAAC,OAAO;QACX,MAAM,wBAAwB,EAAE,CAAC;IACnC,CAAC;CACF;AAED,SAAS,wBAAwB;IAC/B,MAAM,UAAU,CAAC,cAAc,CAAC,oBAAoB,EAAE,WAAW,CAAC,CAAC;AACrE,CAAC;AAED,eAAe,iBAAiB,CAAC,iBAAiB,EAAE,mBAAmB,CAAC,CAAC","sourcesContent":["import { registerWebModule, NativeModule } from 'expo';\n\nimport { VerifyResult } from './types';\nimport { SatyaErrorCode, satyaError } from './types/error.types';\n\nconst UNSUPPORTED =\n  'expo-satya-attest is not available on web (it requires native App Attest / Keystore).';\n\nclass SatyaAttestModule extends NativeModule<Record<string, never>> {\n  satyaCoreVersion(): string {\n    throw unsupportedPlatformError();\n  }\n  async attestNativeReplay(\n    _providerTemplateJson: string,\n    _capturedRequestJson?: string | null\n  ): Promise<string> {\n    throw unsupportedPlatformError();\n  }\n  async attestNativeReplayBundle(\n    _providerTemplateJson: string,\n    _capturedRequestsJson: string\n  ): Promise<string> {\n    throw unsupportedPlatformError();\n  }\n  async verifyArtifact(_artifactJson: string): Promise<boolean> {\n    throw unsupportedPlatformError();\n  }\n  async verifyArtifactDetailed(_artifactJson: string): Promise<VerifyResult> {\n    throw unsupportedPlatformError();\n  }\n  async initialize(_configJson: string): Promise<void> {\n    throw unsupportedPlatformError();\n  }\n  async dispose(): Promise<void> {\n    throw unsupportedPlatformError();\n  }\n}\n\nfunction unsupportedPlatformError(): never {\n  throw satyaError(SatyaErrorCode.UNSUPPORTED_PLATFORM, UNSUPPORTED);\n}\n\nexport default registerWebModule(SatyaAttestModule, 'SatyaAttestModule');\n"]}
+{"version":3,"file":"SatyaAttestModule.web.js","sourceRoot":"","sources":["../src/SatyaAttestModule.web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAGvD,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEjE,MAAM,WAAW,GACf,uFAAuF,CAAC;AAE1F,MAAM,iBAAkB,SAAQ,YAAmC;IACjE,gBAAgB;QACd,MAAM,wBAAwB,EAAE,CAAC;IACnC,CAAC;IACD,KAAK,CAAC,kBAAkB,CACtB,qBAA6B,EAC7B,oBAAoC;QAEpC,MAAM,wBAAwB,EAAE,CAAC;IACnC,CAAC;IACD,KAAK,CAAC,wBAAwB,CAC5B,qBAA6B,EAC7B,qBAA6B,EAC7B,6BAA6C;QAE7C,MAAM,wBAAwB,EAAE,CAAC;IACnC,CAAC;IACD,KAAK,CAAC,cAAc,CAAC,aAAqB;QACxC,MAAM,wBAAwB,EAAE,CAAC;IACnC,CAAC;IACD,KAAK,CAAC,sBAAsB,CAAC,aAAqB;QAChD,MAAM,wBAAwB,EAAE,CAAC;IACnC,CAAC;IACD,KAAK,CAAC,UAAU,CAAC,WAAmB;QAClC,MAAM,wBAAwB,EAAE,CAAC;IACnC,CAAC;IACD,KAAK,CAAC,OAAO;QACX,MAAM,wBAAwB,EAAE,CAAC;IACnC,CAAC;CACF;AAED,SAAS,wBAAwB;IAC/B,MAAM,UAAU,CAAC,cAAc,CAAC,oBAAoB,EAAE,WAAW,CAAC,CAAC;AACrE,CAAC;AAED,eAAe,iBAAiB,CAAC,iBAAiB,EAAE,mBAAmB,CAAC,CAAC","sourcesContent":["import { registerWebModule, NativeModule } from 'expo';\n\nimport { VerifyResult } from './types';\nimport { SatyaErrorCode, satyaError } from './types/error.types';\n\nconst UNSUPPORTED =\n  'expo-satya-attest is not available on web (it requires native App Attest / Keystore).';\n\nclass SatyaAttestModule extends NativeModule<Record<string, never>> {\n  satyaCoreVersion(): string {\n    throw unsupportedPlatformError();\n  }\n  async attestNativeReplay(\n    _providerTemplateJson: string,\n    _capturedRequestJson?: string | null\n  ): Promise<string> {\n    throw unsupportedPlatformError();\n  }\n  async attestNativeReplayBundle(\n    _providerTemplateJson: string,\n    _capturedRequestsJson: string,\n    _partialEndpointSelectionJson?: string | null\n  ): Promise<string> {\n    throw unsupportedPlatformError();\n  }\n  async verifyArtifact(_artifactJson: string): Promise<boolean> {\n    throw unsupportedPlatformError();\n  }\n  async verifyArtifactDetailed(_artifactJson: string): Promise<VerifyResult> {\n    throw unsupportedPlatformError();\n  }\n  async initialize(_configJson: string): Promise<void> {\n    throw unsupportedPlatformError();\n  }\n  async dispose(): Promise<void> {\n    throw unsupportedPlatformError();\n  }\n}\n\nfunction unsupportedPlatformError(): never {\n  throw satyaError(SatyaErrorCode.UNSUPPORTED_PLATFORM, UNSUPPORTED);\n}\n\nexport default registerWebModule(SatyaAttestModule, 'SatyaAttestModule');\n"]}