@open-charging-cloud/wwcp-poi 0.1.1 → 0.2.0

package/dist/index.js

@@ -1,6 +1,6 @@
 import { encode, decode, cbor } from '@vanaheimr/metrological-cbor';
 import { sha512, sha384, sha256 } from '@noble/hashes/sha2.js';
-import { algorithmByName, verifyWith, CoseKey, KEY_TYPE_AKP, KEY_TYPE_OKP, KEY_TYPE_EC2 } from '@vanaheimr/cose';
+import { algorithmByName, verifyWith, CoseKey, KEY_TYPE_AKP, KEY_TYPE_OKP, KEY_TYPE_EC2, DerReader, contentsOf, Tag, derObjectIdentifier, derBitString, isOnCurve, CoseCurves } from '@vanaheimr/cose';
 
 // src/errors.ts
 var POIError = class extends Error {
@@ -170,7 +170,7 @@ function sameValue(left, right) {
       return false;
     const leftKeys = Object.keys(left);
     const rightKeys = Object.keys(right);
-    return leftKeys.length === rightKeys.length && leftKeys.every((key) => Object.prototype.hasOwnProperty.call(right, key) && sameValue(left[key], right[key]));
+    return leftKeys.length === rightKeys.length && leftKeys.every((key2) => Object.prototype.hasOwnProperty.call(right, key2) && sameValue(left[key2], right[key2]));
   }
   return left === right;
 }
