@debugbundle/sdk-react-native 3.0.0 → 3.1.0

package/CHANGELOG.md

@@ -4,6 +4,29 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+### 3.1.0 — 2026-11-01
+
+- Reuse bounded custom privacy patterns and sensitive-key lookups within each
+  protection operation, preserving literal matching and caller-policy isolation.
+- Add complete-path evidence capabilities, bounded structured JS errors,
+  synchronous operation scopes, and opt-in explicit recovery observations.
+- Forward evidence options and native proof through the existing Android and iOS
+  bridges, with Android 3.1.0 and Swift 3.1.1 or later in the compatible 3.x line.
+- Require the Swift native deadline fix so cancellation does not wait for a late URLSession callback.
+- Validate owned before-send replacements against the complete canonical event
+  contract, retain allowed event/SDK metadata changes, and repeat privacy and
+  bounded association checks before native handoff.
+- Preserve native device hydration, reject unsafe error getters and recursive
+  causes, and document unavailable engine evidence without inventing locations.
+- Keep fatal JS evidence smaller and bypass application hooks on that path.
+
+## [3.0.1] - 2026-09-26
+
+### Fixed
+
+- Adopt Android 3.0.1 and require Swift 3.0.1 or later in the compatible 3.x line, bringing the native acknowledgement and bounded retry repairs into React Native installs. The TypeScript facade and native bridge APIs are unchanged.
+- Align embedded SDK versions and published-consumer pins with the patch release, and refresh native release and persistence guidance.
+
 ## [3.0.0] - 2026-09-25
 
 ### Changed

package/DebugBundleReactNative.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name         = "DebugBundleReactNative"
-  s.version      = "3.0.0"
+  s.version      = "3.1.0"
   s.summary      = "React Native wrapper for the DebugBundle mobile SDKs."
   s.license      = { :type => "Apache-2.0", :file => "LICENSE" }
   s.author       = { "DebugBundle" => "support@debugbundle.com" }
@@ -12,5 +12,5 @@ Pod::Spec.new do |s|
 
   s.dependency "React-Core"
   install_modules_dependencies(s) if defined?(install_modules_dependencies)
-  s.dependency "DebugBundle", "~> 3.0"
+  s.dependency "DebugBundle", "~> 3.0", ">= 3.1.1"
 end

package/MIGRATION-3.1.md

