@neurodevs/node-lsl 19.0.0 → 22.0.0

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

@@ -1,18 +1,17 @@
 import { test, assert } from '@neurodevs/node-tdd'
 
-import { CHANNEL_FORMATS } from '../../consts.js'
-import LslStreamInfo, { StreamInfoOptions } from '../../impl/LslStreamInfo.js'
-import SpyStreamInfo from '../../testDoubles/StreamInfo/SpyStreamInfo.js'
+import LslStreamInfo, { LslInfoOptions } from '../../impl/LslStreamInfo.js'
+import SpyLslInfo from '../../testDoubles/LslInfo/SpyLslInfo.js'
 import AbstractPackageTest from '../AbstractPackageTest.js'
+import { CHANNEL_FORMATS } from '@neurodevs/ndx-native'
 
 export default class LslStreamInfoTest extends AbstractPackageTest {
-    private static instance: SpyStreamInfo
+    private static instance: SpyLslInfo
 
     protected static async beforeEach() {
         await super.beforeEach()
 
-        this.setFakeLiblsl()
-        this.setSpyStreamInfo()
+        this.setSpyLslInfo()
 
         this.instance = this.LslStreamInfo()
     }
@@ -225,12 +224,12 @@ export default class LslStreamInfoTest extends AbstractPackageTest {
         channelNames: this.channelNames,
         channelFormat: 'float32',
         sampleRateHz: 100 * Math.random(),
-    } as StreamInfoOptions
+    } as LslInfoOptions
 
-    private static LslStreamInfo(options?: Partial<StreamInfoOptions>) {
+    private static LslStreamInfo(options?: Partial<LslInfoOptions>) {
         return LslStreamInfo.Create({
             ...this.defaultOptions,
             ...options,
-        }) as SpyStreamInfo
+        }) as SpyLslInfo
     }
 }

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

