@scalebun-release/react-native 2.5.0

package/lib/module/features/journey/impression.js

@@ -0,0 +1,84 @@
+/**
+ * Impressions — "this element was actually seen".
+ *
+ * THE GAP. Web has had `$impression` via an IntersectionObserver on `[data-scalebun-track-impression]`
+ * since A2; mobile had no equivalent, so feed, carousel and list analytics ("was the promo ever on
+ * screen before they bounced?") were impossible. React Native has no IntersectionObserver, and there is
+ * no way for the SDK to observe an arbitrary host view without being mounted inside it — so, exactly
+ * like web, this is OPT-IN: the host marks what it wants counted.
+ *
+ * WHY THE MATH IS HERE. The viewability rule is pure geometry, and geometry is the part that is easy to
+ * get subtly wrong (a view scrolled half off the top is not "seen"). Keeping it in a plain function
+ * means it is unit-testable without a renderer, and the component around it stays a thin shell.
+ */
+
+/** Fraction of `el` that lies inside `viewport`, 0–1. Zero for degenerate or off-screen rects. */
+export function visibleFraction(el, viewport) {
+  const area = el.width * el.height;
+  // A zero-area view cannot be "50% visible" — any ratio would be a divide-by-zero dressed up.
+  if (!(area > 0)) return 0;
+  const left = Math.max(el.x, viewport.x);
+  const right = Math.min(el.x + el.width, viewport.x + viewport.width);
+  const top = Math.max(el.y, viewport.y);
+  const bottom = Math.min(el.y + el.height, viewport.y + viewport.height);
+  const w = right - left;
+  const h = bottom - top;
+  if (w <= 0 || h <= 0) return 0;
+  return w * h / area;
+}
+
+/** The share of an element that must be on screen before it counts as seen. Matches web's threshold. */
+export const IMPRESSION_THRESHOLD = 0.5;
+
+/** How long it must stay that visible. A view flicking past during a fling was never really seen. */
+export const IMPRESSION_DWELL_MS = 250;
+export function isViewable(el, viewport, threshold = IMPRESSION_THRESHOLD) {
+  return visibleFraction(el, viewport) >= threshold;
+}
+
+/**
+ * Tracks one element's viewability over time and decides when to fire.
+ *
+ * Fires AT MOST ONCE per instance — an impression is "was this seen", not "how many times did it cross
+ * the line", and a list that scrolls back and forth would otherwise inflate the count several-fold.
+ * Time is injected so the dwell rule can be tested without waiting.
+ */
+export class ImpressionTracker {
+  visibleSince = null;
+  fired = false;
+  constructor(onImpression, threshold = IMPRESSION_THRESHOLD, dwellMs = IMPRESSION_DWELL_MS) {
+    this.onImpression = onImpression;
+    this.threshold = threshold;
+    this.dwellMs = dwellMs;
+  }
+
+  /** Feed a measurement. Safe to call as often as layout/scroll produces one. */
+  update(el, viewport, now) {
+    if (this.fired) return;
+    if (!isViewable(el, viewport, this.threshold)) {
+      this.visibleSince = null; // Scrolled away before the dwell elapsed — start over, do not accumulate.
+      return;
+    }
+    if (this.visibleSince == null) {
+      this.visibleSince = now;
+      return;
+    }
+    const held = now - this.visibleSince;
+    if (held >= this.dwellMs) {
+      this.fired = true;
+      this.onImpression(held);
+    }
+  }
+
+  /** True once this element has been counted. */
+  get hasFired() {
+    return this.fired;
+  }
+
+  /** Forget the element entirely — used when a recycled list row is bound to new content. */
+  reset() {
+    this.visibleSince = null;
+    this.fired = false;
+  }
+}
+//# sourceMappingURL=impression.js.map

package/lib/module/features/journey/interactionProtocol.js

