@openplanr/protocol 0.2.0

package/schemas/v2.0.0/operating-work-change-set.schema.json

@@ -0,0 +1,89 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://openplanr.dev/schemas/v2.0.0/operating-work-change-set.schema.json",
+  "x-openplanr-contract": { "id": "operating-work-change-set", "version": "2.0.0" },
+  "title": "OpenPlanr Operate 2.0 validated persistent-work change set",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["kind", "schemaVersion", "protocolVersion", "cycleId", "scopeId", "domainId", "domainVersion", "findings", "decisions", "actions"],
+  "properties": {
+    "kind": { "const": "operating-work-change-set" },
+    "schemaVersion": { "const": "1.0.0" },
+    "protocolVersion": { "const": "2.0.0" },
+    "cycleId": { "$ref": "#/$defs/cycleId" },
+    "scopeId": { "$ref": "#/$defs/nonPlaceholder" },
+    "domainId": { "$ref": "#/$defs/nonPlaceholder" },
+    "domainVersion": { "allOf": [{ "$ref": "#/$defs/nonPlaceholder" }, { "maxLength": 64 }] },
+    "findings": { "type": "array", "items": { "$ref": "#/$defs/findingDraft" } },
+    "decisions": { "type": "array", "items": { "$ref": "#/$defs/decisionDraft" } },
+    "actions": { "type": "array", "items": { "$ref": "#/$defs/actionDraft" } }
+  },
+  "$defs": {
+    "actionDraft": {
+      "type": "object", "additionalProperties": false,
+      "required": ["draftRef", "title", "ownerActorId", "accountabilityDisposition", "sourceDecisionDraftRef", "sourceFindingDraftRefs", "dependsOnActionDraftRefs", "objectiveId", "expectedResult", "metricId", "baseline", "target", "verificationWindow", "verificationPlanId"],
+      "properties": {
+        "draftRef": { "$ref": "#/$defs/draftRef" },
+        "title": { "$ref": "#/$defs/title" },
+        "ownerActorId": { "type": ["string", "null"], "minLength": 1, "maxLength": 128 },
+        "accountabilityDisposition": { "type": ["string", "null"], "enum": [null, "unowned", "blocked"] },
+        "sourceDecisionDraftRef": { "type": ["string", "null"], "pattern": "^draft_[A-Za-z0-9][A-Za-z0-9._-]{7,127}$" },
+        "sourceFindingDraftRefs": { "type": "array", "uniqueItems": true, "items": { "$ref": "#/$defs/draftRef" } },
+        "dependsOnActionDraftRefs": { "type": "array", "uniqueItems": true, "items": { "$ref": "#/$defs/draftRef" } },
+        "objectiveId": { "$ref": "#/$defs/objectiveId" },
+        "expectedResult": { "$ref": "#/$defs/nonBlankText" },
+        "metricId": { "$ref": "#/$defs/metricId" },
+        "baseline": { "type": "number" },
+        "target": { "type": "number" },
+        "verificationWindow": { "$ref": "#/$defs/nonBlankText" },
+        "verificationPlanId": { "$ref": "#/$defs/verificationPlanId" }
+      },
+      "allOf": [
+        { "if": { "properties": { "ownerActorId": { "type": "null" } } }, "then": { "properties": { "accountabilityDisposition": { "type": "string", "enum": ["unowned", "blocked"] } } } },
+        { "if": { "properties": { "ownerActorId": { "type": "string" } } }, "then": { "properties": { "accountabilityDisposition": { "const": null } } } }
+      ]
+    },
+    "cycleId": { "type": "string", "pattern": "^cyc_[A-Za-z0-9][A-Za-z0-9._-]{7,127}$" },
+    "decisionDraft": {
+      "type": "object", "additionalProperties": false,
+      "required": ["draftRef", "title", "question", "rationale", "evidenceRefIds", "alternatives", "confidence", "assumptionIds", "expectedUpside", "expectedDownside", "dissent", "reopenConditions", "revisitConditions", "ownerActorId", "revisitAt"],
+      "properties": {
+        "draftRef": { "$ref": "#/$defs/draftRef" },
+        "title": { "$ref": "#/$defs/title" },
+        "question": { "$ref": "#/$defs/nonBlankText" },
+        "rationale": { "$ref": "#/$defs/nonBlankText" },
+        "evidenceRefIds": { "type": "array", "minItems": 1, "uniqueItems": true, "items": { "type": "string", "pattern": "^evr_[A-Za-z0-9][A-Za-z0-9._-]{7,127}$" } },
+        "alternatives": { "type": "array", "minItems": 1, "items": { "$ref": "#/$defs/nonBlankText" } },
+        "confidence": { "type": "number", "minimum": 0, "maximum": 1 },
+        "assumptionIds": { "type": "array", "uniqueItems": true, "items": { "type": "string", "pattern": "^asm_[A-Za-z0-9][A-Za-z0-9._-]{7,127}$" } },
+        "expectedUpside": { "$ref": "#/$defs/nonBlankText" },
+        "expectedDownside": { "$ref": "#/$defs/nonBlankText" },
+        "dissent": { "type": "array", "items": { "$ref": "#/$defs/nonBlankText" } },
+        "reopenConditions": { "type": "array", "minItems": 1, "items": { "$ref": "#/$defs/nonBlankText" } },
+        "revisitConditions": { "type": "array", "minItems": 1, "items": { "$ref": "#/$defs/nonBlankText" } },
+        "ownerActorId": { "$ref": "#/$defs/nonPlaceholder" },
+        "revisitAt": { "type": ["string", "null"], "format": "date-time" }
+      }
+    },
+    "draftRef": { "type": "string", "pattern": "^draft_[A-Za-z0-9][A-Za-z0-9._-]{7,127}$" },
+    "findingDraft": {
+      "type": "object", "additionalProperties": false,
+      "required": ["draftRef", "title", "statement", "state", "ownerActorId", "revisitAt"],
+      "properties": {
+        "draftRef": { "$ref": "#/$defs/draftRef" },
+        "title": { "$ref": "#/$defs/title" },
+        "statement": { "$ref": "#/$defs/nonBlankText" },
+        "state": { "type": "string", "enum": ["open", "deferred"] },
+        "ownerActorId": { "type": ["string", "null"], "minLength": 1, "maxLength": 128 },
+        "revisitAt": { "type": ["string", "null"], "format": "date-time" }
+      },
+      "allOf": [{ "if": { "properties": { "state": { "const": "deferred" } } }, "then": { "anyOf": [{ "properties": { "ownerActorId": { "type": "string" } } }, { "properties": { "revisitAt": { "type": "string", "format": "date-time" } } }] } }]
+    },
+    "metricId": { "type": "string", "pattern": "^met_[A-Za-z0-9][A-Za-z0-9._-]{7,127}$" },
+    "nonBlankText": { "type": "string", "minLength": 1, "maxLength": 4096, "pattern": "^.*\\S.*$" },
+    "nonPlaceholder": { "type": "string", "minLength": 1, "maxLength": 128, "not": { "pattern": "(?:<[^>]+>|\\{\\{[^}]+\\}\\})" } },
+    "objectiveId": { "type": "string", "pattern": "^obj_[A-Za-z0-9][A-Za-z0-9._-]{7,127}$" },
+    "title": { "type": "string", "minLength": 1, "maxLength": 256, "pattern": "^\\S(?:[\\s\\S]*\\S)?$", "not": { "pattern": "(?:<[^>]+>|\\{\\{[^}]+\\}\\})" } },
+    "verificationPlanId": { "type": "string", "pattern": "^vfy_[A-Za-z0-9][A-Za-z0-9._-]{7,127}$" }
+  }
+}

