@cloudcare/cocos-session-replay 0.1.0-alpha.6

package/dist/creator2/core/replay.js

@@ -0,0 +1,653 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FTSessionReplay = void 0;
+exports.normalizeSaveImageV2Result = normalizeSaveImageV2Result;
+exports.sampleReplayFrame = sampleReplayFrame;
+exports.replayFramesLookSimilar = replayFramesLookSimilar;
+exports.frameFingerprint = frameFingerprint;
+exports.applyPrivacyRegions = applyPrivacyRegions;
+var replay_encoding_js_1 = require("./replay-encoding.js");
+var replay_budget_js_1 = require("./replay-budget.js");
+var replay_diagnostics_js_1 = require("./replay-diagnostics.js");
+var validation_js_1 = require("./validation.js");
+var MAX_PENDING_POINTER_EVENTS = 512;
+// Approximate comparisons must not hide small animations indefinitely.
+var MAX_APPROXIMATE_STATIC_MS = 2000;
+var SAMPLE_TILE_SIZE = 32;
+/** Cocos canvas Session Replay controls. */
+var FTSessionReplay = /** @class */ (function () {
+    function FTSessionReplay(transport, capture, pointerSource, validateNative) {
+        this.transport = transport;
+        this.capture = capture;
+        this.pointerSource = pointerSource;
+        this.validateNative = validateNative;
+        this.busy = false;
+        this.running = false;
+        this.mode = 'idle';
+        this.hybridReplayEnabled = false;
+        this.captureGeneration = 0;
+        this.config = { captureFps: 1 };
+        this.imagePolicy = (0, validation_js_1.replayImagePolicy)({});
+        this.budget = new replay_budget_js_1.FTReplayBudget(this.imagePolicy);
+        this.imagePolicyEnabled = false;
+        this.recordCounts = new Map();
+        this.recordTouches = false;
+        this.pendingPointerEvents = [];
+    }
+    /**
+     * Enables native Session Replay and starts Cocos canvas capture for a
+     * standalone application.
+     *
+     * @param config - Replay sampling, capture, and touch-privacy settings.
+     */
+    FTSessionReplay.prototype.start = function (config) {
+        var _a;
+        if (config === void 0) { config = {}; }
+        if (this.mode === 'hybrid') {
+            throw new Error('Hybrid Replay is managed by enterCocos() and leaveCocos()');
+        }
+        if (this.mode === 'standalone')
+            return;
+        (0, validation_js_1.samplingRate)(config.sampleRate, 'replay.sampleRate');
+        (0, validation_js_1.samplingRate)(config.sessionOnErrorSampleRate, 'replay.sessionOnErrorSampleRate');
+        this.configureCapture(config);
+        (_a = this.validateNative) === null || _a === void 0 ? void 0 : _a.call(this);
+        this.transport.invoke('replay.configure', config);
+        this.mode = 'standalone';
+        this.startCapture();
+    };
+    /** @internal */
+    FTSessionReplay.prototype.attachHybrid = function (config) {
+        if (this.mode === 'standalone') {
+            throw new Error('Standalone Replay and Hybrid Replay are mutually exclusive');
+        }
+        if (this.mode === 'hybrid')
+            return;
+        this.configureCapture(config || {});
+        this.hybridReplayEnabled = config !== undefined;
+        this.mode = 'hybrid';
+    };
+    /** @internal */
+    FTSessionReplay.prototype.detachHybrid = function () {
+        if (this.mode !== 'hybrid')
+            return;
+        this.stopCapture();
+        this.hybridReplayEnabled = false;
+        this.mode = 'idle';
+    };
+    /** @internal */
+    FTSessionReplay.prototype.enterHybrid = function () {
+        if (this.mode !== 'hybrid') {
+            throw new Error('Call attach() before entering Hybrid Replay');
+        }
+        if (!this.hybridReplayEnabled || this.running)
+            return;
+        this.transport.invoke('hybrid.setExternalRecorderActive', { active: true });
+        this.startCapture();
+    };
+    /** @internal */
+    FTSessionReplay.prototype.leaveHybrid = function () {
+        if (this.mode !== 'hybrid' || !this.hybridReplayEnabled)
+            return;
+        this.stopCapture();
+        this.transport.invoke('hybrid.setExternalRecorderActive', { active: false });
+    };
+    FTSessionReplay.prototype.configureCapture = function (config) {
+        if (config.touchPrivacy !== undefined && config.touchPrivacy !== 'show' && config.touchPrivacy !== 'hide') {
+            throw new TypeError("touchPrivacy must be either 'show' or 'hide'");
+        }
+        this.config = { captureFps: (0, validation_js_1.captureFps)(config.captureFps) };
+        this.imagePolicy = (0, validation_js_1.replayImagePolicy)(config);
+        this.budget = new replay_budget_js_1.FTReplayBudget(this.imagePolicy);
+        // Lossy image MIME must be validated against the deployed player before
+        // becoming an implicit default. Supplying imagePolicy opts into V2 now.
+        this.imagePolicyEnabled = config.imagePolicy !== undefined;
+        this.recordTouches = config.touchPrivacy === 'show';
+    };
+    /** Stops standalone Cocos canvas capture and native Session Replay. */
+    FTSessionReplay.prototype.stop = function () {
+        if (this.mode === 'hybrid') {
+            throw new Error('Hybrid Replay is managed by enterCocos() and leaveCocos()');
+        }
+        if (this.mode === 'idle')
+            return;
+        this.stopCapture();
+        this.transport.invoke('replay.stop');
+        this.mode = 'idle';
+    };
+    /**
+     * Changes the Session Replay privacy treatment for a Cocos node.
+     *
+     * `mask` obscures the node, `hide` removes the region from the replay, and
+     * `unmask` clears an earlier code override, restoring any ReplayPrivacy
+     * component rule or default input masking. Code overrides take priority over
+     * a component on the same node. The node must belong to the active Cocos scene.
+     *
+     * @param node - Cocos node whose rendered bounds receive the privacy rule.
+     * @param mode - Privacy treatment to apply.
+     */
+    FTSessionReplay.prototype.setPrivacy = function (node, mode) {
+        this.capture.setPrivacy(node, mode);
+    };
+    /** @internal */
+    FTSessionReplay.prototype.captureNow = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var generation, stored, context, pointerSize, contextKey, contextChanged, viewportSize, viewportChanged, priorityKey, now, decision, frame, fingerprint, privacyKey, sample, comparable, duplicate, approximatelyStatic, saved, pendingPointers, encoded, error_1;
+            var _a, _b, _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        if (this.busy) {
+                            (0, replay_diagnostics_js_1.emitReplayDiagnostic)({ type: 'capture_skipped', timestamp: Date.now(), reason: 'busy' });
+                            return [2 /*return*/, false];
+                        }
+                        generation = this.captureGeneration;
+                        this.busy = true;
+                        pointerSize = this.lastImageSize;
+                        _e.label = 1;
+                    case 1:
+                        _e.trys.push([1, 5, 6, 11]);
+                        context = this.readContext();
+                        if (!context)
+                            return [2 /*return*/, false];
+                        contextKey = "".concat(context.applicationId, ":").concat(context.sessionId, ":").concat(context.viewId);
+                        contextChanged = contextKey !== this.lastContextKey;
+                        viewportSize = (_b = (_a = this.capture).getViewportSize) === null || _b === void 0 ? void 0 : _b.call(_a);
+                        viewportChanged = this.lastViewportSize !== undefined
+                            && viewportSize !== undefined
+                            && (viewportSize.width !== this.lastViewportSize.width
+                                || viewportSize.height !== this.lastViewportSize.height);
+                        priorityKey = contextChanged
+                            ? contextKey
+                            : viewportChanged && viewportSize
+                                ? "".concat(contextKey, ":").concat(viewportSize.width, "x").concat(viewportSize.height)
+                                : undefined;
+                        now = Date.now();
+                        decision = this.budget.decide(now, priorityKey);
+                        (0, replay_diagnostics_js_1.emitReplayDiagnostic)({
+                            type: 'capture_attempt',
+                            timestamp: now,
+                            usedBytes: decision.usedBytes,
+                            maxBytesPerMinute: this.imagePolicy.maxBytesPerMinute,
+                        });
+                        if (!decision.allowed) {
+                            (0, replay_diagnostics_js_1.emitReplayDiagnostic)({
+                                type: 'capture_skipped',
+                                timestamp: now,
+                                reason: decision.reason || 'budget',
+                            });
+                            return [2 /*return*/, pointerSize ? this.writePendingPointers(context, pointerSize.width, pointerSize.height) : false];
+                        }
+                        return [4 /*yield*/, this.capture.capture(decision.maxImageDimension)];
+                    case 2:
+                        frame = _e.sent();
+                        if (generation !== this.captureGeneration)
+                            return [2 /*return*/, false];
+                        if (!frame)
+                            return [2 /*return*/, false];
+                        pointerSize = { width: frame.width, height: frame.height };
+                        applyPrivacyRegions(frame.rgba, frame.width, frame.height, frame.privacyRegions || []);
+                        fingerprint = frameFingerprint(frame.rgba);
+                        privacyKey = privacyRegionsKey(frame.privacyRegions || []);
+                        sample = sampleReplayFrame(frame.rgba, frame.width, frame.height);
+                        comparable = contextKey === this.lastContextKey
+                            && !viewportChanged
+                            && frame.width === ((_c = this.lastFrameSample) === null || _c === void 0 ? void 0 : _c.width)
+                            && frame.height === ((_d = this.lastFrameSample) === null || _d === void 0 ? void 0 : _d.height)
+                            && privacyKey === this.lastPrivacyKey;
+                        duplicate = comparable && fingerprint === this.lastFingerprint;
+                        approximatelyStatic = comparable
+                            && !duplicate
+                            && this.lastImageTimestamp !== undefined
+                            && now - this.lastImageTimestamp < MAX_APPROXIMATE_STATIC_MS
+                            && replayFramesLookSimilar(this.lastFrameSample, sample);
+                        if (duplicate || approximatelyStatic) {
+                            (0, replay_diagnostics_js_1.emitReplayDiagnostic)({
+                                type: 'capture_skipped',
+                                timestamp: now,
+                                reason: duplicate ? 'dedupe' : 'approx_static',
+                            });
+                            return [2 /*return*/, this.writePendingPointers(context, frame.width, frame.height)];
+                        }
+                        return [4 /*yield*/, this.capture.persist(frame, fingerprint)];
+                    case 3:
+                        stored = _e.sent();
+                        if (generation !== this.captureGeneration)
+                            return [2 /*return*/, false];
+                        return [4 /*yield*/, this.saveImage(stored, decision.compressionQuality, decision.maxFrameBytes)];
+                    case 4:
+                        saved = _e.sent();
+                        if (generation !== this.captureGeneration)
+                            return [2 /*return*/, false];
+                        if (!saved) {
+                            (0, replay_diagnostics_js_1.emitReplayDiagnostic)({ type: 'capture_skipped', timestamp: now, reason: 'budget' });
+                            return [2 /*return*/, this.writePendingPointers(context, frame.width, frame.height)];
+                        }
+                        pendingPointers = this.scaledPendingPointers(saved.width, saved.height);
+                        encoded = (0, replay_encoding_js_1.encodeReplayImageRecord)(__assign(__assign({ context: context, resourceId: saved.resourceId, width: saved.width, height: saved.height }, (saved.mimeType ? { mimeType: saved.mimeType } : {})), { timestamp: stored.timestamp, contextChanged: contextChanged, pointerEvents: pendingPointers }));
+                        this.transport.invoke('replay.writeSegment', {
+                            viewId: context.viewId,
+                            segment: encoded.segment,
+                        });
+                        (0, replay_diagnostics_js_1.emitReplayDiagnostic)({
+                            type: 'segment_encoded',
+                            timestamp: now,
+                            byteSize: (0, replay_diagnostics_js_1.replayUtf8ByteLength)(encoded.segment),
+                            recordCount: encoded.recordCount,
+                            pointerRecordCount: pendingPointers.length,
+                            hasImage: true,
+                        });
+                        this.updateRecordCount(context.viewId, encoded.recordCount);
+                        this.pendingPointerEvents.splice(0, pendingPointers.length);
+                        this.budget.record(now, saved.byteSize, priorityKey);
+                        (0, replay_diagnostics_js_1.emitReplayDiagnostic)(__assign(__assign({ type: 'image_saved', timestamp: now, byteSize: saved.byteSize, width: saved.width, height: saved.height }, (saved.mimeType ? { mimeType: saved.mimeType } : {})), { priority: decision.priority, byteSizeSource: saved.byteSizeSource }));
+                        this.lastFingerprint = fingerprint;
+                        this.lastContextKey = contextKey;
+                        this.lastPrivacyKey = privacyKey;
+                        this.lastFrameSample = sample;
+                        this.lastImageTimestamp = now;
+                        this.lastImageSize = { width: saved.width, height: saved.height };
+                        this.lastViewportSize = viewportSize;
+                        return [2 /*return*/, true];
+                    case 5:
+                        error_1 = _e.sent();
+                        if (generation !== this.captureGeneration)
+                            return [2 /*return*/, false];
+                        (0, replay_diagnostics_js_1.emitReplayDiagnostic)({ type: 'capture_skipped', timestamp: Date.now(), reason: 'error' });
+                        console.error('[cocos-sdk] Session Replay frame dropped:', error_1);
+                        if (context && pointerSize) {
+                            try {
+                                return [2 /*return*/, this.writePendingPointers(context, pointerSize.width, pointerSize.height)];
+                            }
+                            catch (pointerError) {
+                                console.error('[cocos-sdk] Session Replay pointer segment dropped:', pointerError);
+                            }
+                        }
+                        return [2 /*return*/, false];
+                    case 6:
+                        _e.trys.push([6, , 9, 10]);
+                        if (!stored) return [3 /*break*/, 8];
+                        return [4 /*yield*/, this.capture.disposeStoredFrame(stored)];
+                    case 7:
+                        _e.sent();
+                        _e.label = 8;
+                    case 8: return [3 /*break*/, 10];
+                    case 9:
+                        this.busy = false;
+                        return [7 /*endfinally*/];
+                    case 10: return [7 /*endfinally*/];
+                    case 11: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    FTSessionReplay.prototype.startCapture = function () {
+        var _this = this;
+        this.captureGeneration += 1;
+        this.running = true;
+        this.lastFingerprint = undefined;
+        this.lastContextKey = undefined;
+        this.lastPrivacyKey = undefined;
+        this.lastFrameSample = undefined;
+        this.lastImageTimestamp = undefined;
+        this.lastImageSize = undefined;
+        this.lastViewportSize = undefined;
+        this.budget.reset();
+        this.recordCounts.clear();
+        this.pendingPointerEvents = [];
+        if (this.recordTouches && this.pointerSource) {
+            this.stopPointerTracking = this.pointerSource.onReplayPointer(function (event) {
+                (0, replay_diagnostics_js_1.emitReplayDiagnostic)({
+                    type: 'pointer_received',
+                    timestamp: event.timestamp,
+                    eventType: event.eventType,
+                });
+                _this.pendingPointerEvents.push(event);
+                if (_this.pendingPointerEvents.length > MAX_PENDING_POINTER_EVENTS) {
+                    _this.pendingPointerEvents.splice(0, _this.pendingPointerEvents.length - MAX_PENDING_POINTER_EVENTS);
+                }
+            });
+        }
+        this.schedule(0, this.captureGeneration);
+    };
+    FTSessionReplay.prototype.stopCapture = function () {
+        var _a;
+        var wasRunning = this.running;
+        this.captureGeneration += 1;
+        this.running = false;
+        (_a = this.stopPointerTracking) === null || _a === void 0 ? void 0 : _a.call(this);
+        this.stopPointerTracking = undefined;
+        this.pendingPointerEvents = [];
+        if (this.timer !== undefined)
+            clearTimeout(this.timer);
+        this.timer = undefined;
+        if (wasRunning)
+            (0, replay_diagnostics_js_1.emitReplayDiagnostic)({ type: 'replay_stopped', timestamp: Date.now() });
+    };
+    FTSessionReplay.prototype.schedule = function (delay, generation) {
+        var _this = this;
+        if (!this.running)
+            return;
+        this.timer = setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
+            var error_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.running || generation !== this.captureGeneration)
+                            return [2 /*return*/];
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, 4, 5]);
+                        return [4 /*yield*/, this.captureNow()];
+                    case 2:
+                        _a.sent();
+                        return [3 /*break*/, 5];
+                    case 3:
+                        error_2 = _a.sent();
+                        console.error('[cocos-sdk] Session Replay frame dropped:', error_2);
+                        return [3 /*break*/, 5];
+                    case 4:
+                        if (this.running && generation === this.captureGeneration) {
+                            this.schedule(1000 / this.config.captureFps, generation);
+                        }
+                        return [7 /*endfinally*/];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        }); }, delay);
+    };
+    FTSessionReplay.prototype.readContext = function () {
+        var value = this.transport.invoke('replay.getContext');
+        return normalizeRumContext(value);
+    };
+    FTSessionReplay.prototype.saveImage = function (stored, compressionQuality, maxFrameBytes) {
+        return __awaiter(this, void 0, void 0, function () {
+            var value, error_3, resourceId;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(this.imagePolicyEnabled && this.supportsSaveImageV2 !== false)) return [3 /*break*/, 4];
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.invokeSaveImage('replay.saveImageV2', {
+                                path: stored.path,
+                                width: stored.width,
+                                height: stored.height,
+                                quality: compressionQuality,
+                                maxFrameBytes: maxFrameBytes,
+                            })];
+                    case 2:
+                        value = _a.sent();
+                        if (value !== undefined) {
+                            this.supportsSaveImageV2 = true;
+                            if (isRejectedSaveImageV2(value))
+                                return [2 /*return*/, undefined];
+                            return [2 /*return*/, __assign(__assign({}, normalizeSaveImageV2Result(value)), { byteSizeSource: 'native' })];
+                        }
+                        this.supportsSaveImageV2 = false;
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_3 = _a.sent();
+                        if (!isUnknownBridgeMethod(error_3))
+                            throw error_3;
+                        this.supportsSaveImageV2 = false;
+                        return [3 /*break*/, 4];
+                    case 4: return [4 /*yield*/, this.invokeSaveImage('replay.saveImage', {
+                            path: stored.path,
+                            width: stored.width,
+                            height: stored.height,
+                        })];
+                    case 5:
+                        resourceId = _a.sent();
+                        if (!resourceId)
+                            return [2 /*return*/, undefined];
+                        return [2 /*return*/, __assign({ resourceId: resourceId, 
+                                // V1 cannot report encoded size. A conservative frame-limit estimate
+                                // still prevents configured captureFps from multiplying traffic freely.
+                                byteSize: maxFrameBytes, width: stored.width, height: stored.height, byteSizeSource: 'frame_limit_estimate' }, (this.transport.platform === 'ios' ? { mimeType: 'image/png' } : {}))];
+                }
+            });
+        });
+    };
+    FTSessionReplay.prototype.invokeSaveImage = function (method, payload) {
+        return this.transport.invokeAsync
+            ? this.transport.invokeAsync(method, payload)
+            : Promise.resolve(this.transport.invoke(method, payload));
+    };
+    FTSessionReplay.prototype.writePendingPointers = function (context, width, height) {
+        var pointerEvents = this.scaledPendingPointers(width, height);
+        if (pointerEvents.length === 0)
+            return false;
+        var encoded = (0, replay_encoding_js_1.encodeReplayPointerRecords)({ context: context, pointerEvents: pointerEvents });
+        this.transport.invoke('replay.writeSegment', {
+            viewId: context.viewId,
+            segment: encoded.segment,
+        });
+        (0, replay_diagnostics_js_1.emitReplayDiagnostic)({
+            type: 'segment_encoded',
+            timestamp: Date.now(),
+            byteSize: (0, replay_diagnostics_js_1.replayUtf8ByteLength)(encoded.segment),
+            recordCount: encoded.recordCount,
+            pointerRecordCount: pointerEvents.length,
+            hasImage: false,
+        });
+        this.updateRecordCount(context.viewId, encoded.recordCount);
+        this.pendingPointerEvents.splice(0, pointerEvents.length);
+        return true;
+    };
+    FTSessionReplay.prototype.scaledPendingPointers = function (width, height) {
+        return this.pendingPointerEvents.map(function (event) { return ({
+            eventType: event.eventType,
+            pointerId: event.pointerId,
+            x: Math.round(clamp(event.normalizedX, 0, 1) * width),
+            y: Math.round(clamp(event.normalizedY, 0, 1) * height),
+            timestamp: event.timestamp,
+        }); });
+    };
+    FTSessionReplay.prototype.updateRecordCount = function (viewId, added) {
+        var count = (this.recordCounts.get(viewId) || 0) + added;
+        this.recordCounts.set(viewId, count);
+        this.transport.invoke('replay.setRecordCount', { viewId: viewId, count: count });
+    };
+    return FTSessionReplay;
+}());
+exports.FTSessionReplay = FTSessionReplay;
+function normalizeRumContext(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    var context = value;
+    var applicationId = stringValue(context.applicationId, context.application_id);
+    var sessionId = stringValue(context.sessionId, context.session_id);
+    var viewId = stringValue(context.viewId, context.view_id);
+    if (!applicationId || !sessionId || !viewId)
+        return undefined;
+    var globalContext = context.globalContext;
+    return __assign({ applicationId: applicationId, sessionId: sessionId, viewId: viewId }, (globalContext && typeof globalContext === 'object'
+        ? { globalContext: globalContext }
+        : {}));
+}
+function stringValue() {
+    var values = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        values[_i] = arguments[_i];
+    }
+    return values.find(function (value) { return typeof value === 'string' && value.length > 0; });
+}
+function normalizeSaveImageV2Result(value) {
+    if (!value || typeof value !== 'object')
+        throw new TypeError('Invalid replay.saveImageV2 result');
+    var result = value;
+    var resourceId = stringValue(result.resourceId, result.resource_id);
+    var byteSize = numberValue(result.byteSize, result.byte_size);
+    var width = numberValue(result.width);
+    var height = numberValue(result.height);
+    var mimeType = stringValue(result.mimeType, result.mime_type);
+    if (!resourceId || !isPositiveInteger(byteSize) || !isPositiveInteger(width) || !isPositiveInteger(height)) {
+        throw new TypeError('Invalid replay.saveImageV2 result');
+    }
+    if (mimeType && !mimeType.startsWith('image/')) {
+        throw new TypeError('Invalid replay.saveImageV2 mimeType');
+    }
+    return __assign({ resourceId: resourceId, byteSize: byteSize, width: width, height: height }, (mimeType ? { mimeType: mimeType } : {}));
+}
+function isRejectedSaveImageV2(value) {
+    return typeof value === 'object' && value !== null && value.accepted === false;
+}
+function isUnknownBridgeMethod(error) {
+    return error instanceof Error && /unknown bridge method|unrecognized selector/i.test(error.message);
+}
+function numberValue() {
+    var values = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        values[_i] = arguments[_i];
+    }
+    return values.find(function (value) { return typeof value === 'number' && Number.isFinite(value); });
+}
+function isPositiveInteger(value) {
+    return value !== undefined && Number.isInteger(value) && value > 0;
+}
+function sampleReplayFrame(rgba, width, height, maximumSamples) {
+    if (maximumSamples === void 0) { maximumSamples = 4096; }
+    var pixelCount = width * height;
+    if (width < 1 || height < 1 || rgba.length < pixelCount * 4) {
+        throw new RangeError('Replay frame RGBA data does not match its dimensions');
+    }
+    var sampleCount = Math.min(maximumSamples, pixelCount);
+    var luminance = new Uint8Array(sampleCount);
+    var rgb = new Uint8Array(sampleCount * 3);
+    for (var index = 0; index < sampleCount; index += 1) {
+        var pixel = Math.min(pixelCount - 1, Math.floor(index * pixelCount / sampleCount));
+        var offset = pixel * 4;
+        rgb[index * 3] = rgba[offset];
+        rgb[index * 3 + 1] = rgba[offset + 1];
+        rgb[index * 3 + 2] = rgba[offset + 2];
+        luminance[index] = Math.round((rgba[offset] * 54 + rgba[offset + 1] * 183 + rgba[offset + 2] * 19) / 256);
+    }
+    return { width: width, height: height, luminance: luminance, rgb: rgb };
+}
+function replayFramesLookSimilar(previous, current) {
+    if (!previous
+        || previous.width !== current.width
+        || previous.height !== current.height
+        || previous.luminance.length !== current.luminance.length)
+        return false;
+    var totalDifference = 0;
+    var changedSamples = 0;
+    var tileColumns = Math.ceil(current.width / SAMPLE_TILE_SIZE);
+    var tileCount = tileColumns * Math.ceil(current.height / SAMPLE_TILE_SIZE);
+    var tileSamples = new Uint16Array(tileCount);
+    var tileChanges = new Uint16Array(tileCount);
+    for (var index = 0; index < current.luminance.length; index += 1) {
+        var difference = Math.abs(current.luminance[index] - previous.luminance[index]);
+        totalDifference += difference;
+        if (difference >= 12)
+            changedSamples += 1;
+        var pixel = Math.floor(index * current.width * current.height / current.luminance.length);
+        var tile = Math.floor(Math.floor(pixel / current.width) / SAMPLE_TILE_SIZE) * tileColumns
+            + Math.floor((pixel % current.width) / SAMPLE_TILE_SIZE);
+        tileSamples[tile] += 1;
+        var offset = index * 3;
+        // Color-only changes also matter, even when their luminance is unchanged.
+        if (Math.max(Math.abs(current.rgb[offset] - previous.rgb[offset]), Math.abs(current.rgb[offset + 1] - previous.rgb[offset + 1]), Math.abs(current.rgb[offset + 2] - previous.rgb[offset + 2])) >= 12)
+            tileChanges[tile] += 1;
+    }
+    for (var tile = 0; tile < tileCount; tile += 1) {
+        // A moving sprite can occupy much less than 1% of the whole screen.
+        if (tileChanges[tile] >= 2 && tileChanges[tile] / tileSamples[tile] >= 0.1)
+            return false;
+    }
+    var averageDifference = totalDifference / current.luminance.length;
+    var changedRatio = changedSamples / current.luminance.length;
+    return averageDifference <= 2.5 && changedRatio <= 0.01;
+}
+function privacyRegionsKey(regions) {
+    return regions.map(function (region) { return ("".concat(region.mode, ":").concat(region.x, ":").concat(region.y, ":").concat(region.width, ":").concat(region.height)); }).join('|');
+}
+function frameFingerprint(bytes) {
+    var hash = 2166136261;
+    // Sparse hashing can classify changes between sampled bytes as duplicates,
+    // bypassing both local motion detection and the approximate refresh limit.
+    // Read RGBA words without copying normal capture buffers to keep this cheap
+    // on the Cocos JS thread. Mix high bits down so every color channel matters.
+    var aligned = bytes.byteOffset % 4 === 0 ? bytes : bytes.slice();
+    var words = new Uint32Array(aligned.buffer, aligned.byteOffset, Math.floor(aligned.length / 4));
+    for (var index = 0; index < words.length; index += 1) {
+        hash = Math.imul(hash ^ words[index], 16777619);
+        hash ^= hash >>> 16;
+    }
+    for (var index = words.length * 4; index < bytes.length; index += 1) {
+        hash ^= bytes[index];
+        hash = Math.imul(hash, 16777619);
+    }
+    return "".concat(bytes.length.toString(16), "-").concat((hash >>> 0).toString(16));
+}
+function applyPrivacyRegions(rgba, width, height, regions) {
+    regions.forEach(function (region) {
+        var startX = clamp(Math.floor(region.x), 0, width);
+        var startY = clamp(Math.floor(region.y), 0, height);
+        var endX = clamp(Math.ceil(region.x + region.width), 0, width);
+        var endY = clamp(Math.ceil(region.y + region.height), 0, height);
+        var color = region.mode === 'hide' ? 0 : 128;
+        for (var y = startY; y < endY; y += 1) {
+            for (var x = startX; x < endX; x += 1) {
+                var offset = (y * width + x) * 4;
+                rgba[offset] = color;
+                rgba[offset + 1] = color;
+                rgba[offset + 2] = color;
+                rgba[offset + 3] = 255;
+            }
+        }
+    });
+}
+function clamp(value, minimum, maximum) {
+    return Math.min(maximum, Math.max(minimum, value));
+}
+//# sourceMappingURL=replay.js.map