@scalebun-release/react-native 2.5.0

package/lib/commonjs/core/config/schema.js

@@ -0,0 +1,512 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ConfigValidationError = exports.ConfigSchema = void 0;
+var _config = require("../../features/performance/config");
+var _endpoints = require("../constants/endpoints");
+/**
+ * ScaleBun SDK — init-config validation and normalization.
+ *
+ * Hand-rolled, table-driven replacement for the vendored mini-Zod this schema used to be built
+ * on. The generic validator cost ~6.7 KB of minified bundle to serve exactly one consumer —
+ * `SDKBootstrapper.safeParse(rawConfig)` — so the machinery is replaced by a field table and a
+ * ~1.5 KB engine with BEHAVIOUR PARITY, byte-for-byte on messages:
+ *
+ *   - same accept/reject decisions (strict types, no coercion; min/max reject rather than clamp)
+ *   - same normalized output (defaults filled, nested defaults via `{}`, unknown keys stripped,
+ *     optional-and-absent keys omitted)
+ *   - same error surface (`safeParse` → `{ success, data | error }`, error with `.issues`
+ *     [{path, message}] and Zod-style `.format()`), with identical message strings
+ *
+ * The parity suite in __tests__/schemaParity.test.ts runs a generated matrix of configs against
+ * BOTH this implementation and a verbatim copy of the old vendored-z construction, and
+ * deep-compares every result. Changing behaviour here without failing that suite should be
+ * treated as impossible; if you extend the config, extend the parity suite's reference schema in
+ * the same commit.
+ *
+ * `apiBaseUrl` note: any value is accepted (`kind: 'any'`, backward compatibility) but the
+ * bootstrapper force-overwrites it with DEFAULT_API_BASE_URL immediately after parse — the
+ * endpoint is locked at build time by design.
+ */
+
+// ─── Result surface (drop-in for the vendored validator's) ─────────────────────
+
+class ConfigValidationError extends Error {
+  constructor(issues) {
+    super(issues.map(i => `${i.path.join('.') || '(root)'}: ${i.message}`).join('; '));
+    this.name = 'ValidationError';
+    this.issues = issues;
+  }
+
+  /** Nested error object keyed by path, matching Zod's `error.format()`. */
+  format() {
+    const root = {
+      _errors: []
+    };
+    for (const issue of this.issues) {
+      if (issue.path.length === 0) {
+        root._errors.push(issue.message);
+        continue;
+      }
+      let node = root;
+      for (let i = 0; i < issue.path.length; i++) {
+        const key = String(issue.path[i]);
+        const existing = node[key];
+        let child;
+        if (existing && !Array.isArray(existing)) {
+          child = existing;
+        } else {
+          child = {
+            _errors: []
+          };
+          node[key] = child;
+        }
+        if (i === issue.path.length - 1) {
+          child._errors.push(issue.message);
+        }
+        node = child;
+      }
+    }
+    return root;
+  }
+}
+
+// ─── Field table ────────────────────────────────────────────────────────────────
+//
+// One row per config key. `def` present → the field always exists in the output (the default is
+// itself validated, matching DefaultSchema semantics). `opt` → absent input stays absent.
+exports.ConfigValidationError = ConfigValidationError;
+const bool = def => def === undefined ? {
+  kind: 'bool'
+} : {
+  kind: 'bool',
+  def
+};
+const num = o => ({
+  kind: 'num',
+  ...o
+});
+const SHAPE = {
+  projectId: {
+    kind: 'str',
+    min: 1,
+    opt: true
+  },
+  publishableKey: {
+    kind: 'str',
+    min: 1,
+    opt: true
+  },
+  apiBaseUrl: {
+    kind: 'any',
+    def: () => _endpoints.DEFAULT_API_BASE_URL
+  },
+  debug: bool(false),
+  logLevel: {
+    kind: 'enum',
+    values: ['silent', 'error', 'warn', 'info', 'debug'],
+    opt: true
+  },
+  flushIntervalMs: num({
+    min: 1000,
+    def: 5000
+  }),
+  finalizeOnBackground: bool(false),
+  idleThresholdMs: num({
+    min: 1000,
+    def: 60_000
+  }),
+  sessionBackgroundCapMs: num({
+    min: 60_000,
+    def: 30 * 60 * 1000
+  }),
+  maxQueueSize: num({
+    min: 1,
+    def: 1000
+  }),
+  enableNetworkMonitoring: bool(true),
+  captureNetworkBodies: bool(false),
+  networkBodyMaxBytes: num({
+    min: 1,
+    max: 1_048_576,
+    def: 65_536
+  }),
+  persistence: {
+    kind: 'obj',
+    def: true,
+    shape: {
+      enabled: bool(true),
+      maxBytes: num({
+        min: 1024,
+        def: 5_242_880
+      }),
+      maxEntries: num({
+        min: 10,
+        def: 5_000
+      }),
+      redactBeforeWrite: bool(true)
+    }
+  },
+  clientKey: {
+    kind: 'str',
+    opt: true
+  },
+  useObjectStorage: bool(false),
+  enableNativeFileOutbox: bool(false),
+  nativeOutboxUploadEnabled: bool(false),
+  useObjectStorageForFrames: bool(false),
+  nativeOutboxRetryIntervalMs: num({
+    min: 250,
+    def: 3000
+  }),
+  nativeOutboxMaxUploadAttempts: num({
+    min: 1,
+    def: 30
+  }),
+  nativeOutboxPoisonMaxAttempts: num({
+    min: 1,
+    def: 2
+  }),
+  nativeOutboxRespectRetryAfter: bool(true),
+  nativeOutboxStrictThreeSecondRetry: bool(false),
+  nativeOutboxNetworkFailuresCountTowardDead: bool(false),
+  nativeOutboxMaxBytes: num({
+    min: 1024,
+    def: 100 * 1024 * 1024
+  }),
+  nativeOutboxMaxAgeMs: num({
+    min: 1000,
+    def: 7 * 24 * 60 * 60 * 1000
+  }),
+  performance: {
+    kind: 'obj',
+    def: true,
+    shape: {
+      enabled: bool(true),
+      tier1: {
+        kind: 'obj',
+        def: true,
+        shape: {
+          appLaunch: bool(true),
+          screenLoad: bool(true),
+          network: bool(true),
+          uiHang: bool(true)
+        }
+      },
+      tier2: {
+        kind: 'obj',
+        def: true,
+        shape: {
+          enabled: bool(true),
+          sampleRate: num({
+            min: 0,
+            max: 1,
+            def: _config.DEFAULT_TIER2_SAMPLE_RATE
+          })
+        }
+      }
+    }
+  },
+  replay: {
+    kind: 'obj',
+    opt: true,
+    shape: {
+      // Auto-start frame recording in SaaS mode (clientKey set) at cold launch, so replay
+      // sessions carry frames out of the box. Default: true (undefined ⇒ record). Set false
+      // for events-only sessions — the host can still record via ScaleBun.startSession().
+      record: {
+        kind: 'bool',
+        opt: true
+      },
+      // 'frequency' is intentionally NOT developer-settable — timer-based capture is reserved
+      // for ScaleBun-controlled (server/admin) activation. Legacy dev values are coerced to
+      // the default in SDKBootstrapper before this validation runs.
+      captureMode: {
+        kind: 'enum',
+        values: ['navigation', 'interactions'],
+        opt: true
+      },
+      intervalMs: num({
+        min: 500,
+        opt: true
+      }),
+      quality: {
+        kind: 'enum',
+        values: ['high', 'normal', 'low', 'grayscale'],
+        opt: true
+      },
+      deltaEncoding: {
+        kind: 'bool',
+        opt: true
+      },
+      deltaKeyframeInterval: num({
+        min: 1,
+        int: true,
+        opt: true
+      })
+    }
+  },
+  // SB-10: the public, documented top-level privacy config. Previously only the
+  // nested replay privacy took effect; this is validated here and mapped onto the
+  // effective replay privacy policy in the bootstrapper so it actually masks.
+  privacy: {
+    kind: 'obj',
+    opt: true,
+    shape: {
+      maskTextInputs: {
+        kind: 'bool',
+        opt: true
+      },
+      maskImages: {
+        kind: 'bool',
+        opt: true
+      },
+      redactAuth: {
+        kind: 'bool',
+        opt: true
+      },
+      redactCookies: {
+        kind: 'bool',
+        opt: true
+      },
+      redactBodies: {
+        kind: 'bool',
+        opt: true
+      }
+    }
+  },
+  captureInteractionHeatmap: bool(true),
+  /**
+   * RN-3 zero-config: patch React Native's ScrollView export so EVERY scroll view reports its
+   * offset, not just ones wrapped in ScaleBunScrollView.
+   *
+   * DEFAULT FALSE, unlike captureInteractionHeatmap above, and the difference is deliberate.
+   * That flag changes what the SDK records about the host; this one changes what the HOST
+   * RENDERS — every scroll view in the app, including ones inside third-party libraries the app
+   * did not write, starts routing through an SDK component. The failure mode is not a wrong
+   * number in a dashboard, it is the host's UI behaving differently because an analytics SDK
+   * replaced a primitive. That is a decision an integrator makes deliberately, not one they
+   * discover afterwards.
+   *
+   * With it off, a plain <ScrollView> yields no content depth and the tap says so
+   * (scroll_source: 'none') rather than defaulting its offset to 0.
+   */
+  autoInstrumentScrollViews: bool(false),
+  // Opt-in: intercept console.* and ship the lines to the Diagnose → Logs lane in SaaS
+  // mode. OFF by default — console output can carry PII/secrets and adds ingest volume,
+  // so capturing it is the host's explicit choice, not a silent default. When true and a
+  // clientKey is present, the bootstrapper arms the console integration (previously only
+  // reachable through the desktop-debug tooling, so stock SaaS apps captured nothing).
+  captureConsoleLogs: bool(false),
+  ota: {
+    kind: 'obj',
+    opt: true,
+    shape: {
+      enabled: bool(false),
+      checkOnForeground: bool(true),
+      channelOverride: {
+        kind: 'str',
+        opt: true
+      },
+      // No signing-key fields: signed releases are verified natively against
+      // RSA keys embedded in the app package (SB-OTA-RSA-SHA256-V1). JS must
+      // not supply a trusted key.
+      mandatoryBlocksUi: bool(false),
+      // Root/jailbreak policy. Optional with NO default on purpose: the
+      // effective default ('allow') is applied where the orchestrator is
+      // initialised, so the normalized config keeps saying "the host said
+      // nothing" rather than asserting a choice the host never made.
+      // Flipping this to 'withhold' by default would silently stop updates
+      // for every existing app.
+      onCompromisedDevice: {
+        kind: 'enum',
+        values: ['allow', 'withhold'],
+        opt: true
+      }
+    }
+  }
+};
+
+// ─── Engine ─────────────────────────────────────────────────────────────────────
+
+const typeofName = v => v === null ? 'null' : Array.isArray(v) ? 'array' : typeof v;
+function parseField(field, input, path, issues) {
+  const fail = message => {
+    issues.push({
+      path,
+      message
+    });
+    return {
+      ok: false,
+      present: true
+    };
+  };
+  if (input === undefined) {
+    if ('opt' in field && field.opt) return {
+      ok: true,
+      present: false
+    };
+    if (field.kind === 'any') return {
+      ok: true,
+      value: field.def(),
+      present: true
+    };
+    if (field.kind === 'obj' && field.def) return parseField({
+      ...field,
+      def: undefined
+    }, {}, path, issues);
+    if ('def' in field && field.def !== undefined) return {
+      ok: true,
+      value: field.def,
+      present: true
+    };
+    // Required with no default (matches the base schemas' type errors on undefined).
+    return fail(field.kind === 'bool' ? 'Expected boolean, received undefined' : field.kind === 'num' ? 'Expected number, received undefined' : field.kind === 'str' ? 'Expected string, received undefined' : field.kind === 'strArr' ? 'Expected array, received undefined' : field.kind === 'enum' ? "Invalid enum value. Expected " + field.values.map(v => `'${v}'`).join(' | ') : 'Expected object, received undefined');
+  }
+  switch (field.kind) {
+    case 'any':
+      return {
+        ok: true,
+        value: input,
+        present: true
+      };
+    case 'bool':
+      if (typeof input !== 'boolean') return fail(`Expected boolean, received ${typeofName(input)}`);
+      return {
+        ok: true,
+        value: input,
+        present: true
+      };
+    case 'str':
+      if (typeof input !== 'string') return fail(`Expected string, received ${typeofName(input)}`);
+      if (field.min !== undefined && input.length < field.min) {
+        return fail(`String must contain at least ${field.min} character(s)`);
+      }
+      return {
+        ok: true,
+        value: input,
+        present: true
+      };
+    case 'strArr':
+      {
+        // Mirrors the vendored ArraySchema exactly: element failures are
+        // reported at their index and fail the whole field (no partial
+        // arrays reach the output).
+        if (!Array.isArray(input)) return fail(`Expected array, received ${typeofName(input)}`);
+        let allOk = true;
+        for (let i = 0; i < input.length; i++) {
+          if (typeof input[i] !== 'string') {
+            issues.push({
+              path: [...path, i],
+              message: `Expected string, received ${typeofName(input[i])}`
+            });
+            allOk = false;
+          }
+        }
+        return allOk ? {
+          ok: true,
+          value: [...input],
+          present: true
+        } : {
+          ok: false,
+          present: true
+        };
+      }
+    case 'num':
+      if (typeof input !== 'number' || Number.isNaN(input)) {
+        return fail(`Expected number, received ${typeofName(input)}`);
+      }
+      if (field.int && !Number.isInteger(input)) return fail('Expected integer, received float');
+      if (field.min !== undefined && input < field.min) {
+        return fail(`Number must be greater than or equal to ${field.min}`);
+      }
+      if (field.max !== undefined && input > field.max) {
+        return fail(`Number must be less than or equal to ${field.max}`);
+      }
+      return {
+        ok: true,
+        value: input,
+        present: true
+      };
+    case 'enum':
+      if (typeof input !== 'string' || !field.values.includes(input)) {
+        return fail(`Invalid enum value. Expected ${field.values.map(v => `'${v}'`).join(' | ')}`);
+      }
+      return {
+        ok: true,
+        value: input,
+        present: true
+      };
+    case 'obj':
+      {
+        if (typeofName(input) !== 'object') return fail(`Expected object, received ${typeofName(input)}`);
+        const src = input;
+        const out = {};
+        let ok = true;
+        for (const key of Object.keys(field.shape)) {
+          const r = parseField(field.shape[key], src[key], [...path, key], issues);
+          if (!r.ok) ok = false;
+          // Mirrors ObjectSchema: keep defined results, and explicit `key in input`
+          // occurrences even when the parsed value is undefined (optional present-but-
+          // undefined keys survive as own properties, exactly like the old parser).
+          else if (r.value !== undefined || key in src) {
+            if (r.present || key in src) out[key] = r.value;
+          }
+        }
+        // Unknown keys are stripped (Zod's default `.strip()` behaviour).
+        return ok ? {
+          ok: true,
+          value: out,
+          present: true
+        } : {
+          ok: false,
+          present: true
+        };
+      }
+  }
+}
+
+/** The one root-level cross-field rule (was `.refine(...)` on the old schema). */
+const ROOT_REFINE_MESSAGE = 'Either clientKey (SaaS mode) or both projectId and publishableKey (legacy mode) are required';
+const ConfigSchema = exports.ConfigSchema = {
+  safeParse(input) {
+    const issues = [];
+    const r = parseField({
+      kind: 'obj',
+      shape: SHAPE
+    }, input, [], issues);
+    if (r.ok && issues.length === 0) {
+      const data = r.value;
+      if (!(!!data.clientKey || !!data.projectId && !!data.publishableKey)) {
+        issues.push({
+          path: [],
+          message: ROOT_REFINE_MESSAGE
+        });
+        return {
+          success: false,
+          error: new ConfigValidationError(issues)
+        };
+      }
+      return {
+        success: true,
+        data
+      };
+    }
+    return {
+      success: false,
+      error: new ConfigValidationError(issues)
+    };
+  },
+  parse(input) {
+    const r = this.safeParse(input);
+    if (!r.success) throw r.error;
+    return r.data;
+  }
+};
+
+// ─── Output type (was Infer<typeof ConfigSchema>) ──────────────────────────────
+
+// Re-export config types from contracts for consumers migrating to new import paths
+//# sourceMappingURL=schema.js.map

