@scalebun-release/react-native 2.5.0

package/lib/commonjs/features/session/SyncDecisionEngine.js

@@ -0,0 +1,95 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SyncDecisionEngine = void 0;
+var _internalLogger = require("../../core/logger/internalLogger");
+/**
+ * ScaleBun SDK — Sync Decision Engine
+ *
+ * Evaluates session sync eligibility. This engine OWNS the policy —
+ * native layers only gather metadata and expose callback hooks.
+ *
+ * Default behavior in desktop mode: always eligible.
+ * Host apps can provide a custom SyncDecisionCallback for advanced logic.
+ */
+
+// ─── Default Policy ─────────────────────────────────────────────────────────
+
+/**
+ * Default sync decision: always eligible in desktop mode.
+ * Sessions with crashes get high priority.
+ */
+function defaultSyncPolicy(candidate) {
+  // Always eligible locally
+  const priority = candidate.hasCrash ? 'high' : candidate.hasError ? 'normal' : 'low';
+  return {
+    shouldSync: true,
+    reason: 'desktop-mode: always eligible',
+    priority
+  };
+}
+
+// ─── Engine ─────────────────────────────────────────────────────────────────
+
+class SyncDecisionEngine {
+  constructor(customPolicy) {
+    this._policy = customPolicy ?? defaultSyncPolicy;
+  }
+
+  /**
+   * Replace the sync policy callback.
+   * Used by host apps to provide custom eligibility logic.
+   */
+  setPolicy(policy) {
+    this._policy = policy;
+  }
+
+  /**
+   * Evaluate whether a session should be synced.
+   * Native metadata is merged into the candidate before evaluation.
+   *
+   * @param candidate - Session metadata + stats
+   * @param nativeMetadata - Optional metadata gathered by native layer
+   */
+  evaluate(candidate, nativeMetadata) {
+    try {
+      // Merge native metadata if provided
+      const enrichedCandidate = nativeMetadata ? {
+        ...candidate,
+        nativeMetadata
+      } : candidate;
+      const decision = this._policy(enrichedCandidate);
+      __DEV__ && _internalLogger.logger.debug(`[SyncDecisionEngine] Session ${candidate.sessionId}: ` + `shouldSync=${decision.shouldSync}, priority=${decision.priority}, ` + `reason="${decision.reason}"`);
+      return decision;
+    } catch (err) {
+      // Policy must never crash the session flow
+      _internalLogger.logger.error('[SyncDecisionEngine] Policy evaluation failed:', err);
+      return {
+        shouldSync: false,
+        reason: 'policy-error: evaluation threw',
+        priority: 'low'
+      };
+    }
+  }
+
+  /**
+   * Build a SyncCandidate from session state.
+   * Convenience helper to avoid constructing the object manually.
+   */
+  static buildCandidate(sessionId, metadata, eventCount, frameCount, durationMs, hasCrash, hasError, nativeMetadata) {
+    return {
+      sessionId,
+      metadata,
+      nativeMetadata,
+      eventCount,
+      frameCount,
+      durationMs,
+      hasCrash,
+      hasError
+    };
+  }
+}
+exports.SyncDecisionEngine = SyncDecisionEngine;
+//# sourceMappingURL=SyncDecisionEngine.js.map

