@oxvo/browser 7.3.0 → 7.4.15

package/dist/cjs/main/app/canvas.d.ts

@@ -20,6 +20,8 @@ declare class CanvasRecorder {
     private uploadQueue;
     private readonly MAX_CONCURRENT_UPLOADS;
     private readonly MAX_QUEUE_SIZE;
+    private readonly MAX_UPLOAD_ATTEMPTS;
+    private readonly MAX_RETRY_DELAY_MS;
     private readonly pendingBatches;
     private isProcessingQueue;
     constructor(app: App, options: Options);
@@ -39,7 +41,10 @@ declare class CanvasRecorder {
     }[], canvasId: number, createdAt: number): void;
     private processUploadQueue;
     private uploadBatch;
+    private isRetryableUploadStatus;
+    private waitBeforeUploadRetry;
     private cleanupCanvas;
+    flushPendingSnapshots(): void;
     clear(): void;
 }
 export default CanvasRecorder;

package/dist/cjs/main/app/cross_domain_iframe.d.ts

@@ -0,0 +1,44 @@
+import type Message from './messages.gen.js';
+export declare const CROSS_DOMAIN_IFRAME_PROTOCOL_VERSION: 1;
+export declare const CROSS_DOMAIN_IFRAME_ALLOWED_MESSAGE_TYPES: ReadonlySet<number>;
+export type CrossDomainIframeEnvelope = {
+    protocolVersion: typeof CROSS_DOMAIN_IFRAME_PROTOCOL_VERSION;
+    context: string;
+    nonce: string;
+    capability: string;
+};
+export type CrossDomainIframeHandshake = Omit<CrossDomainIframeEnvelope, 'capability'> & {
+    projectKey: string;
+};
+export type CrossDomainIframeSession = {
+    sessionID: string;
+    projectID?: string;
+    startedAt: number;
+    delayMs: number;
+    userUUID: string;
+};
+export type CrossDomainIframeCanvas = {
+    enabled: boolean;
+    quality?: 'low' | 'medium' | 'high';
+    fps?: number;
+    framesSupport?: boolean;
+};
+type ParsedIframeBatch = {
+    messages: Message[];
+    bytes: number;
+} | null;
+export declare function normalizeCrossDomainOrigin(value: unknown): string | null;
+export declare function normalizeCrossDomainOrigins(values: unknown): Set<string>;
+export declare function createCrossDomainSecret(): string | null;
+export declare function parseCrossDomainHandshake(data: unknown, expectedLine: string, expectedProjectKey: string): CrossDomainIframeHandshake | null;
+export declare function matchesCrossDomainEnvelope(data: unknown, expectedLine: string, expected: CrossDomainIframeEnvelope): data is Record<string, unknown> & CrossDomainIframeEnvelope;
+export declare function parseCrossDomainFrameInit(data: unknown, expectedLine: string, expected: Pick<CrossDomainIframeEnvelope, 'context' | 'nonce'>): (CrossDomainIframeEnvelope & {
+    id: number;
+    frameOrderNumber: number;
+    frameLevel: number;
+    capabilityExpiresAt: number;
+    session: CrossDomainIframeSession;
+    canvas?: CrossDomainIframeCanvas;
+}) | null;
+export declare function parseCrossDomainIframeBatch(messages: unknown): ParsedIframeBatch;
+export {};

package/dist/cjs/main/app/debugRedaction.d.ts

@@ -0,0 +1,11 @@
+export declare const redactDebugText: (value: string) => string;
+type DebugRedactionState = {
+    seen: WeakSet<object>;
+    remainingItems: number;
+    remainingText: number;
+};
+export declare const redactDebugValue: (value: unknown, state?: DebugRedactionState, depth?: number) => unknown;
+export declare const redactDebugArgs: (values: unknown[]) => unknown[];
+export declare const debugValueText: (value: unknown) => string;
+export declare const redactedErrorFrom: (value: unknown, fallback: string, knownSecrets?: ReadonlyArray<string | null | undefined>) => Error;
+export {};

package/dist/cjs/main/app/index.d.ts

