@ceralive/modem-control 1.0.0 → 1.1.0

package/src/ports/forbidden-surface.test.ts

@@ -1,241 +0,0 @@
-// Guard: no port interface may ever declare a bearer / connect method.
-//
-// The single most safety-critical constraint in the package (Must-NOT-Have: "no MM
-// Simple.Connect / CreateBearer / Bearer.Connect calls ever"). Interfaces are
-// erased at runtime, so the enforcement is a source scan: every port `.ts` file is
-// parsed with the TypeScript compiler API and each DECLARED member of an interface,
-// type literal, or class is checked for a name that is `connect`, `simpleConnect`,
-// or contains "bearer". Adding such a member to any port fails this test — and CI.
-//
-// The detector walks the real AST rather than the source text, so it catches shapes
-// a naive regex cannot: method signatures, property signatures typed as function
-// types, get/set accessors, optional members, and quoted or computed string-literal
-// member names (`'connect'()`, `['connect']()`) all resolve to their true name. It
-// only ever inspects member NAMES on those three declaration kinds — never string
-// literal values, value-position object-literal keys, comments, local variables, or
-// call expressions — so prose mentions of "bearer" and value keys never trip it.
-
-import { expect, test } from 'bun:test';
-import { readdirSync } from 'node:fs';
-import { join } from 'node:path';
-import * as ts from 'typescript';
-
-const portsDir = import.meta.dir;
-
-function isForbiddenMethodName(name: string): boolean {
-	const lower = name.toLowerCase();
-	return lower === 'connect' || lower === 'simpleconnect' || lower.includes('bearer');
-}
-
-/**
- * Resolve a declared member's name node to its static string name, or `undefined`
- * when the name is not statically knowable (e.g. a computed `[Symbol.iterator]` or a
- * computed reference to a non-literal identifier). Plain identifiers, private names,
- * string / numeric literals, and computed names wrapping a string / numeric literal
- * (`['connect']`) all resolve to their real text.
- */
-function resolveMemberName(name: ts.Node): string | undefined {
-	if (ts.isIdentifier(name) || ts.isPrivateIdentifier(name)) {
-		return name.text;
-	}
-	if (ts.isStringLiteralLike(name) || ts.isNumericLiteral(name)) {
-		return name.text;
-	}
-	if (ts.isComputedPropertyName(name)) {
-		const { expression } = name;
-		if (ts.isStringLiteralLike(expression) || ts.isNumericLiteral(expression)) {
-			return expression.text;
-		}
-	}
-	return undefined;
-}
-
-/**
- * Every DECLARED member name of an interface, type literal, or class in `source`,
- * parsed via the TypeScript compiler API. Value-position object-literal keys, string
- * literal values, comments, local variables, and call expressions are all excluded —
- * only the port's actual type surface is inspected. Method signatures, property
- * signatures (including arrow-typed properties), get/set accessors, optional members,
- * and quoted / computed string-literal member names are all resolved to their name.
- */
-function declaredMemberNames(source: string): string[] {
-	const sourceFile = ts.createSourceFile(
-		'port.ts',
-		source,
-		ts.ScriptTarget.Latest,
-		/* setParentNodes */ true,
-	);
-	const names: string[] = [];
-
-	const collectMembers = (members: readonly (ts.TypeElement | ts.ClassElement)[]): void => {
-		for (const member of members) {
-			if (member.name === undefined) {
-				continue;
-			}
-			const resolved = resolveMemberName(member.name);
-			if (resolved !== undefined) {
-				names.push(resolved);
-			}
-		}
-	};
-
-	const visit = (node: ts.Node): void => {
-		if (
-			ts.isInterfaceDeclaration(node) ||
-			ts.isClassDeclaration(node) ||
-			ts.isClassExpression(node) ||
-			ts.isTypeLiteralNode(node)
-		) {
-			collectMembers(node.members);
-		}
-		ts.forEachChild(node, visit);
-	};
-
-	visit(sourceFile);
-	return names;
-}
-
-// The retired regex detector — kept ONLY so the differential test below can prove,
-// by running it, that the AST rebuild is a strict improvement (it caught just one of
-// the seven forbidden shapes). Not used by any real-port scan; do not reintroduce.
-function stripComments(source: string): string {
-	return source.replace(/\/\*[\s\S]*?\*\//g, '').replace(/\/\/[^\n]*/g, '');
-}
-
-function legacyRegexMemberNames(source: string): string[] {
-	const names: string[] = [];
-	const methodDecl = /(?:^|\n)\s*([a-zA-Z_$][\w$]*)\s*[<(]/g;
-	let match = methodDecl.exec(source);
-	while (match !== null) {
-		const name = match[1];
-		if (name !== undefined) {
-			names.push(name);
-		}
-		match = methodDecl.exec(source);
-	}
-	return names;
-}
-
-function portSourceFiles(): string[] {
-	return readdirSync(portsDir)
-		.filter((file) => file.endsWith('.ts'))
-		.filter((file) => !file.endsWith('.test.ts') && !file.endsWith('.type-test.ts'));
-}
-
-test('no port source declares a bearer / connect method', async () => {
-	for (const file of portSourceFiles()) {
-		const source = await Bun.file(join(portsDir, file)).text();
-		const forbidden = declaredMemberNames(source).filter(isForbiddenMethodName);
-		expect(forbidden, `forbidden member(s) in ${file}: ${forbidden.join(', ')}`).toEqual([]);
-	}
-});
-
-test('the ModemManager port source declares the expected non-bearer mutations', async () => {
-	const source = await Bun.file(join(portsDir, 'modem-manager.ts')).text();
-	const names = declaredMemberNames(source);
-	for (const expected of [
-		'setRadioModes',
-		'setPrimarySimSlot',
-		'sendPin',
-		'sendPuk',
-		'scanNetworks',
-		'inhibit',
-		'uninhibit',
-	]) {
-		expect(names).toContain(expected);
-	}
-});
-
-test('the detector catches every forbidden member shape (self-test)', () => {
-	// Each line is a DISTINCT declaration shape the AST resolver must catch: a plain
-	// method, a computed string-literal method, a quoted string-literal method, an
-	// optional method, a get accessor, a set accessor, and an arrow-typed property.
-	// `setRadioModes` is a legitimate mutation that must pass through unflagged.
-	const rogue = `
-		export interface RogueSurface {
-			connect(): Promise<void>;
-			['simpleConnect'](): void;
-			'createBearer'(): void;
-			bearerReset?(): void;
-			get bearerState(): number;
-			set bearerTarget(value: number);
-			bearerHook: () => Promise<void>;
-			setRadioModes(): Promise<void>;
-		}
-	`;
-	const flagged = declaredMemberNames(rogue).filter(isForbiddenMethodName).sort();
-	expect(flagged).toEqual([
-		'bearerHook',
-		'bearerReset',
-		'bearerState',
-		'bearerTarget',
-		'connect',
-		'createBearer',
-		'simpleConnect',
-	]);
-	// The acceptance bar for the rebuild: at least seven distinct forbidden shapes.
-	expect(flagged.length).toBeGreaterThanOrEqual(7);
-});
-
-test('the detector ignores string values, value-position keys, and non-forbidden members', () => {
-	// Three negative fixtures that must NOT trip the detector:
-	//   1. `reconnectPolicy` — a real interface member whose name merely CONTAINS the
-	//      substring "connect"; the predicate matches "connect" exactly, not as a
-	//      substring, so it must pass (proves the predicate is not overly broad).
-	//   2. `description: '…bearer…'` — a member whose string-literal VALUE contains
-	//      "bearer"; only member NAMES are inspected, never string content.
-	//   3. `bearerConnect: true` — a key in a value-position object literal, not a
-	//      type-level member declaration; the AST never walks object-literal keys.
-	const negative = `
-		interface LegitPort {
-			reconnectPolicy: RetryPolicy;
-			setRadioModes(): Promise<void>;
-			description: 'manages bearer state internally';
-		}
-		const runtimeConfig = {
-			bearerConnect: true,
-			description: 'manages bearer state internally',
-		};
-	`;
-	const members = declaredMemberNames(negative);
-	expect(members).toContain('reconnectPolicy');
-	expect(members).not.toContain('bearerConnect');
-	expect(members.filter(isForbiddenMethodName)).toEqual([]);
-});
-
-test('the AST detector catches member shapes the legacy regex missed (differential)', () => {
-	// The same rogue surface, run through BOTH detectors. The retired regex only ever
-	// matched an identifier immediately followed by `(` or `<` at a line start, so it
-	// caught the single plain method and missed the other six shapes. The AST walk
-	// catches all seven — the strict improvement the rebuild delivers.
-	const rogue = `
-		export interface RogueSurface {
-			connect(): Promise<void>;
-			['simpleConnect'](): void;
-			'createBearer'(): void;
-			bearerReset?(): void;
-			get bearerState(): number;
-			set bearerTarget(value: number);
-			bearerHook: () => Promise<void>;
-		}
-	`;
-	const legacyFlagged = legacyRegexMemberNames(stripComments(rogue))
-		.filter(isForbiddenMethodName)
-		.sort();
-	const astFlagged = declaredMemberNames(rogue).filter(isForbiddenMethodName).sort();
-
-	// The regex caught only the plain method.
-	expect(legacyFlagged).toEqual(['connect']);
-	// The AST catches every shape the regex missed, and then some.
-	for (const missed of [
-		'bearerHook',
-		'bearerReset',
-		'bearerState',
-		'bearerTarget',
-		'createBearer',
-		'simpleConnect',
-	]) {
-		expect(legacyFlagged).not.toContain(missed);
-		expect(astFlagged).toContain(missed);
-	}
-});

package/src/ports/modem-manager.ts

@@ -1,72 +0,0 @@
-// The ModemManager port — radio, SIM, scan, inhibit, and observation.
-//
-// CRITICAL INVARIANT (the single most safety-critical constraint in the package):
-// this port has NO bearer / connection verb. There is no connect, no createBearer,
-// no bearerConnect — MM's Simple.Connect / CreateBearer / Bearer.Connect are NEVER
-// callable through here. NetworkManager is the sole owner of bearers and activation
-// (see README ownership table). `forbidden-surface.test.ts` fails the build if any
-// such method is ever added to this file.
-
-import type { DesiredRadio, EpochMillis, RuntimePath } from '../domain';
-import type { ModemObservationPort } from './observation';
-import type { Receipt } from './receipts';
-
-/** A live handle to one modem — its ModemManager D-Bus object path (per-boot). */
-export type ModemRef = RuntimePath;
-
-/** Outcome of a SIM PIN unlock attempt. */
-export interface SimUnlockResult {
-	readonly outcome: 'unlocked' | 'incorrect-pin' | 'sim-puk-required' | 'unsupported' | 'error';
-	readonly remainingAttempts?: number;
-	readonly reason: string;
-}
-
-/** Outcome of a SIM PUK unblock attempt. */
-export interface SimPukUnlockResult {
-	readonly outcome: 'unlocked' | 'incorrect-puk' | 'permanently-blocked' | 'unsupported' | 'error';
-	readonly remainingAttempts?: number;
-	readonly reason: string;
-}
-
-/** One operator returned by a network scan. */
-export interface ScannedNetwork {
-	/** MCC+MNC operator code. */
-	readonly operatorCode: string;
-	readonly operatorName?: string;
-	readonly availability: 'available' | 'current' | 'forbidden' | 'unknown';
-}
-
-/** Result of a network scan — discriminated, retaining the reason on failure. */
-export type NetworkScanResult =
-	| { readonly ok: true; readonly networks: readonly ScannedNetwork[] }
-	| { readonly ok: false; readonly reason: string };
-
-/** A held inhibition over a modem, released via `uninhibit`. */
-export interface InhibitLease {
-	/** The equipment UID the inhibition is keyed to. */
-	readonly uid: string;
-	readonly acquiredAt: EpochMillis;
-}
-
-/**
- * The ModemManager port — EXTENDS the read-only observation port with the modem
- * mutations MM legitimately owns: radio modes, primary SIM slot, PIN / PUK unlock,
- * network scan, and inhibit / uninhibit. It owns NO bearer / connection lifecycle;
- * bearers and activation belong to `NetworkManagerPort`.
- */
-export interface ModemManagerPort extends ModemObservationPort {
-	/** Set the modem's radio access-technology preference. */
-	setRadioModes(modem: ModemRef, preference: DesiredRadio): Promise<Receipt>;
-	/** Select the primary SIM slot (multi-slot modems only). */
-	setPrimarySimSlot(modem: ModemRef, slotIndex: number): Promise<Receipt>;
-	/** Submit a SIM PIN (exactly-once; read-before-submit is the adapter's job). */
-	sendPin(modem: ModemRef, pin: string): Promise<SimUnlockResult>;
-	/** Submit a SIM PUK plus the new PIN (exactly-once). */
-	sendPuk(modem: ModemRef, puk: string, newPin: string): Promise<SimPukUnlockResult>;
-	/** Scan for visible networks (long-running). */
-	scanNetworks(modem: ModemRef): Promise<NetworkScanResult>;
-	/** Inhibit MM from managing a device (for a maintenance lease), keyed by UID. */
-	inhibit(uid: string): Promise<InhibitLease>;
-	/** Release a previously-taken inhibition. */
-	uninhibit(lease: InhibitLease): Promise<void>;
-}

package/src/ports/network-manager.ts

@@ -1,87 +0,0 @@
-// The NetworkManager port — NM is the SOLE owner of bearers, APN, auth, roaming,
-// autoconnect, and activation (see README ownership table). This port is the ONLY
-// way the controller touches any of those resources; the ModemManager port has no
-// bearer / connection verbs at all.
-
-import type { Brand, EpochMillis } from '../domain';
-import { nonEmptyString } from '../domain';
-import type { Receipt } from './receipts';
-
-/** A NetworkManager connection-profile UUID. */
-export type ConnectionId = Brand<string, 'ConnectionId'>;
-
-/** A kernel network-device interface name (e.g. `wwan0`). */
-export type DeviceIfname = Brand<string, 'DeviceIfname'>;
-
-/** Construct a `ConnectionId` from a non-empty NM connection UUID. */
-export function connectionId(value: string): ConnectionId {
-	return nonEmptyString(value, 'connectionId') as ConnectionId;
-}
-
-/** Construct a `DeviceIfname` from a non-empty interface name. */
-export function deviceIfname(value: string): DeviceIfname {
-	return nonEmptyString(value, 'deviceIfname') as DeviceIfname;
-}
-
-/**
- * A GSM connection profile — NM's `gsm.*` setting group. `password` is SENSITIVE
- * and MUST be redacted in every log / output (see `../redact`). The full nine-field
- * nmcli write parity lands with the concrete adapter (A4.1); this is the port
- * contract that adapter fulfils.
- */
-export interface GsmProfileInput {
-	readonly connectionName: string;
-	/** Concrete APN, or the empty string when `autoConfig` drives it (A4.1). */
-	readonly apn: string;
-	readonly username?: string;
-	/** SENSITIVE — redact everywhere. */
-	readonly password?: string;
-	/** `true` ⇒ `gsm.home-only` (roaming disabled). */
-	readonly homeOnly: boolean;
-	/** `true` ⇒ `gsm.auto-config yes` (Auto-APN); mutually exclusive with creds. */
-	readonly autoConfig: boolean;
-	/** Manual operator selection (`gsm.network-id`); empty unless roaming-pinned. */
-	readonly networkId?: string;
-}
-
-/** A persisted GSM profile as read back from NM, keyed by its connection id. */
-export interface GsmProfile extends GsmProfileInput {
-	readonly connectionId: ConnectionId;
-}
-
-/** A partial update to an existing GSM profile. */
-export type GsmProfilePatch = Partial<GsmProfileInput>;
-
-/**
- * A quiesce lease — a held guarantee that the connection on THIS exact device stays
- * deactivated while a disruptive MM operation runs, then is reactivated on release.
- * Bound to BOTH `connectionId` and `deviceIfname` so it can never quiesce the wrong
- * device (the two-device isolation invariant, A4.1).
- */
-export interface QuiesceLease {
-	readonly connectionId: ConnectionId;
-	readonly deviceIfname: DeviceIfname;
-	readonly acquiredAt: EpochMillis;
-}
-
-/**
- * The NetworkManager port. Activation and deactivation take BOTH the connection id
- * AND the device interface name — never an id alone. This encodes, at the type
- * level, that we address a connection on an EXACT device (`nmcli connection up
- * <uuid> ifname <dev>` / verify-then-`device disconnect <ifname>`); the id-only
- * `nmcli connection down` is structurally impossible to express here (A4.1).
- */
-export interface NetworkManagerPort {
-	createGsmProfile(profile: GsmProfileInput): Promise<GsmProfile>;
-	readGsmProfile(id: ConnectionId): Promise<GsmProfile | undefined>;
-	updateGsmProfile(id: ConnectionId, patch: GsmProfilePatch): Promise<GsmProfile>;
-	deleteGsmProfile(id: ConnectionId): Promise<void>;
-	/** Activate `id` on the EXACT device `ifname`. */
-	activate(id: ConnectionId, ifname: DeviceIfname): Promise<Receipt>;
-	/** Deactivate `id` on the EXACT device `ifname`. */
-	deactivate(id: ConnectionId, ifname: DeviceIfname): Promise<Receipt>;
-	/** Take a quiesce lease over `id` on the EXACT device `ifname`. */
-	acquireQuiesceLease(id: ConnectionId, ifname: DeviceIfname): Promise<QuiesceLease>;
-	/** Release a quiesce lease, reactivating the connection it held down. */
-	releaseQuiesceLease(lease: QuiesceLease): Promise<void>;
-}

package/src/ports/ops.ts

@@ -1,60 +0,0 @@
-// Port-tagged reconcile ops — a planned mutation TAGGED with the port that owns it.
-//
-// The op kinds are DISJOINT by construction: a radio / SIM op (`MmOp`) shares no
-// `kind` with a connection / APN op (`NmOp`). Tagging is therefore type-checked —
-// `{ port: 'nm', op: { kind: 'setRadioModes', … } }` does NOT compile, because a
-// radio op is not assignable to the NM arm. That mis-tag is a COMPILE-TIME error
-// (see `ops.type-test.ts` for the `@ts-expect-error` proofs). This is the ownership
-// matrix (README) enforced by the type system, not merely by convention.
-
-import type { DesiredRadio } from '../domain';
-import type {
-	ConnectionId,
-	DeviceIfname,
-	GsmProfileInput,
-	GsmProfilePatch,
-} from './network-manager';
-
-/** Radio + SIM ops — owned SOLELY by the ModemManager port. */
-export type MmOp =
-	| { readonly kind: 'setRadioModes'; readonly preference: DesiredRadio }
-	| { readonly kind: 'setPrimarySimSlot'; readonly slotIndex: number };
-
-/** Connection / APN / activation ops — owned SOLELY by the NetworkManager port. */
-export type NmOp =
-	| { readonly kind: 'createGsmProfile'; readonly profile: GsmProfileInput }
-	| {
-			readonly kind: 'updateGsmProfile';
-			readonly connectionId: ConnectionId;
-			readonly patch: GsmProfilePatch;
-	  }
-	| {
-			readonly kind: 'activate';
-			readonly connectionId: ConnectionId;
-			readonly deviceIfname: DeviceIfname;
-	  }
-	| {
-			readonly kind: 'deactivate';
-			readonly connectionId: ConnectionId;
-			readonly deviceIfname: DeviceIfname;
-	  };
-
-/**
- * A planned op tagged with its owning port. The two arms are disjoint on BOTH the
- * `port` discriminant AND the op `kind` space, so the planner cannot emit — and a
- * reviewer cannot write — a radio op under the NM port, or a connection op under
- * the MM port.
- */
-export type PortTaggedOp =
-	| { readonly port: 'mm'; readonly op: MmOp }
-	| { readonly port: 'nm'; readonly op: NmOp };
-
-/** Tag an MM op for the ModemManager port. Only an `MmOp` is accepted. */
-export function mmOp(op: MmOp): PortTaggedOp {
-	return { port: 'mm', op };
-}
-
-/** Tag an NM op for the NetworkManager port. Only an `NmOp` is accepted. */
-export function nmOp(op: NmOp): PortTaggedOp {
-	return { port: 'nm', op };
-}

package/src/ports/ops.type-test.ts

@@ -1,39 +0,0 @@
-// COMPILE-TIME negative tests for port-tagged op disjointness.
-//
-// This file is type-checked by `tsc --noEmit` (it is inside the workspace
-// `include`) but is NOT a runtime test — it is never imported and every binding is
-// a type assertion. Each `@ts-expect-error` asserts the type system REJECTS a
-// mis-tagged op; if disjointness ever regresses (e.g. an `NmOp` gains a radio
-// `kind`), the directive becomes UNUSED and `tsc` fails the build. That failure IS
-// the ownership matrix enforced at the type level.
-
-import { connectionId, deviceIfname } from './network-manager';
-import type { MmOp, NmOp, PortTaggedOp } from './ops';
-
-const radioOp: MmOp = { kind: 'setRadioModes', preference: { preferenceOrdered: ['5gnr'] } };
-const slotOp: MmOp = { kind: 'setPrimarySimSlot', slotIndex: 2 };
-const activateOp: NmOp = {
-	kind: 'activate',
-	connectionId: connectionId('11111111-1111-1111-1111-111111111111'),
-	deviceIfname: deviceIfname('wwan0'),
-};
-
-// Positive controls — correctly-tagged ops MUST type-check.
-const goodMm: PortTaggedOp = { port: 'mm', op: radioOp };
-const goodNm: PortTaggedOp = { port: 'nm', op: activateOp };
-
-// @ts-expect-error a radio op tagged for the NM port must NOT compile.
-const badRadioOnNm: PortTaggedOp = { port: 'nm', op: radioOp };
-// @ts-expect-error a SIM op tagged for the NM port must NOT compile.
-const badSlotOnNm: PortTaggedOp = { port: 'nm', op: slotOp };
-// @ts-expect-error an activate op tagged for the MM port must NOT compile.
-const badActivateOnMm: PortTaggedOp = { port: 'mm', op: activateOp };
-
-// Exported so the bindings are "used" and lint stays quiet; never imported at runtime.
-export const PORT_TAGGED_OP_TYPE_CASES: readonly PortTaggedOp[] = [
-	goodMm,
-	goodNm,
-	badRadioOnNm,
-	badSlotOnNm,
-	badActivateOnMm,
-];

package/src/ports/receipts.test.ts

@@ -1,153 +0,0 @@
-// Receipt taxonomy — every status reachable, "prefer 5G on 4G-only" is surfaced as
-// `unsupported` (never silently downgraded), and every receipt carries a reason.
-
-import { expect, test } from 'bun:test';
-import {
-	type DesiredCellularPolicy,
-	defaultCellularPolicy,
-	imeiEquipmentId,
-	type PolicyBindingKey,
-	policyBindingKey,
-	runtimePath,
-} from '../domain';
-import { connectionId, deviceIfname } from './network-manager';
-import type { PolicyDimension, Receipt } from './receipts';
-import { type AppliedCellularState, type ModemCapabilities, planReconcile } from './reconcile';
-
-const BOUND_TO: PolicyBindingKey = policyBindingKey({
-	equipmentId: imeiEquipmentId('490154203237518'),
-	runtimePath: runtimePath('/org/freedesktop/ModemManager1/Modem/0'),
-});
-
-const FOUR_G_ONLY: ModemCapabilities = {
-	supportedRats: new Set(['lte', 'umts', 'gsm']),
-	simSlotCount: 1,
-	supportsAutoApn: true,
-};
-
-const FIVE_G_DUAL_SLOT: ModemCapabilities = {
-	supportedRats: new Set(['5gnr', 'lte', 'umts', 'gsm']),
-	simSlotCount: 2,
-	supportsAutoApn: true,
-};
-
-const ADDRESSABLE = {
-	connectionId: connectionId('conn-uuid'),
-	deviceIfname: deviceIfname('wwan0'),
-	appliedApn: 'auto',
-	appliedRoaming: false,
-	appliedRadioPreference: ['5gnr', 'lte', 'umts', 'gsm'],
-} as const;
-
-function receiptFor(receipts: readonly Receipt[], dimension: PolicyDimension): Receipt {
-	const found = receipts.find((entry) => entry.dimension === dimension);
-	if (found === undefined) {
-		throw new Error(`no receipt for dimension ${dimension}`);
-	}
-	return found;
-}
-
-test('prefer 5G on a 4G-only modem is unsupported with a reason, never silently applied', () => {
-	const policy = defaultCellularPolicy(BOUND_TO);
-	const applied: AppliedCellularState = { nmActivation: 'disconnected', hasProfile: false };
-	const { ops, receipts } = planReconcile(applied, policy, FOUR_G_ONLY);
-
-	const radio = receiptFor(receipts, 'radio');
-	expect(radio.status).toBe('unsupported');
-	expect(radio.reason).toContain('5gnr');
-	expect(radio.reason.length).toBeGreaterThan(0);
-	expect(ops.filter((op) => op.port === 'mm' && op.op.kind === 'setRadioModes')).toEqual([]);
-});
-
-test('all four receipt statuses are reachable', () => {
-	const policy = defaultCellularPolicy(BOUND_TO);
-
-	const applied: AppliedCellularState = {
-		nmActivation: 'activated',
-		hasProfile: true,
-		...ADDRESSABLE,
-	};
-	expect(
-		receiptFor(planReconcile(applied, policy, FIVE_G_DUAL_SLOT).receipts, 'enabled').status,
-	).toBe('applied');
-
-	const pending: AppliedCellularState = {
-		nmActivation: 'disconnected',
-		hasProfile: true,
-		...ADDRESSABLE,
-	};
-	expect(
-		receiptFor(planReconcile(pending, policy, FIVE_G_DUAL_SLOT).receipts, 'enabled').status,
-	).toBe('pending');
-
-	const unsupported: AppliedCellularState = { nmActivation: 'disconnected', hasProfile: false };
-	expect(receiptFor(planReconcile(unsupported, policy, FOUR_G_ONLY).receipts, 'radio').status).toBe(
-		'unsupported',
-	);
-
-	const failed: AppliedCellularState = {
-		nmActivation: 'failed',
-		hasProfile: true,
-		activationFailureReason: 'no-signal',
-		...ADDRESSABLE,
-	};
-	const failedReceipt = receiptFor(
-		planReconcile(failed, policy, FIVE_G_DUAL_SLOT).receipts,
-		'enabled',
-	);
-	expect(failedReceipt.status).toBe('failed');
-	expect(failedReceipt.reason).toContain('no-signal');
-});
-
-test('every dimension yields a receipt and every receipt has a non-empty reason', () => {
-	const policy = defaultCellularPolicy(BOUND_TO);
-	const { receipts } = planReconcile(
-		{ nmActivation: 'disconnected', hasProfile: false },
-		policy,
-		FOUR_G_ONLY,
-	);
-	for (const entry of receipts) {
-		expect(entry.reason.length).toBeGreaterThan(0);
-	}
-	const expectedDimensions: PolicyDimension[] = [
-		'connection',
-		'enabled',
-		'radio',
-		'recovery',
-		'roaming',
-		'simSlot',
-		'usage',
-	];
-	expect(receipts.map((entry) => entry.dimension).sort()).toEqual(expectedDimensions.sort());
-});
-
-test('primary SIM slot selection is unsupported on a single-slot modem', () => {
-	const policy: DesiredCellularPolicy = { ...defaultCellularPolicy(BOUND_TO), simSlot: 2 };
-	const { receipts } = planReconcile(
-		{ nmActivation: 'disconnected', hasProfile: false },
-		policy,
-		FOUR_G_ONLY,
-	);
-	expect(receiptFor(receipts, 'simSlot').status).toBe('unsupported');
-});
-
-test('an out-of-range primary SIM slot is a failed receipt', () => {
-	const policy: DesiredCellularPolicy = { ...defaultCellularPolicy(BOUND_TO), simSlot: 5 };
-	const { receipts } = planReconcile(
-		{ nmActivation: 'disconnected', hasProfile: false },
-		policy,
-		FIVE_G_DUAL_SLOT,
-	);
-	expect(receiptFor(receipts, 'simSlot').status).toBe('failed');
-});
-
-test('Auto-APN is unsupported when the stack cannot auto-configure', () => {
-	const policy = defaultCellularPolicy(BOUND_TO);
-	const caps: ModemCapabilities = { ...FIVE_G_DUAL_SLOT, supportsAutoApn: false };
-	const { receipts } = planReconcile(
-		{ nmActivation: 'disconnected', hasProfile: false },
-		policy,
-		caps,
-	);
-	expect(receiptFor(receipts, 'connection').status).toBe('unsupported');
-});