@gmickel/gno 1.16.0 → 1.17.0

package/src/core/context-guidance.ts

@@ -0,0 +1,69 @@
+import type { SearchResult } from "../pipeline/types";
+import type { ContextRow } from "../store/types";
+
+import { decorateUriForIndex } from "../app/constants";
+import { contextCapsuleContextIdentity } from "./context-capsule-validation";
+import {
+  contextIdentityFromUri,
+  resolveContextSnapshot,
+} from "./context-resolver";
+
+export interface ContextConfiguredGuidance {
+  contextId: string;
+  scopeType: "global" | "collection" | "prefix";
+  scopeKey: string;
+  text: string;
+}
+
+const compareCodeUnits = (left: string, right: string): number => {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+};
+
+/** A docid is only a short source-hash prefix and cannot identify a document. */
+export const contextGuidanceResultIdentity = (
+  result: Pick<SearchResult, "docid" | "uri">
+): string => JSON.stringify([result.uri, result.docid]);
+
+export const resolveContextGuidance = (
+  contextSnapshot: ContextRow[],
+  results: SearchResult[],
+  indexName: string
+): {
+  contexts: ContextConfiguredGuidance[];
+  idsByResultIdentity: Map<string, string[]>;
+} => {
+  const byId = new Map<string, ContextConfiguredGuidance>();
+  const idsByResultIdentity = new Map<string, string[]>();
+  for (const result of results) {
+    const ids: string[] = [];
+    const identity = contextIdentityFromUri(result.uri);
+    const resolved = identity
+      ? resolveContextSnapshot(contextSnapshot, identity)
+      : undefined;
+    for (const provenance of resolved?.provenance ?? []) {
+      const guidance = {
+        scopeType: provenance.scopeType,
+        scopeKey:
+          provenance.scopeType === "prefix"
+            ? decorateUriForIndex(provenance.normalizedScopeKey, indexName)
+            : provenance.normalizedScopeKey,
+        text: provenance.text,
+      };
+      const contextId = contextCapsuleContextIdentity(guidance);
+      byId.set(contextId, { contextId, ...guidance });
+      ids.push(contextId);
+    }
+    idsByResultIdentity.set(
+      contextGuidanceResultIdentity(result),
+      [...new Set(ids)].sort(compareCodeUnits)
+    );
+  }
+  return {
+    contexts: [...byId.values()].sort((left, right) =>
+      compareCodeUnits(left.contextId, right.contextId)
+    ),
+    idsByResultIdentity,
+  };
+};

package/src/core/context-scope.ts

@@ -0,0 +1,32 @@
+/** Canonical URI scope matching shared by Context planning stages. */
+
+import { DEFAULT_INDEX_NAME, parseUri } from "../app/constants";
+import { canonicalizeIndexName } from "../app/index-name";
+
+export const isContextUriInScope = (
+  uri: string,
+  indexName: string,
+  collections: string[],
+  prefixValue: string | null
+): boolean => {
+  const value = parseUri(uri);
+  if (
+    !value ||
+    canonicalizeIndexName(value.indexName ?? DEFAULT_INDEX_NAME) !==
+      indexName ||
+    (collections.length > 0 && !collections.includes(value.collection))
+  ) {
+    return false;
+  }
+  if (prefixValue === null) return true;
+  const prefix = parseUri(prefixValue);
+  return Boolean(
+    prefix &&
+    value.collection === prefix.collection &&
+    canonicalizeIndexName(prefix.indexName ?? DEFAULT_INDEX_NAME) ===
+      indexName &&
+    (prefix.path === "" ||
+      value.path === prefix.path ||
+      value.path.startsWith(`${prefix.path}/`))
+  );
+};

package/src/core/context-verifier-canonical.ts

