@neurodevs/node-lsl 18.1.0 → 20.0.0

package/src/impl/LslWebSocketBridge.ts

@@ -1,22 +1,19 @@
 import WebSocket, { WebSocketServer } from 'ws'
 
-import LslStreamInlet, {
-    StreamInlet,
-    StreamInletOptions,
-} from './LslStreamInlet.js'
+import LslStreamInlet, { LslInlet, LslInletOptions } from './LslStreamInlet.js'
 
-export default class LslWebSocketBridge implements WebSocketBridge {
-    public static Class?: WebSocketBridgeConstructor
+export default class LslWebSocketBridge implements LslWsBridge {
+    public static Class?: LslWsBridgeConstructor
     public static WS = WebSocket
     public static WSS = WebSocketServer
 
-    private inlet: StreamInlet
+    private inlet: LslInlet
     private localServer?: WebSocketServer
     private remoteSockets?: WebSocket[]
 
     private isDestroyed = false
 
-    protected constructor(options: WebSocketBridgeConstructorOptions) {
+    protected constructor(options: LslWsBridgeConstructorOptions) {
         const { inlet, localServer, remoteSockets } = options
 
         this.inlet = inlet
@@ -26,9 +23,9 @@ export default class LslWebSocketBridge implements WebSocketBridge {
         this.throwIfNoLocalServerOrRemoteSockets()
     }
 
-    public static async Create(options: WebSocketBridgeOptions) {
+    public static async Create(options: LslWsBridgeOptions) {
         const { listenPort, connectUrls, ...rest } = options
-        const inletOptions: StreamInletOptions = rest
+        const inletOptions: LslInletOptions = rest
 
         const localServer = this.WebSocketServer(listenPort)
         const remoteSockets = this.createSocketsFrom(connectUrls)
@@ -155,7 +152,7 @@ export default class LslWebSocketBridge implements WebSocketBridge {
     }
 
     private static async LslStreamInlet(
-        options: StreamInletOptions,
+        options: LslInletOptions,
         localServer?: WebSocketServer,
         remoteSockets?: WebSocket[]
     ) {
@@ -164,25 +161,25 @@ export default class LslWebSocketBridge implements WebSocketBridge {
     }
 }
 
-export interface WebSocketBridge {
+export interface LslWsBridge {
     activate(): Promise<void>
     deactivate(): void
     destroy(): void
 }
 
-export type WebSocketBridgeConstructor = new (
-    options: WebSocketBridgeConstructorOptions
-) => WebSocketBridge
+export type LslWsBridgeConstructor = new (
+    options: LslWsBridgeConstructorOptions
+) => LslWsBridge
 
-export interface WebSocketBridgeOptions {
+export interface LslWsBridgeOptions {
     sourceId: string
     chunkSize: number
     listenPort?: number
     connectUrls?: string | string[]
 }
 
-export interface WebSocketBridgeConstructorOptions extends WebSocketBridgeOptions {
-    inlet: StreamInlet
+export interface LslWsBridgeConstructorOptions extends LslWsBridgeOptions {
+    inlet: LslInlet
     localServer?: WebSocketServer
     remoteSockets?: WebSocket[]
 }

package/src/impl/clocks/WindowedClockRegressor.ts

@@ -0,0 +1,136 @@
+export default class WindowedClockRegressor implements ClockRegressor {
+    public static Class?: ClockRegressorConstructor
+
+    private readonly nominalHz: number
+    private readonly windowLenSec: number
+    private readonly defaultWindowLenSec = 30
+    private readonly history: {
+        deviceTime: number
+        earliestLslTime: number
+    }[] = []
+
+    private slope = 1 // lsl-host-seconds per device-second
+
+    protected constructor(
+        nominalHz: number,
+        options?: WindowedClockRegressorOptions
+    ) {
+        const { windowLenSec = this.defaultWindowLenSec } = options ?? {}
+
+        this.nominalHz = nominalHz
+        this.windowLenSec = windowLenSec
+    }
+
+    public static Create(
+        nominalHz: number,
+        options?: WindowedClockRegressorOptions
+    ) {
+        return new (this.Class ?? this)(nominalHz, options)
+    }
+
+    public deriveTimestamps(
+        deviceTime: number,
+        earliestLslTime: number,
+        chunkSize: number
+    ) {
+        this.throwIfDeviceTimeDoesNotIncrease(deviceTime)
+
+        this.history.push({ deviceTime, earliestLslTime })
+        this.pruneHistoryOutsideWindow()
+        this.refitSlope()
+
+        const anchor = this.anchorTimeFor(deviceTime)
+
+        const timestamps = Array(chunkSize).fill(0)
+
+        for (let i = 0; i <= chunkSize - 1; i++) {
+            const stepsFromLast = chunkSize - 1 - i
+            const deviceTimeOffset = -stepsFromLast / this.nominalHz
+            const lslTimeOffset = deviceTimeOffset * this.slope
+
+            timestamps[i] = anchor + lslTimeOffset
+        }
+
+        return timestamps
+    }
+
+    private anchorTimeFor(deviceTime: number) {
+        const xMean = this.currentMeanDeviceTime
+        const yMean = this.currentMeanLslTime
+
+        return yMean + this.slope * (deviceTime - xMean)
+    }
+
+    private throwIfDeviceTimeDoesNotIncrease(deviceTime: number) {
+        const last = this.history[this.history.length - 1]
+
+        if (last && deviceTime <= last.deviceTime) {
+            throw new Error(
+                `\nDevice time (${deviceTime}) did not increase from the previous device time (${last.deviceTime})! Device time is expected to always increase between calls, so this likely indicates a bug in the calling code.\n`
+            )
+        }
+    }
+
+    private pruneHistoryOutsideWindow() {
+        const { deviceTime: latest } = this.history[this.history.length - 1]
+        const cutoff = latest - this.windowLenSec
+
+        while (this.history.length > 0 && this.history[0].deviceTime < cutoff) {
+            this.history.shift()
+        }
+    }
+
+    private refitSlope() {
+        if (this.history.length < 2) {
+            return
+        }
+
+        const xMean = this.currentMeanDeviceTime
+        const yMean = this.currentMeanLslTime
+
+        let numerator = 0
+        let denominator = 0
+
+        for (const { deviceTime, earliestLslTime } of this.history) {
+            const xCentered = deviceTime - xMean
+
+            numerator += xCentered * (earliestLslTime - yMean)
+            denominator += xCentered * xCentered
+        }
+
+        this.slope = numerator / denominator
+    }
+
+    private get currentMeanDeviceTime() {
+        const totalDeviceTime = this.history.reduce(
+            (sum, { deviceTime }) => sum + deviceTime,
+            0
+        )
+        return totalDeviceTime / this.history.length
+    }
+
+    private get currentMeanLslTime() {
+        const totalLslTime = this.history.reduce(
+            (sum, { earliestLslTime }) => sum + earliestLslTime,
+            0
+        )
+        return totalLslTime / this.history.length
+    }
+}
+
+export interface ClockRegressor {
+    deriveTimestamps(
+        deviceTime: number,
+        earliestLslTime: number,
+        chunkSize: number
+    ): number[]
+}
+
+export type ClockRegressorConstructor = new (
+    nominalHz: number,
+    options?: WindowedClockRegressorOptions
+) => ClockRegressor
+
+export interface WindowedClockRegressorOptions {
+    windowLenSec?: number
+}

package/src/impl/controllers/BleDeviceController.ts

@@ -44,7 +44,7 @@ export default class BleDeviceController implements BleController {
         this.rssiIntervalMs = rssiIntervalMs
     }
 
-    public static async Create(options: BleControllerOptions) {
+    public static Create(options: BleControllerOptions) {
         return new (this.Class ?? this)(options)
     }
 
@@ -165,6 +165,19 @@ export default class BleDeviceController implements BleController {
         this.throwIfError(status, error)
     }
 
+    public async subscribeCharacteristics(
+        charCallbacks: CharacteristicCallbacks
+    ) {
+        const { status, error } = this.ndx.addBleCharCallbacks({
+            deviceUuid: this.uuid,
+            charCallbacks,
+        })
+
+        this.throwIfError(status, error)
+
+        this.charCallbacks = [...this.charCallbacks, ...charCallbacks]
+    }
+
     public async disconnect() {
         const { status, error } = this.ndx.stopBleBackend({
             deviceUuid: this.uuid,
@@ -193,6 +206,10 @@ export interface BleController {
 
     connect(): Promise<void>
 
+    subscribeCharacteristics(
+        charCallbacks: CharacteristicCallbacks
+    ): Promise<void>
+
     writeCharacteristic(
         charUuid: CharacteristicUuid,
         value: string

package/src/impl/controllers/UsbDeviceController.ts

@@ -0,0 +1,65 @@
+import { LibndxAdapter } from '@neurodevs/ndx-native'
+
+export default class UsbDeviceController implements UsbController {
+    public static Class?: UsbControllerConstructor
+
+    private onData: (data: Buffer, length: number, timestampSec: number) => void
+    private serialNumber: string
+
+    private ndx = LibndxAdapter.getInstance()
+
+    protected constructor(options: UsbControllerOptions) {
+        const { onData, serialNumber } = options ?? {}
+
+        this.onData = onData
+        this.serialNumber = serialNumber ?? ''
+    }
+
+    public static Create(options: UsbControllerOptions) {
+        return new (this.Class ?? this)(options)
+    }
+
+    public async connect() {
+        this.ndx.createUsbBackend(this.usbControllerOptions)
+        this.ndx.startUsbBackend(this.startUsbControllerOptions)
+    }
+
+    private get usbControllerOptions() {
+        return {
+            serialNumber: this.serialNumber,
+        }
+    }
+
+    private get startUsbControllerOptions() {
+        return {
+            ...this.usbControllerOptions,
+            onData: this.onData,
+        }
+    }
+
+    public async writeUsb(value: string) {
+        this.ndx.writeUsbBackend({
+            ...this.usbControllerOptions,
+            value,
+        })
+    }
+
+    public async disconnect() {
+        this.ndx.stopUsbBackend(this.usbControllerOptions)
+    }
+}
+
+export interface UsbController {
+    connect(): Promise<void>
+    writeUsb(value: string): Promise<void>
+    disconnect(): Promise<void>
+}
+
+export interface UsbControllerOptions {
+    onData: (data: Buffer, length: number, timestampSec: number) => void
+    serialNumber?: string
+}
+
+export type UsbControllerConstructor = new (
+    options?: UsbControllerOptions
+) => UsbController

package/src/index.ts

@@ -1,66 +1,86 @@
+// ClockRegressor
+
+export { default as WindowedClockRegressor } from './impl/clocks/WindowedClockRegressor.js'
+export * from './impl/clocks/WindowedClockRegressor.js'
+
+export { default as FakeClockRegressor } from './testDoubles/ClockRegressor/FakeClockRegressor.js'
+export * from './testDoubles/ClockRegressor/FakeClockRegressor.js'
+
 // DeviceController
 
 export { default as BleDeviceController } from './impl/controllers/BleDeviceController.js'
 export * from './impl/controllers/BleDeviceController.js'
 
+export { default as SpyBleController } from './testDoubles/BleController/SpyBleController.js'
+export * from './testDoubles/BleController/SpyBleController.js'
+
 export { default as FakeBleController } from './testDoubles/BleController/FakeBleController.js'
 export * from './testDoubles/BleController/FakeBleController.js'
 
-export { default as SpyBleController } from './testDoubles/BleController/SpyBleController.js'
-export * from './testDoubles/BleController/SpyBleController.js'
+// LslWsBridge
 
-// EventMarkerEmitter
+export { default as LslWebSocketBridge } from './impl/LslWebSocketBridge.js'
+export * from './impl/LslWebSocketBridge.js'
+
+export { default as SpyLslWsBridge } from './testDoubles/LslWsBridge/SpyLslWsBridge.js'
+export * from './testDoubles/LslWsBridge/SpyLslWsBridge.js'
+
+export { default as FakeLslWsBridge } from './testDoubles/LslWsBridge/FakeLslWsBridge.js'
+export * from './testDoubles/LslWsBridge/FakeLslWsBridge.js'
+
+// LslEmitter
 
 export { default as LslEventMarkerEmitter } from './impl/LslEventMarkerEmitter.js'
 export * from './impl/LslEventMarkerEmitter.js'
 
-export { default as FakeEventMarkerEmitter } from './testDoubles/EventMarkerEmitter/FakeEventMarkerEmitter.js'
-export * from './testDoubles/EventMarkerEmitter/FakeEventMarkerEmitter.js'
+export { default as SpyLslEmitter } from './testDoubles/LslEmitter/SpyLslEmitter.js'
+export * from './testDoubles/LslEmitter/SpyLslEmitter.js'
 
-export { default as SpyEventMarkerEmitter } from './testDoubles/EventMarkerEmitter/SpyEventMarkerEmitter.js'
-export * from './testDoubles/EventMarkerEmitter/SpyEventMarkerEmitter.js'
+export { default as FakeLslEmitter } from './testDoubles/LslEmitter/FakeLslEmitter.js'
+export * from './testDoubles/LslEmitter/FakeLslEmitter.js'
 
-export { default as ThrowingEventMarkerEmitter } from './testDoubles/EventMarkerEmitter/ThrowingEventMarkerEmitter.js'
-export * from './testDoubles/EventMarkerEmitter/ThrowingEventMarkerEmitter.js'
+export { default as ThrowingLslEmitter } from './testDoubles/LslEmitter/ThrowingLslEmitter.js'
+export * from './testDoubles/LslEmitter/ThrowingLslEmitter.js'
 
-// StreamInfo
+// LslInfo
 
 export { default as LslStreamInfo } from './impl/LslStreamInfo.js'
 export * from './impl/LslStreamInfo.js'
 
-export { default as SpyStreamInfo } from './testDoubles/StreamInfo/SpyStreamInfo.js'
-export * from './testDoubles/StreamInfo/SpyStreamInfo.js'
+export { default as SpyLslInfo } from './testDoubles/LslInfo/SpyLslInfo.js'
+export * from './testDoubles/LslInfo/SpyLslInfo.js'
 
-export { default as FakeStreamInfo } from './testDoubles/StreamInfo/FakeStreamInfo.js'
-export * from './testDoubles/StreamInfo/FakeStreamInfo.js'
+export { default as FakeLslInfo } from './testDoubles/LslInfo/FakeLslInfo.js'
+export * from './testDoubles/LslInfo/FakeLslInfo.js'
 
-// StreamInlet
+// LslInlet
 
 export { default as LslStreamInlet } from './impl/LslStreamInlet.js'
 export * from './impl/LslStreamInlet.js'
 
-export { default as FakeStreamInlet } from './testDoubles/StreamInlet/FakeStreamInlet.js'
-export * from './testDoubles/StreamInlet/FakeStreamInlet.js'
+export { default as SpyLslInlet } from './testDoubles/LslInlet/SpyLslInlet.js'
+export * from './testDoubles/LslInlet/SpyLslInlet.js'
 
-// StreamOutlet
+export { default as FakeLslInlet } from './testDoubles/LslInlet/FakeLslInlet.js'
+export * from './testDoubles/LslInlet/FakeLslInlet.js'
+
+// LslOutlet
 
 export { default as LslStreamOutlet } from './impl/LslStreamOutlet.js'
 export * from './impl/LslStreamOutlet.js'
 
-export { default as FakeStreamOutlet } from './testDoubles/StreamOutlet/FakeStreamOutlet.js'
-export * from './testDoubles/StreamOutlet/FakeStreamOutlet.js'
-
-// WebSocketBridge
+export { default as FakeLslOutlet } from './testDoubles/LslOutlet/FakeLslOutlet.js'
+export * from './testDoubles/LslOutlet/FakeLslOutlet.js'
 
-export { default as LslWebSocketBridge } from './impl/LslWebSocketBridge.js'
-export * from './impl/LslWebSocketBridge.js'
+export { default as generateRandomOutletOptions } from './testDoubles/generateRandomOutletOptions.js'
 
-export { default as FakeWebSocketBridge } from './testDoubles/WebSocketBridge/FakeWebSocketBridge.js'
-export * from './testDoubles/WebSocketBridge/FakeWebSocketBridge.js'
+// UsbController
 
-// Utils
+export { default as UsbDeviceController } from './impl/controllers/UsbDeviceController.js'
+export * from './impl/controllers/UsbDeviceController.js'
 
-export { default as generateRandomOutletOptions } from './testDoubles/generateRandomOutletOptions.js'
+export { default as FakeUsbController } from './testDoubles/UsbController/FakeUsbController.js'
+export * from './testDoubles/UsbController/FakeUsbController.js'
 
 // WebSockets
 

package/src/scripts/{runLslEventMarkerEmitter.ts → runLslEmitter.ts}

@@ -1,6 +1,6 @@
 import LslEventMarkerEmitter from '../impl/LslEventMarkerEmitter.js'
 
-const outlet = await LslEventMarkerEmitter.Create()
+const emitter = await LslEventMarkerEmitter.Create()
 
 const markers = [
     { name: 'phase-1-begin', waitAfterMs: 100 },
@@ -8,8 +8,9 @@ const markers = [
     { name: 'never-reached-marker', waitAfterMs: 100 },
 ]
 
-void outlet.emitMany(markers)
+void emitter.emitMany(markers)
 
 await new Promise((resolve) => setTimeout(resolve, 250))
 
-outlet.interrupt()
+emitter.interrupt()
+emitter.destroy()

package/src/scripts/runMuse.ts

@@ -32,7 +32,7 @@ const charCallbacks = Object.entries(MUSE_CHARACTERISTIC_UUIDS).map(
     }
 )
 
-const muse = await BleDeviceController.Create({
+const muse = BleDeviceController.Create({
     deviceUuid: 'CA6A61B7-B7A8-AF24-3C9E-04A6A5012554',
     charCallbacks,
     rssiIntervalMs: 1000,

package/src/scripts/runUsb.ts

@@ -0,0 +1,20 @@
+import UsbDeviceController from '../impl/controllers/UsbDeviceController.js'
+
+console.info('\nCreating UsbDeviceController...')
+
+const controller = UsbDeviceController.Create({
+    serialNumber: 'DP04WG8J',
+    onData: (_data: Buffer, length: number, timestampSec: number) => {
+        console.info(`[${timestampSec}] Buffer length: ${length}`)
+    },
+})
+
+console.info('Connecting to UsbDeviceController...')
+
+await controller.connect()
+
+console.info('Waiting for 10 seconds...')
+
+await new Promise((resolve) => setTimeout(resolve, 10000))
+
+console.info('Done!')

package/src/testDoubles/BleController/FakeBleController.ts

@@ -2,6 +2,7 @@ import generateId from '@neurodevs/generate-id'
 import {
     BleController,
     BleControllerOptions,
+    CharacteristicCallbacks,
 } from '../../impl/controllers/BleDeviceController.js'
 
 export default class FakeBleController implements BleController {
@@ -14,6 +15,9 @@ export default class FakeBleController implements BleController {
         value: string
     }[] = []
 
+    public static callsToSubscribeCharacteristics: CharacteristicCallbacks[] =
+        []
+
     public static numCallsToDisconnect = 0
 
     public static fakeCharacteristics: Record<string, unknown> = {}
@@ -45,6 +49,12 @@ export default class FakeBleController implements BleController {
         })
     }
 
+    public async subscribeCharacteristics(
+        charCallbacks: CharacteristicCallbacks
+    ) {
+        FakeBleController.callsToSubscribeCharacteristics.push(charCallbacks)
+    }
+
     public async disconnect() {
         FakeBleController.numCallsToDisconnect++
     }
@@ -61,6 +71,7 @@ export default class FakeBleController implements BleController {
         this.callsToConstructor = []
         this.numCallsToConnect = 0
         this.callsToWriteCharacteristic = []
+        this.callsToSubscribeCharacteristics = []
         this.numCallsToDisconnect = 0
     }
 }

package/src/testDoubles/ClockRegressor/FakeClockRegressor.ts

@@ -0,0 +1,46 @@
+import {
+    ClockRegressor,
+    WindowedClockRegressorOptions,
+} from '../../impl/clocks/WindowedClockRegressor.js'
+
+export default class FakeClockRegressor implements ClockRegressor {
+    public static callsToConstructor: {
+        nominalHz: number
+        options?: WindowedClockRegressorOptions
+    }[] = []
+    public static callsToDeriveTimestamps: {
+        deviceTime: number
+        earliestLslTime: number
+        chunkSize: number
+    }[] = []
+
+    public static fakeResultValue = 0
+
+    public readonly nominalHz: number
+
+    public constructor(
+        nominalHz: number,
+        options?: WindowedClockRegressorOptions
+    ) {
+        FakeClockRegressor.callsToConstructor.push({ nominalHz, options })
+        this.nominalHz = nominalHz
+    }
+
+    public deriveTimestamps(
+        deviceTime: number,
+        earliestLslTime: number,
+        chunkSize: number
+    ) {
+        FakeClockRegressor.callsToDeriveTimestamps.push({
+            deviceTime,
+            earliestLslTime,
+            chunkSize,
+        })
+        return Array(chunkSize).fill(FakeClockRegressor.fakeResultValue)
+    }
+
+    public static resetTestDouble() {
+        FakeClockRegressor.callsToConstructor = []
+        FakeClockRegressor.callsToDeriveTimestamps = []
+    }
+}

package/src/testDoubles/{EventMarkerEmitter/FakeEventMarkerEmitter.ts → LslEmitter/FakeLslEmitter.ts}

@@ -1,15 +1,15 @@
 import {
-    EventMarkerEmitter,
-    EventMarkerOptions,
+    LslEmitter,
+    EmitOptions,
     TimedEventMarker,
 } from '../../impl/LslEventMarkerEmitter.js'
 
-export default class FakeEventMarkerEmitter implements EventMarkerEmitter {
+export default class FakeLslEmitter implements LslEmitter {
     public static numCallsToConstructor = 0
 
     public static callsToEmit: {
         markerName: string
-        options?: EventMarkerOptions
+        options?: EmitOptions
     }[] = []
 
     public static callsToEmitMany: TimedEventMarker[][] = []
@@ -17,23 +17,23 @@ export default class FakeEventMarkerEmitter implements EventMarkerEmitter {
     public static numCallsToDestroy = 0
 
     public constructor() {
-        FakeEventMarkerEmitter.numCallsToConstructor++
+        FakeLslEmitter.numCallsToConstructor++
     }
 
-    public async emit(markerName: string, options?: EventMarkerOptions) {
-        FakeEventMarkerEmitter.callsToEmit.push({ markerName, options })
+    public async emit(markerName: string, options?: EmitOptions) {
+        FakeLslEmitter.callsToEmit.push({ markerName, options })
     }
 
     public async emitMany(markers: TimedEventMarker[]) {
-        FakeEventMarkerEmitter.callsToEmitMany.push(markers)
+        FakeLslEmitter.callsToEmitMany.push(markers)
     }
 
     public interrupt() {
-        FakeEventMarkerEmitter.numCallsToInterrupt++
+        FakeLslEmitter.numCallsToInterrupt++
     }
 
     public destroy() {
-        FakeEventMarkerEmitter.numCallsToDestroy++
+        FakeLslEmitter.numCallsToDestroy++
     }
 
     public static resetTestDouble() {

package/src/testDoubles/{EventMarkerEmitter/SpyEventMarkerEmitter.ts → LslEmitter/SpyLslEmitter.ts}

@@ -1,12 +1,12 @@
 import LslEventMarkerEmitter from '../../impl/LslEventMarkerEmitter.js'
-import { StreamOutlet } from '../../impl/LslStreamOutlet.js'
+import { LslOutlet } from '../../impl/LslStreamOutlet.js'
 
-export default class SpyEventMarkerEmitter extends LslEventMarkerEmitter {
+export default class SpyLslEmitter extends LslEventMarkerEmitter {
     public static shouldCallWaitOnSuper = false
 
     public totalwaitAfterMs: number
 
-    public constructor(outlet: StreamOutlet) {
+    public constructor(outlet: LslOutlet) {
         super(outlet)
 
         this.totalwaitAfterMs = 0
@@ -15,7 +15,7 @@ export default class SpyEventMarkerEmitter extends LslEventMarkerEmitter {
     public async wait(waitAfterMs: number) {
         this.totalwaitAfterMs += waitAfterMs
 
-        if (SpyEventMarkerEmitter.shouldCallWaitOnSuper) {
+        if (SpyLslEmitter.shouldCallWaitOnSuper) {
             return super.wait(waitAfterMs)
         }
         return Promise.resolve()

package/src/testDoubles/{EventMarkerEmitter/ThrowingEventMarkerEmitter.ts → LslEmitter/ThrowingLslEmitter.ts}

@@ -1,17 +1,17 @@
 import {
-    EventMarkerEmitter,
-    EventMarkerOptions,
+    LslEmitter,
+    EmitOptions,
     TimedEventMarker,
 } from '../../impl/LslEventMarkerEmitter.js'
 
-export default class ThrowingEventMarkerEmitter implements EventMarkerEmitter {
+export default class ThrowingLslEmitter implements LslEmitter {
     private errorMsg = 'Intentional throwing: '
 
     public constructor() {
         throw new Error(this.errorMsg + 'constructor')
     }
 
-    public async emit(_markerName: string, _options?: EventMarkerOptions) {
+    public async emit(_markerName: string, _options?: EmitOptions) {
         throw new Error(this.errorMsg + 'emit')
     }