@goliapkg/sentori-react-native 6.2.0 → 6.3.0

package/android/src/test/{java → java-core}/com/sentori/SentoriScreenshotCaptureTest.kt

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/test/java/com/sentori/SentoriScreenshotCaptureTest.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
 // Phase 42 sub-F.10 — Robolectric coverage for SentoriScreenshotCapture.
 //
 // Run via Gradle on the Android host:

package/android/src/test/java-core/com/sentori/SentoriVerbsTest.kt

@@ -0,0 +1,185 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/test/java/com/sentori/SentoriVerbsTest.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
+package com.sentori
+
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+/**
+ * The five verbs, and the contract an integrator is entitled to:
+ * synchronous, an id back every time, never a throw, and a no-op
+ * before [Sentori.start] rather than a crash.
+ *
+ * Deliberately the same assertions as `SentoriVerbsTests.swift`. The
+ * dashboard cannot tell which platform sent an event and should not
+ * have to, so the two suites disagreeing is itself the bug.
+ */
+@RunWith(RobolectricTestRunner::class)
+class SentoriVerbsTest {
+
+    @Before
+    fun setUp() {
+        SentoriTransport.resetForTests()
+        SentoriConfig.resetForTests()
+        SentoriScope.clear()
+        SentoriSignalRing.clear()
+        SentoriDevice.resetForTests()
+    }
+
+    @After
+    fun tearDown() {
+        SentoriTransport.resetForTests()
+        SentoriConfig.resetForTests()
+    }
+
+    private fun started() {
+        // Port 9 is discard: nothing listens, so a send fails without
+        // waiting on DNS.
+        Sentori.start(
+            SentoriConfig(
+                token = "st_test",
+                ingestUrl = "http://127.0.0.1:9",
+                release = "app@1.0.0",
+                environment = "test",
+            )
+        )
+    }
+
+    private fun queued() = SentoriTransport.peekQueue()
+
+    @Test
+    fun everyVerbBeforeStartIsASilentNoOpThatStillReturnsAnId() {
+        val ids =
+            listOf(
+                Sentori.error(IllegalStateException("boom")),
+                Sentori.warn("checkout.slow"),
+                Sentori.trace("cart.opened"),
+                Sentori.assert("total.positive", false),
+                Sentori.probe("SEN-482"),
+            )
+        ids.forEach { assertEquals("every verb returns an event id", 36, it.length) }
+        assertTrue("and nothing is queued before init", queued().isEmpty())
+    }
+
+    @Test
+    fun errorCarriesTypeMessageStackAndTheSignalRing() {
+        started()
+        Sentori.pushSignal("nav", mapOf("to" to "/checkout"))
+        Sentori.error(IllegalStateException("boom"), mapOf("cartId" to "c_1"))
+
+        val e = queued().last()
+        assertEquals("error", e["kind"])
+        assertEquals("android", e["platform"])
+        assertEquals("app@1.0.0", e["release"])
+
+        @Suppress("UNCHECKED_CAST") val payload = e["payload"] as Map<String, Any?>
+        @Suppress("UNCHECKED_CAST") val err = payload["error"] as Map<String, Any?>
+        assertEquals("java.lang.IllegalStateException", err["type"])
+        assertEquals("boom", err["message"])
+        assertTrue("a stack with no frames symbolicates nothing", (err["stack"] as List<*>).isNotEmpty())
+
+        @Suppress("UNCHECKED_CAST") val data = payload["data"] as Map<String, Any?>
+        assertEquals("c_1", data["cartId"])
+
+        val signals = payload["signals"] as List<*>
+        assertEquals(1, signals.size)
+    }
+
+    @Test
+    fun aPassingAssertIsNeverAnEvent() {
+        started()
+        Sentori.assert("total.positive", true)
+        Sentori.assert("total.positive", true)
+        assertTrue("passes aggregate; only failures are events", queued().isEmpty())
+        assertEquals(2, SentoriTransport.peekAssertStats().first()["passDelta"])
+
+        Sentori.assert("total.positive", false)
+        assertEquals(1, queued().size)
+        assertEquals("assert", queued().first()["kind"])
+    }
+
+    @Test
+    fun assertNeverStopsTheProgram() {
+        started()
+        Sentori.assert("impossible", false)
+        Sentori.assert("also impossible", false)
+        assertEquals("reached here, twice", 2, queued().size)
+    }
+
+    @Test
+    fun quietTraceReachesTheRingAndNotTheQueue() {
+        started()
+        Sentori.trace("tick", quiet = true)
+        assertTrue("a quiet trace must stay affordable", queued().isEmpty())
+        assertEquals("but it is still context", 1, SentoriSignalRing.snapshot().size)
+
+        Sentori.trace("cart.opened")
+        assertEquals(1, queued().size)
+        assertEquals("cart.opened", queued().first()["name"])
+    }
+
+    @Test
+    fun userKeyRidesEventsOnlyAfterUserIsCalled() {
+        started()
+        Sentori.warn("before")
+        assertNull("no identity, no key — not an empty one", queued().last()["userKey"])
+
+        Sentori.user("usr_123", null)
+        Sentori.warn("after")
+        assertEquals(SentoriIdentity.hash("id", "usr_123"), queued().last()["userKey"])
+    }
+
+    @Test
+    fun contextMergesAndRidesEveryEvent() {
+        started()
+        Sentori.context(mapOf("tenant" to "acme"))
+        Sentori.context(mapOf("plan" to "pro"))
+        Sentori.probe("SEN-1")
+
+        @Suppress("UNCHECKED_CAST")
+        val payload = queued().last()["payload"] as Map<String, Any?>
+        @Suppress("UNCHECKED_CAST") val ctx = payload["context"] as Map<String, Any?>
+        assertEquals("acme", ctx["tenant"])
+        assertEquals("pro", ctx["plan"])
+    }
+
+    @Test
+    fun eventIdsAreUuidV7AndSortByTime() {
+        val first = Sentori.newEventId()
+        Thread.sleep(10)
+        val second = Sentori.newEventId()
+        assertEquals(36, first.length)
+        assertEquals("version nibble", '7', first[14])
+        assertTrue("v7 ids sort by creation time as strings", first < second)
+    }
+
+    @Test
+    fun theQueueIsBoundedAndDropsOldestFirst() {
+        started()
+        // Not flushed: nothing drains to a dead port fast enough to
+        // race this, so it measures the cap rather than a timer.
+        repeat(2000) { Sentori.trace("t$it") }
+        assertTrue("an unbounded queue is a leak with a nicer name", queued().size <= 500)
+        assertEquals("t1999", queued().last()["name"])
+    }
+
+    @Test
+    fun garbageInDataDoesNotReachTheCaller() {
+        started()
+        val id =
+            Sentori.warn(
+                "bad",
+                mapOf("nan" to Double.NaN, "obj" to Any(), "nested" to mapOf("k" to Double.NaN)),
+            )
+        assertEquals(36, id.length)
+        assertNotNull(queued().last())
+    }
+}