package/lib/commonjs/features/session/frameLink.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FRAME_OFFSET_TOL = void 0;
+exports.frameLinkVerdict = frameLinkVerdict;
+/**
+ * SHOULD THIS TAP BE LINKED TO THIS KEYFRAME?
+ *
+ * A tap is stamped with the last keyframe of its screen (≤10 s old). Once frames carry the scroll
+ * containers visible in them, that link can be CHECKED instead of assumed: a tap made after the list
+ * was scrolled is not a tap on the picture taken before the scroll, and linking the two presents a
+ * different row as the one that was tapped.
+ *
+ *   'linked'      the frame shows the tap's scroll container at the same offset (±4), or the tap was
+ *                 not in a scroll container
+ *   'unverified'  the tap was in a container but the frame carries no scroll record (older native
+ *                 build) — linked, and marked so a reader knows it was not checked
+ *   'scroll_moved' the frame shows the container at another offset, or does not show it: NOT linked
+ *   'none'        there was no fresh keyframe of this screen
+ */
+
+const FRAME_OFFSET_TOL = exports.FRAME_OFFSET_TOL = 4;
+function frameLinkVerdict(frame, tapScroll) {
+  if (!frame) return 'none';
+  const chain = Array.isArray(tapScroll) ? tapScroll : [];
+  const inner = chain[0];
+  if (!inner || typeof inner.offsetX !== 'number' || typeof inner.offsetY !== 'number') return 'linked';
+  if (!frame.scrollState) return 'unverified';
+  if (inner.containerTag == null) return 'unverified';
+  const same = frame.scrollState.find(e => e.containerTag === inner.containerTag);
+  if (!same || typeof same.offsetX !== 'number' || typeof same.offsetY !== 'number') return 'scroll_moved';
+  return Math.abs(same.offsetX - inner.offsetX) <= FRAME_OFFSET_TOL && Math.abs(same.offsetY - inner.offsetY) <= FRAME_OFFSET_TOL ? 'linked' : 'scroll_moved';
+}
+//# sourceMappingURL=frameLink.js.map

package/lib/commonjs/features/session/frameScrollState.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MAX_FRAME_SCROLL_ENTRIES = void 0;
+exports.sanitizeFrameScrollState = sanitizeFrameScrollState;
+var _nativeScroll = require("../journey/nativeScroll");
+/**
+ * A FRAME'S SCROLL STATE — every visible scroll container at the moment the screenshot was taken.
+ *
+ * A frame that carries only width/height cannot say whether a tap belongs on it: a tap inside a
+ * list scrolled 900px lands on different content than the same point on a frame taken at offset 0.
+ * Native reads the visible scroll containers on the main thread immediately before the pixels
+ * (Android ScrollContextProbe.snapshot, iOS ScreenshotCaptureManager.visibleScrollState), with the
+ * same keys as a tap's `scrollContext`, so a tap is compatible with a frame when its container
+ * reports the same offset in both.
+ *
+ * Units follow the tap on each platform: Android capture-view pixels, iOS points.
+ *
+ * `undefined` = not measured (old native binary, or a snapshot that failed). `[]` = measured and
+ * no scroll container was on screen. The two are never collapsed: an absent measurement must not
+ * read as "nothing scrolls here".
+ */
+
+/** Same cap as the native side and the backend DTO. */
+const MAX_FRAME_SCROLL_ENTRIES = exports.MAX_FRAME_SCROLL_ENTRIES = 4;
+
+/**
+ * Keep only well-formed entries (finite offsets; other numeric fields dropped unless finite),
+ * at most 4. A non-array is "not measured" and stays undefined; a malformed payload must never
+ * become a fabricated offset.
+ */
+function sanitizeFrameScrollState(raw) {
+  if (!Array.isArray(raw)) return undefined;
+  const clean = (0, _nativeScroll.sanitizeScrollContext)(raw).slice(0, MAX_FRAME_SCROLL_ENTRIES);
+  // Entries were present but none survived: that is an unreadable measurement, not "none on screen".
+  if (raw.length > 0 && clean.length === 0) return undefined;
+  return clean;
+}
+//# sourceMappingURL=frameScrollState.js.map

