@sazabi/react-native 0.0.0-stage → 0.1.1

package/dist/outbox.d.ts

@@ -0,0 +1,53 @@
+import type { SdkHealthReporter, Transport } from "./client-sdk-core/index.js";
+import type { StorageAdapter } from "./types.js";
+export declare const OUTBOX_INDEX_KEY = "sazabi.outbox.index";
+/** Stamped on every record of a stashed batch; a re-sent copy carries the same value. */
+export declare const OUTBOX_REPLAY_ID_KEY = "app.outbox.id";
+/**
+ * Route the outbox's health reports to the running instance. Set before
+ * `loadOutbox`, so what the first read discards is reported on this launch.
+ */
+export declare const watchOutbox: (adapter: StorageAdapter, report: SdkHealthReporter) => void;
+/** The instance is gone: nothing it would have reported is reported. */
+export declare const unwatchOutbox: (adapter: StorageAdapter, report: SdkHealthReporter) => void;
+/**
+ * Read the stored outbox once per adapter. Started by `init()` before any
+ * capture installs: a synchronous adapter is loaded before this returns, so
+ * a crash at any later point merges into the stored report instead of
+ * writing beside it.
+ */
+export declare const loadOutbox: (adapter: StorageAdapter, warn?: (message: string) => void) => Promise<void>;
+/**
+ * The crash outbox replaces the browser's keepalive flush. A fatal JavaScript
+ * error terminates the process shortly after the global handler returns, so
+ * the pending queue (the error row included) is encoded into standalone
+ * envelopes stamped with one replay id and written to storage: the batch's
+ * own key first, then the index that lists it.
+ *
+ * Nothing the dying process sends can be cleared afterwards: an upload the
+ * intake accepted just before the process died would be posted again by the
+ * next launch. So when a synchronous adapter took both writes (`true`),
+ * nothing is sent here; the caller delivers the outbox once the process has
+ * proved it survived, and otherwise the next `init()` does. A
+ * promise-returning adapter may never finish the writes, so its batch is
+ * also sent at once, and a copy the next launch re-sends carries the same
+ * replay id. The saved queue goes once both writes were accepted (every row
+ * it held is in this batch), never before: a store that refuses the batch
+ * near its limit must not cost the only copy of those rows.
+ */
+export declare const stashOutbox: (adapter: StorageAdapter, transport: Transport, replayId: string) => boolean;
+/** Post everything the outbox holds once the stored keys have been read. */
+export declare const deliverOutbox: (adapter: StorageAdapter, transport: Transport) => Promise<void>;
+/**
+ * Save the live queue, within the outbox caps, as the app leaves the
+ * foreground: the OS may kill a backgrounded app without another callback,
+ * and an offline queue would die with it. The queued records are stamped
+ * with the replay id, so the live upload and the copy a later launch sends
+ * share it. Not before the previous launch's saved queue has been read.
+ */
+export declare const saveQueue: (adapter: StorageAdapter, transport: Transport, replayId: string) => void;
+/**
+ * `transport`'s live queue was delivered (or stashed by a crash): its saved
+ * copy goes, unless the key now holds another transport's queue.
+ */
+export declare const clearQueue: (adapter: StorageAdapter, transport: Transport) => void;

package/dist/process-state.d.ts

