@atlaskit/editor-plugin-interactivity 0.1.0 → 0.3.0

package/dist/es2019/collector/interaction-group.js

@@ -0,0 +1,125 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { bucketKeyForMs } from './bucket-boundaries';
+
+/**
+ * Latencies are counted per 8 ms, the resolution Event Timing reports durations at. Every
+ * latency is rounded up to this step on the way in, which caps the number of distinct values
+ * a group can hold whatever the latency was derived from.
+ */
+const RESOLUTION_MS = 8;
+
+/** Which percentiles are reported, as quantiles. */
+const REPORTED_QUANTILES = [0.9, 0.98];
+
+/**
+ * The latencies of one set of interactions — every interaction on the page, or only the ones
+ * inside the editor — reported as one object in the event.
+ *
+ * The whole state is a count per distinct latency, so an interaction only costs a counter
+ * whatever its latency was, and everything the event carries — the reported buckets, the
+ * count, the sum, the maximum and the percentiles — is derived from that map when a snapshot
+ * is taken. Nothing is computed while interactions arrive.
+ *
+ * The two counters count different populations: `add` takes the interactions Event Timing
+ * measured, `countTotal` takes all of them, including the ones below the 16 ms reporting threshold
+ * it never delivers. So `totalCount >= observedCount`, and the difference is how many were too
+ * fast to be measured.
+ */
+export class InteractionGroup {
+  constructor() {
+    _defineProperty(this, "countByLatency", new Map());
+    _defineProperty(this, "totalCount", 0);
+  }
+  add(latencyMs) {
+    this.increment(latencyMs);
+  }
+
+  /**
+   * Counts an interaction towards the group's total, measured or not. `page` has no use for it:
+   * `performance.interactionCount` counts the page's interactions.
+   */
+  countTotal() {
+    this.totalCount += 1;
+  }
+  remeasure(previousLatencyMs, latencyMs) {
+    // Moved rather than counted again: the count belongs to the same interaction.
+    this.decrement(previousLatencyMs);
+    this.increment(latencyMs);
+  }
+
+  /**
+   * @param totalCount every interaction of the group, including those below the Event Timing
+   * reporting threshold. Defaults to what `countTotal` was told, which is where an editor
+   * group's total comes from; `page` passes `performance.interactionCount` instead.
+   */
+  snapshot(totalCount = this.totalCount) {
+    var _latencies;
+    // Ascending, so the reported buckets come out in order and the last latency is the
+    // maximum. Sorted once for everything below.
+    const latencies = Array.from(this.countByLatency.keys()).sort((a, b) => a - b);
+    const observedCount = this.observedCount();
+    const percentileRanks = REPORTED_QUANTILES.map(quantile => ({
+      key: String(Math.round(quantile * 100)),
+      rank: Math.max(1, Math.ceil(quantile * observedCount))
+    }));
+    const buckets = {};
+    const percentilesMs = {};
+    let sumMs = 0;
+    let counted = 0;
+    for (const latencyMs of latencies) {
+      var _this$countByLatency$, _buckets$bucket;
+      const count = (_this$countByLatency$ = this.countByLatency.get(latencyMs)) !== null && _this$countByLatency$ !== void 0 ? _this$countByLatency$ : 0;
+      sumMs += latencyMs * count;
+      const bucket = String(bucketKeyForMs(latencyMs));
+      buckets[bucket] = ((_buckets$bucket = buckets[bucket]) !== null && _buckets$bucket !== void 0 ? _buckets$bucket : 0) + count;
+
+      // A percentile is the latency the group's interactions reach counting up from the
+      // fastest, so it is answered as soon as this many of them have been passed.
+      counted += count;
+      for (const {
+        key,
+        rank
+      } of percentileRanks) {
+        if (percentilesMs[key] === undefined && counted >= rank) {
+          percentilesMs[key] = latencyMs;
+        }
+      }
+    }
+    return {
+      // `performance.interactionCount` can lag the entries the observer has delivered.
+      totalCount: Math.max(totalCount, observedCount),
+      observedCount,
+      sumMs,
+      maxMs: (_latencies = latencies[latencies.length - 1]) !== null && _latencies !== void 0 ? _latencies : 0,
+      buckets,
+      percentilesMs
+    };
+  }
+  observedCount() {
+    let total = 0;
+    for (const count of this.countByLatency.values()) {
+      total += count;
+    }
+    return total;
+  }
+
+  /** Rounding lives here so that every count goes through the same step, in or out. */
+  roundLatencyUp(latencyMs) {
+    return Math.ceil(latencyMs / RESOLUTION_MS) * RESOLUTION_MS;
+  }
+  increment(latencyMs) {
+    var _this$countByLatency$2;
+    const step = this.roundLatencyUp(latencyMs);
+    this.countByLatency.set(step, ((_this$countByLatency$2 = this.countByLatency.get(step)) !== null && _this$countByLatency$2 !== void 0 ? _this$countByLatency$2 : 0) + 1);
+  }
+  decrement(latencyMs) {
+    var _this$countByLatency$3;
+    const step = this.roundLatencyUp(latencyMs);
+    const next = ((_this$countByLatency$3 = this.countByLatency.get(step)) !== null && _this$countByLatency$3 !== void 0 ? _this$countByLatency$3 : 0) - 1;
+    if (next > 0) {
+      this.countByLatency.set(step, next);
+    } else {
+      this.countByLatency.delete(step);
+    }
+  }
+}