package/ios/core/SentoriAttachment.swift

@@ -0,0 +1,129 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/ios/Sources/Sentori/SentoriAttachment.swift
+// Run `node scripts/sync-native-core.mjs` after editing it.
+import Foundation
+
+/// Blobs that belong to an event: the screenshot taken as the app
+/// died, the wireframe replay ring behind it.
+///
+/// They upload *after* the event, never before. The server keys an
+/// attachment on an event id it must already know, so an upload that
+/// races the batch 404s — and it always wins that race, because the
+/// batch waits for a flush and the upload does not.
+///
+/// The multipart body is built by hand rather than with a form API.
+/// React Native learned that the expensive way: its `FormData` file
+/// part wants a `uri`, the `data:` form throws a bare network error on
+/// iOS, and every JS attachment died silently for a release. Doing it
+/// literally is both shorter and checkable.
+enum SentoriAttachment {
+
+    /// The kinds the server's CHECK constraint accepts, from
+    /// `handlers/sdk/events_attachments.rs`. Anything else is a 400,
+    /// so it is dropped here with the round trip saved.
+    ///
+    /// This list is worth keeping honest: the first version of it had
+    /// three entries, and the crash handler's view tree — written on
+    /// both platforms, kind `viewTree` — was not one of them. It
+    /// would have been dropped on the way out by the very code meant
+    /// to deliver it, silently, with the event arriving intact and
+    /// the evidence missing.
+    static let known: Set<String> = [
+        "logTail", "replay", "screens", "screenshot",
+        "sessionTrail", "stateSnapshot", "viewTree",
+    ]
+
+    /// `android` | `ios` | `js`, likewise CHECK-constrained.
+    static let knownSources: Set<String> = ["android", "ios", "js"]
+
+    /// Test seam: capture instead of sending.
+    ///
+    /// What is worth asserting here is *what* would be uploaded and
+    /// *when* — the kind, the event it is keyed on, the body, and
+    /// that none of it moves before the batch lands. None of that is
+    /// about TCP. The wire itself is covered by `ios-live-ingest`,
+    /// which posts to a real server and reads the blob back.
+    static var recorderForTests: ((String, String, String) -> Void)?
+
+    /// Upload one blob against an event the server already has.
+    ///
+    /// Fire and forget: nothing here reaches the caller, and a
+    /// failure costs the attachment rather than the crash report it
+    /// belongs to.
+    static func upload(
+        eventId: String,
+        kind: String,
+        base64: String,
+        mediaType: String,
+        source: String = "ios",
+        completion: ((Bool) -> Void)? = nil
+    ) {
+        guard let config = SentoriConfig.current, known.contains(kind),
+            knownSources.contains(source),
+            let encodedId = eventId.addingPercentEncoding(
+                withAllowedCharacters: .urlPathAllowed),
+            let url = URL(
+                string: "\(config.ingestUrl)/v1/events/\(encodedId)/attachments/\(kind)")
+        else {
+            completion?(false)
+            return
+        }
+
+        let boundary = "----sentori-\(eventId)"
+        if let record = recorderForTests {
+            record(
+                eventId, kind,
+                multipartBody(
+                    boundary: boundary, kind: kind, mediaType: mediaType, base64: base64,
+                    source: source))
+            completion?(true)
+            return
+        }
+        var body = ""
+        body += "--\(boundary)\r\n"
+        body += "Content-Disposition: form-data; name=\"file\"; filename=\"\(kind).bin\"\r\n"
+        body += "Content-Type: \(mediaType)\r\n"
+        // The server decodes when told to. Without this header it
+        // stores the base64 text as the image, which renders as
+        // nothing and looks like a capture problem.
+        body += "Content-Transfer-Encoding: base64\r\n"
+        body += "\r\n\(base64)\r\n"
+        body += "--\(boundary)\r\n"
+        body += "Content-Disposition: form-data; name=\"source\"\r\n"
+        body += "\r\n\(source)\r\n"
+        body += "--\(boundary)--\r\n"
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.setValue(
+            "multipart/form-data; boundary=\(boundary)", forHTTPHeaderField: "Content-Type")
+        request.setValue("Bearer \(config.token)", forHTTPHeaderField: "Authorization")
+        request.setValue("swift/\(SentoriVersion.current)", forHTTPHeaderField: "Sentori-Sdk")
+        request.httpBody = body.data(using: .utf8)
+        request.timeoutInterval = 30
+
+        URLSession.shared.dataTask(with: request) { _, response, _ in
+            let code = (response as? HTTPURLResponse)?.statusCode ?? 0
+            completion?((200..<300).contains(code))
+        }.resume()
+    }
+
+    /// The multipart body, exposed so a test can read what would go
+    /// on the wire. Building it correctly is the whole job here, and
+    /// the failure mode is a 2xx that stored the wrong bytes.
+    static func multipartBody(
+        boundary: String, kind: String, mediaType: String, base64: String, source: String
+    ) -> String {
+        var body = ""
+        body += "--\(boundary)\r\n"
+        body += "Content-Disposition: form-data; name=\"file\"; filename=\"\(kind).bin\"\r\n"
+        body += "Content-Type: \(mediaType)\r\n"
+        body += "Content-Transfer-Encoding: base64\r\n"
+        body += "\r\n\(base64)\r\n"
+        body += "--\(boundary)\r\n"
+        body += "Content-Disposition: form-data; name=\"source\"\r\n"
+        body += "\r\n\(source)\r\n"
+        body += "--\(boundary)--\r\n"
+        return body
+    }
+}

