@fluxpointstudios/orynq-sdk-process-trace 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { canonicalize, sha256StringHex, bytesToHex, hexToBytes } from '@fluxpointstudios/orynq-sdk-core/utils';
+import { canonicalize, sha256StringHex, sha256Hex, bytesToHex, hexToBytes } from '@fluxpointstudios/orynq-sdk-core/utils';
 
 // src/types.ts
 var DEFAULT_EVENT_VISIBILITY = {
@@ -7,7 +7,11 @@ var DEFAULT_EVENT_VISIBILITY = {
   decision: "private",
   observation: "public",
   error: "private",
-  custom: "private"
+  custom: "private",
+  // Governance provenance is meant to be auditable by third parties.
+  "governance-attestation": "public",
+  // Tool responses may carry PII/secrets; only hashes + signature are required.
+  "tool-receipt": "private"
 };
 var HASH_DOMAIN_PREFIXES = {
   event: "poi-trace:event:v1|",
@@ -16,7 +20,11 @@ var HASH_DOMAIN_PREFIXES = {
   leaf: "poi-trace:leaf:v1|",
   node: "poi-trace:node:v1|",
   manifest: "poi-trace:manifest:v1|",
-  root: "poi-trace:root:v1|"
+  root: "poi-trace:root:v1|",
+  /** Model/data manifest commitment (pre-execution pinning). */
+  modelManifest: "poi-trace:model-manifest:v1|",
+  /** Governance-attestation signing preimage. */
+  governance: "poi-trace:governance:v1|"
 };
 var GENESIS_SEED = "genesis";
 async function computeEventHash(event) {
@@ -68,7 +76,7 @@ function constantTimeCompare(a, b) {
   }
   return result === 0;
 }
-async function computeRootHash(rollingHash, spans) {
+async function computeRootHash(rollingHash, spans, modelManifestHash) {
   const sortedSpans = [...spans].sort((a, b) => a.spanSeq - b.spanSeq);
   const spanHashes = sortedSpans.map((span) => {
     if (!span.hash) {
@@ -80,6 +88,9 @@ async function computeRootHash(rollingHash, spans) {
   if (spanHashes.length > 0) {
     input += "|" + spanHashes.join("|");
   }
+  if (modelManifestHash !== void 0 && modelManifestHash.length > 0) {
+    input += "|manifest:" + modelManifestHash;
+  }
   return sha256StringHex(input);
 }
 async function computeEventHashes(events) {
@@ -281,6 +292,108 @@ async function verifySpanInclusion(proof, span, events) {
   }
   return verifyMerkleProof(proof);
 }
+async function computeModelManifestHash(manifest) {
+  const canonical = canonicalize(manifest);
+  return sha256StringHex(HASH_DOMAIN_PREFIXES.modelManifest + canonical);
+}
+function validateModelManifest(manifest) {
+  if (typeof manifest !== "object" || manifest === null) {
+    throw new Error("ModelManifest must be an object");
+  }
+  if (typeof manifest.modelHash !== "string" || manifest.modelHash.length === 0) {
+    throw new Error("ModelManifest.modelHash is required and must be a non-empty string");
+  }
+  return manifest;
+}
+function freezeModelManifest(manifest) {
+  if (manifest.metadata) {
+    Object.freeze(manifest.metadata);
+  }
+  return Object.freeze(manifest);
+}
+async function fingerprint(parts) {
+  const joined = parts.filter((p) => typeof p === "string" && p.length > 0).join("\0");
+  return "sha256:" + await sha256StringHex("orynq:model-fingerprint:v1|" + joined);
+}
+async function resolveSystemPromptHash(systemPrompt, systemPromptHash) {
+  if (systemPromptHash !== void 0) return systemPromptHash;
+  if (systemPrompt !== void 0) {
+    return "sha256:" + await sha256StringHex("orynq:system-prompt:v1|" + systemPrompt);
+  }
+  return void 0;
+}
+function assemble(base) {
+  const m = { modelHash: base.modelHash, framework: base.framework };
+  if (base.modelId !== void 0) m.modelId = base.modelId;
+  if (base.revision !== void 0) m.revision = base.revision;
+  if (base.tokenizerHash !== void 0) m.tokenizerHash = base.tokenizerHash;
+  if (base.systemPromptHash !== void 0) m.systemPromptHash = base.systemPromptHash;
+  if (base.trainingDataManifest !== void 0) m.trainingDataManifest = base.trainingDataManifest;
+  if (base.metadata !== void 0) m.metadata = base.metadata;
+  return m;
+}
+async function manifestFromHuggingFace(opts) {
+  if (!opts.modelId) throw new Error("manifestFromHuggingFace: modelId is required");
+  const modelHash = await fingerprint(["huggingface", opts.modelId, opts.revision]);
+  const systemPromptHash = await resolveSystemPromptHash(opts.systemPrompt, opts.systemPromptHash);
+  return assemble({
+    modelHash,
+    framework: "huggingface",
+    modelId: opts.modelId,
+    revision: opts.revision,
+    tokenizerHash: opts.tokenizerHash,
+    systemPromptHash,
+    trainingDataManifest: opts.trainingDataManifest,
+    metadata: opts.metadata
+  });
+}
+async function manifestFromOpenAI(opts) {
+  if (!opts.model) throw new Error("manifestFromOpenAI: model is required");
+  const modelHash = await fingerprint(["openai", opts.model, opts.snapshotId]);
+  const systemPromptHash = await resolveSystemPromptHash(opts.systemPrompt, opts.systemPromptHash);
+  return assemble({
+    modelHash,
+    framework: "openai",
+    modelId: opts.model,
+    revision: opts.snapshotId,
+    tokenizerHash: opts.tokenizerHash,
+    systemPromptHash,
+    trainingDataManifest: opts.trainingDataManifest,
+    metadata: opts.metadata
+  });
+}
+async function manifestFromAnthropic(opts) {
+  if (!opts.model) throw new Error("manifestFromAnthropic: model is required");
+  const modelHash = await fingerprint(["anthropic", opts.model, opts.snapshotId]);
+  const systemPromptHash = await resolveSystemPromptHash(opts.systemPrompt, opts.systemPromptHash);
+  return assemble({
+    modelHash,
+    framework: "anthropic",
+    modelId: opts.model,
+    revision: opts.snapshotId,
+    tokenizerHash: opts.tokenizerHash,
+    systemPromptHash,
+    trainingDataManifest: opts.trainingDataManifest,
+    metadata: opts.metadata
+  });
+}
+async function manifestFromCheckpoint(filepath, opts = {}) {
+  if (!filepath) throw new Error("manifestFromCheckpoint: filepath is required");
+  const { readFile } = await import('fs/promises');
+  const bytes = await readFile(filepath);
+  const modelHash = "sha256:" + await sha256Hex(new Uint8Array(bytes));
+  const systemPromptHash = await resolveSystemPromptHash(opts.systemPrompt, opts.systemPromptHash);
+  return assemble({
+    modelHash,
+    framework: "checkpoint",
+    modelId: opts.modelId ?? filepath,
+    revision: opts.revision,
+    tokenizerHash: opts.tokenizerHash,
+    systemPromptHash,
+    trainingDataManifest: opts.trainingDataManifest,
+    metadata: opts.metadata
+  });
+}
 
 // src/trace-builder.ts
 async function createTrace(opts) {
@@ -310,6 +423,19 @@ async function createTrace(opts) {
       description: opts.description
     };
   }
+  const strict = opts.strict ?? false;
+  if (strict) {
+    run.strict = true;
+  }
+  if (opts.manifest !== void 0) {
+    const manifest = validateModelManifest(opts.manifest);
+    run.modelManifestHash = await computeModelManifestHash(manifest);
+    run.modelManifest = freezeModelManifest(manifest);
+  } else if (strict) {
+    throw new Error(
+      "createTrace: strict mode requires a `manifest` to be pinned before execution"
+    );
+  }
   return run;
 }
 function addSpan(run, opts) {
@@ -430,6 +556,16 @@ async function finalizeTrace(run) {
   if (isFinalized(run)) {
     throw new Error("Trace run is already finalized");
   }
+  if (run.modelManifest === void 0) {
+    if (run.strict) {
+      throw new Error(
+        "finalizeTrace: strict mode requires a model manifest pinned at createTrace() time"
+      );
+    }
+    console.warn(
+      "[orynq] finalizeTrace: no model manifest was pinned \u2014 model/data immutability is NOT proven for this trace. Pass `manifest` to createTrace() (and `strict: true` to enforce). This will become an error in v1.0."
+    );
+  }
   for (const span of run.spans) {
     if (span.status === "running") {
       await closeSpan(run, span.id, "completed");
@@ -442,7 +578,11 @@ async function finalizeTrace(run) {
   const endTime = new Date(endedAt).getTime();
   run.durationMs = endTime - startTime;
   const merkleTree = await buildSpanMerkleTree(run.spans, run.events);
-  const rootHash = await computeRootHash(run.rollingHash, run.spans);
+  const rootHash = await computeRootHash(
+    run.rollingHash,
+    run.spans,
+    run.modelManifestHash
+  );
   run.rootHash = rootHash;
   const publicView = createPublicView(run, merkleTree.rootHash);
   const bundle = {
@@ -452,6 +592,12 @@ async function finalizeTrace(run) {
     merkleRoot: merkleTree.rootHash,
     rootHash
   };
+  if (run.modelManifestHash !== void 0) {
+    bundle.modelManifestHash = run.modelManifestHash;
+  }
+  if (run.modelManifest !== void 0) {
+    bundle.modelManifest = run.modelManifest;
+  }
   return bundle;
 }
 function createPublicView(run, merkleRoot) {
@@ -493,6 +639,12 @@ function createPublicView(run, merkleRoot) {
     publicSpans,
     redactedSpanHashes
   };
+  if (run.modelManifestHash !== void 0) {
+    publicView.modelManifestHash = run.modelManifestHash;
+  }
+  if (run.modelManifest !== void 0) {
+    publicView.modelManifest = run.modelManifest;
+  }
   return publicView;
 }
 function getEventCount(run) {
@@ -515,6 +667,302 @@ function getEventsByKind(run, kind) {
     (e) => e.kind === kind
   );
 }
+
+// src/governance.ts
+function governanceAttestationPreimage(fields) {
+  const enc = new TextEncoder();
+  const domain = enc.encode(HASH_DOMAIN_PREFIXES.governance);
+  const parts = [
+    fields.runId,
+    fields.role,
+    fields.policyRef,
+    fields.decisionRef,
+    fields.signedAt
+  ].map((v) => enc.encode(v));
+  const total = domain.length + parts.reduce((n, p) => n + 4 + p.length, 0);
+  const out = new Uint8Array(total);
+  let off = 0;
+  out.set(domain, off);
+  off += domain.length;
+  for (const p of parts) {
+    out[off] = p.length >>> 24 & 255;
+    out[off + 1] = p.length >>> 16 & 255;
+    out[off + 2] = p.length >>> 8 & 255;
+    out[off + 3] = p.length & 255;
+    off += 4;
+    out.set(p, off);
+    off += p.length;
+  }
+  return out;
+}
+async function addGovernanceAttestation(run, spanId, opts) {
+  if (!opts.role) throw new Error("addGovernanceAttestation: role is required");
+  if (!opts.policyRef) throw new Error("addGovernanceAttestation: policyRef is required");
+  if (!opts.decisionRef) throw new Error("addGovernanceAttestation: decisionRef is required");
+  if (!opts.signer) throw new Error("addGovernanceAttestation: signer is required");
+  if (opts.signer.signatureScheme === "eip712" && opts.eip712 === void 0) {
+    throw new Error(
+      "addGovernanceAttestation: an `eip712` binding is required for eip712 signers"
+    );
+  }
+  const signedAt = opts.signedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const fields = {
+    role: opts.role,
+    policyRef: opts.policyRef,
+    decisionRef: opts.decisionRef,
+    signedAt,
+    runId: run.id
+  };
+  const preimage = governanceAttestationPreimage(fields);
+  const ctx = opts.eip712 ? { preimage, fields, eip712: opts.eip712 } : { preimage, fields };
+  const signature = await opts.signer.sign(ctx);
+  const event = {
+    kind: "governance-attestation",
+    visibility: opts.visibility ?? "public",
+    role: opts.role,
+    policyRef: opts.policyRef,
+    decisionRef: opts.decisionRef,
+    attestor: {
+      address: opts.signer.address,
+      signatureScheme: opts.signer.signatureScheme
+    },
+    signature,
+    signedAt,
+    ...opts.eip712 ? { eip712: opts.eip712 } : {}
+  };
+  const recorded = await addEvent(run, spanId, event);
+  return recorded;
+}
+var polkadotPromise = null;
+async function loadPolkadot() {
+  if (!polkadotPromise) {
+    polkadotPromise = (async () => {
+      let crypto2;
+      let util;
+      try {
+        crypto2 = await import('@polkadot/util-crypto');
+        util = await import('@polkadot/util');
+      } catch {
+        throw new Error(
+          "Built-in sr25519/ed25519 governance support requires the optional peer dependencies '@polkadot/util-crypto' and '@polkadot/util'. Install them, or pass a custom GovernanceSigner / verifier."
+        );
+      }
+      await crypto2.cryptoWaitReady();
+      return { crypto: crypto2, util };
+    })();
+  }
+  return polkadotPromise;
+}
+var SS58_PREFIX = 42;
+function resolveSeed(seed, util) {
+  if (typeof seed === "string") {
+    return util.hexToU8a(seed.startsWith("0x") ? seed : "0x" + seed);
+  }
+  return seed;
+}
+async function createSr25519GovernanceSigner(opts) {
+  const { crypto: crypto2, util } = await loadPolkadot();
+  let publicKey;
+  let secretKey;
+  if (opts.secretKey && opts.publicKey) {
+    publicKey = opts.publicKey;
+    secretKey = opts.secretKey;
+  } else if (opts.seed !== void 0) {
+    const pair = crypto2.sr25519PairFromSeed(resolveSeed(opts.seed, util));
+    publicKey = pair.publicKey;
+    secretKey = pair.secretKey;
+  } else {
+    throw new Error("createSr25519GovernanceSigner: provide `seed` or `secretKey`+`publicKey`");
+  }
+  const address = opts.address ?? crypto2.encodeAddress(publicKey, opts.ss58Format ?? SS58_PREFIX);
+  return {
+    address,
+    signatureScheme: "sr25519",
+    sign(ctx) {
+      return util.u8aToHex(crypto2.sr25519Sign(ctx.preimage, { publicKey, secretKey }));
+    }
+  };
+}
+async function createEd25519GovernanceSigner(opts) {
+  const { crypto: crypto2, util } = await loadPolkadot();
+  let publicKey;
+  let secretKey;
+  if (opts.secretKey && opts.publicKey) {
+    publicKey = opts.publicKey;
+    secretKey = opts.secretKey;
+  } else if (opts.seed !== void 0) {
+    const pair = crypto2.ed25519PairFromSeed(resolveSeed(opts.seed, util));
+    publicKey = pair.publicKey;
+    secretKey = pair.secretKey;
+  } else {
+    throw new Error("createEd25519GovernanceSigner: provide `seed` or `secretKey`+`publicKey`");
+  }
+  const address = opts.address ?? crypto2.encodeAddress(publicKey, opts.ss58Format ?? SS58_PREFIX);
+  return {
+    address,
+    signatureScheme: "ed25519",
+    sign(ctx) {
+      return util.u8aToHex(crypto2.ed25519Sign(ctx.preimage, { publicKey, secretKey }));
+    }
+  };
+}
+async function verifyGovernanceAttestations(bundle, opts = {}) {
+  const events = bundle.privateRun.events.filter(
+    (e) => e.kind === "governance-attestation"
+  );
+  const runId = bundle.privateRun.id;
+  const summaries = [];
+  for (const event of events) {
+    const scheme = event.attestor.signatureScheme;
+    const preimage = governanceAttestationPreimage({
+      role: event.role,
+      policyRef: event.policyRef,
+      decisionRef: event.decisionRef,
+      signedAt: event.signedAt,
+      runId
+    });
+    const base = {
+      eventId: event.id,
+      role: event.role,
+      attestor: event.attestor.address,
+      scheme,
+      policyRef: event.policyRef,
+      decisionRef: event.decisionRef
+    };
+    const authorized = attestorAuthorized(event.attestor.address, event.role, opts);
+    if (!authorized) {
+      summaries.push({
+        ...base,
+        authorized: false,
+        verified: false,
+        error: opts.authorizedAttestors === void 0 && opts.authorizedAttestorsByRole === void 0 ? "no authorized-attestor allow-list supplied \u2014 governance verification fails closed (pass authorizedAttestors)" : `attestor ${event.attestor.address} is not authorized for role "${event.role}"`
+      });
+      continue;
+    }
+    try {
+      const override = opts.verifiers?.[scheme];
+      let signatureValid;
+      if (override) {
+        signatureValid = await override(event, { preimage, runId });
+      } else if (scheme === "sr25519" || scheme === "ed25519") {
+        signatureValid = await verifySubstrateSignature(scheme, event, preimage);
+      } else {
+        summaries.push({
+          ...base,
+          authorized: true,
+          verified: false,
+          error: `no verifier registered for scheme "${scheme}" (pass one via verifiers)`
+        });
+        continue;
+      }
+      summaries.push({ ...base, authorized: true, verified: signatureValid });
+    } catch (error) {
+      summaries.push({
+        ...base,
+        authorized: true,
+        verified: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return summaries;
+}
+function attestorAuthorized(address, role, opts) {
+  const norm = (s) => s.toLowerCase();
+  const roleList = opts.authorizedAttestorsByRole?.[role];
+  if (roleList !== void 0) {
+    return roleList.map(norm).includes(norm(address));
+  }
+  if (opts.authorizedAttestors !== void 0) {
+    return opts.authorizedAttestors.map(norm).includes(norm(address));
+  }
+  return false;
+}
+async function verifySubstrateSignature(scheme, event, preimage) {
+  const { crypto: crypto2, util } = await loadPolkadot();
+  const publicKey = crypto2.decodeAddress(event.attestor.address);
+  const sig = util.hexToU8a(
+    event.signature.startsWith("0x") ? event.signature : "0x" + event.signature
+  );
+  return scheme === "sr25519" ? crypto2.sr25519Verify(preimage, sig, publicKey) : crypto2.ed25519Verify(preimage, sig, publicKey);
+}
+var REQUIRED_EIP712_FIELDS = ["role", "policyRef", "decisionRef", "runId", "signedAt"];
+var DEFAULT_EIP712_FRESHNESS_MS = 24 * 60 * 6e4;
+function createEip712GovernanceVerifier(deps) {
+  if (deps.expectedDomain === void 0 || deps.expectedPrimaryType === void 0 || deps.expectedTypes === void 0) {
+    throw new Error(
+      "createEip712GovernanceVerifier: expectedDomain, expectedPrimaryType, and expectedTypes are required \u2014 an unpinned verifier accepts an empty attacker-signed struct (forgery)"
+    );
+  }
+  const declared = deps.expectedTypes[deps.expectedPrimaryType];
+  if (!declared) {
+    throw new Error(
+      `createEip712GovernanceVerifier: expectedTypes has no entry for primaryType "${deps.expectedPrimaryType}"`
+    );
+  }
+  const declaredNames = new Set(declared.map((f) => f.name));
+  const missing = REQUIRED_EIP712_FIELDS.filter((f) => !declaredNames.has(f));
+  if (missing.length > 0) {
+    throw new Error(
+      `createEip712GovernanceVerifier: the pinned "${deps.expectedPrimaryType}" type must include ${missing.join(", ")} so the signature commits to them`
+    );
+  }
+  return async (event, context) => {
+    if (!event.eip712) {
+      throw new Error("eip712 governance attestation is missing its `eip712` binding");
+    }
+    if (event.eip712.primaryType !== deps.expectedPrimaryType) {
+      return false;
+    }
+    if (!domainMatches(deps.expectedDomain, event.eip712.domain)) {
+      return false;
+    }
+    if (!typesMatch(deps.expectedTypes, event.eip712.types)) {
+      return false;
+    }
+    const signature = event.signature.startsWith("0x") ? event.signature : "0x" + event.signature;
+    const message = event.eip712.message ?? {};
+    const sigValid = await deps.verifyTypedData({
+      address: event.attestor.address,
+      domain: event.eip712.domain,
+      types: event.eip712.types,
+      primaryType: event.eip712.primaryType,
+      message,
+      signature
+    });
+    if (!sigValid) return false;
+    const claimBound = message.role === event.role && message.policyRef === event.policyRef && message.decisionRef === event.decisionRef && message.runId === context.runId && message.signedAt === event.signedAt;
+    if (!claimBound) return false;
+    const toleranceMs = deps.freshnessToleranceMs ?? DEFAULT_EIP712_FRESHNESS_MS;
+    const nowMs = deps.nowMs ?? Date.now();
+    const signedAtMs = Date.parse(String(message.signedAt));
+    if (!Number.isFinite(signedAtMs)) return false;
+    if (Math.abs(nowMs - signedAtMs) > toleranceMs) return false;
+    return true;
+  };
+}
+function domainMatches(expected, actual) {
+  const expectedKeys = Object.keys(expected);
+  const actualKeys = Object.keys(actual);
+  if (actualKeys.length !== expectedKeys.length) return false;
+  for (const key of expectedKeys) {
+    if (actual[key] !== expected[key]) return false;
+  }
+  return true;
+}
+function typesMatch(expected, actual) {
+  const norm = (t) => JSON.stringify(
+    Object.fromEntries(
+      Object.keys(t).sort().map((k) => [
+        k,
+        [...t[k]].sort((a, b) => a.name.localeCompare(b.name)).map((f) => `${f.name}:${f.type}`)
+      ])
+    )
+  );
+  return norm(expected) === norm(actual);
+}
+
+// src/bundle.ts
 function isPublicSpan(span) {
   return span.visibility === "public";
 }
@@ -603,7 +1051,7 @@ function createPublicView2(run, merkleRoot) {
 function extractPublicView(bundle) {
   return bundle.publicView;
 }
-async function verifyBundle(bundle) {
+async function verifyBundle(bundle, options = {}) {
   const errors = [];
   const warnings = [];
   const checks = {
@@ -648,7 +1096,11 @@ async function verifyBundle(bundle) {
     );
   }
   try {
-    const computedRootHash = await computeRootHash(run.rollingHash, run.spans);
+    const computedRootHash = await computeRootHash(
+      run.rollingHash,
+      run.spans,
+      run.modelManifestHash
+    );
     if (computedRootHash === bundle.rootHash) {
       checks.rootHashValid = true;
     } else {
@@ -675,6 +1127,75 @@ async function verifyBundle(bundle) {
       `Failed to compute Merkle root: ${error instanceof Error ? error.message : String(error)}`
     );
   }
+  const hasManifest = run.modelManifest !== void 0;
+  const hasManifestHash = run.modelManifestHash !== void 0 && run.modelManifestHash.length > 0;
+  if (!hasManifest && !hasManifestHash) {
+    checks.modelManifestValid = true;
+  } else {
+    let manifestBindingValid = true;
+    if (hasManifest && !hasManifestHash) {
+      manifestBindingValid = false;
+      errors.push(
+        "Model manifest present but modelManifestHash (its commitment) is missing"
+      );
+    } else if (!hasManifest && hasManifestHash) {
+      manifestBindingValid = false;
+      errors.push(
+        "modelManifestHash present but the model manifest itself is missing"
+      );
+    } else if (run.modelManifest !== void 0) {
+      try {
+        const recomputed = await computeModelManifestHash(run.modelManifest);
+        if (recomputed !== run.modelManifestHash) {
+          manifestBindingValid = false;
+          errors.push(
+            `Model manifest hash mismatch: recorded ${run.modelManifestHash}, computed ${recomputed}`
+          );
+        }
+      } catch (error) {
+        manifestBindingValid = false;
+        errors.push(
+          `Failed to recompute model manifest hash: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    if (manifestBindingValid && !checks.rootHashValid) {
+      manifestBindingValid = false;
+      errors.push(
+        "Model manifest is not bound into the committed root hash"
+      );
+    }
+    checks.modelManifestValid = manifestBindingValid;
+  }
+  const pvManifest = bundle.publicView.modelManifest;
+  const pvManifestHash = bundle.publicView.modelManifestHash;
+  if (pvManifestHash !== void 0 && pvManifestHash !== run.modelManifestHash) {
+    checks.modelManifestValid = false;
+    errors.push(
+      `PublicView modelManifestHash (${pvManifestHash}) does not match the bound commitment (${run.modelManifestHash})`
+    );
+  }
+  if (pvManifest !== void 0 && run.modelManifest === void 0) {
+    checks.modelManifestValid = false;
+    errors.push("PublicView carries a model manifest but the bound run has none");
+  }
+  if (pvManifest !== void 0) {
+    try {
+      const recomputed = await computeModelManifestHash(pvManifest);
+      const expected = pvManifestHash ?? run.modelManifestHash;
+      if (expected !== void 0 && recomputed !== expected) {
+        checks.modelManifestValid = false;
+        errors.push(
+          `PublicView model manifest hash mismatch: recorded ${expected}, computed ${recomputed}`
+        );
+      }
+    } catch (error) {
+      checks.modelManifestValid = false;
+      errors.push(
+        `Failed to recompute publicView model manifest hash: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
   if (bundle.publicView.publicSpans.length === 0 && run.spans.length > 0) {
     warnings.push(
       "No public spans in bundle. The public view will be empty. Consider marking some spans as public for transparency."
@@ -685,7 +1206,39 @@ async function verifyBundle(bundle) {
       `Status mismatch between publicView (${bundle.publicView.status}) and privateRun (${run.status})`
     );
   }
-  const valid = checks.rollingHashValid && checks.rootHashValid && checks.merkleRootValid && checks.spanHashesValid && checks.eventHashesValid && checks.sequenceValid;
+  if (options.governance) {
+    try {
+      const govOpts = options.governance === true ? {} : options.governance;
+      const summaries = await verifyGovernanceAttestations(bundle, govOpts);
+      const failed = summaries.filter((s) => !s.verified);
+      checks.governanceValid = failed.length === 0;
+      for (const f of failed) {
+        errors.push(
+          `Governance attestation failed (${f.scheme}, role ${f.role}, attestor ${f.attestor})` + (f.error ? `: ${f.error}` : "")
+        );
+      }
+    } catch (error) {
+      checks.governanceValid = false;
+      errors.push(
+        `Failed to verify governance attestations: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  if (options.toolReceipts) {
+    try {
+      const outcome = await options.toolReceipts(bundle);
+      checks.toolReceiptsValid = outcome.valid;
+      if (!outcome.valid) {
+        errors.push(...outcome.errors);
+      }
+    } catch (error) {
+      checks.toolReceiptsValid = false;
+      errors.push(
+        `Failed to verify tool receipts: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  const valid = checks.rollingHashValid && checks.rootHashValid && checks.merkleRootValid && checks.spanHashesValid && checks.eventHashesValid && checks.sequenceValid && checks.modelManifestValid !== false && checks.governanceValid !== false && checks.toolReceiptsValid !== false;
   return {
     valid,
     errors,
@@ -1280,6 +1833,6 @@ function parseChunkContent(content) {
 // src/index.ts
 var VERSION = "0.1.0";
 
-export { DEFAULT_EVENT_VISIBILITY, HASH_DOMAIN_PREFIXES, VERSION, addEvent, addSpan, buildSpanMerkleTree, canDisclose, closeSpan, computeEventHash, computeEventHashes, computeManifestHash, computeRollingHash, computeRootHash, computeSpanHash, countEventsByVisibility, countSpansByVisibility, createBundle, createDisclosureRequest, createManifest, createTrace, extractPublicView, filterPublicEvents, finalizeTrace, generateMerkleProof, getSpanEvents2 as getBundleSpanEvents, getChildSpans, getChunkPath, getEvent, getEventCount, getEventsByKind, getGenesisHash, getRootSpans, getSpan, getSpanCount, getSpanEvents, getSpanIndex, initRollingHash, isFinalized, isPublicEvent, isPublicSpan, parseChunkContent, reconstructBundleFromManifest, selectiveDisclose, signBundle, updateRollingHash, verifyBundle, verifyBundleSignature, verifyDisclosure, verifyManifest, verifyMerkleProof, verifyRollingHash, verifySpanDisclosure, verifySpanInclusion };
+export { DEFAULT_EVENT_VISIBILITY, HASH_DOMAIN_PREFIXES, SS58_PREFIX, VERSION, addEvent, addGovernanceAttestation, addSpan, buildSpanMerkleTree, canDisclose, closeSpan, computeEventHash, computeEventHashes, computeManifestHash, computeModelManifestHash, computeRollingHash, computeRootHash, computeSpanHash, countEventsByVisibility, countSpansByVisibility, createBundle, createDisclosureRequest, createEd25519GovernanceSigner, createEip712GovernanceVerifier, createManifest, createSr25519GovernanceSigner, createTrace, extractPublicView, filterPublicEvents, finalizeTrace, freezeModelManifest, generateMerkleProof, getSpanEvents2 as getBundleSpanEvents, getChildSpans, getChunkPath, getEvent, getEventCount, getEventsByKind, getGenesisHash, getRootSpans, getSpan, getSpanCount, getSpanEvents, getSpanIndex, governanceAttestationPreimage, initRollingHash, isFinalized, isPublicEvent, isPublicSpan, manifestFromAnthropic, manifestFromCheckpoint, manifestFromHuggingFace, manifestFromOpenAI, parseChunkContent, reconstructBundleFromManifest, selectiveDisclose, signBundle, updateRollingHash, validateModelManifest, verifyBundle, verifyBundleSignature, verifyDisclosure, verifyGovernanceAttestations, verifyManifest, verifyMerkleProof, verifyRollingHash, verifySpanDisclosure, verifySpanInclusion };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map