diff --git a/.changeset/hifi-session-recording.md b/.changeset/hifi-session-recording.md
new file mode 100644
index 0000000000..1d8132b618
--- /dev/null
+++ b/.changeset/hifi-session-recording.md
@@ -0,0 +1,5 @@
+---
+"jspsych": minor
+---
+
+Add `record_session` option to `initJsPsych` for high-fidelity replay capture. When enabled, `jsPsych.getSessionRecording()` returns a JSON-serializable `SessionRecording` (`schema_version: 1`) capturing per-trial DOM snapshots and mutations, mouse/touch/keyboard/clipboard/scroll/form input, media events, viewport changes, stylesheets, canvas pixel snapshots, and every `Math.random()` output. `jsPsych.getSessionRecordingCompressed()` returns the same data as a gzip Blob. Default is `false`; opt-in only.
diff --git a/docs/reference/jspsych.md b/docs/reference/jspsych.md
index b7a25dc6fa..31e2dc8c56 100644
--- a/docs/reference/jspsych.md
+++ b/docs/reference/jspsych.md
@@ -34,7 +34,7 @@ The settings object can contain several parameters. None of the parameters are r
 | override_safe_mode         | boolean  | Running a jsPsych experiment directly in a web browser (e.g., by double clicking on a local HTML file) will load the page using the `file://` protocol. Some features of jsPsych don't work with this protocol. By default, when jsPsych detects that it's running on a page loaded via the `file://` protocol, it runs in _safe mode_, which automatically disables features that don't work in this context. Specifically, the use of Web Audio is disabled (audio will be played using HTML5 audio instead, even if `use_webaudio` is `true`) and video preloading is disabled. The `override_safe_mode` parameter defaults to `false`, but you can set it to `true` to force these features to operate under the `file://` protocol. In order for this to work, you will need to disable web security (CORS) features in your browser - this is safe to do if you know what you are doing. Note that this parameter has no effect when you are running the experiment on a web server, because the page will be loaded via the `http://` or `https://` protocol. |
 | case_sensitive_responses   | boolean  | If `true`, then jsPsych will make a distinction between uppercase and lowercase keys when evaluating keyboard responses, e.g. "A" (uppercase) will not be recognized as a valid response if the trial only accepts "a" (lowercase). If false, then jsPsych will not make a distinction between uppercase and lowercase keyboard responses, e.g. both "a" and "A" responses will be valid when the trial's key choice parameter is "a". Setting this parameter to false is useful if you want key responses to be treated the same way when CapsLock is turned on or the Shift key is held down. The default value is `false`. |
 extensions | array | Array containing information about one or more jsPsych extensions that are used during the experiment. Each extension should be specified as an object with `type` (required), which is the name of the extension, and `params` (optional), which is an object containing any parameter-value pairs to be passed to the extension's `initialize` function. Default value is an empty array. |
-| record_session             | boolean  | If `true`, jsPsych captures a high-fidelity recording of the session — DOM mutations within the display element, mouse/touch/keyboard/clipboard input, scroll position (window and per-element), video and audio playback events, viewport changes (including pinch zoom), and every `Math.random()` output — sufficient to reconstruct a replay of what the participant saw and did. The recording is retrieved at the end of the experiment via `jsPsych.getSessionRecording()` and can be `JSON.stringify`'d and saved alongside the trial data. While enabled, `Math.random` is wrapped to log every call into the recording; this is reverted when the experiment ends. The default value is `false`. **Note:** text typed into form inputs (e.g. survey responses) is captured verbatim. Inform participants accordingly. |
+| record_session             | boolean \| object | If `true`, jsPsych captures a high-fidelity recording of the session — DOM mutations within the display element, mouse/touch/keyboard/clipboard input, scroll position (window and per-element), video and audio playback events, viewport changes (including pinch zoom), and every `Math.random()` output — sufficient to reconstruct a replay of what the participant saw and did. The recording is retrieved at the end of the experiment via `jsPsych.getSessionRecording()` and can be `JSON.stringify`'d and saved alongside the trial data. While enabled, `Math.random` is wrapped to log every call into the recording; this is reverted when the experiment ends. The default value is `false`. Pass an object instead of `true` to opt out of categories or bound memory: `capture_inputs` (default `true`; set `false` for surveys whose responses must not be retained verbatim), `capture_canvas` (default `true`; set `false` to skip canvas pixel snapshots), `capture_random` (default `true`; set `false` when the RNG is called millions of times and reproducibility isn't needed), and `max_events` (default unlimited; when exceeded, recording stops with `end_reason: "memory_limit"`). **Note:** with `capture_inputs: true`, text typed into form inputs (e.g. survey responses) is captured verbatim. Inform participants accordingly. |
 
 ### Return value
 
diff --git a/packages/jspsych/src/JsPsych.ts b/packages/jspsych/src/JsPsych.ts
index 9139bf11c5..68cc06b3d5 100644
--- a/packages/jspsych/src/JsPsych.ts
+++ b/packages/jspsych/src/JsPsych.ts
@@ -9,7 +9,11 @@ import { JsPsychExtension } from "./modules/extensions";
 import { PluginAPI, createJointPluginAPIObject } from "./modules/plugin-api";
 import { JsPsychPlugin } from "./modules/plugins";
 import * as randomization from "./modules/randomization";
-import { SessionRecorder, SessionRecording } from "./modules/recording";
+import {
+  SessionRecorder,
+  SessionRecording,
+  resolveRecordSessionOptions,
+} from "./modules/recording";
 import * as turk from "./modules/turk";
 import * as utils from "./modules/utils";
 import { ProgressBar } from "./ProgressBar";
@@ -94,8 +98,9 @@ export class JsPsych {
     };
     this.options = options;
 
