@openauditmodel/cli 0.1.0

package/dist/conformance/src/format-errors.js

@@ -0,0 +1,116 @@
+function paramsOf(error) {
+    return (error.params ?? {});
+}
+function asString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+/** Escapes a property name so that it is a legal JSON Pointer reference token. */
+function pointerSegment(property) {
+    return property.replaceAll("~", "~0").replaceAll("/", "~1");
+}
+function joinPointer(base, property) {
+    const pointer = property === undefined ? base : `${base}/${pointerSegment(property)}`;
+    return pointer === "" ? "/" : pointer;
+}
+function describe(error) {
+    const params = paramsOf(error);
+    const fallback = error.message ?? "failed validation";
+    switch (error.keyword) {
+        case "required":
+            return { message: `missing required property "${String(params["missingProperty"])}"` };
+        case "dependentRequired":
+            return {
+                message: `missing property "${String(params["missingProperty"])}", which is required when "${String(params["property"])}" is present`,
+            };
+        case "additionalProperties":
+            return {
+                message: `unknown property "${String(params["additionalProperty"])}" is not permitted here`,
+                detail: "core objects reject unknown properties; use metadata, extensions or attributes instead",
+            };
+        case "propertyNames":
+            return {
+                message: `property name "${String(params["propertyName"])}" does not follow the required naming rule`,
+            };
+        case "enum": {
+            const allowed = Array.isArray(params["allowedValues"])
+                ? params["allowedValues"].map((value) => JSON.stringify(value)).join(", ")
+                : undefined;
+            return {
+                message: "value is not one of the permitted values",
+                ...(allowed === undefined ? {} : { detail: `allowed: ${allowed}` }),
+            };
+        }
+        case "const":
+            return {
+                message: "value does not equal the required constant",
+                detail: `expected: ${JSON.stringify(params["allowedValue"])}`,
+            };
+        case "pattern":
+            return {
+                message: "value does not match the required pattern",
+                detail: `pattern: ${String(params["pattern"])}`,
+            };
+        case "format":
+            return {
+                message: `value is not a valid "${String(params["format"])}" value`,
+            };
+        case "if":
+            return {
+                message: "value does not satisfy a conditional requirement of the schema",
+                detail: "see the accompanying issues for the specific requirement",
+            };
+        case "not":
+            return { message: "value is explicitly forbidden by the schema" };
+        default:
+            return { message: fallback };
+    }
+}
+/** Converts validator errors into issues, deduplicating identical entries. */
+export function toIssues(errors) {
+    if (!errors || errors.length === 0) {
+        return [];
+    }
+    const seen = new Set();
+    const issues = [];
+    for (const error of errors) {
+        const params = paramsOf(error);
+        const base = error.instancePath;
+        // `propertyNames` failures report the offending key either on the error
+        // itself (for the nested constraint that failed) or in its parameters.
+        const propertyName = asString(error.propertyName) ??
+            (error.keyword === "propertyNames" ? asString(params["propertyName"]) : undefined);
+        let path;
+        if (error.keyword === "required" || error.keyword === "dependentRequired") {
+            path = joinPointer(base, asString(params["missingProperty"]));
+        }
+        else if (error.keyword === "additionalProperties") {
+            path = joinPointer(base, asString(params["additionalProperty"]));
+        }
+        else {
+            path = joinPointer(base, propertyName);
+        }
+        const { message, detail } = describe(error);
+        const key = `${path}|${error.keyword}|${message}|${detail ?? ""}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        issues.push({
+            path,
+            message,
+            keyword: error.keyword,
+            ...(detail === undefined ? {} : { detail }),
+        });
+    }
+    return issues;
+}
+/** Renders issues as indented report lines. */
+export function formatIssues(issues, indent = "    ") {
+    return issues
+        .map((issue) => {
+        const detail = issue.detail === undefined ? "" : `\n${indent}  ${issue.detail}`;
+        return `${indent}${issue.path}  ${issue.message}  [${issue.keyword}]${detail}`;
+    })
+        .join("\n");
+}
+//# sourceMappingURL=format-errors.js.map

package/dist/conformance/src/format-errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-errors.js","sourceRoot":"","sources":["../../../conformance/src/format-errors.ts"],"names":[],"mappings":"AAkBA,SAAS,QAAQ,CAAC,KAAkB;IAClC,OAAO,CAAC,KAAK,CAAC,MAAM,IAAI,EAAE,CAA4B,CAAC;AACzD,CAAC;AAED,SAAS,QAAQ,CAAC,KAAc;IAC9B,OAAO,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;AACvD,CAAC;AAED,kFAAkF;AAClF,SAAS,cAAc,CAAC,QAAgB;IACtC,OAAO,QAAQ,CAAC,UAAU,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;AAC9D,CAAC;AAED,SAAS,WAAW,CAAC,IAAY,EAAE,QAA4B;IAC7D,MAAM,OAAO,GAAG,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,IAAI,cAAc,CAAC,QAAQ,CAAC,EAAE,CAAC;IACtF,OAAO,OAAO,KAAK,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC;AACxC,CAAC;AAED,SAAS,QAAQ,CAAC,KAAkB;IAClC,MAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC/B,MAAM,QAAQ,GAAG,KAAK,CAAC,OAAO,IAAI,mBAAmB,CAAC;IAEtD,QAAQ,KAAK,CAAC,OAAO,EAAE,CAAC;QACtB,KAAK,UAAU;YACb,OAAO,EAAE,OAAO,EAAE,8BAA8B,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC,GAAG,EAAE,CAAC;QACzF,KAAK,mBAAmB;YACtB,OAAO;gBACL,OAAO,EAAE,qBAAqB,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC,8BAA8B,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,cAAc;aACtI,CAAC;QACJ,KAAK,sBAAsB;YACzB,OAAO;gBACL,OAAO,EAAE,qBAAqB,MAAM,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC,yBAAyB;gBAC3F,MAAM,EACJ,wFAAwF;aAC3F,CAAC;QACJ,KAAK,eAAe;YAClB,OAAO;gBACL,OAAO,EAAE,kBAAkB,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,4CAA4C;aACtG,CAAC;QACJ,KAAK,MAAM,CAAC,CAAC,CAAC;YACZ,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;gBACpD,CAAC,CAAE,MAAM,CAAC,eAAe,CAAe,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;gBACzF,CAAC,CAAC,SAAS,CAAC;YACd,OAAO;gBACL,OAAO,EAAE,0CAA0C;gBACnD,GAAG,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,YAAY,OAAO,EAAE,EAAE,CAAC;aACpE,CAAC;QACJ,CAAC;QACD,KAAK,OAAO;YACV,OAAO;gBACL,OAAO,EAAE,4CAA4C;gBACrD,MAAM,EAAE,aAAa,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,EAAE;aAC9D,CAAC;QACJ,KAAK,SAAS;YACZ,OAAO;gBACL,OAAO,EAAE,2CAA2C;gBACpD,MAAM,EAAE,YAAY,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,EAAE;aAChD,CAAC;QACJ,KAAK,QAAQ;YACX,OAAO;gBACL,OAAO,EAAE,yBAAyB,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,SAAS;aACpE,CAAC;QACJ,KAAK,IAAI;YACP,OAAO;gBACL,OAAO,EAAE,gEAAgE;gBACzE,MAAM,EAAE,0DAA0D;aACnE,CAAC;QACJ,KAAK,KAAK;YACR,OAAO,EAAE,OAAO,EAAE,6CAA6C,EAAE,CAAC;QACpE;YACE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC;IACjC,CAAC;AACH,CAAC;AAED,8EAA8E;AAC9E,MAAM,UAAU,QAAQ,CAAC,MAAiD;IACxE,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACnC,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,MAAM,MAAM,GAAsB,EAAE,CAAC;IAErC,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;QAC/B,MAAM,IAAI,GAAG,KAAK,CAAC,YAAY,CAAC;QAEhC,wEAAwE;QACxE,uEAAuE;QACvE,MAAM,YAAY,GAChB,QAAQ,CAAE,KAAoC,CAAC,YAAY,CAAC;YAC5D,CAAC,KAAK,CAAC,OAAO,KAAK,eAAe,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;QAErF,IAAI,IAAY,CAAC;QACjB,IAAI,KAAK,CAAC,OAAO,KAAK,UAAU,IAAI,KAAK,CAAC,OAAO,KAAK,mBAAmB,EAAE,CAAC;YAC1E,IAAI,GAAG,WAAW,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC;QAChE,CAAC;aAAM,IAAI,KAAK,CAAC,OAAO,KAAK,sBAAsB,EAAE,CAAC;YACpD,IAAI,GAAG,WAAW,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC;QACnE,CAAC;aAAM,CAAC;YACN,IAAI,GAAG,WAAW,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;QACzC,CAAC;QAED,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;QAC5C,MAAM,GAAG,GAAG,GAAG,IAAI,IAAI,KAAK,CAAC,OAAO,IAAI,OAAO,IAAI,MAAM,IAAI,EAAE,EAAE,CAAC;QAClE,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YAClB,SAAS;QACX,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAEd,MAAM,CAAC,IAAI,CAAC;YACV,IAAI;YACJ,OAAO;YACP,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,GAAG,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC;SAC5C,CAAC,CAAC;IACL,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,+CAA+C;AAC/C,MAAM,UAAU,YAAY,CAAC,MAAkC,EAAE,MAAM,GAAG,MAAM;IAC9E,OAAO,MAAM;SACV,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;QACb,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,MAAM,KAAK,KAAK,CAAC,MAAM,EAAE,CAAC;QAChF,OAAO,GAAG,MAAM,GAAG,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,OAAO,MAAM,KAAK,CAAC,OAAO,IAAI,MAAM,EAAE,CAAC;IACjF,CAAC,CAAC;SACD,IAAI,CAAC,IAAI,CAAC,CAAC;AAChB,CAAC"}

package/dist/conformance/src/integrity/canonicalize.d.ts

@@ -0,0 +1,25 @@
+import { CANONICALIZATION_RFC8785 } from "./types.js";
+/**
+ * Deepest structure accepted for canonicalization. Canonicalization is
+ * recursive, so an arbitrarily deep document would exhaust the stack; audit
+ * events are shallow and this bound is far above any realistic event.
+ */
+export declare const MAX_JSON_DEPTH = 200;
+export declare class CanonicalizationError extends Error {
+    constructor(message: string);
+}
+/**
+ * Rejects anything that is not a value `JSON.parse` could have produced.
+ *
+ * The pointer in the error identifies *where* the problem is, never what the
+ * value was, so that a malformed event cannot leak its content through an error
+ * message.
+ */
+export declare function assertJsonValue(value: unknown, pointer?: string, depth?: number): void;
+/** Returns the RFC 8785 canonical form of a JSON value. */
+export declare function canonicalize(value: unknown): string;
+/** Returns the UTF-8 encoding of the RFC 8785 canonical form. */
+export declare function canonicalBytes(value: unknown): Buffer;
+/** True when this verifier implements the declared canonicalization. */
+export declare function isSupportedCanonicalization(identifier: string): boolean;
+export { CANONICALIZATION_RFC8785 };

package/dist/conformance/src/integrity/canonicalize.js

@@ -0,0 +1,100 @@
+/**
+ * RFC 8785 JSON Canonicalization Scheme.
+ *
+ * Canonicalization is delegated to the `canonicalize` package (Apache-2.0, no
+ * dependencies), which implements the scheme by sorting object keys with the
+ * ECMAScript default string comparison — UTF-16 code unit order, as RFC 8785
+ * §3.2.3 requires — and serialising primitives with `JSON.stringify`, whose
+ * number and string handling is the behaviour RFC 8785 §3.2.2.2 and §3.2.2.3
+ * are defined against.
+ *
+ * The guard in this module exists because that package is permissive with
+ * values JSON cannot represent: it maps `undefined` inside an array to `null`,
+ * drops `undefined` object members, and calls `toJSON` on anything that has it.
+ * Silently reinterpreting an input would produce a digest over something other
+ * than what the caller passed, so those inputs are rejected instead.
+ */
+import canonicalizeValue from "canonicalize";
+import { CANONICALIZATION_RFC8785, SUPPORTED_CANONICALIZATIONS } from "./types.js";
+/**
+ * Deepest structure accepted for canonicalization. Canonicalization is
+ * recursive, so an arbitrarily deep document would exhaust the stack; audit
+ * events are shallow and this bound is far above any realistic event.
+ */
+export const MAX_JSON_DEPTH = 200;
+export class CanonicalizationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "CanonicalizationError";
+    }
+}
+function describePointer(pointer) {
+    return pointer === "" ? "the document root" : pointer;
+}
+function isPlainObject(value) {
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+/**
+ * Rejects anything that is not a value `JSON.parse` could have produced.
+ *
+ * The pointer in the error identifies *where* the problem is, never what the
+ * value was, so that a malformed event cannot leak its content through an error
+ * message.
+ */
+export function assertJsonValue(value, pointer = "", depth = 0) {
+    if (depth > MAX_JSON_DEPTH) {
+        throw new CanonicalizationError(`structure is nested more than ${MAX_JSON_DEPTH} levels deep at ${describePointer(pointer)}`);
+    }
+    if (value === null) {
+        return;
+    }
+    switch (typeof value) {
+        case "boolean":
+        case "string":
+            return;
+        case "number":
+            if (!Number.isFinite(value)) {
+                throw new CanonicalizationError(`number at ${describePointer(pointer)} is not finite and cannot be canonicalized`);
+            }
+            return;
+        case "object":
+            break;
+        default:
+            throw new CanonicalizationError(`value at ${describePointer(pointer)} has type "${typeof value}", which JSON cannot represent`);
+    }
+    if (Array.isArray(value)) {
+        for (const [index, item] of value.entries()) {
+            assertJsonValue(item, `${pointer}/${index}`, depth + 1);
+        }
+        return;
+    }
+    if (!isPlainObject(value)) {
+        throw new CanonicalizationError(`value at ${describePointer(pointer)} is not a plain JSON object`);
+    }
+    for (const [key, member] of Object.entries(value)) {
+        if (member === undefined) {
+            throw new CanonicalizationError(`member "${key}" at ${describePointer(pointer)} is undefined, which JSON cannot represent`);
+        }
+        assertJsonValue(member, `${pointer}/${key.replaceAll("~", "~0").replaceAll("/", "~1")}`, depth + 1);
+    }
+}
+/** Returns the RFC 8785 canonical form of a JSON value. */
+export function canonicalize(value) {
+    assertJsonValue(value);
+    const canonical = canonicalizeValue(value);
+    if (typeof canonical !== "string") {
+        throw new CanonicalizationError("value could not be canonicalized");
+    }
+    return canonical;
+}
+/** Returns the UTF-8 encoding of the RFC 8785 canonical form. */
+export function canonicalBytes(value) {
+    return Buffer.from(canonicalize(value), "utf8");
+}
+/** True when this verifier implements the declared canonicalization. */
+export function isSupportedCanonicalization(identifier) {
+    return SUPPORTED_CANONICALIZATIONS.includes(identifier);
+}
+export { CANONICALIZATION_RFC8785 };
+//# sourceMappingURL=canonicalize.js.map

package/dist/conformance/src/integrity/canonicalize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonicalize.js","sourceRoot":"","sources":["../../../../conformance/src/integrity/canonicalize.ts"],"names":[],"mappings":"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"}

package/dist/conformance/src/integrity/digest.d.ts

@@ -0,0 +1,54 @@
+import { SUPPORTED_HASH_ALGORITHMS, type SupportedHashAlgorithm } from "./types.js";
+/**
+ * True when this verifier implements the declared algorithm. Matching is
+ * case-sensitive: `sha256` is not `SHA-256`, and reinterpreting it would mean
+ * guessing at what a producer meant.
+ */
+export declare function isSupportedHashAlgorithm(algorithm: string): algorithm is SupportedHashAlgorithm;
+/** Digest length in bytes for a supported algorithm. */
+export declare function digestByteLength(algorithm: SupportedHashAlgorithm): number;
+/** True when a value is a well-formed lowercase hexadecimal digest. */
+export declare function isHexDigest(value: unknown): value is string;
+/**
+ * Builds the digest input: a deep clone of the event with the self-referential
+ * integrity members removed.
+ *
+ * Exactly two JSON Pointers are removed, `/integrity/hash` and
+ * `/integrity/signature`. No other member is removed and no empty container is
+ * pruned, so an `integrity` object left with no members is serialised as `{}`.
+ * That rule is arbitrary but it must be fixed, because a producer that pruned
+ * it and a verifier that did not would compute different digests.
+ *
+ * The input event is never mutated.
+ */
+export declare function buildDigestInput(event: unknown): unknown;
+/** Returns the RFC 8785 canonical form of the digest input, for diagnostics and tests. */
+export declare function canonicalDigestInput(event: unknown): string;
+/**
+ * Calculates an event's digest and returns it as lowercase hexadecimal.
+ *
+ * Throws for an algorithm this verifier does not implement; callers that need
+ * to report rather than throw should check `isSupportedHashAlgorithm` first.
+ */
+export declare function calculateDigest(event: unknown, algorithm: string): string;
+/**
+ * Returns a copy of an event with `integrity.hash` set to its calculated
+ * digest.
+ *
+ * The event must already declare `integrity.canonicalization` and
+ * `integrity.hashAlgorithm`, because both are part of the digest input: a
+ * producer that let the tooling choose them would be sealing a claim it never
+ * made. This is a producer-side convenience for tests, fixtures and future
+ * libraries; it performs no signing and touches no key material.
+ */
+export declare function sealEvent<T>(event: T): T;
+/**
+ * Compares two digests as bytes, in constant time for equal-length inputs.
+ *
+ * A digest is not a secret, so this is defence in depth rather than a
+ * requirement; what matters more is that a malformed value is rejected instead
+ * of being coerced. `Buffer.from(value, "hex")` truncates silently on invalid
+ * input, so both values are checked against the accepted encoding first.
+ */
+export declare function digestsEqual(left: string, right: string): boolean;
+export { SUPPORTED_HASH_ALGORITHMS, type SupportedHashAlgorithm };

package/dist/conformance/src/integrity/digest.js

@@ -0,0 +1,126 @@
+/**
+ * Event digest calculation and comparison.
+ *
+ * The procedure implemented here is normative and is specified in
+ * specification/integrity.md §4. It is deterministic: the same event produces
+ * the same digest in any conforming implementation, in any language.
+ */
+import { createHash, timingSafeEqual } from "node:crypto";
+import { canonicalBytes, canonicalize } from "./canonicalize.js";
+import { DIGEST_BYTE_LENGTHS, DIGEST_EXCLUDED_POINTERS, SUPPORTED_HASH_ALGORITHMS, } from "./types.js";
+/** Lowercase hexadecimal, an even number of digits. The only accepted digest encoding. */
+const HEX_DIGEST = /^([0-9a-f]{2})+$/;
+/** Node's digest name for each normative OpenAuditModel algorithm identifier. */
+const NODE_HASH_NAMES = {
+    "SHA-256": "sha256",
+    "SHA-384": "sha384",
+    "SHA-512": "sha512",
+};
+/**
+ * True when this verifier implements the declared algorithm. Matching is
+ * case-sensitive: `sha256` is not `SHA-256`, and reinterpreting it would mean
+ * guessing at what a producer meant.
+ */
+export function isSupportedHashAlgorithm(algorithm) {
+    return SUPPORTED_HASH_ALGORITHMS.includes(algorithm);
+}
+/** Digest length in bytes for a supported algorithm. */
+export function digestByteLength(algorithm) {
+    return DIGEST_BYTE_LENGTHS[algorithm];
+}
+/** True when a value is a well-formed lowercase hexadecimal digest. */
+export function isHexDigest(value) {
+    return typeof value === "string" && HEX_DIGEST.test(value);
+}
+/**
+ * Builds the digest input: a deep clone of the event with the self-referential
+ * integrity members removed.
+ *
+ * Exactly two JSON Pointers are removed, `/integrity/hash` and
+ * `/integrity/signature`. No other member is removed and no empty container is
+ * pruned, so an `integrity` object left with no members is serialised as `{}`.
+ * That rule is arbitrary but it must be fixed, because a producer that pruned
+ * it and a verifier that did not would compute different digests.
+ *
+ * The input event is never mutated.
+ */
+export function buildDigestInput(event) {
+    const clone = structuredClone(event);
+    if (clone !== null && typeof clone === "object" && !Array.isArray(clone)) {
+        const record = clone;
+        const integrity = record["integrity"];
+        if (integrity !== null && typeof integrity === "object" && !Array.isArray(integrity)) {
+            const integrityRecord = integrity;
+            for (const pointer of DIGEST_EXCLUDED_POINTERS) {
+                const member = pointer.slice("/integrity/".length);
+                delete integrityRecord[member];
+            }
+        }
+    }
+    return clone;
+}
+/** Returns the RFC 8785 canonical form of the digest input, for diagnostics and tests. */
+export function canonicalDigestInput(event) {
+    return canonicalize(buildDigestInput(event));
+}
+/**
+ * Calculates an event's digest and returns it as lowercase hexadecimal.
+ *
+ * Throws for an algorithm this verifier does not implement; callers that need
+ * to report rather than throw should check `isSupportedHashAlgorithm` first.
+ */
+export function calculateDigest(event, algorithm) {
+    if (!isSupportedHashAlgorithm(algorithm)) {
+        throw new Error(`unsupported hash algorithm "${algorithm}"; this verifier implements ${SUPPORTED_HASH_ALGORITHMS.join(", ")}`);
+    }
+    const bytes = canonicalBytes(buildDigestInput(event));
+    return createHash(NODE_HASH_NAMES[algorithm]).update(bytes).digest("hex");
+}
+/**
+ * Returns a copy of an event with `integrity.hash` set to its calculated
+ * digest.
+ *
+ * The event must already declare `integrity.canonicalization` and
+ * `integrity.hashAlgorithm`, because both are part of the digest input: a
+ * producer that let the tooling choose them would be sealing a claim it never
+ * made. This is a producer-side convenience for tests, fixtures and future
+ * libraries; it performs no signing and touches no key material.
+ */
+export function sealEvent(event) {
+    const integrity = event?.["integrity"];
+    if (integrity === null || typeof integrity !== "object" || Array.isArray(integrity)) {
+        throw new Error("cannot seal an event that declares no integrity object");
+    }
+    const record = integrity;
+    const canonicalization = record["canonicalization"];
+    const algorithm = record["hashAlgorithm"];
+    if (typeof canonicalization !== "string") {
+        throw new Error("cannot seal an event that declares no integrity.canonicalization");
+    }
+    if (typeof algorithm !== "string") {
+        throw new Error("cannot seal an event that declares no integrity.hashAlgorithm");
+    }
+    const hash = calculateDigest(event, algorithm);
+    return { ...event, integrity: { ...record, hash } };
+}
+/**
+ * Compares two digests as bytes, in constant time for equal-length inputs.
+ *
+ * A digest is not a secret, so this is defence in depth rather than a
+ * requirement; what matters more is that a malformed value is rejected instead
+ * of being coerced. `Buffer.from(value, "hex")` truncates silently on invalid
+ * input, so both values are checked against the accepted encoding first.
+ */
+export function digestsEqual(left, right) {
+    if (!isHexDigest(left) || !isHexDigest(right)) {
+        return false;
+    }
+    const leftBytes = Buffer.from(left, "hex");
+    const rightBytes = Buffer.from(right, "hex");
+    if (leftBytes.length !== rightBytes.length) {
+        return false;
+    }
+    return timingSafeEqual(leftBytes, rightBytes);
+}
+export { SUPPORTED_HASH_ALGORITHMS };
+//# sourceMappingURL=digest.js.map

package/dist/conformance/src/integrity/digest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"digest.js","sourceRoot":"","sources":["../../../../conformance/src/integrity/digest.ts"],"names":[],"mappings":"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"}

package/dist/conformance/src/integrity/types.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Shared types and constants for tamper-evidence verification.
+ *
+ * The tooling detects specific integrity failures. It does not prevent deletion
+ * or modification, and it makes no claim that an event is immutable,
+ * tamper-proof, legally binding or non-repudiable.
+ */
+/** Canonicalization identifier the v0.1 verifier implements: RFC 8785 JCS. */
+export declare const CANONICALIZATION_RFC8785 = "RFC8785";
+/** Canonicalization identifiers this verifier can execute. Matching is case-sensitive. */
+export declare const SUPPORTED_CANONICALIZATIONS: readonly ["RFC8785"];
+/**
+ * Hash algorithms this verifier can execute, as normative identifiers.
+ *
+ * The schema keeps `integrity.hashAlgorithm` an open vocabulary so that new
+ * algorithms can be adopted without a specification change. An identifier the
+ * schema accepts is therefore not necessarily one this verifier implements: an
+ * event declaring an algorithm outside this list is reported as
+ * `unsupported-algorithm` rather than silently treated as verified.
+ */
+export declare const SUPPORTED_HASH_ALGORITHMS: readonly ["SHA-256", "SHA-384", "SHA-512"];
+export type SupportedHashAlgorithm = (typeof SUPPORTED_HASH_ALGORITHMS)[number];
+/** Digest length in bytes for each supported algorithm. */
+export declare const DIGEST_BYTE_LENGTHS: Readonly<Record<SupportedHashAlgorithm, number>>;
+/**
+ * JSON Pointers removed from an event before its digest is calculated.
+ *
+ * Everything else, including `sequence`, `integrity.previousHash`,
+ * `integrity.chainId`, `integrity.batchId`, `integrity.hashAlgorithm` and
+ * `integrity.canonicalization`, is part of the digest input.
+ */
+export declare const DIGEST_EXCLUDED_POINTERS: readonly ["/integrity/hash", "/integrity/signature"];
+/** Why a single event failed verification. */
+export type EventFindingKind = "schema-invalid" | "integrity-missing" | "hash-missing" | "hash-algorithm-missing" | "canonicalization-missing" | "unsupported-canonicalization" | "unsupported-algorithm" | "malformed-hash" | "digest-length-mismatch" | "hash-mismatch" | "canonicalization-failed";
+/** Why a chain failed verification. */
+export type ChainFindingKind = "chain-id-missing" | "sequence-missing" | "duplicate-sequence" | "previous-hash-missing" | "broken-link" | "algorithm-mismatch";
+export type FindingKind = EventFindingKind | ChainFindingKind;
+/** A single reason verification did not succeed. */
+export interface Finding {
+    readonly kind: FindingKind;
+    /** One line, safe to print. Never contains event content. */
+    readonly message: string;
+    /** Ordered detail lines, such as the declared and calculated digests. */
+    readonly detail?: readonly string[];
+    /** Where the problem was found, when it applies to one event. */
+    readonly label?: string;
+}
+/** An informational observation that does not by itself fail verification. */
+export interface Note {
+    readonly message: string;
+    readonly detail?: readonly string[];
+}
+/** A check that passed, reported so that a successful run says what it proved. */
+export interface PassedCheck {
+    readonly message: string;
+}
+/** Outcome of verifying one event's own digest. */
+export interface EventVerificationResult {
+    readonly label: string;
+    readonly verified: boolean;
+    readonly checks: readonly PassedCheck[];
+    readonly findings: readonly Finding[];
+    readonly canonicalization?: string;
+    readonly hashAlgorithm?: string;
+    readonly declaredHash?: string;
+    readonly calculatedHash?: string;
+}
+/** Outcome of verifying one chain. */
+export interface ChainVerificationResult {
+    readonly chainId: string;
+    readonly eventCount: number;
+    readonly firstSequence?: number;
+    readonly lastSequence?: number;
+    readonly intact: boolean;
+    readonly checks: readonly PassedCheck[];
+    readonly findings: readonly Finding[];
+    readonly notes: readonly Note[];
+}
+/** Outcome of verifying every chain in a supplied set of events. */
+export interface ChainReport {
+    readonly chains: readonly ChainVerificationResult[];
+    /** Events that could not be assigned to a chain at all. */
+    readonly unassigned: readonly Finding[];
+    readonly eventCount: number;
+    readonly intact: boolean;
+}

package/dist/conformance/src/integrity/types.js

@@ -0,0 +1,36 @@
+/**
+ * Shared types and constants for tamper-evidence verification.
+ *
+ * The tooling detects specific integrity failures. It does not prevent deletion
+ * or modification, and it makes no claim that an event is immutable,
+ * tamper-proof, legally binding or non-repudiable.
+ */
+/** Canonicalization identifier the v0.1 verifier implements: RFC 8785 JCS. */
+export const CANONICALIZATION_RFC8785 = "RFC8785";
+/** Canonicalization identifiers this verifier can execute. Matching is case-sensitive. */
+export const SUPPORTED_CANONICALIZATIONS = [CANONICALIZATION_RFC8785];
+/**
+ * Hash algorithms this verifier can execute, as normative identifiers.
+ *
+ * The schema keeps `integrity.hashAlgorithm` an open vocabulary so that new
+ * algorithms can be adopted without a specification change. An identifier the
+ * schema accepts is therefore not necessarily one this verifier implements: an
+ * event declaring an algorithm outside this list is reported as
+ * `unsupported-algorithm` rather than silently treated as verified.
+ */
+export const SUPPORTED_HASH_ALGORITHMS = ["SHA-256", "SHA-384", "SHA-512"];
+/** Digest length in bytes for each supported algorithm. */
+export const DIGEST_BYTE_LENGTHS = {
+    "SHA-256": 32,
+    "SHA-384": 48,
+    "SHA-512": 64,
+};
+/**
+ * JSON Pointers removed from an event before its digest is calculated.
+ *
+ * Everything else, including `sequence`, `integrity.previousHash`,
+ * `integrity.chainId`, `integrity.batchId`, `integrity.hashAlgorithm` and
+ * `integrity.canonicalization`, is part of the digest input.
+ */
+export const DIGEST_EXCLUDED_POINTERS = ["/integrity/hash", "/integrity/signature"];
+//# sourceMappingURL=types.js.map

package/dist/conformance/src/integrity/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../conformance/src/integrity/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,8EAA8E;AAC9E,MAAM,CAAC,MAAM,wBAAwB,GAAG,SAAS,CAAC;AAElD,0FAA0F;AAC1F,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAAC,wBAAwB,CAAU,CAAC;AAE/E;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,CAAU,CAAC;AAIpF,2DAA2D;AAC3D,MAAM,CAAC,MAAM,mBAAmB,GAAqD;IACnF,SAAS,EAAE,EAAE;IACb,SAAS,EAAE,EAAE;IACb,SAAS,EAAE,EAAE;CACd,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,iBAAiB,EAAE,sBAAsB,CAAU,CAAC"}

package/dist/conformance/src/integrity/verify-chain.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Verification of previous-hash chains.
+ *
+ * Chain verification proves that the *supplied* set of events is internally
+ * consistent. It cannot prove that the supplied set is complete: an attacker
+ * who removes the tail of a chain, or who never let an event be produced,
+ * leaves nothing for a verifier to find. See specification/integrity.md §8.
+ */
+import type { EventValidator } from "../validate-core.js";
+import type { ChainReport } from "./types.js";
+/** One event offered for chain verification. */
+export interface ChainEventInput {
+    readonly label: string;
+    readonly event: unknown;
+}
+/**
+ * Verifies every chain present in a set of events.
+ *
+ * Events are grouped by `integrity.chainId`; a set containing several chains is
+ * verified as several independent chains, which is the intended model — a
+ * single global chain is never required.
+ */
+export declare function verifyChains(inputs: readonly ChainEventInput[], validator: EventValidator): ChainReport;