@svta/cml-cmcd 2.7.0 → 2.8.0

package/dist/index.js

@@ -1,98 +1,315 @@
 import { SfItem, SfToken, decodeSfDict, encodeSfDict, symbolToStr } from "@svta/cml-structured-field-values";
 import { getBaseUrl, urlToRelativePath, uuid } from "@svta/cml-utils";
 
-//#region src/CMCD_AGGREGATE_BITRATE_KEYS.ts
+//#region src/CMCD_INNER_LIST_KEYS.ts
 /**
-* Maps each aggregate bitrate key to the exact bitrate key that supersedes it.
+* Inner-list keys in version 2 that are scalars in version 1.
 *
-* Per CTA-5004-B, `ab` MUST NOT be sent when the encoded bitrate `br` is
-* known. `lab` and `tab` follow the same rule for the lowest bitrate `lb`
-* and the top bitrate `tb`.
+* Used by both encoding (down-conversion) and decoding (up-conversion).
 *
 * @internal
 */
-const CMCD_AGGREGATE_BITRATE_KEYS = {
-	ab: "br",
-	lab: "lb",
-	tab: "tb"
-};
-
-//#endregion
-//#region src/CMCD_FORMATTER_MAP.ts
-const roundValue = (value) => {
-	if (value instanceof SfItem) return new SfItem(Math.round(value.value), value.params);
-	return Math.round(value);
-};
-const toRounded = (value) => {
-	if (Array.isArray(value)) return value.map(roundValue);
-	return roundValue(value);
-};
-const toUrlSafe = (value, options) => {
-	if (Array.isArray(value)) return value.map((item) => toUrlSafe(item, options));
-	if (value instanceof SfItem && typeof value.value === "string") return new SfItem(toUrlSafe(value.value, options), value.params);
-	else {
-		if (options.baseUrl) value = urlToRelativePath(value, getBaseUrl(options.baseUrl));
-		return options.version === 1 ? encodeURIComponent(value) : value;
-	}
-};
-const hundredValue = (value) => {
-	if (value instanceof SfItem) return new SfItem(Math.round(value.value / 100) * 100, value.params);
-	return Math.round(value / 100) * 100;
-};
-const toHundred = (value) => {
-	if (Array.isArray(value)) return value.map(hundredValue);
-	return hundredValue(value);
-};
-const nor = (value, options) => {
-	let norValue = value;
-	if (options.version >= 2) {
-		if (value instanceof SfItem && typeof value.value === "string") norValue = new SfItem([value]);
-		else if (typeof value === "string") norValue = [value];
-	}
-	return toUrlSafe(norValue, options);
-};
-/**
-* The default formatters for CMCD values.
-*
-* @public
-*/
-const CMCD_FORMATTER_MAP = {
-	br: toRounded,
-	d: toRounded,
-	bl: toHundred,
-	dl: toHundred,
-	mtp: toHundred,
-	nor,
-	rtp: toHundred,
-	tb: toRounded
-};
+const CMCD_INNER_LIST_KEYS = new Set([
+	"ab",
+	"bl",
+	"br",
+	"bsa",
+	"bsd",
+	"bsda",
+	"lab",
+	"lb",
+	"mtp",
+	"pb",
+	"tab",
+	"tb",
+	"tbl",
+	"tpb"
+]);
 
 //#endregion
-//#region src/CMCD_KEY_OBJECT_TYPES.ts
+//#region src/CMCD_KEY_SPECS.ts
+const MEDIA = [
+	"a",
+	"v",
+	"av",
+	"tt",
+	"c",
+	"o"
+];
 /**
-* Maps a key to the object types (`ot`) for which CTA-5004-B allows the key.
-*
-* A key that is absent from this map is allowed for every object type.
-* `d` (Object duration) and `tpb` (Top playable bitrate) MUST NOT be sent for
-* other object types.
+* The encoder rules of each key. The table has one row for each key of CTA-5004-B Table 1, plus `nrr` of CTA-5004 and `cdn`.
 *
 * @internal
 */
