@neurodevs/node-lsl 19.0.0 → 22.0.0

package/build/testDoubles/WebSocketBridge/SpyLslWebSocketBridge.d.ts

@@ -1,4 +0,0 @@
-import LslWebSocketBridge, { WebSocketBridgeConstructorOptions } from '../../impl/LslWebSocketBridge.js';
-export default class SpyLslWebSocketBridge extends LslWebSocketBridge {
-    constructor(options: WebSocketBridgeConstructorOptions);
-}

package/build/testDoubles/WebSocketBridge/SpyLslWebSocketBridge.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SpyLslWebSocketBridge.js","sourceRoot":"","sources":["../../../src/testDoubles/WebSocketBridge/SpyLslWebSocketBridge.ts"],"names":[],"mappings":"AAAA,OAAO,kBAEN,MAAM,kCAAkC,CAAA;AAEzC,MAAM,CAAC,OAAO,OAAO,qBAAsB,SAAQ,kBAAkB;IACjE,YAAmB,OAA0C;QACzD,KAAK,CAAC,OAAO,CAAC,CAAA;IAClB,CAAC;CACJ"}

package/build/testDoubles/WorkerThreads/FakeWorker.d.ts

@@ -1,27 +0,0 @@
-import { WorkerOptions } from 'node:worker_threads';
-import { OnDataCallback } from '../../impl/LslStreamInlet.js';
-import StreamInletWorker from '../../impl/workers/inlet/StreamInletWorker.js';
-export default class FakeWorker {
-    static callsToConstructor: {
-        filename: string | URL;
-        options?: WorkerOptions;
-    }[];
-    static callsToPostMessage: WorkerMessage[];
-    static callsToOn: {
-        type: string;
-        listener: (...args: unknown[]) => void;
-    }[];
-    static inletWorker: StreamInletWorker;
-    static fakeOnData: OnDataCallback;
-    createInletPromise?: Promise<void>;
-    constructor(filename: string | URL, options?: WorkerOptions);
-    postMessage(msg: WorkerMessage): void;
-    on(type: string, listener: (...args: unknown[]) => void): void;
-    private get inletWorker();
-    private get fakeOnData();
-    static resetTestDoubles(): void;
-}
-export interface WorkerMessage {
-    type: string;
-    payload?: Record<string, unknown>[];
-}

package/build/testDoubles/WorkerThreads/FakeWorker.js

@@ -1,67 +0,0 @@
-import StreamInletWorker from '../../impl/workers/inlet/StreamInletWorker.js';
-import { createOutlet, destroyOutlet, pushSample, } from '../../impl/workers/outlet/LslStreamOutlet.worker.js';
-export default class FakeWorker {
-    static callsToConstructor = [];
-    static callsToPostMessage = [];
-    static callsToOn = [];
-    static inletWorker = new StreamInletWorker();
-    static fakeOnData;
-    createInletPromise;
-    constructor(filename, options) {
-        FakeWorker.callsToConstructor.push({ filename, options });
-    }
-    postMessage(msg) {
-        FakeWorker.callsToPostMessage.push(msg);
-        const { type } = msg;
-        switch (type) {
-            case 'createOutlet': {
-                createOutlet(msg);
-                break;
-            }
-            case 'pushSample': {
-                pushSample(msg);
-                break;
-            }
-            case 'destroyOutlet': {
-                destroyOutlet();
-                break;
-            }
-            case 'createInlet': {
-                const { payload } = msg;
-                this.createInletPromise = this.inletWorker.createInlet(payload);
-                break;
-            }
-            case 'startPulling': {
-                this.inletWorker.startPulling(this.fakeOnData);
-                break;
-            }
-            case 'flushInlet': {
-                this.inletWorker.flushInlet();
-                break;
-            }
-            case 'stopPulling': {
-                this.inletWorker.stopPulling();
-                break;
-            }
-            case 'destroyInlet': {
-                this.inletWorker.destroyInlet();
-                break;
-            }
-        }
-    }
-    on(type, listener) {
-        FakeWorker.callsToOn.push({ type, listener });
-    }
-    get inletWorker() {
-        return FakeWorker.inletWorker;
-    }
-    get fakeOnData() {
-        return FakeWorker.fakeOnData;
-    }
-    static resetTestDoubles() {
-        this.callsToConstructor = [];
-        this.callsToPostMessage = [];
-        this.callsToOn = [];
-    }
-}
-//# sourceMappingURL=FakeWorker.js.map

