@ceralive/modem-control 0.2.0 → 1.1.0

package/src/backend/mm-backend.ts

@@ -1,191 +0,0 @@
-// MmDbusBackend — the real D-Bus `ModemManagerPort`, composed from the A3 parts.
-//
-// It fulfils the whole port: the read side delegates to A3.1's epoch-scoped observer;
-// the mutations run through `MmMutations` (each serialized on the shared per-modem
-// `ModemActor`, keyed on A3.2's STABLE key so serialization survives replug); the
-// Signal.Setup lifecycle is driven off the observer's `onEpochRefresh` hook; and the
-// read-only enrichment (firmware revision, eSIM, signal cadence, normalized cell info)
-// is assembled on demand. One transport is shared by all of them.
-//
-// The `onEpochRefresh` hook is the single integration seam: on every current-epoch
-// authoritative snapshot it (1) rebuilds the live path → stable-key map (so a mutation
-// keys the actor by the durable identity, not the transient path) and (2) re-drives
-// Signal.Setup for that epoch — applying to new modems, re-applying to survivors after
-// an owner change, and never firing for a superseded epoch.
-
-import type { DesiredRadio } from '../domain';
-import { epochMillis } from '../domain';
-import type {
-	InhibitLease,
-	ModemManagerPort,
-	ModemRef,
-	NetworkScanResult,
-	ObservationList,
-	ObservationListener,
-	Receipt,
-	SimPukUnlockResult,
-	SimUnlockResult,
-	Unsubscribe,
-} from '../ports';
-import type { DbusTransport } from '../transport';
-import { type CellReading, normalizeCellInfo } from './cell-info';
-import { MM_BUS_NAME, MODEM_IFACE } from './constants';
-import { buildEnrichment, type ModemEnrichment } from './enrichment';
-import { modemIdentityFactsFromTree, resolveModemIdentities } from './identity-ladder';
-import { type DecodedProps, fetchManagedObjects, pathsWithInterface } from './managed-objects';
-import { MmMutations } from './mm-mutations';
-import { ModemActor, type QuiesceHook } from './modem-actor';
-import { createMmDbusObserver, type EpochRefreshEvent, type MmDbusObserver } from './observer';
-import { type SignalCadence, SignalSetupManager } from './signal-setup';
-
-export interface MmDbusBackendOptions {
-	readonly transport: DbusTransport;
-	readonly destination?: string;
-	/** NM quiesce hook for disruptive mode/slot changes (A3.3 default: no-op). */
-	readonly quiesce?: QuiesceHook;
-	/** Signal.Setup reporting interval in seconds. */
-	readonly signalIntervalSeconds?: number;
-	readonly scanTimeoutMs?: number;
-	readonly now?: () => number;
-}
-
-/** The real D-Bus ModemManager backend: observation + mutations + Signal.Setup. */
-export class MmDbusBackend implements ModemManagerPort {
-	readonly #transport: DbusTransport;
-	readonly #destination: string;
-	readonly #now: () => number;
-	readonly #observer: MmDbusObserver;
-	readonly #mutations: MmMutations;
-	readonly #signalSetup: SignalSetupManager;
-	// Live modem path → durable stable key; rebuilt on every epoch snapshot.
-	readonly #stableKeyByPath = new Map<string, string>();
-
-	constructor(options: MmDbusBackendOptions) {
-		this.#transport = options.transport;
-		this.#destination = options.destination ?? MM_BUS_NAME;
-		this.#now = options.now ?? Date.now;
-		const actor = new ModemActor(options.quiesce);
-		this.#signalSetup = new SignalSetupManager({
-			transport: this.#transport,
-			destination: this.#destination,
-			...(options.signalIntervalSeconds !== undefined
-				? { intervalSeconds: options.signalIntervalSeconds }
-				: {}),
-		});
-		this.#observer = createMmDbusObserver({
-			transport: this.#transport,
-			destination: this.#destination,
-			onEpochRefresh: (event) => this.#onEpochRefresh(event),
-		});
-		this.#mutations = new MmMutations({
-			transport: this.#transport,
-			actor,
-			destination: this.#destination,
-			resolveStableKey: (modem) => this.#stableKeyByPath.get(modem) ?? modem,
-			...(options.scanTimeoutMs !== undefined ? { scanTimeoutMs: options.scanTimeoutMs } : {}),
-			now: this.#now,
-		});
-	}
-
-	// ── observation (delegated to the A3.1 observer) ────────────────────────────────
-
-	start(): Promise<ObservationList> {
-		return this.#observer.start();
-	}
-
-	observe(listener: ObservationListener): Unsubscribe {
-		return this.#observer.observe(listener);
-	}
-
-	stop(): Promise<void> {
-		return this.#observer.stop();
-	}
-
-	// ── mutations (serialized per modem through the shared actor) ────────────────────
-
-	setRadioModes(modem: ModemRef, preference: DesiredRadio): Promise<Receipt> {
-		return this.#mutations.setRadioModes(modem, preference);
-	}
-
-	setPrimarySimSlot(modem: ModemRef, slotIndex: number): Promise<Receipt> {
-		return this.#mutations.setPrimarySimSlot(modem, slotIndex);
-	}
-
-	sendPin(modem: ModemRef, pin: string): Promise<SimUnlockResult> {
-		return this.#mutations.sendPin(modem, pin);
-	}
-
-	sendPuk(modem: ModemRef, puk: string, newPin: string): Promise<SimPukUnlockResult> {
-		return this.#mutations.sendPuk(modem, puk, newPin);
-	}
-
-	scanNetworks(modem: ModemRef): Promise<NetworkScanResult> {
-		return this.#mutations.scanNetworks(modem);
-	}
-
-	inhibit(uid: string): Promise<InhibitLease> {
-		return this.#mutations.inhibit(uid);
-	}
-
-	uninhibit(lease: InhibitLease): Promise<void> {
-		return this.#mutations.uninhibit(lease);
-	}
-
-	// ── enrichment (additive, read-only, never gating) ──────────────────────────────
-
-	/** Whether periodic signal reporting is configured for a modem (Signal.Setup). */
-	signalCadence(modem: ModemRef): SignalCadence {
-		return this.#signalSetup.cadenceFor(modem);
-	}
-
-	/** Read the normalized visible-cell list for a modem via `Modem.GetCellInfo`. */
-	async readCellInfo(modem: ModemRef): Promise<readonly CellReading[]> {
-		const provenance = { source: modem, observedAt: epochMillis(this.#now()) };
-		try {
-			const reply = await this.#transport.callMethod({
-				destination: this.#destination,
-				path: modem,
-				interface: MODEM_IFACE,
-				member: 'GetCellInfo',
-			});
-			const cells = Array.isArray(reply.body[0])
-				? (reply.body[0] as unknown as DecodedProps[])
-				: [];
-			return normalizeCellInfo(cells, provenance);
-		} catch {
-			return [];
-		}
-	}
-
-	/** Assemble the full read-only enrichment (revision, eSIM, cadence, cell info). */
-	async readEnrichment(modem: ModemRef): Promise<ModemEnrichment> {
-		const [tree, cellInfo] = await Promise.all([
-			fetchManagedObjects(this.#transport, this.#destination),
-			this.readCellInfo(modem),
-		]);
-		return buildEnrichment(tree, modem, this.#signalSetup.cadenceFor(modem), cellInfo);
-	}
-
-	#onEpochRefresh(event: EpochRefreshEvent): void {
-		this.#refreshStableKeys(event);
-		this.#signalSetup.applyForEpoch(event.epoch, event.tree);
-	}
-
-	#refreshStableKeys(event: EpochRefreshEvent): void {
-		const paths = pathsWithInterface(event.tree, MODEM_IFACE);
-		const facts = paths.map((path) => modemIdentityFactsFromTree(event.tree, path));
-		const resolved = resolveModemIdentities(facts);
-		this.#stableKeyByPath.clear();
-		paths.forEach((path, index) => {
-			const entry = resolved[index];
-			if (entry !== undefined) {
-				this.#stableKeyByPath.set(path, entry.stableKey);
-			}
-		});
-	}
-}
-
-/** Construct the real D-Bus ModemManager backend over an A2.4 transport. */
-export function createMmDbusBackend(options: MmDbusBackendOptions): MmDbusBackend {
-	return new MmDbusBackend(options);
-}

