@bcts/provenance-mark 1.0.0-alpha.17 → 1.0.0-alpha.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bcts/provenance-mark",
-  "version": "1.0.0-alpha.17",
+  "version": "1.0.0-alpha.18",
   "type": "module",
   "description": "Blockchain Commons Provenance Mark for TypeScript - A cryptographically-secured system for establishing and verifying the authenticity of works",
   "license": "BSD-2-Clause-Patent",
@@ -68,8 +68,8 @@
     "@bcts/eslint": "^0.1.0",
     "@bcts/tsconfig": "^0.1.0",
     "@eslint/js": "^9.39.2",
-    "@typescript-eslint/eslint-plugin": "^8.53.1",
-    "@typescript-eslint/parser": "^8.53.1",
+    "@typescript-eslint/eslint-plugin": "^8.54.0",
+    "@typescript-eslint/parser": "^8.54.0",
     "eslint": "^9.39.2",
     "ts-node": "^10.9.2",
     "tsdown": "^0.20.1",
@@ -78,11 +78,11 @@
     "vitest": "^4.0.18"
   },
   "dependencies": {
-    "@bcts/dcbor": "^1.0.0-alpha.17",
-    "@bcts/envelope": "^1.0.0-alpha.17",
-    "@bcts/rand": "^1.0.0-alpha.17",
-    "@bcts/tags": "^1.0.0-alpha.17",
-    "@bcts/uniform-resources": "^1.0.0-alpha.17",
+    "@bcts/dcbor": "^1.0.0-alpha.18",
+    "@bcts/envelope": "^1.0.0-alpha.18",
+    "@bcts/rand": "^1.0.0-alpha.18",
+    "@bcts/tags": "^1.0.0-alpha.18",
+    "@bcts/uniform-resources": "^1.0.0-alpha.18",
     "@noble/ciphers": "^2.1.1",
     "@noble/hashes": "^2.0.1"
   }

package/src/envelope.ts

@@ -8,15 +8,16 @@
  * Ported from provenance-mark-rust/src/mark.rs and generator.rs (envelope feature)
  */
 
-import { Envelope } from "@bcts/envelope";
-import { type Cbor } from "@bcts/dcbor";
+import {
+  type Envelope,
+  type FormatContext,
+  withFormatContextMut,
+  registerTagsIn as envelopeRegisterTagsIn,
+} from "@bcts/envelope";
+import { type Cbor, type SummarizerResult } from "@bcts/dcbor";
 import { PROVENANCE_MARK } from "@bcts/tags";
 import { ProvenanceMark } from "./mark.js";
 import { ProvenanceMarkGenerator } from "./generator.js";
-import { resolutionFromCbor, resolutionToNumber } from "./resolution.js";
-import { ProvenanceSeed } from "./seed.js";
-import { RngState } from "./rng-state.js";
-import { ProvenanceMarkError, ProvenanceMarkErrorType } from "./error.js";
 
 // ============================================================================
 // Tag Registration
@@ -25,40 +26,39 @@ import { ProvenanceMarkError, ProvenanceMarkErrorType } from "./error.js";
 /**
  * Registers provenance mark tags in the global format context.
  *
- * This function sets up a summarizer for the PROVENANCE_MARK tag that displays
- * provenance marks in a human-readable format.
+ * Matches Rust: register_tags()
  */
 export function registerTags(): void {
-  // In TypeScript, we don't have a global format context like Rust.
-  // Tag summarizers are typically handled at the envelope level.
-  // This function is provided for API parity.
-  registerTagsIn(globalTagsContext);
+  withFormatContextMut((context) => {
+    registerTagsIn(context);
+  });
 }
 
 /**
  * Registers provenance mark tags in a specific format context.
  *
+ * Matches Rust: register_tags_in()
+ *
  * @param context - The format context to register tags in
  */