@@ -0,0 +1,116 @@
+# React Native 3.1 candidate
+
+Version 3.1.0 is an unpublished candidate. Rebuild the native binary with the
+coordinated Android 3.1.0 and Swift 3.1.0 foundations before enabling the new
+evidence options. Existing capture methods and their return values are unchanged.
+An older native binary keeps ordinary error capture and disables unproven optional
+evidence. This document does not establish release or device qualification.
+
+The current iOS wrapper provides a bounded JSON-string carrier for canonical
+events. React Native's object conversion can remove nested nulls; the string
+carrier preserves required nullable stack, cause and device fields. Android's
+existing canonical map carrier preserves nested nulls and numeric values.
+The JavaScript client prefers the string method when present and retains both
+older canonical-object and legacy-native fallbacks. New methods are optional on
+the structural `DebugBundleClient` interface so existing custom implementations
+continue to typecheck; the returned concrete client and facade provide them.
+
+## Evidence and delivery proof
+
+`captureExceptionEvidence` defaults to true, but structured details are emitted
+only when the native bridge reports complete-path support. Set it to false to
+retain the ordinary outer error without structured details.
+`captureRecoveryObservations` defaults to false. Enable it explicitly to capture
+recovery observations. Native minimal policy or an explicit diagnostic disable
+still prevents them. These options do not depend on probes or analytics.
+
+The read-only `evidenceCapabilities` client/facade property reports the effective
+intersection of JS options, native support, and the verified downstream path.
+The optional configuration value with the same name pins a verified complete
+path: `{ version: 1, features: [...] }`. Supported features are
+`exception_evidence_v1`, `resource_observations_v1`, `recovery_v1`, and
+`evidence_provenance_v1`. Unknown versions, duplicate or unknown features, and
+extra descriptor fields disable support. A JS pin cannot make an old native
+bridge preserve new evidence. Native config refresh and ingestion acknowledgements
+carry proof; capture does not make a discovery request.
+
+## Explicit operation and recovery APIs
+
+Both the facade and instance client expose `beginOperation()`,
+`withOperationContext(callback)`, and `captureRecovery(observation)`.
+An operation returns `{ operationId, evidenceScope, close() }`. Close it in a
+`finally` block. Nested synchronous operations restore their parent; closing a
+parent revokes its children. Reinitialization revokes existing scopes.
+
+`withOperationContext` closes the implicit scope when the callback returns,
+including when it returns a promise. It does not provide asynchronous context
+propagation. Across `await`, retain the opaque `evidenceScope` value and pass it
+explicitly to each capture; do not leave an implicit scope open across unrelated
+tasks. At most 32 implicit scopes can nest.
+
+```ts
+const client = createDebugBundleClient({
+  projectToken: "YOUR_PROJECT_TOKEN",
+  captureRecoveryObservations: true,
+});
+const operation = client.beginOperation();
+const evidenceScope = operation.evidenceScope;
+operation.close(); // Use explicit ownership across asynchronous application work.
+const failureRef = createApplicationUuidV4();
+const attemptId = createApplicationUuidV4();
+
+client.captureException(error, { failureRef, evidenceScope, session_id: sessionId });
+client.captureRecovery({
+  failureRef, evidenceScope, attemptId, state: "attempt_started",
+  operation: "reload", correlation: { session_id: sessionId },
+});
+// After the application's request completes:
+client.captureRecovery({
+  failureRef, evidenceScope, attemptId, state: "attempt_completed", statusCode: 200,
+  correlation: { session_id: sessionId },
+});
+// Send recovery_observed only after the application confirms semantic recovery.
+```
+
+Use your application's UUID v4 generator for each new failure and retry attempt;
+references must not contain user, URL, or resource identifiers. Correlation must
+match the original service, environment, scope, trace, and session. A page scope
+also requires a nonempty session; the string `"0"` is valid. Null trace only
+matches null trace. Recovery may arrive before the original failure, but its event
+time must be at or after that failure and no more than five minutes later.
+
+Recovery states are `attempt_started`, `attempt_completed`, `attempt_failed`,
+`recovery_observed`, and `failure_persisted`. HTTP 200 and attempt completion do
+not establish application recovery. Optional fields are `operation` (64 UTF-8
+bytes), `statusCode` (100–599), and finite nonnegative `durationMs`. There is no
+arbitrary data extension. These observations cannot change incident lifecycle.
+
+## Runtime limits and compatibility
+
+Hermes/JSC engines without native `Error.isError` retain the outer error and
+report cause traversal as unsupported. With that intrinsic, own native `cause`
+data properties can be followed; accessors and custom stack formatters are not
+invoked. Aggregate traversal remains unsupported because portable JS cannot prove
+that an aggregate array is free of proxy traps. Stack parsing supports V8, Hermes
+and JSC text and labels available traces `runtime_reported`; absent traces remain
+unavailable. No native throw-site trace is invented.
+
+Ordinary graphs use at most eight nodes, four causal edges in a path, 32 frames
+per node, and the shared 32-KiB combined addition limit. The JS fatal handler uses
+at most two nodes, eight total frames, and 4 KiB of combined additions and skips
+application `beforeSend`; it still calls the previously installed error handler.
+This does not add a process signal or native crash handler.
+
+Diagnostic accounting limits one SDK instance to 50 windows, five attempts and
+20 observations per failure, and 64 KiB of metadata plus pending observations.
+Pending bridge calls prevent expired windows from renewing. Native SDKs retain
+their own accounting during offline queue ownership. Dropped or acknowledged
+observations do not refund attempt/observation allowances.
+
+Existing 64-KiB bridge events and bounded native call queues remain enforced.
+Before-send callbacks may replace any valid canonical field, including event kind
+and SDK metadata. Invalid/throwing callbacks retain the protected original; valid
+oversized or unsafe replacements are withheld. Final privacy, capability, policy,
+scope and byte checks apply to the replacement. Unchanged JS device placeholders
+are hydrated by the native worker; explicitly replaced device metadata is retained.
+Older bridge methods remain available.

package/README.md

@@ -2,6 +2,11 @@
 
 React Native SDK for DebugBundle mobile apps.
 
