@ceralive/modem-control 1.0.0 → 1.2.0

package/src/usb-mode/catalog-schema.test.ts

@@ -1,181 +0,0 @@
-// The catalog schema is a SAFETY BOUNDARY: the two invariants it enforces (only
-// within-MM transitions are expressible; no unknown field slips through) are what
-// keep an uncertified or MM↔router switch from ever becoming valid catalog data.
-
-import { describe, expect, test } from 'bun:test';
-import {
-	CERTIFIED_CATALOG,
-	findCatalogEntry,
-	findPermittedTransition,
-	loadCertifiedCatalog,
-} from './catalog';
-import { catalogEntrySchema, certifiedCatalogSchema } from './catalog-schema';
-
-function validCatalog(): unknown {
-	return {
-		schemaVersion: 1,
-		entries: [
-			{
-				vidPid: '2c7c:0125',
-				model: 'TEST-SKU',
-				firmwarePrefix: 'FW01',
-				canonicalMode: 'qmi',
-				permittedTransitions: [
-					{
-						from: 'qmi',
-						to: 'mbim',
-						atCommand: 'AT+QCFG="usbnet",2',
-						expectedResponse: 'OK',
-						expectsPortDrop: true,
-						expectedDescriptors: {
-							deviceClass: 0,
-							interfaces: [{ interfaceClass: 2, interfaceSubClass: 14, interfaceProtocol: 0 }],
-						},
-					},
-				],
-			},
-		],
-	};
-}
-
-function firstTransition(catalog: ReturnType<typeof validCatalog>): Record<string, unknown> {
-	// biome-ignore lint/suspicious/noExplicitAny: test helper reaching into a plain fixture
-	return (catalog as any).entries[0].permittedTransitions[0];
-}
-
-function firstEntry(catalog: ReturnType<typeof validCatalog>): Record<string, unknown> {
-	// biome-ignore lint/suspicious/noExplicitAny: test helper reaching into a plain fixture
-	return (catalog as any).entries[0];
-}
-
-describe('certified catalog schema — accepts valid data', () => {
-	test('a well-formed catalog parses', () => {
-		expect(certifiedCatalogSchema.safeParse(validCatalog()).success).toBe(true);
-	});
-
-	test('a router-ethernet SKU with NO transitions is valid', () => {
-		const catalog = validCatalog() as { entries: Array<Record<string, unknown>> };
-		catalog.entries[0] = {
-			vidPid: '12d1:14db',
-			model: 'HILINK-STICK',
-			firmwarePrefix: 'HILINK',
-			canonicalMode: 'router-ethernet',
-			permittedTransitions: [],
-		};
-		expect(certifiedCatalogSchema.safeParse(catalog).success).toBe(true);
-	});
-});
-
-describe('certified catalog schema — rejects MM↔router transitions (schema-invalid)', () => {
-	test('a transition TO router-ethernet fails to parse', () => {
-		const catalog = validCatalog();
-		firstTransition(catalog).to = 'router-ethernet';
-		expect(certifiedCatalogSchema.safeParse(catalog).success).toBe(false);
-	});
-
-	test('a transition FROM router-ethernet fails to parse', () => {
-		const catalog = validCatalog();
-		firstTransition(catalog).from = 'router-ethernet';
-		expect(certifiedCatalogSchema.safeParse(catalog).success).toBe(false);
-	});
-
-	test('a transition touching rndis fails to parse', () => {
-		const catalog = validCatalog();
-		firstTransition(catalog).to = 'rndis';
-		expect(certifiedCatalogSchema.safeParse(catalog).success).toBe(false);
-	});
-
-	test('a router-ethernet SKU may NOT declare any transition', () => {
-		const catalog = validCatalog();
-		firstEntry(catalog).canonicalMode = 'router-ethernet';
-		expect(certifiedCatalogSchema.safeParse(catalog).success).toBe(false);
-	});
-});
-
-describe('certified catalog schema — strict mode rejects unknown fields', () => {
-	test('an unknown field on the catalog root is rejected', () => {
-		const catalog = validCatalog() as Record<string, unknown>;
-		catalog.smuggled = true;
-		expect(certifiedCatalogSchema.safeParse(catalog).success).toBe(false);
-	});
-
-	test('an unknown field on an entry is rejected', () => {
-		const catalog = validCatalog();
-		firstEntry(catalog).hidden = 'x';
-		expect(certifiedCatalogSchema.safeParse(catalog).success).toBe(false);
-	});
-
-	test('an unknown field on a transition is rejected', () => {
-		const catalog = validCatalog();
-		firstTransition(catalog).sneaky = 1;
-		expect(certifiedCatalogSchema.safeParse(catalog).success).toBe(false);
-	});
-});
-
-describe('certified catalog schema — field validation', () => {
-	test('a self-transition (from === to) is rejected', () => {
-		const catalog = validCatalog();
-		firstTransition(catalog).to = 'qmi';
-		expect(certifiedCatalogSchema.safeParse(catalog).success).toBe(false);
-	});
-
-	test('a malformed VID:PID is rejected', () => {
-		const catalog = validCatalog();
-		firstEntry(catalog).vidPid = '2c7c-0125';
-		expect(certifiedCatalogSchema.safeParse(catalog).success).toBe(false);
-	});
-
-	test('a schemaVersion other than 1 is rejected', () => {
-		const catalog = validCatalog() as Record<string, unknown>;
-		catalog.schemaVersion = 2;
-		expect(certifiedCatalogSchema.safeParse(catalog).success).toBe(false);
-	});
-
-	test('a valid evidence-bundle sha256 is accepted; a malformed one is rejected', () => {
-		const good = validCatalog();
-		firstTransition(good).evidenceBundleSha256 = 'a'.repeat(64);
-		expect(certifiedCatalogSchema.safeParse(good).success).toBe(true);
-
-		const bad = validCatalog();
-		firstTransition(bad).evidenceBundleSha256 = 'nothex';
-		expect(certifiedCatalogSchema.safeParse(bad).success).toBe(false);
-	});
-
-	test('loadCertifiedCatalog throws on invalid input', () => {
-		expect(() => loadCertifiedCatalog({ schemaVersion: 1 })).toThrow();
-	});
-
-	test('a lone entry also validates against catalogEntrySchema', () => {
-		const entry = (validCatalog() as { entries: unknown[] }).entries[0];
-		expect(catalogEntrySchema.safeParse(entry).success).toBe(true);
-	});
-});
-
-describe('the shipped certified catalog', () => {
-	test('validates and exposes the synthetic test SKU with within-MM transitions', () => {
-		const sku = {
-			vidPid: '2c7c:0125',
-			model: 'CERALIVE-SYNTHETIC-TEST-SKU',
-			firmwarePrefix: 'SYNTHETICFW01',
-		};
-		const entry = findCatalogEntry(CERTIFIED_CATALOG, sku);
-		expect(entry).toBeDefined();
-		expect(entry?.canonicalMode).toBe('qmi');
-		const transition =
-			entry !== undefined ? findPermittedTransition(entry, 'qmi', 'mbim') : undefined;
-		expect(transition?.atCommand).toBe('AT+QCFG="usbnet",2');
-		// A transition the catalog does NOT declare is absent (never a guess).
-		expect(
-			entry !== undefined ? findPermittedTransition(entry, 'mbim', 'ecm-ncm') : undefined,
-		).toBeUndefined();
-	});
-
-	test('an unmatched SKU discriminator returns undefined (uncertified)', () => {
-		const entry = findCatalogEntry(CERTIFIED_CATALOG, {
-			vidPid: '2c7c:0125',
-			model: 'CERALIVE-SYNTHETIC-TEST-SKU',
-			firmwarePrefix: 'WRONGFW',
-		});
-		expect(entry).toBeUndefined();
-	});
-});