-    if (options.record_session) {
-      this.sessionRecorder = new SessionRecorder({ jspsychVersion: version });
+    const recordOptions = resolveRecordSessionOptions(options.record_session);
+    if (recordOptions) {
+      this.sessionRecorder = new SessionRecorder({ jspsychVersion: version, recordOptions });
     }
 
     autoBind(this); // so we can pass JsPsych methods as callbacks and `this` remains the JsPsych instance
@@ -237,44 +242,22 @@ export class JsPsych {
    * }
    * ```
    *
-   * @example Offer the participant a download:
-   * ```ts
-   * const blob = await jsPsych.getSessionRecordingCompressed();
-   * if (blob) {
-   *   const a = document.createElement("a");
-   *   a.href = URL.createObjectURL(blob);
-   *   a.download = "session.json.gz";
-   *   a.click();
-   *   URL.revokeObjectURL(a.href);
-   * }
-   * ```
-   *
-   * @example Stash in jsPsych's data record (base64-encoded):
-   * ```ts
-   * const blob = await jsPsych.getSessionRecordingCompressed();
-   * if (blob) {
-   *   const buf = new Uint8Array(await blob.arrayBuffer());
-   *   let binary = "";
-   *   for (const byte of buf) binary += String.fromCharCode(byte);
-   *   jsPsych.data.addProperties({ session_recording_b64: btoa(binary) });
-   * }
-   * ```
    */
   async getSessionRecordingCompressed(): Promise<Blob | undefined> {
     const recording = this.getSessionRecording();
     if (!recording) return undefined;
-    // Drive the compression stream directly via its writer/reader so the
-    // implementation depends only on `TextEncoder`, `CompressionStream`,
-    // and `Blob` — all available in evergreen browsers (Chrome 80,
-    // Firefox 113, Safari 16.4) and in Node 18+.
+    // Run the writer and reader sides of the gzip stream concurrently:
+    // for large recordings, awaiting the write before opening the
+    // reader would stall on backpressure, while not awaiting it at all
+    // means write/close errors surface as unhandled rejections. The
+    // pattern below propagates those errors into the returned promise.
     const json = JSON.stringify(recording);
     const cs = new CompressionStream("gzip");
     const writer = cs.writable.getWriter();
-    // Don't await the writer; the reader loop below pulls chunks out as
-    // the writer pushes them in. Awaiting first would deadlock on
-    // backpressure for large recordings.
-    writer.write(new TextEncoder().encode(json));
-    writer.close();
+    const writePromise = (async () => {
+      await writer.write(new TextEncoder().encode(json));
+      await writer.close();
+    })();
     const reader = cs.readable.getReader();
     const chunks: Uint8Array[] = [];
     for (;;) {
@@ -282,6 +265,7 @@ export class JsPsych {
       if (done) break;
       chunks.push(value);
     }
+    await writePromise;
     return new Blob(chunks, { type: "application/gzip" });
   }
 
diff --git a/packages/jspsych/src/index.ts b/packages/jspsych/src/index.ts
index 15e13fe7d5..f976430822 100755
--- a/packages/jspsych/src/index.ts
+++ b/packages/jspsych/src/index.ts
@@ -66,3 +66,22 @@ export type { JsPsychPlugin, PluginInfo, TrialType } from "./modules/plugins";
 export { ParameterType } from "./modules/plugins";
 export type { JsPsychExtension, JsPsychExtensionInfo } from "./modules/extensions";
 export { DataCollection } from "./modules/data/DataCollection";
+export type {
+  CanvasSnapshot,
+  ClipboardRecord,
+  DomMutation,
+  DomNode,
+  FocusRecord,
+  InputRecord,
+  MediaRecord,
+  RecordedEvent,
+  RecordSessionOptions,
+  RngCall,
+  ScrollRecord,
+  SessionRecording,
+  StylesheetEvent,
+  StylesheetSnapshot,
+  TrialRecording,
+  ViewportChange,
+  ViewportState,
+} from "./modules/recording";
diff --git a/packages/jspsych/src/modules/recording.ts b/packages/jspsych/src/modules/recording/SessionRecorder.ts
similarity index 55%
rename from packages/jspsych/src/modules/recording.ts
rename to packages/jspsych/src/modules/recording/SessionRecorder.ts
index 727c544cd6..d21e8fd1c1 100644
--- a/packages/jspsych/src/modules/recording.ts
+++ b/packages/jspsych/src/modules/recording/SessionRecorder.ts
@@ -1,263 +1,56 @@
-import * as randomization from "./randomization";
-
-// ---------------------------------------------------------------------------
-// Schema types (schema_version: 1)
-// ---------------------------------------------------------------------------
-
-export type JsonValue =
-  | null
-  | boolean
-  | number
-  | string
-  | JsonValue[]
-  | { [key: string]: JsonValue };
-
-export interface SessionRecording {
-  schema_version: 1;
-  jspsych_version: string;
-  recording_started_at: string;
-  recording_started_at_perf: number;
-  user_agent: string;
-  viewport: ViewportState;
-  rng: { seed: string | null; math_random_patched: boolean };
-  display_element_id: string;
-  stylesheets: StylesheetSnapshot[];
-  // Chronological log of `<head>` stylesheet mutations after `start()`.
-  // Initial state is in `stylesheets`; this records subsequent additions,
-  // removals, and `<style>` text edits so the replayer can apply them
-  // alongside the per-trial DOM event stream.
-  stylesheet_events: StylesheetEvent[];
-  trials: TrialRecording[];
-  viewport_changes: ViewportChange[];
-  // Chronological log of every Math.random output consumed during the
-  // session. Captured at session scope (rather than per-trial) so calls
-  // outside trial boundaries — pre-trial parameter evaluation, post-trial
-  // gaps, the experimenter's `on_finish` — are never dropped. A replayer
-  // consumes this list in order.
-  rng_calls: RngCall[];
-  ended_at_perf: number | null;
-  end_reason: "finished" | "aborted" | "unload" | null;
-}
-
-// A snapshot of one stylesheet attached to the document. `inline` covers
-// `<style>` tags; `link` covers `<link rel="stylesheet">`. `css` is the
-// resolved rule text where readable; cross-origin sheets throw SecurityError
-// on `cssRules` access, so for those we record `href` only and leave `css`
-// null so a replayer can fetch the source out-of-band. `id` is unique within
-// the session and shared with `stylesheet_events` so add/remove/update
-// events can reference snapshots created at start.
-export type StylesheetSnapshot =
-  | { id: number; kind: "inline"; css: string; media: string | null }
-  | { id: number; kind: "link"; href: string; css: string | null; media: string | null };
-
-// Session-scope log entries for `<head>` stylesheet changes after start.
-// `stylesheet.add` carries a full snapshot (with a newly-assigned `id`);
-// `stylesheet.remove` and `stylesheet.update` reference an existing `id`
-// from `stylesheets` or a prior `add` event.
-export type StylesheetEvent =
-  | { type: "stylesheet.add"; t: number; sheet: StylesheetSnapshot }
-  | { type: "stylesheet.remove"; t: number; id: number }
-  | { type: "stylesheet.update"; t: number; id: number; css: string };
-
-export interface ViewportState {
-  w: number;
-  h: number;
-  dpr: number;
-  scale: number;
-  offset_x: number;
-  offset_y: number;
-}
-
-export interface ViewportChange extends ViewportState {
-  t: number;
-}
-
-export interface TrialRecording {
-  trial_index: number;
-  t_start: number;
-  t_dom_ready: number | null;
-  t_end: number | null;
-  plugin: string;
-  initial_dom: DomNode | null;
-  events: RecordedEvent[];
-  trial_data: JsonValue;
-}
-
-export type DomNode = ElementNode | TextNode | CommentNode;
-
-export interface ElementNode {
-  id: number;
-  kind: "element";
-  tag: string;
-  attrs: Record<string, string>;
-  children: DomNode[];
-  canvas_size?: { w: number; h: number };
-  media_src?: string;
-}
-
-export interface TextNode {
-  id: number;
-  kind: "text";
-  text: string;
-}
-
-export interface CommentNode {
-  id: number;
-  kind: "comment";
-  text: string;
-}
-
-export type RecordedEvent =
-  | DomMutation
-  | InputRecord
-  | ClipboardRecord
-  | MediaRecord
-  | FocusRecord
-  | ScrollRecord
-  | CanvasSnapshot;
-
-export type DomMutation =
-  | { type: "dom.add"; t: number; parent: number; before: number | null; node: DomNode }
-  | { type: "dom.remove"; t: number; node: number }
-  | { type: "dom.attr"; t: number; node: number; name: string; value: string | null }
-  | { type: "dom.text"; t: number; node: number; text: string };
-
-export type InputRecord =
-  | { type: "mouse.move"; t: number; x: number; y: number }
-  | {
-      type: "mouse.down" | "mouse.up" | "mouse.click";
-      t: number;
-      x: number;
-      y: number;
-      button: number;
-      target: number | null;
-    }
-  | {
-      type: "touch.start" | "touch.move" | "touch.end";
-      t: number;
-      touches: { id: number; x: number; y: number }[];
-    }
-  | {
-      type: "key.down" | "key.up";
-      t: number;
-      key: string;
-      code: string;
-      mods: { ctrl: boolean; shift: boolean; alt: boolean; meta: boolean };
-      repeat: boolean;
-      target: number | null;
-    }
-  // Form-state changes. The MutationObserver only sees the `value` *attribute*,
-  // not the IDL property the browser writes when a participant types or
-  // toggles a control. These records carry the post-change value/checked/
-  // selection so a replayer can reconstitute survey responses without
-  // having to replay keystrokes through a live form.
-  | { type: "input.value"; t: number; node: number; value: string }
-  | { type: "input.checked"; t: number; node: number; checked: boolean }
-  | { type: "input.select"; t: number; node: number; values: string[] };
-
-export interface ClipboardRecord {
-  type: "clipboard.copy" | "clipboard.cut" | "clipboard.paste";
-  t: number;
-  text: string | null;
-  html: string | null;
-  target: number | null;
-}
-
-export type MediaRecord = {
-  type: "media.play" | "media.pause" | "media.ended" | "media.seeked" | "media.time";
-  t: number;
-  node: number;
-  current_time: number;
-};
-
-export interface FocusRecord {
-  type: "focus" | "blur" | "fullscreen.enter" | "fullscreen.exit";
-  t: number;
-}
-
-export type ScrollRecord =
-  | { type: "scroll.window"; t: number; x: number; y: number }
-  | { type: "scroll.element"; t: number; node: number; x: number; y: number };
-
-// Captures `<canvas>` pixel state as a PNG data URL. The MutationObserver
-// can't see drawing operations inside `<canvas>`; without these events a
-// replayer reconstructs the element but renders it blank, so anything the
-// participant drew (e.g. plugin-sketchpad strokes) would be invisible.
-// Emitted at trial load (initial baseline), gesture boundaries
-// (mouseup/touchend/pointerup) and trial end, with per-canvas throttling.
-//
-// `region` distinguishes a full-canvas baseline from an incremental patch:
-//   - omitted: `data_url` is the entire canvas, to be drawn at (0, 0)
-//     after clearing. The first snapshot per canvas is always full so
-//     subsequent partials have a baseline to layer on.
-//   - present: `data_url` is a cropped rectangle of the canvas's current
-//     state. The replayer composites it at (region.x, region.y) without
-//     touching the rest of the canvas.
-// The recorder emits a partial when the changed bounding box covers less
-// than ~80% of the canvas; otherwise it emits a full snapshot since the
-// per-pixel cost of compositing approaches a full re-render.
-export interface CanvasSnapshot {
-  type: "canvas.snapshot";
-  t: number;
-  node: number;
-  data_url: string;
-  region?: { x: number; y: number; w: number; h: number };
-}
-
-export interface RngCall {
-  t: number;
-  fn: string;
-  args: JsonValue;
-  result: JsonValue;
-}
-
-// ---------------------------------------------------------------------------
-// SessionRecorder
-// ---------------------------------------------------------------------------
-
-const SCHEMA_VERSION = 1;
-const VIEWPORT_DEBOUNCE_MS = 100;
-const MEDIA_TIME_THROTTLE_MS = 250;
-// Per-canvas minimum gap between gesture-driven snapshots. Bounds the
-// `toDataURL` cost for users who rapidly click/release; trial-end
-// captures bypass this so the final state always lands.
-const CANVAS_SNAPSHOT_MIN_INTERVAL_MS = 250;
-// When the changed bounding box covers more than this fraction of the
-// canvas, fall back to a full snapshot. Cropping a near-full region
-// pays the `getImageData` + `drawImage` + `toDataURL` cost of a full
-// snapshot anyway, so the partial-snapshot bookkeeping is wasted.
-const CANVAS_FULL_SNAPSHOT_AREA_FRACTION = 0.8;
-// Per-canvas minimum gap between draw-triggered animation snapshots.
-// Distinct from `CANVAS_SNAPSHOT_MIN_INTERVAL_MS`, which throttles the
-// gesture-driven path. ~15 Hz is enough fidelity for replaying typical
-// canvas animations without producing 60 PNGs/sec for a continuously-
-// repainting stimulus.
-const CANVAS_ANIMATION_MIN_INTERVAL_MS = 66;
-// Pixel-mutating methods on `CanvasRenderingContext2D`. Wrapping these
-// lets the recorder notice when a canvas was redrawn between gestures
-// (the original heuristic only snapshotted at mouseup/touchend), so
-// canvases driven by animation loops or non-gesture timers can still
-// be reconstructed in the replay. Path-state methods (beginPath,
-// moveTo, lineTo, …) are intentionally omitted: they don't change
-// pixels until `fill` or `stroke` is called.
-const CANVAS_DRAW_METHODS = [
-  "clearRect",
-  "fillRect",
-  "strokeRect",
-  "fill",
-  "stroke",
-  "fillText",
-  "strokeText",
-  "drawImage",
-  "putImageData",
-] as const;
+import {
+  CANVAS_ANIMATION_MIN_INTERVAL_MS,
+  CANVAS_FULL_SNAPSHOT_AREA_FRACTION,
+  CANVAS_SNAPSHOT_MIN_INTERVAL_MS,
+  CanvasState,
+  MEDIA_EVENTS,
+  MEDIA_TIME_THROTTLE_MS,
+  RNG_NO_ARGS,
+  SCHEMA_VERSION,
+  VIEWPORT_DEBOUNCE_MS,
+} from "./constants";
+import {
+  getReadable2dContext,
+  registerCanvasRecorder,
+  registerMathRandomRecorder,
+  unregisterCanvasRecorder,
+  unregisterMathRandomRecorder,
+} from "./global-patches";
+import {
+  computeDiffBbox,
+  cropCanvasToDataURL,
+  readMedia,
+  readSheetText,
+  readViewport,
+  serializeJson,
+} from "./helpers";
+import type { ResolvedRecordSessionOptions } from "./options";
+import type {
+  ClipboardRecord,
+  DomNode,
+  ElementNode,
+  FocusRecord,
+  MediaRecord,
+  RecordedEvent,
+  SessionRecording,
+  StylesheetSnapshot,
+  TrialRecording,
+  ViewportState,
+} from "./types";
 
 export interface SessionRecorderOptions {
   jspsychVersion: string;
+  recordOptions: ResolvedRecordSessionOptions;
 }
 
 export class SessionRecorder {
   private readonly jspsychVersion: string;
+  private readonly opts: ResolvedRecordSessionOptions;
+  // Total events recorded across all categories (per-trial events,
+  // rng_calls, viewport_changes, stylesheet_events). Compared against
+  // `opts.max_events` to enforce the heap bound.
+  private totalEventCount = 0;
+  private stopRequested = false;
   private recording: SessionRecording;
   private displayElement: HTMLElement | null = null;
   // Outermost layout root for the experiment. The spine in `initial_dom`
@@ -281,17 +74,19 @@ export class SessionRecorder {
   private styleNodeIds = new WeakMap<Node, number>();
   private nextStylesheetId = 1;
 
-  private mouseRafScheduled = false;
+  // RAF-coalesced flushers. Each entry is keyed by a channel name
+  // (mouse / scroll / input); presence of a key means a flush is
+  // already scheduled for that channel.
+  private rafScheduled = new Set<string>();
+
   private lastMouseX = 0;
   private lastMouseY = 0;
   private mouseDirty = false;
 
-  private scrollRafScheduled = false;
   // Pending scroll state to flush at next animation frame. Key "window"
   // refers to the document scroll; numeric keys are tracked node IDs.
   private pendingScroll: Map<number | "window", { x: number; y: number }> = new Map();
 
-  private inputRafScheduled = false;
   // Latest value-per-input collected within the current animation frame.
   // Coalesced so a fast typist produces one record per RAF rather than
   // one per keystroke (matching how mouse.move is throttled).
@@ -300,48 +95,21 @@ export class SessionRecorder {
   private viewportTimer: ReturnType<typeof setTimeout> | null = null;
   private lastViewport: ViewportState | null = null;
 
-  private mediaListeners = new WeakMap<HTMLMediaElement, (ev: Event) => void>();
+  // Tracked media elements with their attached listener. Strong refs so
+  // we can iterate at trial end to detach. `mediaTimeLast` is keyed by
+  // element for its `timeupdate`-throttle bookkeeping.
+  private mediaListeners = new Map<HTMLMediaElement, (ev: Event) => void>();
   private mediaTimeLast = new WeakMap<HTMLMediaElement, number>();
-  // Strong ref to currently tracked media elements so we can iterate and
-  // remove their listeners when the trial ends. Cleared on detach.
-  private mediaTrackedElements = new Set<HTMLMediaElement>();
-
-  // Strong ref to canvas elements within the current trial's display
-  // subtree. Used to drive deferred snapshotting after gestures and at
-  // trial end. Per-canvas throttle/dedupe state is held alongside.
-  private canvasTrackedElements = new Set<HTMLCanvasElement>();
-  private canvasLastSnapshot = new WeakMap<HTMLCanvasElement, string>();
-  private canvasLastSnapshotTime = new WeakMap<HTMLCanvasElement, number>();
-  private canvasSnapshotScheduled = false;
-  // Last full-canvas pixel buffer per tracked canvas, used to compute
-  // the bounding box of changed pixels so subsequent snapshots can ship
-  // only the dirty rectangle. Cleared on canvas removal and on trial
-  // teardown. Absent for canvases that don't expose a 2d context (e.g.
-  // WebGL) — those always emit full snapshots.
-  private canvasShadowData = new WeakMap<HTMLCanvasElement, ImageData>();
-  private canvasInitialSnapshotScheduled = false;
-  // Set to true by the patched 2d-context draw methods whenever a
-  // tracked canvas is mutated. The frame tick reads-and-clears it to
-  // decide which canvases need a fresh diff.
-  private canvasDirty = new WeakMap<HTMLCanvasElement, boolean>();
-  // Last time the draw-detection path emitted (or attempted to emit) a
-  // snapshot for each canvas. Drives `CANVAS_ANIMATION_MIN_INTERVAL_MS`
-  // throttling without conflicting with the gesture-path throttle in
-  // `canvasLastSnapshotTime`.
-  private canvasAnimationLastTime = new WeakMap<HTMLCanvasElement, number>();
+
+  // Per-canvas state: strong-ref Map (we explicitly delete entries on
+  // canvas removal and trial end) so iteration and lookup are one
+  // structure.
+  private canvasStates = new Map<HTMLCanvasElement, CanvasState>();
+  // True when an in-flight RAF-deferred sweep should bypass the per-
+  // canvas throttle. Set by initial-baseline schedules; gesture-driven
+  // schedules leave it alone.
+  private pendingCanvasSnapshotForce = false;
   private canvasFrameLoopScheduled = false;
-  // Patched draw methods on `CanvasRenderingContext2D.prototype`. We
-  // restore them on `stop()` so opting in to recording does not leave
-  // wrappers in place after the experiment ends, even if the recorder
-  // auto-stopped due to abort or unload.
-  private canvasContextPatched = false;
-  private originalCanvasMethods = new Map<string, Function>();
-
-  // Reference to whatever `Math.random` was immediately before the recorder
-  // started. Restored verbatim on stop so opting into recording does not
-  // permanently alter `Math.random`, even if we auto-seeded.
-  private originalMathRandom: () => number = Math.random;
-  private mathRandomPatched = false;
 
   private boundHandlers: Array<{
     target: EventTarget;
@@ -356,6 +124,7 @@ export class SessionRecorder {
 
   constructor(options: SessionRecorderOptions) {
     this.jspsychVersion = options.jspsychVersion;
+    this.opts = options.recordOptions;
     this.recording = this.createBlankRecording();
   }
 
@@ -411,20 +180,24 @@ export class SessionRecorder {
     this.nextStylesheetId = 1;
     this.recording.stylesheets = this.captureStylesheets();
     this.mouseDirty = false;
-    this.mouseRafScheduled = false;
-    this.scrollRafScheduled = false;
+    this.rafScheduled.clear();
     this.pendingScroll.clear();
-    this.inputRafScheduled = false;
     this.pendingInput.clear();
     this.canvasFrameLoopScheduled = false;
-    this.canvasInitialSnapshotScheduled = false;
-
-    this.patchMathRandom();
-    this.patchCanvasContext();
+    this.pendingCanvasSnapshotForce = false;
+    this.totalEventCount = 0;
+    this.stopRequested = false;
+
+    if (this.opts.capture_random) {
+      const seed = registerMathRandomRecorder(this);
+      if (seed !== null) this.recording.rng.seed = seed;
+      this.recording.rng.math_random_patched = true;
+    }
+    if (this.opts.capture_canvas) registerCanvasRecorder(this);
     this.attachSessionListeners();
   }
 
-  stop(reason: "finished" | "aborted" | "unload" = "finished") {
+  stop(reason: "finished" | "aborted" | "unload" | "memory_limit" = "finished") {
     // Idempotent: stopping an already-stopped recorder is a no-op.
     if (!this.running) return;
 
@@ -441,8 +214,8 @@ export class SessionRecorder {
 
     this.detachTrialListeners();
     this.detachSessionListeners();
-    this.unpatchMathRandom();
-    this.unpatchCanvasContext();
+    unregisterMathRandomRecorder(this);
+    unregisterCanvasRecorder(this);
     this.recording.ended_at_perf = this.t();
     this.recording.end_reason = reason;
     this.running = false;
@@ -475,12 +248,10 @@ export class SessionRecorder {
     this.currentTrial.initial_dom = this.serializeDisplaySpine(this.displayElement);
     this.attachTrialListeners();
     this.scanForMediaElements(this.displayElement);
-    // `scanForCanvasElements` registers each canvas via
-    // `trackCanvasElement`, which schedules the initial baseline
-    // snapshot for the next animation frame so synchronously-drawn
-    // stimuli (canvas-button-response, canvas-keyboard-response, ...)
-    // are captured before any interaction.
-    this.scanForCanvasElements(this.displayElement);
+    // Registers each canvas and schedules an initial baseline snapshot
+    // so synchronously-drawn stimuli (canvas-button-response,
+    // canvas-keyboard-response, …) are captured before any interaction.
+    if (this.opts.capture_canvas) this.scanForCanvasElements(this.displayElement);
   }
 
   onTrialFinish(trialData: unknown) {
@@ -498,14 +269,14 @@ export class SessionRecorder {
   // -------- session listeners (viewport, focus) --------
 
   private attachSessionListeners() {
-    this.bind(window, "resize", this.scheduleViewportRead);
+    this.bindSession(window, "resize", this.scheduleViewportRead);
     if (window.visualViewport) {
-      this.bind(window.visualViewport, "resize", this.scheduleViewportRead);
-      this.bind(window.visualViewport, "scroll", this.scheduleViewportRead);
+      this.bindSession(window.visualViewport, "resize", this.scheduleViewportRead);
+      this.bindSession(window.visualViewport, "scroll", this.scheduleViewportRead);
     }
-    this.bind(window, "focus", () => this.pushFocus("focus"));
-    this.bind(window, "blur", () => this.pushFocus("blur"));
-    this.bind(document, "fullscreenchange", () => {
+    this.bindSession(window, "focus", () => this.pushFocus("focus"));
+    this.bindSession(window, "blur", () => this.pushFocus("blur"));
+    this.bindSession(document, "fullscreenchange", () => {
       this.pushFocus(document.fullscreenElement ? "fullscreen.enter" : "fullscreen.exit");
     });
 
@@ -557,7 +328,9 @@ export class SessionRecorder {
         last.offset_y !== v.offset_y
       ) {
         this.lastViewport = v;
-        this.recording.viewport_changes.push({ t: this.t(), ...v });
+        if (this.checkEventBudget()) {
+          this.recording.viewport_changes.push({ t: this.t(), ...v });
+        }
       }
     }, VIEWPORT_DEBOUNCE_MS);
   };
@@ -596,19 +369,19 @@ export class SessionRecorder {
     // were silently dropped before. `targetId` may now resolve to
     // `null` when the target is outside the recorded display spine,
     // which the schema already permits.
-    this.bind(window, "mousemove", this.handleMouseMove, true);
-    this.bind(window, "mousedown", this.handleMouseButton("mouse.down"), true);
-    this.bind(window, "mouseup", this.handleMouseButton("mouse.up"), true);
-    this.bind(window, "click", this.handleMouseButton("mouse.click"), true);
-    this.bind(document, "touchstart", this.handleTouch("touch.start"), {
+    this.bindTrial(window, "mousemove", this.handleMouseMove, true);
+    this.bindTrial(window, "mousedown", this.handleMouseButton("mouse.down"), true);
+    this.bindTrial(window, "mouseup", this.handleMouseButton("mouse.up"), true);
+    this.bindTrial(window, "click", this.handleMouseButton("mouse.click"), true);
+    this.bindTrial(document, "touchstart", this.handleTouch("touch.start"), {
       passive: true,
       capture: true,
     });
-    this.bind(document, "touchmove", this.handleTouch("touch.move"), {
+    this.bindTrial(document, "touchmove", this.handleTouch("touch.move"), {
       passive: true,
       capture: true,
     });
-    this.bind(document, "touchend", this.handleTouch("touch.end"), {
+    this.bindTrial(document, "touchend", this.handleTouch("touch.end"), {
       passive: true,
       capture: true,
     });
@@ -616,21 +389,24 @@ export class SessionRecorder {
     // capture phase: they may be dispatched on any element (including
     // descendants of the body), and capture-phase listening ensures we see
     // them before any user-attached handler can call stopPropagation.
-    this.bind(document, "keydown", this.handleKey("key.down"), true);
-    this.bind(document, "keyup", this.handleKey("key.up"), true);
-    this.bind(document, "copy", this.handleClipboard("clipboard.copy"), true);
-    this.bind(document, "cut", this.handleClipboard("clipboard.cut"), true);
-    this.bind(document, "paste", this.handleClipboard("clipboard.paste"), true);
+    this.bindTrial(document, "keydown", this.handleKey("key.down"), true);
+    this.bindTrial(document, "keyup", this.handleKey("key.up"), true);
+    this.bindTrial(document, "copy", this.handleClipboard("clipboard.copy"), true);
+    this.bindTrial(document, "cut", this.handleClipboard("clipboard.cut"), true);
+    this.bindTrial(document, "paste", this.handleClipboard("clipboard.paste"), true);
     // Scroll events do not bubble, so capture-phase listening at document
     // scope catches scroll on any descendant element. Window scrolling is
     // handled by the same listener via a Document target check.
-    this.bind(document, "scroll", this.handleScroll, true);
+    this.bindTrial(document, "scroll", this.handleScroll, true);
     // Form-state events. `input` covers text fields, textareas, and
     // sliders (fires on every value change). `change` covers checkboxes,
     // radios, and selects (fires on commit). Capture phase at document
-    // scope so nothing in user code can stopPropagation past us.
-    this.bind(document, "input", this.handleInputEvent, true);
-    this.bind(document, "change", this.handleChangeEvent, true);
+    // scope so nothing in user code can stopPropagation past us. Gated
+    // by `capture_inputs` for surveys whose values must not be recorded.
+    if (this.opts.capture_inputs) {
+      this.bindTrial(document, "input", this.handleInputEvent, true);
+      this.bindTrial(document, "change", this.handleChangeEvent, true);
+    }
   }
 
   private detachTrialListeners() {
@@ -639,12 +415,10 @@ export class SessionRecorder {
       this.mutationObserver = null;
     }
     this.detachMediaListeners();
-    // WeakMap entries for the released canvases will be GC'd once the
-    // tracked-set strong refs drop here; explicit deletion happens in
-    // `releaseSubtree` for canvases removed mid-trial.
-    this.canvasTrackedElements.clear();
-    this.canvasSnapshotScheduled = false;
-    this.canvasInitialSnapshotScheduled = false;
+    // Strong refs drop here; explicit deletion happens in `releaseSubtree`
+    // for canvases removed mid-trial.
+    this.canvasStates.clear();
+    this.pendingCanvasSnapshotForce = false;
     // Tear down only the trial-scoped handlers; session-scoped handlers
     // (resize, focus, blur, fullscreenchange) stay attached until stop().
     const remaining: typeof this.boundHandlers = [];
@@ -682,8 +456,10 @@ export class SessionRecorder {
             this.pushEvent({ type: "dom.add", t, parent: parentId, before, node });
             if (added instanceof HTMLMediaElement) this.attachMediaListeners(added);
             else if (added instanceof Element) this.scanForMediaElements(added);
-            if (added instanceof HTMLCanvasElement) this.trackCanvasElement(added);
-            else if (added instanceof Element) this.scanForCanvasElements(added);
+            if (this.opts.capture_canvas) {
+              if (added instanceof HTMLCanvasElement) this.trackCanvasElement(added);
+              else if (added instanceof Element) this.scanForCanvasElements(added);
+            }
           }
         } else if (r.type === "attributes") {
           const id = this.nodeIds.get(r.target);
@@ -719,14 +495,13 @@ export class SessionRecorder {
   }
 
   private releaseSubtree(node: Node) {
-    if (node instanceof HTMLCanvasElement && this.canvasTrackedElements.has(node)) {
+    if (node instanceof HTMLCanvasElement && this.canvasStates.has(node)) {
       // jsPsych core clears the display element via `innerHTML = ""`
       // immediately after each trial, before `onTrialFinish` fires. Take
       // a final snapshot here so the canvas's last pixel state is in the
       // recording instead of being silently dropped on removal.
       this.snapshotCanvas(node, this.t(), true);
-      this.canvasTrackedElements.delete(node);
-      this.canvasShadowData.delete(node);
+      this.canvasStates.delete(node);
     }
     if (this.nodeIds.has(node)) {
       this.nodeIds.delete(node);
@@ -929,7 +704,9 @@ export class SessionRecorder {
             const id = this.styleNodeIds.get(removed);
             if (id === undefined) continue;
             this.styleNodeIds.delete(removed);
-            this.recording.stylesheet_events.push({ type: "stylesheet.remove", t, id });
+            if (this.checkEventBudget()) {
+              this.recording.stylesheet_events.push({ type: "stylesheet.remove", t, id });
+            }
           }
           for (const added of Array.from(r.addedNodes)) {
             if (!(added instanceof HTMLStyleElement) && !(added instanceof HTMLLinkElement)) {
@@ -937,8 +714,9 @@ export class SessionRecorder {
             }
             if (this.styleNodeIds.has(added)) continue;
             const snap = this.snapshotStylesheetElement(added as HTMLElement);
-            if (snap)
+            if (snap && this.checkEventBudget()) {
               this.recording.stylesheet_events.push({ type: "stylesheet.add", t, sheet: snap });
+            }
           }
         } else if (r.type === "characterData") {
           // Direct edit to the text node inside a <style> (e.g. via
@@ -959,6 +737,7 @@ export class SessionRecorder {
     for (const el of updated) {
       const id = this.styleNodeIds.get(el);
       if (id === undefined) continue;
+      if (!this.checkEventBudget()) break;
       this.recording.stylesheet_events.push({
         type: "stylesheet.update",
         t,
@@ -984,21 +763,27 @@ export class SessionRecorder {
 
   // -------- input handlers --------
 
+  // Coalesces a flush of `key`'s pending state to the next animation
+  // frame. Repeated calls before the frame fires are no-ops, so a
+  // burst of input events produces one flush instead of many.
+  private scheduleRafFlush(key: string, flush: () => void) {
+    if (this.rafScheduled.has(key)) return;
+    this.rafScheduled.add(key);
+    requestAnimationFrame(() => {
+      this.rafScheduled.delete(key);
+      flush();
+    });
+  }
+
   private handleMouseMove = (ev: Event) => {
     const e = ev as MouseEvent;
     this.lastMouseX = e.clientX;
     this.lastMouseY = e.clientY;
     this.mouseDirty = true;
-    if (!this.mouseRafScheduled) {
-      this.mouseRafScheduled = true;
-      requestAnimationFrame(() => {
-        this.mouseRafScheduled = false;
-        this.flushPendingMouse();
-      });
-    }
+    this.scheduleRafFlush("mouse", this.flushPendingMouse);
   };
 
-  private flushPendingMouse() {
+  private flushPendingMouse = () => {
     if (!this.mouseDirty) return;
     this.mouseDirty = false;
     this.pushEvent({
@@ -1007,15 +792,12 @@ export class SessionRecorder {
       x: this.lastMouseX,
       y: this.lastMouseY,
     });
-  }
+  };
 
   private handleScroll = (ev: Event) => {
     const target = ev.target;
     if (target === document || target === document.documentElement || target === document.body) {
-      this.pendingScroll.set("window", {
-        x: window.scrollX,
-        y: window.scrollY,
-      });
+      this.pendingScroll.set("window", { x: window.scrollX, y: window.scrollY });
     } else if (target instanceof Element) {
       const id = this.nodeIds.get(target);
       if (id === undefined) return;
@@ -1023,13 +805,7 @@ export class SessionRecorder {
     } else {
       return;
     }
-    if (!this.scrollRafScheduled) {
-      this.scrollRafScheduled = true;
-      requestAnimationFrame(() => {
-        this.scrollRafScheduled = false;
-        this.flushPendingScroll();
-      });
-    }
+    this.scheduleRafFlush("scroll", this.flushPendingScroll);
   };
 
   // `input` events come from text-like form fields, textareas, and sliders.
@@ -1050,23 +826,17 @@ export class SessionRecorder {
     const id = this.nodeIds.get(target);
     if (id === undefined) return;
     this.pendingInput.set(id, target.value);
-    if (!this.inputRafScheduled) {
-      this.inputRafScheduled = true;
-      requestAnimationFrame(() => {
-        this.inputRafScheduled = false;
-        this.flushPendingInput();
-      });
-    }
+    this.scheduleRafFlush("input", this.flushPendingInput);
   };
 
-  private flushPendingInput() {
+  private flushPendingInput = () => {
     if (this.pendingInput.size === 0) return;
     const t = this.t();
     for (const [node, value] of this.pendingInput) {
       this.pushEvent({ type: "input.value", t, node, value });
     }
     this.pendingInput.clear();
-  }
+  };
 
   private handleChangeEvent = (ev: Event) => {
     const target = ev.target;
@@ -1087,7 +857,7 @@ export class SessionRecorder {
     }
   };
 
-  private flushPendingScroll() {
+  private flushPendingScroll = () => {
     if (this.pendingScroll.size === 0) return;
     const t = this.t();
     for (const [key, pos] of this.pendingScroll) {
@@ -1098,7 +868,7 @@ export class SessionRecorder {
       }
     }
     this.pendingScroll.clear();
-  }
+  };
 
   private handleMouseButton(type: "mouse.down" | "mouse.up" | "mouse.click") {
     return (ev: Event) => {
@@ -1113,7 +883,7 @@ export class SessionRecorder {
       });
       // Gesture release is the moment a stroke completes; snapshot any
       // tracked canvases so the drawing it produced reaches the replay.
-      if (type === "mouse.up") this.scheduleCanvasSnapshot();
+      if (type === "mouse.up") this.scheduleCanvasSnapshot(false);
     };
   }
 
@@ -1126,7 +896,7 @@ export class SessionRecorder {
         y: tt.clientY,
       }));
       this.pushEvent({ type, t: this.t(), touches });
-      if (type === "touch.end") this.scheduleCanvasSnapshot();
+      if (type === "touch.end") this.scheduleCanvasSnapshot(false);
     };
   }
 
@@ -1207,27 +977,15 @@ export class SessionRecorder {
       }
       this.pushEvent({ type, t: this.t(), node: id, current_time: media.currentTime });
     };
-    media.addEventListener("play", handler);
-    media.addEventListener("pause", handler);
-    media.addEventListener("ended", handler);
-    media.addEventListener("seeked", handler);
-    media.addEventListener("timeupdate", handler);
-    this.mediaTrackedElements.add(media);
+    for (const ev of MEDIA_EVENTS) media.addEventListener(ev, handler);
     this.mediaListeners.set(media, handler);
   }
 
   private detachMediaListeners() {
-    for (const media of this.mediaTrackedElements) {
-      const handler = this.mediaListeners.get(media);
-      if (!handler) continue;
-      media.removeEventListener("play", handler);
-      media.removeEventListener("pause", handler);
-      media.removeEventListener("ended", handler);
-      media.removeEventListener("seeked", handler);
-      media.removeEventListener("timeupdate", handler);
-      this.mediaListeners.delete(media);
+    for (const [media, handler] of this.mediaListeners) {
+      for (const ev of MEDIA_EVENTS) media.removeEventListener(ev, handler);
     }
-    this.mediaTrackedElements.clear();
+    this.mediaListeners.clear();
   }
 
   // -------- canvas snapshotting --------
@@ -1247,57 +1005,25 @@ export class SessionRecorder {
   }
 
   private trackCanvasElement(canvas: HTMLCanvasElement) {
-    this.canvasTrackedElements.add(canvas);
-    // Schedule an initial baseline snapshot. For canvases discovered at
-    // `onTrialLoad` this catches the post-render state of plugins that
-    // draw their stimulus synchronously. For canvases added mid-trial
-    // via the MutationObserver path this gives the same coverage. The
-    // diff path skips re-snapshotting canvases that are already
-    // baselined, so calling this for every added canvas is cheap.
-    this.scheduleInitialCanvasSnapshot();
+    if (!this.canvasStates.has(canvas)) this.canvasStates.set(canvas, {});
+    // Force a baseline snapshot to capture synchronously-drawn stimuli
+    // even if a gesture immediately preceded the trial. The diff path
+    // dedupes already-baselined canvases, so this is cheap.
+    this.scheduleCanvasSnapshot(true);
   }
 
-  // Wraps the pixel-mutating methods on `CanvasRenderingContext2D`
-  // so the recorder is notified whenever a tracked canvas is drawn to.
-  // The wrapper sets a per-canvas dirty flag and schedules a frame
-  // tick; the original method is then called with the original `this`
-  // and arguments so the wrap is invisible to plugin code. Idempotent
-  // and per-instance: the originals captured here are restored on
-  // `stop()`, even across nested recorder lifetimes.
-  private patchCanvasContext() {
-    if (this.canvasContextPatched) return;
-    if (typeof CanvasRenderingContext2D === "undefined") return;
-    const proto = CanvasRenderingContext2D.prototype as unknown as Record<string, Function>;
-    const recorder = this;
-    for (const method of CANVAS_DRAW_METHODS) {
-      const original = proto[method];
-      if (typeof original !== "function") continue;
-      this.originalCanvasMethods.set(method, original);
-      proto[method] = function (this: CanvasRenderingContext2D, ...args: unknown[]) {
-        try {
-          const canvas = this.canvas as HTMLCanvasElement | undefined;
-          if (canvas && recorder.canvasTrackedElements.has(canvas)) {
-            recorder.canvasDirty.set(canvas, true);
-            recorder.scheduleCanvasFrameTick();
-          }
-        } catch {
-          // Tracking must never break the experiment's own drawing.
-        }
-        return (original as Function).apply(this, args);
-      };
-    }
-    this.canvasContextPatched = true;
-  }
-
-  private unpatchCanvasContext() {
-    if (!this.canvasContextPatched) return;
-    if (typeof CanvasRenderingContext2D === "undefined") return;
-    const proto = CanvasRenderingContext2D.prototype as unknown as Record<string, Function>;
-    for (const [method, original] of this.originalCanvasMethods) {
-      proto[method] = original;
-    }
-    this.originalCanvasMethods.clear();
-    this.canvasContextPatched = false;
+  /** @internal Called from the shared draw-method wrapper. */
+  notifyCanvasDraw(canvas: HTMLCanvasElement) {
+    const state = this.canvasStates.get(canvas);
+    if (!state) return;
+    // Already-dirty short-circuit: a stroke composed of many draw calls
+    // (lineTo + stroke + lineTo + stroke ...) within a frame would
+    // otherwise re-write the same `true` and re-check the schedule
+    // flag tens of times per frame. Once dirty, nothing else needs
+    // doing until the frame tick clears the flag.
+    if (state.dirty) return;
+    state.dirty = true;
+    this.scheduleCanvasFrameTick();
   }
 
   // Coalesces draw notifications into a single per-frame tick. Multiple
@@ -1316,16 +1042,16 @@ export class SessionRecorder {
     this.canvasFrameLoopScheduled = false;
     if (!this.running) return;
     const t = this.t();
-    for (const canvas of this.canvasTrackedElements) {
-      if (!this.canvasDirty.get(canvas)) continue;
-      const last = this.canvasAnimationLastTime.get(canvas) ?? -Infinity;
+    for (const [canvas, state] of this.canvasStates) {
+      if (!state.dirty) continue;
+      const last = state.animationLastTime ?? -Infinity;
       // Skip without clearing the dirty flag: the next draw call will
       // re-schedule a tick, by which time the throttle window has
       // likely elapsed. If draws stop while throttled, the trial-end
       // `releaseSubtree` snapshot will catch the final pixels.
       if (t - last < CANVAS_ANIMATION_MIN_INTERVAL_MS) continue;
-      this.canvasAnimationLastTime.set(canvas, t);
-      this.canvasDirty.set(canvas, false);
+      state.animationLastTime = t;
+      state.dirty = false;
       // `force = true` bypasses the gesture-path 250 ms throttle. The
       // animation throttle above already bounds frequency from this
       // path; the diff inside `snapshotCanvas` then dedupes byte-
@@ -1334,33 +1060,19 @@ export class SessionRecorder {
     }
   };
 
-  // Defers an unconditional snapshot to the next animation frame so we
-  // wait for any synchronous drawing during plugin setup (or during
-  // user `on_load`) to commit. Distinct from `scheduleCanvasSnapshot`,
-  // which respects the per-canvas throttle: initial baselines must not
-  // be throttled out by an immediately preceding gesture.
-  private scheduleInitialCanvasSnapshot() {
-    if (this.canvasInitialSnapshotScheduled) return;
-    if (this.canvasTrackedElements.size === 0) return;
-    this.canvasInitialSnapshotScheduled = true;
-    requestAnimationFrame(() => {
-      this.canvasInitialSnapshotScheduled = false;
-      this.captureCanvasSnapshots(true);
-    });
-  }
-
-  // Defers actual snapshotting to the next animation frame so we wait
-  // until the page has had a chance to paint the post-gesture state
-  // (otherwise `toDataURL` could return the canvas as it was *before*
-  // the up event's listeners ran). Coalesced via a single scheduled flag
-  // so a flurry of mouseups doesn't queue redundant work.
-  private scheduleCanvasSnapshot() {
-    if (this.canvasSnapshotScheduled) return;
-    if (this.canvasTrackedElements.size === 0) return;
-    this.canvasSnapshotScheduled = true;
-    requestAnimationFrame(() => {
-      this.canvasSnapshotScheduled = false;
-      this.captureCanvasSnapshots(false);
+  // Defers a canvas-snapshot sweep to the next animation frame so the
+  // browser has had a chance to paint the post-gesture state. `force`
+  // bypasses the per-canvas throttle (used for initial baselines that
+  // must not be throttled out by an immediately preceding gesture).
+  // If both forced and unforced are scheduled in the same frame the
+  // forced wins, since it's a strict superset of the unforced sweep.
+  private scheduleCanvasSnapshot(force: boolean) {
+    if (this.canvasStates.size === 0) return;
+    if (force) this.pendingCanvasSnapshotForce = true;
+    this.scheduleRafFlush("canvas-snapshot", () => {
+      const f = this.pendingCanvasSnapshotForce;
+      this.pendingCanvasSnapshotForce = false;
+      this.captureCanvasSnapshots(f);
     });
   }
 
@@ -1370,9 +1082,9 @@ export class SessionRecorder {
   // `force` bypasses the throttle for trial-end captures so the final
   // state of every canvas is always recorded.
   private captureCanvasSnapshots(force: boolean) {
-    if (this.canvasTrackedElements.size === 0) return;
+    if (this.canvasStates.size === 0) return;
     const now = this.t();
-    for (const canvas of this.canvasTrackedElements) {
+    for (const canvas of this.canvasStates.keys()) {
       this.snapshotCanvas(canvas, now, force);
     }
   }
@@ -1391,16 +1103,17 @@ export class SessionRecorder {
   private snapshotCanvas(canvas: HTMLCanvasElement, t: number, force: boolean) {
     const id = this.nodeIds.get(canvas);
     if (id === undefined) return;
-    if (!force) {
-      const last = this.canvasLastSnapshotTime.get(canvas) ?? -Infinity;
-      if (t - last < CANVAS_SNAPSHOT_MIN_INTERVAL_MS) return;
+    const state = this.canvasStates.get(canvas);
+    if (!state) return;
+    if (!force && t - (state.lastSnapshotTime ?? -Infinity) < CANVAS_SNAPSHOT_MIN_INTERVAL_MS) {
+      return;
     }
     const w = canvas.width;
     const h = canvas.height;
     if (w === 0 || h === 0) return;
     try {
       const ctx = getReadable2dContext(canvas);
-      const shadow = this.canvasShadowData.get(canvas);
+      const shadow = state.shadowData;
       const shadowValid = !!shadow && shadow.width === w && shadow.height === h;
 
       // Without a readable 2d context (WebGL canvases, or 2d contexts
@@ -1408,7 +1121,7 @@ export class SessionRecorder {
       // we can't diff. Emit a full snapshot via toDataURL and skip
       // shadow tracking for this canvas.
       if (!ctx) {
-        this.emitFullCanvasSnapshot(canvas, id, t);
+        this.emitFullCanvasSnapshot(canvas, state, id, t);
         return;
       }
 
@@ -1416,9 +1129,8 @@ export class SessionRecorder {
       // Capture the current pixels into the shadow buffer and emit a
       // full snapshot so the replayer has a starting point.
       if (!shadowValid) {
-        const current = ctx.getImageData(0, 0, w, h);
-        this.canvasShadowData.set(canvas, current);
-        this.emitFullCanvasSnapshot(canvas, id, t);
+        state.shadowData = ctx.getImageData(0, 0, w, h);
+        this.emitFullCanvasSnapshot(canvas, state, id, t);
         return;
       }
 
@@ -1429,14 +1141,14 @@ export class SessionRecorder {
 
       const fullThreshold = w * h * CANVAS_FULL_SNAPSHOT_AREA_FRACTION;
       if (bbox.w * bbox.h >= fullThreshold) {
-        this.canvasShadowData.set(canvas, current);
-        this.emitFullCanvasSnapshot(canvas, id, t);
+        state.shadowData = current;
+        this.emitFullCanvasSnapshot(canvas, state, id, t);
         return;
       }
 
       const dataUrl = cropCanvasToDataURL(canvas, bbox);
-      this.canvasShadowData.set(canvas, current);
-      this.canvasLastSnapshotTime.set(canvas, t);
+      state.shadowData = current;
+      state.lastSnapshotTime = t;
       this.pushEvent({
         type: "canvas.snapshot",
         t,
@@ -1451,255 +1163,78 @@ export class SessionRecorder {
     }
   }
 
-  // Emits a full-canvas snapshot, applying the same data-URL dedupe the
-  // pre-diff implementation used. Useful for first captures, near-full
-  // dirty regions, and canvases without a readable 2d context.
-  private emitFullCanvasSnapshot(canvas: HTMLCanvasElement, id: number, t: number) {
+  private emitFullCanvasSnapshot(
+    canvas: HTMLCanvasElement,
+    state: CanvasState,
+    id: number,
+    t: number
+  ) {
     const dataUrl = canvas.toDataURL();
-    if (this.canvasLastSnapshot.get(canvas) === dataUrl) return;
-    this.canvasLastSnapshot.set(canvas, dataUrl);
-    this.canvasLastSnapshotTime.set(canvas, t);
+    if (state.lastSnapshot === dataUrl) return;
+    state.lastSnapshot = dataUrl;
+    state.lastSnapshotTime = t;
     this.pushEvent({ type: "canvas.snapshot", t, node: id, data_url: dataUrl });
   }
 
   // -------- RNG --------
 
-  private isNativeMathRandom(fn: typeof Math.random) {
-    // Native built-ins stringify with the [native code] sentinel; any
-    // user-installed PRNG (e.g. via jsPsych.randomization.setSeed) will
-    // serialize as JS source instead.
-    return /\{\s*\[native code\]\s*\}/.test(Function.prototype.toString.call(fn));
-  }
-
-  private patchMathRandom() {
-    if (this.mathRandomPatched) return;
-    // Capture the *true* pre-recording Math.random before any potential
-    // auto-seeding so `stop()` can restore exactly what was there.
-    this.originalMathRandom = Math.random;
-
-    // Only auto-seed when Math.random is the native function; if the user
-    // already installed a seeded PRNG, leave it alone.
-    if (this.recording.rng.seed === null && this.isNativeMathRandom(this.originalMathRandom)) {
-      this.recording.rng.seed = randomization.setSeed();
-    }
-
-    const upstream = Math.random.bind(Math);
-    Math.random = () => {
-      const v = upstream();
-      // Captured at session scope: includes calls during pre-trial
-      // parameter evaluation, post-trial gaps, and the experimenter's
-      // `on_finish` — none of which are bracketed by a current trial.
-      this.recording.rng_calls.push({ t: this.t(), fn: "Math.random", args: [], result: v });
-      return v;
-    };
-    this.mathRandomPatched = true;
-    this.recording.rng.math_random_patched = true;
-  }
-
-  private unpatchMathRandom() {
-    if (!this.mathRandomPatched) return;
-    Math.random = this.originalMathRandom;
-    this.mathRandomPatched = false;
+  /** @internal Called from the shared `Math.random` wrapper. */
+  recordRngCall(value: number) {
+    if (!this.checkEventBudget()) return;
+    this.recording.rng_calls.push({
+      t: this.t(),
+      fn: "Math.random",
+      args: RNG_NO_ARGS,
+      result: value,
+    });
   }
 
   // -------- helpers --------
 
-  private bind(
+  private bindSession(
     target: EventTarget,
     type: string,
     handler: EventListenerOrEventListenerObject,
     options?: AddEventListenerOptions | boolean
   ) {
     target.addEventListener(type, handler, options);
-    // Trial-scoped binds happen while `mutationObserver` is set (i.e. inside
-    // `attachTrialListeners`); session-scoped binds happen when it is not.
-    const trial = this.mutationObserver !== null;
-    this.boundHandlers.push({ target, type, handler, options, trial });
+    this.boundHandlers.push({ target, type, handler, options, trial: false });
   }
 
-  private pushEvent(ev: RecordedEvent) {
-    if (this.currentTrial) this.currentTrial.events.push(ev);
-  }
-
-  private t(): number {
-    return performance.now() - this.startPerf;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-// Reads the `media` attribute, preferring the parsed value on the
-// CSSStyleSheet (which normalizes whitespace/casing) and falling back to
-// the raw attribute on the owning element.
-function readMedia(el: HTMLElement, sheet: CSSStyleSheet | null): string | null {
-  const fromSheet = sheet?.media?.mediaText;
-  if (fromSheet) return fromSheet;
-  const attr = el.getAttribute("media");
-  return attr && attr.length > 0 ? attr : null;
-}
-
-// Reads the resolved CSS rule text from a stylesheet. Returns null when
-// `cssRules` is unreadable (cross-origin sheets without CORS access throw
-// SecurityError) so callers can record only the href in that case.
-function readSheetText(sheet: CSSStyleSheet): string | null {
-  try {
-    const rules = sheet.cssRules;
-    if (!rules) return null;
-    const parts: string[] = [];
-    for (let i = 0; i < rules.length; i++) {
-      parts.push(rules[i].cssText);
-    }
-    return parts.join("\n");
-  } catch {
-    return null;
-  }
-}
-
-// Returns the canvas's 2d rendering context if one exists and is
-// readable (i.e. `getImageData` is callable). WebGL canvases return
-// null here so the caller falls back to full-canvas `toDataURL`
-// snapshots.
-function getReadable2dContext(canvas: HTMLCanvasElement): CanvasRenderingContext2D | null {
-  try {
-    const ctx = canvas.getContext("2d");
-    return ctx ?? null;
-  } catch {
-    return null;
+  private bindTrial(
+    target: EventTarget,
+    type: string,
+    handler: EventListenerOrEventListenerObject,
+    options?: AddEventListenerOptions | boolean
+  ) {
+    target.addEventListener(type, handler, options);
+    this.boundHandlers.push({ target, type, handler, options, trial: true });
   }
-}
 
-// Finds the bounding box of pixels that differ between two same-size
-// ImageData buffers. Uses an edge-shrink walk: scan top-down for the
-// first dirty row, bottom-up for the last, then within that row band
-// scan inward from each side for the first dirty column. For typical
-// incremental drawing (a stroke, a localized clear) this terminates
-// after only a few thousand pixel comparisons even on a multi-megapixel
-// canvas. Returns null when the buffers are byte-identical.
-//
-// Exported for unit testing; a replayer doesn't need it.
-export function computeDiffBbox(
-  prev: Uint8ClampedArray,
-  curr: Uint8ClampedArray,
-  w: number,
-  h: number
-): { x: number; y: number; w: number; h: number } | null {
-  let top = -1;
-  for (let y = 0; y < h; y++) {
-    const rowStart = y * w * 4;
-    const rowEnd = rowStart + w * 4;
-    for (let i = rowStart; i < rowEnd; i++) {
-      if (prev[i] !== curr[i]) {
-        top = y;
-        break;
-      }
-    }
-    if (top !== -1) break;
-  }
-  if (top === -1) return null;
-
-  let bottom = top;
-  for (let y = h - 1; y > top; y--) {
-    const rowStart = y * w * 4;
-    const rowEnd = rowStart + w * 4;
-    let dirty = false;
-    for (let i = rowStart; i < rowEnd; i++) {
-      if (prev[i] !== curr[i]) {
-        dirty = true;
-        break;
-      }
-    }
-    if (dirty) {
-      bottom = y;
-      break;
-    }
+  private pushEvent(ev: RecordedEvent) {
+    if (!this.currentTrial) return;
+    if (!this.checkEventBudget()) return;
+    this.currentTrial.events.push(ev);
   }
 
-  let left = w - 1;
-  let right = 0;
-  for (let y = top; y <= bottom; y++) {
-    const rowStart = y * w * 4;
-    // Scan inward from the left up to the current `left` candidate.
-    for (let x = 0; x < left; x++) {
-      const i = rowStart + x * 4;
-      if (
-        prev[i] !== curr[i] ||
-        prev[i + 1] !== curr[i + 1] ||
-        prev[i + 2] !== curr[i + 2] ||
-        prev[i + 3] !== curr[i + 3]
-      ) {
-        left = x;
-        break;
-      }
-    }
-    // Scan inward from the right past the current `right` candidate.
-    for (let x = w - 1; x > right; x--) {
-      const i = rowStart + x * 4;
-      if (
-        prev[i] !== curr[i] ||
-        prev[i + 1] !== curr[i + 1] ||
-        prev[i + 2] !== curr[i + 2] ||
-        prev[i + 3] !== curr[i + 3]
-      ) {
-        right = x;
-        break;
+  // Increments the session-wide event counter and triggers a memory-
+  // limit shutdown when the cap is exceeded. Returns false if the
+  // caller should drop the event. Defers the actual `stop()` to a
+  // microtask so any in-flight synchronous batch (mutation observer
+  // burst, etc.) can complete cleanly.
+  private checkEventBudget(): boolean {
+    if (this.totalEventCount >= this.opts.max_events) {
+      if (!this.stopRequested) {
+        this.stopRequested = true;
+        queueMicrotask(() => this.stop("memory_limit"));
       }
+      return false;
     }
-    if (left === 0 && right === w - 1) break;
+    this.totalEventCount++;
+    return true;
   }
 
-  return { x: left, y: top, w: right - left + 1, h: bottom - top + 1 };
-}
-
-// Copies a rectangular region out of a source canvas into a temporary
-// canvas and returns its data URL. The temporary canvas is sized to
-// the region so the resulting PNG carries only the dirty pixels.
-function cropCanvasToDataURL(
-  source: HTMLCanvasElement,
-  region: { x: number; y: number; w: number; h: number }
-): string {
-  const tmp = document.createElement("canvas");
-  tmp.width = region.w;
-  tmp.height = region.h;
-  const tctx = tmp.getContext("2d");
-  if (!tctx) return source.toDataURL();
-  tctx.drawImage(source, region.x, region.y, region.w, region.h, 0, 0, region.w, region.h);
-  return tmp.toDataURL();
-}
-
-function readViewport(): ViewportState {
-  const vv = window.visualViewport;
-  return {
-    w: window.innerWidth,
-    h: window.innerHeight,
-    dpr: window.devicePixelRatio || 1,
-    scale: vv?.scale ?? 1,
-    offset_x: vv?.offsetLeft ?? 0,
-    offset_y: vv?.offsetTop ?? 0,
-  };
-}
-
-/**
- * JSON-safe serialization for `trial_data` (the per-trial data row). Drops
- * functions and DOM nodes — the recording's visual fidelity comes from DOM
- * mutations, not from re-executing trial parameters.
- */
-export function serializeJson(value: unknown, seen = new WeakSet<object>()): JsonValue {
-  if (value === null || value === undefined) return null;
-  const t = typeof value;
-  if (t === "boolean" || t === "string") return value as JsonValue;
-  if (t === "number") return Number.isFinite(value as number) ? (value as number) : null;
-  if (t === "function") return null;
-  if (t !== "object") return null;
-  if (seen.has(value as object)) return null;
-  seen.add(value as object);
-  if (Array.isArray(value)) return value.map((v) => serializeJson(v, seen));
-  if (value instanceof Date) return value.toISOString();
-  if (value instanceof Element || value instanceof Node) return null;
-  const out: Record<string, JsonValue> = {};
-  for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
-    out[k] = serializeJson(v, seen);
+  private t(): number {
+    return performance.now() - this.startPerf;
   }
-  return out;
 }
diff --git a/packages/jspsych/src/modules/recording/constants.ts b/packages/jspsych/src/modules/recording/constants.ts
new file mode 100644
index 0000000000..43eef8d58d
--- /dev/null
+++ b/packages/jspsych/src/modules/recording/constants.ts
@@ -0,0 +1,69 @@
+import type { JsonValue } from "./types";
+
+export const SCHEMA_VERSION = 1;
+export const VIEWPORT_DEBOUNCE_MS = 100;
+export const MEDIA_TIME_THROTTLE_MS = 250;
+
+// Hoisted to avoid allocating a fresh empty array on every Math.random
+// call; the rng_calls log can grow into the millions for a long
+// randomization-heavy session.
+export const RNG_NO_ARGS: JsonValue[] = [];
+
+// Events listened on `<video>` / `<audio>` while a trial is active.
+// Listed once so attach/detach iterate the same set without drift.
+export const MEDIA_EVENTS = ["play", "pause", "ended", "seeked", "timeupdate"] as const;
+
+// Per-canvas minimum gap between gesture-driven snapshots. Bounds the
+// `toDataURL` cost for users who rapidly click/release; trial-end
+// captures bypass this so the final state always lands.
+export const CANVAS_SNAPSHOT_MIN_INTERVAL_MS = 250;
+
+// When the changed bounding box covers more than this fraction of the
+// canvas, fall back to a full snapshot. Cropping a near-full region
+// pays the `getImageData` + `drawImage` + `toDataURL` cost of a full
+// snapshot anyway, so the partial-snapshot bookkeeping is wasted.
+export const CANVAS_FULL_SNAPSHOT_AREA_FRACTION = 0.8;
+
+// Per-canvas minimum gap between draw-triggered animation snapshots.
+// Distinct from `CANVAS_SNAPSHOT_MIN_INTERVAL_MS`, which throttles the
+// gesture-driven path. ~15 Hz is enough fidelity for replaying typical
+// canvas animations without producing 60 PNGs/sec for a continuously-
+// repainting stimulus.
+export const CANVAS_ANIMATION_MIN_INTERVAL_MS = 66;
+
+// Pixel-mutating methods on `CanvasRenderingContext2D`. Path-state
+// methods (`beginPath`, `moveTo`, `lineTo`, …) are intentionally
+// omitted: they don't change pixels until `fill` or `stroke` is called.
+export const CANVAS_DRAW_METHODS = [
+  "clearRect",
+  "fillRect",
+  "strokeRect",
+  "fill",
+  "stroke",
+  "fillText",
+  "strokeText",
+  "drawImage",
+  "putImageData",
+] as const;
+
+// Per-canvas snapshot bookkeeping. All fields are optional because they
+// fill in lazily as the canvas first emits, throttles, or animates.
+export interface CanvasState {
+  // Last full-canvas data URL. Used to dedupe byte-identical
+  // re-snapshots from the gesture/forced paths.
+  lastSnapshot?: string;
+  // Last time any snapshot was emitted for this canvas. Drives the
+  // gesture-path throttle (`CANVAS_SNAPSHOT_MIN_INTERVAL_MS`).
+  lastSnapshotTime?: number;
+  // Last full-canvas pixel buffer; the next snapshot diffs against
+  // this to find the changed bounding box. Absent for canvases
+  // without a readable 2d context (WebGL); those always emit full
+  // snapshots.
+  shadowData?: ImageData;
+  // Last time the draw-detection animation path emitted, throttled
+  // independently of the gesture path via `CANVAS_ANIMATION_MIN_INTERVAL_MS`.
+  animationLastTime?: number;
+  // Set by the patched 2d-context draw methods; read-and-cleared by
+  // the frame tick. `undefined` and `false` are equivalent.
+  dirty?: boolean;
+}
diff --git a/packages/jspsych/src/modules/recording/global-patches.ts b/packages/jspsych/src/modules/recording/global-patches.ts
new file mode 100644
index 0000000000..a130e97287
--- /dev/null
+++ b/packages/jspsych/src/modules/recording/global-patches.ts
@@ -0,0 +1,174 @@
+// Multiple `JsPsych` instances can run with `record_session: true`
+// concurrently. The previous implementation patched
+// `CanvasRenderingContext2D.prototype` and `Math.random` per-recorder,
+// which meant the second recorder's "original" was actually the first
+// recorder's wrapper; restoring on stop in interleaved order left the
+// process with stale wrappers reinstalled on the prototype. The
+// helpers below install each global patch exactly once (refcounted by
+// the set of active recorders) so registration/unregistration order
+// is irrelevant.
+
+import * as randomization from "../randomization";
+import { CANVAS_DRAW_METHODS } from "./constants";
+
+// Just the recorder methods this module needs to call. Avoids a cycle
+// with `SessionRecorder.ts`; the concrete class structurally satisfies
+// this.
+interface RecorderHooks {
+  notifyCanvasDraw(canvas: HTMLCanvasElement): void;
+  recordRngCall(value: number): void;
+}
+
+// ---------------------------------------------------------------------------
+// Canvas: 2d-context draw methods + getContext type-tracking
+// ---------------------------------------------------------------------------
+
+const activeCanvasRecorders: Set<RecorderHooks> = new Set();
+let canvasMethodOriginals: Map<string, Function> | null = null;
+// Per-canvas committed context type, learned by wrapping
+// `HTMLCanvasElement.prototype.getContext`. The recorder consults
+// this map to decide whether `getContext("2d")` is safe to call —
+// see `getReadable2dContext` for the rationale.
+const committedContextTypes: WeakMap<HTMLCanvasElement, string> = new WeakMap();
+let getContextOriginal: HTMLCanvasElement["getContext"] | null = null;
+
+export function registerCanvasRecorder(recorder: RecorderHooks) {
+  if (activeCanvasRecorders.has(recorder)) return;
+  installCanvasGlobalPatches();
+  activeCanvasRecorders.add(recorder);
+}
+
+export function unregisterCanvasRecorder(recorder: RecorderHooks) {
+  if (!activeCanvasRecorders.delete(recorder)) return;
+  if (activeCanvasRecorders.size === 0) uninstallCanvasGlobalPatches();
+}
+
+function installCanvasGlobalPatches() {
+  if (canvasMethodOriginals !== null) return;
+  if (typeof CanvasRenderingContext2D !== "undefined") {
+    const proto = CanvasRenderingContext2D.prototype as unknown as Record<string, Function>;
+    canvasMethodOriginals = new Map();
+    for (const method of CANVAS_DRAW_METHODS) {
+      const original = proto[method];
+      if (typeof original !== "function") continue;
+      canvasMethodOriginals.set(method, original);
+      proto[method] = function (this: CanvasRenderingContext2D, ...args: unknown[]) {
+        try {
+          const canvas = this.canvas as HTMLCanvasElement | undefined;
+          if (canvas) {
+            for (const r of activeCanvasRecorders) r.notifyCanvasDraw(canvas);
+          }
+        } catch {
+          // Tracking must never break the experiment's own drawing.
+        }
+        return (original as Function).apply(this, args);
+      };
+    }
+  }
+  // Wrap `getContext` so we learn each canvas's committed context type
+  // without ever creating a context ourselves. This is what lets
+  // `getReadable2dContext` skip the diff path for WebGL canvases — and,
+  // crucially, for canvases that the user hasn't yet committed to any
+  // type, since calling `getContext("2d")` on a fresh canvas locks it
+  // into 2D and breaks any later `getContext("webgl")` call.
+  if (typeof HTMLCanvasElement !== "undefined") {
+    const proto = HTMLCanvasElement.prototype;
+    getContextOriginal = proto.getContext;
+    const wrapped = function (this: HTMLCanvasElement, ...args: unknown[]) {
+      const result = (getContextOriginal as Function).apply(this, args);
+      if (result && !committedContextTypes.has(this) && typeof args[0] === "string") {
+        committedContextTypes.set(this, args[0] as string);
+      }
+      return result;
+    };
+    proto.getContext = wrapped as typeof proto.getContext;
+  }
+}
+
+function uninstallCanvasGlobalPatches() {
+  if (canvasMethodOriginals !== null && typeof CanvasRenderingContext2D !== "undefined") {
+    const proto = CanvasRenderingContext2D.prototype as unknown as Record<string, Function>;
+    for (const [method, original] of canvasMethodOriginals) {
+      proto[method] = original;
+    }
+  }
+  canvasMethodOriginals = null;
+  if (getContextOriginal !== null && typeof HTMLCanvasElement !== "undefined") {
+    HTMLCanvasElement.prototype.getContext = getContextOriginal;
+  }
+  getContextOriginal = null;
+}
+
+// Returns the canvas's 2d rendering context if user code has already
+// committed one, otherwise null. Calling `getContext("2d")` on a fresh
+// canvas would permanently lock it to 2D and break any subsequent
+// `getContext("webgl")` call from a plugin, so we only touch canvases
+// whose committed type was learned via the `getContext` wrapper above.
+// Canvases of unknown or non-2d type fall through to full `toDataURL`
+// snapshots in `snapshotCanvas`.
+export function getReadable2dContext(canvas: HTMLCanvasElement): CanvasRenderingContext2D | null {
+  if (committedContextTypes.get(canvas) !== "2d") return null;
+  try {
+    const ctx = canvas.getContext("2d");
+    return ctx ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Math.random
+// ---------------------------------------------------------------------------
+
+const activeMathRandomRecorders: Set<RecorderHooks> = new Set();
+let mathRandomPrePatch: typeof Math.random | null = null;
+let mathRandomWrapper: typeof Math.random | null = null;
+
+function isNativeMathRandom(fn: typeof Math.random) {
+  // Native built-ins stringify with the [native code] sentinel; any
+  // user-installed PRNG (e.g. via jsPsych.randomization.setSeed) will
+  // serialize as JS source instead.
+  return /\{\s*\[native code\]\s*\}/.test(Function.prototype.toString.call(fn));
+}
+
+// Returns the seed string assigned by auto-seeding when this recorder
+// caused the install, or null when no seeding happened (either because
+// the user already installed a PRNG, or because a previous recorder
+// already patched).
+export function registerMathRandomRecorder(recorder: RecorderHooks): string | null {
+  if (activeMathRandomRecorders.has(recorder)) return null;
+  let seed: string | null = null;
+  if (mathRandomWrapper === null) {
+    mathRandomPrePatch = Math.random;
+    if (isNativeMathRandom(mathRandomPrePatch)) {
+      seed = randomization.setSeed();
+    }
+    const upstream = Math.random.bind(Math);
+    mathRandomWrapper = () => {
+      const v = upstream();
+      // Captured at session scope on every active recorder so calls
+      // outside trial boundaries (pre-trial parameter evaluation,
+      // post-trial gaps, the experimenter's `on_finish`) are still
+      // recorded.
+      for (const r of activeMathRandomRecorders) r.recordRngCall(v);
+      return v;
+    };
+    Math.random = mathRandomWrapper;
+  }
+  activeMathRandomRecorders.add(recorder);
+  return seed;
+}
+
+export function unregisterMathRandomRecorder(recorder: RecorderHooks) {
+  if (!activeMathRandomRecorders.delete(recorder)) return;
+  if (activeMathRandomRecorders.size > 0) return;
+  // Only restore if our wrapper is still installed. If the user
+  // reassigned `Math.random` mid-session, leave their replacement in
+  // place — clobbering it would silently undo a deliberate user
+  // decision.
+  if (mathRandomWrapper !== null && Math.random === mathRandomWrapper) {
+    if (mathRandomPrePatch !== null) Math.random = mathRandomPrePatch;
+  }
+  mathRandomWrapper = null;
+  mathRandomPrePatch = null;
+}
diff --git a/packages/jspsych/src/modules/recording/helpers.ts b/packages/jspsych/src/modules/recording/helpers.ts
new file mode 100644
index 0000000000..d926d1c664
--- /dev/null
+++ b/packages/jspsych/src/modules/recording/helpers.ts
@@ -0,0 +1,162 @@
+import type { JsonValue, ViewportState } from "./types";
+
+// Reads the `media` attribute, preferring the parsed value on the
+// CSSStyleSheet (which normalizes whitespace/casing) and falling back to
+// the raw attribute on the owning element.
+export function readMedia(el: HTMLElement, sheet: CSSStyleSheet | null): string | null {
+  const fromSheet = sheet?.media?.mediaText;
+  if (fromSheet) return fromSheet;
+  const attr = el.getAttribute("media");
+  return attr && attr.length > 0 ? attr : null;
+}
+
+// Reads the resolved CSS rule text from a stylesheet. Returns null when
+// `cssRules` is unreadable (cross-origin sheets without CORS access throw
+// SecurityError) so callers can record only the href in that case.
+export function readSheetText(sheet: CSSStyleSheet): string | null {
+  try {
+    const rules = sheet.cssRules;
+    if (!rules) return null;
+    const parts: string[] = [];
+    for (let i = 0; i < rules.length; i++) {
+      parts.push(rules[i].cssText);
+    }
+    return parts.join("\n");
+  } catch {
+    return null;
+  }
+}
+
+// Finds the bounding box of pixels that differ between two same-size
+// ImageData buffers. Uses an edge-shrink walk: scan top-down for the
+// first dirty row, bottom-up for the last, then within that row band
+// scan inward from each side for the first dirty column. For typical
+// incremental drawing (a stroke, a localized clear) this terminates
+// after only a few thousand pixel comparisons even on a multi-megapixel
+// canvas. Returns null when the buffers are byte-identical.
+//
+// Exported for unit testing; a replayer doesn't need it.
+export function computeDiffBbox(
+  prev: Uint8ClampedArray,
+  curr: Uint8ClampedArray,
+  w: number,
+  h: number
+): { x: number; y: number; w: number; h: number } | null {
+  let top = -1;
+  for (let y = 0; y < h; y++) {
+    const rowStart = y * w * 4;
+    const rowEnd = rowStart + w * 4;
+    for (let i = rowStart; i < rowEnd; i++) {
+      if (prev[i] !== curr[i]) {
+        top = y;
+        break;
+      }
+    }
+    if (top !== -1) break;
+  }
+  if (top === -1) return null;
+
+  let bottom = top;
+  for (let y = h - 1; y > top; y--) {
+    const rowStart = y * w * 4;
+    const rowEnd = rowStart + w * 4;
+    let dirty = false;
+    for (let i = rowStart; i < rowEnd; i++) {
+      if (prev[i] !== curr[i]) {
+        dirty = true;
+        break;
+      }
+    }
+    if (dirty) {
+      bottom = y;
+      break;
+    }
+  }
+
+  let left = w - 1;
+  let right = 0;
+  for (let y = top; y <= bottom; y++) {
+    const rowStart = y * w * 4;
+    // Scan inward from the left up to the current `left` candidate.
+    for (let x = 0; x < left; x++) {
+      const i = rowStart + x * 4;
+      if (
+        prev[i] !== curr[i] ||
+        prev[i + 1] !== curr[i + 1] ||
+        prev[i + 2] !== curr[i + 2] ||
+        prev[i + 3] !== curr[i + 3]
+      ) {
+        left = x;
+        break;
+      }
+    }
+    // Scan inward from the right past the current `right` candidate.
+    for (let x = w - 1; x > right; x--) {
+      const i = rowStart + x * 4;
+      if (
+        prev[i] !== curr[i] ||
+        prev[i + 1] !== curr[i + 1] ||
+        prev[i + 2] !== curr[i + 2] ||
+        prev[i + 3] !== curr[i + 3]
+      ) {
+        right = x;
+        break;
+      }
+    }
+    if (left === 0 && right === w - 1) break;
+  }
+
+  return { x: left, y: top, w: right - left + 1, h: bottom - top + 1 };
+}
+
+// Copies a rectangular region out of a source canvas into a temporary
+// canvas and returns its data URL. The temporary canvas is sized to
+// the region so the resulting PNG carries only the dirty pixels.
+export function cropCanvasToDataURL(
+  source: HTMLCanvasElement,
+  region: { x: number; y: number; w: number; h: number }
+): string {
+  const tmp = document.createElement("canvas");
+  tmp.width = region.w;
+  tmp.height = region.h;
+  const tctx = tmp.getContext("2d");
+  if (!tctx) return source.toDataURL();
+  tctx.drawImage(source, region.x, region.y, region.w, region.h, 0, 0, region.w, region.h);
+  return tmp.toDataURL();
+}
+
+export function readViewport(): ViewportState {
+  const vv = window.visualViewport;
+  return {
+    w: window.innerWidth,
+    h: window.innerHeight,
+    dpr: window.devicePixelRatio || 1,
+    scale: vv?.scale ?? 1,
+    offset_x: vv?.offsetLeft ?? 0,
+    offset_y: vv?.offsetTop ?? 0,
+  };
+}
+
+/**
+ * JSON-safe serialization for `trial_data` (the per-trial data row). Drops
+ * functions and DOM nodes — the recording's visual fidelity comes from DOM
+ * mutations, not from re-executing trial parameters.
+ */
+export function serializeJson(value: unknown, seen = new WeakSet<object>()): JsonValue {
+  if (value === null || value === undefined) return null;
+  const t = typeof value;
+  if (t === "boolean" || t === "string") return value as JsonValue;
+  if (t === "number") return Number.isFinite(value as number) ? (value as number) : null;
+  if (t === "function") return null;
+  if (t !== "object") return null;
+  if (seen.has(value as object)) return null;
+  seen.add(value as object);
+  if (Array.isArray(value)) return value.map((v) => serializeJson(v, seen));
+  if (value instanceof Date) return value.toISOString();
+  if (value instanceof Element || value instanceof Node) return null;
+  const out: Record<string, JsonValue> = {};
+  for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
+    out[k] = serializeJson(v, seen);
+  }
+  return out;
+}
diff --git a/packages/jspsych/src/modules/recording/index.ts b/packages/jspsych/src/modules/recording/index.ts
new file mode 100644
index 0000000000..9e9dbe26e6
--- /dev/null
+++ b/packages/jspsych/src/modules/recording/index.ts
@@ -0,0 +1,32 @@
+// Public surface for the session-recording module. The implementation is
+// split across sibling files; consumers (and re-exports from the package
+// entry) should import from this barrel.
+
+export type {
+  CanvasSnapshot,
+  ClipboardRecord,
+  CommentNode,
+  DomMutation,
+  DomNode,
+  ElementNode,
+  FocusRecord,
+  InputRecord,
+  JsonValue,
+  MediaRecord,
+  RecordedEvent,
+  RngCall,
+  ScrollRecord,
+  SessionRecording,
+  StylesheetEvent,
+  StylesheetSnapshot,
+  TextNode,
+  TrialRecording,
+  ViewportChange,
+  ViewportState,
+} from "./types";
+export type { RecordSessionOptions } from "./options";
+export { resolveRecordSessionOptions } from "./options";
+export { SessionRecorder } from "./SessionRecorder";
+export type { SessionRecorderOptions } from "./SessionRecorder";
+// Re-exported for unit tests in this repo; a replayer doesn't need them.
+export { computeDiffBbox, serializeJson } from "./helpers";
diff --git a/packages/jspsych/src/modules/recording/options.ts b/packages/jspsych/src/modules/recording/options.ts
new file mode 100644
index 0000000000..8080c02583
--- /dev/null
+++ b/packages/jspsych/src/modules/recording/options.ts
@@ -0,0 +1,51 @@
+/**
+ * Options for `initJsPsych({ record_session })`. Pass `true` for the
+ * defaults, `false` to disable, or this object to tune what gets
+ * captured. Each `capture_*` flag defaults to `true`; setting one to
+ * `false` skips both the listeners and the corresponding event types in
+ * the recording.
+ */
+export interface RecordSessionOptions {
+  /** Capture form input values (text, textarea, checkbox/radio, select).
+   *  Defaults true. Set false for surveys whose responses must not be
+   *  retained verbatim. */
+  capture_inputs?: boolean;
+  /** Capture canvas pixel snapshots. Defaults true. Set false when
+   *  experiments use large/animated canvases and the pixel readback
+   *  would dominate recording size or perturb timing. */
+  capture_canvas?: boolean;
+  /** Capture every `Math.random()` output to `rng_calls`. Defaults true.
+   *  Set false when reproducibility isn't needed and the RNG is called
+   *  millions of times (e.g. shuffling a large array per trial). */
+  capture_random?: boolean;
+  /** Hard cap on total recorded events across all categories
+   *  (per-trial events + rng_calls + viewport_changes + stylesheet_events).
+   *  When exceeded, recording stops with `end_reason: "memory_limit"`.
+   *  Defaults to no limit. */
+  max_events?: number;
+}
+
+export interface ResolvedRecordSessionOptions {
+  capture_inputs: boolean;
+  capture_canvas: boolean;
+  capture_random: boolean;
+  max_events: number;
+}
+
+/**
+ * Normalizes the user-facing `record_session` value into either `null`
+ * (disabled) or a fully-defaulted options object. Exported for callers
+ * (e.g. `JsPsych`) that need to decide whether to construct a recorder.
+ */
+export function resolveRecordSessionOptions(
+  raw: boolean | RecordSessionOptions | undefined
+): ResolvedRecordSessionOptions | null {
+  if (!raw) return null;
+  const obj = raw === true ? {} : raw;
+  return {
+    capture_inputs: obj.capture_inputs ?? true,
+    capture_canvas: obj.capture_canvas ?? true,
+    capture_random: obj.capture_random ?? true,
+    max_events: obj.max_events ?? Infinity,
+  };
+}
diff --git a/packages/jspsych/src/modules/recording/types.ts b/packages/jspsych/src/modules/recording/types.ts
new file mode 100644
index 0000000000..8ce5d23e50
--- /dev/null
+++ b/packages/jspsych/src/modules/recording/types.ts
@@ -0,0 +1,194 @@
+// ---------------------------------------------------------------------------
+// Schema types (schema_version: 1)
+//
+// These describe the public shape of `jsPsych.getSessionRecording()`.
+// A replayer consumes them; the recorder emits them.
+// ---------------------------------------------------------------------------
+
+export type JsonValue =
+  | null
+  | boolean
+  | number
+  | string
+  | JsonValue[]
+  | { [key: string]: JsonValue };
+
+export interface SessionRecording {
+  schema_version: 1;
+  jspsych_version: string;
+  recording_started_at: string;
+  recording_started_at_perf: number;
+  user_agent: string;
+  viewport: ViewportState;
+  rng: { seed: string | null; math_random_patched: boolean };
+  display_element_id: string;
+  stylesheets: StylesheetSnapshot[];
+  stylesheet_events: StylesheetEvent[];
+  trials: TrialRecording[];
+  viewport_changes: ViewportChange[];
+  // Session-scoped (not per-trial) so RNG calls during pre-trial
+  // parameter evaluation, between-trial gaps, and `on_finish` are
+  // captured. Replayer consumes in order.
+  rng_calls: RngCall[];
+  ended_at_perf: number | null;
+  end_reason: "finished" | "aborted" | "unload" | "memory_limit" | null;
+}
+
+// `inline` covers `<style>` tags; `link` covers `<link rel="stylesheet">`.
+// `css` is the resolved rule text where readable; cross-origin sheets
+// throw SecurityError on `cssRules` access, so for those `css` is null
+// and a replayer can fetch the source out-of-band. `id` is unique within
+// the session and shared with `stylesheet_events` so add/remove/update
+// events can reference snapshots created at start.
+export type StylesheetSnapshot =
+  | { id: number; kind: "inline"; css: string; media: string | null }
+  | { id: number; kind: "link"; href: string; css: string | null; media: string | null };
+
+// `stylesheet.add` carries a full snapshot (with a newly-assigned `id`);
+// `stylesheet.remove` and `stylesheet.update` reference an existing `id`
+// from `stylesheets` or a prior `add` event.
+export type StylesheetEvent =
+  | { type: "stylesheet.add"; t: number; sheet: StylesheetSnapshot }
+  | { type: "stylesheet.remove"; t: number; id: number }
+  | { type: "stylesheet.update"; t: number; id: number; css: string };
+
+export interface ViewportState {
+  w: number;
+  h: number;
+  dpr: number;
+  scale: number;
+  offset_x: number;
+  offset_y: number;
+}
+
+export interface ViewportChange extends ViewportState {
+  t: number;
+}
+
+export interface TrialRecording {
+  trial_index: number;
+  t_start: number;
+  t_dom_ready: number | null;
+  t_end: number | null;
+  plugin: string;
+  initial_dom: DomNode | null;
+  events: RecordedEvent[];
+  trial_data: JsonValue;
+}
+
+export type DomNode = ElementNode | TextNode | CommentNode;
+
+export interface ElementNode {
+  id: number;
+  kind: "element";
+  tag: string;
+  attrs: Record<string, string>;
+  children: DomNode[];
+  canvas_size?: { w: number; h: number };
+  media_src?: string;
+}
+
+export interface TextNode {
+  id: number;
+  kind: "text";
+  text: string;
+}
+
+export interface CommentNode {
+  id: number;
+  kind: "comment";
+  text: string;
+}
+
+export type RecordedEvent =
+  | DomMutation
+  | InputRecord
+  | ClipboardRecord
+  | MediaRecord
+  | FocusRecord
+  | ScrollRecord
+  | CanvasSnapshot;
+
+export type DomMutation =
+  | { type: "dom.add"; t: number; parent: number; before: number | null; node: DomNode }
+  | { type: "dom.remove"; t: number; node: number }
+  | { type: "dom.attr"; t: number; node: number; name: string; value: string | null }
+  | { type: "dom.text"; t: number; node: number; text: string };
+
+export type InputRecord =
+  | { type: "mouse.move"; t: number; x: number; y: number }
+  | {
+      type: "mouse.down" | "mouse.up" | "mouse.click";
+      t: number;
+      x: number;
+      y: number;
+      button: number;
+      target: number | null;
+    }
+  | {
+      type: "touch.start" | "touch.move" | "touch.end";
+      t: number;
+      touches: { id: number; x: number; y: number }[];
+    }
+  | {
+      type: "key.down" | "key.up";
+      t: number;
+      key: string;
+      code: string;
+      mods: { ctrl: boolean; shift: boolean; alt: boolean; meta: boolean };
+      repeat: boolean;
+      target: number | null;
+    }
+  // Form-state changes. The MutationObserver only sees the `value` *attribute*,
+  // not the IDL property the browser writes when a participant types or
+  // toggles a control. These records carry the post-change value/checked/
+  // selection so a replayer can reconstitute survey responses without
+  // having to replay keystrokes through a live form.
+  | { type: "input.value"; t: number; node: number; value: string }
+  | { type: "input.checked"; t: number; node: number; checked: boolean }
+  | { type: "input.select"; t: number; node: number; values: string[] };
+
+export interface ClipboardRecord {
+  type: "clipboard.copy" | "clipboard.cut" | "clipboard.paste";
+  t: number;
+  text: string | null;
+  html: string | null;
+  target: number | null;
+}
+
+export type MediaRecord = {
+  type: "media.play" | "media.pause" | "media.ended" | "media.seeked" | "media.time";
+  t: number;
+  node: number;
+  current_time: number;
+};
+
+export interface FocusRecord {
+  type: "focus" | "blur" | "fullscreen.enter" | "fullscreen.exit";
+  t: number;
+}
+
+export type ScrollRecord =
+  | { type: "scroll.window"; t: number; x: number; y: number }
+  | { type: "scroll.element"; t: number; node: number; x: number; y: number };
+
+// PNG data URL of `<canvas>` pixel state. MutationObserver can't see
+// drawing operations, so the replayer needs these to reconstruct
+// anything participants draw. `region` distinguishes a full-canvas
+// baseline (omitted: drawn at 0,0 after clearing) from an incremental
+// patch (present: composited at region.x,y). First snapshot per canvas
+// is always full; partials only when dirty area < 80% of canvas.
+export interface CanvasSnapshot {
+  type: "canvas.snapshot";
+  t: number;
+  node: number;
+  data_url: string;
+  region?: { x: number; y: number; w: number; h: number };
+}
+
+export interface RngCall {
+  t: number;
+  fn: string;
+  args: JsonValue;
+  result: JsonValue;
+}
diff --git a/packages/jspsych/tests/core/record-session.test.ts b/packages/jspsych/tests/core/record-session.test.ts
index b3f274110e..138ed02657 100644
--- a/packages/jspsych/tests/core/record-session.test.ts
+++ b/packages/jspsych/tests/core/record-session.test.ts
@@ -1318,4 +1318,228 @@ describe("record_session option", () => {
     // Only the first trial should have started; the second never did.
     expect(rec.trials).toHaveLength(1);
   });
+
+  test("does not commit a 2D context on a canvas the user hasn't yet committed", async () => {
+    // Regression: `getContext("2d")` on a fresh canvas permanently
+    // locks it to 2D. The recorder used to call this proactively to
+    // run its diff path, which would break any plugin that creates a
+    // canvas, attaches it to the DOM, and only later asks for a
+    // WebGL context. The recorder must now defer until the user
+    // commits a context themselves.
+    const jsPsych = initJsPsych({ record_session: true });
+    let webglContextRequested: unknown = "not-yet";
+    await startTimeline(
+      [
+        {
+          type: htmlKeyboardResponse,
+          stimulus: '<canvas id="c" width="20" height="20"></canvas>',
+          on_load: () => {
+            // Don't commit any context. The recorder's initial RAF will
+            // run before the trial ends; if it called `getContext("2d")`
+            // proactively, the canvas would be locked into 2D.
+          },
+        },
+      ],
+      jsPsych
+    );
+    // Let the recorder's initial-baseline RAF fire.
+    await new Promise((r) => setTimeout(r, 50));
+    // Now ask for a WebGL context — this must succeed (or at least
+    // not return null due to a pre-existing 2D commit). jsdom doesn't
+    // implement WebGL so the call returns null regardless; instead we
+    // verify the canvas can still commit to 2D without coming back
+    // pre-stamped. The clean signal is: a brand-new
+    // `getContext("2d")` returns a non-null context. (If the
+    // recorder had already locked the canvas into 2D, this would
+    // still succeed — so the stronger check below uses a separate
+    // canvas to verify we never see a `2d` commit recorded for one
+    // the user never asked about.)
+    const c = document.getElementById("c") as HTMLCanvasElement;
+    webglContextRequested = c.getContext("2d");
+    expect(webglContextRequested).not.toBeNull();
+    await pressKey("a");
+  });
+
+  test("preserves user-installed Math.random reassignments after stop", async () => {
+    // If the user replaces Math.random during a session, the recorder
+    // must not clobber that replacement on stop. Calls made via the
+    // user's replacement bypass the recorder's wrapper (which is
+    // expected — the user explicitly took over) but the replacement
+    // function must still be in place when the experiment ends.
+    const trueOriginal = Math.random;
+    const userRandom = () => 0.42;
+
+    try {
+      const jsPsych = initJsPsych({ record_session: true });
+      await startTimeline(
+        [
+          {
+            type: htmlKeyboardResponse,
+            stimulus: "x",
+            on_load: () => {
+              Math.random = userRandom;
+            },
+          },
+        ],
+        jsPsych
+      );
+      await pressKey("a");
+
+      expect(Math.random).toBe(userRandom);
+    } finally {
+      // Restore the realm-original so subsequent tests have working RNG.
+      Math.random = trueOriginal;
+    }
+  });
+
+  test("multi-instance recorders restore prototype patches cleanly", async () => {
+    // Two recorders running concurrently must share a single set of
+    // prototype patches; restoring after the second stops must leave
+    // the prototype back in its true original state.
+    const proto = (CanvasRenderingContext2D as any).prototype;
+    const originalFillRect = proto.fillRect;
+    const originalGetContext = HTMLCanvasElement.prototype.getContext;
+
+    const jsPsychA = initJsPsych({ record_session: true });
+    await startTimeline([{ type: htmlKeyboardResponse, stimulus: "a" }], jsPsychA);
+
+    // Mid-A run: the prototype is wrapped.
+    expect(proto.fillRect).not.toBe(originalFillRect);
+    expect(HTMLCanvasElement.prototype.getContext).not.toBe(originalGetContext);
+
+    // Spin up a second recorder while the first is still running.
+    const jsPsychB = initJsPsych({ record_session: true });
+    const recorderB = (jsPsychB as any).sessionRecorder as {
+      start: (el: HTMLElement) => void;
+      stop: (reason?: "finished" | "aborted" | "unload") => void;
+    };
+    recorderB.start(document.body);
+
+    // Both running: still exactly one wrapper, not double-wrapped.
+    const wrapperWhileBothRunning = proto.fillRect;
+    expect(wrapperWhileBothRunning).not.toBe(originalFillRect);
+
+    // Stop B first; A is still active so the wrapper stays.
+    recorderB.stop("finished");
+    expect(proto.fillRect).toBe(wrapperWhileBothRunning);
+    expect(HTMLCanvasElement.prototype.getContext).not.toBe(originalGetContext);
+
+    // Finish A. Now nothing is active; the prototype reverts.
+    await pressKey("a");
+    expect(proto.fillRect).toBe(originalFillRect);
+    expect(HTMLCanvasElement.prototype.getContext).toBe(originalGetContext);
+  });
+
+  describe("record_session as options object", () => {
+    test("capture_inputs: false skips form input/change listeners", async () => {
+      const jsPsych = initJsPsych({ record_session: { capture_inputs: false } });
+      await startTimeline(
+        [
+          {
+            type: htmlKeyboardResponse,
+            stimulus: '<input id="q" type="text">',
+            on_load: () => {
+              const input = document.getElementById("q") as HTMLInputElement;
+              input.value = "secret";
+              input.dispatchEvent(new Event("input", { bubbles: true }));
+              input.dispatchEvent(new Event("change", { bubbles: true }));
+            },
+          },
+        ],
+        jsPsych
+      );
+      await pressKey("a");
+
+      const rec = jsPsych.getSessionRecording()!;
+      const inputs = rec.trials[0].events.filter(
+        (e) => e.type === "input.value" || e.type === "input.checked" || e.type === "input.select"
+      );
+      expect(inputs).toHaveLength(0);
+    });
+
+    test("capture_canvas: false skips canvas tracking and prototype patching", async () => {
+      const proto = (CanvasRenderingContext2D as any).prototype;
+      const originalFillRect = proto.fillRect;
+
+      const jsPsych = initJsPsych({ record_session: { capture_canvas: false } });
+      let fillRectDuringTrial: any = null;
+      await startTimeline(
+        [
+          {
+            type: htmlKeyboardResponse,
+            stimulus: '<canvas id="c" width="20" height="20"></canvas>',
+            on_load: () => {
+              const c = document.getElementById("c") as HTMLCanvasElement;
+              c.getContext("2d")!.fillRect(0, 0, 10, 10);
+              fillRectDuringTrial = proto.fillRect;
+            },
+          },
+        ],
+        jsPsych
+      );
+      await pressKey("a");
+
+      const rec = jsPsych.getSessionRecording()!;
+      // No canvas events emitted, and the prototype was never patched
+      // because no recorder requested the canvas global.
+      expect(rec.trials[0].events.filter((e) => e.type === "canvas.snapshot")).toHaveLength(0);
+      expect(fillRectDuringTrial).toBe(originalFillRect);
+    });
+
+    test("capture_random: false leaves Math.random alone and skips rng_calls", async () => {
+      const trueOriginal = Math.random;
+      const jsPsych = initJsPsych({ record_session: { capture_random: false } });
+      await startTimeline(
+        [
+          {
+            type: htmlKeyboardResponse,
+            stimulus: "x",
+            on_load: () => {
+              // Math.random must not have been wrapped.
+              expect(Math.random).toBe(trueOriginal);
+              Math.random();
+              Math.random();
+            },
+          },
+        ],
+        jsPsych
+      );
+      await pressKey("a");
+
+      const rec = jsPsych.getSessionRecording()!;
+      expect(rec.rng.math_random_patched).toBe(false);
+      expect(rec.rng_calls).toHaveLength(0);
+      expect(Math.random).toBe(trueOriginal);
+    });
+
+    test("max_events stops the recording with end_reason 'memory_limit'", async () => {
+      const jsPsych = initJsPsych({ record_session: { max_events: 3 } });
+      await startTimeline(
+        [
+          {
+            type: htmlKeyboardResponse,
+            stimulus: "x",
+            on_load: () => {
+              // Synthesize many events; each Math.random push counts.
+              for (let i = 0; i < 50; i++) Math.random();
+            },
+          },
+        ],
+        jsPsych
+      );
+      // Let the queueMicrotask-deferred stop fire and the trial settle.
+      await new Promise((r) => setTimeout(r, 20));
+      await pressKey("a");
+
+      const rec = jsPsych.getSessionRecording()!;
+      expect(rec.end_reason).toBe("memory_limit");
+      // Cap is enforced as "≤ max_events" — we never push the (cap+1)st.
+      const totalEvents =
+        rec.rng_calls.length +
+        rec.viewport_changes.length +
+        rec.stylesheet_events.length +
+        rec.trials.reduce((acc, t) => acc + t.events.length, 0);
+      expect(totalEvents).toBeLessThanOrEqual(3);
+    });
+  });
 });