@ceralive/modem-control 0.1.0

package/src/transport/dbus-native.ts

@@ -0,0 +1,85 @@
+// Internal typed facade over the `@httptoolkit/dbus-native` CommonJS module.
+//
+// The library ships a `types.d.ts` that covers only a fraction of the surface we use
+// (no `invoke`, `addMatch`, `connection`, or `messageType`), so we describe the exact
+// parts we depend on here and cast once, at this single boundary. NOTHING in this file
+// is re-exported from the package's public entry (`../index.ts`): the raw library types
+// stay quarantined behind the transport seam. See `./README.md` for why this library
+// was chosen and the documented fallback (`@particle/dbus-next`).
+
+import * as dbusNativeModule from '@httptoolkit/dbus-native';
+
+// A D-Bus message as the library marshals/unmarshals it.
+export interface RawMessage {
+	type?: number;
+	path?: string;
+	interface?: string;
+	member?: string;
+	destination?: string;
+	sender?: string;
+	signature?: string;
+	body?: unknown[];
+	errorName?: string;
+	serial?: number;
+	replySerial?: number;
+}
+
+// The context (`this`) the library binds when it invokes a reply callback. `signature`
+// is the reply's own D-Bus signature — the promisified `invoke` drops this and collapses
+// multi-value bodies, which is why we always call `invoke` with an explicit callback.
+export interface ReplyContext {
+	signature?: string;
+	message?: RawMessage;
+}
+
+export type ReplyCallback = (this: ReplyContext, error: unknown, ...body: unknown[]) => void;
+
+// The underlying stream/EventEmitter. We drive reconnect off its lifecycle events and
+// assert on `listenerCount` in the leak test, so both are part of the facade.
+export interface RawConnection {
+	on(event: string, handler: (...args: unknown[]) => void): void;
+	once(event: string, handler: (...args: unknown[]) => void): void;
+	removeListener(event: string, handler: (...args: unknown[]) => void): void;
+	removeAllListeners(event?: string): void;
+	listenerCount(event: string): number;
+	end(): void;
+}
+
+export interface RawBus {
+	connection: RawConnection;
+	invoke(message: RawMessage, callback: ReplyCallback): void;
+	addMatch(rule: string): Promise<unknown>;
+	removeMatch(rule: string): Promise<unknown>;
+	disconnect(): Promise<void>;
+}
+
+export interface CreateClientOptions {
+	busAddress?: string;
+	socket?: string;
+	// Return 64-bit `x`/`t` fields as Long.js objects instead of lossy numbers. The
+	// transport always sets this so `codec.decodeBody` can convert them to `bigint`.
+	ReturnLongjs?: boolean;
+	direct?: boolean;
+}
+
+export interface DbusNativeModule {
+	createClient(options: CreateClientOptions): RawBus;
+	messageType: {
+		invalid: number;
+		methodCall: number;
+		methodReturn: number;
+		error: number;
+		signal: number;
+	};
+}
+
+// Bun/Node CJS interop: `import *` yields the module namespace whose `default` (when
+// present) is `module.exports`. One cast confines the untyped surface to this line.
+const resolved = ((dbusNativeModule as { default?: unknown }).default ??
+	dbusNativeModule) as unknown as DbusNativeModule;
+
+export const messageType = resolved.messageType;
+
+export function createClient(options: CreateClientOptions): RawBus {
+	return resolved.createClient(options);
+}

package/src/transport/errors.ts