package/src/usb-mode/catalog-schema.ts

@@ -1,113 +0,0 @@
-// The certified USB-mode catalog schema — the contract that gates a mode switch.
-//
-// A catalog ENTRY is one server-derived SKU discriminator (VID:PID + model +
-// firmware prefix) plus everything a certified transition needs: the canonical mode
-// the SKU speaks, the AT commands that switch it, the expected AT response and
-// port-drop behaviour, the USB descriptors it should present AFTER the switch, and a
-// forward-reference to the evidence bundle that certified it. Certification is a
-// human-reviewed commit that adds an entry — evidence bundles are inputs to that
-// review, never read at runtime.
-//
-// TWO safety invariants are enforced by the SCHEMA ITSELF, not by convention:
-//   1. Permitted transitions are WITHIN-ModemManager only — `qmi ↔ mbim ↔ ecm-ncm`.
-//      A transition's `from`/`to` are typed to the MM-mode enum, so any attempt to
-//      declare an `MM ↔ router` (or `rndis`) transition FAILS to parse.
-//   2. `.strict()` everywhere — an entry carrying an unknown field is rejected, so a
-//      typo or a smuggled extra field can never slip past review as valid data.
-
-import { z } from 'zod';
-
-/**
- * The full canonical USB composition-mode vocabulary. A SKU's `canonicalMode` may be
- * any of these; only the first three are ModemManager-manageable. (Structurally
- * identical to `PreferredUsbMode` in the power contract — A4.2 owns this vocabulary.)
- */
-export const CANONICAL_USB_MODES = ['qmi', 'mbim', 'ecm-ncm', 'rndis', 'router-ethernet'] as const;
-export type CanonicalUsbMode = (typeof CANONICAL_USB_MODES)[number];
-
-/**
- * The ModemManager-manageable modes — the ONLY modes a transition may move between.
- * `rndis` and `router-ethernet` are deliberately absent: a device in either is not
- * MM-managed, so switching to/from them crosses the MM↔router line the schema forbids.
- */
-export const MM_USB_MODES = ['qmi', 'mbim', 'ecm-ncm'] as const;
-export type MmUsbMode = (typeof MM_USB_MODES)[number];
-
-const canonicalMode = z.enum(CANONICAL_USB_MODES);
-const mmMode = z.enum(MM_USB_MODES);
-
-/** A `bInterfaceClass`/`bInterfaceSubClass`/`bInterfaceProtocol` byte triple. */
-const usbByte = z.number().int().min(0).max(255);
-
-/** The USB descriptors a device must present AFTER a transition — the postcondition. */
-export const expectedDescriptorsSchema = z.strictObject({
-	deviceClass: usbByte,
-	interfaces: z
-		.array(
-			z.strictObject({
-				interfaceClass: usbByte,
-				interfaceSubClass: usbByte,
-				interfaceProtocol: usbByte,
-			}),
-		)
-		.min(1),
-});
-export type ExpectedDescriptors = z.infer<typeof expectedDescriptorsSchema>;
-
-/** One permitted, certified transition between two MM modes. */
-export const permittedTransitionSchema = z
-	.strictObject({
-		from: mmMode,
-		to: mmMode,
-		/** The EXACT AT command that performs the switch (allowlisted at send time). */
-		atCommand: z.string().min(1),
-		/** The AT response expected on success (e.g. `OK`) — never proof on its own. */
-		expectedResponse: z.string().min(1),
-		/** Whether the control port is expected to drop after the command is written. */
-		expectsPortDrop: z.boolean(),
-		/** The descriptors the device must present after re-enumerating — the postcondition. */
-		expectedDescriptors: expectedDescriptorsSchema,
-		/** sha256 of the evidence bundle that certified this transition (A6.2 fills it). */
-		evidenceBundleSha256: z
-			.string()
-			.regex(/^[0-9a-f]{64}$/)
-			.optional(),
-	})
-	.refine((t) => t.from !== t.to, { message: 'a transition must change mode (from !== to)' });
-export type PermittedTransition = z.infer<typeof permittedTransitionSchema>;
-
-/** One certified SKU: its discriminator, canonical mode, and permitted transitions. */
-export const catalogEntrySchema = z
-	.strictObject({
-		/** VID:PID, lowercase hex, `xxxx:xxxx`. */
-		vidPid: z.string().regex(/^[0-9a-f]{4}:[0-9a-f]{4}$/),
-		/** The server-derived model string (a discriminator, not free text). */
-		model: z.string().min(1),
-		/** The firmware-revision prefix that discriminates this personality. */
-		firmwarePrefix: z.string().min(1),
-		/** The mode this SKU speaks as certified. */
-		canonicalMode,
-		/** The certified transitions — empty for a non-MM (router/rndis) SKU. */
-		permittedTransitions: z.array(permittedTransitionSchema),
-	})
-	.refine(
-		(e) =>
-			e.permittedTransitions.length === 0 ||
-			(MM_USB_MODES as readonly string[]).includes(e.canonicalMode),
-		{ message: 'only an MM-mode SKU (qmi/mbim/ecm-ncm) may declare permitted transitions' },
-	);
-export type CatalogEntry = z.infer<typeof catalogEntrySchema>;
-
-/** The whole certified catalog file. */
-export const certifiedCatalogSchema = z.strictObject({
-	schemaVersion: z.literal(1),
-	entries: z.array(catalogEntrySchema),
-});
-export type CertifiedCatalog = z.infer<typeof certifiedCatalogSchema>;
-
-/** A live device's SKU discriminator — matched against the catalog. */
-export interface SkuDiscriminator {
-	readonly vidPid: string;
-	readonly model: string;
-	readonly firmwarePrefix: string;
-}

