diff --git a/packages/serial/src/index.ts b/packages/serial/src/index.ts
index 9721ee83f0e4..295b05ed49d8 100644
--- a/packages/serial/src/index.ts
+++ b/packages/serial/src/index.ts
@@ -8,13 +8,16 @@ export * from "./message/SuccessIndicator.js";
 export * from "./message/ZnifferMessages.js";
 export * from "./parsers/BootloaderParsers.js";
 export * from "./parsers/SerialAPIParser.js";
-export * from "./serialport/ZWaveSerialPort.js";
-export * from "./serialport/ZWaveSerialPortBase.js";
+export * from "./parsers/ZWaveSerialFrame.js";
+export * from "./parsers/ZnifferSerialFrame.js";
+export * from "./plumbing/Faucet.js";
+export * from "./serialport/LegacyBindingWrapper.js";
+export * from "./serialport/NodeSerialPort.js";
+export * from "./serialport/NodeSocket.js";
 export * from "./serialport/ZWaveSerialPortImplementation.js";
-export * from "./serialport/ZWaveSocket.js";
+export * from "./serialport/ZWaveSerialStream.js";
 export * from "./serialport/ZWaveSocketOptions.js";
-export * from "./zniffer/ZnifferSerialPort.js";
-export * from "./zniffer/ZnifferSerialPortBase.js";
-export * from "./zniffer/ZnifferSocket.js";
+export * from "./serialport/definitions.js";
+export * from "./zniffer/ZnifferSerialStream.js";
 
 export * from "./index_serialapi.js";
diff --git a/packages/serial/src/index_mock.ts b/packages/serial/src/index_mock.ts
index e077354e3e17..59e501aeb6cc 100644
--- a/packages/serial/src/index_mock.ts
+++ b/packages/serial/src/index_mock.ts
@@ -1,3 +1,3 @@
-export * from "./mock/MockSerialPort.js";
+export * from "./mock/MockPort.js";
 export * from "./mock/SerialPortBindingMock.js";
 export * from "./mock/SerialPortMock.js";
diff --git a/packages/serial/src/mock/MockPort.ts b/packages/serial/src/mock/MockPort.ts
new file mode 100644
index 000000000000..17f2756acc7a
--- /dev/null
+++ b/packages/serial/src/mock/MockPort.ts
@@ -0,0 +1,81 @@
+import { ZWaveLogContainer } from "@zwave-js/core";
+import type { UnderlyingSink, UnderlyingSource } from "node:stream/web";
+import {
+	type ZWaveSerialBindingFactory,
+	type ZWaveSerialStream,
+	ZWaveSerialStreamFactory,
+} from "../serialport/ZWaveSerialStream.js";
+
+export class MockPort {
+	public constructor() {
+		const { readable, writable: sink } = new TransformStream<Uint8Array>();
+		this.#sink = sink;
+		this.readable = readable;
+	}
+
+	// Remembers the last written data
+	public lastWrite: Uint8Array | undefined;
+
+	// Internal stream to allow emitting data from the port
+	#sourceController: ReadableStreamDefaultController<Uint8Array> | undefined;
+
+	// Public readable stream to allow handling the written data
+	#sink: WritableStream<Uint8Array>;
+	/** Exposes the data written by the host as a readable stream */
+	public readonly readable: ReadableStream<Uint8Array>;
+
+	public factory(): ZWaveSerialBindingFactory {
+		return () => {
+			const sink: UnderlyingSink<Uint8Array> = {
+				write: async (chunk, _controller) => {
+					// Remember the last written data
+					this.lastWrite = chunk;
+					// Only write to the sink if its readable side has a reader attached.
+					// Otherwise, we get backpressure on the writable side of the mock port
+					if (this.readable.locked) {
+						const writer = this.#sink.getWriter();
+						try {
+							await writer.write(chunk);
+						} finally {
+							writer.releaseLock();
+						}
+					}
+				},
+			};
+
+			const source: UnderlyingSource<Uint8Array> = {
+				start: (controller) => {
+					this.#sourceController = controller;
+				},
+			};
+
+			return Promise.resolve({ sink, source });
+		};
+	}
+
+	public emitData(data: Uint8Array): void {
+		this.#sourceController?.enqueue(data);
+	}
+
+	public destroy(): void {
+		try {
+			this.#sourceController?.close();
+			this.#sourceController = undefined;
+		} catch {
+			// Ignore - the controller might already be closed
+		}
+	}
+}
+
+export async function createAndOpenMockedZWaveSerialPort(): Promise<{
+	port: MockPort;
+	serial: ZWaveSerialStream;
+}> {
+	const port = new MockPort();
+	const factory = new ZWaveSerialStreamFactory(
+		port.factory(),
+		new ZWaveLogContainer({ enabled: false }),
+	);
+	const serial = await factory.createStream();
+	return { port, serial };
+}
diff --git a/packages/serial/src/mock/MockSerialPort.ts b/packages/serial/src/mock/_MockSerialPort.ts.txt
similarity index 100%
rename from packages/serial/src/mock/MockSerialPort.ts
rename to packages/serial/src/mock/_MockSerialPort.ts.txt
diff --git a/packages/serial/src/parsers/BootloaderParsers.ts b/packages/serial/src/parsers/BootloaderParsers.ts
index e35a7d209584..6f36b74f7d1b 100644
--- a/packages/serial/src/parsers/BootloaderParsers.ts
+++ b/packages/serial/src/parsers/BootloaderParsers.ts
@@ -1,39 +1,13 @@
-import { Transform, type TransformCallback } from "node:stream";
+import { Bytes } from "@zwave-js/shared";
+import { type Transformer } from "node:stream/web";
 import type { SerialLogger } from "../log/Logger.js";
 import { XModemMessageHeaders } from "../message/MessageHeaders.js";