package/lib/commonjs/features/session/index.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "DEFAULT_SESSION_REPLAY_CONFIG", {
+  enumerable: true,
+  get: function () {
+    return _sessionTypes.DEFAULT_SESSION_REPLAY_CONFIG;
+  }
+});
+Object.defineProperty(exports, "DesktopSessionTransport", {
+  enumerable: true,
+  get: function () {
+    return _DesktopSessionTransport.DesktopSessionTransport;
+  }
+});
+Object.defineProperty(exports, "EventRetentionPriority", {
+  enumerable: true,
+  get: function () {
+    return _sessionTypes.EventRetentionPriority;
+  }
+});
+Object.defineProperty(exports, "FrameRetentionPriority", {
+  enumerable: true,
+  get: function () {
+    return _sessionTypes.FrameRetentionPriority;
+  }
+});
+Object.defineProperty(exports, "JourneyEventPipeline", {
+  enumerable: true,
+  get: function () {
+    return _JourneyEventPipeline.JourneyEventPipeline;
+  }
+});
+Object.defineProperty(exports, "QUALITY_PRESETS", {
+  enumerable: true,
+  get: function () {
+    return _sessionTypes.QUALITY_PRESETS;
+  }
+});
+Object.defineProperty(exports, "ReplayCaptureManager", {
+  enumerable: true,
+  get: function () {
+    return _ReplayCaptureManager.ReplayCaptureManager;
+  }
+});
+Object.defineProperty(exports, "SESSION_EVENTS", {
+  enumerable: true,
+  get: function () {
+    return _sessionTypes.SESSION_EVENTS;
+  }
+});
+Object.defineProperty(exports, "SessionManager", {
+  enumerable: true,
+  get: function () {
+    return _SessionManager.SessionManager;
+  }
+});
+Object.defineProperty(exports, "SyncDecisionEngine", {
+  enumerable: true,
+  get: function () {
+    return _SyncDecisionEngine.SyncDecisionEngine;
+  }
+});
+Object.defineProperty(exports, "getEventRetentionPriority", {
+  enumerable: true,
+  get: function () {
+    return _sessionTypes.getEventRetentionPriority;
+  }
+});
+Object.defineProperty(exports, "getFrameRetentionPriority", {
+  enumerable: true,
+  get: function () {
+    return _sessionTypes.getFrameRetentionPriority;
+  }
+});
+var _sessionTypes = require("./sessionTypes");
+var _SessionManager = require("./SessionManager");
+var _JourneyEventPipeline = require("./JourneyEventPipeline");
+var _ReplayCaptureManager = require("./ReplayCaptureManager");
+var _DesktopSessionTransport = require("./DesktopSessionTransport");
+var _SyncDecisionEngine = require("./SyncDecisionEngine");
+//# sourceMappingURL=index.js.map

package/lib/commonjs/features/session/nativeCapture.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.nativeCapture = void 0;
+var _device = require("../../core/context/device");
+var _frameScrollState = require("./frameScrollState");
+/**
+ * ScaleBun SDK — Native Frame Capture
+ *
+ * Provides the callback for the SessionManager to request screenshots
+ * from the native layer (PixelCopy on Android, UIWindow on iOS).
+ */
+
+const nativeCapture = async (sessionId, reason, _quality) => {
+  try {
+    // Resolve via the TurboModule-aware accessor (New Arch / bridgeless).
+    // Reading raw `NativeModules.ReplaySdk` returns null under bridgeless New
+    // Architecture, so frame capture silently no-ops → 0 frames.
+    const {
+      getReplaySdkNative
+    } = require('../replay/bridge/nativeModule');
+    const replaySdk = getReplaySdkNative();
+    if (!replaySdk?.captureScreenshot) return null;
+    const result = await replaySdk.captureScreenshot(reason);
+    if (!result?.base64) return null;
+
+    // Platform.OS verbatim. The ternary this replaces labelled every non-iOS frame 'android'.
+    const platform = (0, _device.resolvePlatformOS)();
+    // Visible scroll containers read beside the pixels; undefined when native did not measure.
+    const scrollState = (0, _frameScrollState.sanitizeFrameScrollState)(result.scrollState);
+    return {
+      base64: result.base64,
+      width: result.width ?? 0,
+      height: result.height ?? 0,
+      byteSize: result.sizeBytes ?? result.byteSize ?? 0,
+      // P2-2: actual on-device encoding after the AVIF->WebP->JPEG fallback.
+      format: result.format ?? 'jpeg',
+      // P2-1: native-provided change-detection hash (perceptual or content);
+      // undefined when native doesn't supply one (JS falls back to base64 hash).
+      frameHash: result.frameHash,
+      platform,
+      ...(scrollState ? {
+        scrollState
+      } : {})
+    };
+  } catch {
+    return null;
+  }
+};
+exports.nativeCapture = nativeCapture;
+//# sourceMappingURL=nativeCapture.js.map