package/src/usb-mode/certified-catalog.json

@@ -1,67 +0,0 @@
-{
-	"schemaVersion": 1,
-	"entries": [
-		{
-			"vidPid": "2c7c:0125",
-			"model": "CERALIVE-SYNTHETIC-TEST-SKU",
-			"firmwarePrefix": "SYNTHETICFW01",
-			"canonicalMode": "qmi",
-			"permittedTransitions": [
-				{
-					"from": "qmi",
-					"to": "mbim",
-					"atCommand": "AT+QCFG=\"usbnet\",2",
-					"expectedResponse": "OK",
-					"expectsPortDrop": true,
-					"expectedDescriptors": {
-						"deviceClass": 0,
-						"interfaces": [
-							{ "interfaceClass": 2, "interfaceSubClass": 14, "interfaceProtocol": 0 },
-							{ "interfaceClass": 10, "interfaceSubClass": 0, "interfaceProtocol": 2 }
-						]
-					}
-				},
-				{
-					"from": "mbim",
-					"to": "qmi",
-					"atCommand": "AT+QCFG=\"usbnet\",0",
-					"expectedResponse": "OK",
-					"expectsPortDrop": true,
-					"expectedDescriptors": {
-						"deviceClass": 0,
-						"interfaces": [
-							{ "interfaceClass": 255, "interfaceSubClass": 255, "interfaceProtocol": 255 }
-						]
-					}
-				},
-				{
-					"from": "qmi",
-					"to": "ecm-ncm",
-					"atCommand": "AT+QCFG=\"usbnet\",1",
-					"expectedResponse": "OK",
-					"expectsPortDrop": true,
-					"expectedDescriptors": {
-						"deviceClass": 0,
-						"interfaces": [
-							{ "interfaceClass": 2, "interfaceSubClass": 6, "interfaceProtocol": 0 },
-							{ "interfaceClass": 255, "interfaceSubClass": 255, "interfaceProtocol": 255 }
-						]
-					}
-				},
-				{
-					"from": "ecm-ncm",
-					"to": "qmi",
-					"atCommand": "AT+QCFG=\"usbnet\",0",
-					"expectedResponse": "OK",
-					"expectsPortDrop": true,
-					"expectedDescriptors": {
-						"deviceClass": 0,
-						"interfaces": [
-							{ "interfaceClass": 255, "interfaceSubClass": 255, "interfaceProtocol": 255 }
-						]
-					}
-				}
-			]
-		}
-	]
-}

