react-native-revnix 1.4.0

package/dist/esm/ui/index.js

@@ -0,0 +1,6 @@
+export { RevnixPaywall, DEFAULT_PAYWALL_THEME, LIGHT_PAYWALL_THEME, } from "./RevnixPaywall.js";
+export { RevnixBlockPaywall, } from "./RevnixBlockPaywall.js";
+export { DESIGN_CANVAS, } from "../blocks/types.js";
+export { backgroundBaseColor, backgroundLayers, coverPlacement, } from "../blocks/background.js";
+export { detectLocale, linkLabels, localeChain, localizeBlockDoc, normalizeLocale, setLocale, } from "../blocks/locale.js";
+export { minorUnitsForCurrency, resolveTags } from "../blocks/tags.js";

package/dist/esm/version.js

@@ -0,0 +1,4 @@
+// L3: the single source of the SDK version inside src/. Must match
+// package.json "version" — version.test.ts fails the build when they drift
+// (they had: client.ts said 0.7.0 while the package shipped 0.9.0).
+export const SDK_VERSION = "1.4.0";

package/dist/iap.d.ts

@@ -0,0 +1,20 @@
+import type { RegisterPurchaseInput, Store } from "./types.js";
+export interface IapPurchase {
+    productId: string;
+    transactionId?: string | null;
+    /** Unix ms. */
+    transactionDate?: number | null;
+    /** Android purchase token. react-native-iap v13+ also sets it on iOS,
+     *  where it is the StoreKit 2 JWS — not the token Revnix needs, but the
+     *  proof it wants (`signedTransactionInfo`), so the Apple branch picks it
+     *  up from here when it has the JWS shape. */
+    purchaseToken?: string | null;
+    /** StoreKit 2 JWS (`VerificationResult.jwsRepresentation`), for IAP
+     *  libraries that expose it under its own name. */
+    jwsRepresentation?: string | null;
+    originalTransactionIdentifierIOS?: string | null;
+}
+export declare function purchaseInputFromIap(purchase: IapPurchase, source: Store, extras?: {
+    expiresAt?: number;
+    rawPayload?: unknown;
+}): RegisterPurchaseInput;