@@ -30,9 +30,19 @@ export interface StartOptions {
 interface OnStartInfo {
     sessionID: string;
     sessionToken: string;
+    assistToken?: string;
     userUUID: string;
 }
+type AssistSessionGrant = Readonly<{
+    sessionId: string;
+    token: string;
+}>;
 declare const CANCELED: "canceled";
+export type MessengerLinkageChallenge = Readonly<{
+    challenge: string;
+    sessionId: string;
+    expiresIn: number;
+}>;
 type SuccessfulStart = OnStartInfo & {
     success: true;
 };
@@ -97,11 +107,16 @@ type AppOptions = {
          * */
         enabled?: boolean;
         /**
-         * used to send message up, will be '*' by default
-         * (check your CSP settings)
-         * @default '*'
+         * Exact parent origin used by a tracker running inside a child iframe.
+         * Wildcards are rejected.
          * */
         parentDomain?: string;
+        /**
+         * Exact child origins allowed to join the top-level recording. The
+         * cross-domain listener is not installed unless this list is non-empty.
+         * Wildcards are rejected.
+         * */
+        childOrigins?: string[];
     };
     networkCapture?: NetworkOptions;
     /**
@@ -162,6 +177,9 @@ export default class App {
     private canvasRecorder;
     private conditionsManager;
     private readonly markerWatcher;
+    private readonly bootstrapAttempts;
+    private offlineRecordingSessionToken;
+    private assistSessionGrant;
     get tagMatcher(): TagMatcher;
     private canStart;
     private rootId;
@@ -169,22 +187,43 @@ export default class App {
     private frameOderNumber;
     private frameLevel;
     private emptyBatchCounter;
+    private readonly crossDomainChildOrigins;
+    private readonly crossDomainParentOrigin;
+    private readonly crossDomainFrameNonce;
+    private crossDomainFrameCapability;
+    private crossDomainFrameCapabilityExpiresAt;
+    private crossDomainFrameSession;
+    private crossDomainFrameCanvas;
+    private crossDomainResumeAfterHandshake;
+    private crossDomainConnectionRequested;
+    private readonly crossDomainFrames;
+    private readonly crossDomainEnvelopeBudgets;
+    private readonly pendingCrossDomainFrames;
+    private crossDomainAuthorizationGeneration;
+    private nextCrossDomainFrameOrder;
+    private crossDomainCanvasConfig;
     constructor(projectKey: string, sessionToken: string | undefined, options: Partial<Options>, signalError: (error: string, apis: string[]) => void, insideIframe: boolean);
     /** used by child iframes for crossdomain only */
     parentActive: boolean;
     checkStatus: () => boolean;
+    private postToParent;
+    private postHandshakeToParent;
+    private applyCrossDomainFrameInit;
+    private clearCrossDomainFrameAuthorization;
     parentCrossDomainFrameListener: (event: MessageEvent) => void;
-    trackedFrames: string[];
-    private frameLastSeen;
-    private readonly FRAME_STALE_MS;
-    private pruneStaleFrames;
+    private findCrossDomainFrame;
+    private revokeCrossDomainFrame;
+    private pruneDetachedCrossDomainFrames;
+    private currentCrossDomainSession;
+    private frameInitPayload;
+    private rotateCrossDomainFrameCapability;
+    private crossDomainFrameNeedsRotation;
+    private postToCrossDomainFrame;
+    private consumeCrossDomainEnvelopeBudget;
+    private establishCrossDomainFrame;
+    private validatedCrossDomainFrame;
+    private consumeCrossDomainFrameBudget;
     crossDomainIframeListener: (event: MessageEvent) => void;
-    /**
-     * { command : [remaining iframes] }
-     * + order of commands
-     **/
-    pollingQueue: Record<string, any>;
-    private readonly addCommand;
     bootChildrenFrames: () => Promise<void>;
     killChildrenFrames: () => void;
     signalIframeTracker: () => void;
@@ -221,18 +260,33 @@ export default class App {
     checkRequiredVersion(version: string): boolean;
     private getTrackerInfo;
     private buildStartPayload;
+    private getBootstrapAttemptStorageKey;
+    private isValidBootstrapAttempt;
+    private removeStoredBootstrapAttempt;
+    private loadBootstrapAttempt;
+    private getOrCreateBootstrapAttempt;
+    private clearBootstrapAttempt;
+    private buildBootstrapIntentFingerprint;
+    private parseBootstrapIntent;
+    private bootstrapIntentsMatch;
     getSessionMeta(): {
         userUUID: string | null;
         projectKey: string;
         revID: string;
         trackerVersion: string;
         isSnippet: boolean;
+        metadata: {
+            [x: string]: string;
+        };
         sessionID: string | undefined;
-        metadata: Record<string, string>;
         userID: string | null;
         timestamp: number;
         projectID?: string;
     };
+    requestMessengerLinkageChallenge(): Promise<MessengerLinkageChallenge | null>;
+    getAssistSessionGrant(): AssistSessionGrant | null;
+    private setAssistSessionGrant;
+    private clearAssistSessionGrant;
     getSessionSecret(): string | undefined;
     getSessionKey(): string | undefined;
     getSessionLink(options?: {
@@ -294,6 +348,7 @@ export default class App {
     uploadOfflineRecording(): Promise<void>;
     prevOpts: StartOptions;
     private userStartCallback?;
+    private startCrossDomainFrame;
     private _start;
     restartCanvasTracking: () => void;
     attachResanitizeCallback: (cb: (node: Node, id: number) => void) => void;
@@ -302,6 +357,7 @@ export default class App {
     checkSanitization: (el: Node) => SanitizeLevel | undefined;
     flushBuffer: (buffer: Message[]) => Promise<unknown>;
     waitStart(): Promise<unknown>;
+    private waitCrossDomainStart;
     waitStarted(): Promise<unknown>;
     waitStatus(status: ActivityState): Promise<unknown>;
     /**

package/dist/cjs/main/app/messages.gen.d.ts

@@ -1,5 +1,7 @@
 import * as Messages from '../../common/messages.gen.js';
 export { default, Type } from '../../common/messages.gen.js';
+export type MessageFieldType = 'number' | 'string' | 'boolean';
+export declare const MESSAGE_FIELD_TYPES: Readonly<Record<number, readonly MessageFieldType[]>>;
 export declare function Timestamp(timestamp: number): Messages.Timestamp;
 export declare function SetPageLocationDeprecated(url: string, referrer: string, navigationStart: number): Messages.SetPageLocationDeprecated;
 export declare function SetViewportSize(width: number, height: number): Messages.SetViewportSize;

package/dist/cjs/main/app/session.d.ts

@@ -47,6 +47,7 @@ export default class Session {
     getSessionSecret: (projectKey?: string) => string | undefined;
     getRawSecretWithProject: () => string | null;
     setSessionSecret: (token: string, projectKey: string) => void;
+    clearSessionSecret: () => void;
     applySessionHash(hash: string): void;
     getSessionHash(): string | undefined;
     getTabId(): string;

package/dist/cjs/main/entry.d.ts

@@ -1,6 +1,6 @@
-import TrackerClass from './index';
-export { default as App } from './app/index';
-export { default as browser, default as oxvosessions } from './singleton';
-export { SanitizeLevel, Messages, Options } from './index';
-export { default as Analytics } from './modules/analytics/index';
+import TrackerClass from './index.js';
+export { default as App } from './app/index.js';
+export { default as browser, default as oxvosessions } from './singleton.js';
+export { SanitizeLevel, Messages, Options } from './index.js';
+export { default as Analytics } from './modules/analytics/index.js';
 export default TrackerClass;

package/dist/cjs/main/index.d.ts

@@ -1,4 +1,4 @@
-import App from './app/index';
+import App from './app/index.js';
 export { default as App } from './app/index.js';
 import * as _Messages from './app/messages.gen.js';
 export declare const Messages: typeof _Messages;
@@ -109,6 +109,11 @@ export default class API {
     stop(): string | undefined;
     forceFlushBatch(): void;
     getSessionSecret(): string | null | undefined;
+    requestMessengerLinkageChallenge(): Promise<Readonly<{
+        challenge: string;
+        sessionId: string;
+        expiresIn: number;
+    }> | null>;
     getSessionMeta(): SessionInfo | null;
     getSessionKey(): string | null | undefined;
     getTabId(): string | null;

package/dist/cjs/main/modules/analytics/index.d.ts

@@ -32,6 +32,7 @@ export default class Analytics {
     private readonly getTimestamp;
     private readonly setUserId;
     private readonly standalone;
+    private pendingStartAttempt;
     /**
      * @param localStorage Class or Object that implements Storage-like interface that stores
      * values persistently like window.localStorage or any other file-based storage
@@ -50,6 +51,10 @@ export default class Analytics {
     constructor(options: Options);
     _getToken: () => string | null;
     _getTimestamp: () => number;
+    private loadStartAttempt;
+    private isValidStartAttempt;
+    private startAttempt;
+    private clearStartAttempt;
     init: () => Promise<void>;
     /**
      * Used by tracker when running in blundled mode

package/dist/cjs/main/singleton.d.ts

@@ -34,6 +34,11 @@ declare class BrowserSingleton {
     }): string | undefined;
     getSessionKey(): string | null | undefined;
     getSessionSecret(): string | null | undefined;
+    requestMessengerLinkageChallenge(): Promise<Readonly<{
+        challenge: string;
+        sessionId: string;
+        expiresIn: number;
+    }> | null>;
     track(key: string, payload?: any, issue?: boolean): void;
     report(key: string, payload?: any): void;
     handleError(e: Error | ErrorEvent | PromiseRejectionEvent, metadata?: Record<string, any>): void;

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}