@ceralive/modem-control 0.2.0 → 1.1.0

package/src/backend/usage/sampler.test.ts

@@ -1,219 +0,0 @@
-// The sampler orchestration — ambiguous-identity pause, threshold advisory
-// appear/clear, rate-limited persistence + shutdown flush, reboot re-baselining, and
-// the queryable snapshot API the A6.1 bench CLI `usage` command consumes.
-
-import { describe, expect, test } from 'bun:test';
-import { type DesiredUsage, logicalSlotId } from '../../domain';
-import type { CounterSource } from './proc-net-dev';
-import { createUsageSampler, type UsageObservation } from './sampler';
-import { type PersistedUsage, USAGE_SCHEMA_VERSION, type UsageStore } from './store';
-
-const SLOT_A = logicalSlotId('slot-a');
-const SLOT_B = logicalSlotId('slot-b');
-
-class FakeCounters implements CounterSource {
-	readonly #map = new Map<string, number>();
-	set(ifname: string, value: number): void {
-		this.#map.set(ifname, value);
-	}
-	async read(): Promise<ReadonlyMap<string, number>> {
-		return new Map(this.#map);
-	}
-}
-
-class MemStore implements UsageStore {
-	doc: PersistedUsage | null = null;
-	saves = 0;
-	async load(bootId: string, nowMs: number): Promise<PersistedUsage> {
-		return this.doc ?? { schemaVersion: USAGE_SCHEMA_VERSION, bootId, savedAtMs: nowMs, slots: [] };
-	}
-	async save(state: PersistedUsage): Promise<void> {
-		this.saves += 1;
-		this.doc = state;
-	}
-}
-
-function obs(
-	slot: string,
-	ifname: string,
-	usage: DesiredUsage = {},
-	confidence: 'high' | 'medium' | 'low' = 'high',
-	mappingGeneration = 0,
-): UsageObservation {
-	return { logicalSlotId: logicalSlotId(slot), mappingGeneration, ifname, confidence, usage };
-}
-
-describe('UsageSampler — snapshot API (A6.1 usage command)', () => {
-	test('reports independent per-slot cumulative usage', async () => {
-		const counters = new FakeCounters();
-		const sampler = await createUsageSampler({
-			bootId: 'boot-1',
-			source: counters,
-			store: new MemStore(),
-			now: () => 1000,
-		});
-		counters.set('wwan0', 100);
-		counters.set('wwan1', 5000);
-		await sampler.sample([obs(SLOT_A, 'wwan0'), obs(SLOT_B, 'wwan1')]);
-		counters.set('wwan0', 300);
-		counters.set('wwan1', 5001);
-		await sampler.sample([obs(SLOT_A, 'wwan0'), obs(SLOT_B, 'wwan1')]);
-
-		const snap = sampler.snapshot();
-		expect(snap.bootId).toBe('boot-1');
-		expect(snap.slots).toHaveLength(2);
-		const a = snap.slots.find((s) => s.logicalSlotId === 'slot-a');
-		const b = snap.slots.find((s) => s.logicalSlotId === 'slot-b');
-		expect(a?.cycleBytes).toBe(200);
-		expect(a?.paused).toBe(false);
-		expect(a?.thresholdExceeded).toBe(false);
-		expect(b?.cycleBytes).toBe(1);
-	});
-});
-
-describe('UsageSampler — ambiguous identity pauses sampling', () => {
-	test('a low-confidence slot attributes nothing and reports paused', async () => {
-		const counters = new FakeCounters();
-		const sampler = await createUsageSampler({
-			bootId: 'boot-1',
-			source: counters,
-			store: new MemStore(),
-			now: () => 1000,
-		});
-		counters.set('wwan0', 100);
-		await sampler.sample([obs(SLOT_A, 'wwan0')]);
-		counters.set('wwan0', 400);
-		await sampler.sample([obs(SLOT_A, 'wwan0')]);
-		expect(sampler.snapshot().slots[0]?.cycleBytes).toBe(300);
-
-		// Identity turns ambiguous — counter keeps climbing, nothing is attributed.
-		counters.set('wwan0', 9999);
-		await sampler.sample([obs(SLOT_A, 'wwan0', {}, 'low')]);
-		const paused = sampler.snapshot().slots[0];
-		expect(paused?.paused).toBe(true);
-		expect(paused?.cycleBytes).toBe(300);
-	});
-});
-
-describe('UsageSampler — threshold advisory appears and clears', () => {
-	test('crossing thresholdBytes flags an advisory that clears on cycle rollover', async () => {
-		const counters = new FakeCounters();
-		let clock = Date.UTC(2024, 5, 15); // mid-June
-		const usage: DesiredUsage = { cycleDay: 1, thresholdBytes: 1000 };
-		const sampler = await createUsageSampler({
-			bootId: 'boot-1',
-			source: counters,
-			store: new MemStore(),
-			now: () => clock,
-		});
-
-		counters.set('wwan0', 0);
-		await sampler.sample([obs(SLOT_A, 'wwan0', usage)]);
-		counters.set('wwan0', 2000); // +2000 > 1000 threshold
-		await sampler.sample([obs(SLOT_A, 'wwan0', usage)]);
-		const exceeded = sampler.snapshot().slots[0];
-		expect(exceeded?.cycleBytes).toBe(2000);
-		expect(exceeded?.thresholdBytes).toBe(1000);
-		expect(exceeded?.thresholdExceeded).toBe(true);
-
-		// New billing cycle (July 1) → per-cycle total resets → advisory clears.
-		clock = Date.UTC(2024, 6, 2);
-		counters.set('wwan0', 2100); // +100 into the fresh cycle
-		await sampler.sample([obs(SLOT_A, 'wwan0', usage)]);
-		const cleared = sampler.snapshot().slots[0];
-		expect(cleared?.cycleBytes).toBe(100);
-		expect(cleared?.thresholdExceeded).toBe(false);
-	});
-});
-
-describe('UsageSampler — rate-limited persistence + shutdown flush', () => {
-	test('persists at most once per minute; flush forces an immediate write', async () => {
-		const counters = new FakeCounters();
-		const store = new MemStore();
-		let clock = 1000;
-		const sampler = await createUsageSampler({
-			bootId: 'boot-1',
-			source: counters,
-			store,
-			now: () => clock,
-			persistIntervalMs: 60_000,
-		});
-		counters.set('wwan0', 100);
-		await sampler.sample([obs(SLOT_A, 'wwan0')]); // t=1000, within interval → no save
-		clock = 2000;
-		await sampler.sample([obs(SLOT_A, 'wwan0')]); // t=2000, still within → no save
-		expect(store.saves).toBe(0);
-
-		await sampler.flush(); // shutdown hook — forces a write despite the rate limit
-		expect(store.saves).toBe(1);
-
-		clock = 62_000; // > 60s since the flush persist → next sample persists
-		counters.set('wwan0', 150);
-		await sampler.sample([obs(SLOT_A, 'wwan0')]);
-		expect(store.saves).toBe(2);
-	});
-
-	test('a clean flush persists the latest cycle total', async () => {
-		const counters = new FakeCounters();
-		const store = new MemStore();
-		const sampler = await createUsageSampler({
-			bootId: 'boot-1',
-			source: counters,
-			store,
-			now: () => 1000,
-		});
-		counters.set('wwan0', 100);
-		await sampler.sample([obs(SLOT_A, 'wwan0')]);
-		counters.set('wwan0', 500);
-		await sampler.sample([obs(SLOT_A, 'wwan0')]);
-		await sampler.flush();
-		expect(store.doc?.slots[0]?.cycleBytes).toBe(400);
-		expect(store.doc?.slots[0]?.lastObserved).toBe(500);
-	});
-});
-
-describe('UsageSampler — reboot (new boot id) re-baselines without losing the cycle total', () => {
-	test('same-boot reload resumes the baseline; a new boot id drops it', async () => {
-		const counters = new FakeCounters();
-		const store = new MemStore();
-		const first = await createUsageSampler({
-			bootId: 'boot-1',
-			source: counters,
-			store,
-			now: () => 1000,
-		});
-		counters.set('wwan0', 100);
-		await first.sample([obs(SLOT_A, 'wwan0')]);
-		counters.set('wwan0', 300);
-		await first.sample([obs(SLOT_A, 'wwan0')]);
-		await first.flush();
-		expect(store.doc?.slots[0]?.cycleBytes).toBe(200);
-
-		// Same boot id → baseline resumes; counter continues from 300.
-		const resumed = await createUsageSampler({
-			bootId: 'boot-1',
-			source: counters,
-			store,
-			now: () => 1000,
-		});
-		counters.set('wwan0', 350);
-		await resumed.sample([obs(SLOT_A, 'wwan0')]);
-		expect(resumed.snapshot().slots[0]?.cycleBytes).toBe(250);
-		await resumed.flush();
-
-		// Reboot: new boot id + counters reset to a low value. The cycle total is kept,
-		// but the baseline is dropped so the reset is not mis-attributed.
-		const rebooted = await createUsageSampler({
-			bootId: 'boot-2',
-			source: counters,
-			store,
-			now: () => 1000,
-		});
-		counters.set('wwan0', 50); // kernel counters reset on reboot
-		await rebooted.sample([obs(SLOT_A, 'wwan0')]); // zero-delta re-baseline
-		expect(rebooted.snapshot().slots[0]?.cycleBytes).toBe(250);
-		counters.set('wwan0', 150);
-		await rebooted.sample([obs(SLOT_A, 'wwan0')]);
-		expect(rebooted.snapshot().slots[0]?.cycleBytes).toBe(350);
-	});
-});

package/src/backend/usage/sampler.ts

@@ -1,228 +0,0 @@
-// The usage sampler — orchestrates the counter source, pure accounting reducer,
-// billing-cycle math, and fail-soft persistence into one internal service.
-//
-// SESSION = the kernel boot id. Interface byte counters reset to zero on reboot, so
-// the boot id both scopes every baseline key AND lets a reload detect a reboot: a
-// persisted document from a different boot keeps its per-cycle totals but drops its
-// baselines, so the first post-reboot sample re-baselines zero-delta.
-//
-// PERSISTENCE: state is written at most once per minute (rate-limited) plus a
-// `flush()` shutdown hook. A crash therefore loses AT MOST ~1 minute of unpersisted
-// deltas (the window since the last rate-limited write); a clean shutdown calls
-// `flush()` and loses effectively nothing.
-
-import { type DesiredUsage, epochMillis, type LogicalSlotId } from '../../domain';
-import { applySample, type BaselineKey, initialAccount, type SlotAccount } from './accounting';
-import { cycleStart } from './billing-cycle';
-import type { CounterSource } from './proc-net-dev';
-import type { PersistedSlot, PersistedUsage, UsageStore } from './store';
-import { USAGE_SCHEMA_VERSION } from './store';
-
-/** One slot's observation for a sampling pass — identity + mapping + local policy. */
-export interface UsageObservation {
-	readonly logicalSlotId: LogicalSlotId;
-	/** Bumped by A4.2 whenever the ifname-to-slot mapping changes (→ zero-delta rebase). */
-	readonly mappingGeneration: number;
-	readonly ifname: string;
-	/** A3.2 identity-ladder confidence; `low` pauses sampling for this slot. */
-	readonly confidence: 'high' | 'medium' | 'low';
-	/** Local-controller-owned usage policy (cycle day + advisory threshold). */
-	readonly usage: DesiredUsage;
-}
-
-/** A queryable per-slot usage figure — consumed by the A6.1 bench CLI `usage` command. */
-export interface SlotUsageSnapshot {
-	readonly logicalSlotId: string;
-	readonly cycleBytes: number;
-	readonly cycleStartMs: number;
-	readonly paused: boolean;
-	readonly thresholdBytes?: number;
-	/** Advisory-only: `cycleBytes > thresholdBytes`. Never gates the connection. */
-	readonly thresholdExceeded: boolean;
-}
-
-/** The sampler's current state, per slot, at a point in time. */
-export interface UsageSnapshot {
-	readonly bootId: string;
-	readonly generatedAtMs: number;
-	readonly slots: readonly SlotUsageSnapshot[];
-}
-
-export interface UsageSamplerOptions {
-	/** The kernel boot id (see `readBootId`) — the session identity. */
-	readonly bootId: string;
-	readonly source: CounterSource;
-	readonly store: UsageStore;
-	/** Injectable clock (defaults to `Date.now`). */
-	readonly now?: () => number;
-	/** Minimum spacing between persists (default 60_000 ms = the ≤1-min loss bound). */
-	readonly persistIntervalMs?: number;
-	/** Cycle day used when a slot's policy omits `cycleDay` (default 1 = 1st of month). */
-	readonly defaultCycleDay?: number;
-}
-
-const DEFAULT_PERSIST_INTERVAL_MS = 60_000;
-const DEFAULT_CYCLE_DAY = 1;
-
-function toPersistedSlot(logicalSlotId: string, account: SlotAccount): PersistedSlot {
-	return {
-		logicalSlotId,
-		cycleBytes: account.cycleBytes,
-		cycleStartMs: account.cycleStartMs,
-		...(account.key !== undefined
-			? { mappingGeneration: account.key.mappingGeneration, ifname: account.key.ifname }
-			: {}),
-		...(account.lastObserved !== undefined ? { lastObserved: account.lastObserved } : {}),
-	};
-}
-
-export class UsageSampler {
-	readonly #bootId: string;
-	readonly #source: CounterSource;
-	readonly #store: UsageStore;
-	readonly #now: () => number;
-	readonly #persistIntervalMs: number;
-	readonly #defaultCycleDay: number;
-	readonly #accounts = new Map<string, SlotAccount>();
-	readonly #policies = new Map<string, DesiredUsage>();
-	#lastPersistMs: number;
-	#dirty = false;
-
-	private constructor(options: UsageSamplerOptions, initial: PersistedUsage) {
-		this.#bootId = options.bootId;
-		this.#source = options.source;
-		this.#store = options.store;
-		this.#now = options.now ?? Date.now;
-		this.#persistIntervalMs = options.persistIntervalMs ?? DEFAULT_PERSIST_INTERVAL_MS;
-		this.#defaultCycleDay = options.defaultCycleDay ?? DEFAULT_CYCLE_DAY;
-		this.#lastPersistMs = this.#now();
-		this.#hydrate(initial);
-	}
-
-	/** Load persisted state (recreating a fresh file if absent/corrupt) then build the sampler. */
-	static async create(options: UsageSamplerOptions): Promise<UsageSampler> {
-		const now = options.now ?? Date.now;
-		const initial = await options.store.load(options.bootId, now());
-		return new UsageSampler(options, initial);
-	}
-
-	/** Rebuild in-memory accounts. A reboot (differing boot id) drops the baselines. */
-	#hydrate(initial: PersistedUsage): void {
-		const sameBoot = initial.bootId === this.#bootId;
-		for (const slot of initial.slots) {
-			const canResume =
-				sameBoot &&
-				slot.ifname !== undefined &&
-				slot.mappingGeneration !== undefined &&
-				slot.lastObserved !== undefined;
-			if (canResume) {
-				const key: BaselineKey = {
-					logicalSlotId: slot.logicalSlotId,
-					mappingGeneration: slot.mappingGeneration as number,
-					ifname: slot.ifname as string,
-					bootId: this.#bootId,
-				};
-				this.#accounts.set(slot.logicalSlotId, {
-					cycleBytes: slot.cycleBytes,
-					cycleStartMs: slot.cycleStartMs,
-					paused: false,
-					key,
-					lastObserved: slot.lastObserved as number,
-				});
-			} else {
-				this.#accounts.set(slot.logicalSlotId, {
-					cycleBytes: slot.cycleBytes,
-					cycleStartMs: slot.cycleStartMs,
-					paused: false,
-				});
-			}
-		}
-	}
-
-	/** Take one sampling pass over the current counters for the given observations. */
-	async sample(observations: readonly UsageObservation[]): Promise<void> {
-		const counters = await this.#source.read();
-		const now = this.#now();
-		for (const obs of observations) {
-			const slotId = obs.logicalSlotId as string;
-			this.#policies.set(slotId, obs.usage);
-			const cycleDay = obs.usage.cycleDay ?? this.#defaultCycleDay;
-			const cycleStartMs = cycleStart(epochMillis(now), cycleDay);
-			const current = counters.get(obs.ifname);
-			if (current === undefined) {
-				// No reading for this interface — ensure the slot exists, attribute nothing.
-				if (!this.#accounts.has(slotId)) {
-					this.#accounts.set(slotId, initialAccount(cycleStartMs));
-				}
-				continue;
-			}
-			const key: BaselineKey = {
-				logicalSlotId: slotId,
-				mappingGeneration: obs.mappingGeneration,
-				ifname: obs.ifname,
-				bootId: this.#bootId,
-			};
-			const next = applySample(this.#accounts.get(slotId), {
-				key,
-				current,
-				confidence: obs.confidence,
-				cycleStartMs,
-			});
-			this.#accounts.set(slotId, next);
-		}
-		this.#dirty = true;
-		await this.#maybePersist(now);
-	}
-
-	/** Current per-slot usage — the queryable snapshot the CLI and platform read. */
-	snapshot(): UsageSnapshot {
-		const generatedAtMs = this.#now();
-		const slots: SlotUsageSnapshot[] = [];
-		for (const [slotId, account] of this.#accounts) {
-			const thresholdBytes = this.#policies.get(slotId)?.thresholdBytes;
-			slots.push({
-				logicalSlotId: slotId,
-				cycleBytes: account.cycleBytes,
-				cycleStartMs: account.cycleStartMs,
-				paused: account.paused,
-				...(thresholdBytes !== undefined ? { thresholdBytes } : {}),
-				thresholdExceeded: thresholdBytes !== undefined && account.cycleBytes > thresholdBytes,
-			});
-		}
-		return { bootId: this.#bootId, generatedAtMs, slots };
-	}
-
-	/** Flush unpersisted state immediately — the shutdown hook (bounds loss to ≤1 min). */
-	async flush(): Promise<void> {
-		if (this.#dirty) {
-			await this.#persist(this.#now());
-		}
-	}
-
-	async #maybePersist(now: number): Promise<void> {
-		if (now - this.#lastPersistMs >= this.#persistIntervalMs) {
-			await this.#persist(now);
-		}
-	}
-
-	async #persist(now: number): Promise<void> {
-		const slots: PersistedSlot[] = [];
-		for (const [slotId, account] of this.#accounts) {
-			slots.push(toPersistedSlot(slotId, account));
-		}
-		const state: PersistedUsage = {
-			schemaVersion: USAGE_SCHEMA_VERSION,
-			bootId: this.#bootId,
-			savedAtMs: now,
-			slots,
-		};
-		await this.#store.save(state);
-		this.#lastPersistMs = now;
-		this.#dirty = false;
-	}
-}
-
-/** Load persisted state and build a ready sampler. See `UsageSampler.create`. */
-export function createUsageSampler(options: UsageSamplerOptions): Promise<UsageSampler> {
-	return UsageSampler.create(options);
-}

