@neurodevs/node-lsl 2.0.2 → 3.2.1

package/src/Liblsl.ts

@@ -11,51 +11,35 @@ export default class LiblslImpl implements Liblsl {
 
 	public static getInstance() {
 		if (!this.instance) {
-			this.instance = new this()
+			this.setInstance(new this())
 		}
 		return this.instance!
 	}
 
-	public static reset() {
-		delete this.instance
-	}
-
 	public static setInstance(instance: Liblsl) {
 		this.instance = instance
 	}
 
+	public static resetInstance() {
+		delete this.instance
+	}
+
 	public constructor() {
 		const path = process.env.LIBLSL_PATH!
 
 		if (!path) {
 			assertOptions(process, ['env.LIBLSL_PATH'])
 		}
+
 		try {
 			this.bindings = this.loadBindings(path)
-		} catch (err) {
-			console.error(err)
+		} catch {
 			throw new SpruceError({
 				code: 'FAILED_TO_LOAD_LIBLSL',
 				liblslPath: path,
 			})
 		}
 	}
-	public appendChannelsToStreamInfo(
-		info: LslBindingsStreamInfo,
-		channels: LslChannel[]
-	): void {
-		assertOptions({ info, channels }, ['info', 'channels'])
-		const desc = this.bindings.lsl_get_desc(info)
-
-		const parent = this.bindings.lsl_append_child(desc, 'channels')
-
-		for (const channel of channels) {
-			const c = this.bindings.lsl_append_child(parent, 'channel')
-			this.bindings.lsl_append_child_value(c, 'label', channel.label)
-			this.bindings.lsl_append_child_value(c, 'unit', channel.unit)
-			this.bindings.lsl_append_child_value(c, 'type', channel.type)
-		}
-	}
 
 	private loadBindings(path: string) {
 		return LiblslImpl.ffi.Library(path!, {
@@ -69,28 +53,10 @@ export default class LiblslImpl implements Liblsl {
 			lsl_get_desc: [xmlPtr, [streamInfo]],
 			lsl_append_child: [xmlPtr, [xmlPtr, 'string']],
 			lsl_append_child_value: [xmlPtr, [xmlPtr, 'string', 'string']],
-		}) as unknown as LiblslBindings
-	}
-
-	public pushSample(outlet: LslBindingsOutlet, sample: LslSample): void {
-		assertOptions({ outlet, sample }, ['outlet', 'sample'])
-		const clock = this.bindings.lsl_local_clock()
-		this.bindings.lsl_push_sample_ft(outlet, sample, clock)
+		}) as LiblslBindings
 	}
 
