@kontourai/survey 0.4.3 → 0.4.4

package/dist/src/learning-projections.d.ts

@@ -0,0 +1,19 @@
+import type { SurveyInput } from "./types.js";
+export type LearningProjectionKind = "learning.comfort-zone" | "learning.escalation";
+export type LearningProjectionSignal = "comfort-zone.outside" | "escalation.unresolved";
+export type LearningProjectionSeverity = "info" | "attention";
+export interface LearningProjection {
+    id: string;
+    kind: LearningProjectionKind;
+    source: string;
+    createdAt: string;
+    target?: string;
+    claimId?: string;
+    reviewOutcomeId?: string;
+    escalationId?: string;
+    signal: LearningProjectionSignal;
+    severity?: LearningProjectionSeverity;
+    summary: string;
+    metadata?: Record<string, unknown>;
+}
+export declare function buildSurveyLearningProjections(input: SurveyInput): LearningProjection[];

package/dist/src/learning-projections.js

@@ -0,0 +1,77 @@
+export function buildSurveyLearningProjections(input) {
+    const claimsByCandidateSet = groupBy(input.claims, (claim) => claim.candidateSetId);
+    const candidateSetTargets = new Map(input.candidateSets.map((candidateSet) => [candidateSet.id, candidateSet.target]));
+    const projections = [];
+    for (const reviewOutcome of input.reviewOutcomes) {
+        if (reviewOutcome.withinComfortZone !== false)
+            continue;
+        const target = candidateSetTargets.get(reviewOutcome.candidateSetId);
+        const claim = findClaimForReview(claimsByCandidateSet.get(reviewOutcome.candidateSetId) ?? [], reviewOutcome);
+        const note = reviewOutcome.comfortZoneNote;
+        projections.push({
+            id: `${reviewOutcome.id}.learning.comfort-zone`,
+            kind: "learning.comfort-zone",
+            source: input.source,
+            createdAt: reviewOutcome.reviewedAt ?? input.generatedAt,
+            target,
+            claimId: claim?.id,
+            reviewOutcomeId: reviewOutcome.id,
+            signal: "comfort-zone.outside",
+            severity: "attention",
+            summary: note ? `Review outcome is outside comfort zone: ${note}` : "Review outcome is outside comfort zone.",
+            metadata: {
+                comfortZone: {
+                    withinComfortZone: false,
+                    ...(note ? { note } : {}),
+                },
+            },
+        });
+    }
+    for (const escalation of input.escalations ?? []) {
+        if (escalation.resolvedBy)
+            continue;
+        projections.push({
+            id: `${escalation.id}.learning.escalation`,
+            kind: "learning.escalation",
+            source: input.source,
+            createdAt: escalation.raisedAt,
+            target: escalation.target,
+            claimId: escalation.attachToClaimId,
+            escalationId: escalation.id,
+            signal: "escalation.unresolved",
+            severity: "attention",
+            summary: `Unresolved ${escalation.dimension} escalation: ${escalation.reason}`,
+            metadata: {
+                escalation: unresolvedEscalationMetadata(escalation),
+            },
+        });
+    }
+    return projections;
+}
+function findClaimForReview(claims, reviewOutcome) {
+    if (reviewOutcome.candidateId) {
+        return claims.find((claim) => claim.candidateId === reviewOutcome.candidateId);
+    }
+    return claims[0];
+}
+function unresolvedEscalationMetadata(escalation) {
+    return {
+        id: escalation.id,
+        target: escalation.target,
+        dimension: escalation.dimension,
+        reason: escalation.reason,
+        raisedBy: escalation.raisedBy,
+        raisedAt: escalation.raisedAt,
+        ...(escalation.attachToClaimId ? { attachToClaimId: escalation.attachToClaimId } : {}),
+        resolved: false,
+        ...(escalation.metadata ? { metadata: escalation.metadata } : {}),
+    };
+}
+function groupBy(items, getKey) {
+    const map = new Map();
+    for (const item of items) {
+        const key = getKey(item);
+        map.set(key, [...(map.get(key) ?? []), item]);
+    }
+    return map;
+}

package/dist/src/raw-source.d.ts

@@ -25,7 +25,22 @@ export interface ManualEntrySourceInput extends Omit<RawSourceInput, "checksum"
     checksum?: ChecksumInput;
     locatorScheme?: LocatorScheme;
 }