package/lib/commonjs/features/session/outboxFrameCapture.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeOutboxFrameCapture = makeOutboxFrameCapture;
+var _nativeModule = require("../replay/bridge/nativeModule");
+var _device = require("../../core/context/device");
+var _frameScrollState = require("./frameScrollState");
+/**
+ * ScaleBun SDK — Native File-Outbox Frame Capture Adapter
+ *
+ * Wraps the native staged-frame bridge for ReplayCaptureManager. The capture step
+ * captures + masks + encodes natively and STAGES the image (no upload marker), so
+ * the JS orchestrator keeps full ownership of sequencing / keyframe-delta /
+ * change-detection. The orchestrator then commits (writes JS-authoritative meta →
+ * uploadable) or discards (suppressed) the staged frame.
+ *
+ * No frame bytes/base64 ever cross the bridge on this path — capture returns
+ * metadata + a native content hash only.
+ *
+ * Every method is no-throw and gated by a readiness check so that with the flag
+ * off (or an old native binary) `capture` returns null and ReplayCaptureManager
+ * transparently falls back to the legacy `captureScreenshot` path.
+ */
+
+/** Build the adapter. `ensureReady` resolves false when the native outbox is off. */
+function makeOutboxFrameCapture(ensureReady) {
+  // Platform.OS verbatim — see core/context/device.
+  const platform = (0, _device.resolvePlatformOS)();
+  return {
+    async capture(sessionId, screenName, trigger) {
+      try {
+        if (!(await ensureReady())) return null;
+        const native = (0, _nativeModule.getReplaySdkNative)();
+        if (!native?.captureScreenshotToFile) return null;
+        const res = await native.captureScreenshotToFile({
+          sessionId,
+          screenName: screenName ?? 'unknown',
+          trigger
+        });
+        if (!res) return null;
+        // Visible scroll containers read beside the pixels; undefined when not measured.
+        const scrollState = (0, _frameScrollState.sanitizeFrameScrollState)(res.scrollState);
+        return {
+          frameId: res.frameId,
+          width: res.width,
+          height: res.height,
+          byteSize: res.sizeBytes,
+          format: res.format,
+          contentType: res.contentType,
+          frameHash: res.frameHash,
+          masked: res.masked,
+          timestamp: res.timestamp,
+          platform,
+          ...(scrollState ? {
+            scrollState
+          } : {})
+        };
+      } catch {
+        return null;
+      }
+    },
+    async commit(meta) {
+      try {
+        const native = (0, _nativeModule.getReplaySdkNative)();
+        if (!native?.commitOutboxFrame) return false;
+        const path = await native.commitOutboxFrame(meta);
+        return path != null;
+      } catch {
+        return false;
+      }
+    },
+    async discard(sessionId, frameId) {
+      try {
+        await (0, _nativeModule.getReplaySdkNative)()?.discardOutboxFrame?.(sessionId, frameId);
+      } catch {
+        /* no-throw */
+      }
+    }
+  };
+}
+//# sourceMappingURL=outboxFrameCapture.js.map

package/lib/commonjs/features/session/sessionTypes.js

