@scalebun-release/react-native 2.5.0

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

@@ -0,0 +1,88 @@
+/**
+ * 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.
+ */
+
+import { logger } from '../../core/logger/internalLogger';
+// ─── 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 ─────────────────────────────────────────────────────────────────
+
+export 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__ && 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
+      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
+    };
+  }
+}
+//# sourceMappingURL=SyncDecisionEngine.js.map

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

@@ -0,0 +1,29 @@
+/**
+ * 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
+ */
+
+export const FRAME_OFFSET_TOL = 4;
+export 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/module/features/session/frameScrollState.js

@@ -0,0 +1,34 @@
+/**
+ * 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".
+ */
+
+import { sanitizeScrollContext } from '../journey/nativeScroll';
+/** Same cap as the native side and the backend DTO. */
+export const 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.
+ */
+export function sanitizeFrameScrollState(raw) {
+  if (!Array.isArray(raw)) return undefined;
+  const clean = 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/module/features/session/index.js

@@ -0,0 +1,35 @@
+/**
+ * ScaleBun SDK — Unified Session Feature
+ *
+ * Public API surface for the unified session system.
+ * Re-exports all domain types, contracts, configs, and constants.
+ */
+
+// ─── Domain Types ───────────────────────────────────────────────────────────
+
+// ─── Configuration ──────────────────────────────────────────────────────────
+
+export { DEFAULT_SESSION_REPLAY_CONFIG, QUALITY_PRESETS } from './sessionTypes';
+
+// ─── Transport Contracts ────────────────────────────────────────────────────
+
+// ─── Sync Contracts ─────────────────────────────────────────────────────────
+
+// ─── Native Capture Types ───────────────────────────────────────────────────
+
+// ─── Retention Policies ─────────────────────────────────────────────────────
+
+export { FrameRetentionPriority, getFrameRetentionPriority, EventRetentionPriority, getEventRetentionPriority } from './sessionTypes';
+
+// ─── Protocol Constants ─────────────────────────────────────────────────────
+
+export { SESSION_EVENTS } from './sessionTypes';
+
+// ─── SDK Integration Layer ──────────────────────────────────────────────────
+
+export { SessionManager } from './SessionManager';
+export { JourneyEventPipeline } from './JourneyEventPipeline';
+export { ReplayCaptureManager } from './ReplayCaptureManager';
+export { DesktopSessionTransport } from './DesktopSessionTransport';
+export { SyncDecisionEngine } from './SyncDecisionEngine';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,45 @@
+/**
+ * ScaleBun SDK — Native Frame Capture
+ *
+ * Provides the callback for the SessionManager to request screenshots
+ * from the native layer (PixelCopy on Android, UIWindow on iOS).
+ */
+import { resolvePlatformOS } from '../../core/context/device';
+import { sanitizeFrameScrollState } from './frameScrollState';
+export 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 = resolvePlatformOS();
+    // Visible scroll containers read beside the pixels; undefined when native did not measure.
+    const scrollState = 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;
+  }
+};
+//# sourceMappingURL=nativeCapture.js.map

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

@@ -0,0 +1,77 @@
+/**
+ * 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.
+ */
+
+import { getReplaySdkNative } from '../replay/bridge/nativeModule';
+import { resolvePlatformOS } from '../../core/context/device';
+import { sanitizeFrameScrollState } from './frameScrollState';
+/** Build the adapter. `ensureReady` resolves false when the native outbox is off. */
+export function makeOutboxFrameCapture(ensureReady) {
+  // Platform.OS verbatim — see core/context/device.
+  const platform = resolvePlatformOS();
+  return {
+    async capture(sessionId, screenName, trigger) {
+      try {
+        if (!(await ensureReady())) return null;
+        const native = 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 = 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 = getReplaySdkNative();
+        if (!native?.commitOutboxFrame) return false;
+        const path = await native.commitOutboxFrame(meta);
+        return path != null;
+      } catch {
+        return false;
+      }
+    },
+    async discard(sessionId, frameId) {
+      try {
+        await getReplaySdkNative()?.discardOutboxFrame?.(sessionId, frameId);
+      } catch {
+        /* no-throw */
+      }
+    }
+  };
+}
+//# sourceMappingURL=outboxFrameCapture.js.map

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

@@ -0,0 +1,226 @@
+/**
+ * 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) */
+export const 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
+};
+export const 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.
+ */
+export let 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 */
+export 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 ───────────────────────────────────────────
+
+export const 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.
+ */
+export let 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 */
+export 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

package/lib/module/features/session/viewportPlausibility.js