+export interface PolicyStandardMetadata {
+    inlineText: string;
+    standardVersion: string;
+    paragraphRef?: string;
+    reference?: string;
+}
+export interface PolicyStandardSourceInput extends Omit<RawSourceInput, "locatorScheme" | "metadata"> {
+    inlineText: string;
+    standardVersion: string;
+    paragraphRef?: string;
+    reference?: string;
+    locatorScheme?: LocatorScheme;
+    metadata?: Record<string, unknown>;
+}
 export declare function uploadedDocumentSource(input: UploadedDocumentSourceInput): RawSource;
 export declare function apiRecordSource(input: ApiRecordSourceInput): RawSource;
 export declare function webPageSource(input: WebPageSourceInput): RawSource;
 export declare function manualEntrySource(input: ManualEntrySourceInput): RawSource;
+export declare function policyStandardSource(input: PolicyStandardSourceInput): RawSource;

package/dist/src/raw-source.js

@@ -19,6 +19,28 @@ export function manualEntrySource(input) {
         ...input,
     });
 }
+export function policyStandardSource(input) {
+    const policyStandard = {
+        inlineText: input.inlineText,
+        standardVersion: input.standardVersion,
+        paragraphRef: input.paragraphRef,
+        reference: input.reference,
+    };
+    const source = rawSource("policy-standard", {
+        locatorScheme: "text",
+        ...input,
+        metadata: {
+            ...input.metadata,
+            policyStandard,
+        },
+    });
+    return {
+        ...source,
+        inlineText: input.inlineText,
+        standardVersion: input.standardVersion,
+        paragraphRef: input.paragraphRef,
+    };
+}
 function rawSource(kind, input) {
     return {
         id: input.id ?? sourceId(kind, input.sourceRef),

package/dist/src/review-proof.d.ts

@@ -1,5 +1,9 @@
 import type { IntegrityAnchor } from "@kontourai/surface";
 import type { Candidate, CandidateSet, ClaimTarget, Extraction, RawSource, ReviewOutcome } from "./types.js";
+export declare const REVIEW_PROOF_SCHEMA = "survey.review-proof";
+export declare const REVIEW_PROOF_SCHEMA_VERSION = 1;
+export declare const REVIEW_PROOF_PACKAGE_NAME = "@kontourai/survey";
+export declare const REVIEW_PROOF_CONTRACT_VERSION = "1";
 export interface ReviewProofInput {
     rawSource: RawSource;
     extraction: Extraction;
@@ -13,6 +17,30 @@ export interface ReviewProofInput {
 }
 export interface CanonicalReviewProofPayload {
     schemaVersion: 1;
+    proof: {
+        schema: typeof REVIEW_PROOF_SCHEMA;
+        schemaVersion: typeof REVIEW_PROOF_SCHEMA_VERSION;
+        packageName: typeof REVIEW_PROOF_PACKAGE_NAME;
+        packageVersion: typeof REVIEW_PROOF_CONTRACT_VERSION;
+        issuer: string;
+        producer: string;
+        issuedAt: string;
+        subject: {
+            claimId: string;
+            candidateSetId: string;
+            candidateId?: string;
+            subjectType: string;
+            subjectId: string;
+            surface: string;
+            claimType: string;
+            fieldOrBehavior: string;
+        };
+        sourcePayload: {
+            id: string;
+            sourceRef: string;
+            checksum?: string;
+        };
+    };
     rawSource: {
         id: string;
         kind: RawSource["kind"];

package/dist/src/review-proof.js

@@ -1,7 +1,38 @@
 import { createHash } from "node:crypto";
+export const REVIEW_PROOF_SCHEMA = "survey.review-proof";
+export const REVIEW_PROOF_SCHEMA_VERSION = 1;
+export const REVIEW_PROOF_PACKAGE_NAME = "@kontourai/survey";
+// Version of the review proof contract emitted by this helper. This is intentionally
+// independent from the npm package release version because it participates in hashes.
+export const REVIEW_PROOF_CONTRACT_VERSION = "1";
 export function buildCanonicalReviewProofPayload(input) {
+    assertCandidateConsistency(input);
     return {
-        schemaVersion: 1,
+        schemaVersion: REVIEW_PROOF_SCHEMA_VERSION,
+        proof: {
+            schema: REVIEW_PROOF_SCHEMA,
+            schemaVersion: REVIEW_PROOF_SCHEMA_VERSION,
+            packageName: REVIEW_PROOF_PACKAGE_NAME,
+            packageVersion: REVIEW_PROOF_CONTRACT_VERSION,
+            issuer: input.claim.collectedBy,
+            producer: input.extraction.extractor,
+            issuedAt: input.reviewOutcome?.reviewedAt ?? input.claim.updatedAt ?? input.extraction.extractedAt,
+            subject: {
+                claimId: input.claim.id,
+                candidateSetId: input.claim.candidateSetId,
+                candidateId: input.candidate.id,
+                subjectType: input.claim.subjectType,
+                subjectId: input.claim.subjectId,
+                surface: input.claim.surface,
+                claimType: input.claim.claimType,
+                fieldOrBehavior: input.claim.fieldOrBehavior,
+            },
+            sourcePayload: {
+                id: input.rawSource.id,
+                sourceRef: input.rawSource.sourceRef,
+                checksum: input.rawSource.checksum,
+            },
+        },
         rawSource: {
             id: input.rawSource.id,
             kind: input.rawSource.kind,
@@ -80,6 +111,32 @@ export function buildCanonicalReviewProofPayload(input) {
         },
     };
 }
+function assertCandidateConsistency(input) {
+    if (input.extraction.sourceId !== input.rawSource.id) {
+        throw new Error(`Review proof extraction sourceId "${input.extraction.sourceId}" does not match raw source id "${input.rawSource.id}".`);
+    }
+    if (input.candidate.extractionId !== input.extraction.id) {
+        throw new Error(`Review proof candidate extractionId "${input.candidate.extractionId}" does not match extraction id "${input.extraction.id}".`);
+    }
+    if (!input.candidateSet.candidates.some((candidate) => candidate.id === input.candidate.id)) {
+        throw new Error(`Review proof candidate id "${input.candidate.id}" is not present in candidate set "${input.candidateSet.id}".`);
+    }
+    if (input.candidateSet.selectedCandidateId && input.candidateSet.selectedCandidateId !== input.candidate.id) {
+        throw new Error(`Review proof candidate set selectedCandidateId "${input.candidateSet.selectedCandidateId}" does not match reviewed candidate id "${input.candidate.id}".`);
+    }
+    if (input.claim.candidateSetId !== input.candidateSet.id) {
+        throw new Error(`Review proof claim candidateSetId "${input.claim.candidateSetId}" does not match candidate set id "${input.candidateSet.id}".`);
+    }
+    if (input.claim.candidateId && input.claim.candidateId !== input.candidate.id) {
+        throw new Error(`Review proof claim candidateId "${input.claim.candidateId}" does not match reviewed candidate id "${input.candidate.id}".`);
+    }
+    if (input.reviewOutcome && input.reviewOutcome.candidateSetId !== input.candidateSet.id) {
+        throw new Error(`Review proof review outcome candidateSetId "${input.reviewOutcome.candidateSetId}" does not match candidate set id "${input.candidateSet.id}".`);
+    }
+    if (input.reviewOutcome?.candidateId && input.reviewOutcome.candidateId !== input.candidate.id) {
+        throw new Error(`Review proof review outcome candidateId "${input.reviewOutcome.candidateId}" does not match reviewed candidate id "${input.candidate.id}".`);
+    }
+}
 export function canonicalReviewProofJson(payload) {
     return JSON.stringify(canonicalize(payload));
 }

package/dist/src/review-resource.d.ts

@@ -0,0 +1,111 @@
+import type { CandidateSetStatus, ClaimTarget, Extraction, RawSource, ReviewOutcome } from "./types.js";
+export declare const reviewResourceApiVersion = "survey.kontourai.io/v1alpha1";
+export type ReviewResourceApiVersion = typeof reviewResourceApiVersion;
+export type ReviewResourceKind = "ReviewItem" | "ReviewDecision";
+export interface ResourceMetadata {
+    name: string;
+    uid?: string;
+    labels?: Record<string, string>;
+    annotations?: Record<string, string>;
+    producer?: Record<string, unknown>;
+}
+export interface ResourceEnvelope<K extends ReviewResourceKind, Spec, Status = Record<string, never>> {
+    apiVersion: ReviewResourceApiVersion;
+    kind: K;
+    metadata: ResourceMetadata;
+    spec: Spec;
+    status?: Status;
+}
+export type CandidateRole = "current" | "proposed" | "alternative" | "source-version" | "computed";
+export interface SourceReference {
+    sourceRef: string;
+    sourceId?: string;
+    kind?: RawSource["kind"];
+    observedAt?: string;
+    fetchedAt?: string;
+    checksum?: string;
+    locatorScheme?: RawSource["locatorScheme"];
+}
+export interface ReviewLocator {
+    scheme: RawSource["locatorScheme"];
+    locator?: string;
+    excerpt?: string;
+}
+export interface ExtractionReference {
+    extractionId?: string;
+    target: string;
+    confidence?: number;
+    extractor?: string;
+    extractedAt?: string;
+}
+export interface ClaimTargetHint {
+    claimId?: string;
+    subjectType: string;
+    subjectId: string;
+    surface: string;
+    claimType: string;
+    fieldOrBehavior: string;
+    impactLevel: ClaimTarget["impactLevel"];
+    evidenceType?: ClaimTarget["evidenceType"];
+    evidenceMethod?: ClaimTarget["evidenceMethod"];
+    collectedBy?: string;
+    derivedFrom?: string[];
+}
+export interface SurveyRecordProjectionHint {
+    rawSourceId?: RawSource["id"];
+    extractionId?: Extraction["id"];
+    candidateSetId?: string;
+    candidateId?: string;
+    reviewOutcomeId?: ReviewOutcome["id"];
+    claimId?: ClaimTarget["id"];
+}
+export interface ReviewCandidate {
+    id: string;
+    role?: CandidateRole;
+    value: unknown;
+    confidence?: number;
+    sourceRank?: number;
+    rejectionReason?: string;
+    source: SourceReference;
+    locator?: ReviewLocator;
+    extraction: ExtractionReference;
+    claimTarget: ClaimTargetHint;
+    projection?: SurveyRecordProjectionHint;
+    producer?: Record<string, unknown>;
+}
+export interface ReviewItemSpec {
+    target: string;
+    candidates: ReviewCandidate[];
+    candidateSetStatus?: CandidateSetStatus;
+    selectedCandidateId?: string;
+    rationale?: string;
+    producerPolicy?: Record<string, unknown>;
+    projection?: SurveyRecordProjectionHint;
+}
+export interface ReviewItemStatus {
+    observedCandidateCount?: number;
+    selectedCandidateId?: string;
+    reviewDecisionName?: string;
+}
+export type ReviewItem = ResourceEnvelope<"ReviewItem", ReviewItemSpec, ReviewItemStatus>;
+export interface ReviewActor {
+    id: string;
+    displayName?: string;
+}
+export interface ReviewDecisionSpec {
+    reviewItemName: string;
+    candidateId?: string;
+    status: ReviewOutcome["status"];
+    actor?: ReviewActor;
+    reviewedAt?: string;
+    rationale?: string;
+    evidenceIds?: string[];
+    withinComfortZone?: boolean;
+    comfortZoneNote?: string;
+    projection?: SurveyRecordProjectionHint;
+}
+export interface ReviewDecisionStatus {
+    appliedToClaimIds?: string[];
+}
+export type ReviewDecision = ResourceEnvelope<"ReviewDecision", ReviewDecisionSpec, ReviewDecisionStatus>;
+export type ReviewResource = ReviewItem | ReviewDecision;

package/dist/src/review-resource.js

@@ -0,0 +1 @@
+export const reviewResourceApiVersion = "survey.kontourai.io/v1alpha1";

package/dist/src/to-surface.js

@@ -43,14 +43,7 @@ export function buildSurveyTrustInput(input, options = {}) {
             },
             metadata: {
                 ...projection.metadata,
-                survey: {
-                    ...(isRecord(projection.metadata?.survey) ? projection.metadata.survey : {}),
-                    rawSourceId: rawSource.id,
-                    extractionId: extraction.id,
-                    candidateSetId: candidateSet.id,
-                    candidateId: candidate.id,
-                    reviewOutcomeId: review?.id,
-                },
+                survey: buildSurveyMetadata({ projection, rawSource, extraction, candidateSet, candidate, review }),
             },
         };
         if (options.reviewProofs && review) {
@@ -68,6 +61,7 @@ export function buildSurveyTrustInput(input, options = {}) {
             });
         }
         claims.push(claim);
+        const policyStandard = policyStandardFields(rawSource);
         evidence.push({
             id: evidenceId,
             claimId: projection.id,
@@ -75,7 +69,7 @@ export function buildSurveyTrustInput(input, options = {}) {
             method: projection.evidenceMethod ?? "extraction",
             sourceRef: rawSource.sourceRef,
             sourceLocator: extraction.locator,
-            excerptOrSummary: extraction.excerpt ?? `Extracted ${projection.fieldOrBehavior} from ${rawSource.kind}.`,
+            excerptOrSummary: evidenceExcerptOrSummary({ rawSource, extraction, projection, policyStandard }),
             observedAt: rawSource.observedAt,
             collectedBy: projection.collectedBy,
             integrityRef: rawSource.checksum,
@@ -83,15 +77,13 @@ export function buildSurveyTrustInput(input, options = {}) {
                 ...rawSource.metadata,
                 ...extraction.metadata,
                 ...candidate.metadata,
+                ...(policyStandard ? { policyStandard } : {}),
                 rawSourceKind: rawSource.kind,
                 locatorScheme: rawSource.locatorScheme,
                 confidence: candidate.confidence ?? extraction.confidence,
             },
         });
         const rationale = review?.rationale ?? candidateSet.rationale;
-        const comfortZoneNote = review?.withinComfortZone === false
-            ? `[outside comfort zone] ${review.comfortZoneNote ?? "reviewer flagged this as outside their comfort zone"}`
-            : undefined;
         events.push({
             id: `${projection.id}.event.${status}`,
             claimId: projection.id,
@@ -101,9 +93,10 @@ export function buildSurveyTrustInput(input, options = {}) {
             evidenceIds: review?.evidenceIds?.length ? review.evidenceIds : [evidenceId],
             createdAt: review?.reviewedAt ?? input.generatedAt,
             verifiedAt: status === "verified" || status === "assumed" ? review?.reviewedAt ?? input.generatedAt : undefined,
-            notes: [rationale, comfortZoneNote].filter(Boolean).join(" | ") || undefined,
+            notes: rationale,
         });
     }
+    projectInterpretations({ input, rawSources, claims, evidence, events });
     if (input.escalations) {
         const claimIds = new Set(claims.map((c) => c.id));
         for (const escalation of input.escalations) {
@@ -135,6 +128,199 @@ export function buildSurveyTrustInput(input, options = {}) {
         events,
     };
 }
+function projectInterpretations(input) {
+    const interpretations = input.input.interpretations
+        ? [...indexById(input.input.interpretations, "interpretation").values()]
+        : [];
+    if (interpretations.length === 0)
+        return;
+    const claimsById = new Map(input.claims.map((claim) => [claim.id, claim]));
+    for (const interpretation of interpretations) {
+        const projection = buildInterpretationProjection({
+            interpretation,
+            rawSources: input.rawSources,
+            claims: input.claims,
+            claimsById,
+            input: input.input,
+        });
+        input.evidence.push(projection.evidence);
+        input.events.push(projection.event);
+        attachInterpretationClaimMetadata({
+            claim: projection.claim,
+            interpretation,
+            anchorSource: projection.anchorSource,
+            evidenceId: projection.evidence.id,
+        });
+    }
+}
+function buildInterpretationProjection(input) {
+    const anchorSource = requirePolicyStandardAnchor(input.interpretation, input.rawSources);
+    const claim = resolveInterpretationClaim(input.interpretation, input.claims, input.input);
+    if (!input.claimsById.has(claim.id)) {
+        throw new Error(`Interpretation ${input.interpretation.id} resolved unknown claim ${claim.id}`);
+    }
+    const policyStandard = policyStandardFields(anchorSource);
+    const evidence = createInterpretationAnchorEvidence({
+        interpretation: input.interpretation,
+        claim,
+        anchorSource,
+        policyStandard,
+    });
+    return {
+        claim,
+        anchorSource,
+        evidence,
+        event: createInterpretationEvent({
+            interpretation: input.interpretation,
+            claim,
+            evidenceId: evidence.id,
+        }),
+    };
+}
+function requirePolicyStandardAnchor(interpretation, rawSources) {
+    const anchorSource = requireMapValue(rawSources, interpretation.anchorsToSourceId, "interpretation anchor raw source");
+    if (anchorSource.kind !== "policy-standard") {
+        throw new Error(`Interpretation ${interpretation.id} anchors to raw source ${anchorSource.id}, but expected policy-standard source`);
+    }
+    return anchorSource;
+}
+function createInterpretationAnchorEvidence(input) {
+    return {
+        id: `${input.interpretation.id}.evidence.anchor`,
+        claimId: input.claim.id,
+        evidenceType: "policy_rule",
+        method: "anchoring",
+        sourceRef: input.anchorSource.sourceRef,
+        sourceLocator: input.interpretation.ruleLocator,
+        excerptOrSummary: input.policyStandard?.inlineText ?? `Anchored policy-standard reading at ${input.interpretation.ruleLocator}.`,
+        observedAt: input.anchorSource.observedAt,
+        collectedBy: input.interpretation.actor,
+        integrityRef: input.anchorSource.checksum,
+        metadata: {
+            ...input.anchorSource.metadata,
+            ...(input.interpretation.metadata ? { interpretation: input.interpretation.metadata } : {}),
+            ...(input.policyStandard ? { policyStandard: input.policyStandard } : {}),
+            rawSourceKind: input.anchorSource.kind,
+            locatorScheme: input.anchorSource.locatorScheme,
+            anchorsToSourceId: input.anchorSource.id,
+            ruleLocator: input.interpretation.ruleLocator,
+        },
+    };
+}
+function createInterpretationEvent(input) {
+    return {
+        id: `${input.interpretation.id}.event`,
+        claimId: input.claim.id,
+        status: input.claim.status ?? "proposed",
+        actor: input.interpretation.actor,
+        method: "survey-interpretation",
+        evidenceIds: [input.evidenceId],
+        createdAt: input.interpretation.recordedAt,
+        verifiedAt: input.claim.status === "verified" || input.claim.status === "assumed" ? input.interpretation.recordedAt : undefined,
+        notes: input.interpretation.reading,
+    };
+}
+function attachInterpretationClaimMetadata(input) {
+    const claimMetadata = isRecord(input.claim.metadata) ? input.claim.metadata : {};
+    const surveyMetadata = isRecord(claimMetadata.survey) ? claimMetadata.survey : {};
+    const existingInterpretations = Array.isArray(surveyMetadata.interpretations) ? surveyMetadata.interpretations : [];
+    input.claim.metadata = {
+        ...claimMetadata,
+        survey: {
+            ...surveyMetadata,
+            interpretations: [
+                ...existingInterpretations,
+                {
+                    interpretationId: input.interpretation.id,
+                    ruleLocator: input.interpretation.ruleLocator,
+                    reading: input.interpretation.reading,
+                    actor: input.interpretation.actor,
+                    recordedAt: input.interpretation.recordedAt,
+                    ...(input.interpretation.metadata ? { metadata: input.interpretation.metadata } : {}),
+                    edges: [
+                        {
+                            type: "appliesTo",
+                            targetKind: "claim",
+                            targetId: input.claim.id,
+                        },
+                        {
+                            type: "anchorsTo",
+                            targetKind: "rawSource",
+                            targetId: input.anchorSource.id,
+                            evidenceId: input.evidenceId,
+                            ruleLocator: input.interpretation.ruleLocator,
+                        },
+                    ],
+                },
+            ],
+        },
+    };
+}
+function resolveInterpretationClaim(interpretation, claims, input) {
+    if (interpretation.appliesToClaimId) {
+        const claim = claims.find((item) => item.id === interpretation.appliesToClaimId);
+        if (!claim) {
+            throw new Error(`Interpretation ${interpretation.id} references unknown claim ${interpretation.appliesToClaimId}`);
+        }
+        if (interpretation.appliesToTarget) {
+            const targetClaim = resolveInterpretationTargetClaim(interpretation, claims, input);
+            if (targetClaim.id !== claim.id) {
+                throw new Error(`Interpretation ${interpretation.id} has conflicting appliesToClaimId ${claim.id} and appliesToTarget ${interpretation.appliesToTarget} resolved to ${targetClaim.id}`);
+            }
+        }
+        return claim;
+    }
+    if (!interpretation.appliesToTarget) {
+        throw new Error(`Interpretation ${interpretation.id} needs appliesToClaimId or appliesToTarget`);
+    }
+    return resolveInterpretationTargetClaim(interpretation, claims, input);
+}
+function resolveInterpretationTargetClaim(interpretation, claims, input) {
+    const candidateSetIdsByTarget = new Set(input.candidateSets
+        .filter((candidateSet) => candidateSet.target === interpretation.appliesToTarget)
+        .map((candidateSet) => candidateSet.id));
+    const matches = input.claims.filter((claim) => claim.fieldOrBehavior === interpretation.appliesToTarget ||
+        candidateSetIdsByTarget.has(claim.candidateSetId));
+    const uniqueClaimIds = [...new Set(matches.map((claim) => claim.id))];
+    if (uniqueClaimIds.length === 0) {
+        throw new Error(`Interpretation ${interpretation.id} target ${interpretation.appliesToTarget} did not match any claim`);
+    }
+    if (uniqueClaimIds.length > 1) {
+        throw new Error(`Interpretation ${interpretation.id} target ${interpretation.appliesToTarget} is ambiguous across claims: ${uniqueClaimIds.join(", ")}`);
+    }
+    const claim = claims.find((item) => item.id === uniqueClaimIds[0]);
+    if (!claim)
+        throw new Error(`Interpretation ${interpretation.id} resolved unknown claim ${uniqueClaimIds[0]}`);
+    return claim;
+}
+function buildSurveyMetadata(input) {
+    const producerSurveyMetadata = isRecord(input.projection.metadata?.survey) ? input.projection.metadata.survey : {};
+    const producerCandidateMetadata = isRecord(producerSurveyMetadata.candidate) ? producerSurveyMetadata.candidate : {};
+    return {
+        ...producerSurveyMetadata,
+        rawSourceId: input.rawSource.id,
+        extractionId: input.extraction.id,
+        candidateSetId: input.candidateSet.id,
+        candidateId: input.candidate.id,
+        reviewOutcomeId: input.review?.id,
+        ...(input.candidate.rejectionReason !== undefined
+            ? {
+                candidate: {
+                    ...producerCandidateMetadata,
+                    rejectionReason: input.candidate.rejectionReason,
+                },
+            }
+            : {}),
+        ...(input.review?.withinComfortZone === false
+            ? {
+                comfortZone: {
+                    withinComfortZone: false,
+                    ...(input.review.comfortZoneNote ? { note: input.review.comfortZoneNote } : {}),
+                },
+            }
+            : {}),
+    };
+}
 function statusFor(input) {
     if (input.review)
         return input.review.status;
@@ -173,12 +359,39 @@ function selectReview(reviews, candidateId) {
     return reviews.find((review) => review.candidateId === candidateId) ?? reviews.find((review) => !review.candidateId);
 }
 function evidenceTypeFor(rawSource) {
+    if (rawSource.kind === "policy-standard")
+        return "policy_rule";
     if (rawSource.kind === "uploaded-document")
         return "document_citation";
     if (rawSource.kind === "web-page")
         return "crawl_observation";
     return "attestation";
 }
+function policyStandardFields(rawSource) {
+    const metadata = rawSource.metadata?.policyStandard;
+    const metadataRecord = isRecord(metadata) ? metadata : {};
+    const inlineText = rawSource.inlineText ?? stringValue(metadataRecord.inlineText) ?? stringValue(metadataRecord.text);
+    const standardVersion = rawSource.standardVersion ?? stringValue(metadataRecord.standardVersion) ?? stringValue(metadataRecord.version);
+    const paragraphRef = rawSource.paragraphRef ?? stringValue(metadataRecord.paragraphRef);
+    const reference = stringValue(metadataRecord.reference);
+    if (!inlineText && !standardVersion && !paragraphRef && !reference)
+        return undefined;
+    return {
+        inlineText,
+        standardVersion,
+        paragraphRef,
+        reference,
+    };
+}
+function evidenceExcerptOrSummary(input) {
+    if (input.rawSource.kind === "policy-standard" && input.policyStandard?.inlineText) {
+        return input.policyStandard.inlineText;
+    }
+    return input.extraction.excerpt ?? `Extracted ${input.projection.fieldOrBehavior} from ${input.rawSource.kind}.`;
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : undefined;
+}
 function eventMethodFor(status, candidateSet) {
     if (status === "verified")
         return "survey-review";