@ceralive/modem-control 1.0.0 → 1.2.0

package/src/backend/usage/policy-store.ts

@@ -1,216 +0,0 @@
-// Durable persistence for the operator's data-usage POLICY (cycle day + advisory
-// threshold), the write-side counterpart of `store.ts`'s counter persistence.
-//
-// WHY THIS IS LOCAL STATE AND NOT A MODEM WRITE. ModemManager has no data-usage
-// API at all. Verified against a live MM 1.24.2 (`mmcli --help-all`, plus a D-Bus
-// introspection of a real `…/ModemManager1/Modem/N`): the only `Setup`/threshold
-// surface on the whole object is `Modem.Signal.Setup` /
-// `Modem.Signal.SetupThresholds`, whose keys are `rssi-threshold` and
-// `error-rate-threshold` — RADIO QUALITY, not bytes. The only byte counters MM
-// offers are the per-BEARER read-only `Stats` (`rx-bytes`/`tx-bytes`), which
-// reset with every connection and therefore cannot carry a monthly cycle.
-//
-// That is exactly why the sampler in this directory counts `/proc/net/dev`
-// instead, and why `ports/README.md`'s ownership table records usage policy as
-// LOCAL-CONTROLLER owned. So the write path is a local, versioned, fail-soft
-// file — never a D-Bus mutation. (`Modem.Signal.Setup` is additionally forbidden
-// outright by the shadow-mode mutation-freedom contract; nothing here goes near
-// it.)
-//
-// The two hard guarantees are the SAME ones `store.ts` makes, and deliberately
-// implemented the same way so the pair can be read side by side:
-//   - MODE 0600 via temp → chmod → atomic rename, regardless of umask.
-//   - FAIL-SOFT ON CORRUPTION: an unparseable/incompatible file logs METADATA
-//     ONLY (byte length + a classification reason, never the content) and is
-//     replaced by a fresh empty 0600 file rather than throwing.
-//
-// A policy row carries ONLY an opaque slot id and two numbers. By construction
-// there is no subscriber or device identity here (no ICCID/IMSI/IMEI, no
-// operator, no model) — the same no-PII property the counter store holds.
-
-import { chmod, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
-import { dirname } from 'node:path';
-import type { DesiredUsage } from '../../domain';
-
-/** The current on-disk schema version. Bump when the persisted shape changes. */
-export const USAGE_POLICY_SCHEMA_VERSION = 1;
-
-/** One slot's persisted usage policy. Both fields are absent when unset. */
-export interface PersistedUsagePolicySlot {
-	readonly logicalSlotId: string;
-	/** Day of month (1–31) the cycle resets; UTC, month-length clamped (A4.3). */
-	readonly cycleDay?: number;
-	/** Advisory threshold in bytes; crossing it raises an advisory, never gates. */
-	readonly thresholdBytes?: number;
-}
-
-/** The full persisted policy document. */
-export interface PersistedUsagePolicy {
-	readonly schemaVersion: typeof USAGE_POLICY_SCHEMA_VERSION;
-	readonly savedAtMs: number;
-	readonly slots: readonly PersistedUsagePolicySlot[];
-}
-
-/** A metadata-only log event. Corruption NEVER carries the raw file content. */
-export type UsagePolicyLogEvent = {
-	readonly kind: 'corrupt-policy';
-	readonly bytes: number;
-	readonly reason: string;
-};
-
-/** Sink for policy-store log events. Defaults to a metadata-only `console.warn`. */
-export type UsagePolicyLogger = (event: UsagePolicyLogEvent) => void;
-
-/** The persistence seam `setUsagePolicy` drives. */
-export interface UsagePolicyStore {
-	/** Load persisted policy; recreate a fresh 0600 file if absent or corrupt. */
-	load(nowMs: number): Promise<PersistedUsagePolicy>;
-	/** Atomically write policy with mode 0600 (temp → chmod → rename). */
-	save(state: PersistedUsagePolicy): Promise<void>;
-}
-
-export interface UsagePolicyFileStoreOptions {
-	readonly path: string;
-	readonly logger?: UsagePolicyLogger;
-}
-
-function defaultLogger(event: UsagePolicyLogEvent): void {
-	console.warn(`[usage-policy] ${event.kind}: bytes=${event.bytes} reason=${event.reason}`);
-}
-
-function freshState(nowMs: number): PersistedUsagePolicy {
-	return { schemaVersion: USAGE_POLICY_SCHEMA_VERSION, savedAtMs: nowMs, slots: [] };
-}
-
-/** A schema violation naming only the offending FIELD (never file content). */
-class PolicySchemaError extends Error {
-	constructor(field: string) {
-		super(`schema-mismatch: ${field}`);
-	}
-}
-
-/** True for a value that is a legal cycle day (integer 1–31). */
-export function isValidCycleDay(value: unknown): value is number {
-	return typeof value === 'number' && Number.isInteger(value) && value >= 1 && value <= 31;
-}
-
-/** True for a value that is a legal advisory threshold (non-negative integer). */
-export function isValidThresholdBytes(value: unknown): value is number {
-	return typeof value === 'number' && Number.isInteger(value) && value >= 0;
-}
-
-function validateSlot(raw: unknown): PersistedUsagePolicySlot {
-	if (typeof raw !== 'object' || raw === null) {
-		throw new PolicySchemaError('slot');
-	}
-	const slot = raw as Record<string, unknown>;
-	if (typeof slot.logicalSlotId !== 'string' || slot.logicalSlotId.length === 0) {
-		throw new PolicySchemaError('logicalSlotId');
-	}
-	if (slot.cycleDay !== undefined && !isValidCycleDay(slot.cycleDay)) {
-		throw new PolicySchemaError('cycleDay');
-	}
-	if (slot.thresholdBytes !== undefined && !isValidThresholdBytes(slot.thresholdBytes)) {
-		throw new PolicySchemaError('thresholdBytes');
-	}
-	return {
-		logicalSlotId: slot.logicalSlotId,
-		...(slot.cycleDay !== undefined ? { cycleDay: slot.cycleDay } : {}),
-		...(slot.thresholdBytes !== undefined ? { thresholdBytes: slot.thresholdBytes } : {}),
-	};
-}
-
-/** Parse + validate the document. Throws `PolicySchemaError` (metadata-only). */
-function validate(raw: unknown): PersistedUsagePolicy {
-	if (typeof raw !== 'object' || raw === null) {
-		throw new PolicySchemaError('document');
-	}
-	const doc = raw as Record<string, unknown>;
-	if (doc.schemaVersion !== USAGE_POLICY_SCHEMA_VERSION) {
-		throw new PolicySchemaError('schemaVersion');
-	}
-	if (typeof doc.savedAtMs !== 'number' || !Number.isFinite(doc.savedAtMs)) {
-		throw new PolicySchemaError('savedAtMs');
-	}
-	if (!Array.isArray(doc.slots)) {
-		throw new PolicySchemaError('slots');
-	}
-	return {
-		schemaVersion: USAGE_POLICY_SCHEMA_VERSION,
-		savedAtMs: doc.savedAtMs,
-		slots: doc.slots.map(validateSlot),
-	};
-}
-
-/** Classify a load failure into a metadata-only reason string (no raw content). */
-function classifyFailure(error: unknown): string {
-	if (error instanceof PolicySchemaError) {
-		return error.message;
-	}
-	if (error instanceof SyntaxError) {
-		const offset = /position (\d+)/.exec(error.message)?.[1];
-		return offset !== undefined ? `invalid-json at offset ${offset}` : 'invalid-json';
-	}
-	return 'unreadable';
-}
-
-/**
- * Read one slot's policy out of a loaded document.
- *
- * This is the read half the composition root uses to build each slot's
- * `UsageObservation.usage`, so the persisted file — not an in-memory guess — is
- * what the sampler accounts against. An unknown slot answers `{}`, i.e. "no
- * policy set", which is exactly what `defaultCellularPolicy` starts from.
- */
-export function selectUsagePolicy(
-	state: PersistedUsagePolicy,
-	logicalSlotId: string,
-): DesiredUsage {
-	const slot = state.slots.find((entry) => entry.logicalSlotId === logicalSlotId);
-	if (slot === undefined) {
-		return {};
-	}
-	return {
-		...(slot.cycleDay !== undefined ? { cycleDay: slot.cycleDay } : {}),
-		...(slot.thresholdBytes !== undefined ? { thresholdBytes: slot.thresholdBytes } : {}),
-	};
-}
-
-export function createUsagePolicyFileStore(options: UsagePolicyFileStoreOptions): UsagePolicyStore {
-	const logger = options.logger ?? defaultLogger;
-	const { path } = options;
-
-	async function writeAtomic(state: PersistedUsagePolicy): Promise<void> {
-		await mkdir(dirname(path), { recursive: true });
-		const tmp = `${path}.tmp`;
-		await writeFile(tmp, JSON.stringify(state));
-		// chmod AFTER the write (not an open flag) so mode is 0600 regardless of umask.
-		await chmod(tmp, 0o600);
-		await rename(tmp, path);
-	}
-
-	return {
-		async load(nowMs: number): Promise<PersistedUsagePolicy> {
-			let text: string;
-			try {
-				text = await readFile(path, 'utf8');
-			} catch {
-				// Absent (or unreadable) → start empty; the first save lays down a 0600 file.
-				return freshState(nowMs);
-			}
-			try {
-				return validate(JSON.parse(text));
-			} catch (error) {
-				logger({
-					kind: 'corrupt-policy',
-					bytes: Buffer.byteLength(text, 'utf8'),
-					reason: classifyFailure(error),
-				});
-				const fresh = freshState(nowMs);
-				await writeAtomic(fresh);
-				return fresh;
-			}
-		},
-		save: writeAtomic,
-	};
-}

package/src/backend/usage/policy-write.test.ts

@@ -1,198 +0,0 @@
-// `setUsagePolicy` contract — tri-state merge, typed refusals, persist-before-apply
-// ordering, and the live-sampler cycle-reset rule.
-
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import type { DesiredUsage } from '../../domain';
-import {
-	createUsagePolicyFileStore,
-	type PersistedUsagePolicy,
-	selectUsagePolicy,
-	USAGE_POLICY_SCHEMA_VERSION,
-	type UsagePolicyStore,
-} from './policy-store';
-import { getUsagePolicy, setUsagePolicy, type UsagePolicyTarget } from './policy-write';
-
-let dir: string;
-let path: string;
-let store: UsagePolicyStore;
-
-const SLOT = 'slot-a';
-const NOW = 1_700_000_000_000;
-
-beforeEach(async () => {
-	dir = await mkdtemp(join(tmpdir(), 'usage-policy-write-'));
-	path = join(dir, 'policy.json');
-	store = createUsagePolicyFileStore({ path });
-});
-
-afterEach(async () => {
-	await rm(dir, { recursive: true, force: true });
-});
-
-function recordingSampler(): UsagePolicyTarget & {
-	calls: { slot: string; usage: DesiredUsage; at?: number }[];
-} {
-	const calls: { slot: string; usage: DesiredUsage; at?: number }[] = [];
-	return {
-		calls,
-		applyUsagePolicy(slot, usage, at) {
-			calls.push({ slot, usage, ...(at !== undefined ? { at } : {}) });
-			return { cycleStartMs: NOW, cycleReset: true };
-		},
-	};
-}
-
-describe('setUsagePolicy — persistence', () => {
-	test('writes a policy that reads back through getUsagePolicy', async () => {
-		const result = await setUsagePolicy(
-			{ store, now: () => NOW },
-			{ logicalSlotId: SLOT, cycleDay: 15, thresholdBytes: 5_000_000_000 },
-		);
-
-		expect(result.status).toBe('applied');
-		expect(await getUsagePolicy({ store }, SLOT)).toEqual({
-			cycleDay: 15,
-			thresholdBytes: 5_000_000_000,
-		});
-	});
-
-	test('an OMITTED field is left alone — a threshold write never drops the cycle day', async () => {
-		await setUsagePolicy({ store }, { logicalSlotId: SLOT, cycleDay: 9 });
-
-		await setUsagePolicy({ store }, { logicalSlotId: SLOT, thresholdBytes: 100 });
-
-		expect(await getUsagePolicy({ store }, SLOT)).toEqual({ cycleDay: 9, thresholdBytes: 100 });
-	});
-
-	test('an explicit null CLEARS that field and leaves the sibling standing', async () => {
-		await setUsagePolicy({ store }, { logicalSlotId: SLOT, cycleDay: 9, thresholdBytes: 100 });
-
-		await setUsagePolicy({ store }, { logicalSlotId: SLOT, cycleDay: null });
-
-		expect(await getUsagePolicy({ store }, SLOT)).toEqual({ thresholdBytes: 100 });
-	});
-
-	test('clearing BOTH fields removes the row rather than storing an empty one', async () => {
-		await setUsagePolicy({ store }, { logicalSlotId: SLOT, cycleDay: 9, thresholdBytes: 100 });
-
-		await setUsagePolicy({ store }, { logicalSlotId: SLOT, cycleDay: null, thresholdBytes: null });
-
-		expect((await store.load(NOW)).slots).toEqual([]);
-	});
-
-	test('a write to one slot never disturbs another', async () => {
-		await setUsagePolicy({ store }, { logicalSlotId: 'slot-a', cycleDay: 1 });
-		await setUsagePolicy({ store }, { logicalSlotId: 'slot-b', cycleDay: 20 });
-
-		await setUsagePolicy({ store }, { logicalSlotId: 'slot-a', cycleDay: 5 });
-
-		const state = await store.load(NOW);
-		expect(selectUsagePolicy(state, 'slot-a')).toEqual({ cycleDay: 5 });
-		expect(selectUsagePolicy(state, 'slot-b')).toEqual({ cycleDay: 20 });
-		expect(state.slots).toHaveLength(2);
-	});
-});
-
-describe('setUsagePolicy — typed refusals', () => {
-	test.each([
-		[{ logicalSlotId: '', cycleDay: 1 }, 'invalid-slot-id'],
-		[{ logicalSlotId: SLOT, cycleDay: 0 }, 'invalid-cycle-day'],
-		[{ logicalSlotId: SLOT, cycleDay: 32 }, 'invalid-cycle-day'],
-		[{ logicalSlotId: SLOT, cycleDay: 3.5 }, 'invalid-cycle-day'],
-		[{ logicalSlotId: SLOT, thresholdBytes: -1 }, 'invalid-threshold-bytes'],
-		[{ logicalSlotId: SLOT, thresholdBytes: 1.5 }, 'invalid-threshold-bytes'],
-	] as const)('%p is rejected as %s and writes nothing', async (request, reason) => {
-		const result = await setUsagePolicy({ store }, request);
-
-		expect(result).toMatchObject({ status: 'rejected', reason });
-		expect((await store.load(NOW)).slots).toEqual([]);
-	});
-
-	test('a refusal is returned, never thrown', async () => {
-		expect(setUsagePolicy({ store }, { logicalSlotId: SLOT, cycleDay: 99 })).resolves.toMatchObject(
-			{ status: 'rejected' },
-		);
-	});
-
-	test('a store that throws yields a typed failure and never reaches the sampler', async () => {
-		const sampler = recordingSampler();
-		const broken: UsagePolicyStore = {
-			load: async () => ({
-				schemaVersion: USAGE_POLICY_SCHEMA_VERSION,
-				savedAtMs: NOW,
-				slots: [],
-			}),
-			save: async () => {
-				throw new Error('disk full');
-			},
-		};
-
-		const result = await setUsagePolicy(
-			{ store: broken, sampler },
-			{ logicalSlotId: SLOT, cycleDay: 3 },
-		);
-
-		expect(result).toMatchObject({ status: 'failed', reason: 'disk full' });
-		expect(sampler.calls).toEqual([]);
-	});
-});
-
-describe('setUsagePolicy — live apply', () => {
-	test('the merged policy (not the raw request) reaches the sampler', async () => {
-		await setUsagePolicy({ store }, { logicalSlotId: SLOT, cycleDay: 9 });
-		const sampler = recordingSampler();
-
-		const result = await setUsagePolicy(
-			{ store, sampler, now: () => NOW },
-			{ logicalSlotId: SLOT, thresholdBytes: 250 },
-		);
-
-		expect(sampler.calls).toEqual([
-			{ slot: SLOT, usage: { cycleDay: 9, thresholdBytes: 250 }, at: NOW },
-		]);
-		expect(result).toMatchObject({ status: 'applied', applied: { cycleReset: true } });
-	});
-
-	test('with no sampler the write is persistence-only and reports no application', async () => {
-		const result = await setUsagePolicy({ store }, { logicalSlotId: SLOT, cycleDay: 2 });
-
-		expect(result).toEqual({ status: 'applied', logicalSlotId: SLOT, usage: { cycleDay: 2 } });
-	});
-
-	test('a sampler that throws is a typed failure AFTER the write already landed', async () => {
-		const result = await setUsagePolicy(
-			{
-				store,
-				sampler: {
-					applyUsagePolicy() {
-						throw new Error('sampler gone');
-					},
-				},
-			},
-			{ logicalSlotId: SLOT, cycleDay: 4 },
-		);
-
-		expect(result).toMatchObject({ status: 'failed', reason: 'sampler gone' });
-		expect(await getUsagePolicy({ store }, SLOT)).toEqual({ cycleDay: 4 });
-	});
-});
-
-describe('getUsagePolicy', () => {
-	test('an unwritten slot answers "no policy set"', async () => {
-		expect(await getUsagePolicy({ store }, 'never-written')).toEqual({});
-	});
-
-	test('reads a policy laid down by a previous process', async () => {
-		const seeded: PersistedUsagePolicy = {
-			schemaVersion: USAGE_POLICY_SCHEMA_VERSION,
-			savedAtMs: NOW,
-			slots: [{ logicalSlotId: SLOT, cycleDay: 28 }],
-		};
-		await store.save(seeded);
-
-		expect(await getUsagePolicy({ store }, SLOT)).toEqual({ cycleDay: 28 });
-	});
-});

package/src/backend/usage/policy-write.ts

@@ -1,207 +0,0 @@
-// `setUsagePolicy` — the WRITE half of the data-usage surface.
-//
-// The read half already existed (`UsageSampler.snapshot()` reports `cycleBytes`,
-// `thresholdBytes` and `thresholdExceeded`), but nothing could SET the two
-// numbers those readings are computed against: `DesiredUsage` was a shape the
-// planner echoed into a receipt, with no persistence and no apply path. This
-// module closes that, mirroring the read side's file-store idiom exactly.
-//
-// It is a LOCAL write, not a modem write — see `policy-store.ts`'s header for the
-// ModemManager API evidence. Nothing here touches D-Bus, `mmcli`, or any bearer.
-//
-// TYPED RESULTS, NEVER THROWS ON BAD INPUT. Following the `PowerHook` precedent
-// (`power-contract.ts`: `applied` / `unsupported` / `failed`), an out-of-range
-// day is a `rejected` result carrying a named reason rather than an exception —
-// this is called from an RPC boundary where a throw becomes an opaque 500.
-
-import type { DesiredUsage } from '../../domain';
-import {
-	isValidCycleDay,
-	isValidThresholdBytes,
-	type PersistedUsagePolicySlot,
-	selectUsagePolicy,
-	USAGE_POLICY_SCHEMA_VERSION,
-	type UsagePolicyStore,
-} from './policy-store';
-
-/**
- * The live-apply seam. `UsageSampler` implements it; a caller with no running
- * sampler simply omits it and the write is persistence-only.
- */
-export interface UsagePolicyTarget {
-	applyUsagePolicy(
-		logicalSlotId: string,
-		usage: DesiredUsage,
-		atMs?: number,
-	): UsagePolicyApplication;
-}
-
-/** What a live apply did to the slot's accounting window. */
-export interface UsagePolicyApplication {
-	/** The UTC start of the cycle the slot is now accruing into. */
-	readonly cycleStartMs: number;
-	/** True when the cycle ANCHOR moved, so the per-cycle total restarted at 0. */
-	readonly cycleReset: boolean;
-}
-
-export interface SetUsagePolicyDeps {
-	readonly store: UsagePolicyStore;
-	/** Optional live sampler to apply the change to immediately. */
-	readonly sampler?: UsagePolicyTarget;
-	/** Injectable clock (defaults to `Date.now`). */
-	readonly now?: () => number;
-}
-
-/**
- * The requested change.
- *
- * Tri-state per field, and the distinction is the whole point: `undefined`
- * leaves the persisted value ALONE (so a caller changing only the threshold
- * cannot silently drop a cycle day it never mentioned), while an explicit `null`
- * CLEARS it. A caller that cannot express `null` can never unset a policy.
- */
-export interface SetUsagePolicyRequest {
-	readonly logicalSlotId: string;
-	readonly cycleDay?: number | null;
-	readonly thresholdBytes?: number | null;
-}
-
-export type SetUsagePolicyRejection =
-	| 'invalid-slot-id'
-	| 'invalid-cycle-day'
-	| 'invalid-threshold-bytes';
-
-export type SetUsagePolicyResult =
-	| {
-			readonly status: 'applied';
-			readonly logicalSlotId: string;
-			/** The policy now persisted for this slot (post-merge). */
-			readonly usage: DesiredUsage;
-			/** Present only when a live sampler was supplied. */
-			readonly applied?: UsagePolicyApplication;
-	  }
-	| {
-			readonly status: 'rejected';
-			readonly logicalSlotId: string;
-			readonly reason: SetUsagePolicyRejection;
-	  }
-	| {
-			readonly status: 'failed';
-			readonly logicalSlotId: string;
-			readonly reason: string;
-	  };
-
-function validateRequest(request: SetUsagePolicyRequest): SetUsagePolicyRejection | undefined {
-	if (typeof request.logicalSlotId !== 'string' || request.logicalSlotId.length === 0) {
-		return 'invalid-slot-id';
-	}
-	if (
-		request.cycleDay !== undefined &&
-		request.cycleDay !== null &&
-		!isValidCycleDay(request.cycleDay)
-	) {
-		return 'invalid-cycle-day';
-	}
-	if (
-		request.thresholdBytes !== undefined &&
-		request.thresholdBytes !== null &&
-		!isValidThresholdBytes(request.thresholdBytes)
-	) {
-		return 'invalid-threshold-bytes';
-	}
-	return undefined;
-}
-
-/** Fold the request onto the currently-persisted policy (tri-state merge). */
-function mergePolicy(current: DesiredUsage, request: SetUsagePolicyRequest): DesiredUsage {
-	const cycleDay =
-		request.cycleDay === undefined ? current.cycleDay : (request.cycleDay ?? undefined);
-	const thresholdBytes =
-		request.thresholdBytes === undefined
-			? current.thresholdBytes
-			: (request.thresholdBytes ?? undefined);
-	return {
-		...(cycleDay !== undefined ? { cycleDay } : {}),
-		...(thresholdBytes !== undefined ? { thresholdBytes } : {}),
-	};
-}
-
-function toSlot(logicalSlotId: string, usage: DesiredUsage): PersistedUsagePolicySlot {
-	return {
-		logicalSlotId,
-		...(usage.cycleDay !== undefined ? { cycleDay: usage.cycleDay } : {}),
-		...(usage.thresholdBytes !== undefined ? { thresholdBytes: usage.thresholdBytes } : {}),
-	};
-}
-
-/**
- * Persist a slot's usage policy and, when a live sampler is supplied, apply it
- * to that sampler in the same call.
- *
- * ORDER IS LOAD → VALIDATE → PERSIST → APPLY, and it is deliberate. The store is
- * the source of truth (the composition root rebuilds every `UsageObservation`
- * from it), so a live apply that landed while the write failed would leave the
- * running process disagreeing with what a restart would restore.
- */
-export async function setUsagePolicy(
-	deps: SetUsagePolicyDeps,
-	request: SetUsagePolicyRequest,
-): Promise<SetUsagePolicyResult> {
-	const logicalSlotId = typeof request.logicalSlotId === 'string' ? request.logicalSlotId : '';
-	const rejection = validateRequest(request);
-	if (rejection !== undefined) {
-		return { status: 'rejected', logicalSlotId, reason: rejection };
-	}
-
-	const now = deps.now ?? Date.now;
-	const at = now();
-
-	let usage: DesiredUsage;
-	try {
-		const state = await deps.store.load(at);
-		usage = mergePolicy(selectUsagePolicy(state, logicalSlotId), request);
-		const others = state.slots.filter((slot) => slot.logicalSlotId !== logicalSlotId);
-		// An empty policy is REMOVED rather than stored as an empty row: "no policy"
-		// and "a policy that sets nothing" are the same fact, and keeping the row
-		// would grow the file by one entry per slot an operator ever cleared.
-		const slots =
-			usage.cycleDay === undefined && usage.thresholdBytes === undefined
-				? others
-				: [...others, toSlot(logicalSlotId, usage)];
-		await deps.store.save({
-			schemaVersion: USAGE_POLICY_SCHEMA_VERSION,
-			savedAtMs: at,
-			slots,
-		});
-	} catch (error) {
-		return {
-			status: 'failed',
-			logicalSlotId,
-			reason: error instanceof Error ? error.message : 'persist-failed',
-		};
-	}
-
-	if (deps.sampler === undefined) {
-		return { status: 'applied', logicalSlotId, usage };
-	}
-	try {
-		const applied = deps.sampler.applyUsagePolicy(logicalSlotId, usage, at);
-		return { status: 'applied', logicalSlotId, usage, applied };
-	} catch (error) {
-		return {
-			status: 'failed',
-			logicalSlotId,
-			reason: error instanceof Error ? error.message : 'apply-failed',
-		};
-	}
-}
-
-/** Read one slot's persisted policy. The read counterpart of `setUsagePolicy`. */
-export async function getUsagePolicy(
-	deps: Pick<SetUsagePolicyDeps, 'store' | 'now'>,
-	logicalSlotId: string,
-): Promise<DesiredUsage> {
-	const now = deps.now ?? Date.now;
-	const state = await deps.store.load(now());
-	return selectUsagePolicy(state, logicalSlotId);
-}

package/src/backend/usage/proc-net-dev.test.ts

@@ -1,56 +0,0 @@
-// `/proc/net/dev` parser — proves rx+tx cumulative totals over the real fixed-column
-// format, header skipping, and fail-soft handling of malformed rows.
-
-import { describe, expect, test } from 'bun:test';
-import { parseProcNetDev } from './proc-net-dev';
-
-// A real capture (columns: rx bytes packets errs drop fifo frame compressed multicast
-// | tx bytes packets errs drop fifo colls carrier compressed).
-const REAL = `Inter-|   Receive                                                |  Transmit
- face |bytes    packets errs drop fifo frame compressed multicast|bytes    packets errs drop fifo colls carrier compressed
-    lo: 160183007830 18519510    0    0    0     0          0         0 160183007830 18519510    0    0    0     0       0          0
-  eno2: 88166142004 86575608    0    0   48     0          0    146660 25843393633 48414413    0    3    0     0       0          0
- wlan0: 44865976  194892    0    0    0     0          0         0  5698312   36057    0   23    0     0       0          0
-`;
-
-describe('parseProcNetDev', () => {
-	test('reads rx+tx cumulative bytes for each interface, skipping the 2-line header', () => {
-		const counters = parseProcNetDev(REAL);
-		expect(counters.size).toBe(3);
-		// lo: 160183007830 (rx) + 160183007830 (tx).
-		expect(counters.get('lo')).toBe(160183007830 + 160183007830);
-		// eno2: rx 88166142004 + tx 25843393633.
-		expect(counters.get('eno2')).toBe(88166142004 + 25843393633);
-		// wlan0: rx 44865976 + tx 5698312.
-		expect(counters.get('wlan0')).toBe(44865976 + 5698312);
-	});
-
-	test('handles bridge-style names with no leading space and long names', () => {
-		const text = `h1
-h2
-br-d739ee545df1: 575402021  542380    0    0    0     0          0         0 450821722  810015    0    4    0     0       0          0
-docker0: 1750867165 1097738    0    0    0     0          0         0 5810268898 1237921    0 12223    0     0       0          0
-`;
-		const counters = parseProcNetDev(text);
-		expect(counters.get('br-d739ee545df1')).toBe(575402021 + 450821722);
-		expect(counters.get('docker0')).toBe(1750867165 + 5810268898);
-	});
-
-	test('ignores malformed / short rows without throwing', () => {
-		const text = `h1
-h2
-    lo: 100 1 0 0 0 0 0 0 200 2 0 0 0 0 0 0
-garbage-without-colon 1 2 3
-  short: 1 2 3
-   nan: x 1 0 0 0 0 0 0 y 2 0 0 0 0 0 0
-`;
-		const counters = parseProcNetDev(text);
-		// Only the well-formed `lo` row survives.
-		expect(counters.size).toBe(1);
-		expect(counters.get('lo')).toBe(300);
-	});
-
-	test('empty input yields an empty map', () => {
-		expect(parseProcNetDev('').size).toBe(0);
-	});
-});