@jspsych/extension-tobii 0.1.1

package/dist/index.browser.js

@@ -0,0 +1,1005 @@
+var jsPsychExtensionTobii = (function (jspsych) {
+  'use strict';
+
+  var version = "0.1.1";
+
+  class WebSocketClient {
+    constructor(config = {}) {
+      this.ws = null;
+      this.reconnectTimeout = null;
+      this.currentReconnectAttempt = 0;
+      this.nextRequestId = 0;
+      this.config = {
+        url: config.url || "ws://localhost:8080",
+        autoConnect: config.autoConnect ?? true,
+        reconnectAttempts: config.reconnectAttempts ?? 5,
+        reconnectDelay: config.reconnectDelay ?? 1e3
+      };
+      this.status = {
+        connected: false,
+        tracking: false
+      };
+      this.messageHandlers = /* @__PURE__ */ new Map();
+    }
+    /**
+     * Connect to WebSocket server
+     */
+    async connect() {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        return;
+      }
+      return new Promise((resolve, reject) => {
+        try {
+          this.ws = new WebSocket(this.config.url);
+          const timeoutId = setTimeout(() => {
+            if (this.ws?.readyState !== WebSocket.OPEN) {
+              reject(new Error(`Connection timeout (${this.config.url})`));
+            }
+          }, 5e3);
+          this.ws.onopen = () => {
+            clearTimeout(timeoutId);
+            this.status.connected = true;
+            this.status.connectedAt = Date.now();
+            this.currentReconnectAttempt = 0;
+            resolve();
+          };
+          this.ws.onmessage = (event) => {
+            this.handleMessage(event);
+          };
+          this.ws.onerror = (error) => {
+            this.status.lastError = "WebSocket error";
+            console.error("WebSocket error:", error);
+          };
+          this.ws.onclose = () => {
+            this.status.connected = false;
+            this.status.tracking = false;
+            this.handleDisconnect();
+          };
+        } catch (error) {
+          reject(error);
+        }
+      });
+    }
+    /**
+     * Disconnect from WebSocket server
+     */
+    async disconnect() {
+      if (this.reconnectTimeout !== null) {
+        clearTimeout(this.reconnectTimeout);
+        this.reconnectTimeout = null;
+      }
+      if (this.ws) {
+        this.ws.close();
+        this.ws = null;
+      }
+      this.status.connected = false;
+      this.status.tracking = false;
+    }
+    /**
+     * Check if connected
+     */
+    isConnected() {
+      return this.ws?.readyState === WebSocket.OPEN;
+    }
+    /**
+     * Get connection status
+     */
+    getStatus() {
+      return { ...this.status };
+    }
+    /**
+     * Send message to server
+     */
+    async send(message) {
+      if (!this.isConnected()) {
+        throw new Error("Not connected to server");
+      }
+      this.ws.send(JSON.stringify(message));
+    }
+    /**
+     * Send message and wait for response
+     */
+    async sendAndWait(message, timeout = 5e3) {
+      if (!this.isConnected()) {
+        throw new Error("Not connected to server");
+      }
+      return new Promise((resolve, reject) => {
+        const requestId = `req_${this.nextRequestId++}`;
+        const messageWithId = { ...message, requestId };
+        const timeoutId = setTimeout(() => {
+          this.messageHandlers.delete(requestId);
+          reject(new Error("Request timeout"));
+        }, timeout);
+        this.messageHandlers.set(requestId, (data) => {
+          clearTimeout(timeoutId);
+          this.messageHandlers.delete(requestId);
+          resolve(data);
+        });
+        this.ws.send(JSON.stringify(messageWithId));
+      });
+    }
+    /**
+     * Register message handler
+     */
+    on(messageType, handler) {
+      if (this.messageHandlers.has(messageType)) {
+        console.warn(`Tobii WebSocket: Overwriting existing handler for message type "${messageType}"`);
+      }
+      this.messageHandlers.set(messageType, handler);
+    }
+    /**
+     * Unregister message handler
+     */
+    off(messageType) {
+      this.messageHandlers.delete(messageType);
+    }
+    /**
+     * Handle incoming message
+     */
+    handleMessage(event) {
+      try {
+        const receiveTime = performance.now();
+        const data = JSON.parse(event.data);
+        data._clientReceiveTime = receiveTime;
+        if (data.requestId && this.messageHandlers.has(data.requestId)) {
+          const handler = this.messageHandlers.get(data.requestId);
+          handler(data);
+          return;
+        }
+        if (data.type && this.messageHandlers.has(data.type)) {
+          const handler = this.messageHandlers.get(data.type);
+          handler(data);
+        }
+      } catch (error) {
+        console.error("Error handling message:", error);
+      }
+    }
+    /**
+     * Handle disconnection and attempt reconnect
+     */
+    handleDisconnect() {
+      if (this.currentReconnectAttempt < this.config.reconnectAttempts) {
+        this.currentReconnectAttempt++;
+        const delay = this.config.reconnectDelay * this.currentReconnectAttempt;
+        this.reconnectTimeout = window.setTimeout(async () => {
+          try {
+            await this.connect();
+            const reconnectedHandler = this.messageHandlers.get("reconnected");
+            if (reconnectedHandler) {
+              reconnectedHandler({ type: "reconnected" });
+            }
+          } catch (error) {
+            console.warn(`Tobii: Reconnection attempt ${this.currentReconnectAttempt}/${this.config.reconnectAttempts} failed:`, error);
+          }
+        }, delay);
+      } else {
+        this.status.lastError = "Max reconnection attempts reached";
+      }
+    }
+  }
+
+  class DataManager {
+    /**
+     * @param maxBufferSize Maximum number of samples to retain. Oldest samples
+     *   are dropped when the buffer exceeds this size. Default is 7200
+     *   (~60 seconds at 120 Hz).
+     */
+    constructor(maxBufferSize = 7200) {
+      this.gazeBuffer = [];
+      this.trialStartTime = null;
+      this.trialEndTime = null;
+      this.maxBufferSize = maxBufferSize;
+    }
+    /**
+     * Add gaze data point to the buffer
+     */
+    addGazeData(data) {
+      this.gazeBuffer.push(data);
+      if (this.gazeBuffer.length > this.maxBufferSize) {
+        this.gazeBuffer = this.gazeBuffer.slice(-this.maxBufferSize);
+      }
+    }
+    /**
+     * Mark trial start
+     */
+    startTrial() {
+      this.trialStartTime = performance.now();
+    }
+    /**
+     * Mark trial end
+     */
+    endTrial() {
+      this.trialEndTime = performance.now();
+    }
+    /**
+     * Get all gaze data for current trial
+     */
+    getTrialData() {
+      if (this.trialStartTime === null) {
+        return [];
+      }
+      const endTime = this.trialEndTime || performance.now();
+      return this.gazeBuffer.filter((data) => {
+        const ts = data.browserTimestamp ?? data.timestamp;
+        return ts >= this.trialStartTime && ts <= endTime;
+      });
+    }
+    /**
+     * Get gaze data for specific time range (using browserTimestamp if available)
+     */
+    getDataRange(startTime, endTime) {
+      return this.gazeBuffer.filter((data) => {
+        const ts = data.browserTimestamp ?? data.timestamp;
+        return ts >= startTime && ts <= endTime;
+      });
+    }
+    /**
+     * Get most recent gaze data point
+     */
+    getCurrentGaze() {
+      if (this.gazeBuffer.length === 0) {
+        return null;
+      }
+      return this.gazeBuffer[this.gazeBuffer.length - 1];
+    }
+    /**
+     * Clear all gaze data
+     */
+    clear() {
+      this.gazeBuffer = [];
+      this.trialStartTime = null;
+      this.trialEndTime = null;
+    }
+    /**
+     * Clear old data (keep only recent data)
+     */
+    clearOldData(keepDuration = 6e4) {
+      const cutoffTime = performance.now() - keepDuration;
+      this.gazeBuffer = this.gazeBuffer.filter((data) => {
+        const ts = data.browserTimestamp ?? data.timestamp;
+        return ts >= cutoffTime;
+      });
+    }
+    /**
+     * Get buffer size
+     */
+    getBufferSize() {
+      return this.gazeBuffer.length;
+    }
+    /**
+     * Get recent gaze data from the last N milliseconds
+     */
+    getRecentData(durationMs) {
+      const now = performance.now();
+      const startTime = now - durationMs;
+      return this.gazeBuffer.filter((data) => {
+        const ts = data.browserTimestamp ?? data.timestamp;
+        return ts >= startTime;
+      });
+    }
+  }
+
+  class TimeSync {
+    constructor(ws) {
+      this.ws = ws;
+      this.offset = 0;
+      this.synced = false;
+    }
+    /**
+     * Synchronize time with server
+     */
+    async synchronize() {
+      const measurements = [];
+      const numSamples = 10;
+      for (let i = 0; i < numSamples; i++) {
+        const t0 = performance.now();
+        const response = await this.ws.sendAndWait({
+          type: "time_sync",
+          clientTime: t0
+        });
+        const t1 = performance.now();
+        const roundTripTime = t1 - t0;
+        const serverTime = response.serverTime;
+        const latency = roundTripTime / 2;
+        const offset = serverTime - (t0 + latency);
+        measurements.push(offset);
+        await this.delay(100);
+      }
+      this.offset = this.median(measurements);
+      this.synced = true;
+    }
+    /**
+     * Convert local timestamp to server timestamp
+     */
+    toServerTime(localTime) {
+      return localTime + this.offset;
+    }
+    /**
+     * Convert server timestamp to local timestamp
+     */
+    toLocalTime(serverTime) {
+      return serverTime - this.offset;
+    }
+    /**
+     * Check if time is synchronized
+     */
+    isSynced() {
+      return this.synced;
+    }
+    /**
+     * Get current offset
+     */
+    getOffset() {
+      return this.offset;
+    }
+    /**
+     * Calculate median of array
+     */
+    median(values) {
+      const sorted = [...values].sort((a, b) => a - b);
+      const mid = Math.floor(sorted.length / 2);
+      return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+    }
+    /**
+     * Delay helper
+     */
+    delay(ms) {
+      return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+  }
+
+  class DeviceTimeSync {
+    constructor(ws, timeSync) {
+      this.ws = ws;
+      this.timeSync = timeSync;
+      this.offsetBC = null;
+      this.bcSampleCount = 0;
+      this.bcStdDev = null;
+      this.bcMin = null;
+      this.bcMax = null;
+    }
+    /**
+     * Request the B-C offset from the server and compute the A-C chain.
+     * Requires that TimeSync (A-B) is already synchronized and that
+     * gaze samples have been collected on the server.
+     */
+    async synchronizeDeviceClock() {
+      if (!this.timeSync.isSynced()) {
+        return false;
+      }
+      try {
+        const response = await this.ws.sendAndWait({
+          type: "get_device_clock_offset"
+        });
+        if (!response.success) {
+          return false;
+        }
+        this.offsetBC = response.offset;
+        this.bcSampleCount = response.sample_count;
+        this.bcStdDev = response.std_dev;
+        this.bcMin = response.min;
+        this.bcMax = response.max;
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    /**
+     * Whether the full A↔C chain is established
+     */
+    isSynced() {
+      return this.timeSync.isSynced() && this.offsetBC !== null;
+    }
+    /**
+     * Convert a performance.now() timestamp to device clock time.
+     * offset_AB: B = A + offset_AB
+     * offset_BC: B = C + offset_BC  →  C = B - offset_BC
+     * So: C = (A + offset_AB) - offset_BC = A + (offset_AB - offset_BC)
+     */
+    toDeviceTime(performanceNow) {
+      if (!this.isSynced()) {
+        throw new Error("Device time sync not established. Call synchronizeDeviceClock() first.");
+      }
+      const offsetAB = this.timeSync.getOffset();
+      return performanceNow + offsetAB - this.offsetBC;
+    }
+    /**
+     * Convert a device clock timestamp to performance.now() domain.
+     * A = C - offset_AB + offset_BC = C - (offset_AB - offset_BC)
+     */
+    toLocalTime(deviceTime) {
+      if (!this.isSynced()) {
+        throw new Error("Device time sync not established. Call synchronizeDeviceClock() first.");
+      }
+      const offsetAB = this.timeSync.getOffset();
+      return deviceTime - offsetAB + this.offsetBC;
+    }
+    /**
+     * Get full synchronization status with all offsets and diagnostics
+     */
+    getStatus() {
+      const offsetAB = this.timeSync.getOffset();
+      const offsetAC = this.offsetBC !== null ? offsetAB - this.offsetBC : null;
+      return {
+        synced: this.isSynced(),
+        offsetAB,
+        offsetBC: this.offsetBC,
+        offsetAC,
+        bcSampleCount: this.bcSampleCount,
+        bcStdDev: this.bcStdDev,
+        bcMin: this.bcMin,
+        bcMax: this.bcMax
+      };
+    }
+    /**
+     * Validate timestamp alignment across a set of gaze samples.
+     *
+     * For each sample, computes: residual = (_receiveTime + offset_AC) - timestamp
+     * using the internal _receiveTime property (raw WebSocket receive time) as an
+     * independent measurement to cross-validate the sync offset.
+     * If clocks are well-aligned, residuals should cluster tightly around the
+     * one-way WebSocket latency (server→client).
+     *
+     * @param samples - Array of gaze samples (must have internal _receiveTime set)
+     * @returns Alignment statistics, or null if sync is not established or no valid samples
+     */
+    validateTimestampAlignment(samples) {
+      if (!this.isSynced()) {
+        return null;
+      }
+      const offsetAB = this.timeSync.getOffset();
+      const offsetAC = offsetAB - this.offsetBC;
+      const residuals = [];
+      for (const sample of samples) {
+        const receiveTime = sample._receiveTime;
+        if (receiveTime != null && sample.timestamp != null) {
+          residuals.push(receiveTime + offsetAC - sample.timestamp);
+        }
+      }
+      if (residuals.length === 0) {
+        return null;
+      }
+      const n = residuals.length;
+      const mean = residuals.reduce((a, b) => a + b, 0) / n;
+      const variance = residuals.reduce((a, b) => a + (b - mean) ** 2, 0) / n;
+      const stdDev = Math.sqrt(variance);
+      const min = Math.min(...residuals);
+      const max = Math.max(...residuals);
+      return {
+        sampleCount: n,
+        meanResidual: mean,
+        stdDev,
+        min,
+        max
+      };
+    }
+    /**
+     * Reset sync state (e.g., after reconnection)
+     */
+    reset() {
+      this.offsetBC = null;
+      this.bcSampleCount = 0;
+      this.bcStdDev = null;
+      this.bcMin = null;
+      this.bcMax = null;
+    }
+  }
+
+  function normalizedToPixels(x, y) {
+    const width = window.innerWidth;
+    const height = window.innerHeight;
+    return {
+      x: Math.round(x * width),
+      y: Math.round(y * height)
+    };
+  }
+  function pixelsToNormalized(x, y) {
+    const width = window.innerWidth;
+    const height = window.innerHeight;
+    return {
+      x: x / width,
+      y: y / height
+    };
+  }
+  function getScreenDimensions() {
+    return {
+      width: window.innerWidth,
+      height: window.innerHeight
+    };
+  }
+  function distance(p1, p2) {
+    const dx = p2.x - p1.x;
+    const dy = p2.y - p1.y;
+    return Math.sqrt(dx * dx + dy * dy);
+  }
+  function windowToContainer(x, y, container) {
+    const rect = container.getBoundingClientRect();
+    return {
+      x: Math.round(x - rect.left),
+      y: Math.round(y - rect.top)
+    };
+  }
+  function getContainerDimensions(container) {
+    const rect = container.getBoundingClientRect();
+    return {
+      width: rect.width,
+      height: rect.height
+    };
+  }
+  function isWithinContainer(x, y, container) {
+    const rect = container.getBoundingClientRect();
+    return x >= rect.left && x <= rect.right && y >= rect.top && y <= rect.bottom;
+  }
+
+  function toCSV(data, filename) {
+    if (data.length === 0) {
+      console.warn("No data to export");
+      return;
+    }
+    const keys = Array.from(new Set(data.flatMap((item) => Object.keys(flattenObject(item)))));
+    const header = keys.join(",");
+    const rows = data.map((item) => {
+      const flattened = flattenObject(item);
+      return keys.map((key) => {
+        const value = flattened[key];
+        if (typeof value === "string" && value.includes(",")) {
+          return `"${value}"`;
+        }
+        return value ?? "";
+      }).join(",");
+    });
+    const csv = [header, ...rows].join("\n");
+    downloadFile(csv, filename, "text/csv");
+  }
+  function toJSON(data, filename) {
+    const json = JSON.stringify(data, null, 2);
+    downloadFile(json, filename, "application/json");
+  }
+  function flattenObject(obj, prefix = "") {
+    const flattened = {};
+    for (const [key, value] of Object.entries(obj)) {
+      const newKey = prefix ? `${prefix}.${key}` : key;
+      if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+        Object.assign(flattened, flattenObject(value, newKey));
+      } else if (Array.isArray(value)) {
+        flattened[newKey] = JSON.stringify(value);
+      } else {
+        flattened[newKey] = value;
+      }
+    }
+    return flattened;
+  }
+  function downloadFile(content, filename, mimeType) {
+    const blob = new Blob([content], { type: mimeType });
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = filename;
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    setTimeout(() => URL.revokeObjectURL(url), 6e4);
+  }
+
+  function validateGazeData(data) {
+    if (typeof data !== "object" || data === null)
+      return false;
+    const d = data;
+    return typeof d.x === "number" && typeof d.y === "number" && typeof d.timestamp === "number" && !isNaN(d.x) && !isNaN(d.y) && !isNaN(d.timestamp);
+  }
+  function validateCalibrationPoint(point) {
+    if (typeof point !== "object" || point === null)
+      return false;
+    const p = point;
+    return typeof p.x === "number" && typeof p.y === "number" && p.x >= 0 && p.x <= 1 && p.y >= 0 && p.y <= 1;
+  }
+  function filterValidGaze(data) {
+    return data.filter(validateGazeData);
+  }
+  function validateCalibrationResult(data) {
+    if (typeof data !== "object" || data === null)
+      return false;
+    return typeof data.success === "boolean";
+  }
+  function validateValidationResult(data) {
+    if (typeof data !== "object" || data === null)
+      return false;
+    return typeof data.success === "boolean";
+  }
+
+  class TobiiExtension {
+    constructor(jsPsych) {
+      this.tracking = false;
+      this.config = {};
+      this.gazeSampleCount = 0;
+      this.deviceTimeSyncTriggered = false;
+      this.initialize = async (params = {}) => {
+        this.config = params;
+        this.ws = new WebSocketClient(params.connection);
+        this.dataManager = new DataManager();
+        this.timeSync = new TimeSync(this.ws);
+        this.deviceTimeSync = new DeviceTimeSync(this.ws, this.timeSync);
+        this.ws.on("gaze_data", (data) => {
+          const rawGaze = data.gaze;
+          if (rawGaze && validateGazeData(rawGaze)) {
+            const receiveTime = data._clientReceiveTime ?? performance.now();
+            const gazeWithTimestamps = {
+              ...rawGaze,
+              browserTimestamp: this.deviceTimeSync.isSynced() ? this.deviceTimeSync.toLocalTime(rawGaze.timestamp) : receiveTime
+            };
+            gazeWithTimestamps._receiveTime = receiveTime;
+            this.dataManager.addGazeData(gazeWithTimestamps);
+            this.gazeSampleCount++;
+            if (!this.deviceTimeSyncTriggered && this.gazeSampleCount >= 50) {
+              this.deviceTimeSyncTriggered = true;
+              this.deviceTimeSync.synchronizeDeviceClock().catch((e) => {
+                console.warn("Tobii: Device time sync failed, can be retried manually:", e);
+              });
+            }
+          }
+        });
+        this.ws.on("reconnected", async () => {
+          try {
+            await this.timeSync.synchronize();
+          } catch (e) {
+            console.warn("Tobii: Time sync failed after reconnection:", e);
+          }
+          this.deviceTimeSync.reset();
+          this.gazeSampleCount = 0;
+          this.deviceTimeSyncTriggered = false;
+        });
+        if (params.connection?.autoConnect) {
+          await this.connect();
+        }
+      };
+      this.on_start = async (_params = {}) => {
+        this.dataManager.startTrial();
+        if (!this.tracking) {
+          await this.startTracking();
+        }
+      };
+      this.on_load = async () => {
+      };
+      this.on_finish = async (_params = {}) => {
+        this.dataManager.endTrial();
+        const trialData = this.dataManager.getTrialData();
+        this.dataManager.clearOldData();
+        return {
+          tobii_data: trialData
+        };
+      };
+      this.jsPsych = jsPsych;
+    }
+    static {
+      this.info = {
+        name: "tobii",
+        version,
+        data: {
+          /** Eye tracking gaze data collected during the trial */
+          tobii_data: {
+            type: jspsych.ParameterType.COMPLEX,
+            array: true
+          }
+        }
+      };
+    }
+    // ==========================================
+    // PUBLIC API METHODS
+    // These are accessible via jsPsych.extensions.tobii.*
+    // ==========================================
+    /**
+     * Connect to the WebSocket server
+     */
+    async connect() {
+      await this.ws.connect();
+      await this.timeSync.synchronize();
+    }
+    /**
+     * Disconnect from the WebSocket server
+     */
+    async disconnect() {
+      if (this.tracking) {
+        await this.stopTracking();
+      }
+      await this.ws.disconnect();
+    }
+    /**
+     * Check if connected to server
+     */
+    isConnected() {
+      return this.ws.isConnected();
+    }
+    /**
+     * Get connection status details
+     */
+    getConnectionStatus() {
+      return this.ws.getStatus();
+    }
+    /**
+     * Start eye tracking data collection
+     */
+    async startTracking() {
+      if (!this.isConnected()) {
+        throw new Error("Not connected to server. Call connect() first.");
+      }
+      const response = await this.ws.sendAndWait({ type: "start_tracking" });
+      if (response.success) {
+        this.tracking = true;
+      } else {
+        throw new Error(`Server failed to start tracking: ${response.error || "unknown error"}`);
+      }
+    }
+    /**
+     * Stop eye tracking data collection
+     */
+    async stopTracking() {
+      try {
+        await this.ws.sendAndWait({ type: "stop_tracking" });
+      } finally {
+        this.tracking = false;
+      }
+    }
+    /**
+     * Check if currently tracking
+     */
+    isTracking() {
+      return this.tracking;
+    }
+    /**
+     * Start calibration procedure
+     */
+    async startCalibration() {
+      await this.ws.send({ type: "calibration_start" });
+    }
+    /**
+     * Collect calibration data for a specific point
+     * @returns Promise resolving to success status when SDK finishes collecting
+     */
+    async collectCalibrationPoint(x, y) {
+      if (!validateCalibrationPoint({ x, y })) {
+        throw new Error(
+          `Invalid calibration point (${x}, ${y}). Coordinates must be in range [0, 1].`
+        );
+      }
+      const response = await this.ws.sendAndWait({
+        type: "calibration_point",
+        point: { x, y },
+        timestamp: performance.now()
+      });
+      return { success: response.success === true };
+    }
+    /**
+     * Compute calibration from collected points
+     */
+    async computeCalibration() {
+      const response = await this.ws.sendAndWait({
+        type: "calibration_compute"
+      });
+      if (!validateCalibrationResult(response)) {
+        return { success: false, error: "Invalid server response" };
+      }
+      return response;
+    }
+    /**
+     * Get calibration data/quality metrics
+     */
+    async getCalibrationData() {
+      const response = await this.ws.sendAndWait({
+        type: "get_calibration_data"
+      });
+      if (!validateCalibrationResult(response)) {
+        return { success: false, error: "Invalid server response" };
+      }
+      return response;
+    }
+    /**
+     * Start validation procedure
+     */
+    async startValidation() {
+      await this.ws.send({ type: "validation_start" });
+    }
+    /**
+     * Collect validation data for a specific point
+     * @param x - Normalized x coordinate (0-1)
+     * @param y - Normalized y coordinate (0-1)
+     * @param gazeSamples - Optional array of gaze samples collected at this point
+     */
+    async collectValidationPoint(x, y, gazeSamples) {
+      if (!validateCalibrationPoint({ x, y })) {
+        throw new Error(
+          `Invalid validation point (${x}, ${y}). Coordinates must be in range [0, 1].`
+        );
+      }
+      await this.ws.send({
+        type: "validation_point",
+        point: { x, y },
+        timestamp: performance.now(),
+        gaze_samples: gazeSamples || []
+      });
+    }
+    /**
+     * Get recent gaze data from the data manager buffer
+     * @param durationMs - How many milliseconds of recent data to retrieve
+     */
+    getRecentGazeData(durationMs) {
+      return this.dataManager.getRecentData(durationMs);
+    }
+    /**
+     * Compute validation from collected points
+     */
+    async computeValidation() {
+      const response = await this.ws.sendAndWait({
+        type: "validation_compute"
+      });
+      if (!validateValidationResult(response)) {
+        return { success: false, error: "Invalid server response" };
+      }
+      return response;
+    }
+    /**
+     * Get current gaze position
+     */
+    async getCurrentGaze() {
+      const localGaze = this.dataManager.getCurrentGaze();
+      if (localGaze) {
+        return localGaze;
+      }
+      const response = await this.ws.sendAndWait({
+        type: "get_current_gaze"
+      });
+      return response.gaze || null;
+    }
+    /**
+     * Get current user position (head position)
+     */
+    async getUserPosition() {
+      if (!this.isConnected()) {
+        return null;
+      }
+      const response = await this.ws.sendAndWait({
+        type: "get_user_position"
+      });
+      return response.position || null;
+    }
+    /**
+     * Get gaze data for a specific time range
+     */
+    async getGazeData(startTime, endTime) {
+      const localData = this.dataManager.getDataRange(startTime, endTime);
+      return filterValidGaze(localData);
+    }
+    /**
+     * Clear stored gaze data
+     */
+    clearGazeData() {
+      this.dataManager.clear();
+    }
+    /**
+     * Convert normalized coordinates (0-1) to pixels
+     */
+    normalizedToPixels(x, y) {
+      return normalizedToPixels(x, y);
+    }
+    /**
+     * Convert pixel coordinates to normalized (0-1)
+     */
+    pixelsToNormalized(x, y) {
+      return pixelsToNormalized(x, y);
+    }
+    /**
+     * Get screen dimensions
+     */
+    getScreenDimensions() {
+      return getScreenDimensions();
+    }
+    /**
+     * Calculate distance between two points
+     */
+    calculateDistance(p1, p2) {
+      return distance(p1, p2);
+    }
+    /**
+     * Convert window pixel coordinates to container-relative coordinates
+     * @param x - X coordinate in window pixels
+     * @param y - Y coordinate in window pixels
+     * @param container - Optional container element (defaults to jsPsych display element)
+     */
+    windowToContainer(x, y, container) {
+      const el = container || this.jsPsych.getDisplayElement();
+      return windowToContainer(x, y, el);
+    }
+    /**
+     * Get container dimensions
+     * @param container - Optional container element (defaults to jsPsych display element)
+     */
+    getContainerDimensions(container) {
+      const el = container || this.jsPsych.getDisplayElement();
+      return getContainerDimensions(el);
+    }
+    /**
+     * Check if window coordinates fall within a container
+     * @param x - X coordinate in window pixels
+     * @param y - Y coordinate in window pixels
+     * @param container - Optional container element (defaults to jsPsych display element)
+     */
+    isWithinContainer(x, y, container) {
+      const el = container || this.jsPsych.getDisplayElement();
+      return isWithinContainer(x, y, el);
+    }
+    /**
+     * Export gaze data to CSV
+     */
+    exportToCSV(data, filename) {
+      toCSV(data, filename);
+    }
+    /**
+     * Export gaze data to JSON
+     */
+    exportToJSON(data, filename) {
+      toJSON(data, filename);
+    }
+    /**
+     * Set extension configuration
+     */
+    setConfig(config) {
+      this.config = { ...this.config, ...config };
+    }
+    /**
+     * Get current configuration
+     */
+    getConfig() {
+      return { ...this.config };
+    }
+    /**
+     * Get time synchronization offset
+     */
+    getTimeOffset() {
+      return this.timeSync.getOffset();
+    }
+    /**
+     * Check if time is synchronized
+     */
+    isTimeSynced() {
+      return this.timeSync.isSynced();
+    }
+    /**
+     * Convert a performance.now() timestamp to Tobii device clock time.
+     * Requires that device time sync is established.
+     */
+    toDeviceTime(performanceNow) {
+      return this.deviceTimeSync.toDeviceTime(performanceNow);
+    }
+    /**
+     * Convert a Tobii device clock timestamp to performance.now() domain.
+     * Requires that device time sync is established.
+     */
+    toLocalTime(deviceTime) {
+      return this.deviceTimeSync.toLocalTime(deviceTime);
+    }
+    /**
+     * Check if the browser-to-device time sync chain is established
+     */
+    isDeviceTimeSynced() {
+      return this.deviceTimeSync.isSynced();
+    }
+    /**
+     * Get full device time synchronization status with all offsets and diagnostics
+     */
+    getTimeSyncStatus() {
+      return this.deviceTimeSync.getStatus();
+    }
+    /**
+     * Validate timestamp alignment across a set of gaze samples.
+     * Computes per-sample residuals to verify the A↔C offset is consistent.
+     * Low stdDev indicates well-aligned timestamps.
+     * @param samples - Gaze samples to validate (uses internal _receiveTime for cross-check)
+     */
+    validateTimestampAlignment(samples) {
+      return this.deviceTimeSync.validateTimestampAlignment(samples);
+    }
+  }
+
+  return TobiiExtension;
+
+})(jsPsychModule);
+//# sourceMappingURL=https://unpkg.com/@jspsych/extension-tobii@0.1.1/dist/index.browser.js.map