@scalebun-release/react-native 2.5.0

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

@@ -0,0 +1,124 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DesktopSessionTransport = void 0;
+var _protocol = require("../../core/constants/protocol");
+var _internalLogger = require("../../core/logger/internalLogger");
+var _sessionTypes = require("./sessionTypes");
+/**
+ * ScaleBun SDK — Desktop Session Transport
+ *
+ * Implements SessionTransport by wrapping the existing DebugTransport.
+ * Maps unified domain objects → protocol EventMessages with category 'session'.
+ *
+ * imageRef is an artifact reference; this transport resolves it to
+ * base64 at the transport boundary when sending frames.
+ *
+ * Never leaks Electron/IPC/Desktop implementation details into the domain layer.
+ */
+
+// The SDK-owned constant, not the debug/protocol shim — the shim re-exports from the vendored
+// schema module, which would pull every desktop wire-message schema into production bundles.
+
+// ─── Desktop Transport Implementation ───────────────────────────────────────
+
+class DesktopSessionTransport {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  sendSessionStart(session) {
+    this._send(_sessionTypes.SESSION_EVENTS.SESSION_START, {
+      sessionId: session.sessionId,
+      deviceId: session.deviceId,
+      startedAt: session.startedAt,
+      metadata: session.metadata,
+      status: session.status
+    });
+  }
+  sendSessionEnd(session) {
+    this._send(_sessionTypes.SESSION_EVENTS.SESSION_END, {
+      sessionId: session.sessionId,
+      endedAt: session.endedAt,
+      status: session.status,
+      metadata: session.metadata,
+      artifactIndex: session.artifactIndex,
+      transportState: session.transportState,
+      syncState: session.syncState
+    });
+  }
+  sendEvent(event) {
+    this._send(_sessionTypes.SESSION_EVENTS.EVENT, {
+      eventId: event.eventId,
+      sessionId: event.sessionId,
+      journeyId: event.journeyId,
+      ts: event.ts,
+      type: event.type,
+      subtype: event.subtype,
+      severity: event.severity,
+      screen: event.screen,
+      payload: event.payload,
+      correlationId: event.correlationId,
+      traceId: event.traceId,
+      source: event.source
+    });
+  }
+
+  /**
+   * Send a replay frame to desktop.
+   * imageData (base64) is resolved at this transport boundary —
+   * the domain frame only carries an artifact reference (imageRef).
+   */
+  sendFrame(frame, imageData) {
+    this._send(_sessionTypes.SESSION_EVENTS.FRAME, {
+      frameId: frame.frameId,
+      sessionId: frame.sessionId,
+      ts: frame.ts,
+      imageRef: frame.imageRef,
+      imageData,
+      // base64 — transport-layer only
+      width: frame.width,
+      height: frame.height,
+      quality: frame.quality,
+      captureReason: frame.captureReason,
+      sourcePlatform: frame.sourcePlatform,
+      redactionState: frame.redactionState,
+      screen: frame.screen // Frame-to-screen correlation
+    });
+  }
+
+  // ─── Internal ───────────────────────────────────────────────────────
+
+  _send(name, data) {
+    try {
+      if (this.transport.getState() !== 'connected') {
+        __DEV__ && _internalLogger.logger.debug(`[DesktopSessionTransport] Not connected, buffering: ${name}`);
+      }
+      const msg = {
+        type: 'event',
+        protocolVersion: _protocol.PROTOCOL_VERSION,
+        deviceId: this.transport.deviceId,
+        sessionId: this.transport.sessionId,
+        timestamp: Date.now(),
+        sequence: this.transport.nextSequence(),
+        payload: {
+          id: generateMessageId(),
+          category: 'session',
+          name,
+          data
+        }
+      };
+      this.transport.send(msg);
+    } catch (err) {
+      _internalLogger.logger.error(`[DesktopSessionTransport] Failed to send ${name}:`, err);
+    }
+  }
+}
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+exports.DesktopSessionTransport = DesktopSessionTransport;
+function generateMessageId() {
+  return `msg-${Date.now().toString(36)}-${Math.random().toString(36).substring(2, 8)}`;
+}
+//# sourceMappingURL=DesktopSessionTransport.js.map

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

