@ceralive/modem-control 1.0.0 → 1.2.0

package/src/backend/mapping.ts

@@ -1,160 +0,0 @@
-// Pure mapping: a decoded ModemManager object tree → a `CellularSnapshot`.
-//
-// A3.1 is lifecycle-only. This mapper is DELIBERATELY conservative: it captures
-// identity, presence, source health, radio power, and MM state — the facts the
-// observer needs to order and reconcile modems — but leaves the richer 3GPP
-// registration + access-technology set as `unknown`/empty. Faithful registration and
-// cell-info normalisation are A3.2 (identity ladder) and A3.3 (Signal.Setup / cell
-// info); mapping them here would either be a guess or trip the domain guards. The
-// snapshot this produces is always guard-valid by construction.
-
-import {
-	type CellularSnapshot,
-	imeiEquipmentId,
-	type MmState,
-	subscriptionId as makeSubscriptionId,
-	type RadioPower,
-	runtimePath,
-	type SubscriptionId,
-} from '../domain';
-import { MODEM_IFACE, MODEM3GPP_IFACE, SIM_IFACE } from './constants';
-import {
-	type DecodedManagedObjects,
-	findInterface,
-	followObjectPath,
-	numberProp,
-	pathsWithInterface,
-	stringProp,
-} from './managed-objects';
-
-/** The dimensions of a mapped modem, WITHOUT a revision (the observer stamps that). */
-export type MappedModem = Omit<CellularSnapshot, 'revision'>;
-
-/** MMModemState (`Modem.State`, signed) → the domain `MmState`. */
-function mapMmState(state: number | undefined): MmState {
-	switch (state) {
-		case -1:
-			return 'failed';
-		case 1:
-			return 'initializing';
-		case 2:
-			return 'locked';
-		case 3:
-			return 'disabled';
-		case 4:
-			return 'disabling';
-		case 5:
-			return 'enabling';
-		case 6:
-			return 'enabled';
-		case 7:
-			return 'searching';
-		case 8:
-			return 'registered';
-		case 9:
-			return 'disconnecting';
-		case 10:
-			return 'connecting';
-		case 11:
-			return 'connected';
-		default:
-			return 'unknown';
-	}
-}
-
-/** MMModemPowerState (`Modem.PowerState`) → the domain `RadioPower`. */
-function mapRadioPower(power: number | undefined): RadioPower {
-	switch (power) {
-		case 1:
-			return 'off';
-		case 2:
-			return 'low';
-		case 3:
-			return 'on';
-		default:
-			return 'unknown';
-	}
-}
-
-/** Locked / failed modems keep the radio off; every other state we cannot see as
- *  off (the guards forbid an active MM state with the radio off), so an unknown
- *  power reading is treated as `on` when the modem is clearly on the air. */
-function reconcilePower(power: RadioPower, state: MmState): RadioPower {
-	const onTheAir =
-		state === 'enabled' ||
-		state === 'searching' ||
-		state === 'registered' ||
-		state === 'connecting' ||
-		state === 'connected' ||
-		state === 'disconnecting';
-	if (onTheAir && (power === 'unknown' || power === 'off')) {
-		return 'on';
-	}
-	return power;
-}
-
-/** Read a modem's subscription id (ICCID) from its active SIM object, if any. */
-function readSubscriptionId(
-	tree: DecodedManagedObjects,
-	modemPath: string,
-): SubscriptionId | undefined {
-	const modem = findInterface(tree, modemPath, MODEM_IFACE);
-	const sim = followObjectPath(tree, modem, 'Sim', SIM_IFACE);
-	const iccid = stringProp(sim, 'SimIdentifier');
-	return iccid !== undefined && iccid.length > 0 ? makeSubscriptionId(iccid) : undefined;
-}
-
-/** Map ONE modem object to its dimensions. The modem must expose `Modem`. */
-export function mapModem(tree: DecodedManagedObjects, modemPath: string): MappedModem {
-	const modem = findInterface(tree, modemPath, MODEM_IFACE);
-	const modem3gpp = findInterface(tree, modemPath, MODEM3GPP_IFACE);
-
-	const equipment = stringProp(modem, 'EquipmentIdentifier') ?? stringProp(modem3gpp, 'Imei') ?? '';
-	const mmState = mapMmState(numberProp(modem, 'State'));
-	const radioPower = reconcilePower(mapRadioPower(numberProp(modem, 'PowerState')), mmState);
-	const sub = readSubscriptionId(tree, modemPath);
-
-	return {
-		identity: {
-			equipmentId: imeiEquipmentId(equipment),
-			runtimePath: runtimePath(modemPath),
-			...(sub !== undefined ? { subscriptionId: sub } : {}),
-		},
-		presence: 'present',
-		sourceHealth: 'live',
-		simSlots: [],
-		radioPower,
-		mmState,
-		// Conservative: 3GPP registration + RAT set are A3.3's job (see file header).
-		registration: { status: 'unknown', activeRats: new Set() },
-		nmActivation: 'unavailable',
-		dataInterface: { present: false },
-		reconcileStatus: 'pending',
-		recoveryState: { stage: 'idle', attempts: 0 },
-	};
-}
-
-/** Every modem path in the tree (objects exposing the `Modem` interface), in order. */
-export function modemPaths(tree: DecodedManagedObjects): string[] {
-	return pathsWithInterface(tree, MODEM_IFACE);
-}
-
-/** A stable fingerprint of a mapped modem's meaningful dimensions (ignores revision
- *  and source health), used to suppress redundant revision bumps on identical reads. */
-export function fingerprint(mapped: MappedModem): string {
-	return JSON.stringify({
-		id: mapped.identity.equipmentId,
-		sub: mapped.identity.subscriptionId ?? null,
-		path: mapped.identity.runtimePath,
-		presence: mapped.presence,
-		radioPower: mapped.radioPower,
-		mmState: mapped.mmState,
-		registration: {
-			status: mapped.registration.status,
-			rats: [...mapped.registration.activeRats].sort(),
-		},
-		nmActivation: mapped.nmActivation,
-		dataInterface: mapped.dataInterface,
-		reconcileStatus: mapped.reconcileStatus,
-	});
-}

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']);
-	});
-});