-const CMCD_KEY_OBJECT_TYPES = {
-	d: [
-		"a",
-		"v",
-		"av",
-		"tt",
-		"c",
-		"o"
-	],
-	tpb: [
-		"a",
-		"v",
-		"av",
-		"c"
-	]
+const CMCD_KEY_SPECS = {
+	ab: {
+		type: "ot-list",
+		round: 1,
+		supersededBy: "br",
+		version: 2
+	},
+	bg: {
+		type: "boolean",
+		omitDefault: false,
+		requiredOn: "b",
+		version: 2
+	},
+	bl: {
+		type: "ot-list",
+		round: 100
+	},
+	br: {
+		type: "ot-list",
+		round: 1,
+		requiredOn: "bc"
+	},
+	bs: {
+		type: "boolean",
+		omitDefault: false
+	},
+	bsa: {
+		type: "ot-list",
+		round: 1,
+		version: 2
+	},
+	bsd: {
+		type: "ot-list",
+		round: 1,
+		version: 2
+	},
+	bsda: {
+		type: "ot-list",
+		round: 1,
+		version: 2
+	},
+	cdn: {
+		type: "string",
+		max: 128,
+		version: 2
+	},
+	cen: {
+		type: "string",
+		max: 64,
+		mode: "event",
+		onlyOn: "ce",
+		requiredOn: "ce",
+		version: 2
+	},
+	cid: {
+		type: "string",
+		max: 128,
+		v1Max: 64,
+		requiredOn: "c"
+	},
+	cmsdd: {
+		type: "string",
+		mode: "event",
+		onlyOn: "rr",
+		version: 2
+	},
+	cmsds: {
+		type: "string",
+		mode: "event",
+		onlyOn: "rr",
+		version: 2
+	},
+	cs: {
+		type: "string",
+		version: 2
+	},
+	d: {
+		type: "integer",
+		round: 1,
+		ot: MEDIA
+	},
+	dfa: {
+		type: "integer",
+		round: 1,
+		version: 2
+	},
+	dl: {
+		type: "integer",
+		round: 100
+	},
+	e: {
+		type: "token",
+		mode: "event",
+		requiredOn: "always",
+		version: 2
+	},
+	ec: {
+		type: "string-list",
+		requiredOn: "e",
+		version: 2
+	},
+	h: {
+		type: "string",
+		max: 128,
+		mode: "event",
+		requiredOn: "h",
+		version: 2
+	},
+	lab: {
+		type: "ot-list",
+		round: 1,
+		supersededBy: "lb",
+		version: 2
+	},
+	lb: {
+		type: "ot-list",
+		round: 1,
+		version: 2
+	},
+	ltc: {
+		type: "integer",
+		round: 1,
+		version: 2
+	},
+	msd: {
+		type: "integer",
+		round: 1,
+		version: 2
+	},
+	mtp: {
+		type: "ot-list",
+		round: 100
+	},
+	nor: { type: "nor" },
+	nr: {
+		type: "boolean",
+		omitDefault: false,
+		version: 2
+	},
+	nrr: {
+		type: "string",
+		version: 1
+	},
+	ot: { type: "token" },
+	pb: {
+		type: "ot-list",
+		round: 1,
+		version: 2
+	},
+	pr: {
+		type: "decimal",
+		omitDefault: 1,
+		requiredOn: "pr"
+	},
+	pt: {
+		type: "integer",
+		round: 1,
+		version: 2
+	},
+	rc: {
+		type: "integer",
+		round: 1,
+		mode: "event",
+		onlyOn: "rr",
+		version: 2
+	},
+	rtp: {
+		type: "integer",
+		round: 100
+	},
+	sf: {
+		type: "token",
+		v1Map: { e: "o" }
+	},
+	sid: {
+		type: "string",
+		max: 64
+	},
+	smrt: {
+		type: "string",
+		mode: "event",
+		onlyOn: "rr",
+		version: 2
+	},
+	sn: {
+		type: "integer",
+		round: 1,
+		version: 2
+	},
+	st: {
+		type: "token",
+		v1Map: { ll: "l" }
+	},
+	sta: {
+		type: "token",
+		requiredOn: "ps",
+		version: 2
+	},
+	su: {
+		type: "boolean",
+		omitDefault: false
+	},
+	tab: {
+		type: "ot-list",
+		round: 1,
+		supersededBy: "tb",
+		version: 2
+	},
+	tb: {
+		type: "ot-list",
+		round: 1
+	},
+	tbl: {
+		type: "ot-list",
+		round: 100,
+		version: 2
+	},
+	tpb: {
+		type: "ot-list",
+		round: 1,
+		ot: [
+			"a",
+			"v",
+			"av",
+			"c"
+		],
+		version: 2
+	},
+	ts: {
+		type: "integer",
+		round: 1,
+		mode: "event",
+		requiredOn: "always",
+		version: 2
+	},
+	ttfb: {
+		type: "integer",
+		round: 1,
+		mode: "event",
+		onlyOn: "rr",
+		version: 2
+	},
+	ttfbb: {
+		type: "integer",
+		round: 1,
+		mode: "event",
+		onlyOn: "rr",
+		version: 2
+	},
+	ttlb: {
+		type: "integer",
+		round: 1,
+		mode: "event",
+		onlyOn: "rr",
+		version: 2
+	},
+	url: {
+		type: "string",
+		mode: "event",
+		onlyOn: "rr",
+		requiredOn: "rr",
+		version: 2
+	},
+	v: {
+		type: "integer",
+		round: 1,
+		requiredOn: "always",
+		version: 2
+	}
 };
 
 //#endregion
@@ -105,998 +322,1122 @@ const CMCD_KEY_OBJECT_TYPES = {
 const CMCD_V2 = 2;
 
 //#endregion
-//#region src/CmcdEventType.ts
+//#region src/CmcdReportingMode.ts
 /**
-* CMCD event type 'bc' (bitrate change).
+* CMCD event mode variable name.
 *
 * @public
 */
-const CMCD_EVENT_BITRATE_CHANGE = "bc";
+const CMCD_EVENT_MODE = "event";
 /**
-* CMCD event type 'ps' (play state change).
+* CMCD request mode variable name.
 *
 * @public
 */
-const CMCD_EVENT_PLAY_STATE = "ps";
+const CMCD_REQUEST_MODE = "request";
 /**
-* CMCD event type 'pr' (playback rate change).
+* CMCD reporting mode types.
 *
-* @public
-*/
-const CMCD_EVENT_PLAYBACK_RATE = "pr";
-/**
-* CMCD event type 'e' (error).
+* @enum
 *
 * @public
 */
-const CMCD_EVENT_ERROR = "e";
+const CmcdReportingMode = {
+	REQUEST: CMCD_REQUEST_MODE,
+	EVENT: CMCD_EVENT_MODE
+};
+
+//#endregion
+//#region src/downConvertToV1.ts
+function hasParams(params) {
+	for (const _ in params) return true;
+	return false;
+}
 /**
-* CMCD event type 't' (time interval).
+* Unwrap an inner list or SfItem value to a scalar.
 *
-* @public
+* The scalar is the value of the item with the object type flag of `ot`
+* (CTA-5004-B section 4.1, item 14). Without that item, it is the value
+* of the first item without parameters. Otherwise it is `undefined`.
 */
-const CMCD_EVENT_TIME_INTERVAL = "t";
+function unwrapValue(value, ot) {
+	if (value instanceof SfItem) value = value.value;
+	if (!Array.isArray(value)) return value;
+	let fallback;
+	for (const item of value) {
+		if (!(item instanceof SfItem)) {
+			if (fallback === void 0) fallback = item;
+			continue;
+		}
+		if (ot && item.params?.[ot] === true) return item.value;
+		if (fallback === void 0 && !hasParams(item.params)) fallback = item.value;
+	}
+	return fallback;
+}
 /**
-* CMCD event type 'c' (content ID).
+* Down-convert version 2 CMCD data to version 1.
 *
-* @public
-*/
-const CMCD_EVENT_CONTENT_ID = "c";
-/**
-* CMCD event type 'b' (backgrounded mode).
+* - Extracts `nrr` from the `nor` SfItem's `r` parameter.
+* - Unwraps inner-list values to scalars for the object type `ot`.
 *
-* @public
+* @internal
 */
-const CMCD_EVENT_BACKGROUNDED_MODE = "b";
+function downConvertToV1(obj, ot) {
+	const result = {};
+	for (const [key, value] of Object.entries(obj)) {
+		if (value == null) {
+			result[key] = value;
+			continue;
+		}
+		if (key === "nor") {
+			const list = value instanceof SfItem && Array.isArray(value.value) ? value.value : value;
+			const first = Array.isArray(list) ? list[0] : list;
+			if (first instanceof SfItem) {
+				result["nor"] = first.value;
+				if (first.params?.r) result["nrr"] = first.params.r;
+			} else result["nor"] = first;
+		} else if (CMCD_INNER_LIST_KEYS.has(key)) result[key] = unwrapValue(value, ot);
+		else result[key] = value;
+	}
+	return result;
+}
+
+//#endregion
+//#region src/isCmcdCustomKey.ts
+const CUSTOM_KEY_REGEX = /^[a-z][a-z0-9.-]*$/;
 /**
-* CMCD event type 'm' (mute).
+* Check if a key is a valid custom key: a lowercase first letter, then
+* characters from `a-z 0-9 . -`. The key needs a hyphen, not at the start
+* or end. This check applies the CTA-5004-B custom-key rules, restricted
+* to names that RFC 8941 key serialization accepts.
 *
-* @public
-*/
-const CMCD_EVENT_MUTE = "m";
-/**
-* CMCD event type 'um' (unmute).
+* @param key - The key to check.
 *
-* @public
-*/
-const CMCD_EVENT_UNMUTE = "um";
-/**
-* CMCD event type 'pe' (player expand).
+* @returns `true` if the key is a custom key, `false` otherwise.
 *
 * @public
-*/
-const CMCD_EVENT_PLAYER_EXPAND = "pe";
-/**
-* CMCD event type 'pc' (player collapse).
 *
-* @public
+* @example
+* {@includeCode ../test/isCmcdCustomKey.test.ts#example}
 */
-const CMCD_EVENT_PLAYER_COLLAPSE = "pc";
+function isCmcdCustomKey(key) {
+	const separator = key.indexOf("-", 1);
+	return separator > 0 && separator < key.length - 1 && CUSTOM_KEY_REGEX.test(key);
+}
+
+//#endregion
+//#region src/getKeySpec.ts
+const CUSTOM_KEY_SPEC = {
+	type: "custom",
+	omitDefault: false,
+	max: 64,
+	v1Max: Infinity
+};
 /**
-* CMCD event type 'rr' (response received).
+* Returns the row of a key in the key table.
 *
-* @public
-*/
-const CMCD_EVENT_RESPONSE_RECEIVED = "rr";
-/**
-* CMCD event type 'as' (ad start).
+* @param key - The key to look up.
 *
-* @public
-*/
-const CMCD_EVENT_AD_START = "as";
-/**
-* CMCD event type 'ae' (ad end).
+* @returns The row of a reserved key, the custom row for a valid custom key, or `undefined`.
 *
-* @public
+* @internal
 */
-const CMCD_EVENT_AD_END = "ae";
+function getKeySpec(key) {
+	if (Object.prototype.hasOwnProperty.call(CMCD_KEY_SPECS, key)) return CMCD_KEY_SPECS[key];
+	return isCmcdCustomKey(key) ? CUSTOM_KEY_SPEC : void 0;
+}
+
+//#endregion
+//#region src/isValid.ts
 /**
-* CMCD event type 'abs' (ad break start).
+* Checks if the given value is valid to send as a CMCD value.
 *
-* @public
-*/
-const CMCD_EVENT_AD_BREAK_START = "abs";
-/**
-* CMCD event type 'abe' (ad break end).
+* `undefined`, `null`, an empty string, `false`, an empty array, and a
+* number that is not finite are not valid. CTA-5004-B requires omitting
+* the key when its value is unknown.
 *
-* @public
-*/
-const CMCD_EVENT_AD_BREAK_END = "abe";
-/**
-* CMCD event type 'sk' (skip).
+* @param value - The value to check.
 *
-* @public
+* @returns `true` if the value is valid.
+*
+* @internal
 */
-const CMCD_EVENT_SKIP = "sk";
+function isValid(value) {
+	if (typeof value === "number") return Number.isFinite(value);
+	if (Array.isArray(value)) return value.length > 0;
+	return value != null && value !== "" && value !== false;
+}
+
+//#endregion
+//#region src/formatNor.ts
+function toBase(baseUrl) {
+	if (!baseUrl) return;
+	try {
+		return new URL(getBaseUrl(baseUrl)).href;
+	} catch {
+		return;
+	}
+}
+function formatPath(path, base, version) {
+	if (typeof path !== "string" || path === "") return;
+	const relative = base ? urlToRelativePath(path, base) : path;
+	return version === 1 ? encodeURIComponent(relative) : relative;
+}
+function formatEntry(entry, base, version) {
+	if (entry instanceof SfItem) {
+		const path = formatPath(entry.value, base, version);
+		return path === void 0 ? void 0 : new SfItem(path, entry.params);
+	}
+	return formatPath(entry, base, version);
+}
+function formatEntries(entries, base, version) {
+	const list = [];
+	for (const entry of entries) {
+		const formatted = formatEntry(entry, base, version);
+		if (formatted !== void 0) list.push(formatted);
+	}
+	return list.length > 0 ? list : void 0;
+}
 /**
-* CMCD event type 'ce' (custom event).
+* Formats a `nor` value. Each path becomes relative to `baseUrl` when `baseUrl` is a valid URL.
+* Version 1 encodes the path with `encodeURIComponent`. Version 2 wraps one path in a list.
+* The parameters of an entry and of an inner list stay on the value.
 *
-* @public
+* @param value - A path, an `SfItem` of a path, or a list of them. An `SfItem` can also wrap the list.
+* @param options - The version and `baseUrl` of the report.
+*
+* @returns The formatted value, or `undefined` when no entry is a non-empty string.
+*
+* @internal
 */
-const CMCD_EVENT_CUSTOM_EVENT = "ce";
+function formatNor(value, options) {
+	const base = toBase(options.baseUrl);
+	const version = options.version;
+	if (Array.isArray(value)) return formatEntries(value, base, version);
+	if (value instanceof SfItem && Array.isArray(value.value)) {
+		const list = formatEntries(value.value, base, version);
+		return list && new SfItem(list, value.params);
+	}
+	const entry = formatEntry(value, base, version);
+	return version === 1 || entry === void 0 ? entry : [entry];
+}
+
+//#endregion
+//#region src/toTokenString.ts
 /**
-* CMCD event types for the 'e' key (event mode).
+* Resolve the text of a token value.
 *
-* @enum
+* A token may be a plain string, a registry `Symbol`, an `SfToken`, or an
+* `SfItem` that wraps such a value.
 *
-* @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#event | CTA-5004-B Event}
+* @param value - The value to resolve.
 *
-* @public
+* @returns The token text, or `undefined` when the value is not a token.
+*
+* @internal
 */
-const CmcdEventType = {
-	BITRATE_CHANGE: CMCD_EVENT_BITRATE_CHANGE,
-	PLAY_STATE: CMCD_EVENT_PLAY_STATE,
-	PLAYBACK_RATE: CMCD_EVENT_PLAYBACK_RATE,
-	ERROR: CMCD_EVENT_ERROR,
-	TIME_INTERVAL: CMCD_EVENT_TIME_INTERVAL,
-	CONTENT_ID: CMCD_EVENT_CONTENT_ID,
-	BACKGROUNDED_MODE: CMCD_EVENT_BACKGROUNDED_MODE,
-	MUTE: CMCD_EVENT_MUTE,
-	UNMUTE: CMCD_EVENT_UNMUTE,
-	PLAYER_EXPAND: CMCD_EVENT_PLAYER_EXPAND,
-	PLAYER_COLLAPSE: CMCD_EVENT_PLAYER_COLLAPSE,
-	RESPONSE_RECEIVED: CMCD_EVENT_RESPONSE_RECEIVED,
-	AD_START: CMCD_EVENT_AD_START,
-	AD_END: CMCD_EVENT_AD_END,
-	AD_BREAK_START: CMCD_EVENT_AD_BREAK_START,
-	AD_BREAK_END: CMCD_EVENT_AD_BREAK_END,
-	SKIP: CMCD_EVENT_SKIP,
-	CUSTOM_EVENT: CMCD_EVENT_CUSTOM_EVENT
-};
+function toTokenString(value) {
+	if (value instanceof SfItem) return toTokenString(value.value);
+	if (typeof value === "string") return value;
+	if (typeof value === "symbol" || value instanceof SfToken) return symbolToStr(value);
+}
 
 //#endregion
-//#region src/CMCD_STATE_EVENT_FIELDS.ts
+//#region src/normalizeValue.ts
+function toText(value, spec, version) {
+	const max = (version === 1 ? spec.v1Max : void 0) ?? spec.max ?? Infinity;
+	return typeof value === "string" && value !== "" && value.length <= max ? value : void 0;
+}
+function normalizeBare(value, spec, version) {
+	switch (spec.type) {
+		case "boolean": return typeof value === "boolean" ? value : void 0;
+		case "integer":
+		case "ot-list": return typeof value === "number" && Number.isFinite(value) ? Math.round(value / spec.round) * spec.round : void 0;
+		case "decimal": return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+		case "string": return toText(value, spec, version);
+		case "string-list": return typeof value === "string" && value !== "" ? value : void 0;
+		case "token": {
+			const text = toTokenString(value);
+			const v1Map = version === 1 ? spec.v1Map : void 0;
+			const token = text !== void 0 && v1Map !== void 0 && Object.prototype.hasOwnProperty.call(v1Map, text) ? v1Map[text] : text;
+			return token ? new SfToken(token) : void 0;
+		}
+		case "custom":
+			if (typeof value === "string") return toText(value, spec, version);
+			if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+			if (Array.isArray(value)) return value.length > 0 ? value : void 0;
+			return typeof value === "boolean" || typeof value === "symbol" || value instanceof SfToken ? value : void 0;
+		default: return;
+	}
+}
+function normalizeItem(value, spec, version) {
+	if (value instanceof SfItem) {
+		const bare = normalizeBare(value.value, spec, version);
+		return bare === void 0 ? void 0 : new SfItem(bare, value.params);
+	}
+	return normalizeBare(value, spec, version);
+}
+function normalizeList(value, spec, version) {
+	const wrapper = value instanceof SfItem && Array.isArray(value.value) ? value : void 0;
+	const items = wrapper ? wrapper.value : Array.isArray(value) ? value : [value];
+	const list = [];
+	for (const item of items) {
+		const normalized = normalizeItem(item, spec, version);
+		if (normalized !== void 0) list.push(normalized);
+	}
+	if (list.length === 0) return;
+	return wrapper ? new SfItem(list, wrapper.params) : list;
+}
 /**
-* Maps each state-change event type to the persistent field whose value
-* the event signals.
+* Applies the value rule of a key type from the key table.
 *
-* Per CTA-5004-B, the state-change events `ps`, `pr`, `c`, `b`, `bc` are
-* state-transition markers. Each event must include the field whose value
-* it signals. Callers force-include the field after filtering
-* (`prepareCmcdData`), deduplicate against its value (`CmcdReporter`), and
-* check its presence in payloads (`validateCmcdStructure`).
+* An `SfItem` keeps its parameters, and the rule applies to the value inside it.
+* In version 2, a list key wraps one value in a list.
+* The rules do not check the limits of RFC 8941, such as the integer range.
 *
-* Iteration order matters: `CmcdReporter.update()` records state-change
-* events in map order when several tracked fields change in one call.
-* Do not reorder entries without auditing reporter behavior.
+* @param value - The value to prepare.
+* @param spec - The row of the key in the key table.
+* @param options - The version and `baseUrl` of the report.
+*
+* @returns The value to send, or `undefined` when the value fails the rule.
 *
 * @internal
 */
-const CMCD_STATE_EVENT_FIELDS = /* @__PURE__ */ new Map([
-	[CMCD_EVENT_PLAY_STATE, "sta"],
-	[CMCD_EVENT_PLAYBACK_RATE, "pr"],
-	[CMCD_EVENT_CONTENT_ID, "cid"],
-	[CMCD_EVENT_BACKGROUNDED_MODE, "bg"],
-	[CMCD_EVENT_BITRATE_CHANGE, "br"]
-]);
+function normalizeValue(value, spec, options) {
+	if (spec.type === "nor") return formatNor(value, options);
+	if (spec.type === "string-list" || spec.type === "ot-list" && options.version !== 1) return normalizeList(value, spec, options.version);
+	return normalizeItem(value, spec, options.version);
+}
 
 //#endregion
-//#region src/CmcdReportingMode.ts
-/**
-* CMCD event mode variable name.
-*
-* @public
-*/
-const CMCD_EVENT_MODE = "event";
+//#region src/toBareValue.ts
 /**
-* CMCD request mode variable name.
+* Returns the value inside an `SfItem`, or the value itself.
 *
-* @public
-*/
-const CMCD_REQUEST_MODE = "request";
-/**
-* CMCD reporting mode types.
+* `decodeCmcd` returns a member with parameters as an `SfItem`. For an
+* inner list with parameters, the value of the `SfItem` is the list.
 *
-* @enum
+* @param value - The value to read.
+* @returns The value without its parameters.
 *
-* @public
+* @internal
 */
-const CmcdReportingMode = {
-	REQUEST: CMCD_REQUEST_MODE,
-	EVENT: CMCD_EVENT_MODE
-};
+function toBareValue(value) {
+	return value instanceof SfItem ? value.value : value;
+}
 
 //#endregion
-//#region src/CMCD_EVENT_KEYS.ts
+//#region src/prepareCmcdData.ts
+function hasKey(spec, reportingMode, isV1) {
+	return (spec.mode === void 0 || spec.mode === reportingMode) && (spec.version === void 0 || spec.version === 1 === isV1);
+}
+function isRequired(spec, event) {
+	return spec.requiredOn === "always" || event !== void 0 && spec.requiredOn === event;
+}
+function hasObjectTypes(spec) {
+	return (spec.type === "integer" || spec.type === "ot-list") && spec.ot !== void 0;
+}
+function needsV1ObjectType(obj, filter) {
+	if (typeof filter !== "function" || filter("ot")) return true;
+	for (const key of CMCD_INNER_LIST_KEYS) if (Array.isArray(toBareValue(obj[key])) && filter(key)) return true;
+	return false;
+}
+function allowsObjectType(spec, objectType) {
+	if (objectType === void 0 || spec.type !== "integer" && spec.type !== "ot-list" || spec.ot === void 0) return true;
+	return spec.ot.includes(objectType);
+}
+function isDefaultValue(spec, value) {
+	return "omitDefault" in spec && toBareValue(value) === spec.omitDefault;
+}
+function insertKey(keys, specs, key) {
+	let index = 0;
+	while (index < keys.length && keys[index] < key) index++;
+	keys.splice(index, 0, key);
+	specs.splice(index, 0, CMCD_KEY_SPECS[key]);
+}
+function prepareValue(key, value, spec, options, formatterOptions) {
+	const formatter = options.formatters?.[key];
+	if (typeof formatter !== "function") return value == null ? void 0 : normalizeValue(value, spec, formatterOptions);
+	const formatted = isValid(value) ? formatter(value, formatterOptions) : value;
+	if (!isValid(formatted) && !(formatted === false && spec.type === "boolean")) return;
+	if (spec.type === "token") {
+		if (typeof formatted === "string") return new SfToken(formatted);
+		if (formatted instanceof SfItem && typeof formatted.value === "string") return new SfItem(new SfToken(formatted.value), formatted.params);
+	}
+	return formatted;
+}
 /**
-* Defines the event-specific keys for CMCD (Common Media Client Data) version 2.
+* Convert a generic object to CMCD data.
+*
+* @param obj - The CMCD object to process.
+* @param options - Options for encoding.
 *
 * @public
+*
+* @example
+* {@includeCode ../test/prepareCmcdData.test.ts#example}
 */
-const CMCD_EVENT_KEYS = [
-	"cen",
-	"e",
-	"h",
-	"ts"
-];
+function prepareCmcdData(obj, options = {}) {
+	const results = {};
+	if (obj == null || typeof obj !== "object") return results;
+	const version = options.version || toBareValue(obj["v"]) || CMCD_V2;
+	const reportingMode = options.reportingMode || CMCD_REQUEST_MODE;
+	const isV1 = version === 1;
+	const isEventReport = !isV1 && reportingMode === CMCD_EVENT_MODE;
+	const formatterOptions = {
+		version,
+		reportingMode,
+		baseUrl: options.baseUrl
+	};
+	const filter = options.filter;
+	let objectTypeValue;
+	let objectType;
+	if (isV1 && needsV1ObjectType(obj, filter)) {
+		objectTypeValue = prepareValue("ot", obj["ot"], CMCD_KEY_SPECS["ot"], options, formatterOptions);
+		objectType = toTokenString(objectTypeValue);
+	}
+	const data = isV1 ? downConvertToV1(obj, objectType) : obj;
+	const eventValue = isEventReport ? prepareValue("e", data["e"], CMCD_KEY_SPECS["e"], options, formatterOptions) : void 0;
+	const event = toTokenString(eventValue);
+	const keys = [];
+	const specs = [];
+	let passed = false;
+	let needsObjectType = false;
+	for (const key of Object.keys(data).sort()) {
+		const spec = getKeySpec(key);
+		if (spec === void 0 || !hasKey(spec, reportingMode, isV1)) continue;
+		if (typeof filter !== "function" || filter(key)) passed = true;
+		else if (!isRequired(spec, event)) continue;
+		if (spec.onlyOn !== void 0 && spec.onlyOn !== event) continue;
+		if (key === "ot" || hasObjectTypes(spec)) needsObjectType = true;
+		keys.push(key);
+		specs.push(spec);
+	}
+	if (!passed && !isEventReport) return results;
+	if (needsObjectType && !isV1) {
+		objectTypeValue = prepareValue("ot", data["ot"], CMCD_KEY_SPECS["ot"], options, formatterOptions);
+		objectType = toTokenString(objectTypeValue);
+	}
+	if (isEventReport && !keys.includes("ts")) insertKey(keys, specs, "ts");
+	if (!isV1 && !keys.includes("v")) insertKey(keys, specs, "v");
+	const values = new Array(keys.length);
+	for (let i = keys.length - 1; i >= 0; i--) {
+		const key = keys[i];
+		const spec = specs[i];
+		if (spec.type === "ot-list" && spec.supersededBy !== void 0) {
+			const exact = keys.indexOf(spec.supersededBy, i + 1);
+			if (exact !== -1 && values[exact] !== void 0) continue;
+		}
+		if (key === "v") values[i] = version;
+		else if (key === "ot") values[i] = objectTypeValue;
+		else if (key === "e") values[i] = eventValue;
+		else if (isV1 || allowsObjectType(spec, objectType)) values[i] = prepareValue(key, data[key], spec, options, formatterOptions);
+		if (key === "ts") {
+			const timestamp = toBareValue(values[i]);
+			if (typeof timestamp !== "number" || !Number.isFinite(timestamp)) values[i] = Date.now();
+		}
+	}
+	for (let i = 0; i < keys.length; i++) {
+		const value = values[i];
+		if (value !== void 0 && (!isDefaultValue(specs[i], value) || isRequired(specs[i], event))) results[keys[i]] = value;
+	}
+	return results;
+}
 
 //#endregion
-//#region src/CMCD_REQUEST_KEYS.ts
+//#region src/CmcdHeaderField.ts
 /**
-* Defines the request-specific keys for CMCD (Common Media Client Data) version 2.
+* CMCD object header name.
 *
 * @public
 */
-const CMCD_REQUEST_KEYS = [
-	"ab",
-	"bg",
-	"bl",
-	"br",
-	"bs",
-	"bsa",
-	"bsd",
-	"bsda",
-	"cdn",
-	"cid",
-	"cs",
-	"d",
-	"dfa",
-	"dl",
-	"ec",
-	"lab",
-	"lb",
-	"ltc",
-	"msd",
-	"mtp",
-	"nor",
-	"nr",
-	"ot",
-	"pb",
-	"pr",
-	"pt",
-	"rtp",
-	"sf",
-	"sid",
-	"sn",
-	"st",
-	"sta",
-	"su",
-	"tab",
-	"tb",
-	"tbl",
-	"tpb",
-	"v"
-];
-
-//#endregion
-//#region src/isCmcdCustomKey.ts
-const CUSTOM_KEY_REGEX = /^[a-z][a-z0-9.-]*$/;
+const CMCD_OBJECT = "CMCD-Object";
 /**
-* Check if a key is a valid custom key: a lowercase first letter, then
-* characters from `a-z 0-9 . -`. The key needs a hyphen, not at the start
-* or end. This check applies the CTA-5004-B custom-key rules, restricted
-* to names that RFC 8941 key serialization accepts.
-*
-* @param key - The key to check.
-*
-* @returns `true` if the key is a custom key, `false` otherwise.
+* CMCD request header name.
 *
 * @public
-*
-* @example
-* {@includeCode ../test/isCmcdCustomKey.test.ts#example}
 */
-function isCmcdCustomKey(key) {
-	const separator = key.indexOf("-", 1);
-	return separator > 0 && separator < key.length - 1 && CUSTOM_KEY_REGEX.test(key);
-}
-
-//#endregion
-//#region src/isCmcdRequestKey.ts
-const CMCD_REQUEST_KEY_SET = /* @__PURE__ */ new Set(CMCD_REQUEST_KEYS);
+const CMCD_REQUEST = "CMCD-Request";
 /**
-* Check if a key is a valid CMCD request key.
-*
-* @param key - The key to check.
-*
-* @returns `true` if the key is a valid CMCD request key, `false` otherwise.
+* CMCD session header name.
 *
 * @public
-*
-* @example
-* {@includeCode ../test/isCmcdRequestKey.test.ts#example}
 */
-function isCmcdRequestKey(key) {
-	return CMCD_REQUEST_KEY_SET.has(key) || isCmcdCustomKey(key);
-}
-
-//#endregion
-//#region src/CMCD_RESPONSE_KEYS.ts
+const CMCD_SESSION = "CMCD-Session";
 /**
-* Response-only and timing keys for version 2.
+* CMCD status header name.
 *
 * @public
 */
-const CMCD_RESPONSE_KEYS = [
-	"cmsdd",
-	"cmsds",
-	"rc",
-	"smrt",
-	"ttfb",
-	"ttfbb",
-	"ttlb",
-	"url"
-];
-
-//#endregion
-//#region src/isCmcdResponseReceivedKey.ts
-const CMCD_RESPONSE_KEY_SET = /* @__PURE__ */ new Set(CMCD_RESPONSE_KEYS);
+const CMCD_STATUS = "CMCD-Status";
 /**
-* Check if a key is a valid CMCD response key.
+* CMCD header fields.
 *
-* @param key - The key to check.
 *
-* @returns `true` if the key is a valid CMCD response key, `false` otherwise.
+* @enum
 *
 * @public
-*
-* @example
-* {@includeCode ../test/isCmcdResponseReceivedKey.test.ts#example}
 */
-function isCmcdResponseReceivedKey(key) {
-	return CMCD_RESPONSE_KEY_SET.has(key);
-}
-
-//#endregion
-//#region src/isCmcdEventKey.ts
-const CMCD_EVENT_KEY_SET = /* @__PURE__ */ new Set(CMCD_EVENT_KEYS);
+const CmcdHeaderField = {
+	OBJECT: CMCD_OBJECT,
+	REQUEST: CMCD_REQUEST,
+	SESSION: CMCD_SESSION,
+	STATUS: CMCD_STATUS
+};
 /**
-* Check if a key is a valid CMCD event key.
-*
-* @param key - The key to check.
-*
-* @returns `true` if the key is a valid CMCD event key, `false` otherwise.
+* All CMCD header fields as an array.
 *
 * @public
-*
-* @example
-* {@includeCode ../test/isCmcdEventKey.test.ts#example}
 */
-function isCmcdEventKey(key) {
-	return isCmcdRequestKey(key) || isCmcdResponseReceivedKey(key) || CMCD_EVENT_KEY_SET.has(key);
-}
+const CMCD_HEADER_FIELDS = [
+	CMCD_OBJECT,
+	CMCD_REQUEST,
+	CMCD_SESSION,
+	CMCD_STATUS
+];
 
 //#endregion
-//#region src/CMCD_INNER_LIST_KEYS.ts
+//#region src/CMCD_HEADER_MAP.ts
 /**
-* Inner-list keys in version 2 that are scalars in version 1.
-*
-* Used by both encoding (down-conversion) and decoding (up-conversion).
+* The map of CMCD keys to their appropriate header shard.
 *
-* @internal
-*/
-const CMCD_INNER_LIST_KEYS = new Set([
-	"ab",
-	"bl",
-	"br",
-	"bsa",
-	"bsd",
-	"bsda",
-	"lab",
-	"lb",
-	"mtp",
-	"pb",
-	"tab",
-	"tb",
-	"tbl",
-	"tpb"
-]);
-
-//#endregion
-//#region src/CMCD_V1_KEYS.ts
-/**
-* Defines the keys for CMCD (Common Media Client Data) version 1.
+* Event-only keys (e, ts, cen, h) and response-received keys (rc, ttfb,
+* ttlb, url, and others) are intentionally absent. They are transmitted
+* in the event-mode POST body, not HTTP headers.
 *
 * @public
 */
-const CMCD_V1_KEYS = [
-	"bl",
-	"br",
-	"bs",
-	"cid",
-	"d",
-	"dl",
-	"mtp",
-	"nor",
-	"nrr",
-	"ot",
-	"pr",
-	"rtp",
-	"sf",
-	"sid",
-	"st",
-	"su",
-	"tb",
-	"v"
-];
+const CMCD_HEADER_MAP = {
+	ab: CMCD_OBJECT,
+	br: CMCD_OBJECT,
+	d: CMCD_OBJECT,
+	lab: CMCD_OBJECT,
+	lb: CMCD_OBJECT,
+	ot: CMCD_OBJECT,
+	tab: CMCD_OBJECT,
+	tb: CMCD_OBJECT,
+	tpb: CMCD_OBJECT,
+	bl: CMCD_REQUEST,
+	cs: CMCD_REQUEST,
+	dfa: CMCD_REQUEST,
+	dl: CMCD_REQUEST,
+	ltc: CMCD_REQUEST,
+	mtp: CMCD_REQUEST,
+	nor: CMCD_REQUEST,
+	nrr: CMCD_REQUEST,
+	pb: CMCD_REQUEST,
+	sn: CMCD_REQUEST,
+	sta: CMCD_REQUEST,
+	su: CMCD_REQUEST,
+	tbl: CMCD_REQUEST,
+	cid: CMCD_SESSION,
+	msd: CMCD_SESSION,
+	sf: CMCD_SESSION,
+	sid: CMCD_SESSION,
+	st: CMCD_SESSION,
+	v: CMCD_SESSION,
+	bg: CMCD_STATUS,
+	bs: CMCD_STATUS,
+	bsa: CMCD_STATUS,
+	bsd: CMCD_STATUS,
+	bsda: CMCD_STATUS,
+	cdn: CMCD_STATUS,
+	ec: CMCD_STATUS,
+	nr: CMCD_STATUS,
+	pr: CMCD_STATUS,
+	pt: CMCD_STATUS,
+	rtp: CMCD_STATUS
+};
 
 //#endregion
-//#region src/isCmcdV1Key.ts
-const CMCD_V1_KEY_SET$1 = /* @__PURE__ */ new Set(CMCD_V1_KEYS);
+//#region src/groupCmcdHeaders.ts
+function createHeaderMap(headerMap) {
+	return Object.keys(headerMap).reduce((acc, field) => {
+		headerMap[field]?.forEach((key) => acc[key] = field);
+		return acc;
+	}, {});
+}
 /**
-* Filter for CMCD version 1 keys.
+* Group a CMCD object into header shards
 *
-* @param key - The CMCD key to filter.
+* @param cmcd - The CMCD object to convert.
+* @param customHeaderMap - A map of CMCD header fields to custom CMCD keys.
 *
-* @returns `true` if the key should be included, `false` otherwise.
+* @returns The CMCD header shards.
 *
-* @public
+* @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#header-field-definition | CTA-5004-B Header Field Definition}
 *
-* @example
-* {@includeCode ../test/isCmcdV1Key.test.ts#example}
+* @public
 */
-function isCmcdV1Key(key) {
-	return CMCD_V1_KEY_SET$1.has(key) || isCmcdCustomKey(key);
+function groupCmcdHeaders(cmcd, customHeaderMap) {
+	const result = {};
+	if (!cmcd) return result;
+	const keys = Object.keys(cmcd);
+	const custom = customHeaderMap ? createHeaderMap(customHeaderMap) : {};
+	for (const key of keys) {
+		const field = CMCD_HEADER_MAP[key] || custom[key] || CmcdHeaderField.REQUEST;
+		const data = result[field] ??= {};
+		data[key] = cmcd[key];
+	}
+	return result;
 }
 
 //#endregion
-//#region src/isTokenField.ts
-const TOKEN_FIELDS = /* @__PURE__ */ new Set([
-	"ot",
-	"sf",
-	"st",
-	"e",
-	"sta"
-]);
+//#region src/toPreparedCmcdHeaders.ts
 /**
-* Checks if the given key is a token field.
-*
-* @param key - The key to check.
+* Encode already-prepared CMCD data to CMCD header shards.
 *
-* @returns `true` if the key is a token field.
+* @param data - The prepared CMCD data to encode.
+* @param customHeaderMap - A map of CMCD header fields to custom CMCD keys.
+* @returns The CMCD header shards.
 *
 * @internal
 */
-function isTokenField(key) {
-	return TOKEN_FIELDS.has(key);
+function toPreparedCmcdHeaders(data, customHeaderMap) {
+	const result = {};
+	const shards = groupCmcdHeaders(data, customHeaderMap);
+	for (const [field, value] of Object.entries(shards)) {
+		const shard = encodeSfDict(value, { whitespace: false });
+		if (shard) result[field] = shard;
+	}
+	return result;
 }
 
 //#endregion
-//#region src/isValid.ts
+//#region src/toCmcdHeaders.ts
 /**
-* Checks if the given value is valid to send as a CMCD value.
+* Convert a CMCD object to request headers
 *
-* `undefined`, `null`, an empty string, `false`, an empty array, and a
-* number that is not finite are not valid. CTA-5004-B requires omitting
-* the key when its value is unknown.
+* @param cmcd - The CMCD object to convert.
+* @param options - Options for encoding.
 *
-* @param value - The value to check.
+* @returns The CMCD header shards.
 *
-* @returns `true` if the value is valid.
+* @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#header-field-definition | CTA-5004-B Header Field Definition}
 *
-* @internal
+* @public
+*
+* @example
+* {@includeCode ../test/toCmcdHeaders.test.ts#example}
 */
-function isValid(value) {
-	if (typeof value === "number") return Number.isFinite(value);
-	if (Array.isArray(value)) return value.length > 0;
-	return value != null && value !== "" && value !== false;
+function toCmcdHeaders(cmcd, options = {}) {
+	if (!cmcd) return {};
+	return toPreparedCmcdHeaders(prepareCmcdData(cmcd, options), options?.customHeaderMap);
 }
 
 //#endregion
-//#region src/toTokenString.ts
+//#region src/appendCmcdHeaders.ts
 /**
-* Resolve the text of a token value.
+* Append CMCD header shards to a header object.
 *
-* A token may be a plain string, a registry `Symbol`, an `SfToken`, or an
-* `SfItem` that wraps such a value.
+* @param headers - The headers to append to.
+* @param cmcd - The CMCD object to append.
+* @param options - Options for encoding.
 *
-* @param value - The value to resolve.
+* @returns The headers with CMCD header shards appended.
 *
-* @returns The token text, or `undefined` when the value is not a token.
+* @public
 *
-* @internal
+* @example
+* {@includeCode ../test/appendCmcdHeaders.test.ts#example}
+*
+* @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#header-field-definition | CTA-5004-B Header Field Definition}
 */
-function toTokenString(value) {
-	if (value instanceof SfItem) return toTokenString(value.value);
-	if (typeof value === "string") return value;
-	if (typeof value === "symbol" || value instanceof SfToken) return symbolToStr(value);
+function appendCmcdHeaders(headers, cmcd, options) {
+	return Object.assign(headers, toCmcdHeaders(cmcd, options));
 }
 
 //#endregion
-//#region src/prepareCmcdData.ts
-const filterMap = {
-	event: isCmcdEventKey,
-	request: isCmcdRequestKey
-};
+//#region src/CMCD_PARAM.ts
 /**
-* Unwrap an inner list or SfItem value to a scalar.
+* CMCD parameter name.
+*
+* @public
 */
-function unwrapValue(value, ot) {
-	if (Array.isArray(value)) {
-		let item;
-		const otText = toTokenString(ot);
-		if (otText) item = value.find((item$1) => toTokenString(item$1.params?.ot) === otText);
-		if (!item) item = value[0];
-		return unwrapValue(item);
-	}
-	if (value instanceof SfItem) return value.value;
-	return value;
-}
+const CMCD_PARAM = "CMCD";
+
+//#endregion
+//#region src/encodePreparedCmcd.ts
 /**
-* Down-convert version 2 CMCD data to version 1.
+* Encode already-prepared CMCD data to a structured field dictionary string.
 *
-* - Extracts `nrr` from the `nor` SfItem's `r` parameter.
-* - Unwraps inner-list values to scalars.
+* @param data - The prepared CMCD data to encode.
+* @returns The encoded CMCD string.
+*
+* @internal
 */
-function downConvertToV1(obj) {
-	const result = {};
-	for (const [key, value] of Object.entries(obj)) {
-		if (value == null) {
-			result[key] = value;
-			continue;
-		}
-		if (key === "nor") {
-			const first = (Array.isArray(value) ? value : [value])[0];
-			if (first instanceof SfItem) {
-				result["nor"] = first.value;
-				if (first.params?.r) result["nrr"] = first.params.r;
-			} else result["nor"] = first;
-		} else if (CMCD_INNER_LIST_KEYS.has(key)) result[key] = unwrapValue(value, obj["ot"]);
-		else result[key] = value;
-	}
-	return result;
-}
-function formatValue(key, value, options, formatterOptions) {
-	const formatter = options.formatters?.[key] ?? CMCD_FORMATTER_MAP[key];
-	return typeof formatter === "function" && isValid(value) ? formatter(value, formatterOptions) : value;
+function encodePreparedCmcd(data) {
+	return encodeSfDict(data, { whitespace: false });
 }
+
+//#endregion
+//#region src/encodeCmcd.ts
 /**
-* Convert a generic object to CMCD data.
+* Encode a CMCD object to a string.
 *
-* @param obj - The CMCD object to process.
+* @param cmcd - The CMCD object to encode.
 * @param options - Options for encoding.
 *
+* @returns The encoded CMCD string.
+*
+* @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#payload-definition-for-headers-and-query-argument-transmission | CTA-5004-B Payload Definition}
+*
 * @public
 *
 * @example
-* {@includeCode ../test/prepareCmcdData.test.ts#example}
+* {@includeCode ../test/encodeCmcd.test.ts#example}
 */
-function prepareCmcdData(obj, options = {}) {
-	const results = {};
-	if (obj == null || typeof obj !== "object") return results;
-	const version = options.version || obj["v"] || CMCD_V2;
-	const reportingMode = options.reportingMode || CMCD_REQUEST_MODE;
-	const data = version === 1 ? downConvertToV1(obj) : obj;
-	const eventType = toTokenString(data["e"]);
-	const keyFilter = version === 1 ? isCmcdV1Key : filterMap[reportingMode];
-	let keys = Object.keys(data).filter(keyFilter);
-	if (data["e"] && eventType !== CMCD_EVENT_RESPONSE_RECEIVED) keys = keys.filter((key) => !isCmcdResponseReceivedKey(key));
-	const filter = options.filter;
-	if (typeof filter === "function") keys = keys.filter(filter);
-	const isEventMode = reportingMode === CMCD_EVENT_MODE;
-	if (isEventMode) {
-		if (!keys.includes("e") && data["e"] != null) keys.push("e");
-		if (!keys.includes("ts")) keys.push("ts");
-		if (!keys.includes("cen") && data["cen"] != null && eventType === CMCD_EVENT_CUSTOM_EVENT) keys.push("cen");
-		if (!keys.includes("ec") && data["ec"] != null && eventType === CMCD_EVENT_ERROR) keys.push("ec");
-		if (!keys.includes("url") && data["url"] != null && eventType === CMCD_EVENT_RESPONSE_RECEIVED) keys.push("url");
-		const requiredField = eventType ? CMCD_STATE_EVENT_FIELDS.get(eventType) : void 0;
-		if (requiredField && data[requiredField] != null && !keys.includes(requiredField)) keys.push(requiredField);
-	}
-	if (keys.length === 0) return results;
-	if (version > 1 && !keys.includes("v")) keys.push("v");
-	const formatterOptions = {
-		version,
-		reportingMode,
-		baseUrl: options.baseUrl
-	};
-	keys.sort();
-	let objectType;
-	let objectTypeResolved = false;
-	for (const key of keys) {
-		let value = data[key];
-		const exactKey = CMCD_AGGREGATE_BITRATE_KEYS[key];
-		if (exactKey && keys.includes(exactKey) && isValid(formatValue(exactKey, data[exactKey], options, formatterOptions))) continue;
-		const objectTypes = version > 1 ? CMCD_KEY_OBJECT_TYPES[key] : void 0;
-		if (objectTypes) {
-			if (!objectTypeResolved) {
-				const ot = formatValue("ot", data["ot"], options, formatterOptions);
-				objectType = isValid(ot) ? toTokenString(ot) : void 0;
-				objectTypeResolved = true;
-			}
-			if (objectType !== void 0 && !objectTypes.includes(objectType)) continue;
-		}
-		if (key === "cen" && eventType !== CMCD_EVENT_CUSTOM_EVENT) continue;
-		value = formatValue(key, value, options, formatterOptions);
-		if (key === "v") if (version === 1) continue;
-		else value = version;
-		if (key === "pr" && value === 1 && !(isEventMode && eventType === CMCD_EVENT_PLAYBACK_RATE)) continue;
-		if (isEventMode && key === "ts" && !Number.isFinite(value)) value = Date.now();
-		const isBgFalseTransition = isEventMode && value === false && key === "bg" && eventType === CMCD_EVENT_BACKGROUNDED_MODE;
-		if (!isValid(value) && !isBgFalseTransition) continue;
-		if (isTokenField(key)) {
-			if (typeof value === "string") value = new SfToken(value);
-			else if (value instanceof SfItem && typeof value.value === "string") value = new SfItem(new SfToken(value.value), value.params);
-		}
-		results[key] = value;
-	}
-	return results;
+function encodeCmcd(cmcd, options = {}) {
+	if (!cmcd) return "";
+	return encodePreparedCmcd(prepareCmcdData(cmcd, options));
 }
 
 //#endregion
-//#region src/CmcdHeaderField.ts
+//#region src/toCmcdUrl.ts
 /**
-* CMCD object header name.
+* Convert a CMCD object to a URL encoded string.
+*
+* @param cmcd - The CMCD object to convert.
+* @param options - Options for encoding.
+*
+* @returns The URL encoded CMCD data.
+*
+* @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#query-argument-definition | CTA-5004-B Query Argument Definition}
 *
 * @public
 */
-const CMCD_OBJECT = "CMCD-Object";
+function toCmcdUrl(cmcd, options = {}) {
+	if (!cmcd) return "";
+	const params = encodeCmcd(cmcd, options);
+	return encodeURIComponent(params);
+}
+
+//#endregion
+//#region src/toCmcdQuery.ts
 /**
-* CMCD request header name.
+* Convert a CMCD object to a query arg.
+*
+* @param cmcd - The CMCD object to convert.
+* @param options - Options for encoding.
+*
+* @returns The CMCD query arg.
+*
+* @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#query-argument-definition | CTA-5004-B Query Argument Definition}
 *
 * @public
+*
+* @example
+* {@includeCode ../test/toCmcdQuery.test.ts#example}
 */
-const CMCD_REQUEST = "CMCD-Request";
+function toCmcdQuery(cmcd, options = {}) {
+	if (!cmcd) return "";
+	return `${CMCD_PARAM}=${toCmcdUrl(cmcd, options)}`;
+}
+
+//#endregion
+//#region src/appendCmcdQuery.ts
+const REGEX = /CMCD=[^&#]+/;
 /**
-* CMCD session header name.
+* Append CMCD query args to a URL.
+*
+* @param url - The URL to append to.
+* @param cmcd - The CMCD object to append.
+* @param options - Options for encoding.
+*
+* @returns The URL with the CMCD query args appended.
 *
 * @public
+*
+* @example
+* {@includeCode ../test/appendCmcdQuery.test.ts#example}
+*
+* @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#query-argument-definition | CTA-5004-B Query Argument Definition}
 */
-const CMCD_SESSION = "CMCD-Session";
+function appendCmcdQuery(url, cmcd, options) {
+	const query = toCmcdQuery(cmcd, options);
+	if (!query) return url;
+	if (REGEX.test(url)) return url.replace(REGEX, query);
+	return `${url}${url.includes("?") ? "&" : "?"}${query}`;
+}
+
+//#endregion
+//#region src/CMCD_DEFAULT_TIME_INTERVAL.ts
 /**
-* CMCD status header name.
+* The default time interval in seconds when using event mode
 *
 * @public
 */
-const CMCD_STATUS = "CMCD-Status";
+const CMCD_DEFAULT_TIME_INTERVAL = 30;
+
+//#endregion
+//#region src/CMCD_EVENT_KEYS.ts
 /**
-* CMCD header fields.
+* Defines the event-specific keys for CMCD (Common Media Client Data) version 2.
 *
+* @public
+*/
+const CMCD_EVENT_KEYS = [
+	"cen",
+	"e",
+	"h",
+	"ts"
+];
+
+//#endregion
+//#region src/CMCD_FORMATTER_MAP.ts
+const formatNumbers = (value, format) => {
+	if (Array.isArray(value)) {
+		const list = [];
+		for (const item of value) {
+			const formatted = formatNumbers(item, format);
+			if (Number.isFinite(formatted instanceof SfItem ? formatted.value : formatted)) list.push(formatted);
+		}
+		return list;
+	}
+	if (value instanceof SfItem) {
+		const formatted = formatNumbers(value.value, format);
+		return isValid(formatted) ? new SfItem(formatted, value.params) : NaN;
+	}
+	return typeof value === "number" ? format(value) : NaN;
+};
+const toRounded = (value) => formatNumbers(value, Math.round);
+const toNumber = (value) => formatNumbers(value, Number);
+const roundToHundred = (value) => Math.round(value / 100) * 100;
+const toHundred = (value) => formatNumbers(value, roundToHundred);
+/**
+* Formatters for CMCD values.
 *
-* @enum
+* The encoder applies the same rounding through its key table, and `nor` is the `nor` rule of the encoder.
+* Use an entry to build a custom formatter for `CmcdEncodeOptions.formatters`.
+* The formatter of a numeric key drops a value or a list element that is not a finite number.
 *
 * @public
 */
-const CmcdHeaderField = {
-	OBJECT: CMCD_OBJECT,
-	REQUEST: CMCD_REQUEST,
-	SESSION: CMCD_SESSION,
-	STATUS: CMCD_STATUS
+const CMCD_FORMATTER_MAP = {
+	br: toRounded,
+	d: toRounded,
+	bl: toHundred,
+	dl: toHundred,
+	mtp: toHundred,
+	nor: (value, options) => formatNor(value, options) ?? "",
+	rtp: toHundred,
+	tb: toRounded,
+	tbl: toHundred,
+	ab: toRounded,
+	bsa: toRounded,
+	bsd: toRounded,
+	bsda: toRounded,
+	dfa: toRounded,
+	lab: toRounded,
+	lb: toRounded,
+	ltc: toRounded,
+	msd: toRounded,
+	pb: toRounded,
+	pr: toNumber,
+	pt: toRounded,
+	rc: toRounded,
+	sn: toRounded,
+	tab: toRounded,
+	tpb: toRounded,
+	ts: toRounded,
+	ttfb: toRounded,
+	ttfbb: toRounded,
+	ttlb: toRounded
 };
+
+//#endregion
+//#region src/CMCD_REQUEST_KEYS.ts
 /**
-* All CMCD header fields as an array.
+* Defines the request-specific keys for CMCD (Common Media Client Data) version 2.
 *
 * @public
 */
-const CMCD_HEADER_FIELDS = [
-	CMCD_OBJECT,
-	CMCD_REQUEST,
-	CMCD_SESSION,
-	CMCD_STATUS
+const CMCD_REQUEST_KEYS = [
+	"ab",
+	"bg",
+	"bl",
+	"br",
+	"bs",
+	"bsa",
+	"bsd",
+	"bsda",
+	"cdn",
+	"cid",
+	"cs",
+	"d",
+	"dfa",
+	"dl",
+	"ec",
+	"lab",
+	"lb",
+	"ltc",
+	"msd",
+	"mtp",
+	"nor",
+	"nr",
+	"ot",
+	"pb",
+	"pr",
+	"pt",
+	"rtp",
+	"sf",
+	"sid",
+	"sn",
+	"st",
+	"sta",
+	"su",
+	"tab",
+	"tb",
+	"tbl",
+	"tpb",
+	"v"
 ];
 
 //#endregion
-//#region src/CMCD_HEADER_MAP.ts
+//#region src/CMCD_RESPONSE_KEYS.ts
 /**
-* The map of CMCD keys to their appropriate header shard.
-*
-* Event-only keys (e, ts, cen, h) and response-received keys (rc, ttfb,
-* ttlb, url, and others) are intentionally absent. They are transmitted
-* in the event-mode POST body, not HTTP headers.
+* Response-only and timing keys for version 2.
 *
 * @public
 */
-const CMCD_HEADER_MAP = {
-	ab: CMCD_OBJECT,
-	br: CMCD_OBJECT,
-	d: CMCD_OBJECT,
-	lab: CMCD_OBJECT,
-	lb: CMCD_OBJECT,
-	ot: CMCD_OBJECT,
-	tab: CMCD_OBJECT,
-	tb: CMCD_OBJECT,
-	tpb: CMCD_OBJECT,
-	bl: CMCD_REQUEST,
-	cs: CMCD_REQUEST,
-	dfa: CMCD_REQUEST,
-	dl: CMCD_REQUEST,
-	ltc: CMCD_REQUEST,
-	mtp: CMCD_REQUEST,
-	nor: CMCD_REQUEST,
-	nrr: CMCD_REQUEST,
-	pb: CMCD_REQUEST,
-	sn: CMCD_REQUEST,
-	sta: CMCD_REQUEST,
-	su: CMCD_REQUEST,
-	tbl: CMCD_REQUEST,
-	cid: CMCD_SESSION,
-	msd: CMCD_SESSION,
-	sf: CMCD_SESSION,
-	sid: CMCD_SESSION,
-	st: CMCD_SESSION,
-	v: CMCD_SESSION,
-	bg: CMCD_STATUS,
-	bs: CMCD_STATUS,
-	bsa: CMCD_STATUS,
-	bsd: CMCD_STATUS,
-	bsda: CMCD_STATUS,
-	cdn: CMCD_STATUS,
-	ec: CMCD_STATUS,
-	nr: CMCD_STATUS,
-	pr: CMCD_STATUS,
-	pt: CMCD_STATUS,
-	rtp: CMCD_STATUS
-};
+const CMCD_RESPONSE_KEYS = [
+	"cmsdd",
+	"cmsds",
+	"rc",
+	"smrt",
+	"ttfb",
+	"ttfbb",
+	"ttlb",
+	"url"
+];
 
 //#endregion
-//#region src/groupCmcdHeaders.ts
-function createHeaderMap(headerMap) {
-	return Object.keys(headerMap).reduce((acc, field) => {
-		headerMap[field]?.forEach((key) => acc[key] = field);
-		return acc;
-	}, {});
-}
+//#region src/CMCD_V1_KEYS.ts
 /**
-* Group a CMCD object into header shards
-*
-* @param cmcd - The CMCD object to convert.
-* @param customHeaderMap - A map of CMCD header fields to custom CMCD keys.
-*
-* @returns The CMCD header shards.
-*
-* @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#header-field-definition | CTA-5004-B Header Field Definition}
+* Defines the keys for CMCD (Common Media Client Data) version 1.
 *
 * @public
 */
-function groupCmcdHeaders(cmcd, customHeaderMap) {
-	const result = {};
-	if (!cmcd) return result;
-	const keys = Object.keys(cmcd);
-	const custom = customHeaderMap ? createHeaderMap(customHeaderMap) : {};
-	for (const key of keys) {
-		const field = CMCD_HEADER_MAP[key] || custom[key] || CmcdHeaderField.REQUEST;
-		const data = result[field] ??= {};
-		data[key] = cmcd[key];
-	}
-	return result;
-}
+const CMCD_V1_KEYS = [
+	"bl",
+	"br",
+	"bs",
+	"cid",
+	"d",
+	"dl",
+	"mtp",
+	"nor",
+	"nrr",
+	"ot",
+	"pr",
+	"rtp",
+	"sf",
+	"sid",
+	"st",
+	"su",
+	"tb",
+	"v"
+];
 
 //#endregion
-//#region src/toPreparedCmcdHeaders.ts
+//#region src/CMCD_KEYS.ts
 /**
-* Encode already-prepared CMCD data to CMCD header shards.
-*
-* @param data - The prepared CMCD data to encode.
-* @param customHeaderMap - A map of CMCD header fields to custom CMCD keys.
-* @returns The CMCD header shards.
+* A list of all CMCD keys.
 *
-* @internal
+* @public
 */
-function toPreparedCmcdHeaders(data, customHeaderMap) {
-	const result = {};
-	const shards = groupCmcdHeaders(data, customHeaderMap);
-	for (const [field, value] of Object.entries(shards)) {
-		const shard = encodeSfDict(value, { whitespace: false });
-		if (shard) result[field] = shard;
-	}
-	return result;
-}
+const CMCD_KEYS = /* @__PURE__ */ [
+	...CMCD_V1_KEYS,
+	...CMCD_REQUEST_KEYS,
+	...CMCD_RESPONSE_KEYS,
+	...CMCD_EVENT_KEYS
+].filter((key, index, arr) => arr.indexOf(key) === index);
 
 //#endregion
-//#region src/toCmcdHeaders.ts
+//#region src/CMCD_MIME_TYPE.ts
 /**
-* Convert a CMCD object to request headers
-*
-* @param cmcd - The CMCD object to convert.
-* @param options - Options for encoding.
-*
-* @returns The CMCD header shards.
-*
-* @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#header-field-definition | CTA-5004-B Header Field Definition}
+* CMCD MIME type for event report payloads.
 *
 * @public
-*
-* @example
-* {@includeCode ../test/toCmcdHeaders.test.ts#example}
 */
-function toCmcdHeaders(cmcd, options = {}) {
-	if (!cmcd) return {};
-	return toPreparedCmcdHeaders(prepareCmcdData(cmcd, options), options?.customHeaderMap);
-}
+const CMCD_MIME_TYPE = "application/cmcd";
 
 //#endregion
-//#region src/appendCmcdHeaders.ts
+//#region src/CMCD_REQUEST_PROVENANCE.ts
 /**
-* Append CMCD header shards to a header object.
+* The `customData` property where `CmcdReporter.createRequestReport()`
+* writes session provenance on every request it returns.
 *
-* @param headers - The headers to append to.
-* @param cmcd - The CMCD object to append.
-* @param options - Options for encoding.
+* The value is a frozen `CmcdRequestProvenance` record. `sid` names the
+* session that issued the request. `cid` is the content id at the time the
+* request was issued. `data` is the request's per-call data as an encoded
+* CMCD string. `CmcdReporter.recordResponseReceived()` reads the record to
+* attribute a late response to its session and to rebuild the request-time
+* report keys.
+* Spread and `Object.assign` copy the record into ordinary request clones.
+* `JSON.stringify` and structured clone drop symbol-keyed properties. Before
+* either operation, read the value and restore it afterward. JSON preserves
+* the record's fields. Attribution uses the `sid` value rather than object
+* identity, so a parsed plain-object copy attributes correctly. For a record
+* naming a `sid` the reporter does not retain, the reporter drops the
+* response rather than reattributing it.
 *
-* @returns The headers with CMCD header shards appended.
+* The symbol registry provides the symbol, so duplicated copies of this
+* library in one bundle interoperate. The registry key is stable across
+* versions.
 *
 * @public
-*
-* @example
-* {@includeCode ../test/appendCmcdHeaders.test.ts#example}
-*
-* @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#header-field-definition | CTA-5004-B Header Field Definition}
 */
-function appendCmcdHeaders(headers, cmcd, options) {
-	return Object.assign(headers, toCmcdHeaders(cmcd, options));
-}
+const CMCD_REQUEST_PROVENANCE = /* @__PURE__ */ Symbol.for("@svta/cml-cmcd/request-provenance");
 
 //#endregion
-//#region src/CMCD_PARAM.ts
+//#region src/CMCD_V1.ts
 /**
-* CMCD parameter name.
+* CMCD Version 1
 *
 * @public
 */
-const CMCD_PARAM = "CMCD";
+const CMCD_V1 = 1;
 
 //#endregion
-//#region src/encodePreparedCmcd.ts
+//#region src/CmcdEventType.ts
 /**
-* Encode already-prepared CMCD data to a structured field dictionary string.
-*
-* @param data - The prepared CMCD data to encode.
-* @returns The encoded CMCD string.
+* CMCD event type 'bc' (bitrate change).
 *
-* @internal
+* @public
 */
-function encodePreparedCmcd(data) {
-	return encodeSfDict(data, { whitespace: false });
-}
-
-//#endregion
-//#region src/encodeCmcd.ts
+const CMCD_EVENT_BITRATE_CHANGE = "bc";
 /**
-* Encode a CMCD object to a string.
-*
-* @param cmcd - The CMCD object to encode.
-* @param options - Options for encoding.
-*
-* @returns The encoded CMCD string.
-*
-* @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#payload-definition-for-headers-and-query-argument-transmission | CTA-5004-B Payload Definition}
+* CMCD event type 'ps' (play state change).
 *
 * @public
-*
-* @example
-* {@includeCode ../test/encodeCmcd.test.ts#example}
 */
-function encodeCmcd(cmcd, options = {}) {
-	if (!cmcd) return "";
-	return encodePreparedCmcd(prepareCmcdData(cmcd, options));
-}
-
-//#endregion
-//#region src/toCmcdUrl.ts
+const CMCD_EVENT_PLAY_STATE = "ps";
 /**
-* Convert a CMCD object to a URL encoded string.
-*
-* @param cmcd - The CMCD object to convert.
-* @param options - Options for encoding.
-*
-* @returns The URL encoded CMCD data.
-*
-* @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#query-argument-definition | CTA-5004-B Query Argument Definition}
+* CMCD event type 'pr' (playback rate change).
 *
 * @public
 */
-function toCmcdUrl(cmcd, options = {}) {
-	if (!cmcd) return "";
-	const params = encodeCmcd(cmcd, options);
-	return encodeURIComponent(params);
-}
-
-//#endregion
-//#region src/toCmcdQuery.ts
+const CMCD_EVENT_PLAYBACK_RATE = "pr";
 /**
-* Convert a CMCD object to a query arg.
+* CMCD event type 'e' (error).
 *
-* @param cmcd - The CMCD object to convert.
-* @param options - Options for encoding.
+* @public
+*/
+const CMCD_EVENT_ERROR = "e";
+/**
+* CMCD event type 't' (time interval).
 *
-* @returns The CMCD query arg.
+* @public
+*/
+const CMCD_EVENT_TIME_INTERVAL = "t";
+/**
+* CMCD event type 'c' (content ID).
 *
-* @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#query-argument-definition | CTA-5004-B Query Argument Definition}
+* @public
+*/
+const CMCD_EVENT_CONTENT_ID = "c";
+/**
+* CMCD event type 'b' (backgrounded mode).
 *
 * @public
+*/
+const CMCD_EVENT_BACKGROUNDED_MODE = "b";
+/**
+* CMCD event type 'm' (mute).
 *
-* @example
-* {@includeCode ../test/toCmcdQuery.test.ts#example}
+* @public
 */
-function toCmcdQuery(cmcd, options = {}) {
-	if (!cmcd) return "";
-	return `${CMCD_PARAM}=${toCmcdUrl(cmcd, options)}`;
-}
-
-//#endregion
-//#region src/appendCmcdQuery.ts
-const REGEX = /CMCD=[^&#]+/;
+const CMCD_EVENT_MUTE = "m";
 /**
-* Append CMCD query args to a URL.
+* CMCD event type 'um' (unmute).
 *
-* @param url - The URL to append to.
-* @param cmcd - The CMCD object to append.
-* @param options - Options for encoding.
+* @public
+*/
+const CMCD_EVENT_UNMUTE = "um";
+/**
+* CMCD event type 'pe' (player expand).
 *
-* @returns The URL with the CMCD query args appended.
+* @public
+*/
+const CMCD_EVENT_PLAYER_EXPAND = "pe";
+/**
+* CMCD event type 'pc' (player collapse).
 *
 * @public
+*/
+const CMCD_EVENT_PLAYER_COLLAPSE = "pc";
+/**
+* CMCD event type 'rr' (response received).
 *
-* @example
-* {@includeCode ../test/appendCmcdQuery.test.ts#example}
+* @public
+*/
+const CMCD_EVENT_RESPONSE_RECEIVED = "rr";
+/**
+* CMCD event type 'as' (ad start).
 *
-* @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#query-argument-definition | CTA-5004-B Query Argument Definition}
+* @public
 */
-function appendCmcdQuery(url, cmcd, options) {
-	const query = toCmcdQuery(cmcd, options);
-	if (!query) return url;
-	if (REGEX.test(url)) return url.replace(REGEX, query);
-	return `${url}${url.includes("?") ? "&" : "?"}${query}`;
-}
-
-//#endregion
-//#region src/CMCD_DEFAULT_TIME_INTERVAL.ts
+const CMCD_EVENT_AD_START = "as";
 /**
-* The default time interval in seconds when using event mode
+* CMCD event type 'ae' (ad end).
 *
 * @public
 */
-const CMCD_DEFAULT_TIME_INTERVAL = 30;
-
-//#endregion
-//#region src/CMCD_KEYS.ts
+const CMCD_EVENT_AD_END = "ae";
 /**
-* A list of all CMCD keys.
+* CMCD event type 'abs' (ad break start).
 *
 * @public
 */
-const CMCD_KEYS = /* @__PURE__ */ [
-	...CMCD_V1_KEYS,
-	...CMCD_REQUEST_KEYS,
-	...CMCD_RESPONSE_KEYS,
-	...CMCD_EVENT_KEYS
-].filter((key, index, arr) => arr.indexOf(key) === index);
-
-//#endregion
-//#region src/CMCD_MIME_TYPE.ts
+const CMCD_EVENT_AD_BREAK_START = "abs";
 /**
-* CMCD MIME type for event report payloads.
+* CMCD event type 'abe' (ad break end).
 *
 * @public
 */
-const CMCD_MIME_TYPE = "application/cmcd";
-
-//#endregion
-//#region src/CMCD_REQUEST_PROVENANCE.ts
+const CMCD_EVENT_AD_BREAK_END = "abe";
 /**
-* The `customData` property where `CmcdReporter.createRequestReport()`
-* writes session provenance on every request it returns.
-*
-* The value is a frozen `CmcdRequestProvenance` record. `sid` names the
-* session that issued the request. `cid` is the content id at the time the
-* request was issued. `data` is the request's per-call data as an encoded
-* CMCD string. `CmcdReporter.recordResponseReceived()` reads the record to
-* attribute a late response to its session and to rebuild the request-time
-* report keys.
-* Spread and `Object.assign` copy the record into ordinary request clones.
-* `JSON.stringify` and structured clone drop symbol-keyed properties. Before
-* either operation, read the value and restore it afterward. JSON preserves
-* the record's fields. Attribution uses the `sid` value rather than object
-* identity, so a parsed plain-object copy attributes correctly. For a record
-* naming a `sid` the reporter does not retain, the reporter drops the
-* response rather than reattributing it.
+* CMCD event type 'sk' (skip).
 *
-* The symbol registry provides the symbol, so duplicated copies of this
-* library in one bundle interoperate. The registry key is stable across
-* versions.
+* @public
+*/
+const CMCD_EVENT_SKIP = "sk";
+/**
+* CMCD event type 'ce' (custom event).
 *
 * @public
 */
-const CMCD_REQUEST_PROVENANCE = /* @__PURE__ */ Symbol.for("@svta/cml-cmcd/request-provenance");
-
-//#endregion
-//#region src/CMCD_V1.ts
+const CMCD_EVENT_CUSTOM_EVENT = "ce";
 /**
-* CMCD Version 1
+* CMCD event types for the 'e' key (event mode).
+*
+* @enum
+*
+* @see {@link https://cta-wave.github.io/Resources/common-media-client-data--cta-5004-b.html#event | CTA-5004-B Event}
 *
 * @public
 */
-const CMCD_V1 = 1;
+const CmcdEventType = {
+	BITRATE_CHANGE: CMCD_EVENT_BITRATE_CHANGE,
+	PLAY_STATE: CMCD_EVENT_PLAY_STATE,
+	PLAYBACK_RATE: CMCD_EVENT_PLAYBACK_RATE,
+	ERROR: CMCD_EVENT_ERROR,
+	TIME_INTERVAL: CMCD_EVENT_TIME_INTERVAL,
+	CONTENT_ID: CMCD_EVENT_CONTENT_ID,
+	BACKGROUNDED_MODE: CMCD_EVENT_BACKGROUNDED_MODE,
+	MUTE: CMCD_EVENT_MUTE,
+	UNMUTE: CMCD_EVENT_UNMUTE,
+	PLAYER_EXPAND: CMCD_EVENT_PLAYER_EXPAND,
+	PLAYER_COLLAPSE: CMCD_EVENT_PLAYER_COLLAPSE,
+	RESPONSE_RECEIVED: CMCD_EVENT_RESPONSE_RECEIVED,
+	AD_START: CMCD_EVENT_AD_START,
+	AD_END: CMCD_EVENT_AD_END,
+	AD_BREAK_START: CMCD_EVENT_AD_BREAK_START,
+	AD_BREAK_END: CMCD_EVENT_AD_BREAK_END,
+	SKIP: CMCD_EVENT_SKIP,
+	CUSTOM_EVENT: CMCD_EVENT_CUSTOM_EVENT
+};
 
 //#endregion
 //#region src/CmcdObjectType.ts
@@ -1556,6 +1897,39 @@ var CmcdReportRecorder = class {
 	}
 };
 
+//#endregion
+//#region src/CMCD_STATE_EVENT_FIELDS.ts
+/**
+* Maps each state-change event type to the persistent field whose value
+* the event signals.
+*
+* The key table (`CMCD_KEY_SPECS`) marks the field as always sent on its
+* event, so the key filter of `prepareCmcdData` does not remove it.
+* `CmcdReporter` deduplicates events against the field value. It drops an
+* event whose field has no value and restores the field if a transform
+* removes it.
+*
+* Sending the field with each state-change event is a library choice.
+* The exception is the exit from backgrounded mode, which CTA-5004-B
+* defines as a `b` event without `bg`. CTA-5004-B requires the field only
+* on the `ps` event, which MUST carry `sta`. CTA-5004-B states no such rule
+* for `pr`, `c`, or `bc`. `validateCmcdStructure` follows CTA-5004-B and
+* does not read this map.
+*
+* Iteration order matters: `CmcdReporter.update()` records state-change
+* events in map order when several tracked fields change in one call.
+* Do not reorder entries without auditing reporter behavior.
+*
+* @internal
+*/
+const CMCD_STATE_EVENT_FIELDS = /* @__PURE__ */ new Map([
+	[CMCD_EVENT_PLAY_STATE, "sta"],
+	[CMCD_EVENT_PLAYBACK_RATE, "pr"],
+	[CMCD_EVENT_CONTENT_ID, "cid"],
+	[CMCD_EVENT_BACKGROUNDED_MODE, "bg"],
+	[CMCD_EVENT_BITRATE_CHANGE, "br"]
+]);
+
 //#endregion
 //#region src/CmcdTransmissionMode.ts
 /**
@@ -1599,19 +1973,21 @@ const CmcdTransmissionMode = {
 * - Wraps scalar values in arrays for inner-list keys.
 * - Wraps `nor` string in an array.
 *
-* The function returns version 2 data (has `v: 2`) unchanged.
+* The function returns version 2 data (has `v: 2`) unchanged. An inner list
+* with parameters, which `decodeCmcd` returns as an `SfItem` that wraps the
+* list, also stays unchanged.
 *
 * @internal
 */
 function upConvertToV2(obj) {
-	if (obj["v"] === CMCD_V2) return obj;
+	if (toBareValue(obj["v"]) === CMCD_V2) return obj;
 	const result = {};
 	for (const [key, value] of Object.entries(obj)) {
 		if (value == null) {
 			result[key] = value;
 			continue;
 		}
-		if (CMCD_INNER_LIST_KEYS.has(key) && !Array.isArray(value)) result[key] = [value];
+		if (CMCD_INNER_LIST_KEYS.has(key) && !Array.isArray(toBareValue(value))) result[key] = [value];
 		else if (key === "nor" && typeof value === "string") result[key] = [value];
 		else result[key] = value;
 	}
@@ -1661,10 +2037,9 @@ function cmcdObjectTypeListEqual(a, b) {
 		const ai = a[i];
 		const bi = b[i];
 		if (ai === bi) continue;
-		if (typeof ai === "number" || typeof bi === "number") return false;
-		if (ai.value !== bi.value) return false;
-		const ap = ai.params;
-		const bp = bi.params;
+		if ((typeof ai === "number" ? ai : ai.value) !== (typeof bi === "number" ? bi : bi.value)) return false;
+		const ap = typeof ai === "number" ? void 0 : ai.params;
+		const bp = typeof bi === "number" ? void 0 : bi.params;
 		const ak = ap && Object.keys(ap)[0];
 		const bk = bp && Object.keys(bp)[0];
 		if (ak !== bk) return false;
@@ -1672,6 +2047,18 @@ function cmcdObjectTypeListEqual(a, b) {
 	}
 	return true;
 }
+/**
+* Equality for `br` deduplication. A `br` value can be an `SfItem` that
+* wraps the list, as `decodeCmcd` returns for an inner list with
+* parameters. Two values are equal when their lists are equal. The
+* parameters of the list are not compared.
+*/
+function brEqual(a, b) {
+	const listA = toBareValue(a);
+	const listB = toBareValue(b);
+	if (!Array.isArray(listA) || !Array.isArray(listB)) return Object.is(a, b);
+	return cmcdObjectTypeListEqual(listA, listB);
+}
 const equal = Object.is;
 const identity = (v) => v;
 /**
@@ -1682,8 +2069,8 @@ const STATE_FIELDS = /* @__PURE__ */ Array.from(CMCD_STATE_EVENT_FIELDS, ([event
 	if (field === "br") return {
 		event,
 		field,
-		equal: (a, b) => a === void 0 || b === void 0 ? a === b : cmcdObjectTypeListEqual(a, b),
-		snapshot: (v) => v.slice()
+		equal: brEqual,
+		snapshot: (v) => Array.isArray(v) ? v.slice() : copyItemValue(v)
 	};
 	return {
 		event,
@@ -1702,29 +2089,14 @@ function buildRequiredEventKeys() {
 	]);
 }
 /**
-* Maps each event type to the key CTA-5004-B requires beyond `e` and `ts`.
-* Built from the state-change table plus the three event types whose
-* required key is event data, not player state.
+* Maps each event type to the key that a report of that type must keep,
+* beyond `e` and `ts`. Built from the state-change table plus the three
+* event types whose required key is event data, not player state.
 */
 const CMCD_REQUIRED_EVENT_KEYS = /* @__PURE__ */ buildRequiredEventKeys();
 /**
-* Whether a required key's value will survive report preparation.
-*
-* This is `isValid` without its `false` exclusion. `false` must count as
-* usable because `bg: false` is a valid value on a backgrounded-mode event,
-* which the encoder writes as `?0`. If `false` counted as unusable,
-* restoration would silently revert a transform that cleared the key.
-* Later processing drops empty strings, empty lists, and non-finite numbers.
-* A transform that substitutes one of them leaves the report without a
-* required key.
-*/
-function isUsableRequiredValue(value) {
-	if (value == null || value === "") return false;
-	if (typeof value === "number") return Number.isFinite(value);
-	return !Array.isArray(value) || value.length > 0;
-}
-/**
-* Copies a value with the `SfItem` structure, including its `params` record.
+* Copies a value with the `SfItem` structure, including its `params` record
+* and the list of an `SfItem` that wraps a list.
 *
 * The copy keeps the prototype because `prepareCmcdData`, the formatter map,
 * validation, and the structured-field encoder all branch on
@@ -1735,6 +2107,7 @@ function copyItemValue(value) {
 	if (value === null || typeof value !== "object") return value;
 	const copy = Object.assign(Object.create(Object.getPrototypeOf(value)), value);
 	if (copy.params !== null && typeof copy.params === "object") copy.params = { ...copy.params };
+	if (Array.isArray(copy.value)) copy.value = copy.value.map(copyItemValue);
 	return copy;
 }
 /**
@@ -1744,7 +2117,8 @@ function copyItemValue(value) {
 *
 * The copy is complete for the CMCD value space. `CmcdValue` and
 * `CmcdCustomValue` admit only primitives, `SfItem<primitive>`, and arrays of
-* those. `SfItem.params` is a flat record. The reporter calls this function
+* those. `decodeCmcd` also returns an `SfItem` that wraps a list, and the
+* copy includes that list. `SfItem.params` is a flat record. The reporter calls this function
 * where a transform is configured, at session end on the ended session's
 * store, and on the request's stored player-facing view. The session-end
 * copy detaches the frozen snapshot from caller-held references.
@@ -1873,7 +2247,7 @@ var CmcdReporter = class {
 			provenance: mintProvenance(sid, data.cid),
 			data,
 			msd: NaN,
-			lastEmitted: {},
+			lastEmitted: toBareValue(data.bg) === true ? {} : { bg: false },
 			eventTargets,
 			requestTarget: {
 				sn: 0,
@@ -1952,6 +2326,14 @@ var CmcdReporter = class {
 	* a new session therefore always fires, even when the persisted value did
 	* not change across the `sid` boundary.
 	*
+	* The `bg` field is an exception. A session that does not start with
+	* `bg: true` begins with `false` as its last reported `bg` value.
+	* `bg: false` therefore fires `BACKGROUNDED_MODE` only if the session
+	* started with `bg: true` or reported `bg: true`. CTA-5004-B defines a
+	* `b` event without `bg` as the exit from backgrounded mode, so the exit
+	* report does not carry `bg`. A target transform can add `bg: false` to
+	* the exit report. The encoder writes that value as `?0`.
+	*
 	* Multi-field updates fire the events in this order: `sta`, `pr`, `cid`,
 	* `bg`, `br`. The order of keys in the input object does not affect the
 	* firing order.
@@ -1971,8 +2353,7 @@ var CmcdReporter = class {
 	* writes them into every outgoing report, so this method is the only way
 	* to change them. A per-call value on {@link CmcdReporter.recordEvent},
 	* {@link CmcdReporter.createRequestReport}, or
-	* {@link CmcdReporter.recordResponseReceived} has no effect. Response
-	* attribution uses the provenance record alone.
+	* {@link CmcdReporter.recordResponseReceived} has no effect.
 	* `msd` must be a finite number of milliseconds between `0` and
 	* `999_999_999_999_999` (the RFC 8941 integer maximum). The reporter
 	* rounds `msd` to the nearest integer and ignores invalid values.
@@ -2035,9 +2416,9 @@ var CmcdReporter = class {
 	*    data store, as `update()` would.
 	* 2. Discards the event if the state field has no value after that write
 	*    (never set, or cleared with `update({ field: undefined })`).
-	*    A state-change event without its required field would violate CTA-5004-B.
 	* 3. Suppresses the event if the field's current value equals the
-	*    last reported value (no state transition).
+	*    last reported value (no state transition). {@link CmcdReporter.update}
+	*    describes the `bg` value that a new session starts with.
 	*
 	* The reporter always records all other event types.
 	*
@@ -2123,6 +2504,7 @@ var CmcdReporter = class {
 			e: type,
 			ts: data.ts ?? Date.now()
 		};
+		if (type === CMCD_EVENT_BACKGROUNDED_MODE && toBareValue(item.bg) === false) delete item.bg;
 		const { transform } = config;
 		if (!transform) {
 			this.queueTargetEvent(session, target, config, item, type);
@@ -2134,8 +2516,8 @@ var CmcdReporter = class {
 		const ts = item.ts;
 		const report = transform(item, request);
 		if (report == null) return;
-		if (!isUsableRequiredValue(report.ts)) report.ts = ts;
-		if (requiredKey && isUsableRequiredValue(requiredValue) && !isUsableRequiredValue(report[requiredKey])) Object.assign(report, { [requiredKey]: requiredValue });
+		if (!isValid(report.ts)) report.ts = ts;
+		if (requiredKey && isValid(requiredValue) && !isValid(report[requiredKey])) Object.assign(report, { [requiredKey]: requiredValue });
 		this.queueTargetEvent(session, target, config, report, type);
 	}
 	/**
@@ -2189,27 +2571,24 @@ var CmcdReporter = class {
 	* TypeScript therefore rejects a call whose request the configured
 	* transforms could not read. See {@link CmcdReporterCustomData}.
 	*
-	* The reporter attributes the event only to the session that issued the
-	* request. The provenance record that
-	* {@link CmcdReporter.createRequestReport} stored on the request's
-	* `customData` (under {@link CMCD_REQUEST_PROVENANCE}) selects the session
-	* by `sid`. Without a match, the reporter discards the response rather than
-	* attributing it elsewhere. There is no other key. The reporter discards the
-	* response when a serialization boundary lost the record and nothing
-	* restored it (see {@link CMCD_REQUEST_PROVENANCE}). It also discards the
-	* response when the session is no longer retained (see
-	* `CmcdReporterConfig.sessionRetention`). A per-call `data.sid` cannot
-	* substitute. The reporter accepts any record whose `sid` names a retained
-	* session. The record may come from another reporter with the same session
-	* attributes, or be hand-built. A response that completes after a `sid`
-	* change reports under its own retained session, with that session's data
-	* snapshot and sequence numbers.
+	* The provenance record that {@link CmcdReporter.createRequestReport}
+	* stored on the request's `customData` (under
+	* {@link CMCD_REQUEST_PROVENANCE}) selects the session by `sid`. A record
+	* that names no retained session drops the response (see
+	* `CmcdReporterConfig.sessionRetention`). A request without a record reports
+	* under the current session, as in version 2.4.0. The request-time data then
+	* comes from `customData.cmcd`. A per-call `data.sid` cannot substitute. The
+	* reporter accepts any record whose `sid` names a retained session. The
+	* record may come from another reporter with the same session attributes,
+	* or be hand-built. If the request has a record, a response that completes
+	* after a `sid` change reports under its own retained session, with that
+	* session's data snapshot and sequence numbers.
 	*
-	* Request-time report keys come from the record's encoded per-call `data`
-	* snapshot, which the reporter decodes for each response. The record's `cid`
-	* replaces the session's current `cid` in the report. A response that
-	* completes after a mid-session content change therefore reports its
-	* request-time values.
+	* With a record, request-time report keys come from the record's encoded
+	* per-call `data` snapshot, which the reporter decodes for each response.
+	* The record's `cid` replaces the session's current `cid` in the report. A
+	* response that completes after a mid-session content change therefore
+	* reports its request-time values.
 	*
 	* @typeParam RD - The `customData` of this request. Defaults to the
 	*                reporter's own `C`.
@@ -2218,17 +2597,17 @@ var CmcdReporter = class {
 	* @param data - Additional CMCD data to include with the event.
 	*               Values provided here override the derived values.
 	*               The reporter ignores session-owned keys (`sid`, `msd`)
-	*               supplied here. Attribution uses the provenance record alone.
+	*               supplied here.
 	*/
 	recordResponseReceived(response, data = {}) {
 		const { request } = response;
 		const url = data.url ?? request?.url;
 		if (!url) return;
 		const provenance = request.customData?.[CMCD_REQUEST_PROVENANCE];
-		const session = this.resolveSession(provenance);
+		const session = provenance === void 0 ? this.session : this.resolveSession(provenance);
 		if (!session) return;
-		const cmcd = decodeSnapshot(provenance);
-		const { cid } = provenance;
+		const cmcd = provenance === void 0 ? { ...request.customData?.cmcd } : decodeSnapshot(provenance);
+		const { cid } = provenance ?? {};
 		const urlObj = new URL(url);
 		urlObj.searchParams.delete(CMCD_PARAM);
 		const derived = {
@@ -2251,11 +2630,11 @@ var CmcdReporter = class {
 		}, request);
 	}
 	/**
-	* Resolves the session a response belongs to. The provenance record's `sid`
+	* Resolves the session that a provenance record names. The record's `sid`
 	* must name one of this reporter's retained sessions, or the reporter
-	* discards the response. There is no other key. A lost record, or one that
-	* names a removed or unknown `sid`, resolves nothing. Any other attribution
-	* would be wrong. The reporter reads the `sid` as a plain property. A record
+	* discards the response. A record that names a removed or unknown `sid`
+	* resolves nothing. Any other attribution would be wrong. The reporter reads
+	* the `sid` as a plain property. A record
 	* copied through JSON therefore resolves the same session, and a hand-built
 	* record that names a retained session is accepted.
 	*/
@@ -2544,6 +2923,63 @@ function fromCmcdUrl(url, options) {
 	return decodeCmcd(decodeURIComponent(url.replace(/^CMCD=/, "")), options);
 }
 
+//#endregion
+//#region src/isCmcdRequestKey.ts
+const CMCD_REQUEST_KEY_SET = /* @__PURE__ */ new Set(CMCD_REQUEST_KEYS);
+/**
+* Check if a key is a valid CMCD request key.
+*
+* @param key - The key to check.
+*
+* @returns `true` if the key is a valid CMCD request key, `false` otherwise.
+*
+* @public
+*
+* @example
+* {@includeCode ../test/isCmcdRequestKey.test.ts#example}
+*/
+function isCmcdRequestKey(key) {
+	return CMCD_REQUEST_KEY_SET.has(key) || isCmcdCustomKey(key);
+}
+
+//#endregion
+//#region src/isCmcdResponseReceivedKey.ts
+const CMCD_RESPONSE_KEY_SET = /* @__PURE__ */ new Set(CMCD_RESPONSE_KEYS);
+/**
+* Check if a key is a valid CMCD response key.
+*
+* @param key - The key to check.
+*
+* @returns `true` if the key is a valid CMCD response key, `false` otherwise.
+*
+* @public
+*
+* @example
+* {@includeCode ../test/isCmcdResponseReceivedKey.test.ts#example}
+*/
+function isCmcdResponseReceivedKey(key) {
+	return CMCD_RESPONSE_KEY_SET.has(key);
+}
+
+//#endregion
+//#region src/isCmcdEventKey.ts
+const CMCD_EVENT_KEY_SET = /* @__PURE__ */ new Set(CMCD_EVENT_KEYS);
+/**
+* Check if a key is a valid CMCD event key.
+*
+* @param key - The key to check.
+*
+* @returns `true` if the key is a valid CMCD event key, `false` otherwise.
+*
+* @public
+*
+* @example
+* {@includeCode ../test/isCmcdEventKey.test.ts#example}
+*/
+function isCmcdEventKey(key) {
+	return isCmcdRequestKey(key) || isCmcdResponseReceivedKey(key) || CMCD_EVENT_KEY_SET.has(key);
+}
+
 //#endregion
 //#region src/isCmcdV1Data.ts
 /**
@@ -2562,6 +2998,25 @@ function isCmcdV1Data(data) {
 	return data.v !== CMCD_V2;
 }
 
+//#endregion
+//#region src/isCmcdV1Key.ts
+const CMCD_V1_KEY_SET$1 = /* @__PURE__ */ new Set(CMCD_V1_KEYS);
+/**
+* Filter for CMCD version 1 keys.
+*
+* @param key - The CMCD key to filter.
+*
+* @returns `true` if the key should be included, `false` otherwise.
+*
+* @public
+*
+* @example
+* {@includeCode ../test/isCmcdV1Key.test.ts#example}
+*/
+function isCmcdV1Key(key) {
+	return CMCD_V1_KEY_SET$1.has(key) || isCmcdCustomKey(key);
+}
+
 //#endregion
 //#region src/isCmcdV2Data.ts
 /**
@@ -2619,7 +3074,7 @@ function mergeValidationResults(...results) {
 */
 function resolveVersion(data, options) {
 	if (options?.version === 1 || options?.version === 2) return options.version;
-	const payloadVersion = data["v"];
+	const payloadVersion = toBareValue(data["v"]);
 	if (payloadVersion === 1 || payloadVersion === 2) return payloadVersion;
 	return CMCD_V1;
 }
@@ -2660,6 +3115,51 @@ function validateCmcdKeys(data, options) {
 	};
 }
 
+//#endregion
+//#region src/CMCD_AGGREGATE_BITRATE_KEYS.ts
+/**
+* Maps each aggregate bitrate key to the exact bitrate key that supersedes it.
+*
+* Per CTA-5004-B, `ab` MUST NOT be sent when the encoded bitrate `br` is
+* known. `lab` and `tab` follow the same rule for the lowest bitrate `lb`
+* and the top bitrate `tb`.
+*
+* @internal
+*/
+const CMCD_AGGREGATE_BITRATE_KEYS = {
+	ab: "br",
+	lab: "lb",
+	tab: "tb"
+};
+
+//#endregion
+//#region src/CMCD_KEY_OBJECT_TYPES.ts
+/**
+* Maps a key to the object types (`ot`) for which CTA-5004-B allows the key.
+*
+* A key that is absent from this map is allowed for every object type.
+* `d` (Object duration) and `tpb` (Top playable bitrate) MUST NOT be sent for
+* other object types.
+*
+* @internal
+*/
+const CMCD_KEY_OBJECT_TYPES = {
+	d: [
+		"a",
+		"v",
+		"av",
+		"tt",
+		"c",
+		"o"
+	],
+	tpb: [
+		"a",
+		"v",
+		"av",
+		"c"
+	]
+};
+
 //#endregion
 //#region src/validateCmcdStructure.ts
 /**
@@ -2727,9 +3227,9 @@ function validateCmcdStructure(data, options) {
 			message: `Response key "${key}" must only be present when e="rr".`,
 			severity: CMCD_VALIDATION_SEVERITY_ERROR
 		});
-		for (const [stateEventType, requiredField] of CMCD_STATE_EVENT_FIELDS) if (eventType === stateEventType && !(requiredField in data)) issues.push({
-			key: requiredField,
-			message: `State-change event (e="${stateEventType}") requires the "${requiredField}" key to be present.`,
+		if (eventType === CMCD_EVENT_PLAY_STATE && !("sta" in data)) issues.push({
+			key: "sta",
+			message: "Play state change event (e=\"ps\") requires the \"sta\" key to be present.",
 			severity: CMCD_VALIDATION_SEVERITY_ERROR
 		});
 		if (eventType === CMCD_EVENT_ERROR && !("ec" in data)) issues.push({
@@ -2755,9 +3255,10 @@ function validateCmcdStructure(data, options) {
 			severity: CMCD_VALIDATION_SEVERITY_ERROR
 		});
 	}
-	if ("v" in data && data["v"] !== 1 && data["v"] !== 2) issues.push({
+	const v = toBareValue(data["v"]);
+	if ("v" in data && v !== 1 && v !== 2) issues.push({
 		key: "v",
-		message: `Unsupported CMCD version "${String(data["v"])}". Expected 1 or 2.`,
+		message: `Unsupported CMCD version "${String(v)}". Expected 1 or 2.`,
 		severity: CMCD_VALIDATION_SEVERITY_ERROR
 	});
 	else if (version > 1 && !("v" in data)) issues.push({
@@ -2779,7 +3280,7 @@ function validateCmcdStructure(data, options) {
 //#endregion
 //#region src/CMCD_KEY_TYPES.ts
 /**
-* CMCD key value type: inner list of numbers with token identifiers.
+* CMCD key value type: inner list of integers with token identifiers.
 *
 * @internal
 */
@@ -2886,9 +3387,9 @@ const CMCD_KEY_TYPES = {
 */
 const CMCD_V1_KEY_TYPE_OVERRIDES = {
 	bl: CMCD_KEY_TYPE_INTEGER,
-	br: CMCD_KEY_TYPE_NUMBER,
+	br: CMCD_KEY_TYPE_INTEGER,
 	mtp: CMCD_KEY_TYPE_INTEGER,
-	tb: CMCD_KEY_TYPE_NUMBER,
+	tb: CMCD_KEY_TYPE_INTEGER,
 	nor: CMCD_KEY_TYPE_STRING
 };
 
@@ -2979,22 +3480,31 @@ const CMCD_TOKEN_VALUES = {
 
 //#endregion
 //#region src/validateCmcdValues.ts
-const HUNDRED_ROUNDING_KEYS = /* @__PURE__ */ new Set([
-	"bl",
-	"dl",
-	"mtp",
-	"rtp",
-	"tbl"
-]);
-const INTEGER_ROUNDING_KEYS = /* @__PURE__ */ new Set([
-	"br",
-	"d",
-	"tb"
-]);
+const HUNDRED_ROUNDING_UNITS = {
+	bl: "ms",
+	dl: "ms",
+	mtp: "kbps",
+	rtp: "kbps",
+	tbl: "ms"
+};
 function isFiniteNumber(value) {
 	return typeof value === "number" && Number.isFinite(value);
 }
-function validateListValue(key, value, issues) {
+function isInteger(value) {
+	return Number.isInteger(value);
+}
+function validateRounding(key, value, version, issues, index) {
+	const unit = HUNDRED_ROUNDING_UNITS[key];
+	if (!unit || value % 100 === 0) return;
+	const should = key === "tbl" || key === "bl" && version !== CMCD_V1;
+	const target = index === void 0 ? `Key "${key}"` : `Key "${key}" array element [${index}]`;
+	issues.push({
+		key,
+		message: `${target} ${should ? "should" : "must"} be rounded to the nearest 100 ${unit}. Received ${value}.`,
+		severity: should ? CMCD_VALIDATION_SEVERITY_WARNING : CMCD_VALIDATION_SEVERITY_ERROR
+	});
+}
+function validateListValue(key, value, version, issues) {
 	if (!Array.isArray(value)) {
 		issues.push({
 			key,
@@ -3004,18 +3514,13 @@ function validateListValue(key, value, issues) {
 		return;
 	}
 	for (let i = 0; i < value.length; i++) {
-		const element = value[i];
-		if (element instanceof SfItem) {
-			if (!isFiniteNumber(element.value)) issues.push({
-				key,
-				message: `Key "${key}" array element [${i}] must be a finite number.`,
-				severity: CMCD_VALIDATION_SEVERITY_ERROR
-			});
-		} else if (!isFiniteNumber(element)) issues.push({
+		const element = toBareValue(value[i]);
+		if (!isInteger(element)) issues.push({
 			key,
-			message: `Key "${key}" array element [${i}] must be a finite number.`,
+			message: `Key "${key}" array element [${i}] must be a finite integer.`,
 			severity: CMCD_VALIDATION_SEVERITY_ERROR
 		});
+		else validateRounding(key, element, version, issues, i);
 	}
 }
 function validateStringArrayValue(key, value, issues) {
@@ -3027,20 +3532,11 @@ function validateStringArrayValue(key, value, issues) {
 		});
 		return;
 	}
-	for (let i = 0; i < value.length; i++) {
-		const element = value[i];
-		if (element instanceof SfItem) {
-			if (typeof element.value !== "string") issues.push({
-				key,
-				message: `Key "${key}" array element [${i}] must be a string.`,
-				severity: CMCD_VALIDATION_SEVERITY_ERROR
-			});
-		} else if (typeof element !== "string") issues.push({
-			key,
-			message: `Key "${key}" array element [${i}] must be a string.`,
-			severity: CMCD_VALIDATION_SEVERITY_ERROR
-		});
-	}
+	for (let i = 0; i < value.length; i++) if (typeof toBareValue(value[i]) !== "string") issues.push({
+		key,
+		message: `Key "${key}" array element [${i}] must be a string.`,
+		severity: CMCD_VALIDATION_SEVERITY_ERROR
+	});
 }
 /**
 * Validates that all values in a CMCD payload conform to the expected types and constraints.
@@ -3059,7 +3555,8 @@ function validateStringArrayValue(key, value, issues) {
 function validateCmcdValues(data, options) {
 	const version = resolveVersion(data, options);
 	const issues = [];
-	for (const [key, value] of Object.entries(data)) {
+	for (const [key, entry] of Object.entries(data)) {
+		const value = toBareValue(entry);
 		if (isCmcdCustomKey(key)) {
 			if (typeof value !== "string") issues.push({
 				key,
@@ -3086,16 +3583,12 @@ function validateCmcdValues(data, options) {
 		if (version === CMCD_V1 && key in CMCD_V1_KEY_TYPE_OVERRIDES) expectedType = CMCD_V1_KEY_TYPE_OVERRIDES[key];
 		switch (expectedType) {
 			case CMCD_KEY_TYPE_INTEGER:
-				if (!isFiniteNumber(value) || !Number.isInteger(value)) issues.push({
+				if (!isInteger(value)) issues.push({
 					key,
 					message: `Key "${key}" must be a finite integer.`,
 					severity: CMCD_VALIDATION_SEVERITY_ERROR
 				});
-				else if (HUNDRED_ROUNDING_KEYS.has(key) && value % 100 !== 0) issues.push({
-					key,
-					message: `Key "${key}" should be rounded to the nearest 100.`,
-					severity: CMCD_VALIDATION_SEVERITY_WARNING
-				});
+				else validateRounding(key, value, version, issues);
 				break;
 			case CMCD_KEY_TYPE_NUMBER:
 				if (!isFiniteNumber(value)) issues.push({
@@ -3103,16 +3596,6 @@ function validateCmcdValues(data, options) {
 					message: `Key "${key}" must be a finite number.`,
 					severity: CMCD_VALIDATION_SEVERITY_ERROR
 				});
-				else if (HUNDRED_ROUNDING_KEYS.has(key) && value % 100 !== 0) issues.push({
-					key,
-					message: `Key "${key}" should be rounded to the nearest 100.`,
-					severity: CMCD_VALIDATION_SEVERITY_WARNING
-				});
-				else if (INTEGER_ROUNDING_KEYS.has(key) && !Number.isInteger(value)) issues.push({
-					key,
-					message: `Key "${key}" should be rounded to an integer.`,
-					severity: CMCD_VALIDATION_SEVERITY_WARNING
-				});
 				break;
 			case CMCD_KEY_TYPE_BOOLEAN:
 				if (typeof value !== "boolean") issues.push({
@@ -3144,7 +3627,7 @@ function validateCmcdValues(data, options) {
 				break;
 			}
 			case CMCD_KEY_TYPE_NUMBER_LIST:
-				validateListValue(key, value, issues);
+				validateListValue(key, value, version, issues);
 				break;
 			case CMCD_KEY_TYPE_STRING_LIST:
 				validateStringArrayValue(key, value, issues);