@ceralive/modem-control 0.2.0 → 1.1.0

package/src/transport/no-library-leak.test.ts

@@ -1,61 +0,0 @@
-// Guard: the `@httptoolkit/dbus-native` library must never surface in a public export.
-//
-// The package entry (`control/src/index.ts`) and the transport seam's own public entry
-// (`./index.ts`) may reference the library only through the quarantined facade
-// (`./dbus-native.ts`) — never re-export it. Swapping the underlying library (documented
-// fallback `@particle/dbus-next`) must stay invisible to every caller.
-
-import { expect, test } from 'bun:test';
-import { readdirSync } from 'node:fs';
-import { join } from 'node:path';
-import * as transportPublic from './index';
-
-// A single-quoted module specifier — the shape of a real import/export, distinct from a
-// prose mention of the library in a comment (those use backticks).
-const LIBRARY_IMPORT = "'@httptoolkit/dbus-native'";
-const transportDir = import.meta.dir;
-const controlSrcDir = join(transportDir, '..');
-
-test('the package entry does not import or re-export the D-Bus library', async () => {
-	const source = await Bun.file(join(controlSrcDir, 'index.ts')).text();
-	expect(source).not.toContain(LIBRARY_IMPORT);
-});
-
-test('the transport public entry does not import or re-export the D-Bus library', async () => {
-	const source = await Bun.file(join(transportDir, 'index.ts')).text();
-	expect(source).not.toContain(LIBRARY_IMPORT);
-});
-
-test('only the quarantined facade imports the D-Bus library from production modules', async () => {
-	// Enumerate every non-test production module in transport/ dynamically, so a NEW module
-	// (e.g. a future transport split) that imports the library directly is caught — the old
-	// fixed list never knew about files it did not name. The importer set must be EXACTLY the
-	// sanctioned facade, `dbus-native.ts`.
-	const productionModules = readdirSync(transportDir).filter(
-		(name) => name.endsWith('.ts') && !name.endsWith('.test.ts'),
-	);
-	const importers: string[] = [];
-	for (const moduleName of productionModules) {
-		const source = await Bun.file(join(transportDir, moduleName)).text();
-		if (source.includes(LIBRARY_IMPORT)) {
-			importers.push(moduleName);
-		}
-	}
-	expect(importers.sort()).toEqual(['dbus-native.ts']);
-});
-
-test('the transport public surface exposes only the seam\u2019s own values', () => {
-	const exported = Object.keys(transportPublic).sort();
-	expect(exported).toEqual(
-		[
-			'BigIntRequiredError',
-			'DisconnectedError',
-			'SixtyFourBitRangeError',
-			'TransportError',
-			'UnsupportedSignatureError',
-			'createDbusTransport',
-			'isVariant',
-			'variant',
-		].sort(),
-	);
-});

package/src/transport/reliability.test.ts

