cyborg-hunter 0.3.0

package/src/core/signals/focus.js

@@ -0,0 +1,101 @@
+// src/core/signals/focus.js
+// Tab-away detection and idle gap monitoring.
+//
+// Tab-away uses two complementary mechanisms:
+//   1. visibilitychange — fires when tab is fully hidden (tab switch, app switch)
+//   2. window blur/focus — fires when window loses focus without tab hiding
+//      (catches sidebar clicks, DevTools, browser menus)
+//
+// Both are logged with their type so downstream analysis can distinguish
+// "left the tab entirely" from "clicked sidebar."
+
+/**
+ * Attaches session-scoped tab-away detection.
+ * Called from monitor.js at startSession() time.
+ */
+export function attachFocusSignals(ctx) {
+  var config = ctx.config;
+
+  if (config.signals.tabAway) {
+    var _tabAwayStart = null;
+    var _tabAwayType = null;
+
+    function _onLeave(type) {
+      if (_tabAwayStart !== null) return; // already tracking
+      _tabAwayStart = performance.now();
+      _tabAwayType = type;
+      ctx.fireSignal("tabAway", null, { type: type });
+    }
+
+    function _onReturn() {
+      if (_tabAwayStart === null) return;
+      var duration = performance.now() - _tabAwayStart;
+      var event = {
+        start: _tabAwayStart,
+        duration_ms: Math.round(duration),
+        type: _tabAwayType
+      };
+      // Push to current trial if one is active
+      if (ctx.getTrialData()) ctx.getTrialData().tabAwayEvents.push(event);
+      ctx.sessionData.tabAwaySums.push(Math.round(duration));
+      ctx.fireSignal("tabReturn", null, {
+        duration_ms: Math.round(duration),
+        type: _tabAwayType
+      });
+      _tabAwayStart = null;
+      _tabAwayType = null;
+    }
+
+    // Mechanism 1: full tab hide (tab switch, app switch)
+    ctx.addListener(document, "visibilitychange", function () {
+      if (document.hidden) {
+        _onLeave("tabHidden");
+      } else {
+        _onReturn();
+      }
+    });
+
+    // Mechanism 2: window blur (sidebar click, devtools, browser chrome)
+    ctx.addListener(window, "blur", function () {
+      _onLeave("windowBlur");
+    });
+    ctx.addListener(window, "focus", function () {
+      if (!document.hidden) _onReturn();
+    });
+  }
+}
+
+/**
+ * Attaches trial-scoped idle gap detection.
+ * Flags periods of >10s with no input activity within a trial.
+ * Called from monitor.js at startTrial() time.
+ */
+export function attachIdleGapSignals(ctx) {
+  var config = ctx.config;
+  var trialData = ctx.trialData;
+
+  if (config.signals.idleGaps) {
+    var idleThreshold = config.thresholds.idleGapMs;
+    var lastActivityTime = performance.now();
+
+    // Any input event resets the activity timer
+    ctx.addTrialListener(document, "keydown", function () {
+      lastActivityTime = performance.now();
+    });
+    ctx.addTrialListener(document, "mousemove", function () {
+      lastActivityTime = performance.now();
+    }, { passive: true });
+
+    var idleCheckId = setInterval(function () {
+      if (!ctx.getTrialData()) return; // trial ended
+      var gap = performance.now() - lastActivityTime;
+      if (gap > idleThreshold) {
+        trialData.idleGaps.push({
+          duration_ms: Math.round(gap), t: performance.now()
+        });
+        lastActivityTime = performance.now();
+      }
+    }, config.thresholds.idleCheckIntervalMs);
+    ctx.addInterval(idleCheckId);
+  }
+}

package/src/core/signals/mouse.js