package/src/backend/mm-mutations.ts

@@ -1,228 +0,0 @@
-// The ModemManager mutations — the disruptive-and-SIM half of `ModemManagerPort`.
-//
-// Every disruptive op runs through the shared per-modem `ModemActor` (serialized on
-// the STABLE key, so two ops on one modem never interleave and a replug keeps the
-// same queue). Mode and slot changes additionally run QUIESCED (NM briefly stands
-// down first, via the actor's quiesce hook). PIN / PUK / scan serialize too but do
-// NOT quiesce — they don't touch the bearer. NONE of these methods can reach a bearer
-// or connect verb: the port has none, and the fake's tripwire proves it at test time.
-
-import type { DesiredRadio, RadioAccessTechnology } from '../domain';
-import { epochMillis } from '../domain';
-import type {
-	InhibitLease,
-	ModemRef,
-	NetworkScanResult,
-	Receipt,
-	ScannedNetwork,
-	SimPukUnlockResult,
-	SimUnlockResult,
-} from '../ports';
-import { receipt } from '../ports';
-import type { DbusTransport } from '../transport';
-import {
-	MM_BUS_NAME,
-	MM_MANAGER_IFACE,
-	MM_ROOT_PATH,
-	MODEM_IFACE,
-	MODEM3GPP_IFACE,
-} from './constants';
-import {
-	type DecodedProps,
-	fetchManagedObjects,
-	findInterface,
-	numberProp,
-	propValue,
-	stringProp,
-} from './managed-objects';
-import type { ModemActor } from './modem-actor';
-import { sendSimPin, sendSimPuk } from './sim-unlock';
-
-/** MMModemMode bit per RAT family (2G/3G/4G/5G). */
-const MODE_BIT: Record<RadioAccessTechnology, number> = { gsm: 2, umts: 4, lte: 8, '5gnr': 16 };
-
-/** MMModem3gppNetworkAvailability → the port's availability. */
-const AVAILABILITY: Record<number, ScannedNetwork['availability']> = {
-	0: 'unknown',
-	1: 'available',
-	2: 'current',
-	3: 'forbidden',
-};
-
-/** A network scan can take a long time — MM's own default is not enough. */
-const DEFAULT_SCAN_TIMEOUT_MS = 300_000;
-
-export interface MmMutationsDeps {
-	readonly transport: DbusTransport;
-	readonly actor: ModemActor;
-	readonly destination?: string;
-	/** Map a live modem path to its stable actor key (survives replug). */
-	readonly resolveStableKey: (modem: ModemRef) => string;
-	readonly scanTimeoutMs?: number;
-	readonly now?: () => number;
-}
-
-/** The disruptive + SIM mutations of `ModemManagerPort`, serialized per modem. */
-export class MmMutations {
-	readonly #transport: DbusTransport;
-	readonly #actor: ModemActor;
-	readonly #destination: string;
-	readonly #resolveStableKey: (modem: ModemRef) => string;
-	readonly #scanTimeoutMs: number;
-	readonly #now: () => number;
-
-	constructor(deps: MmMutationsDeps) {
-		this.#transport = deps.transport;
-		this.#actor = deps.actor;
-		this.#destination = deps.destination ?? MM_BUS_NAME;
-		this.#resolveStableKey = deps.resolveStableKey;
-		this.#scanTimeoutMs = deps.scanTimeoutMs ?? DEFAULT_SCAN_TIMEOUT_MS;
-		this.#now = deps.now ?? Date.now;
-	}
-
-	setRadioModes(modem: ModemRef, preference: DesiredRadio): Promise<Receipt> {
-		const allowed = maskOf(preference.allowedSet ?? new Set(preference.preferenceOrdered));
-		const preferred = preference.preferenceOrdered[0];
-		const preferredMask = preferred !== undefined ? MODE_BIT[preferred] : 0;
-		if (allowed === 0) {
-			return Promise.resolve(receipt('radio', 'failed', 'no radio modes were requested'));
-		}
-		return this.#actor.runQuiesced({ stableKey: this.#resolveStableKey(modem) }, async () => {
-			try {
-				await this.#transport.callMethod({
-					destination: this.#destination,
-					path: modem,
-					interface: MODEM_IFACE,
-					member: 'SetCurrentModes',
-					signature: '(uu)',
-					args: [[allowed, preferredMask]],
-				});
-				return receipt('radio', 'applied', 'radio mode preference applied');
-			} catch (error) {
-				return receipt('radio', 'failed', `SetCurrentModes failed: ${describe(error)}`);
-			}
-		});
-	}
-
-	async setPrimarySimSlot(modem: ModemRef, slotIndex: number): Promise<Receipt> {
-		const slots = await this.#readSlotCount(modem);
-		if (slots === undefined) {
-			return receipt('simSlot', 'failed', 'could not read the modem SIM-slot list');
-		}
-		if (slots <= 1) {
-			return receipt('simSlot', 'unsupported', 'single-slot modem has no primary slot to select');
-		}
-		if (slotIndex < 1 || slotIndex > slots) {
-			return receipt('simSlot', 'failed', `slot ${slotIndex} is out of range (1..${slots})`);
-		}
-		return this.#actor.runQuiesced({ stableKey: this.#resolveStableKey(modem) }, async () => {
-			try {
-				await this.#transport.callMethod({
-					destination: this.#destination,
-					path: modem,
-					interface: MODEM_IFACE,
-					member: 'SetPrimarySimSlot',
-					signature: 'u',
-					args: [slotIndex],
-				});
-				return receipt('simSlot', 'applied', `primary SIM slot set to ${slotIndex}`);
-			} catch (error) {
-				return receipt('simSlot', 'failed', `SetPrimarySimSlot failed: ${describe(error)}`);
-			}
-		});
-	}
-
-	sendPin(modem: ModemRef, pin: string): Promise<SimUnlockResult> {
-		return this.#actor.run(this.#resolveStableKey(modem), () =>
-			sendSimPin(this.#transport, this.#destination, modem, pin),
-		);
-	}
-
-	sendPuk(modem: ModemRef, puk: string, newPin: string): Promise<SimPukUnlockResult> {
-		return this.#actor.run(this.#resolveStableKey(modem), () =>
-			sendSimPuk(this.#transport, this.#destination, modem, puk, newPin),
-		);
-	}
-
-	scanNetworks(modem: ModemRef): Promise<NetworkScanResult> {
-		return this.#actor.run(this.#resolveStableKey(modem), async () => {
-			try {
-				const reply = await this.#transport.callMethod({
-					destination: this.#destination,
-					path: modem,
-					interface: MODEM3GPP_IFACE,
-					member: 'Scan',
-					timeoutMs: this.#scanTimeoutMs,
-				});
-				return { ok: true, networks: parseScan(reply.body[0]) };
-			} catch (error) {
-				return { ok: false, reason: `network scan failed: ${describe(error)}` };
-			}
-		});
-	}
-
-	async inhibit(uid: string): Promise<InhibitLease> {
-		await this.#inhibitDevice(uid, true);
-		return { uid, acquiredAt: epochMillis(this.#now()) };
-	}
-
-	async uninhibit(lease: InhibitLease): Promise<void> {
-		await this.#inhibitDevice(lease.uid, false);
-	}
-
-	#inhibitDevice(uid: string, inhibit: boolean): Promise<unknown> {
-		return this.#transport.callMethod({
-			destination: this.#destination,
-			path: MM_ROOT_PATH,
-			interface: MM_MANAGER_IFACE,
-			member: 'InhibitDevice',
-			signature: 'sb',
-			args: [uid, inhibit],
-		});
-	}
-
-	async #readSlotCount(modem: ModemRef): Promise<number | undefined> {
-		try {
-			const tree = await fetchManagedObjects(this.#transport, this.#destination);
-			const slots = propValue(findInterface(tree, modem, MODEM_IFACE), 'SimSlots');
-			return Array.isArray(slots) ? slots.length : undefined;
-		} catch {
-			return undefined;
-		}
-	}
-}
-
-/** OR of the MMModemMode bits for a set of RATs. */
-function maskOf(rats: ReadonlySet<RadioAccessTechnology>): number {
-	let mask = 0;
-	for (const rat of rats) {
-		mask |= MODE_BIT[rat];
-	}
-	return mask;
-}
-
-/** Parse a `Modem3gpp.Scan` reply (`aa{sv}` → dicts) into scanned networks. */
-function parseScan(value: unknown): readonly ScannedNetwork[] {
-	if (!Array.isArray(value)) {
-		return [];
-	}
-	const networks: ScannedNetwork[] = [];
-	for (const entry of value as DecodedProps[]) {
-		const operatorCode = stringProp(entry, 'operator-code');
-		if (operatorCode === undefined) {
-			continue;
-		}
-		const name = stringProp(entry, 'operator-long') ?? stringProp(entry, 'operator-short');
-		const availability = AVAILABILITY[numberProp(entry, 'status') ?? 0] ?? 'unknown';
-		networks.push({
-			operatorCode,
-			...(name !== undefined ? { operatorName: name } : {}),
-			availability,
-		});
-	}
-	return networks;
-}
-
-function describe(error: unknown): string {
-	return error instanceof Error ? error.message : String(error);
-}