@@ -1,173 +0,0 @@
-// Reliability tests for the transport seam: reconnect after a bus restart, a ≥5000-event
-// signal stream, late replies, and a 100-cycle subscribe/unsubscribe leak check.
-//
-// These run against dedicated private `dbus-daemon` instances (not the outer session
-// bus): the reconnect test must kill and respawn its bus, which is only safe on a bus we
-// own. That also makes this file self-contained — it needs no `dbus-run-session`.
-
-import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
-import type { DbusTransport } from './index';
-import { createDbusTransport } from './index';
-import {
-	FAKE_IFACE,
-	FAKE_PATH,
-	type FakeService,
-	startFakeService,
-	TICK_MEMBER,
-} from './test-support/fake-service';
-import { PrivateBus } from './test-support/private-bus';
-
-const HAS_DBUS_DAEMON = Bun.which('dbus-daemon') !== null;
-
-const sleep = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));
-
-async function waitFor(predicate: () => boolean, timeoutMs: number, label: string): Promise<void> {
-	const deadline = Date.now() + timeoutMs;
-	while (Date.now() < deadline) {
-		if (predicate()) {
-			return;
-		}
-		await sleep(10);
-	}
-	throw new Error(`timed out after ${timeoutMs}ms waiting for ${label}`);
-}
-
-const tickSpec = { interface: FAKE_IFACE, member: TICK_MEMBER, path: FAKE_PATH };
-
-describe.skipIf(!HAS_DBUS_DAEMON)('transport reliability (shared private bus)', () => {
-	let bus: PrivateBus;
-	let fake: FakeService;
-	let transport: DbusTransport;
-
-	beforeAll(async () => {
-		bus = new PrivateBus();
-		await bus.start();
-		fake = await startFakeService({ socket: bus.socket });
-		transport = createDbusTransport({ socket: bus.socket });
-		await transport.connect();
-	});
-
-	afterAll(async () => {
-		await transport.disconnect();
-		await fake.stop();
-		await bus.stop();
-	});
-
-	test('a late reply (reply delayed 600ms) still resolves the call correctly', async () => {
-		const reply = await transport.callMethod({
-			destination: fake.busName,
-			path: FAKE_PATH,
-			interface: FAKE_IFACE,
-			member: 'SlowPing',
-			signature: 'u',
-			args: [600],
-		});
-		expect(reply.body[0]).toBe('pong');
-	});
-
-	test('a ≥5000-event signal stream is delivered completely, in order, as exact bigints', async () => {
-		const total = 5000;
-		const received: bigint[] = [];
-		const subscription = await transport.subscribeSignal(tickSpec, (event) => {
-			received.push(event.body[0] as bigint);
-		});
-
-		for (let seq = 0; seq < total; seq += 1) {
-			fake.emitTick(BigInt(seq));
-		}
-
-		await waitFor(() => received.length >= total, 20_000, `${total} tick signals`);
-		expect(received.length).toBe(total);
-		expect(received[0]).toBe(0n);
-		expect(received[total - 1]).toBe(BigInt(total - 1));
-		// Order and exactness across the whole stream.
-		let ordered = true;
-		for (let i = 0; i < total; i += 1) {
-			if (received[i] !== BigInt(i)) {
-				ordered = false;
-				break;
-			}
-		}
-		expect(ordered).toBe(true);
-
-		await subscription.unsubscribe();
-	});
-
-	test('100 subscribe/unsubscribe cycles leave no leaked listener', async () => {
-		const baseline = transport.subscriptionCount();
-		for (let cycle = 0; cycle < 100; cycle += 1) {
-			const subscription = await transport.subscribeSignal(tickSpec, () => undefined);
-			await subscription.unsubscribe();
-		}
-		expect(transport.subscriptionCount()).toBe(baseline);
-
-		// Behavioural proof: after all those cycles a fresh subscriber receives each signal
-		// exactly once — a leaked listener from an earlier cycle would double-deliver.
-		let deliveries = 0;
-		const subscription = await transport.subscribeSignal(tickSpec, () => {
-			deliveries += 1;
-		});
-		fake.emitTick(1n);
-		await waitFor(() => deliveries >= 1, 3_000, 'one tick after leak cycles');
-		await sleep(100);
-		expect(deliveries).toBe(1);
-		await subscription.unsubscribe();
-	});
-});
-
-test.skipIf(!HAS_DBUS_DAEMON)(
-	'transport reconnects and resubscribes after a bus restart without a consumer-facing crash',
-	async () => {
-		const bus = new PrivateBus();
-		await bus.start();
-		let fake = await startFakeService({ socket: bus.socket });
-		const transport = createDbusTransport({
-			socket: bus.socket,
-			reconnect: { initialDelayMs: 25, maxDelayMs: 200 },
-		});
-
-		const events: string[] = [];
-		let consumerError: unknown = null;
-		transport.on('disconnected', () => events.push('disconnected'));
-		transport.on('reconnected', () => events.push('reconnected'));
-		transport.on('error', (error) => {
-			consumerError = error;
-		});
-
-		await transport.connect();
-
-		const ticks: bigint[] = [];
-		const subscription = await transport.subscribeSignal(tickSpec, (event) => {
-			ticks.push(event.body[0] as bigint);
-		});
-
-		fake.emitTick(11n);
-		await waitFor(() => ticks.includes(11n), 3_000, 'pre-restart tick');
-
-		// Kill the bus mid-flight; the old fake dies with it.
-		bus.kill();
-		await waitFor(() => events.includes('disconnected'), 5_000, 'disconnected event');
-
-		// Bring the bus back at the same socket; the transport must reconnect on its own.
-		await bus.start();
-		await waitFor(() => events.includes('reconnected'), 15_000, 'reconnected event');
-
-		// A fresh producer on the restored bus; the transport auto-resubscribed, so its
-		// signal must arrive without the caller re-subscribing.
-		fake = await startFakeService({ socket: bus.socket });
-		fake.emitTick(22n);
-		await waitFor(() => ticks.includes(22n), 8_000, 'post-reconnect tick (resubscribe)');
-
-		expect(events).toContain('disconnected');
-		expect(events).toContain('reconnected');
-		expect(ticks).toContain(11n);
-		expect(ticks).toContain(22n);
-		expect(consumerError).toBeNull();
-
-		await subscription.unsubscribe();
-		await transport.disconnect();
-		await fake.stop();
-		await bus.stop();
-	},
-	30_000,
-);