+Version 3.1.0 adds proof-gated structured exception details and
+opt-in explicit recovery through both native bridges. See the
+[3.1 migration and API guide](MIGRATION-3.1.md) for options, operation scopes,
+recovery examples, runtime limitations, and coordinated native dependencies.
+
 This package targets iOS and Android React Native apps. It is a mobile direct-ingestion SDK, not a browser relay host: it does not provide CORS, `allowedOrigins`, `transportMode`, or `/debugbundle/browser` helpers.
 
 ## Status
@@ -142,8 +147,39 @@ checks.
 
 ## Release
 
-The package publishes to npm from `v*` tags through GitHub Actions. Configure an npm GitHub Actions trusted publisher for `debugbundle/debugbundle-react-native` and `release.yml`, with a blank environment and direct `npm publish` enabled. Publishing uses OIDC without a long-lived npm token. Make sure the tag matches `package.json` exactly. The next protected release requires a matching 2.x wrapper/Swift pod line and a published Android 2.x BOM/module pin. `make check-protected-native-pins` refuses the current 1.x source line; update the wrapper version, native pins, and embedded SDK versions together only after the exact Android and Swift artifacts are available to Maven Central and CocoaPods consumers. The release workflow then compiles and runs clean apps against those published artifacts on Android API 37 and Xcode 27 before npm publication.
+The package publishes to npm from `v*` tags through GitHub Actions. Configure an npm GitHub Actions trusted publisher for `debugbundle/debugbundle-react-native` and `release.yml`, with a blank environment and direct `npm publish` enabled. Publishing uses OIDC without a long-lived npm token. Make sure the tag matches `package.json` exactly. The 3.1.0 wrapper pins Android 3.1.0 and requires Swift 3.1.1 or later within the compatible 3.x CocoaPods line. `make check-protected-native-pins` checks the wrapper, native pins and embedded SDK versions together. Publish only after the exact Android and Swift artifacts are available and their published-consumer checks pass. The release workflow compiles and runs clean apps against those published artifacts on Android API 37 and Xcode 27 before npm publication.
 
-Probe and context native calls share the event bridge's pending count and byte limits, including reserved exception capacity. Saturated auxiliary calls are discarded without evaluating probe suppliers. Probe labels are limited to 128 characters. Persistent JS context retains at most 50 fields with keys up to 128 characters, and field-sensitive privacy runs before local retention and native handoff. Throwing capture context accessors are withheld without escaping into application code. These bounds do not move native SDK persistence off its caller thread.
+Probe and context native calls share the event bridge's pending count and byte limits, including reserved exception capacity. Saturated auxiliary calls are discarded without evaluating probe suppliers. Probe labels are limited to 128 characters. Persistent JS context retains at most 50 fields with keys up to 128 characters, and field-sensitive privacy runs before local retention and native handoff. Throwing capture context accessors are withheld without escaping into application code. The native 3.x SDKs perform queue persistence on their bounded background workers; abrupt process termination before persistence completes can lose admitted events.
 
 Version 3 defers optional `beforeSend` callbacks until capture returns. Callbacks run on the JavaScript event loop and must return promptly. Pending preparation and native delivery share bounded count/byte limits; valid expanded replacements may be dropped under pressure. See [the version3 migration guide](MIGRATION-3.0.md).
