@svta/cml-c2pa 1.0.1 → 1.1.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { decode } from "cbor-x/decode";
+import { decode, decodeMultiple } from "cbor-x/decode";
 import { encode } from "cbor-x/encode";
 import { findIsoBox, readEmsg, readIsoBoxes } from "@svta/cml-iso-bmff";
 
@@ -19,6 +19,7 @@ const LiveVideoStatusCode = {
 	SEGMENT_INVALID: "livevideo.segment.invalid",
 	ASSERTION_INVALID: "livevideo.assertion.invalid",
 	CONTINUITY_METHOD_INVALID: "livevideo.continuityMethod.invalid",
+	CONTINUITY_METHOD_UNSUPPORTED: "livevideo.continuityMethod.unsupported",
 	SESSIONKEY_INVALID: "livevideo.sessionkey.invalid"
 };
 
@@ -109,7 +110,7 @@ function parseJumbfBoxes(bytes) {
 
 //#endregion
 //#region src/jumbf/parseJumbfLabel.ts
-const TEXT_DECODER$2 = new TextDecoder();
+const TEXT_DECODER$3 = /* @__PURE__ */ new TextDecoder();
 const JUMD_UUID_SIZE = 16;
 const JUMD_TOGGLES_OFFSET = 16;
 const JUMD_LABEL_START = 17;
@@ -135,7 +136,7 @@ function parseJumbfLabel(jumdData) {
 	let end = JUMD_LABEL_START;
 	while (end < jumdData.length && jumdData[end] !== 0) end++;
 	if (end >= jumdData.length) return null;
-	return TEXT_DECODER$2.decode(jumdData.subarray(JUMD_LABEL_START, end));
+	return TEXT_DECODER$3.decode(jumdData.subarray(JUMD_LABEL_START, end));
 }
 
 //#endregion
@@ -152,7 +153,7 @@ const SHA_ALGORITHM_PATTERN = /^sha(\d+)$/i;
 function normalizeAlgorithmName(rawAlg) {
 	return (rawAlg ?? "SHA-256").replace(SHA_ALGORITHM_PATTERN, "SHA-$1");
 }
-const HEX_TABLE = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+const HEX_TABLE = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
 /**
 * Converts a Uint8Array to a lowercase hex string.
 *
@@ -208,6 +209,7 @@ const C2PA_MANIFEST_UUID = [
 	16,
 	234
 ];
+/** @internal */
 const JUMBF_UUID = [
 	216,
 	254,
@@ -226,9 +228,20 @@ const JUMBF_UUID = [
 	196,
 	129
 ];
+/** @internal */
 function matchesUuid(usertype, expected) {
 	return usertype.length === expected.length && expected.every((b, i) => b === usertype[i]);
 }
+/** @internal */
+function toUint8Array(value) {
+	if (value instanceof Uint8Array) return value;
+	if (Array.isArray(value)) return new Uint8Array(value);
+	return null;
+}
+/** @internal */
+function asInteger(value) {
+	return typeof value === "number" && Number.isInteger(value) ? value : null;
+}
 function isC2paUuid(usertype) {
 	return matchesUuid(usertype, C2PA_MANIFEST_UUID) || matchesUuid(usertype, JUMBF_UUID);
 }
@@ -245,6 +258,18 @@ function findC2paUuidBox(boxes) {
 }
 const FULLBOX_HEADER_SIZE = 4;
 const AUX_UUID_OFFSET_SIZE = 8;
+const TEXT_DECODER$2 = new TextDecoder();
+/** @internal */
+function readUuidBoxPurpose(payload) {
+	if (payload.length < FULLBOX_HEADER_SIZE) return null;
+	let offset = FULLBOX_HEADER_SIZE;
+	while (offset < payload.length && payload[offset] !== 0) offset++;
+	if (offset >= payload.length) return null;
+	return {
+		purpose: TEXT_DECODER$2.decode(payload.subarray(FULLBOX_HEADER_SIZE, offset)),
+		rest: payload.subarray(offset + 1)
+	};
+}
 /**
 * Strips the JUMBF UUID box prefix (fullbox header, purpose string, aux offset)
 * to return only the JUMBF manifest data.
@@ -257,14 +282,9 @@ const AUX_UUID_OFFSET_SIZE = 8;
 * @internal
 */
 function stripJumbfUuidPrefix(payload) {
-	if (payload.length < FULLBOX_HEADER_SIZE) return null;
-	let offset = FULLBOX_HEADER_SIZE;
-	while (offset < payload.length && payload[offset] !== 0) offset++;
-	if (offset >= payload.length) return null;
-	offset++;
-	offset += AUX_UUID_OFFSET_SIZE;
-	if (offset > payload.length) return null;
-	return payload.subarray(offset);
+	const prefix = readUuidBoxPurpose(payload);
+	if (!prefix || prefix.rest.length < AUX_UUID_OFFSET_SIZE) return null;
+	return prefix.rest.subarray(AUX_UUID_OFFSET_SIZE);
 }
 
 //#endregion
@@ -327,7 +347,7 @@ function readElementRaw(bytes, offset) {
 
 //#endregion
 //#region src/x509/extractCertificateInfo.ts
-const TEXT_DECODER$1 = new TextDecoder();
+const TEXT_DECODER$1 = /* @__PURE__ */ new TextDecoder();
 const OID_COMMON_NAME = new Uint8Array([
 	85,
 	4,
@@ -431,7 +451,7 @@ function extractCertificateInfo(certDER) {
 
 //#endregion
 //#region src/readC2paManifest.ts
-const TEXT_DECODER = new TextDecoder();
+const TEXT_DECODER = /* @__PURE__ */ new TextDecoder();
 const MAX_JUMBF_NESTING_DEPTH = 20;
 const X5CHAIN_HEADER_LABEL = 33;
 function resolveManifestBoxes(jumbfBoxes, depth = 0) {
@@ -745,35 +765,6 @@ async function computeBmffHash(segmentBytes, options) {
 	return new Uint8Array(hashBuffer);
 }
 
-//#endregion
-//#region src/bmff/validateBmffHash.ts
-const OFFSET_PREFIX_SIZES_TO_TRY = [8, 0];
-/**
-* Validates the C2PA BMFF content hash (`c2pa.hash.bmff.v3`) for a DASH segment.
-*
-* Tries both offset-prefix modes — 8-byte file offset prefix and no prefix — to handle
-* inter-signer interoperability until a standard signaling mechanism is defined in the spec.
-*
-* Use {@link computeBmffHash} directly when the offset prefix size is known.
-*
-* @param segmentBytes - Raw segment bytes to validate
-* @param expectedHash - Expected hash bytes from the VSI CBOR map
-* @param options - Validation options (exclusions, algorithm)
-* @returns `true` if the computed hash matches the expected hash in either offset mode
-*
-* @example
-* {@includeCode ../../test/bmff/validateBmffHash.test.ts#example}
-*
-* @public
-*/
-async function validateBmffHash(segmentBytes, expectedHash, options) {
-	for (const offsetPrefixSize of OFFSET_PREFIX_SIZES_TO_TRY) if (hashesEqual(await computeBmffHash(segmentBytes, {
-		...options,
-		offsetPrefixSize
-	}), expectedHash)) return true;
-	return false;
-}
-
 //#endregion
 //#region src/C2paStatusCode.ts
 /**
@@ -790,7 +781,9 @@ const C2paStatusCode = {
 	ASSERTION_HASHEDURI_MISMATCH: "assertion.hashedURI.mismatch",
 	ASSERTION_MISSING: "assertion.missing",
 	ASSERTION_ACTION_INGREDIENT_MISMATCH: "assertion.action.ingredientMismatch",
-	CLAIM_SIGNATURE_MISMATCH: "claim.signature.mismatch"
+	CLAIM_SIGNATURE_MISMATCH: "claim.signature.mismatch",
+	ASSERTION_BMFFHASH_MALFORMED: "assertion.bmffHash.malformed",
+	ASSERTION_BMFFHASH_MISMATCH: "assertion.bmffHash.mismatch"
 };
 
 //#endregion
@@ -948,7 +941,7 @@ const CBOR_UINT32_LENGTH_INDICATOR = 90;
 const CBOR_INLINE_MAX = 23;
 const CBOR_UINT8_MAX = 255;
 const CBOR_UINT16_MAX = 65535;
-const COSE_SIG1_CONTEXT_BYTES = new TextEncoder().encode("Signature1");
+const COSE_SIG1_CONTEXT_BYTES = /* @__PURE__ */ new TextEncoder().encode("Signature1");
 function byteStringHeaderSize(length) {
 	if (length <= CBOR_INLINE_MAX) return 1;
 	if (length <= CBOR_UINT8_MAX) return 2;
@@ -1423,6 +1416,117 @@ async function verifySignerBinding(signerBindingBytes, sessionCoseKey, signerCer
 	return verifyCoseSign1(coseSign1, encode(signerCertBytes), publicKey);
 }
 
+//#endregion
+//#region src/bmff/parseExclusions.ts
+function parseConstraints(rawConstraints) {
+	if (!Array.isArray(rawConstraints)) return [];
+	const constraints = [];
+	for (const c of rawConstraints) {
+		if (!c || typeof c !== "object") continue;
+		const record = c;
+		if (typeof record["offset"] !== "number") continue;
+		const value = toUint8Array(record["value"]);
+		if (value) constraints.push({
+			offset: record["offset"],
+			value
+		});
+	}
+	return constraints;
+}
+/**
+* Parses the `exclusions` array of a `c2pa.hash.bmff.v3` assertion.
+*
+* @internal
+*/
+function parseExclusions(rawExclusions) {
+	if (!Array.isArray(rawExclusions)) return [];
+	const exclusions = [];
+	for (const exc of rawExclusions) {
+		if (!exc || typeof exc !== "object") continue;
+		const record = exc;
+		if (typeof record["xpath"] !== "string") continue;
+		const constraints = parseConstraints(record["data"]);
+		exclusions.push(constraints.length > 0 ? {
+			xpath: record["xpath"],
+			data: constraints
+		} : { xpath: record["xpath"] });
+	}
+	return exclusions;
+}
+
+//#endregion
+//#region src/merkle/validateMerkleMaps.ts
+function parseMerkleRow(rawHashes) {
+	if (!Array.isArray(rawHashes) || rawHashes.length === 0) return null;
+	const row = [];
+	for (const entry of rawHashes) {
+		const bytes = toUint8Array(entry);
+		if (!bytes) return null;
+		row.push(bytes);
+	}
+	return row;
+}
+function extractMerkleMaps(bmffHashAssertionData) {
+	const rawMerkle = bmffHashAssertionData["merkle"];
+	if (!Array.isArray(rawMerkle) || rawMerkle.length === 0) return null;
+	const exclusions = parseExclusions(bmffHashAssertionData["exclusions"]);
+	const assertionAlg = bmffHashAssertionData["alg"];
+	const offsetPrefixSize = bmffHashAssertionData["hash"] == null ? 8 : 0;
+	const maps = [];
+	for (const entry of rawMerkle) {
+		if (!entry || typeof entry !== "object") return null;
+		const record = entry;
+		const uniqueId = asInteger(record["uniqueId"]);
+		const localId = asInteger(record["localId"]);
+		const count = asInteger(record["count"]);
+		const hashes = parseMerkleRow(record["hashes"]);
+		if (uniqueId === null || localId === null || count === null || !hashes) return null;
+		const initHash = toUint8Array(record["initHash"]);
+		if (!initHash) return null;
+		const rawAlg = record["alg"] ?? assertionAlg;
+		if (typeof rawAlg !== "string") return null;
+		maps.push({
+			uniqueId,
+			localId,
+			count,
+			hashes,
+			initHash,
+			alg: normalizeAlgorithmName(rawAlg),
+			exclusions,
+			offsetPrefixSize
+		});
+	}
+	return maps;
+}
+async function validateMerkleMaps(bytes, assertion, codes) {
+	const data = assertion?.data;
+	if (data === null || typeof data !== "object" || Array.isArray(data)) return null;
+	if (data["merkle"] === void 0) return null;
+	const merkleMaps = extractMerkleMaps(data);
+	if (!merkleMaps) {
+		codes.add(C2paStatusCode.ASSERTION_BMFFHASH_MALFORMED);
+		return [];
+	}
+	const initHashByAlg = /* @__PURE__ */ new Map();
+	for (const merkleMap of merkleMaps) {
+		if (!merkleMap.initHash) continue;
+		let computed = initHashByAlg.get(merkleMap.alg);
+		if (!computed) {
+			computed = await computeBmffHash(bytes, {
+				offsetPrefixSize: merkleMap.offsetPrefixSize,
+				exclusions: merkleMap.exclusions,
+				alg: merkleMap.alg ?? void 0
+			});
+			initHashByAlg.set(merkleMap.alg, computed);
+		}
+		if (!hashesEqual(computed, merkleMap.initHash)) {
+			codes.add(LiveVideoStatusCode.INIT_INVALID);
+			codes.add(C2paStatusCode.ASSERTION_BMFFHASH_MISMATCH);
+		}
+	}
+	return merkleMaps;
+}
+
 //#endregion
 //#region src/init/validateC2paInitSegment.ts
 const BMFF_HASH_ASSERTION_LABEL$1 = "c2pa.hash.bmff.v3";
@@ -1485,10 +1589,11 @@ async function validateBmffHashAssertion(bytes, assertion) {
 	if (!rawHash) return true;
 	const expectedHash = rawHash instanceof Uint8Array ? rawHash : new Uint8Array(rawHash);
 	const alg = normalizeAlgorithmName(data["alg"]);
-	return validateBmffHash(bytes, expectedHash, {
+	return hashesEqual(await computeBmffHash(bytes, {
 		exclusions: data["exclusions"] ?? [],
-		alg
-	});
+		alg,
+		offsetPrefixSize: 8
+	}), expectedHash);
 }
 function extractSessionKeyFields(entry) {
 	const keyData = entry;
@@ -1565,19 +1670,22 @@ async function validateC2paInitSegment(bytes) {
 		certificate: null,
 		manifestId: null,
 		sessionKeys: [],
+		merkleMaps: [],
 		isValid: false,
 		errorCodes: [LiveVideoStatusCode.INIT_INVALID]
 	};
 	const internalData = readC2paManifest(bytes, boxes);
 	const { manifest } = internalData;
 	const certificate = internalData.signatureBytes ? extractCertificateFromSignatureBytes(internalData.signatureBytes) : null;
-	const bmffHashValid = await validateBmffHashAssertion(bytes, manifest.assertions.find((a) => a.label === BMFF_HASH_ASSERTION_LABEL$1) ?? null);
+	const bmffHashAssertion = manifest.assertions.find((a) => a.label === BMFF_HASH_ASSERTION_LABEL$1) ?? null;
+	const bmffHashValid = await validateBmffHashAssertion(bytes, bmffHashAssertion);
 	const sessionKeysAssertion = manifest.assertions.find((a) => a.label === SESSION_KEYS_ASSERTION_LABEL);
 	const sessionKeys = sessionKeysAssertion && certificate ? await validateSessionKeys(sessionKeysAssertion, certificate) : [];
 	const integrityCodes = await validateManifestIntegrity(internalData, certificate);
 	const codes = /* @__PURE__ */ new Set();
+	const merkleMaps = await validateMerkleMaps(bytes, bmffHashAssertion, codes);
 	if (!bmffHashValid) codes.add(LiveVideoStatusCode.INIT_INVALID);
-	if (sessionKeys.length === 0) codes.add(LiveVideoStatusCode.SESSIONKEY_INVALID);
+	if (sessionKeys.length === 0 && merkleMaps === null) codes.add(LiveVideoStatusCode.SESSIONKEY_INVALID);
 	for (const code of integrityCodes) codes.add(code);
 	const errorCodes = [...codes];
 	return {
@@ -1585,6 +1693,7 @@ async function validateC2paInitSegment(bytes) {
 		certificate,
 		manifestId: manifest.instanceId,
 		sessionKeys,
+		merkleMaps: merkleMaps ?? [],
 		isValid: errorCodes.length === 0,
 		errorCodes
 	};
@@ -1783,6 +1892,36 @@ function validateSequenceNumber(state, sequenceNumber, minSequenceNumber) {
 	};
 }
 
+//#endregion
+//#region src/bmff/validateBmffHash.ts
+const OFFSET_PREFIX_SIZES_TO_TRY = [8, 0];
+/**
+* Validates the C2PA BMFF content hash (`c2pa.hash.bmff.v3`) for a DASH segment.
+*
+* Tries both offset-prefix modes — 8-byte file offset prefix and no prefix — to handle
+* inter-signer interoperability for hashes carried in the VSI CBOR map (§19.7.3), where
+* the spec does not signal the prefix mode. Flat hashes from a `c2pa.hash.bmff.v3`
+* assertion always use the 8-byte prefix (§18.6.2); verify those with
+* {@link computeBmffHash} and `offsetPrefixSize: 8` instead.
+*
+* @param segmentBytes - Raw segment bytes to validate
+* @param expectedHash - Expected hash bytes from the VSI CBOR map
+* @param options - Validation options (exclusions, algorithm)
+* @returns `true` if the computed hash matches the expected hash in either offset mode
+*
+* @example
+* {@includeCode ../../test/bmff/validateBmffHash.test.ts#example}
+*
+* @public
+*/
+async function validateBmffHash(segmentBytes, expectedHash, options) {
+	for (const offsetPrefixSize of OFFSET_PREFIX_SIZES_TO_TRY) if (hashesEqual(await computeBmffHash(segmentBytes, {
+		...options,
+		offsetPrefixSize
+	}), expectedHash)) return true;
+	return false;
+}
+
 //#endregion
 //#region src/segment/validateC2paSegment.ts
 function findSessionKey(sessionKeys, kidHex) {
@@ -1864,7 +2003,6 @@ const LIVE_VIDEO_ASSERTION_LABEL = "c2pa.livevideo.segment";
 const BMFF_HASH_ASSERTION_LABEL = "c2pa.hash.bmff.v3";
 const MANIFEST_ID_PREFIX_PATTERN = /^(xmp:iid:|urn:uuid:)/i;
 const CONTINUITY_METHOD_MANIFEST_ID = "c2pa.manifestId";
-const SUPPORTED_CONTINUITY_METHODS = new Set([CONTINUITY_METHOD_MANIFEST_ID]);
 function normalizeManifestId(id) {
 	if (!id) return null;
 	return id.replace(MANIFEST_ID_PREFIX_PATTERN, "").toLowerCase();
@@ -1873,11 +2011,6 @@ function extractAssertionData(data) {
 	if (data !== null && typeof data === "object" && !Array.isArray(data)) return data;
 	return null;
 }
-function toUint8Array(value) {
-	if (value instanceof Uint8Array) return value;
-	if (Array.isArray(value)) return new Uint8Array(value);
-	return null;
-}
 function parseLiveVideoAssertion(assertions) {
 	const assertion = assertions.find((a) => a.label === LIVE_VIDEO_ASSERTION_LABEL);
 	if (!assertion) return null;
@@ -1890,7 +2023,8 @@ function parseLiveVideoAssertion(assertions) {
 		sequenceNumber: typeof rawSeq === "number" ? rawSeq : null,
 		previousManifestId: typeof rawPrev === "string" ? rawPrev : null,
 		streamId: typeof rawStreamId === "string" ? rawStreamId : null,
-		continuityMethod: typeof rawContinuity === "string" ? rawContinuity : null
+		continuityMethod: typeof rawContinuity === "string" ? rawContinuity : null,
+		data: data ?? {}
 	};
 }
 const EMPTY_BMFF_HASH = {
@@ -1899,36 +2033,6 @@ const EMPTY_BMFF_HASH = {
 	exclusions: [],
 	alg: null
 };
-function parseConstraints(rawConstraints) {
-	if (!Array.isArray(rawConstraints)) return [];
-	const constraints = [];
-	for (const c of rawConstraints) {
-		if (!c || typeof c !== "object") continue;
-		const record = c;
-		if (typeof record["offset"] !== "number") continue;
-		const value = toUint8Array(record["value"]);
-		if (value) constraints.push({
-			offset: record["offset"],
-			value
-		});
-	}
-	return constraints;
-}
-function parseExclusions(rawExclusions) {
-	if (!Array.isArray(rawExclusions)) return [];
-	const exclusions = [];
-	for (const exc of rawExclusions) {
-		if (!exc || typeof exc !== "object") continue;
-		const record = exc;
-		if (typeof record["xpath"] !== "string") continue;
-		const constraints = parseConstraints(record["data"]);
-		exclusions.push(constraints.length > 0 ? {
-			xpath: record["xpath"],
-			data: constraints
-		} : { xpath: record["xpath"] });
-	}
-	return exclusions;
-}
 function parseBmffHashAssertion(assertions) {
 	const assertion = assertions.find((a) => a.label === BMFF_HASH_ASSERTION_LABEL);
 	if (!assertion) return EMPTY_BMFF_HASH;
@@ -1970,21 +2074,28 @@ function parseManifest(bytes) {
 		};
 	}
 }
-function collectErrorCodes(hasManifest, hasLiveVideo, streamIdValid, sequenceNumberValid, bmffHashMatches, continuityMethod, previousManifestId, lastManifestId) {
+function collectErrorCodes(hasManifest, hasLiveVideo, streamIdValid, sequenceNumberValid, bmffHashMatches) {
 	const codes = /* @__PURE__ */ new Set();
 	if (!hasManifest) codes.add(LiveVideoStatusCode.MANIFEST_INVALID);
 	if (!hasLiveVideo) codes.add(LiveVideoStatusCode.ASSERTION_INVALID);
 	if (!streamIdValid) codes.add(LiveVideoStatusCode.ASSERTION_INVALID);
 	if (!sequenceNumberValid) codes.add(LiveVideoStatusCode.ASSERTION_INVALID);
 	if (!bmffHashMatches) codes.add(LiveVideoStatusCode.SEGMENT_INVALID);
-	if (!continuityMethod) codes.add(LiveVideoStatusCode.CONTINUITY_METHOD_INVALID);
-	else if (!SUPPORTED_CONTINUITY_METHODS.has(continuityMethod)) codes.add(LiveVideoStatusCode.CONTINUITY_METHOD_INVALID);
-	else if (continuityMethod === CONTINUITY_METHOD_MANIFEST_ID) {
-		if (!previousManifestId) codes.add(LiveVideoStatusCode.CONTINUITY_METHOD_INVALID);
-		else if (lastManifestId && normalizeManifestId(previousManifestId) !== normalizeManifestId(lastManifestId)) codes.add(LiveVideoStatusCode.SEGMENT_INVALID);
-	}
 	return [...codes];
 }
+async function validateContinuity(parsed, lastManifestId, options) {
+	const { manifest, liveVideo } = parsed;
+	const method = liveVideo?.continuityMethod ?? null;
+	if (!method) return [LiveVideoStatusCode.CONTINUITY_METHOD_INVALID];
+	if (method === CONTINUITY_METHOD_MANIFEST_ID) {
+		const prev = liveVideo?.previousManifestId ?? null;
+		if (!prev) return [LiveVideoStatusCode.CONTINUITY_METHOD_INVALID];
+		return !!lastManifestId && normalizeManifestId(prev) !== normalizeManifestId(lastManifestId) ? [LiveVideoStatusCode.SEGMENT_INVALID] : [];
+	}
+	const custom = options?.continuityValidator;
+	if (custom?.method !== method || !manifest || !liveVideo) return [LiveVideoStatusCode.CONTINUITY_METHOD_INVALID, LiveVideoStatusCode.CONTINUITY_METHOD_UNSUPPORTED];
+	return await Promise.resolve().then(() => custom.validate(liveVideo.data, manifest)).catch(() => false) ? [] : [LiveVideoStatusCode.SEGMENT_INVALID];
+}
 /**
 * Validates a C2PA manifest-box live stream segment.
 *
@@ -1992,6 +2103,8 @@ function collectErrorCodes(hasManifest, hasLiveVideo, streamIdValid, sequenceNum
 * Recomputes the `c2pa.hash.bmff.v3` content hash from the raw segment bytes and compares
 * it against the expected hash in the manifest assertion. Checks live-video assertions
 * (sequenceNumber, streamId, continuityMethod) and manifest-ID chain continuity.
+* A validator for an implementer-defined continuity method can be registered
+* via {@link ManifestBoxValidationOptions}.
 *
 * This function is **pure** — it does not access any external state. The
 * caller is responsible for persisting `nextManifestId` and `nextState`
@@ -2000,6 +2113,7 @@ function collectErrorCodes(hasManifest, hasLiveVideo, streamIdValid, sequenceNum
 * @param bytes - Raw segment bytes
 * @param lastManifestId - Manifest ID from the previous segment, or null for the first segment
 * @param state - Optional state from the previous segment for streamId/sequenceNumber checks
+* @param options - Optional custom continuity method validator
 * @returns Validation result, the manifest ID, and state to persist for the next call
 *
 * @example
@@ -2007,7 +2121,7 @@ function collectErrorCodes(hasManifest, hasLiveVideo, streamIdValid, sequenceNum
 *
 * @public
 */
-async function validateC2paManifestBoxSegment(bytes, lastManifestId, state) {
+async function validateC2paManifestBoxSegment(bytes, lastManifestId, state, options) {
 	const { manifest, issuer, liveVideo, bmff, internalData } = parseManifest(bytes);
 	const sequenceNumber = liveVideo?.sequenceNumber ?? null;
 	const previousManifestId = liveVideo?.previousManifestId ?? null;
@@ -2016,11 +2130,19 @@ async function validateC2paManifestBoxSegment(bytes, lastManifestId, state) {
 	const streamIdValid = state?.lastStreamId == null || streamId === state.lastStreamId;
 	const sequenceNumberValid = state?.lastSequenceNumber == null || sequenceNumber !== null && sequenceNumber > state.lastSequenceNumber;
 	let bmffHashMatches = true;
-	if (bmff.hashBytes !== null) bmffHashMatches = await validateBmffHash(bytes, bmff.hashBytes, {
+	if (bmff.hashBytes !== null) bmffHashMatches = hashesEqual(await computeBmffHash(bytes, {
 		exclusions: bmff.exclusions,
-		alg: bmff.alg ?? void 0
-	});
-	const liveVideoCodes = collectErrorCodes(manifest !== null, liveVideo !== null, streamIdValid, sequenceNumberValid, bmffHashMatches, continuityMethod, previousManifestId, lastManifestId);
+		alg: bmff.alg ?? void 0,
+		offsetPrefixSize: 8
+	}), bmff.hashBytes);
+	const continuityCodes = await validateContinuity({
+		manifest,
+		issuer,
+		liveVideo,
+		bmff,
+		internalData
+	}, lastManifestId, options);
+	const liveVideoCodes = [...new Set([...collectErrorCodes(manifest !== null, liveVideo !== null, streamIdValid, sequenceNumberValid, bmffHashMatches), ...continuityCodes])];
 	const integrityCodes = internalData ? await validateManifestIntegrity(internalData, internalData.signatureBytes ? extractCertificateFromSignatureBytes(internalData.signatureBytes) : null) : [];
 	const errorCodes = [...liveVideoCodes, ...integrityCodes];
 	const currentManifestId = manifest?.instanceId ?? null;
@@ -2045,5 +2167,187 @@ async function validateC2paManifestBoxSegment(bytes, lastManifestId, state) {
 }
 
 //#endregion
-export { C2paStatusCode, LiveVideoStatusCode, SequenceValidationReason, validateC2paInitSegment, validateC2paManifestBoxSegment, validateC2paSegment };
+//#region src/merkle/validateC2paMerkleSegment.ts
+const MERKLE_BOX_PURPOSE = "merkle";
+function readAuxPayload(rawPayload) {
+	const prefix = readUuidBoxPurpose(rawPayload);
+	if (!prefix || prefix.purpose !== MERKLE_BOX_PURPOSE) return "other";
+	return prefix.rest;
+}
+function extractMerkleAuxBoxes(segmentBytes) {
+	const payloads = [];
+	for (const box of readIsoBoxes(segmentBytes)) {
+		const uuidBox = box;
+		if (uuidBox.type !== "uuid") continue;
+		if (!matchesUuid(uuidBox.usertype ?? [], JUMBF_UUID)) continue;
+		const payload = readAuxPayload(uuidBox.view.readData(uuidBox.view.bytesRemaining));
+		if (payload !== "other") payloads.push(payload);
+	}
+	return payloads;
+}
+function readMapField(map, name) {
+	if (map instanceof Map) return map.get(name);
+	return map[name];
+}
+function decodeFirstCbor(payload) {
+	let first;
+	let found = false;
+	try {
+		decodeMultiple(payload, (value) => {
+			first = value;
+			found = true;
+			return false;
+		});
+	} catch {
+		return;
+	}
+	return found ? first : void 0;
+}
+function parseBmffMerkleMap(payload) {
+	const decoded = decodeFirstCbor(payload);
+	if (decoded === null || decoded === void 0 || typeof decoded !== "object") return null;
+	const uniqueId = asInteger(readMapField(decoded, "uniqueId"));
+	const localId = asInteger(readMapField(decoded, "localId"));
+	const location = asInteger(readMapField(decoded, "location"));
+	if (uniqueId === null || localId === null || location === null) return null;
+	const rawHashes = readMapField(decoded, "hashes");
+	if (rawHashes == null) return {
+		uniqueId,
+		localId,
+		location,
+		hashes: null
+	};
+	if (!Array.isArray(rawHashes)) return null;
+	const hashes = [];
+	for (const entry of rawHashes) {
+		if (entry == null) {
+			hashes.push(null);
+			continue;
+		}
+		const bytes = toUint8Array(entry);
+		if (!bytes) return null;
+		hashes.push(bytes);
+	}
+	return {
+		uniqueId,
+		localId,
+		location,
+		hashes
+	};
+}
+async function hashPair(left, right, alg) {
+	const input = new Uint8Array(left.length + right.length);
+	input.set(left, 0);
+	input.set(right, left.length);
+	return new Uint8Array(await crypto.subtle.digest(alg, input));
+}
+function treeLayout(leafCount) {
+	const layers = [leafCount];
+	while (layers[layers.length - 1] > 1) layers.push(Math.ceil(layers[layers.length - 1] / 2));
+	return layers;
+}
+async function verifyMerkleProof(leafHash, location, proofPath, merkleMap) {
+	const { count, hashes: manifestRow } = merkleMap;
+	if (location < 0 || location >= count) return C2paStatusCode.ASSERTION_BMFFHASH_MALFORMED;
+	const layers = treeLayout(count);
+	const committedLevel = layers.indexOf(manifestRow.length);
+	if (committedLevel === -1) return C2paStatusCode.ASSERTION_BMFFHASH_MALFORMED;
+	const rawPath = proofPath ?? [];
+	if (rawPath.length > committedLevel) return C2paStatusCode.ASSERTION_BMFFHASH_MALFORMED;
+	const path = rawPath.filter((node) => node !== null);
+	const alg = normalizeAlgorithmName(merkleMap.alg ?? void 0);
+	let currentHash = leafHash;
+	let currentIndex = location;
+	let proofIndex = 0;
+	for (const layer of layers) {
+		if (layer === manifestRow.length) break;
+		const siblingIndex = currentIndex % 2 === 0 ? currentIndex + 1 : currentIndex - 1;
+		if (siblingIndex >= 0 && siblingIndex < layer) {
+			const sibling = path[proofIndex++];
+			if (!sibling) return C2paStatusCode.ASSERTION_BMFFHASH_MALFORMED;
+			currentHash = currentIndex % 2 === 0 ? await hashPair(currentHash, sibling, alg) : await hashPair(sibling, currentHash, alg);
+		}
+		currentIndex = Math.floor(currentIndex / 2);
+	}
+	if (proofIndex !== path.length) return C2paStatusCode.ASSERTION_BMFFHASH_MALFORMED;
+	const expected = manifestRow[currentIndex];
+	if (!expected) return C2paStatusCode.ASSERTION_BMFFHASH_MALFORMED;
+	return hashesEqual(currentHash, expected) ? "ok" : C2paStatusCode.ASSERTION_BMFFHASH_MISMATCH;
+}
+function findMerkleMap(merkleMaps, uniqueId, localId) {
+	return merkleMaps.find((m) => m.uniqueId === uniqueId && m.localId === localId) ?? null;
+}
+async function computeLeafHash(segmentBytes, merkleMap, cache) {
+	const cached = cache.find((entry) => entry.alg === merkleMap.alg && entry.offsetPrefixSize === merkleMap.offsetPrefixSize && entry.exclusions === merkleMap.exclusions);
+	if (cached) return cached.hash;
+	const hash = await computeBmffHash(segmentBytes, {
+		offsetPrefixSize: merkleMap.offsetPrefixSize,
+		exclusions: merkleMap.exclusions,
+		alg: merkleMap.alg ?? void 0
+	});
+	cache.push({
+		alg: merkleMap.alg,
+		offsetPrefixSize: merkleMap.offsetPrefixSize,
+		exclusions: merkleMap.exclusions,
+		hash
+	});
+	return hash;
+}
+/**
+* Validates a fragmented MP4 VOD media segment against the init manifest's
+* merkle maps (§15.12.2.2). Pure: the caller persists `nextState` and resets
+* `state` after a seek.
+*
+* `merkleMaps` must be non-empty; the caller is responsible for only calling
+* this in VOD Merkle mode (i.e. after `InitSegmentValidation.merkleMaps` came
+* back non-empty).
+*
+* @example
+* {@includeCode ../../test/merkle/validateC2paMerkleSegment.test.ts#example}
+*
+* @public
+*/
+async function validateC2paMerkleSegment(segmentBytes, merkleMaps, state) {
+	const previousLocations = state?.lastLocations ?? /* @__PURE__ */ new Map();
+	const nextLocations = new Map(previousLocations);
+	const codes = /* @__PURE__ */ new Set();
+	const leafHashCache = [];
+	let location = null;
+	let bmffHashHex = null;
+	const payloads = extractMerkleAuxBoxes(segmentBytes);
+	if (payloads.length === 0) codes.add(C2paStatusCode.ASSERTION_BMFFHASH_MALFORMED);
+	for (const payload of payloads) {
+		const segmentMap = parseBmffMerkleMap(payload);
+		if (!segmentMap) {
+			codes.add(C2paStatusCode.ASSERTION_BMFFHASH_MALFORMED);
+			continue;
+		}
+		const merkleMap = findMerkleMap(merkleMaps, segmentMap.uniqueId, segmentMap.localId);
+		if (!merkleMap) {
+			codes.add(C2paStatusCode.ASSERTION_BMFFHASH_MALFORMED);
+			continue;
+		}
+		if (location === null) location = segmentMap.location;
+		const trackKey = `${segmentMap.uniqueId}:${segmentMap.localId}`;
+		const lastLocation = previousLocations.get(trackKey);
+		if (!(lastLocation === void 0 || segmentMap.location === lastLocation + 1)) codes.add(LiveVideoStatusCode.ASSERTION_INVALID);
+		const leafHash = await computeLeafHash(segmentBytes, merkleMap, leafHashCache);
+		if (bmffHashHex === null) bmffHashHex = bytesToHex(leafHash);
+		const proofResult = await verifyMerkleProof(leafHash, segmentMap.location, segmentMap.hashes, merkleMap);
+		if (proofResult === "ok") nextLocations.set(trackKey, segmentMap.location);
+		else codes.add(proofResult);
+	}
+	return {
+		result: {
+			location,
+			bmffHashHex,
+			isValid: codes.size === 0,
+			errorCodes: [...codes]
+		},
+		nextState: { lastLocations: nextLocations }
+	};
+}
+
+//#endregion
+export { C2paStatusCode, LiveVideoStatusCode, SequenceValidationReason, validateC2paInitSegment, validateC2paManifestBoxSegment, validateC2paMerkleSegment, validateC2paSegment };
 //# sourceMappingURL=index.js.map