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

package/dist/index.cjs

@@ -9,7 +9,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|",
@@ -18,7 +22,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) {
@@ -70,7 +78,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) {
@@ -82,6 +90,9 @@ async function computeRootHash(rollingHash, spans) {
   if (spanHashes.length > 0) {
     input += "|" + spanHashes.join("|");
   }
+  if (modelManifestHash !== void 0 && modelManifestHash.length > 0) {
+    input += "|manifest:" + modelManifestHash;
+  }
   return utils.sha256StringHex(input);
 }
 async function computeEventHashes(events) {
@@ -283,6 +294,108 @@ async function verifySpanInclusion(proof, span, events) {
   }
   return verifyMerkleProof(proof);
 }
+async function computeModelManifestHash(manifest) {
+  const canonical = utils.canonicalize(manifest);
+  return utils.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 utils.sha256StringHex("orynq:model-fingerprint:v1|" + joined);
+}
+async function resolveSystemPromptHash(systemPrompt, systemPromptHash) {
+  if (systemPromptHash !== void 0) return systemPromptHash;
+  if (systemPrompt !== void 0) {
+    return "sha256:" + await utils.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 utils.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) {
@@ -312,6 +425,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) {
@@ -432,6 +558,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");
@@ -444,7 +580,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 = {
@@ -454,6 +594,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) {
@@ -495,6 +641,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) {
@@ -517,6 +669,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";
 }
@@ -605,7 +1053,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 = {
@@ -650,7 +1098,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 {
@@ -677,6 +1129,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."
@@ -687,7 +1208,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,
@@ -1284,8 +1837,10 @@ var VERSION = "0.1.0";
 
 exports.DEFAULT_EVENT_VISIBILITY = DEFAULT_EVENT_VISIBILITY;
 exports.HASH_DOMAIN_PREFIXES = HASH_DOMAIN_PREFIXES;
+exports.SS58_PREFIX = SS58_PREFIX;
 exports.VERSION = VERSION;
 exports.addEvent = addEvent;
+exports.addGovernanceAttestation = addGovernanceAttestation;
 exports.addSpan = addSpan;
 exports.buildSpanMerkleTree = buildSpanMerkleTree;
 exports.canDisclose = canDisclose;
@@ -1293,6 +1848,7 @@ exports.closeSpan = closeSpan;
 exports.computeEventHash = computeEventHash;
 exports.computeEventHashes = computeEventHashes;
 exports.computeManifestHash = computeManifestHash;
+exports.computeModelManifestHash = computeModelManifestHash;
 exports.computeRollingHash = computeRollingHash;
 exports.computeRootHash = computeRootHash;
 exports.computeSpanHash = computeSpanHash;
@@ -1300,11 +1856,15 @@ exports.countEventsByVisibility = countEventsByVisibility;
 exports.countSpansByVisibility = countSpansByVisibility;
 exports.createBundle = createBundle;
 exports.createDisclosureRequest = createDisclosureRequest;
+exports.createEd25519GovernanceSigner = createEd25519GovernanceSigner;
+exports.createEip712GovernanceVerifier = createEip712GovernanceVerifier;
 exports.createManifest = createManifest;
+exports.createSr25519GovernanceSigner = createSr25519GovernanceSigner;
 exports.createTrace = createTrace;
 exports.extractPublicView = extractPublicView;
 exports.filterPublicEvents = filterPublicEvents;
 exports.finalizeTrace = finalizeTrace;
+exports.freezeModelManifest = freezeModelManifest;
 exports.generateMerkleProof = generateMerkleProof;
 exports.getBundleSpanEvents = getSpanEvents2;
 exports.getChildSpans = getChildSpans;
@@ -1318,18 +1878,25 @@ exports.getSpan = getSpan;
 exports.getSpanCount = getSpanCount;
 exports.getSpanEvents = getSpanEvents;
 exports.getSpanIndex = getSpanIndex;
+exports.governanceAttestationPreimage = governanceAttestationPreimage;
 exports.initRollingHash = initRollingHash;
 exports.isFinalized = isFinalized;
 exports.isPublicEvent = isPublicEvent;
 exports.isPublicSpan = isPublicSpan;
+exports.manifestFromAnthropic = manifestFromAnthropic;
+exports.manifestFromCheckpoint = manifestFromCheckpoint;
+exports.manifestFromHuggingFace = manifestFromHuggingFace;
+exports.manifestFromOpenAI = manifestFromOpenAI;
 exports.parseChunkContent = parseChunkContent;
 exports.reconstructBundleFromManifest = reconstructBundleFromManifest;
 exports.selectiveDisclose = selectiveDisclose;
 exports.signBundle = signBundle;
 exports.updateRollingHash = updateRollingHash;
+exports.validateModelManifest = validateModelManifest;
 exports.verifyBundle = verifyBundle;
 exports.verifyBundleSignature = verifyBundleSignature;
 exports.verifyDisclosure = verifyDisclosure;
+exports.verifyGovernanceAttestations = verifyGovernanceAttestations;
 exports.verifyManifest = verifyManifest;
 exports.verifyMerkleProof = verifyMerkleProof;
 exports.verifyRollingHash = verifyRollingHash;