+
+## Probe checkpoint guidance
+
+Application instrumentation supplies probe labels and bounded data. Deploy a new
+checkpoint before activating it. Remote activation affects future matching calls
+when policy permits; it does not inject code or recover unretained measurements.
+Built-in runtime/error/device collectors keep their documented SDK settings.
+
+Use fixed labels and allowlisted technical states: `media.preview.checkpoint`
+(stage/input kind/attempt), `auth.session.checkpoint` (observed session presence
+and result), `job.dependency.checkpoint` (named dependency/attempt/result), or
+`cache.preview.checkpoint` (hit/miss/coarse age bucket). Omit customer identifiers,
+tokens/cookies, cache keys, URLs and raw payloads. HTTP 200 or attempt completion
+alone does not establish semantic recovery.
+
+Empty probe data means no matching retained observation for the selected sample
+window. It does not confirm activation delivery to every SDK or execution of a
+label. Check the deployed SDK/wrapper version, instrumentation, scope, expiry,
+policy, sampling and delivery receipts. See the [probe recipes](https://debugbundle.com/docs/probes#bounded-checkpoint-recipes).
+
+`make evidence-performance` compares 20 identical native JS error/recovery pairs
+with evidence disabled/enabled and an empty/full low-priority bridge queue. It uses
+built SDK modules, a held in-memory bridge, network-disabled Docker and Node/V8.
+Ordinary timing runs are separate from allocation-sampled runs; the latter retain
+major/minor-GC-collected samples and report estimated allocation, not exact byte
+counts. Heap deltas, SDK-owned bytes and diagnostic budgets are reported separately.
+Setup and error creation are excluded; all original failures, two-node causes and
+queue release are checked. The [V8 protocol](https://raw.githubusercontent.com/ChromeDevTools/devtools-protocol/master/json/js_protocol.json)
+defines sampling semantics. These facade measurements do not establish Hermes,
+Android ART or actual native bridge performance; the native qualification lanes
+remain separate.

package/android/build.gradle

@@ -11,7 +11,7 @@ if (isReactNativeHostBuild) {
 def hostKotlinVersion = rootProject.ext.has("kotlinVersion")
   ? rootProject.ext.get("kotlinVersion")
   : "2.1.20"
-def debugBundleAndroidVersion = rootProject.findProperty("debugBundleAndroidVersion") ?: "3.0.0"
+def debugBundleAndroidVersion = rootProject.findProperty("debugBundleAndroidVersion") ?: "3.1.0"
 
 android {
   namespace "com.debugbundle.reactnative"

package/android/src/main/java/com/debugbundle/reactnative/DebugBundleReactNativeModule.java

@@ -3,6 +3,8 @@ package com.debugbundle.reactnative;
 import android.content.Context;
 import com.debugbundle.android.DebugBundle;
 import com.debugbundle.android.DebugBundleConfig;
+import com.debugbundle.android.DebugBundleEvidenceOptions;
+import com.debugbundle.android.DebugBundleEvidenceCapabilities;
 import com.debugbundle.android.DebugBundleLogLevel;
 import com.debugbundle.android.DebugBundleRequestInfo;
 import com.debugbundle.android.DebugBundleResponseInfo;
@@ -14,6 +16,7 @@ import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableArray;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -199,12 +202,12 @@ public final class DebugBundleReactNativeModule extends ReactContextBaseJavaModu
     }
   }
 
-  private String currentSdkVersion = "3.0.0";
+  private String currentSdkVersion = "3.1.0";
   private String currentService = "react-native-app";
   private String currentEnvironment = "production";
 
   private DebugBundleConfig createConfig(ReadableMap config) {
-    currentSdkVersion = stringOrDefault(config, "sdkVersion", "3.0.0");
+    currentSdkVersion = stringOrDefault(config, "sdkVersion", "3.1.0");
     currentService = stringOrDefault(config, "service", "react-native-app");
     currentEnvironment = stringOrDefault(config, "environment", "production");
     return DebugBundleConfig.create(
@@ -236,7 +239,10 @@ public final class DebugBundleReactNativeModule extends ReactContextBaseJavaModu
         intOrDefault(config, "maxProbeEntriesPerLabel", 10),
         booleanOrDefault(config, "probeFlushOnError", true),
         stringSet(config, "redactFields", Collections.emptySet()),
-        currentSdkVersion);
+        currentSdkVersion).withEvidenceOptions(new DebugBundleEvidenceOptions(
+            booleanOrDefault(config, "captureExceptionEvidence", true),
+            booleanOrDefault(config, "captureRecoveryObservations", false),
+            evidenceCapabilities(config)));
   }
 
   private WritableMap stateMap() {
@@ -250,6 +256,11 @@ public final class DebugBundleReactNativeModule extends ReactContextBaseJavaModu
     }
     state.putBoolean("nativeModuleAvailable", true);
     state.putNull("degradedReason");
+    DebugBundleEvidenceCapabilities proof = DebugBundleEvidenceCapabilities.normalize(nativeOperations.evidenceCapabilities());
+    WritableMap descriptor = writableMapFactory.create();
+    descriptor.putInt("version", proof.getVersion());
+    descriptor.putArray("features", writableMapFactory.array(proof.getFeatures()));
+    state.putMap("evidenceCapabilities", descriptor);
     return state;
   }
 
@@ -270,6 +281,22 @@ public final class DebugBundleReactNativeModule extends ReactContextBaseJavaModu
     return nested.toHashMap();
   }
 