package/src/transport/signals.ts

@@ -1,150 +0,0 @@
-// Signal subscription and match-rule tracking for the D-Bus transport seam.
-//
-// The transport's single persistent `message` listener fans out here: `dispatch` walks the
-// live subscription registry and delivers each decoded signal to every matching listener.
-// Match rules are refcounted so N subscriptions sharing a rule add/remove it on the bus
-// exactly once, and `reissueRules` re-adds every live rule after a reconnect — so
-// subscribing/unsubscribing never grows the connection's listener count (the 100-cycle
-// leak check depends on this).
-
-import { decodeBody } from './codec';
-import { messageType, type RawBus, type RawMessage } from './dbus-native';
-import type { DbusValue, SignalEvent, SignalListener, SignalSpec, Subscription } from './types';
-
-// The live connection context the registry reads through. The transport supplies these so
-// the registry always sees the current bus/connected state (which change across reconnects)
-// rather than capturing a stale reference, and routes decode/listener failures to the
-// transport's `error` event.
-export interface SignalHost {
-	currentBus(): RawBus | null;
-	isConnected(): boolean;
-	emitError(error: unknown): void;
-}
-
-interface SubscriptionRecord {
-	readonly id: number;
-	readonly spec: SignalSpec;
-	readonly listener: SignalListener;
-	readonly rule: string;
-}
-
-function buildMatchRule(spec: SignalSpec): string {
-	const parts = [`type='signal'`, `interface='${spec.interface}'`, `member='${spec.member}'`];
-	if (spec.path !== undefined) {
-		parts.push(`path='${spec.path}'`);
-	}
-	if (spec.sender !== undefined) {
-		parts.push(`sender='${spec.sender}'`);
-	}
-	return parts.join(',');
-}
-
-function signalMatches(spec: SignalSpec, message: RawMessage): boolean {
-	if (message.interface !== spec.interface || message.member !== spec.member) {
-		return false;
-	}
-	if (spec.path !== undefined && message.path !== spec.path) {
-		return false;
-	}
-	if (spec.sender !== undefined && message.sender !== spec.sender) {
-		return false;
-	}
-	return true;
-}
-
-export class SignalRegistry {
-	readonly #host: SignalHost;
-	readonly #subscriptions = new Map<number, SubscriptionRecord>();
-	readonly #matchRuleRefcount = new Map<string, number>();
-	#nextSubId = 1;
-
-	constructor(host: SignalHost) {
-		this.#host = host;
-	}
-
-	async subscribe(spec: SignalSpec, listener: SignalListener): Promise<Subscription> {
-		const rule = buildMatchRule(spec);
-		const id = this.#nextSubId++;
-		this.#subscriptions.set(id, { id, spec, listener, rule });
-		await this.#addMatchRule(rule);
-
-		let removed = false;
-		return {
-			unsubscribe: async (): Promise<void> => {
-				if (removed) {
-					return;
-				}
-				removed = true;
-				this.#subscriptions.delete(id);
-				await this.#removeMatchRule(rule);
-			},
-		};
-	}
-
-	count(): number {
-		return this.#subscriptions.size;
-	}
-
-	// Re-issue every live match rule against a freshly established bus so a reconnect
-	// resubscribes transparently. Called by `#establish` before it swaps in the new bus, so
-	// the fresh bus is passed in explicitly rather than read from the host.
-	async reissueRules(bus: RawBus): Promise<void> {
-		for (const rule of this.#matchRuleRefcount.keys()) {
-			await bus.addMatch(rule);
-		}
-	}
-
-	dispatch(message: RawMessage): void {
-		if (message.type !== messageType.signal) {
-			return;
-		}
-		for (const record of this.#subscriptions.values()) {
-			if (!signalMatches(record.spec, message)) {
-				continue;
-			}
-			let body: DbusValue[];
-			try {
-				const signature = message.signature ?? '';
-				body = signature.length > 0 ? decodeBody(signature, message.body ?? []) : [];
-			} catch (error) {
-				this.#host.emitError(error);
-				continue;
-			}
-			const event: SignalEvent = {
-				path: message.path ?? '',
-				interface: message.interface ?? '',
-				member: message.member ?? '',
-				sender: message.sender,
-				signature: message.signature ?? '',
-				body,
-			};
-			try {
-				record.listener(event);
-			} catch (error) {
-				this.#host.emitError(error);
-			}
-		}
-	}
-
-	async #addMatchRule(rule: string): Promise<void> {
-		const current = this.#matchRuleRefcount.get(rule) ?? 0;
-		this.#matchRuleRefcount.set(rule, current + 1);
-		const bus = this.#host.currentBus();
-		if (current === 0 && this.#host.isConnected() && bus) {
-			await bus.addMatch(rule);
-		}
-	}
-
-	async #removeMatchRule(rule: string): Promise<void> {
-		const current = this.#matchRuleRefcount.get(rule) ?? 0;
-		if (current <= 1) {
-			this.#matchRuleRefcount.delete(rule);
-			const bus = this.#host.currentBus();
-			if (current === 1 && this.#host.isConnected() && bus) {
-				await bus.removeMatch(rule).catch(() => undefined);
-			}
-		} else {
-			this.#matchRuleRefcount.set(rule, current - 1);
-		}
-	}
-}