@@ -0,0 +1,117 @@
+// src/core/signals/mouse.js
+// Mouse tracking (20Hz throttled) and bot metrics computation.
+//
+// Trial-scoped: mousemove, click, mousedown, mouseup events are recorded
+// during each trial. The bot metrics (pathEfficiency, directionChanges,
+// speedVariance) are computed at endTrial() time by computeMouseMetrics().
+
+/**
+ * Attaches trial-scoped mouse tracking listeners.
+ * Called from monitor.js at startTrial() time.
+ */
+export function attachMouseSignals(ctx) {
+  var config = ctx.config;
+  var trialData = ctx.trialData;
+
+  if (config.signals.mouseTracking) {
+    var mouseThrottle = config.thresholds.mouseThrottleMs;
+    var mouseMaxEvents = config.thresholds.mouseMaxEvents;
+    var lastMoveTime = 0;
+    var trialStartTime = trialData.startTime;
+    trialData.mouseTrackingCapped = false;
+    trialData.mouseTrackingCappedAtMs = null;
+
+    // Throttled mousemove — 20Hz by default, capped at mouseMaxEvents
+    ctx.addTrialListener(document, "mousemove", function (e) {
+      if (trialData.mouseEvents.length >= mouseMaxEvents) {
+        if (!trialData.mouseTrackingCapped) {
+          trialData.mouseTrackingCapped = true;
+          trialData.mouseTrackingCappedAtMs = Math.round(performance.now() - trialStartTime);
+        }
+        return;
+      }
+      var now = performance.now();
+      if (now - lastMoveTime < mouseThrottle) return;
+      lastMoveTime = now;
+      trialData.mouseEvents.push({
+        x: Math.round(e.pageX), y: Math.round(e.pageY),
+        t: Math.round(now - trialStartTime), type: "move"
+      });
+    }, { passive: true });
+
+    // Click/mousedown/mouseup — no throttling needed, low frequency
+    function mouseEventHandler(type) {
+      return function (e) {
+        if (trialData.mouseEvents.length >= mouseMaxEvents) return;
+        trialData.mouseEvents.push({
+          x: Math.round(e.pageX), y: Math.round(e.pageY),
+          t: Math.round(performance.now() - trialStartTime), type: type
+        });
+      };
+    }
+    ctx.addTrialListener(document, "click", mouseEventHandler("click"), { passive: true });
+    ctx.addTrialListener(document, "mousedown", mouseEventHandler("down"), { passive: true });
+    ctx.addTrialListener(document, "mouseup", mouseEventHandler("up"), { passive: true });
+  }
+}
+
+/**
+ * Computes inline mouse bot metrics from recorded mouse events.
+ * Three lightweight O(n) features:
+ *   1. pathEfficiency: straight-line distance / total path (bots ≈ 1.0, humans ≈ 0.3-0.7)
+ *   2. directionChanges: sign reversals in dx/dy (bots ≈ 0, humans have many)
+ *   3. speedVariance: variance of inter-sample speeds (bots have near-zero variance)
+ *
+ * Called from monitor.js at endTrial() time.
+ */
+export function computeMouseMetrics(mouseEvents, minEvents) {
+  var moveEvents = mouseEvents.filter(function (e) { return e.type === "move"; });
+  if (moveEvents.length < minEvents) return null;
+
+  var totalDist = 0;
+  var speeds = [];
+  var dxSignChanges = 0, dySignChanges = 0;
+  var prevDx = 0, prevDy = 0;
+
+  for (var mi = 1; mi < moveEvents.length; mi++) {
+    var dx = moveEvents[mi].x - moveEvents[mi - 1].x;
+    var dy = moveEvents[mi].y - moveEvents[mi - 1].y;
+    var dist = Math.sqrt(dx * dx + dy * dy);
+    totalDist += dist;
+
+    // Speed: pixels per millisecond between consecutive samples
+    var dt = moveEvents[mi].t - moveEvents[mi - 1].t;
+    if (dt > 0) speeds.push(dist / dt);
+
+    // Direction changes: sign reversal in dx or dy
+    if (mi > 1) {
+      if ((dx > 0 && prevDx < 0) || (dx < 0 && prevDx > 0)) dxSignChanges++;
+      if ((dy > 0 && prevDy < 0) || (dy < 0 && prevDy > 0)) dySignChanges++;
+    }
+    prevDx = dx;
+    prevDy = dy;
+  }
+
+  var first = moveEvents[0];
+  var last = moveEvents[moveEvents.length - 1];
+  var displacement = Math.sqrt(
+    Math.pow(last.x - first.x, 2) + Math.pow(last.y - first.y, 2)
+  );
+  var pathEfficiency = totalDist > 0 ? Math.round((displacement / totalDist) * 1000) / 1000 : 0;
+
+  // Speed variance using Welford's online algorithm for numerical stability
+  var speedMean = 0, speedM2 = 0;
+  for (var si = 0; si < speeds.length; si++) {
+    var sdelta = speeds[si] - speedMean;
+    speedMean += sdelta / (si + 1);
+    speedM2 += sdelta * (speeds[si] - speedMean);
+  }
+  var speedVariance = speeds.length > 1 ? Math.round((speedM2 / (speeds.length - 1)) * 10000) / 10000 : 0;
+
+  return {
+    pathEfficiency: pathEfficiency,
+    directionChanges: dxSignChanges + dySignChanges,
+    speedVariance: speedVariance,
+    moveCount: moveEvents.length
+  };
+}