@@ -0,0 +1,90 @@
+/** Stable JSON and raw text checks used by Capsule verification guards. */
+
+const compareCodeUnits = (left: string, right: string): number =>
+  left < right ? -1 : left > right ? 1 : 0;
+
+const canonicalizeJsonValue = (value: unknown): unknown => {
+  if (Array.isArray(value)) return value.map(canonicalizeJsonValue);
+  if (value !== null && typeof value === "object") {
+    const sorted: Record<string, unknown> = {};
+    for (const key of Object.keys(value).sort(compareCodeUnits)) {
+      const child = (value as Record<string, unknown>)[key];
+      if (child === undefined) {
+        throw new Error(`Canonical JSON rejects undefined at ${key}`);
+      }
+      sorted[key] = canonicalizeJsonValue(child);
+    }
+    return sorted;
+  }
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    throw new Error("Canonical JSON rejects non-finite numbers");
+  }
+  return value;
+};
+
+export const canonicalVerifierJson = (value: unknown): string =>
+  JSON.stringify(canonicalizeJsonValue(value));
+
+const isNoncanonicalNormalizedText = (value: unknown): boolean => {
+  if (typeof value === "string") {
+    return value.includes("\r") || value !== value.normalize("NFC");
+  }
+  return false;
+};
+
+const containsNoncanonicalText = (value: unknown): boolean =>
+  Array.isArray(value) && value.some(isNoncanonicalNormalizedText);
+
+const recordOf = (value: unknown): Record<string, unknown> =>
+  value !== null && typeof value === "object"
+    ? (value as Record<string, unknown>)
+    : {};
+
+/** Mirrors only the text fields normalized by normalizePayload. */
+export const hasNoncanonicalVerifierText = (value: unknown): boolean => {
+  const capsule = recordOf(value);
+  const scope = recordOf(capsule.scope);
+  const retrieval = recordOf(capsule.retrieval);
+  const guidance = recordOf(capsule.guidance);
+  const coverage = recordOf(capsule.coverage);
+  const evidence = Array.isArray(capsule.evidence) ? capsule.evidence : [];
+  const configuredContexts = Array.isArray(guidance.configuredContexts)
+    ? guidance.configuredContexts
+    : [];
+  const coveredFacets = Array.isArray(coverage.coveredFacets)
+    ? coverage.coveredFacets
+    : [];
+
+  return (
+    isNoncanonicalNormalizedText(capsule.goal) ||
+    isNoncanonicalNormalizedText(capsule.query) ||
+    isNoncanonicalNormalizedText(scope.uriPrefix) ||
+    containsNoncanonicalText(scope.collections) ||
+    containsNoncanonicalText(scope.tagsAll) ||
+    containsNoncanonicalText(scope.tagsAny) ||
+    containsNoncanonicalText(scope.categories) ||
+    containsNoncanonicalText(retrieval.facets) ||
+    containsNoncanonicalText(retrieval.queryVariants) ||
+    evidence.some((item) => {
+      const record = recordOf(item);
+      return (
+        isNoncanonicalNormalizedText(record.title) ||
+        isNoncanonicalNormalizedText(record.heading) ||
+        containsNoncanonicalText(record.contextIds) ||
+        containsNoncanonicalText(record.facets)
+      );
+    }) ||
+    configuredContexts.some((item) => {
+      const record = recordOf(item);
+      return (
+        isNoncanonicalNormalizedText(record.scopeKey) ||
+        isNoncanonicalNormalizedText(record.text)
+      );
+    }) ||
+    containsNoncanonicalText(coverage.requestedFacets) ||
+    coveredFacets.some((item) =>
+      isNoncanonicalNormalizedText(recordOf(item).facet)
+    ) ||
+    containsNoncanonicalText(coverage.unresolvedFacets)
+  );
+};

package/src/core/context-verifier-input.ts