package/build/testDoubles/WorkerThreads/FakeWorker.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"FakeWorker.js","sourceRoot":"","sources":["../../../src/testDoubles/WorkerThreads/FakeWorker.ts"],"names":[],"mappings":"AAGA,OAAO,iBAAiB,MAAM,+CAA+C,CAAA;AAC7E,OAAO,EACH,YAAY,EACZ,aAAa,EACb,UAAU,GACb,MAAM,qDAAqD,CAAA;AAE5D,MAAM,CAAC,OAAO,OAAO,UAAU;IACpB,MAAM,CAAC,kBAAkB,GAG1B,EAAE,CAAA;IAED,MAAM,CAAC,kBAAkB,GAAoB,EAAE,CAAA;IAE/C,MAAM,CAAC,SAAS,GAGjB,EAAE,CAAA;IAED,MAAM,CAAC,WAAW,GAAG,IAAI,iBAAiB,EAAE,CAAA;IAC5C,MAAM,CAAC,UAAU,CAAgB;IAEjC,kBAAkB,CAAgB;IAEzC,YAAmB,QAAsB,EAAE,OAAuB;QAC9D,UAAU,CAAC,kBAAkB,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAA;IAC7D,CAAC;IAEM,WAAW,CAAC,GAAkB;QACjC,UAAU,CAAC,kBAAkB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;QAEvC,MAAM,EAAE,IAAI,EAAE,GAAG,GAAG,CAAA;QAEpB,QAAQ,IAAI,EAAE,CAAC;YACX,KAAK,cAAc,CAAC,CAAC,CAAC;gBAClB,YAAY,CAAC,GAAU,CAAC,CAAA;gBACxB,MAAK;YACT,CAAC;YACD,KAAK,YAAY,CAAC,CAAC,CAAC;gBAChB,UAAU,CAAC,GAAU,CAAC,CAAA;gBACtB,MAAK;YACT,CAAC;YACD,KAAK,eAAe,CAAC,CAAC,CAAC;gBACnB,aAAa,EAAE,CAAA;gBACf,MAAK;YACT,CAAC;YACD,KAAK,aAAa,CAAC,CAAC,CAAC;gBACjB,MAAM,EAAE,OAAO,EAAE,GAAG,GAAG,CAAA;gBACvB,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,WAAW,CAAC,WAAW,CAClD,OAAc,CACjB,CAAA;gBACD,MAAK;YACT,CAAC;YACD,KAAK,cAAc,CAAC,CAAC,CAAC;gBAClB,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,UAAU,CAAC,CAAA;gBAC9C,MAAK;YACT,CAAC;YACD,KAAK,YAAY,CAAC,CAAC,CAAC;gBAChB,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,CAAA;gBAC7B,MAAK;YACT,CAAC;YACD,KAAK,aAAa,CAAC,CAAC,CAAC;gBACjB,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,CAAA;gBAC9B,MAAK;YACT,CAAC;YACD,KAAK,cAAc,CAAC,CAAC,CAAC;gBAClB,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,CAAA;gBAC/B,MAAK;YACT,CAAC;QACL,CAAC;IACL,CAAC;IAEM,EAAE,CAAC,IAAY,EAAE,QAAsC;QAC1D,UAAU,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAA;IACjD,CAAC;IAED,IAAY,WAAW;QACnB,OAAO,UAAU,CAAC,WAAW,CAAA;IACjC,CAAC;IAED,IAAY,UAAU;QAClB,OAAO,UAAU,CAAC,UAAU,CAAA;IAChC,CAAC;IAEM,MAAM,CAAC,gBAAgB;QAC1B,IAAI,CAAC,kBAAkB,GAAG,EAAE,CAAA;QAC5B,IAAI,CAAC,kBAAkB,GAAG,EAAE,CAAA;QAC5B,IAAI,CAAC,SAAS,GAAG,EAAE,CAAA;IACvB,CAAC"}

package/src/consts.ts