package/src/core/signals/typing.js

@@ -0,0 +1,110 @@
+// src/core/signals/typing.js
+// Typing speed measurement and synthetic insertion detection.
+//
+// Synthetic insertion: text inserted without a preceding keydown event.
+// This catches execCommand('insertText'), clipboard-manager pastes,
+// and browser extension injections that bypass the paste event.
+//
+// Typing speed: computed at endTrial() from edit timestamps. The threshold
+// (default 10 cps) flags unusually fast typing that suggests AI assistance.
+
+/**
+ * Attaches trial-scoped typing and synthetic insertion listeners.
+ * Called from monitor.js at startTrial() time.
+ *
+ * Note: The clipboardManager signal handles both synthetic insertion
+ * detection AND edit timestamp collection. When clipboardManager is off
+ * but typingSpeed is on, a simpler input listener collects timestamps.
+ */
+export function attachTypingSignals(ctx) {
+  var config = ctx.config;
+  var trialData = ctx.trialData;
+
+  // ── Synthetic insertion detection + edit timestamps ──
+  if (config.signals.clipboardManager) {
+    var _lastKeydownTime = 0;
+    ctx.addTrialListener(document, "keydown", function () {
+      _lastKeydownTime = performance.now();
+    });
+    ctx.addTrialListener(document, "input", function (e) {
+      if (e.target && (e.target.tagName === "INPUT" || e.target.tagName === "TEXTAREA" || e.target.isContentEditable)) {
+        // Record edit timestamp for typing speed computation
+        trialData.editTimestamps.push(performance.now());
+
+        // Check if this input arrived without a recent keydown
+        if (performance.now() - _lastKeydownTime > config.thresholds.syntheticGapMs && e.inputType === "insertText") {
+          var dataLen = (e.data || "").length;
+          trialData.syntheticInsertions.push({
+            type: "synthetic_insertion", t: performance.now(),
+            dataLength: dataLen
+          });
+          ctx.fireSignal("syntheticInsertion", e, { dataLength: dataLen });
+        }
+      }
+    }, true); // capture phase to catch before frameworks
+  }
+
+  // ── Fallback: keystroke timestamps for typing speed only ──
+  // If clipboardManager isn't enabled, still collect edit timestamps
+  // for typing speed computation via a simpler listener.
+  if (config.signals.typingSpeed && !config.signals.clipboardManager) {
+    ctx.addTrialListener(document, "input", function (e) {
+      if (e.target && (e.target.tagName === "INPUT" || e.target.tagName === "TEXTAREA" || e.target.isContentEditable)) {
+        trialData.editTimestamps.push(performance.now());
+      }
+    }, true);
+  }
+}
+
+/**
+ * Attaches trial-scoped foreign input detection.
+ * When experimentContainer is set, tracks input events that land on
+ * elements OUTSIDE the experiment's DOM. This catches participants
+ * typing into AI extension sidebars, chatbot widgets, etc.
+ */
+export function attachForeignInputSignals(ctx) {
+  var config = ctx.config;
+  var trialData = ctx.trialData;
+
+  ctx.addTrialListener(document, "input", function (e) {
+    var target = e.target;
+    if (!target) return;
+    var isTextInput = target.tagName === "INPUT" || target.tagName === "TEXTAREA" || target.isContentEditable;
+    if (!isTextInput) return;
+    var known = ctx.isKnownInput(target);
+    if (known === false) {
+      var entry = {
+        t: performance.now(),
+        targetTag: target.tagName || "unknown",
+        targetId: (target.id || "").slice(0, 50),
+        targetClass: (target.className || "").toString().slice(0, 100),
+        inputType: e.inputType || ""
+      };
+      if (config.collectForPostHoc.foreignInputContent) {
+        entry.data = e.data || "";
+      }
+      trialData.foreignInputEvents.push(entry);
+      ctx.fireSignal("typingOutsideExperiment", e, {
+        targetTag: entry.targetTag,
+        targetId: entry.targetId,
+        targetClass: entry.targetClass,
+        data: e.data || ""
+      });
+    }
+  }, true);
+}
+
+/**
+ * Computes typing speed (chars per second) from edit timestamps.
+ * Called from monitor.js at endTrial() time.
+ * Returns the computed charsPerSec or null if insufficient data.
+ */
+export function computeTypingSpeed(editTimestamps) {
+  if (editTimestamps.length < 2) return null;
+  var firstEdit = editTimestamps[0];
+  var lastEdit = editTimestamps[editTimestamps.length - 1];
+  var spanSec = (lastEdit - firstEdit) / 1000;
+  if (spanSec <= 0) return null;
+  var charCount = editTimestamps.length;
+  return Math.round((charCount / spanSec) * 10) / 10;
+}