@@ -0,0 +1,137 @@
+/**
+ * Is the viewport the platform just reported actually believable?
+ *
+ * WHY THIS EXISTS
+ * ───────────────
+ * The native layer reports the content view's size and the SDK trusts it unconditionally: in
+ * `SessionManager._normalizeInteractionPayload`, a payload tagged `confidence: 'high'` short-circuits
+ * every other source and is cached as the normalization base for the rest of the session. One device
+ * in production reports a size that cannot be true, and nothing noticed.
+ *
+ * Measured on production 2026-09-20, across 56 device models:
+ *
+ *   device                    viewportWidth(px)   windowWidth(dp)   implied density
+ *   OPPO CPH2821                      720               360.0             2.000  ok
+ *   Xiaomi 23129RAA4G                1080               392.7             2.750  ok
+ *   samsung SM-M526BR                1080               411.4             2.625  ok
+ *   HUAWEI INE-LX1                   1080               360.0             3.000  ok
+ *   HONOR DNY-NX9                    1264               361.1             3.500  ok
+ *   every iPhone                  390..440          390..440             1.000  ok  (pt space)
+ *   OnePlus OnePlus8Pro               288               434.7             0.663  IMPLAUSIBLE
+ *
+ * 55 of 56 pass, one fails, and the failure is the device whose replays render as an impossibly
+ * tall, narrow phone. Its `windowWidth` of 434.7dp is *correct* for a 1440px screen (1440/434.7 =
+ * 3.3125) — it is `viewportWidth` that is wrong, by a factor of five.
+ *
+ * WHY THIS TEST AND NOT A DEVICE LIST
+ * ───────────────────────────────────
+ * The SDK already sends two INDEPENDENTLY SOURCED measurements of the same screen: the native
+ * content view (physical px on Android, points on iOS) and the JS layout width from
+ * `Dimensions.get('window')` (density-independent). Converted into a common unit they must agree.
+ * That is a self-consistency check, so it holds on hardware nobody here has ever seen — which is the
+ * whole point. A model allowlist would have to be updated for the next OnePlus, and would not exist
+ * until after that device had already shipped bad data for a week.
+ *
+ * WHY NOT ASPECT RATIO, the obvious alternative: it does not separate. The OnePlus sits at 0.643 and
+ * a legitimate Android emulator in the same fleet sits at 0.629. Aspect is kept below only as a
+ * SECONDARY guard against a corrupted height, never as the primary signal.
+ *
+ * Pure and dependency-free on purpose: the backend holds a byte-identical copy so ingest can reach
+ * the same verdict as capture, and `geometry:parity` asserts the two have not drifted.
+ */
+
+/** Android densities run 0.75 (ldpi) to 4.0 (xxxhdpi); the bound is loose so only nonsense fails. */
+const DENSITY_MIN = 0.9;
+const DENSITY_MAX = 5.0;
+
+/**
+ * How far the two measurements may disagree when the real density IS known.
+ *
+ * Generous at 10% because `windowWidth` is itself derived by the platform as px/density and can
+ * carry rounding, and because insets are excluded inconsistently across OEMs. The failure this
+ * catches is off by 5x, so precision is not what makes it work.
+ */
+const DENSITY_TOLERANCE = 0.1;
+
+/** A screen cannot be 10x taller than it is wide, or wider than it is tall by that much. */
+const ASPECT_MIN = 0.2;
+const ASPECT_MAX = 5.0;
+function positive(v) {
+  return typeof v === 'number' && isFinite(v) && v > 0 ? v : null;
+}
+
+/**
+ * Judge a reported viewport.
+ *
+ * `unverified` is a THIRD state on purpose and never collapses into `ok`. A payload from an older
+ * SDK build carries no `windowWidth`, so the invariant cannot be evaluated at all — recording that
+ * as "checked and fine" would be the same defect as rendering a missing measurement as zero. The
+ * caller decides what to do with an unverifiable sample; it must not be told a lie about it.
+ */
+export function checkViewport(sample) {
+  const vw = positive(sample.viewportWidth);
+  const vh = positive(sample.viewportHeight);
+  const dpW = positive(sample.windowWidth);
+  if (vw == null || vh == null) {
+    return {
+      verdict: 'unverified',
+      impliedDensity: null,
+      expectedDensity: null,
+      reason: 'no-viewport'
+    };
+  }
+
+  // Secondary guard: a plausible density cannot rescue a height that is obviously corrupt.
+  const aspect = vw / vh;
+  if (aspect < ASPECT_MIN || aspect > ASPECT_MAX) {
+    return {
+      verdict: 'implausible',
+      impliedDensity: null,
+      expectedDensity: null,
+      reason: 'aspect-out-of-range'
+    };
+  }
+  if (dpW == null) {
+    return {
+      verdict: 'unverified',
+      impliedDensity: null,
+      expectedDensity: null,
+      reason: 'no-window-width'
+    };
+  }
+  const impliedDensity = vw / dpW;
+
+  // Point-space (iOS): the native size is ALREADY in the unit `Dimensions.get('window')` uses, so
+  // the two must be the same number, not related by a density.
+  const space = typeof sample.coordinateSpace === 'string' ? sample.coordinateSpace : '';
+  const expectedDensity = space.endsWith('-pt') ? 1 : positive(sample.density);
+  if (expectedDensity != null) {
+    const off = Math.abs(impliedDensity - expectedDensity) / expectedDensity;
+    return off <= DENSITY_TOLERANCE ? {
+      verdict: 'ok',
+      impliedDensity,
+      expectedDensity,
+      reason: null
+    } : {
+      verdict: 'implausible',
+      impliedDensity,
+      expectedDensity,
+      reason: 'density-mismatch'
+    };
+  }
+
+  // Density unknown (an older payload, or a platform that does not report it): fall back to the
+  // range test. Weaker, but it still rejects the 0.663 that started this.
+  return impliedDensity >= DENSITY_MIN && impliedDensity <= DENSITY_MAX ? {
+    verdict: 'ok',
+    impliedDensity,
+    expectedDensity: null,
+    reason: null
+  } : {
+    verdict: 'implausible',
+    impliedDensity,
+    expectedDensity: null,
+    reason: 'density-out-of-range'
+  };
+}
+//# sourceMappingURL=viewportPlausibility.js.map