package/dist/es2019/collector/interaction-observer.js

@@ -0,0 +1,90 @@
+import { REPORTING_THRESHOLD_MS } from './bucket-boundaries';
+/** `performance.interactionCount` is Chromium-only and absent from the DOM typings. */
+const interactionCount = () => performance.interactionCount;
+
+/** `durationThreshold` is absent from the DOM typings for `PerformanceObserverInit`. */
+
+/**
+ * Reports the interactions the browser observes to `onEntries`.
+ *
+ * `drain` and `stop` are safe to call before `start` and after each other, so a session
+ * that never started collecting needs no special handling.
+ */
+export class InteractionObserver {
+  /**
+   * Whether the browser reports both things a session needs: `interactionId`, which groups
+   * entries into interactions, and `performance.interactionCount`, which counts the ones
+   * below the reporting threshold. Both are Chromium-only, and without the count
+   * `totalCount` would be indistinguishable from `observedCount`.
+   */
+  static isSupported() {
+    if (typeof window === 'undefined' || typeof PerformanceObserver === 'undefined') {
+      return false;
+    }
+    if (!('PerformanceEventTiming' in window) || !('interactionId' in PerformanceEventTiming.prototype)) {
+      return false;
+    }
+    if (!PerformanceObserver.supportedEntryTypes.includes('event')) {
+      return false;
+    }
+    return typeof interactionCount() === 'number';
+  }
+
+  /**
+   * Total interactions on the page since page load, including those below the reporting
+   * threshold that no observer ever sees. A property of the page, not of an observer.
+   */
+  static readPageInteractionCount() {
+    var _interactionCount;
+    return (_interactionCount = interactionCount()) !== null && _interactionCount !== void 0 ? _interactionCount : 0;
+  }
+  constructor(onEntries) {
+    this.onEntries = onEntries;
+  }
+
+  /**
+   * Starts reporting interactions from this point on. Does nothing when already started, so
+   * a second call cannot leave an observer running with nobody to disconnect it.
+   *
+   * `buffered` is `false`: the entries the browser collected earlier are interactions with
+   * the page while the editor was still loading, and they belong to no session of ours.
+   */
+  start() {
+    if (this.observer) {
+      return;
+    }
+    this.observer = new PerformanceObserver(list => {
+      // Delay by a microtask to work around a Safari bug where the callback is
+      // invoked synchronously rather than in a separate task.
+      // See: https://github.com/GoogleChrome/web-vitals/issues/277
+      Promise.resolve().then(() => {
+        this.onEntries(list.getEntries());
+      });
+    });
+    const init = {
+      type: 'event',
+      buffered: false,
+      // 16 ms is also the smallest value the spec honours; lower values are clamped.
+      durationThreshold: REPORTING_THRESHOLD_MS
+    };
+    this.observer.observe(init);
+  }
+
+  /**
+   * Synchronously reports the entries the browser has produced but not yet dispatched to
+   * the callback. A snapshot taken because the page is going away has to include them,
+   * because there is no later chance to.
+   */
+  drain() {
+    var _this$observer;
+    const entries = (_this$observer = this.observer) === null || _this$observer === void 0 ? void 0 : _this$observer.takeRecords();
+    if (entries) {
+      this.onEntries(entries);
+    }
+  }
+  stop() {
+    var _this$observer2;
+    (_this$observer2 = this.observer) === null || _this$observer2 === void 0 ? void 0 : _this$observer2.disconnect();
+    this.observer = undefined;
+  }
+}