-	public createOutlet(options: CreateOutletOptions) {
-		const { info, chunkSize, maxBuffered } = assertOptions(options, [
-			'info',
-			'chunkSize',
-			'maxBuffered',
-		])
-
-		return this.bindings.lsl_create_outlet(info, chunkSize, maxBuffered)
-	}
-
-	public createStreamInfo(
-		options: CreateStreamInfoOptions
-	): LslBindingsStreamInfo {
+	public createStreamInfo(options: CreateStreamInfoOptions): BoundStreamInfo {
 		const { name, type, channelCount, sampleRate, channelFormat, sourceId } =
 			assertOptions(options, [
 				'name',
@@ -110,20 +76,49 @@ export default class LiblslImpl implements Liblsl {
 			sourceId
 		)
 	}
+
+	public appendChannelsToStreamInfo(
+		options: AppendChannelsToStreamInfoOptions
+	): void {
+		const { info, channels } = assertOptions(options, ['info', 'channels'])
+
+		const desc = this.bindings.lsl_get_desc(info)
+
+		const parent = this.bindings.lsl_append_child(desc, 'channels')
+
+		for (const channel of channels) {
+			const child = this.bindings.lsl_append_child(parent, 'channel')
+			this.bindings.lsl_append_child_value(child, 'label', channel.label)
+			this.bindings.lsl_append_child_value(child, 'unit', channel.unit)
+			this.bindings.lsl_append_child_value(child, 'type', channel.type)
+		}
+	}
+
+	public createOutlet(options: CreateOutletOptions) {
+		const { info, chunkSize, maxBuffered } = assertOptions(options, [
+			'info',
+			'chunkSize',
+			'maxBuffered',
+		])
+
+		return this.bindings.lsl_create_outlet(info, chunkSize, maxBuffered)
+	}
+
+	public pushSample(options: PushSampleOptions): void {
+		const { outlet, sample } = assertOptions(options, ['outlet', 'sample'])
+
+		const clock = this.bindings.lsl_local_clock()
+		this.bindings.lsl_push_sample_ft(outlet, sample, clock)
+	}
 }
 
 export interface Liblsl {
-	appendChannelsToStreamInfo(
-		info: LslBindingsStreamInfo,
-		channels: LslChannel[]
-	): void
-	createStreamInfo(options: CreateStreamInfoOptions): LslBindingsStreamInfo
-	createOutlet(options: CreateOutletOptions): LslBindingsOutlet
-	pushSample(outlet: LslBindingsOutlet, sample: LslSample): void
+	createStreamInfo(options: CreateStreamInfoOptions): BoundStreamInfo
+	appendChannelsToStreamInfo(options: AppendChannelsToStreamInfoOptions): void
+	createOutlet(options: CreateOutletOptions): BoundOutlet
+	pushSample(options: PushSampleOptions): void
 }
 
-export type LslSample = (number | string | undefined)[]
-
 export interface CreateStreamInfoOptions {
 	name: string
 	type: string
@@ -135,11 +130,28 @@ export interface CreateStreamInfoOptions {
 	unit?: string
 }
 
+export interface AppendChannelsToStreamInfoOptions {
+	info: BoundStreamInfo
+	channels: LslChannel[]
+}
+
+export interface CreateOutletOptions {
+	info: BoundStreamInfo
+	chunkSize: number
+	maxBuffered: number
+}
+
+export interface PushSampleOptions {
+	outlet: BoundOutlet
+	sample: LslSample
+}
+
 export interface LslChannel {
 	label: string
 	unit: string
 	type: string
 }
+export type LslSample = (number | string | undefined)[]
 
 export interface LiblslBindings {
 	lsl_create_streaminfo(
@@ -149,41 +161,32 @@ export interface LiblslBindings {
 		sampleRate: number,
 		channelFormat: number,
 		sourceId: string
-	): LslBindingsStreamInfo
+	): BoundStreamInfo
 
 	lsl_create_outlet(
-		info: LslBindingsStreamInfo,
+		info: BoundStreamInfo,
 		chunkSize: number,
 		maxBuffered: number
-	): LslBindingsOutlet
+	): BoundOutlet
 
 	lsl_push_sample_ft(
-		outlet: LslBindingsOutlet,
+		outlet: BoundOutlet,
 		sample: LslSample,
 		timestamp: number
 	): void
 
 	lsl_local_clock(): number
-	lsl_get_desc(info: LslBindingsStreamInfo): LslBindingsDesc
-	lsl_append_child(desc: LslBindingsDesc, name: string): LslBindingsChild
-	lsl_append_child_value(
-		child: LslBindingsChild,
-		name: string,
-		value: string
-	): void
+	lsl_get_desc(info: BoundStreamInfo): BoundDesc
+	lsl_append_child(desc: BoundDesc, name: string): BoundChild
+	lsl_append_child_value(child: BoundChild, name: string, value: string): void
 }
 
+export interface BoundStreamInfo {}
+export interface BoundOutlet {}
+export interface BoundDesc {}
+export interface BoundChild {}
+
 const streamInfo = ref.refType(ref.types.void)
 const outletType = ref.refType(ref.types.void)
 const FloatArray = ArrayType(ref.types.float)
 const xmlPtr = ref.refType(ref.types.void)
-export interface CreateOutletOptions {
-	info: LslBindingsStreamInfo
-	chunkSize: number
-	maxBuffered: number
-}
-
-export interface LslBindingsStreamInfo {}
-export interface LslBindingsOutlet {}
-export interface LslBindingsDesc {}
-export interface LslBindingsChild {}

package/src/LslOutlet.ts

@@ -1,21 +1,17 @@
 import { SchemaError, assertOptions } from '@sprucelabs/schema'
-import LiblslImpl, {
-	LslBindingsOutlet,
-	LslBindingsStreamInfo,
-	LslSample,
-} from './Liblsl'
+import LiblslImpl, { BoundOutlet, BoundStreamInfo, LslSample } from './Liblsl'
 
 export default class LslOutletImpl implements LslOutlet {
 	private outletOptions: LslOutletOptions
 	public static Class?: new (options: LslOutletOptions) => LslOutlet
-	private streamInfo: LslBindingsStreamInfo
-	private outlet: LslBindingsOutlet
+	private streamInfo: BoundStreamInfo
+	private outlet: BoundOutlet
 
 	protected constructor(options: LslOutletOptions) {
 		const { sampleRate, channelFormat } = assertOptions(options, [
 			'name',
 			'type',
-			'channelLabels',
+			'channelNames',
 			'sampleRate',
 			'channelFormat',
 			'sourceId',
@@ -27,10 +23,12 @@ export default class LslOutletImpl implements LslOutlet {
 
 		this.outletOptions = options
 
-		const { chunkSize, maxBuffered, channelLabels, ...streamInfoOptions } = this
+		const { chunkSize, maxBuffered, channelNames, ...streamInfoOptions } = this
 			.outletOptions as any
 
-		this.assertValidChannelCount(channelLabels.length)
+		const channelCount = channelNames.length
+
+		this.assertValidChannelCount(channelCount)
 		this.assertValidSampleRate(sampleRate)
 		this.assertValidChannelFormat(channelFormat)
 		this.assertValidChunkSize(chunkSize)
@@ -41,18 +39,18 @@ export default class LslOutletImpl implements LslOutlet {
 
 		this.streamInfo = this.lsl.createStreamInfo({
 			...streamInfoOptions,
-			channelCount: channelLabels.length,
-			channelFormat: CHANNEL_FORMATS.indexOf(this.outletOptions.channelFormat),
+			channelCount,
+			channelFormat: this.lookupChannelFormat(channelFormat),
 		})
 
-		this.lsl.appendChannelsToStreamInfo(
-			this.streamInfo,
-			channelLabels.map((label: string) => ({
+		this.lsl.appendChannelsToStreamInfo({
+			info: this.streamInfo,
+			channels: channelNames.map((label: string) => ({
 				label,
 				unit: this.outletOptions.unit,
 				type: this.outletOptions.type,
-			}))
-		)
+			})),
+		})
 
 		this.outlet = this.lsl.createOutlet({
 			info: this.streamInfo,
@@ -65,6 +63,14 @@ export default class LslOutletImpl implements LslOutlet {
 		return new (this.Class ?? this)(options)
 	}
 
+	public pushSample(sample: LslSample) {
+		this.lsl.pushSample({ outlet: this.outlet, sample })
+	}
+
+	private lookupChannelFormat(channelFormat: ChannelFormat): number {
+		return CHANNEL_FORMATS.indexOf(channelFormat)
+	}
+
 	private assertValidMaxBufferred(maxBuffered: number) {
 		if (!this.isPositiveIntegerOrZero(maxBuffered)) {
 			throw new SchemaError({
@@ -87,7 +93,6 @@ export default class LslOutletImpl implements LslOutlet {
 
 	private assertValidChannelFormat(channelFormat: ChannelFormat) {
 		const validFormats = CHANNEL_FORMATS
-
 		if (validFormats.indexOf(channelFormat) === -1) {
 			throw new SchemaError({
 				code: 'INVALID_PARAMETERS',
@@ -98,11 +103,11 @@ export default class LslOutletImpl implements LslOutlet {
 	}
 
 	private assertValidSampleRate(sampleRate: number) {
-		if (!this.isPositiveNumber(sampleRate)) {
+		if (!this.isGreaterThanZero(sampleRate)) {
 			throw new SchemaError({
 				code: 'INVALID_PARAMETERS',
 				parameters: ['sampleRate'],
-				friendlyMessage: 'Sample rate must be a positive number.',
+				friendlyMessage: 'Sample rate must be a positive number or zero.',
 			})
 		}
 	}
@@ -111,30 +116,26 @@ export default class LslOutletImpl implements LslOutlet {
 		if (!this.isPositiveInteger(channelCount)) {
 			throw new SchemaError({
 				code: 'INVALID_PARAMETERS',
-				parameters: ['channelLabels'],
-				friendlyMessage: 'channelLabels must have 1 or more labels.',
+				parameters: ['channelNames'],
+				friendlyMessage: 'channelNames must have 1 or more labels.',
 			})
 		}
 	}
 
-	private isPositiveNumber(value: number) {
-		return value > 0
-	}
-
-	private isPositiveIntegerOrZero(value: number) {
-		return Number.isInteger(value) && value >= 0
+	private isGreaterThanZero(value: number) {
+		return value >= 0
 	}
 
 	private isPositiveInteger(value: number) {
 		return Number.isInteger(value) && value > 0
 	}
 
-	private get lsl() {
-		return LiblslImpl.getInstance()
+	private isPositiveIntegerOrZero(value: number) {
+		return Number.isInteger(value) && value >= 0
 	}
 
-	public pushSample(sample: LslSample) {
-		this.lsl.pushSample(this.outlet, sample)
+	private get lsl() {
+		return LiblslImpl.getInstance()
 	}
 }
 
@@ -150,10 +151,15 @@ const CHANNEL_FORMATS = [
 ] as const
 
 export type ChannelFormat = (typeof CHANNEL_FORMATS)[number]
+
+export interface LslOutlet {
+	pushSample(sample: LslSample): void
+}
+
 export interface LslOutletOptions {
 	name: string
 	type: string
-	channelLabels: string[]
+	channelNames: string[]
 	sampleRate: number
 	channelFormat: ChannelFormat
 	sourceId: string
@@ -162,7 +168,3 @@ export interface LslOutletOptions {
 	chunkSize: number
 	maxBuffered: number
 }
-
-export interface LslOutlet {
-	pushSample(sample: LslSample): void
-}

package/src/TimeMarkerOutlet.ts

@@ -0,0 +1,19 @@
+import LslOutletImpl, { LslOutletOptions } from './LslOutlet'
+
+export default class TimeMarkerOutlet extends LslOutletImpl {
+	public static Outlet(options?: Partial<LslOutletOptions>) {
+		const defaultOptions = {
+			name: 'Time markers',
+			type: 'Markers',
+			channelNames: ['Markers'],
+			sampleRate: 0,
+			channelFormat: 'string',
+			sourceId: 'time-markers',
+			manufacturer: 'N/A',
+			unit: 'N/A',
+			chunkSize: 0,
+			maxBuffered: 0,
+		} as LslOutletOptions
+		return new (this.Class ?? this)({ ...defaultOptions, ...options })
+	}
+}

package/src/__tests__/behavioral/LslOutlet.test.ts

@@ -5,63 +5,37 @@ import AbstractSpruceTest, {
 	errorAssert,
 	generateId,
 } from '@sprucelabs/test-utils'
-import LiblslImpl, {
-	CreateOutletOptions,
-	CreateStreamInfoOptions,
-	Liblsl,
-	LslBindingsOutlet,
-	LslBindingsStreamInfo,
-	LslChannel,
-	LslSample,
-} from '../../Liblsl'
+import LiblslImpl, { LslSample } from '../../Liblsl'
 import LslOutlet, { ChannelFormat, LslOutletOptions } from '../../LslOutlet'
-
-export const CHANNEL_FORMATS = [
-	'undefined',
-	'float32',
-	'double64',
-	'string',
-	'int32',
-	'int16',
-	'int8',
-	'int64',
-] as const
+import { TEST_CHANNEL_FORMATS } from '../support/consts'
+import generateRandomOutletOptions from '../support/generateRandomOutletOptions'
+import { SpyLiblsl } from '../support/SpyLiblsl'
 
 export default class LslOutletTest extends AbstractSpruceTest {
-	private static spyLsl: SpyLiblsl
+	private static spyLiblsl: SpyLiblsl
 	private static randomOutletOptions: LslOutletOptions
-	private static channelIdx: number
+	private static channelFormatIdx: number
 
 	protected static async beforeEach() {
 		await super.beforeEach()
 		delete LslOutlet.Class
-		this.channelIdx = randomInt(7)
-		this.randomOutletOptions = {
-			name: generateId(),
-			type: generateId(),
-			channelLabels: new Array(randomInt(1, 10)).fill(generateId()),
-			sampleRate: Math.random() * 10,
-			channelFormat: CHANNEL_FORMATS[this.channelIdx],
-			sourceId: generateId(),
-			manufacturer: generateId(),
-			unit: generateId(),
-			chunkSize: randomInt(0, 10),
-			maxBuffered: randomInt(0, 10),
-		}
-
-		this.spyLsl = new SpyLiblsl()
-		LiblslImpl.setInstance(this.spyLsl)
+		this.channelFormatIdx = randomInt(8)
+		this.randomOutletOptions = generateRandomOutletOptions(
+			this.channelFormatIdx
+		)
+		this.spyLiblsl = new SpyLiblsl()
+		LiblslImpl.setInstance(this.spyLiblsl)
 	}
 
 	@test()
-	protected static async throwsWhenMissingRequiredParameters() {
+	protected static async throwsWhenMissingRequiredParams() {
 		//@ts-ignore
 		const err = assert.doesThrow(() => new LslOutlet())
 		errorAssert.assertError(err, 'MISSING_PARAMETERS', {
 			parameters: [
 				'name',
 				'type',
-				'channelLabels',
+				'channelNames',
 				'sampleRate',
 				'channelFormat',
 				'sourceId',
@@ -74,18 +48,13 @@ export default class LslOutletTest extends AbstractSpruceTest {
 	}
 
 	@test()
-	protected static async canCreateWithRequiredParams() {
-		this.Outlet()
-	}
-
-	@test()
-	protected static async throwsWithInvalidChannelCount() {
-		this.assertThrowsInvalidChannelLabels(0)
+	protected static async throwsWithInvalidChannelNames() {
+		this.assertThrowsInvalidChannelNames(0)
 	}
 
 	@test()
 	protected static async throwsWithInvalidSampleRate() {
-		this.assertThrowsInvalidSampleRate(0)
+		this.Outlet({ sampleRate: 0 })
 		this.assertThrowsInvalidSampleRate(-1)
 		this.assertThrowsInvalidSampleRate(-1.5)
 	}
@@ -99,15 +68,7 @@ export default class LslOutletTest extends AbstractSpruceTest {
 	}
 
 	@test()
-	protected static async supportsAllKnownChannelFormats() {
-		const valid = CHANNEL_FORMATS
-		for (const format of valid) {
-			this.Outlet({ channelFormat: format as ChannelFormat })
-		}
-	}
-
-	@test()
-	protected static async throwWithInvalidChunkSize() {
+	protected static async throwsWithInvalidChunkSize() {
 		this.Outlet({ chunkSize: 0 })
 		this.assertThrowsInvalidChunkSize(-1)
 		this.assertThrowsInvalidChunkSize(-1.5)
@@ -122,56 +83,66 @@ export default class LslOutletTest extends AbstractSpruceTest {
 		this.assertThrowsInvalidMaxBuffered(1.5)
 	}
 
-	@test('pushing sample sends to lsl 1', [1])
-	@test('pushing sample sends to lsl 2', [1, 2])
-	protected static async pushingSampleSendsToLsl(sample: LslSample) {
+	@test()
+	protected static async supportsAllKnownChannelFormats() {
+		for (const format of TEST_CHANNEL_FORMATS) {
+			this.Outlet({ channelFormat: format as ChannelFormat })
+		}
+	}
+
+	@test('pushing [1, 2] sample sends to LSL', [1, 2])
+	@test('pushing [1] sample sends to LSL', [1])
+	protected static async canPushSampleToLsl(sample: LslSample) {
 		this.pushSample(sample)
-		assert.isEqual(this.spyLsl.lastPushedOutlet, this.spyLsl.outlet)
-		assert.isEqualDeep(this.spyLsl.lastPushedSample, sample)
-		assert.isEqualDeep(this.spyLsl.lastOutletOptions, {
-			info: this.spyLsl.streamInfo,
+		assert.isEqual(
+			this.spyLiblsl.lastPushSampleOptions?.outlet,
+			this.spyLiblsl.outlet
+		)
+		assert.isEqualDeep(this.spyLiblsl.lastPushSampleOptions?.sample, sample)
+		assert.isEqualDeep(this.spyLiblsl.lastCreateOutletOptions, {
+			info: this.spyLiblsl.streamInfo,
 			chunkSize: this.randomOutletOptions.chunkSize,
 			maxBuffered: this.randomOutletOptions.maxBuffered,
 		})
 	}
 
 	@test()
-	protected static async constructionPassesCorrectOptionsToCreateStreamInfo() {
+	protected static async constructionCreatesStreamInfo() {
 		this.Outlet()
 
 		const { ...options } = this.randomOutletOptions as any
 
-		options.channelCount = options.channelLabels.length
+		options.channelCount = options.channelNames.length
 
 		delete options.manufacturer
 		delete options.unit
 		delete options.chunkSize
 		delete options.maxBuffered
-		delete options.channelLabels
+		delete options.channelNames
 
-		assert.isEqualDeep(this.spyLsl.lastStreamInfoOptions, {
+		assert.isEqualDeep(this.spyLiblsl.lastCreateStreamInfoOptions, {
 			...options,
-			channelFormat: this.channelIdx,
+			channelFormat: this.channelFormatIdx,
 		})
 	}
 
 	@test()
-	protected static async canOverrideClasInstantiatedInFactory() {
+	protected static async canOverrideClassInstantiatedInFactory() {
 		LslOutlet.Class = CheckingOutlet
 		const instance = this.Outlet()
 		assert.isInstanceOf(instance, CheckingOutlet)
 	}
 
-	@test('can add one label', [generateId()])
-	@test('can add two labels', [generateId(), generateId()])
+	@test('can add one label to channels', [generateId()])
+	@test('can add two labels to channels', [generateId(), generateId()])
 	protected static async appendsChannelsBasedOnCount(labels: string[]) {
 		const type = generateId()
 		const unit = generateId()
 
-		this.Outlet({ channelLabels: labels, type, unit })
+		this.Outlet({ channelNames: labels, type, unit })
 
-		assert.isEqualDeep(this.spyLsl.lastAppendChannelsToStreamInfo, {
-			info: this.spyLsl.streamInfo,
+		assert.isEqualDeep(this.spyLiblsl.lastAppendChannelsToStreamInfoOptions, {
+			info: this.spyLiblsl.streamInfo,
 			channels: labels.map((label) => ({
 				label,
 				type,
@@ -187,7 +158,7 @@ export default class LslOutletTest extends AbstractSpruceTest {
 		outlet.pushSample([2])
 		outlet.pushSample([3])
 
-		assert.isEqual(this.spyLsl.createStreamInfoHitCount, 1)
+		assert.isEqual(this.spyLiblsl.createStreamInfoHitCount, 1)
 	}
 
 	private static pushSample(sample: LslSample) {
@@ -207,10 +178,10 @@ export default class LslOutletTest extends AbstractSpruceTest {
 		this.assertDoesThrowInvalidParameters({ sampleRate }, ['sampleRate'])
 	}
 
-	private static assertThrowsInvalidChannelLabels(count: number) {
+	private static assertThrowsInvalidChannelNames(count: number) {
 		this.assertDoesThrowInvalidParameters(
-			{ channelLabels: new Array(count).fill(generateId()) },
-			['channelLabels']
+			{ channelNames: new Array(count).fill(generateId()) },
+			['channelNames']
 		)
 	}
 
@@ -232,46 +203,6 @@ export default class LslOutletTest extends AbstractSpruceTest {
 	}
 }
 
-class SpyLiblsl implements Liblsl {
-	public lastPushedOutlet?: LslBindingsOutlet
-	public lastPushedSample?: LslSample
-	public lastOutletOptions?: CreateOutletOptions
-	public lastStreamInfoOptions?: CreateStreamInfoOptions
-	public outlet: LslBindingsOutlet = {} as LslBindingsOutlet
-	public streamInfo: LslBindingsStreamInfo = {} as LslBindingsStreamInfo
-	public lastAppendChannelsToStreamInfo?: {
-		info: LslBindingsStreamInfo
-		channels: LslChannel[]
-	}
-	public createStreamInfoHitCount = 0
-
-	public createStreamInfo(
-		options: CreateStreamInfoOptions
-	): LslBindingsStreamInfo {
-		this.createStreamInfoHitCount++
-		this.lastStreamInfoOptions = options
-		return this.streamInfo
-	}
-	public appendChannelsToStreamInfo(
-		info: LslBindingsStreamInfo,
-		channels: LslChannel[]
-	): void {
-		this.lastAppendChannelsToStreamInfo = {
-			info,
-			channels,
-		}
-	}
-
-	public createOutlet(options: CreateOutletOptions): LslBindingsOutlet {
-		this.lastOutletOptions = options
-		return this.outlet
-	}
-	public pushSample(outlet: LslBindingsOutlet, sample: LslSample): void {
-		this.lastPushedOutlet = outlet
-		this.lastPushedSample = sample
-	}
-}
-
 class CheckingOutlet extends LslOutlet {
 	public constructor(options: LslOutletOptions) {
 		super(options)