@highlight-run/rrweb 2.0.0-lambda.7 → 2.0.0-lambda.8

package/dist/rrweb.js

@@ -1873,6 +1873,7 @@ function requireStringifier$1() {
   hasRequiredStringifier$1 = 1;
   const STYLE_TAG = /(<)(\/?style\b)/gi;
   const COMMENT_OPEN = /(<)(!--)/g;
+  const AT_NAME_END = /[\t\n\f\r "#'()/;[\\\]{}]/;
   function escapeHTMLInCSS(str) {
     if (typeof str !== "string") return str;
     if (!str.includes("<")) return str;
@@ -1898,12 +1899,13 @@ function requireStringifier$1() {
   function atruleStart(str, node2) {
     let name = "@" + node2.name;
     let params = node2.params ? str.rawValue(node2, "params") : "";
-    if (typeof node2.raws.afterName !== "undefined") {
-      name += node2.raws.afterName;
-    } else if (params) {
-      name += " ";
+    let afterName = node2.raws.afterName;
+    if (typeof afterName === "undefined") {
+      afterName = params ? " " : "";
+    } else if (afterName === "" && params && !AT_NAME_END.test(params[0])) {
+      afterName = " ";
     }
-    return name + params;
+    return name + afterName + params;
   }
   function pushBody(str, stack, node2) {
     let nodes = node2.nodes;
@@ -1915,10 +1917,15 @@ function requireStringifier$1() {
     let semicolon = str.raw(node2, "semicolon");
     let isDocument = node2.type === "document";
     for (let i2 = nodes.length - 1; i2 >= 0; i2--) {
+      let child = nodes[i2];
+      let childSemicolon = last !== i2 || semicolon;
+      if (!childSemicolon && i2 < nodes.length - 1 && (child.type === "atrule" && !child.nodes || child.type === "decl" && child.prop.startsWith("--"))) {
+        childSemicolon = true;
+      }
       stack.push({
         document: isDocument,
-        node: nodes[i2],
-        semicolon: last !== i2 || semicolon
+        node: child,
+        semicolon: childSemicolon
       });
     }
   }
@@ -2209,6 +2216,9 @@ function requireStringifier$1() {
       return value;
     }
     root(node2) {
+      if (node2.source && node2.source.input.hasBOM) {
+        this.builder("\uFEFF", node2, "start");
+      }
       this.body(node2);
       if (node2.raws.after) {
         let after = node2.raws.after;
@@ -3281,15 +3291,12 @@ function requirePreviousMap$1() {
     }
     loadFile(path, cssFile, trusted) {
       if (!trusted && !this.unsafeMap) {
-        if (!/\.map$/i.test(path)) {
+        if (!/\.map$/i.test(path)) return void 0;
+        if (!cssFile) return void 0;
+        let rel = relative(dirname(cssFile), path);
+        if (rel === ".." || rel.startsWith(".." + sep) || isAbsolute(rel)) {
           return void 0;
         }
-        if (cssFile) {
-          let relativePath = relative(dirname(cssFile), path);
-          if (relativePath === ".." || relativePath.startsWith(".." + sep) || isAbsolute(relativePath)) {
-            return void 0;
-          }
-        }
       }
       this.root = dirname(path);
       if (existsSync(path)) {
@@ -3661,6 +3668,7 @@ function requireList$1() {
       return list.split(string, spaces);
     },
     split(string, separators, last) {
+      if (!string) return [];
       let array = [];
       let current = "";
       let split = false;
@@ -4947,11 +4955,16 @@ var hasRequiredWarning$1;
 function requireWarning$1() {
   if (hasRequiredWarning$1) return warning$1;
   hasRequiredWarning$1 = 1;
+  let Container = requireContainer$1();
+  let { my } = requireSymbols$1();
   class Warning {
     constructor(text, opts = {}) {
       this.type = "warning";
       this.text = text;
       if (opts.node && opts.node.source) {
+        if (!opts.node[my]) {
+          Container.rebuild(opts.node);
+        }
         let range = opts.node.rangeBy(opts);
         this.line = range.start.line;
         this.column = range.start.column;
@@ -5461,14 +5474,19 @@ function requireLazyResult$1() {
       }
       if (visit2.iterator !== 0) {
         let iterator = visit2.iterator;
+        if (visit2.descending) {
+          visit2.descending = false;
+          node2.indexes[iterator] += 1;
+        }
         let child;
         while (child = node2.nodes[node2.indexes[iterator]]) {
-          node2.indexes[iterator] += 1;
           if (!child[isClean]) {
             child[isClean] = true;
+            visit2.descending = true;
             stack.push(toStack(child));
             return;
           }
+          node2.indexes[iterator] += 1;
         }
         visit2.iterator = 0;
         delete node2.indexes[iterator];
@@ -5498,12 +5516,16 @@ function requireLazyResult$1() {
         let visitNode = visit2.node;
         if (visit2.iterator !== 0) {
           let iterator = visit2.iterator;
+          if (visit2.descending) {
+            visit2.descending = false;
+            visitNode.indexes[iterator] += 1;
+          }
           let child;
           let descended = false;
           while (child = visitNode.nodes[visitNode.indexes[iterator]]) {
-            visitNode.indexes[iterator] += 1;
             if (!child[isClean]) {
               child[isClean] = true;
+              visit2.descending = true;
               stack.push({
                 eventIndex: 0,
                 events: getEvents(child),
@@ -5513,6 +5535,7 @@ function requireLazyResult$1() {
               descended = true;
               break;
             }
+            visitNode.indexes[iterator] += 1;
           }
           if (descended) continue;
           visit2.iterator = 0;
@@ -5675,7 +5698,7 @@ function requireProcessor$1() {
   let Root = requireRoot$1();
   class Processor {
     constructor(plugins = []) {
-      this.version = "8.5.19";
+      this.version = "8.5.25";
       this.plugins = this.normalize(plugins);
     }
     normalize(plugins) {
@@ -6542,6 +6565,7 @@ function requireStringifier() {
   hasRequiredStringifier = 1;
   const STYLE_TAG = /(<)(\/?style\b)/gi;
   const COMMENT_OPEN = /(<)(!--)/g;
+  const AT_NAME_END = /[\t\n\f\r "#'()/;[\\\]{}]/;
   function escapeHTMLInCSS(str) {
     if (typeof str !== "string") return str;
     if (!str.includes("<")) return str;
@@ -6567,12 +6591,13 @@ function requireStringifier() {
   function atruleStart(str, node2) {
     let name = "@" + node2.name;
     let params = node2.params ? str.rawValue(node2, "params") : "";
-    if (typeof node2.raws.afterName !== "undefined") {
-      name += node2.raws.afterName;
-    } else if (params) {
-      name += " ";
+    let afterName = node2.raws.afterName;
+    if (typeof afterName === "undefined") {
+      afterName = params ? " " : "";
+    } else if (afterName === "" && params && !AT_NAME_END.test(params[0])) {
+      afterName = " ";
     }
-    return name + params;
+    return name + afterName + params;
   }
   function pushBody(str, stack, node2) {
     let nodes = node2.nodes;
@@ -6584,10 +6609,15 @@ function requireStringifier() {
     let semicolon = str.raw(node2, "semicolon");
     let isDocument = node2.type === "document";
     for (let i2 = nodes.length - 1; i2 >= 0; i2--) {
+      let child = nodes[i2];
+      let childSemicolon = last !== i2 || semicolon;
+      if (!childSemicolon && i2 < nodes.length - 1 && (child.type === "atrule" && !child.nodes || child.type === "decl" && child.prop.startsWith("--"))) {
+        childSemicolon = true;
+      }
       stack.push({
         document: isDocument,
-        node: nodes[i2],
-        semicolon: last !== i2 || semicolon
+        node: child,
+        semicolon: childSemicolon
       });
     }
   }
@@ -6878,6 +6908,9 @@ function requireStringifier() {
       return value;
     }
     root(node2) {
+      if (node2.source && node2.source.input.hasBOM) {
+        this.builder("\uFEFF", node2, "start");
+      }
       this.body(node2);
       if (node2.raws.after) {
         let after = node2.raws.after;
@@ -7950,15 +7983,12 @@ function requirePreviousMap() {
     }
     loadFile(path, cssFile, trusted) {
       if (!trusted && !this.unsafeMap) {
-        if (!/\.map$/i.test(path)) {
+        if (!/\.map$/i.test(path)) return void 0;
+        if (!cssFile) return void 0;
+        let rel = relative(dirname(cssFile), path);
+        if (rel === ".." || rel.startsWith(".." + sep) || isAbsolute(rel)) {
           return void 0;
         }
-        if (cssFile) {
-          let relativePath = relative(dirname(cssFile), path);
-          if (relativePath === ".." || relativePath.startsWith(".." + sep) || isAbsolute(relativePath)) {
-            return void 0;
-          }
-        }
       }
       this.root = dirname(path);
       if (existsSync(path)) {
@@ -8330,6 +8360,7 @@ function requireList() {
       return list.split(string, spaces);
     },
     split(string, separators, last) {
+      if (!string) return [];
       let array = [];
       let current = "";
       let split = false;
@@ -9616,11 +9647,16 @@ var hasRequiredWarning;
 function requireWarning() {
   if (hasRequiredWarning) return warning;
   hasRequiredWarning = 1;
+  let Container = requireContainer();
+  let { my } = requireSymbols();
   class Warning {
     constructor(text, opts = {}) {
       this.type = "warning";
       this.text = text;
       if (opts.node && opts.node.source) {
+        if (!opts.node[my]) {
+          Container.rebuild(opts.node);
+        }
         let range = opts.node.rangeBy(opts);
         this.line = range.start.line;
         this.column = range.start.column;
@@ -10130,14 +10166,19 @@ function requireLazyResult() {
       }
       if (visit2.iterator !== 0) {
         let iterator = visit2.iterator;
+        if (visit2.descending) {
+          visit2.descending = false;
+          node2.indexes[iterator] += 1;
+        }
         let child;
         while (child = node2.nodes[node2.indexes[iterator]]) {
-          node2.indexes[iterator] += 1;
           if (!child[isClean]) {
             child[isClean] = true;
+            visit2.descending = true;
             stack.push(toStack(child));
             return;
           }
+          node2.indexes[iterator] += 1;
         }
         visit2.iterator = 0;
         delete node2.indexes[iterator];
@@ -10167,12 +10208,16 @@ function requireLazyResult() {
         let visitNode = visit2.node;
         if (visit2.iterator !== 0) {
           let iterator = visit2.iterator;
+          if (visit2.descending) {
+            visit2.descending = false;
+            visitNode.indexes[iterator] += 1;
+          }
           let child;
           let descended = false;
           while (child = visitNode.nodes[visitNode.indexes[iterator]]) {
-            visitNode.indexes[iterator] += 1;
             if (!child[isClean]) {
               child[isClean] = true;
+              visit2.descending = true;
               stack.push({
                 eventIndex: 0,
                 events: getEvents(child),
@@ -10182,6 +10227,7 @@ function requireLazyResult() {
               descended = true;
               break;
             }
+            visitNode.indexes[iterator] += 1;
           }
           if (descended) continue;
           visit2.iterator = 0;
@@ -10344,7 +10390,7 @@ function requireProcessor() {
   let Root = requireRoot();
   class Processor {
     constructor(plugins = []) {
-      this.version = "8.5.19";
+      this.version = "8.5.25";
       this.plugins = this.normalize(plugins);
     }
     normalize(plugins) {
@@ -19147,20 +19193,530 @@ class Replayer {
     this.config.logger.log(REPLAY_CONSOLE_PREFIX, ...args);
   }
 }
+const RRWEB_EMBEDDED_CHANNEL = "rrweb-embedded";
+const RRWEB_EMBEDDED_PROTOCOL_VERSION = 1;
+const SERIALIZABLE_CONFIG_KEYS = [
+  "speed",
+  "maxSpeed",
+  "loadTimeout",
+  "skipInactive",
+  "inactivePeriodThreshold",
+  "showWarning",
+  "showDebug",
+  "blockClass",
+  "liveMode",
+  "insertStyleRules",
+  "triggerFocus",
+  "UNSAFE_replayCanvas",
+  "cspContent",
+  "pauseAnimation",
+  "mouseTail",
+  "useVirtualDom",
+  "inactiveThreshold",
+  "inactiveSkipTime"
+];
+function pickSerializableConfig(config) {
+  const out = {};
+  if (config && typeof config === "object") {
+    for (const key of SERIALIZABLE_CONFIG_KEYS) {
+      const value = config[key];
+      if (value !== void 0 && typeof value !== "function") {
+        out[key] = value;
+      }
+    }
+  }
+  return out;
+}
+function wrap(message) {
+  return {
+    channel: RRWEB_EMBEDDED_CHANNEL,
+    version: RRWEB_EMBEDDED_PROTOCOL_VERSION,
+    message
+  };
+}
+function isEnvelope(data) {
+  if (!data || typeof data !== "object") return false;
+  const e2 = data;
+  return e2.channel === RRWEB_EMBEDDED_CHANNEL && e2.version === RRWEB_EMBEDDED_PROTOCOL_VERSION && !!e2.message && typeof e2.message === "object" && typeof e2.message.type === "string";
+}
+const PAYLOAD_EVENTS = /* @__PURE__ */ new Set([
+  ReplayerEvents.Resize,
+  ReplayerEvents.EventCast,
+  ReplayerEvents.CustomEvent
+]);
+class EmbeddedReplayerHost {
+  constructor(options = {}) {
+    __publicField(this, "root");
+    __publicField(this, "parentWindow");
+    __publicField(this, "timeUpdateIntervalMs");
+    __publicField(this, "expectedParentOrigin");
+    __publicField(this, "replayer", null);
+    __publicField(this, "playing", false);
+    __publicField(this, "timer", null);
+    __publicField(this, "started", false);
+    /**
+     * Last layout the parent asked for. Retained because each `Replayer` builds
+     * its own wrapper element, so a re-init would otherwise drop the scaling and
+     * render the replay at 1:1 in the corner.
+     */
+    __publicField(this, "layout", null);
+    __publicField(this, "onMessage", (event) => {
+      if (event.source !== this.parentWindow) return;
+      if (this.expectedParentOrigin === null) return;
+      if (event.origin !== this.expectedParentOrigin) return;
+      if (!isEnvelope(event.data)) return;
+      try {
+        this.handle(event.data.message);
+      } catch (err) {
+        this.post({
+          type: "error",
+          message: err instanceof Error ? err.message : String(err)
+        });
+      }
+    });
+    this.root = options.root ?? document.body;
+    this.parentWindow = options.parentWindow ?? window.parent;
+    this.timeUpdateIntervalMs = options.timeUpdateIntervalMs ?? 50;
+    this.expectedParentOrigin = options.expectedParentOrigin ?? new URLSearchParams(location.search).get("parentOrigin") ?? null;
+  }
+  /** Install the message listener and announce readiness to the parent. */
+  start() {
+    if (this.started) return;
+    this.started = true;
+    if (this.expectedParentOrigin === null) {
+      console.warn(
+        "[rrweb-embedded] no parentOrigin configured; all incoming messages will be ignored"
+      );
+    }
+    window.addEventListener("message", this.onMessage);
+    this.post({ type: "ready" });
+  }
+  /** Tear everything down (also invoked on a `destroy` command). */
+  stop() {
+    var _a2;
+    window.removeEventListener("message", this.onMessage);
+    this.setPlaying(false);
+    (_a2 = this.replayer) == null ? void 0 : _a2.destroy();
+    this.replayer = null;
+    this.started = false;
+  }
+  handle(command) {
+    var _a2, _b, _c, _d, _e, _f, _g;
+    switch (command.type) {
+      case "ping":
+        this.post({ type: "ready" });
+        return;
+      case "init":
+        this.init(command.events, command.config, command.autoplay);
+        return;
+      case "play":
+        (_a2 = this.replayer) == null ? void 0 : _a2.play(command.timeOffset ?? 0);
+        this.setPlaying(true);
+        return;
+      case "pause":
+        (_b = this.replayer) == null ? void 0 : _b.pause(command.timeOffset);
+        this.setPlaying(false);
+        this.postTime();
+        return;
+      case "resume":
+        (_c = this.replayer) == null ? void 0 : _c.resume(command.timeOffset ?? 0);
+        this.setPlaying(true);
+        return;
+      case "setLayout":
+        this.layout = {
+          scale: command.scale,
+          anchor: command.anchor ?? "center"
+        };
+        this.applyLayout();
+        this.postDimensions();
+        return;
+      case "setConfig":
+        (_d = this.replayer) == null ? void 0 : _d.setConfig(pickSerializableConfig(command.config));
+        return;
+      case "replaceEvents":
+        if (this.replayer) {
+          this.replayer.replaceEvents(command.events);
+          this.postInitialized();
+        }
+        return;
+      case "addEvent":
+        (_e = this.replayer) == null ? void 0 : _e.addEvent(command.event);
+        return;
+      case "enableInteract":
+        (_f = this.replayer) == null ? void 0 : _f.enableInteract();
+        return;
+      case "disableInteract":
+        (_g = this.replayer) == null ? void 0 : _g.disableInteract();
+        return;
+      case "destroy":
+        this.stop();
+        return;
+    }
+  }
+  init(events, config, autoplay) {
+    if (this.replayer) {
+      this.setPlaying(false);
+      this.replayer.destroy();
+    }
+    const replayerConfig = {
+      ...pickSerializableConfig(config),
+      root: this.root
+    };
+    this.replayer = new Replayer(events, replayerConfig);
+    this.wireEvents(this.replayer);
+    this.applyLayout();
+    this.postInitialized();
+    this.postDimensions();
+    if (autoplay) {
+      this.replayer.play(0);
+      this.setPlaying(true);
+    }
+  }
+  /**
+   * Translate the parent's layout intent into styles on the replay wrapper.
+   *
+   * Mirrors what an embedder would otherwise apply from its own stylesheet:
+   * `transform-origin: top left` with `left: 50%` to center horizontally, and
+   * either `top: 50%` + a -50% Y translate to center vertically, or `top: 0`
+   * with no Y translate to anchor at the top edge.
+   */
+  applyLayout() {
+    var _a2;
+    const wrapper = (_a2 = this.replayer) == null ? void 0 : _a2.wrapper;
+    if (!wrapper || !this.layout) return;
+    const { scale, anchor } = this.layout;
+    const top = anchor === "top";
+    wrapper.style.position = "absolute";
+    wrapper.style.transformOrigin = "top left";
+    wrapper.style.left = "50%";
+    wrapper.style.top = top ? "0" : "50%";
+    wrapper.style.transform = top ? `scale(${scale}) translate(-50%, 0)` : `scale(${scale}) translate(-50%, -50%)`;
+  }
+  /** Report the wrapper's rendered geometry; the parent cannot measure it. */
+  postDimensions() {
+    var _a2;
+    const wrapper = (_a2 = this.replayer) == null ? void 0 : _a2.wrapper;
+    if (!wrapper) return;
+    const rect = wrapper.getBoundingClientRect();
+    this.post({
+      type: "dimensions",
+      width: rect.width,
+      height: rect.height,
+      top: rect.top,
+      left: rect.left
+    });
+  }
+  /** Push the stable getters (metadata, activity intervals) to the parent. */
+  postInitialized() {
+    if (!this.replayer) return;
+    this.post({
+      type: "initialized",
+      metadata: this.replayer.getMetaData(),
+      activityIntervals: this.replayer.getActivityIntervals()
+    });
+  }
+  wireEvents(replayer) {
+    for (const name of Object.values(ReplayerEvents)) {
+      replayer.on(name, (payload) => {
+        if (name === ReplayerEvents.Finish) {
+          this.setPlaying(false);
+          this.postTime();
+        }
+        if (name === ReplayerEvents.Resize) {
+          this.postDimensions();
+        }
+        this.post(
+          PAYLOAD_EVENTS.has(name) && payload !== void 0 ? { type: "replayer-event", event: name, payload } : { type: "replayer-event", event: name }
+        );
+      });
+    }
+  }
+  /* --- current-time telemetry ------------------------------------------- */
+  setPlaying(playing) {
+    if (this.playing === playing) return;
+    this.playing = playing;
+    if (playing) this.startTimePump();
+    else this.stopTimePump();
+  }
+  startTimePump() {
+    if (this.timer !== null) return;
+    this.timer = setInterval(() => this.postTime(), this.timeUpdateIntervalMs);
+  }
+  /**
+   * Push the current playback position across the bridge.
+   *
+   * The parent cannot read the position synchronously — it lives in this realm
+   * behind an origin boundary — so the client's `getCurrentTime()` is only ever
+   * as fresh as the last push. While playing, the pump keeps it current. When
+   * playback stops the pump stops too, so the last pumped value would be up to
+   * one interval stale; callers that seek from it (`play(getCurrentTime())` to
+   * resume) would drift backwards. Pausing and finishing therefore push one
+   * final, settled value.
+   */
+  postTime() {
+    if (!this.replayer) return;
+    this.post({ type: "time", currentTime: this.replayer.getCurrentTime() });
+  }
+  stopTimePump() {
+    if (this.timer !== null) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  post(message) {
+    this.parentWindow.postMessage(
+      wrap(message),
+      this.expectedParentOrigin ?? "*"
+    );
+  }
+}
+function startEmbeddedReplayerHost(options) {
+  const host2 = new EmbeddedReplayerHost(options);
+  host2.start();
+  return host2;
+}
+class EmbeddedReplayerClient {
+  constructor(iframe, options = {}) {
+    __publicField(this, "iframe");
+    __publicField(this, "hostOrigin");
+    __publicField(this, "listeners", /* @__PURE__ */ new Map());
+    __publicField(this, "metadata", null);
+    __publicField(this, "activityIntervals", []);
+    __publicField(this, "dimensions", null);
+    __publicField(this, "lastCurrentTime", 0);
+    __publicField(this, "ready", false);
+    __publicField(this, "readyResolvers", []);
+    __publicField(this, "disposed", false);
+    /**
+     * Commands issued before the host handshakes. A command posted while the
+     * iframe is still on its initial `about:blank` (which carries the PARENT's
+     * origin) is rejected by the browser as an origin mismatch and lost — the
+     * viewer calls `setLayout` on mount, well before the host boots. Buffer until
+     * `ready`, then flush; by then the frame is on the host origin.
+     */
+    __publicField(this, "pending", []);
+    __publicField(this, "onMessage", (event) => {
+      if (event.source !== this.iframe.contentWindow) return;
+      if (!isEnvelope(event.data)) return;
+      this.handle(event.data.message);
+    });
+    this.iframe = iframe;
+    this.hostOrigin = options.hostOrigin ?? "*";
+    window.addEventListener("message", this.onMessage);
+    this.probe();
+  }
+  /** Resolves once the host iframe has loaded and announced readiness. */
+  whenReady() {
+    if (this.ready) return Promise.resolve();
+    return new Promise((resolve) => this.readyResolvers.push(resolve));
+  }
+  /* --- commands --------------------------------------------------------- */
+  init(events, config, autoplay = false) {
+    this.send({ type: "init", events, config, autoplay });
+  }
+  play(timeOffset) {
+    this.send({ type: "play", timeOffset });
+  }
+  pause(timeOffset) {
+    this.send({ type: "pause", timeOffset });
+  }
+  resume(timeOffset) {
+    this.send({ type: "resume", timeOffset });
+  }
+  setConfig(config) {
+    this.send({ type: "setConfig", config });
+  }
+  /**
+   * Scale and position the replay. Compute `scale` from your own container size
+   * and the recorded viewport, as you would when driving a local `Replayer`;
+   * the host applies it, since the wrapper element is not reachable from here.
+   * The layout is retained across re-inits.
+   */
+  setLayout(scale, anchor) {
+    this.send({ type: "setLayout", scale, anchor });
+  }
+  replaceEvents(events) {
+    this.send({ type: "replaceEvents", events });
+  }
+  addEvent(event) {
+    this.send({ type: "addEvent", event });
+  }
+  enableInteract() {
+    this.send({ type: "enableInteract" });
+  }
+  disableInteract() {
+    this.send({ type: "disableInteract" });
+  }
+  /** Tear down: destroys the host replayer and detaches the listener. */
+  destroy() {
+    if (this.disposed) return;
+    this.disposed = true;
+    try {
+      this.send({ type: "destroy" });
+    } finally {
+      window.removeEventListener("message", this.onMessage);
+      this.listeners.clear();
+    }
+  }
+  /* --- event surface ---------------------------------------------------- */
+  on(event, listener) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(listener);
+  }
+  off(event, listener) {
+    var _a2;
+    (_a2 = this.listeners.get(event)) == null ? void 0 : _a2.delete(listener);
+  }
+  /* --- getters ---------------------------------------------------------- */
+  // Cached getters mirroring the local Replayer's synchronous ones. Metadata
+  // and activity intervals arrive on `initialized` (re-sent on replaceEvents);
+  // current time is streamed by the host while playing.
+  /** Last-known current time (pushed by the host while playing). */
+  getCurrentTime() {
+    return this.lastCurrentTime;
+  }
+  getMetaData() {
+    return this.metadata;
+  }
+  getActivityIntervals() {
+    return this.activityIntervals;
+  }
+  /**
+   * Rendered geometry of the replay, in the host document's coordinate space —
+   * the cross-origin stand-in for `replayer.wrapper.getBoundingClientRect()`.
+   * Null until the host has reported it (listen for `'dimensions'`).
+   */
+  getDimensions() {
+    return this.dimensions;
+  }
+  /* --- internals -------------------------------------------------------- */
+  send(command) {
+    if (!this.ready) {
+      this.pending.push(command);
+      return;
+    }
+    this.postToHost(command);
+  }
+  postToHost(command) {
+    const target = this.iframe.contentWindow;
+    if (!target) return;
+    target.postMessage(wrap(command), this.hostOrigin);
+  }
+  flushPending() {
+    const queued = this.pending;
+    this.pending = [];
+    queued.forEach((command) => this.postToHost(command));
+  }
+  /** Data-free handshake probe; see the note in the constructor. */
+  probe() {
+    var _a2;
+    (_a2 = this.iframe.contentWindow) == null ? void 0 : _a2.postMessage(wrap({ type: "ping" }), "*");
+  }
+  handle(message) {
+    switch (message.type) {
+      case "ready":
+        this.ready = true;
+        this.flushPending();
+        this.readyResolvers.forEach((r2) => r2());
+        this.readyResolvers = [];
+        return;
+      case "initialized":
+        this.metadata = message.metadata;
+        this.activityIntervals = message.activityIntervals;
+        this.emit("initialized", message.metadata);
+        return;
+      case "replayer-event":
+        this.emit(message.event, message.payload);
+        return;
+      case "time":
+        this.lastCurrentTime = message.currentTime;
+        this.emit("time", message.currentTime);
+        return;
+      case "dimensions":
+        this.dimensions = {
+          width: message.width,
+          height: message.height,
+          top: message.top,
+          left: message.left
+        };
+        this.emit("dimensions", this.dimensions);
+        return;
+      case "error":
+        this.emit("error", message.message);
+        return;
+    }
+  }
+  emit(event, payload) {
+    var _a2;
+    (_a2 = this.listeners.get(event)) == null ? void 0 : _a2.forEach((listener) => listener(payload));
+  }
+}
+function originOf(url) {
+  try {
+    return new URL(url).origin;
+  } catch {
+    return "'self'";
+  }
+}
+function buildHostDocument(options) {
+  const scriptOrigin = originOf(options.scriptUrl);
+  const styleSources = [
+    "'unsafe-inline'",
+    scriptOrigin,
+    ...options.extraStyleSources ?? []
+  ].join(" ");
+  const csp = [
+    `default-src 'none'`,
+    `script-src ${scriptOrigin}`,
+    `style-src ${styleSources}`,
+    `img-src * data: blob:`,
+    `font-src * data:`,
+    `media-src * data: blob:`,
+    `frame-src *`,
+    `connect-src 'none'`,
+    `worker-src 'none'`
+  ].join("; ");
+  const styleTag = options.styleUrl ? `<link rel="stylesheet" href="${escapeAttr(options.styleUrl)}">` : "";
+  return `<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta http-equiv="Content-Security-Policy" content="${escapeAttr(csp)}">
+<style>html,body{margin:0;padding:0;height:100%;overflow:hidden;background:transparent}</style>
+${styleTag}
+<script type="module" src="${escapeAttr(options.scriptUrl)}"><\/script>
+</head>
+<body></body>
+</html>`;
+}
+function escapeAttr(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
 const { addCustomEvent } = record;
 const { freezePage } = record;
 const { takeFullSnapshot } = record;
 export {
+  EmbeddedReplayerClient,
+  EmbeddedReplayerHost,
   EventType,
   IncrementalSource,
   MouseInteractions,
+  RRWEB_EMBEDDED_CHANNEL,
+  RRWEB_EMBEDDED_PROTOCOL_VERSION,
   Replayer,
   ReplayerEvents,
   addCustomEvent,
+  buildHostDocument,
   canvasMutation,
   freezePage,
   _mirror as mirror,
+  pickSerializableConfig,
   record,
+  startEmbeddedReplayerHost,
   takeFullSnapshot,
   utils
 };