@@ -1,5 +1,3 @@
-import { Worker } from 'node:worker_threads'
-
 import { FakeLiblsl } from '@neurodevs/ndx-native'
 import { test, assert } from '@neurodevs/node-tdd'
 import {
@@ -11,16 +9,12 @@ import {
     unwrapPointer,
 } from 'ffi-rs'
 
-import LslStreamInlet, {
-    StreamInletOptions,
-} from '../../impl/LslStreamInlet.js'
-import StreamInletWorker from '../../impl/workers/inlet/StreamInletWorker.js'
-import { SpyStreamInlet } from '../../testDoubles/StreamInlet/SpyStreamInlet.js'
-import FakeWorker from '../../testDoubles/WorkerThreads/FakeWorker.js'
+import LslStreamInlet, { LslInletOptions } from '../../impl/LslStreamInlet.js'
+import SpyLslInlet from '../../testDoubles/LslInlet/SpyLslInlet.js'
 import AbstractPackageTest from '../AbstractPackageTest.js'
 
 export default class LslStreamInletTest extends AbstractPackageTest {
-    private static instance: SpyStreamInlet
+    private static instance: SpyLslInlet
 
     private static callsToOnData: {
         samples: number[]
@@ -59,21 +53,14 @@ export default class LslStreamInletTest extends AbstractPackageTest {
     protected static async beforeEach() {
         await super.beforeEach()
 
-        this.setFakeLiblsl()
-        this.setFakeStreamInfo()
-        this.setSpyStreamInlet()
+        this.setFakeLslInfo()
+        this.setSpyLslInlet()
 
         this.callsToOnData = []
 
         LslStreamInlet.waitAfterOpenStreamMs = 0
-
-        LslStreamInlet.Worker = FakeWorker as unknown as typeof Worker
-        FakeWorker.resetTestDoubles()
-
-        StreamInletWorker.lsl = this.fakeLiblsl
-        StreamInletWorker.freePointer = () => {}
-
-        FakeWorker.fakeOnData = this.onData
+        LslStreamInlet.lsl = this.fakeLiblsl
+        LslStreamInlet.freePointer = () => {}
 
         this.instance = await this.LslStreamInlet()
     }
@@ -133,7 +120,7 @@ export default class LslStreamInletTest extends AbstractPackageTest {
 
         let calls: FreePointerParams[] = []
 
-        StreamInletWorker.freePointer = (params: FreePointerParams) => {
+        LslStreamInlet.freePointer = (params: FreePointerParams) => {
             calls.push(params)
         }
 
@@ -201,9 +188,7 @@ export default class LslStreamInletTest extends AbstractPackageTest {
         await this.startPulling()
 
         assert.isEqual(
-            FakeWorker.callsToPostMessage.filter(
-                (msg) => msg.type === 'startPulling'
-            ).length,
+            this.fakeLiblsl.createInletHitCount,
             1,
             'startPulling did not return early!'
         )
@@ -243,7 +228,7 @@ export default class LslStreamInletTest extends AbstractPackageTest {
         assert.isEqualDeep(
             this.fakeLiblsl.lastOpenStreamOptions,
             {
-                inletHandle: this.inletHandle,
+                inletHandle: instance['inletHandle'],
                 timeoutMs: openStreamTimeoutMs,
                 errorCodePtr: this.errorCodePtr,
             },
@@ -253,27 +238,6 @@ export default class LslStreamInletTest extends AbstractPackageTest {
         instance.stopPulling()
     }
 
-    @test()
-    protected static async waitsAfterOpeningStreamWithPassedOption() {
-        const waitAfterOpenStreamMs = 10
-
-        const instance = await this.LslStreamInlet({
-            waitAfterOpenStreamMs,
-        })
-
-        let t0 = Date.now()
-        await this.startPulling(instance)
-        let elapsed = Date.now() - t0
-
-        instance.stopPulling()
-
-        assert.isAbove(
-            elapsed,
-            waitAfterOpenStreamMs * 0.8,
-            'Did not wait after opening stream!'
-        )
-    }
-
     @test()
     protected static async stopPullingClosesInletStream() {
         await this.startPulling()
@@ -386,15 +350,10 @@ export default class LslStreamInletTest extends AbstractPackageTest {
     protected static async pushSampleHandlesErrorCode() {
         let passedErrorCode: number | undefined
 
-        StreamInletWorker.handleLslError = (errorCode: number) => {
+        LslStreamInlet.handleLslError = (errorCode: number) => {
             passedErrorCode = errorCode
         }
 
-        const fakeErrorCode = [-4, -3, -2, -1, 0][Math.floor(Math.random() * 5)]
-        const worker = this.getFakeWorker()
-
-        worker['inletWorker']['pullErrorBuffer'].writeInt32LE(fakeErrorCode)
-
         await this.startThenStop()
 
         assert.isEqualDeep(
@@ -414,10 +373,9 @@ export default class LslStreamInletTest extends AbstractPackageTest {
 
         let pulls = 0
 
-        const inletWorker = this.getFakeWorker(instance)['inletWorker']
-        const original = inletWorker['pullDataOnce'].bind(inletWorker)
+        const original = instance['pullDataOnce'].bind(instance)
 
-        inletWorker['pullDataOnce'] = async () => {
+        instance['pullDataOnce'] = async () => {
             pulls++
             await original()
         }
@@ -508,32 +466,23 @@ export default class LslStreamInletTest extends AbstractPackageTest {
     }
 
     private static async runInletWithOptions(
-        options?: Partial<StreamInletOptions>
+        options?: Partial<LslInletOptions>
     ) {
         const inlet = await this.LslStreamInlet(options)
+        this.instance = inlet
         await this.startThenStop(inlet)
         return inlet
     }
 
-    private static async startThenStop(inlet?: SpyStreamInlet) {
+    private static async startThenStop(inlet?: SpyLslInlet) {
         const instance = inlet || this.instance
         await this.startPulling(instance)
         await this.wait(10)
         instance.stopPulling()
     }
 
-    private static async startPulling(instance?: SpyStreamInlet) {
-        const inst = instance || this.instance
-        const startPullingPromise = inst.startPulling()
-
-        while (!this.getFakeWorker(inst).createInletPromise) {
-            await this.wait(1)
-        }
-
-        await this.getFakeWorker(inst).createInletPromise
-        inst['workerReady'] = true
-
-        await startPullingPromise
+    private static async startPulling(instance?: SpyLslInlet) {
+        await (instance || this.instance).startPulling()
     }
 
     private static stopPulling() {
@@ -549,26 +498,19 @@ export default class LslStreamInletTest extends AbstractPackageTest {
     }
 
     private static get inletHandle() {
-        return this.getFakeWorker()['inletWorker']['inletHandle']
-    }
-
-    private static getFakeWorker(instance?: SpyStreamInlet) {
-        const inst = instance || this.instance
-        return inst['worker'] as unknown as FakeWorker
+        return this.instance['inletHandle']
     }
 
     private static onData = (samples: number[], timestamps: number[]) => {
         this.callsToOnData.push({ samples, timestamps })
     }
 
-    protected static async LslStreamInlet(
-        options?: Partial<StreamInletOptions>
-    ) {
+    protected static async LslStreamInlet(options?: Partial<LslInletOptions>) {
         return (await AbstractPackageTest.LslStreamInlet(
             {
                 ...options,
             },
             this.onData
-        )) as SpyStreamInlet
+        )) as SpyLslInlet
     }
 }

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

@@ -1,27 +1,25 @@
-import { Worker } from 'node:worker_threads'
-import { ChannelFormat, LslSample, FakeLiblsl } from '@neurodevs/ndx-native'
+import {
+    ChannelFormat,
+    LslSample,
+    FakeLiblsl,
+    CHANNEL_FORMATS,
+} from '@neurodevs/ndx-native'
 import { test, assert } from '@neurodevs/node-tdd'
 
-import { CHANNEL_FORMATS } from '../../consts.js'
 import LslStreamOutlet, {
-    StreamOutletOptions,
+    LslOutletOptions,
 } from '../../impl/LslStreamOutlet.js'
-import {
-    setOutletHandleLslError,
-    setOutletLiblslAdapter,
-} from '../../impl/workers/outlet/LslStreamOutlet.worker.js'
 import {
     TEST_SUPPORTED_CHANNEL_FORMATS,
     TEST_UNSUPPORTED_CHANNEL_FORMATS,
     TestChannelFormat,
 } from '../../testDoubles/consts.js'
 import generateRandomOutletOptions from '../../testDoubles/generateRandomOutletOptions.js'
-import FakeStreamInfo from '../../testDoubles/StreamInfo/FakeStreamInfo.js'
-import FakeWorker from '../../testDoubles/WorkerThreads/FakeWorker.js'
+import FakeLslInfo from '../../testDoubles/LslInfo/FakeLslInfo.js'
 import AbstractPackageTest from '../AbstractPackageTest.js'
 
 export default class LslStreamOutletTest extends AbstractPackageTest {
-    private static randomOutletOptions: StreamOutletOptions
+    private static randomOutletOptions: LslOutletOptions
 
     protected static async beforeEach() {
         await super.beforeEach()
@@ -30,13 +28,9 @@ export default class LslStreamOutletTest extends AbstractPackageTest {
 
         this.randomOutletOptions = generateRandomOutletOptions()
 
-        this.setFakeLiblsl()
-        this.setFakeStreamInfo()
-
-        LslStreamOutlet.Worker = FakeWorker as unknown as typeof Worker
-        FakeWorker.resetTestDoubles()
+        this.setFakeLslInfo()
 
-        setOutletLiblslAdapter(this.fakeLiblsl)
+        LslStreamOutlet.lsl = this.fakeLiblsl
     }
 
     @test()
@@ -175,7 +169,7 @@ export default class LslStreamOutletTest extends AbstractPackageTest {
     protected static async constructionCreatesStreamInfo() {
         await this.LslStreamOutlet()
 
-        assert.isEqualDeep(FakeStreamInfo.callsToConstructor[0], {
+        assert.isEqualDeep(FakeLslInfo.callsToConstructor[0], {
             channelNames: this.randomOutletOptions.channelNames,
             channelFormat: this.randomOutletOptions.channelFormat,
             sampleRateHz: this.randomOutletOptions.sampleRateHz,
@@ -241,9 +235,9 @@ export default class LslStreamOutletTest extends AbstractPackageTest {
     protected static async pushSampleHandlesErrorCode() {
         let passedErrorCode: number | undefined
 
-        setOutletHandleLslError((errorCode: number) => {
+        LslStreamOutlet.handleLslError = (errorCode: number) => {
             passedErrorCode = errorCode
-        })
+        }
 
         FakeLiblsl.fakeErrorCode = [-4, -3, -2, -1, 0][
             Math.floor(Math.random() * 5)
@@ -346,7 +340,7 @@ export default class LslStreamOutletTest extends AbstractPackageTest {
     }
 
     private static async createAndAssertThrows(
-        option: keyof StreamOutletOptions,
+        option: keyof LslOutletOptions,
         value: number | string[] | ChannelFormat,
         expectedMessage: string
     ) {
@@ -368,9 +362,7 @@ export default class LslStreamOutletTest extends AbstractPackageTest {
         return await this.LslStreamOutlet({ channelFormat: 'float32' })
     }
 
-    private static async LslStreamOutlet(
-        options?: Partial<StreamOutletOptions>
-    ) {
+    private static async LslStreamOutlet(options?: Partial<LslOutletOptions>) {
         return await LslStreamOutlet.Create({
             ...this.randomOutletOptions,
             ...options,
@@ -379,7 +371,7 @@ export default class LslStreamOutletTest extends AbstractPackageTest {
 }
 
 class CheckingOutlet extends LslStreamOutlet {
-    public constructor(options: StreamOutletOptions) {
+    public constructor(options: LslOutletOptions) {
         super(options)
     }
 }

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

@@ -2,30 +2,28 @@ import { randomInt } from 'node:crypto'
 
 import { test, assert } from '@neurodevs/node-tdd'
 
-import { StreamInletOptions } from '../../impl/LslStreamInlet.js'
+import { LslInletOptions } from '../../impl/LslStreamInlet.js'
 import LslWebSocketBridge, {
-    WebSocketBridgeOptions,
+    LslWsBridgeOptions,
 } from '../../impl/LslWebSocketBridge.js'
-import FakeStreamInlet from '../../testDoubles/StreamInlet/FakeStreamInlet.js'
-import SpyLslWebSocketBridge from '../../testDoubles/WebSocketBridge/SpyLslWebSocketBridge.js'
+import FakeLslInlet from '../../testDoubles/LslInlet/FakeLslInlet.js'
+import SpyLslWsBridge from '../../testDoubles/LslWsBridge/SpyLslWsBridge.js'
 import FakeWebSocket from '../../testDoubles/WebSockets/FakeWebSocket.js'
 import FakeWebSocketServer from '../../testDoubles/WebSockets/FakeWebSocketServer.js'
 import AbstractPackageTest from '../AbstractPackageTest.js'
 
 export default class LslWebSocketBridgeTest extends AbstractPackageTest {
-    private static instance: SpyLslWebSocketBridge
+    private static instance: SpyLslWsBridge
 
     protected static async beforeEach() {
         await super.beforeEach()
 
-        this.setFakeLiblsl()
-        this.setFakeStreamInlet()
+        this.setFakeLslInlet()
         this.setFakeWebSocket()
         this.setFakeWebSocketServer()
-        this.setSpyLslWebSocketBridge()
+        this.setSpyLslWsBridge()
 
-        this.instance =
-            (await this.LslWebSocketBridge()) as SpyLslWebSocketBridge
+        this.instance = (await this.LslWebSocketBridge()) as SpyLslWsBridge
     }
 
     @test()
@@ -35,7 +33,7 @@ export default class LslWebSocketBridgeTest extends AbstractPackageTest {
 
     @test()
     protected static async createsLslStreamInlet() {
-        const call = FakeStreamInlet.callsToConstructor[0]
+        const call = FakeLslInlet.callsToConstructor[0]
 
         const sourceId = call.options!.sourceId
         const chunkSize = call.options!.chunkSize
@@ -54,7 +52,7 @@ export default class LslWebSocketBridgeTest extends AbstractPackageTest {
         await this.activate()
 
         assert.isEqual(
-            FakeStreamInlet.numCallsToStartPulling,
+            FakeLslInlet.numCallsToStartPulling,
             1,
             'Did not call startPulling on inlet!'
         )
@@ -66,7 +64,7 @@ export default class LslWebSocketBridgeTest extends AbstractPackageTest {
         this.deactivate()
 
         assert.isEqual(
-            FakeStreamInlet.numCallsToStopPulling,
+            FakeLslInlet.numCallsToStopPulling,
             1,
             'Did not call stopPulling on inlet!'
         )
@@ -77,7 +75,7 @@ export default class LslWebSocketBridgeTest extends AbstractPackageTest {
         this.destroy()
 
         assert.isEqual(
-            FakeStreamInlet.numCallsToDestroy,
+            FakeLslInlet.numCallsToDestroy,
             1,
             'Did not call destroy on inlet!'
         )
@@ -270,7 +268,7 @@ export default class LslWebSocketBridgeTest extends AbstractPackageTest {
         const samples = [...new Float32Array([1, 2, 3, 4, 5, 6])]
         const timestamps = [...new Float64Array([7, 8])]
 
-        FakeStreamInlet.callsToConstructor[0]?.onData!(samples, timestamps)
+        FakeLslInlet.callsToConstructor[0]?.onData!(samples, timestamps)
         return { samples, timestamps }
     }
 
@@ -278,7 +276,7 @@ export default class LslWebSocketBridgeTest extends AbstractPackageTest {
 
     private static readonly connectUrls = [this.generateId(), this.generateId()]
 
-    private static readonly inletOptions: StreamInletOptions = {
+    private static readonly inletOptions: LslInletOptions = {
         sourceId: this.sourceId,
         chunkSize: randomInt(1, 100),
     }
@@ -289,9 +287,7 @@ export default class LslWebSocketBridgeTest extends AbstractPackageTest {
         connectUrls: this.connectUrls,
     }
 
-    private static LslWebSocketBridge(
-        options?: Partial<WebSocketBridgeOptions>
-    ) {
+    private static LslWebSocketBridge(options?: Partial<LslWsBridgeOptions>) {
         return LslWebSocketBridge.Create({ ...this.baseOptions, ...options })
     }
 }

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

@@ -1,13 +1,13 @@
 import { test, assert } from '@neurodevs/node-tdd'
 
 import UsbDeviceController, {
-    UsbController,
+    UsbDevice,
 } from '../../impl/controllers/UsbDeviceController.js'
 import AbstractPackageTest from '../AbstractPackageTest.js'
 import { FakeLibndx } from '@neurodevs/ndx-native'
 
 export default class UsbDeviceControllerTest extends AbstractPackageTest {
-    private static instance: UsbController
+    private static instance: UsbDevice
 
     private static readonly serialNumber = this.generateId()
     private static readonly valueToWrite = this.generateId()

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

@@ -4,7 +4,7 @@ import { test, assert } from '@neurodevs/node-tdd'
 
 import WindowedClockRegressor, {
     ClockRegressor,
-} from '../../impl/WindowedClockRegressor.js'
+} from '../../impl/clocks/WindowedClockRegressor.js'
 import AbstractPackageTest from '../AbstractPackageTest.js'
 
 export default class WindowedClockRegressorTest extends AbstractPackageTest {

package/src/assertions.ts

@@ -1,6 +1,5 @@
-import { ChannelFormat } from '@neurodevs/ndx-native'
+import { CHANNEL_FORMATS, ChannelFormat } from '@neurodevs/ndx-native'
 
-import { CHANNEL_FORMATS } from './consts.js'
 import {
     isGreaterThanOrEqualToZero,
     isPositiveInteger,

package/src/impl/{LslEventMarkerEmitter.ts → LslEventMarkerOutlet.ts}

@@ -1,28 +1,28 @@
 import { generateShortId } from '@neurodevs/generate-id'
 
 import LslStreamOutlet, {
-    StreamOutletOptions,
-    StreamOutlet,
+    LslOutletOptions,
+    LslOutlet,
 } from './LslStreamOutlet.js'
 
-export default class LslEventMarkerEmitter implements EventMarkerEmitter {
-    public static Class?: EventMarkerEmitterConstructor
+export default class LslEventMarkerOutlet implements EventMarkerOutlet {
+    public static Class?: EventMarkerOutletConstructor
 
-    protected outlet: StreamOutlet
+    protected outlet: LslOutlet
     private isRunning = false
     private waitResolve?: () => void
     private timeout?: any
 
-    protected constructor(outlet: StreamOutlet) {
+    protected constructor(outlet: LslOutlet) {
         this.outlet = outlet
     }
 
-    public static async Create(options?: EventMarkerEmitterOptions) {
+    public static async Create(options?: EventMarkerOutletOptions) {
         const outlet = await this.LslStreamOutlet(options)
         return new (this.Class ?? this)(outlet)
     }
 
-    public async emit(markerName: string, options?: EventMarkerOptions) {
+    public async emit(markerName: string, options?: EmitOptions) {
         this.throwIfAlreadyRunning('emit')
         this.isRunning = true
 
@@ -99,10 +99,10 @@ export default class LslEventMarkerEmitter implements EventMarkerEmitter {
             channelFormat: 'string',
             sampleRateHz: 0,
             chunkSize: 1,
-        } as StreamOutletOptions
+        } as LslOutletOptions
     }
 
-    private static LslStreamOutlet(options?: Partial<StreamOutletOptions>) {
+    private static LslStreamOutlet(options?: Partial<LslOutletOptions>) {
         return LslStreamOutlet.Create({
             ...this.generateDefaultOutletOptions(),
             ...options,
@@ -110,20 +110,20 @@ export default class LslEventMarkerEmitter implements EventMarkerEmitter {
     }
 }
 
-export interface EventMarkerEmitter {
-    emit(markerName: string, options?: EventMarkerOptions): Promise<void>
+export interface EventMarkerOutlet {
+    emit(markerName: string, options?: EmitOptions): Promise<void>
     emitMany(markers: TimedEventMarker[]): Promise<void>
     interrupt(): void
     destroy(): void
 }
 
-export type EventMarkerEmitterOptions = Partial<StreamOutletOptions>
+export type EventMarkerOutletOptions = Partial<LslOutletOptions>
 
-export type EventMarkerEmitterConstructor = new (
-    outlet: StreamOutlet
-) => EventMarkerEmitter
+export type EventMarkerOutletConstructor = new (
+    outlet: LslOutlet
+) => EventMarkerOutlet
 
-export interface EventMarkerOptions {
+export interface EmitOptions {
     waitAfterMs?: number
 }
 

package/src/impl/LslJsonOutlet.ts

@@ -0,0 +1,87 @@
+import LslStreamOutlet, { LslOutlet } from './LslStreamOutlet.js'
+
+export default class LslJsonOutlet implements JsonOutlet {
+    public static Class?: JsonOutletConstructor
+    public static backupIdCounter = 0
+
+    private outlet: LslOutlet
+    private maxBytesPerSample?: number
+
+    protected constructor(outlet: LslOutlet, maxBytesPerSample?: number) {
+        this.outlet = outlet
+        this.maxBytesPerSample = maxBytesPerSample
+    }
+
+    public static async Create(options?: JsonOutletOptions) {
+        const outlet = await this.LslStreamOutlet(options)
+        return new (this.Class ?? this)(outlet, options?.maxBytesPerSample)
+    }
+
+    public pushJson(data: Json) {
+        const json = JSON.stringify(data)
+        this.throwIfPayloadTooLarge(json)
+        this.outlet.pushSample([json])
+    }
+
+    private throwIfPayloadTooLarge(json: string) {
+        const totalBytes = Buffer.byteLength(json)
+
+        if (this.maxBytesPerSample && totalBytes > this.maxBytesPerSample) {
+            throw new Error(
+                `Payload of ${totalBytes} bytes exceeds maxBytesPerSample of ${this.maxBytesPerSample}!`
+            )
+        }
+    }
+
+    public destroy() {
+        this.outlet.destroy()
+    }
+
+    private static LslStreamOutlet(options?: JsonOutletOptions) {
+        this.backupIdCounter++
+
+        const { channelName, maxBytesPerSample: _, ...rest } = options ?? {}
+
+        return LslStreamOutlet.Create({
+            name: `JSON (json-${this.backupIdCounter})`,
+            type: 'JSON',
+            sourceId: `json-${this.backupIdCounter}`,
+            channelNames: [channelName ?? 'JSON'],
+            channelFormat: 'string',
+            sampleRateHz: 0,
+            chunkSize: 1,
+            ...rest,
+        })
+    }
+}
+
+export interface JsonOutlet {
+    pushJson(data: Json): void
+    destroy(): void
+}
+
+export type Json = Record<string, unknown>
+
+export type JsonOutletConstructor = new (
+    outlet: LslOutlet,
+    maxBytesPerSample?: number
+) => JsonOutlet
+
+export interface JsonOutletOptions {
+    name?: string
+    type?: string
+    sourceId?: string
+    channelName?: string
+    sampleRateHz?: number
+    chunkSize?: number
+    maxBufferedMs?: number
+    maxBytesPerSample?: number
+    manufacturer?: string
+    units?: string
+    waitAfterConstructionMs?: number
+}
+
+export type JsonOutletConstructorOptions = Omit<
+    JsonOutletOptions,
+    'waitAfterConstructionMs'
+>