package/src/backend/modem-actor.test.ts

@@ -1,95 +0,0 @@
-// The shared per-modem disruptive actor — pure, deterministic serialization proof.
-//
-// Same stable key ⇒ strict serialization (no interleave); different keys ⇒
-// independent (overlap); a rejected task never stalls the queue; and a quiesce lease
-// is always acquired around and released after a runQuiesced task, even on throw.
-
-import { describe, expect, test } from 'bun:test';
-import {
-	ModemActor,
-	type QuiesceHook,
-	type QuiesceLeaseHandle,
-	type QuiesceTarget,
-} from './modem-actor';
-
-const sleep = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));
-
-const worker = (log: string[], name: string) => async (): Promise<void> => {
-	log.push(`${name}:start`);
-	await sleep(15);
-	log.push(`${name}:end`);
-};
-
-describe('ModemActor — per-key serialization', () => {
-	test('two tasks on the SAME key run strictly in order, never interleaved', async () => {
-		const actor = new ModemActor();
-		const log: string[] = [];
-		await Promise.all([
-			actor.run('slot:a', worker(log, 'a')),
-			actor.run('slot:a', worker(log, 'b')),
-		]);
-		expect(log).toEqual(['a:start', 'a:end', 'b:start', 'b:end']);
-	});
-
-	test('tasks on DIFFERENT keys run independently (they overlap)', async () => {
-		const actor = new ModemActor();
-		const log: string[] = [];
-		await Promise.all([
-			actor.run('slot:a', worker(log, 'a')),
-			actor.run('slot:b', worker(log, 'b')),
-		]);
-		const lastStart = Math.max(log.indexOf('a:start'), log.indexOf('b:start'));
-		const firstEnd = Math.min(log.indexOf('a:end'), log.indexOf('b:end'));
-		// Both started before either finished → the two keys did not serialize.
-		expect(lastStart).toBeLessThan(firstEnd);
-	});
-
-	test('a rejected task does not stall the queue', async () => {
-		const actor = new ModemActor();
-		await expect(actor.run('slot:a', () => Promise.reject(new Error('boom')))).rejects.toThrow(
-			'boom',
-		);
-		await expect(actor.run('slot:a', () => Promise.resolve('ok'))).resolves.toBe('ok');
-	});
-
-	test('an idle key drops its queue entry (bounded map)', async () => {
-		const actor = new ModemActor();
-		await actor.run('slot:a', () => Promise.resolve(1));
-		await sleep(0);
-		expect(actor.activeKeyCount).toBe(0);
-	});
-});
-
-describe('ModemActor — quiesce lease', () => {
-	function recordingHook(events: string[]): QuiesceHook {
-		return {
-			acquire(target: QuiesceTarget): Promise<QuiesceLeaseHandle> {
-				events.push(`acquire:${target.stableKey}`);
-				return Promise.resolve({
-					release(): Promise<void> {
-						events.push('release');
-						return Promise.resolve();
-					},
-				});
-			},
-		};
-	}
-
-	test('runQuiesced acquires before, releases after the task', async () => {
-		const events: string[] = [];
-		const actor = new ModemActor(recordingHook(events));
-		await actor.runQuiesced({ stableKey: 'slot:a' }, async () => {
-			events.push('task');
-		});
-		expect(events).toEqual(['acquire:slot:a', 'task', 'release']);
-	});
-
-	test('the lease is released even when the task throws', async () => {
-		const events: string[] = [];
-		const actor = new ModemActor(recordingHook(events));
-		await expect(
-			actor.runQuiesced({ stableKey: 'slot:a' }, () => Promise.reject(new Error('x'))),
-		).rejects.toThrow('x');
-		expect(events).toEqual(['acquire:slot:a', 'release']);
-	});
-});