@@ -1,21 +0,0 @@
-export const CHANNEL_FORMATS = [
-    'undefined',
-    'float32',
-    'double64',
-    'string',
-    'int32',
-    'int16',
-    'int8',
-    'int64',
-] as const
-
-export const CHANNEL_FORMATS_MAP = {
-    undefined: 0,
-    float32: 1,
-    double64: 2,
-    string: 3,
-    int32: 4,
-    int16: 5,
-    int8: 6,
-    int64: 7,
-}

package/src/impl/workers/inlet/LslStreamInlet.worker.ts

@@ -1,74 +0,0 @@
-import { parentPort } from 'node:worker_threads'
-import StreamInletWorker from './StreamInletWorker.js'
-
-const worker = new StreamInletWorker()
-
-parentPort?.on('message', async (msg: InletMessage) => {
-    try {
-        switch (msg.type) {
-            case 'createInlet':
-                const { payload } = msg
-                await worker.createInlet(payload)
-                parentPort?.postMessage({ type: 'ready' })
-                break
-
-            case 'startPulling':
-                worker.startPulling((samples, timestamps) => {
-                    parentPort?.postMessage({
-                        type: 'data',
-                        payload: {
-                            samples,
-                            timestamps,
-                        },
-                    })
-                })
-                break
-
-            case 'stopPulling':
-                worker.stopPulling()
-                break
-            case 'flushInlet':
-                worker.flushInlet()
-                break
-
-            case 'destroyInlet':
-                worker.destroyInlet()
-                parentPort?.close()
-                break
-        }
-    } catch (err) {
-        parentPort?.postMessage({
-            type: 'error',
-            error: err instanceof Error ? err.message : String(err),
-        })
-    }
-})
-
-export type InletMessage =
-    | {
-          type: 'createInlet'
-          payload: CreateInletPayload
-      }
-    | {
-          type: 'startPulling'
-      }
-    | {
-          type: 'flushInlet'
-      }
-    | {
-          type: 'stopPulling'
-      }
-    | {
-          type: 'destroyInlet'
-      }
-
-export interface CreateInletPayload {
-    sourceId: string
-    chunkSize: number
-    maxBufferedMs: number
-    openStreamTimeoutMs: number
-    waitAfterOpenStreamMs: number
-    pullTimeoutMs: number
-    waitBetweenPullsMs: number
-    flushInletOnStop: boolean
-}

package/src/impl/workers/inlet/StreamInletWorker.ts