package/schemas/v2.0.0/operating-work-ledger.schema.json

@@ -0,0 +1,40 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://openplanr.dev/schemas/v2.0.0/operating-work-ledger.schema.json",
+  "x-openplanr-contract": { "id": "operating-work-ledger", "version": "2.0.0" },
+  "title": "OpenPlanr Operate 2.0 rebuildable persistent-work ledger",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["kind", "schemaVersion", "protocolVersion", "scopeId", "domainId", "domainVersion", "generatedAt", "findings", "decisions", "actions", "cycleLinks"],
+  "properties": {
+    "kind": { "const": "operating-work-ledger" },
+    "schemaVersion": { "const": "1.0.0" },
+    "protocolVersion": { "const": "2.0.0" },
+    "scopeId": { "$ref": "#/$defs/nonPlaceholder" },
+    "domainId": { "$ref": "#/$defs/nonPlaceholder" },
+    "domainVersion": { "allOf": [{ "$ref": "#/$defs/nonPlaceholder" }, { "maxLength": 64 }] },
+    "generatedAt": { "type": "string", "format": "date-time" },
+    "findings": { "type": "array", "items": { "$ref": "operating-finding.schema.json" } },
+    "decisions": { "type": "array", "items": { "$ref": "operating-decision.schema.json" } },
+    "actions": { "type": "array", "items": { "$ref": "operating-action.schema.json" } },
+    "cycleLinks": { "type": "array", "items": { "$ref": "#/$defs/cycleLink" } }
+  },
+  "$defs": {
+    "cycleLink": {
+      "type": "object", "additionalProperties": false,
+      "required": ["entityKind", "entityId", "cycleId", "relation"],
+      "properties": {
+        "entityKind": { "type": "string", "enum": ["finding", "decision", "action"] },
+        "entityId": { "type": "string", "pattern": "^(?:fnd|dec|act)_[A-Za-z0-9][A-Za-z0-9._-]{7,127}$" },
+        "cycleId": { "type": "string", "pattern": "^cyc_[A-Za-z0-9][A-Za-z0-9._-]{7,127}$" },
+        "relation": { "type": "string", "enum": ["source", "touched", "carried-forward"] }
+      },
+      "oneOf": [
+        { "properties": { "entityKind": { "const": "finding" }, "entityId": { "pattern": "^fnd_[A-Za-z0-9][A-Za-z0-9._-]{7,127}$" } } },
+        { "properties": { "entityKind": { "const": "decision" }, "entityId": { "pattern": "^dec_[A-Za-z0-9][A-Za-z0-9._-]{7,127}$" } } },
+        { "properties": { "entityKind": { "const": "action" }, "entityId": { "pattern": "^act_[A-Za-z0-9][A-Za-z0-9._-]{7,127}$" } } }
+      ]
+    },
+    "nonPlaceholder": { "type": "string", "minLength": 1, "maxLength": 128, "not": { "pattern": "(?:<[^>]+>|\\{\\{[^}]+\\}\\})" } }
+  }
+}