package/src/usb-mode/index.ts

@@ -1,58 +0,0 @@
-// The certified USB-mode catalog — schema, data, lookups, and the evidence-bundle
-// ingestion seam.
-//
-// A6.1's bench CLI (`set-usb-mode`) and A6.2's `certify` tool both consume this: the
-// CLI looks up the permitted transition for a target mode, `certify` validates a
-// candidate entry against the schema before a human commits it.
-//
-// The ingestion seam (`./ingestion`, `./promotion-review`) is the documented path from a
-// captured `certify` bundle to a reviewed catalog commit — see `docs/CATALOG-INGESTION.md`.
-// It refuses a `synthetic: true` bundle for catalog promotion, by construction.
-
-export {
-	CERTIFIED_CATALOG,
-	findCatalogEntry,
-	findPermittedTransition,
-	loadCertifiedCatalog,
-} from './catalog';
-export {
-	CANONICAL_USB_MODES,
-	type CanonicalUsbMode,
-	type CatalogEntry,
-	type CertifiedCatalog,
-	catalogEntrySchema,
-	certifiedCatalogSchema,
-	type ExpectedDescriptors,
-	expectedDescriptorsSchema,
-	MM_USB_MODES,
-	type MmUsbMode,
-	type PermittedTransition,
-	permittedTransitionSchema,
-	type SkuDiscriminator,
-} from './catalog-schema';
-export {
-	buildCatalogEntryCandidate,
-	buildClassifierFixture,
-	type CatalogClaim,
-	CLAIMABLE_CANONICAL_MODES,
-	type ClassifierFixture,
-	type EvidenceBundleView,
-	evidenceBundleViewSchema,
-	type FixtureProvenance,
-	type IngestionOutcome,
-	type IngestionRefusal,
-	type IngestionRefusalReason,
-	type IngestionRequest,
-	parseIngestionRequest,
-} from './ingestion';
-export {
-	type PromotionContext,
-	type PromotionRequest,
-	renderPromotionReview,
-} from './promotion-review';
-export {
-	type ParsedUsbDevice,
-	type ParsedUsbInterface,
-	parseUsbDevices,
-	selectUniqueDevice,
-} from './usb-devices-parse';

