@neurodevs/node-lsl 17.0.0 → 17.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neurodevs/node-lsl",
-  "version": "17.0.0",
+  "version": "17.1.1",
   "description": "Lab Streaming Layer (LSL) bindings for Node",
   "type": "module",
   "keywords": [
@@ -45,27 +45,27 @@
   },
   "dependencies": {
     "@neurodevs/generate-id": "^1.0.9",
-    "ffi-rs": "^1.3.0",
-    "node-gyp": "^10.2.0",
+    "ffi-rs": "^1.3.1",
+    "node-gyp": "^12.1.0",
     "ref-array-napi": "^1.2.2",
     "ref-napi": "^3.0.3",
     "ws": "^8.18.3"
   },
   "devDependencies": {
-    "@neurodevs/node-tdd": "^0.2.2",
+    "@neurodevs/node-tdd": "^0.2.3",
     "@types/ffi-napi": "^4.0.10",
-    "@types/node": "^22.9.0",
+    "@types/node": "^25.0.2",
     "@types/ws": "^8.18.1",
     "chokidar-cli": "^3.0.0",
-    "concurrently": "^9.1.0",
-    "eslint": "^9.15.0",
+    "concurrently": "^9.2.1",
+    "eslint": "^9.39.2",
     "eslint-config-spruce": "^11.2.26",
-    "jest": "^29.7.0",
-    "jest-circus": "^29.7.0",
-    "prettier": "^3.3.3",
+    "jest": "^30.2.0",
+    "jest-circus": "^30.2.0",
+    "prettier": "^3.7.4",
     "ts-node": "^10.9.2",
-    "tsc-watch": "^6.2.1",
-    "typescript": "^5.6.3"
+    "tsc-watch": "^7.2.0",
+    "typescript": "^5.9.3"
   },
   "jest": {
     "testRunner": "jest-circus/runner",

package/src/__tests__/AbstractPackageTest.ts

@@ -1,7 +1,6 @@
 import AbstractModuleTest from '@neurodevs/node-tdd'
-import WebSocket from 'ws'
+import WebSocket, { Server } from 'ws'
 
-import { Server } from 'ws'
 import LiblslAdapter from '../impl/LiblslAdapter.js'
 import LslEventMarkerOutlet from '../impl/LslEventMarkerOutlet.js'
 import LslStreamInfo from '../impl/LslStreamInfo.js'
@@ -11,6 +10,7 @@ import LslStreamInlet, {
 } from '../impl/LslStreamInlet.js'
 import LslStreamOutlet from '../impl/LslStreamOutlet.js'
 import LslWebSocketBridge from '../impl/LslWebSocketBridge.js'
+
 import SpyEventMarkerOutlet from '../testDoubles/EventMarkerOutlet/SpyEventMarkerOutlet.js'
 import FakeLiblsl from '../testDoubles/Liblsl/FakeLiblsl.js'
 import FakeStreamInfo from '../testDoubles/StreamInfo/FakeStreamInfo.js'
@@ -78,6 +78,7 @@ export default class AbstractPackageTest extends AbstractModuleTest {
         FakeWebSocketServer.resetTestDouble()
     }
 
+    protected static readonly info = new FakeStreamInfo()
     protected static readonly name_ = this.generateId()
     protected static readonly type = this.generateId()
     protected static readonly sourceId = this.generateId()
@@ -102,14 +103,9 @@ export default class AbstractPackageTest extends AbstractModuleTest {
         onData: OnDataCallback
     ) {
         const defaultOptions = {
-            sampleRateHz: 0,
-            channelNames: this.channelNames,
-            channelFormat: 'float32',
+            info: this.info,
             chunkSize: this.chunkSize,
             maxBufferedMs: this.maxBufferedMs,
-            name: this.name_,
-            type: this.type,
-            sourceId: this.sourceId,
             ...options,
         } as StreamInletOptions
 

package/src/__tests__/impl/LslStreamInfo.test.ts

@@ -196,7 +196,7 @@ export default class LslStreamInfoTest extends AbstractPackageTest {
         assert.isEqualDeep(
             this.fakeLiblsl.lastAppendChannelsToStreamInfoOptions,
             {
-                info: this.instance.getBoundInfo(),
+                info: this.instance.boundInfo,
                 channels: this.channelNames.map((label: string) => ({
                     label,
                     units: this.units,
@@ -213,15 +213,15 @@ export default class LslStreamInfoTest extends AbstractPackageTest {
 
         assert.isEqualDeep(
             this.fakeLiblsl.lastDestroyStreamInfoOptions?.info,
-            this.instance.getBoundInfo(),
+            this.instance.boundInfo,
             'Should have called destroyStreamInfo!'
         )
     }
 
     @test()
-    protected static async doesNotCreateNewStreamInfoIfPassedBoundStreamInfo() {
+    protected static async doesNotCreateNewStreamInfoIfPassedBoundInfo() {
         this.LslStreamInfo({
-            boundStreamInfo: this.instance.getBoundInfo(),
+            boundInfo: this.instance.boundInfo,
         })
 
         assert.isEqual(
@@ -232,21 +232,21 @@ export default class LslStreamInfoTest extends AbstractPackageTest {
     }
 
     @test()
-    protected static async setsBoundStreamInfoWhenPassed() {
+    protected static async setsBoundInfoWhenPassed() {
         const instance = this.LslStreamInfo({
-            boundStreamInfo: this.instance.getBoundInfo(),
+            boundInfo: this.instance.boundInfo,
         })
 
         assert.isEqualDeep(
-            instance.getBoundInfo(),
-            this.instance.getBoundInfo(),
+            instance.boundInfo,
+            this.instance.boundInfo,
             'Should have set bound stream info!'
         )
     }
 
     @test()
-    protected static async cachesInfoAttributesByBoundStreamInfo() {
-        const cached = LslStreamInfo.From(this.instance.getBoundInfo())
+    protected static async cachesInfoAttributesByBoundInfo() {
+        const cached = LslStreamInfo.From(this.instance.boundInfo)
 
         assert.isEqualDeep(
             cached,

package/src/__tests__/impl/LslStreamInlet.test.ts

@@ -1,16 +1,11 @@
 import { test, assert } from '@neurodevs/node-tdd'
-import { BoundStreamInfo } from '../../impl/LiblslAdapter.js'
-import LslStreamInfo, { StreamInfo } from '../../impl/LslStreamInfo.js'
+
 import { StreamInletOptions } from '../../impl/LslStreamInlet.js'
-import FakeLiblsl from '../../testDoubles/Liblsl/FakeLiblsl.js'
-import FakeStreamInfo from '../../testDoubles/StreamInfo/FakeStreamInfo.js'
 import { SpyStreamInlet } from '../../testDoubles/StreamInlet/SpyStreamInlet.js'
 import AbstractPackageTest from '../AbstractPackageTest.js'
 
 export default class LslStreamInletTest extends AbstractPackageTest {
     private static instance: SpyStreamInlet
-    private static outletInfo: StreamInfo
-    private static passedHandle?: BoundStreamInfo
 
     private static callsToOnData: {
         samples: Float32Array
@@ -26,26 +21,6 @@ export default class LslStreamInletTest extends AbstractPackageTest {
 
         this.callsToOnData = []
 
-        this.outletInfo = LslStreamInfo.Create({
-            sourceId: this.sourceId,
-            channelNames: [],
-            channelFormat: 'float32',
-            sampleRateHz: 0,
-        })
-
-        FakeStreamInfo.resetTestDouble()
-
-        FakeLiblsl.fakeStreamInfoHandles = [
-            this.outletInfo.boundStreamInfo as bigint,
-        ]
-
-        const From = LslStreamInfo.From.bind(LslStreamInfo)
-
-        LslStreamInfo.From = (handle: BoundStreamInfo) => {
-            this.passedHandle = handle
-            return From(handle) as FakeStreamInfo
-        }
-
         this.instance = await this.LslStreamInlet()
     }
 
@@ -54,15 +29,6 @@ export default class LslStreamInletTest extends AbstractPackageTest {
         assert.isTruthy(this.instance, 'Failed to create instance!')
     }
 
-    @test()
-    protected static async createsStreamInfoWithExpectedOptions() {
-        assert.isEqualDeep(
-            this.passedHandle,
-            this.outletInfo.boundStreamInfo,
-            'Stream info should have expected options!'
-        )
-    }
-
     @test()
     protected static async callsBindingsToCreateStreamInlet() {
         const fakeInfo = this.instance.getStreamInfo()
@@ -72,7 +38,7 @@ export default class LslStreamInletTest extends AbstractPackageTest {
         assert.isEqualDeep(
             this.fakeLiblsl.lastCreateInletOptions,
             {
-                info: fakeInfo.boundStreamInfo,
+                info: fakeInfo.boundInfo,
                 maxBufferedMs: this.maxBufferedMs,
             },
             'Should have called createInlet!'
@@ -101,6 +67,30 @@ export default class LslStreamInletTest extends AbstractPackageTest {
         )
     }
 
+    @test()
+    protected static async destroyCallsStopIfIsRunning() {
+        this.instance.startPulling()
+        this.instance.destroy()
+
+        assert.isFalse(
+            this.instance.isRunning,
+            'Did not stop inlet before destroying!'
+        )
+    }
+
+    @test()
+    protected static async destroyDoesNotCallStopIfNotRunning() {
+        let wasHit = false
+
+        this.instance.stopPulling = () => {
+            wasHit = true
+        }
+
+        this.instance.destroy()
+
+        assert.isFalse(wasHit, 'Stop should not have been called!')
+    }
+
     @test()
     protected static async exposesIsRunningFieldThatIsFalseAtFirst() {
         assert.isFalse(this.isRunning, 'isRunning should be false at first!')

package/src/__tests__/impl/LslWebSocketBridge.test.ts

@@ -1,10 +1,10 @@
 import { randomInt } from 'crypto'
-
 import { test, assert } from '@neurodevs/node-tdd'
 
 import LslWebSocketBridge, {
     WebSocketBridgeOptions,
 } from '../../impl/LslWebSocketBridge.js'
+import FakeStreamInfo from '../../testDoubles/StreamInfo/FakeStreamInfo.js'
 import FakeStreamInlet from '../../testDoubles/StreamInlet/FakeStreamInlet.js'
 import SpyLslWebSocketBridge from '../../testDoubles/WebSocketBridge/SpyLslWebSocketBridge.js'
 import FakeWebSocket from '../../testDoubles/WebSockets/FakeWebSocket.js'
@@ -34,12 +34,14 @@ export default class LslWebSocketBridgeTest extends AbstractPackageTest {
 
     @test()
     protected static async createsLslStreamInlet() {
-        const { sourceId, chunkSize } =
-            FakeStreamInlet.callsToConstructor[0]?.options ?? {}
+        const call = FakeStreamInlet.callsToConstructor[0]
+
+        const info = call?.info
+        const chunkSize = call?.options?.chunkSize
 
         assert.isEqualDeep(
             {
-                sourceId,
+                info,
                 chunkSize,
             },
             this.inletOptions
@@ -276,7 +278,7 @@ export default class LslWebSocketBridgeTest extends AbstractPackageTest {
     private static readonly connectUrls = [this.generateId(), this.generateId()]
 
     private static readonly inletOptions = {
-        sourceId: this.generateId(),
+        info: new FakeStreamInfo(),
         chunkSize: randomInt(1, 100),
     }
 

package/src/impl/LiblslAdapter.ts

@@ -267,12 +267,12 @@ export default class LiblslAdapter implements Liblsl {
             ],
             paramsValue: [
                 inlet,
-                unwrapPointer([dataBufferPtr])[0],
-                unwrapPointer([timestampBufferPtr])[0],
+                dataBufferPtr,
+                timestampBufferPtr,
                 dataBufferElements,
                 timestampBufferElements,
                 timeout,
-                unwrapPointer([errcodePtr])[0],
+                errcodePtr,
             ],
         })
     }
@@ -494,14 +494,9 @@ export interface PullSampleOptions {
     errcodePtr: JsExternal
 }
 
-export interface PullChunkOptions {
-    inlet: BoundInlet
-    dataBufferPtr: JsExternal
+export interface PullChunkOptions extends PullSampleOptions {
     timestampBufferPtr: JsExternal
-    dataBufferElements: number
     timestampBufferElements: number
-    timeout: number
-    errcodePtr: JsExternal
 }
 
 export interface FlushInletOptions {

package/src/impl/LslStreamInfo.ts

@@ -17,26 +17,20 @@ export default class LslStreamInfo implements StreamInfo {
     public readonly channelFormat: ChannelFormat
     public readonly sampleRateHz: number
     public readonly units: string
-
-    protected boundInfo!: BoundStreamInfo
-
-    private readonly defaultName = `lsl-stream-info-${generateId()}`
-    private readonly defaultType = generateId()
-    private readonly defaultSourceId = generateId()
-    private readonly defaultUnits = 'N/A'
+    public readonly boundInfo: BoundStreamInfo
 
     private lsl = LiblslAdapter.getInstance()
 
     protected constructor(options: StreamInfoOptions) {
         const {
-            name = this.defaultName,
-            type = this.defaultType,
-            sourceId = this.defaultSourceId,
+            name = `lsl-stream-info-${generateId()}`,
+            type = generateId(),
+            sourceId = generateId(),
             channelNames,
             channelFormat,
             sampleRateHz,
-            units = this.defaultUnits,
-            boundStreamInfo,
+            units = 'N/A',
+            boundInfo,
         } = options
 
         this.name = name
@@ -48,18 +42,18 @@ export default class LslStreamInfo implements StreamInfo {
         this.sampleRateHz = sampleRateHz
         this.units = units
 
-        if (!boundStreamInfo) {
-            this.createStreamInfo()
+        if (!boundInfo) {
+            this.boundInfo = this.createStreamInfo()
             this.appendChannelsToStreamInfo()
         } else {
-            this.boundInfo = boundStreamInfo
+            this.boundInfo = boundInfo
         }
     }
 
     public static Create(options: StreamInfoOptions) {
         const instance = new (this.Class ?? this)(options)
 
-        const { boundStreamInfo: handle } = instance
+        const { boundInfo: handle } = instance
         this.instanceCache.set(handle, instance)
 
         return instance
@@ -70,7 +64,7 @@ export default class LslStreamInfo implements StreamInfo {
     }
 
     private createStreamInfo() {
-        this.boundInfo = this.lsl.createStreamInfo({
+        return this.lsl.createStreamInfo({
             name: this.name,
             type: this.type,
             sourceId: this.sourceId,
@@ -98,14 +92,6 @@ export default class LslStreamInfo implements StreamInfo {
     public destroy() {
         this.lsl.destroyStreamInfo({ info: this.boundInfo })
     }
-
-    public get boundStreamInfo() {
-        return this.boundInfo
-    }
-
-    public set boundStreamInfo(boundInfo: BoundStreamInfo) {
-        this.boundInfo = boundInfo
-    }
 }
 
 export interface StreamInfo {
@@ -118,7 +104,7 @@ export interface StreamInfo {
     readonly channelCount: number
     readonly channelFormat: ChannelFormat
     readonly sampleRateHz: number
-    boundStreamInfo: BoundStreamInfo
+    readonly boundInfo: BoundStreamInfo
 }
 
 type StreamInfoConstructor = new (options: StreamInfoOptions) => StreamInfo
@@ -131,5 +117,5 @@ export interface StreamInfoOptions {
     type?: string
     sourceId?: string
     units?: string
-    boundStreamInfo?: BoundStreamInfo
+    boundInfo?: BoundStreamInfo
 }

package/src/impl/LslStreamInlet.ts

@@ -3,7 +3,7 @@ import { createPointer, DataType, JsExternal, unwrapPointer } from 'ffi-rs'
 import handleError from '../handleError.js'
 import { BoundInlet } from './LiblslAdapter.js'
 import LiblslAdapter from './LiblslAdapter.js'
-import LslStreamInfo, { StreamInfo } from './LslStreamInfo.js'
+import { StreamInfo } from './LslStreamInfo.js'
 
 export default class LslStreamInlet implements StreamInlet {
     public static Class?: StreamInletConstructor
@@ -25,12 +25,15 @@ export default class LslStreamInlet implements StreamInlet {
     }
 
     private dataBuffer!: Buffer<ArrayBuffer>
+    private wrappedDataBufferPtr!: JsExternal[]
     private dataBufferPtr!: JsExternal
 
     private timestampBuffer!: Buffer<ArrayBuffer>
+    private wrappedTimestampBufferPtr!: JsExternal[]
     private timestampBufferPtr!: JsExternal
 
     private errorCodeBuffer!: Buffer<ArrayBuffer>
+    private wrappedErrorCodeBufferPtr!: JsExternal[]
     private errorCodeBufferPtr!: JsExternal
 
     private readonly sixMinutesInMs = 360 * 1000
@@ -39,7 +42,7 @@ export default class LslStreamInlet implements StreamInlet {
 
     protected constructor(
         info: StreamInfo,
-        options: StreamInletOptions,
+        options: StreamInletConstructorOptions,
         onData: OnDataCallback
     ) {
         const { chunkSize, maxBufferedMs, timeoutMs } = options ?? {}
@@ -59,8 +62,7 @@ export default class LslStreamInlet implements StreamInlet {
         options: StreamInletOptions,
         onData: OnDataCallback
     ) {
-        const { sourceId } = options
-        const info = await this.LslStreamInfo(sourceId)
+        const { info } = options
         return new (this.Class ?? this)(info, options, onData)
     }
 
@@ -74,15 +76,11 @@ export default class LslStreamInlet implements StreamInlet {
 
     private createBoundInlet() {
         this.inlet = this.lsl.createInlet({
-            info: this.boundStreamInfo,
+            info: this.info.boundInfo,
             maxBufferedMs: this.maxBufferedMs,
         })
     }
 
-    private get boundStreamInfo() {
-        return this.info.boundStreamInfo
-    }
-
     public startPulling() {
         this.isRunning = true
 
@@ -127,29 +125,33 @@ export default class LslStreamInlet implements StreamInlet {
     }
 
     private createDataBufferPtr() {
-        this.dataBufferPtr = unwrapPointer(
-            createPointer({
-                paramsType: [DataType.U8Array],
-                paramsValue: [this.dataBuffer],
-            })
-        )[0]
+        this.wrappedDataBufferPtr = createPointer({
+            paramsType: [DataType.U8Array],
+            paramsValue: [this.dataBuffer],
+        })
+
+        this.dataBufferPtr = unwrapPointer(this.wrappedDataBufferPtr)[0]
     }
 
     private createTimestampBufferPtr() {
+        this.wrappedTimestampBufferPtr = createPointer({
+            paramsType: [DataType.U8Array],
+            paramsValue: [this.timestampBuffer],
+        })
+
         this.timestampBufferPtr = unwrapPointer(
-            createPointer({
-                paramsType: [DataType.U8Array],
-                paramsValue: [this.timestampBuffer],
-            })
+            this.wrappedTimestampBufferPtr
         )[0]
     }
 
     private createErrorCodeBufferPtr() {
+        this.wrappedErrorCodeBufferPtr = createPointer({
+            paramsType: [DataType.U8Array],
+            paramsValue: [this.errorCodeBuffer],
+        })
+
         this.errorCodeBufferPtr = unwrapPointer(
-            createPointer({
-                paramsType: [DataType.U8Array],
-                paramsValue: [this.errorCodeBuffer],
-            })
+            this.wrappedErrorCodeBufferPtr
         )[0]
     }
 
@@ -171,7 +173,7 @@ export default class LslStreamInlet implements StreamInlet {
     private pullSample() {
         const timestamp = this.callPullSampleBinding()
 
-        if (timestamp) {
+        if (timestamp > 0) {
             return {
                 samples: this.createFloatArrayFromDataBuffer(),
                 timestamps: new Float64Array([timestamp]),
@@ -201,7 +203,7 @@ export default class LslStreamInlet implements StreamInlet {
     private pullChunk() {
         const firstTimestamp = this.callPullChunkBinding()
 
-        if (firstTimestamp) {
+        if (firstTimestamp > 0) {
             return {
                 samples: this.createFloatArrayFromDataBuffer(),
                 timestamps: this.createDoubleArrayFromTimestampBuffer(),
@@ -214,8 +216,8 @@ export default class LslStreamInlet implements StreamInlet {
         return this.lsl.pullChunk({
             inlet: this.inlet,
             dataBufferPtr: this.dataBufferPtr,
-            timestampBufferPtr: this.timestampBufferPtr,
             dataBufferElements: this.chunkSize * this.channelCount,
+            timestampBufferPtr: this.timestampBufferPtr,
             timestampBufferElements: this.chunkSize,
             timeout: this.timeoutMs / 1000,
             errcodePtr: this.errorCodeBufferPtr,
@@ -243,23 +245,15 @@ export default class LslStreamInlet implements StreamInlet {
     }
 
     public destroy() {
+        if (this.isRunning) {
+            this.stopPulling()
+        }
         this.destroyBoundInlet()
     }
 
     private destroyBoundInlet() {
         this.lsl.destroyInlet({ inlet: this.inlet })
     }
-
-    private static async LslStreamInfo(sourceId: string) {
-        const lsl = LiblslAdapter.getInstance()
-
-        const handles = await lsl.resolveByProp({
-            prop: 'source_id',
-            value: sourceId,
-        })
-
-        return LslStreamInfo.From(handles[0])
-    }
 }
 
 export interface StreamInlet {
@@ -272,17 +266,19 @@ export interface StreamInlet {
 
 export type StreamInletConstructor = new (
     info: StreamInfo,
-    options: StreamInletOptions,
+    options: StreamInletConstructorOptions,
     onData: OnDataCallback
 ) => StreamInlet
 
 export interface StreamInletOptions {
-    sourceId: string
+    info: StreamInfo
     chunkSize: number
     maxBufferedMs?: number
     timeoutMs?: number
 }
 
+export type StreamInletConstructorOptions = Omit<StreamInletOptions, 'info'>
+
 export type OnDataCallback = (
     samples: Float32Array,
     timestamps: Float64Array

package/src/impl/LslStreamOutlet.ts

@@ -21,6 +21,7 @@ import LslStreamInfo, {
 export default class LslStreamOutlet implements StreamOutlet {
     public static Class?: StreamOutletConstructor
 
+    public readonly info: StreamInfo
     public readonly name: string
     public readonly type: string
     public readonly sourceId: string
@@ -33,7 +34,6 @@ export default class LslStreamOutlet implements StreamOutlet {
     public readonly manufacturer: string = 'N/A'
     public readonly units: string = 'N/A'
 
-    private info: StreamInfo
     private boundOutlet!: BoundOutlet
     private pushSampleMethod!: (options: unknown) => LslErrorCode
 
@@ -109,16 +109,12 @@ export default class LslStreamOutlet implements StreamOutlet {
 
     private createStreamOutlet() {
         this.boundOutlet = this.lsl.createOutlet({
-            info: this.boundStreamInfo,
+            info: this.info.boundInfo,
             chunkSize: this.chunkSize,
             maxBufferedMs: this.maxBufferedMs,
         })
     }
 
-    private get boundStreamInfo() {
-        return this.info.boundStreamInfo
-    }
-
     private setPushSampleMethod() {
         this.pushSampleMethod = (
             this.lsl[this.pushMethod] as (options: unknown) => LslErrorCode
@@ -146,12 +142,12 @@ export default class LslStreamOutlet implements StreamOutlet {
     }
 
     public destroy() {
-        this.destroyBoundStreamInfo()
+        this.destroyBoundInfo()
         this.destroyBoundOutlet()
     }
 
-    private destroyBoundStreamInfo() {
-        this.lsl.destroyStreamInfo({ info: this.boundStreamInfo })
+    private destroyBoundInfo() {
+        this.lsl.destroyStreamInfo({ info: this.info.boundInfo })
     }
 
     private destroyBoundOutlet() {
@@ -190,6 +186,7 @@ export default class LslStreamOutlet implements StreamOutlet {
 export interface StreamOutlet {
     pushSample(sample: LslSample): void
     destroy(): void
+    readonly info: StreamInfo
     readonly name: string
     readonly type: string
     readonly sourceId: string

package/src/impl/LslWebSocketBridge.ts

@@ -1,4 +1,5 @@
 import WebSocket, { WebSocketServer } from 'ws'
+import { StreamInfo } from './LslStreamInfo.js'
 import LslStreamInlet, {
     StreamInlet,
     StreamInletOptions,
@@ -153,7 +154,7 @@ export default class LslWebSocketBridge implements WebSocketBridge {
         return listenPort ? new this.WSS({ port: listenPort }) : undefined
     }
 
-    private static LslStreamInlet(
+    private static async LslStreamInlet(
         options: StreamInletOptions,
         localServer?: WebSocketServer,
         remoteSockets?: WebSocket[]
@@ -174,14 +175,13 @@ export type WebSocketBridgeConstructor = new (
 ) => WebSocketBridge
 
 export interface WebSocketBridgeOptions {
-    sourceId: string
+    info: StreamInfo
     chunkSize: number
     listenPort?: number
     connectUrls?: string | string[]
 }
 
-export interface WebSocketBridgeConstructorOptions
-    extends WebSocketBridgeOptions {
+export interface WebSocketBridgeConstructorOptions extends WebSocketBridgeOptions {
     inlet: StreamInlet
     localServer?: WebSocketServer
     remoteSockets?: WebSocket[]