@openreplay/tracker 18.0.12-beta.1 → 18.0.13-beta.0

package/dist/lib/index.js

@@ -2340,8 +2340,9 @@ class Nodes {
         this.nextNodeId = this.createFrameId(level, frameOrder);
     }
     registerNode(node) {
-        let id = node[this.node_id];
-        const isNew = id === undefined;
+        const existing = node[this.node_id];
+        const isNew = existing === undefined || this.nodes.get(existing) !== node;
+        let id = existing;
         if (isNew) {
             id = this.nextNodeId;
             this.totalNodeAmount++;
@@ -2370,6 +2371,12 @@ class Nodes {
             return undefined;
         return node[this.node_id];
     }
+    isBound(node) {
+        if (!node)
+            return false;
+        const id = node[this.node_id];
+        return id !== undefined && this.nodes.get(id) === node;
+    }
     getNode(id) {
         return this.nodes.get(id);
     }
@@ -2968,46 +2975,58 @@ class Observer {
         this.inlinerOptions = options.inlinerOptions;
         this.observer = createMutationObserver(this.app.safe((mutations) => {
             for (const mutation of mutations) {
-                // mutations order is sequential
-                const target = mutation.target;
-                const type = mutation.type;
-                if (!isObservable(target)) {
-                    continue;
-                }
-                if (type === 'childList') {
-                    for (let i = 0; i < mutation.removedNodes.length; i++) {
-                        // Should be the same as bindTree(mutation.removedNodes[i]), but logic needs to be be untied
-                        if (isObservable(mutation.removedNodes[i])) {
-                            this.bindNode(mutation.removedNodes[i]);
+                // THEORY S1: app.safe() wraps this whole callback in a try/catch that
+                // SILENTLY swallows — so a throw while processing one mutation aborts
+                // the entire batch (the single commitNodes() below never runs) and
+                // every pending node in it is lost. Isolating + logging per mutation
+                // both surfaces it into the session and prevents one bad node from
+                // dropping the rest of the batch.
+                try {
+                    // mutations order is sequential
+                    const target = mutation.target;
+                    const type = mutation.type;
+                    if (!isObservable(target)) {
+                        continue;
+                    }
+                    if (type === 'childList') {
+                        for (let i = 0; i < mutation.removedNodes.length; i++) {
+                            // Should be the same as bindTree(mutation.removedNodes[i]), but logic needs to be be untied
+                            if (isObservable(mutation.removedNodes[i])) {
+                                this.bindNode(mutation.removedNodes[i]);
+                            }
+                        }
+                        for (let i = 0; i < mutation.addedNodes.length; i++) {
+                            this.bindTree(mutation.addedNodes[i]);
                         }
+                        continue;
                     }
-                    for (let i = 0; i < mutation.addedNodes.length; i++) {
-                        this.bindTree(mutation.addedNodes[i]);
+                    const id = this.app.nodes.getID(target);
+                    if (id === undefined) {
+                        continue;
                     }
-                    continue;
-                }
-                const id = this.app.nodes.getID(target);
-                if (id === undefined) {
-                    continue;
-                }
-                if (!this.recents.has(id)) {
-                    this.recents.set(id, RecentsType.Changed); // TODO only when altered
-                }
-                if (type === 'attributes') {
-                    const name = mutation.attributeName;
-                    if (name === null) {
+                    if (!this.recents.has(id)) {
+                        this.recents.set(id, RecentsType.Changed); // TODO only when altered
+                    }
+                    if (type === 'attributes') {
+                        const name = mutation.attributeName;
+                        if (name === null) {
+                            continue;
+                        }
+                        let attr = this.attributesMap.get(id);
+                        if (attr === undefined) {
+                            this.attributesMap.set(id, (attr = new Set()));
+                        }
+                        attr.add(name);
                         continue;
                     }
-                    let attr = this.attributesMap.get(id);
-                    if (attr === undefined) {
-                        this.attributesMap.set(id, (attr = new Set()));
+                    if (type === 'characterData') {
+                        this.textSet.add(id);
+                        continue;
                     }
-                    attr.add(name);
-                    continue;
                 }
-                if (type === 'characterData') {
-                    this.textSet.add(id);
-                    continue;
+                catch (mutationErr) {
+                    const t = mutation.target;
+                    this.orDebug(`mutation processing threw type=${mutation.type} target=<${t.tagName ?? t.nodeName ?? 'unknown'}>: ${mutationErr?.message ?? String(mutationErr)}`);
                 }
             }
             this.commitNodes();
@@ -3173,10 +3192,11 @@ class Observer {
         this.bindNode(node);
         const walker = document.createTreeWalker(node, NodeFilter.SHOW_ELEMENT + NodeFilter.SHOW_TEXT, {
             acceptNode: (node) => {
-                if (this.app.nodes.getID(node) !== undefined) {
-                    this.app.debug.info('! Node is already bound', node);
-                }
-                return isIgnored(node) || this.app.nodes.getID(node) !== undefined
+                // Use the Map-aware isBound() rather than the raw __openreplay_id
+                // property: a node carrying a stale id from a previous observe cycle
+                // must be re-accepted and re-bound here, otherwise the snapshot walk
+                // silently skips it (and its subtree, e.g. a <style>'s CSS text).
+                return isIgnored(node) || this.app.nodes.isBound(node)
                     ? NodeFilter.FILTER_REJECT
                     : NodeFilter.FILTER_ACCEPT;
             },
@@ -3230,15 +3250,25 @@ class Observer {
             if (parent === null) {
                 // Sometimes one observation contains attribute mutations for the removimg node, which gets ignored here.
                 // That shouldn't affect the visual rendering ( should it? maybe when transition applied? )
+                // THEORY: an element silently dropped at commit time (no message emitted).
+                if (isElementNode(node)) {
+                    this.orDebug(`commit drop <${node.tagName}> reason=no-parent`);
+                }
                 this.unbindTree(node);
                 return false;
             }
             parentID = this.app.nodes.getID(parent);
             if (parentID === undefined) {
+                if (isElementNode(node)) {
+                    this.orDebug(`commit drop <${node.tagName}> reason=parent-unbound parent=<${parent.tagName ?? parent.nodeName}>`);
+                }
                 this.unbindTree(node);
                 return false;
             }
             if (!this.commitNode(parentID)) {
+                if (isElementNode(node)) {
+                    this.orDebug(`commit drop <${node.tagName}> reason=parent-commit-failed`);
+                }
                 this.unbindTree(node);
                 return false;
             }
@@ -3382,7 +3412,45 @@ class Observer {
         beforeCommit(this.app.nodes.getID(node));
         this.commitNodes(true);
     }
+    /**
+     * [OPENREPLAYDEBUG] Emits a diagnostic line INTO the recorded session's
+     * console (searchable in replay by "[OPENREPLAYDEBUG]"), NOT the local
+     * devtools console — used to test capture-loss theories against real traffic.
+     */
+    orDebug(message) {
+        try {
+            this.app.send(ConsoleLog('warn', `[OPENREPLAYDEBUG] ${message}`));
+        }
+        catch (_) {
+            /* diagnostics must never break recording */
+        }
+    }
     disconnect() {
+        // THEORY S3: a disconnect may discard MutationRecords still queued by the
+        // browser. takeRecords() drains them — they would be discarded by
+        // disconnect() below anyway, so this changes nothing functionally, it only
+        // lets us SEE whether a disconnect strands un-processed DOM additions
+        // (e.g. a freshly appended <head> <style>). NOTE: if this disconnect is part
+        // of stop(), the surrounding buffer may be cleared and this log lost; it is
+        // most reliable for mid-session re-observes (cold-start cycle / iframe).
+        const pending = this.observer.takeRecords();
+        if (pending.length) {
+            let addedEls = 0;
+            const tags = [];
+            for (const m of pending) {
+                for (let i = 0; i < m.addedNodes.length; i++) {
+                    const n = m.addedNodes[i];
+                    if (n.tagName) {
+                        addedEls++;
+                        if (tags.length < 10)
+                            tags.push(n.tagName);
+                    }
+                }
+            }
+            if (addedEls > 0) {
+                this.orDebug(`disconnect stranded ${pending.length} pending record(s), ${addedEls} added element(s): ${tags.join(',')}`);
+            }
+        }
         this.observer.disconnect();
         this.clear();
         this.throttledSetNodeData.clear();
@@ -4058,7 +4126,7 @@ class App {
         this.stopCallbacks = [];
         this.commitCallbacks = [];
         this.activityState = ActivityState.NotActive;
-        this.version = '18.0.12-beta.1'; // TODO: version compatability check inside each plugin.
+        this.version = '18.0.13-beta.0'; // TODO: version compatability check inside each plugin.
         this.socketMode = false;
         this.compressionThreshold = 24 * 1000;
         this.bc = null;
@@ -4982,6 +5050,16 @@ class App {
         }
         else if (data === 'not_init') {
             this.debug.warn('OR WebWorker: writer not initialised. Restarting tracker');
+            // [OPENREPLAYDEBUG] THEORY: a message batch reached the worker before the
+            // writer was initialised (start handshake not finished) and was DISCARDED.
+            // Surface it into the session (searchable in replay) to test whether
+            // startup batches — which can carry the initial DOM snapshot — are lost.
+            try {
+                this.send(ConsoleLog('warn', '[OPENREPLAYDEBUG] worker not_init: a pre-start message batch was discarded'));
+            }
+            catch (_) {
+                /* diagnostics must never break recording */
+            }
         }
         else if (data.type === 'failure') {
             this.stop(false);
@@ -9356,7 +9434,7 @@ class ConstantProperties {
             user_id: this.user_id,
             distinct_id: this.deviceId,
             sdk_edition: 'web',
-            sdk_version: '18.0.12-beta.1',
+            sdk_version: '18.0.13-beta.0',
             timezone: getUTCOffsetString(),
             search_engine: this.searchEngine,
         };
@@ -10058,7 +10136,7 @@ class API {
         this.signalStartIssue = (reason, missingApi) => {
             const doNotTrack = this.checkDoNotTrack();
             console.log("Tracker couldn't start due to:", JSON.stringify({
-                trackerVersion: '18.0.12-beta.1',
+                trackerVersion: '18.0.13-beta.0',
                 projectKey: this.options.projectKey,
                 doNotTrack,
                 reason: missingApi.length ? `missing api: ${missingApi.join(',')}` : reason,