@@ -520,12 +520,12 @@ function cborToJson(value) {
       return value.items.map(cborToJson);
     case "map": {
       const object = {};
-      for (const [key, item] of value.entries) {
-        if (key.type !== "text")
+      for (const [key2, item] of value.entries) {
+        if (key2.type !== "text")
           throw new POIError("A CBOR map with keys other than texts has no JSON representation!");
-        if (Object.prototype.hasOwnProperty.call(object, key.value))
-          throw new POIError(`A CBOR map names '${key.value}' twice!`);
-        set(object, key.value, cborToJson(item));
+        if (Object.prototype.hasOwnProperty.call(object, key2.value))
+          throw new POIError(`A CBOR map names '${key2.value}' twice!`);
+        set(object, key2.value, cborToJson(item));
       }
       return object;
     }
@@ -817,22 +817,22 @@ function signatureAlgorithm(name) {
     throw new POIError(`Unknown or noncanonical signature algorithm '${name}'!`);
   return algorithm;
 }
-function publicKeyBytes(key, algorithm) {
+function publicKeyBytes(key2, algorithm) {
   switch (algorithm.family) {
     case "ecdsa":
-      if (key.keyType !== KEY_TYPE_EC2 || key.x === null || key.y === null)
+      if (key2.keyType !== KEY_TYPE_EC2 || key2.x === null || key2.y === null)
         throw new POIError(`The algorithm '${algorithm.name}' needs an elliptic curve key with x and y!`);
-      return Uint8Array.of(4, ...key.x, ...key.y);
+      return Uint8Array.of(4, ...key2.x, ...key2.y);
     case "eddsa":
-      if (key.keyType !== KEY_TYPE_OKP || key.x === null)
+      if (key2.keyType !== KEY_TYPE_OKP || key2.x === null)
         throw new POIError(`The algorithm '${algorithm.name}' needs an octet key pair!`);
-      return key.x;
+      return key2.x;
     case "mldsa":
-      if (key.keyType !== KEY_TYPE_AKP || key.pub === null)
+      if (key2.keyType !== KEY_TYPE_AKP || key2.pub === null)
         throw new POIError(`The algorithm '${algorithm.name}' needs an algorithm key pair!`);
-      if (key.algorithm?.name !== algorithm.name)
-        throw new POIError(`The algorithm '${algorithm.name}' differs from the one of its key, '${key.algorithm?.name ?? "none"}'!`);
-      return key.pub;
+      if (key2.algorithm?.name !== algorithm.name)
+        throw new POIError(`The algorithm '${algorithm.name}' differs from the one of its key, '${key2.algorithm?.name ?? "none"}'!`);
+      return key2.pub;
     default:
       throw new POIError(`'${algorithm.name}' is no signature algorithm!`);
   }
@@ -852,19 +852,21 @@ function verifySignature(algorithmName, publicKey, input, value) {
   if (signature.length === 0)
     throw new POIError("The signature value must be nonempty canonical standard Base64!");
   const keyBytes = publicKeyBytes(publicKey, algorithm);
-  let valid;
+  let valid2;
   try {
-    valid = verifyWith(algorithm, publicKey.curve, input, signature, keyBytes);
+    valid2 = verifyWith(algorithm, publicKey.curve, input, signature, keyBytes);
   } catch (e) {
     throw new POIError(`The signature is invalid: ${e instanceof Error ? e.message : String(e)}`);
   }
-  if (!valid)
+  if (!valid2)
     throw new POIError("The signature is invalid!");
 }
 var KeyUsages = {
   Infrastructure: "infrastructure",
+  ChargeTransparencyRecords: "chargeTransparencyRecords",
   Tariffs: "tariffs",
   PriceStatements: "priceStatements",
+  WitnessPublications: "witnessPublications",
   Models: "models",
   Software: "software",
   Certificates: "certificates",
@@ -886,9 +888,9 @@ var isDeterministicCbor = (bytes) => {
   }
 };
 var POIPublicKey = class _POIPublicKey {
-  constructor(id, key, keyBytes, notBefore, notAfter, holder, usages, json) {
+  constructor(id, key2, keyBytes, notBefore, notAfter, holder, usages, json) {
     this.id = id;
-    this.key = key;
+    this.key = key2;
     this.keyBytes = keyBytes;
     this.notBefore = notBefore;
     this.notAfter = notAfter;
@@ -932,20 +934,20 @@ var POIPublicKey = class _POIPublicKey {
     if (id === void 0 || keyText === void 0)
       throw new POIError("A public key needs its identification and its key!");
     let keyBytes;
-    let key;
+    let key2;
     try {
       keyBytes = fromBase64(keyText);
     } catch {
       throw new POIError(isDotNetBase64(keyText) ? "A public key must be given as canonical Base64!" : `Invalid public key: ${DOTNET_BAD_BASE64}`);
     }
     try {
-      key = CoseKey.parse(keyBytes);
+      key2 = CoseKey.parse(keyBytes);
     } catch (e) {
       throw new POIError(`Invalid COSE key: ${e instanceof Error ? e.message : String(e)}`);
     }
     if (!isDeterministicCbor(keyBytes))
       throw new POIError(`Invalid COSE key: Invalid deterministic CBOR: the key of the public key '${id}' is not written as the deterministic CBOR of its COSE key!`);
-    if (key.isPrivate)
+    if (key2.isPrivate)
       throw new POIError("A public key must not contain private parts!");
     const notBefore = optionalTimestamp(json, "notBefore", `The notBefore of the key '${id}'`);
     const notAfter = optionalTimestamp(json, "notAfter", `The notAfter of the key '${id}'`);
@@ -973,13 +975,13 @@ var POIPublicKey = class _POIPublicKey {
       throw new POIError("Invalid public key: A public key must not expire before it becomes valid!");
     let thumbprint;
     try {
-      thumbprint = toHex(key.thumbprint("sha256"));
+      thumbprint = toHex(key2.thumbprint("sha256"));
     } catch (e) {
       throw new POIError(`Invalid public key: ${e instanceof Error ? e.message : String(e)}`);
     }
     if (thumbprint !== id)
       throw new POIError(`The identification '${id}' of a public key is not its thumbprint '${thumbprint}'!`);
-    return new _POIPublicKey(id, key, keyBytes, notBefore, notAfter, holder, usages, json);
+    return new _POIPublicKey(id, key2, keyBytes, notBefore, notAfter, holder, usages, json);
   }
   /** Reads an array of keys, refusing a key given twice. */
   static parseAll(value, what) {
@@ -988,7 +990,7 @@ var POIPublicKey = class _POIPublicKey {
     if (!isArray(value))
       throw new POIError(`The ${what} must be a JSON array!`);
     const keys = value.map((item) => _POIPublicKey.parse(item, `A key of the ${what}`));
-    if (new Set(keys.map((key) => key.id)).size !== keys.length)
+    if (new Set(keys.map((key2) => key2.id)).size !== keys.length)
       throw new POIError(`A key of the ${what} must not be given twice!`);
     return keys;
   }
@@ -1004,16 +1006,16 @@ function parseETag(value, hexOnly = false) {
     throw new POIError(`Unknown ETag format '${format}'!`);
   if (!isHashAlgorithm(algorithm))
     throw new POIError(`Unknown ETag hash algorithm '${algorithm}'!`);
-  let digest;
+  let digest2;
   if (encoding === "hex")
-    digest = fromHex(text, true);
+    digest2 = fromHex(text, true);
   else if (encoding === "base64" && !hexOnly)
-    digest = fromBase64(text);
+    digest2 = fromBase64(text);
   else
     throw new POIError(hexOnly ? `An ETag of a change set, commit or checkpoint must be written in hex, not in '${encoding}'!` : `Unknown ETag encoding '${encoding}'!`);
-  if (digest.length !== DIGEST_LENGTH[algorithm])
-    throw new POIError(`A ${algorithm} ETag has ${DIGEST_LENGTH[algorithm]} bytes, not ${digest.length}!`);
-  return { format, algorithm, digest };
+  if (digest2.length !== DIGEST_LENGTH[algorithm])
+    throw new POIError(`A ${algorithm} ETag has ${DIGEST_LENGTH[algorithm]} bytes, not ${digest2.length}!`);
+  return { format, algorithm, digest: digest2 };
 }
 function parseETags(value, hexOnly = false, what = "The ETags") {
   if (!isArray(value))
@@ -1141,18 +1143,18 @@ var groupId = (letters) => {
     return match === null ? ignoringCase(text) : `${ignoringCase(match[1] ?? "")}*${ignoringCase(match[2] ?? "")}*${letters}${ignoringCase(match[3] ?? "")}`;
   };
 };
-function twice(entities, key) {
+function twice(entities, key2) {
   const seen = /* @__PURE__ */ new Set();
   for (const entity of entities) {
-    const id = key(idOf(entity));
+    const id = key2(idOf(entity));
     if (seen.has(id))
       return entity;
     seen.add(id);
   }
   return void 0;
 }
-var givenTwice = (what, entities, key) => {
-  const duplicate = twice(entities, key);
+var givenTwice = (what, entities, key2) => {
+  const duplicate = twice(entities, key2);
   return duplicate === void 0 ? void 0 : `The ${what} '${idOf(duplicate)}' must not be given twice in the roaming network!`;
 };
 var childrenOf = (parties, property) => parties.flatMap((party) => objectsOf(get(party, property)));
@@ -1440,20 +1442,20 @@ function applyTemplates(member, templates, rules) {
   for (const [property, rule] of Object.entries(rules.unions)) {
     const own = get(member, property);
     const elements = isArray(own) ? [...own] : [];
-    const key = rule.key ?? byJSON;
-    const taken = new Set(elements.map(key));
+    const key2 = rule.key ?? byJSON;
+    const taken = new Set(elements.map(key2));
     for (const template of templates) {
       const values = get(template, property);
       if (isArray(values)) {
         for (const element of values)
-          if (!taken.has(key(element))) {
-            taken.add(key(element));
+          if (!taken.has(key2(element))) {
+            taken.add(key2(element));
             elements.push(clone(element));
           }
       }
     }
     if (rule.order === "ordinal") {
-      const sortBy = rule.sortBy ?? key;
+      const sortBy = rule.sortBy ?? key2;
       elements.sort((left, right) => ordinal(sortBy(left), sortBy(right)));
     }
     if (elements.length > 0)
@@ -1713,8 +1715,8 @@ function instantOf(text) {
   const date = /* @__PURE__ */ new Date(0);
   date.setUTCFullYear(Number(year), Number(month) - 1, Number(day));
   date.setUTCHours(Number(hour), Number(minute), Number(second), Number(digits.slice(0, 3)));
-  const valid = Number(year) >= 1 && date.getUTCFullYear() === Number(year) && date.getUTCMonth() === Number(month) - 1 && date.getUTCDate() === Number(day) && date.getUTCHours() === Number(hour) && date.getUTCMinutes() === Number(minute) && date.getUTCSeconds() === Number(second) && Number(offsetMinutes) <= 59 && offset <= 14 * 60;
-  return valid ? [date.getTime() - (sign === "-" ? -offset : offset) * 6e4, Number(digits.slice(3))] : void 0;
+  const valid2 = Number(year) >= 1 && date.getUTCFullYear() === Number(year) && date.getUTCMonth() === Number(month) - 1 && date.getUTCDate() === Number(day) && date.getUTCHours() === Number(hour) && date.getUTCMinutes() === Number(minute) && date.getUTCSeconds() === Number(second) && Number(offsetMinutes) <= 59 && offset <= 14 * 60;
+  return valid2 ? [date.getTime() - (sign === "-" ? -offset : offset) * 6e4, Number(digits.slice(3))] : void 0;
 }
 var invalidInstant = (json, property) => {
   const value = get(json, property);
@@ -1832,9 +1834,9 @@ function invalidConstruction(certificate, id) {
     return `The certificate '${id}' of an energy meter model names no energy meters! (Parameter 'EnergyMeters')`;
   const models = /* @__PURE__ */ new Map();
   for (const meter of energyMeters) {
-    const key = `${idKey(idAt(meter, "manufacturerId"))}\0${idKey(idAt(meter, "modelId"))}`;
-    const model = models.get(key);
-    models.set(key, { first: model?.first ?? meter, count: (model?.count ?? 0) + 1 });
+    const key2 = `${idKey(idAt(meter, "manufacturerId"))}\0${idKey(idAt(meter, "modelId"))}`;
+    const model = models.get(key2);
+    models.set(key2, { first: model?.first ?? meter, count: (model?.count ?? 0) + 1 });
   }
   const twiceNamed = [...models.values()].find((model) => model.count > 1)?.first;
   return twiceNamed === void 0 ? void 0 : `The energy meter model '${idAt(twiceNamed, "modelId")}' of '${idAt(twiceNamed, "manufacturerId")}' must not be given twice in the certificate '${id}'! (Parameter 'EnergyMeters')`;
@@ -2104,12 +2106,12 @@ function optionalI18N(json, property, description) {
 }
 function i18nOf(value, prefix) {
   const texts2 = [];
-  for (const [key, text] of Object.entries(value)) {
-    const language = key.toLowerCase();
+  for (const [key2, text] of Object.entries(value)) {
+    const language = key2.toLowerCase();
     if (!LANGUAGES.has(language))
-      throw new POIError(`${prefix}'${key}' is no language!`);
+      throw new POIError(`${prefix}'${key2}' is no language!`);
     if (typeof text !== "string")
-      throw new POIError(`${prefix}the text in '${key}' must be a text!`);
+      throw new POIError(`${prefix}the text in '${key2}' must be a text!`);
     if (texts2.some(([other]) => other === language))
       throw new POIError(`${prefix}the language '${language}' is given twice!`);
     texts2.push([language, text]);
@@ -2134,8 +2136,8 @@ var ignoringCase2 = (text) => Array.from(text, (character) => {
 }).join("");
 var sameId = (left, right) => left !== void 0 && right !== void 0 && ignoringCase2(left) === ignoringCase2(right);
 var sameText = (left, right) => left === void 0 ? right === void 0 : sameId(left, right);
-function distinct(values, key, description) {
-  if (new Set(values.map(key)).size !== values.length)
+function distinct(values, key2, description) {
+  if (new Set(values.map(key2)).size !== values.length)
     throw new POIError(`An ${description} must not be given twice!`);
   return [...values];
 }
@@ -2215,8 +2217,8 @@ function urlOf(json, property, description) {
 }
 function lenientI18N(value) {
   const texts2 = /* @__PURE__ */ new Map();
-  for (const [key, text] of Object.entries(value)) {
-    const language = trimmed(key).toLowerCase();
+  for (const [key2, text] of Object.entries(value)) {
+    const language = trimmed(key2).toLowerCase();
     if (typeof text === "string" && (LANGUAGES.has(language) || /^[+-]?\d+$/u.test(language)))
       texts2.set(language, text);
   }
@@ -2389,9 +2391,9 @@ function keysOf(party, property, description) {
     if (!isObject(item))
       throw new POIError(`Invalid ${description} '${compactJSON(item)}'!`);
     try {
-      const key = POIPublicKey.parse(item);
-      onlyProperties(item, KEY_PROPERTIES, `The public key '${key.id}'`);
-      return key;
+      const key2 = POIPublicKey.parse(item);
+      onlyProperties(item, KEY_PROPERTIES, `The public key '${key2.id}'`);
+      return key2;
     } catch (e) {
       throw new POIError(`Invalid ${description} '${compactJSON(item)}': ${e instanceof Error ? e.message : String(e)}`);
     }
@@ -2402,16 +2404,16 @@ function partyKeysOf(party, name, kind) {
   const identityKeys = keysOf(party, "identityKeys", "identity key");
   const invalid = (message) => new POIError(`The given JSON representation of ${kind} is invalid: ${message}`);
   for (const [keys, description] of [[signingKeys, "signing key"], [identityKeys, "identity key"]]) {
-    const ids = keys.map((key) => key.id);
+    const ids = keys.map((key2) => key2.id);
     if (new Set(ids).size !== ids.length)
       throw invalid(`An ${description} of ${name} must not be given twice!`);
   }
-  const signingIds = signingKeys.map((key) => key.id).sort(ordinal);
+  const signingIds = signingKeys.map((key2) => key2.id).sort(ordinal);
   const identities = [...identityKeys].sort((a, b) => ordinal(a.id, b.id));
-  const both = signingIds.find((id) => identityKeys.some((key) => key.id === id));
+  const both = signingIds.find((id) => identityKeys.some((key2) => key2.id === id));
   if (both !== void 0)
     throw invalid(`The key '${both}' of ${name} must not be both a signing and an identity key!`);
-  const withUsages = identities.find((key) => key.usages.length > 0);
+  const withUsages = identities.find((key2) => key2.usages.length > 0);
   if (withUsages !== void 0)
     throw invalid(`The identity key '${withUsages.id}' of ${name} names no usages: they are of signing keys!`);
   return { signingKeys, identityKeys };
@@ -3449,23 +3451,23 @@ function asRead(value, kind) {
   if (!isObject(value))
     return value;
   const known = PROPERTIES_OF[kind];
-  return Object.fromEntries(Object.entries(value).filter(([key]) => known === void 0 || known.includes(key)).map(([key, element]) => [key, PROPERTIES_OF[key] === void 0 ? element : asRead(element, key)]));
+  return Object.fromEntries(Object.entries(value).filter(([key2]) => known === void 0 || known.includes(key2)).map(([key2, element]) => [key2, PROPERTIES_OF[key2] === void 0 ? element : asRead(element, key2)]));
 }
 function notWritten(value, property, path, of) {
   const eachOnce = of === "new value";
-  const join = (at, key) => at === "" ? key : `${at}.${key}`;
+  const join = (at, key2) => at === "" ? key2 : `${at}.${key2}`;
   const holdsAs = (at, written) => ({ path: at, reason: `the content holds it as '${contentText(written)}'` });
-  const leftOut = (key, element, kind, keepsEmptyName) => {
+  const leftOut = (key2, element, kind, keepsEmptyName) => {
     if (element === null)
       return "a property without a value is left out";
-    if (isArray(element) && element.length === 0 && LEFT_OUT_WHEN_EMPTY.has(key) && !(key === "identityKeys" && kind === "keyStatement"))
+    if (isArray(element) && element.length === 0 && LEFT_OUT_WHEN_EMPTY.has(key2) && !(key2 === "identityKeys" && kind === "keyStatement"))
       return "a list without elements is left out";
-    if (TEXTS_IN_LANGUAGES.has(key) && isObject(element) && languagesOf(element).length === 0 && !(key === "name" && keepsEmptyName))
+    if (TEXTS_IN_LANGUAGES.has(key2) && isObject(element) && languagesOf(element).length === 0 && !(key2 === "name" && keepsEmptyName))
       return "the content leaves it out";
-    if (key === "dataLicenseIds")
+    if (key2 === "dataLicenseIds")
       return "the content leaves it out";
     const known = kind === void 0 ? void 0 : PROPERTIES_OF[kind];
-    if (known !== void 0 && !known.includes(key))
+    if (known !== void 0 && !known.includes(key2))
       return "the content leaves it out";
     return void 0;
   };
@@ -3476,7 +3478,7 @@ function notWritten(value, property, path, of) {
       if (name !== void 0 && ORDERED_TEXTS.has(name) && item.some((element) => typeof element === "string" && trimmed(element) !== element))
         return { path: at, reason: "the texts of its elements are trimmed" };
       const keys = orderKeys(item, name);
-      if (keys?.some((key, index) => index > 0 && ordinal(keys[index - 1] ?? "", key) >= (eachOnce ? 0 : 1)) === true)
+      if (keys?.some((key2, index) => index > 0 && ordinal(keys[index - 1] ?? "", key2) >= (eachOnce ? 0 : 1)) === true)
         return { path: at, reason: eachOnce ? "its elements are in the order the content holds them in, each once" : "its elements are in the order the content holds them in" };
       for (const [index, element] of item.entries()) {
         const elementAt = `${at}[${String(index)}]`;
@@ -3497,22 +3499,22 @@ function notWritten(value, property, path, of) {
       const keepsEmptyName = name === void 0 && holder === "chargingStationOperators";
       if (name !== void 0 && TEXTS_IN_LANGUAGES.has(name) && [...Object.keys(item)].sort(ordinal).join("\0") !== languagesOf(item).sort(ordinal).join("\0"))
         return { path: at, reason: "a text in languages names each language as Styx writes it, in lower case, with a text" };
-      for (const [key, element] of Object.entries(item)) {
-        if (key === "@context") {
+      for (const [key2, element] of Object.entries(item)) {
+        if (key2 === "@context") {
           if (root)
             continue;
           return { path: at, reason: "embedded, an object names no JSON-LD context" };
         }
-        const elementAt = join(at, key);
-        const omitted2 = leftOut(key, element, kind, keepsEmptyName);
+        const elementAt = join(at, key2);
+        const omitted2 = leftOut(key2, element, kind, keepsEmptyName);
         if (omitted2 !== void 0)
           return { path: elementAt, reason: omitted2 };
-        if (typeof element === "string" && TIMESTAMP_PROPERTIES.has(key) && !TIMESTAMP3.test(element))
+        if (typeof element === "string" && TIMESTAMP_PROPERTIES.has(key2) && !TIMESTAMP3.test(element))
           return { path: elementAt, reason: "a timestamp is UTC to the millisecond, yyyy-MM-ddTHH:mm:ss.fffZ" };
-        const written = key === "customData" ? void 0 : writtenValueOf(key, element, kind);
+        const written = key2 === "customData" ? void 0 : writtenValueOf(key2, element, kind);
         if (written !== void 0 && contentText(written) !== contentText(element))
           return holdsAs(elementAt, written);
-        const found = check2(element, key, kind, elementAt);
+        const found = check2(element, key2, kind, elementAt);
         if (found !== void 0)
           return found;
       }
@@ -3537,10 +3539,10 @@ function notWrittenAsHeld(content) {
       return value.map(unknownLicense).find((found2) => found2 !== void 0);
     if (!isObject(value))
       return void 0;
-    for (const [key, element] of Object.entries(value)) {
-      if (key === "customData")
+    for (const [key2, element] of Object.entries(value)) {
+      if (key2 === "customData")
         continue;
-      const unknown = key === "dataLicenseIds" && isArray(element) ? element.find((id) => typeof id === "string" && !KNOWN_DATA_LICENSES.has(id)) : void 0;
+      const unknown = key2 === "dataLicenseIds" && isArray(element) ? element.find((id) => typeof id === "string" && !KNOWN_DATA_LICENSES.has(id)) : void 0;
       if (unknown !== void 0)
         return `The data license '${asText(unknown)}' is not well-known, so it must be given completely!`;
       const found2 = unknownLicense(element);
@@ -3719,8 +3721,8 @@ function prunedDigest(entity, kind, algorithm, path = "$") {
   return { digest: leafHash(algorithm, canonicalJSONBytes(skeletonJSON)), attested };
 }
 function prunedTree(roamingNetwork, algorithm) {
-  const { digest, attested } = prunedDigest(roamingNetwork, "roamingNetwork", algorithm);
-  return { root: digest, attested };
+  const { digest: digest2, attested } = prunedDigest(roamingNetwork, "roamingNetwork", algorithm);
+  return { root: digest2, attested };
 }
 
 // src/proofs/keyStatement.ts
@@ -3788,9 +3790,9 @@ var KeyStatement = class _KeyStatement {
       return { algorithm, keyId, value: value2 };
     });
     onlyProperties(json, ["@context", "roamingNetworkId", "roamingNetworkOperatorId", "identityKeys", "minConsensus", "signedAt", "validUntil", "signatures"], "A key statement");
-    if (identityKeys.some((key, index) => {
+    if (identityKeys.some((key2, index) => {
       const before = identityKeys[index - 1];
-      return before !== void 0 && before.id >= key.id;
+      return before !== void 0 && before.id >= key2.id;
     }))
       throw new POIError("The identity keys of a key statement are written in the order of their @ids!");
     if (validUntil < signedAt)
@@ -3803,7 +3805,7 @@ var KeyStatement = class _KeyStatement {
       "@context": KEY_STATEMENT_CONTEXT,
       roamingNetworkId: this.roamingNetworkId,
       roamingNetworkOperatorId: this.roamingNetworkOperatorId,
-      identityKeys: this.identityKeys.map((key) => without(key.json, "@context")),
+      identityKeys: this.identityKeys.map((key2) => without(key2.json, "@context")),
       minConsensus: this.minConsensus,
       signedAt: toTimestamp(this.signedAt),
       validUntil: toTimestamp(this.validUntil)
@@ -3826,8 +3828,8 @@ var KeyStatement = class _KeyStatement {
   /** The `@id`s of its identity keys per holder, as it names their holders: what a trust anchor of it pins (8.6). */
   get holders() {
     const holders = /* @__PURE__ */ new Map();
-    for (const key of this.identityKeys)
-      holders.set(key.holderOrUnnamed, [...holders.get(key.holderOrUnnamed) ?? [], key.id]);
+    for (const key2 of this.identityKeys)
+      holders.set(key2.holderOrUnnamed, [...holders.get(key2.holderOrUnnamed) ?? [], key2.id]);
     return [...holders.values()];
   }
   /**
@@ -3880,7 +3882,7 @@ var KeyStatement = class _KeyStatement {
     if (only2 !== void 0 && this.signatures.length === 1 && required2 === 1 && !trusted.has(only2.keyId))
       throw new POIError(`The key statement is signed by the key '${only2.keyId}', which is not trusted!`);
     for (const signature of this.signatures) {
-      const identityKey = keys.find((key) => key.id === signature.keyId);
+      const identityKey = keys.find((key2) => key2.id === signature.keyId);
       if (identityKey === void 0)
         throw new POIError(`The identity key '${signature.keyId}' that signed the key statement is not given!`);
       if (!identityKey.isValidAt(this.signedAt))
@@ -3894,7 +3896,7 @@ var KeyStatement = class _KeyStatement {
       throw new POIError(`The key statement is signed by trusted identity keys of ${holders.size} holder${holders.size === 1 ? "" : "s"}, not of ${required2}!`);
     if (options.at !== void 0 && !this.isValidAt(options.at))
       throw new POIError(`The key statement is not valid at ${toTimestamp(options.at)}: it was signed at ${toTimestamp(this.signedAt)} and is valid until ${toTimestamp(this.validUntil)}!`);
-    const trustedThen = new Map(this.identityKeys.map((key) => [key.id, key.holderOrUnnamed]));
+    const trustedThen = new Map(this.identityKeys.map((key2) => [key2.id, key2.holderOrUnnamed]));
     for (const [id, holder] of trusted)
       if (!trustedThen.has(id))
         trustedThen.set(id, nameOfHolder(holder));
@@ -3904,7 +3906,7 @@ var KeyStatement = class _KeyStatement {
 
 // src/proofs/signingKeyCertificate.ts
 var SIGNING_KEY_CERTIFICATE_CONTEXT = CONTEXT_PREFIX + "roamingNetwork/signingKeyCertificate/v2";
-var describeHolder = (key) => key.holder !== void 0 ? `the holder '${key.holder}'` : "no named holder";
+var describeHolder = (key2) => key2.holder !== void 0 ? `the holder '${key2.holder}'` : "no named holder";
 var SigningKeyCertificate = class _SigningKeyCertificate {
   constructor(roamingNetworkOperatorId, signingKey, signedAt, algorithm, keyId, value, json) {
     this.roamingNetworkOperatorId = roamingNetworkOperatorId;
@@ -3965,7 +3967,7 @@ var SigningKeyCertificate = class _SigningKeyCertificate {
    * where trusted keys are given, of the same holder as the signing key, valid at `signedAt`. Returns that identity key.
    */
   verify(identityKeys, trustedIdentityKeyIds) {
-    const identityKey = identityKeys.find((key) => key.id === this.keyId);
+    const identityKey = identityKeys.find((key2) => key2.id === this.keyId);
     if (identityKey === void 0)
       throw new POIError(`The identity key '${this.keyId}' that certified the signing key '${this.signingKey.id}' is not given!`);
     if (trustedIdentityKeyIds !== void 0 && !trustedIdentityKeyIds.has(this.keyId))
@@ -3988,7 +3990,7 @@ var ROAMING_NETWORK_CONTEXT = CONTEXT_PREFIX + "roamingNetwork/v1";
 var KeyStatementError = class extends POIError {
 };
 var sameId2 = (left, right) => ignoringCase(trimmed(left)) === ignoringCase(trimmed(right));
-var holdersOf = (keys) => new Set(keys.map((key) => key.holderOrUnnamed));
+var holdersOf = (keys) => new Set(keys.map((key2) => key2.holderOrUnnamed));
 var RoamingNetworkOperator = class _RoamingNetworkOperator {
   constructor(id, identityKeys, minConsensus, keyStatement, signingKeyCertificates, json) {
     this.id = id;
@@ -4046,7 +4048,7 @@ var RoamingNetworkOperator = class _RoamingNetworkOperator {
       certified.set(certificate.signingKey.id, certificate.signingKey);
     }
     const signingKeys = [...certified.values()];
-    const both = [...signingKeys].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0).find((key) => identityKeys.some((identityKey) => identityKey.id === key.id));
+    const both = [...signingKeys].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0).find((key2) => identityKeys.some((identityKey) => identityKey.id === key2.id));
     if (both !== void 0)
       throw invalid(`The key '${both.id}' of the roaming network operator '${id}' must not be both a signing and an identity key!`);
     for (const [kind, keys] of [["signing", signingKeys], ["identity", identityKeys]]) {
@@ -4075,15 +4077,15 @@ var RoamingNetworkOperator = class _RoamingNetworkOperator {
     if (keyStatement !== void 0) {
       if (!sameId2(keyStatement.roamingNetworkOperatorId, id))
         throw new KeyStatementError(`The key statement of the roaming network operator '${id}' is one of '${keyStatement.roamingNetworkOperatorId}'!`);
-      const unknown = keyStatement.identityKeys.find((key) => !identityKeys.some((identityKey) => sameValue(without(asRead(identityKey.json, "identityKeys"), "@context"), without(key.json, "@context"))));
+      const unknown = keyStatement.identityKeys.find((key2) => !identityKeys.some((identityKey) => sameValue(without(asRead(identityKey.json, "identityKeys"), "@context"), without(key2.json, "@context"))));
       if (unknown !== void 0)
         throw new KeyStatementError(`The key statement of the roaming network operator '${id}' names the identity key '${unknown.id}', which is not one of its identity keys!`);
       if (keyStatement.minConsensus !== minConsensus)
         throw new KeyStatementError(`The key statement of the roaming network operator '${id}' states the minConsensus ${keyStatement.minConsensus}, not its ${minConsensus}!`);
       try {
         const holders = /* @__PURE__ */ new Map();
-        for (const key of identityKeys)
-          holders.set(key.holderOrUnnamed, [...holders.get(key.holderOrUnnamed) ?? [], key.id]);
+        for (const key2 of identityKeys)
+          holders.set(key2.holderOrUnnamed, [...holders.get(key2.holderOrUnnamed) ?? [], key2.id]);
         keyStatement.verifyHolders([...holders.values()], identityKeys, { minConsensus });
       } catch (e) {
         throw new KeyStatementError(minConsensus > 1 ? `The key statement of the roaming network operator '${id}' is not signed by identity keys of ${minConsensus} of its holders: ${e instanceof Error ? e.message : String(e)}` : `The key statement of the roaming network operator '${id}' is not signed by one of its identity keys: ${e instanceof Error ? e.message : String(e)}`);
@@ -4222,6 +4224,91 @@ var RoamingNetwork = class _RoamingNetwork {
   }
 };
 
+// src/history/epoch.ts
+var EPOCH_PROFILES_CONTEXT = CONTEXT_PREFIX + "roamingNetwork/epochProfiles/v1";
+var EPOCH_CONTEXT = CONTEXT_PREFIX + "roamingNetwork/epoch/v1";
+var EPOCH_LINK_CONTEXT = CONTEXT_PREFIX + "roamingNetwork/epochLink/v1";
+var STYX_CANONICAL_JSON = "styx-canonical-json-v1";
+var COMMIT_CONTEXT = CONTEXT_PREFIX + "roamingNetwork/commit/v3";
+var CHECKPOINT_CONTEXT = CONTEXT_PREFIX + "roamingNetwork/checkpoint/v1";
+var PRICE_STATEMENT_CONTEXT = CONTEXT_PREFIX + "roamingNetwork/priceStatement/v1";
+var EpochProfiles = class _EpochProfiles {
+  constructor(identificationHash, signatureAlgorithms) {
+    this.identificationHash = identificationHash;
+    this.signatureAlgorithms = signatureAlgorithms;
+  }
+  identificationHash;
+  signatureAlgorithms;
+  /** The profiles of the first epoch: SHA-256 identifications, every signature algorithm. */
+  static FIRST = new _EpochProfiles("sha256", []);
+  /** Reads profiles as `RoamingNetworkEpochProfiles.TryParse` does, refusing those this library can not calculate. */
+  static parse(value) {
+    const json = requireObject(value, "The profiles of an epoch");
+    onlyProperties(json, ["@context", "canonicalization", "identificationHash", "commit", "checkpoint", "priceStatement", "signatureAlgorithms"], "The profiles of an epoch");
+    if (get(json, "@context") !== void 0 && get(json, "@context") !== EPOCH_PROFILES_CONTEXT)
+      throw new POIError(`The JSON-LD context of the profiles of an epoch must be '${EPOCH_PROFILES_CONTEXT}'!`);
+    if (get(json, "canonicalization") !== STYX_CANONICAL_JSON)
+      throw new POIError(`The canonicalization of an epoch must be '${STYX_CANONICAL_JSON}', the one this library calculates!`);
+    const identificationHash = get(json, "identificationHash");
+    if (!isHashAlgorithm(identificationHash))
+      throw new POIError("The identification hash of an epoch must be sha256, sha384 or sha512!");
+    if (get(json, "commit") !== COMMIT_CONTEXT || get(json, "checkpoint") !== CHECKPOINT_CONTEXT || get(json, "priceStatement") !== PRICE_STATEMENT_CONTEXT)
+      throw new POIError(`The JSON-LD contexts of commits, checkpoints and price statements of an epoch must be '${COMMIT_CONTEXT}', '${CHECKPOINT_CONTEXT}' and '${PRICE_STATEMENT_CONTEXT}', the ones this library calculates!`);
+    const algorithmsJSON = get(json, "signatureAlgorithms");
+    const algorithms = [];
+    if (algorithmsJSON !== void 0) {
+      if (!isArray(algorithmsJSON) || !algorithmsJSON.every((name) => typeof name === "string"))
+        throw new POIError("The signature algorithms of an epoch must be a JSON array of COSE names!");
+      for (const name of algorithmsJSON) {
+        signatureAlgorithm(name);
+        if (!algorithms.includes(name))
+          algorithms.push(name);
+      }
+    }
+    return new _EpochProfiles(identificationHash, algorithms.sort());
+  }
+  /** Whether the epoch accepts signatures of the algorithm. */
+  allowsSignatureAlgorithm(algorithm) {
+    return this.signatureAlgorithms.length === 0 ? SIGNATURE_ALGORITHMS.includes(algorithm) : this.signatureAlgorithms.includes(algorithm);
+  }
+  toJSON() {
+    return {
+      canonicalization: STYX_CANONICAL_JSON,
+      identificationHash: this.identificationHash,
+      commit: COMMIT_CONTEXT,
+      checkpoint: CHECKPOINT_CONTEXT,
+      priceStatement: PRICE_STATEMENT_CONTEXT,
+      signatureAlgorithms: [...this.signatureAlgorithms]
+    };
+  }
+  toString() {
+    return `${this.identificationHash}, ${this.signatureAlgorithms.length === 0 ? "every signature algorithm" : this.signatureAlgorithms.join(", ")}`;
+  }
+};
+var FIRST_EPOCH = { number: 1, profiles: EpochProfiles.FIRST };
+function parseEpoch(value, what = "An epoch") {
+  const json = requireObject(value, what);
+  onlyProperties(json, ["@context", "epoch", "profiles", "previous", "previousProfiles"], what);
+  if (get(json, "@context") !== void 0 && get(json, "@context") !== EPOCH_CONTEXT)
+    throw new POIError(`The JSON-LD context of the epoch must be '${EPOCH_CONTEXT}'!`);
+  return {
+    number: requireInteger(json, "epoch", 1, 4294967295, `The number of ${what.toLowerCase()}`),
+    profiles: EpochProfiles.parse(get(json, "profiles"))
+  };
+}
+var sameEpoch = (left, right) => left.number === right.number && left.profiles.identificationHash === right.profiles.identificationHash && left.profiles.signatureAlgorithms.join() === right.profiles.signatureAlgorithms.join();
+function parseEpochLink(value) {
+  const json = requireObject(value, "The epoch before");
+  onlyProperties(json, ["@context", "epoch", "checkpointId", "eTags"], "The epoch before");
+  if (get(json, "@context") !== void 0 && get(json, "@context") !== EPOCH_LINK_CONTEXT)
+    throw new POIError(`The JSON-LD context of the epoch before must be '${EPOCH_LINK_CONTEXT}'!`);
+  return {
+    epoch: requireInteger(json, "epoch", 1, 4294967295, "The number of the epoch before"),
+    checkpointId: requireString(json, "checkpointId", "The final checkpoint of the epoch before"),
+    eTags: parseETags(get(json, "eTags"), true, "The ETags of the epoch before")
+  };
+}
+
 // src/proofs/trustAnchor.ts
 var TRUST_ANCHOR_CONTEXT = CONTEXT_PREFIX + "roamingNetwork/trustAnchor/v2";
 var TRUST_ANCHOR_QR_PREFIX = "WWCP/TA-2:";
@@ -4312,7 +4399,7 @@ var TrustAnchor = class _TrustAnchor {
     const keys = requireArray(get(json, "keys"), "The keys of a trust anchor").map((holder) => {
       if (typeof holder === "string")
         return holder;
-      if (Array.isArray(holder) && holder.length > 0 && holder.every((key) => typeof key === "string"))
+      if (Array.isArray(holder) && holder.length > 0 && holder.every((key2) => typeof key2 === "string"))
         return holder;
       throw new POIError("A trust anchor names the identity keys of the roaming network operator by their @ids, per holder!");
     });
@@ -4326,12 +4413,12 @@ var TrustAnchor = class _TrustAnchor {
     if (value.type !== "map")
       throw new POIError("The CBOR representation of a trust anchor must be a map!");
     const values = /* @__PURE__ */ new Map();
-    for (const [key, item] of value.entries) {
-      if (key.type !== "text")
+    for (const [key2, item] of value.entries) {
+      if (key2.type !== "text")
         throw new POIError("The CBOR representation of a trust anchor must be a map with text keys!");
-      if (values.has(key.value))
-        throw new POIError(`The CBOR representation of a trust anchor names '${key.value}' twice!`);
-      values.set(key.value, item);
+      if (values.has(key2.value))
+        throw new POIError(`The CBOR representation of a trust anchor names '${key2.value}' twice!`);
+      values.set(key2.value, item);
     }
     const context = values.get("@context");
     if (context !== void 0 && !(context.type === "text" && context.value === TRUST_ANCHOR_CONTEXT))
@@ -4345,10 +4432,10 @@ var TrustAnchor = class _TrustAnchor {
     const keys = values.get("keys");
     if (keys?.type !== "array")
       throw new POIError("The identity keys of a trust anchor must be an array, one entry per holder!");
-    const thumbprint = (key) => {
-      if (key.type !== "bytes" || key.value.length !== 32)
+    const thumbprint = (key2) => {
+      if (key2.type !== "bytes" || key2.value.length !== 32)
         throw new POIError("The identity keys of a trust anchor must be their SHA-256 thumbprints, 32 bytes each, per holder!");
-      return toHex(key.value);
+      return toHex(key2.value);
     };
     const holders = keys.items.map((holder) => holder.type === "array" ? holder.items.map(thumbprint) : thumbprint(holder));
     let quorum = 1;
@@ -4389,7 +4476,7 @@ var TrustAnchor = class _TrustAnchor {
       [cbor.text("@id"), cbor.text(this.id)],
       [cbor.text("@context"), cbor.text(TRUST_ANCHOR_CONTEXT)],
       [cbor.text("urls"), cbor.array(this.urls.map((url) => cbor.text(url)))],
-      [cbor.text("keys"), cbor.array(this.holders.map((keys) => keys.length === 1 ? cbor.bytes(fromHex(required(keys[0], "The key of a holder"), true)) : cbor.array(keys.map((key) => cbor.bytes(fromHex(key, true))))))]
+      [cbor.text("keys"), cbor.array(this.holders.map((keys) => keys.length === 1 ? cbor.bytes(fromHex(required(keys[0], "The key of a holder"), true)) : cbor.array(keys.map((key2) => cbor.bytes(fromHex(key2, true))))))]
     ];
     if (Object.keys(this.name).length > 0)
       entries.push([cbor.text("name"), cbor.map(Object.entries(this.name).map(([language, text]) => [cbor.text(language), cbor.text(text)]))]);
@@ -4448,7 +4535,7 @@ function checkTrustAnchor(urls, holders, minConsensus) {
       throw new POIError(`The URLs of a trust anchor name one roaming network, not '${networkId}' and '${urlNetworkId}'!`);
   }
   const keys = holders.flat();
-  if (keys.length === 0 || holders.some((holder) => holder.length === 0) || keys.some((key) => !/^[0-9a-f]{64}$/.test(key)) || new Set(keys).size !== keys.length)
+  if (keys.length === 0 || holders.some((holder) => holder.length === 0) || keys.some((key2) => !/^[0-9a-f]{64}$/.test(key2)) || new Set(keys).size !== keys.length)
     throw new POIError("A trust anchor names at least one identity key by its @id, 64 lowercase hexadecimal digits, each once, and every holder with at least one!");
   if (minConsensus < 1 || minConsensus > holders.length)
     throw new POIError(`The minConsensus ${minConsensus} of a trust anchor needs identity keys of as many holders, not of ${holders.length}!`);
@@ -4457,8 +4544,11 @@ function checkTrustAnchor(urls, holders, minConsensus) {
 
 // src/proofs/trustContext.ts
 var TrustContext = class _TrustContext {
-  constructor(anchor, holders, statement, evaluatedAt) {
+  constructor(anchor, holders, statement, evaluatedAt, epoch = FIRST_EPOCH, epochs = [FIRST_EPOCH]) {
+    this.statement = statement;
     this.evaluatedAt = evaluatedAt;
+    this.epoch = epoch;
+    this.epochs = epochs;
     this.anchor = frozenAnchor(anchor);
     this.trustedHolders = Object.freeze(holders.map((holder) => Object.freeze([...holder])));
     this.authorizedAnchor = frozenAnchor(TrustAnchor.create(
@@ -4476,7 +4566,10 @@ var TrustContext = class _TrustContext {
     this.validUntil = statement.validUntil;
     Object.freeze(this);
   }
+  statement;
   evaluatedAt;
+  epoch;
+  epochs;
   anchor;
   authorizedAnchor;
   trustedHolders;
@@ -4485,6 +4578,10 @@ var TrustContext = class _TrustContext {
   keyStatementDigest;
   requiredConsensus;
   validUntil;
+  /** Attach only profiles established by a verified transition; the bootstrap keeps the first epoch. */
+  static withEpoch(reference, epoch, epochs = [epoch]) {
+    return new _TrustContext(reference.anchor, reference.trustedHolders, reference.statement, reference.evaluatedAt, epoch, Object.freeze([...epochs]));
+  }
   static create(anchor, statement, options) {
     const result = _TrustContext.evaluate(anchor, statement, options);
     if (result.context === void 0)
@@ -4507,11 +4604,11 @@ var TrustContext = class _TrustContext {
     let verificationError;
     try {
       for (const signature of statement.signatures) {
-        const key = pool.find((key2) => key2.id === signature.keyId);
-        if (key === void 0)
+        const key2 = pool.find((key3) => key3.id === signature.keyId);
+        if (key2 === void 0)
           throw new POIError("The public key of a signer was not provided");
-        statement.verifySignature(signature, key);
-        if (!key.isValidAt(statement.signedAt))
+        statement.verifySignature(signature, key2);
+        if (!key2.isValidAt(statement.signedAt))
           keysValid = false;
       }
     } catch (error) {
@@ -4657,10 +4754,10 @@ var Attestation = class _Attestation {
     return canonicalJSONBytes(json);
   }
   /** Verifies the signature with a trusted key, refusing one by another key. */
-  verifySignature(key) {
-    if (this.keyId !== key.id)
+  verifySignature(key2) {
+    if (this.keyId !== key2.id)
       throw new POIError("The attestation is signed by another key.");
-    verifySignature(this.algorithm, key.key, this.signingBytes(), this.value);
+    verifySignature(this.algorithm, key2.key, this.signingBytes(), this.value);
   }
   /** Whether it is valid at the given point in time: signed then or before, and not after its `validUntil`. */
   isValidAt(time) {
@@ -4744,10 +4841,13 @@ var ChargingStationProof = class _ChargingStationProof {
     const { eTag, attested } = this.calculate();
     const { keyStatement, required: required2, signingKeyOf } = this.certifiedSigningKeys(basis, time);
     const certifiedSigningKeyOf = (attestation) => signingKeyOf(attestation.keyId, attestation.signedAt);
+    let validUntil = keyStatement.validUntil;
     const counted = [];
     const holders = /* @__PURE__ */ new Set();
     const refused = [];
+    if (basis instanceof TrustContext && basis.epoch.number > 1 && this.commitId.length !== { sha256: 64, sha384: 96, sha512: 128 }[basis.epoch.profiles.identificationHash]) throw new POIError("The station commit identification does not match its verified epoch profile");
     for (const attestation of this.attestations) {
+      if (basis instanceof TrustContext && (!basis.epoch.profiles.allowsSignatureAlgorithm(attestation.algorithm) || attestation.signedAt < (basis.epoch.startedAt ?? -Infinity))) continue;
       if (attestation.roamingNetworkId !== networkId || attestation.commitId !== this.commitId || attestation.revision !== this.revision || attestation.eTag.algorithm !== this.hashAlgorithm)
         continue;
       if (attestation.subject !== void 0 || !bytesEqual(attestation.eTag.digest, eTag.digest)) {
@@ -4774,11 +4874,12 @@ var ChargingStationProof = class _ChargingStationProof {
         continue;
       }
       counted.push(attestation);
+      validUntil = Math.min(validUntil, attestation.validUntil, certified.validUntil);
       holders.add(certified.holder);
     }
     if (holders.size < required2)
       throw new POIError(`Valid attestations of trusted keys of ${holders.size} holder${holders.size === 1 ? "" : "s"} attest the root ${etagToText(eTag)} of the proof, not of ${required2}!` + (refused.length > 0 ? ` (${refused.join("; ")})` : ""));
-    return { eTag, attested, attestations: counted, attestedBy: [...holders].sort(), keyStatement };
+    return { eTag, attested, attestations: counted, attestedBy: [...holders].sort(), keyStatement, validUntil };
   }
   /**
    * Verifies a checkpoint against a trust anchor with this proof of the version of its commit (10.5), as
@@ -4850,8 +4951,12 @@ var ChargingStationProof = class _ChargingStationProof {
         if (certificate.signingKey.id !== keyId || certificate.roamingNetworkOperatorId !== operatorId || !certificate.signingKey.isValidAt(signedAt) || !certificate.signingKey.isValidAt(time) || !certificate.signingKey.maySign(KeyUsages.Party))
           continue;
         try {
-          certificate.verify(identityKeys, trustedIds);
-          return { key: certificate.signingKey, holder: required(holderOf.get(certificate.keyId), "The holder of a trusted identity key") };
+          const identity = certificate.verify(identityKeys, trustedIds);
+          return {
+            key: certificate.signingKey,
+            holder: required(holderOf.get(certificate.keyId), "The holder of a trusted identity key"),
+            validUntil: Math.min(certificate.signingKey.notAfter ?? Infinity, identity.notAfter ?? Infinity)
+          };
         } catch {
           continue;
         }
@@ -4877,7 +4982,7 @@ var ChargingStationProof = class _ChargingStationProof {
 };
 
 // src/proofs/priceStatement.ts
-var PRICE_STATEMENT_CONTEXT = CONTEXT_PREFIX + "roamingNetwork/priceStatement/v1";
+var PRICE_STATEMENT_CONTEXT2 = CONTEXT_PREFIX + "roamingNetwork/priceStatement/v1";
 var PRICE_STATEMENT_PROOF_CONTEXT = CONTEXT_PREFIX + "roamingNetwork/priceStatementProof/v1";
 var PRICE_STATEMENT_ENTITY_TYPES = ["ChargingPool", "ChargingStation", "EVSE"];
 var MAX_PRICE_STATEMENT_SEQUENCE = Number.MAX_SAFE_INTEGER;
@@ -4919,7 +5024,7 @@ var PriceStatement = class _PriceStatement {
   json;
   static parse(value) {
     const given2 = requireObject(value, "A price statement");
-    checkContext(given2, PRICE_STATEMENT_CONTEXT, "a price statement");
+    checkContext(given2, PRICE_STATEMENT_CONTEXT2, "a price statement");
     onlyProperties(given2, [
       "@context",
       "roamingNetworkId",
@@ -4938,7 +5043,7 @@ var PriceStatement = class _PriceStatement {
       "keyId",
       "value"
     ], "A price statement");
-    const json = { ...given2, "@context": PRICE_STATEMENT_CONTEXT };
+    const json = { ...given2, "@context": PRICE_STATEMENT_CONTEXT2 };
     const entityType = requireString(json, "entityType", "The entity type of a price statement");
     if (!PRICE_STATEMENT_ENTITY_TYPES.includes(entityType))
       throw new POIError(`A price statement is one of a ChargingPool, a ChargingStation or an EVSE, not of a '${entityType}'!`);
@@ -5013,19 +5118,19 @@ var PriceStatement = class _PriceStatement {
       throw new POIError(`The price statement is one of the roaming network '${this.roamingNetworkId}', not of '${roamingNetworkId}'!`);
     if (this.signer !== operatorId || !this.entityId.startsWith(operatorId + "*"))
       throw new POIError(`The price statement of the ${this.entityType} '${this.entityId}' is not signed by its operator '${operatorId}'!`);
-    const key = signingKeys.find((signingKey) => signingKey.id === this.keyId);
-    if (key === void 0)
+    const key2 = signingKeys.find((signingKey) => signingKey.id === this.keyId);
+    if (key2 === void 0)
       throw new POIError(`The key '${this.keyId}' is no signing key of the charging station operator '${operatorId}'!`);
-    if (!key.isValidAt(this.signedAt))
-      throw new POIError(`The signing key '${key.id}' of the charging station operator '${operatorId}' was not valid when the price statement was signed!`);
-    if (!key.maySign(KeyUsages.PriceStatements))
-      throw new POIError(`The signing key '${key.id}' of the charging station operator '${operatorId}' may not sign 'priceStatements', only '${key.usages.join(", ")}'!`);
+    if (!key2.isValidAt(this.signedAt))
+      throw new POIError(`The signing key '${key2.id}' of the charging station operator '${operatorId}' was not valid when the price statement was signed!`);
+    if (!key2.maySign(KeyUsages.PriceStatements))
+      throw new POIError(`The signing key '${key2.id}' of the charging station operator '${operatorId}' may not sign 'priceStatements', only '${key2.usages.join(", ")}'!`);
     try {
-      verifySignature(this.algorithm, key.key, this.signingBytes(), this.value);
+      verifySignature(this.algorithm, key2.key, this.signingBytes(), this.value);
     } catch (e) {
       throw new POIError(`The signature of the price statement is invalid: ${e instanceof Error ? e.message : String(e)}`);
     }
-    return key;
+    return key2;
   }
   /** Whether it is valid at the given point in time: from `validFrom`, until `validUntil` where it names one. */
   isValidAt(time) {
@@ -5121,91 +5226,6 @@ var PriceStatementProof = class _PriceStatementProof {
   }
 };
 
-// src/history/epoch.ts
-var EPOCH_PROFILES_CONTEXT = CONTEXT_PREFIX + "roamingNetwork/epochProfiles/v1";
-var EPOCH_CONTEXT = CONTEXT_PREFIX + "roamingNetwork/epoch/v1";
-var EPOCH_LINK_CONTEXT = CONTEXT_PREFIX + "roamingNetwork/epochLink/v1";
-var STYX_CANONICAL_JSON = "styx-canonical-json-v1";
-var COMMIT_CONTEXT = CONTEXT_PREFIX + "roamingNetwork/commit/v3";
-var CHECKPOINT_CONTEXT = CONTEXT_PREFIX + "roamingNetwork/checkpoint/v1";
-var PRICE_STATEMENT_CONTEXT2 = CONTEXT_PREFIX + "roamingNetwork/priceStatement/v1";
-var EpochProfiles = class _EpochProfiles {
-  constructor(identificationHash, signatureAlgorithms) {
-    this.identificationHash = identificationHash;
-    this.signatureAlgorithms = signatureAlgorithms;
-  }
-  identificationHash;
-  signatureAlgorithms;
-  /** The profiles of the first epoch: SHA-256 identifications, every signature algorithm. */
-  static FIRST = new _EpochProfiles("sha256", []);
-  /** Reads profiles as `RoamingNetworkEpochProfiles.TryParse` does, refusing those this library can not calculate. */
-  static parse(value) {
-    const json = requireObject(value, "The profiles of an epoch");
-    onlyProperties(json, ["@context", "canonicalization", "identificationHash", "commit", "checkpoint", "priceStatement", "signatureAlgorithms"], "The profiles of an epoch");
-    if (get(json, "@context") !== void 0 && get(json, "@context") !== EPOCH_PROFILES_CONTEXT)
-      throw new POIError(`The JSON-LD context of the profiles of an epoch must be '${EPOCH_PROFILES_CONTEXT}'!`);
-    if (get(json, "canonicalization") !== STYX_CANONICAL_JSON)
-      throw new POIError(`The canonicalization of an epoch must be '${STYX_CANONICAL_JSON}', the one this library calculates!`);
-    const identificationHash = get(json, "identificationHash");
-    if (!isHashAlgorithm(identificationHash))
-      throw new POIError("The identification hash of an epoch must be sha256, sha384 or sha512!");
-    if (get(json, "commit") !== COMMIT_CONTEXT || get(json, "checkpoint") !== CHECKPOINT_CONTEXT || get(json, "priceStatement") !== PRICE_STATEMENT_CONTEXT2)
-      throw new POIError(`The JSON-LD contexts of commits, checkpoints and price statements of an epoch must be '${COMMIT_CONTEXT}', '${CHECKPOINT_CONTEXT}' and '${PRICE_STATEMENT_CONTEXT2}', the ones this library calculates!`);
-    const algorithmsJSON = get(json, "signatureAlgorithms");
-    const algorithms = [];
-    if (algorithmsJSON !== void 0) {
-      if (!isArray(algorithmsJSON) || !algorithmsJSON.every((name) => typeof name === "string"))
-        throw new POIError("The signature algorithms of an epoch must be a JSON array of COSE names!");
-      for (const name of algorithmsJSON) {
-        signatureAlgorithm(name);
-        if (!algorithms.includes(name))
-          algorithms.push(name);
-      }
-    }
-    return new _EpochProfiles(identificationHash, algorithms.sort());
-  }
-  /** Whether the epoch accepts signatures of the algorithm. */
-  allowsSignatureAlgorithm(algorithm) {
-    return this.signatureAlgorithms.length === 0 ? SIGNATURE_ALGORITHMS.includes(algorithm) : this.signatureAlgorithms.includes(algorithm);
-  }
-  toJSON() {
-    return {
-      canonicalization: STYX_CANONICAL_JSON,
-      identificationHash: this.identificationHash,
-      commit: COMMIT_CONTEXT,
-      checkpoint: CHECKPOINT_CONTEXT,
-      priceStatement: PRICE_STATEMENT_CONTEXT2,
-      signatureAlgorithms: [...this.signatureAlgorithms]
-    };
-  }
-  toString() {
-    return `${this.identificationHash}, ${this.signatureAlgorithms.length === 0 ? "every signature algorithm" : this.signatureAlgorithms.join(", ")}`;
-  }
-};
-var FIRST_EPOCH = { number: 1, profiles: EpochProfiles.FIRST };
-function parseEpoch(value, what = "An epoch") {
-  const json = requireObject(value, what);
-  onlyProperties(json, ["@context", "epoch", "profiles", "previous", "previousProfiles"], what);
-  if (get(json, "@context") !== void 0 && get(json, "@context") !== EPOCH_CONTEXT)
-    throw new POIError(`The JSON-LD context of the epoch must be '${EPOCH_CONTEXT}'!`);
-  return {
-    number: requireInteger(json, "epoch", 1, 4294967295, `The number of ${what.toLowerCase()}`),
-    profiles: EpochProfiles.parse(get(json, "profiles"))
-  };
-}
-var sameEpoch = (left, right) => left.number === right.number && left.profiles.identificationHash === right.profiles.identificationHash && left.profiles.signatureAlgorithms.join() === right.profiles.signatureAlgorithms.join();
-function parseEpochLink(value) {
-  const json = requireObject(value, "The epoch before");
-  onlyProperties(json, ["@context", "epoch", "checkpointId", "eTags"], "The epoch before");
-  if (get(json, "@context") !== void 0 && get(json, "@context") !== EPOCH_LINK_CONTEXT)
-    throw new POIError(`The JSON-LD context of the epoch before must be '${EPOCH_LINK_CONTEXT}'!`);
-  return {
-    epoch: requireInteger(json, "epoch", 1, 4294967295, "The number of the epoch before"),
-    checkpointId: requireString(json, "checkpointId", "The final checkpoint of the epoch before"),
-    eTags: parseETags(get(json, "eTags"), true, "The ETags of the epoch before")
-  };
-}
-
 // src/history/changeSet.ts
 var CHANGE_SET_CONTEXT = CONTEXT_PREFIX + "roamingNetwork/changeSet/v3";
 var MERGE_CHANGE_SET_ID_PREFIX = "merge-";
@@ -5223,7 +5243,7 @@ function checkRebasedFrom(json, id) {
     throw new POIError(`The rebasedFrom of the change set '${id}' must be an array of the change sets it was rebased from!`);
   rebasedFrom.forEach((entry, index) => {
     const malformed = `Entry ${index} of the rebasedFrom of the change set '${id}' must name the @id, the beforeETags and the afterETags of a change set it was rebased from!`;
-    if (!isObject(entry) || Object.keys(entry).some((key) => key !== "@id" && key !== "beforeETags" && key !== "afterETags"))
+    if (!isObject(entry) || Object.keys(entry).some((key2) => key2 !== "@id" && key2 !== "beforeETags" && key2 !== "afterETags"))
       throw new POIError(malformed);
     const namedId = get(entry, "@id");
     const beforeETags = get(entry, "beforeETags");
@@ -5366,10 +5386,10 @@ var ChangeSet = class _ChangeSet {
     });
   }
   /** Verifies one signature with the given key. */
-  verifySignature(signature, key) {
-    if (signature.keyId !== key.id)
+  verifySignature(signature, key2) {
+    if (signature.keyId !== key2.id)
       throw new POIError("The signature key ID does not match the key ID.");
-    verifySignature(signature.algorithm, key.key, this.signingBytes(signature), signature.value);
+    verifySignature(signature.algorithm, key2.key, this.signingBytes(signature), signature.value);
   }
 };
 
@@ -5473,8 +5493,9 @@ var Commit = class _Commit {
       throw new POIError("The change set must be a JSON object!");
     if (parentIds.length === 0 !== (changeSet === void 0))
       throw new POIError(`The commit '${id}' must have parents and a change set, or neither, as a genesis commit!`);
-    if (!eTags.some((eTag) => eTag.format === "effectiveTree"))
-      throw new POIError(`The commit '${id}' names no effectiveTree ETag!`);
+    for (const format of ["json", "cbor", "effectiveTree"])
+      if (!eTags.some((eTag) => eTag.format === format))
+        throw new POIError(`The commit '${id}' names no ${format} ETag: a commit requires the json, cbor and effectiveTree ETags of its version!`);
     const signaturesJSON = get(json, "signatures");
     const signatures = signaturesJSON === void 0 ? [] : requireArray(signaturesJSON, "The signatures of a commit").map((signature) => parseRoleSignature(signature, "A signature of a commit"));
     const identificationHash = hashAlgorithmOfIdentification(id);
@@ -5531,10 +5552,10 @@ var Commit = class _Commit {
     return roleSignatureBytes(COMMIT_SIGNATURE_CONTEXT, signature, "commit", this.signedContent());
   }
   /** Verifies one signature with a trusted key, refusing one by another key. */
-  verifySignature(signature, key) {
-    if (signature.keyId !== key.id)
+  verifySignature(signature, key2) {
+    if (signature.keyId !== key2.id)
       throw new POIError("The signature key ID does not match the trusted key ID.");
-    verifySignature(signature.algorithm, key.key, this.signingBytes(signature), signature.value);
+    verifySignature(signature.algorithm, key2.key, this.signingBytes(signature), signature.value);
   }
   /** The description of its change set, in its first language. */
   get description() {
@@ -6188,17 +6209,17 @@ function ownerOf(content, change, index, addedEnergyMeterChildren) {
   }
   const energyMeterChild = ENERGY_METER_CHILD_TYPES[change.entityType];
   if (energyMeterChild !== void 0) {
-    const key = `${change.entityType}:${change.entityId.toUpperCase()}`;
+    const key2 = `${change.entityType}:${change.entityId.toUpperCase()}`;
     let owner;
     if (change.kind === "Add") {
       if (change.parentEntityType !== "ChargingStationOperator" && change.parentEntityType !== "GridOperator" || change.parentEntityId === void 0)
         throw new POIError(`Change ${index}: adding the ${change.entityType} '${change.entityId}' needs its ChargingStationOperator or GridOperator as its parent!`);
       const party = partyNamed(content, change.parentEntityType, change.parentEntityId);
       owner = { type: change.parentEntityType, id: asText(party?.["@id"] ?? change.parentEntityId) };
-      addedEnergyMeterChildren.set(key, owner);
+      addedEnergyMeterChildren.set(key2, owner);
     } else {
       const found = energyMeterChildOf(content, energyMeterChild, change.entityId);
-      owner = addedEnergyMeterChildren.get(key) ?? (found === void 0 ? void 0 : { type: found.partyType, id: asText(found.party["@id"]) });
+      owner = addedEnergyMeterChildren.get(key2) ?? (found === void 0 ? void 0 : { type: found.partyType, id: asText(found.party["@id"]) });
     }
     if (owner === void 0)
       throw new POIError(`Change ${index}: the ${change.entityType} '${change.entityId}' belongs to no charging station operator and no grid operator!`);
@@ -6265,40 +6286,40 @@ function checkOwnership(before, changeSet) {
     if (keys === void 0)
       return;
     const known = change.entityType === "RoamingNetworkOperator" ? rnoIdentity : parties.get(`${change.entityType}:${change.entityId}`)?.identityKeys ?? [];
-    for (const key of POIPublicKey.parseAll(keys, `identity keys of change ${index}`))
-      if (!known.some((knownKey) => knownKey.id === key.id))
-        newIdentityKeys.push(key);
+    for (const key2 of POIPublicKey.parseAll(keys, `identity keys of change ${index}`))
+      if (!known.some((knownKey) => knownKey.id === key2.id))
+        newIdentityKeys.push(key2);
   });
   const allKeys = /* @__PURE__ */ new Map();
-  for (const key of [...rnoSigning, ...rnoIdentity, ...[...parties.values()].flatMap((party) => [...party.signingKeys, ...party.identityKeys]), ...newIdentityKeys])
-    allKeys.set(key.id, key);
+  for (const key2 of [...rnoSigning, ...rnoIdentity, ...[...parties.values()].flatMap((party) => [...party.signingKeys, ...party.identityKeys]), ...newIdentityKeys])
+    allKeys.set(key2.id, key2);
   const partyKeys = [
-    ...rno === void 0 ? [] : [...rnoSigning, ...rnoIdentity].map((key) => ({ party: `RoamingNetworkOperator '${rno.id}'`, key })),
-    ...[...parties.values()].flatMap((party) => [...party.signingKeys, ...party.identityKeys].map((key) => ({ party: `${party.type} '${party.id}'`, key })))
+    ...rno === void 0 ? [] : [...rnoSigning, ...rnoIdentity].map((key2) => ({ party: `RoamingNetworkOperator '${rno.id}'`, key: key2 })),
+    ...[...parties.values()].flatMap((party) => [...party.signingKeys, ...party.identityKeys].map((key2) => ({ party: `${party.type} '${party.id}'`, key: key2 })))
   ];
-  const valid = /* @__PURE__ */ new Set();
+  const valid2 = /* @__PURE__ */ new Set();
   changeSet.signatures.forEach((signature, index) => {
-    const key = allKeys.get(signature.keyId);
-    if (key === void 0)
+    const key2 = allKeys.get(signature.keyId);
+    if (key2 === void 0)
       throw new POIError(`Signature ${index} is by the key '${signature.keyId}', which is no key of a party of this roaming network!`);
     for (const partyKey of partyKeys.filter((item) => item.key.id === signature.keyId))
       if (!partyKey.key.isValidAt(createdAt))
         throw new POIError(`Signature ${index}: the key '${partyKey.key.id}' of the ${partyKey.party} is not valid at ${toTimestamp(createdAt)}!`);
     try {
-      changeSet.verifySignature(signature, key);
+      changeSet.verifySignature(signature, key2);
     } catch (e) {
       throw new POIError(`Signature ${index} ('${signature.keyId}') is invalid: ${e instanceof Error ? e.message : String(e)}`);
     }
-    valid.add(signature.keyId);
+    valid2.add(signature.keyId);
   });
-  for (const key of newIdentityKeys)
-    if (!valid.has(key.id))
-      throw new POIError(`The new identity key '${key.id}' did not sign the change set: no proof of possession!`);
-  const signedValid = (key) => valid.has(key.id) && key.isValidAt(createdAt);
+  for (const key2 of newIdentityKeys)
+    if (!valid2.has(key2.id))
+      throw new POIError(`The new identity key '${key2.id}' did not sign the change set: no proof of possession!`);
+  const signedValid = (key2) => valid2.has(key2.id) && key2.isValidAt(createdAt);
   const rnoHolders = (keys, ...usages) => new Set([
-    ...keys !== "identity" ? rnoSigning.filter((key) => [KeyUsages.Party, ...usages].some((usage) => key.maySign(usage))) : [],
+    ...keys !== "identity" ? rnoSigning.filter((key2) => [KeyUsages.Party, ...usages].some((usage) => key2.maySign(usage))) : [],
     ...keys !== "signing" ? rnoIdentity : []
-  ].filter(signedValid).map((key) => key.holderOrUnnamed));
+  ].filter(signedValid).map((key2) => key2.holderOrUnnamed));
   changeSet.changes.forEach((change, index) => {
     checkPartyChange(change, index);
     const owner = ownerOf(before.content, change, index, addedEnergyMeterChildren);
@@ -6313,7 +6334,7 @@ function checkOwnership(before, changeSet) {
     const party = parties.get(`${owner.type}:${owner.id}`);
     if (party === void 0)
       throw new POIError(`${describeChange(change, index)}: the ${owner.type} '${owner.id}' does not exist!`);
-    const bySigningKey = owner.keys !== "identity" && party.signingKeys.some((key) => key.maySign(owner.usage) && signedValid(key));
+    const bySigningKey = owner.keys !== "identity" && party.signingKeys.some((key2) => key2.maySign(owner.usage) && signedValid(key2));
     const byIdentityKey = owner.keys !== "signing" && party.identityKeys.some(signedValid);
     const byRecovery = owner.keys !== "signing" && rnoHolders("identity").size >= minConsensus && rnoIdentity.some(signedValid);
     const byRNO = owner.keys === "signing" && party.signingKeys.length === 0 && rnoHolders("signing", owner.usage).size >= minConsensus;
@@ -6406,8 +6427,8 @@ function checkKeyHolders(before, after) {
   const keysOf2 = (network) => {
     const keys = /* @__PURE__ */ new Map();
     const add = (type, id, partyKeys) => {
-      for (const key of partyKeys)
-        keys.set(`${type}:${id}:${key.id}`, { party: `${type} '${id}'`, key });
+      for (const key2 of partyKeys)
+        keys.set(`${type}:${id}:${key2.id}`, { party: `${type} '${id}'`, key: key2 });
     };
     if (network.operator !== void 0)
       add("RoamingNetworkOperator", network.operator.id, [...network.operator.identityKeys, ...network.operator.signingKeyCertificates.map((certificate) => certificate.signingKey)]);
@@ -6416,10 +6437,10 @@ function checkKeyHolders(before, after) {
     return keys;
   };
   const holders = keysOf2(before);
-  for (const [where, { party, key }] of keysOf2(after)) {
+  for (const [where, { party, key: key2 }] of keysOf2(after)) {
     const previous = holders.get(where);
-    if (previous !== void 0 && previous.key.holder !== key.holder)
-      throw new POIError(`The key '${key.id}' of the ${party} keeps its holder ${previous.key.holder === void 0 ? "none" : `'${previous.key.holder}'`}, not ${key.holder === void 0 ? "none" : `'${key.holder}'`}!`);
+    if (previous !== void 0 && previous.key.holder !== key2.holder)
+      throw new POIError(`The key '${key2.id}' of the ${party} keeps its holder ${previous.key.holder === void 0 ? "none" : `'${previous.key.holder}'`}, not ${key2.holder === void 0 ? "none" : `'${key2.holder}'`}!`);
   }
 }
 
@@ -6555,10 +6576,10 @@ var Checkpoint = class _Checkpoint {
     return roleSignatureBytes(CHECKPOINT_SIGNATURE_CONTEXT, signature, "checkpoint", this.signedContent());
   }
   /** Verifies one signature with a trusted key, refusing one by another key. */
-  verifySignature(signature, key) {
-    if (signature.keyId !== key.id)
+  verifySignature(signature, key2) {
+    if (signature.keyId !== key2.id)
       throw new POIError("The signature key ID does not match the trusted key ID.");
-    verifySignature(signature.algorithm, key.key, this.signingBytes(signature), signature.value);
+    verifySignature(signature.algorithm, key2.key, this.signingBytes(signature), signature.value);
   }
   /** Whether the checkpoint names the given commit with its revision and ETags. */
   isOf(commit) {
@@ -7125,11 +7146,11 @@ var QIDigitalDocument = class {
     return canonicalJSONBytes(this.signatureInput());
   }
   /** Verifies its signature with the given public key: by that key, with a canonical algorithm and value (`VerifySignature`). */
-  verifySignature(key) {
+  verifySignature(key2) {
     const signature = this.signature;
     if (signature === void 0)
       throw new POIError(`${this.documentText} is not signed.`);
-    if (signature.keyId !== key.id)
+    if (signature.keyId !== key2.id)
       throw new POIError(`The key ID of ${this.documentText} does not match the expected key ID.`);
     try {
       signatureAlgorithm(signature.algorithm);
@@ -7144,7 +7165,7 @@ var QIDigitalDocument = class {
     }
     if (value.length === 0)
       throw new POIError("The value must contain nonempty canonical standard Base64.");
-    verifySignature(signature.algorithm, key.key, this.signingBytes(), signature.value);
+    verifySignature(signature.algorithm, key2.key, this.signingBytes(), signature.value);
   }
   /**
    * Verifies its signature with the one of the given signing keys of its issuer it names, valid when it was signed, and
@@ -7154,7 +7175,7 @@ var QIDigitalDocument = class {
     const signature = this.signature;
     if (signature === void 0)
       throw new POIError(`${capitalized(this.documentText)} is not signed!`);
-    const signingKey = signingKeys.find((key) => key.id === signature.keyId);
+    const signingKey = signingKeys.find((key2) => key2.id === signature.keyId);
     if (signingKey === void 0)
       throw new POIError(`The key '${signature.keyId}' of ${this.documentText} is no signing key of ${this.issuerText}!`);
     if (!signingKey.isValidAt(signature.signedAt))
@@ -8429,7 +8450,7 @@ var OperatorTrust = class _OperatorTrust {
     for (const [id, holder] of this.identityKeyHolders)
       known.set(holder, [...known.get(holder) ?? [], id]);
     const { signedBy, holderOf } = statement.verifyHolders([...known.values()], operator.identityKeys, { minConsensus: this.requiredConsensus, at: timeOf(at) });
-    const trusted = /* @__PURE__ */ new Set([...this.anchor.keys, ...statement.identityKeys.map((key) => key.id)]);
+    const trusted = /* @__PURE__ */ new Set([...this.anchor.keys, ...statement.identityKeys.map((key2) => key2.id)]);
     return new _OperatorTrust(
       this.anchor,
       operator,
@@ -8492,11 +8513,11 @@ var OperatorTrust = class _OperatorTrust {
   verifyOperatorSignatures(signatures, verify, what) {
     const signedBy = /* @__PURE__ */ new Set();
     for (const signature of signatures.filter((signature2) => signature2.role === SignatureRoles.RoamingNetworkOperator)) {
-      const key = this.signingKeyOf(signature);
+      const key2 = this.signingKeyOf(signature);
       const holder = this.holderOf(signature);
-      if (key === void 0 || holder === void 0)
+      if (key2 === void 0 || holder === void 0)
         throw new POIError(`the key '${signature.keyId}' is no signing key a trusted identity key of its holder certifies`);
-      verify(signature, key);
+      verify(signature, key2);
       signedBy.add(holder);
     }
     if (signedBy.size < this.requiredConsensus)
@@ -8531,8 +8552,8 @@ function verifyVersion(basis, networkJSON, commitJSON, at) {
   if (commit.roamingNetworkId !== network.id || !network.matchesCommitETags(commit.eTags))
     throw new POIError("the commit does not lead to the roaming network");
   const trust = OperatorTrust.of(basis, network, at);
-  const signedBy = trust.verifyOperatorSignatures(commit.signatures, (signature, key) => {
-    commit.verifySignature(signature, key);
+  const signedBy = trust.verifyOperatorSignatures(commit.signatures, (signature, key2) => {
+    commit.verifySignature(signature, key2);
   }, "the commit");
   return {
     network,
@@ -8691,6 +8712,10 @@ function verifyChargingStation(anchor, proof, options = {}) {
     revision: parsed.revision,
     eTag: verified.eTag,
     attestedBy: verified.attestedBy,
+    verification: {
+      at: anchor instanceof TrustContext ? anchor.evaluatedAt : timeOf(options.at),
+      validUntil: verified.validUntil
+    },
     warnings
   };
 }
@@ -8709,7 +8734,7 @@ function verifyPriceStatements(station, statements, options = {}) {
   const signedWith = /* @__PURE__ */ new Map();
   for (const item of list) {
     const statement = PriceStatement.parse(item);
-    const key = `${statement.entityType}:${statement.entityId}`;
+    const key2 = `${statement.entityType}:${statement.entityId}`;
     const entity = entities.get(statement.chain);
     if (entity === void 0)
       throw new POIError(`The price statement of the ${statement.entityType} '${statement.entityId}' is none of the station, its pool or its EVSEs!`);
@@ -8721,23 +8746,23 @@ function verifyPriceStatements(station, statements, options = {}) {
         if (!entity.tariffs.has(asText(price["chargingTariffId"])))
           throw new POIError(`The price statement of the EVSE '${statement.entityId}' names the charging tariff '${asText(price["chargingTariffId"])}', which is not one of its own!`);
     }
-    const known = byEntity.get(key) ?? [];
+    const known = byEntity.get(key2) ?? [];
     if (!known.some((other) => other.digestHex() === statement.digestHex()))
-      byEntity.set(key, [...known, statement]);
+      byEntity.set(key2, [...known, statement]);
   }
   const current = /* @__PURE__ */ new Map();
-  for (const [key, chain] of byEntity) {
+  for (const [key2, chain] of byEntity) {
     chain.sort((left, right) => left.sequence - right.sequence);
     if (new Set(chain.map((statement) => statement.sequence)).size !== chain.length)
-      throw new POIError(`Two price statements of one sequence of '${key}': a split view!`);
+      throw new POIError(`Two price statements of one sequence of '${key2}': a split view!`);
     chain.forEach((statement, index) => {
       const before = chain[index - 1];
       if (before !== void 0 && statement.sequence === before.sequence + 1)
         verifyPriceStatementChain([before, statement]);
     });
-    const valid = [...chain].reverse().find((statement) => statement.validFrom <= time);
-    if (valid?.isValidAt(time) === true && signedWith.get(valid.digestHex())?.isValidAt(time) === true)
-      current.set(key, { statement: valid, digest: valid.digestHex() });
+    const valid2 = [...chain].reverse().find((statement) => statement.validFrom <= time);
+    if (valid2?.isValidAt(time) === true && signedWith.get(valid2.digestHex())?.isValidAt(time) === true)
+      current.set(key2, { statement: valid2, digest: valid2.digestHex() });
   }
   return current;
 }
@@ -8780,14 +8805,14 @@ function verifyCheckpointSignatures(checkpoint, trust, options = {}) {
   const ignored = [];
   for (const signature of checkpoint.signatures) {
     if (signature.role === SignatureRoles.RoamingNetworkOperator) {
-      const key = trust.signingKeyOf(signature);
+      const key2 = trust.signingKeyOf(signature);
       const holder = trust.holderOf(signature);
-      if (key === void 0 || holder === void 0) {
+      if (key2 === void 0 || holder === void 0) {
         ignored.push(`the key '${signature.keyId}' is no signing key a trusted identity key of its holder certifies`);
         continue;
       }
       try {
-        checkpoint.verifySignature(signature, key);
+        checkpoint.verifySignature(signature, key2);
         signedBy.add(holder);
       } catch (e) {
         ignored.push(`the signature by '${signature.keyId}' is invalid: ${e instanceof Error ? e.message : String(e)}`);
@@ -9008,11 +9033,11 @@ var RuntimeStatus = class _RuntimeStatus {
   }
   /** Takes a status update: `Updated` unless the status it changes is a later one already, `Outdated` then. */
   apply(update) {
-    const key = _RuntimeStatus.key(update.entityType, update.entityId, update.kind);
-    const current = this.entries.get(key);
+    const key2 = _RuntimeStatus.key(update.entityType, update.entityId, update.kind);
+    const current = this.entries.get(key2);
     if (current !== void 0 && current.timestamp > update.timestamp)
       return "Outdated";
-    this.entries.set(key, { value: update.value, timestamp: update.timestamp });
+    this.entries.set(key2, { value: update.value, timestamp: update.timestamp });
     return "Updated";
   }
   get(entityType, entityId2, kind = "status") {
@@ -9022,7 +9047,1108 @@ var RuntimeStatus = class _RuntimeStatus {
     return this.entries.size;
   }
 };
+var MeasurementKeyError = class extends POIError {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+  code;
+};
+function parseMeasurementPublicKey(value, format) {
+  if (!["spki-der", "cose-key"].includes(format))
+    throw new MeasurementKeyError("unsupported-key", "Unknown measurement-key format");
+  const json = requireObject(value, "A measurement public key");
+  const id = requireString(json, "@id");
+  const bytes = fromBase64(requireString(json, "key"));
+  let cose;
+  let idScheme;
+  try {
+    if (format === "spki-der") {
+      const document = new DerReader(bytes, "Measurement SubjectPublicKeyInfo");
+      const sequence = contentsOf(document.read(Tag.sequence), "SubjectPublicKeyInfo");
+      document.expectEnd();
+      const algorithm = contentsOf(sequence.read(Tag.sequence), "AlgorithmIdentifier");
+      const oid = derObjectIdentifier(algorithm.read(Tag.objectIdentifier), "Public key algorithm");
+      const curve = derObjectIdentifier(algorithm.read(Tag.objectIdentifier), "Public key curve");
+      algorithm.expectEnd();
+      if (oid !== "1.2.840.10045.2.1" || curve !== "1.2.840.10045.3.1.7")
+        throw new MeasurementKeyError("unsupported-key", "The measurement-key pilot supports ECDSA P-256 only");
+      const point = derBitString(sequence.read(Tag.bitString), "Measurement public point");
+      sequence.expectEnd();
+      if (point.length !== 65 || point[0] !== 4 || !isOnCurve(CoseCurves.P256, point))
+        throw new MeasurementKeyError("invalid-key", "A measurement key needs a valid uncompressed P-256 point");
+      cose = CoseKey.fromCoordinates(CoseCurves.P256, point.slice(1, 33), point.slice(33));
+      idScheme = "sha256-spki";
+      if (id !== toHex(hash("sha256", bytes))) throw new MeasurementKeyError("invalid-key", "The measurement SPKI hash does not match its ID");
+    } else {
+      cose = CoseKey.parse(bytes);
+      if (cose.isPrivate || cose.curve?.id !== CoseCurves.P256.id || cose.x?.length !== 32 || cose.y?.length !== 32)
+        throw new MeasurementKeyError("unsupported-key", "A public P-256 COSE measurement key is required");
+      const point = Uint8Array.from([4, ...cose.x, ...cose.y]);
+      if (!isOnCurve(CoseCurves.P256, point)) throw new MeasurementKeyError("invalid-key", "The measurement point is not on P-256");
+      if (toBase64(cose.toBytes()) !== toBase64(bytes) || id !== toHex(cose.thumbprint()))
+        throw new MeasurementKeyError("invalid-key", "The COSE key must be deterministic and match its thumbprint");
+      idScheme = "sha256-cose-key-thumbprint";
+      cose = CoseKey.fromCoordinates(CoseCurves.P256, cose.x, cose.y);
+    }
+  } catch (error) {
+    if (error instanceof MeasurementKeyError) throw error;
+    throw new MeasurementKeyError("invalid-key", error instanceof Error ? error.message : "Invalid measurement key");
+  }
+  return Object.freeze({
+    id,
+    idScheme,
+    canonicalId: toHex(cose.thumbprint()),
+    sourceFormat: format,
+    value: toBase64(cose.toBytes()),
+    encodings: Object.freeze(["COSE_Key", "CBOR", "base64"]),
+    algorithm: "ECDSA-secp256r1"
+  });
+}
+function verifyMeterKey(context, proof, request) {
+  if (!(context instanceof TrustContext)) throw new POIError("Meter-key authorization requires a TrustContext");
+  const station = verifyChargingStation(context, proof, { evseId: request.evseId });
+  if (station.verification.validUntil < context.evaluatedAt)
+    throw new POIError("The certified-key observation is no longer current");
+  const evse = station.evses.find((item) => item["@id"] === request.evseId);
+  const meter = evse?.["energyMeter"];
+  if (!isObject(meter)) throw new MeasurementKeyError("missing-meter", "The selected EVSE supplies no directly associated energy meter");
+  const meterId = requireString(meter, "@id");
+  const serial = requireString(meter, "serialNumber");
+  if (request.meterSerialNumber.trim() === "" || serial !== request.meterSerialNumber || request.meterId !== void 0 && meterId !== request.meterId)
+    throw new MeasurementKeyError("identity-mismatch", "The signed meter identity does not match the selected EVSE meter");
+  const all = meter["publicKeys"];
+  const keys = Array.isArray(all) ? all.filter((item) => request.keyId === void 0 || isObject(item) && item["@id"] === request.keyId) : [];
+  if (keys.length !== 1) throw new MeasurementKeyError("ambiguous-key", "Select exactly one explicitly identified meter key; no trial verification across keys");
+  const key2 = parseMeasurementPublicKey(keys[0] ?? null, request.keyFormat);
+  return Object.freeze({
+    evseId: request.evseId,
+    chargingStationId: requireString(station.chargingStation, "@id"),
+    meterId,
+    meterSerialNumber: serial,
+    key: key2,
+    evidence: Object.freeze({
+      roamingNetworkId: context.roamingNetworkId,
+      roamingNetworkOperatorId: context.roamingNetworkOperatorId,
+      commitId: station.commitId,
+      revision: station.revision,
+      treeRoot: etagToText(station.eTag),
+      keyStatementDigest: context.keyStatementDigest,
+      verifiedAt: station.verification.at,
+      validUntil: station.verification.validUntil,
+      association: "current-snapshot"
+    })
+  });
+}
+
+// src/verifier/historicalMeasurements.ts
+var HISTORICAL_METER_EVIDENCE_CONTEXT = "https://open.charging.cloud/contexts/wwcp/historicalMeterEvidence/v1";
+function parseHistoricalMeterEvidence(value) {
+  const json = requireObject(value, "Historical meter evidence");
+  onlyProperties(json, ["@context", "EVSEId", "versions"], "Historical meter evidence");
+  if (json["@context"] !== HISTORICAL_METER_EVIDENCE_CONTEXT) throw new POIError("Unsupported historical meter evidence");
+  const versions = requireArray(json["versions"], "Historical station versions").map((item) => {
+    const version = requireObject(item, "A historical station version");
+    onlyProperties(version, ["chargingStationProof", "commitProof", "checkpoints"], "A historical station version");
+    return {
+      proof: requireObject(version["chargingStationProof"], "A historical station proof"),
+      ...version["commitProof"] === void 0 ? {} : { commitProof: version["commitProof"] },
+      checkpoints: (version["checkpoints"] === void 0 ? [] : requireArray(version["checkpoints"], "Historical checkpoints")).map((item2) => {
+        const entry = requireObject(item2, "A checkpoint with its signing authority");
+        onlyProperties(entry, ["checkpoint", "operator"], "A historical checkpoint entry");
+        return { checkpoint: requireObject(entry["checkpoint"], "A checkpoint"), operator: requireObject(entry["operator"], "Its operator") };
+      })
+    };
+  });
+  if (versions.length === 0) throw new POIError("Historical station evidence is empty");
+  return { evseId: requireString(json, "EVSEId"), versions };
+}
+function historicalOperatorContext(current, operator, at) {
+  const json = requireObject(operator, "A historical roaming network operator");
+  const statement = KeyStatement.parse(json["keyStatement"]);
+  if (statement.roamingNetworkId !== current.roamingNetworkId || statement.roamingNetworkOperatorId !== current.roamingNetworkOperatorId || json["@id"] !== current.roamingNetworkOperatorId)
+    throw new POIError("The historical statement belongs to another authorized network/operator");
+  const authority = current instanceof HistoricalTrustContext ? current.authorityAt(at) : void 0;
+  const anchor = authority?.authorizedAnchor ?? current.authorizedAnchor;
+  const created = TrustContext.create(anchor, statement, {
+    trustedIdentityKeyIds: anchor.keys,
+    otherIdentityKeys: POIPublicKey.parseAll(json["identityKeys"], "Historical operator identities"),
+    at
+  });
+  const context = TrustContext.withEpoch(created, authority?.epoch ?? current.epoch, current.epochs);
+  if (authority === void 0 && context.requiredConsensus < current.requiredConsensus) throw new POIError("Historical verification must not weaken the current local quorum");
+  return context;
+}
+var HistoricalTrustContext = class _HistoricalTrustContext {
+  constructor(reference, evaluatedAt, authorities = []) {
+    this.evaluatedAt = evaluatedAt;
+    this.authorities = authorities;
+    this.epoch = reference.epoch;
+    this.epochs = reference.epochs;
+    this.authorizedAnchor = reference.authorizedAnchor;
+    this.roamingNetworkId = reference.roamingNetworkId;
+    this.roamingNetworkOperatorId = reference.roamingNetworkOperatorId;
+    this.requiredConsensus = reference.requiredConsensus;
+    this.keyStatementDigest = reference.keyStatementDigest;
+    this.trustedHolders = reference.trustedHolders;
+    this.validUntil = evaluatedAt + 6e4;
+    Object.freeze(this);
+  }
+  evaluatedAt;
+  authorities;
+  authorizedAnchor;
+  roamingNetworkId;
+  roamingNetworkOperatorId;
+  requiredConsensus;
+  keyStatementDigest;
+  /** An operation deadline, not historical document validity or a lease on local trust. */
+  validUntil;
+  trustedHolders;
+  epoch;
+  epochs;
+  /** Contexts must be reconstructed from current local roots and verified transition certificates, never serialized success flags. */
+  static fromVerifiedAuthorities(reference, authorities, now) {
+    if (!Number.isFinite(now) || authorities.length === 0 || authorities.some((item) => item.context.roamingNetworkId !== reference.roamingNetworkId || item.context.roamingNetworkOperatorId !== reference.roamingNetworkOperatorId || !Number.isFinite(item.from) || item.until <= item.from)) throw new POIError("Invalid historical authority lineage");
+    return new _HistoricalTrustContext(reference, now, authorities);
+  }
+  authorityAt(at) {
+    if (this.authorities.length === 0) return void 0;
+    const matches = this.authorities.filter((item) => at >= item.from && at < item.until);
+    if (matches.length !== 1) throw new POIError("No unambiguous authorized policy covers this historical time");
+    return matches[0]?.context;
+  }
+  static create(anchor, reference, options) {
+    const now = options.now ?? Date.now();
+    if (!Number.isFinite(now) || reference.signedAt > now) throw new POIError("Invalid historical authorization/reference time");
+    const verified = TrustContext.create(anchor, reference, {
+      trustedIdentityKeyIds: options.trustedIdentityKeyIds,
+      ...options.otherIdentityKeys === void 0 ? {} : { otherIdentityKeys: options.otherIdentityKeys },
+      at: reference.signedAt
+    });
+    return new _HistoricalTrustContext(verified, now);
+  }
+};
+function verifyHistoricalMeterEvidence(current, value, request, policy = {}) {
+  if (!(current instanceof TrustContext) && !(current instanceof HistoricalTrustContext)) throw new POIError("Historical verification requires current local authorization");
+  const requiredWitnesses = policy.requiredWitnesses ?? 0;
+  if (!Number.isSafeInteger(requiredWitnesses) || requiredWitnesses < 0) throw new POIError("Invalid historical witness policy");
+  for (const revocation of policy.revocations ?? []) if (!Number.isFinite(revocation.invalidFrom)) throw new POIError("Invalid compromise time");
+  const revoked = (id, at) => (policy.revocations ?? []).some((item) => item.keyId === id && at >= item.invalidFrom);
+  const evidence = parseHistoricalMeterEvidence(value);
+  if (evidence.evseId !== request.evseId) throw new POIError("Historical evidence belongs to another EVSE");
+  const times = [...new Set(request.measurementTimes)];
+  if (times.length === 0 || times.some((time) => !Number.isFinite(time) || time > current.evaluatedAt))
+    throw new POIError("Historical verification needs finite, non-future original measurement times");
+  const versions = evidence.versions.map((version) => ({ ...version, parsed: ChargingStationProof.parse(version.proof) }));
+  const used = /* @__PURE__ */ new Map();
+  const bindings = [];
+  for (const time of times) {
+    const matches = [];
+    const errors = [];
+    for (const version2 of versions) {
+      try {
+        const operator = version2.parsed.roamingNetwork["operator"];
+        const context = historicalOperatorContext(current, operator ?? null, time);
+        const binding2 = verifyMeterKey(context, version2.proof, request);
+        const verified = version2.parsed.verify(context);
+        const operatorJSON = requireObject(operator, "The historical operator");
+        const trust = OperatorTrust.fromOperatorJSON(context, operatorJSON);
+        const holders = /* @__PURE__ */ new Set();
+        for (const attestation of verified.attestations) {
+          const certificate = trust.operator.signingKeyCertificates.find((item) => item.signingKey.id === attestation.keyId);
+          if (certificate !== void 0 && !revoked(attestation.keyId, attestation.signedAt) && !revoked(certificate.keyId, attestation.signedAt)) {
+            const holder = trust.holderOf(attestation);
+            if (holder !== void 0) holders.add(holder);
+          }
+        }
+        if (holders.size < context.requiredConsensus || revoked(binding2.key.id, time) || revoked(binding2.key.canonicalId, time))
+          throw new POIError("Historical keys are affected by a caller-authorized compromise");
+        matches.push({ binding: binding2, version: version2 });
+      } catch (error) {
+        errors.push(error instanceof Error ? error.message : String(error));
+      }
+    }
+    if (matches.length === 0) throw new POIError(`No historical EVSE/meter/key coverage at ${new Date(time).toISOString()}: ${errors.join("; ")}`);
+    const identities = new Set(matches.map(({ binding: binding2 }) => `${binding2.meterId}:${binding2.key.canonicalId}`));
+    if (identities.size !== 1) throw new POIError("Conflicting historical key assignments cover the same measurement time");
+    const selected = matches.sort((a, b) => a.binding.evidence.commitId.localeCompare(b.binding.evidence.commitId))[0];
+    if (selected === void 0) throw new POIError("Missing historical selection");
+    const { binding, version } = selected;
+    used.set(binding.evidence.commitId, version);
+    bindings.push(Object.freeze({ ...binding, evidence: Object.freeze({
+      ...binding.evidence,
+      verifiedAt: current.evaluatedAt,
+      validUntil: current.validUntil,
+      keyStatementDigest: current.keyStatementDigest,
+      historicalStatementDigest: binding.evidence.keyStatementDigest,
+      attestationValidUntil: binding.evidence.validUntil,
+      measurementTimes: Object.freeze([time]),
+      association: "historical-attestation"
+    }) }));
+  }
+  const heads = /* @__PURE__ */ new Map();
+  const publication = [];
+  for (const [commitId, version] of used) {
+    if (version.commitProof === void 0) {
+      if (version.checkpoints.length > 0 || policy.requirePublication === true || requiredWitnesses > 0)
+        throw new POIError("Required historical commit inclusion evidence is missing");
+      publication.push({ commitId, publication: "missing", witnessedBy: [] });
+      continue;
+    }
+    const proof = CheckpointProof.parse(version.commitProof);
+    const entries = version.checkpoints.map((entry2) => ({ ...entry2, parsed: Checkpoint.parse(entry2.checkpoint) }));
+    const entry = entries.find((item) => item.parsed.id === proof.checkpointId);
+    if (entry === void 0) throw new POIError("The checkpoint of the historical commit proof is missing");
+    const checkpoint = entry.parsed;
+    if (checkpoint.roamingNetworkId !== current.roamingNetworkId || checkpoint.createdAt > current.evaluatedAt)
+      throw new POIError("Foreign or future historical checkpoint");
+    const coordinate2 = `${checkpoint.epoch}:${checkpoint.sequence}`;
+    if (heads.has(coordinate2) && heads.get(coordinate2) !== checkpoint.id) throw new POIError("Conflicting historical checkpoint heads");
+    heads.set(coordinate2, checkpoint.id);
+    const checked = verifyAuthorizedCheckpoint(current, checkpoint, entry.operator, policy);
+    const witnesses = checked.witnessedBy;
+    proof.verify(checkpoint);
+    version.parsed.verifyAgainstCommitProof(proof);
+    publication.push({
+      commitId,
+      publication: witnesses.length > 0 ? "witnessed-checkpoint" : "rno-checkpoint",
+      checkpointId: checkpoint.id,
+      witnessedBy: [...witnesses]
+    });
+  }
+  return Object.freeze({
+    bindings: Object.freeze(bindings),
+    versions: Object.freeze(publication.map((item) => Object.freeze(item))),
+    checkedAt: current.evaluatedAt,
+    timeBasis: "signed-measurement-timestamps",
+    independentTime: "not-proven",
+    latestVersion: "not-proven"
+  });
+}
+function verifyAuthorizedCheckpoint(current, checkpoint, operator, policy = {}) {
+  if (!(current instanceof TrustContext) && !(current instanceof HistoricalTrustContext)) throw new POIError("Checkpoint verification requires current local authority");
+  for (const item of policy.revocations ?? []) if (!Number.isFinite(item.invalidFrom)) throw new POIError("Invalid checkpoint compromise time");
+  const requiredWitnesses = policy.requiredWitnesses ?? 0;
+  if (!Number.isSafeInteger(requiredWitnesses) || requiredWitnesses < 0) throw new POIError("Invalid checkpoint witness policy");
+  if (checkpoint.roamingNetworkId !== current.roamingNetworkId || checkpoint.createdAt > current.evaluatedAt) throw new POIError("Foreign or future checkpoint");
+  const revoked = (id, at) => (policy.revocations ?? []).some((item) => item.keyId === id && at >= item.invalidFrom);
+  const profile = current.epochs.find((epoch) => epoch.number === checkpoint.epoch)?.profiles;
+  if (profile === void 0) throw new POIError("The checkpoint epoch has no verified transition from the local policy");
+  const holders = /* @__PURE__ */ new Set();
+  const witnesses = /* @__PURE__ */ new Set();
+  const witnessKeys = /* @__PURE__ */ new Set();
+  let required2 = current instanceof HistoricalTrustContext ? current.authorityAt(checkpoint.createdAt)?.requiredConsensus ?? current.requiredConsensus : current.requiredConsensus;
+  for (const signature of checkpoint.signatures) {
+    if (!profile.allowsSignatureAlgorithm(signature.algorithm)) continue;
+    if (signature.signedAt < checkpoint.createdAt || signature.signedAt > current.evaluatedAt || revoked(signature.keyId, signature.signedAt)) continue;
+    try {
+      if (signature.role === "roamingNetworkOperator") {
+        const context = historicalOperatorContext(current, operator, signature.signedAt);
+        required2 = Math.max(required2, context.requiredConsensus);
+        const trust = OperatorTrust.fromOperatorJSON(context, operator);
+        const certificate = trust.operator.signingKeyCertificates.find((item) => item.signingKey.id === signature.keyId);
+        const key2 = trust.signingKeyOf(signature);
+        const holder = trust.holderOf(signature);
+        if (certificate === void 0 || revoked(certificate.keyId, signature.signedAt) || key2 === void 0 || holder === void 0) continue;
+        checkpoint.verifySignature(signature, key2);
+        holders.add(holder);
+      } else if (signature.role === "witness") {
+        const witness = policy.witnesses?.find((item) => item.witness === signature.signer && item.key.id === signature.keyId);
+        if (witness === void 0 || !witness.key.isValidAt(signature.signedAt) || !witness.key.maySign("party") || witnessKeys.has(witness.key.id)) continue;
+        checkpoint.verifySignature(signature, witness.key);
+        witnesses.add(witness.witness);
+        witnessKeys.add(witness.key.id);
+      }
+    } catch {
+    }
+  }
+  if (holders.size < required2 || witnesses.size < requiredWitnesses) throw new POIError("Historical checkpoint lacks the locally required RNO/witness quorum");
+  return { checkpoint, signedBy: [...holders], witnessedBy: [...witnesses] };
+}
+
+// src/verifier/pricePublication.ts
+var PRICE_PUBLICATION_RECEIPT_CONTEXT = "https://open.charging.cloud/contexts/wwcp/pricePublicationReceipt/v1";
+var WITNESS_PUBLICATION_POLICY_CONTEXT = "https://open.charging.cloud/contexts/wwcp/witnessPublicationPolicy/v1";
+function pricePublicationOfferHashes(statement, tariff) {
+  return { priceStatementSHA256: toHex(hash("sha256", canonicalJSONBytes(statement.json))), tariffSHA256: toHex(hash("sha256", canonicalJSONBytes(tariff))) };
+}
+function identifier(json, property) {
+  const text = requireString(json, property);
+  if (text.trim() !== text || text.length === 0 || text.length > 512) throw new POIError("Invalid publication identity");
+  for (let index = 0; index < text.length; index++) if (text.charCodeAt(index) < 32) throw new POIError("Invalid publication identity");
+  return text;
+}
+function publicPublicationURL(text) {
+  const url = new URL(text);
+  if (url.protocol !== "https:" || url.username !== "" || url.password !== "" || url.hash !== "" || text.length > 2048) throw new POIError("Publication sources require public HTTPS without credentials or fragments");
+  const host = url.hostname.toLowerCase().replace(/^\[|\]$/gu, "");
+  if (host === "localhost" || host.endsWith(".localhost") || host.endsWith(".local") || host === "::1" || host.includes(":") || /^\d+(\.\d+){3}$/u.test(host) || !host.includes(".")) throw new POIError("Publication sources require a public DNS hostname");
+  return url.href;
+}
+function parseWitnessPublicationPolicy(value) {
+  const json = requireObject(value, "Witness publication policy");
+  onlyProperties(json, ["@context", "requiredOrganizations", "witnesses"], "Witness publication policy");
+  if (json["@context"] !== WITNESS_PUBLICATION_POLICY_CONTEXT) throw new POIError("Unsupported witness publication policy");
+  const requiredOrganizations = requireInteger(json, "requiredOrganizations", 1, 16);
+  const entries = requireArray(json["witnesses"], "Publication witnesses");
+  if (entries.length > 32 || canonicalJSONBytes(json).length > 1024 * 1024) throw new POIError("Witness policy exceeds its capacity");
+  const witnesses = [], ids = /* @__PURE__ */ new Set(), material = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const item = requireObject(entry, "A publication witness");
+    onlyProperties(item, ["id", "organization", "role", "networks", "keys", "notBefore", "notAfter", "clockErrorMs", "endpoints"], "A publication witness");
+    if (item["role"] !== "price-publication-and-time") throw new POIError("A witness needs the explicit publication and time role");
+    const id = identifier(item, "id"), organization = identifier(item, "organization");
+    if (ids.has(id)) throw new POIError("Duplicate witness identity");
+    ids.add(id);
+    const networks = requireArray(item["networks"], "Witness network scopes");
+    if (networks.length === 0 || networks.length > 32 || networks.some((value2) => typeof value2 !== "string" || value2.length === 0 || value2 === "*") || new Set(networks).size !== networks.length) throw new POIError("Explicit witness network scopes required");
+    const keys = POIPublicKey.parseAll(item["keys"], "Witness publication keys");
+    if (keys.length === 0 || keys.length > 8 || new Set(keys.map((key2) => key2.id)).size !== keys.length) throw new POIError("Invalid witness key list");
+    for (const key2 of keys) {
+      if (!key2.maySign("witnessPublications")) throw new POIError("Witness key usage does not permit publication receipts");
+      const fingerprint = toHex(key2.key.thumbprint()), before = material.get(fingerprint);
+      if (before !== void 0 && before !== organization) throw new POIError("The same witness key cannot represent different organizations");
+      material.set(fingerprint, organization);
+    }
+    const notBefore = requireTimestamp(item, "notBefore"), notAfter = requireTimestamp(item, "notAfter");
+    if (notAfter <= notBefore) throw new POIError("Invalid witness validity interval");
+    const clockErrorMs = requireInteger(item, "clockErrorMs", 0, 3e5);
+    const endpoints = requireArray(item["endpoints"], "Witness receipt endpoints");
+    if (endpoints.length > 4 || endpoints.some((url) => typeof url !== "string")) throw new POIError("Invalid witness receipt endpoints");
+    witnesses.push(Object.freeze({
+      id,
+      organization,
+      networks: Object.freeze(networks),
+      keys: Object.freeze(keys),
+      notBefore,
+      notAfter,
+      clockErrorMs,
+      endpoints: Object.freeze(endpoints.map(publicPublicationURL)),
+      json: item
+    }));
+  }
+  return Object.freeze({ requiredOrganizations, witnesses: Object.freeze(witnesses), json });
+}
+var PricePublicationReceipt = class _PricePublicationReceipt {
+  constructor(json, observedAt, signedAt) {
+    this.json = json;
+    this.observedAt = observedAt;
+    this.signedAt = signedAt;
+  }
+  json;
+  observedAt;
+  signedAt;
+  static parse(value) {
+    const json = requireObject(value, "Price publication receipt");
+    onlyProperties(json, ["@context", "assertion", "roamingNetworkId", "EVSEId", "priceStatementDigest", "priceStatementSHA256", "tariffSHA256", "checkpointId", "witnessId", "publicSourceURL", "observedAt", "signedAt", "algorithm", "keyId", "value"], "Price publication receipt");
+    if (json["@context"] !== PRICE_PUBLICATION_RECEIPT_CONTEXT || json["assertion"] !== "public-price-retrieval") throw new POIError("Unsupported publication receipt assertion");
+    for (const field of ["roamingNetworkId", "EVSEId", "witnessId", "algorithm", "keyId"]) identifier(json, field);
+    const signature = requireString(json, "value");
+    if (signature.length === 0 || signature.length > 131072) throw new POIError("Invalid publication signature size");
+    if (!isLowerHex(requireString(json, "priceStatementDigest"), 32) || !/^(?:[0-9a-f]{64}|[0-9a-f]{96}|[0-9a-f]{128})$/u.test(requireString(json, "checkpointId"))) throw new POIError("Invalid publication receipt digest");
+    for (const field of ["priceStatementSHA256", "tariffSHA256"]) if (!isLowerHex(requireString(json, field), 32)) throw new POIError("Invalid signed-price or tariff digest");
+    publicPublicationURL(requireString(json, "publicSourceURL"));
+    const observedAt = requireTimestamp(json, "observedAt"), signedAt = requireTimestamp(json, "signedAt");
+    if (signedAt < observedAt || signedAt - observedAt > 6e4) throw new POIError("A publication receipt must be signed within one minute after observation");
+    return new _PricePublicationReceipt(json, observedAt, signedAt);
+  }
+  signingBytes() {
+    const { value: _, ...signed } = this.json;
+    return canonicalJSONBytes(signed);
+  }
+  digest() {
+    return toHex(hash("sha256", canonicalJSONBytes(this.json)));
+  }
+};
+function verifyPricePublication(receipts, policy, subject) {
+  if (!Number.isFinite(subject.chargingStarted) || !Number.isFinite(subject.now) || subject.chargingStarted > subject.now || receipts.length > 64) throw new POIError("Invalid publication evaluation context");
+  const accepted = policy === void 0 ? void 0 : parseWitnessPublicationPolicy(policy.json);
+  const organizations = /* @__PURE__ */ new Set(), rows = [];
+  for (const raw of receipts) {
+    let receipt;
+    try {
+      receipt = PricePublicationReceipt.parse(raw);
+      const json = receipt.json, witness = accepted?.witnesses.find((item) => item.id === json["witnessId"]);
+      if (witness?.networks.includes(subject.roamingNetworkId) !== true) {
+        rows.push({ witnessId: requireString(json, "witnessId"), status: "untrusted", detail: "No locally authorized witness for this network" });
+        continue;
+      }
+      const key2 = witness.keys.find((item) => item.id === json["keyId"]);
+      if (key2 === void 0) throw new POIError("The receipt key is not authorized for this witness");
+      if ((subject.excludedIdentities ?? []).includes(witness.id) || (subject.excludedIdentities ?? []).includes(witness.organization) || (subject.excludedKeyMaterial ?? []).includes(toHex(key2.key.thumbprint()))) throw new POIError("An RNO/CPO authority cannot count as an independent publication witness");
+      const lower = receipt.observedAt - witness.clockErrorMs, upper = receipt.signedAt + witness.clockErrorMs;
+      if (lower < witness.notBefore || upper >= witness.notAfter || !key2.isValidAt(lower) || !key2.isValidAt(upper)) throw new POIError("Witness/key does not cover the observation and signing interval");
+      if (receipt.signedAt > subject.now || json["roamingNetworkId"] !== subject.roamingNetworkId || json["EVSEId"] !== subject.evseId || json["priceStatementDigest"] !== subject.statement.digestHex()) throw new POIError("Foreign, substituted or future publication receipt");
+      const hashes = pricePublicationOfferHashes(subject.statement, subject.tariff);
+      if (json["priceStatementSHA256"] !== hashes.priceStatementSHA256 || json["tariffSHA256"] !== hashes.tariffSHA256) throw new POIError("Receipt does not bind the exact original CPO signature and selected tariff definition/currency");
+      const checkpoint = subject.checkpoints.find((item) => item.id === json["checkpointId"]);
+      if (checkpoint === void 0 || checkpoint.createdAt > receipt.observedAt + witness.clockErrorMs || subject.statement.signedAt > receipt.observedAt + witness.clockErrorMs) throw new POIError("Receipt needs the exact authorized price checkpoint and a consistent observation time");
+      verifySignature(requireString(json, "algorithm"), key2.key, receipt.signingBytes(), requireString(json, "value"));
+      const common = { witnessId: witness.id, organization: witness.organization, keyId: key2.id, receiptDigest: receipt.digest(), latestPublicationAt: upper, sourceURL: requireString(json, "publicSourceURL") };
+      if (upper >= subject.chargingStarted) rows.push({ ...common, status: "after-start", detail: "The latest observation/signing time including the accepted clock error is not before the signed start" });
+      else if (organizations.has(witness.organization)) rows.push({ ...common, status: "duplicate-organization", detail: "Only one vote per independently approved organization" });
+      else {
+        organizations.add(witness.organization);
+        rows.push({ ...common, status: "counted", detail: "Public retrieval of this exact included offer witnessed before its signed charging start" });
+      }
+    } catch (error) {
+      rows.push({ witnessId: typeof receipt?.json["witnessId"] === "string" ? receipt.json["witnessId"] : "", status: "invalid", detail: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  const requiredOrganizations = accepted?.requiredOrganizations ?? 2;
+  return Object.freeze({
+    status: organizations.size >= requiredOrganizations ? "witnessed-before-signed-start" : rows.some((row) => row.status === "invalid") ? "invalid" : "not-proven",
+    requiredOrganizations,
+    organizations: Object.freeze([...organizations].sort()),
+    timeBasis: "trusted-witness-clocks-versus-signed-start",
+    actualStartTime: "not-independently-proven",
+    receipts: Object.freeze(rows)
+  });
+}
+
+// src/verifier/sessionPrices.ts
+var SESSION_PRICE_EVIDENCE_CONTEXT = "https://open.charging.cloud/contexts/wwcp/sessionPriceEvidence/v1";
+var SESSION_PRICE_AGREEMENT_CONTEXT = "https://open.charging.cloud/contexts/wwcp/sessionPriceAgreement/v1";
+var SIMPLE_GROSS_PRICE_PROFILE = "chargy-gross-rates/v1";
+var SessionPriceAgreement = class _SessionPriceAgreement {
+  constructor(json, chargingStarted, signedAt) {
+    this.json = json;
+    this.chargingStarted = chargingStarted;
+    this.signedAt = signedAt;
+  }
+  json;
+  chargingStarted;
+  signedAt;
+  static parse(value) {
+    const json = requireObject(value, "A session price assignment");
+    onlyProperties(json, ["@context", "roamingNetworkId", "EVSEId", "meterSerialNumber", "chargingStarted", "startDocumentSHA256", "chargingMode", "chargingTariffId", "priceStatementDigest", "priceBinding", "pricingProfile", "role", "signer", "signedAt", "algorithm", "keyId", "value"], "A session price assignment");
+    if (json["@context"] !== SESSION_PRICE_AGREEMENT_CONTEXT || json["role"] !== "chargingStationOperator") throw new POIError("Unsupported price assignment context/role");
+    for (const field of ["roamingNetworkId", "EVSEId", "meterSerialNumber", "chargingMode", "chargingTariffId", "priceBinding", "pricingProfile", "signer", "algorithm", "keyId", "value"]) requireString(json, field);
+    for (const field of ["startDocumentSHA256", "priceStatementDigest"]) if (!isLowerHex(requireString(json, field), 32)) throw new POIError("Invalid price assignment digest");
+    return new _SessionPriceAgreement(json, requireTimestamp(json, "chargingStarted"), requireTimestamp(json, "signedAt"));
+  }
+  signingBytes() {
+    const { value: _, ...signed } = this.json;
+    return canonicalJSONBytes(signed);
+  }
+  verify(station) {
+    if (this.json["roamingNetworkId"] !== station.roamingNetwork.id || this.json["signer"] !== station.operator["@id"]) throw new POIError("Foreign price assignment authority");
+    const key2 = station.operatorSigningKeys.find((item) => item.id === this.json["keyId"]);
+    if (key2 === void 0 || !key2.isValidAt(this.signedAt) || !key2.isValidAt(this.chargingStarted) || !key2.maySign("priceStatements")) throw new POIError("Unauthorized/expired price assignment key");
+    verifySignature(requireString(this.json, "algorithm"), key2.key, this.signingBytes(), requireString(this.json, "value"));
+  }
+};
+function parseSessionPriceEvidence(value) {
+  const json = requireObject(value, "Session price evidence");
+  onlyProperties(json, ["@context", "EVSEId", "chargingStationProof", "priceStatements", "agreement", "priceStatementProofs", "checkpoints", "publicationReceipts", "witnessCandidates"], "Session price evidence");
+  if (json["@context"] !== SESSION_PRICE_EVIDENCE_CONTEXT) throw new POIError("Unsupported session price evidence");
+  const publicationReceipts = json["publicationReceipts"] === void 0 ? [] : requireArray(json["publicationReceipts"], "Publication receipts");
+  const witnessCandidates = json["witnessCandidates"] === void 0 ? [] : requireArray(json["witnessCandidates"], "Untrusted witness recommendations");
+  if (publicationReceipts.length > 64 || witnessCandidates.length > 32) throw new POIError("Too many publication receipts or recommendations");
+  return {
+    publicationReceipts,
+    witnessCandidates,
+    evseId: requireString(json, "EVSEId"),
+    proof: requireObject(json["chargingStationProof"], "The priced station proof"),
+    priceStatements: requireArray(json["priceStatements"], "Price statements"),
+    ...json["agreement"] === void 0 ? {} : { agreement: json["agreement"] },
+    priceProofs: json["priceStatementProofs"] === void 0 ? [] : requireArray(json["priceStatementProofs"], "Price inclusion proofs"),
+    checkpoints: (json["checkpoints"] === void 0 ? [] : requireArray(json["checkpoints"], "Price checkpoints")).map((item) => {
+      const entry = requireObject(item, "A price checkpoint entry");
+      onlyProperties(entry, ["checkpoint", "operator"], "A price checkpoint entry");
+      return { checkpoint: requireObject(entry["checkpoint"], "A price checkpoint"), operator: requireObject(entry["operator"], "The checkpoint authority") };
+    })
+  };
+}
+function grossRates(currency, elements) {
+  if (elements.length !== 1) return void 0;
+  const element = elements[0];
+  if (element === void 0 || Object.keys(element).some((key2) => key2 !== "priceComponents" && key2 !== "restrictions")) return void 0;
+  if (element["restrictions"] !== void 0 && (!isObject(element["restrictions"]) || Object.keys(element["restrictions"]).length > 0)) return void 0;
+  const components = element["priceComponents"];
+  if (!Array.isArray(components) || components.length === 0) return void 0;
+  const rates = { currency };
+  for (const raw of components) {
+    if (!isObject(raw) || Object.keys(raw).some((key2) => !["type", "price", "stepSize"].includes(key2))) return void 0;
+    const type = raw["type"], value = raw["price"], step = raw["stepSize"];
+    if (!isNumber(value) || Decimal.parse(asText(value)).mantissa < 0n || typeof step !== "number" || !Number.isSafeInteger(step) || step < 1) return void 0;
+    const field = type === "ENERGY" ? "energyPerKWh" : type === "FLAT" ? "flatFee" : type === "TIME" ? "timePerHour" : void 0;
+    if (field === void 0 || rates[field] !== void 0) return void 0;
+    rates[field] = asText(value);
+  }
+  return rates;
+}
+function verifySessionPriceEvidence(current, value, request, policy = {}) {
+  if (!(current instanceof TrustContext) && !(current instanceof HistoricalTrustContext)) throw new POIError("Session prices require current local authorization");
+  if (!Number.isFinite(request.chargingStarted) || request.chargingStarted > current.evaluatedAt || !isLowerHex(request.startDocumentSHA256, 32)) throw new POIError("Invalid original price context");
+  for (const item of policy.revocations ?? []) if (!Number.isFinite(item.invalidFrom)) throw new POIError("Invalid compromise time");
+  const evidence = parseSessionPriceEvidence(value);
+  if (evidence.evseId !== request.evseId) throw new POIError("Price evidence belongs to another EVSE");
+  const proof = ChargingStationProof.parse(evidence.proof), context = historicalOperatorContext(current, proof.roamingNetwork["operator"] ?? null, request.chargingStarted);
+  const station = verifyChargingStation(context, evidence.proof, { evseId: request.evseId }), diagnostics = [];
+  const base = { station, publicationBeforeStart: "not-proven", customerConsent: "not-proven", latestOrSoleOffer: "not-proven", checkedAt: current.evaluatedAt, checkpointIds: [], witnessedBy: [] };
+  const fail = (signatures, applicability2, message) => ({ ...base, signatures, applicability: applicability2, agreement: "missing", publication: "missing", chainGaps: false, diagnostics: [message] });
+  if (evidence.priceStatements.length === 0) return fail("missing", "missing", "No signed price statement supplied");
+  let statements;
+  try {
+    statements = evidence.priceStatements.map((item) => PriceStatement.parse(item));
+    for (const statement of statements) {
+      statement.verify(station.roamingNetwork.id, asText(station.operator["@id"]), station.operatorSigningKeys);
+      if (statement.signedAt > current.evaluatedAt || (policy.revocations ?? []).some((item) => item.keyId === statement.keyId && statement.signedAt >= item.invalidFrom)) throw new POIError("Future/revoked CPO price signature");
+    }
+  } catch (error) {
+    return fail("invalid", "invalid", error instanceof Error ? error.message : String(error));
+  }
+  let active;
+  try {
+    active = verifyPriceStatements(station, [...evidence.priceStatements], { at: request.chargingStarted });
+  } catch (error) {
+    return fail("valid", "invalid", error instanceof Error ? error.message : String(error));
+  }
+  const chainGaps = statements.some((statement) => statement.sequence > 0 && !statements.some((before) => statement.follows(before)));
+  let agreement;
+  if (evidence.agreement !== void 0) {
+    try {
+      agreement = SessionPriceAgreement.parse(evidence.agreement);
+      agreement.verify(station);
+      const a = agreement.json;
+      if (a["EVSEId"] !== request.evseId || a["meterSerialNumber"] !== request.meterSerialNumber || agreement.chargingStarted !== request.chargingStarted || a["startDocumentSHA256"] !== request.startDocumentSHA256 || agreement.signedAt > current.evaluatedAt || (policy.revocations ?? []).some((item) => item.keyId === a["keyId"] && agreement !== void 0 && agreement.signedAt >= item.invalidFrom)) throw new POIError("Price assignment does not match this original session");
+    } catch (error) {
+      return { ...fail("valid", "invalid", error instanceof Error ? error.message : String(error)), agreement: "invalid", chainGaps };
+    }
+  }
+  const tariffs = station.tariffs.get(request.evseId) ?? [];
+  const candidates = [...active.values()].flatMap(({ statement, digest: digest2 }) => statement.prices.flatMap((price) => {
+    const tariff = tariffs.find((item) => item["@id"] === price["chargingTariffId"]);
+    return tariff === void 0 ? [] : [{ statement, digest: digest2, tariff, price }];
+  }));
+  const eligible = agreement === void 0 ? candidates : candidates.filter((item) => item.digest === agreement.json["priceStatementDigest"] && item.tariff["@id"] === agreement.json["chargingTariffId"]);
+  if (eligible.length !== 1) return { ...fail("valid", eligible.length === 0 ? "missing" : "ambiguous", eligible.length === 0 ? "No selected tariff/price is active at charging start" : "Competing price/tariff candidates need a signed selection"), agreement: agreement === void 0 ? "missing" : "invalid", chainGaps };
+  const selected = eligible[0];
+  if (selected === void 0) throw new POIError("Missing selected price");
+  const currency = requireString(selected.tariff, "currency"), elements = requireArray(selected.price["elements"], "Signed price elements").map((item) => requireObject(item, "A signed price element")), rates = grossRates(currency, elements);
+  let applicability = agreement === void 0 ? "unbound" : "bound";
+  if (agreement !== void 0 && (agreement.json["chargingMode"] !== "adhoc" || agreement.json["priceBinding"] !== "fixed-at-start" || agreement.json["pricingProfile"] !== SIMPLE_GROSS_PRICE_PROFILE || rates === void 0)) {
+    applicability = "unsupported";
+    diagnostics.push("EMP/contract terms, variable binding, unknown price profile or conditional elements are not established by this profile");
+  }
+  let publication = "missing";
+  const checkpointIds = [], witnessed = /* @__PURE__ */ new Set();
+  if (evidence.priceProofs.length > 0 || evidence.checkpoints.length > 0) {
+    try {
+      const entries = evidence.checkpoints.map((entry) => ({ ...entry, checked: verifyAuthorizedCheckpoint(current, Checkpoint.parse(entry.checkpoint), entry.operator, policy) })), byId3 = new Map(entries.map((entry) => [entry.checked.checkpoint.id, entry.checked])), heads = /* @__PURE__ */ new Map();
+      for (const checked of [...entries.map((entry) => entry.checked), ...(policy.relatedCheckpoints ?? []).map((entry) => verifyAuthorizedCheckpoint(current, Checkpoint.parse(entry.checkpoint), entry.operator, policy))]) {
+        const cp = checked.checkpoint, coordinate2 = `${cp.epoch}:${cp.sequence}`;
+        if (heads.has(coordinate2) && heads.get(coordinate2) !== cp.id) throw new POIError("Conflicting station/price checkpoint heads");
+        heads.set(coordinate2, cp.id);
+      }
+      let selectedProof = false;
+      for (const raw of evidence.priceProofs) {
+        const p = PriceStatementProof.parse(raw), checked = byId3.get(p.checkpointId);
+        if (checked === void 0) throw new POIError("Missing price checkpoint");
+        p.priceStatement.verify(station.roamingNetwork.id, asText(station.operator["@id"]), station.operatorSigningKeys);
+        if (!statements.some((statement) => statement.digestHex() === p.priceStatement.digestHex())) throw new POIError("Price proof belongs to an unsupplied statement");
+        p.verify(checked.checkpoint);
+        if (p.priceStatement.digestHex() !== selected.digest) continue;
+        selectedProof = true;
+        checkpointIds.push(checked.checkpoint.id);
+        for (const name of checked.witnessedBy) witnessed.add(name);
+        if (p.priceStatement.after !== void 0) {
+          const after = byId3.get(p.priceStatement.after)?.checkpoint;
+          if (after === void 0) {
+            publication = "incomplete";
+            diagnostics.push("Missing checkpoint named by after-link");
+            continue;
+          }
+          if (after.epoch !== checked.checkpoint.epoch || after.sequence >= checked.checkpoint.sequence) throw new POIError("Invalid checkpoint temporal order");
+          verifyCheckpointLine(entries.map((entry) => entry.checked.checkpoint).filter((cp) => cp.epoch === after.epoch && cp.sequence >= after.sequence && cp.sequence <= checked.checkpoint.sequence).sort((a, b) => a.sequence - b.sequence));
+        }
+      }
+      if (publication !== "incomplete") publication = selectedProof ? "valid" : "missing";
+    } catch (error) {
+      publication = "invalid";
+      diagnostics.push(error instanceof Error ? error.message : String(error));
+    }
+  }
+  const operator = proof.roamingNetwork["operator"];
+  const operatorJSON = isObject(operator) ? operator : {};
+  const authorities = [operatorJSON, ...evidence.checkpoints.map((entry) => isObject(entry.operator) ? entry.operator : {})];
+  const partyKeys = [...station.operatorSigningKeys, ...POIPublicKey.parseAll(station.operator["identityKeys"] ?? [], "CPO identity keys")];
+  for (const authority of authorities) {
+    partyKeys.push(...POIPublicKey.parseAll(authority["identityKeys"] ?? [], "RNO identity keys"));
+    const certificates = Array.isArray(authority["signingKeyCertificates"]) ? authority["signingKeyCertificates"] : [];
+    for (const certificate of certificates) if (isObject(certificate) && certificate["signingKey"] !== void 0) partyKeys.push(POIPublicKey.parse(certificate["signingKey"]));
+  }
+  const publicationWitnesses = verifyPricePublication(evidence.publicationReceipts, policy.publicationPolicy, {
+    roamingNetworkId: station.roamingNetwork.id,
+    evseId: request.evseId,
+    statement: selected.statement,
+    tariff: selected.tariff,
+    chargingStarted: request.chargingStarted,
+    now: current.evaluatedAt,
+    checkpoints: publication === "valid" ? evidence.checkpoints.map((entry) => Checkpoint.parse(entry.checkpoint)).filter((cp) => checkpointIds.includes(cp.id)) : [],
+    excludedKeyMaterial: partyKeys.map((key2) => toHex(key2.key.thumbprint())),
+    excludedIdentities: [asText(station.operator["@id"]), ...authorities.map((authority) => asText(authority["@id"]))]
+  });
+  if (policy.requirePublication === true && publication !== "valid") diagnostics.push("Required price publication evidence is incomplete");
+  return {
+    ...base,
+    publicationWitnesses,
+    publicationBeforeStart: publicationWitnesses.status,
+    signatures: "valid",
+    applicability,
+    agreement: agreement === void 0 ? "missing" : "valid",
+    publication,
+    chainGaps,
+    diagnostics,
+    checkpointIds,
+    witnessedBy: [...witnessed],
+    selected: { statement: selected.statement.json, digest: selected.digest, tariff: selected.tariff, currency, elements, ...rates === void 0 || agreement?.json["pricingProfile"] !== SIMPLE_GROSS_PRICE_PROFILE ? {} : { rates } }
+  };
+}
+
+// src/verifier/observedVersions.ts
+function emptyObservedVersions() {
+  return { version: 1, points: [], heads: {}, conflicts: [] };
+}
+function observedVersionsChecksum(value) {
+  return toHex(hash("sha256", canonicalJSONBytes(value)));
+}
+function key(point) {
+  return JSON.stringify([point.kind, point.chain]);
+}
+function coordinate(point) {
+  return JSON.stringify([point.kind, point.chain, point.epoch, point.position]);
+}
+function digest(value) {
+  return /^(?:[0-9a-f]{64}|[0-9a-f]{96}|[0-9a-f]{128})$/u.test(value);
+}
+function isSchema(value) {
+  return value === 1;
+}
+function valid(point) {
+  if (!["station", "checkpoint", "price", "live", "policy"].includes(point.kind) || point.chain.length === 0 || point.chain.length > 2048 || point.epoch.length > 128 || !Number.isSafeInteger(point.position) || point.position < 0 || !digest(point.digest) || point.previous !== void 0 && !digest(point.previous) || point.identity !== void 0 && !digest(point.identity) || point.revision !== void 0 && (!Number.isSafeInteger(point.revision) || point.revision < 0) || typeof point.original !== "string" || point.original.length === 0 || point.original.length > 4 * 1024 * 1024)
+    throw new POIError("Invalid observed version");
+}
+function compareObservedVersions(before, candidates, mode, observedAt) {
+  if (!isSchema(before.version) || !Number.isFinite(observedAt) || before.points.length > 4096 || before.conflicts.length > 128) throw new POIError("Invalid observed history");
+  for (const point of [...before.points, ...candidates]) valid(point);
+  const points = new Map(before.points.map((point) => [coordinate(point), point])), conflicts = [...before.conflicts], issues = [];
+  const heads = { ...before.heads };
+  const issue = (point, code, detail) => {
+    issues.push({ code, kind: point.kind, chain: point.chain, detail });
+  };
+  const conflict = (point, known, code, detail) => {
+    issue(point, code, detail);
+    if (!conflicts.some((item) => item.code === code && item.kind === point.kind && item.chain === point.chain && item.epoch === point.epoch && item.known === known.digest && item.incoming === point.digest))
+      conflicts.push({ code, kind: point.kind, chain: point.chain, epoch: point.epoch, position: point.position, known: known.digest, incoming: point.digest, original: point.original, observedAt });
+  };
+  for (const point of candidates) {
+    const existing = points.get(coordinate(point));
+    if (existing !== void 0 && existing.digest !== point.digest) {
+      conflict(point, existing, "fork", "Two authenticated digests at the same coordinate");
+      continue;
+    }
+    const identity = [...points.values()].find((item) => key(item) === key(point) && item.identity !== void 0 && point.identity !== void 0 && item.identity !== point.identity);
+    if (identity !== void 0) {
+      conflict(point, identity, "identity", "The identity or pinned document keys of an observed chain changed");
+      continue;
+    }
+    if (point.kind === "live" && point.previous !== void 0) {
+      const sibling = [...points.values()].find((item) => key(item) === key(point) && item.epoch === point.epoch && item.previous === point.previous && item.digest !== point.digest);
+      if (sibling !== void 0) {
+        conflict(point, sibling, "link", "Two authenticated live updates name the same predecessor");
+        continue;
+      }
+    }
+    if (existing === void 0) points.set(coordinate(point), point);
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const point of points.values()) {
+    const group = JSON.stringify([point.kind, point.chain, point.epoch]);
+    groups.set(group, [...groups.get(group) ?? [], point]);
+  }
+  for (const group of groups.values()) {
+    if (!candidates.some((candidate) => group.some((point) => key(point) === key(candidate)))) continue;
+    group.sort((a, b) => a.position - b.position);
+    for (let i = 1; i < group.length; i++) {
+      const point = group[i], previous = group[i - 1];
+      if (point === void 0 || previous === void 0 || point.kind === "station") continue;
+      if ((point.kind === "price" || point.kind === "checkpoint") && point.position === previous.position + 1 && point.previous !== previous.digest)
+        conflict(point, previous, "link", "Authenticated adjacent versions contradict their predecessor link");
+      if (point.kind === "checkpoint" && point.previous === previous.digest && point.revision !== void 0 && previous.revision !== void 0 && (point.revision < previous.revision || point.revision === previous.revision && !(point.final === true && point.rootDigest === previous.rootDigest))) conflict(point, previous, "link", "Checkpoint revision does not increase");
+    }
+  }
+  const selected = /* @__PURE__ */ new Map();
+  for (const point of candidates) {
+    const name = key(point), old = selected.get(name);
+    if (old === void 0 || old.epoch === point.epoch && point.position > old.position) selected.set(name, point);
+  }
+  for (const point of selected.values()) {
+    if (conflicts.some((item) => item.kind === point.kind && item.chain === point.chain)) issue(point, "known-fork", "This chain has an unresolved authenticated contradiction");
+    if (mode === "historical") continue;
+    if (new Set(candidates.filter((candidate) => key(candidate) === key(point)).map((candidate) => candidate.epoch)).size > 1) {
+      issue(point, "epoch-transition", "A current selection cannot combine epochs without a verified transition");
+      continue;
+    }
+    const head = before.heads[key(point)];
+    const closed = before.points.find((item) => item.kind === "checkpoint" && item.epoch === point.epoch && item.final === true);
+    if (point.kind === "checkpoint" && closed !== void 0 && point.position > closed.position) {
+      issue(point, "epoch-transition", "This epoch was closed by its final checkpoint");
+      continue;
+    }
+    if (head !== void 0 && head.epoch !== point.epoch) {
+      issue(point, "epoch-transition", "An epoch change requires an explicitly verified transition");
+      continue;
+    }
+    const prior = before.points.filter((item) => key(item) === key(point) && item.epoch === point.epoch).sort((a, b) => b.position - a.position)[0];
+    if (prior !== void 0 && point.position < prior.position) {
+      issue(point, "rollback", `Version ${point.position} is older than locally observed ${prior.position}`);
+      continue;
+    }
+    const anchor = head === void 0 ? prior : before.points.find((item) => key(item) === key(point) && item.epoch === head.epoch && item.digest === head.digest);
+    if (anchor !== void 0 && point.position > anchor.position && point.kind !== "station") {
+      let cursor = point;
+      const visited = /* @__PURE__ */ new Set();
+      while (cursor.digest !== anchor.digest && !visited.has(cursor.digest)) {
+        visited.add(cursor.digest);
+        const parent = [...points.values()].find((item) => key(item) === key(point) && item.epoch === point.epoch && item.digest === cursor?.previous);
+        if (parent === void 0 || parent.position >= cursor.position || point.kind !== "live" && parent.position + 1 !== cursor.position) {
+          cursor = void 0;
+          break;
+        }
+        cursor = parent;
+      }
+      if (cursor?.digest !== anchor.digest) issue(point, "continuity-missing", "Missing authenticated predecessor path to the locally observed head");
+    }
+  }
+  const accepted = issues.length === 0;
+  if (accepted && mode === "current") for (const point of selected.values()) heads[key(point)] = { epoch: point.epoch, position: point.position, digest: point.digest };
+  if (points.size > 4096 || conflicts.length > 128) throw new POIError("Observed history capacity reached; reset requires an explicit local decision");
+  const state = { ...before, version: 1, points: [...points.values()], heads, conflicts };
+  const advanced = candidates.some((point) => before.points.some((old) => key(old) === key(point) && old.epoch === point.epoch && old.position < point.position));
+  return { accepted, status: !accepted ? "rejected" : mode === "historical" ? "historical" : !before.points.some((old) => candidates.some((point) => key(point) === key(old) && point.epoch === old.epoch)) ? "first-seen" : advanced ? "advanced" : "matches", issues, state };
+}
+function stationVersionObservation(proof, epoch = "") {
+  return { kind: "station", chain: "network", epoch, position: proof.revision, digest: proof.commitId, original: prettyJSON(proof.json) };
+}
+function checkpointVersionObservation(checkpoint) {
+  return {
+    kind: "checkpoint",
+    chain: "network",
+    epoch: String(checkpoint.epoch),
+    position: checkpoint.sequence,
+    revision: checkpoint.revision,
+    digest: checkpoint.id,
+    final: checkpoint.isFinal,
+    rootDigest: checkpoint.commitId,
+    ...checkpoint.previousId === void 0 ? {} : { previous: checkpoint.previousId },
+    original: prettyJSON(checkpoint.json)
+  };
+}
+function priceVersionObservation(statement) {
+  return {
+    kind: "price",
+    chain: statement.chain,
+    epoch: "",
+    position: statement.sequence,
+    digest: statement.digestHex(),
+    ...statement.previous === void 0 ? {} : { previous: statement.previous },
+    original: prettyJSON(statement.json)
+  };
+}
+function checkpointRootVersionObservation(checkpoint) {
+  return { kind: "station", chain: "network", epoch: checkpoint.epoch === 1 ? "" : String(checkpoint.epoch), position: checkpoint.revision, digest: checkpoint.commitId, original: prettyJSON(checkpoint.json) };
+}
+
+// src/verifier/documentKeys.ts
+var CHARGING_DOCUMENT_USAGE = "chargeTransparencyRecords";
+var ALGORITHMS = {
+  1: "ECDSA-secp256r1",
+  2: "ECDSA-secp384r1",
+  3: "ECDSA-secp521r1",
+  6: "EdDSA-Ed25519",
+  7: "EdDSA-Ed448",
+  8: "ECDSA-secp256k1"
+};
+function verifyChargingDocumentKeys(context, proof, request) {
+  if (!Number.isFinite(request.at) || request.at > context.evaluatedAt)
+    throw new POIError("Invalid charging-document evaluation time");
+  const parsed = ChargingStationProof.parse(proof);
+  const historical = historicalOperatorContext(context, parsed.roamingNetwork["operator"] ?? null, request.at);
+  const station = verifyChargingStation(historical, parsed, { evseId: request.evseId });
+  if (station.operator["@id"] !== request.operatorId)
+    throw new POIError("The live document CPO is not the operator of the proven EVSE");
+  const keys = station.operatorSigningKeys.filter((key2) => key2.isValidAt(request.at) && key2.maySign(CHARGING_DOCUMENT_USAGE)).map((key2) => {
+    const algorithm = key2.key.curve === null ? key2.key.algorithm?.name : ALGORITHMS[key2.key.curve.id];
+    if (algorithm === void 0)
+      throw new POIError("Unsupported CPO charging-document key algorithm");
+    return { id: key2.id, algorithm, encodings: ["COSE_Key", "CBOR", "base64"], value: requireString(key2.json, "key"), keyUsage: ["signCTRs"] };
+  });
+  if (keys.length === 0)
+    throw new POIError("The proven CPO supplies no valid keys authorized for charging transparency records");
+  return {
+    evseId: request.evseId,
+    chargingStationId: requireString(station.chargingStation, "@id"),
+    operatorId: request.operatorId,
+    at: request.at,
+    commitId: station.commitId,
+    revision: station.revision,
+    keys
+  };
+}
+
+// src/verifier/trustTransitions.ts
+var TRUST_TRANSITION_CONTEXT = "https://open.charging.cloud/contexts/wwcp/trustTransition/v1";
+var trustStatementDigest = (statement) => toHex(hash("sha256", canonicalJSONBytes(statement.content())));
+function trustPolicyId(anchor) {
+  return toHex(hash("sha256", canonicalJSONBytes({
+    network: anchor.id,
+    holders: anchor.holders.map((holder) => [...holder]),
+    minConsensus: anchor.minConsensus,
+    urls: anchor.urls.map((url) => new URL(url).href.replace(/\/+$/u, "")).sort()
+  })));
+}
+var TrustTransition = class _TrustTransition {
+  constructor(json, sequence, previous, signedAt, validUntil, fromPolicyId, fromStatementDigest, anchor, operator) {
+    this.json = json;
+    this.sequence = sequence;
+    this.previous = previous;
+    this.signedAt = signedAt;
+    this.validUntil = validUntil;
+    this.fromPolicyId = fromPolicyId;
+    this.fromStatementDigest = fromStatementDigest;
+    this.anchor = anchor;
+    this.operator = operator;
+  }
+  json;
+  sequence;
+  previous;
+  signedAt;
+  validUntil;
+  fromPolicyId;
+  fromStatementDigest;
+  anchor;
+  operator;
+  static parse(value) {
+    const json = requireObject(value, "A trust transition");
+    onlyProperties(json, [
+      "@context",
+      "sequence",
+      "previous",
+      "fromPolicyId",
+      "fromStatementDigest",
+      "toAnchor",
+      "toOperator",
+      "signedAt",
+      "validUntil",
+      "checkpoints",
+      "epochChange",
+      "signatures"
+    ], "A trust transition");
+    if (json["@context"] !== TRUST_TRANSITION_CONTEXT || new TextEncoder().encode(prettyJSON(json)).length > 2 * 1024 * 1024)
+      throw new POIError("Unsupported or excessive trust transition");
+    const previous = get(json, "previous");
+    const sequence = requireInteger(json, "sequence", 0, 31);
+    if (previous !== void 0 !== sequence > 0 || previous !== void 0 && (typeof previous !== "string" || !/^[0-9a-f]{64}$/u.test(previous)))
+      throw new POIError("Invalid predecessor of a trust transition");
+    const signedAt = requireTimestamp(json, "signedAt");
+    const validUntil = requireTimestamp(json, "validUntil");
+    if (validUntil < signedAt)
+      throw new POIError("Invalid transition validity");
+    return new _TrustTransition(
+      json,
+      sequence,
+      previous,
+      signedAt,
+      validUntil,
+      requireString(json, "fromPolicyId"),
+      requireString(json, "fromStatementDigest"),
+      TrustAnchor.parse(requireString(json, "toAnchor")),
+      requireObject(json["toOperator"], "The target operator")
+    );
+  }
+  /** What it names, but its signatures. */
+  content() {
+    const { signatures: _, ...content } = this.json;
+    return content;
+  }
+  /** The SHA-256 of the canonical JSON of its content: the `previous` of the next transition. */
+  digest() {
+    return toHex(hash("sha256", canonicalJSONBytes(this.content())));
+  }
+  /** The signature input of a signature: its content with the side, the algorithm and the key of the signature. */
+  signingBytes(side, algorithm, keyId) {
+    return canonicalJSONBytes({ ...this.content(), side, algorithm, keyId });
+  }
+};
+var VerifiedTrustTransition = class _VerifiedTrustTransition {
+  constructor(source, context, epoch, checkpoints, first, oldEpoch, signedBy) {
+    this.source = source;
+    this.context = context;
+    this.epoch = epoch;
+    this.checkpoints = checkpoints;
+    this.first = first;
+    this.oldEpoch = oldEpoch;
+    this.signedBy = signedBy;
+  }
+  source;
+  context;
+  epoch;
+  checkpoints;
+  first;
+  oldEpoch;
+  signedBy;
+  static verify(basis, fromOperator, transition, options) {
+    if (!Number.isFinite(options.acceptedAt) || options.acceptedAt < transition.signedAt || options.acceptedAt > transition.validUntil || transition.sequence !== options.sequence || transition.previous !== options.previous)
+      throw new POIError("Transition is expired, out of order or not accepted within its signed interval");
+    if (transition.fromPolicyId !== trustPolicyId(basis.anchor) || transition.fromStatementDigest !== basis.keyStatementDigest || transition.anchor.id !== basis.roamingNetworkId || transition.operator["@id"] !== basis.roamingNetworkOperatorId)
+      throw new POIError("Transition does not continue the exact authorized policy/network/operator");
+    const oldOperator = requireObject(fromOperator, "Previous operator");
+    const oldStatement = KeyStatement.parse(oldOperator["keyStatement"]);
+    OperatorTrust.fromOperatorJSON(basis, oldOperator);
+    const nextStatement = KeyStatement.parse(transition.operator["keyStatement"]);
+    const identities = POIPublicKey.parseAll(transition.operator["identityKeys"], "Target identity keys");
+    const next = TrustContext.create(transition.anchor, nextStatement, { trustedIdentityKeyIds: transition.anchor.keys, otherIdentityKeys: identities, at: transition.signedAt });
+    OperatorTrust.fromOperatorJSON(next, transition.operator);
+    if (next.roamingNetworkOperatorId !== basis.roamingNetworkOperatorId || next.requiredConsensus < basis.requiredConsensus)
+      throw new POIError("A trust transition must not silently reduce the required holder quorum");
+    for (const holder of basis.authorizedAnchor.holders)
+      if (transition.anchor.holders.filter((group) => group.some((id) => holder.includes(id))).length > 1)
+        throw new POIError("A transition splits a previously known holder");
+    const oldPool = [...oldStatement.identityKeys, ...POIPublicKey.parseAll(oldOperator["identityKeys"], "Previous identity keys")];
+    const nextPool = [...nextStatement.identityKeys, ...identities];
+    const old = /* @__PURE__ */ new Set();
+    const target = /* @__PURE__ */ new Set();
+    for (const raw of requireArray(transition.json["signatures"], "Transition signatures")) {
+      const signature = requireObject(raw, "A transition signature");
+      onlyProperties(signature, ["side", "algorithm", "keyId", "value"], "A transition signature");
+      const side = requireString(signature, "side");
+      const algorithm = requireString(signature, "algorithm");
+      const id = requireString(signature, "keyId");
+      if (side !== "old" && side !== "new")
+        throw new POIError("Invalid transition signature side");
+      const groups = side === "old" ? basis.trustedHolders : next.trustedHolders;
+      const pool = side === "old" ? oldPool : nextPool;
+      const holder = groups.findIndex((group) => group.includes(id));
+      const key2 = pool.find((key3) => key3.id === id);
+      if (key2?.isValidAt(transition.signedAt) !== true)
+        throw new POIError("Transition signer is not an authorized valid identity key");
+      verifySignature(algorithm, key2.key, transition.signingBytes(side, algorithm, id), requireString(signature, "value"));
+      if (holder >= 0)
+        (side === "old" ? old : target).add(holder);
+    }
+    if (old.size < basis.requiredConsensus || target.size < next.requiredConsensus)
+      throw new POIError("Both old and new holder quorums must sign the trust transition");
+    const checkpoints = (transition.json["checkpoints"] === void 0 ? [] : requireArray(transition.json["checkpoints"], "Transition checkpoints")).map((raw) => {
+      const checkpoint = Checkpoint.parse(raw);
+      verifyAuthorizedCheckpoint(historicalOperatorContext(basis, oldOperator, checkpoint.createdAt), checkpoint, oldOperator);
+      if (checkpoint.epoch !== options.epoch.number)
+        throw new POIError("The transition checkpoint line belongs to another epoch");
+      return checkpoint;
+    });
+    let epoch = options.epoch;
+    let first;
+    if (transition.json["epochChange"] !== void 0) {
+      const change = requireObject(transition.json["epochChange"], "An epoch change");
+      onlyProperties(change, ["genesis", "firstCheckpoint"], "An epoch change");
+      const final = checkpoints.at(-1);
+      if (final?.next === void 0)
+        throw new POIError("An epoch transition needs the signed final checkpoint");
+      if (final.createdAt > transition.signedAt)
+        throw new POIError("The final checkpoint postdates the transition");
+      const genesis = Commit.parse(change["genesis"]);
+      const expected = Commit.genesisOf(basis.roamingNetworkId, final.json["eTags"] ?? null, final.next);
+      first = Checkpoint.parse(change["firstCheckpoint"]);
+      if (genesis.id !== expected.id || !first.isOf(expected) || first.sequence !== 0 || first.epoch !== final.next.number || first.previous?.checkpointId !== final.id || first.previous.epoch !== final.epoch || !sameETags(first.previous.eTags, final.eTags))
+        throw new POIError("The next epoch must start from the exact deterministic genesis and final checkpoint");
+      if ((trustPolicyId(next.anchor) !== trustPolicyId(basis.anchor) || next.keyStatementDigest !== basis.keyStatementDigest) && first.createdAt !== transition.signedAt)
+        throw new POIError("A combined policy/epoch handoff must activate at its first checkpoint time");
+      if (first.createdAt < final.createdAt || first.createdAt > transition.signedAt)
+        throw new POIError("Invalid epoch-transition checkpoint times");
+      const trust = OperatorTrust.fromOperatorJSON(historicalOperatorContext(next, transition.operator, first.createdAt), transition.operator);
+      for (const profile of [options.epoch.profiles, final.next.profiles]) {
+        const signatures = first.signatures.filter((signature) => signature.role === "roamingNetworkOperator" && profile.allowsSignatureAlgorithm(signature.algorithm));
+        trust.verifyOperatorSignatures(signatures, (signature, key2) => first?.verifySignature(signature, key2), "epoch-transition checkpoint");
+      }
+      for (const signature of first.signatures)
+        if (!options.epoch.profiles.allowsSignatureAlgorithm(signature.algorithm) && !final.next.profiles.allowsSignatureAlgorithm(signature.algorithm))
+          throw new POIError("An epoch-transition signature uses neither accepted profile");
+      epoch = { ...final.next, startedAt: first.createdAt };
+    }
+    return new _VerifiedTrustTransition(
+      transition,
+      TrustContext.withEpoch(next, epoch, [...basis.epochs.filter((item) => item.number !== epoch.number), epoch]),
+      epoch,
+      checkpoints,
+      first,
+      options.epoch,
+      { old: [...old], next: [...target] }
+    );
+  }
+};
+function applyVerifiedTrustTransition(before, verified, at) {
+  const id = verified.source.digest();
+  const known = before.transitions?.find((entry) => entry.id === id);
+  const policy = compareObservedVersions(
+    before,
+    [{
+      kind: "policy",
+      chain: "trust",
+      epoch: "",
+      position: verified.source.sequence,
+      digest: id,
+      original: prettyJSON(verified.source.json),
+      ...verified.source.previous === void 0 ? {} : { previous: verified.source.previous }
+    }],
+    "historical",
+    at
+  );
+  if (!policy.accepted)
+    return policy;
+  before = policy.state;
+  if (known !== void 0)
+    return { accepted: true, status: "matches", issues: [], state: before };
+  if ((before.transitions?.length ?? 0) !== verified.source.sequence)
+    throw new POIError("The observed journal has another transition predecessor");
+  const oldPoints = verified.checkpoints.flatMap((checkpoint) => [checkpointVersionObservation(checkpoint), checkpointRootVersionObservation(checkpoint)]);
+  const prior = compareObservedVersions(before, oldPoints, "current", at);
+  if (!prior.accepted)
+    return prior;
+  let state = prior.state;
+  if (verified.first !== void 0) {
+    const points = [checkpointVersionObservation(verified.first), checkpointRootVersionObservation(verified.first)];
+    const checked = compareObservedVersions(state, points, "historical", at);
+    if (!checked.accepted)
+      return checked;
+    const heads = { ...checked.state.heads };
+    for (const point of points)
+      heads[JSON.stringify([point.kind, point.chain])] = { epoch: point.epoch, position: point.position, digest: point.digest };
+    state = { ...checked.state, heads };
+  }
+  return {
+    accepted: true,
+    status: "advanced",
+    issues: [],
+    state: {
+      ...state,
+      transitions: [
+        ...state.transitions ?? [],
+        {
+          id,
+          sequence: verified.source.sequence,
+          fromPolicyId: verified.source.fromPolicyId,
+          toPolicyId: trustPolicyId(verified.source.anchor),
+          fromEpoch: verified.oldEpoch.number,
+          toEpoch: verified.epoch.number,
+          original: prettyJSON(verified.source.json)
+        }
+      ]
+    }
+  };
+}
+var initialTrustEpoch = () => ({ number: 1, profiles: EpochProfiles.FIRST });
 
-export { ATTESTATION_CONTEXT, ArchiveSegment, Attestation, CHANGE_SET_CONTEXT, CHECKPOINT_CONTEXT2 as CHECKPOINT_CONTEXT, CHILD_ARRAYS, COMMIT_CONTEXT2 as COMMIT_CONTEXT, CONTEXT_PREFIX, ChangeSet, ChargingStationProof, Checkpoint, CheckpointProof, Commit, DCCMeasurementResult, DCCResult, DCCStatement, DCC_PERFORMANCE_LOCATIONS, DCOC_MODULES, DDoCNotifiedBody, Decimal, DigitalCalibrationCertificate, DigitalCertificateOfConformity, DigitalDeclarationOfConformity, EPOCH_CONTEXT, EPOCH_LINK_CONTEXT, EPOCH_PROFILES_CONTEXT, EV_TALER_EXCHANGE_CONTEXT, EV_TALER_MERCHANT_CONTEXT, EV_TALER_PAYMENT_MEANS, EV_TALER_PAYMENT_OPTION, EpochProfiles, FIRST_EPOCH, History, KEY_STATEMENT_CONTEXT, KeyStatement, KeyUsages, LIVE_TOPICS, MAX_DECIMAL_SCALE, MAX_PRICE_STATEMENT_SEQUENCE, MERGE_CHANGE_SET_ID_PREFIX, OperatorTrust, POIClient, POIError, POIPublicKey, PROOF_CONTEXT, PriceStatement, PriceStatementProof, QIDigitalDocument, QIDigitalItem, QIDigitalLegislation, QIDigitalManufacturer, QIDigitalModel, QIDigitalPerson, QIDigitalQuantity, QIDigitalSignature, QIDigitalStandard, QI_DIGITAL_CONFORMITIES, ROAMING_NETWORK_CONTEXT, RUNTIME_STATUS_KINDS, RoamingNetwork, RoamingNetworkOperator, RuntimeStatus, SIGNATURE_ALGORITHMS, SIGNING_KEY_CERTIFICATE_CONTEXT, STATUS_UPDATE_CONTEXT, STYX_CANONICAL_JSON, SignatureRoles, SigningKeyCertificate, TRUST_ANCHOR_CONTEXT, TRUST_ANCHOR_QR_PREFIX, TrustAnchor, TrustContext, applyChangeSet, approvesQualitySystem, auditPath, canonicalJSON, canonicalJSONBytes, canonicalString, cborETag, cborToJson, changeSetIdentification, check, checkOwnership, clone, commitsRoot, decodeDeterministicCbor, describeVersion, deterministicCbor, effectiveChargingStationOperator, effectiveContent, effectiveTreeETag, entityDigest, etagToJSON, etagToText, evTalerExchangesAt, evTalerMerchantOf, evTalerTariffOf, fromBase45, fromBase64, fromHex, fromJavaScript, get, hash, isArray, isObject, isTalerPublicKey, jsonETag, jsonToCbor, leafHash, liveRequest, merkleRoot, merkleRootOfLeafHashes, nodeHash, parseArchiveSegmentInfo, parseETag, parseETags, parseEpoch, parseEpochLink, parseEvidence, parseFrame, parseJSON, parseJSONBytes, parseJSONObject, parsePriceStatements, parseStatusUpdate, parseTimestamp, parseTrustedWitnesses, paymentOptionName, prettyJSON, priceStatementChainOf, priceStatementsRoot, prunedTree, qiDigitalContext, rootFromAuditPath, sameETag, sameETags, sameEpoch, sameValue, skeleton, subscribeRequest, toBase45, toBase64, toHex, toTimestamp, verifyChargingStation, verifyCheckpointLine, verifyCheckpointPriceStatements, verifyCheckpointSignatures, verifyEvidence, verifyPriceStatementChain, verifyPriceStatements, verifySegmentLine, verifySignature, verifyVersion };
+export { ATTESTATION_CONTEXT, ArchiveSegment, Attestation, CHANGE_SET_CONTEXT, CHARGING_DOCUMENT_USAGE, CHECKPOINT_CONTEXT2 as CHECKPOINT_CONTEXT, CHILD_ARRAYS, COMMIT_CONTEXT2 as COMMIT_CONTEXT, CONTEXT_PREFIX, ChangeSet, ChargingStationProof, Checkpoint, CheckpointProof, Commit, DCCMeasurementResult, DCCResult, DCCStatement, DCC_PERFORMANCE_LOCATIONS, DCOC_MODULES, DDoCNotifiedBody, Decimal, DigitalCalibrationCertificate, DigitalCertificateOfConformity, DigitalDeclarationOfConformity, EPOCH_CONTEXT, EPOCH_LINK_CONTEXT, EPOCH_PROFILES_CONTEXT, EV_TALER_EXCHANGE_CONTEXT, EV_TALER_MERCHANT_CONTEXT, EV_TALER_PAYMENT_MEANS, EV_TALER_PAYMENT_OPTION, EpochProfiles, FIRST_EPOCH, HISTORICAL_METER_EVIDENCE_CONTEXT, HistoricalTrustContext, History, KEY_STATEMENT_CONTEXT, KeyStatement, KeyUsages, LIVE_TOPICS, MAX_DECIMAL_SCALE, MAX_PRICE_STATEMENT_SEQUENCE, MERGE_CHANGE_SET_ID_PREFIX, MeasurementKeyError, OperatorTrust, POIClient, POIError, POIPublicKey, PRICE_PUBLICATION_RECEIPT_CONTEXT, PROOF_CONTEXT, PricePublicationReceipt, PriceStatement, PriceStatementProof, QIDigitalDocument, QIDigitalItem, QIDigitalLegislation, QIDigitalManufacturer, QIDigitalModel, QIDigitalPerson, QIDigitalQuantity, QIDigitalSignature, QIDigitalStandard, QI_DIGITAL_CONFORMITIES, ROAMING_NETWORK_CONTEXT, RUNTIME_STATUS_KINDS, RoamingNetwork, RoamingNetworkOperator, RuntimeStatus, SESSION_PRICE_AGREEMENT_CONTEXT, SESSION_PRICE_EVIDENCE_CONTEXT, SIGNATURE_ALGORITHMS, SIGNING_KEY_CERTIFICATE_CONTEXT, SIMPLE_GROSS_PRICE_PROFILE, STATUS_UPDATE_CONTEXT, STYX_CANONICAL_JSON, SessionPriceAgreement, SignatureRoles, SigningKeyCertificate, TRUST_ANCHOR_CONTEXT, TRUST_ANCHOR_QR_PREFIX, TRUST_TRANSITION_CONTEXT, TrustAnchor, TrustContext, TrustTransition, VerifiedTrustTransition, WITNESS_PUBLICATION_POLICY_CONTEXT, applyChangeSet, applyVerifiedTrustTransition, approvesQualitySystem, auditPath, canonicalJSON, canonicalJSONBytes, canonicalString, cborETag, cborToJson, changeSetIdentification, check, checkOwnership, checkpointRootVersionObservation, checkpointVersionObservation, clone, commitsRoot, compareObservedVersions, decodeDeterministicCbor, describeVersion, deterministicCbor, effectiveChargingStationOperator, effectiveContent, effectiveTreeETag, emptyObservedVersions, entityDigest, etagToJSON, etagToText, evTalerExchangesAt, evTalerMerchantOf, evTalerTariffOf, fromBase45, fromBase64, fromHex, fromJavaScript, get, hash, historicalOperatorContext, initialTrustEpoch, isArray, isObject, isTalerPublicKey, jsonETag, jsonToCbor, leafHash, liveRequest, merkleRoot, merkleRootOfLeafHashes, nodeHash, observedVersionsChecksum, parseArchiveSegmentInfo, parseETag, parseETags, parseEpoch, parseEpochLink, parseEvidence, parseFrame, parseHistoricalMeterEvidence, parseJSON, parseJSONBytes, parseJSONObject, parseMeasurementPublicKey, parsePriceStatements, parseSessionPriceEvidence, parseStatusUpdate, parseTimestamp, parseTrustedWitnesses, parseWitnessPublicationPolicy, paymentOptionName, prettyJSON, pricePublicationOfferHashes, priceStatementChainOf, priceStatementsRoot, priceVersionObservation, prunedTree, publicPublicationURL, qiDigitalContext, rootFromAuditPath, sameETag, sameETags, sameEpoch, sameValue, skeleton, stationVersionObservation, subscribeRequest, toBase45, toBase64, toHex, toTimestamp, trustPolicyId, trustStatementDigest, verifyAuthorizedCheckpoint, verifyChargingDocumentKeys, verifyChargingStation, verifyCheckpointLine, verifyCheckpointPriceStatements, verifyCheckpointSignatures, verifyEvidence, verifyHistoricalMeterEvidence, verifyMeterKey, verifyPricePublication, verifyPriceStatementChain, verifyPriceStatements, verifySegmentLine, verifySessionPriceEvidence, verifySignature, verifyVersion };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map