@@ -0,0 +1,244 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.JourneyEventPipeline = void 0;
+var _internalLogger = require("../../core/logger/internalLogger");
+var _sessionTypes = require("./sessionTypes");
+/**
+ * ScaleBun SDK — Journey Event Pipeline
+ *
+ * Bounded ring buffer for session events with:
+ * - Configurable max capacity
+ * - Backpressure: drops lowest-priority events when full
+ * - Crash-adjacent/error events are preserved over generic events
+ * - Canonical event creation with deduplication
+ * - Event emission callback for transport
+ */
+
+// ─── Types ──────────────────────────────────────────────────────────────────
+
+const DEFAULT_PIPELINE_CONFIG = {
+  maxEventCount: 1000,
+  crashAnchorWindow: 20,
+  dedupeWindowMs: 100
+};
+
+// ─── Pipeline ───────────────────────────────────────────────────────────────
+
+class JourneyEventPipeline {
+  events = [];
+  onEmit = null;
+
+  /** Set of eventIds that are crash-anchored (never drop) */
+  protectedEventIds = new Set();
+
+  /** Track last event type+subtype+ts+confidence for dedup */
+  lastEventKey = '';
+  lastEventTs = 0;
+  lastEventConfidence = null;
+  constructor(sessionId, config) {
+    this.sessionId = sessionId;
+    this.config = {
+      ...DEFAULT_PIPELINE_CONFIG,
+      ...config
+    };
+  }
+
+  // ─── Public API ─────────────────────────────────────────────────────
+
+  /** Set the callback invoked when an event is added */
+  setEmitCallback(cb) {
+    this.onEmit = cb;
+  }
+
+  /** Get all events (read-only snapshot) */
+  getEvents() {
+    return this.events;
+  }
+
+  /** Current event count */
+  get count() {
+    return this.events.length;
+  }
+
+  /**
+   * Create and add a canonical event.
+   * Handles deduplication, retention, and emission.
+   */
+  emit(type, opts) {
+    try {
+      const key = `${type}:${opts?.subtype ?? ''}`;
+      const receivedAt = Date.now();
+      const occurredAt = opts?.timestamp ?? receivedAt;
+      if (key === this.lastEventKey && receivedAt - this.lastEventTs < this.config.dedupeWindowMs) {
+        // Within dedup window — allow high-confidence native events to
+        // REPLACE a prior low-confidence JS event for the same gesture.
+        // This prevents the race where JS fires first and the pipeline
+        // drops the native event that has more accurate coordinates.
+        const incomingConfidence = opts?.payload?.confidence;
+        if (incomingConfidence === 'high' && this.lastEventConfidence !== 'high') {
+          this._replaceLastEvent(key, receivedAt, opts);
+        }
+        return null;
+      }
+      this.lastEventKey = key;
+      this.lastEventTs = receivedAt;
+      this.lastEventConfidence = opts?.payload?.confidence ?? null;
+      const event = {
+        eventId: generateEventId(),
+        sessionId: this.sessionId,
+        journeyId: opts?.journeyId,
+        ts: occurredAt,
+        type,
+        subtype: opts?.subtype,
+        severity: opts?.severity ?? inferSeverity(type),
+        screen: opts?.screen,
+        frameId: opts?.frameId,
+        payload: opts?.payload,
+        correlationId: opts?.correlationId,
+        traceId: opts?.traceId,
+        source: opts?.source ?? 'sdk'
+      };
+      this._addEvent(event);
+      return event;
+    } catch (err) {
+      _internalLogger.logger.error('[JourneyEventPipeline] emit failed:', err);
+      return null;
+    }
+  }
+
+  /**
+   * Anchor a crash event — protect nearby events from eviction.
+   */
+  anchorCrash(crashEventId) {
+    const crashIdx = this.events.findIndex(e => e.eventId === crashEventId);
+    const window = this.config.crashAnchorWindow;
+    const start = Math.max(0, crashIdx - window);
+    const end = Math.min(this.events.length - 1, crashIdx + window);
+    const nearbyEventIds = [];
+    for (let i = start; i <= end; i++) {
+      nearbyEventIds.push(this.events[i].eventId);
+      this.protectedEventIds.add(this.events[i].eventId);
+    }
+    const crashEvent = crashIdx >= 0 ? this.events[crashIdx] : null;
+    return {
+      crashEventId,
+      nearbyEventIds,
+      nearbyFrameIds: [],
+      // Filled by SessionManager (cross-references frames)
+      timestamp: crashEvent?.ts ?? Date.now()
+    };
+  }
+
+  /**
+   * Build the event portion of the artifact index.
+   */
+  buildEventRefs() {
+    const eventRefs = [];
+    const networkRefs = [];
+    const logRefs = [];
+    for (const e of this.events) {
+      eventRefs.push(e.eventId);
+      if (e.type.startsWith('NETWORK_REQUEST')) {
+        networkRefs.push(e.eventId);
+      }
+      if (e.type === 'LOG_EMITTED') {
+        logRefs.push(e.eventId);
+      }
+    }
+    return {
+      eventRefs,
+      networkRefs,
+      logRefs
+    };
+  }
+
+  /** Clear all events (used on session end) */
+  clear() {
+    this.events = [];
+    this.protectedEventIds.clear();
+    this.lastEventKey = '';
+    this.lastEventTs = 0;
+    this.lastEventConfidence = null;
+  }
+
+  // ─── Internals ──────────────────────────────────────────────────────
+
+  _replaceLastEvent(key, now, opts) {
+    for (let i = this.events.length - 1; i >= 0; i--) {
+      const ev = this.events[i];
+      const evKey = `${ev.type}:${ev.subtype ?? ''}`;
+      if (evKey === key && now - ev.ts < this.config.dedupeWindowMs) {
+        ev.payload = opts?.payload;
+        this.lastEventConfidence = opts?.payload?.confidence ?? null;
+        __DEV__ && _internalLogger.logger.debug('[JourneyEventPipeline] replaced low-confidence event with native-high');
+        // Re-emit so transport receives the corrected coordinates.
+        // Backend uses upsert on eventId, so this overwrites the stale record.
+        try {
+          this.onEmit?.(ev);
+        } catch {/* transport must not crash pipeline */}
+        break;
+      }
+    }
+  }
+  _addEvent(event) {
+    // If at capacity, evict lowest-priority unprotected event
+    if (this.events.length >= this.config.maxEventCount) {
+      this._evictLowestPriority();
+    }
+    this.events.push(event);
+
+    // Emit to transport
+    try {
+      this.onEmit?.(event);
+    } catch {
+      // Transport emission must not crash pipeline
+    }
+  }
+
+  /**
+   * Evict the oldest event with the lowest retention priority,
+   * skipping crash-anchored/protected events.
+   */
+  _evictLowestPriority() {
+    let lowestIdx = -1;
+    let lowestPriority = Infinity;
+    for (let i = 0; i < this.events.length; i++) {
+      const event = this.events[i];
+      // Never evict protected events
+      if (this.protectedEventIds.has(event.eventId)) continue;
+      const priority = (0, _sessionTypes.getEventRetentionPriority)(event.type);
+      if (priority < lowestPriority) {
+        lowestPriority = priority;
+        lowestIdx = i;
+      }
+    }
+    if (lowestIdx >= 0) {
+      this.events.splice(lowestIdx, 1);
+    } else {
+      // All events are protected — drop oldest anyway
+      this.events.shift();
+    }
+  }
+}
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+exports.JourneyEventPipeline = JourneyEventPipeline;
+function generateEventId() {
+  return `evt-${Date.now().toString(36)}-${Math.random().toString(36).substring(2, 8)}`;
+}
+function inferSeverity(type) {
+  switch (type) {
+    case 'CRASH_CAPTURED':
+      return 'fatal';
+    case 'ERROR_CAPTURED':
+      return 'error';
+    case 'NETWORK_REQUEST_FAILED':
+      return 'warning';
+    default:
+      return 'info';
+  }
+}
+//# sourceMappingURL=JourneyEventPipeline.js.map