@@ -0,0 +1,66 @@
+/** Canonical verification input preflight; performs no store I/O. */
+
+import type { ContextCapsuleV1 } from "./context-capsule";
+
+import {
+  canonicalContextCapsuleJson,
+  ContextCapsuleContractError,
+  parseContextCapsuleV1,
+  type ContextCapsuleCreateOptions,
+} from "./context-capsule";
+import {
+  canonicalVerifierJson,
+  hasNoncanonicalVerifierText,
+} from "./context-verifier-canonical";
+
+export interface ContextVerifierTokenAuthority {
+  countTokens?: ContextCapsuleCreateOptions["countTokens"];
+  tokenizerFingerprint?: string | null;
+}
+
+export const rawCanonicalContextJson = (input: unknown): string => {
+  try {
+    return canonicalVerifierJson(input);
+  } catch (cause) {
+    throw new ContextCapsuleContractError(
+      "invalid_input",
+      "Context Capsule input must be canonical JSON",
+      { cause }
+    );
+  }
+};
+
+export const parseCanonicalContextCapsuleForVerification = (
+  input: unknown,
+  authority: ContextVerifierTokenAuthority = {}
+): ContextCapsuleV1 => {
+  const rawInputBefore = rawCanonicalContextJson(input);
+  if (hasNoncanonicalVerifierText(input)) {
+    throw new ContextCapsuleContractError(
+      "invalid_input",
+      "Context Capsule input must already use NFC text and LF line endings"
+    );
+  }
+  let capsule = parseContextCapsuleV1(input);
+  if (capsule.budget.estimator === "active_tokenizer") {
+    if (
+      authority.countTokens === undefined ||
+      authority.tokenizerFingerprint !== capsule.budget.tokenizerFingerprint
+    ) {
+      throw new ContextCapsuleContractError(
+        "tokenizer_unavailable",
+        "The Capsule's active tokenizer and matching fingerprint are required for verification"
+      );
+    }
+    capsule = parseContextCapsuleV1(input, {
+      countTokens: authority.countTokens,
+    });
+  }
+  if (rawInputBefore !== canonicalContextCapsuleJson(capsule)) {
+    throw new ContextCapsuleContractError(
+      "invalid_input",
+      "Context Capsule input must already use its canonical semantic representation"
+    );
+  }
+  return capsule;
+};

package/src/core/context-verifier.ts