@@ -0,0 +1,49 @@
+import type { ClientEvent, EventSeverity, PointerTracker } from "./client-sdk-core/index.js";
+export interface SdkInstance {
+    identify(distinctId: string, traits?: Record<string, unknown>): void;
+    reset(): void;
+    addEvent(name: string, attributes?: Record<string, unknown>): void;
+    log(severity: EventSeverity, message: string, metadata?: Record<string, unknown>): void;
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+interface PendingIdentity {
+    distinctId: string;
+    traits?: Record<string, unknown>;
+}
+export interface CurrentScreen {
+    name?: string;
+    path?: string;
+    /** The navigator's per-visit route key: two pushes of one screen are two visits. */
+    key?: string;
+}
+interface SdkState {
+    instance?: SdkInstance;
+    initialized: boolean;
+    warnedWebHost: boolean;
+    /** Bumped by every init() and shutdown(), so a consent promise that resolves after a shutdown starts nothing. */
+    generation: number;
+    pendingIdentity?: PendingIdentity;
+    pendingReset: boolean;
+    /** The running instance's pointer tracker, fed by every `<SazabiRoot>`. */
+    tracker?: PointerTracker;
+    /** Where `<SazabiRoot>` reports a render or commit error it caught. */
+    renderErrorSink?: (error: unknown) => void;
+    /** Where `trackNavigation()` sends its rows. */
+    navigationEmit?: (event: ClientEvent) => void;
+    /** Applied to the route path a navigation row records: a deep link can carry a query string. */
+    navigationRedactUrl?: (url: string) => string;
+    /** The route the user is on, stamped on every row as `app.screen.*`. */
+    screen: CurrentScreen;
+    /** The development note about the unreadable rejection slot, printed once per process. */
+    warnedRejectionSlot: boolean;
+}
+/**
+ * Process-wide, not module-wide: a second evaluation of this module (a
+ * duplicate copy in the bundle, a module registry reset in development)
+ * finds the running instance instead of installing a second `ErrorUtils`
+ * handler, rejection tracker, and transport beside it, and a `<SazabiRoot>`
+ * or `trackNavigation()` imported from that copy feeds the running instance.
+ */
+export declare const state: SdkState;
+export {};

package/dist/register.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/register.js

@@ -0,0 +1,4 @@
+import{s,d}from"./chunk-h2nxjrr9.js";try{if(!s())d()}catch{}
+
+//# debugId=1C55478F3E7B6A0D64756E2164756E21
+//# sourceMappingURL=register.js.map

package/dist/register.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/register.ts"],
+  "sourcesContent": [
+    "/**\n * Early-instrumentation entrypoint: `import \"@sazabi/react-native/register\"`.\n *\n * Importing this module installs the SDK's `XMLHttpRequest` patch as a\n * dormant, transparent passthrough at module-evaluation time, before any\n * other library's module-scope code can capture the prototype methods\n * (Metro evaluates an entry file's imports in order, and every static import\n * runs before the first statement). `init()` later activates it with\n * configuration; until then it observes nothing, stores nothing, and sends\n * nothing.\n *\n * Put this import above all other imports in your app's entry module.\n */\nimport { isWebHost } from \"./host\";\nimport { ensureNetworkPatches } from \"./network\";\n\ntry {\n  // react-native-web runs in a browser, where @sazabi/browser owns capture.\n  if (!isWebHost()) {\n    ensureNetworkPatches();\n  }\n} catch {\n  // Registration must never break the host app; init() re-ensures.\n}\n"
+  ],
+  "mappings": "qCAgBA,GAAI,CAEF,GAAI,CAAC,EAAU,EACb,EAAqB,EAEvB,KAAM",
+  "debugId": "1C55478F3E7B6A0D64756E2164756E21",
+  "names": []
+}

package/dist/storage.d.ts