@@ -0,0 +1,230 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SESSION_EVENTS = exports.QUALITY_PRESETS = exports.FrameRetentionPriority = exports.EventRetentionPriority = exports.DEFAULT_SESSION_REPLAY_CONFIG = void 0;
+exports.getEventRetentionPriority = getEventRetentionPriority;
+exports.getFrameRetentionPriority = getFrameRetentionPriority;
+/**
+ * ScaleBun SDK — Unified Session Domain Model
+ *
+ * Single source of truth for event types, frame types, session lifecycle,
+ * transport contracts, sync contracts, capture configuration, and artifact indexing.
+ *
+ * Architecture rules:
+ * - imageRef in ReplayFrame is an artifact reference (ID/path), NOT base64.
+ *   Base64 is transport-layer detail only.
+ * - SyncDecisionEngine in the SDK owns sync policy; native only gathers metadata.
+ * - Frame capture is native-only (PixelCopy on Android, UIWindow on iOS).
+ *   No JS screenshot fallback for session replay.
+ * - Frame retention prefers crash-adjacent/error-context frames over generic old frames.
+ */
+
+// ─── Session ────────────────────────────────────────────────────────────────
+
+// ─── Journey Event ──────────────────────────────────────────────────────────
+
+// ─── Replay Frame ───────────────────────────────────────────────────────────
+
+/**
+ * imageRef is an ARTIFACT REFERENCE (opaque ID/path), not raw base64.
+ * Base64 content is a transport/storage detail resolved separately.
+ * This keeps the domain model transport-agnostic.
+ */
+
+// ─── Session Artifact Index ─────────────────────────────────────────────────
+
+// ─── Capture Configuration ──────────────────────────────────────────────────
+
+/** When to capture frames */
+
+/** Frame quality presets — maps to native JPEG compression */
+
+/** Quality preset → concrete capture parameters (used by native engines) */
+const QUALITY_PRESETS = exports.QUALITY_PRESETS = {
+  high: {
+    maxWidth: 0,
+    jpegQuality: 90
+  },
+  // 0 = full width
+  normal: {
+    maxWidth: 720,
+    jpegQuality: 70
+  },
+  low: {
+    maxWidth: 480,
+    jpegQuality: 40
+  },
+  grayscale: {
+    maxWidth: 720,
+    jpegQuality: 60
+  } // native applies grayscale conversion
+};
+const DEFAULT_SESSION_REPLAY_CONFIG = exports.DEFAULT_SESSION_REPLAY_CONFIG = {
+  captureMode: 'navigation',
+  quality: 'normal',
+  intervalMs: 2000,
+  includeNetworkLogs: true,
+  includeSdkLogs: false,
+  includeUserSteps: true,
+  maxFrames: 200,
+  maxEventCount: 1000,
+  maxDurationMs: 10 * 60 * 1000,
+  // 10 minutes
+  privacyPolicy: {
+    redactTextInputs: true,
+    redactImages: false,
+    blockTestIds: [],
+    captureExclusions: []
+  },
+  // P2 capture knobs
+  changeDetection: true,
+  changeSensitivity: 0,
+  maxKeyframeIntervalMs: 5000,
+  frameFormatPreference: ['avif', 'webp', 'jpeg'],
+  frameQuality: 55,
+  deltaEncoding: false,
+  deltaKeyframeInterval: 10,
+  activitySampling: true
+};
+
+// ─── Transport Contracts ────────────────────────────────────────────────────
+
+/**
+ * SessionTransport abstraction.
+ * DesktopSessionTransport implements this now.
+ * RemoteDashboardSessionTransport will implement this later.
+ * Core session logic never knows transport details.
+ */
+
+// ─── Sync Decision Contracts ────────────────────────────────────────────────
+
+/**
+ * Metadata gathered by NATIVE layer, passed to SDK for sync decision.
+ * Native only gathers; SDK's SyncDecisionEngine owns the eligibility policy.
+ */
+
+/**
+ * Candidate presented to SyncDecisionEngine for eligibility evaluation.
+ */
+
+/**
+ * Callback type for custom sync eligibility evaluation.
+ * The SDK provides a default implementation; host apps can override.
+ */
+
+// ─── Native Capture Result ──────────────────────────────────────────────────
+
+/**
+ * Result returned by native capture engine.
+ * base64 is transient — used at the transport boundary, NOT stored in domain as imageRef.
+ */
+
+/**
+ * Native device/session metadata result.
+ */
+// ─── Frame Retention Policy ─────────────────────────────────────────────────
+/**
+ * Priority levels for frame retention when buffer is full.
+ * Higher priority frames are kept longer.
+ *
+ * CRASH_ADJACENT and ERROR_CONTEXT frames are NEVER dropped before
+ * generic NAVIGATION/INTERACTION/FREQUENCY frames.
+ */
+let FrameRetentionPriority = exports.FrameRetentionPriority = /*#__PURE__*/function (FrameRetentionPriority) {
+  /** Lowest: regular periodic captures */
+  FrameRetentionPriority[FrameRetentionPriority["FREQUENCY"] = 0] = "FREQUENCY";
+  /** Low: regular navigation frames */
+  FrameRetentionPriority[FrameRetentionPriority["NAVIGATION"] = 1] = "NAVIGATION";
+  /** Medium: interaction-triggered frames */
+  FrameRetentionPriority[FrameRetentionPriority["INTERACTION"] = 2] = "INTERACTION";
+  /** Medium-high: manually triggered captures */
+  FrameRetentionPriority[FrameRetentionPriority["MANUAL"] = 3] = "MANUAL";
+  /** High: captured in response to an error event */
+  FrameRetentionPriority[FrameRetentionPriority["ERROR_CONTEXT"] = 4] = "ERROR_CONTEXT";
+  /** Highest: adjacent to a crash event — never drop before others */
+  FrameRetentionPriority[FrameRetentionPriority["CRASH_ADJACENT"] = 5] = "CRASH_ADJACENT";
+  return FrameRetentionPriority;
+}({});
+/** Map CaptureReason → retention priority */
+function getFrameRetentionPriority(reason) {
+  switch (reason) {
+    case 'error-context':
+      return FrameRetentionPriority.ERROR_CONTEXT;
+    case 'manual':
+      return FrameRetentionPriority.MANUAL;
+    case 'interaction':
+      return FrameRetentionPriority.INTERACTION;
+    case 'screen_loaded':
+      return FrameRetentionPriority.INTERACTION;
+    // Same priority as interaction
+    case 'scroll':
+      return FrameRetentionPriority.INTERACTION;
+    case 'navigation':
+      return FrameRetentionPriority.NAVIGATION;
+    case 'frequency':
+      return FrameRetentionPriority.FREQUENCY;
+  }
+}
+
+// ─── Session Protocol Event Names ───────────────────────────────────────────
+
+const SESSION_EVENTS = exports.SESSION_EVENTS = {
+  SESSION_START: 'session:start',
+  SESSION_END: 'session:end',
+  EVENT: 'session:event',
+  FRAME: 'session:frame'
+};
+
+// ─── Event Retention Policy ─────────────────────────────────────────────────
+
+/**
+ * Priority levels for event retention when buffer is full.
+ * Crash/error events are NEVER dropped before generic events.
+ */
+let EventRetentionPriority = exports.EventRetentionPriority = /*#__PURE__*/function (EventRetentionPriority) {
+  EventRetentionPriority[EventRetentionPriority["LOG"] = 0] = "LOG";
+  EventRetentionPriority[EventRetentionPriority["NETWORK"] = 1] = "NETWORK";
+  EventRetentionPriority[EventRetentionPriority["LIFECYCLE"] = 2] = "LIFECYCLE";
+  EventRetentionPriority[EventRetentionPriority["SCREEN_VIEW"] = 3] = "SCREEN_VIEW";
+  EventRetentionPriority[EventRetentionPriority["USER_ACTION"] = 4] = "USER_ACTION";
+  EventRetentionPriority[EventRetentionPriority["ERROR"] = 5] = "ERROR";
+  EventRetentionPriority[EventRetentionPriority["CRASH"] = 6] = "CRASH";
+  return EventRetentionPriority;
+}({});
+/** Map JourneyEventType → retention priority */
+function getEventRetentionPriority(type) {
+  switch (type) {
+    case 'LOG_EMITTED':
+      return EventRetentionPriority.LOG;
+    case 'NETWORK_REQUEST_STARTED':
+    case 'NETWORK_REQUEST_COMPLETED':
+    case 'NETWORK_REQUEST_FAILED':
+      return EventRetentionPriority.NETWORK;
+    case 'APP_FOREGROUND':
+    case 'APP_BACKGROUND':
+    case 'SESSION_STARTED':
+    case 'SESSION_ENDED':
+    case 'LOADING_STARTED':
+    case 'LOADING_COMPLETED':
+      return EventRetentionPriority.LIFECYCLE;
+    // An exit is the other half of a view and carries the dwell time, so it retains together with
+    // it — dropping exits first would leave entries whose duration can never be recovered.
+    case 'SCREEN_VIEW':
+    case 'SCREEN_EXIT':
+      return EventRetentionPriority.SCREEN_VIEW;
+    case 'USER_ACTION':
+    case 'REPLAY_FRAME_CAPTURED':
+      return EventRetentionPriority.USER_ACTION;
+    case 'ERROR_CAPTURED':
+      return EventRetentionPriority.ERROR;
+    case 'CRASH_CAPTURED':
+      return EventRetentionPriority.CRASH;
+  }
+}
+
+// ─── Re-exports from contracts ──────────────────────────────────────────────
+// Pure types are now canonical in @scalebun/sdk-contracts.
+// Runtime values (enums, constants, functions) remain here.
+//# sourceMappingURL=sessionTypes.js.map