@@ -0,0 +1,447 @@
+/** Deterministic, non-mutating verification for saved Context Capsules. */
+
+import type {
+  ChunkRow,
+  DocumentRow,
+  StorePort,
+  StoreResult,
+} from "../store/types";
+import type { ContextCapsuleV1 } from "./context-capsule";
+import type { ContextCapsuleVerification } from "./context-capsule-verification";
+
+import { decorateUriForIndex, deriveDocid } from "../app/constants";
+import { chunkMatchesCanonicalContent } from "../pipeline/chunk-lookup";
+import { type ContextCapsuleCreateOptions } from "./context-capsule";
+import { sha256Text } from "./context-capsule-validation";
+import {
+  CONTEXT_CAPSULE_FINGERPRINT_DRIFT_REASONS,
+  contextCapsuleVerificationSchema,
+} from "./context-capsule-verification";
+import {
+  captureContextEvidenceSnapshot,
+  type ContextEvidenceSnapshot,
+} from "./context-evidence";
+import { canonicalVerifierJson } from "./context-verifier-canonical";
+import {
+  parseCanonicalContextCapsuleForVerification,
+  rawCanonicalContextJson,
+} from "./context-verifier-input";
+import { extractInclusiveLines } from "./sections";
+
+type ContextVerifierStore = Pick<
+  StorePort,
+  | "getActivationIndexSnapshot"
+  | "getChunksBatch"
+  | "getCollections"
+  | "getContexts"
+  | "getDocumentsByDocids"
+> &
+  Required<Pick<StorePort, "getContentBatch">>;
+
+export interface ContextVerifierFingerprints {
+  config: string;
+  retrieval: string;
+  embeddingModel: string | null;
+  rerankModel: string | null;
+  tokenizer: string | null;
+}
+
+export interface ContextVerifierDeps {
+  store: ContextVerifierStore;
+  currentFingerprints: ContextVerifierFingerprints;
+  resolveCurrentRanks?: (
+    capsule: ContextCapsuleV1
+  ) => Promise<ReadonlyMap<string, number>>;
+  countTokens?: ContextCapsuleCreateOptions["countTokens"];
+  tokenizerFingerprint?: string | null;
+}
+
+export type ContextVerifierErrorCode =
+  | "capsule_mutated_during_verify"
+  | "chunk_load_failed"
+  | "content_load_failed"
+  | "context_changed_during_verify"
+  | "document_load_failed"
+  | "index_changed_during_verify";
+
+export class ContextVerifierError extends Error {
+  readonly code: ContextVerifierErrorCode;
+
+  constructor(
+    code: ContextVerifierErrorCode,
+    message: string,
+    cause?: unknown
+  ) {
+    super(message, cause === undefined ? undefined : { cause });
+    this.name = "ContextVerifierError";
+    this.code = code;
+  }
+}
+
+const unwrapStore = <T>(
+  result: StoreResult<T>,
+  code: ContextVerifierErrorCode,
+  operation: string
+): T => {
+  if (result.ok) return result.value;
+  throw new ContextVerifierError(
+    code,
+    `${operation}: ${result.error.message}`,
+    result.error.cause
+  );
+};
+
+const matchingDocument = (
+  documents: readonly DocumentRow[],
+  uri: string,
+  sourceHash: string,
+  mirrorHash: string,
+  indexName: string
+): DocumentRow | null => {
+  const matches = documents.filter(
+    (document) =>
+      document.active &&
+      document.docid === deriveDocid(sourceHash) &&
+      document.sourceHash === sourceHash &&
+      document.mirrorHash === mirrorHash &&
+      decorateUriForIndex(document.uri, indexName) === uri
+  );
+  return matches.length === 1 ? (matches[0] ?? null) : null;
+};
+
+const rawInclusiveLines = (
+  content: string,
+  startLine: number,
+  endLine: number
+): string => {
+  const lines = content.split("\n");
+  if (startLine > lines.length) return "";
+  return lines.slice(startLine - 1, Math.min(endLine, lines.length)).join("\n");
+};
+
+type Evidence = ContextCapsuleV1["evidence"][number];
+type EvidenceReceipt = ContextCapsuleVerification["evidence"][number];
+
+interface LoadedEvidence {
+  contentByHash: Map<string, string>;
+  chunksByHash: Map<string, ChunkRow[]>;
+  documents: DocumentRow[];
+  snapshot: ContextEvidenceSnapshot;
+}
+
+const missingReceipt = (evidence: Evidence): EvidenceReceipt => ({
+  evidenceId: evidence.evidenceId,
+  uri: evidence.uri,
+  contentStatus: "missing",
+  contentCode: "source_missing",
+  rankingStatus: "unavailable",
+  rankingCode: "ranking_unavailable",
+  currentSourceHash: null,
+  currentMirrorHash: null,
+  currentPassageHash: null,
+  currentRetrievalRank: null,
+});
+
+const missingMirrorReceipt = (
+  evidence: Evidence,
+  sourceHash: string,
+  mirrorHash: string | null
+): EvidenceReceipt => ({
+  evidenceId: evidence.evidenceId,
+  uri: evidence.uri,
+  contentStatus: "missing",
+  contentCode: "mirror_missing",
+  rankingStatus: "unavailable",
+  rankingCode: "ranking_unavailable",
+  currentSourceHash: sourceHash,
+  currentMirrorHash: mirrorHash,
+  currentPassageHash: null,
+  currentRetrievalRank: null,
+});
+
+const verifyContent = (
+  evidence: Evidence,
+  loaded: LoadedEvidence,
+  indexName: string
+): EvidenceReceipt => {
+  const identities = loaded.snapshot.documents.filter(
+    (document) => document.uri === evidence.uri
+  );
+  const identity = identities.length === 1 ? identities[0] : undefined;
+  if (!identity) return missingReceipt(evidence);
+  if (!identity.mirrorHash) {
+    return missingMirrorReceipt(evidence, identity.sourceHash, null);
+  }
+  const document = matchingDocument(
+    loaded.documents,
+    evidence.uri,
+    identity.sourceHash,
+    identity.mirrorHash,
+    indexName
+  );
+  const currentSourceHash = document?.sourceHash ?? identity.sourceHash;
+  const registeredMirrorHash = document?.mirrorHash ?? identity.mirrorHash;
+  const content = loaded.contentByHash.get(registeredMirrorHash);
+  if (content === undefined) {
+    return missingMirrorReceipt(
+      evidence,
+      currentSourceHash,
+      registeredMirrorHash
+    );
+  }
+
+  const currentMirrorHash = sha256Text(content);
+  const exactPassage = extractInclusiveLines(
+    content,
+    evidence.startLine,
+    evidence.endLine
+  );
+  const currentPassageHash = sha256Text(
+    exactPassage ??
+      rawInclusiveLines(content, evidence.startLine, evidence.endLine)
+  );
+  const chunks = loaded.chunksByHash.get(registeredMirrorHash);
+  const chunk = chunks?.find(
+    (candidate) =>
+      candidate.mirrorHash === registeredMirrorHash &&
+      candidate.startLine === evidence.startLine &&
+      candidate.endLine === evidence.endLine &&
+      chunkMatchesCanonicalContent(candidate, content)
+  );
+  const chunkValid = chunk !== undefined;
+
+  let contentCode: EvidenceReceipt["contentCode"] = "verified_unchanged";
+  if (currentSourceHash !== evidence.sourceHash) {
+    contentCode = "source_stale";
+  } else if (
+    currentMirrorHash !== registeredMirrorHash ||
+    content.includes("\r")
+  ) {
+    contentCode = "mirror_corrupt";
+  } else if (registeredMirrorHash !== evidence.mirrorHash) {
+    contentCode = "mirror_stale";
+  } else if (
+    exactPassage === null ||
+    currentPassageHash !== evidence.passageHash
+  ) {
+    contentCode = "passage_stale";
+  } else if (!chunks || chunks.length === 0) {
+    contentCode = "chunk_missing";
+  } else if (!chunkValid) {
+    contentCode = "chunk_corrupt";
+  }
+
+  return {
+    evidenceId: evidence.evidenceId,
+    uri: evidence.uri,
+    contentStatus: contentCode === "verified_unchanged" ? "unchanged" : "stale",
+    contentCode,
+    rankingStatus: "unavailable",
+    rankingCode: "ranking_unavailable",
+    currentSourceHash,
+    currentMirrorHash,
+    currentPassageHash,
+    currentRetrievalRank: null,
+  };
+};
+
+const applyRanking = (
+  receipt: EvidenceReceipt,
+  evidence: Evidence,
+  currentRanks: ReadonlyMap<string, number> | null
+): EvidenceReceipt => {
+  if (receipt.contentStatus !== "unchanged") return receipt;
+  const rank = currentRanks?.get(evidence.evidenceId);
+  if (!Number.isSafeInteger(rank) || (rank ?? 0) < 1) return receipt;
+  const reranked = rank !== evidence.retrievalRank;
+  return {
+    ...receipt,
+    rankingStatus: reranked ? "reranked" : "unchanged",
+    rankingCode: reranked ? "ranking_changed" : "ranking_unchanged",
+    currentRetrievalRank: rank ?? null,
+  };
+};
+
+const aggregateReceipt = (
+  capsule: ContextCapsuleV1,
+  indexFingerprint: string,
+  currentFingerprints: ContextVerifierFingerprints,
+  evidence: EvidenceReceipt[]
+): ContextCapsuleVerification => {
+  const contentStatus = evidence.some(
+    (item) => item.contentStatus === "missing"
+  )
+    ? "missing"
+    : evidence.some((item) => item.contentStatus === "stale")
+      ? "stale"
+      : "unchanged";
+  const rankingStatus = evidence.some(
+    (item) => item.rankingStatus === "unavailable"
+  )
+    ? "unavailable"
+    : evidence.some((item) => item.rankingStatus === "reranked")
+      ? "reranked"
+      : "unchanged";
+  const reasons = fingerprintReasons(
+    capsule,
+    currentFingerprints,
+    indexFingerprint
+  );
+  return contextCapsuleVerificationSchema.parse({
+    schemaVersion: capsule.schemaVersion,
+    coordinateSpace: capsule.coordinateSpace,
+    capsuleId: capsule.capsuleId,
+    operationStatus: "completed",
+    contentStatus,
+    contentCode:
+      contentStatus === "missing"
+        ? "content_missing"
+        : contentStatus === "stale"
+          ? "content_stale"
+          : "verified_unchanged",
+    rankingStatus,
+    rankingCode:
+      rankingStatus === "unavailable"
+        ? "ranking_unavailable"
+        : rankingStatus === "reranked"
+          ? "ranking_changed"
+          : "ranking_unchanged",
+    currentFingerprints: {
+      ...currentFingerprints,
+      index: indexFingerprint,
+    },
+    fingerprintStatus: reasons.length === 0 ? "unchanged" : "drifted",
+    fingerprintReasons: reasons,
+    indexSnapshot: {
+      before: indexFingerprint,
+      after: indexFingerprint,
+      stable: true,
+    },
+    evidence,
+  });
+};
+
+const fingerprintReasons = (
+  capsule: ContextCapsuleV1,
+  current: ContextVerifierFingerprints,
+  indexFingerprint: string
+): (typeof CONTEXT_CAPSULE_FINGERPRINT_DRIFT_REASONS)[number][] => {
+  const changed = {
+    config_changed: current.config !== capsule.fingerprints.config,
+    retrieval_changed: current.retrieval !== capsule.fingerprints.retrieval,
+    embedding_model_changed:
+      current.embeddingModel !== capsule.fingerprints.embeddingModel,
+    rerank_model_changed:
+      current.rerankModel !== capsule.fingerprints.rerankModel,
+    tokenizer_changed: current.tokenizer !== capsule.fingerprints.tokenizer,
+    index_changed: indexFingerprint !== capsule.retrieval.indexSnapshot.after,
+  } satisfies Record<
+    (typeof CONTEXT_CAPSULE_FINGERPRINT_DRIFT_REASONS)[number],
+    boolean
+  >;
+  return CONTEXT_CAPSULE_FINGERPRINT_DRIFT_REASONS.filter(
+    (reason) => changed[reason]
+  );
+};
+
+export { parseCanonicalContextCapsuleForVerification } from "./context-verifier-input";
+
+/** Verify a Capsule without rebuilding it or mutating caller-owned input. */
+export const verifyContextCapsule = async (
+  input: unknown,
+  deps: ContextVerifierDeps
+): Promise<ContextCapsuleVerification> => {
+  const rawInputBefore = rawCanonicalContextJson(input);
+  const capsule = parseCanonicalContextCapsuleForVerification(input, deps);
+  const before = await captureContextEvidenceSnapshot(
+    deps.store,
+    capsule.scope.indexName,
+    capsule.scope.collections
+  );
+  const evidenceUris = new Set(capsule.evidence.map((item) => item.uri));
+  const referencedDocuments = before.documents.filter((document) =>
+    evidenceUris.has(document.uri)
+  );
+  const docids = [
+    ...new Set(
+      referencedDocuments.map((document) => deriveDocid(document.sourceHash))
+    ),
+  ];
+  const mirrorHashes = [
+    ...new Set(
+      referencedDocuments.flatMap((document) =>
+        document.mirrorHash === null ? [] : [document.mirrorHash]
+      )
+    ),
+  ];
+  const [documentResult, contentResult, chunkResult, rankResult] =
+    await Promise.all([
+      deps.store.getDocumentsByDocids(docids, { activeOnly: true }),
+      deps.store.getContentBatch(mirrorHashes),
+      deps.store.getChunksBatch(mirrorHashes),
+      deps.resolveCurrentRanks?.(structuredClone(capsule)).catch(() => null) ??
+        Promise.resolve(null),
+    ]);
+  const loaded: LoadedEvidence = {
+    snapshot: before,
+    documents: unwrapStore(
+      documentResult,
+      "document_load_failed",
+      "Failed to batch-load verification documents"
+    ),
+    contentByHash: unwrapStore(
+      contentResult,
+      "content_load_failed",
+      "Failed to batch-load verification mirrors"
+    ),
+    chunksByHash: unwrapStore(
+      chunkResult,
+      "chunk_load_failed",
+      "Failed to batch-load verification chunks"
+    ),
+  };
+  const after = await captureContextEvidenceSnapshot(
+    deps.store,
+    capsule.scope.indexName,
+    capsule.scope.collections
+  );
+  if (before.indexFingerprint !== after.indexFingerprint) {
+    throw new ContextVerifierError(
+      "index_changed_during_verify",
+      "Index changed while Context Capsule verification was running"
+    );
+  }
+  if (before.contextFingerprint !== after.contextFingerprint) {
+    throw new ContextVerifierError(
+      "context_changed_during_verify",
+      "Configured contexts changed while Context Capsule verification was running"
+    );
+  }
+  const rawInputAfter = rawCanonicalContextJson(input);
+  if (rawInputBefore !== rawInputAfter) {
+    throw new ContextVerifierError(
+      "capsule_mutated_during_verify",
+      "Context Capsule input changed while verification was running"
+    );
+  }
+
+  const evidence = capsule.evidence.map((item) =>
+    applyRanking(
+      verifyContent(item, loaded, capsule.scope.indexName),
+      item,
+      rankResult
+    )
+  );
+  return aggregateReceipt(
+    capsule,
+    before.indexFingerprint,
+    deps.currentFingerprints,
+    evidence
+  );
+};
+
+/** Canonical JSON projection for cross-surface receipt parity. */
+export const canonicalContextCapsuleVerificationJson = (
+  input: unknown
+): string =>
+  canonicalVerifierJson(contextCapsuleVerificationSchema.parse(input));