package/src/core/state-machine.js

@@ -0,0 +1,88 @@
+// src/core/state-machine.js
+// Lifecycle state machine enforcing correct call order:
+// init → startSession → startTrial/endTrial → destroy
+// States: "created", "session", "trial", "destroyed"
+
+// Valid state transitions. Each state maps to an array of states it can
+// transition to. Any other transition is rejected with a warning.
+export const VALID_TRANSITIONS = {
+  created:   ["session", "destroyed"],
+  session:   ["trial", "destroyed"],
+  trial:     ["session", "destroyed"],  // endTrial returns to session
+  destroyed: []
+};
+
+/**
+ * Creates a state machine instance.
+ * Returns an object with a `current` getter and a `transition(to)` method.
+ * transition() returns true on success, false on invalid transition.
+ */
+export function createStateMachine() {
+  let state = "created";
+  return {
+    get current() { return state; },
+    transition(to) {
+      if (VALID_TRANSITIONS[state] && VALID_TRANSITIONS[state].indexOf(to) !== -1) {
+        state = to;
+        return true;
+      }
+      console.warn("[CyborgHunter] Invalid transition: " + state + " → " + to);
+      return false;
+    }
+  };
+}
+
+/**
+ * Deep copy utility — prevents external mutation of internal state.
+ * Uses JSON round-trip for simplicity. Falls back to identity for
+ * non-serializable objects (shouldn't happen in practice).
+ */
+export function deepCopy(obj) {
+  if (obj === null || typeof obj !== "object") return obj;
+  try { return JSON.parse(JSON.stringify(obj)); }
+  catch (e) { return obj; }
+}
+
+/**
+ * Storage helpers with localStorage/sessionStorage fallback.
+ * Some browsers disable localStorage in private browsing mode,
+ * so we fall back to sessionStorage, then to no-op.
+ */
+export const STORAGE_PREFIX = "integrity_monitor_";
+
+export function storageSet(key, value) {
+  var fullKey = STORAGE_PREFIX + key;
+  try {
+    localStorage.setItem(fullKey, JSON.stringify(value));
+  } catch (e) {
+    // localStorage unavailable (private browsing) — try sessionStorage
+    try {
+      sessionStorage.setItem(fullKey, JSON.stringify(value));
+    } catch (e2) { /* both unavailable — in-memory only */ }
+  }
+}
+
+export function storageGet(key) {
+  var fullKey = STORAGE_PREFIX + key;
+  try {
+    var raw = localStorage.getItem(fullKey);
+    if (raw) return JSON.parse(raw);
+  } catch (e) { /* fall through */ }
+  try {
+    var raw2 = sessionStorage.getItem(fullKey);
+    if (raw2) return JSON.parse(raw2);
+  } catch (e) { /* fall through */ }
+  return null;
+}
+
+export function storageClear(participantId) {
+  var prefix = STORAGE_PREFIX + participantId;
+  [localStorage, sessionStorage].forEach(function (store) {
+    try {
+      for (var i = store.length - 1; i >= 0; i--) {
+        var k = store.key(i);
+        if (k && k.startsWith(prefix)) store.removeItem(k);
+      }
+    } catch (e) { /* non-critical */ }
+  });
+}

package/src/jspsych/extension.js