+  private static DebugBundleEvidenceCapabilities evidenceCapabilities(ReadableMap config) {
+    if (!config.hasKey("evidenceCapabilities") || config.isNull("evidenceCapabilities")) return null;
+    Map<String, Object> descriptor = hashMap(config, "evidenceCapabilities");
+    if (descriptor.size() != 2 || !descriptor.containsKey("version") || !descriptor.containsKey("features") ||
+        !(descriptor.get("version") instanceof Number) || ((Number) descriptor.get("version")).doubleValue() != 1 ||
+        !(descriptor.get("features") instanceof List<?>)) return new DebugBundleEvidenceCapabilities();
+    List<?> raw = (List<?>) descriptor.get("features");
+    if (raw.size() > 4) return new DebugBundleEvidenceCapabilities();
+    List<String> features = new ArrayList<>();
+    for (Object value : raw) {
+      if (!(value instanceof String)) return new DebugBundleEvidenceCapabilities();
+      features.add((String) value);
+    }
+    return DebugBundleEvidenceCapabilities.normalize(new DebugBundleEvidenceCapabilities(1, features));
+  }
+
   private static String stringOrDefault(ReadableMap map, String key, String fallback) {
     if (!map.hasKey(key) || map.isNull(key)) {
       return fallback;
@@ -422,9 +449,11 @@ public final class DebugBundleReactNativeModule extends ReactContextBaseJavaModu
 
   interface WritableMapFactory {
     WritableMap create();
+    default WritableArray array(List<String> values) { return Arguments.fromList(values); }
   }
 
   interface NativeOperations {
+    default DebugBundleEvidenceCapabilities evidenceCapabilities() { return new DebugBundleEvidenceCapabilities(); }
     void initialize(Context context, DebugBundleConfig config);
 
     void captureException(Throwable error, Map<String, Object> context);
@@ -471,6 +500,8 @@ public final class DebugBundleReactNativeModule extends ReactContextBaseJavaModu
   }
 
   private static final class DefaultNativeOperations implements NativeOperations {
+    @Override
+    public DebugBundleEvidenceCapabilities evidenceCapabilities() { return DebugBundle.INSTANCE.getEvidenceCapabilities(); }
     @Override
     public void initialize(Context context, DebugBundleConfig config) {
       DebugBundle.init(context, config);

package/app.plugin.js

@@ -49,4 +49,4 @@ function withAndroidDesugaring(contents) {
   return next;
 }
 
-export default createRunOncePlugin(withDebugBundle, "@debugbundle/sdk-react-native", "3.0.0");
+export default createRunOncePlugin(withDebugBundle, "@debugbundle/sdk-react-native", "3.1.0");

package/dist/NativeDebugBundleReactNative.d.ts

@@ -3,6 +3,7 @@ import type { UnsafeObject } from "react-native/Libraries/Types/CodegenTypes";
 export interface Spec extends TurboModule {
     initialize(config: UnsafeObject): Promise<UnsafeObject>;
     enqueueCanonicalEvent?(event: UnsafeObject): Promise<boolean>;
+    enqueueCanonicalEventJson?(event: string): Promise<boolean>;
     enqueueEvent(event: UnsafeObject): Promise<void>;
     captureProbe?(label: string, data: UnsafeObject, occurredAt: string): Promise<boolean>;
     isProbeActive?(label: string): boolean;

package/dist/NativeDebugBundleReactNative.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NativeDebugBundleReactNative.d.ts","sourceRoot":"","sources":["../src/NativeDebugBundleReactNative.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2CAA2C,CAAC;AAG9E,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,UAAU,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IACxD,qBAAqB,CAAC,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC9D,YAAY,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjD,YAAY,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACvF,aAAa,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;IACvC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,SAAS,IAAI,OAAO,CAAC,YAAY,CAAC,CAAC;IACnC,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5D,eAAe,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClE,yBAAyB,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC7D;;AAED,wBAAgF"}
+{"version":3,"file":"NativeDebugBundleReactNative.d.ts","sourceRoot":"","sources":["../src/NativeDebugBundleReactNative.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2CAA2C,CAAC;AAG9E,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,UAAU,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IACxD,qBAAqB,CAAC,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC9D,yBAAyB,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC5D,YAAY,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjD,YAAY,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACvF,aAAa,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;IACvC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,SAAS,IAAI,OAAO,CAAC,YAAY,CAAC,CAAC;IACnC,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5D,eAAe,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClE,yBAAyB,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC7D;;AAED,wBAAgF"}

package/dist/before-send.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"before-send.d.ts","sourceRoot":"","sources":["../src/before-send.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AA2ClF,wBAAgB,eAAe,CAC7B,KAAK,EAAE,wBAAwB,EAC/B,IAAI,EAAE,qBAAqB,GAAG,IAAI,GACjC,wBAAwB,GAAG,IAAI,CAmBjC"}
+{"version":3,"file":"before-send.d.ts","sourceRoot":"","sources":["../src/before-send.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAIlF,wBAAgB,eAAe,CAAC,KAAK,EAAE,wBAAwB,EAAE,IAAI,EAAE,qBAAqB,GAAG,IAAI,GAAG,wBAAwB,GAAG,IAAI,CASpI"}

package/dist/before-send.js

@@ -1,142 +1,20 @@
-const ROOT_KEYS = new Set([
-    "schema_version",
-    "event_id",
-    "event_type",
-    "sdk_name",
-    "sdk_version",
-    "service",
-    "occurred_at",
-    "correlation",
-    "context",
-    "payload"
-]);
-const REQUIRED_PAYLOAD_FIELDS = {
-    frontend_exception: ["name", "message", "stack"],
-    frontend_breadcrumb: ["breadcrumb_type", "data"],
-    log_event: ["level", "message", "attributes"],
-    request_event: ["method", "path", "query", "headers", "response_status", "duration_ms"],
-    error_suppressed: ["fingerprint", "suppressed_count", "window_seconds", "first_seen", "last_seen"],
-    probe_event: ["label", "data", "activation_id", "probe_label_pattern"]
-};
-const ALLOWED_PAYLOAD_FIELDS = {
-    frontend_exception: new Set([
-        "name", "message", "stack", "route", "browser", "breadcrumbs", "device",
-        "browser_event", "rejection_reason", "dom_context", "probe_data"
-    ]),
-    frontend_breadcrumb: new Set(["breadcrumb_type", "route", "data", "device"]),
-    log_event: new Set(["level", "message", "attributes", "device"]),
-    request_event: new Set([
-        "method", "path", "query", "headers", "body", "response_status", "duration_ms",
-        "route_template", "response_headers", "response_body", "device"
-    ]),
-    error_suppressed: new Set([
-        "fingerprint", "suppressed_count", "window_seconds", "first_seen", "last_seen", "device"
-    ]),
-    probe_event: new Set(["label", "data", "activation_id", "probe_label_pattern", "device"])
-};
-const EVENT_TYPES = new Set(Object.keys(REQUIRED_PAYLOAD_FIELDS));
-const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+import { canonicalEvent } from "./evidence-wire.js";
+import { EventValidationUnavailable, ownJSON } from "./owned-json.js";
 export function applyBeforeSend(event, hook) {
-    if (!hook) {
+    if (!hook)
         return event;
-    }
     try {
-        const result = hook(cloneEvent(event));
-        // Hooks have synchronous return contracts. Contain mistaken async failures
-        // before treating their Promise as invalid and keeping the protected original.
+        const result = hook(JSON.parse(JSON.stringify(event)));
         if (result instanceof Promise) {
             void result.catch(() => undefined);
             return event;
         }
-        if (result === null) {
+        if (result === null)
             return null;
-        }
-        return isValidEvent(result) ? result : event;
+        const owned = ownJSON(result);
+        return canonicalEvent(owned) ? owned : event;
     }
-    catch {
-        return event;
-    }
-}
-function cloneEvent(event) {
-    return JSON.parse(JSON.stringify(event));
-}
-function isValidEvent(event) {
-    if (!isRecord(event) || !Object.keys(event).every((key) => ROOT_KEYS.has(key))) {
-        return false;
-    }
-    if (event.schema_version !== "2026-03-01" ||
-        !UUID_PATTERN.test(stringValue(event.event_id)) ||
-        !EVENT_TYPES.has(stringValue(event.event_type)) ||
-        event.sdk_name !== "@debugbundle/sdk-react-native" ||
-        !nonEmptyString(event.sdk_version) ||
-        !isIsoTimestamp(event.occurred_at) ||
-        !isRecord(event.service) ||
-        !nonEmptyString(event.service.name) ||
-        !nonEmptyString(event.service.environment) ||
-        event.service.runtime !== "react-native" ||
-        event.service.framework !== "react-native" ||
-        !isRecord(event.payload)) {
-        return false;
-    }
-    const eventType = event.event_type;
-    return (REQUIRED_PAYLOAD_FIELDS[eventType].every((field) => Object.prototype.hasOwnProperty.call(event.payload, field)) &&
-        Object.keys(event.payload).every((field) => ALLOWED_PAYLOAD_FIELDS[eventType].has(field)) &&
-        hasValidPayloadShape(eventType, event.payload));
-}
-function hasValidPayloadShape(eventType, payload) {
-    switch (eventType) {
-        case "frontend_exception":
-            return (hasNonEmptyStrings(payload, "name", "message", "stack") &&
-                (!("breadcrumbs" in payload) || Array.isArray(payload.breadcrumbs)) &&
-                optionalRecord(payload, "probe_data"));
-        case "frontend_breadcrumb":
-            return hasNonEmptyStrings(payload, "breadcrumb_type") && isRecord(payload.data);
-        case "log_event":
-            return hasNonEmptyStrings(payload, "level", "message") && isRecord(payload.attributes);
-        case "request_event":
-            return (hasNonEmptyStrings(payload, "method", "path") &&
-                isRecord(payload.query) &&
-                isRecord(payload.headers) &&
-                isNonNegativeNumber(payload.response_status) &&
-                isNonNegativeNumber(payload.duration_ms) &&
-                optionalRecord(payload, "response_headers"));
-        case "error_suppressed":
-            return (hasNonEmptyStrings(payload, "fingerprint") &&
-                isNonNegativeInteger(payload.suppressed_count) &&
-                isPositiveInteger(payload.window_seconds) &&
-                isIsoTimestamp(payload.first_seen) &&
-                isIsoTimestamp(payload.last_seen));
-        case "probe_event":
-            return (hasNonEmptyStrings(payload, "label", "probe_label_pattern") &&
-                isRecord(payload.data) &&
-                (payload.activation_id === null ||
-                    nonEmptyString(payload.activation_id) && UUID_PATTERN.test(payload.activation_id)));
+    catch (error) {
+        return error instanceof EventValidationUnavailable ? null : event;
     }
 }
-function hasNonEmptyStrings(payload, ...fields) {
-    return fields.every((field) => nonEmptyString(payload[field]));
-}
-function optionalRecord(payload, field) {
-    return !(field in payload) || isRecord(payload[field]);
-}
-function isNonNegativeNumber(value) {
-    return typeof value === "number" && Number.isFinite(value) && value >= 0;
-}
-function isNonNegativeInteger(value) {
-    return Number.isInteger(value) && value >= 0;
-}
-function isPositiveInteger(value) {
-    return Number.isInteger(value) && value > 0;
-}
-function isRecord(value) {
-    return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function nonEmptyString(value) {
-    return typeof value === "string" && value.trim().length > 0;
-}
-function stringValue(value) {
-    return typeof value === "string" ? value : "";
-}
-function isIsoTimestamp(value) {
-    return nonEmptyString(value) && Number.isFinite(Date.parse(value));
-}

package/dist/canonical-schema.d.ts

@@ -0,0 +1,15 @@
+import { type OwnedJSON } from "./owned-json.js";
+export declare function canonicalTimestamp(text: string): boolean;
+/** Small closed Draft-7 interpreter for the generated accepting contract. */
+export declare class CanonicalSchema {
+    private refs;
+    private patterns;
+    private root;
+    constructor(schema: unknown);
+    private resolve;
+    private compile;
+    accepts(value: OwnedJSON): boolean;
+    private matches;
+}
+export declare function canonicalShape(value: OwnedJSON): boolean;
+//# sourceMappingURL=canonical-schema.d.ts.map

package/dist/canonical-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical-schema.d.ts","sourceRoot":"","sources":["../src/canonical-schema.ts"],"names":[],"mappings":"AACA,OAAO,EAA0C,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAQzF,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAOxD;AAED,6EAA6E;AAC7E,qBAAa,eAAe;IAC1B,OAAO,CAAC,IAAI,CAAgC;IAC5C,OAAO,CAAC,QAAQ,CAA6B;IAC7C,OAAO,CAAC,IAAI,CAAY;gBACZ,MAAM,EAAE,OAAO;IAE3B,OAAO,CAAC,OAAO;IAcf,OAAO,CAAC,OAAO;IAaf,OAAO,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO;IAwClC,OAAO,CAAC,OAAO;CAQhB;AAID,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAGxD"}