package/dist/es2019/collector/interaction-tracker.js

@@ -0,0 +1,156 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { interactionEventKind } from './interaction-events';
+
+/**
+ * The Event Timing fields this package reads. `interactionId` is missing from the DOM
+ * typings' `PerformanceEventTiming`, so it is declared here as optional, which also makes
+ * a `PerformanceEntry` from `getEntries()` assignable without a cast.
+ */
+
+/**
+ * What an entry did to the interaction it belongs to: either it is the first entry of a new
+ * interaction, or it measured an interaction that was already counted as slower than it was
+ * known to be. Both carry the editor group of the interaction, if it is one of the editor's.
+ */
+
+/**
+ * How many interactions are remembered, so their growth can still be applied, and how many of
+ * the editor's events. Entries of one interaction arrive within the interaction itself, so
+ * anything older than the last few hundred is not needed.
+ */
+const MAX_TRACKED = 256;
+/**
+ * How many are dropped per cleanup. Dropping one at a time would run a cleanup on every new
+ * interaction once the limit is reached; a batch makes it one cleanup per 64 of them.
+ */
+const PRUNE_BATCH = 64;
+
+/**
+ * Identifies the event an entry measured: an entry's `startTime` is that event's timestamp and its
+ * `name` is its type. The type is in the key because browsers coarsen the timestamp, so two events
+ * of one task can share it — and events of one type are always of one group, so a collision cannot
+ * move an interaction into another group.
+ */
+function eventKey(type, timeStamp) {
+  return `${type}|${timeStamp}`;
+}
+
+/**
+ * Makes interactions out of what the two observers report, for one session.
+ *
+ * Entries sharing a non-zero `interactionId` are one interaction whose latency is the
+ * maximum `duration` among them. Entries arrive incrementally, so an interaction's latency
+ * can grow after it was first reported — callers apply that to what they already counted
+ * rather than counting the interaction twice.
+ *
+ * A non-zero `interactionId` is the browser's own definition of an interaction, which is
+ * also what INP filters on: it is assigned to the pointer and keyboard events that make one
+ * up, and never to scrolling or pointer movement.
+ *
+ * The editor's events answer what an entry cannot: which interactions were with the editor, and
+ * how many there were, including the ones below the Event Timing reporting threshold.
+ */
+export class InteractionTracker {
+  /**
+   * @param startsAfterInteractionId interactions up to and including this one belong to the
+   * previous tracker and are ignored. `interactionId` counts up over the life of the page, so
+   * a session opening mid-page passes the highest id the one before it saw; without that, an
+   * entry still arriving for an interaction from the previous session would look new here and
+   * be counted in both.
+   */
+  constructor(startsAfterInteractionId = 0) {
+    _defineProperty(this, "interactions", new Map());
+    _defineProperty(this, "groupByEvent", new Map());
+    _defineProperty(this, "highestInteractionId", 0);
+    this.startsAfterInteractionId = startsAfterInteractionId;
+  }
+
+  /** The highest `interactionId` this tracker has seen. */
+  get lastInteractionId() {
+    return Math.max(this.highestInteractionId, this.startsAfterInteractionId);
+  }
+
+  /**
+   * Merges an entry into the interaction it belongs to.
+   *
+   * @returns what that did to the interaction's latency, or nothing when the entry is not
+   * part of an interaction, belongs to a previous tracker, or does not change one.
+   */
+  merge(entry) {
+    const {
+      interactionId
+    } = entry;
+    // `first-input` and non-interaction events report `interactionId` 0.
+    if (!interactionId) {
+      return undefined;
+    }
+    if (interactionId <= this.startsAfterInteractionId) {
+      return undefined;
+    }
+    this.highestInteractionId = Math.max(this.highestInteractionId, interactionId);
+
+    // Every latency is counted through here, so this is where one that cannot be measured
+    // is rejected: a `NaN` getting through becomes a `NaN` bucket key and a `NaN` `sumMs`
+    // for the rest of the session.
+    if (!Number.isFinite(entry.duration) || entry.duration < 0) {
+      return undefined;
+    }
+    const tracked = this.interactions.get(interactionId);
+    if (tracked === undefined) {
+      // Taken once: an entry that only makes the interaction slower has to move its count
+      // within the group it was counted in, not into another one.
+      const group = this.groupByEvent.get(eventKey(entry.name, entry.startTime));
+      this.interactions.set(interactionId, {
+        latencyMs: entry.duration,
+        group
+      });
+      this.prune(this.interactions);
+      return {
+        type: 'new',
+        latencyMs: entry.duration,
+        group
+      };
+    }
+    if (entry.duration <= tracked.latencyMs) {
+      return undefined;
+    }
+    const fromMs = tracked.latencyMs;
+    tracked.latencyMs = entry.duration;
+    return {
+      type: 'remeasured',
+      fromMs,
+      toMs: entry.duration,
+      group: tracked.group
+    };
+  }
+
+  /** @returns the group of an interaction to count, when this is the event its group counts on. */
+  recordEditorEvent(event) {
+    const kind = interactionEventKind(event.type);
+    if (!kind) {
+      return undefined;
+    }
+
+    // Every event of the interaction, because any of them can be the one Event Timing reports
+    // as the slowest: for a pointer press that is usually the click.
+    this.groupByEvent.set(eventKey(event.type, event.timeStamp), kind.group);
+    this.prune(this.groupByEvent);
+    return kind.counts ? kind.group : undefined;
+  }
+  prune(entries) {
+    if (entries.size <= MAX_TRACKED) {
+      return;
+    }
+
+    // `Map` preserves insertion order, so the entries inserted first are the least likely to
+    // see another entry or another event.
+    let remaining = PRUNE_BATCH;
+    for (const key of entries.keys()) {
+      entries.delete(key);
+      remaining -= 1;
+      if (remaining === 0) {
+        return;
+      }
+    }
+  }
+}

