@lvce-editor/renderer-process 30.58.0 → 30.58.2

package/dist/sessionReplayWorkerMain.js

@@ -4,30 +4,79 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// ../session-replay-worker/src/api/transfer.ts
-var getTransferrables = (value) => {
-  const seen = /* @__PURE__ */ new Set();
-  const result = /* @__PURE__ */ new Set();
-  const visit = (item) => {
-    if (!item || typeof item !== "object" || seen.has(item)) return;
-    seen.add(item);
-    if (Object.prototype.toString.call(item) === "[object ArrayBuffer]") result.add(item);
-    else if (ArrayBuffer.isView(item)) visit(item.buffer);
-    else if (["MessagePort", "OffscreenCanvas", "ImageBitmap", "AudioData", "VideoFrame", "ReadableStream", "WritableStream", "TransformStream"].some(
-      (name) => typeof globalThis[name] === "function" && item instanceof globalThis[name]
-    ))
-      result.add(item);
-    else if (Object.prototype.toString.call(item) === "[object Map]") {
-      for (const [key, entry] of item) {
-        visit(key);
-        visit(entry);
+// ../session-replay-worker/src/parts/ReplayCommand/ReplayCommand.ts
+var replayCommands = [
+  "Css.addCssStyleSheet",
+  "Css.removeCssStyleSheet",
+  "Viewlet.addCss",
+  "Viewlet.append",
+  "Viewlet.appendToBody",
+  "Viewlet.appendToRoot",
+  "Viewlet.commitPending",
+  "Viewlet.create",
+  "Viewlet.createFunctionalRoot",
+  "Viewlet.createPlaceholder",
+  "Viewlet.dispose",
+  "Viewlet.executeCommands",
+  "Viewlet.patchCss",
+  "Viewlet.queueCommands",
+  "Viewlet.replaceChildren",
+  "Viewlet.scrollSelectorBy",
+  "Viewlet.sendMultiple",
+  "Viewlet.setBounds",
+  "Viewlet.setCheckBoxValue",
+  "Viewlet.setComponentDom",
+  "Viewlet.setCss",
+  "Viewlet.setDom",
+  "Viewlet.setDom2",
+  "Viewlet.setInputValues",
+  "Viewlet.setPatches",
+  "Viewlet.setProperty",
+  "Viewlet.setTreePatches",
+  "Viewlet.setValueByName",
+  "Viewlet.show"
+];
+
+// ../session-replay-worker/src/parts/FilterReplayMessage/FilterReplayMessage.ts
+var createReplayMessageFilter = () => {
+  const replies = /* @__PURE__ */ Object.create(null);
+  return ({ connection, direction, message, renderer }) => {
+    if (!renderer || !message || typeof message !== "object") return false;
+    const { id, method } = message;
+    if (direction === "to-renderer") {
+      if (!replayCommands.includes(method)) return false;
+      if (method === "Viewlet.queueCommands" && id !== void 0) {
+        const pending3 = replies[connection] ||= [];
+        if (!pending3.includes(id)) pending3.push(id);
       }
-    } else if (Object.prototype.toString.call(item) === "[object Set]") {
-      for (const entry of item) visit(entry);
-    } else for (const entry of Object.values(item)) visit(entry);
+      return true;
+    }
+    if (method || id === void 0) return false;
+    const pending2 = replies[connection];
+    const index = pending2?.indexOf(id) ?? -1;
+    if (index === -1) return false;
+    pending2.splice(index, 1);
+    if (pending2.length === 0) delete replies[connection];
+    return true;
   };
-  visit(value);
-  return [...result];
+};
+
+// ../session-replay-worker/src/parts/Activity/Activity.ts
+var getActivity = (events, duration) => {
+  const length = Math.max(1, Math.min(240, Math.ceil(duration / 250)));
+  const counts = Array.from({ length });
+  counts.fill(0);
+  if (duration <= 0) return counts;
+  let initialFrame = true;
+  for (const event of events) {
+    if (event.type === "frame" && initialFrame) {
+      initialFrame = false;
+      continue;
+    }
+    const index = Math.min(counts.length - 1, Math.floor(event.timestamp / duration * counts.length));
+    counts[index]++;
+  }
+  return counts;
 };
 
 // ../../node_modules/@lvce-editor/constants/dist/parts/ElementTagMap/ElementTagMap.js
@@ -374,9 +423,9 @@ var getElementTag = (type) => {
   throw new Error(`element tag not found ${type}`);
 };
 
-// ../session-replay-worker/src/visualDom.ts
+// ../session-replay-worker/src/parts/VisualDom/VisualDom.ts
 var element = (tag = "div") => ({ attrs: {}, children: [], tag });
-var styleKeys = /* @__PURE__ */ new Set(["width", "height", "top", "left", "marginTop", "paddingLeft", "paddingRight"]);
+var styleKeys = ["width", "height", "top", "left", "translate", "marginTop", "paddingLeft", "paddingRight"];
 var attributes = { className: "class", htmlFor: "for", inputType: "type" };
 var setStyle = (node, key, value) => {
   node.attrs ||= {};
@@ -402,7 +451,7 @@ var property = (node, key, value) => {
     default:
       break;
   }
-  if (styleKeys.has(key)) {
+  if (styleKeys.includes(key)) {
     setStyle(
       node,
       key.replaceAll(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`),
@@ -430,8 +479,21 @@ var find = (node, selector) => {
   }
   return void 0;
 };
+var expandPatches = (patches) => patches.flatMap((value) => {
+  if (value.type !== 18) return [value];
+  const { navigations } = value;
+  if (!Array.isArray(navigations) || navigations.length % 2 !== 0) throw new Error("Invalid compact replay navigation");
+  const result = [];
+  for (let index = 0; index < navigations.length; index += 2) {
+    const type = navigations[index];
+    const childIndex = navigations[index + 1];
+    if (![7, 8, 10].includes(type) || !Number.isSafeInteger(childIndex) || childIndex < 0) throw new Error("Invalid compact replay navigation");
+    result.push({ ...value, index: childIndex, type });
+  }
+  return result;
+});
 var createVisualDom = () => {
-  const views = /* @__PURE__ */ new Map();
+  const views = /* @__PURE__ */ Object.create(null);
   const parents = /* @__PURE__ */ new WeakMap();
   const owners = /* @__PURE__ */ new WeakMap();
   let nodeCount = 0;
@@ -464,14 +526,14 @@ var createVisualDom = () => {
     if (parent) append(parent, next, index);
     const uid = owners.get(node);
     if (uid !== void 0) {
-      views.set(uid, next);
+      views[uid] = next;
       owners.set(next, uid);
     }
     return next;
   };
   const renderNode = (value) => {
     let node;
-    if (value.type === VirtualDomElements_exports.Reference) node = views.get(value.uid) || { text: "Reference node not found" };
+    if (value.type === VirtualDomElements_exports.Reference) node = views[value.uid] || { text: "Reference node not found" };
     else if (value.type === VirtualDomElements_exports.Text) node = { text: value.text };
     else {
       node = element(ElementTagMap_exports.getElementTag(value.type));
@@ -498,8 +560,9 @@ var createVisualDom = () => {
     if (stack.some((entry) => entry.remaining !== 0)) throw new Error("Incomplete replay virtual DOM");
     return roots;
   };
-  const patch = (uid, patches) => {
-    let current = views.get(uid);
+  const patch = (uid, input) => {
+    const patches = expandPatches(input);
+    let current = views[uid];
     if (!current) return;
     owners.set(current, uid);
     const mutations = {
@@ -509,7 +572,7 @@ var createVisualDom = () => {
       },
       10: (node, value) => parents.get(node)?.children?.[value.index],
       11: (node, value) => {
-        const next = views.get(value.uid);
+        const next = views[value.uid];
         return next ? replace(node, next) : node;
       },
       2: (node, value) => {
@@ -540,7 +603,7 @@ var createVisualDom = () => {
     };
     for (let index = 0; index < patches.length; index++) {
       const value = patches[index];
-      if (value.type === 7 && value.index === current.children?.length && patches[index + 1]?.type === 2) append(current, element());
+      if (value.type === 7 && value.index === current.children?.length && [2, 11].includes(patches[index + 1]?.type)) append(current, element());
       if (!mutations[value.type]) continue;
       current = mutations[value.type](current, value);
       if (!current) return;
@@ -549,21 +612,21 @@ var createVisualDom = () => {
   return { append, clear, detach, element, find, patch, property, render, replace, views };
 };
 
-// ../session-replay-worker/src/visualState.ts
+// ../session-replay-worker/src/parts/VisualState/VisualState.ts
 var createVisualState = (initial) => {
   const frame = structuredClone(initial);
   const dom = createVisualDom();
   const { append, clear, detach, element: element2, find: find2, patch, property: property2, render, replace, views } = dom;
-  const sheets = new Map((frame.styles || []).map((text, index) => [`initial-${index}`, text]));
-  const calls = /* @__PURE__ */ new Map();
-  const batches = /* @__PURE__ */ new Map();
+  let sheets = (frame.styles || []).map((text, index) => ({ text, uid: `initial-${index}` }));
+  const calls = /* @__PURE__ */ Object.create(null);
+  const batches = [];
   const setDom = (uid, nodes) => {
-    const view = views.get(uid);
+    const view = views[uid];
     if (!view) return;
     const next = render(nodes)[0];
     if (next) {
       replace(view, next);
-      views.set(uid, next);
+      views[uid] = next;
     }
   };
   const apply = (method, params = []) => {
@@ -573,26 +636,28 @@ var createVisualState = (initial) => {
     for (const [method, ...params] of commands2) apply(method, params);
   };
   const commit = (uid, transaction) => {
-    const batch = batches.get(transaction);
+    const batch = batches.find((entry) => entry.transaction === transaction);
     if (!batch || batch.uid !== uid) return;
     batch.committed = true;
-    for (const [key, pending2] of batches) {
+    for (let index = 0; index < batches.length; index++) {
+      const pending2 = batches[index];
       if (pending2.uid !== uid) continue;
       if (!pending2.committed) return;
       execute(pending2.commands);
-      batches.delete(key);
+      batches.splice(index, 1);
+      index--;
     }
   };
   const appendView = (uid, childId, references) => {
-    const view = views.get(uid);
-    const child = views.get(childId);
+    const view = views[uid];
+    const child = views[childId];
     if (!view || !child) return;
     const nextReferences = references?.slice(references.indexOf(childId) + 1) || [];
-    const next = nextReferences.map((id) => views.get(id)).find((node) => node && view.children?.includes(node));
+    const next = nextReferences.map((id) => views[id]).find((node) => node && view.children?.includes(node));
     append(view, child, next ? view.children.indexOf(next) : void 0);
   };
   const setProperty = (uid, selector, key, value) => {
-    const view = views.get(uid);
+    const view = views[uid];
     const node = view && find2(view, selector);
     if (!node) return;
     if (key === "textContent") {
@@ -601,29 +666,31 @@ var createVisualState = (initial) => {
     } else property2(node, key, value);
   };
   const setBounds = (uid, left, top, width, height) => {
-    const view = views.get(uid);
+    const view = views[uid];
     const bounds = Object.entries({ height, left, top, width });
     for (const [key, value] of bounds) property2(view, key, value);
   };
   const setCss = (uid, text) => {
-    sheets.set(uid, text);
+    const sheet = sheets.find((entry) => [entry.uid].includes(uid));
+    if (sheet) sheet.text = text;
+    else sheets.push({ text, uid });
   };
   const create = (_id, uid = Number(_id)) => {
-    views.set(uid, element2());
+    views[uid] = element2();
   };
   const handlers = {
     "Css.addCssStyleSheet": setCss,
     "Css.removeCssStyleSheet": (uid) => {
-      sheets.delete(uid);
+      sheets = sheets.filter((entry) => ![entry.uid].includes(uid));
     },
     "Viewlet.addCss": setCss,
     "Viewlet.append": appendView,
     "Viewlet.appendToBody": (uid) => {
-      const view = views.get(uid);
+      const view = views[uid];
       if (view) append(frame.dom, view);
     },
     "Viewlet.appendToRoot": (uid, root) => {
-      const view = views.get(uid);
+      const view = views[uid];
       const parent = find2(frame.dom, `#${root}`);
       if (view && parent) append(parent, view);
     },
@@ -631,33 +698,33 @@ var createVisualState = (initial) => {
     "Viewlet.create": create,
     "Viewlet.createFunctionalRoot": create,
     "Viewlet.createPlaceholder": (uid, parentId, top, left, width, height) => {
-      views.set(uid, element2());
-      property2(views.get(uid), "className", `Viewlet ${uid}`);
+      views[uid] = element2();
+      property2(views[uid], "className", `Viewlet ${uid}`);
       setBounds(uid, left, top, width, height);
       appendView(parentId, uid);
     },
     "Viewlet.dispose": (uid) => {
-      const view = views.get(uid);
+      const view = views[uid];
       if (view) detach(view);
-      views.delete(uid);
-      sheets.delete(uid);
+      delete views[uid];
+      sheets = sheets.filter((entry) => ![entry.uid].includes(uid));
     },
     "Viewlet.executeCommands": execute,
     "Viewlet.patchCss": (uid, start, count, replacement) => {
-      const text = sheets.get(uid);
-      if (typeof text === "string") sheets.set(uid, text.slice(0, start) + replacement + text.slice(start + count));
+      const sheet = sheets.find((entry) => [entry.uid].includes(uid));
+      if (sheet) sheet.text = sheet.text.slice(0, start) + replacement + sheet.text.slice(start + count);
     },
     "Viewlet.replaceChildren": (uid, children) => {
-      const view = views.get(uid);
+      const view = views[uid];
       if (!view) return;
       clear(view);
       for (const id of children) {
-        const child = views.get(id);
+        const child = views[id];
         if (child) append(view, child);
       }
     },
     "Viewlet.scrollSelectorBy": (uid, selector, delta) => {
-      const view = views.get(uid);
+      const view = views[uid];
       const node = view && find2(view, selector);
       if (node) property2(node, "scrollLeft", (node.scroll?.[0] || 0) + delta);
     },
@@ -667,7 +734,7 @@ var createVisualState = (initial) => {
     "Viewlet.setComponentDom": setDom,
     "Viewlet.setCss": setCss,
     "Viewlet.setDom": (uid, nodes) => {
-      const view = views.get(uid);
+      const view = views[uid];
       if (!view) return;
       clear(view);
       const children = render(nodes);
@@ -685,7 +752,7 @@ var createVisualState = (initial) => {
     "Viewlet.setTreePatches": patch,
     "Viewlet.setValueByName": (uid, name, value) => setProperty(uid, `[name="${name}"]`, "value", value),
     "Viewlet.show": (uid) => {
-      const view = views.get(uid);
+      const view = views[uid];
       if (view) append(find2(frame.dom, "#Workbench") || frame.dom, view);
     }
   };
@@ -695,21 +762,27 @@ var createVisualState = (initial) => {
       const { connection, direction, message } = data;
       const key = `${connection}:${message.id}`;
       if (direction === "to-renderer") {
-        if (message.method === "Viewlet.queueCommands") calls.set(key, message.params);
+        if (message.method === "Viewlet.queueCommands") calls[key] = message.params;
         else apply(message.method, message.params);
-      } else if (calls.has(key)) {
-        const [uid, commands2] = calls.get(key);
-        calls.delete(key);
-        if (Number.isSafeInteger(message.result)) batches.set(message.result, { commands: commands2, committed: false, uid });
+      } else if (Object.hasOwn(calls, key)) {
+        const [uid, commands2] = calls[key];
+        delete calls[key];
+        if (Number.isSafeInteger(message.result)) {
+          const transaction = message.result;
+          const batch = { commands: commands2, committed: false, transaction, uid };
+          const index = batches.findIndex((entry) => entry.transaction === transaction);
+          if (index === -1) batches.push(batch);
+          else batches[index] = batch;
+        }
       }
     },
     frame() {
-      return { ...frame, styles: [...sheets.values()] };
+      return { ...frame, styles: sheets.map((sheet) => sheet.text) };
     }
   };
 };
 
-// ../session-replay-worker/src/protocol.ts
+// ../session-replay-worker/src/parts/Protocol/Protocol.ts
 var version = 1;
 var maxEventBytes = 75e4;
 var maxSessionBytes = 64 * 1024 * 1024;
@@ -760,19 +833,46 @@ var loadContent = (value) => {
     }
     return { duration, frame: frames[Math.max(0, low - 1)].data, position };
   };
-  return { duration, seek };
+  return { activity: getActivity(session.events, duration), duration, seek };
 };
 
-// ../session-replay-worker/src/proxy.ts
-var wrapPorts = (value, replacePort, seen = /* @__PURE__ */ new Map()) => {
+// ../session-replay-worker/src/parts/Transfer/Transfer.ts
+var getTransferrables = (value) => {
+  const seen = [];
+  const result = [];
+  const visit = (item) => {
+    if (!item || typeof item !== "object" || seen.includes(item)) return;
+    seen.push(item);
+    if (Object.prototype.toString.call(item) === "[object ArrayBuffer]") result.push(item);
+    else if (ArrayBuffer.isView(item)) visit(item.buffer);
+    else if (["MessagePort", "OffscreenCanvas", "ImageBitmap", "AudioData", "VideoFrame", "ReadableStream", "WritableStream", "TransformStream"].some(
+      (name) => typeof globalThis[name] === "function" && item instanceof globalThis[name]
+    ))
+      result.push(item);
+    else if (Object.prototype.toString.call(item) === "[object Map]") {
+      for (const [key, entry] of item) {
+        visit(key);
+        visit(entry);
+      }
+    } else if (Object.prototype.toString.call(item) === "[object Set]") {
+      for (const entry of item) visit(entry);
+    } else for (const entry of Object.values(item)) visit(entry);
+  };
+  visit(value);
+  return result;
+};
+
+// ../session-replay-worker/src/parts/Proxy/Proxy.ts
+var wrapPorts = (value, replacePort, seen = []) => {
   if (!value || typeof value !== "object") return value;
-  if (seen.has(value)) return seen.get(value);
+  const previous = seen.find((entry) => entry.original === value);
+  if (previous) return previous.replacement;
   if (value instanceof MessagePort) {
     const replacement = replacePort(value);
-    seen.set(value, replacement);
+    seen.push({ original: value, replacement });
     return replacement;
   }
-  seen.set(value, value);
+  seen.push({ original: value, replacement: value });
   if (value instanceof Map) {
     const entries = [...value];
     value.clear();
@@ -787,12 +887,18 @@ var wrapPorts = (value, replacePort, seen = /* @__PURE__ */ new Map()) => {
   }
   return value;
 };
+var consumeReply = (replies, id) => {
+  const index = replies.findIndex((reply) => [reply].includes(id));
+  if (index === -1) return false;
+  replies.splice(index, 1);
+  return true;
+};
 var createProxyRegistry = ({
   record,
   report: report2 = () => {
   }
 }) => {
-  const connections = /* @__PURE__ */ new Set();
+  const connections = /* @__PURE__ */ Object.create(null);
   let nextId = 0;
   const createNestedPort = (connection, renderer, port) => create(port, `${connection}/port`, renderer);
   const create = (port, label = "renderer", renderer = true) => {
@@ -806,16 +912,16 @@ var createProxyRegistry = ({
         endpoint.onmessageerror = null;
         endpoint.close();
       }
-      connections.delete(close);
+      delete connections[connection];
     };
-    connections.add(close);
-    const ignoredReplies = { "from-renderer": /* @__PURE__ */ new Set(), "to-renderer": /* @__PURE__ */ new Set() };
+    connections[connection] = close;
+    const ignoredReplies = { "from-renderer": [], "to-renderer": [] };
     const forward = (source, target, direction) => {
       source.onmessage = ({ data }) => {
         const opposite = direction === "to-renderer" ? "from-renderer" : "to-renderer";
         const ignored = typeof data?.method === "string" && data.method.startsWith("SessionReplay.");
-        if (ignored && data.id !== void 0) ignoredReplies[opposite].add(data.id);
-        const ignoredReply = !data?.method && ignoredReplies[direction].delete(data?.id);
+        if (ignored && data.id !== void 0 && !ignoredReplies[opposite].includes(data.id)) ignoredReplies[opposite].push(data.id);
+        const ignoredReply = !data?.method && consumeReply(ignoredReplies[direction], data?.id);
         if (!ignored && !ignoredReply) {
           try {
             record({ connection, direction, label, message: data, renderer });
@@ -839,14 +945,15 @@ var createProxyRegistry = ({
   return {
     create,
     dispose() {
-      for (const close of connections) close();
+      for (const close of Object.values(connections)) close();
     }
   };
 };
 
-// ../session-replay-worker/src/recorder.ts
+// ../session-replay-worker/src/parts/Recorder/Recorder.ts
 var createRecorder = ({
   fetch: request = globalThis.fetch,
+  navigator = globalThis.navigator,
   now = () => performance.now(),
   storage: storage2
 }) => {
@@ -865,7 +972,13 @@ var createRecorder = ({
     if (metadata) throw new Error("A session is already recording");
     options = config;
     origin = now();
-    metadata = { createdAt: (/* @__PURE__ */ new Date()).toISOString(), id: crypto.randomUUID(), version };
+    metadata = {
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      id: crypto.randomUUID(),
+      platform: navigator?.platform || "",
+      userAgent: navigator?.userAgent || "",
+      version
+    };
     if (options.local) await storage2.save(metadata, []);
     return metadata.id;
   };
@@ -899,7 +1012,8 @@ var createRecorder = ({
       if (!response.ok) throw new Error(`Session replay upload failed (${response.status})`);
       return response.json();
     };
-    if (!remote) remote = await send(endpoint, { createdAt: metadata.createdAt, version });
+    if (!remote)
+      remote = await send(endpoint, { createdAt: metadata.createdAt, platform: metadata.platform, userAgent: metadata.userAgent, version });
     while (pending2.length > 0) {
       const batch = [];
       let batchBytes = 0;
@@ -947,7 +1061,7 @@ var createRecorder = ({
   };
 };
 
-// ../session-replay-worker/src/api/capture.ts
+// ../session-replay-worker/src/parts/Capture/Capture.ts
 var serializeMessage = (message) => {
   const ancestors = [];
   let count = 0;
@@ -968,13 +1082,13 @@ var serializeMessage = (message) => {
   );
 };
 
-// ../session-replay-worker/src/serializeProxyMessage.ts
+// ../session-replay-worker/src/parts/SerializeProxyMessage/SerializeProxyMessage.ts
 var redacted = "[redacted]";
 var isMasked = (node) => node.inputType === "password" || Object.hasOwn(node, "data-session-replay-mask") || Object.hasOwn(node, "data-session-replay-ignore");
-var structuralKeys = /* @__PURE__ */ new Set(["type", "childCount", "uid"]);
+var structuralKeys = ["type", "childCount", "uid"];
 var redactNode = (node) => {
   for (const key of Object.keys(node)) {
-    if (structuralKeys.has(key)) continue;
+    if (structuralKeys.includes(key)) continue;
     if (["text", "value", "textContent"].includes(key)) node[key] = redacted;
     else if (key === "inputType" && node[key] === "password") continue;
     else if (["data-session-replay-mask", "data-session-replay-ignore"].includes(key)) node[key] = "";
@@ -993,14 +1107,14 @@ var redactUpdates = (method, params) => {
   }
 };
 var createMessageSerializer = () => {
-  const maskedViews = /* @__PURE__ */ new Set();
+  const maskedViews = /* @__PURE__ */ Object.create(null);
   const sanitizeCommand = (method, params, masked) => {
     if (!method.startsWith("Viewlet.") || typeof params[0] !== "number") return;
     const uid = params[0];
     const patches = params[1];
     const masksInput = Array.isArray(patches) && patches.some((patch) => patch?.key === "inputType" && patch.value === "password");
-    if (masked || masksInput) maskedViews.add(uid);
-    if (maskedViews.has(uid)) redactUpdates(method, params);
+    if (masked || masksInput) maskedViews[uid] = true;
+    if (maskedViews[uid]) redactUpdates(method, params);
   };
   const sanitizeArray = (array) => {
     let remaining = 0;
@@ -1040,7 +1154,7 @@ var createMessageSerializer = () => {
   };
 };
 
-// ../session-replay-worker/src/storage.ts
+// ../session-replay-worker/src/parts/Storage/Storage.ts
 var withoutSessionId = ({ sessionId, ...event }) => event;
 var open = () => new Promise((resolve, reject) => {
   const request = indexedDB.open("lvce-session-replays", 1);
@@ -1075,7 +1189,7 @@ var createStorage = async () => {
   };
 };
 
-// ../session-replay-worker/src/worker.ts
+// ../session-replay-worker/src/parts/Worker/Worker.ts
 var storage;
 var recorder;
 var content;
@@ -1091,9 +1205,10 @@ var report = (error) => {
   recording = false;
 };
 var serializeMessage2 = createMessageSerializer();
+var shouldRecord = createReplayMessageFilter();
 var proxies = createProxyRegistry({
   record(message) {
-    if (!recording) return;
+    if (!recording || !shouldRecord(message)) return;
     if (pending >= 500) {
       report(new Error("Recording cannot keep up with worker messages"));
       return;
@@ -1125,7 +1240,7 @@ var commands = {
       session = await response.json();
     } else ({ session } = source);
     content = loadContent(session);
-    return content.seek(0);
+    return { ...content.seek(0), activity: content.activity };
   },
   proxy: (port) => proxies.create(port),
   record: (...params) => recorder.record(...params),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/renderer-process",
-  "version": "30.58.0",
+  "version": "30.58.2",
   "keywords": [
     "lvce-editor",
     "renderer-process"