package/src/transport/signature.ts

@@ -1,110 +0,0 @@
-// D-Bus signature parsing and support checks.
-//
-// We keep our own tiny recursive-descent parser rather than reaching into the
-// underlying library's internal `lib/signature.js`: the parsed tree drives our
-// signature-aware encode/decode (below) and the tree shape is part of this seam's
-// contract, not the library's. The node shape intentionally mirrors the library's
-// (`{ type, child }`) so a tree the library hands us inside a decoded variant can be
-// re-serialised with `signatureFromNode` without a translation step.
-
-import { UnsupportedSignatureError } from './errors';
-
-export interface SignatureNode {
-	readonly type: string;
-	readonly child: readonly SignatureNode[];
-}
-
-const CONTAINER_CLOSE: Record<string, string> = {
-	'{': '}',
-	'(': ')',
-};
-
-// Every basic and container type char D-Bus defines. `h` (UNIX_FD) is deliberately
-// listed as *known* so the parser accepts it structurally — we reject it explicitly in
-// `assertSupportedSignature` with a typed error rather than as a vague parse failure.
-const KNOWN_TYPES = new Set('ybnqiuxtdsogarvhe{}()'.split(''));
-
-// UNIX_FD: file-descriptor passing. Unsupported everywhere in this transport.
-const UNSUPPORTED_TYPE = 'h';
-
-// Throws UnsupportedSignatureError if the signature contains `h` anywhere (including
-// nested inside arrays, structs, dict entries, or variants). Signatures are pure type
-// strings, so a plain character scan is exact.
-export function assertSupportedSignature(signature: string): void {
-	const index = signature.indexOf(UNSUPPORTED_TYPE);
-	if (index !== -1) {
-		throw new UnsupportedSignatureError(signature, UNSUPPORTED_TYPE);
-	}
-}
-
-// Parse a full signature (which may contain several top-level complete types) into a
-// flat list of nodes.
-export function parseSignature(signature: string): SignatureNode[] {
-	let index = 0;
-
-	function next(): string | null {
-		if (index < signature.length) {
-			const char = signature[index] as string;
-			index += 1;
-			return char;
-		}
-		return null;
-	}
-
-	function parseOne(char: string): SignatureNode {
-		if (!KNOWN_TYPES.has(char)) {
-			throw new Error(`Unknown D-Bus type "${char}" in signature "${signature}"`);
-		}
-
-		const children: SignatureNode[] = [];
-		switch (char) {
-			case 'a': {
-				const element = next();
-				if (element === null) {
-					throw new Error(`Bad signature "${signature}": array with no element type`);
-				}
-				children.push(parseOne(element));
-				return { type: 'a', child: children };
-			}
-			case '{':
-			case '(': {
-				const close = CONTAINER_CLOSE[char];
-				let element = next();
-				while (element !== null && element !== close) {
-					children.push(parseOne(element));
-					element = next();
-				}
-				if (element === null) {
-					throw new Error(`Bad signature "${signature}": unterminated "${char}"`);
-				}
-				return { type: char, child: children };
-			}
-			default:
-				return { type: char, child: children };
-		}
-	}
-
-	const nodes: SignatureNode[] = [];
-	let char = next();
-	while (char !== null) {
-		nodes.push(parseOne(char));
-		char = next();
-	}
-	return nodes;
-}
-
-// Re-serialise a single parsed node back to its signature string. Used to recover the
-// inner signature of a decoded variant, whose contained type the library hands us as a
-// parse tree rather than a string.
-export function signatureFromNode(node: SignatureNode): string {
-	switch (node.type) {
-		case 'a':
-			return `a${signatureFromNode(node.child[0] as SignatureNode)}`;
-		case '(':
-			return `(${node.child.map(signatureFromNode).join('')})`;
-		case '{':
-			return `{${node.child.map(signatureFromNode).join('')}}`;
-		default:
-			return node.type;
-	}
-}