@@ -1,348 +0,0 @@
-import {
-    handleLslError,
-    InfoHandle,
-    InletHandle,
-    LiblslAdapter,
-} from '@neurodevs/ndx-native'
-import {
-    JsExternal,
-    unwrapPointer,
-    createPointer,
-    DataType,
-    freePointer,
-    PointerType,
-} from 'ffi-rs'
-
-import { OnDataCallback } from '../../LslStreamInlet.js'
-import { CreateInletPayload } from './LslStreamInlet.worker.js'
-
-export default class StreamInletWorker {
-    public static lsl = LiblslAdapter.getInstance()
-    public static handleLslError = handleLslError
-    public static freePointer = freePointer
-
-    private sourceId!: string
-    private chunkSize!: number
-    private maxBufferedMs!: number
-    private openStreamTimeoutMs!: number
-    private waitAfterOpenStreamMs!: number
-    private waitBetweenPullsMs!: number
-    private pullTimeoutMs!: number
-    private flushInletOnStop!: boolean
-
-    private pullMethod!: () => {
-        samples: number[] | undefined
-        timestamps: number[] | undefined
-    }
-
-    protected infoHandle!: InfoHandle
-    protected inletHandle!: InletHandle
-    private channelCount!: number
-
-    private sampleBuffer!: Buffer<ArrayBuffer>
-    private sampleBufferRef!: JsExternal[]
-    private sampleBufferPtr!: JsExternal
-
-    private timestampBuffer!: Buffer<ArrayBuffer>
-    private timestampBufferRef!: JsExternal[]
-    private timestampBufferPtr!: JsExternal
-
-    private pullErrorBuffer!: Buffer<ArrayBuffer>
-    private pullErrorBufferRef!: JsExternal[]
-    private pullErrorBufferPtr!: JsExternal
-
-    private openStreamErrorBuffer!: Buffer<ArrayBuffer>
-    private openStreamErrorBufferRef!: JsExternal[]
-    private openStreamErrorBufferPtr!: JsExternal
-
-    private onData!: OnDataCallback
-
-    private readonly bytesPerFloat = 4
-    private readonly bytesPerDouble = 8
-    private readonly bytesPerI32 = 4
-
-    private isRunning = false
-
-    public async createInlet(payload: CreateInletPayload) {
-        Object.assign(this, payload)
-
-        this.infoHandle = this.resolveInfoHandle()
-        this.inletHandle = this.doCreateInlet()
-        this.channelCount = this.getChannelCount()
-
-        this.allocateWritableBuffers()
-        this.setPullMethod()
-
-        this.openStream()
-        await this.waitForSetup()
-    }
-
-    private resolveInfoHandle() {
-        const handles = this.resolveByProp()
-
-        if (handles.length === 0) {
-            this.throwNoStreamFound()
-        } else if (handles.length > 1) {
-            this.warnMultipleStreamsFound()
-        }
-        return handles[0]
-    }
-
-    private resolveByProp() {
-        return this.lsl.resolveByProp({
-            prop: 'source_id',
-            value: this.sourceId,
-        })
-    }
-
-    private throwNoStreamFound() {
-        throw new Error(`No stream info for sourceId "${this.sourceId}"`)
-    }
-
-    private warnMultipleStreamsFound() {
-        console.warn(
-            `Multiple stream infos for sourceId "${this.sourceId}", using the first one.`
-        )
-    }
-
-    private doCreateInlet() {
-        return this.lsl.createInlet({
-            infoHandle: this.infoHandle,
-            maxBufferedMs: this.maxBufferedMs,
-        })
-    }
-
-    private getChannelCount() {
-        return this.lsl.getChannelCount({ infoHandle: this.infoHandle })
-    }
-
-    private allocateWritableBuffers() {
-        this.allocateDataBuffer()
-        this.allocateTimestampBuffer()
-        this.allocatePullErrorBuffer()
-        this.allocateOpenStreamErrorBuffer()
-    }
-
-    private allocateDataBuffer() {
-        this.sampleBuffer = Buffer.alloc(
-            this.channelCount * this.chunkSize * this.bytesPerFloat
-        )
-
-        this.sampleBufferRef = createPointer({
-            paramsType: [DataType.U8Array],
-            paramsValue: [this.sampleBuffer],
-        })
-
-        this.sampleBufferPtr = unwrapPointer(this.sampleBufferRef)[0]
-    }
-
-    private allocateTimestampBuffer() {
-        this.timestampBuffer = Buffer.alloc(
-            this.chunkSize * this.bytesPerDouble
-        )
-
-        this.timestampBufferRef = createPointer({
-            paramsType: [DataType.U8Array],
-            paramsValue: [this.timestampBuffer],
-        })
-
-        this.timestampBufferPtr = unwrapPointer(this.timestampBufferRef)[0]
-    }
-
-    private allocatePullErrorBuffer() {
-        this.pullErrorBuffer = Buffer.alloc(this.bytesPerI32)
-
-        this.pullErrorBufferRef = createPointer({
-            paramsType: [DataType.U8Array],
-            paramsValue: [this.pullErrorBuffer],
-        })
-
-        this.pullErrorBufferPtr = unwrapPointer(this.pullErrorBufferRef)[0]
-    }
-
-    private allocateOpenStreamErrorBuffer() {
-        this.openStreamErrorBuffer = Buffer.alloc(this.bytesPerI32)
-
-        this.openStreamErrorBufferRef = createPointer({
-            paramsType: [DataType.U8Array],
-            paramsValue: [this.openStreamErrorBuffer],
-        })
-
-        this.openStreamErrorBufferPtr = unwrapPointer(
-            this.openStreamErrorBufferRef
-        )[0]
-    }
-
-    private setPullMethod() {
-        this.pullMethod =
-            this.chunkSize === 1 ? this.pullSample : this.pullChunk
-    }
-
-    private pullSample = () => {
-        const timestampSec = this.doPullsample()
-
-        if (timestampSec > 0) {
-            return {
-                samples: this.readSamplesFromBuffer(),
-                timestamps: [timestampSec],
-            }
-        }
-        return { samples: undefined, timestamps: undefined }
-    }
-
-    private doPullsample() {
-        return this.lsl.pullSample({
-            inletHandle: this.inletHandle,
-            sampleBufferPtr: this.sampleBufferPtr,
-            sampleBufferElements: this.channelCount,
-            timeoutMs: this.pullTimeoutMs,
-            errorCodePtr: this.pullErrorBufferPtr,
-        })
-    }
-
-    private readSamplesFromBuffer() {
-        const floats = new Float32Array(
-            this.sampleBuffer.buffer,
-            this.sampleBuffer.byteOffset,
-            this.chunkSize * this.channelCount
-        )
-        return Array.from(floats)
-    }
-
-    private pullChunk = () => {
-        const firstTimestampSec = this.doPullChunk()
-
-        if (firstTimestampSec > 0) {
-            return {
-                samples: this.readSamplesFromBuffer(),
-                timestamps: this.readTimestampsFromBuffer(),
-            }
-        }
-        return { samples: undefined, timestamps: undefined }
-    }
-
-    private doPullChunk() {
-        return this.lsl.pullChunk({
-            inletHandle: this.inletHandle,
-            sampleBufferPtr: this.sampleBufferPtr,
-            sampleBufferElements: this.chunkSize * this.channelCount,
-            timestampBufferPtr: this.timestampBufferPtr,
-            timestampBufferElements: this.chunkSize,
-            timeoutMs: this.pullTimeoutMs,
-            errorCodePtr: this.pullErrorBufferPtr,
-        })
-    }
-
-    private readTimestampsFromBuffer() {
-        const doubles = new Float64Array(
-            this.timestampBuffer.buffer,
-            this.timestampBuffer.byteOffset,
-            this.chunkSize
-        )
-        return Array.from(doubles)
-    }
-
-    private openStream() {
-        this.lsl.openStream({
-            inletHandle: this.inletHandle,
-            timeoutMs: this.openStreamTimeoutMs,
-            errorCodePtr: this.openStreamErrorBufferPtr,
-        })
-    }
-
-    private async waitForSetup() {
-        return new Promise((r) => setTimeout(r, this.waitAfterOpenStreamMs))
-    }
-
-    public startPulling(onData: OnDataCallback) {
-        if (this.isRunning) {
-            console.warn('StreamInletWorker is already running.')
-            return
-        }
-        this.isRunning = true
-        this.onData = onData
-
-        void this.pullLoop()
-    }
-
-    private async pullLoop() {
-        while (this.isRunning) {
-            await this.pullDataOnce()
-            await this.waitBetweenPulls()
-        }
-    }
-
-    private async pullDataOnce() {
-        const { samples, timestamps } = this.pullMethod()
-        this.handleLslErrorIfPresent()
-
-        if (samples && timestamps) {
-            this.onData(samples, timestamps)
-        }
-    }
-
-    private handleLslErrorIfPresent() {
-        const errorCode = this.pullErrorBuffer.readInt32LE()
-        this.handleLslError(errorCode)
-    }
-
-    private async waitBetweenPulls() {
-        await new Promise((r) => setTimeout(r, this.waitBetweenPullsMs))
-    }
-
-    public flushInlet() {
-        this.lsl.flushInlet({ inletHandle: this.inletHandle })
-    }
-
-    public stopPulling() {
-        this.isRunning = false
-        this.closeStream()
-
-        if (this.flushInletOnStop) {
-            this.flushInlet()
-        }
-    }
-
-    private closeStream() {
-        this.lsl.closeStream({ inletHandle: this.inletHandle })
-    }
-
-    public destroyInlet() {
-        this.doDestroyInlet()
-        this.freeNativePointers()
-    }
-
-    private doDestroyInlet() {
-        this.lsl.destroyInlet({ inletHandle: this.inletHandle })
-    }
-
-    private freeNativePointers() {
-        this.freePointer({
-            paramsType: [
-                DataType.U8Array,
-                DataType.U8Array,
-                DataType.U8Array,
-                DataType.U8Array,
-            ],
-            paramsValue: [
-                this.openStreamErrorBufferPtr,
-                this.sampleBufferPtr,
-                this.timestampBufferPtr,
-                this.pullErrorBufferPtr,
-            ],
-            pointerType: PointerType.CPointer,
-        })
-    }
-
-    private get lsl() {
-        return StreamInletWorker.lsl
-    }
-
-    private get handleLslError() {
-        return StreamInletWorker.handleLslError
-    }
-
-    private get freePointer() {
-        return StreamInletWorker.freePointer
-    }
-}