package/src/backend/modem-actor.ts

@@ -1,112 +0,0 @@
-// The shared per-modem disruptive-operation actor.
-//
-// EVERY disruptive modem operation funnels through ONE serialization queue PER
-// MODEM: radio-mode changes and primary-slot changes (A3.3), the recovery ladder
-// (A3.4), and USB-mode / AT transitions (A4.2) all route through the SAME actor so
-// two disruptive ops on ONE modem can never interleave. Ops on DIFFERENT modems run
-// independently — each modem owns its own queue.
-//
-// The queue is keyed on the STABLE identity key (A3.2's `stableKey`), NOT the
-// transient D-Bus object path. A modem that unplugs and replugs into the same slot
-// resolves to the same stable key, so serialization survives the replug (the path
-// changed, the queue did not).
-//
-// Mode and slot changes additionally coordinate with NetworkManager through the
-// `QuiesceHook` — before a disruptive change NM briefly deactivates the connection so
-// it cannot race MM's own re-activation, then reactivates it on release. In A3.3 the
-// hook is a NO-OP stub with the exact lease shape A4.1's real nmcli adapter will fill
-// in (`NetworkManagerPort.acquireQuiesceLease`).
-
-import type { ConnectionId, DeviceIfname } from '../ports';
-
-/** What a quiesce lease is taken over — the modem, and (once A4.1 knows them) its
- *  NM connection + device. In A3.3 only `stableKey` is populated. */
-export interface QuiesceTarget {
-	readonly stableKey: string;
-	readonly connectionId?: ConnectionId;
-	readonly deviceIfname?: DeviceIfname;
-}
-
-/** A held quiesce lease — released (reactivating the connection) when the op ends. */
-export interface QuiesceLeaseHandle {
-	release(): Promise<void>;
-}
-
-/**
- * The NM-quiesce coordination hook the actor calls around a disruptive mode/slot
- * change. A4.1 wires the real `nmcli` lease (verify-active → `device disconnect` →
- * hold → reactivate); A3.3 ships `NO_OP_QUIESCE`, whose call site + shape are the
- * exact seam A4.1 fills in.
- */
-export interface QuiesceHook {
-	acquire(target: QuiesceTarget): Promise<QuiesceLeaseHandle>;
-}
-
-const NO_OP_LEASE: QuiesceLeaseHandle = {
-	release(): Promise<void> {
-		return Promise.resolve();
-	},
-};
-
-/** The A3.3 default quiesce hook — acquires nothing, releases nothing. */
-export const NO_OP_QUIESCE: QuiesceHook = {
-	acquire(): Promise<QuiesceLeaseHandle> {
-		return Promise.resolve(NO_OP_LEASE);
-	},
-};
-
-/**
- * A per-modem serialized actor. `run` serializes a task behind every prior task for
- * the same stable key; `runQuiesced` additionally holds an NM quiesce lease for the
- * task's duration. Different stable keys never block one another.
- */
-export class ModemActor {
-	readonly #quiesce: QuiesceHook;
-	// Tail of each modem's queue — a promise that settles when the last-enqueued task
-	// for that key finishes (errors swallowed so the chain never breaks).
-	readonly #tails = new Map<string, Promise<void>>();
-
-	constructor(quiesce: QuiesceHook = NO_OP_QUIESCE) {
-		this.#quiesce = quiesce;
-	}
-
-	/** Run `task` serialized behind every prior task for `stableKey`. */
-	run<T>(stableKey: string, task: () => Promise<T>): Promise<T> {
-		const prior = this.#tails.get(stableKey) ?? Promise.resolve();
-		// `then(task, task)` runs `task` whether the prior task resolved OR rejected,
-		// so one failure never stalls the queue.
-		const result = prior.then(task, task);
-		const settled = result.then(
-			() => undefined,
-			() => undefined,
-		);
-		this.#tails.set(stableKey, settled);
-		// Drop the entry once this task was the last one, to bound the map.
-		void settled.then(() => {
-			if (this.#tails.get(stableKey) === settled) {
-				this.#tails.delete(stableKey);
-			}
-		});
-		return result;
-	}
-
-	/**
-	 * Run `task` serialized for `target.stableKey` with an NM quiesce lease held for
-	 * its whole duration — the lease is always released, even if `task` throws.
-	 */
-	runQuiesced<T>(target: QuiesceTarget, task: () => Promise<T>): Promise<T> {
-		return this.run(target.stableKey, async () => {
-			const lease = await this.#quiesce.acquire(target);
-			try {
-				return await task();
-			} finally {
-				await lease.release();
-			}
-		});
-	}
-
-	/** Number of modems with a live queue — exposed for leak / idle assertions. */
-	get activeKeyCount(): number {
-		return this.#tails.size;
-	}
-}