package/ios/{SentoriCrashHandler.swift → core/SentoriCrashHandler.swift}

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/ios/Sources/Sentori/SentoriCrashHandler.swift
+// Run `node scripts/sync-native-core.mjs` after editing it.
 import Foundation
 import MachO
 
@@ -64,6 +67,34 @@ import MachO
         return UserDefaults.standard.dictionary(forKey: configKey) ?? [:]
     }
 
+    /// Test-only seam onto `write`, which the real path reaches from
+    /// an `@convention(c)` handler an XCTest cannot raise safely.
+    ///
+    /// The test that calls this was written against this name and has
+    /// never compiled: the sources were loose files in an Expo module
+    /// with no module to import, so nothing ever built the test target
+    /// and nothing reported that the member was missing. Internal
+    /// rather than public — `@testable import` reaches it, an app
+    /// does not.
+    internal static func persistForTesting(exception: NSException) {
+        write(exception: exception)
+    }
+
+    /// Test-only seam that writes a crash file verbatim.
+    ///
+    /// `persistForTesting(exception:)` goes through `write`, which
+    /// composes the file from a live exception and a live screen —
+    /// neither of which an XCTest can arrange. Delivery tests need to
+    /// state the file they are about to deliver, particularly the
+    /// pre-death attachments, which only exist when there was a
+    /// window to capture.
+    internal static func persistRawForTesting(_ event: [String: Any]) {
+        guard let dir = pendingDir(),
+            let data = try? JSONSerialization.data(withJSONObject: event)
+        else { return }
+        try? data.write(to: dir.appendingPathComponent("\(UUID().uuidString.lowercased()).json"))
+    }
+
     private static func write(exception: NSException) {
         let cfg = config()
         let release = (cfg["release"] as? String) ?? "unknown"

package/ios/{SentoriHangWatchdog.swift → core/SentoriHangWatchdog.swift}

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/ios/Sources/Sentori/SentoriHangWatchdog.swift
+// Run `node scripts/sync-native-core.mjs` after editing it.
 import Foundation
 
 /// iOS hang detector — mirrors the Android ANR watchdog (Phase 22 sub-D).

package/ios/{SentoriMobileVitals.swift → core/SentoriMobileVitals.swift}

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/ios/Sources/Sentori/SentoriMobileVitals.swift
+// Run `node scripts/sync-native-core.mjs` after editing it.
 import Foundation
 import UIKit
 import QuartzCore

package/ios/{SentoriNativeExceptionBridge.swift → core/SentoriNativeExceptionBridge.swift}

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/ios/Sources/Sentori/SentoriNativeExceptionBridge.swift
+// Run `node scripts/sync-native-core.mjs` after editing it.
 import Foundation
 
 /// v0.9.5 #8 — partial-fix for the "TurboModule swallows NSException

package/ios/{SentoriPushNotifications.swift → core/SentoriPushNotifications.swift}

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/ios/Sources/Sentori/SentoriPushNotifications.swift
+// Run `node scripts/sync-native-core.mjs` after editing it.
 // v2.9 — iOS push notification bridge.
 //
 // Owns:
@@ -40,9 +43,40 @@ import ObjectiveC.runtime
 
     // MARK: Permission
 
+    /// `UNUserNotificationCenter.current()` raises
+    /// `NSInternalInconsistencyException` — "bundleProxyForCurrentProcess
+    /// is nil" — in any process without an app bundle: a unit-test
+    /// target that links this SDK, a command-line tool, some extension
+    /// hosts. An Objective-C exception cannot be caught in Swift, so
+    /// it terminates the host outright.
+    ///
+    /// That is the failure-isolation rule broken in the loudest
+    /// possible way, and it is the SDK crashing the app rather than
+    /// the app crashing. Found when this package's own test target
+    /// called it and the runner died mid-suite.
+    ///
+    /// The precondition is whether this process *is* an app bundle,
+    /// not whether it has an identifier. `bundleIdentifier` is
+    /// non-nil in an xctest host and the call raised anyway: the
+    /// message names the real cause — `mainBundle.bundleURL` pointing
+    /// at Xcode's `Agents/` directory, which LaunchServices has no
+    /// bundle proxy for.
+    ///
+    /// An app is `…/Foo.app`; a notification service extension is
+    /// `…/Bar.appex` and legitimately uses this API. Anything else —
+    /// a test runner, a command-line tool — gets "unavailable" and a
+    /// `no-transport` result rather than a terminated process.
+    private var notificationCentreIsUsable: Bool {
+        ["app", "appex"].contains(Bundle.main.bundleURL.pathExtension)
+    }
+
     /// Returns the current permission status as a JS-friendly string.
     /// Does NOT prompt.
     @objc public func currentPermission(completion: @escaping (String) -> Void) {
+        guard notificationCentreIsUsable else {
+            completion("unavailable")
+            return
+        }
         UNUserNotificationCenter.current().getNotificationSettings { settings in
             completion(authString(settings.authorizationStatus))
         }
@@ -51,6 +85,10 @@ import ObjectiveC.runtime
     /// Requests authorization. Triggers the OS prompt the first time;
     /// subsequent calls return the cached decision.
     @objc public func requestPermission(completion: @escaping (String) -> Void) {
+        guard notificationCentreIsUsable else {
+            completion("unavailable")
+            return
+        }
         let center = UNUserNotificationCenter.current()
         center.requestAuthorization(options: [.alert, .badge, .sound]) { granted, error in
             if let error = error {
@@ -71,6 +109,10 @@ import ObjectiveC.runtime
     /// method, which routes the token into our buffer.
     @objc public func registerForRemoteNotifications() {
         ensureSwizzleInstalled()
+        // Same guard as the permission calls: installing the
+        // delegate touches the notification centre, which raises in a
+        // process that is not an app bundle.
+        guard notificationCentreIsUsable else { return }
         UNUserNotificationCenter.current().delegate = self
         DispatchQueue.main.async {
             UIApplication.shared.registerForRemoteNotifications()
@@ -96,9 +138,17 @@ import ObjectiveC.runtime
     @objc public func handleRegisteredToken(_ deviceToken: Data) {
         let hex = deviceToken.map { String(format: "%02x", $0) }.joined()
         bufferLock.lock()
+        let changed = tokenHex != nil && tokenHex != hex
         tokenHex = hex
         registrationError = nil
         bufferLock.unlock()
+
+        // A token that replaced a different one is a rotation, and the
+        // server has to hear about it now. Buffering it in a field was
+        // the whole of what happened here before, so a rotation stayed
+        // invisible until the host next called `register` — and the
+        // device received nothing in between.
+        if changed { Sentori.push.handleRotatedToken(hex) }
     }
 
     /// Host-callable counterpart for the failure path.

package/ios/{SentoriReplayCapture.swift → core/SentoriReplayCapture.swift}

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/ios/Sources/Sentori/SentoriReplayCapture.swift
+// Run `node scripts/sync-native-core.mjs` after editing it.
 import Foundation
 import UIKit
 

package/ios/{SentoriScreenshotCapture.swift → core/SentoriScreenshotCapture.swift}

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/ios/Sources/Sentori/SentoriScreenshotCapture.swift
+// Run `node scripts/sync-native-core.mjs` after editing it.
 import Foundation
 import UIKit
 
@@ -309,6 +312,17 @@ import UIKit
         return found
     }
 
+    /// Test-only seam onto the tree walk. The test that covers the
+    /// depth cap reached for it through
+    /// `value(forKey: "viewTreeForTesting")` — a name nothing defines,
+    /// and KVC cannot reach a Swift static method under any name. It
+    /// compiled because KVC is resolved at runtime, and it never ran
+    /// because the sources were loose files in an Expo module with no
+    /// test target to build.
+    internal static func viewTreeForTesting(root: UIView) -> [String: Any] {
+        return walkTree(root: root)
+    }
+
     private static func walkTree(root: UIView) -> [String: Any] {
         var nodes: [String: Any] = [:]
         var counter = 0

package/ios/{SentoriThreadSampler.swift → core/SentoriThreadSampler.swift}

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/ios/Sources/Sentori/SentoriThreadSampler.swift
+// Run `node scripts/sync-native-core.mjs` after editing it.
 import Foundation
 
 /// Captures the main thread's program-counter chain for hang reporting.

package/lib/push.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"push.d.ts","sourceRoot":"","sources":["../src/push.ts"],"names":[],"mappings":"AAqCA,OAAO,EAEL,aAAa,EAEb,qBAAqB,EAEtB,MAAM,aAAa,CAAA;AAqBpB,MAAM,MAAM,mBAAmB,GAAG;IAChC;;;;;;mEAM+D;IAC/D,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAClC;kDAC8C;IAC9C,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,uBAAuB,KAAK,IAAI,CAAA;IACtD,sDAAsD;IACtD,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAA;IAC/B;iEAC6D;IAC7D,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;IAC/B;;yBAEqB;IACrB,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,CAAA;IAC9B;;;kBAGc;IACd,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,mBAAmB,GAC3B,iBAAiB,GACjB,cAAc,GACd,mBAAmB,GACnB,iBAAiB,GACjB,eAAe,CAAA;AAEnB;;;;mCAImC;AACnC,MAAM,MAAM,kBAAkB,GAC1B;IACE,EAAE,EAAE,IAAI,CAAA;IACR;;oDAEgD;IAChD,GAAG,EAAE,MAAM,CAAA;CACZ,GACD;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,mBAAmB,CAAA;CAAE,CAAA;AAE/D,MAAM,MAAM,uBAAuB,GAAG;IACpC,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAClC,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,QAAQ,CAAC,IAAI,GAAE,mBAAwB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAqC1F;AAyBD;;;GAGG;AACH,wBAAsB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAiBhD;AAED;4DAC4D;AAC5D,wBAAgB,YAAY,IAAI,IAAI,GAAG,MAAM,CAE5C;AAED,sDAAsD;AACtD,OAAO,EAAE,aAAa,IAAI,SAAS,EAAE,qBAAqB,IAAI,iBAAiB,EAAE,CAAA;AAsNjF;oEACoE;AACpE,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,CAEhE;AA+ED;;+DAE+D;AAC/D,wBAAgB,eAAe,IAAI,IAAI,CAMtC;AAID;qCACqC;AACrC,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,KAAK,GAAG,SAAS,GAAG,SAAS,GAAG,IAAI,GAAG,IAAI,CAEnF"}
+{"version":3,"file":"push.d.ts","sourceRoot":"","sources":["../src/push.ts"],"names":[],"mappings":"AAqCA,OAAO,EAEL,aAAa,EAEb,qBAAqB,EAEtB,MAAM,aAAa,CAAA;AA6BpB,MAAM,MAAM,mBAAmB,GAAG;IAChC;;;;;;mEAM+D;IAC/D,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAClC;kDAC8C;IAC9C,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,uBAAuB,KAAK,IAAI,CAAA;IACtD,sDAAsD;IACtD,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAA;IAC/B;iEAC6D;IAC7D,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;IAC/B;;yBAEqB;IACrB,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,CAAA;IAC9B;;;kBAGc;IACd,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,mBAAmB,GAC3B,iBAAiB,GACjB,cAAc,GACd,mBAAmB,GACnB,iBAAiB,GACjB,eAAe,CAAA;AAEnB;;;;mCAImC;AACnC,MAAM,MAAM,kBAAkB,GAC1B;IACE,EAAE,EAAE,IAAI,CAAA;IACR;;oDAEgD;IAChD,GAAG,EAAE,MAAM,CAAA;CACZ,GACD;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,mBAAmB,CAAA;CAAE,CAAA;AAE/D,MAAM,MAAM,uBAAuB,GAAG;IACpC,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAClC,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,QAAQ,CAAC,IAAI,GAAE,mBAAwB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAyC1F;AAgDD;;;GAGG;AACH,wBAAsB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAoBhD;AAED;4DAC4D;AAC5D,wBAAgB,YAAY,IAAI,IAAI,GAAG,MAAM,CAE5C;AAED,sDAAsD;AACtD,OAAO,EAAE,aAAa,IAAI,SAAS,EAAE,qBAAqB,IAAI,iBAAiB,EAAE,CAAA;AA4NjF;oEACoE;AACpE,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,CAEhE;AA+ED;;+DAE+D;AAC/D,wBAAgB,eAAe,IAAI,IAAI,CAUtC;AAID;qCACqC;AACrC,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,KAAK,GAAG,SAAS,GAAG,SAAS,GAAG,IAAI,GAAG,IAAI,CAEnF"}

package/lib/push.js

@@ -21,10 +21,18 @@
 //      buffered events while the app is foreground. Pauses on
 //      background, resumes on active, per the perf iron rule.
 import { logger, pushSignal } from '@goliapkg/sentori-core';
-import { currentUserKey } from './scope.js';
+import { currentUserKey, currentUserTraits, onIdentityChange } from './scope.js';
 import { pushDrainState, pushGetStatus, pushRegister as nativePushRegister, pushRequestPermission, pushUnregister as nativePushUnregister, } from './native.js';
 const STORAGE_KEY = 'sentori.push.ipt';
 let _cachedIpt = null;
+// The last token the vendor handed us, kept so a sign-in can re-send
+// the registration without asking the OS for a token again.
+let _lastNativeToken = null;
+let _lastOptions = {};
+// What the server was last told. A re-registration that would send
+// the same thing is not sent: `user()` is a verb an app may call on
+// every screen, and one HTTP request per call is not free to a host.
+let _lastSentIdentity = null;
 let _drainInterval = null;
 let _appStateSubscription = null;
 let _backgrounded = false;
@@ -77,9 +85,13 @@ export async function register(opts = {}) {
         const token = await waitForToken(opts.tokenTimeoutMs ?? 8000);
         const ipt = await registerWithServer(cfg, token, opts);
         _cachedIpt = ipt;
+        _lastNativeToken = token;
+        _lastOptions = opts;
         void persistIpt(ipt);
         opts.onToken?.(ipt);
         bindBufferDrain(opts.onMessage, opts.onTap);
+        // From here on, signing in or out updates the row by itself.
+        onIdentityChange(reRegisterAfterIdentityChange);
         return { ok: true, ipt };
     }
     catch (e) {
@@ -95,6 +107,30 @@ function fail(opts, reason, message) {
     opts.onError?.(new Error(message));
     return { ok: false, message, reason };
 }
+/**
+ * Send the registration again because the person changed.
+ *
+ * Only for a device that has already registered — the vendor token is
+ * the evidence, the same rule the native SDKs use for a rotated
+ * token. Nothing here throws and nothing here is awaited by the host:
+ * `user()` is synchronous and stays that way.
+ */
+function reRegisterAfterIdentityChange() {
+    const token = _lastNativeToken;
+    const cfg = tryGetRuntimeConfig();
+    if (token == null || cfg == null)
+        return;
+    const identity = JSON.stringify([currentUserKey() ?? null, currentUserTraits() ?? null]);
+    if (identity === _lastSentIdentity)
+        return;
+    _lastSentIdentity = identity;
+    void registerWithServer(cfg, token, _lastOptions).catch((e) => {
+        // A failed update leaves the row pointing at the previous person,
+        // so the next change must be allowed to try again.
+        _lastSentIdentity = null;
+        logger.warn('push', 'updating the device after a sign-in failed', e);
+    });
+}
 /** Internal carrier so the helpers below can name which failure they
  *  are without every one of them returning a result object. */
 class PushRegisterError extends Error {
@@ -124,6 +160,9 @@ export async function unregister() {
         }
     }
     nativePushUnregister();
+    onIdentityChange(undefined);
+    _lastNativeToken = null;
+    _lastSentIdentity = null;
     _cachedIpt = null;
     void clearPersistedIpt();
     teardownBufferDrain();
@@ -196,6 +235,13 @@ async function registerWithServer(cfg, nativeToken, opts) {
     // not — 2026-08-11.)
     if (opts.metadata != null)
         body.metadata = opts.metadata;
+    // Attributes of the person rather than of the device, kept apart so
+    // a build channel called "pro" cannot answer a send aimed at the pro
+    // plan. Absent leaves whatever the row already had; `{}` clears it,
+    // which is what signing out sends.
+    const traits = currentUserTraits();
+    if (traits != null)
+        body.traits = traits;
     const res = await fetch(joinUrl(cfg.ingestUrl, '/v1/push/tokens'), {
         method: 'POST',
         headers: {
@@ -412,6 +458,10 @@ export function __resetForTests() {
     _onMessage = undefined;
     _onTap = undefined;
     _ackQueue = [];
+    _lastNativeToken = null;
+    _lastOptions = {};
+    _lastSentIdentity = null;
+    onIdentityChange(undefined);
     teardownBufferDrain();
 }
 let _platformOverride = null;