-export function registerTagsIn(context: TagsContext): void {
-  context.setSummarizer(Number(PROVENANCE_MARK.value), (cborValue: Cbor) => {
-    const mark = ProvenanceMark.fromUntaggedCbor(cborValue);
-    return mark.toString();
-  });
+export function registerTagsIn(context: FormatContext): void {
+  envelopeRegisterTagsIn(context);
+
+  context
+    .tags()
+    .setSummarizer(
+      BigInt(PROVENANCE_MARK.value),
+      (untaggedCbor: Cbor, _flat: boolean): SummarizerResult => {
+        try {
+          const mark = ProvenanceMark.fromUntaggedCbor(untaggedCbor);
+          return { ok: true, value: mark.toString() };
+        } catch {
+          return { ok: false, error: { type: "Custom", message: "invalid provenance mark" } };
+        }
+      },
+    );
 }
 
-// Simple tags context interface for registration
-export interface TagsContext {
-  setSummarizer(tag: number, summarizer: (cbor: Cbor) => string): void;
-}
-
-// Global tags context (minimal implementation)
-const globalTagsContext: TagsContext = {
-  setSummarizer(_tag: number, _summarizer: (cbor: Cbor) => string): void {
-    // Tag summarizers are handled by the envelope package's format context
-  },
-};
-
 // ============================================================================
 // ProvenanceMark Envelope Support
 // ============================================================================
@@ -66,43 +66,26 @@ const globalTagsContext: TagsContext = {
 /**
  * Convert a ProvenanceMark to an Envelope.
  *
- * The envelope contains the tagged CBOR representation of the mark.
+ * Delegates to ProvenanceMark.intoEnvelope() — single source of truth.
  *
  * @param mark - The provenance mark to convert
  * @returns An envelope containing the mark
  */
 export function provenanceMarkToEnvelope(mark: ProvenanceMark): Envelope {
-  return Envelope.new(mark.toCborData());
+  return mark.intoEnvelope();
 }
 
 /**
  * Extract a ProvenanceMark from an Envelope.
  *
+ * Delegates to ProvenanceMark.fromEnvelope() — single source of truth.
+ *
  * @param envelope - The envelope to extract from
  * @returns The extracted provenance mark
  * @throws ProvenanceMarkError if extraction fails
  */
 export function provenanceMarkFromEnvelope(envelope: Envelope): ProvenanceMark {
-  // The envelope contains the CBOR-encoded bytes of the mark
-  // Use asByteString to extract the raw bytes, then decode
-  const bytes = envelope.asByteString();
-  if (bytes !== undefined) {
-    return ProvenanceMark.fromCborData(bytes);
-  }
-
-  // Try extracting from subject if it's a node
-  const envCase = envelope.case();
-  if (envCase.type === "node") {
-    const subject = envCase.subject;
-    const subjectBytes = subject.asByteString();
-    if (subjectBytes !== undefined) {
-      return ProvenanceMark.fromCborData(subjectBytes);
-    }
-  }
-
-  throw new ProvenanceMarkError(ProvenanceMarkErrorType.CborError, undefined, {
-    message: "Could not extract ProvenanceMark from envelope",
-  });
+  return ProvenanceMark.fromEnvelope(envelope);
 }
 
 // ============================================================================
@@ -112,121 +95,24 @@ export function provenanceMarkFromEnvelope(envelope: Envelope): ProvenanceMark {
 /**
  * Convert a ProvenanceMarkGenerator to an Envelope.
  *
- * The envelope contains structured assertions for all generator fields:
- * - type: "provenance-generator"
- * - res: The resolution
- * - seed: The seed
- * - next-seq: The next sequence number
- * - rng-state: The RNG state
+ * Delegates to ProvenanceMarkGenerator.intoEnvelope() — single source of truth.
  *
  * @param generator - The generator to convert
  * @returns An envelope containing the generator
  */
 export function provenanceMarkGeneratorToEnvelope(generator: ProvenanceMarkGenerator): Envelope {
-  // Create envelope with chain ID as subject
-  let envelope = Envelope.new(generator.chainId());
-
-  // Add type assertion (using addType() which uses IS_A KnownValue, like Rust's add_type())
-  envelope = envelope.addType("provenance-generator");
-
-  // Add resolution
-  envelope = envelope.addAssertion("res", resolutionToNumber(generator.res()));
-
-  // Add seed
-  envelope = envelope.addAssertion("seed", generator.seed().toBytes());
-
-  // Add next sequence number
-  envelope = envelope.addAssertion("next-seq", generator.nextSeq());
-
-  // Add RNG state
-  envelope = envelope.addAssertion("rng-state", generator.rngState().toBytes());
-
-  return envelope;
+  return generator.intoEnvelope();
 }
 
-// Type extension for envelope with extra methods
-type EnvelopeExt = Envelope & {
-  asByteString(): Uint8Array | undefined;
-  hasType(t: string): boolean;
-  assertionsWithPredicate(p: string): Envelope[];
-  subject(): Envelope;
-};
-
 /**
  * Extract a ProvenanceMarkGenerator from an Envelope.
  *
+ * Delegates to ProvenanceMarkGenerator.fromEnvelope() — single source of truth.
+ *
  * @param envelope - The envelope to extract from
  * @returns The extracted generator
  * @throws ProvenanceMarkError if extraction fails
  */
 export function provenanceMarkGeneratorFromEnvelope(envelope: Envelope): ProvenanceMarkGenerator {
-  const env = envelope as EnvelopeExt;
-
-  // Check type
-  if (!env.hasType("provenance-generator")) {
-    throw new ProvenanceMarkError(ProvenanceMarkErrorType.CborError, undefined, {
-      message: "Envelope is not a provenance-generator",
-    });
-  }
-
-  // Extract chain ID from subject
-  const subject = env.subject() as EnvelopeExt;
-  const chainId = subject.asByteString();
-  if (chainId === undefined) {
-    throw new ProvenanceMarkError(ProvenanceMarkErrorType.CborError, undefined, {
-      message: "Could not extract chain ID",
-    });
-  }
-
-  // Helper to extract assertion object value
-  const extractAssertion = (predicate: string): { cbor: Cbor; bytes: Uint8Array | undefined } => {
-    const assertions = env.assertionsWithPredicate(predicate);
-    if (assertions.length === 0) {
-      throw new ProvenanceMarkError(ProvenanceMarkErrorType.CborError, undefined, {
-        message: `Missing ${predicate} assertion`,
-      });
-    }
-    const assertionCase = assertions[0].case();
-    if (assertionCase.type !== "assertion") {
-      throw new ProvenanceMarkError(ProvenanceMarkErrorType.CborError, undefined, {
-        message: `Invalid ${predicate} assertion`,
-      });
-    }
-    const obj = assertionCase.assertion.object() as EnvelopeExt;
-    const objCase = obj.case();
-    if (objCase.type === "leaf") {
-      return { cbor: objCase.cbor, bytes: obj.asByteString() };
-    }
-    throw new ProvenanceMarkError(ProvenanceMarkErrorType.CborError, undefined, {
-      message: `Invalid ${predicate} value`,
-    });
-  };
-
-  // Extract resolution
-  const resValue = extractAssertion("res");
-  const res = resolutionFromCbor(resValue.cbor);
-
-  // Extract seed
-  const seedValue = extractAssertion("seed");
-  if (seedValue.bytes === undefined) {
-    throw new ProvenanceMarkError(ProvenanceMarkErrorType.CborError, undefined, {
-      message: "Invalid seed data",
-    });
-  }
-  const seed = ProvenanceSeed.fromBytes(seedValue.bytes);
-
-  // Extract next-seq
-  const seqValue = extractAssertion("next-seq");
-  const nextSeq = Number(seqValue.cbor);
-
-  // Extract rng-state
-  const rngValue = extractAssertion("rng-state");
-  if (rngValue.bytes === undefined) {
-    throw new ProvenanceMarkError(ProvenanceMarkErrorType.CborError, undefined, {
-      message: "Invalid rng-state data",
-    });
-  }
-  const rngState = RngState.fromBytes(rngValue.bytes);
-
-  return ProvenanceMarkGenerator.new(res, seed, chainId, nextSeq, rngState);
+  return ProvenanceMarkGenerator.fromEnvelope(envelope);
 }

package/src/index.ts

@@ -97,5 +97,7 @@ export {
   provenanceMarkFromEnvelope,
   provenanceMarkGeneratorToEnvelope,
   provenanceMarkGeneratorFromEnvelope,
-  type TagsContext,
 } from "./envelope.js";
+
+// Re-export FormatContext for registerTagsIn callers
+export { FormatContext } from "@bcts/envelope";

package/src/mark-info.ts

@@ -74,7 +74,7 @@ export class ProvenanceMarkInfo {
     lines.push("---");
 
     lines.push("");
-    lines.push(this._mark.date().toISOString());
+    lines.push(this._mark.date().toISOString().replace(".000Z", "Z"));
 
     lines.push("");
     lines.push(`#### ${this._ur.toString()}`);

package/src/mark.ts

@@ -14,6 +14,8 @@ import {
 import { Envelope } from "@bcts/envelope";
 
 import { ProvenanceMarkError, ProvenanceMarkErrorType } from "./error.js";
+import { validate as validateMarks } from "./validate.js";
+import type { ValidationIssue, ValidationReport } from "./validate.js";
 import {
   type ProvenanceMarkResolution,
   linkLength,
@@ -286,6 +288,42 @@ export class ProvenanceMark {
     return prefix ? `\u{1F151} ${s}` : s;
   }
 
+  /**
+   * A compact 8-letter identifier derived from the upper-case ByteWords
+   * identifier by taking the first and last letter of each ByteWords word
+   * (4 words x 2 letters = 8 letters).
+   *
+   * Example: "ABLE ACID ALSO APEX" -> "AEADAOAX"
+   * If prefix is true, prepends the provenance mark prefix character.
+   */
+  bytewordsMinimalIdentifier(prefix: boolean): string {
+    const full = encodeBytewordsIdentifier(this._hash.slice(0, 4));
+
+    const words = full.split(/\s+/);
+    let out = "";
+    if (words.length === 4) {
+      for (const w of words) {
+        if (w.length === 0) continue;
+        out += w[0].toUpperCase();
+        out += w[w.length - 1].toUpperCase();
+      }
+    }
+
+    // Conservative fallback: if the input wasn't in the expected
+    // space-separated 4-word format, remove whitespace and chunk the
+    // remaining letters.
+    if (out.length !== 8) {
+      out = "";
+      const compact = full.replace(/[^a-zA-Z]/g, "").toUpperCase();
+      for (let i = 0; i + 3 < compact.length; i += 4) {
+        out += compact[i];
+        out += compact[i + 3];
+      }
+    }
+
+    return prefix ? `\u{1F151} ${out}` : out;
+  }
+
   /**
    * Get the first four bytes of the hash as Bytemoji.
    */
@@ -309,30 +347,54 @@ export class ProvenanceMark {
 
   /**
    * Check if this mark precedes another mark, throwing on validation errors.
+   * Errors carry a structured `validationIssue` in their details, matching Rust's
+   * `Error::Validation(ValidationIssue)` pattern.
    */
   precedesOpt(next: ProvenanceMark): void {
     // `next` can't be a genesis
     if (next._seq === 0) {
-      throw new ProvenanceMarkError(ProvenanceMarkErrorType.ValidationError, undefined, {
-        message: "non-genesis mark at sequence 0",
-      });
+      const issue: ValidationIssue = { type: "NonGenesisAtZero" };
+      throw new ProvenanceMarkError(
+        ProvenanceMarkErrorType.ValidationError,
+        "non-genesis mark at sequence 0",
+        { validationIssue: issue },
+      );
     }
     if (arraysEqual(next._key, next._chainId)) {
-      throw new ProvenanceMarkError(ProvenanceMarkErrorType.ValidationError, undefined, {
-        message: "genesis mark must have key equal to chain_id",
-      });
+      const issue: ValidationIssue = { type: "InvalidGenesisKey" };
+      throw new ProvenanceMarkError(
+        ProvenanceMarkErrorType.ValidationError,
+        "genesis mark must have key equal to chain_id",
+        { validationIssue: issue },
+      );
     }
     // `next` must have the next highest sequence number
     if (this._seq !== next._seq - 1) {
-      throw new ProvenanceMarkError(ProvenanceMarkErrorType.ValidationError, undefined, {
-        message: `sequence gap: expected ${this._seq + 1}, got ${next._seq}`,
-      });
+      const issue: ValidationIssue = {
+        type: "SequenceGap",
+        expected: this._seq + 1,
+        actual: next._seq,
+      };
+      throw new ProvenanceMarkError(
+        ProvenanceMarkErrorType.ValidationError,
+        `sequence gap: expected ${this._seq + 1}, got ${next._seq}`,
+        { validationIssue: issue },
+      );
     }
     // `next` must have an equal or later date
     if (this._date > next._date) {
-      throw new ProvenanceMarkError(ProvenanceMarkErrorType.ValidationError, undefined, {
-        message: `date ordering: ${this._date.toISOString()} > ${next._date.toISOString()}`,
-      });
+      const dateStr = this._date.toISOString().replace(".000Z", "Z");
+      const nextDateStr = next._date.toISOString().replace(".000Z", "Z");
+      const issue: ValidationIssue = {
+        type: "DateOrdering",
+        previous: dateStr,
+        next: nextDateStr,
+      };
+      throw new ProvenanceMarkError(
+        ProvenanceMarkErrorType.ValidationError,
+        `date ordering: ${dateStr} > ${nextDateStr}`,
+        { validationIssue: issue },
+      );
     }
     // `next` must reveal the key that was used to generate this mark's hash
     const expectedHash = ProvenanceMark.makeHash(
@@ -345,15 +407,16 @@ export class ProvenanceMark {
       this._infoBytes,
     );
     if (!arraysEqual(this._hash, expectedHash)) {
-      throw new ProvenanceMarkError(ProvenanceMarkErrorType.ValidationError, undefined, {
-        message: "hash mismatch",
-        expected: Array.from(expectedHash)
-          .map((b) => b.toString(16).padStart(2, "0"))
-          .join(""),
-        actual: Array.from(this._hash)
-          .map((b) => b.toString(16).padStart(2, "0"))
-          .join(""),
-      });
+      const issue: ValidationIssue = {
+        type: "HashMismatch",
+        expected: bytesToHex(expectedHash),
+        actual: bytesToHex(this._hash),
+      };
+      throw new ProvenanceMarkError(
+        ProvenanceMarkErrorType.ValidationError,
+        `hash mismatch: expected ${bytesToHex(expectedHash)}, got ${bytesToHex(this._hash)}`,
+        { validationIssue: issue },
+      );
     }
   }
 
@@ -617,6 +680,20 @@ export class ProvenanceMark {
     return new ProvenanceMark(res, key, hash, chainId, seqBytes, dateBytes, infoBytes, seq, date);
   }
 
+  // ============================================================================
+  // Validation (delegate to ValidationReport)
+  // ============================================================================
+
+  /**
+   * Validate a collection of provenance marks.
+   *
+   * Matches Rust: `ProvenanceMark::validate()` which delegates to
+   * `ValidationReport::validate()`.
+   */
+  static validate(marks: ProvenanceMark[]): ValidationReport {
+    return validateMarks(marks);
+  }
+
   // ============================================================================
   // Envelope Support (EnvelopeEncodable)
   // ============================================================================
@@ -624,37 +701,27 @@ export class ProvenanceMark {
   /**
    * Convert this provenance mark to a Gordian Envelope.
    *
-   * The envelope contains the tagged CBOR representation of the mark.
-   *
-   * Note: Use provenanceMarkToEnvelope() for a standalone function alternative.
+   * Creates a leaf envelope containing the tagged CBOR representation.
+   * Matches Rust: `Envelope::new(mark.to_cbor())` which creates a CBOR leaf.
    */
   intoEnvelope(): Envelope {
-    return Envelope.new(this.toCborData());
+    return Envelope.newLeaf(this.taggedCbor());
   }
 
   /**
    * Extract a ProvenanceMark from a Gordian Envelope.
    *
+   * Matches Rust: `envelope.subject().try_leaf()?.try_into()`
+   *
    * @param envelope - The envelope to extract from
    * @returns The extracted provenance mark
    * @throws ProvenanceMarkError if extraction fails
    */
   static fromEnvelope(envelope: Envelope): ProvenanceMark {
-    // The envelope contains the CBOR-encoded bytes of the mark
-    // Use asByteString to extract the raw bytes, then decode
-    const bytes = envelope.asByteString();
-    if (bytes !== undefined) {
-      return ProvenanceMark.fromCborData(bytes);
-    }
-
-    // Try extracting from subject if it's a node
-    const envCase = envelope.case();
-    if (envCase.type === "node") {
-      const subject = envCase.subject;
-      const subjectBytes = subject.asByteString();
-      if (subjectBytes !== undefined) {
-        return ProvenanceMark.fromCborData(subjectBytes);
-      }
+    // Extract the CBOR leaf from the envelope subject, matching Rust's try_leaf()
+    const leaf = envelope.subject().asLeaf();
+    if (leaf !== undefined) {
+      return ProvenanceMark.fromTaggedCbor(leaf);
     }
 
     throw new ProvenanceMarkError(ProvenanceMarkErrorType.CborError, undefined, {

package/src/validate.ts

@@ -1,6 +1,7 @@
 // Ported from provenance-mark-rust/src/validate.rs
 
 import type { ProvenanceMark } from "./mark.js";
+import { ProvenanceMarkError } from "./error.js";
 
 /**
  * Format for validation report output.
@@ -257,23 +258,47 @@ export function formatReport(report: ValidationReport, format: ValidationReportF
  */
 function reportToJSON(report: ValidationReport): unknown {
   return {
-    marks: report.marks.map((m) => m.toUrlEncoding()),
+    marks: report.marks.map((m) => m.urString()),
     chains: report.chains.map((chain) => ({
       chain_id: hexEncode(chain.chainId),
       has_genesis: chain.hasGenesis,
-      marks: chain.marks.map((m) => m.toUrlEncoding()),
+      marks: chain.marks.map((m) => m.urString()),
       sequences: chain.sequences.map((seq) => ({
         start_seq: seq.startSeq,
         end_seq: seq.endSeq,
         marks: seq.marks.map((fm) => ({
-          mark: fm.mark.toUrlEncoding(),
-          issues: fm.issues,
+          mark: fm.mark.urString(),
+          issues: fm.issues.map(issueToJSON),
         })),
       })),
     })),
   };
 }
 
+/**
+ * Convert a ValidationIssue to JSON matching Rust's serde format.
+ *
+ * Rust uses `#[serde(tag = "type", content = "data")]` which wraps
+ * struct variant data in a `"data"` field. Unit variants have no
+ * `"data"` field.
+ */
+function issueToJSON(issue: ValidationIssue): unknown {
+  switch (issue.type) {
+    case "HashMismatch":
+      return { type: "HashMismatch", data: { expected: issue.expected, actual: issue.actual } };
+    case "SequenceGap":
+      return { type: "SequenceGap", data: { expected: issue.expected, actual: issue.actual } };
+    case "DateOrdering":
+      return { type: "DateOrdering", data: { previous: issue.previous, next: issue.next } };
+    case "KeyMismatch":
+      return { type: "KeyMismatch" };
+    case "NonGenesisAtZero":
+      return { type: "NonGenesisAtZero" };
+    case "InvalidGenesisKey":
+      return { type: "InvalidGenesisKey" };
+  }
+}
+
 /**
  * Build sequence bins for a chain.
  */
@@ -301,8 +326,14 @@ function buildSequenceBins(marks: ProvenanceMark[]): SequenceReport[] {
           sequences.push(createSequenceReport(currentSequence));
         }
 
-        // Parse the error to determine the issue type
-        const issue = parseValidationError(e, prev, mark);
+        // Extract structured issue directly from the error
+        // Matches Rust: Error::Validation(v) => v, _ => ValidationIssue::KeyMismatch
+        let issue: ValidationIssue;
+        if (e instanceof ProvenanceMarkError && e.details?.["validationIssue"] !== undefined) {
+          issue = e.details["validationIssue"] as ValidationIssue;
+        } else {
+          issue = { type: "KeyMismatch" }; // Fallback
+        }
 
         // Start new sequence with this mark, flagged with the issue
         currentSequence = [{ mark, issues: [issue] }];
@@ -318,53 +349,6 @@ function buildSequenceBins(marks: ProvenanceMark[]): SequenceReport[] {
   return sequences;
 }
 
-/**
- * Parse a validation error into a ValidationIssue.
- */
-function parseValidationError(
-  e: unknown,
-  prev: ProvenanceMark,
-  next: ProvenanceMark,
-): ValidationIssue {
-  const message = e instanceof Error ? e.message : "";
-
-  if (message !== "" && message.includes("non-genesis mark at sequence 0")) {
-    return { type: "NonGenesisAtZero" };
-  }
-  if (message !== "" && message.includes("genesis mark must have key equal to chain_id")) {
-    return { type: "InvalidGenesisKey" };
-  }
-  if (message !== "" && message.includes("sequence gap")) {
-    const seqGapRegex = /expected (\d+), got (\d+)/;
-    const match = seqGapRegex.exec(message);
-    if (match !== null) {
-      return {
-        type: "SequenceGap",
-        expected: parseInt(match[1], 10),
-        actual: parseInt(match[2], 10),
-      };
-    }
-  }
-  if (message !== "" && message.includes("date ordering")) {
-    return {
-      type: "DateOrdering",
-      previous: prev.date().toISOString(),
-      next: next.date().toISOString(),
-    };
-  }
-  if (message !== "" && message.includes("hash mismatch")) {
-    const hashRegex = /expected: (\w+), actual: (\w+)/;
-    const match = hashRegex.exec(message);
-    if (match !== null) {
-      return { type: "HashMismatch", expected: match[1], actual: match[2] };
-    }
-    return { type: "HashMismatch", expected: "", actual: "" };
-  }
-
-  // Fallback
-  return { type: "KeyMismatch" };
-}
-
 /**
  * Create a sequence report from flagged marks.
  */
@@ -379,10 +363,11 @@ function createSequenceReport(marks: FlaggedMark[]): SequenceReport {
  */
 export function validate(marks: ProvenanceMark[]): ValidationReport {
   // Deduplicate exact duplicates
+  // Matches Rust semantics: PartialEq compares (res, message())
   const seen = new Set<string>();
   const deduplicatedMarks: ProvenanceMark[] = [];
   for (const mark of marks) {
-    const key = mark.toUrlEncoding();
+    const key = `${mark.res()}:${hexEncode(mark.message())}`;
     if (!seen.has(key)) {
       seen.add(key);
       deduplicatedMarks.push(mark);