package/src/usb-mode/ingestion.test.ts

@@ -1,268 +0,0 @@
-// The ingestion seam's contract: a bundle round-trips into a schema-valid catalog entry
-// and a real-shaped classifier fixture, the sha256 links the two, and a synthetic bundle
-// is REFUSED for catalog promotion with a typed reason rather than silently accepted.
-
-import { describe, expect, test } from 'bun:test';
-import { classifyDevice, detectUsbMode } from '../backend/device-classifier';
-import { catalogEntrySchema } from './catalog-schema';
-import {
-	buildCatalogEntryCandidate,
-	buildClassifierFixture,
-	type IngestionRequest,
-	parseIngestionRequest,
-} from './ingestion';
-import { renderPromotionReview } from './promotion-review';
-import { parseUsbDevices, selectUniqueDevice } from './usb-devices-parse';
-
-const SHA = 'a'.repeat(64);
-
-/** Verbatim-shaped `usb-devices` output for a QMI stick plus one unrelated hub. */
-const USB_DEVICES = `
-T:  Bus=04 Lev=01 Prnt=01 Port=00 Cnt=01 Dev#=  2 Spd=5000 MxCh= 4
-D:  Ver= 3.20 Cls=09(hub  ) Sub=00 Prot=03 MxPS= 9 #Cfgs=  1
-P:  Vendor=0bda ProdID=0411 Rev=01.01
-S:  Manufacturer=Generic
-S:  Product=USB3.2 Hub
-I:  If#= 0 Alt= 0 #EPs= 1 Cls=09(hub  ) Sub=00 Prot=00 Driver=hub
-
-T:  Bus=04 Lev=03 Prnt=04 Port=03 Cnt=01 Dev#=  7 Spd=480 MxCh= 0
-D:  Ver= 2.00 Cls=00(>ifc ) Sub=00 Prot=00 MxPS=64 #Cfgs=  1
-P:  Vendor=2c7c ProdID=0125 Rev=03.18
-S:  Manufacturer=Quectel
-S:  Product=SYNTHETIC-BENCH-STICK
-I:  If#= 2 Alt= 0 #EPs= 3 Cls=ff(vend.) Sub=00 Prot=00 Driver=option
-I:  If#= 4 Alt= 0 #EPs= 3 Cls=ff(vend.) Sub=ff Prot=ff Driver=qmi_wwan
-`;
-
-function bundle(overrides: Record<string, unknown> = {}): Record<string, unknown> {
-	return {
-		schemaVersion: 1,
-		synthetic: false,
-		capturedAtMs: 1_760_000_000_000,
-		slot: 'Modem/2',
-		sku: {
-			vidPid: '2c7c:0125',
-			model: 'CERALIVE-SYNTHETIC-TEST-SKU',
-			firmwarePrefix: 'SYNTHETICFW01',
-		},
-		usb: {
-			usbDevices: USB_DEVICES,
-			udevProperties: {
-				ID_PATH: 'platform-xhci-hcd.0.auto-usb-0:1.4.4',
-				ID_VENDOR_ID: '2c7c',
-				ID_MODEL_ID: '0125',
-				INTERFACE: 'wwan0',
-			},
-		},
-		// Fields the real bundle carries and the ingestion VIEW deliberately ignores.
-		usbExtra: { lsusb: 'Device Descriptor:' },
-		modemManager: { mmcliKeyfile: {}, managedObjects: {}, signalWindow: [] },
-		...overrides,
-	};
-}
-
-const request = (overrides: Record<string, unknown> = {}, sha = SHA): IngestionRequest => ({
-	bundle: bundle(overrides),
-	bundleSha256: sha,
-});
-
-const TRANSITION = {
-	from: 'qmi',
-	to: 'mbim',
-	atCommand: 'AT+QCFG="usbnet",2',
-	expectedResponse: 'OK',
-	expectsPortDrop: true,
-	afterDescriptors: {
-		deviceClass: 0,
-		interfaces: [
-			{ interfaceClass: 2, interfaceSubClass: 14, interfaceProtocol: 0 },
-			{ interfaceClass: 10, interfaceSubClass: 0, interfaceProtocol: 2 },
-		],
-	},
-	timeline: [{ event: 'command-sent', atMs: 1 }],
-};
-
-describe('parseUsbDevices — the descriptor source a base bundle actually carries', () => {
-	test('parses every device, its bDeviceClass, and each interface driver', () => {
-		const devices = parseUsbDevices(USB_DEVICES);
-		expect(devices).toHaveLength(2);
-		const stick = devices[1];
-		expect(stick?.vidPid).toBe('2c7c:0125');
-		expect(stick?.bDeviceClass).toBe(0);
-		expect(stick?.product).toBe('SYNTHETIC-BENCH-STICK');
-		expect(stick?.interfaces).toEqual([
-			{ interfaceClass: 0xff, interfaceSubClass: 0x00, interfaceProtocol: 0x00, driver: 'option' },
-			{
-				interfaceClass: 0xff,
-				interfaceSubClass: 0xff,
-				interfaceProtocol: 0xff,
-				driver: 'qmi_wwan',
-			},
-		]);
-	});
-
-	test('a block with no P: line yields no record — identity is never invented', () => {
-		expect(parseUsbDevices('T:  Bus=01\nI:  If#= 0 Cls=ff Sub=ff Prot=ff Driver=x')).toEqual([]);
-	});
-
-	test('a duplicate VID:PID is AMBIGUOUS, not first-wins (the Huawei HiLink pair)', () => {
-		const pair = `${USB_DEVICES}\nT:  Bus=01 Lev=01\nD:  Cls=00\nP:  Vendor=2c7c ProdID=0125 Rev=03.18\nI:  If#= 0 Cls=ff Sub=ff Prot=ff Driver=qmi_wwan\n`;
-		const selected = selectUniqueDevice(parseUsbDevices(pair), '2c7c:0125');
-		expect(selected).toEqual({ ambiguousMatches: 2 });
-	});
-});
-
-describe('buildClassifierFixture — the real udev shape, not a hand-typed approximation', () => {
-	test('produces a snapshot the REAL classifier classifies correctly', () => {
-		const outcome = buildClassifierFixture(request());
-		expect(outcome.ok).toBe(true);
-		if (!outcome.ok) {
-			return;
-		}
-		const { snapshot, provenance } = outcome.value;
-		expect(snapshot.vendorId).toBe('2c7c');
-		expect(snapshot.productId).toBe('0125');
-		expect(snapshot.model).toBe('CERALIVE-SYNTHETIC-TEST-SKU');
-		expect(snapshot.firmwareRevision).toBe('SYNTHETICFW01');
-		expect(snapshot.physicalUid).toBe('platform-xhci-hcd.0.auto-usb-0:1.4.4');
-		expect(snapshot.ifname).toBe('wwan0');
-		// The whole point of deriving from real capture text: the fixture must survive
-		// the production classifier, not merely typecheck.
-		expect(classifyDevice(snapshot).deviceClass).toBe('mm-managed');
-		expect(detectUsbMode(snapshot)).toBe('qmi');
-		expect(provenance.bundleSha256).toBe(SHA);
-		expect(provenance.synthetic).toBe(false);
-	});
-
-	test('a SYNTHETIC bundle still yields a fixture, stamped synthetic in provenance', () => {
-		const outcome = buildClassifierFixture(request({ synthetic: true }));
-		expect(outcome.ok).toBe(true);
-		if (outcome.ok) {
-			expect(outcome.value.provenance.synthetic).toBe(true);
-		}
-	});
-
-	test('refuses a bundle with no sku (blocker B2 shape) rather than inventing one', () => {
-		const outcome = buildClassifierFixture(request({ sku: undefined }));
-		expect(outcome).toMatchObject({ ok: false, reason: 'sku-missing' });
-	});
-
-	test('refuses when the SKU is absent from the usb-devices capture', () => {
-		const outcome = buildClassifierFixture(
-			request({ sku: { ...(bundle().sku as object), vidPid: '1199:9071' } }),
-		);
-		expect(outcome).toMatchObject({ ok: false, reason: 'device-not-in-capture' });
-	});
-});
-
-describe('buildCatalogEntryCandidate — schema round-trip and sha linkage', () => {
-	test('a stage-1 bundle yields an entry with NO permitted transitions', () => {
-		const outcome = buildCatalogEntryCandidate(request(), { canonicalMode: 'qmi' });
-		expect(outcome.ok).toBe(true);
-		if (!outcome.ok) {
-			return;
-		}
-		expect(outcome.value.permittedTransitions).toEqual([]);
-		// Round-trip through the AUTHORITATIVE schema, not the builder's own view.
-		expect(catalogEntrySchema.parse(outcome.value)).toEqual(outcome.value);
-	});
-
-	test('a stage-2 bundle links the transition to THIS bundle sha256', () => {
-		const sha = 'b'.repeat(64);
-		const outcome = buildCatalogEntryCandidate(
-			{ bundle: bundle({ transition: TRANSITION }), bundleSha256: sha },
-			{ canonicalMode: 'qmi' },
-		);
-		expect(outcome.ok).toBe(true);
-		if (!outcome.ok) {
-			return;
-		}
-		const [transition] = outcome.value.permittedTransitions;
-		expect(transition?.evidenceBundleSha256).toBe(sha);
-		expect(transition?.expectedDescriptors).toEqual(TRANSITION.afterDescriptors);
-		expect(transition?.atCommand).toBe('AT+QCFG="usbnet",2');
-		expect(catalogEntrySchema.parse(outcome.value)).toEqual(outcome.value);
-	});
-
-	test('REFUSES a synthetic:true bundle for catalog promotion — typed, not silent', () => {
-		const outcome = buildCatalogEntryCandidate(request({ synthetic: true }), {
-			canonicalMode: 'qmi',
-		});
-		expect(outcome.ok).toBe(false);
-		if (outcome.ok) {
-			return;
-		}
-		expect(outcome.reason).toBe('synthetic-bundle');
-		expect(outcome.detail).toContain('synthetic:true');
-	});
-
-	test('refuses a claimed mode that contradicts the captured transition.from', () => {
-		const outcome = buildCatalogEntryCandidate(
-			{ bundle: bundle({ transition: TRANSITION }), bundleSha256: SHA },
-			{ canonicalMode: 'mbim' },
-		);
-		expect(outcome).toMatchObject({ ok: false, reason: 'transition-mode-mismatch' });
-	});
-
-	test('refuses a router-mode SKU that carries a transition (schema invariant)', () => {
-		const outcome = buildCatalogEntryCandidate(
-			{ bundle: bundle({ transition: TRANSITION }), bundleSha256: SHA },
-			{ canonicalMode: 'router-ethernet' },
-		);
-		// The mode cross-check fires first; either refusal is correct, neither is an accept.
-		expect(outcome.ok).toBe(false);
-	});
-
-	test('accepts a router-mode SKU with no transitions (the RB-15 shape)', () => {
-		const outcome = buildCatalogEntryCandidate(request(), { canonicalMode: 'router-ethernet' });
-		expect(outcome.ok).toBe(true);
-		if (outcome.ok) {
-			expect(outcome.value.canonicalMode).toBe('router-ethernet');
-			expect(outcome.value.permittedTransitions).toEqual([]);
-		}
-	});
-
-	test('refuses a malformed sha256 before reading the bundle at all', () => {
-		expect(parseIngestionRequest({ bundle: bundle(), bundleSha256: 'nope' })).toMatchObject({
-			ok: false,
-			reason: 'sha256-malformed',
-		});
-	});
-
-	test('refuses a bundle that fails the view schema', () => {
-		expect(
-			parseIngestionRequest({ bundle: { schemaVersion: 2 }, bundleSha256: SHA }),
-		).toMatchObject({ ok: false, reason: 'bundle-malformed' });
-	});
-});
-
-describe('renderPromotionReview — the review artifact, including for refusals', () => {
-	test('renders the entry, the fixture, and a checklist on success', () => {
-		const req = request();
-		const comment = renderPromotionReview({
-			context: { runbook: 'RB-11', evidencePath: 'test-results/modem-phase-b/08/x/bundle.json' },
-			entry: buildCatalogEntryCandidate(req, { canonicalMode: 'qmi' }),
-			fixture: buildClassifierFixture(req),
-		});
-		expect(comment).toContain('Proposed `certified-catalog.json` entry');
-		expect(comment).toContain('Proposed classifier fixture');
-		expect(comment).toContain('Reviewer checklist');
-		expect(comment).toContain('RB-11');
-		expect(comment).toContain('**This comment promotes');
-	});
-
-	test('a refused promotion renders the refusal and NO checklist', () => {
-		const req = request({ synthetic: true });
-		const comment = renderPromotionReview({
-			context: { runbook: 'RB-11', evidencePath: 'x.json' },
-			entry: buildCatalogEntryCandidate(req, { canonicalMode: 'qmi' }),
-			fixture: buildClassifierFixture(req),
-		});
-		expect(comment).toContain('Catalog entry — REFUSED');
-		expect(comment).toContain('`synthetic-bundle`');
-		expect(comment).toContain('### No checklist');
-		expect(comment).not.toContain('Reviewer checklist');
-		// The fixture half still renders — synthetic fixtures are legitimate test data.
-		expect(comment).toContain('Derived from a **synthetic** bundle');
-	});
-});