@@ -0,0 +1,42 @@
+import { type SessionStore } from "./client-sdk-core/index.js";
+import type { StorageAdapter } from "./types.js";
+/**
+ * Storage adapters may be synchronous (MMKV) or promise-returning
+ * (AsyncStorage). Every call here is best-effort: an adapter that throws or
+ * rejects degrades the SDK to in-memory state and never surfaces to the app.
+ */
+export declare const readKey: (adapter: StorageAdapter, key: string) => Promise<string | null>;
+export declare const isThenable: (value: unknown) => value is PromiseLike<unknown>;
+/** What a read found; `undefined` means the adapter failed to answer. */
+export type ReadResult = {
+    value: string | null;
+} | undefined;
+/** Read a key, synchronously when the adapter can, so the crash outbox loads inside `init()`. */
+export declare const readKeyNow: (adapter: StorageAdapter, key: string) => ReadResult | Promise<ReadResult>;
+/**
+ * Every key the adapter holds. `undefined` when the adapter has no listing
+ * or it failed: the caller then knows only what the indexes list, never
+ * that a key is absent.
+ */
+export declare const listKeysNow: (adapter: StorageAdapter) => readonly string[] | undefined | Promise<readonly string[] | undefined>;
+/**
+ * `true` once the adapter accepted the write, `false` when it refused. A
+ * synchronous adapter answers synchronously, which is how the crash path
+ * knows the batch is on disk before the process can die.
+ */
+export declare const writeKey: (adapter: StorageAdapter, key: string, value: string) => boolean | Promise<boolean>;
+/** `true` once the adapter accepted the removal, synchronously when it can. */
+export declare const removeKey: (adapter: StorageAdapter, key: string) => boolean | Promise<boolean>;
+export interface HydratingStore {
+    /** Synchronous view the session machine reads through. */
+    store: SessionStore;
+    /** Resolves once every key has been read from the adapter. */
+    ready: Promise<void>;
+}
+/**
+ * The session machine needs synchronous reads, so persisted state is read
+ * once into an in-memory mirror and every later write goes through to the
+ * adapter. A key written locally before hydration finishes keeps the local
+ * value: a `reset()` must not be undone by a slow read of the old identity.
+ */
+export declare const createHydratingStore: (adapter: StorageAdapter, keys: readonly string[]) => HydratingStore;

package/dist/types.d.ts

@@ -0,0 +1,117 @@
+import type { BeforeSend, ConsoleCaptureConfig, NetworkCaptureConfig as CoreNetworkCaptureConfig, PointerCaptureConfig } from "./client-sdk-core/index.js";
+export type { AttributeValue, BeforeSend, ClientEvent, ClientEventType, ConsoleCaptureConfig, ConsoleCaptureLevel, EventAttributes, EventSeverity, PointerCaptureConfig, } from "./client-sdk-core/index.js";
+/**
+ * Persistent key-value storage the SDK writes sessions, identity, and the
+ * crash outbox to. `@react-native-async-storage/async-storage`, MMKV
+ * wrappers, and `expo-sqlite/kv-store` all satisfy it; a synchronous store
+ * makes the crash outbox reliable on a fatal error.
+ */
+export interface StorageAdapter {
+    getItem(key: string): string | null | Promise<string | null>;
+    setItem(key: string, value: string): void | Promise<void>;
+    removeItem(key: string): void | Promise<void>;
+    /**
+     * Every key the store holds (AsyncStorage's `getAllKeys`, MMKV's
+     * `getAllKeys`). Optional: with it, a launch recovers a crash report whose
+     * own key was written but whose index entry never landed because the
+     * process died between the two writes. Without it such a report is lost.
+     */
+    getAllKeys?(): readonly string[] | Promise<readonly string[]>;
+}
+export interface NetworkCaptureConfig extends CoreNetworkCaptureConfig {
+    /**
+     * Requests eligible for `traceparent` injection. A string is a host
+     * (`api.example.com`), a domain with every subdomain (`.example.com`), or
+     * an origin with an optional path prefix (`https://api.example.com`); a
+     * RegExp is tested against the full URL. Default: every request except
+     * the intake endpoint. A native app has no origin and no CORS preflight,
+     * so injection is on everywhere unless narrowed here.
+     */
+    allowlist?: (string | RegExp)[];
+}
+/**
+ * What `HermesInternal.enablePromiseRejectionTracker` takes: the shape every
+ * React Native crash reporter installs.
+ */
+export interface RejectionTracker {
+    allRejections: boolean;
+    onUnhandled(id: number, rejection: unknown): void;
+    onHandled?(id: number): void;
+}
+export interface ErrorCaptureConfig {
+    /**
+     * Track unhandled promise rejections through Hermes's rejection tracker.
+     * Hermes has one tracker slot, so turn this off when another SDK owns it.
+     * Default true.
+     */
+    unhandledRejections?: boolean;
+    /**
+     * The tracker another library installed before `init()`, to run after the
+     * SDK's own on every rejection. Hermes gives no way to read the slot's
+     * occupant (`HermesInternal` is frozen and its global pinned), so `init()`
+     * replaces whatever holds it; hand that tracker over here to keep it
+     * running. A tracker installed after `init()` replaces the SDK's instead.
+     */
+    previousRejectionTracker?: RejectionTracker;
+}
+/** The subset of a React Navigation container ref the SDK subscribes to. */
+export interface NavigationContainerRefLike {
+    addListener(type: "state", listener: () => void): () => void;
+    getCurrentRoute(): {
+        key?: string | undefined;
+        name: string;
+        params?: object | undefined;
+        path?: string | undefined;
+    } | undefined;
+}
+export interface ReactNativeSdkConfig {
+    /**
+     * The project's intake URL, exactly as the log source issues it, e.g.
+     * `https://<key>.us-west-2.intake.sazabi.com`. The credential is embedded in
+     * the hostname, so this is normally the only endpoint config needed; `/v1/logs`
+     * may be included or omitted.
+     */
+    intakeUrl?: string;
+    /**
+     * Public ingest key (`sazabi_public_...`). Optional: derived from `intakeUrl`
+     * when that URL is a keyed intake host. Set it only for a proxy or custom
+     * endpoint whose hostname carries no key.
+     */
+    publicKey?: string;
+    /** Logical service name for the app. */
+    serviceName: string;
+    /** App version (e.g. the marketing version or a git SHA). */
+    serviceVersion?: string;
+    /** Deployment environment (e.g. "production"). */
+    environment?: string;
+    /** Session persistence and the crash outbox. Without it, sessions last one launch. */
+    storage?: StorageAdapter;
+    network?: NetworkCaptureConfig;
+    console?: ConsoleCaptureConfig;
+    pointer?: PointerCaptureConfig;
+    errors?: ErrorCaptureConfig;
+    /**
+     * Consent gate: capture holds until this resolves true. When it resolves
+     * false the SDK stays dormant.
+     */
+    consent?: () => boolean | Promise<boolean>;
+    /** Batch flush cadence in ms. Default 5000. */
+    flushIntervalMs?: number;
+    /** Soft cap per OTLP request body in bytes. Default 57344. */
+    maxBatchBytes?: number;
+    /**
+     * Max buffered events (and at most 1 MiB) while the intake is unreachable;
+     * the oldest are dropped first and counted in `app.sdk.dropped_events`.
+     * Default 500.
+     */
+    maxQueuedEvents?: number;
+    /**
+     * Edit or drop events before they are queued: return the event to send it,
+     * `null` to drop it. Runs for every event type, `sdk_health` included. A
+     * hook that throws drops the event and warns once; an event captured
+     * synchronously while the hook runs (a `log()` inside it) is dropped. A
+     * request the hook makes produces its own network event later, which the
+     * hook sees like any other and must exclude itself.
+     */
+    beforeSend?: BeforeSend;
+}