package/schemas/v2.0.0/software-operating-snapshot-projection.schema.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://openplanr.dev/schemas/v2.0.0/software-operating-snapshot-projection.schema.json",
+  "x-openplanr-contract": { "id": "software-operating-snapshot-projection", "version": "1.0.0" },
+  "title": "OpenPlanr public software operating snapshot projection",
+  "description": "The exact public identity software-operating-snapshot-projection@1.0.0. It is a rebuildable view over the domain-neutral state, not a repository-specific kernel field.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["kind", "schemaVersion", "protocolVersion", "projectionId", "scopeId", "domainId", "domainVersion", "domainContract", "snapshotId", "stateId", "sourceArtifactIds", "derivedAt"],
+  "properties": {
+    "kind": { "const": "software-operating-snapshot-projection" }, "schemaVersion": { "const": "1.0.0" }, "protocolVersion": { "const": "2.0.0" }, "projectionId": { "$ref": "#/$defs/projectionId" }, "scopeId": { "$ref": "#/$defs/id" }, "domainId": { "const": "software" }, "domainVersion": { "$ref": "#/$defs/version" }, "domainContract": { "$ref": "#/$defs/domainContract" }, "snapshotId": { "$ref": "#/$defs/snapshotId" }, "stateId": { "$ref": "#/$defs/stateId" }, "sourceArtifactIds": { "type": "array", "uniqueItems": true, "items": { "$ref": "#/$defs/artifactId" } }, "derivedAt": { "type": "string", "format": "date-time" }
+  },
+  "$defs": { "artifactId": { "type": "string", "pattern": "^art_[A-Za-z0-9][A-Za-z0-9._-]{7,127}$" }, "domainContract": { "type": "object", "additionalProperties": false, "required": ["apiDomainId", "id", "version"], "properties": { "apiDomainId": { "const": "software" }, "id": { "const": "software-domain" }, "version": { "const": "1.0.0" } } }, "id": { "type": "string", "minLength": 1, "maxLength": 128 }, "projectionId": { "type": "string", "pattern": "^prj_[A-Za-z0-9][A-Za-z0-9._-]{7,127}$" }, "snapshotId": { "type": "string", "pattern": "^snp_[A-Za-z0-9][A-Za-z0-9._-]{7,127}$" }, "stateId": { "type": "string", "pattern": "^oms_[A-Za-z0-9][A-Za-z0-9._-]{7,127}$" }, "version": { "type": "string", "pattern": "^(?:0|[1-9][0-9]*)\\.(?:0|[1-9][0-9]*)\\.(?:0|[1-9][0-9]*)$" } }
+}

package/src/browser-contracts.d.mts

@@ -0,0 +1,5 @@
+export declare const PROTOCOL_V15_CONTRACTS: Readonly<Record<string, string>>;
+export declare const PROTOCOL_V16_CONTRACTS: Readonly<Record<string, string>>;
+export declare const PROTOCOL_V17_CONTRACTS: Readonly<Record<string, string>>;
+export declare const PROTOCOL_V18_CONTRACTS: Readonly<Record<string, string>>;
+export declare function protocolAssetUrl(kind: string, options?: { protocolVersion?: '1.5.0' | '1.6.0' | '1.7.0' | '1.8.0' }): URL;