package/dist/es2019/collector/interactivity-collector.js

@@ -0,0 +1,274 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { getDocument } from '@atlaskit/browser-apis';
+import { EditorEventObserver } from './editor-event-observer';
+import { InteractionObserver } from './interaction-observer';
+import { InteractivitySession } from './interactivity-session';
+import { SCHEMA_VERSION } from './bucket-boundaries';
+import { LifecycleObserver } from './lifecycle-observer';
+import { SnapshotScheduler } from './snapshot-scheduler';
+/**
+ * Collects interaction latencies for one editor mount and emits session-to-date snapshots.
+ *
+ * Every interaction is counted in `page`, and the ones with the editor again in one of the editor
+ * groups, which is what tells a slow editor apart from a slow page around it.
+ *
+ * `start` and `stop` bound the collecting, which happens once. Within it there can be several
+ * sessions, because a session covers one document in one mode: a Confluence live page
+ * navigates and switches between reading and editing without ever remounting the editor, and
+ * each of those closes the current session and opens the next.
+ */
+export class InteractivityCollector {
+  constructor(options) {
+    _defineProperty(this, "started", false);
+    _defineProperty(this, "stopped", false);
+    this.emit = options.emit;
+    this.getEditorDomSize = options.getEditorDomSize;
+    this.getNodeSize = options.getNodeSize;
+    this.getObjectId = options.getObjectId;
+    this.getSessionMode = options.getSessionMode;
+    this.interactionObserver = new InteractionObserver(entries => this.recordEntries(entries));
+    this.editorEvents = new EditorEventObserver(event => this.recordEditorEvent(event));
+    this.snapshotScheduler = new SnapshotScheduler(() => this.onTimer());
+    this.lifecycleObserver = new LifecycleObserver({
+      onHidden: () => this.onHidden(),
+      onVisible: () => this.onVisible(),
+      onPageHide: () => this.onPageHide(),
+      onPageShow: () => this.onPageShow()
+    });
+    this.session = this.createSession(0);
+  }
+
+  /**
+   * Starts collecting. Calling it again while collecting changes nothing.
+   *
+   * @returns whether collecting is running; `false` when the browser cannot support it, or
+   * when it has already been stopped.
+   */
+  start() {
+    // Collecting is over for good once stopped: the session it covered has been reported.
+    if (this.stopped) {
+      return false;
+    }
+    if (this.started) {
+      return true;
+    }
+    if (!InteractionObserver.isSupported()) {
+      return false;
+    }
+
+    // Opened again so the session's timings start with the collecting, not with whenever
+    // this object was constructed.
+    this.session = this.createSession(0);
+    this.interactionObserver.start();
+    this.editorEvents.observe(this.editorRoot);
+    this.snapshotScheduler.start();
+    this.lifecycleObserver.start();
+    this.started = true;
+    return true;
+  }
+
+  /** Reports the session as ended by the editor unmounting, and stops collecting. */
+  stop() {
+    if (this.stopped) {
+      return;
+    }
+    this.takeSnapshot('unmount');
+    this.stopped = true;
+    this.interactionObserver.stop();
+    this.editorEvents.stop();
+    this.snapshotScheduler.stop();
+    this.lifecycleObserver.stop();
+  }
+
+  /**
+   * The element the editor renders itself into is what makes an interaction one of the editor's.
+   * The session is not tied to it: interactions from before it arrives are counted in `page`.
+   */
+  setEditorRoot(root) {
+    this.editorRoot = root !== null && root !== void 0 ? root : undefined;
+    if (this.started && !this.stopped) {
+      this.editorEvents.observe(this.editorRoot);
+    }
+  }
+
+  /**
+   * Rotates the session when the editor is pointed at different content.
+   *
+   * An unknown object id is no information, never a change. The provider resolves
+   * asynchronously after mount, and `contextIdentifierPlugin` resets its state to the
+   * configured provider on transactions that do not carry a new one, so the id read here goes
+   * missing for a moment on a document that never changed.
+   */
+  onObjectIdChanged() {
+    if (this.stopped) {
+      return;
+    }
+    const objectId = this.getObjectId();
+    if (objectId === undefined || objectId === this.session.objectId) {
+      return;
+    }
+    if (this.session.objectId === undefined) {
+      this.session.objectId = objectId;
+      return;
+    }
+    this.rotateSession('navigation');
+  }
+
+  /**
+   * Rotates the session when the editor switches between reading and editing. Interactions
+   * with a read-only page are a different population from interactions while editing, so one
+   * session never covers both.
+   */
+  onViewModeChanged() {
+    if (this.stopped) {
+      return;
+    }
+    const mode = this.getSessionMode();
+    if (mode === undefined || mode === this.session.mode) {
+      return;
+    }
+    if (this.session.mode === undefined) {
+      this.session.mode = mode;
+      return;
+    }
+    this.rotateSession('modeChange');
+  }
+
+  /**
+   * @param startsAfterInteractionId the highest interaction the previous session saw, so
+   * entries still arriving for it are not counted here as well.
+   */
+  createSession(startsAfterInteractionId) {
+    var _getDocument;
+    return new InteractivitySession({
+      objectId: this.getObjectId(),
+      mode: this.getSessionMode(),
+      hidden: ((_getDocument = getDocument()) === null || _getDocument === void 0 ? void 0 : _getDocument.visibilityState) === 'hidden',
+      startsAfterInteractionId
+    });
+  }
+
+  /** Reports the current session as ended by `reason` and puts a new one in its place. */
+  rotateSession(reason) {
+    this.takeSnapshot(reason);
+    this.session = this.createSession(this.session.tracker.lastInteractionId);
+    this.snapshotScheduler.restart();
+  }
+  onTimer() {
+    this.takeSnapshot('timer');
+  }
+  onHidden() {
+    if (this.session.hiddenSince === undefined) {
+      this.session.hiddenSince = performance.now();
+    }
+    this.takeSnapshot('hidden');
+  }
+  onVisible() {
+    if (this.session.hiddenSince !== undefined) {
+      this.session.hiddenMs += performance.now() - this.session.hiddenSince;
+      this.session.hiddenSince = undefined;
+    }
+    this.session.lifecycleSnapshotEmitted = false;
+  }
+  onPageHide() {
+    this.takeSnapshot('pagehide');
+  }
+
+  /**
+   * The page came back from the back/forward cache, which never raises a visibility change.
+   * The session continues, and the signal that suspended it has been reported, so the next
+   * one is due.
+   */
+  onPageShow() {
+    this.session.lifecycleSnapshotEmitted = false;
+  }
+
+  /**
+   * Counts an interaction with the editor, including the ones Event Timing never reports because
+   * they were faster than its threshold — which is why a count alone moves the session on.
+   */
+  recordEditorEvent(event) {
+    if (this.stopped) {
+      return;
+    }
+    const group = this.session.tracker.recordEditorEvent(event);
+    if (!group) {
+      return;
+    }
+
+    // The session names its editor groups after the fields they are reported in.
+    this.session[group].countTotal();
+    this.session.revision += 1;
+  }
+  recordEntries(entries) {
+    const {
+      tracker,
+      page
+    } = this.session;
+    for (const entry of entries) {
+      const update = tracker.merge(entry);
+      if (!update) {
+        continue;
+      }
+      if (update.type === 'new') {
+        page.add(update.latencyMs);
+        if (update.group) {
+          this.session[update.group].add(update.latencyMs);
+        }
+      } else {
+        page.remeasure(update.fromMs, update.toMs);
+        if (update.group) {
+          this.session[update.group].remeasure(update.fromMs, update.toMs);
+        }
+      }
+      this.session.revision += 1;
+    }
+  }
+  takeSnapshot(reason) {
+    if (this.stopped) {
+      return;
+    }
+    const session = this.session;
+
+    // Checked before anything is consumed: `visibilitychange` and `pagehide` fire back to
+    // back on the same transition and it is reported once, and draining first would take
+    // entries out of the browser's queue only to suppress the snapshot carrying them.
+    const lifecycleSignal = reason === 'hidden' || reason === 'pagehide';
+    if (lifecycleSignal && session.lifecycleSnapshotEmitted) {
+      return;
+    }
+
+    // Must run before the change check: the browser may be holding entries that have not
+    // reached the observer callback yet, and on `pagehide` there is no later chance to
+    // pick them up.
+    this.interactionObserver.drain();
+    if (session.revision === session.emittedRevision) {
+      return;
+    }
+    if (lifecycleSignal) {
+      session.lifecycleSnapshotEmitted = true;
+    }
+    session.seq += 1;
+    session.emittedRevision = session.revision;
+    const now = performance.now();
+    const hiddenMs = session.hiddenMs + (session.hiddenSince === undefined ? 0 : now - session.hiddenSince);
+    const pageTotalCount = InteractionObserver.readPageInteractionCount() - session.interactionCountAtStart;
+    this.emit({
+      schema: SCHEMA_VERSION,
+      interactivitySessionId: session.id,
+      objectId: session.objectId,
+      seq: session.seq,
+      reason,
+      sessionMode: session.mode,
+      activeMs: Math.round(Math.max(0, now - session.startedAt - hiddenMs)),
+      hiddenMs: Math.round(hiddenMs),
+      nodeSize: this.getNodeSize(),
+      editorDomSize: this.getEditorDomSize(),
+      // Only `page` is told its total; each editor group has counted its own.
+      page: session.page.snapshot(pageTotalCount),
+      editorTyping: session.editorTyping.snapshot(),
+      editorPointer: session.editorPointer.snapshot(),
+      editorOther: session.editorOther.snapshot()
+    });
+  }
+}

