@percy/core 1.31.14-beta.1 → 1.31.14-beta.3

package/dist/archive.js

@@ -0,0 +1,117 @@
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+const ARCHIVE_VERSION = 1;
+const MAX_FILENAME_LENGTH = 200;
+const UNSAFE_CHARS = /[/\\:*?"<>|]/g;
+
+// Validates the archive dir to prevent path traversal attacks.
+// Returns the resolved absolute path.
+export function validateArchiveDir(archiveDir) {
+  let resolved = path.resolve(archiveDir);
+  let normalized = path.normalize(resolved);
+
+  // Reject if the normalized path still contains '..' segments
+  if (normalized.split(path.sep).includes('..')) {
+    throw new Error(`Invalid archive dir: path traversal detected in "${archiveDir}"`);
+  }
+  return resolved;
+}
+
+// Sanitizes a snapshot name into a safe filename.
+// Strips unsafe characters and appends a hash to prevent collisions.
+export function sanitizeFilename(name) {
+  let safe = name.replace(UNSAFE_CHARS, '_');
+  if (safe.length > MAX_FILENAME_LENGTH) {
+    safe = safe.substring(0, MAX_FILENAME_LENGTH);
+  }
+
+  // Append a short hash of the original name for collision prevention
+  let hash = crypto.createHash('sha256').update(name).digest('hex').substring(0, 8);
+  return `${safe}-${hash}`;
+}
+
+// Serializes a snapshot into a JSON-safe object for archiving.
+// Resources have their binary content base64-encoded.
+export function serializeSnapshot(snapshot) {
+  let {
+    resources,
+    ...snapshotData
+  } = snapshot;
+  return {
+    version: ARCHIVE_VERSION,
+    snapshot: snapshotData,
+    resources: (resources || []).map(r => ({
+      ...r,
+      content: r.content ? Buffer.from(r.content).toString('base64') : null
+    }))
+  };
+}
+
+// Validates and deserializes an archived snapshot from parsed JSON.
+// Decodes base64 resource content back to Buffers.
+export function deserializeSnapshot(data) {
+  if (!data || typeof data !== 'object') {
+    throw new Error('Invalid archive: expected an object');
+  }
+  if (data.version !== ARCHIVE_VERSION) {
+    throw new Error(`Unsupported archive version: ${data.version} (expected ${ARCHIVE_VERSION})`);
+  }
+  if (!data.snapshot || typeof data.snapshot.name !== 'string' || !data.snapshot.name) {
+    throw new Error('Invalid archive: missing snapshot name');
+  }
+  if (!Array.isArray(data.resources) || data.resources.length === 0) {
+    throw new Error('Invalid archive: missing or empty resources');
+  }
+  return {
+    ...data.snapshot,
+    resources: data.resources.map(r => ({
+      ...r,
+      content: r.content ? Buffer.from(r.content, 'base64') : null
+    }))
+  };
+}
+
+// Archives a single snapshot to the archive directory.
+// Creates the directory if it doesn't exist.
+export function archiveSnapshot(archiveDir, snapshot) {
+  fs.mkdirSync(archiveDir, {
+    recursive: true
+  });
+  let filename = sanitizeFilename(snapshot.name);
+  let filepath = path.join(archiveDir, `${filename}.json`);
+  let serialized = serializeSnapshot(snapshot);
+  fs.writeFileSync(filepath, JSON.stringify(serialized));
+}
+
+// Reads all archived snapshots from the given directory.
+// Skips symlinks and invalid files with warnings.
+export function readArchivedSnapshots(archiveDir, log) {
+  let resolved = validateArchiveDir(archiveDir);
+  if (!fs.existsSync(resolved) || !fs.lstatSync(resolved).isDirectory()) {
+    throw new Error(`Archive directory not found: ${archiveDir}`);
+  }
+  let entries = fs.readdirSync(resolved);
+  let snapshots = [];
+  for (let entry of entries) {
+    if (!entry.endsWith('.json')) continue;
+    let filepath = path.join(resolved, entry);
+    let stat = fs.lstatSync(filepath);
+
+    // Skip symlinks for security
+    if (stat.isSymbolicLink()) {
+      log === null || log === void 0 || log.warn(`Skipping symlink: ${entry}`);
+      continue;
+    }
+    if (!stat.isFile()) continue;
+    try {
+      let raw = fs.readFileSync(filepath, 'utf-8');
+      let data = JSON.parse(raw);
+      let snapshot = deserializeSnapshot(data);
+      snapshots.push(snapshot);
+    } catch (error) {
+      log === null || log === void 0 || log.warn(`Skipping invalid archive file "${entry}": ${error.message}`);
+    }
+  }
+  return snapshots;
+}

package/dist/closed-shadow.js

@@ -0,0 +1,194 @@
+// Closed-shadow capture helper. CLI-side only.
+//
+// External Percy SDK plugins (puppeteer-percy, playwright-percy,
+// cypress-percy, selenium-chrome-percy) will get their own copy when
+// SDK-side closed-shadow capture is added — that work is intentionally
+// scoped to a separate change so this PR stays focused on the CLI path.
+//
+// Discovers closed shadow roots in the live page and exposes them to
+// PercyDOM.serialize() via per-document `__percyClosedShadowRoots`
+// WeakMaps that clone-dom.js reads through shadow-utils.getRuntime().
+//
+// Closed shadow roots are inaccessible from JavaScript
+// (`element.shadowRoot === null`), but Chrome DevTools Protocol's DOM domain
+// can pierce them. We get the full DOM tree with `pierce: true` (which also
+// traverses iframe boundaries — closed shadow hosts inside iframes are
+// captured by the same walk), collect every closed-shadow host/root pair,
+// resolve both to JS object references via `DOM.resolveNode`, then call
+// `Runtime.callFunctionOn` to write the mapping. The function body installs
+// the WeakMap on the host's *own* `ownerDocument.defaultView` — so a host
+// inside an iframe writes into the iframe's realm, where shadow-utils will
+// later read it.
+//
+// Works for any caller that has a CDP session-like object exposing
+// `send(method, params) => Promise`:
+//   - Puppeteer:    `await page.target().createCDPSession()`
+//   - Playwright:   `await context.newCDPSession(page)`
+//   - Selenium:     `await driver.getDevTools()` (Chromium only)
+//   - Percy CLI:    Percy's own session.send wrapper
+//
+// Side effect: temporarily enables and then disables the CDP `DOM` domain
+// on the supplied session. Don't run concurrently with another `DOM`-domain
+// consumer on the same session — the helper installs an in-flight guard
+// against itself, but can't see other consumers.
+//
+// Limitation: captures the closed shadow roots present at the time of the
+// call. Custom elements that lazy-attach a closed shadow root after this
+// returns (e.g. inside `requestIdleCallback` or `IntersectionObserver`)
+// won't be captured. The caller is responsible for waiting until the page
+// is settled before invoking.
+//
+// Returns the number of closed shadow roots successfully exposed (0 if none,
+// -1 on top-level error). Per-pair errors are swallowed and surfaced via the
+// optional `log` callback — closed-shadow capture is best-effort and must
+// never break a snapshot run.
+
+const DEFAULT_LOG = () => {};
+
+// Mirrors HARD_MAX_IFRAME_DEPTH from serialize-frames so every recursive
+// walk in the capture pipeline shares the same ceiling. Counted only across
+// shadow / iframe boundary crossings — not plain children — otherwise a
+// normal deep DOM (html → body → div → … → custom-element) would burn
+// through the budget before reaching any shadow host.
+const MAX_SHADOW_DEPTH = 10;
+
+// Bound concurrent CDP messages so we don't flood a session with hundreds
+// of in-flight resolveNode/callFunctionOn calls when a page has many
+// closed shadow hosts. Phase 1 (resolve) issues 2 calls per pair, so peak
+// in-flight there is 2 * CDP_BATCH_SIZE; phase 2 (stamp) is 1 per pair so
+// peak is exactly CDP_BATCH_SIZE. 8 chosen as a conservative default that
+// keeps both phases well under typical CDP message-queue depths.
+const CDP_BATCH_SIZE = 8;
+
+// The function body that installs the WeakMap and writes the host→shadow
+// pair. Runs inside Runtime.callFunctionOn with the host as `this`, so
+// `this.ownerDocument.defaultView` is the host's *own* realm — the iframe's
+// window when the host is inside an iframe.
+//
+// IMPORTANT: this is a string (required by Runtime.callFunctionOn) AND it
+// is intentionally ES5 — it executes in the page's realm, which may be any
+// browser/JS target the page itself targets. Don't "modernize" with arrow
+// functions, let/const, or optional chaining.
+const STAMP_FUNCTION = 'function(shadowRoot) {' + '  var w = this.ownerDocument && this.ownerDocument.defaultView;' + '  if (!w) return;' + '  if (!w.__percyClosedShadowRoots) w.__percyClosedShadowRoots = new WeakMap();' + '  w.__percyClosedShadowRoots.set(this, shadowRoot);' + '}';
+
+// Marker for the in-flight guard — prevents concurrent invocations on the
+// same session from racing each other's DOM.enable / DOM.disable lifecycle.
+// Module-local Symbol (not Symbol.for) so it can't collide with any other
+// global registry entry.
+const IN_FLIGHT = Symbol('percy.closedShadow.inFlight');
+export async function exposeClosedShadowRoots(cdp, log = DEFAULT_LOG) {
+  if (!cdp || typeof cdp.send !== 'function') return -1;
+  if (cdp[IN_FLIGHT]) {
+    log('Skipping concurrent closed-shadow CDP discovery on the same session');
+    return -1;
+  }
+  cdp[IN_FLIGHT] = true;
+  let domEnabled = false;
+  try {
+    await cdp.send('DOM.enable');
+    domEnabled = true;
+    const {
+      root
+    } = await cdp.send('DOM.getDocument', {
+      depth: -1,
+      pierce: true
+    });
+    const closedPairs = [];
+    walkCDPNodes(root, closedPairs);
+    if (closedPairs.length === 0) {
+      return 0;
+    }
+    log(`Found ${closedPairs.length} closed shadow root(s), exposing via CDP`);
+
+    // Phase 1: resolve every backendNodeId → objectId in parallel batches.
+    const resolved = [];
+    for (let i = 0; i < closedPairs.length; i += CDP_BATCH_SIZE) {
+      const slice = closedPairs.slice(i, i + CDP_BATCH_SIZE);
+      const out = await Promise.all(slice.map(async pair => {
+        try {
+          const [hostRes, shadowRes] = await Promise.all([cdp.send('DOM.resolveNode', {
+            backendNodeId: pair.hostBackendNodeId
+          }), cdp.send('DOM.resolveNode', {
+            backendNodeId: pair.shadowBackendNodeId
+          })]);
+          return {
+            hostObj: hostRes.object,
+            shadowObj: shadowRes.object,
+            pair
+          };
+        } catch (err) {
+          const msg = err && err.message ? err.message : err;
+          log(`Skipping a closed shadow pair: ${msg} (host=${pair.hostBackendNodeId}, shadow=${pair.shadowBackendNodeId})`);
+          return null;
+        }
+      }));
+      for (const entry of out) if (entry) resolved.push(entry);
+    }
+
+    // Phase 2: stamp the WeakMap (per-realm), also batched. Track real
+    // successes — earlier shapes returned closedPairs.length and overstated
+    // success when stamps failed.
+    let stamped = 0;
+    for (let i = 0; i < resolved.length; i += CDP_BATCH_SIZE) {
+      const slice = resolved.slice(i, i + CDP_BATCH_SIZE);
+      const results = await Promise.all(slice.map(({
+        hostObj,
+        shadowObj,
+        pair
+      }) => cdp.send('Runtime.callFunctionOn', {
+        functionDeclaration: STAMP_FUNCTION,
+        objectId: hostObj.objectId,
+        arguments: [{
+          objectId: shadowObj.objectId
+        }]
+      }).then(() => true).catch(err => {
+        const msg = err && err.message ? err.message : err;
+        log(`Skipping a closed shadow pair: ${msg} (host=${pair.hostBackendNodeId}, shadow=${pair.shadowBackendNodeId})`);
+        return false;
+      })));
+      for (const ok of results) if (ok) stamped++;
+    }
+    return stamped;
+  } catch (err) {
+    log(`Could not expose closed shadow roots via CDP: ${err && err.message ? err.message : err}`);
+    return -1;
+  } finally {
+    if (domEnabled) {
+      await cdp.send('DOM.disable').catch(disableErr => {
+        log(`DOM.disable failed during closed-shadow cleanup: ${disableErr && disableErr.message ? disableErr.message : disableErr}`);
+      });
+    }
+    delete cdp[IN_FLIGHT];
+  }
+}
+
+// Walk a DOM.getDocument tree (with pierce: true) collecting every
+// closed-shadow host/root pair we encounter. `pierce: true` traverses both
+// shadow boundaries and iframe `contentDocument` boundaries, so a single
+// walk reaches closed shadow hosts inside nested iframes. Recursion is
+// bounded at MAX_SHADOW_DEPTH levels — counted only across shadow/iframe
+// boundary crossings, not plain children — so a deep ordinary DOM doesn't
+// exhaust the budget before reaching its shadow hosts. Exported for tests.
+export function walkCDPNodes(node, pairs, depth = 0) {
+  if (!node || depth >= MAX_SHADOW_DEPTH) return;
+  if (node.shadowRoots) {
+    for (const sr of node.shadowRoots) {
+      if (sr.shadowRootType === 'closed') {
+        pairs.push({
+          hostBackendNodeId: node.backendNodeId,
+          shadowBackendNodeId: sr.backendNodeId
+        });
+      }
+      // crossing a shadow boundary — increment depth
+      walkCDPNodes(sr, pairs, depth + 1);
+    }
+  }
+  if (node.children) {
+    // plain children — same realm, same depth
+    for (const child of node.children) walkCDPNodes(child, pairs, depth);
+  }
+  // pierce: true surfaces iframe content documents on the iframe node;
+  // crossing into the iframe's realm — increment depth.
+  if (node.contentDocument) walkCDPNodes(node.contentDocument, pairs, depth + 1);
+}
+export default exposeClosedShadowRoots;

package/dist/config.js

@@ -7,6 +7,9 @@ export const configSchema = {
       deferUploads: {
         type: 'boolean'
       },
+      archiveDir: {
+        type: 'string'
+      },
       useSystemProxy: {
         type: 'boolean',
         default: false
@@ -329,6 +332,14 @@ export const configSchema = {
         type: 'boolean',
         default: false
       },
+      ignoreIframeSelectors: {
+        type: 'array',
+        default: [],
+        items: {
+          type: 'string',
+          minLength: 1
+        }
+      },
       pseudoClassEnabledElements: {
         type: 'object',
         additionalProperties: false,
@@ -637,6 +648,9 @@ export const snapshotSchema = {
         ignoreStyleSheetSerializationErrors: {
           $ref: '/config/snapshot#/properties/ignoreStyleSheetSerializationErrors'
         },
+        ignoreIframeSelectors: {
+          $ref: '/config/snapshot#/properties/ignoreIframeSelectors'
+        },
         pseudoClassEnabledElements: {
           $ref: '/config/snapshot#/properties/pseudoClassEnabledElements'
         },

package/dist/page.js

@@ -1,8 +1,55 @@
 import fs from 'fs';
 import logger from '@percy/logger';
 import Network from './network.js';
+import { exposeClosedShadowRoots } from './closed-shadow.js';
 import { PERCY_DOM } from './api.js';
 import { hostname, waitFor, waitForTimeout as sleep, serializeFunction } from './utils.js';
+
+// Internal ceiling on the customElements wait. Set tight (500ms) so a
+// page with a never-registering custom element — third-party widget whose
+// loader is blocked, typo'd tag name, etc. — doesn't add a full 1500ms to
+// every snapshot. Real cascades of legitimate lazy-defined elements
+// complete well within this budget; the loop also exits early as soon as
+// `:not(:defined)` clears.
+export const DEFAULT_WAIT_FOR_CUSTOM_ELEMENTS_TIMEOUT = 500;
+
+// Body of the customElements wait. Runs in the browser via
+// Runtime.callFunctionOn. Re-polls each tick so lazy-defined element
+// cascades are awaited up to the deadline.
+//
+// IMPORTANT: this body is intentionally ES5 — it is evaluated in the
+// page's realm and must work in any browser the page targets. Don't
+// "modernize" with arrow functions, let/const, or optional chaining.
+export const WAIT_FOR_CUSTOM_ELEMENTS_BODY = `
+  var deadline = Date.now() + (arguments[0] || 500);
+  return new Promise(function(resolve) {
+    function tick() {
+      var undef = document.querySelectorAll(":not(:defined)");
+      if (!undef.length) return resolve();
+      if (Date.now() >= deadline) return resolve();
+      var names = {};
+      for (var i = 0; i < undef.length; i++) names[undef[i].localName] = true;
+      var promises = Object.keys(names).map(function(n) {
+        return window.customElements.whenDefined(n).catch(function(){});
+      });
+      Promise.race([
+        Promise.all(promises),
+        new Promise(function(r) { setTimeout(r, 100); })
+      ]).then(tick);
+    }
+    tick();
+  });
+`;
+
+/* istanbul ignore next: runs in the page realm via Runtime.callFunctionOn,
+   not in the test process — there is no way to instrument it from here */
+function serializeDomCapture(_, options) {
+  /* eslint-disable-next-line no-undef */
+  return {
+    domSnapshot: PercyDOM.serialize(options),
+    url: document.URL
+  };
+}
 export class Page {
   static TIMEOUT = undefined;
   log = logger('core:page');
@@ -195,6 +242,7 @@ export class Page {
       reshuffleInvalidTags,
       ignoreCanvasSerializationErrors,
       ignoreStyleSheetSerializationErrors,
+      ignoreIframeSelectors,
       pseudoClassEnabledElements
     } = snapshot;
     this.log.debug(`Taking snapshot: ${name}${width ? ` @${width}px` : ''}`, this.meta);
@@ -219,17 +267,33 @@ export class Page {
 
     // wait for any final network activity before capturing the dom snapshot
     await this.network.idle();
+
+    // Pre-snapshot best-effort steps: waiting for lazy custom elements and
+    // discovering closed shadow roots via CDP. Both target a fully-loaded
+    // page; if the session has already terminated, skip them so the proper
+    // crash/close error surfaces from the downstream insertPercyDom +
+    // serialize evals (which gate on the same session).
+    //
+    // Ordering is load-bearing: closed-shadow capture must run AFTER the
+    // customElements wait so we catch shadows attached inside upgrade /
+    // connectedCallback hooks. Don't reorder or parallelise these.
+    if (!this.session.closedReason) {
+      // Best-effort: a flaky page should not break the snapshot.
+      try {
+        await this.eval(WAIT_FOR_CUSTOM_ELEMENTS_BODY, DEFAULT_WAIT_FOR_CUSTOM_ELEMENTS_TIMEOUT);
+      } catch (err) {
+        /* istanbul ignore next: best-effort log; defensive against non-Error throws */
+        this.log.debug(`Custom elements wait failed: ${err.message ?? err}`, this.meta);
+      }
+      if (!disableShadowDOM) {
+        await exposeClosedShadowRoots(this.session, this._logShadowDebug.bind(this));
+      }
+    }
     await this.insertPercyDom();
 
     // serialize and capture a DOM snapshot
     this.log.debug('Serialize DOM', this.meta);
-
-    /* istanbul ignore next: no instrumenting injected code */
-    let capture = await this.eval((_, options) => ({
-      /* eslint-disable-next-line no-undef */
-      domSnapshot: PercyDOM.serialize(options),
-      url: document.URL
-    }), {
+    let capture = await this.eval(serializeDomCapture, {
       enableJavaScript,
       disableShadowDOM,
       forceShadowAsLightDOM,
@@ -237,6 +301,7 @@ export class Page {
       reshuffleInvalidTags,
       ignoreCanvasSerializationErrors,
       ignoreStyleSheetSerializationErrors,
+      ignoreIframeSelectors,
       pseudoClassEnabledElements
     });
     return {
@@ -245,6 +310,15 @@ export class Page {
     };
   }
 
+  // Logger for the closed-shadow CDP helper. Defined on the prototype (not
+  // a class-field arrow) so it's reachable from a unit test that constructs
+  // a Page via Object.create without invoking the constructor — gives us a
+  // direct way to cover the callback without simulating a closed shadow
+  // discovery flow at the integration level.
+  _logShadowDebug(msg) {
+    this.log.debug(msg, this.meta);
+  }
+
   // Initialize newly attached pages and iframes with page options
   _handleAttachedToTarget = event => {
     let session = !event ? this.session : this.session.children.get(event.sessionId);

package/dist/percy.js

@@ -43,6 +43,8 @@ export class Percy {
   constructor({
     // initial log level
     loglevel,
+    // path to save snapshot data to disk
+    archiveDir,
     // process uploads before the next snapshot
     delayUploads,
     // process uploads after all snapshots
@@ -83,6 +85,7 @@ export class Percy {
     });
     labels ?? (labels = (_config$percy = config.percy) === null || _config$percy === void 0 ? void 0 : _config$percy.labels);
     deferUploads ?? (deferUploads = (_config$percy2 = config.percy) === null || _config$percy2 === void 0 ? void 0 : _config$percy2.deferUploads);
+    if (archiveDir) skipUploads = skipUploads != null ? skipUploads : true;
     this.config = config;
     this.cliStartTime = null;
     if (testing) loglevel = 'silent';
@@ -95,6 +98,7 @@ export class Percy {
     this.skipDiscovery = this.dryRun || !!skipDiscovery;
     this.delayUploads = this.skipUploads || !!delayUploads;
     this.deferUploads = this.skipUploads || !!deferUploads;
+    this.archiveDir = this.skipUploads && archiveDir ? archiveDir : null;
     this.labels = labels;
     this.suggestionsCallCounter = suggestionsCallCounter;
     this.client = new PercyClient({
@@ -132,7 +136,7 @@ export class Percy {
     };
 
     // generator methods are wrapped to autorun and return promises
-    for (let m of ['start', 'stop', 'flush', 'idle', 'snapshot', 'upload']) {
+    for (let m of ['start', 'stop', 'flush', 'idle', 'snapshot', 'upload', 'replaySnapshot']) {
       // the original generator can be referenced with percy.yield.<method>
       let method = (this.yield || (this.yield = {}))[m] = this[m].bind(this);
       this[m] = (...args) => generatePromise(method(...args));
@@ -259,6 +263,15 @@ export class Percy {
         await this.loadAutoConfiguredHostnames();
       }
 
+      // validate and log archive dir if configured
+      if (this.archiveDir) {
+        let {
+          validateArchiveDir
+        } = await import('./archive.js');
+        this.archiveDir = validateArchiveDir(this.archiveDir);
+        this.log.info(`Archiving snapshots to: ${this.archiveDir}`);
+      }
+
       // start the snapshots queue immediately when not delayed or deferred
       if (!this.delayUploads && !this.deferUploads) yield _classPrivateFieldGet(_snapshots, this).start();
       // do not start the discovery queue when not needed
@@ -400,6 +413,11 @@ export class Percy {
         this.log.info(info('Found', _classPrivateFieldGet(_snapshots, this).size));
       }
 
+      // log archive summary
+      if (this.archiveDir && _classPrivateFieldGet(_snapshots, this).size) {
+        this.log.info(`Archived ${_classPrivateFieldGet(_snapshots, this).size} snapshot(s) to: ${this.archiveDir}`);
+      }
+
       // Save domain validation config before closing
       if (!this.skipUploads && !this.skipDiscovery) {
         await this.saveHostnamesToAutoConfigure();
@@ -611,6 +629,17 @@ export class Percy {
             config: this.config
           })
         }, snapshot => {
+          // archive snapshot to disk if configured
+          if (this.archiveDir) {
+            import('./archive.js').then(({
+              archiveSnapshot
+            }) => {
+              archiveSnapshot(this.archiveDir, snapshot);
+            }).catch(err => {
+              this.log.error(`Failed to archive snapshot "${snapshot.name}": ${err.message}`);
+            });
+          }
+
           // attaching promise resolve reject so to wait for snapshot to complete
           if (this.syncMode(snapshot)) {
             snapshotPromise[snapshot.name] = new Promise((resolve, reject) => {
@@ -700,6 +729,25 @@ export class Percy {
       }
     }.call(this);
   }
+
+  // Pushes a pre-built snapshot directly to the upload queue without discovery.
+  // Used by the replay command to upload previously archived snapshots.
+  *replaySnapshot(snapshot) {
+    var _this$build4;
+    if (this.readyState !== 1) {
+      throw new Error('Not running');
+    } else if ((_this$build4 = this.build) !== null && _this$build4 !== void 0 && _this$build4.error) {
+      throw new Error(this.build.error);
+    }
+    snapshot.meta = {
+      snapshot: {
+        name: snapshot.name,
+        testCase: snapshot.testCase
+      }
+    };
+    this.log.info(`Replaying snapshot: ${snapshot.name}`, snapshot.meta);
+    _classPrivateFieldGet(_snapshots, this).push(snapshot);
+  }
   shouldSkipAssetDiscovery(tokenType) {
     if (this.testing && JSON.stringify(this.testing) === JSON.stringify({})) {
       return true;
@@ -780,7 +828,7 @@ export class Percy {
   async sendBuildLogs() {
     if (!process.env.PERCY_TOKEN) return;
     try {
-      var _this$build4, _this$build5, _this$build6, _this$build7;
+      var _this$build5, _this$build6, _this$build7, _this$build8;
       const logsObject = {
         clilogs: logger.query(log => !['ci'].includes(log.debug))
       };
@@ -792,10 +840,10 @@ export class Percy {
         logsObject.cilogs = redactedContent;
       }
       const content = base64encode(Pako.gzip(JSON.stringify(logsObject)));
-      const referenceId = (_this$build4 = this.build) !== null && _this$build4 !== void 0 && _this$build4.id ? `build_${(_this$build5 = this.build) === null || _this$build5 === void 0 ? void 0 : _this$build5.id}` : (_this$build6 = this.build) === null || _this$build6 === void 0 ? void 0 : _this$build6.id;
+      const referenceId = (_this$build5 = this.build) !== null && _this$build5 !== void 0 && _this$build5.id ? `build_${(_this$build6 = this.build) === null || _this$build6 === void 0 ? void 0 : _this$build6.id}` : (_this$build7 = this.build) === null || _this$build7 === void 0 ? void 0 : _this$build7.id;
       const eventObject = {
         content: content,
-        build_id: (_this$build7 = this.build) === null || _this$build7 === void 0 ? void 0 : _this$build7.id,
+        build_id: (_this$build8 = this.build) === null || _this$build8 === void 0 ? void 0 : _this$build8.id,
         reference_id: referenceId,
         service_name: 'cli',
         base64encoded: true
@@ -868,9 +916,9 @@ export class Percy {
     const newAllowedDomains = Array.from(processedHosts).filter(domain => !autoConfiguredHosts.has(domain));
     const hasNewDomains = newAllowedDomains.length > 0 || newErrorHosts.size > 0;
     try {
-      var _this$build8;
+      var _this$build9;
       await this.client.updateProjectDomainConfig({
-        buildId: (_this$build8 = this.build) === null || _this$build8 === void 0 ? void 0 : _this$build8.id,
+        buildId: (_this$build9 = this.build) === null || _this$build9 === void 0 ? void 0 : _this$build9.id,
         allowedDomains: Array.from(processedHosts),
         errorDomains: Array.from(newErrorHosts)
       });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@percy/core",
-  "version": "1.31.14-beta.1",
+  "version": "1.31.14-beta.3",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -30,6 +30,7 @@
     },
     "./utils": "./dist/utils.js",
     "./config": "./dist/config.js",
+    "./archive": "./dist/archive.js",
     "./install": "./dist/install.js",
     "./test/helpers": "./test/helpers/index.js",
     "./test/helpers/server": "./test/helpers/server.js"
@@ -43,12 +44,12 @@
     "test:types": "tsd"
   },
   "dependencies": {
-    "@percy/client": "1.31.14-beta.1",
-    "@percy/config": "1.31.14-beta.1",
-    "@percy/dom": "1.31.14-beta.1",
-    "@percy/logger": "1.31.14-beta.1",
-    "@percy/monitoring": "1.31.14-beta.1",
-    "@percy/webdriver-utils": "1.31.14-beta.1",
+    "@percy/client": "1.31.14-beta.3",
+    "@percy/config": "1.31.14-beta.3",
+    "@percy/dom": "1.31.14-beta.3",
+    "@percy/logger": "1.31.14-beta.3",
+    "@percy/monitoring": "1.31.14-beta.3",
+    "@percy/webdriver-utils": "1.31.14-beta.3",
     "content-disposition": "^0.5.4",
     "cross-spawn": "^7.0.3",
     "extract-zip": "^2.0.1",
@@ -62,7 +63,7 @@
     "yaml": "^2.4.1"
   },
   "optionalDependencies": {
-    "@percy/cli-doctor": "1.31.14-beta.1"
+    "@percy/cli-doctor": "1.31.14-beta.3"
   },
-  "gitHead": "dd6957822cc94d460fd9c043a44cc4c9c5fcba23"
+  "gitHead": "a17d4a1453c6bef282fd3da38082b670e125a5be"
 }