package/src/browser-contracts.mjs

@@ -0,0 +1,40 @@
+import {
+  PROTOCOL_V16_CONTRACT_FILES,
+  PROTOCOL_V17_CONTRACT_FILES,
+  PROTOCOL_V18_CONTRACT_FILES,
+} from './skill-source-contracts.mjs';
+
+export const PROTOCOL_V15_CONTRACTS = Object.freeze({
+  'command-catalog': 'command-catalog.schema.json',
+  'generated-asset-manifest': 'generated-asset-manifest.schema.json',
+  'implementation-result': 'implementation-result.schema.json',
+  'migration-preservation-manifest': 'migration-preservation-manifest.schema.json',
+  'output-catalog': 'output-catalog.schema.json',
+  'output-path-catalog': 'output-path-catalog.schema.json',
+  'role-registry': 'role-registry.schema.json',
+  'rule-catalog': 'rule-catalog.schema.json',
+  'skill-catalog': 'skill-catalog.schema.json',
+  'task-kind-registry': 'task-kind-registry.schema.json',
+  'task-manifest': 'task-manifest.schema.json',
+  'task-output-manifest': 'task-output-manifest.schema.json'
+});
+
+export const PROTOCOL_V16_CONTRACTS = PROTOCOL_V16_CONTRACT_FILES;
+export const PROTOCOL_V17_CONTRACTS = PROTOCOL_V17_CONTRACT_FILES;
+export const PROTOCOL_V18_CONTRACTS = PROTOCOL_V18_CONTRACT_FILES;
+
+const PROTOCOL_CONTRACTS_BY_VERSION = Object.freeze({
+  '1.5.0': PROTOCOL_V15_CONTRACTS,
+  '1.6.0': PROTOCOL_V16_CONTRACTS,
+  '1.7.0': PROTOCOL_V17_CONTRACTS,
+  '1.8.0': PROTOCOL_V18_CONTRACTS
+});
+
+/** Resolve a packaged schema asset without a source checkout or Node-only API. */
+export function protocolAssetUrl(kind, { protocolVersion = '1.5.0' } = {}) {
+  const filename = PROTOCOL_CONTRACTS_BY_VERSION[protocolVersion]?.[kind];
+  if (!filename) {
+    throw new RangeError(`Unknown browser-safe Protocol contract: ${kind}@${protocolVersion}`);
+  }
+  return new URL(`../schemas/v${protocolVersion}/${filename}`, import.meta.url);
+}

package/src/canonical-json.d.mts

@@ -0,0 +1,5 @@
+export declare function canonicalizeJson(value: unknown): string;
+export declare function sha256Hex(value: string | Uint8Array): string;
+export declare function sha256Jcs(value: unknown): `sha256:${string}`;
+export declare function withDocumentDigest<T extends Record<string, unknown>>(value: T): T & { documentDigest: `sha256:${string}` };
+export declare function verifyDocumentDigest(value: unknown): boolean;

package/src/canonical-json.mjs