package/lib/commonjs/core/constants/endpoints.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DEFAULT_API_BASE_URL = void 0;
+/**
+ * ScaleBun cloud API base URL — the single, LOCKED endpoint for the SDK.
+ *
+ * `SDKBootstrapper` ignores any `apiBaseUrl` passed in init config and always
+ * uses this value, so an integrator cannot repoint the SDK at another backend.
+ * Includes the `/api/v1` path segment because every SDK route is built relative
+ * to this base (e.g. `${apiBaseUrl}/batch`, `${apiBaseUrl}/ingestion/sessions`,
+ * `${apiBaseUrl}/config`). Without `/api/v1` the ingestion routes return 404 and
+ * events are silently lost. To target a staging or self-hosted backend, change
+ * this value at build time.
+ */
+const DEFAULT_API_BASE_URL = exports.DEFAULT_API_BASE_URL = 'https://api.scalebun.com/api/v1';
+//# sourceMappingURL=endpoints.js.map

package/lib/commonjs/core/constants/protocol.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PROTOCOL_VERSION = exports.DEFAULT_HEARTBEAT_INTERVAL_MS = void 0;
+/**
+ * ScaleBun SDK — Debug-protocol constants needed OUTSIDE the debug lane.
+ *
+ * `PROTOCOL_VERSION` is stamped onto journey/session envelopes by production code
+ * (journeyManager, DesktopSessionTransport). Importing it from `vendor/protocol` — its canonical
+ * home — drags the whole vendored schema module into every production bundle, because that module
+ * builds all desktop wire-message schemas at module scope and Metro performs no tree shaking.
+ * Measured: 4,240 bytes of minified schema code shipped for the sake of two numeric constants.
+ *
+ * So the two constants are declared here, dependency-free, and production code imports THIS file.
+ * The vendored module keeps re-exporting its own copies for the debug lane, which is the only
+ * place the schemas themselves are used.
+ *
+ * The vendored file itself is deliberately untouched — `vendor/protocol` is a byte-identical copy
+ * of `@scalebun/protocol` enforced by parity gates, so the values are duplicated here rather than
+ * re-exported. `core/constants/__tests__/protocolConstants.test.ts` asserts both copies stay
+ * equal; if the canonical protocol bumps a value, that test fails until this file follows.
+ */
+
+/** Wire-protocol version stamped on every desktop-debug and journey envelope. */
+const PROTOCOL_VERSION = exports.PROTOCOL_VERSION = 1;
+
+/** Heartbeat interval sent in ACK; the SDK uses this for its ping timer. */
+const DEFAULT_HEARTBEAT_INTERVAL_MS = exports.DEFAULT_HEARTBEAT_INTERVAL_MS = 5000;
+//# sourceMappingURL=protocol.js.map