-
-export enum BootloaderChunkType {
-	Error,
-	Menu,
-	Message,
-	FlowControl,
-}
-
-export type BootloaderChunk =
-	| {
-		type: BootloaderChunkType.Error;
-		error: string;
-		_raw: string;
-	}
-	| {
-		type: BootloaderChunkType.Menu;
-		version: string;
-		options: { num: number; option: string }[];
-		_raw: string;
-	}
-	| {
-		type: BootloaderChunkType.Message;
-		message: string;
-		_raw: string;
-	}
-	| {
-		type: BootloaderChunkType.FlowControl;
-		command:
-			| XModemMessageHeaders.ACK
-			| XModemMessageHeaders.NAK
-			| XModemMessageHeaders.CAN
-			| XModemMessageHeaders.C;
-	};
+import {
+	type BootloaderChunk,
+	BootloaderChunkType,
+	type ZWaveSerialFrame,
+	ZWaveSerialFrameType,
+} from "./ZWaveSerialFrame.js";
 
 function isFlowControl(byte: number): boolean {
 	return (
@@ -44,27 +18,24 @@ function isFlowControl(byte: number): boolean {
 	);
 }
 
-/** Parses the screen output from the bootloader, either waiting for a NUL char or a timeout */
-export class BootloaderScreenParser extends Transform {
-	constructor(private logger?: SerialLogger) {
-		// We read byte streams but emit messages
-		super({ readableObjectMode: true });
-	}
+class BootloaderScreenParserTransformer
+	implements Transformer<Uint8Array, number | string>
+{
+	constructor(private logger?: SerialLogger) {}
 
 	private receiveBuffer = "";
 	private flushTimeout: NodeJS.Timeout | undefined;
 
-	_transform(
-		chunk: any,
-		encoding: string,
-		callback: TransformCallback,
-	): void {
+	transform(
+		chunk: Uint8Array,
+		controller: TransformStreamDefaultController<number | string>,
+	) {
 		if (this.flushTimeout) {
 			clearTimeout(this.flushTimeout);
 			this.flushTimeout = undefined;
 		}
 
-		this.receiveBuffer += chunk.toString("utf8");
+		this.receiveBuffer += Bytes.view(chunk).toString("utf8");
 
 		// Correct buggy ordering of NUL char in error codes.
 		// The bootloader may send errors as "some error 0x\012" instead of "some error 0x12\0"
@@ -82,7 +53,7 @@ export class BootloaderScreenParser extends Transform {
 			if (screen === "") continue;
 
 			this.logger?.bootloaderScreen(screen);
-			this.push(screen);
+			controller.enqueue(screen);
 		}
 
 		// Emit single flow-control bytes
@@ -91,7 +62,7 @@ export class BootloaderScreenParser extends Transform {
 			if (!isFlowControl(charCode)) break;
 
 			this.logger?.data("inbound", Uint8Array.from([charCode]));
-			this.push(charCode);
+			controller.enqueue(charCode);
 			this.receiveBuffer = this.receiveBuffer.slice(1);
 		}
 
@@ -99,12 +70,21 @@ export class BootloaderScreenParser extends Transform {
 		if (this.receiveBuffer) {
 			this.flushTimeout = setTimeout(() => {
 				this.flushTimeout = undefined;
-				this.push(this.receiveBuffer);
+				controller.enqueue(this.receiveBuffer);
 				this.receiveBuffer = "";
 			}, 500);
 		}
+	}
+}
 
-		callback();
+/** Parses the screen output from the bootloader, either waiting for a NUL char or a timeout */
+export class BootloaderScreenParser
+	extends TransformStream<Uint8Array, number | string>
+{
+	constructor(
+		logger?: SerialLogger,
+	) {
+		super(new BootloaderScreenParserTransformer(logger));
 	}
 }
 
@@ -116,77 +96,84 @@ const menuSuffix = "BL >";
 const optionsRegex = /^(?<num>\d+)\. (?<option>.+)/gm;
 
 /** Transforms the bootloader screen output into meaningful chunks */
-export class BootloaderParser extends Transform {
+export class BootloaderParser extends TransformStream<
+	number | string,
+	ZWaveSerialFrame & { type: ZWaveSerialFrameType.Bootloader }
+> {
 	constructor() {
-		// We read strings and return objects
-		super({ objectMode: true });
-	}
-
-	_transform(
-		chunk: any,
-		encoding: string,
-		callback: TransformCallback,
-	): void {
-		// Flow control bytes come in as numbers
-		if (typeof chunk === "number") {
-			return callback(
-				null,
-				{
-					type: BootloaderChunkType.FlowControl,
-					command: chunk,
-				}, /* satisfies BootloaderChunk */
-			);
+		function wrapChunk(
+			chunk: BootloaderChunk,
+		): ZWaveSerialFrame & { type: ZWaveSerialFrameType.Bootloader } {
+			return {
+				type: ZWaveSerialFrameType.Bootloader,
+				data: chunk,
+			};
 		}
-
-		let screen = (chunk as string).trim();
-
-		// Apparently, the bootloader sometimes sends \0 in the wrong location.
-		// Therefore check if the screen contains the menu preamble, instead of forcing
-		// it to start with it
-		const menuPreambleIndex = screen.indexOf(bootloaderMenuPreamble);
-
-		if (menuPreambleIndex > -1 && screen.endsWith(menuSuffix)) {
-			screen = screen.slice(menuPreambleIndex);
-			const version = preambleRegex.exec(screen)?.groups?.version;
-			if (!version) {
-				return callback(
-					null,
-					{
-						type: BootloaderChunkType.Error,
-						error: "Could not determine bootloader version",
-						_raw: screen,
-					}, /* satisfies BootloaderChunk */
+		const transformer: Transformer<
+			number | string,
+			ZWaveSerialFrame & { type: ZWaveSerialFrameType.Bootloader }
+		> = {
+			transform(chunk, controller) {
+				// Flow control bytes come in as numbers
+				if (typeof chunk === "number") {
+					controller.enqueue(wrapChunk({
+						type: BootloaderChunkType.FlowControl,
+						command: chunk,
+					}));
+					return;
+				}
+
+				let screen = chunk.trim();
+
+				// Apparently, the bootloader sometimes sends \0 in the wrong location.
+				// Therefore check if the screen contains the menu preamble, instead of forcing
+				// it to start with it
+				const menuPreambleIndex = screen.indexOf(
+					bootloaderMenuPreamble,
 				);
-			}
-
-			const options: { num: number; option: string }[] = [];
-			let match: RegExpExecArray | null;
-			while ((match = optionsRegex.exec(screen)) !== null) {
-				options.push({
-					num: parseInt(match.groups!.num),
-					option: match.groups!.option,
-				});
-			}
-
-			this.push(
-				{
-					type: BootloaderChunkType.Menu,
-					_raw: screen,
-					version,
-					options,
-				}, /* satisfies BootloaderChunk */
-			);
-		} else {
-			// Some output
-			this.push(
-				{
-					type: BootloaderChunkType.Message,
-					_raw: screen,
-					message: screen,
-				}, /* satisfies BootloaderChunk */
-			);
-		}
 
-		callback();
+				if (menuPreambleIndex > -1 && screen.endsWith(menuSuffix)) {
+					screen = screen.slice(menuPreambleIndex);
+					const version = preambleRegex.exec(screen)?.groups?.version;
+					if (!version) {
+						controller.enqueue(wrapChunk({
+							type: BootloaderChunkType.Error,
+							error: "Could not determine bootloader version",
+							_raw: screen,
+						}) /* satisfies BootloaderChunk */);
+						return;
+					}
+
+					const options: { num: number; option: string }[] = [];
+					let match: RegExpExecArray | null;
+					while ((match = optionsRegex.exec(screen)) !== null) {
+						options.push({
+							num: parseInt(match.groups!.num),
+							option: match.groups!.option,
+						});
+					}
+
+					controller.enqueue(
+						wrapChunk({
+							type: BootloaderChunkType.Menu,
+							_raw: screen,
+							version,
+							options,
+						}), /* satisfies BootloaderChunk */
+					);
+				} else {
+					// Some output
+					controller.enqueue(
+						wrapChunk({
+							type: BootloaderChunkType.Message,
+							_raw: screen,
+							message: screen,
+						}), /* satisfies BootloaderChunk */
+					);
+				}
+			},
+		};
+
+		super(transformer);
 	}
 }
diff --git a/packages/serial/src/parsers/SerialAPIParser.ts b/packages/serial/src/parsers/SerialAPIParser.ts
index c1afc92f08ac..74687e6be8f3 100644
--- a/packages/serial/src/parsers/SerialAPIParser.ts
+++ b/packages/serial/src/parsers/SerialAPIParser.ts
@@ -1,7 +1,12 @@
 import { Bytes, num2hex } from "@zwave-js/shared";
-import { Transform, type TransformCallback } from "node:stream";
+import { type Transformer } from "node:stream/web";
 import type { SerialLogger } from "../log/Logger.js";
 import { MessageHeaders } from "../message/MessageHeaders.js";
+import {
+	type SerialAPIChunk,
+	type ZWaveSerialFrame,
+	ZWaveSerialFrameType,
+} from "./ZWaveSerialFrame.js";
 
 /**
  * Checks if there's enough data in the buffer to deserialize a complete message
@@ -16,25 +21,40 @@ function getMessageLength(data: Uint8Array): number {
 	return remainingLength + 2;
 }
 
-export class SerialAPIParser extends Transform {
-	constructor(
-		private logger?: SerialLogger,
-		private onDiscarded?: (data: Uint8Array) => void,
-	) {
-		// We read byte streams but emit messages
-		super({ readableObjectMode: true });
-	}
+type SerialAPIParserTransformerOutput = ZWaveSerialFrame & {
+	type:
+		| ZWaveSerialFrameType.SerialAPI
+		| ZWaveSerialFrameType.Discarded;
+};
+
+function wrapSerialAPIChunk(
+	chunk: SerialAPIChunk,
+): SerialAPIParserTransformerOutput {
+	return {
+		type: ZWaveSerialFrameType.SerialAPI,
+		data: chunk,
+	};
+}
+
+class SerialAPIParserTransformer implements
+	Transformer<
+		Uint8Array,
+		SerialAPIParserTransformerOutput
+	>
+{
+	constructor(private logger?: SerialLogger) {}
 
 	private receiveBuffer = new Bytes();
 
 	// Allow ignoring the high nibble of an ACK once to work around an issue in the 700 series firmware
 	public ignoreAckHighNibble: boolean = false;
 
-	_transform(
-		chunk: any,
-		encoding: string,
-		callback: TransformCallback,
-	): void {
+	transform(
+		chunk: Uint8Array,
+		controller: TransformStreamDefaultController<
+			SerialAPIParserTransformerOutput
+		>,
+	) {
 		this.receiveBuffer = Bytes.concat([this.receiveBuffer, chunk]);
 
 		while (this.receiveBuffer.length > 0) {
@@ -45,18 +65,24 @@ export class SerialAPIParser extends Transform {
 					// Emit the single-byte messages directly
 					case MessageHeaders.ACK: {
 						this.logger?.ACK("inbound");
-						this.push(MessageHeaders.ACK);
+						controller.enqueue(
+							wrapSerialAPIChunk(MessageHeaders.ACK),
+						);
 						this.ignoreAckHighNibble = false;
 						break;
 					}
 					case MessageHeaders.NAK: {
 						this.logger?.NAK("inbound");
-						this.push(MessageHeaders.NAK);
+						controller.enqueue(
+							wrapSerialAPIChunk(MessageHeaders.NAK),
+						);
 						break;
 					}
 					case MessageHeaders.CAN: {
 						this.logger?.CAN("inbound");
-						this.push(MessageHeaders.CAN);
+						controller.enqueue(
+							wrapSerialAPIChunk(MessageHeaders.CAN),
+						);
 						break;
 					}
 					default: {
@@ -76,7 +102,9 @@ export class SerialAPIParser extends Transform {
 								}`,
 							);
 							this.logger?.ACK("inbound");
-							this.push(MessageHeaders.ACK);
+							controller.enqueue(
+								wrapSerialAPIChunk(MessageHeaders.ACK),
+							);
 							this.ignoreAckHighNibble = false;
 							break;
 						}
@@ -97,7 +125,10 @@ export class SerialAPIParser extends Transform {
 						}
 						const discarded = this.receiveBuffer.subarray(0, skip);
 						this.logger?.discarded(discarded);
-						this.onDiscarded?.(discarded);
+						controller.enqueue({
+							type: ZWaveSerialFrameType.Discarded,
+							data: discarded,
+						});
 					}
 				}
 				// Continue with the next valid byte
@@ -116,9 +147,26 @@ export class SerialAPIParser extends Transform {
 				this.receiveBuffer = this.receiveBuffer.subarray(msgLength);
 
 				this.logger?.data("inbound", msg);
-				this.push(msg);
+				controller.enqueue(wrapSerialAPIChunk(msg));
 			}
 		}
-		callback();
+	}
+}
+export class SerialAPIParser extends TransformStream {
+	constructor(
+		logger?: SerialLogger,
+	) {
+		const transformer = new SerialAPIParserTransformer(logger);
+		super(transformer);
+		this.#transformer = transformer;
+	}
+
+	#transformer: SerialAPIParserTransformer;
+
+	public get ignoreAckHighNibble(): boolean {
+		return this.#transformer.ignoreAckHighNibble;
+	}
+	public set ignoreAckHighNibble(value: boolean) {
+		this.#transformer.ignoreAckHighNibble = value;
 	}
 }
diff --git a/packages/serial/src/parsers/ZWaveSerialFrame.ts b/packages/serial/src/parsers/ZWaveSerialFrame.ts
new file mode 100644
index 000000000000..381b8fbc1e20
--- /dev/null
+++ b/packages/serial/src/parsers/ZWaveSerialFrame.ts
@@ -0,0 +1,61 @@
+import { type Bytes } from "@zwave-js/shared";
+import {
+	type MessageHeaders,
+	type XModemMessageHeaders,
+} from "../message/MessageHeaders.js";
+
+export enum ZWaveSerialFrameType {
+	SerialAPI = 0,
+	Bootloader = 1,
+	Discarded = 0xff,
+}
+
+export type ZWaveSerialFrame = {
+	type: ZWaveSerialFrameType.SerialAPI;
+	data: SerialAPIChunk;
+} | {
+	type: ZWaveSerialFrameType.Bootloader;
+	data: BootloaderChunk;
+} | {
+	type: ZWaveSerialFrameType.Discarded;
+	data: Uint8Array;
+};
+
+export type SerialAPIChunk =
+	| Bytes
+	| MessageHeaders.ACK
+	| MessageHeaders.NAK
+	| MessageHeaders.CAN;
+
+export enum BootloaderChunkType {
+	Error,
+	Menu,
+	Message,
+	FlowControl,
+}
+
+export type BootloaderChunk =
+	| {
+		type: BootloaderChunkType.Error;
+		error: string;
+		_raw: string;
+	}
+	| {
+		type: BootloaderChunkType.Menu;
+		version: string;
+		options: { num: number; option: string }[];
+		_raw: string;
+	}
+	| {
+		type: BootloaderChunkType.Message;
+		message: string;
+		_raw: string;
+	}
+	| {
+		type: BootloaderChunkType.FlowControl;
+		command:
+			| XModemMessageHeaders.ACK
+			| XModemMessageHeaders.NAK
+			| XModemMessageHeaders.CAN
+			| XModemMessageHeaders.C;
+	};
diff --git a/packages/serial/src/parsers/ZnifferParser.ts b/packages/serial/src/parsers/ZnifferParser.ts
index 72d6171eee0c..599fb6831954 100644
--- a/packages/serial/src/parsers/ZnifferParser.ts
+++ b/packages/serial/src/parsers/ZnifferParser.ts
@@ -1,8 +1,12 @@
 import { Bytes } from "@zwave-js/shared";
-import { Transform, type TransformCallback } from "node:stream";
+import { type Transformer } from "node:stream/web";
 import type { SerialLogger } from "../log/Logger.js";
 import { ZnifferFrameType } from "../message/Constants.js";
 import { ZnifferMessageHeaders } from "../message/MessageHeaders.js";
+import {
+	type ZnifferSerialFrame,
+	ZnifferSerialFrameType,
+} from "./ZnifferSerialFrame.js";
 
 /** Given a buffer that starts with SOF, this method returns the number of bytes the first message occupies in the buffer */
 function getMessageLength(data: Uint8Array): number | undefined {
@@ -28,25 +32,22 @@ function getMessageLength(data: Uint8Array): number | undefined {
 	}
 }
 
-export class ZnifferParser extends Transform {
+class ZnifferParserTransformer
+	implements Transformer<Uint8Array, ZnifferSerialFrame>
+{
 	constructor(
 		private logger?: SerialLogger,
-		private onDiscarded?: (data: Uint8Array) => void,
-	) {
-		// We read byte streams but emit messages
-		super({ readableObjectMode: true });
-	}
+	) {}
 
 	private receiveBuffer = new Bytes();
 
 	// Allow ignoring the high nibble of an ACK once to work around an issue in the 700 series firmware
 	public ignoreAckHighNibble: boolean = false;
 
-	_transform(
-		chunk: any,
-		encoding: string,
-		callback: TransformCallback,
-	): void {
+	transform(
+		chunk: Uint8Array,
+		controller: TransformStreamDefaultController<ZnifferSerialFrame>,
+	) {
 		this.receiveBuffer = Bytes.concat([this.receiveBuffer, chunk]);
 
 		while (this.receiveBuffer.length > 0) {
@@ -63,7 +64,10 @@ export class ZnifferParser extends Transform {
 			if (skip > 0) {
 				const discarded = this.receiveBuffer.subarray(0, skip);
 				this.logger?.discarded(discarded);
-				this.onDiscarded?.(discarded);
+				controller.enqueue({
+					type: ZnifferSerialFrameType.Discarded,
+					data: discarded,
+				});
 
 				// Continue with the next valid byte
 				this.receiveBuffer = this.receiveBuffer.subarray(skip);
@@ -84,9 +88,21 @@ export class ZnifferParser extends Transform {
 				this.receiveBuffer = this.receiveBuffer.subarray(msgLength);
 
 				this.logger?.data("inbound", msg);
-				this.push(msg);
+				controller.enqueue({
+					type: ZnifferSerialFrameType.SerialAPI,
+					data: msg,
+				});
 			}
 		}
-		callback();
+	}
+}
+
+export class ZnifferParser
+	extends TransformStream<Uint8Array, ZnifferSerialFrame>
+{
+	constructor(
+		logger?: SerialLogger,
+	) {
+		super(new ZnifferParserTransformer(logger));
 	}
 }
diff --git a/packages/serial/src/parsers/ZnifferSerialFrame.ts b/packages/serial/src/parsers/ZnifferSerialFrame.ts
new file mode 100644
index 000000000000..92b23e216c3c
--- /dev/null
+++ b/packages/serial/src/parsers/ZnifferSerialFrame.ts
@@ -0,0 +1,14 @@
+import { type Bytes } from "@zwave-js/shared";
+
+export enum ZnifferSerialFrameType {
+	SerialAPI = 0,
+	Discarded = 0xff,
+}
+
+export type ZnifferSerialFrame = {
+	type: ZnifferSerialFrameType.SerialAPI;
+	data: Bytes;
+} | {
+	type: ZnifferSerialFrameType.Discarded;
+	data: Uint8Array;
+};
diff --git a/packages/serial/src/plumbing/Faucet.ts b/packages/serial/src/plumbing/Faucet.ts
new file mode 100644
index 000000000000..86b735cb608f
--- /dev/null
+++ b/packages/serial/src/plumbing/Faucet.ts
@@ -0,0 +1,78 @@
+/**
+ * Connects a readable stream and a writable stream
+ * while allowing the writable stream to be temporarily disconnected
+ * or un-writable.
+ *
+ * Data that is emitted while no writable stream is connected is discarded.
+ */
+export class Faucet<T> {
+	/** Creates a new Faucet. The data starts flowing immediately */
+	public constructor(
+		readable: ReadableStream<T>,
+		writable?: WritableStream<T>,
+	) {
+		this.#readable = readable;
+		this.#writable = writable;
+
+		void this.#flow();
+	}
+
+	#readable: ReadableStream<T>;
+	#writable: WritableStream<T> | undefined;
+
+	#abort: AbortController | undefined;
+
+	/**
+	 * Connects a new writable to the faucet.
+	 * If a writable is already connected, it is replaced.
+	 */
+	public connect(writable: WritableStream<T>): void {
+		this.#writable = writable;
+	}
+
+	/**
+	 * Disconnects the current writable from the faucet.
+	 */
+	public disconnect(): void {
+		this.#writable = undefined;
+	}
+
+	async #flow() {
+		const reader = this.#readable.getReader();
+		const abort = new AbortController();
+		this.#abort = abort;
+
+		try {
+			const abortPromise = new Promise<void>((resolve) => {
+				abort.signal.addEventListener("abort", () => {
+					resolve();
+				});
+			});
+
+			while (true) {
+				const result = await Promise.race([
+					reader.read(),
+					abortPromise.then(() => ({ done: true, value: undefined })),
+				]);
+				if (result.done || result.value == undefined) break;
+
+				let writer;
+				try {
+					writer = this.#writable?.getWriter();
+					await writer?.write(result.value);
+				} catch {
+					// ignore
+				} finally {
+					writer?.releaseLock();
+				}
+			}
+		} finally {
+			reader.releaseLock();
+		}
+	}
+
+	/** Closes the faucet and stops reading data */
+	public close(): void {
+		this.#abort?.abort();
+	}
+}
diff --git a/packages/serial/src/plumbing/Merge.ts b/packages/serial/src/plumbing/Merge.ts
new file mode 100644
index 000000000000..37704651aafa
--- /dev/null
+++ b/packages/serial/src/plumbing/Merge.ts
@@ -0,0 +1,43 @@
+import { isAbortError, noop } from "@zwave-js/shared";
+import { createDeferredPromise } from "alcalzone-shared/deferred-promise";
+
+/**
+ * Merge multiple streams into a single one, not taking order into account.
+ * If a stream ends before other ones, the other will continue adding data,
+ * and the finished one will not add any more data.
+ */
+export function mergeReadableStreams<T>(
+	...streams: ReadableStream<T>[]
+): ReadableStream<T> {
+	const resolvePromises = streams.map(() => createDeferredPromise<void>());
+	return new ReadableStream<T>({
+		start(controller) {
+			void Promise.all(resolvePromises)
+				.then(() => controller.close())
+				.catch(noop);
+			try {
+				for (const [key, stream] of Object.entries(streams)) {
+					void (async () => {
+						try {
+							for await (const data of stream) {
+								controller.enqueue(data);
+							}
+						} catch (e) {
+							// AbortErrors are expected when the stream is closed
+							if (!isAbortError(e)) {
+								try {
+									controller.error(e);
+								} catch {
+									// ignore if the controller is already in a failed state
+								}
+							}
+						}
+						resolvePromises[+key].resolve();
+					})();
+				}
+			} catch (e) {
+				controller.error(e);
+			}
+		},
+	});
+}
diff --git a/packages/serial/src/plumbing/SerialModeSwitch.ts b/packages/serial/src/plumbing/SerialModeSwitch.ts
new file mode 100644
index 000000000000..23f0d886a7f0
--- /dev/null
+++ b/packages/serial/src/plumbing/SerialModeSwitch.ts
@@ -0,0 +1,98 @@
+import { Bytes } from "@zwave-js/shared";
+import { bootloaderMenuPreamble } from "../parsers/BootloaderParsers.js";
+import { ZWaveSerialMode } from "../serialport/definitions.js";
+
+const IS_TEST = process.env.NODE_ENV === "test" || !!process.env.CI;
+
+// A transform stream with two outputs, where only one of both is
+// active at the same time
+
+export class SerialModeSwitch extends WritableStream<Uint8Array> {
+	public mode: ZWaveSerialMode | undefined;
+
+	// The output sides of the stream
+	#serialAPIWriter: WritableStreamDefaultWriter<Uint8Array>;
+	public readonly toSerialAPI: ReadableStream<Uint8Array>;
+
+	#bootloaderWriter: WritableStreamDefaultWriter<Uint8Array>;
+	public readonly toBootloader: ReadableStream<Uint8Array>;
+
+	public constructor() {
+		// Set up a writable stream for the input side of the public interface
+		// which also handles dispatching the data to the correct output
+		super({
+			write: async (chunk) => {
+				if (this.mode == undefined) {
+					const buffer = Bytes.view(chunk);
+					// If we haven't figured out the startup mode yet,
+					// inspect the chunk to see if it contains the bootloader preamble
+					const str = buffer.toString("ascii")
+						// like .trim(), but including null bytes
+						.replaceAll(/^[\s\0]+|[\s\0]+$/g, "");
+
+					if (str.startsWith(bootloaderMenuPreamble)) {
+						// We're sure we're in bootloader mode
+						this.mode = ZWaveSerialMode.Bootloader;
+					} else if (
+						buffer.every((b) =>
+							b === 0x00
+							|| b === 0x0a
+							|| b === 0x0d
+							|| (b >= 0x20 && b <= 0x7e)
+						) && buffer.some((b) => b >= 0x20 && b <= 0x7e)
+					) {
+						// Only printable line breaks, null bytes and at least one printable ASCII character
+						// --> We're pretty sure we're in bootloader mode
+						this.mode = ZWaveSerialMode.Bootloader;
+					} else {
+						// We're in Serial API mode
+						this.mode = ZWaveSerialMode.SerialAPI;
+					}
+				}
+
+				// On Windows, writing to the parsers immediately seems to lag the event loop
+				// long enough that the state machine sometimes has not transitioned to the next state yet.
+				// By using setImmediate, we "break" the work into manageable chunks.
+				// We have some tests that don't like this though, so we don't do it in tests
+				const write = async () => {
+					if (this.mode === ZWaveSerialMode.Bootloader) {
+						await this.#bootloaderWriter.write(chunk);
+						await this.#bootloaderWriter.ready;
+					} else {
+						await this.#serialAPIWriter.write(chunk);
+						await this.#serialAPIWriter.ready;
+					}
+				};
+
+				if (IS_TEST) {
+					await write();
+				} else {
+					setImmediate(write);
+				}
+			},
+			abort: async (reason) => {
+				// We need to abort our sinks so the error is propagated
+				try {
+					await this.#bootloaderWriter.abort(reason);
+				} catch {
+					// Don't care
+				}
+				try {
+					await this.#serialAPIWriter.abort(reason);
+				} catch {
+					// Don't care
+				}
+			},
+		});
+
+		// Set put identity streams for the output side of the public interface
+		const { readable: toSerialAPI, writable: outputSerialAPI } =
+			new TransformStream();
+		const { readable: toBootloader, writable: outputBootloader } =
+			new TransformStream();
+		this.toSerialAPI = toSerialAPI;
+		this.#serialAPIWriter = outputSerialAPI.getWriter();
+		this.toBootloader = toBootloader;
+		this.#bootloaderWriter = outputBootloader.getWriter();
+	}
+}
diff --git a/packages/serial/src/plumbing/ZWaveSerialParser.ts b/packages/serial/src/plumbing/ZWaveSerialParser.ts
new file mode 100644
index 000000000000..07ce196e5f6f
--- /dev/null
+++ b/packages/serial/src/plumbing/ZWaveSerialParser.ts
@@ -0,0 +1,72 @@
+import { noop } from "@zwave-js/shared";
+import { type SerialLogger } from "../log/Logger.js";
+import {
+	BootloaderParser,
+	BootloaderScreenParser,
+} from "../parsers/BootloaderParsers.js";
+import { SerialAPIParser } from "../parsers/SerialAPIParser.js";
+import { type ZWaveSerialFrame } from "../parsers/ZWaveSerialFrame.js";
+import { type ZWaveSerialMode } from "../serialport/definitions.js";
+import { mergeReadableStreams } from "./Merge.js";
+import { SerialModeSwitch } from "./SerialModeSwitch.js";
+
+/** The internal plumbing to convert raw serial data to Z-Wave serial frames */
+export class ZWaveSerialParser {
+	public constructor(logger: SerialLogger, signal?: AbortSignal) {
+		// Prepare parsers for reading from the serial port
+		// -> Serial API mode
+		this.parser = new SerialAPIParser(logger);
+
+		// -> Bootloader mode
+		// This one looks for NUL chars which terminate each bootloader output screen
+		const bootloaderScreenParser = new BootloaderScreenParser(
+			logger,
+		);
+		// This one parses the bootloader output into a more usable format
+		const bootloaderParser = new BootloaderParser();
+
+		// Mode switch
+		this.modeSwitch = new SerialModeSwitch();
+
+		// Now set up the plumbing:
+		//                        ┌>         parser         ┐
+		// writable == modeSwitch ┤                         ├> readable
+		//                        └> BL screen -> BL parser ┘
+
+		this.modeSwitch.toSerialAPI
+			.pipeTo(this.parser.writable, { signal })
+			.catch(noop);
+
+		this.modeSwitch.toBootloader
+			.pipeThrough(bootloaderScreenParser, { signal })
+			.pipeTo(bootloaderParser.writable, { signal })
+			.catch(noop);
+
+		// Join the output streams from the parsers and expose it as the public readable stream
+		this.readable = mergeReadableStreams(
+			this.parser.readable,
+			bootloaderParser.readable,
+		);
+	}
+	// Public interface to let consumers read from and write to this stream
+	public readonly readable: ReadableStream<ZWaveSerialFrame>;
+	public get writable(): WritableStream<Uint8Array> {
+		return this.modeSwitch;
+	}
+
+	private parser: SerialAPIParser;
+
+	// Allow switching between modes
+	private modeSwitch: SerialModeSwitch;
+	public get mode(): ZWaveSerialMode | undefined {
+		return this.modeSwitch.mode;
+	}
+	public set mode(mode: ZWaveSerialMode | undefined) {
+		this.modeSwitch.mode = mode;
+	}
+
+	// Allow ignoring the high nibble of an ACK once to work around an issue in the 700 series firmware
+	public ignoreAckHighNibbleOnce(): void {
+		this.parser.ignoreAckHighNibble = true;
+	}
+}
diff --git a/packages/serial/src/serialport/LegacyBindingWrapper.ts b/packages/serial/src/serialport/LegacyBindingWrapper.ts
new file mode 100644
index 000000000000..45755eb2364e
--- /dev/null
+++ b/packages/serial/src/serialport/LegacyBindingWrapper.ts
@@ -0,0 +1,67 @@
+/* eslint-disable @typescript-eslint/no-deprecated */
+import { ZWaveError, ZWaveErrorCodes } from "@zwave-js/core";
+import { type UnderlyingSink, type UnderlyingSource } from "node:stream/web";
+import { type ZWaveSerialPortImplementation } from "./ZWaveSerialPortImplementation.js";
+import { type ZWaveSerialBindingFactory } from "./ZWaveSerialStream.js";
+
+export function wrapLegacySerialBinding(
+	legacy: ZWaveSerialPortImplementation,
+): ZWaveSerialBindingFactory {
+	return async function() {
+		const instance = legacy.create();
+
+		await legacy.open(instance);
+		let isOpen = true;
+
+		async function close(): Promise<void> {
+			if (isOpen) {
+				await legacy.close(instance);
+			}
+		}
+
+		const sink: UnderlyingSink<Uint8Array> = {
+			start(controller) {
+				instance.on("error", (err) => controller.error(err));
+			},
+			write(data, controller) {
+				if (!isOpen) {
+					controller.error(new Error("The serial port is not open!"));
+				}
+
+				return new Promise((resolve, reject) => {
+					instance.write(data, (err) => {
+						if (err) reject(err);
+						else resolve();
+					});
+				});
+			},
+			close() {
+				return close();
+			},
+			abort(_reason) {
+				return close();
+			},
+		};
+
+		const source: UnderlyingSource<Uint8Array> = {
+			start(controller) {
+				instance.on("data", (data) => controller.enqueue(data));
+				// Abort source controller too if the serial port closes
+				instance.on("close", () => {
+					isOpen = false;
+					controller.error(
+						new ZWaveError(
+							`The serial port closed unexpectedly!`,
+							ZWaveErrorCodes.Driver_Failed,
+						),
+					);
+				});
+			},
+			cancel() {
+				instance.removeAllListeners();
+			},
+		};
+
+		return { source, sink };
+	};
+}
diff --git a/packages/serial/src/serialport/NodeSerialPort.ts b/packages/serial/src/serialport/NodeSerialPort.ts
new file mode 100644
index 000000000000..efc398eb0088
--- /dev/null
+++ b/packages/serial/src/serialport/NodeSerialPort.ts
@@ -0,0 +1,123 @@
+import { ZWaveError, ZWaveErrorCodes } from "@zwave-js/core";
+import { type UnderlyingSink, type UnderlyingSource } from "node:stream/web";
+import { SerialPort } from "serialport";
+import { type DisconnectError } from "./DisconnectError.js";
+import { type ZWaveSerialBindingFactory } from "./ZWaveSerialStream.js";
+
+/** The default version of the Z-Wave serial binding factory that works using node-serialport */
+export function createNodeSerialPortFactory(
+	port: string,
+	Binding: typeof SerialPort = SerialPort,
+): ZWaveSerialBindingFactory {
+	return async function() {
+		const serial = new Binding({
+			path: port,
+			autoOpen: false,
+			baudRate: 115200,
+			dataBits: 8,
+			stopBits: 1,
+			parity: "none",
+		});
+
+		let isOpen = serial.isOpen;
+
+		function removeListeners() {
+			serial.removeAllListeners("close");
+			serial.removeAllListeners("error");
+			serial.removeAllListeners("open");
+		}
+
+		async function close(): Promise<void> {
+			if (!isOpen) return;
+			isOpen = false;
+
+			return new Promise((resolve) => {
+				removeListeners();
+				serial.once("close", resolve);
+				serial.close();
+			});
+		}
+
+		function open(): Promise<void> {
+			return new Promise<void>((resolve, reject) => {
+				const onClose = () => {
+					removeListeners();
+					reject(
+						new ZWaveError(
+							`The serial port closed unexpectedly!`,
+							ZWaveErrorCodes.Driver_Failed,
+						),
+					);
+				};
+				const onError = (err: Error) => {
+					removeListeners();
+					reject(err);
+				};
+				const onOpen = () => {
+					removeListeners();
+					isOpen = true;
+					resolve();
+				};
+
+				serial.once("close", onClose);
+				serial.once("error", onError);
+				serial.once("open", onOpen);
+
+				serial.open();
+			});
+		}
+
+		await close();
+		await open();
+
+		// Once the serialport is opened, wrap it as web streams.
+		// This could be done in the start method of the sink, but handling async errors is a pain there.
+
+		const sink: UnderlyingSink<Uint8Array> = {
+			start(controller) {
+				serial.on("error", (err) => controller.error(err));
+			},
+			write(data, controller) {
+				if (!isOpen) {
+					controller.error(new Error("The serial port is not open!"));
+				}
+
+				return new Promise((resolve, reject) => {
+					serial.write(data, (err) => {
+						if (err) reject(err);
+						else resolve();
+					});
+				});
+			},
+			close() {
+				return close();
+			},
+			abort(_reason) {
+				return close();
+			},
+		};
+
+		const source: UnderlyingSource<Uint8Array> = {
+			start(controller) {
+				serial.on("data", (data) => controller.enqueue(data));
+				// Abort source controller too if the serial port closes
+				serial.on("close", (err?: DisconnectError) => {
+					if (err?.disconnected === true) {
+						isOpen = false;
+						controller.error(
+							new ZWaveError(
+								`The serial port closed unexpectedly!`,
+								ZWaveErrorCodes.Driver_Failed,
+							),
+						);
+					}
+				});
+			},
+			cancel() {
+				serial.removeAllListeners();
+			},
+		};
+
+		return { source, sink };
+	};
+}
diff --git a/packages/serial/src/serialport/NodeSocket.ts b/packages/serial/src/serialport/NodeSocket.ts
new file mode 100644
index 000000000000..f03e8e22ec51
--- /dev/null
+++ b/packages/serial/src/serialport/NodeSocket.ts
@@ -0,0 +1,111 @@
+import { ZWaveError, ZWaveErrorCodes } from "@zwave-js/core";
+import net from "node:net";
+import { type UnderlyingSink, type UnderlyingSource } from "node:stream/web";
+import { type ZWaveSerialBindingFactory } from "./ZWaveSerialStream.js";
+import { type ZWaveSocketOptions } from "./ZWaveSocketOptions.js";
+
+export function createNodeSocketFactory(
+	socketOptions: ZWaveSocketOptions,
+): ZWaveSerialBindingFactory {
+	return async function() {
+		const socket = new net.Socket();
+
+		function removeListeners() {
+			socket.removeAllListeners("close");
+			socket.removeAllListeners("error");
+			socket.removeAllListeners("open");
+		}
+
+		function open(): Promise<void> {
+			return new Promise((resolve, reject) => {
+				const onClose = () => {
+					// detect socket disconnection errors
+					reject(
+						new ZWaveError(
+							`The socket closed unexpectedly!`,
+							ZWaveErrorCodes.Driver_Failed,
+						),
+					);
+				};
+
+				const onError = (err: Error) => {
+					removeListeners();
+					reject(err);
+				};
+				const onConnect = () => {
+					socket.setKeepAlive(true, 2500);
+					removeListeners();
+					resolve();
+				};
+
+				socket.once("close", onClose);
+				socket.once("error", onError);
+				socket.once("connect", onConnect);
+
+				socket.connect(socketOptions);
+			});
+		}
+
+		function close(): Promise<void> {
+			return new Promise((resolve) => {
+				removeListeners();
+				if (socket.destroyed) {
+					resolve();
+				} else {
+					socket.once("close", () => resolve()).destroy();
+				}
+			});
+		}
+
+		await open();
+		let isOpen = true;
+
+		// Once the socket is opened, wrap it as web streams.
+		// This could be done in the start method of the sink, but handling async errors is a pain there.
+
+		const sink: UnderlyingSink<Uint8Array> = {
+			start(controller) {
+				socket.on("error", (err) => controller.error(err));
+			},
+			write(data, controller) {
+				if (!isOpen) {
+					controller.error(new Error("The serial port is not open!"));
+				}
+
+				return new Promise((resolve, reject) => {
+					socket.write(data, (err) => {
+						if (err) reject(err);
+						else resolve();
+					});
+				});
+			},
+			close() {
+				return close();
+			},
+			abort(_reason) {
+				return close();
+			},
+		};
+
+		const source: UnderlyingSource<Uint8Array> = {
+			start(controller) {
+				socket.on("data", (data) => controller.enqueue(data));
+				// Abort source controller too if the serial port closes
+				socket.on("close", () => {
+					isOpen = false;
+					controller.error(
+						new ZWaveError(
+							`The serial port closed unexpectedly!`,
+							ZWaveErrorCodes.Driver_Failed,
+						),
+					);
+				});
+			},
+			cancel() {
+				socket.removeAllListeners();
+			},
+		};
+
+		return { source, sink };
+	};
+}
diff --git a/packages/serial/src/serialport/ZWaveSerialPort.test.ts b/packages/serial/src/serialport/ZWaveSerialPort.test.ts
deleted file mode 100644
index b801d8cec252..000000000000
--- a/packages/serial/src/serialport/ZWaveSerialPort.test.ts
+++ /dev/null
@@ -1,245 +0,0 @@
-import { Bytes } from "@zwave-js/shared/safe";
-import { wait } from "alcalzone-shared/async";
-import { PassThrough } from "node:stream";
-import sinon from "sinon";
-import { afterEach, beforeEach, test } from "vitest";
-import { MessageHeaders } from "../message/MessageHeaders.js";
-import { createAndOpenMockedZWaveSerialPort } from "../mock/MockSerialPort.js";
-import type { MockPortBinding } from "../mock/SerialPortBindingMock.js";
-import type { ZWaveSerialPort } from "./ZWaveSerialPort.js";
-
-interface TestContext {
-	port: ZWaveSerialPort;
-	binding: MockPortBinding;
-}
-
-async function waitForData(port: {
-	once: (event: "data", callback: (data: any) => void) => any;
-}): Promise<
-	MessageHeaders.ACK | MessageHeaders.NAK | MessageHeaders.CAN | Uint8Array
-> {
-	return new Promise((resolve) => {
-		port.once("data", resolve);
-	});
-}
-
-beforeEach(async (t) => {
-	t.context = await createAndOpenMockedZWaveSerialPort("/dev/zwavetest");
-});
-
-afterEach(async (t) => {
-	const port = t.context.port;
-	port.removeAllListeners();
-	if (port.isOpen) await port.close();
-});
-
-test("isOpen returns true after opening", async (t) => {
-	const { port } = t.context;
-	t.expect(port.isOpen).toBe(true);
-});
-
-test("isOpen returns false after closing", async (t) => {
-	const { port } = t.context;
-	await port.close();
-	t.expect(port.isOpen).toBe(false);
-});
-
-test("passes written data through unchanged", async (t) => {
-	const { port, binding } = t.context;
-	const buffers = [
-		Bytes.from([1, 2, 3]),
-		Bytes.from("abcdef1234567890", "hex"),
-	];
-	for (const buffer of buffers) {
-		await port.writeAsync(buffer);
-		t.expect(binding.lastWrite).toStrictEqual(buffer);
-	}
-});
-
-test("write rejects if the port is not open", async (t) => {
-	const { port } = t.context;
-	await port.close();
-	await t.expect(() => port.writeAsync(Bytes.from([MessageHeaders.ACK])))
-		.rejects.toThrowError();
-});
-
-test("emit an event for each single-byte message that was read", async (t) => {
-	const { port, binding } = t.context;
-	binding.emitData(Bytes.from([MessageHeaders.ACK]));
-	let data = await waitForData(port);
-	t.expect(data).toStrictEqual(MessageHeaders.ACK);
-
-	binding.emitData(Bytes.from([MessageHeaders.CAN]));
-	data = await waitForData(port);
-	t.expect(data).toStrictEqual(MessageHeaders.CAN);
-
-	binding.emitData(Bytes.from([MessageHeaders.NAK]));
-	data = await waitForData(port);
-	t.expect(data).toStrictEqual(MessageHeaders.NAK);
-});
-
-test("emits a series of events when multiple single-byte messages are received", async (t) => {
-	const { port, binding } = t.context;
-	binding.emitData(
-		Bytes.from([
-			MessageHeaders.ACK,
-			MessageHeaders.CAN,
-			MessageHeaders.NAK,
-		]),
-	);
-
-	let count = 0;
-	return new Promise((resolve) => {
-		port.on("data", (data) => {
-			count++;
-			if (count === 1) t.expect(data).toBe(MessageHeaders.ACK);
-			if (count === 2) t.expect(data).toBe(MessageHeaders.CAN);
-			if (count === 3) t.expect(data).toBe(MessageHeaders.NAK);
-
-			if (count === 3) resolve();
-		});
-	});
-});
-
-test("skips all invalid/unexpected data", async (t) => {
-	const { port, binding } = t.context;
-	binding.emitData(
-		Bytes.from([
-			MessageHeaders.ACK,
-			MessageHeaders.CAN,
-			0xff,
-			0xfe,
-			0xfd,
-			0xfa,
-			MessageHeaders.ACK,
-		]),
-	);
-
-	let count = 0;
-	return new Promise((resolve) => {
-		port.on("data", (data) => {
-			count++;
-			if (count === 1) t.expect(data).toBe(MessageHeaders.ACK);
-			if (count === 2) t.expect(data).toBe(MessageHeaders.CAN);
-			if (count === 3) t.expect(data).toBe(MessageHeaders.ACK);
-
-			if (count === 3) resolve();
-		});
-	});
-});
-
-test("skips all invalid/unexpected data (test 2)", async (t) => {
-	const { port, binding } = t.context;
-	binding.emitData(
-		Bytes.from([
-			MessageHeaders.ACK,
-			MessageHeaders.CAN,
-			0xff,
-			0xfe,
-			0xfd,
-			0xfa,
-		]),
-	);
-	setTimeout(() => {
-		binding.emitData(Bytes.from([MessageHeaders.NAK]));
-	}, 10);
-
-	let count = 0;
-	return new Promise((resolve) => {
-		port.on("data", (data) => {
-			count++;
-			if (count === 1) t.expect(data).toBe(MessageHeaders.ACK);
-			if (count === 2) t.expect(data).toBe(MessageHeaders.CAN);
-			if (count === 3) t.expect(data).toBe(MessageHeaders.NAK);
-
-			if (count === 3) resolve();
-		});
-	});
-});
-test("emits a buffer when a message is received", async (t) => {
-	const { port, binding } = t.context;
-	const data = Bytes.from([
-		MessageHeaders.SOF,
-		0x05, // remaining length
-		0xff,
-		0xff,
-		0xff,
-		0xff,
-		0xff,
-	]);
-	binding.emitData(data);
-
-	const received = await waitForData(port);
-	t.expect(received).toStrictEqual(data);
-});
-
-test("may be consumed with an async iterator", async (t) => {
-	const { port, binding } = t.context;
-	const data = Bytes.from([
-		MessageHeaders.ACK,
-		MessageHeaders.CAN,
-		0xff,
-		0xfe,
-		0xfd,
-		0xfa,
-		MessageHeaders.ACK,
-	]);
-	binding.emitData(data);
-
-	let count = 0;
-	for await (const msg of port) {
-		count++;
-		if (count === 1) t.expect(msg).toBe(MessageHeaders.ACK);
-		if (count === 2) t.expect(msg).toBe(MessageHeaders.CAN);
-		if (count === 3) t.expect(msg).toBe(MessageHeaders.ACK);
-		if (count === 3) break;
-	}
-});
-
-test("can be piped into", async (t) => {
-	const { port, binding } = t.context;
-	const passThrough = new PassThrough();
-	passThrough.pipe(port);
-
-	return new Promise((resolve) => {
-		const data = Bytes.from([1, 2, 3, 4, 5]);
-		passThrough.write(data, (err) => {
-			t.expect(err).toBeFalsy();
-			// I see no better way of forcing the write to bubble through the streams
-			setTimeout(() => {
-				t.expect(binding.lastWrite).toStrictEqual(data);
-				resolve();
-			}, 1);
-		});
-	});
-});
-
-test("can be piped to a reader", async (t) => {
-	const { port, binding } = t.context;
-	const stream = new PassThrough();
-	port.pipe(stream);
-
-	// eslint-disable-next-line no-restricted-globals -- Serialport uses Node.js Buffers
-	const expected = Buffer.from([0x01, 0x03, 0xff, 0xff, 0xff]);
-	binding.emitData(expected);
-
-	const data = await waitForData(stream);
-	t.expect(data).toStrictEqual(expected);
-});
-
-test("can be unpiped again", async (t) => {
-	const { port, binding } = t.context;
-	const stream = new PassThrough();
-	const spy = sinon.spy();
-	stream.on("data", spy);
-
-	port.pipe(stream);
-	port.unpipe();
-
-	const expected = Bytes.from([0x01, 0x03, 0xff, 0xff, 0xff]);
-	binding.emitData(expected);
-
-	await wait(1);
-
-	t.expect(spy.callCount).toBe(0);
-});
diff --git a/packages/serial/src/serialport/ZWaveSerialPort.ts b/packages/serial/src/serialport/ZWaveSerialPort.ts
deleted file mode 100644
index 0cb6feed590a..000000000000
--- a/packages/serial/src/serialport/ZWaveSerialPort.ts
+++ /dev/null
@@ -1,82 +0,0 @@
-import {
-	ZWaveError,
-	ZWaveErrorCodes,
-	type ZWaveLogContainer,
-} from "@zwave-js/core";
-import { SerialPort } from "serialport";
-import type { DisconnectError } from "./DisconnectError.js";
-import { ZWaveSerialPortBase } from "./ZWaveSerialPortBase.js";
-
-/** The default version of the Z-Wave serial binding that works using node-serialport */
-export class ZWaveSerialPort extends ZWaveSerialPortBase {
-	constructor(
-		port: string,
-		loggers: ZWaveLogContainer,
-		Binding: typeof SerialPort = SerialPort,
-	) {
-		let removeListeners: (removeOnClose: boolean) => void;
-
-		super(
-			{
-				create: () =>
-					new Binding({
-						path: port,
-						autoOpen: false,
-						baudRate: 115200,
-						dataBits: 8,
-						stopBits: 1,
-						parity: "none",
-					}),
-				open: (serial: SerialPort) =>
-					new Promise((resolve, reject) => {
-						const onClose = (err?: DisconnectError) => {
-							// detect serial disconnection errors
-							if (err?.disconnected === true) {
-								removeListeners(true);
-								this.emit(
-									"error",
-									new ZWaveError(
-										`The serial port closed unexpectedly!`,
-										ZWaveErrorCodes.Driver_Failed,
-									),
-								);
-							}
-						};
-						const onError = (err: Error) => {
-							removeListeners(true);
-							reject(err);
-						};
-						const onOpen = () => {
-							removeListeners(false);
-							resolve();
-						};
-
-						// We need to remove the listeners again no matter which of the handlers is called
-						// Otherwise this would cause an EventEmitter leak.
-						// Hence this somewhat ugly construct
-						removeListeners = (removeOnClose: boolean) => {
-							if (removeOnClose) {
-								serial.removeListener("close", onClose);
-							}
-							serial.removeListener("error", onError);
-							serial.removeListener("open", onOpen);
-						};
-
-						serial.once("close", onClose);
-						serial.once("error", onError);
-						serial.once("open", onOpen).open();
-					}),
-				close: (serial: SerialPort) =>
-					new Promise((resolve) => {
-						removeListeners(true);
-						serial.once("close", resolve).close();
-					}),
-			},
-			loggers,
-		);
-	}
-
-	public get isOpen(): boolean {
-		return (this.serial as SerialPort).isOpen;
-	}
-}
diff --git a/packages/serial/src/serialport/ZWaveSerialPortBase.ts b/packages/serial/src/serialport/ZWaveSerialPortBase.ts
deleted file mode 100644
index b587ce48072d..000000000000
--- a/packages/serial/src/serialport/ZWaveSerialPortBase.ts
+++ /dev/null
@@ -1,267 +0,0 @@
-import type { ZWaveLogContainer } from "@zwave-js/core";
-import { Bytes, Mixin } from "@zwave-js/shared";
-import { EventEmitter } from "node:events";
-import { PassThrough, type Readable, type Writable } from "node:stream";
-import { SerialLogger } from "../log/Logger.js";
-import { MessageHeaders } from "../message/MessageHeaders.js";
-import {
-	type BootloaderChunk,
-	BootloaderParser,
-	BootloaderScreenParser,
-	bootloaderMenuPreamble,
-} from "../parsers/BootloaderParsers.js";
-import { SerialAPIParser } from "../parsers/SerialAPIParser.js";
-import { type ZWaveSerialPortImplementation } from "./ZWaveSerialPortImplementation.js";
-
-export type ZWaveSerialChunk =
-	| MessageHeaders.ACK
-	| MessageHeaders.NAK
-	| MessageHeaders.CAN
-	| Uint8Array;
-
-export enum ZWaveSerialMode {
-	SerialAPI,
-	Bootloader,
-}
-
-export interface ZWaveSerialPortEventCallbacks {
-	error: (e: Error) => void;
-	data: (data: ZWaveSerialChunk) => void;
-	discardedData: (data: Uint8Array) => void;
-	bootloaderData: (data: BootloaderChunk) => void;
-}
-
-export type ZWaveSerialPortEvents = Extract<
-	keyof ZWaveSerialPortEventCallbacks,
-	string
->;
-
-export interface ZWaveSerialPortBase {
-	on<TEvent extends ZWaveSerialPortEvents>(
-		event: TEvent,
-		callback: ZWaveSerialPortEventCallbacks[TEvent],
-	): this;
-	addListener<TEvent extends ZWaveSerialPortEvents>(
-		event: TEvent,
-		callback: ZWaveSerialPortEventCallbacks[TEvent],
-	): this;
-	once<TEvent extends ZWaveSerialPortEvents>(
-		event: TEvent,
-		callback: ZWaveSerialPortEventCallbacks[TEvent],
-	): this;
-	off<TEvent extends ZWaveSerialPortEvents>(
-		event: TEvent,
-		callback: ZWaveSerialPortEventCallbacks[TEvent],
-	): this;
-	removeListener<TEvent extends ZWaveSerialPortEvents>(
-		event: TEvent,
-		callback: ZWaveSerialPortEventCallbacks[TEvent],
-	): this;
-	removeAllListeners(event?: ZWaveSerialPortEvents): this;
-
-	emit<TEvent extends ZWaveSerialPortEvents>(
-		event: TEvent,
-		...args: Parameters<ZWaveSerialPortEventCallbacks[TEvent]>
-	): boolean;
-}
-
-const IS_TEST = process.env.NODE_ENV === "test" || !!process.env.CI;
-
-// This is basically a duplex transform stream wrapper around any stream (network, serial, ...)
-// 0 ┌─────────────────┐ ┌─────────────────┐ ┌──
-// 1 <--               <--   PassThrough   <-- write
-// 1 │    any stream   │ │ ZWaveSerialPort │ │
-// 0 -->               -->     Parsers     --> read
-// 1 └─────────────────┘ └─────────────────┘ └──
-// The implementation idea is based on https://stackoverflow.com/a/17476600/10179833
-
-@Mixin([EventEmitter])
-export class ZWaveSerialPortBase extends PassThrough {
-	protected serial: ReturnType<ZWaveSerialPortImplementation["create"]>;
-	protected logger: SerialLogger;
-
-	// Serial API parser
-	private parser: SerialAPIParser;
-	// Bootloader parsers
-	private bootloaderScreenParser: BootloaderScreenParser;
-	private bootloaderParser: BootloaderParser;
-
-	// Allow switching between modes
-	public mode: ZWaveSerialMode | undefined;
-
-	// Allow ignoring the high nibble of an ACK once to work around an issue in the 700 series firmware
-	public ignoreAckHighNibbleOnce(): void {
-		this.parser.ignoreAckHighNibble = true;
-	}
-
-	// Allow strongly-typed async iteration
-	declare public [Symbol.asyncIterator]: () => AsyncIterableIterator<
-		ZWaveSerialChunk
-	>;
-
-	constructor(
-		private implementation: ZWaveSerialPortImplementation,
-		loggers: ZWaveLogContainer,
-	) {
-		super({ readableObjectMode: true });
-
-		// Route the data event handlers to the parser and handle everything else ourselves
-		for (
-			const method of [
-				"on",
-				"once",
-				"off",
-				"addListener",
-				"removeListener",
-				"removeAllListeners",
-			] as const
-		) {
-			const original = this[method].bind(this);
-			this[method] = (event: any, ...args: any[]) => {
-				if (event === "data") {
-					// @ts-expect-error
-					this.parser[method]("data", ...args);
-				} else if (event === "bootloaderData") {
-					// @ts-expect-error
-					this.bootloaderParser[method]("data", ...args);
-				} else {
-					(original as any)(event, ...args);
-				}
-				return this;
-			};
-		}
-
-		this.logger = new SerialLogger(loggers);
-
-		this.serial = implementation.create().on("error", (e) => {
-			// Pass errors through
-			this.emit("error", e);
-		});
-
-		// Prepare parsers to hook up to the serial port
-		// -> Serial API mode
-		this.parser = new SerialAPIParser(
-			this.logger,
-			(discarded) => this.emit("discardedData", discarded),
-		);
-
-		// -> Bootloader mode
-		// This one looks for NUL chars which terminate each bootloader output screen
-		this.bootloaderScreenParser = new BootloaderScreenParser(this.logger);
-		// This one parses the bootloader output into a more usable format
-		this.bootloaderParser = new BootloaderParser();
-		// this.bootloaderParser.pipe(this.output);
-		this.bootloaderScreenParser.pipe(this.bootloaderParser);
-
-		// Check the incoming messages and route them to the correct parser
-		this.serial.on("data", (data) => {
-			if (this.mode == undefined) {
-				const buffer = Bytes.view(data as Uint8Array);
-				// If we haven't figured out the startup mode yet,
-				// inspect the chunk to see if it contains the bootloader preamble
-				const str = buffer.toString("ascii")
-					// like .trim(), but including null bytes
-					.replaceAll(/^[\s\0]+|[\s\0]+$/g, "");
-
-				if (str.startsWith(bootloaderMenuPreamble)) {
-					// We're sure we're in bootloader mode
-					this.mode = ZWaveSerialMode.Bootloader;
-				} else if (
-					buffer.every((b) =>
-						b === 0x00
-						|| b === 0x0a
-						|| b === 0x0d
-						|| (b >= 0x20 && b <= 0x7e)
-					) && buffer.some((b) => b >= 0x20 && b <= 0x7e)
-				) {
-					// Only printable line breaks, null bytes and at least one printable ASCII character
-					// --> We're pretty sure we're in bootloader mode
-					this.mode = ZWaveSerialMode.Bootloader;
-				} else {
-					// We're in Serial API mode
-					this.mode = ZWaveSerialMode.SerialAPI;
-				}
-			}
-
-			// On Windows, writing to the parsers immediately seems to lag the event loop
-			// long enough that the state machine sometimes has not transitioned to the next state yet.
-			// By using setImmediate, we "break" the work into manageable chunks.
-			// We have some tests that don't like this though, so we don't do it in tests
-			const write = () => {
-				if (this.mode === ZWaveSerialMode.Bootloader) {
-					this.bootloaderScreenParser.write(data);
-				} else {
-					this.parser.write(data);
-				}
-			};
-
-			if (IS_TEST) {
-				write();
-			} else {
-				setImmediate(write);
-			}
-		});
-
-		// When something is piped to us, pipe it to the serial port instead
-		// Also pass all written data to the serialport unchanged
-		this.on("pipe" as any, (source: Readable) => {
-			source.unpipe(this as any);
-			// Pass all written data to the serialport unchanged
-			source.pipe(this.serial as unknown as Writable, { end: false });
-		});
-
-		// When the wrapper is piped to a stream, pipe the serial API stream instead
-		this.pipe = this.parser.pipe.bind(this.parser);
-		this.unpipe = (destination) => {
-			this.parser.unpipe(destination);
-			return this;
-		};
-		// Delegate iterating to the serial API parser
-		this[Symbol.asyncIterator] = () => this.parser[Symbol.asyncIterator]();
-	}
-
-	public async open(): Promise<void> {
-		await this.implementation.open(this.serial);
-		this._isOpen = true;
-	}
-
-	public close(): Promise<void> {
-		this._isOpen = false;
-		return this.implementation.close(this.serial);
-	}
-
-	private _isOpen: boolean = false;
-	public get isOpen(): boolean {
-		return this._isOpen;
-	}
-
-	public async writeAsync(data: Uint8Array): Promise<void> {
-		if (!this.isOpen) {
-			throw new Error("The serial port is not open!");
-		}
-
-		// Only log in Serial API mode
-		if (this.mode === ZWaveSerialMode.SerialAPI && data.length === 1) {
-			switch (data[0]) {
-				case MessageHeaders.ACK:
-					this.logger.ACK("outbound");
-					break;
-				case MessageHeaders.CAN:
-					this.logger.CAN("outbound");
-					break;
-				case MessageHeaders.NAK:
-					this.logger.NAK("outbound");
-					break;
-			}
-		} else {
-			this.logger.data("outbound", data);
-		}
-
-		return new Promise((resolve, reject) => {
-			this.serial.write(data, (err) => {
-				if (err) reject(err);
-				else resolve();
-			});
-		});
-	}
-}
diff --git a/packages/serial/src/serialport/ZWaveSerialPortImplementation.ts b/packages/serial/src/serialport/ZWaveSerialPortImplementation.ts
index 4e185210f2ff..2eede1ea2f36 100644
--- a/packages/serial/src/serialport/ZWaveSerialPortImplementation.ts
+++ b/packages/serial/src/serialport/ZWaveSerialPortImplementation.ts
@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-deprecated */
 import { isObject } from "alcalzone-shared/typeguards";
 import { type EventEmitter } from "node:events";
 import { type Duplex } from "node:stream";
@@ -13,6 +14,7 @@ export function isZWaveSerialPortImplementation(
 	);
 }
 
+/** @deprecated Use {@link ZWaveSerialBindingFactory} instead */
 export interface ZWaveSerialPortImplementation {
 	create(): Duplex & EventEmitter;
 	open(
diff --git a/packages/serial/src/serialport/ZWaveSerialStream.test.ts b/packages/serial/src/serialport/ZWaveSerialStream.test.ts
new file mode 100644
index 000000000000..3f18e4c5b071
--- /dev/null
+++ b/packages/serial/src/serialport/ZWaveSerialStream.test.ts
@@ -0,0 +1,226 @@
+import { ZWaveLogContainer } from "@zwave-js/core";
+import { Bytes } from "@zwave-js/shared";
+import { isUint8Array } from "node:util/types";
+import {
+	type ExpectStatic,
+	afterEach,
+	beforeEach,
+	test as baseTest,
+} from "vitest";
+import { MessageHeaders } from "../message/MessageHeaders.js";
+import { MockPort } from "../mock/MockPort.js";
+import {
+	type ZWaveSerialFrame,
+	ZWaveSerialFrameType,
+} from "../parsers/ZWaveSerialFrame.js";
+import {
+	type ZWaveSerialStream,
+	ZWaveSerialStreamFactory,
+} from "./ZWaveSerialStream.js";
+
+interface LocalTestContext {
+	context: {
+		port: MockPort;
+		factory: ZWaveSerialStreamFactory;
+		serial: ZWaveSerialStream;
+	};
+}
+
+const test = baseTest.extend<LocalTestContext>({
+	context: [
+		async ({}, use) => {
+			// Setup
+			const port = new MockPort();
+			const context = {} as LocalTestContext["context"];
+			context.port = port;
+			context.factory = new ZWaveSerialStreamFactory(
+				port.factory(),
+				new ZWaveLogContainer({ enabled: false }),
+			);
+
+			// Run tests
+			await use(context);
+
+			// Teardown
+			port.destroy();
+		},
+		{ auto: true },
+	],
+});
+
+beforeEach<LocalTestContext>(async ({ context, expect }) => {
+	context.serial = await context.factory.createStream();
+});
+
+afterEach<LocalTestContext>(async ({ context }) => {
+	await context.serial.close();
+});
+
+async function waitForData(
+	stream: ReadableStream<ZWaveSerialFrame>,
+): Promise<ZWaveSerialFrame> {
+	const reader = stream.getReader();
+	try {
+		const result = await reader.read();
+		if (result.value) return result.value;
+		throw new Error("Unexpected end of stream");
+	} finally {
+		reader.releaseLock();
+	}
+}
+
+function assertSerialAPIFrame(
+	expect: ExpectStatic,
+	frame: ZWaveSerialFrame,
+	expectedData: MessageHeaders | Uint8Array,
+) {
+	expect(frame.type).toBe(ZWaveSerialFrameType.SerialAPI);
+	if (typeof expectedData === "number") {
+		expect(frame.data).toStrictEqual(expectedData);
+	} else {
+		expect(isUint8Array(frame.data)).toBe(true);
+		expect(Bytes.view(frame.data as Uint8Array)).to.deep.equal(
+			expectedData,
+		);
+	}
+	expect(frame.data).toStrictEqual(expectedData);
+}
+
+test("isOpen returns true after opening", async ({ context, expect }) => {
+	const { serial } = context;
+	expect(serial.isOpen).toBe(true);
+});
+
+test("isOpen returns false after closing", async ({ context, expect }) => {
+	const { serial } = context;
+	await serial.close();
+	expect(serial.isOpen).toBe(false);
+});
+
+test("passes written data through unchanged", async ({ context, expect }) => {
+	const { port, serial } = context;
+	const buffers = [
+		Bytes.from([1, 2, 3]),
+		Bytes.from("abcdef1234567890", "hex"),
+	];
+	for (const buffer of buffers) {
+		await serial.writeAsync(buffer);
+		expect(port.lastWrite).toStrictEqual(buffer);
+	}
+});
+
+test("write rejects if the port is not open", async ({ context, expect }) => {
+	const { port, serial } = context;
+	await serial.close();
+	await expect(() => serial.writeAsync(Bytes.from([MessageHeaders.ACK])))
+		.rejects.toThrowError();
+});
+
+test("emits a chunk of data for each single-byte message that was read", async ({ context, expect }) => {
+	const { port, serial } = context;
+	port.emitData(Bytes.from([MessageHeaders.ACK]));
+	let data = await waitForData(serial.readable);
+	assertSerialAPIFrame(expect, data, MessageHeaders.ACK);
+
+	port.emitData(Bytes.from([MessageHeaders.CAN]));
+	data = await waitForData(serial.readable);
+	assertSerialAPIFrame(expect, data, MessageHeaders.CAN);
+
+	port.emitData(Bytes.from([MessageHeaders.NAK]));
+	data = await waitForData(serial.readable);
+	assertSerialAPIFrame(expect, data, MessageHeaders.NAK);
+});
+
+test("emits a series of chunks when multiple single-byte messages are received", async ({ context, expect }) => {
+	const { port, serial } = context;
+	port.emitData(
+		Bytes.from([
+			MessageHeaders.ACK,
+			MessageHeaders.CAN,
+			MessageHeaders.NAK,
+		]),
+	);
+
+	let count = 0;
+	for await (const data of serial.readable) {
+		count++;
+		if (count === 1) assertSerialAPIFrame(expect, data, MessageHeaders.ACK);
+		if (count === 2) assertSerialAPIFrame(expect, data, MessageHeaders.CAN);
+		if (count === 3) assertSerialAPIFrame(expect, data, MessageHeaders.NAK);
+
+		if (count === 3) break;
+	}
+});
+
+test("marks all invalid/unexpected data", async ({ context, expect }) => {
+	const { port, serial } = context;
+	port.emitData(
+		Bytes.from([
+			MessageHeaders.ACK,
+			MessageHeaders.CAN,
+			0xff,
+			0xfe,
+			0xfd,
+			0xfa,
+			MessageHeaders.ACK,
+		]),
+	);
+
+	let count = 0;
+	for await (const data of serial.readable) {
+		if (data.type === ZWaveSerialFrameType.Discarded) continue;
+
+		count++;
+		if (count === 1) assertSerialAPIFrame(expect, data, MessageHeaders.ACK);
+		if (count === 2) assertSerialAPIFrame(expect, data, MessageHeaders.CAN);
+		if (count === 3) assertSerialAPIFrame(expect, data, MessageHeaders.ACK);
+
+		if (count === 3) break;
+	}
+});
+
+test("marks all invalid/unexpected data (test 2)", async ({ context, expect }) => {
+	const { port, serial } = context;
+	port.emitData(
+		Bytes.from([
+			MessageHeaders.ACK,
+			MessageHeaders.CAN,
+			0xff,
+			0xfe,
+			0xfd,
+			0xfa,
+		]),
+	);
+	setTimeout(async () => {
+		port.emitData(Bytes.from([MessageHeaders.NAK]));
+	}, 10);
+
+	let count = 0;
+	for await (const data of serial.readable) {
+		if (data.type === ZWaveSerialFrameType.Discarded) continue;
+
+		count++;
+		if (count === 1) assertSerialAPIFrame(expect, data, MessageHeaders.ACK);
+		if (count === 2) assertSerialAPIFrame(expect, data, MessageHeaders.CAN);
+		if (count === 3) assertSerialAPIFrame(expect, data, MessageHeaders.NAK);
+
+		if (count === 3) break;
+	}
+});
+
+test("emits a buffer when a message is received", async ({ context, expect }) => {
+	const { port, serial } = context;
+	const data = Bytes.from([
+		MessageHeaders.SOF,
+		0x05, // remaining length
+		0xff,
+		0xff,
+		0xff,
+		0xff,
+		0xff,
+	]);
+	port.emitData(data);
+
+	const received = await waitForData(serial.readable);
+	assertSerialAPIFrame(expect, received, data);
+});
diff --git a/packages/serial/src/serialport/ZWaveSerialStream.ts b/packages/serial/src/serialport/ZWaveSerialStream.ts
new file mode 100644
index 000000000000..ea274d155f23
--- /dev/null
+++ b/packages/serial/src/serialport/ZWaveSerialStream.ts
@@ -0,0 +1,171 @@
+// This is basically a duplex transform stream wrapper around a
+// readable and a writable stream, both compatible with the Web Streams API.
+// This allows supporting different low-level connections to a Z-Wave controller,
+// whether it's a serial port, a network connection, or something else.
+//
+// 0 ┌─────────────────┐ ┌─────────────────┐ ┌──
+// 1 <--               <--   PassThrough   <-- write
+// 1 │    any stream   │ │ ZWaveSerialPort │ │
+// 0 -->               -->     Parsers     --> read
+// 1 └─────────────────┘ └─────────────────┘ └──
+
+import { type ZWaveLogContainer } from "@zwave-js/core";
+import { noop } from "@zwave-js/shared";
+import {
+	ReadableStream,
+	type ReadableWritablePair,
+	type UnderlyingSink,
+	type UnderlyingSource,
+} from "node:stream/web";
+import { SerialLogger } from "../log/Logger.js";
+import { MessageHeaders } from "../message/MessageHeaders.js";
+import { type ZWaveSerialFrame } from "../parsers/ZWaveSerialFrame.js";
+import { ZWaveSerialParser } from "../plumbing/ZWaveSerialParser.js";
+import { ZWaveSerialMode } from "./definitions.js";
+
+/** The low level bindings used by ZWaveSerialStream.
+ * The `sink` is guaranteed to be opened first, so possible setup should be done in
+ * the `start` method there. */
+export interface ZWaveSerialBinding {
+	sink: UnderlyingSink<Uint8Array>;
+	source: UnderlyingSource<Uint8Array>;
+}
+
+export type ZWaveSerialBindingFactory = () => Promise<ZWaveSerialBinding>;
+
+/** Tests if `obj` is (probably) a ZWaveSerialBindingFactory */
+export function isZWaveSerialBindingFactory(
+	obj: unknown,
+): obj is ZWaveSerialBindingFactory {
+	return typeof obj === "function" && obj.length === 0;
+}
+
+/** Re-usable stream factory to create new serial streams */
+export class ZWaveSerialStreamFactory {
+	constructor(
+		binding: ZWaveSerialBindingFactory,
+		loggers: ZWaveLogContainer,
+	) {
+		this.binding = binding;
+		this.logger = new SerialLogger(loggers);
+	}
+
+	private binding: ZWaveSerialBindingFactory;
+	protected logger: SerialLogger;
+
+	public async createStream(): Promise<ZWaveSerialStream> {
+		// Set up streams for the underlying resource
+		const { source, sink } = await this.binding();
+		return new ZWaveSerialStream(source, sink, this.logger);
+	}
+}
+
+/** Single-use serial stream. Has to be re-created after being closed. */
+export class ZWaveSerialStream implements
+	ReadableWritablePair<
+		// The serial binding emits ZWaveSerialFrames
+		ZWaveSerialFrame,
+		// and accepts binary data
+		Uint8Array
+	>
+{
+	constructor(
+		source: UnderlyingSource<Uint8Array>,
+		sink: UnderlyingSink<Uint8Array>,
+		logger: SerialLogger,
+	) {
+		this.logger = logger;
+		this.#abort = new AbortController();
+
+		// Expose the underlying sink as the writable side of this stream.
+		// We use an identity stream in the middle to pipe through, so we
+		// can properly abort the stream
+		const { readable: input, writable } = new TransformStream();
+		this.writable = writable;
+		const sinkStream = new WritableStream(sink);
+		void input
+			.pipeTo(sinkStream, { signal: this.#abort.signal })
+			.catch(noop);
+
+		// Pipe the underlying source through the parser to the readable side
+		this.parser = new ZWaveSerialParser(logger, this.#abort.signal);
+		this.readable = this.parser.readable;
+		const sourceStream = new ReadableStream(source);
+		void sourceStream.pipeTo(this.parser.writable, {
+			signal: this.#abort.signal,
+		}).catch((_e) => {
+			this._isOpen = false;
+		});
+	}
+
+	protected logger: SerialLogger;
+
+	// Public interface to let consumers read from and write to this stream
+	public readonly readable: ReadableStream<ZWaveSerialFrame>;
+	public readonly writable: WritableStream<Uint8Array>;
+
+	// Signal to close the underlying stream
+	#abort: AbortController;
+
+	// Serial API parser
+	private parser: ZWaveSerialParser;
+
+	// Allow switching between modes
+	public get mode(): ZWaveSerialMode | undefined {
+		return this.parser.mode;
+	}
+	public set mode(mode: ZWaveSerialMode | undefined) {
+		this.parser.mode = mode;
+	}
+
+	// Allow ignoring the high nibble of an ACK once to work around an issue in the 700 series firmware
+	public ignoreAckHighNibbleOnce(): void {
+		this.parser.ignoreAckHighNibbleOnce();
+	}
+
+	public async close(): Promise<void> {
+		this._isOpen = false;
+		// Close the underlying stream
+		this.#abort.abort();
+
+		return Promise.resolve();
+
+		// // Wait for streams to finish
+		// await this.#pipePromise;
+	}
+
+	private _isOpen: boolean = true;
+	public get isOpen(): boolean {
+		return this._isOpen;
+	}
+
+	public async writeAsync(data: Uint8Array): Promise<void> {
+		if (!this.isOpen) {
+			throw new Error("The serial port is not open!");
+		}
+
+		// Only log in Serial API mode
+		if (this.mode === ZWaveSerialMode.SerialAPI && data.length === 1) {
+			switch (data[0]) {
+				case MessageHeaders.ACK:
+					this.logger.ACK("outbound");
+					break;
+				case MessageHeaders.CAN:
+					this.logger.CAN("outbound");
+					break;
+				case MessageHeaders.NAK:
+					this.logger.NAK("outbound");
+					break;
+			}
+		} else {
+			this.logger.data("outbound", data);
+		}
+
+		const writer = this.writable.getWriter();
+		try {
+			await writer.write(data);
+		} finally {
+			writer.releaseLock();
+		}
+	}
+}
diff --git a/packages/serial/src/serialport/ZWaveSocket.ts b/packages/serial/src/serialport/ZWaveSocket.ts
deleted file mode 100644
index 6ab2e85f7e7e..000000000000
--- a/packages/serial/src/serialport/ZWaveSocket.ts
+++ /dev/null
@@ -1,74 +0,0 @@
-import {
-	ZWaveError,
-	ZWaveErrorCodes,
-	type ZWaveLogContainer,
-} from "@zwave-js/core";
-import * as net from "node:net";
-import { ZWaveSerialPortBase } from "./ZWaveSerialPortBase.js";
-import { type ZWaveSocketOptions } from "./ZWaveSocketOptions.js";
-
-/** A version of the Z-Wave serial binding that works using a socket (TCP or IPC) */
-export class ZWaveSocket extends ZWaveSerialPortBase {
-	constructor(
-		private socketOptions: ZWaveSocketOptions,
-		loggers: ZWaveLogContainer,
-	) {
-		let removeListeners: (removeOnClose: boolean) => void;
-
-		super(
-			{
-				create: () => new net.Socket(),
-				open: (serial: net.Socket) =>
-					new Promise((resolve, reject) => {
-						const onClose = () => {
-							// detect socket disconnection errors
-							this.emit(
-								"error",
-								new ZWaveError(
-									`The socket closed unexpectedly!`,
-									ZWaveErrorCodes.Driver_Failed,
-								),
-							);
-						};
-
-						const onError = (err: Error) => {
-							removeListeners(true);
-							reject(err);
-						};
-						const onConnect = () => {
-							serial.setKeepAlive(true, 2500);
-							removeListeners(false);
-							resolve();
-						};
-
-						// We need to remove the listeners again no matter which of the handlers is called
-						// Otherwise this would cause an EventEmitter leak.
-						// Hence this somewhat ugly construct
-						removeListeners = (removeOnClose: boolean) => {
-							if (removeOnClose) {
-								serial.removeListener("close", onClose);
-							}
-							serial.removeListener("error", onError);
-							serial.removeListener("connect", onConnect);
-						};
-
-						serial.once("close", onClose);
-						serial.once("error", onError);
-						serial.once("connect", onConnect);
-
-						serial.connect(this.socketOptions);
-					}),
-				close: (serial: net.Socket) =>
-					new Promise((resolve) => {
-						removeListeners(true);
-						if (serial.destroyed) {
-							resolve();
-						} else {
-							serial.once("close", () => resolve()).destroy();
-						}
-					}),
-			},
-			loggers,
-		);
-	}
-}
diff --git a/packages/serial/src/serialport/definitions.ts b/packages/serial/src/serialport/definitions.ts
new file mode 100644
index 000000000000..e3d19cf0d549
--- /dev/null
+++ b/packages/serial/src/serialport/definitions.ts
@@ -0,0 +1,12 @@
+import { type MessageHeaders } from "../message/MessageHeaders.js";
+
+export type ZWaveSerialChunk =
+	| MessageHeaders.ACK
+	| MessageHeaders.NAK
+	| MessageHeaders.CAN
+	| Uint8Array;
+
+export enum ZWaveSerialMode {
+	SerialAPI,
+	Bootloader,
+}
diff --git a/packages/serial/src/zniffer/ZnifferSerialPort.ts b/packages/serial/src/zniffer/ZnifferSerialPort.ts
deleted file mode 100644
index 8917d5abde59..000000000000
--- a/packages/serial/src/zniffer/ZnifferSerialPort.ts
+++ /dev/null
@@ -1,84 +0,0 @@
-import {
-	ZWaveError,
-	ZWaveErrorCodes,
-	type ZWaveLogContainer,
-} from "@zwave-js/core";
-import { SerialPort } from "serialport";
-import type { DisconnectError } from "../serialport/DisconnectError.js";
-import { ZnifferSerialPortBase } from "./ZnifferSerialPortBase.js";
-
-// FIXME: This class is identical to ZWaveSerialPort, except for the class name and the base class
-
-/** The default version of the Zniffer serial binding that works using node-serialport */
-export class ZnifferSerialPort extends ZnifferSerialPortBase {
-	constructor(
-		port: string,
-		loggers: ZWaveLogContainer,
-		Binding: typeof SerialPort = SerialPort,
-	) {
-		let removeListeners: (removeOnClose: boolean) => void;
-
-		super(
-			{
-				create: () =>
-					new Binding({
-						path: port,
-						autoOpen: false,
-						baudRate: 115200,
-						dataBits: 8,
-						stopBits: 1,
-						parity: "none",
-					}),
-				open: (serial: SerialPort) =>
-					new Promise((resolve, reject) => {
-						const onClose = (err?: DisconnectError) => {
-							// detect serial disconnection errors
-							if (err?.disconnected === true) {
-								removeListeners(true);
-								this.emit(
-									"error",
-									new ZWaveError(
-										`The serial port closed unexpectedly!`,
-										ZWaveErrorCodes.Driver_Failed,
-									),
-								);
-							}
-						};
-						const onError = (err: Error) => {
-							removeListeners(true);
-							reject(err);
-						};
-						const onOpen = () => {
-							removeListeners(false);
-							resolve();
-						};
-
-						// We need to remove the listeners again no matter which of the handlers is called
-						// Otherwise this would cause an EventEmitter leak.
-						// Hence this somewhat ugly construct
-						removeListeners = (removeOnClose: boolean) => {
-							if (removeOnClose) {
-								serial.removeListener("close", onClose);
-							}
-							serial.removeListener("error", onError);
-							serial.removeListener("open", onOpen);
-						};
-
-						serial.once("close", onClose);
-						serial.once("error", onError);
-						serial.once("open", onOpen).open();
-					}),
-				close: (serial: SerialPort) =>
-					new Promise((resolve) => {
-						removeListeners(true);
-						serial.once("close", resolve).close();
-					}),
-			},
-			loggers,
-		);
-	}
-
-	public get isOpen(): boolean {
-		return (this.serial as SerialPort).isOpen;
-	}
-}
diff --git a/packages/serial/src/zniffer/ZnifferSerialPortBase.ts b/packages/serial/src/zniffer/ZnifferSerialPortBase.ts
deleted file mode 100644
index 2f3c6f500a88..000000000000
--- a/packages/serial/src/zniffer/ZnifferSerialPortBase.ts
+++ /dev/null
@@ -1,178 +0,0 @@
-import type { ZWaveLogContainer } from "@zwave-js/core";
-import { Mixin } from "@zwave-js/shared";
-import { EventEmitter } from "node:events";
-import { PassThrough, type Readable, type Writable } from "node:stream";
-import { SerialLogger } from "../log/Logger.js";
-import { ZnifferParser } from "../parsers/ZnifferParser.js";
-import { type ZWaveSerialPortImplementation } from "../serialport/ZWaveSerialPortImplementation.js";
-
-export interface ZnifferSerialPortEventCallbacks {
-	error: (e: Error) => void;
-	data: (data: Uint8Array) => void;
-	discardedData: (data: Uint8Array) => void;
-}
-
-export type ZnifferSerialPortEvents = Extract<
-	keyof ZnifferSerialPortEventCallbacks,
-	string
->;
-
-export interface ZnifferSerialPortBase {
-	on<TEvent extends ZnifferSerialPortEvents>(
-		event: TEvent,
-		callback: ZnifferSerialPortEventCallbacks[TEvent],
-	): this;
-	addListener<TEvent extends ZnifferSerialPortEvents>(
-		event: TEvent,
-		callback: ZnifferSerialPortEventCallbacks[TEvent],
-	): this;
-	once<TEvent extends ZnifferSerialPortEvents>(
-		event: TEvent,
-		callback: ZnifferSerialPortEventCallbacks[TEvent],
-	): this;
-	off<TEvent extends ZnifferSerialPortEvents>(
-		event: TEvent,
-		callback: ZnifferSerialPortEventCallbacks[TEvent],
-	): this;
-	removeListener<TEvent extends ZnifferSerialPortEvents>(
-		event: TEvent,
-		callback: ZnifferSerialPortEventCallbacks[TEvent],
-	): this;
-	removeAllListeners(event?: ZnifferSerialPortEvents): this;
-
-	emit<TEvent extends ZnifferSerialPortEvents>(
-		event: TEvent,
-		...args: Parameters<ZnifferSerialPortEventCallbacks[TEvent]>
-	): boolean;
-}
-
-const IS_TEST = process.env.NODE_ENV === "test" || !!process.env.CI;
-
-// This is basically a duplex transform stream wrapper around any stream (network, serial, ...)
-// 0 ┌─────────────────┐ ┌───────────────────┐ ┌──
-// 1 <--               <--    PassThrough    <-- write
-// 1 │    any stream   │ │ ZnifferSerialPort │ │
-// 0 -->               -->      Parsers      --> read
-// 1 └─────────────────┘ └───────────────────┘ └──
-// The implementation idea is based on https://stackoverflow.com/a/17476600/10179833
-
-@Mixin([EventEmitter])
-export class ZnifferSerialPortBase extends PassThrough {
-	protected serial: ReturnType<ZWaveSerialPortImplementation["create"]>;
-	protected logger: SerialLogger;
-
-	// Zniffer frame parser
-	private parser: ZnifferParser;
-
-	// Allow strongly-typed async iteration
-	declare public [Symbol.asyncIterator]: () => AsyncIterableIterator<
-		Uint8Array
-	>;
-
-	constructor(
-		private implementation: ZWaveSerialPortImplementation,
-		loggers: ZWaveLogContainer,
-	) {
-		super({ readableObjectMode: true });
-
-		// Route the data event handlers to the parser and handle everything else ourselves
-		for (
-			const method of [
-				"on",
-				"once",
-				"off",
-				"addListener",
-				"removeListener",
-				"removeAllListeners",
-			] as const
-		) {
-			const original = this[method].bind(this);
-			this[method] = (event: any, ...args: any[]) => {
-				if (event === "data") {
-					// @ts-expect-error
-					this.parser[method]("data", ...args);
-				} else {
-					(original as any)(event, ...args);
-				}
-				return this;
-			};
-		}
-
-		this.logger = new SerialLogger(loggers);
-
-		this.serial = implementation.create().on("error", (e) => {
-			// Pass errors through
-			this.emit("error", e);
-		});
-
-		// Prepare parser to hook up to the serial port
-		this.parser = new ZnifferParser(
-			this.logger,
-			(discarded) => this.emit("discardedData", discarded),
-		);
-
-		// Check the incoming messages and route them to the correct parser
-		this.serial.on("data", (data) => {
-			// On Windows, writing to the parsers immediately seems to lag the event loop
-			// long enough that the state machine sometimes has not transitioned to the next state yet.
-			// By using setImmediate, we "break" the work into manageable chunks.
-			// We have some tests that don't like this though, so we don't do it in tests
-			const write = () => {
-				this.parser.write(data);
-			};
-
-			if (IS_TEST) {
-				write();
-			} else {
-				setImmediate(write);
-			}
-		});
-
-		// When something is piped to us, pipe it to the serial port instead
-		// Also pass all written data to the serialport unchanged
-		this.on("pipe" as any, (source: Readable) => {
-			source.unpipe(this as any);
-			// Pass all written data to the serialport unchanged
-			source.pipe(this.serial as unknown as Writable, { end: false });
-		});
-
-		// When the wrapper is piped to a stream, pipe the serial API stream instead
-		this.pipe = this.parser.pipe.bind(this.parser);
-		this.unpipe = (destination) => {
-			this.parser.unpipe(destination);
-			return this;
-		};
-		// Delegate iterating to the serial API parser
-		this[Symbol.asyncIterator] = () => this.parser[Symbol.asyncIterator]();
-	}
-
-	public async open(): Promise<void> {
-		await this.implementation.open(this.serial);
-		this._isOpen = true;
-	}
-
-	public close(): Promise<void> {
-		this._isOpen = false;
-		return this.implementation.close(this.serial);
-	}
-
-	private _isOpen: boolean = false;
-	public get isOpen(): boolean {
-		return this._isOpen;
-	}
-
-	public async writeAsync(data: Uint8Array): Promise<void> {
-		if (!this.isOpen) {
-			throw new Error("The serial port is not open!");
-		}
-
-		this.logger.data("outbound", data);
-
-		return new Promise((resolve, reject) => {
-			this.serial.write(data, (err) => {
-				if (err) reject(err);
-				else resolve();
-			});
-		});
-	}
-}
diff --git a/packages/serial/src/zniffer/ZnifferSerialStream.ts b/packages/serial/src/zniffer/ZnifferSerialStream.ts
new file mode 100644
index 000000000000..d7ddf3389132
--- /dev/null
+++ b/packages/serial/src/zniffer/ZnifferSerialStream.ts
@@ -0,0 +1,131 @@
+// This is basically a duplex transform stream wrapper around a
+// readable and a writable stream, both compatible with the Web Streams API.
+// This allows supporting different low-level connections to a Z-Wave controller,
+// whether it's a serial port, a network connection, or something else.
+//
+// 0 ┌─────────────────┐ ┌─────────────────┐ ┌──
+// 1 <--               <--   PassThrough   <-- write
+// 1 │    any stream   │ │ ZWaveSerialPort │ │
+// 0 -->               -->     Parsers     --> read
+// 1 └─────────────────┘ └─────────────────┘ └──
+
+import { type ZWaveLogContainer } from "@zwave-js/core";
+import { noop } from "@zwave-js/shared";
+import {
+	ReadableStream,
+	type ReadableWritablePair,
+	type UnderlyingSink,
+	type UnderlyingSource,
+} from "node:stream/web";
+import { SerialLogger } from "../log/Logger.js";
+import { ZnifferParser } from "../parsers/ZnifferParser.js";
+import { type ZnifferSerialFrame } from "../parsers/ZnifferSerialFrame.js";
+import { type ZWaveSerialBindingFactory } from "../serialport/ZWaveSerialStream.js";
+
+/** Re-usable stream factory to create new serial streams */
+export class ZnifferSerialStreamFactory {
+	constructor(
+		binding: ZWaveSerialBindingFactory,
+		loggers: ZWaveLogContainer,
+	) {
+		this.binding = binding;
+		this.logger = new SerialLogger(loggers);
+	}
+
+	private binding: ZWaveSerialBindingFactory;
+	protected logger: SerialLogger;
+
+	public async createStream(): Promise<ZnifferSerialStream> {
+		// Set up streams for the underlying resource
+		const { source, sink } = await this.binding();
+		return new ZnifferSerialStream(source, sink, this.logger);
+	}
+}
+
+/** Single-use serial stream. Has to be re-created after being closed. */
+export class ZnifferSerialStream implements
+	ReadableWritablePair<
+		// The serial binding emits ZniferSerialFrames
+		ZnifferSerialFrame,
+		// and accepts binary data
+		Uint8Array
+	>
+{
+	constructor(
+		source: UnderlyingSource<Uint8Array>,
+		sink: UnderlyingSink<Uint8Array>,
+		logger: SerialLogger,
+	) {
+		this.logger = logger;
+		this.#abort = new AbortController();
+
+		// Expose the underlying sink as the writable side of this stream.
+		// We use an identity stream in the middle to pipe through, so we
+		// can properly abort the stream
+		const { readable: input, writable } = new TransformStream<
+			Uint8Array,
+			Uint8Array
+		>();
+		this.writable = writable;
+		const sinkStream = new WritableStream(sink);
+		void input
+			.pipeTo(sinkStream, { signal: this.#abort.signal })
+			.catch(noop);
+
+		// Pipe the underlying source through the parser to the readable side
+		const { readable, writable: output } = new TransformStream<
+			ZnifferSerialFrame,
+			ZnifferSerialFrame
+		>();
+		this.readable = readable;
+		const parser = new ZnifferParser(logger);
+		const sourceStream = new ReadableStream(source);
+
+		void sourceStream
+			.pipeThrough(parser, { signal: this.#abort.signal })
+			.pipeTo(output, { signal: this.#abort.signal })
+			.catch((_e) => {
+				this._isOpen = false;
+			});
+	}
+
+	protected logger: SerialLogger;
+
+	// Public interface to let consumers read from and write to this stream
+	public readonly readable: ReadableStream<ZnifferSerialFrame>;
+	public readonly writable: WritableStream<Uint8Array>;
+
+	// Signal to close the underlying stream
+	#abort: AbortController;
+
+	public async close(): Promise<void> {
+		this._isOpen = false;
+		// Close the underlying stream
+		this.#abort.abort();
+
+		return Promise.resolve();
+
+		// // Wait for streams to finish
+		// await this.#pipePromise;
+	}
+
+	private _isOpen: boolean = true;
+	public get isOpen(): boolean {
+		return this._isOpen;
+	}
+
+	public async writeAsync(data: Uint8Array): Promise<void> {
+		if (!this.isOpen) {
+			throw new Error("The serial port is not open!");
+		}
+
+		this.logger.data("outbound", data);
+
+		const writer = this.writable.getWriter();
+		try {
+			await writer.write(data);
+		} finally {
+			writer.releaseLock();
+		}
+	}
+}
diff --git a/packages/serial/src/zniffer/ZnifferSocket.ts b/packages/serial/src/zniffer/ZnifferSocket.ts
deleted file mode 100644
index 0f6667745554..000000000000
--- a/packages/serial/src/zniffer/ZnifferSocket.ts
+++ /dev/null
@@ -1,76 +0,0 @@
-import {
-	ZWaveError,
-	ZWaveErrorCodes,
-	type ZWaveLogContainer,
-} from "@zwave-js/core";
-import * as net from "node:net";
-import { type ZWaveSocketOptions } from "../serialport/ZWaveSocketOptions.js";
-import { ZnifferSerialPortBase } from "./ZnifferSerialPortBase.js";
-
-// FIXME: This class is identical to ZWaveSocket, except for the class name and the base class
-
-/** A version of the Zniffer serial binding that works using a socket (TCP or IPC) */
-export class ZnifferSocket extends ZnifferSerialPortBase {
-	constructor(
-		private socketOptions: ZWaveSocketOptions,
-		loggers: ZWaveLogContainer,
-	) {
-		let removeListeners: (removeOnClose: boolean) => void;
-
-		super(
-			{
-				create: () => new net.Socket(),
-				open: (serial: net.Socket) =>
-					new Promise((resolve, reject) => {
-						const onClose = () => {
-							// detect socket disconnection errors
-							this.emit(
-								"error",
-								new ZWaveError(
-									`The socket closed unexpectedly!`,
-									ZWaveErrorCodes.Driver_Failed,
-								),
-							);
-						};
-
-						const onError = (err: Error) => {
-							removeListeners(true);
-							reject(err);
-						};
-						const onConnect = () => {
-							serial.setKeepAlive(true, 2500);
-							removeListeners(false);
-							resolve();
-						};
-
-						// We need to remove the listeners again no matter which of the handlers is called
-						// Otherwise this would cause an EventEmitter leak.
-						// Hence this somewhat ugly construct
-						removeListeners = (removeOnClose: boolean) => {
-							if (removeOnClose) {
-								serial.removeListener("close", onClose);
-							}
-							serial.removeListener("error", onError);
-							serial.removeListener("connect", onConnect);
-						};
-
-						serial.once("close", onClose);
-						serial.once("error", onError);
-						serial.once("connect", onConnect);
-
-						serial.connect(this.socketOptions);
-					}),
-				close: (serial: net.Socket) =>
-					new Promise((resolve) => {
-						removeListeners(true);
-						if (serial.destroyed) {
-							resolve();
-						} else {
-							serial.once("close", () => resolve()).destroy();
-						}
-					}),
-			},
-			loggers,
-		);
-	}
-}
diff --git a/packages/shared/src/errors.ts b/packages/shared/src/errors.ts
index cd0d0527ad4b..0775cf82dc09 100644
--- a/packages/shared/src/errors.ts
+++ b/packages/shared/src/errors.ts
@@ -4,3 +4,7 @@ export function getErrorMessage(e: unknown, includeStack?: boolean): string {
 	}
 	return String(e);
 }
+
+export function isAbortError(e: unknown): boolean {
+	return e instanceof DOMException && e.name === "AbortError";
+}
diff --git a/packages/testing/src/MockController.ts b/packages/testing/src/MockController.ts
index 26737402f2ad..391bf1b08fb6 100644
--- a/packages/testing/src/MockController.ts
+++ b/packages/testing/src/MockController.ts
@@ -15,11 +15,11 @@ import {
 	MessageHeaders,
 	MessageOrigin,
 	type MessageParsingContext,
-	SerialAPIParser,
+	type ZWaveSerialStream,
 } from "@zwave-js/serial";
-import type { MockPortBinding } from "@zwave-js/serial/mock";
+import { type MockPort } from "@zwave-js/serial/mock";
 import { AsyncQueue } from "@zwave-js/shared";
-import { TimedExpectation } from "@zwave-js/shared/safe";
+import { TimedExpectation, isAbortError, noop } from "@zwave-js/shared/safe";
 import { wait } from "alcalzone-shared/async";
 import {
 	type MockControllerCapabilities,
@@ -38,7 +38,9 @@ import {
 } from "./MockZWaveFrame.js";
 
 export interface MockControllerOptions {
-	serial: MockPortBinding;
+	mockPort: MockPort;
+	serial: ZWaveSerialStream;
+	// serial: MockPortBinding;
 	ownNodeId?: number;
 	homeId?: number;
 	capabilities?: Partial<MockControllerCapabilities>;
@@ -47,26 +49,10 @@ export interface MockControllerOptions {
 /** A mock Z-Wave controller which interacts with {@link MockNode}s and can be controlled via a {@link MockSerialPort} */
 export class MockController {
 	public constructor(options: MockControllerOptions) {
+		this.mockPort = options.mockPort;
 		this.serial = options.serial;
-		// Pipe the serial data through a parser, so we get complete message buffers or headers out the other end
-		this.serialParser = new SerialAPIParser();
-		this.serial.on("write", async (data) => {
-			// Execute hooks for inspecting the raw data first
-			for (const behavior of this.behaviors) {
-				if (await behavior.onHostData?.(this, data)) {
-					return;
-				}
-			}
-			// Then parse the data normally
-			this.serialParser.write(data);
-		});
-		this.serialParser.on("data", (data) => this.serialOnData(data));
 
-		// Set up the fake host
-		// const valuesStorage = new Map();
-		// const metadataStorage = new Map();
-		// const valueDBCache = new Map<number, ValueDB>();
-		// const supervisionSessionIDs = new Map<number, () => number>();
+		void this.handleSerialData();
 
 		this.ownNodeId = options.ownNodeId ?? 1;
 		this.homeId = options.homeId ?? 0x7e571000;
@@ -159,8 +145,8 @@ export class MockController {
 	public encodingContext: MessageEncodingContext;
 	public parsingContext: MessageParsingContext;
 
-	public readonly serial: MockPortBinding;
-	private readonly serialParser: SerialAPIParser;
+	public readonly mockPort: MockPort;
+	public readonly serial: ZWaveSerialStream;
 
 	private expectedHostACKs: TimedExpectation[] = [];
 	private expectedHostMessages: TimedExpectation<Message, Message>[] = [];
@@ -210,6 +196,34 @@ export class MockController {
 	/** Allows reproducing issues with the 7.19.x firmware where the high nibble of the ACK after soft-reset is corrupted */
 	public corruptACK: boolean = false;
 
+	private async handleSerialData(): Promise<void> {
+		try {
+			read: for await (const data of this.mockPort.readable) {
+				// Execute hooks for inspecting the raw data first
+				for (const behavior of this.behaviors) {
+					if (await behavior.onHostData?.(this, data)) {
+						continue read;
+					}
+				}
+
+				if (data.length === 1) {
+					const header = data[0];
+					switch (header) {
+						case MessageHeaders.ACK:
+						case MessageHeaders.NAK:
+						case MessageHeaders.CAN:
+							void this.serialOnData(header).catch(noop);
+							continue;
+					}
+				}
+				void this.serialOnData(data).catch(noop);
+			}
+		} catch (e) {
+			if (isAbortError(e)) return;
+			throw e;
+		}
+	}
+
 	/** Gets called when parsed/chunked data is received from the serial port */
 	private async serialOnData(
 		data:
@@ -385,7 +399,7 @@ export class MockController {
 
 	/** Sends a message header (ACK/NAK/CAN) to the host/driver */
 	private sendHeaderToHost(data: MessageHeaders): void {
-		this.serial.emitData(Uint8Array.from([data]));
+		this.mockPort.emitData(Uint8Array.from([data]));
 	}
 
 	/** Sends a raw buffer to the host/driver and expect an ACK */
@@ -404,14 +418,14 @@ export class MockController {
 		} else {
 			data = await msg.serializeAsync(this.encodingContext);
 		}
-		this.serial.emitData(data);
+		this.mockPort.emitData(data);
 		// TODO: make the timeout match the configured ACK timeout
 		await this.expectHostACK(1000);
 	}
 
 	/** Sends a raw buffer to the host/driver and expect an ACK */
 	public async sendToHost(data: Uint8Array): Promise<void> {
-		this.serial.emitData(data);
+		this.mockPort.emitData(data);
 		// TODO: make the timeout match the configured ACK timeout
 		await this.expectHostACK(1000);
 	}
@@ -422,7 +436,7 @@ export class MockController {
 	public ackHostMessage(): void {
 		if (this.corruptACK) {
 			const highNibble = randomBytes(1)[0] & 0xf0;
-			this.serial.emitData(
+			this.mockPort.emitData(
 				Uint8Array.from([highNibble | MessageHeaders.ACK]),
 			);
 		} else {
diff --git a/packages/zwave-js/src/lib/controller/Controller.nodes.getOrThrow.test.ts b/packages/zwave-js/src/lib/controller/Controller.nodes.getOrThrow.test.ts
index 02e5553c2b3c..e00599bce6de 100644
--- a/packages/zwave-js/src/lib/controller/Controller.nodes.getOrThrow.test.ts
+++ b/packages/zwave-js/src/lib/controller/Controller.nodes.getOrThrow.test.ts
@@ -23,9 +23,10 @@ const test = baseTest.extend<LocalTestContext>({
 			const { driver } = await createAndStartTestingDriver({
 				loadConfiguration: false,
 				skipNodeInterview: true,
-				beforeStartup(mockPort) {
+				beforeStartup(mockPort, serial) {
 					context.controller = new MockController({
-						serial: mockPort,
+						mockPort,
+						serial,
 					});
 					context.controller.defineBehavior(
 						...createDefaultMockControllerBehaviors(),
diff --git a/packages/zwave-js/src/lib/driver/Driver.ts b/packages/zwave-js/src/lib/driver/Driver.ts
index e5e06345cca9..afaaeb18c6dc 100644
--- a/packages/zwave-js/src/lib/driver/Driver.ts
+++ b/packages/zwave-js/src/lib/driver/Driver.ts
@@ -125,15 +125,20 @@ import {
 	MessageType,
 	type SuccessIndicator,
 	XModemMessageHeaders,
+	type ZWaveSerialBindingFactory,
+	ZWaveSerialFrameType,
 	ZWaveSerialMode,
-	ZWaveSerialPort,
-	ZWaveSerialPortBase,
 	type ZWaveSerialPortImplementation,
-	ZWaveSocket,
+	type ZWaveSerialStream,
+	ZWaveSerialStreamFactory,
+	createNodeSerialPortFactory,
+	createNodeSocketFactory,
 	getDefaultPriority,
 	hasNodeId,
 	isSuccessIndicator,
+	isZWaveSerialBindingFactory,
 	isZWaveSerialPortImplementation,
+	wrapLegacySerialBinding,
 } from "@zwave-js/serial";
 import { ApplicationUpdateRequest } from "@zwave-js/serial/serialapi";
 import {
@@ -170,6 +175,7 @@ import {
 	cloneDeep,
 	createWrappingCounter,
 	getErrorMessage,
+	isAbortError,
 	isUint8Array,
 	mergeDeep,
 	noop,
@@ -187,7 +193,6 @@ import { isArray, isObject } from "alcalzone-shared/typeguards";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { URL } from "node:url";
 import * as util from "node:util";
 import { SerialPort } from "serialport";
 import { ZWaveController } from "../controller/Controller.js";
@@ -638,7 +643,11 @@ export class Driver extends TypedEventTarget<DriverEventCallbacks>
 		PersistValuesContext
 {
 	public constructor(
-		private port: string | ZWaveSerialPortImplementation,
+		private port:
+			| string
+			// eslint-disable-next-line @typescript-eslint/no-deprecated
+			| ZWaveSerialPortImplementation
+			| ZWaveSerialBindingFactory,
 		...optionsAndPresets: (PartialZWaveOptions | undefined)[]
 	) {
 		super();
@@ -647,6 +656,7 @@ export class Driver extends TypedEventTarget<DriverEventCallbacks>
 		if (
 			typeof port !== "string"
 			&& !isZWaveSerialPortImplementation(port)
+			&& !isZWaveSerialBindingFactory(port)
 		) {
 			throw new ZWaveError(
 				`The port must be a string or a valid custom serial port implementation!`,
@@ -752,8 +762,9 @@ export class Driver extends TypedEventTarget<DriverEventCallbacks>
 		this._scheduler = new TaskScheduler();
 	}
 
+	private serialFactory: ZWaveSerialStreamFactory | undefined;
 	/** The serial port instance */
-	private serial: ZWaveSerialPortBase | undefined;
+	private serial: ZWaveSerialStream | undefined;
 
 	private messageEncodingContext: Omit<
 		MessageEncodingContext,
@@ -1301,52 +1312,41 @@ export class Driver extends TypedEventTarget<DriverEventCallbacks>
 		this.driverLog.print("starting driver...");
 
 		// Open the serial port
+		let binding: ZWaveSerialBindingFactory;
 		if (typeof this.port === "string") {
 			if (this.port.startsWith("tcp://")) {
 				const url = new URL(this.port);
 				this.driverLog.print(`opening serial port ${this.port}`);
-				this.serial = new ZWaveSocket(
-					{
-						host: url.hostname,
-						port: parseInt(url.port),
-					},
-					this._logContainer,
-				);
+				binding = createNodeSocketFactory({
+					host: url.hostname,
+					port: parseInt(url.port),
+				});
 			} else {
 				this.driverLog.print(`opening serial port ${this.port}`);
-				this.serial = new ZWaveSerialPort(
+				binding = createNodeSerialPortFactory(
 					this.port,
-					this._logContainer,
-					this._options.testingHooks?.serialPortBinding,
+					// this._options.testingHooks?.serialPortBinding,
 				);
 			}
-		} else {
+		} else if (isZWaveSerialPortImplementation(this.port)) {
 			this.driverLog.print(
 				"opening serial port using the provided custom implementation",
 			);
-			this.serial = new ZWaveSerialPortBase(
-				this.port,
-				this._logContainer,
+			this.driverLog.print(
+				"This is deprecated! Switch to the factory pattern instead.",
+				"warn",
 			);
+			binding = wrapLegacySerialBinding(this.port);
+		} else {
+			this.driverLog.print(
+				"opening serial port using the provided custom factory",
+			);
+			binding = this.port;
 		}
-		this.serial
-			.on("data", this.serialport_onData.bind(this))
-			.on("bootloaderData", this.serialport_onBootloaderData.bind(this))
-			.on("error", (err) => {
-				if (this.isSoftResetting && !this.serial?.isOpen) {
-					// A disconnection while soft resetting is to be expected
-					return;
-				} else if (!this._isOpen) {
-					// tryOpenSerialport takes care of error handling
-					return;
-				}
-
-				void this.destroyWithMessage(
-					`Serial port errored: ${err.message}`,
-				);
-			});
-		// If the port is already open, close it first
-		if (this.serial.isOpen) await this.serial.close();
+		this.serialFactory = new ZWaveSerialStreamFactory(
+			binding,
+			this._logContainer,
+		);
 
 		// IMPORTANT: Test code expects the open promise to be created and returned synchronously
 		// Everything async (including opening the serial port) must happen in the setImmediate callback
@@ -1505,7 +1505,9 @@ export class Driver extends TypedEventTarget<DriverEventCallbacks>
 			attempt++
 		) {
 			try {
-				await this.serial!.open();
+				this.serial = await this.serialFactory!.createStream();
+				// Start reading from the serial port
+				void this.handleSerialData(this.serial);
 				return;
 			} catch (e) {
 				lastError = e;
@@ -3415,7 +3417,6 @@ export class Driver extends TypedEventTarget<DriverEventCallbacks>
 
 		if (this.serial != undefined) {
 			// Avoid spewing errors if the port was in the middle of receiving something
-			this.serial.removeAllListeners();
 			if (this.serial.isOpen) await this.serial.close();
 			this.serial = undefined;
 		}
@@ -3481,6 +3482,36 @@ export class Driver extends TypedEventTarget<DriverEventCallbacks>
 		this._destroyPromise.resolve();
 	}
 
+	private async handleSerialData(serial: ZWaveSerialStream): Promise<void> {
+		try {
+			for await (const frame of serial.readable) {
+				setImmediate(() => {
+					if (frame.type === ZWaveSerialFrameType.SerialAPI) {
+						void this.serialport_onData(frame.data);
+					} else if (frame.type === ZWaveSerialFrameType.Bootloader) {
+						void this.serialport_onBootloaderData(frame.data);
+					} else {
+						// Handle discarded data?
+					}
+				});
+			}
+		} catch (e) {
+			if (isAbortError(e)) {
+				return;
+			} else if (
+				isZWaveError(e) && e.code === ZWaveErrorCodes.Driver_Failed
+			) {
+				// A disconnection while soft resetting is to be expected.
+				// The soft reset method will handle reopening
+				if (this.isSoftResetting) return;
+
+				void this.destroyWithMessage(e.message);
+				return;
+			}
+			throw e;
+		}
+	}
+
 	/**
 	 * Is called when the serial port has received a single-byte message or a complete message buffer
 	 */
diff --git a/packages/zwave-js/src/lib/driver/DriverMock.ts b/packages/zwave-js/src/lib/driver/DriverMock.ts
index d2e48facd9ac..30905a430527 100644
--- a/packages/zwave-js/src/lib/driver/DriverMock.ts
+++ b/packages/zwave-js/src/lib/driver/DriverMock.ts
@@ -1,25 +1,22 @@
-import type { ZWaveSerialPortBase } from "@zwave-js/serial";
-import {
-	MockBinding,
-	type MockPortBinding,
-	SerialPortMock,
-} from "@zwave-js/serial/mock";
+import { type ZWaveSerialStream } from "@zwave-js/serial";
+import { MockPort } from "@zwave-js/serial/mock";
 import { createDeferredPromise } from "alcalzone-shared/deferred-promise";
 import fs from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
-import type { SerialPort } from "serialport";
 import { Driver } from "./Driver.js";
 import type { PartialZWaveOptions, ZWaveOptions } from "./ZWaveOptions.js";
 
 export interface CreateAndStartDriverWithMockPortResult {
 	driver: Driver;
 	continueStartup: () => void;
-	mockPort: MockPortBinding;
+	mockPort: MockPort;
+	serial: ZWaveSerialStream;
 }
 
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
 export interface CreateAndStartDriverWithMockPortOptions {
-	portAddress: string;
+	// portAddress: string;
 }
 
 /** Creates a real driver instance with a mocked serial port to enable end to end tests */
@@ -28,25 +25,27 @@ export function createAndStartDriverWithMockPort(
 		& Partial<CreateAndStartDriverWithMockPortOptions>
 		& PartialZWaveOptions = {},
 ): Promise<CreateAndStartDriverWithMockPortResult> {
-	const { portAddress = "/tty/FAKE", ...driverOptions } = options;
-	return new Promise(async (resolve, reject) => {
+	const { ...driverOptions } = options;
+	return new Promise(async (resolve, _reject) => {
 		// eslint-disable-next-line prefer-const
 		let driver: Driver;
-		let mockPort: MockPortBinding;
+		const mockPort = new MockPort();
+		const bindingFactory = mockPort.factory();
+		// let mockPort: MockPortBinding;
 
-		MockBinding.reset();
-		MockBinding.createPort(portAddress, {
-			record: true,
-			readyData: new Uint8Array(),
-		});
+		// MockBinding.reset();
+		// MockBinding.createPort(portAddress, {
+		// 	record: true,
+		// 	readyData: new Uint8Array(),
+		// });
 
 		// This will be called when the driver has opened the serial port
 		const onSerialPortOpen = (
-			_port: ZWaveSerialPortBase,
+			serial: ZWaveSerialStream,
 		): Promise<void> => {
-			// Extract the mock serial port
-			mockPort = MockBinding.getInstance(portAddress)!;
-			if (!mockPort) reject(new Error("Mock serial port is not open!"));
+			// // Extract the mock serial port
+			// mockPort = MockBinding.getInstance(portAddress)!;
+			// if (!mockPort) reject(new Error("Mock serial port is not open!"));
 
 			// And return the info to the calling code, giving it control over
 			// continuing the driver startup.
@@ -54,6 +53,7 @@ export function createAndStartDriverWithMockPort(
 			resolve({
 				driver,
 				mockPort,
+				serial,
 				continueStartup: () => continuePromise.resolve(),
 			});
 
@@ -69,12 +69,10 @@ export function createAndStartDriverWithMockPort(
 
 		const testingHooks: ZWaveOptions["testingHooks"] = {
 			...driverOptions.testingHooks,
-			// instruct the driver to use SerialPortMock as the serialport implementation
-			serialPortBinding: SerialPortMock as unknown as typeof SerialPort,
 			onSerialPortOpen,
 		};
 
-		driver = new Driver(portAddress, {
+		driver = new Driver(bindingFactory, {
 			...driverOptions,
 			testingHooks,
 		});
@@ -88,7 +86,10 @@ export type CreateAndStartTestingDriverResult = Omit<
 >;
 
 export interface CreateAndStartTestingDriverOptions {
-	beforeStartup: (mockPort: MockPortBinding) => void | Promise<void>;
+	beforeStartup: (
+		mockPort: MockPort,
+		serial: ZWaveSerialStream,
+	) => void | Promise<void>;
 	/**
 	 * Whether the controller identification should be skipped (default: false).
 	 * If not, a Mock controller must be available on the serial port.
@@ -131,7 +132,7 @@ export async function createAndStartTestingDriver(
 	const testId = Math.round(Math.random() * 0xffffffff)
 		.toString(16)
 		.padStart(8, "0");
-	internalOptions.portAddress ??= `/tty/FAKE${testId}`;
+	// internalOptions.portAddress ??= `/tty/FAKE${testId}`;
 
 	if (skipControllerIdentification) {
 		internalOptions.testingHooks ??= {};
@@ -156,11 +157,11 @@ export async function createAndStartTestingDriver(
 	internalOptions.storage ??= {};
 	internalOptions.storage.cacheDir = cacheDir;
 
-	const { driver, continueStartup, mockPort } =
+	const { driver, continueStartup, mockPort, serial } =
 		await createAndStartDriverWithMockPort(internalOptions);
 
 	if (typeof beforeStartup === "function") {
-		await beforeStartup(mockPort);
+		await beforeStartup(mockPort, serial);
 	}
 
 	// Make sure the mock FS gets restored when the driver is destroyed
@@ -172,7 +173,7 @@ export async function createAndStartTestingDriver(
 
 	return new Promise((resolve) => {
 		driver.once("driver ready", () => {
-			resolve({ driver, mockPort });
+			resolve({ driver, mockPort, serial });
 		});
 		continueStartup();
 	});
diff --git a/packages/zwave-js/src/lib/driver/ZWaveOptions.ts b/packages/zwave-js/src/lib/driver/ZWaveOptions.ts
index 39c6646c37e9..b3d79c78a999 100644
--- a/packages/zwave-js/src/lib/driver/ZWaveOptions.ts
+++ b/packages/zwave-js/src/lib/driver/ZWaveOptions.ts
@@ -5,9 +5,8 @@ import type {
 	RFRegion,
 } from "@zwave-js/core";
 import type { ZWaveHostOptions } from "@zwave-js/host";
-import type { ZWaveSerialPortBase } from "@zwave-js/serial";
+import { type ZWaveSerialStream } from "@zwave-js/serial";
 import { type DeepPartial, type Expand } from "@zwave-js/shared";
-import type { SerialPort } from "serialport";
 import type {
 	InclusionUserCallbacks,
 	JoinNetworkUserCallbacks,
@@ -360,12 +359,11 @@ export interface ZWaveOptions extends ZWaveHostOptions {
 
 	/** DO NOT USE! Used for testing internally */
 	testingHooks?: {
-		serialPortBinding?: typeof SerialPort;
 		/**
 		 * A hook that allows accessing the serial port instance after opening
 		 * and before interacting with it.
 		 */
-		onSerialPortOpen?: (port: ZWaveSerialPortBase) => Promise<void>;
+		onSerialPortOpen?: (port: ZWaveSerialStream) => Promise<void>;
 
 		/**
 		 * Set this to true to skip the controller identification sequence.
diff --git a/packages/zwave-js/src/lib/node/Endpoint.test.ts b/packages/zwave-js/src/lib/node/Endpoint.test.ts
index f56ec27d7e71..abb41b83391b 100644
--- a/packages/zwave-js/src/lib/node/Endpoint.test.ts
+++ b/packages/zwave-js/src/lib/node/Endpoint.test.ts
@@ -30,8 +30,11 @@ const test = baseTest.extend<LocalTestContext>({
 			const { driver } = await createAndStartTestingDriver({
 				skipNodeInterview: true,
 				loadConfiguration: false,
-				beforeStartup(mockPort) {
-					const controller = new MockController({ serial: mockPort });
+				beforeStartup(mockPort, serial) {
+					const controller = new MockController({
+						mockPort,
+						serial,
+					});
 					controller.defineBehavior(
 						...createDefaultMockControllerBehaviors(),
 					);
diff --git a/packages/zwave-js/src/lib/node/VirtualEndpoint.test.ts b/packages/zwave-js/src/lib/node/VirtualEndpoint.test.ts
index a5c45171ffe6..dc9c1fae957b 100644
--- a/packages/zwave-js/src/lib/node/VirtualEndpoint.test.ts
+++ b/packages/zwave-js/src/lib/node/VirtualEndpoint.test.ts
@@ -10,8 +10,9 @@ import {
 	FunctionType,
 	SendDataMulticastRequest,
 	SendDataRequest,
+	type ZWaveSerialStream,
 } from "@zwave-js/serial";
-import type { MockPortBinding } from "@zwave-js/serial/mock";
+import type { MockPort } from "@zwave-js/serial/mock";
 import { type ThrowingMap, noop } from "@zwave-js/shared";
 import {
 	MockController,
@@ -33,7 +34,8 @@ interface LocalTestContext {
 	context: {
 		driver: Driver;
 		controller: MockController;
-		serialport: MockPortBinding;
+		mockPort: MockPort;
+		serial: ZWaveSerialStream;
 		makePhysicalNode(nodeId: number): ZWaveNode;
 	};
 }
@@ -44,42 +46,43 @@ const test = baseTest.extend<LocalTestContext>({
 			// Setup
 			const context = {} as LocalTestContext["context"];
 
-			const { driver, mockPort } = await createAndStartTestingDriver({
-				loadConfiguration: false,
-				skipNodeInterview: true,
-				beforeStartup(mockPort) {
-					context.controller = new MockController({
-						serial: mockPort,
-						capabilities: {
-							supportedFunctionTypes:
-								getDefaultSupportedFunctionTypes().filter(
-									(ft) =>
-										ft !== FunctionType.SendDataBridge
-										&& ft
-											!== FunctionType
-												.SendDataMulticastBridge,
-								),
-						},
-					});
-					context.controller.defineBehavior(
-						...createDefaultMockControllerBehaviors(),
-					);
-
-					const ignoreBroadcast: MockControllerBehavior = {
-						onHostMessage(controller, msg) {
-							if (
-								msg instanceof SendDataRequest
-								&& msg.getNodeId() === 255
-							) {
-								return true;
-							}
-						},
-					};
-					context.controller.defineBehavior(ignoreBroadcast);
-				},
-			});
-			context.driver = driver;
-			context.serialport = mockPort;
+			const { driver, mockPort, serial } =
+				await createAndStartTestingDriver({
+					loadConfiguration: false,
+					skipNodeInterview: true,
+					beforeStartup(mockPort, serial) {
+						context.controller = new MockController({
+							mockPort,
+							serial,
+							capabilities: {
+								supportedFunctionTypes:
+									getDefaultSupportedFunctionTypes().filter(
+										(ft) =>
+											ft !== FunctionType.SendDataBridge
+											&& ft
+												!== FunctionType
+													.SendDataMulticastBridge,
+									),
+							},
+						});
+						context.controller.defineBehavior(
+							...createDefaultMockControllerBehaviors(),
+						);
+
+						const ignoreBroadcast: MockControllerBehavior = {
+							onHostMessage(controller, msg) {
+								if (
+									msg instanceof SendDataRequest
+									&& msg.getNodeId() === 255
+								) {
+									return true;
+								}
+							},
+						};
+						context.controller.defineBehavior(ignoreBroadcast);
+					},
+				});
+			Object.assign(context, { driver, mockPort, serial });
 
 			context.makePhysicalNode = (nodeId: number) => {
 				// Make the driver know about the node
@@ -324,7 +327,7 @@ test.sequential(
 test.sequential(
 	"broadcast uses the correct commands behind the scenes",
 	async ({ context, expect }) => {
-		const { driver, serialport, controller, makePhysicalNode } = context;
+		const { driver, controller, makePhysicalNode } = context;
 		makePhysicalNode(2);
 		makePhysicalNode(3);
 		const broadcast = driver.controller.getBroadcastNode();
@@ -346,7 +349,7 @@ test.sequential(
 test.sequential(
 	"multicast uses the correct commands behind the scenes",
 	async ({ context, expect }) => {
-		const { driver, serialport, controller, makePhysicalNode } = context;
+		const { driver, controller, makePhysicalNode } = context;
 		makePhysicalNode(2);
 		makePhysicalNode(3);
 		const multicast = driver.controller.getMulticastGroup([2, 3]);
diff --git a/packages/zwave-js/src/lib/test/cc/API.test.ts b/packages/zwave-js/src/lib/test/cc/API.test.ts
index cf57f3847bc1..7f8c5f4f1469 100644
--- a/packages/zwave-js/src/lib/test/cc/API.test.ts
+++ b/packages/zwave-js/src/lib/test/cc/API.test.ts
@@ -28,8 +28,11 @@ const test = baseTest.extend<LocalTestContext>({
 			const { driver } = await createAndStartTestingDriver({
 				skipNodeInterview: true,
 				loadConfiguration: false,
-				beforeStartup(mockPort) {
-					const controller = new MockController({ serial: mockPort });
+				beforeStartup(mockPort, serial) {
+					const controller = new MockController({
+						mockPort,
+						serial,
+					});
 					controller.defineBehavior(
 						...createDefaultMockControllerBehaviors(),
 					);
diff --git a/packages/zwave-js/src/lib/test/cc/CommandClass.persistValues.test.ts b/packages/zwave-js/src/lib/test/cc/CommandClass.persistValues.test.ts
index 3d8ff4579fe4..7d480168bcf9 100644
--- a/packages/zwave-js/src/lib/test/cc/CommandClass.persistValues.test.ts
+++ b/packages/zwave-js/src/lib/test/cc/CommandClass.persistValues.test.ts
@@ -28,8 +28,11 @@ const test = baseTest.extend<LocalTestContext>({
 			const { driver } = await createAndStartTestingDriver({
 				skipNodeInterview: true,
 				loadConfiguration: false,
-				beforeStartup(mockPort) {
-					const controller = new MockController({ serial: mockPort });
+				beforeStartup(mockPort, serial) {
+					const controller = new MockController({
+						mockPort,
+						serial,
+					});
 					controller.defineBehavior(
 						...createDefaultMockControllerBehaviors(),
 					);
diff --git a/packages/zwave-js/src/lib/test/driver/assemblePartialCCs.test.ts b/packages/zwave-js/src/lib/test/driver/assemblePartialCCs.test.ts
index 2eabe114acca..31a3db51005f 100644
--- a/packages/zwave-js/src/lib/test/driver/assemblePartialCCs.test.ts
+++ b/packages/zwave-js/src/lib/test/driver/assemblePartialCCs.test.ts
@@ -31,8 +31,11 @@ const test = baseTest.extend<LocalTestContext>({
 				securityKeys: {
 					S0_Legacy: new Uint8Array(16).fill(0xff),
 				},
-				beforeStartup(mockPort) {
-					const controller = new MockController({ serial: mockPort });
+				beforeStartup(mockPort, serial) {
+					const controller = new MockController({
+						mockPort,
+						serial,
+					});
 					controller.defineBehavior(
 						...createDefaultMockControllerBehaviors(),
 					);
diff --git a/packages/zwave-js/src/lib/test/driver/bootloaderDetection.test.ts b/packages/zwave-js/src/lib/test/driver/bootloaderDetection.test.ts
index 9fedce7b3239..b5673c94e84c 100644
--- a/packages/zwave-js/src/lib/test/driver/bootloaderDetection.test.ts
+++ b/packages/zwave-js/src/lib/test/driver/bootloaderDetection.test.ts
@@ -21,11 +21,11 @@ integrationTest(
 					// 	&& (ctrl[0] === MessageHeaders.NAK || ctrl[0] === 0x32)
 					// ) {
 					// I've seen logs with as few as 5 bytes in the first chunk
-					self.serial.emitData(
+					self.mockPort.emitData(
 						Bytes.from("\0\r\nGeck", "ascii"),
 					);
 					await wait(20);
-					self.serial.emitData(Bytes.from(
+					self.mockPort.emitData(Bytes.from(
 						`o Bootloader v2.05.01
 1. upload gbl
 2. run
diff --git a/packages/zwave-js/src/lib/test/driver/computeNetCCPayloadSize.test.ts b/packages/zwave-js/src/lib/test/driver/computeNetCCPayloadSize.test.ts
index 22c6f8c0f488..2ed04bc0ab50 100644
--- a/packages/zwave-js/src/lib/test/driver/computeNetCCPayloadSize.test.ts
+++ b/packages/zwave-js/src/lib/test/driver/computeNetCCPayloadSize.test.ts
@@ -28,8 +28,11 @@ const test = baseTest.extend<LocalTestContext>({
 				securityKeys: {
 					S0_Legacy: new Uint8Array(16).fill(0xff),
 				},
-				beforeStartup(mockPort) {
-					const controller = new MockController({ serial: mockPort });
+				beforeStartup(mockPort, serial) {
+					const controller = new MockController({
+						mockPort,
+						serial,
+					});
 					controller.defineBehavior(
 						...createDefaultMockControllerBehaviors(),
 					);
diff --git a/packages/zwave-js/src/lib/test/driver/controllerJammed.test.ts b/packages/zwave-js/src/lib/test/driver/controllerJammed.test.ts
index 01b882a58af4..b19c9e09d8f5 100644
--- a/packages/zwave-js/src/lib/test/driver/controllerJammed.test.ts
+++ b/packages/zwave-js/src/lib/test/driver/controllerJammed.test.ts
@@ -41,122 +41,125 @@ const controllerCapabilitiesNoBridge: MockControllerCapabilities = {
 	),
 };
 
-integrationTest("update the controller status and wait if TX status is Fail", {
-	// debug: true,
-	// provisioningDirectory: path.join(
-	// 	__dirname,
-	// 	"__fixtures/supervision_binary_switch",
-	// ),
-
-	controllerCapabilities: controllerCapabilitiesNoBridge,
-
-	additionalDriverOptions: {
-		testingHooks: {
-			skipNodeInterview: true,
+integrationTest(
+	"update the controller status and wait if TX status is Fail",
+	{
+		// debug: true,
+		// provisioningDirectory: path.join(
+		// 	__dirname,
+		// 	"__fixtures/supervision_binary_switch",
+		// ),
+
+		controllerCapabilities: controllerCapabilitiesNoBridge,
+
+		additionalDriverOptions: {
+			testingHooks: {
+				skipNodeInterview: true,
+			},
 		},
-	},
 
-	customSetup: async (driver, controller, mockNode) => {
-		// Return a TX status of Fail when desired
-		const handleSendData: MockControllerBehavior = {
-			async onHostMessage(controller, msg) {
-				if (msg instanceof SendDataRequest) {
-					if (!shouldFail) {
-						// Defer to the default behavior
-						return false;
-					}
+		customSetup: async (driver, controller, mockNode) => {
+			// Return a TX status of Fail when desired
+			const handleSendData: MockControllerBehavior = {
+				async onHostMessage(controller, msg) {
+					if (msg instanceof SendDataRequest) {
+						if (!shouldFail) {
+							// Defer to the default behavior
+							return false;
+						}
+
+						// Check if this command is legal right now
+						const state = controller.state.get(
+							MockControllerStateKeys.CommunicationState,
+						) as MockControllerCommunicationState | undefined;
+						if (
+							state != undefined
+							&& state !== MockControllerCommunicationState.Idle
+						) {
+							throw new Error(
+								"Received SendDataRequest while not idle",
+							);
+						}
 
-					// Check if this command is legal right now
-					const state = controller.state.get(
-						MockControllerStateKeys.CommunicationState,
-					) as MockControllerCommunicationState | undefined;
-					if (
-						state != undefined
-						&& state !== MockControllerCommunicationState.Idle
-					) {
-						throw new Error(
-							"Received SendDataRequest while not idle",
+						// Put the controller into sending state
+						controller.state.set(
+							MockControllerStateKeys.CommunicationState,
+							MockControllerCommunicationState.Sending,
 						);
-					}
 
-					// Put the controller into sending state
-					controller.state.set(
-						MockControllerStateKeys.CommunicationState,
-						MockControllerCommunicationState.Sending,
-					);
-
-					// Notify the host that the message was sent
-					const res = new SendDataResponse({
-						wasSent: true,
-					});
-					await controller.sendMessageToHost(res);
-
-					await wait(100);
-
-					controller.state.set(
-						MockControllerStateKeys.CommunicationState,
-						MockControllerCommunicationState.Idle,
-					);
-
-					const cb = new SendDataRequestTransmitReport({
-						callbackId: msg.callbackId!,
-						transmitStatus: TransmitStatus.Fail,
-						txReport: {
-							txTicks: 0,
-							routeSpeed: 0 as any,
-							routingAttempts: 0,
-							ackRSSI: 0,
-						},
-					});
-					await controller.sendMessageToHost(cb);
-
-					return true;
-				} else if (msg instanceof SendDataAbort) {
-					// Put the controller into idle state
-					controller.state.set(
-						MockControllerStateKeys.CommunicationState,
-						MockControllerCommunicationState.Idle,
-					);
-				}
-			},
-		};
-		controller.defineBehavior(handleSendData);
-	},
-	testBody: async (t, driver, node, mockController, mockNode) => {
-		node.markAsAlive();
+						// Notify the host that the message was sent
+						const res = new SendDataResponse({
+							wasSent: true,
+						});
+						await controller.sendMessageToHost(res);
 
-		const statusChanges: ControllerStatus[] = [];
-		driver.controller.on("status changed", (status) => {
-			statusChanges.push(status);
-		});
+						await wait(100);
 
-		const nodeDead = sinon.spy();
-		node.on("dead", nodeDead);
+						controller.state.set(
+							MockControllerStateKeys.CommunicationState,
+							MockControllerCommunicationState.Idle,
+						);
 
-		shouldFail = true;
-		const promise = node.ping();
-		await wait(500);
+						const cb = new SendDataRequestTransmitReport({
+							callbackId: msg.callbackId!,
+							transmitStatus: TransmitStatus.Fail,
+							txReport: {
+								txTicks: 0,
+								routeSpeed: 0 as any,
+								routingAttempts: 0,
+								ackRSSI: 0,
+							},
+						});
+						await controller.sendMessageToHost(cb);
 
-		// The controller should now be jammed, but the node's status must not change
-		t.expect(driver.controller.status).toBe(ControllerStatus.Jammed);
-		t.expect(node.status).toBe(NodeStatus.Alive);
+						return true;
+					} else if (msg instanceof SendDataAbort) {
+						// Put the controller into idle state
+						controller.state.set(
+							MockControllerStateKeys.CommunicationState,
+							MockControllerCommunicationState.Idle,
+						);
+					}
+				},
+			};
+			controller.defineBehavior(handleSendData);
+		},
+		testBody: async (t, driver, node, mockController, mockNode) => {
+			node.markAsAlive();
 
-		setTimeout(() => {
-			shouldFail = false;
-		}, 2000);
+			const statusChanges: ControllerStatus[] = [];
+			driver.controller.on("status changed", (status) => {
+				statusChanges.push(status);
+			});
+
+			const nodeDead = sinon.spy();
+			node.on("dead", nodeDead);
+
+			shouldFail = true;
+			const promise = node.ping();
+			await wait(500);
+
+			// The controller should now be jammed, but the node's status must not change
+			t.expect(driver.controller.status).toBe(ControllerStatus.Jammed);
+			t.expect(node.status).toBe(NodeStatus.Alive);
 
-		await promise;
+			setTimeout(() => {
+				shouldFail = false;
+			}, 2000);
 
-		t.expect(driver.controller.status).toBe(ControllerStatus.Ready);
-		t.expect(node.status).toBe(NodeStatus.Alive);
+			await promise;
 
-		sinon.assert.notCalled(nodeDead);
-		t.expect(statusChanges).toStrictEqual([
-			ControllerStatus.Jammed,
-			ControllerStatus.Ready,
-		]);
+			t.expect(driver.controller.status).toBe(ControllerStatus.Ready);
+			t.expect(node.status).toBe(NodeStatus.Alive);
+
+			sinon.assert.notCalled(nodeDead);
+			t.expect(statusChanges).toStrictEqual([
+				ControllerStatus.Jammed,
+				ControllerStatus.Ready,
+			]);
+		},
 	},
-});
+);
 
 integrationTest(
 	"When sending fails continuously, soft-reset to recover",
diff --git a/packages/zwave-js/src/lib/test/driver/hasPendingMessages.test.ts b/packages/zwave-js/src/lib/test/driver/hasPendingMessages.test.ts
index c25d0dcf064c..0aabc8b5e00d 100644
--- a/packages/zwave-js/src/lib/test/driver/hasPendingMessages.test.ts
+++ b/packages/zwave-js/src/lib/test/driver/hasPendingMessages.test.ts
@@ -23,8 +23,11 @@ const test = baseTest.extend<LocalTestContext>({
 			const { driver } = await createAndStartTestingDriver({
 				loadConfiguration: false,
 				skipNodeInterview: true,
-				beforeStartup(mockPort) {
-					const controller = new MockController({ serial: mockPort });
+				beforeStartup(mockPort, serial) {
+					const controller = new MockController({
+						mockPort,
+						serial,
+					});
 					controller.defineBehavior(
 						...createDefaultMockControllerBehaviors(),
 					);
diff --git a/packages/zwave-js/src/lib/test/driver/receiveMessages.test.ts b/packages/zwave-js/src/lib/test/driver/receiveMessages.test.ts
index 294c3dfc3b72..d8e6081eba83 100644
--- a/packages/zwave-js/src/lib/test/driver/receiveMessages.test.ts
+++ b/packages/zwave-js/src/lib/test/driver/receiveMessages.test.ts
@@ -1,4 +1,5 @@
 import { WakeUpCCIntervalSet } from "@zwave-js/cc/WakeUpCC";
+import { type MockPort } from "@zwave-js/serial/mock";
 import { ApplicationCommandRequest } from "@zwave-js/serial/serialapi";
 import { Bytes } from "@zwave-js/shared";
 import { MockController } from "@zwave-js/testing";
@@ -10,6 +11,7 @@ interface LocalTestContext {
 	context: {
 		driver: Driver;
 		controller: MockController;
+		mockPort: MockPort;
 	};
 }
 
@@ -19,18 +21,20 @@ const test = baseTest.extend<LocalTestContext>({
 			// Setup
 			const context = {} as LocalTestContext["context"];
 
-			const { driver } = await createAndStartTestingDriver({
+			const { driver, mockPort } = await createAndStartTestingDriver({
 				loadConfiguration: false,
 				// We don't need a real interview for this
 				skipControllerIdentification: true,
 				skipNodeInterview: true,
-				beforeStartup(mockPort) {
+				beforeStartup(mockPort, serial) {
 					context.controller = new MockController({
-						serial: mockPort,
+						mockPort,
+						serial,
 					});
 				},
 			});
 			context.driver = driver;
+			context.mockPort = mockPort;
 
 			// Run tests
 			await use(context);
@@ -46,7 +50,7 @@ const test = baseTest.extend<LocalTestContext>({
 test.sequential(
 	"should not crash if a message is received that cannot be deserialized",
 	async ({ context, expect }) => {
-		const { driver, controller } = context;
+		const { driver, controller, mockPort } = context;
 		const req = new ApplicationCommandRequest({
 			command: new WakeUpCCIntervalSet({
 				nodeId: 1,
@@ -54,7 +58,7 @@ test.sequential(
 				wakeUpInterval: 5,
 			}),
 		});
-		controller.serial.emitData(
+		mockPort.emitData(
 			await req.serializeAsync(driver["getEncodingContext"]()),
 		);
 		await controller.expectHostACK(1000);
@@ -64,13 +68,13 @@ test.sequential(
 test.sequential(
 	"should correctly handle multiple messages in the receive buffer",
 	async ({ context, expect }) => {
-		const { controller } = context;
+		const { controller, mockPort } = context;
 		// This buffer contains a SendData transmit report and a ManufacturerSpecific report
 		const data = Bytes.from(
 			"010700130f000002e6010e000400020872050086000200828e",
 			"hex",
 		);
-		controller.serial.emitData(data);
+		mockPort.emitData(data);
 
 		// Ensure the driver ACKed two messages
 		await controller.expectHostACK(1000);
diff --git a/packages/zwave-js/src/lib/test/driver/unresponsiveStick.test.ts b/packages/zwave-js/src/lib/test/driver/unresponsiveStick.test.ts
index 36caa4ca8da0..1c9078ed2008 100644
--- a/packages/zwave-js/src/lib/test/driver/unresponsiveStick.test.ts
+++ b/packages/zwave-js/src/lib/test/driver/unresponsiveStick.test.ts
@@ -7,7 +7,7 @@ import {
 import { SoftResetRequest } from "@zwave-js/serial/serialapi";
 import { type MockControllerBehavior } from "@zwave-js/testing";
 import { wait } from "alcalzone-shared/async";
-import Sinon from "sinon";
+import { vi } from "vitest";
 import { integrationTest } from "../integrationTestSuite.js";
 
 let shouldRespond = true;
@@ -85,11 +85,13 @@ integrationTest(
 			shouldRespond = false;
 			mockController.autoAckHostMessages = false;
 
-			const serialPortCloseSpy = Sinon.stub().callsFake(() => {
-				shouldRespond = true;
-				mockController.autoAckHostMessages = true;
-			});
-			mockController.serial.on("close", serialPortCloseSpy);
+			const serialPortCloseSpy = vi.spyOn(mockController.serial, "close")
+				.mockImplementation(
+					async () => {
+						shouldRespond = true;
+						mockController.autoAckHostMessages = true;
+					},
+				);
 
 			await wait(1000);
 
@@ -108,7 +110,7 @@ integrationTest(
 
 			// The serial port should have been closed and reopened
 			await wait(100);
-			t.expect(serialPortCloseSpy.called).toBe(true);
+			t.expect(serialPortCloseSpy).toHaveBeenCalled();
 
 			// FIXME: When closing the serial port, we lose the connection between the mock port instance and the controller
 			// Fix it at some point, then enable the below test.
diff --git a/packages/zwave-js/src/lib/test/integrationTestSuite.ts b/packages/zwave-js/src/lib/test/integrationTestSuite.ts
index e7ceebb0a65a..91e818bd40ba 100644
--- a/packages/zwave-js/src/lib/test/integrationTestSuite.ts
+++ b/packages/zwave-js/src/lib/test/integrationTestSuite.ts
@@ -1,4 +1,5 @@
-import type { MockPortBinding } from "@zwave-js/serial/mock";
+import { type ZWaveSerialStream } from "@zwave-js/serial";
+import type { MockPort } from "@zwave-js/serial/mock";
 import { copyFilesRecursive, noop } from "@zwave-js/shared";
 import {
 	type MockController,
@@ -69,7 +70,8 @@ function suite(
 
 	let driver: Driver;
 	let node: ZWaveNode;
-	let mockPort: MockPortBinding;
+	let mockPort: MockPort;
+	let serial: ZWaveSerialStream;
 	let continueStartup: () => void;
 	let mockController: MockController;
 	let mockNode: MockNode;
@@ -93,7 +95,7 @@ function suite(
 			await copyFilesRecursive(provisioningDirectory, cacheDir);
 		}
 
-		({ driver, continueStartup, mockPort } = await prepareDriver(
+		({ driver, continueStartup, mockPort, serial } = await prepareDriver(
 			cacheDir,
 			debug,
 			additionalDriverOptions,
@@ -104,6 +106,7 @@ function suite(
 			mockNodes: [mockNode],
 		} = prepareMocks(
 			mockPort,
+			serial,
 			{
 				capabilities: controllerCapabilities,
 			},
diff --git a/packages/zwave-js/src/lib/test/integrationTestSuiteMulti.ts b/packages/zwave-js/src/lib/test/integrationTestSuiteMulti.ts
index 9aaaa2e51895..52f387a41382 100644
--- a/packages/zwave-js/src/lib/test/integrationTestSuiteMulti.ts
+++ b/packages/zwave-js/src/lib/test/integrationTestSuiteMulti.ts
@@ -1,4 +1,5 @@
-import type { MockPortBinding } from "@zwave-js/serial/mock";
+import { type ZWaveSerialStream } from "@zwave-js/serial";
+import type { MockPort } from "@zwave-js/serial/mock";
 import { copyFilesRecursive, noop } from "@zwave-js/shared";
 import {
 	type MockController,
@@ -68,7 +69,8 @@ function suite(
 	} = options;
 
 	let driver: Driver;
-	let mockPort: MockPortBinding;
+	let mockPort: MockPort;
+	let serial: ZWaveSerialStream;
 	let continueStartup: () => void;
 	let mockController: MockController;
 	let mockNodes: MockNode[];
@@ -93,13 +95,14 @@ function suite(
 			await copyFilesRecursive(provisioningDirectory, cacheDir);
 		}
 
-		({ driver, continueStartup, mockPort } = await prepareDriver(
+		({ driver, continueStartup, mockPort, serial } = await prepareDriver(
 			cacheDir,
 			debug,
 			additionalDriverOptions,
 		));
 		({ mockController, mockNodes } = prepareMocks(
 			mockPort,
+			serial,
 			{
 				capabilities: controllerCapabilities,
 			},
diff --git a/packages/zwave-js/src/lib/test/integrationTestSuiteShared.ts b/packages/zwave-js/src/lib/test/integrationTestSuiteShared.ts
index ae4b9aa40255..be056da04225 100644
--- a/packages/zwave-js/src/lib/test/integrationTestSuiteShared.ts
+++ b/packages/zwave-js/src/lib/test/integrationTestSuiteShared.ts
@@ -1,4 +1,5 @@
-import { type MockPortBinding } from "@zwave-js/serial/mock";
+import { type ZWaveSerialStream } from "@zwave-js/serial";
+import { type MockPort } from "@zwave-js/serial/mock";
 import { Bytes } from "@zwave-js/shared/safe";
 import {
 	MockController,
@@ -44,7 +45,6 @@ export function prepareDriver(
 
 	return createAndStartDriverWithMockPort({
 		...additionalOptions,
-		portAddress: "/tty/FAKE",
 		logConfig,
 		securityKeys: {
 			S0_Legacy: Bytes.from("0102030405060708090a0b0c0d0e0f10", "hex"),
@@ -70,7 +70,8 @@ export function prepareDriver(
 }
 
 export function prepareMocks(
-	mockPort: MockPortBinding,
+	mockPort: MockPort,
+	serial: ZWaveSerialStream,
 	controller: Pick<
 		MockControllerOptions,
 		"ownNodeId" | "homeId" | "capabilities"
@@ -84,7 +85,8 @@ export function prepareMocks(
 		homeId: 0x7e570001,
 		ownNodeId: 1,
 		...controller,
-		serial: mockPort,
+		mockPort,
+		serial,
 	});
 	// Apply default behaviors that are required for interacting with the driver correctly
 	mockController.defineBehavior(...createDefaultMockControllerBehaviors());
diff --git a/packages/zwave-js/src/lib/test/node/Node.ccVersions.test.ts b/packages/zwave-js/src/lib/test/node/Node.ccVersions.test.ts
index 3a05f9e4e79c..3de80e476d64 100644
--- a/packages/zwave-js/src/lib/test/node/Node.ccVersions.test.ts
+++ b/packages/zwave-js/src/lib/test/node/Node.ccVersions.test.ts
@@ -22,8 +22,11 @@ const test = baseTest.extend<LocalTestContext>({
 			const { driver } = await createAndStartTestingDriver({
 				skipNodeInterview: true,
 				loadConfiguration: false,
-				beforeStartup(mockPort) {
-					const controller = new MockController({ serial: mockPort });
+				beforeStartup(mockPort, serial) {
+					const controller = new MockController({
+						mockPort,
+						serial,
+					});
 					controller.defineBehavior(
 						...createDefaultMockControllerBehaviors(),
 					);
diff --git a/packages/zwave-js/src/lib/test/node/Node.constructor.test.ts b/packages/zwave-js/src/lib/test/node/Node.constructor.test.ts
index 56ef6506355e..107aba8e94ad 100644
--- a/packages/zwave-js/src/lib/test/node/Node.constructor.test.ts
+++ b/packages/zwave-js/src/lib/test/node/Node.constructor.test.ts
@@ -26,8 +26,11 @@ const test = baseTest.extend<LocalTestContext>({
 			const { driver } = await createAndStartTestingDriver({
 				skipNodeInterview: true,
 				loadConfiguration: false,
-				beforeStartup(mockPort) {
-					const controller = new MockController({ serial: mockPort });
+				beforeStartup(mockPort, serial) {
+					const controller = new MockController({
+						mockPort,
+						serial,
+					});
 					controller.defineBehavior(
 						...createDefaultMockControllerBehaviors(),
 					);
diff --git a/packages/zwave-js/src/lib/test/node/Node.createCCInstance.test.ts b/packages/zwave-js/src/lib/test/node/Node.createCCInstance.test.ts
index 1b1e36a3f052..e9eacf4edcc9 100644
--- a/packages/zwave-js/src/lib/test/node/Node.createCCInstance.test.ts
+++ b/packages/zwave-js/src/lib/test/node/Node.createCCInstance.test.ts
@@ -28,8 +28,11 @@ const test = baseTest.extend<LocalTestContext>({
 			const { driver } = await createAndStartTestingDriver({
 				skipNodeInterview: true,
 				loadConfiguration: false,
-				beforeStartup(mockPort) {
-					const controller = new MockController({ serial: mockPort });
+				beforeStartup(mockPort, serial) {
+					const controller = new MockController({
+						mockPort,
+						serial,
+					});
 					controller.defineBehavior(
 						...createDefaultMockControllerBehaviors(),
 					);
diff --git a/packages/zwave-js/src/lib/test/node/Node.getEndpoint.test.ts b/packages/zwave-js/src/lib/test/node/Node.getEndpoint.test.ts
index 8ca17b6cd643..c75006241c8c 100644
--- a/packages/zwave-js/src/lib/test/node/Node.getEndpoint.test.ts
+++ b/packages/zwave-js/src/lib/test/node/Node.getEndpoint.test.ts
@@ -29,8 +29,11 @@ const test = baseTest.extend<LocalTestContext>({
 			const { driver } = await createAndStartTestingDriver({
 				skipNodeInterview: true,
 				loadConfiguration: false,
-				beforeStartup(mockPort) {
-					const controller = new MockController({ serial: mockPort });
+				beforeStartup(mockPort, serial) {
+					const controller = new MockController({
+						mockPort,
+						serial,
+					});
 					controller.defineBehavior(
 						...createDefaultMockControllerBehaviors(),
 					);
diff --git a/packages/zwave-js/src/lib/test/node/Node.getSetValue.test.ts b/packages/zwave-js/src/lib/test/node/Node.getSetValue.test.ts
index 2c3211792847..0bec8b59c777 100644
--- a/packages/zwave-js/src/lib/test/node/Node.getSetValue.test.ts
+++ b/packages/zwave-js/src/lib/test/node/Node.getSetValue.test.ts
@@ -27,8 +27,11 @@ const test = baseTest.extend<LocalTestContext>({
 			const { driver } = await createAndStartTestingDriver({
 				skipNodeInterview: true,
 				loadConfiguration: false,
-				beforeStartup(mockPort) {
-					const controller = new MockController({ serial: mockPort });
+				beforeStartup(mockPort, serial) {
+					const controller = new MockController({
+						mockPort,
+						serial,
+					});
 					controller.defineBehavior(
 						...createDefaultMockControllerBehaviors(),
 					);
diff --git a/packages/zwave-js/src/lib/test/node/Node.status.test.ts b/packages/zwave-js/src/lib/test/node/Node.status.test.ts
index 7f95024c4020..c2d29f3fe47d 100644
--- a/packages/zwave-js/src/lib/test/node/Node.status.test.ts
+++ b/packages/zwave-js/src/lib/test/node/Node.status.test.ts
@@ -24,8 +24,11 @@ const test = baseTest.extend<LocalTestContext>({
 			const { driver } = await createAndStartTestingDriver({
 				skipNodeInterview: true,
 				loadConfiguration: false,
-				beforeStartup(mockPort) {
-					const controller = new MockController({ serial: mockPort });
+				beforeStartup(mockPort, serial) {
+					const controller = new MockController({
+						mockPort,
+						serial,
+					});
 					controller.defineBehavior(
 						...createDefaultMockControllerBehaviors(),
 					);
diff --git a/packages/zwave-js/src/lib/test/node/Node.updateNodeInfo.test.ts b/packages/zwave-js/src/lib/test/node/Node.updateNodeInfo.test.ts
index 6985372ff54f..f5d38df33d84 100644
--- a/packages/zwave-js/src/lib/test/node/Node.updateNodeInfo.test.ts
+++ b/packages/zwave-js/src/lib/test/node/Node.updateNodeInfo.test.ts
@@ -32,8 +32,11 @@ const test = baseTest.extend<LocalTestContext>({
 			const { driver } = await createAndStartTestingDriver({
 				skipNodeInterview: true,
 				loadConfiguration: false,
-				beforeStartup(mockPort) {
-					const controller = new MockController({ serial: mockPort });
+				beforeStartup(mockPort, serial) {
+					const controller = new MockController({
+						mockPort,
+						serial,
+					});
 					controller.defineBehavior(
 						...createDefaultMockControllerBehaviors(),
 					);
diff --git a/packages/zwave-js/src/lib/test/node/Node.valueEvents.test.ts b/packages/zwave-js/src/lib/test/node/Node.valueEvents.test.ts
index 9451eaf16fab..674855a34305 100644
--- a/packages/zwave-js/src/lib/test/node/Node.valueEvents.test.ts
+++ b/packages/zwave-js/src/lib/test/node/Node.valueEvents.test.ts
@@ -25,8 +25,11 @@ const test = baseTest.extend<LocalTestContext>({
 			const { driver } = await createAndStartTestingDriver({
 				skipNodeInterview: true,
 				loadConfiguration: false,
-				beforeStartup(mockPort) {
-					const controller = new MockController({ serial: mockPort });
+				beforeStartup(mockPort, serial) {
+					const controller = new MockController({
+						mockPort,
+						serial,
+					});
 					controller.defineBehavior(
 						...createDefaultMockControllerBehaviors(),
 					);
diff --git a/packages/zwave-js/src/lib/test/node/Node.waitForWakeup.test.ts b/packages/zwave-js/src/lib/test/node/Node.waitForWakeup.test.ts
index de9f9645a162..ae8ba10ee0f9 100644
--- a/packages/zwave-js/src/lib/test/node/Node.waitForWakeup.test.ts
+++ b/packages/zwave-js/src/lib/test/node/Node.waitForWakeup.test.ts
@@ -29,8 +29,11 @@ const test = baseTest.extend<LocalTestContext>({
 			const { driver } = await createAndStartTestingDriver({
 				skipNodeInterview: true,
 				loadConfiguration: false,
-				beforeStartup(mockPort) {
-					const controller = new MockController({ serial: mockPort });
+				beforeStartup(mockPort, serial) {
+					const controller = new MockController({
+						mockPort,
+						serial,
+					});
 					controller.defineBehavior(
 						...createDefaultMockControllerBehaviors(),
 					);
diff --git a/packages/zwave-js/src/lib/zniffer/Zniffer.ts b/packages/zwave-js/src/lib/zniffer/Zniffer.ts
index ab73a037ccdf..45607f992b1c 100644
--- a/packages/zwave-js/src/lib/zniffer/Zniffer.ts
+++ b/packages/zwave-js/src/lib/zniffer/Zniffer.ts
@@ -28,11 +28,13 @@ import {
 	ZnifferRegionLegacy,
 	getChipTypeAndVersion,
 	isLongRangeNodeId,
+	isZWaveError,
 	securityClassIsS2,
 } from "@zwave-js/core";
 import { sdkVersionGte } from "@zwave-js/core";
 import { type CCParsingContext, type HostIDs } from "@zwave-js/host";
 import {
+	type ZWaveSerialBindingFactory,
 	type ZWaveSerialPortImplementation,
 	type ZnifferDataMessage,
 	ZnifferFrameType,
@@ -44,23 +46,27 @@ import {
 	ZnifferGetVersionResponse,
 	ZnifferMessage,
 	ZnifferMessageType,
-	ZnifferSerialPort,
-	ZnifferSerialPortBase,
+	ZnifferSerialFrameType,
+	type ZnifferSerialStream,
+	ZnifferSerialStreamFactory,
 	ZnifferSetBaudRateRequest,
 	ZnifferSetBaudRateResponse,
 	ZnifferSetFrequencyRequest,
 	ZnifferSetFrequencyResponse,
-	ZnifferSocket,
 	ZnifferStartRequest,
 	ZnifferStartResponse,
 	ZnifferStopRequest,
 	ZnifferStopResponse,
+	createNodeSerialPortFactory,
+	createNodeSocketFactory,
 	isZWaveSerialPortImplementation,
+	wrapLegacySerialBinding,
 } from "@zwave-js/serial";
 import {
 	Bytes,
 	TypedEventTarget,
 	getEnumMemberName,
+	isAbortError,
 	isEnumMember,
 	noop,
 	num2hex,
@@ -186,7 +192,11 @@ export interface CapturedFrame {
 
 export class Zniffer extends TypedEventTarget<ZnifferEventCallbacks> {
 	public constructor(
-		private port: string | ZWaveSerialPortImplementation,
+		private port:
+			| string
+			// eslint-disable-next-line @typescript-eslint/no-deprecated
+			| ZWaveSerialPortImplementation
+			| ZWaveSerialBindingFactory,
 		options: ZnifferOptions = {},
 	) {
 		super();
@@ -265,8 +275,10 @@ export class Zniffer extends TypedEventTarget<ZnifferEventCallbacks> {
 
 	private _options: ZnifferOptions;
 
+	private serialFactory: ZnifferSerialStreamFactory | undefined;
 	/** The serial port instance */
-	private serial: ZnifferSerialPortBase | undefined;
+	private serial: ZnifferSerialStream | undefined;
+
 	private parsingContext: Omit<
 		CCParsingContext,
 		keyof HostIDs | "sourceNodeId" | "frameType" | keyof SecurityManagers
@@ -331,40 +343,44 @@ export class Zniffer extends TypedEventTarget<ZnifferEventCallbacks> {
 		}
 
 		// Open the serial port
+		let binding: ZWaveSerialBindingFactory;
 		if (typeof this.port === "string") {
 			if (this.port.startsWith("tcp://")) {
 				const url = new URL(this.port);
-				// this.znifferLog.print(`opening serial port ${this.port}`);
-				this.serial = new ZnifferSocket(
-					{
-						host: url.hostname,
-						port: parseInt(url.port),
-					},
-					this._logContainer,
-				);
+				this.znifferLog.print(`opening serial port ${this.port}`);
+				binding = createNodeSocketFactory({
+					host: url.hostname,
+					port: parseInt(url.port),
+				});
 			} else {
-				// this.znifferLog.print(`opening serial port ${this.port}`);
-				this.serial = new ZnifferSerialPort(
+				this.znifferLog.print(`opening serial port ${this.port}`);
+				binding = createNodeSerialPortFactory(
 					this.port,
-					this._logContainer,
+					// this._options.testingHooks?.serialPortBinding,
 				);
 			}
+		} else if (isZWaveSerialPortImplementation(this.port)) {
+			this.znifferLog.print(
+				"opening serial port using the provided custom implementation",
+			);
+			this.znifferLog.print(
+				"This is deprecated! Switch to the factory pattern instead.",
+				"warn",
+			);
+			binding = wrapLegacySerialBinding(this.port);
 		} else {
-			// this.znifferLog.print(
-			// 	"opening serial port using the provided custom implementation",
-			// );
-			this.serial = new ZnifferSerialPortBase(
-				this.port,
-				this._logContainer,
+			this.znifferLog.print(
+				"opening serial port using the provided custom factory",
 			);
+			binding = this.port;
 		}
-		this.serial
-			.on("data", this.serialport_onData.bind(this))
-			.on("error", (err) => {
-				this.emit("error", err);
-			});
+		this.serialFactory = new ZnifferSerialStreamFactory(
+			binding,
+			this._logContainer,
+		);
 
-		await this.serial.open();
+		this.serial = await this.serialFactory.createStream();
+		void this.handleSerialData(this.serial);
 
 		this.znifferLog.print(logo, "info");
 
@@ -452,6 +468,30 @@ supported frequencies: ${
 		this.emit("ready");
 	}
 
+	private async handleSerialData(serial: ZnifferSerialStream): Promise<void> {
+		try {
+			for await (const frame of serial.readable) {
+				setImmediate(() => {
+					if (frame.type === ZnifferSerialFrameType.SerialAPI) {
+						void this.serialport_onData(frame.data);
+					} else {
+						// Handle discarded data?
+					}
+				});
+			}
+		} catch (e) {
+			if (isAbortError(e)) {
+				return;
+			} else if (
+				isZWaveError(e) && e.code === ZWaveErrorCodes.Driver_Failed
+			) {
+				this.emit("error", e);
+				return this.destroy();
+			}
+			throw e;
+		}
+	}
+
 	/**
 	 * Is called when the serial port has received a Zniffer frame
 	 */
@@ -1004,7 +1044,6 @@ supported frequencies: ${
 
 		if (this.serial != undefined) {
 			// Avoid spewing errors if the port was in the middle of receiving something
-			this.serial.removeAllListeners();
 			if (this.serial.isOpen) await this.serial.close();
 			this.serial = undefined;
 		}
diff --git a/packages/zwave-js/src/mockServer.ts b/packages/zwave-js/src/mockServer.ts
index a1ed1eb925c0..09e5e3594530 100644
--- a/packages/zwave-js/src/mockServer.ts
+++ b/packages/zwave-js/src/mockServer.ts
@@ -18,9 +18,14 @@ import {
 	type ValueMetadata,
 	type ValueMetadataNumeric,
 } from "@zwave-js/core";
-import type { ZWaveSerialPort } from "@zwave-js/serial";
 import {
-	type MockPortBinding,
+	Faucet,
+	type ZWaveSerialFrame,
+	ZWaveSerialFrameType,
+	type ZWaveSerialStream,
+} from "@zwave-js/serial";
+import {
+	type MockPort,
 	createAndOpenMockedZWaveSerialPort,
 } from "@zwave-js/serial/mock";
 import { getErrorMessage } from "@zwave-js/shared";
@@ -85,8 +90,8 @@ export interface MockServerOptions {
 export class MockServer {
 	public constructor(private options: MockServerOptions = {}) {}
 
-	private serialport: ZWaveSerialPort | undefined;
-	private binding: MockPortBinding | undefined;
+	private serialport: ZWaveSerialStream | undefined;
+	private binding: MockPort | undefined;
 	private server: Server | undefined;
 	private responder: MdnsResponder | undefined;
 	private service: CiaoService | undefined;
@@ -94,18 +99,19 @@ export class MockServer {
 	private mockNodes: MockNode[] | undefined;
 
 	public async start(): Promise<void> {
-		const { port: serialport, binding } =
-			await createAndOpenMockedZWaveSerialPort("/tty/FAKE");
+		const { serial, port: mockPort } =
+			await createAndOpenMockedZWaveSerialPort();
 
-		this.serialport = serialport;
-		this.binding = binding;
+		this.serialport = serial;
+		this.binding = mockPort;
 
 		console.log("Mock serial port opened");
 
 		// Hook up a fake controller and nodes
 		({ mockController: this.mockController, mockNodes: this.mockNodes } =
 			prepareMocks(
-				binding,
+				mockPort,
+				serial,
 				this.options.config?.controller,
 				this.options.config?.nodes,
 			));
@@ -115,6 +121,9 @@ export class MockServer {
 			this.options.config.onInit(this.mockController, this.mockNodes);
 		}
 
+		// Forward data from the serialport to the socket while one is connected
+		const faucet = new Faucet(serial.readable);
+
 		// Start a TCP server, listen for connections, and forward them to the serial port
 		this.server = createServer((socket) => {
 			if (!this.serialport) {
@@ -125,21 +134,32 @@ export class MockServer {
 
 			console.log("Client connected");
 
-			socket.pipe(this.serialport);
-			this.serialport.on("data", (chunk) => {
-				if (typeof chunk === "number") {
-					socket.write(Uint8Array.from([chunk]));
-				} else {
-					socket.write(chunk);
-				}
+			// Wrap the socket in a writable stream
+			const writable = new WritableStream({
+				write: (chunk: ZWaveSerialFrame) => {
+					if (chunk.type !== ZWaveSerialFrameType.SerialAPI) return;
+					if (typeof chunk.data === "number") {
+						socket.write(Uint8Array.from([chunk.data]));
+					} else {
+						socket.write(chunk.data);
+					}
+				},
 			});
 
-			// when the connection is closed, unpipe the streams
+			// And forward data from the serial port
+			faucet.connect(writable);
+
 			socket.on("close", () => {
+				faucet.disconnect();
+				void writable.close();
 				console.log("Client disconnected");
+			});
 
-				socket.unpipe(this.serialport);
-				this.serialport?.removeAllListeners("data");
+			// Forward data from the socket to the serial port
+			socket.on("data", async (chunk) => {
+				await this.serialport?.writeAsync(chunk).catch((e) => {
+					console.error(`Error writing to serialport`, e);
+				});
 			});
 		});
 
@@ -203,13 +223,14 @@ export class MockServer {
 		this.mockController?.destroy();
 		this.server?.close();
 		await this.serialport?.close();
-		if (this.binding?.isOpen) await this.binding?.close();
+		this.binding?.destroy();
 		console.log("Mock server shut down");
 	}
 }
 
 function prepareMocks(
-	mockPort: MockPortBinding,
+	mockPort: MockPort,
+	serial: ZWaveSerialStream,
 	controller: MockServerControllerOptions = {},
 	nodes: MockServerNodeOptions[] = [],
 ): { mockController: MockController; mockNodes: MockNode[] } {
@@ -217,7 +238,8 @@ function prepareMocks(
 		homeId: 0x7e570001,
 		ownNodeId: 1,
 		...controller,
-		serial: mockPort,
+		mockPort,
+		serial,
 	});
 	// Apply default behaviors that are required for interacting with the driver correctly
 	mockController.defineBehavior(...createDefaultMockControllerBehaviors());
diff --git a/test/run.ts b/test/run.ts
index 98362510be27..d7607bd872c1 100644
--- a/test/run.ts
+++ b/test/run.ts
@@ -2,13 +2,14 @@ import { wait as _wait } from "alcalzone-shared/async";
 import path from "node:path";
 import "reflect-metadata";
 import { Bytes } from "@zwave-js/shared/safe";
-import os from "node:os";
+import _os from "node:os";
 import { fileURLToPath } from "node:url";
 import { Driver } from "zwave-js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 const wait = _wait;
+const os = _os;
 
 process.on("unhandledRejection", (_r) => {
 	debugger;
@@ -21,9 +22,10 @@ process.on("unhandledRejection", (_r) => {
 // 	: "/dev/ttyACM0";
 // const port = require("os").platform() === "win32" ? "COM5" : "/dev/ttyUSB0";
 // 800 series
-const port = os.platform() === "win32"
-	? "COM5"
-	: "/dev/serial/by-id/usb-Zooz_800_Z-Wave_Stick_533D004242-if00";
+// const port = os.platform() === "win32"
+// 	? "COM5"
+// 	: "/dev/serial/by-id/usb-Zooz_800_Z-Wave_Stick_533D004242-if00";
+const port = "tcp://127.0.0.1:5555";
 
 const driver = new Driver(port, {
 	// logConfig: {