@@ -0,0 +1,158 @@
+/** One physical interaction, shared by replay and analytics projections. */
+export const INTERACTION_PROTOCOL_VERSION = 1;
+export function generateInteractionId() {
+  return `ixj-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+/**
+ * RN-6 — THE CORRELATION CONTRACT.
+ *
+ * WHAT IS BEING JOINED, AND WHY IT IS HARD. A physical tap is observed twice: natively, by
+ * a window callback that sees ACTION_DOWN/UP and produces the coordinates; and in JS, by a
+ * capture-phase touch handler that produces the IDENTITY — which control was hit, what UI
+ * state was declared, which screen. Both sides mint their own id and neither can derive
+ * the other's: native builds `ixn-a-<process nonce>-<MotionEvent ts>` from a clock JS
+ * cannot read, and JS builds `ixj-<Date.now()>-<random>`. So the two observations have to
+ * be JOINED, and the only shared quantity is time.
+ *
+ * WHY THE OLD JOIN WAS DANGEROUS RATHER THAN MERELY APPROXIMATE. It took whichever start
+ * was nearest in time within ±1500 ms and used it unconditionally. The fields it carries
+ * across are `target`, `targetId`, `ui`, `stateStatus` and `screenName`; the coordinates
+ * come from the native side and are always right. So a wrong pairing does not produce
+ * obviously broken data — it produces heat in the CORRECT position attributed to the
+ * WRONG control, in the wrong UI state, on the wrong screen. Nothing downstream can
+ * detect that, because every field is individually well-formed.
+ *
+ * 1500 ms is a very long time on a touch surface. A deliberate double-tap is 150–300 ms
+ * apart; an impatient tapper is faster. So "nearest within 1500 ms" routinely had more
+ * than one candidate, and picked one with no record that it had a choice.
+ *
+ * WHAT THIS REPLACES IT WITH — three outcomes instead of one, and a refusal:
+ *
+ *   'exact'      one candidate is clearly closest: the runner-up is at least
+ *                `marginMs` further away. The join is used.
+ *   'ambiguous'  two candidates are within `marginMs` of each other, so choosing
+ *                between them is a coin flip. The join is REFUSED and the caller must
+ *                emit the interaction WITHOUT js-derived identity. A tap with no target
+ *                is honest and visibly incomplete; a tap with the wrong target is
+ *                indistinguishable from a correct one and corrupts every aggregate it
+ *                enters.
+ *   'none'       nothing within tolerance. Same refusal, different reason — worth
+ *                separating because 'none' means the JS handler never fired (a real
+ *                capture gap) while 'ambiguous' means it fired too often to attribute.
+ *
+ * It also reports `deltaMs` and `runnerUpDeltaMs` so the outcome is auditable after the
+ * fact rather than being a claim this comment makes.
+ *
+ * WHAT IT DELIBERATELY DOES NOT DO: use position to disambiguate. The native event carries
+ * raw px in the capture view and normalized 0..1 coordinates; the JS start carries its own
+ * x/y in a different space (dp in the root view). Comparing them needs a proven scale
+ * factor between the two, and getting it wrong would REJECT valid pairings — strictly
+ * worse than today. That calibration needs a device run, so it is a follow-up, not a
+ * guess made here.
+ */
+
+/**
+ * How far apart a native event and a JS start may be and still be the same touch.
+ *
+ * Unchanged at 1500 ms from the previous implementation, deliberately: narrowing it is a
+ * separate, measurable decision about how late the JS handler can run on a slow device,
+ * and bundling it into this change would make any regression impossible to attribute.
+ */
+export const CORRELATION_TOLERANCE_MS = 1500;
+
+/**
+ * How much closer the winner must be than the runner-up to count as identified.
+ *
+ * 100 ms because that is comfortably below the fastest deliberate double-tap (~150 ms):
+ * when two candidate starts are within 100 ms of each other in distance, the native event
+ * sits effectively between them and the "nearest" one is a coin flip.
+ */
+export const CORRELATION_MARGIN_MS = 100;
+
+/** Match a native bridge event to the JS evidence sampled at the same finger-down. */
+export function correlateInteraction(starts, occurredAt, toleranceMs = CORRELATION_TOLERANCE_MS, marginMs = CORRELATION_MARGIN_MS) {
+  const candidates = [];
+  for (let i = 0; i < starts.length; i++) {
+    const start = starts[i];
+    if (!start) continue;
+    const delta = Math.abs(start.occurredAt - occurredAt);
+    if (delta <= toleranceMs) candidates.push({
+      index: i,
+      delta
+    });
+  }
+  if (candidates.length === 0) {
+    return {
+      index: -1,
+      outcome: 'none',
+      deltaMs: null,
+      runnerUpDeltaMs: null
+    };
+  }
+
+  /* Stable ordering: equal deltas resolve by index so a repeated run cannot produce a
+     different answer from the same inputs. A non-deterministic correlation would make
+     every downstream measurement unreproducible. */
+  candidates.sort((a, b) => a.delta - b.delta || a.index - b.index);
+  const best = candidates[0];
+  const runnerUp = candidates[1];
+  if (runnerUp && runnerUp.delta - best.delta < marginMs) {
+    return {
+      index: -1,
+      outcome: 'ambiguous',
+      deltaMs: best.delta,
+      runnerUpDeltaMs: runnerUp.delta
+    };
+  }
+  return {
+    start: starts[best.index],
+    index: best.index,
+    outcome: 'exact',
+    deltaMs: best.delta,
+    runnerUpDeltaMs: runnerUp ? runnerUp.delta : null
+  };
+}
+
+/**
+ * Drop starts that can no longer match anything, in place.
+ *
+ * WHY IT MATTERS BEYOND MEMORY. A start older than the tolerance is unreachable, but while
+ * it sits in the list it is still a CANDIDATE for the ambiguity test — so a stale entry can
+ * turn a perfectly clear pairing into a refusal, and an accumulating list makes that more
+ * likely the longer a session runs. Pruning is therefore part of the correctness of the
+ * join, not housekeeping.
+ *
+ * Mutates rather than returning a copy because the caller holds it in a ref that the native
+ * listener and the touch handler both read.
+ */
+export function pruneInteractionStarts(starts, now, toleranceMs = CORRELATION_TOLERANCE_MS) {
+  let removed = 0;
+  for (let i = starts.length - 1; i >= 0; i--) {
+    const start = starts[i];
+    if (!start || now - start.occurredAt > toleranceMs) {
+      starts.splice(i, 1);
+      removed++;
+    }
+  }
+  return removed;
+}
+
+/** Analytics is a projection of the same evidence; no second click is invented. */
+export function automaticInteractionProperties(payload, screenName, canonicalMirror) {
+  return {
+    gesture_type: payload.gestureType,
+    screen_name: screenName,
+    interaction_id: payload.interaction_id,
+    interaction_protocol: payload.interaction_protocol,
+    state_status: payload.state_status,
+    ui: payload.ui,
+    target_id: payload.target_id,
+    normalized_x: payload.normalizedX,
+    normalized_y: payload.normalizedY,
+    direction: payload.direction,
+    duration_ms: payload.durationMs,
+    canonical_mirror: canonicalMirror || undefined
+  };
+}
+//# sourceMappingURL=interactionProtocol.js.map

package/lib/module/features/journey/journeyManager.js

@@ -0,0 +1,459 @@
+/**
+ * ScaleBun SDK — Journey Manager
+ *
+ * Core orchestrator for journey recording and running.
+ * Coordinates gesture buffer, nav detector, screenshot helper,
+ * and transport to implement the full journey lifecycle.
+ */
+
+import { DEFAULT_JOURNEY_CONFIG } from './journeyTypes';
+import { GestureBuffer } from './gestureBuffer';
+import { SDK_VERSION } from '../../core/constants/version';
+import { GestureDetector } from './gestureDetector';
+import { NavDetector } from './navDetector';
+import { ScreenshotHelper } from './screenshotHelper';
+import { findTarget } from './targetRegistry';
+// 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.
+import { PROTOCOL_VERSION } from '../../core/constants/protocol';
+
+// ─── Journey Event Names ────────────────────────────────────────────────────
+
+const JOURNEY_EVENTS = {
+  DEBUG_READY: 'journey:debug_ready',
+  CURRENT_SCREEN: 'journey:current_screen',
+  RECORDING_STATE: 'journey:recording_state',
+  STEP_RECORDED: 'journey:step_recorded',
+  JOURNEY_SAVED: 'journey:saved',
+  RUN_STARTED: 'journey:run_started',
+  RUN_STEP_STATUS: 'journey:run_step_status',
+  RUN_FINISHED: 'journey:run_finished',
+  IMAGE_CHUNK: 'journey:image_chunk'
+};
+
+// ─── Journey Manager ────────────────────────────────────────────────────────
+
+export class JourneyManager {
+  // Recording state
+  _isRecording = false;
+  _journeyTempId = '';
+  _steps = [];
+  _stepIndex = 0;
+
+  // Running state
+  _isRunning = false;
+  _runId = '';
+  _stopRunFlag = false;
+
+  // Singleton guard
+  static _instance = null;
+  constructor(transport, config) {
+    this.transport = transport;
+    this.config = {
+      enabled: config?.enabled ?? DEFAULT_JOURNEY_CONFIG.enabled,
+      autoStart: config?.autoStart ?? DEFAULT_JOURNEY_CONFIG.autoStart,
+      screenshots: {
+        ...DEFAULT_JOURNEY_CONFIG.screenshots,
+        ...config?.screenshots
+      },
+      gestures: {
+        ...DEFAULT_JOURNEY_CONFIG.gestures,
+        ...config?.gestures
+      },
+      nav: {
+        ...DEFAULT_JOURNEY_CONFIG.nav,
+        ...config?.nav
+      }
+    };
+    this.gestureBuffer = new GestureBuffer(this.config.gestures.bufferSize);
+    this.gestureDetector = new GestureDetector(this.gestureBuffer);
+    this.navDetector = new NavDetector();
+    this.screenshotHelper = new ScreenshotHelper(this.config.screenshots);
+  }
+
+  /** Singleton factory — idempotent */
+  static getInstance(transport, config) {
+    if (!JourneyManager._instance) {
+      JourneyManager._instance = new JourneyManager(transport, config);
+    }
+    return JourneyManager._instance;
+  }
+
+  /** Reset singleton (for teardown) */
+  static resetInstance() {
+    if (JourneyManager._instance) {
+      JourneyManager._instance.teardown();
+      JourneyManager._instance = null;
+    }
+  }
+
+  // ─── Accessors ──────────────────────────────────────────────────────
+
+  get isRecording() {
+    return this._isRecording;
+  }
+  get isRunning() {
+    return this._isRunning;
+  }
+  get steps() {
+    return this._steps;
+  }
+  get currentScreen() {
+    return this.navDetector.currentScreen;
+  }
+  get detector() {
+    return this.gestureDetector;
+  }
+  get nav() {
+    return this.navDetector;
+  }
+  get screenshot() {
+    return this.screenshotHelper;
+  }
+
+  // ─── Initialization ─────────────────────────────────────────────────
+
+  /** Initialize the journey system. Called by ScaleBunDebugRoot on mount. */
+  initialize(rootRef) {
+    // Install gesture detection
+    this.gestureDetector.install();
+
+    // Install nav detection
+    this.navDetector.install(this.config.nav);
+
+    // Set screenshot root ref
+    if (rootRef) {
+      this.screenshotHelper.setRootRef(rootRef);
+    }
+
+    // Subscribe to nav changes to emit to desktop
+    this.navDetector.onScreenChange((screenName, stack) => {
+      this._emitEvent(JOURNEY_EVENTS.CURRENT_SCREEN, {
+        screenName,
+        stack
+      });
+      // Also push NAV gesture into buffer
+      this.gestureDetector.handleNavigation(screenName);
+    });
+
+    // Emit DEBUG_READY
+    this._emitDebugReady();
+
+    // Auto-start if configured
+    if (this.config.autoStart) {
+      this.startRecording();
+    }
+  }
+
+  // ─── Recording ──────────────────────────────────────────────────────
+
+  startRecording() {
+    if (this._isRecording) return;
+    this._isRecording = true;
+    this._journeyTempId = this._generateId();
+    this._steps = [];
+    this._stepIndex = 0;
+    console.warn('[ScaleBun Journey] Recording started:', this._journeyTempId);
+    this._emitEvent(JOURNEY_EVENTS.RECORDING_STATE, {
+      on: true,
+      journeyTempId: this._journeyTempId
+    });
+  }
+  stopRecording() {
+    if (!this._isRecording) return;
+    this._isRecording = false;
+    console.warn('[ScaleBun Journey] Recording stopped:', this._journeyTempId, `(${this._steps.length} steps)`);
+    this._emitEvent(JOURNEY_EVENTS.RECORDING_STATE, {
+      on: false,
+      journeyTempId: this._journeyTempId
+    });
+  }
+
+  /** Capture a step — matches gesture from buffer + takes screenshot */
+  async captureStep(gestureMode, label, note) {
+    if (!this._isRecording) {
+      return {
+        success: false,
+        error: 'Not recording'
+      };
+    }
+    const mode = gestureMode;
+
+    // 1. Match gesture from buffer
+    const matchedGesture = this.gestureBuffer.matchRecent(mode, this.config.gestures.matchWindowMs);
+
+    // 2. Take screenshot
+    const {
+      result: screenshotResult,
+      error: screenshotError
+    } = await this.screenshotHelper.capture();
+
+    // 3. Build step
+    const step = {
+      stepIndex: this._stepIndex++,
+      gestureType: mode,
+      target: matchedGesture?.target,
+      screenName: this.navDetector.currentScreen,
+      timestamp: Date.now(),
+      label,
+      note
+    };
+    if (!matchedGesture) {
+      step.captureOnly = true;
+      step.captureOnlyReason = `No ${mode} gesture found in last ${this.config.gestures.matchWindowMs}ms`;
+    }
+
+    // 4. Attach screenshot metadata + send image
+    let screenshotId;
+    if (screenshotResult) {
+      screenshotId = this._generateId();
+      step.screenshotId = screenshotId;
+      step.screenshotMeta = {
+        width: screenshotResult.width,
+        height: screenshotResult.height,
+        mime: screenshotResult.mime,
+        byteSize: screenshotResult.byteSize
+      };
+
+      // Send image as separate event (chunked for large images)
+      this._emitEvent(JOURNEY_EVENTS.IMAGE_CHUNK, {
+        imageId: screenshotId,
+        stepIndex: step.stepIndex,
+        base64: screenshotResult.base64,
+        mime: screenshotResult.mime,
+        width: screenshotResult.width,
+        height: screenshotResult.height,
+        byteSize: screenshotResult.byteSize
+      });
+    } else if (screenshotError) {
+      step.note = (step.note ? step.note + ' | ' : '') + `Screenshot: ${screenshotError}`;
+    }
+
+    // 5. Store and emit
+    this._steps.push(step);
+    this._emitEvent(JOURNEY_EVENTS.STEP_RECORDED, {
+      journeyTempId: this._journeyTempId,
+      step
+    });
+    return {
+      success: true,
+      data: {
+        stepIndex: step.stepIndex,
+        gestureType: step.gestureType,
+        screenName: step.screenName,
+        hasScreenshot: !!screenshotResult,
+        captureOnly: step.captureOnly ?? false,
+        captureOnlyReason: step.captureOnlyReason
+      }
+    };
+  }
+
+  // ─── Save Journey ───────────────────────────────────────────────────
+
+  async saveJourney(name, journeyId) {
+    const id = journeyId || this._generateId();
+    let screenWidth = 0,
+      screenHeight = 0,
+      platformOS = 'unknown';
+    try {
+      const RN = require('react-native');
+      const dims = RN.Dimensions.get('window');
+      screenWidth = dims.width;
+      screenHeight = dims.height;
+      platformOS = RN.Platform.OS;
+    } catch {/* no-throw */}
+    const journey = {
+      journeyId: id,
+      name,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      steps: [...this._steps],
+      metadata: {
+        platform: platformOS,
+        screenWidth,
+        screenHeight,
+        navMode: this.navDetector.navMode
+      }
+    };
+    this._emitEvent(JOURNEY_EVENTS.JOURNEY_SAVED, {
+      journeyId: id,
+      name,
+      journey
+    });
+    return {
+      success: true,
+      data: {
+        journeyId: id,
+        name,
+        stepCount: this._steps.length
+      }
+    };
+  }
+
+  // ─── Run Journey ────────────────────────────────────────────────────
+
+  async runJourney(journeyData, options) {
+    if (this._isRunning) return;
+    const journey = journeyData;
+    if (!journey?.steps?.length) return;
+    this._isRunning = true;
+    this._stopRunFlag = false;
+    this._runId = this._generateId();
+    const speed = options?.speed ?? 1;
+    const stepByStep = options?.stepByStep ?? false;
+    const startTime = Date.now();
+    this._emitEvent(JOURNEY_EVENTS.RUN_STARTED, {
+      journeyId: journey.journeyId,
+      runId: this._runId
+    });
+    let passed = 0,
+      failed = 0,
+      skipped = 0;
+    for (let i = 0; i < journey.steps.length; i++) {
+      if (this._stopRunFlag) break;
+      const step = journey.steps[i];
+      let status = 'PENDING';
+      let reason = '';
+      try {
+        if (step.gestureType === 'NAV') {
+          // Try navigation
+          status = 'PASS';
+          reason = 'NAV step acknowledged';
+        } else if (step.target?.testId && findTarget(step.target.testId)) {
+          // Deterministic execution via registered target
+          const target = findTarget(step.target.testId);
+          if (step.gestureType === 'TAP' && target.press) {
+            target.press();
+            status = 'PASS';
+          } else if (step.gestureType === 'TYPE' && target.setValue) {
+            target.setValue('replay-text');
+            status = 'PASS';
+          } else if (step.gestureType === 'SCROLL' && target.scrollTo) {
+            target.scrollTo({
+              y: 100,
+              animated: true
+            });
+            status = 'PASS';
+          } else {
+            status = 'SKIP';
+            reason = `SKIPPED_UNRESOLVED: No handler for ${step.gestureType} on target ${step.target.testId}`;
+          }
+        } else {
+          // No deterministic target — best-effort
+          status = 'SKIP';
+          reason = `SKIPPED_UNRESOLVED: No registered target for step ${i}`;
+        }
+      } catch (e) {
+        status = 'FAIL';
+        reason = e?.message || 'Step execution error';
+      }
+
+      // Capture screenshot after step
+      let screenshotId;
+      const {
+        result: ss
+      } = await this.screenshotHelper.capture();
+      if (ss) {
+        screenshotId = this._generateId();
+        this._emitEvent(JOURNEY_EVENTS.IMAGE_CHUNK, {
+          imageId: screenshotId,
+          stepIndex: i,
+          base64: ss.base64,
+          mime: ss.mime,
+          width: ss.width,
+          height: ss.height,
+          byteSize: ss.byteSize
+        });
+      }
+
+      // Verify screen name match
+      if (status === 'PASS' && step.screenName !== 'UnknownScreen') {
+        if (this.navDetector.currentScreen !== step.screenName) {
+          reason = `Screen mismatch: expected ${step.screenName}, got ${this.navDetector.currentScreen}`;
+          // Don't fail — just note it
+        }
+      }
+      if (status === 'PASS') passed++;else if (status === 'FAIL') failed++;else skipped++;
+      this._emitEvent(JOURNEY_EVENTS.RUN_STEP_STATUS, {
+        runId: this._runId,
+        stepIndex: i,
+        status,
+        reason: reason || undefined,
+        screenshotId,
+        screenshotMeta: ss ? {
+          width: ss.width,
+          height: ss.height,
+          mime: ss.mime,
+          byteSize: ss.byteSize
+        } : undefined
+      });
+
+      // Delay between steps (respecting speed)
+      if (i < journey.steps.length - 1 && !stepByStep) {
+        await new Promise(resolve => setTimeout(resolve, 1000 / speed));
+      }
+    }
+    const durationMs = Date.now() - startTime;
+    this._emitEvent(JOURNEY_EVENTS.RUN_FINISHED, {
+      runId: this._runId,
+      summary: {
+        total: journey.steps.length,
+        passed,
+        failed,
+        skipped,
+        durationMs
+      }
+    });
+    this._isRunning = false;
+  }
+  stopRun() {
+    this._stopRunFlag = true;
+  }
+
+  // ─── Teardown ───────────────────────────────────────────────────────
+
+  teardown() {
+    this.stopRecording();
+    this.stopRun();
+    this.gestureDetector.teardown();
+    this.navDetector.teardown();
+    this.gestureBuffer.clear();
+  }
+
+  // ─── Internal ───────────────────────────────────────────────────────
+
+  _emitDebugReady() {
+    const payload = {
+      journeyEnabled: this.config.enabled,
+      canScreenshot: this.screenshotHelper.canCapture,
+      navMode: this.navDetector.navMode,
+      sdkVersion: SDK_VERSION
+    };
+    this._emitEvent(JOURNEY_EVENTS.DEBUG_READY, payload);
+  }
+  _emitEvent(name, data) {
+    try {
+      const msg = {
+        type: 'event',
+        protocolVersion: PROTOCOL_VERSION,
+        deviceId: this.transport.deviceId,
+        sessionId: this.transport.sessionId,
+        timestamp: Date.now(),
+        sequence: this.transport.nextSequence(),
+        payload: {
+          id: this._generateId(),
+          category: 'journey',
+          name,
+          data
+        }
+      };
+      this.transport.send(msg);
+    } catch {
+      // No-throw
+    }
+  }
+  _generateId() {
+    return `${Date.now().toString(36)}-${Math.random().toString(36).substring(2, 8)}`;
+  }
+}
+//# sourceMappingURL=journeyManager.js.map