package/lib/commonjs/core/constants/timings.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DEBUG_READY_EMIT_DELAY_MS = void 0;
+Object.defineProperty(exports, "DEFAULT_HEARTBEAT_INTERVAL_MS", {
+  enumerable: true,
+  get: function () {
+    return _protocol.DEFAULT_HEARTBEAT_INTERVAL_MS;
+  }
+});
+exports.TRANSPORT_RECONNECT_MAX_MS = exports.TRANSPORT_RECONNECT_BASE_MS = exports.TRANSPORT_MAX_RECONNECT_ATTEMPTS = exports.TRANSPORT_MAX_BUFFER_SIZE = exports.TRANSPORT_HIGH_LATENCY_WARN_MS = exports.DEFAULT_WS_PORT = void 0;
+var _protocol = require("./protocol");
+/**
+ * ScaleBun SDK — Timing & Transport Constants
+ *
+ * Named exports for every magic number in the SDK debug transport layer.
+ * Import from here instead of using inline literals.
+ */
+
+// From the SDK-owned constants copy, NOT vendor/protocol — importing the vendored module here
+// would ship every desktop wire-message schema in every production bundle. See ./protocol.ts.
+
+/** Default WebSocket port when no port is specified in DebugConfig */
+const DEFAULT_WS_PORT = exports.DEFAULT_WS_PORT = 9333;
+/** Maximum messages to buffer in transport while disconnected */
+const TRANSPORT_MAX_BUFFER_SIZE = exports.TRANSPORT_MAX_BUFFER_SIZE = 500;
+/** Give up reconnecting after this many failed attempts */
+const TRANSPORT_MAX_RECONNECT_ATTEMPTS = exports.TRANSPORT_MAX_RECONNECT_ATTEMPTS = 20;
+/** Base delay (ms) for exponential reconnect backoff */
+const TRANSPORT_RECONNECT_BASE_MS = exports.TRANSPORT_RECONNECT_BASE_MS = 250;
+/** Maximum delay (ms) cap for exponential reconnect backoff */
+const TRANSPORT_RECONNECT_MAX_MS = exports.TRANSPORT_RECONNECT_MAX_MS = 5000;
+/** Pong round-trip threshold (ms) above which a high-latency warning is logged */
+const TRANSPORT_HIGH_LATENCY_WARN_MS = exports.TRANSPORT_HIGH_LATENCY_WARN_MS = 1000;
+/** Delay (ms) before emitting debug_ready after connection is established */
+const DEBUG_READY_EMIT_DELAY_MS = exports.DEBUG_READY_EMIT_DELAY_MS = 500;
+//# sourceMappingURL=timings.js.map

package/lib/commonjs/core/constants/version.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SDK_VERSION = void 0;
+/**
+ * ScaleBun SDK version. Sent with the session-start envelope so the dashboard
+ * can attribute telemetry to the SDK build that produced it.
+ * Keep in sync with package.json "version" — `version.test.ts` fails when they drift.
+ *
+ * Why the test matters: the 1.11.0 bump missed this line, so the build would have reported itself as
+ * 1.10.6. Every "is the release live, and on what share of traffic" question is answered from this
+ * value, so a stale one makes a rollout unobservable — which is the exact problem sending an SDK
+ * version was introduced to solve.
+ */
+const SDK_VERSION = exports.SDK_VERSION = '2.5.0';
+//# sourceMappingURL=version.js.map

package/lib/commonjs/core/context/app.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=app.js.map