package/dist/iap.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.purchaseInputFromIap = purchaseInputFromIap;
+// A JWS is three dot-separated base64url segments. Older react-native-iap
+// versions put other receipt shapes in purchaseToken on iOS — shape-check so
+// only a real JWS is sent as proof (the server rejects a malformed one).
+const JWS_SHAPE = /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/;
+function jwsFromIap(purchase) {
+    for (const candidate of [purchase.jwsRepresentation, purchase.purchaseToken]) {
+        if (candidate && JWS_SHAPE.test(candidate))
+            return candidate;
+    }
+    return undefined;
+}
+// REV-200 (CTO-R2 M25): base64url → string without atob (not available on
+// every React Native runtime). The ids read from the payload are ASCII;
+// multi-byte content is never consulted.
+const B64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function base64UrlDecode(segment) {
+    const b64 = segment.replace(/-/g, "+").replace(/_/g, "/");
+    let out = "";
+    let buffer = 0;
+    let bits = 0;
+    for (const ch of b64) {
+        const idx = B64_ALPHABET.indexOf(ch);
+        if (idx === -1)
+            continue; // padding / stray characters
+        buffer = (buffer << 6) | idx;
+        bits += 6;
+        if (bits >= 8) {
+            bits -= 8;
+            out += String.fromCharCode((buffer >> bits) & 0xff);
+        }
+    }
+    return out;
+}
+// The JWS payload's own ids — read WITHOUT verifying the signature, which is
+// fine here: the server verifies the chain and only trusts the proof when the
+// verified payload's ids match what we send. Reading them locally is exactly
+// how we make them match.
+function jwsPayload(jws) {
+    try {
+        const segment = jws.split(".")[1];
+        if (!segment)
+            return undefined;
+        const parsed = JSON.parse(base64UrlDecode(segment));
+        return typeof parsed === "object" && parsed !== null
+            ? parsed
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function purchaseInputFromIap(purchase, source, extras) {
+    if (source === "apple") {
+        const transactionId = purchase.transactionId;
+        if (!transactionId) {
+            throw new Error("Revnix: Apple purchase is missing transactionId");
+        }
+        const jws = jwsFromIap(purchase);
+        const proof = jws ? jwsPayload(jws) : undefined;
+        return {
+            source,
+            // REV-200 (M25): token precedence. The old fallback (original id
+            // missing → the renewal's own transactionId) minted a purchaseKey the
+            // store webhook would never produce — a second purchase.completed and
+            // double-counted revenue — AND failed the server's proof check, which
+            // requires the verified JWS's originalTransactionId to EQUAL this
+            // token, silently downgrading a proof-carrying purchase to
+            // provisional. The JWS payload names the true original id, so when a
+            // JWS is present it wins; the IAP library's field is next; the bare
+            // transactionId remains only for the proof-less first purchase, where
+            // original === transaction anyway.
+            token: proof?.originalTransactionId ??
+                purchase.originalTransactionIdentifierIOS ??
+                transactionId,
+            productId: purchase.productId,
+            transactionId,
+            occurredAt: purchase.transactionDate ?? undefined,
+            expiresAt: extras?.expiresAt,
+            rawPayload: extras?.rawPayload,
+            // Without this the purchase lands PROVISIONAL (see
+            // RegisterPurchaseInput.signedTransactionInfo).
+            signedTransactionInfo: jws,
+        };
+    }
+    const token = purchase.purchaseToken;
+    if (!token) {
+        throw new Error("Revnix: Google purchase is missing purchaseToken");
+    }
+    return {
+        source,
+        token,
+        productId: purchase.productId,
+        // The Google webhook adapter (convex/lib/google.ts) reports the
+        // purchaseToken as the transactionId — send the same, never the Play
+        // orderId, or client-register and webhook won't share a purchaseKey.
+        transactionId: token,
+        occurredAt: purchase.transactionDate ?? undefined,
+        expiresAt: extras?.expiresAt,
+        rawPayload: extras?.rawPayload,
+    };
+}

package/dist/implicit.d.ts

@@ -0,0 +1,69 @@
+/** The six reserved keys. Lowercase throughout: a placement key must match
+ *  `^[a-z0-9][a-z0-9._-]{0,63}$` server-side, which is why this is
+ *  `deeplink_open` and not Superwall's `deepLink_open`. */
+export declare const IMPLICIT_PLACEMENTS: readonly ["app_install", "app_launch", "session_start", "deeplink_open", "paywall_decline", "transaction_abandon"];
+export type ImplicitPlacement = (typeof IMPLICIT_PLACEMENTS)[number];
+/** Why a trigger came back with no paywall — as opposed to a placement that
+ *  resolved fine and simply has none attached, which is `null`. */
+export type ImplicitSkipReason = "not_configured" | "same_paywall";
+/** The one moment the SDK cannot see unaided: the URL that opened the app is
+ *  delivered to the host's own entry point, and an SDK trying to intercept it
+ *  would be fighting the host's router. Call `handleDeepLink(url)`. */
+export declare const HOST_CALL_PLACEMENT: ImplicitPlacement;
+/** The placementKey `handleDeepLink` reports for a dashboard QR/link preview
+ *  (`<scheme>://revnix-preview?revnix_preview=<token>`) — not one of the six
+ *  above, and never sent to /v1/placements/triggered. */
+export declare const PREVIEW_PLACEMENT_KEY = "revnix_preview";
+/** How long the app must have been backgrounded for the return to count as a
+ *  new session rather than an app switch. Matches Superwall's own definition
+ *  so a team moving over gets the same numbers. */
+export declare const DEFAULT_SESSION_TIMEOUT_MS: number;
+/** How long after a FAILED /v1/config read the SDK waits before asking again.
+ *  See RevnixClient.implicitConfigRetryAt. */
+export declare const IMPLICIT_CONFIG_RETRY_MS = 60000;
+/** Where the app is. Both transitions matter: a session is defined by how
+ *  long the app was in the BACKGROUND, which cannot be known from foreground
+ *  events alone — "time since the last return" would mint a session after 35
+ *  minutes of continuous use plus a three-second app switch. */
+export type RevnixAppState = "foreground" | "background";
+/** The platform seam. The SDK ships a browser implementation (see
+ *  `browserLifecycle`); React Native passes an adapter over `AppState`, which
+ *  is a few lines and keeps `react-native` out of this package's dependencies:
+ *
+ *      lifecycle: {
+ *        onStateChange: (handler) => {
+ *          const sub = AppState.addEventListener("change", (s) => {
+ *            handler(s === "active" ? "foreground" : "background");
+ *          });
+ *          return () => sub.remove();
+ *        },
+ *      }
+ */
+export interface RevnixLifecycle {
+    /** Subscribe to app state transitions. Returns an unsubscribe. Called at
+     *  most once per client; the client calls the unsubscribe from dispose().
+     *  Repeated reports of the same state are harmless. */
+    onStateChange(handler: (state: RevnixAppState) => void): () => void;
+}
+/** Foreground detection in a browser tab. `visibilitychange` rather than
+ *  `focus`: switching windows fires focus without the page ever having been
+ *  hidden, which would mint sessions for someone alt-tabbing. Returns null
+ *  where there is no document (React Native, Node, SSR) — the host passes its
+ *  own adapter there. */
+export declare function browserLifecycle(): RevnixLifecycle | null;
+/** What the host is handed when a moment resolved to a paywall. */
+export interface ImplicitTrigger<TResolution> {
+    /** Which of the six fired, or `PREVIEW_PLACEMENT_KEY` for a dashboard preview. */
+    placement: ImplicitPlacement | typeof PREVIEW_PLACEMENT_KEY;
+    /** The resolution, exactly as `resolvePlacement` would have returned it —
+     *  offering, paywall, experiment and targeting all included. */
+    resolution: TResolution;
+}
+/** The trigger response body. The resolve shape plus the two fields the
+ *  trigger route adds. */
+export interface ImplicitTriggerResponse {
+    skipReason: ImplicitSkipReason | null;
+    /** True when this call appended a NEW ledger event (false for a duplicate,
+     *  and for the three moments that reuse an event reported elsewhere). */
+    recorded: boolean;
+}

package/dist/implicit.js

@@ -0,0 +1,67 @@
+"use strict";
+// REV-272: implicit placements — the six moments the SDK reports on its own.
+//
+// A placement is normally a location the HOST resolves by name, so every new
+// place a paywall could appear costs a code change and a release. Six moments
+// are the same in every app and visible to the SDK without the host saying
+// anything, so an operator can attach a paywall to them from the dashboard
+// alone. This module owns the vocabulary and the platform-lifecycle seam;
+// client.ts owns the firing.
+//
+// Mirrors convex/lib/implicitPlacements.ts in revnix-app — the backend is the
+// source of truth for the key spellings, and a mismatch here is silent (the
+// server 400s a key it does not know, and the moment is simply never
+// configured), so the two lists are checked against each other in the tests.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IMPLICIT_CONFIG_RETRY_MS = exports.DEFAULT_SESSION_TIMEOUT_MS = exports.PREVIEW_PLACEMENT_KEY = exports.HOST_CALL_PLACEMENT = exports.IMPLICIT_PLACEMENTS = void 0;
+exports.browserLifecycle = browserLifecycle;
+/** The six reserved keys. Lowercase throughout: a placement key must match
+ *  `^[a-z0-9][a-z0-9._-]{0,63}$` server-side, which is why this is
+ *  `deeplink_open` and not Superwall's `deepLink_open`. */
+exports.IMPLICIT_PLACEMENTS = [
+    "app_install",
+    "app_launch",
+    "session_start",
+    "deeplink_open",
+    "paywall_decline",
+    "transaction_abandon",
+];
+/** The one moment the SDK cannot see unaided: the URL that opened the app is
+ *  delivered to the host's own entry point, and an SDK trying to intercept it
+ *  would be fighting the host's router. Call `handleDeepLink(url)`. */
+exports.HOST_CALL_PLACEMENT = "deeplink_open";
+/** The placementKey `handleDeepLink` reports for a dashboard QR/link preview
+ *  (`<scheme>://revnix-preview?revnix_preview=<token>`) — not one of the six
+ *  above, and never sent to /v1/placements/triggered. */
+exports.PREVIEW_PLACEMENT_KEY = "revnix_preview";
+/** How long the app must have been backgrounded for the return to count as a
+ *  new session rather than an app switch. Matches Superwall's own definition
+ *  so a team moving over gets the same numbers. */
+exports.DEFAULT_SESSION_TIMEOUT_MS = 30 * 60000;
+/** How long after a FAILED /v1/config read the SDK waits before asking again.
+ *  See RevnixClient.implicitConfigRetryAt. */
+exports.IMPLICIT_CONFIG_RETRY_MS = 60000;
+/** Foreground detection in a browser tab. `visibilitychange` rather than
+ *  `focus`: switching windows fires focus without the page ever having been
+ *  hidden, which would mint sessions for someone alt-tabbing. Returns null
+ *  where there is no document (React Native, Node, SSR) — the host passes its
+ *  own adapter there. */
+function browserLifecycle() {
+    const doc = globalThis.document;
+    if (!doc ||
+        typeof doc.addEventListener !== "function" ||
+        typeof doc.removeEventListener !== "function") {
+        return null;
+    }
+    const add = doc.addEventListener.bind(doc);
+    const remove = doc.removeEventListener.bind(doc);
+    return {
+        onStateChange(handler) {
+            const listener = () => {
+                handler(doc.visibilityState === "visible" ? "foreground" : "background");
+            };
+            add("visibilitychange", listener);
+            return () => remove("visibilitychange", listener);
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+import { RevnixClient } from "./client.js";
+import { setLocale } from "./blocks/locale.js";
+import type { RevnixConfig } from "./types.js";
+export { RevnixClient } from "./client.js";
+export { PurchaseBlockedError, RevnixAuthError, RevnixError, RevnixNetworkError, RevnixRateLimitError, RevnixTimeoutError, } from "./errors.js";
+export { purchaseInputFromIap, type IapPurchase } from "./iap.js";
+export { memoryStorage, generateAnonymousId } from "./storage.js";
+export { SDK_VERSION } from "./version.js";
+export { DEVICE_HEADER, encodeDeviceHeader } from "./device.js";
+export { browserLifecycle, DEFAULT_SESSION_TIMEOUT_MS, HOST_CALL_PLACEMENT, IMPLICIT_PLACEMENTS, PREVIEW_PLACEMENT_KEY, type ImplicitPlacement, type ImplicitSkipReason, type ImplicitTrigger, type ImplicitTriggerResponse, type RevnixLifecycle, } from "./implicit.js";
+export type { AdRevenue, AliasResult, CustomerEntitlements, DeviceFacts, Entitlement, EntitlementSource, Environment, IdentifyResult, IdentifyStrategy, IdentityInfo, ImplicitResolution, LastDeepLink, MmpAttribution, MmpProvider, PaywallConfig, PaywallInteraction, PaywallPurchaseOutcome, PlacementOffering, PlacementPackage, PlacementPaywall, PlacementProduct, PlacementResolution, RegisterPurchaseInput, RegisterPurchaseResult, RevnixAttribution, RevnixConfig, RevnixDiagnostic, RevnixStorage, Store, } from "./types.js";
+/** Singleton facade — configure once at app start, then import `Revnix`
+ *  anywhere. Prefer constructing RevnixClient directly in tests. */
+export declare const Revnix: {
+    configure(config: RevnixConfig): RevnixClient;
+    setLocale: typeof setLocale;
+    readonly client: RevnixClient;
+};

package/dist/index.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Revnix = exports.PREVIEW_PLACEMENT_KEY = exports.IMPLICIT_PLACEMENTS = exports.HOST_CALL_PLACEMENT = exports.DEFAULT_SESSION_TIMEOUT_MS = exports.browserLifecycle = exports.encodeDeviceHeader = exports.DEVICE_HEADER = exports.SDK_VERSION = exports.generateAnonymousId = exports.memoryStorage = exports.purchaseInputFromIap = exports.RevnixTimeoutError = exports.RevnixRateLimitError = exports.RevnixNetworkError = exports.RevnixError = exports.RevnixAuthError = exports.PurchaseBlockedError = exports.RevnixClient = void 0;
+const client_js_1 = require("./client.js");
+const locale_js_1 = require("./blocks/locale.js");
+var client_js_2 = require("./client.js");
+Object.defineProperty(exports, "RevnixClient", { enumerable: true, get: function () { return client_js_2.RevnixClient; } });
+var errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "PurchaseBlockedError", { enumerable: true, get: function () { return errors_js_1.PurchaseBlockedError; } });
+Object.defineProperty(exports, "RevnixAuthError", { enumerable: true, get: function () { return errors_js_1.RevnixAuthError; } });
+Object.defineProperty(exports, "RevnixError", { enumerable: true, get: function () { return errors_js_1.RevnixError; } });
+Object.defineProperty(exports, "RevnixNetworkError", { enumerable: true, get: function () { return errors_js_1.RevnixNetworkError; } });
+Object.defineProperty(exports, "RevnixRateLimitError", { enumerable: true, get: function () { return errors_js_1.RevnixRateLimitError; } });
+Object.defineProperty(exports, "RevnixTimeoutError", { enumerable: true, get: function () { return errors_js_1.RevnixTimeoutError; } });
+var iap_js_1 = require("./iap.js");
+Object.defineProperty(exports, "purchaseInputFromIap", { enumerable: true, get: function () { return iap_js_1.purchaseInputFromIap; } });
+var storage_js_1 = require("./storage.js");
+Object.defineProperty(exports, "memoryStorage", { enumerable: true, get: function () { return storage_js_1.memoryStorage; } });
+Object.defineProperty(exports, "generateAnonymousId", { enumerable: true, get: function () { return storage_js_1.generateAnonymousId; } });
+var version_js_1 = require("./version.js");
+Object.defineProperty(exports, "SDK_VERSION", { enumerable: true, get: function () { return version_js_1.SDK_VERSION; } });
+var device_js_1 = require("./device.js");
+Object.defineProperty(exports, "DEVICE_HEADER", { enumerable: true, get: function () { return device_js_1.DEVICE_HEADER; } });
+Object.defineProperty(exports, "encodeDeviceHeader", { enumerable: true, get: function () { return device_js_1.encodeDeviceHeader; } });
+var implicit_js_1 = require("./implicit.js");
+Object.defineProperty(exports, "browserLifecycle", { enumerable: true, get: function () { return implicit_js_1.browserLifecycle; } });
+Object.defineProperty(exports, "DEFAULT_SESSION_TIMEOUT_MS", { enumerable: true, get: function () { return implicit_js_1.DEFAULT_SESSION_TIMEOUT_MS; } });
+Object.defineProperty(exports, "HOST_CALL_PLACEMENT", { enumerable: true, get: function () { return implicit_js_1.HOST_CALL_PLACEMENT; } });
+Object.defineProperty(exports, "IMPLICIT_PLACEMENTS", { enumerable: true, get: function () { return implicit_js_1.IMPLICIT_PLACEMENTS; } });
+Object.defineProperty(exports, "PREVIEW_PLACEMENT_KEY", { enumerable: true, get: function () { return implicit_js_1.PREVIEW_PLACEMENT_KEY; } });
+let instance = null;
+/** Singleton facade — configure once at app start, then import `Revnix`
+ *  anywhere. Prefer constructing RevnixClient directly in tests. */
+exports.Revnix = {
+    configure(config) {
+        // REV-204 (L10): dev fast-refresh re-runs configure(); without teardown
+        // the old client kept its retry/prefetch background work running
+        // alongside the new one.
+        instance?.dispose();
+        instance = new client_js_1.RevnixClient(config);
+        return instance;
+    },
+    setLocale: locale_js_1.setLocale,
+    get client() {
+        if (!instance) {
+            throw new Error("Revnix: call Revnix.configure(...) before use");
+        }
+        return instance;
+    },
+};

package/dist/storage.d.ts

@@ -0,0 +1,14 @@
+import type { RevnixStorage } from "./types.js";
+/** Default storage: survives only the current JS runtime. Real apps must
+ *  pass a persistent adapter (MMKV, AsyncStorage, localStorage) or every
+ *  launch becomes a new anonymous customer. */
+export declare function memoryStorage(): RevnixStorage;
+export declare function resolveStorage(configured?: RevnixStorage): {
+    storage: RevnixStorage;
+    persistent: boolean;
+};
+export declare function generateAnonymousId(): string;
+/** One id per paywall display (REV-094) — the backend dedupes retries on it
+ *  while genuine repeat views (fresh ids) count separately. */
+export declare function generateViewId(): string;
+export declare function generateEventId(): string;

package/dist/storage.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoryStorage = memoryStorage;
+exports.resolveStorage = resolveStorage;
+exports.generateAnonymousId = generateAnonymousId;
+exports.generateViewId = generateViewId;
+exports.generateEventId = generateEventId;
+/** Default storage: survives only the current JS runtime. Real apps must
+ *  pass a persistent adapter (MMKV, AsyncStorage, localStorage) or every
+ *  launch becomes a new anonymous customer. */
+function memoryStorage() {
+    const map = new Map();
+    return {
+        getItem: (key) => map.get(key) ?? null,
+        setItem: (key, value) => {
+            map.set(key, value);
+        },
+    };
+}
+// CTO-SCALE-REVIEW M5: what actually backs the client when `storage` is
+// omitted. Memory-only used to be the silent default — every launch became a
+// new anonymous customer + a new install report (analytics inflated by the
+// DAU multiplier, purchases orphaned on the previous launch's id). Now:
+//   1. explicit adapter → use it (unchanged);
+//   2. web (localStorage usable) → use localStorage automatically;
+//   3. truly nothing (React Native without an adapter) → memory, but WARN
+//      loudly, and the client skips install reporting (see client.ts) so a
+//      forgotten config line can't fabricate fleet-wide installs.
+function resolveStorage(configured) {
+    if (configured)
+        return { storage: configured, persistent: true };
+    const ls = globalThis.localStorage;
+    if (ls) {
+        try {
+            const probe = "revnix.__probe";
+            ls.setItem(probe, "1");
+            ls.removeItem(probe);
+            return {
+                storage: {
+                    getItem: (key) => ls.getItem(key),
+                    setItem: (key, value) => {
+                        ls.setItem(key, value);
+                    },
+                },
+                persistent: true,
+            };
+        }
+        catch {
+            // Private mode / quota quirks — fall through to memory.
+        }
+    }
+    console.warn("[revnix] No `storage` adapter configured and no localStorage available; " +
+        "the customer id lives in memory only. Every launch will look like a NEW " +
+        "anonymous customer: prior purchases won't be attached and analytics " +
+        "would be inflated, so install reporting and experiment enrollment are " +
+        "disabled. Pass a persistent adapter (AsyncStorage/MMKV on React " +
+        "Native) to fix this.");
+    return { storage: memoryStorage(), persistent: false };
+}
+function randomHex(byteLength) {
+    const bytes = new Uint8Array(byteLength);
+    const cryptoObj = globalThis.crypto;
+    // L2: no Math.random fallback — a guessable customer id is readable by
+    // anyone holding the public key, so failing loudly beats failing silently.
+    // Every supported runtime (browsers, RN ≥0.72 via Hermes, Node ≥19) exposes
+    // getRandomValues; older Node needs `globalThis.crypto = require("crypto").webcrypto`.
+    if (!cryptoObj?.getRandomValues) {
+        throw new Error("[revnix] crypto.getRandomValues is unavailable in this runtime; " +
+            "cannot generate a secure customer id. Polyfill globalThis.crypto " +
+            "or pass an explicit `customerId` in configure().");
+    }
+    cryptoObj.getRandomValues(bytes);
+    return [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function generateAnonymousId() {
+    return `rvx_anon_${randomHex(16)}`;
+}
+/** One id per paywall display (REV-094) — the backend dedupes retries on it
+ *  while genuine repeat views (fresh ids) count separately. */
+function generateViewId() {
+    return `rvx_view_${randomHex(16)}`;
+}
+function generateEventId() {
+    return `rvx_evt_${randomHex(16)}`;
+}