package/dist/es2019/collector/interactivity-session.js

@@ -0,0 +1,45 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { InteractionObserver } from './interaction-observer';
+import { InteractionTracker } from './interaction-tracker';
+import { InteractionGroup } from './interaction-group';
+function createSessionId() {
+  if (typeof crypto.randomUUID === 'function') {
+    return crypto.randomUUID();
+  }
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes, byte => byte.toString(16).padStart(2, '0')).join('');
+}
+/**
+ * Everything that belongs to one session.
+ *
+ * Nothing here is reset — the next session is a new instance — so a field added here cannot
+ * be left carrying the previous session's value.
+ */
+export class InteractivitySession {
+  constructor(start) {
+    _defineProperty(this, "id", createSessionId());
+    _defineProperty(this, "startedAt", performance.now());
+    /** Page interaction count when the session opened, subtracted to get its own total. */
+    _defineProperty(this, "interactionCountAtStart", InteractionObserver.readPageInteractionCount());
+    _defineProperty(this, "page", new InteractionGroup());
+    _defineProperty(this, "editorTyping", new InteractionGroup());
+    _defineProperty(this, "editorPointer", new InteractionGroup());
+    _defineProperty(this, "editorOther", new InteractionGroup());
+    /** Increments per snapshot; a query takes the highest one per session. */
+    _defineProperty(this, "seq", 0);
+    _defineProperty(this, "hiddenMs", 0);
+    /**
+     * Bumped on every change to the accumulated data. A snapshot is emitted only when this
+     * has moved past `emittedRevision`, so identical snapshots are never sent twice.
+     */
+    _defineProperty(this, "revision", 0);
+    _defineProperty(this, "emittedRevision", 0);
+    /** One lifecycle snapshot per hidden episode; cleared when the page comes back. */
+    _defineProperty(this, "lifecycleSnapshotEmitted", false);
+    this.objectId = start.objectId;
+    this.mode = start.mode;
+    this.hiddenSince = start.hidden ? this.startedAt : undefined;
+    this.tracker = new InteractionTracker(start.startsAfterInteractionId);
+  }
+}