package/src/backend/usage/store.test.ts

@@ -1,148 +0,0 @@
-// Persistence contract — mode 0600 (real fs.stat), fail-soft corruption recovery
-// with METADATA-ONLY logging, and the no-PII guarantee on the serialized bytes.
-
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import {
-	createUsageFileStore,
-	type PersistedUsage,
-	USAGE_SCHEMA_VERSION,
-	type UsageLogEvent,
-} from './store';
-
-let dir: string;
-let path: string;
-
-beforeEach(async () => {
-	dir = await mkdtemp(join(tmpdir(), 'usage-store-'));
-	path = join(dir, 'usage.json');
-});
-
-afterEach(async () => {
-	await rm(dir, { recursive: true, force: true });
-});
-
-const sample: PersistedUsage = {
-	schemaVersion: USAGE_SCHEMA_VERSION,
-	bootId: 'boot-uuid-1',
-	savedAtMs: 1_700_000_000_000,
-	slots: [
-		{ logicalSlotId: 'slot-a', cycleBytes: 1234, cycleStartMs: 1_699_000_000_000 },
-		{
-			logicalSlotId: 'slot-b',
-			cycleBytes: 42,
-			cycleStartMs: 1_699_000_000_000,
-			mappingGeneration: 2,
-			ifname: 'wwan0',
-			lastObserved: 999,
-		},
-	],
-};
-
-describe('UsageStore — versioned round-trip', () => {
-	test('save then load returns identical, schema-versioned state', async () => {
-		const store = createUsageFileStore({ path });
-		await store.save(sample);
-		const loaded = await store.load('boot-uuid-1', 1_700_000_100_000);
-		expect(loaded.schemaVersion).toBe(USAGE_SCHEMA_VERSION);
-		expect(loaded).toEqual(sample);
-	});
-
-	test('an absent file loads as fresh empty state (no write, no warning)', async () => {
-		const events: UsageLogEvent[] = [];
-		const store = createUsageFileStore({ path, logger: (e) => events.push(e) });
-		const loaded = await store.load('boot-uuid-9', 5);
-		expect(loaded.slots).toEqual([]);
-		expect(loaded.bootId).toBe('boot-uuid-9');
-		expect(events).toHaveLength(0);
-	});
-});
-
-describe('UsageStore — mode 0600 via chmod-after-write', () => {
-	test('the persisted file ends up owner-read/write only (real fs.stat)', async () => {
-		const store = createUsageFileStore({ path });
-		await store.save(sample);
-		const info = await stat(path);
-		expect(info.mode & 0o777).toBe(0o600);
-	});
-});
-
-describe('UsageStore — fail-soft corruption recovery', () => {
-	test('a corrupt file logs METADATA ONLY and recreates a fresh 0600 file', async () => {
-		// Corrupt content carrying a secret-looking token we must never echo in the log.
-		const corrupt = '{ this is not json ICCID=8988211000000123456 }';
-		await writeFile(path, corrupt);
-		const events: UsageLogEvent[] = [];
-		const store = createUsageFileStore({ path, logger: (e) => events.push(e) });
-
-		const loaded = await store.load('boot-uuid-2', 77);
-
-		// Exactly one metadata-only warning.
-		expect(events).toHaveLength(1);
-		const event = events[0];
-		expect(event?.kind).toBe('corrupt-state');
-		expect(event?.bytes).toBe(Buffer.byteLength(corrupt, 'utf8'));
-		expect(typeof event?.reason).toBe('string');
-		// The log NEVER contains the raw content (no secret token leak).
-		expect(JSON.stringify(event)).not.toContain('ICCID');
-		expect(JSON.stringify(event)).not.toContain('8988211000000123456');
-
-		// Fail-soft: fresh empty state returned and the file recreated at mode 0600.
-		expect(loaded.slots).toEqual([]);
-		expect(loaded.bootId).toBe('boot-uuid-2');
-		const info = await stat(path);
-		expect(info.mode & 0o777).toBe(0o600);
-
-		// The recreated file is now valid — a second load is clean (no new warning).
-		const reloaded = await store.load('boot-uuid-2', 78);
-		expect(reloaded.slots).toEqual([]);
-		expect(events).toHaveLength(1);
-	});
-
-	test('an incompatible schema version is treated as corruption and recreated', async () => {
-		await writeFile(
-			path,
-			JSON.stringify({ schemaVersion: 999, bootId: 'x', savedAtMs: 0, slots: [] }),
-		);
-		const events: UsageLogEvent[] = [];
-		const store = createUsageFileStore({ path, logger: (e) => events.push(e) });
-		const loaded = await store.load('boot-uuid-3', 1);
-		expect(events).toHaveLength(1);
-		expect(events[0]?.reason).toContain('schemaVersion');
-		expect(loaded.slots).toEqual([]);
-	});
-});
-
-describe('UsageStore — no PII in the persisted bytes', () => {
-	test('the serialized file contains only opaque ids and numbers', async () => {
-		const store = createUsageFileStore({ path });
-		await store.save(sample);
-		const raw = await readFile(path, 'utf8');
-
-		// No subscriber/device-identifying fields, by construction. Word-bounded so a
-		// benign key like `mappingGeneration` (contains "pin") is not a false positive.
-		expect(raw).not.toMatch(
-			/\b(iccid|imsi|imei|eid|msisdn|operator|manufacturer|subscriber|pin|puk|password)\b/i,
-		);
-
-		// Every slot object exposes only the allowed keys; ids are opaque strings.
-		const parsed = JSON.parse(raw) as PersistedUsage;
-		const allowed = new Set([
-			'logicalSlotId',
-			'cycleBytes',
-			'cycleStartMs',
-			'mappingGeneration',
-			'ifname',
-			'lastObserved',
-		]);
-		for (const slot of parsed.slots) {
-			for (const keyName of Object.keys(slot)) {
-				expect(allowed.has(keyName)).toBe(true);
-			}
-			expect(typeof slot.logicalSlotId).toBe('string');
-			expect(typeof slot.cycleBytes).toBe('number');
-		}
-	});
-});