package/dist/version.d.ts

@@ -0,0 +1,4 @@
+export declare const SDK_NAME = "@sazabi/react-native";
+export declare const SDK_VERSION = "0.1.1";
+/** SDK-emitted console lines carry this prefix and are never re-captured. */
+export declare const SDK_CONSOLE_PREFIX = "[@sazabi/react-native]";

package/package.json

@@ -1,6 +1,64 @@
 {
   "name": "@sazabi/react-native",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "description": "Sazabi React Native observability SDK — semantic event stream capture with W3C trace context propagation",
+  "version": "0.1.1",
+  "keywords": [
+    "sazabi",
+    "react-native",
+    "expo",
+    "observability",
+    "monitoring",
+    "logging",
+    "error-tracking",
+    "crash-reporting",
+    "opentelemetry",
+    "otlp",
+    "tracing"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./register": {
+      "types": "./dist/register.d.ts",
+      "default": "./dist/register.js"
+    },
+    "./dist/register.js": {
+      "types": "./dist/register.d.ts",
+      "default": "./dist/register.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "react-native": {
+    "./register": "./dist/register.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "react": ">=18",
+    "react-native": ">=0.76"
+  },
+  "peerDependenciesMeta": {
+    "react-native": {
+      "optional": true
+    }
+  },
+  "sideEffects": [
+    "./dist/register.js"
+  ],
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/sazabi/react-native",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sazabi/react-native.git"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  }
+}