@@ -0,0 +1,74 @@
+// Typed error taxonomy for the D-Bus transport seam.
+//
+// Wire data crossing the transport boundary is never compile-time checked, so every
+// failure mode that a caller (or the A3.x D-Bus backend) must branch on is a real,
+// exported class — never a bare thrown string or a generic Error.
+
+export class TransportError extends Error {
+	constructor(message: string, options?: ErrorOptions) {
+		super(message, options);
+		this.name = 'TransportError';
+	}
+}
+
+// A D-Bus signature contained a type this transport refuses to handle. The only such
+// type today is `h` (UNIX_FD / file-descriptor passing): the transport never marshals
+// or unmarshals a file descriptor, so encountering `h` in an outgoing call signature,
+// a reply signature, a signal signature, or nested inside a variant throws this rather
+// than silently dropping or coercing the descriptor.
+export class UnsupportedSignatureError extends TransportError {
+	readonly signature: string;
+	readonly unsupportedType: string;
+
+	constructor(signature: string, unsupportedType: string) {
+		super(
+			`D-Bus signature "${signature}" contains unsupported type "${unsupportedType}": ` +
+				'UNIX_FD / file-descriptor passing is not supported by this transport',
+		);
+		this.name = 'UnsupportedSignatureError';
+		this.signature = signature;
+		this.unsupportedType = unsupportedType;
+	}
+}
+
+// A 64-bit field (`x` INT64 / `t` UINT64) was handed a JavaScript `number` on encode.
+// A `number` cannot carry the full 64-bit range without silent precision loss above
+// 2^53, so the transport requires a `bigint` for these fields and refuses `number`
+// loudly instead of corrupting the value on the wire.
+export class BigIntRequiredError extends TransportError {
+	readonly signature: string;
+	readonly received: string;
+
+	constructor(signature: string, received: unknown) {
+		super(
+			`D-Bus 64-bit field "${signature}" requires a bigint, received ${typeof received} ` +
+				`(${String(received)}): a JS number silently loses precision above 2^53`,
+		);
+		this.name = 'BigIntRequiredError';
+		this.signature = signature;
+		this.received = typeof received;
+	}
+}
+
+// A 64-bit value was outside the range representable by its signed/unsigned field.
+export class SixtyFourBitRangeError extends TransportError {
+	readonly signature: string;
+	readonly value: bigint;
+
+	constructor(signature: string, value: bigint) {
+		super(`Value ${value} is out of range for 64-bit D-Bus field "${signature}"`);
+		this.name = 'SixtyFourBitRangeError';
+		this.signature = signature;
+		this.value = value;
+	}
+}
+
+// The bus connection dropped (or was never established) while a method call was
+// in-flight or pending. The call rejects with this instead of hanging forever; the
+// transport's own reconnect loop keeps running independently.
+export class DisconnectedError extends TransportError {
+	constructor(message = 'D-Bus connection is not established') {
+		super(message);
+		this.name = 'DisconnectedError';
+	}
+}

package/src/transport/index.ts

@@ -0,0 +1,30 @@
+// Public surface of the D-Bus transport seam.
+//
+// This is the ONLY module the rest of `@ceralive/modem-control` (and the A3.x D-Bus
+// backend) imports from `./transport`. Every type here is the transport's own — no
+// `@httptoolkit/dbus-native` type is re-exported, so swapping the underlying library
+// (documented fallback: `@particle/dbus-next`) is invisible to callers. See README.md.
+
+export {
+	BigIntRequiredError,
+	DisconnectedError,
+	SixtyFourBitRangeError,
+	TransportError,
+	UnsupportedSignatureError,
+} from './errors';
+export { createDbusTransport } from './transport';
+export type {
+	DbusTransport,
+	DbusTransportOptions,
+	DbusValue,
+	DbusVariant,
+	MethodCall,
+	MethodReply,
+	ReconnectOptions,
+	SignalEvent,
+	SignalListener,
+	SignalSpec,
+	Subscription,
+	TransportEvent,
+} from './types';
+export { isVariant, variant } from './types';

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

@@ -0,0 +1,50 @@
+// 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 { 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 () => {
+	const productionModules = ['transport.ts', 'codec.ts', 'signature.ts', 'errors.ts', 'types.ts'];
+	for (const moduleName of productionModules) {
+		const source = await Bun.file(join(transportDir, moduleName)).text();
+		expect(source).not.toContain(LIBRARY_IMPORT);
+	}
+});
+
+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

@@ -0,0 +1,173 @@
+// 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/signature.ts

@@ -0,0 +1,110 @@
+// 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

@@ -0,0 +1,143 @@
+// 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);
+
+	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.
+	define(
+		'SlowPing',
+		(delayMs) => new Promise((resolve) => setTimeout(() => resolve('pong'), Number(delayMs))),
+		'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> {
+			await bus.disconnect().catch(() => undefined);
+		},
+	};
+}