@@ -0,0 +1,199 @@
+// src/jspsych/extension.js
+// jsPsych extension adapter for Cyborg Hunter.
+// Translates jsPsych's trial lifecycle into CyborgHunter API calls.
+//
+// Two main usage patterns:
+//   1. Monitor everything (default) — every trial gets startTrial/endTrial
+//   2. Explicit opt-in (autoMonitor: false) — monitor only specified trials
+//      (trials must pass { trialId: '...' } in their extension parameters)
+//
+// IMPORTANT: This file does NOT import from the core library. It references
+// window.CyborgHunter at runtime. The researcher must load cyborg-hunter.min.js
+// before this script. This avoids bundling the core into the extension.
+
+class CyborgHunterExtension {
+  // jsPsych reads this static info object to register the extension.
+  // The `data` field declares what on_finish() will return — here, an
+  // `integrity` object containing the trial's signal report.
+  static info = {
+    name: 'cyborg-hunter',
+    version: '0.1.0',
+    data: { integrity: { type: 'object' } }
+  };
+
+  constructor(jsPsych) {
+    this.jsPsych = jsPsych;
+    this.monitor = null;       // CyborgHunter monitor instance (set in initialize)
+    this.params = {};           // extension-level params from jsPsych config
+    this._monitoring = false;   // whether the current trial is being monitored
+    this._trialStart_perfNow = null; // performance.now() captured at on_load
+  }
+
+  // Called once when jsPsych initializes extensions (before any trials run).
+  // `params` comes from the experiment's extensions config, e.g.:
+  //   extensions: [{ type: jsPsychCyborgHunter, params: { preset: 'standard' } }]
+  //
+  // We pull out extension-specific keys (autoMonitor, excludeTrialTypes) and
+  // pass everything else through to CyborgHunter.init() as monitor config.
+  initialize(params) {
+    this.params = params;
+    const { autoMonitor, excludeTrialTypes, ...monitorConfig } = params;
+
+    // Look up the global CyborgHunter object (or its backward-compat alias).
+    // The researcher must include cyborg-hunter.min.js before this extension.
+    const CyborgHunter = window.CyborgHunter || window.IntegrityMonitor;
+    if (!CyborgHunter) {
+      throw new Error('CyborgHunter not found. Load cyborg-hunter.min.js before the jsPsych extension.');
+    }
+
+    // init() creates the monitor; startSession() begins session-scoped listeners.
+    this.monitor = CyborgHunter.init(monitorConfig);
+    this.monitor.startSession();
+  }
+
+  // jsPsych 7 unconditionally calls on_start for every trial that lists this
+  // extension — even though the work happens in on_load (after DOM render).
+  // Without this no-op, the very next trial after the first throws
+  // "this.extensions['cyborg-hunter'].on_start is not a function".
+  on_start(_params) {}
+
+  // Called at the start of each trial, after the trial's DOM is rendered.
+  // `params` here are per-trial extension parameters, e.g.:
+  //   extensions: [{ type: jsPsychCyborgHunter, params: { trialId: 'rule-3' } }]
+  on_load(params) {
+    this._monitoring = false;
+
+    // In explicit opt-in mode (autoMonitor: false), only monitor trials
+    // that provide a trialId in their per-trial extension params.
+    if (this.params.autoMonitor === false) {
+      if (!params || !params.trialId) return;
+    }
+
+    // Auto-monitor with exclusions: skip trial types the researcher listed.
+    // This is useful for excluding instruction screens, fixation crosses, etc.
+    // Trial type name comes from the plugin's static info.name property.
+    if (this.params.excludeTrialTypes) {
+      const currentTrial = this.jsPsych.getCurrentTrial();
+      const typeName = currentTrial.type?.info?.name || '';
+      if (this.params.excludeTrialTypes.includes(typeName)) return;
+    }
+
+    // Start monitoring this trial. We pass through per-trial params so the
+    // core library knows the trial ID, phase, decoy text, and where to scope
+    // typing/mouse signals.
+    this._monitoring = true;
+    // P3: Record performance.now() at trial start so ingest can compute
+    // trial-relative tab-away timestamps by direct subtraction (no offset
+    // estimator needed). Captured on the same monotonic clock that
+    // tabAwayEvents[*].start uses, so the difference is exact.
+    this._trialStart_perfNow = performance.now();
+    const trialIndex = this.jsPsych.getProgress().current_trial_global;
+    this.monitor.startTrial({
+      trialId: (params && params.trialId) || `trial-${trialIndex}`,
+      phase: params?.phase || null,
+      decoyAnswer: params?.decoyAnswer || null,
+      experimentContainer: params?.experimentContainer || null
+    });
+  }
+
+  // Called when a trial finishes (after participant response, before data save).
+  // Returns the integrity report object, which jsPsych merges into trial data
+  // under the key declared in static info.data (i.e., data.integrity).
+  on_finish(params) {
+    if (!this._monitoring) return {};
+    this._monitoring = false;
+    const report = this.monitor.endTrial();
+    // P3: Attach the on_load performance.now() so downstream ingest can
+    // convert session-absolute event timestamps (e.g., tabAwayEvents[*].start)
+    // to trial-relative ms without heuristic offset estimation.
+    report.trialStart_perfNow = this._trialStart_perfNow;
+    this._trialStart_perfNow = null;
+    return { integrity: report };
+  }
+
+  // Called explicitly by the researcher from their initJsPsych({ on_finish })
+  // callback, BEFORE saving data. Example:
+  //
+  //   const jsPsych = initJsPsych({
+  //     extensions: [{ type: jsPsychCyborgHunter, params: { ... } }],
+  //     on_finish: function () {
+  //       jsPsych.extensions['cyborg-hunter'].finalize();
+  //       jsPsych.data.get().localSave('csv', 'data.csv');
+  //     }
+  //   });
+  //
+  // Why this isn't automatic: jsPsych 7 has no on_finish_experiment extension
+  // hook (only initialize / on_start / on_load / on_finish exist). An earlier
+  // version of this wrapper defined on_finish_experiment and silently dropped
+  // session data because jsPsych never called it.
+  //
+  // Persists the full session report using Option A split attachment:
+  //   - Scalars (counts, booleans, version) go to jsPsych.data.addProperties()
+  //     so they land as columns on EVERY trial row — small, filterable in R/pandas.
+  //   - Arrays and nested objects (sidebarEvents, integrityScore, etc.) go to
+  //     jsPsych.data.addDataToLastTrial() so they're attached ONCE to the final
+  //     trial row — avoids duplicating kilobytes of JSON across every row.
+  //
+  // After persisting, tears down all listeners and clears session state.
+  finalize() {
+    if (!this.monitor) return;
+
+    try {
+      // Single call — Task 5A made getSessionReport() the source of truth, so
+      // this object has both the accumulators AND the scoring summary.
+      const report = this.monitor.getSessionReport();
+
+      const {
+        // Arrays — go to last trial only (no CSV bloat).
+        sidebarEvents = [], keyboardShortcuts = [], windowPositions = [],
+        layoutShifts = [], zoomChanges = [], idleGaps = [], extensionInjections = [],
+        tabAwaySums = [], charsPerSec = [], aiExtensionsFound = [],
+        // Scoring summary — full object to last trial; key scalars also duplicated
+        // to every trial via addProperties below.
+        hardScore, softScore, anyHardTriggered, trialsCompleted, softScoreThreshold,
+        // Scalars.
+        pasteCount = 0, copyCount = 0, dropCount = 0,
+        libraryVersion, config,
+        // Anything else the monitor adds in the future — goes with the arrays
+        // so it's captured on the last trial without polluting every row.
+        ...extras
+      } = report;
+
+      // Scalars: one column per field, duplicated across every trial row.
+      // Cheap, useful for per-trial filtering and quick exclusion queries.
+      this.jsPsych.data.addProperties({
+        integrityPasteCount: pasteCount,
+        integrityCopyCount: copyCount,
+        integrityDropCount: dropCount,
+        integrityAnyHardTriggered: !!anyHardTriggered,
+        integritySoftScore: softScore,
+        cyborgHunterVersion: libraryVersion,
+      });
+
+      // Arrays + nested objects: attached once, on the final trial row.
+      this.jsPsych.data.addDataToLastTrial({
+        integritySession: {
+          pasteCount, copyCount, dropCount,
+          sidebarEvents, keyboardShortcuts, windowPositions,
+          layoutShifts, zoomChanges, idleGaps, extensionInjections,
+          tabAwaySums, charsPerSec, aiExtensionsFound,
+          ...extras
+        },
+        integrityScore: { hardScore, softScore, anyHardTriggered, trialsCompleted, softScoreThreshold },
+      });
+    } catch (e) {
+      // Never let a reporting error crash the experiment's end-of-session path.
+      console.warn('[cyborg-hunter] Failed to save session report:', e);
+    }
+
+    this.monitor.destroy();
+  }
+}
+
+// Export for both module and IIFE contexts.
+// When loaded as a script tag, window.jsPsychCyborgHunter is the class
+// that researchers pass to jsPsych's extensions array.
+export { CyborgHunterExtension };
+if (typeof window !== 'undefined') {
+  window.jsPsychCyborgHunter = CyborgHunterExtension;
+}