package/src/transport/test-support/fake-service.ts

@@ -1,168 +0,0 @@
-// Minimal fake D-Bus service built on the SAME `@httptoolkit/dbus-native` library, for
-// the half-(a) conformance tests. It is deliberately tiny — a handful of echo/describe
-// methods and one signal — NOT the MM-faithful object model (root ObjectManager, Modem /
-// Modem3gpp interfaces, SIM objects, bearer tripwires); that richer fake is task A2.3.
-//
-// The service runs with `ReturnLongjs: true` so 64-bit values it receives survive as
-// Long objects and re-marshal losslessly on echo. Decode-direction methods return fixed,
-// hand-built values in the library's native encode shape; encode-direction methods report
-// back a canonical string of what they received, so the tests never depend on this
-// transport's own codec to judge it.
-
-import * as dbusNativeModule from '@httptoolkit/dbus-native';
-
-export const FAKE_BUS_NAME = 'tv.ceralive.ModemStackFake';
-export const FAKE_PATH = '/tv/ceralive/fake';
-export const FAKE_IFACE = 'tv.ceralive.ModemStackFake.Conformance';
-export const TICK_MEMBER = 'Tick';
-
-export const INT64_MAX = 2n ** 63n - 1n;
-export const UINT64_MAX = 2n ** 64n - 1n;
-
-type MethodImpl = (...args: unknown[]) => unknown;
-
-interface FakeBus {
-	connection: {
-		on(event: string, handler: (...args: unknown[]) => void): void;
-		once(event: string, handler: (...args: unknown[]) => void): void;
-		removeListener(event: string, handler: (...args: unknown[]) => void): void;
-	};
-	requestName(name: string, flags: number): Promise<unknown>;
-	setMethodCallHandler(
-		path: string,
-		iface: string,
-		member: string,
-		handler: [MethodImpl, string],
-	): void;
-	sendSignal(path: string, iface: string, member: string, signature: string, args: unknown[]): void;
-	disconnect(): Promise<void>;
-}
-
-interface FakeModule {
-	createClient(options: { busAddress?: string; socket?: string; ReturnLongjs?: boolean }): FakeBus;
-}
-
-const fakeModule = ((dbusNativeModule as { default?: unknown }).default ??
-	dbusNativeModule) as unknown as FakeModule;
-
-// Fixed GetManagedObjects reply in library-native encode shape: object path → interface
-// name → property name → variant [signature, value]. Exercises the real MM
-// `a{oa{sa{sv}}}` nesting plus a 64-bit variant (t = 2^64-1) and a string variant.
-function managedObjectsValue(): unknown {
-	return [
-		[
-			'/org/freedesktop/ModemManager1/Modem/0',
-			[
-				[
-					'org.freedesktop.ModemManager1.Modem',
-					[
-						['SupportedCapabilities', ['t', UINT64_MAX.toString()]],
-						['SignalQuality', ['u', 87]],
-						['DeviceIdentifier', ['s', 'fake-device-0']],
-					],
-				],
-			],
-		],
-	];
-}
-
-export interface FakeService {
-	readonly busName: string;
-	emitTick(seq: bigint): void;
-	stop(): Promise<void>;
-}
-
-export interface FakeServiceOptions {
-	readonly busAddress?: string;
-	readonly socket?: string;
-}
-
-export async function startFakeService(options: FakeServiceOptions): Promise<FakeService> {
-	const clientOptions: { busAddress?: string; socket?: string; ReturnLongjs?: boolean } = {
-		ReturnLongjs: true,
-	};
-	if (options.socket !== undefined) {
-		clientOptions.socket = options.socket;
-	} else if (options.busAddress !== undefined) {
-		clientOptions.busAddress = options.busAddress;
-	}
-
-	const bus = fakeModule.createClient(clientOptions);
-
-	await new Promise<void>((resolve, reject) => {
-		const onConnect = (): void => {
-			bus.connection.removeListener('error', onError);
-			resolve();
-		};
-		const onError = (error: unknown): void => {
-			bus.connection.removeListener('connect', onConnect);
-			reject(error instanceof Error ? error : new Error(String(error)));
-		};
-		bus.connection.once('connect', onConnect);
-		bus.connection.once('error', onError);
-	});
-
-	// After connect, swallow late socket errors so a killed bus (reconnect test) does not
-	// surface an unhandled EventEmitter 'error' from this helper's dead connection.
-	bus.connection.on('error', () => undefined);
-
-	// A reconnect/drop test kills the bus and ABANDONS this fake (stopping it would itself
-	// write to the closed stream). Any reply the library still owes — e.g. a SlowPing whose
-	// delay has not elapsed — would then be written to that dead stream when its timer
-	// fires, throwing "Can't write a message to a closed stream" ASYNCHRONOUSLY, seconds
-	// later, inside whatever unrelated test happens to be running. Track the reply timers
-	// and cancel them the instant the connection stream ends, so a dead fake never writes.
-	const pendingReplyTimers = new Set<ReturnType<typeof setTimeout>>();
-	const clearPendingReplies = (): void => {
-		for (const timer of pendingReplyTimers) {
-			clearTimeout(timer);
-		}
-		pendingReplyTimers.clear();
-	};
-	bus.connection.on('end', clearPendingReplies);
-
-	const define = (member: string, impl: MethodImpl, resultSignature: string): void => {
-		bus.setMethodCallHandler(FAKE_PATH, FAKE_IFACE, member, [impl, resultSignature]);
-	};
-
-	define('Ping', () => 'pong', 's');
-	// The library awaits a Promise returned by a handler, so this replies after a delay —
-	// used to prove a late reply still resolves the caller's method call. The timer is
-	// tracked so a bus drop before it fires cancels the owed reply instead of writing it
-	// to a closed stream.
-	define(
-		'SlowPing',
-		(delayMs) =>
-			new Promise((resolve) => {
-				const timer = setTimeout(() => {
-					pendingReplyTimers.delete(timer);
-					resolve('pong');
-				}, Number(delayMs));
-				pendingReplyTimers.add(timer);
-			}),
-		's',
-	);
-	define('GetManagedObjects', () => managedObjectsValue(), 'a{oa{sa{sv}}}');
-	define('GetInt64', () => INT64_MAX.toString(), 'x');
-	define('GetUint64', () => UINT64_MAX.toString(), 't');
-	// Echo re-marshals the received Long — an exact 64-bit round-trip through the daemon.
-	define('EchoInt64', (value) => value, 'x');
-	define('EchoUint64', (value) => value, 't');
-	// Describe reports the received value's exact decimal string, judging the transport's
-	// encode without re-encoding anything.
-	define('DescribeInt64', (value) => String(value), 's');
-	define('DescribeUint64', (value) => String(value), 's');
-
-	await bus.requestName(FAKE_BUS_NAME, 0);
-
-	return {
-		busName: FAKE_BUS_NAME,
-		emitTick(seq: bigint): void {
-			bus.sendSignal(FAKE_PATH, FAKE_IFACE, TICK_MEMBER, 't', [seq.toString()]);
-		},
-		async stop(): Promise<void> {
-			clearPendingReplies();
-			await bus.disconnect().catch(() => undefined);
-		},
-	};
-}