@@ -0,0 +1,142 @@
+const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+
+function assertUnicodeScalarString(value, path) {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code >= 0xd800 && code <= 0xdbff) {
+      const next = value.charCodeAt(index + 1);
+      if (!(next >= 0xdc00 && next <= 0xdfff)) {
+        throw new TypeError(`JCS cannot canonicalize a lone high surrogate at ${path}.`);
+      }
+      index += 1;
+    } else if (code >= 0xdc00 && code <= 0xdfff) {
+      throw new TypeError(`JCS cannot canonicalize a lone low surrogate at ${path}.`);
+    }
+  }
+}
+
+function serialize(value, path, seen) {
+  if (value === null) return 'null';
+  if (typeof value === 'boolean') return value ? 'true' : 'false';
+  if (typeof value === 'string') {
+    assertUnicodeScalarString(value, path);
+    return JSON.stringify(value);
+  }
+  if (typeof value === 'number') {
+    if (!Number.isFinite(value)) throw new TypeError(`JCS requires a finite number at ${path}.`);
+    return JSON.stringify(value);
+  }
+  if (typeof value !== 'object') throw new TypeError(`JCS cannot canonicalize ${typeof value} at ${path}.`);
+  if (seen.has(value)) throw new TypeError(`JCS cannot canonicalize a cycle at ${path}.`);
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      const entries = [];
+      for (let index = 0; index < value.length; index += 1) {
+        if (!hasOwn(value, index)) throw new TypeError(`JCS cannot canonicalize a sparse array at ${path}[${index}].`);
+        entries.push(serialize(value[index], `${path}[${index}]`, seen));
+      }
+      return `[${entries.join(',')}]`;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+      throw new TypeError(`JCS requires a plain JSON object at ${path}.`);
+    }
+    const entries = Object.keys(value).sort().map((key) => {
+      assertUnicodeScalarString(key, `${path} key`);
+      return `${JSON.stringify(key)}:${serialize(value[key], `${path}.${key}`, seen)}`;
+    });
+    return `{${entries.join(',')}}`;
+  } finally {
+    seen.delete(value);
+  }
+}
+
+/** RFC 8785 JSON canonicalization for already parsed JSON values. */
+export function canonicalizeJson(value) {
+  return serialize(value, '$', new Set());
+}
+
+const SHA256_K = new Uint32Array([
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+
+const rotr = (value, bits) => (value >>> bits) | (value << (32 - bits));
+
+/** Dependency-free synchronous SHA-256 for browser and Node runtimes. */
+export function sha256Hex(value) {
+  const candidate = typeof value === 'string' ? new TextEncoder().encode(value) : value;
+  if (!ArrayBuffer.isView(candidate) || Object.prototype.toString.call(candidate) !== '[object Uint8Array]') {
+    throw new TypeError('sha256Hex expects a string or Uint8Array.');
+  }
+  const input = new Uint8Array(candidate.buffer, candidate.byteOffset, candidate.byteLength);
+  const paddedLength = Math.ceil((input.length + 9) / 64) * 64;
+  const bytes = new Uint8Array(paddedLength);
+  bytes.set(input);
+  bytes[input.length] = 0x80;
+  const view = new DataView(bytes.buffer);
+  const bitLength = BigInt(input.length) * 8n;
+  view.setUint32(paddedLength - 8, Number((bitLength >> 32n) & 0xffffffffn));
+  view.setUint32(paddedLength - 4, Number(bitLength & 0xffffffffn));
+
+  let h0 = 0x6a09e667;
+  let h1 = 0xbb67ae85;
+  let h2 = 0x3c6ef372;
+  let h3 = 0xa54ff53a;
+  let h4 = 0x510e527f;
+  let h5 = 0x9b05688c;
+  let h6 = 0x1f83d9ab;
+  let h7 = 0x5be0cd19;
+  const words = new Uint32Array(64);
+
+  for (let offset = 0; offset < bytes.length; offset += 64) {
+    for (let index = 0; index < 16; index += 1) words[index] = view.getUint32(offset + index * 4);
+    for (let index = 16; index < 64; index += 1) {
+      const s0 = rotr(words[index - 15], 7) ^ rotr(words[index - 15], 18) ^ (words[index - 15] >>> 3);
+      const s1 = rotr(words[index - 2], 17) ^ rotr(words[index - 2], 19) ^ (words[index - 2] >>> 10);
+      words[index] = (words[index - 16] + s0 + words[index - 7] + s1) >>> 0;
+    }
+    let a = h0; let b = h1; let c = h2; let d = h3;
+    let e = h4; let f = h5; let g = h6; let h = h7;
+    for (let index = 0; index < 64; index += 1) {
+      const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const choice = (e & f) ^ (~e & g);
+      const temp1 = (h + s1 + choice + SHA256_K[index] + words[index]) >>> 0;
+      const s0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const majority = (a & b) ^ (a & c) ^ (b & c);
+      const temp2 = (s0 + majority) >>> 0;
+      h = g; g = f; f = e; e = (d + temp1) >>> 0;
+      d = c; c = b; b = a; a = (temp1 + temp2) >>> 0;
+    }
+    h0 = (h0 + a) >>> 0; h1 = (h1 + b) >>> 0;
+    h2 = (h2 + c) >>> 0; h3 = (h3 + d) >>> 0;
+    h4 = (h4 + e) >>> 0; h5 = (h5 + f) >>> 0;
+    h6 = (h6 + g) >>> 0; h7 = (h7 + h) >>> 0;
+  }
+  return [h0, h1, h2, h3, h4, h5, h6, h7].map((part) => part.toString(16).padStart(8, '0')).join('');
+}
+
+export function sha256Jcs(value) {
+  return `sha256:${sha256Hex(canonicalizeJson(value))}`;
+}
+
+export function withDocumentDigest(value) {
+  const copy = { ...value };
+  delete copy.documentDigest;
+  return { ...copy, documentDigest: sha256Jcs(copy) };
+}
+
+export function verifyDocumentDigest(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const copy = { ...value };
+  const actual = copy.documentDigest;
+  delete copy.documentDigest;
+  return actual === sha256Jcs(copy);
+}