package/src/impl/workers/outlet/LslStreamOutlet.worker.ts

@@ -1,144 +0,0 @@
-import { parentPort } from 'node:worker_threads'
-
-import {
-    LiblslAdapter,
-    Liblsl,
-    OutletHandle,
-    handleLslError,
-    LslErrorCode,
-} from '@neurodevs/ndx-native'
-
-import LslStreamInfo, {
-    StreamInfo,
-    StreamInfoOptions,
-} from '../../LslStreamInfo.js'
-
-let lsl = LiblslAdapter.getInstance()
-
-export function setOutletLiblslAdapter(adapter: Liblsl) {
-    LiblslAdapter.setInstance(adapter)
-    lsl = LiblslAdapter.getInstance()
-}
-
-let handleLslErrorFn = handleLslError
-
-export function setOutletHandleLslError(fn: typeof handleLslError) {
-    handleLslErrorFn = fn
-}
-
-let info: StreamInfo
-let handle: OutletHandle
-let pushMethod: (opts: unknown) => LslErrorCode
-
-parentPort?.on('message', (msg: OutletMessage) => {
-    const { type } = msg
-
-    try {
-        switch (type) {
-            case 'createOutlet': {
-                createOutlet(msg)
-                break
-            }
-
-            case 'pushSample': {
-                pushSample(msg)
-                break
-            }
-
-            case 'destroyOutlet': {
-                destroyOutlet()
-                break
-            }
-        }
-    } catch (err) {
-        parentPort?.postMessage({
-            type: 'error',
-            error: err instanceof Error ? err.message : String(err),
-        })
-    }
-})
-
-export function createOutlet(msg: {
-    type: 'createOutlet'
-    payload: CreateOutletPayload
-}) {
-    const { payload } = msg
-
-    info = LslStreamInfo.Create(payload.infoOptions)
-
-    handle = lsl.createOutlet({
-        infoHandle: info.infoHandle,
-        chunkSize: payload.chunkSize,
-        maxBufferedMs: payload.maxBufferedMs,
-    })
-
-    pushMethod = (
-        lsl[payload.pushMethod] as (opts: unknown) => LslErrorCode
-    ).bind(lsl)
-
-    parentPort?.postMessage({ type: 'ready' })
-}
-
-export function pushSample(msg: {
-    type: 'pushSample'
-    payload: PushSamplePayload
-}) {
-    const { payload } = msg
-    const { sample, timestampSec = lsl.localClock() } = payload
-
-    if (!handle || !pushMethod) {
-        throw new Error('Outlet not initialized')
-    }
-
-    const errorCode = pushMethod({
-        outletHandle: handle,
-        sample,
-        timestampSec,
-    })
-
-    try {
-        handleLslErrorFn(errorCode)
-    } catch {
-        parentPort?.postMessage({
-            type: 'error',
-            error: `Error pushing sample: ${LslErrorCode[errorCode]}`,
-        })
-    }
-}
-
-export function destroyOutlet() {
-    if (handle) {
-        lsl.destroyOutlet({ outletHandle: handle })
-    }
-
-    if (info) {
-        lsl.destroyStreamInfo({ infoHandle: info.infoHandle })
-    }
-
-    parentPort?.close()
-}
-
-export type OutletMessage =
-    | {
-          type: 'createOutlet'
-          payload: CreateOutletPayload
-      }
-    | {
-          type: 'pushSample'
-          payload: PushSamplePayload
-      }
-    | {
-          type: 'destroyOutlet'
-      }
-
-export interface CreateOutletPayload {
-    infoOptions: StreamInfoOptions
-    chunkSize: number
-    maxBufferedMs: number
-    pushMethod: 'pushSampleFloatTimestamp' | 'pushSampleStringTimestamp'
-}
-
-export interface PushSamplePayload {
-    sample: unknown
-    timestampSec?: number
-}