@kontourai/survey 1.3.0 → 1.5.0

package/README.md

@@ -79,7 +79,7 @@ const surveyInput = new SurveyInputBuilder({
     claim: {
       subjectType: "public-record.entity",
       subjectId: "listing-123",
-      surface: "public-record.profile",
+      facet: "public-record.profile",
       claimType: "public-data.field",
       fieldOrBehavior: "availabilityStatus",
       impactLevel: "medium",

package/dist/example-data/corrected-document-candidates.js

@@ -143,7 +143,7 @@ function documentClaim(id, target, candidateId, fieldOrBehavior, status) {
         candidateId: `document:candidate:${candidateId}`,
         subjectType: "verified-record.period",
         subjectId: "entity-1:2026",
-        surface: "document-review",
+        facet: "document-review",
         claimType: "source-field",
         fieldOrBehavior,
         status,
@@ -159,7 +159,7 @@ function computationClaim(id, status, inputClaimIds) {
         candidateId: `document:candidate:statement-position:${id}`,
         subjectType: "verified-record.period",
         subjectId: "entity-1:2026",
-        surface: "document-review",
+        facet: "document-review",
         claimType: "computed-field",
         fieldOrBehavior: "statementPosition",
         status,

package/dist/example-data/public-directory-review-resource.d.ts

@@ -45,7 +45,7 @@ export declare const publicDirectoryReviewItemExample: {
                 claimId: string;
                 subjectType: string;
                 subjectId: string;
-                surface: string;
+                facet: string;
                 claimType: string;
                 fieldOrBehavior: string;
                 impactLevel: "medium";
@@ -97,7 +97,7 @@ export declare const publicDirectoryReviewItemExample: {
                 claimId: string;
                 subjectType: string;
                 subjectId: string;
-                surface: string;
+                facet: string;
                 claimType: string;
                 fieldOrBehavior: string;
                 impactLevel: "medium";

package/dist/example-data/public-directory-review-resource.js

@@ -47,7 +47,7 @@ export const publicDirectoryReviewItemExample = {
                     claimId: "public-field.entity-123.availability-status.current",
                     subjectType: "public-record.entity",
                     subjectId: "entity-123",
-                    surface: "public-record.profile",
+                    facet: "public-record.profile",
                     claimType: "public-data.field",
                     fieldOrBehavior: "availabilityStatus",
                     impactLevel: "medium",
@@ -98,7 +98,7 @@ export const publicDirectoryReviewItemExample = {
                     claimId: "public-field.entity-123.availability-status.proposal-456",
                     subjectType: "public-record.entity",
                     subjectId: "entity-123",
-                    surface: "public-record.profile",
+                    facet: "public-record.profile",
                     claimType: "public-data.field-candidate",
                     fieldOrBehavior: "availabilityStatus",
                     impactLevel: "medium",

package/dist/example-data/public-field-review.js

@@ -91,7 +91,7 @@ export const publicFieldReviewExample = {
             candidateId: "public-field:candidate:approved",
             subjectType: "public-record.entity",
             subjectId: "entity-123",
-            surface: "public-record.profile",
+            facet: "public-record.profile",
             claimType: "public-data.field",
             fieldOrBehavior: "availabilityStatus",
             impactLevel: "medium",
@@ -109,7 +109,7 @@ export const publicFieldReviewExample = {
             candidateId: "public-field:candidate:proposal",
             subjectType: "public-record.entity",
             subjectId: "entity-123",
-            surface: "public-record.profile",
+            facet: "public-record.profile",
             claimType: "public-data.field-candidate",
             fieldOrBehavior: "availabilityStatus",
             impactLevel: "medium",

package/dist/example-data/regulated-document-review-resource.d.ts

@@ -48,7 +48,7 @@ export declare const regulatedDocumentReviewItemExample: {
                 claimId: string;
                 subjectType: string;
                 subjectId: string;
-                surface: string;
+                facet: string;
                 claimType: string;
                 fieldOrBehavior: string;
                 impactLevel: "high";
@@ -96,7 +96,7 @@ export declare const regulatedDocumentReviewItemExample: {
                 claimId: string;
                 subjectType: string;
                 subjectId: string;
-                surface: string;
+                facet: string;
                 claimType: string;
                 fieldOrBehavior: string;
                 impactLevel: "high";

package/dist/example-data/regulated-document-review-resource.js

@@ -50,7 +50,7 @@ export const regulatedDocumentReviewItemExample = {
                     claimId: "document.entity-1.statement-position.original",
                     subjectType: "verified-record.period",
                     subjectId: "entity-1:2026",
-                    surface: "document-review",
+                    facet: "document-review",
                     claimType: "computed-field",
                     fieldOrBehavior: "statementPosition",
                     impactLevel: "high",
@@ -102,7 +102,7 @@ export const regulatedDocumentReviewItemExample = {
                     claimId: "document.entity-1.statement-position.current",
                     subjectType: "verified-record.period",
                     subjectId: "entity-1:2026",
-                    surface: "document-review",
+                    facet: "document-review",
                     claimType: "computed-field",
                     fieldOrBehavior: "statementPosition",
                     impactLevel: "high",

package/dist/examples/public-field-observation.js

@@ -30,7 +30,7 @@ const surveyInput = new SurveyInputBuilder({
     claim: {
         subjectType: "public-record.entity",
         subjectId: "entity-1",
-        surface: "public-record.profile",
+        facet: "public-record.profile",
         claimType: "public-data.field",
         fieldOrBehavior: "availabilityStatus",
         impactLevel: "medium",

package/dist/examples/review-workbench/downstream-public-directory-adapter.js

@@ -201,7 +201,7 @@ function candidateClaimTarget(args, claimId) {
         claimId,
         subjectType: "public-record.entity",
         subjectId: args.proposal.publicRecordId,
-        surface: "public-directory.profile",
+        facet: "public-directory.profile",
         claimType: args.role === "current" ? "public-data.field" : "public-data.field-candidate",
         fieldOrBehavior: args.field,
         impactLevel: "medium",

package/dist/src/agent-utterance.d.ts

@@ -96,6 +96,30 @@ export interface UtteranceStatementRecords {
     candidate: Candidate;
     candidateSet: CandidateSet;
 }
+interface BuildUtteranceRecordsParams {
+    sourceId: string;
+    utterance: string;
+    extracted: ExtractedStatement[];
+    extractorName: string;
+    observedAt: string;
+}
+interface UtteranceRecordsResult {
+    records: UtteranceStatementRecords[];
+    extractions: Extraction[];
+    candidateSets: CandidateSet[];
+}
+/**
+ * Build the full set of Survey records for every extracted statement in one
+ * utterance: per-statement Extractions/Candidates plus per-target grouped
+ * Candidate Sets. This is the shared orchestrator both `utteranceToSurveyInput`
+ * and `surveyAgentUtterance` call, so both callers derive these records
+ * identically — Slice 1's "single derivation path" invariant, preserved.
+ *
+ * `records[idx]` corresponds to `extracted[idx]` for every idx — `items` and
+ * `records` are both built via `.map` over the same `extracted[]` array in
+ * the same order; only `candidateSets` is deduped/grouped by target.
+ */
+export declare function buildUtteranceRecords(params: BuildUtteranceRecordsParams): UtteranceRecordsResult;
 /**
  * Project an agent utterance and its extracted statements into the standard
  * SurveyInput shape so they can flow into buildSurveyTrustBundle.
@@ -164,3 +188,4 @@ export declare function surveyAgentUtterance(utterance: string, extractor: Utter
  * alone in this reference implementation.
  */
 export declare const referenceUtteranceExtractor: UtteranceClaimExtractor;
+export {};

package/dist/src/agent-utterance.js

@@ -18,6 +18,177 @@
  */
 import { resolveInquiry } from "@kontourai/surface";
 import { lookupMapping, resolveQuestion } from "./inquiry-mapping.js";
+import { projectProposalsToCandidateSet } from "./producer-profile.js";
+/**
+ * The Candidate Conflict comparison key for an utterance-proposed value.
+ *
+ * Neither extractor (the reference extractor below, nor the Anthropic-backed
+ * one in `./anthropic.js`) normalizes `value` before it reaches
+ * `ExtractedStatement` — case and internal formatting are preserved
+ * verbatim. String values are the only case where "representation noise"
+ * (leading/trailing whitespace from excerpt boundaries, incidental case
+ * differences like "Healthy" vs "healthy") is plausible given the two
+ * extractors' actual output, so this key trims + lowercases STRING values
+ * in the COMPARISON KEY ONLY — the stored `Candidate.value`/`Extraction.value`
+ * stay byte-for-byte verbatim; this function only feeds `equivalenceKey`,
+ * never `value`. Non-string values (number, boolean, null — the other types
+ * the Anthropic tool schema permits) compare via exact canonical
+ * `JSON.stringify`, so there is no cross-type coercion that could silently
+ * equate e.g. "5" and 5, or lose a genuine numeric disagreement (5 vs 6 is
+ * never noise). This mirrors the Producer Profile core's established
+ * pattern: each profile decides its own narrow equivalence definition
+ * (see `./producer-profile.js`); the core itself does not own this decision.
+ */
+function utteranceEquivalenceKey(value) {
+    const normalized = value ?? null;
+    if (typeof normalized === "string") {
+        return `str:${normalized.trim().toLowerCase()}`;
+    }
+    return `json:${JSON.stringify(normalized)}`;
+}
+/**
+ * Build the Extraction and CandidateSetProposal for a single extracted
+ * statement. This centralizes the Source Locator rule (span-first,
+ * excerpt-fallback — the single locator rule this module guarantees) and
+ * hands the resulting proposal off to `groupUtteranceExtractionsByTarget`
+ * for per-target projection through the Producer Profile core.
+ */
+function buildUtteranceExtraction(params) {
+    const { sourceId, idx, statement, utterance, extractorName, observedAt } = params;
+    const statementId = `${sourceId}.statement.${idx}`;
+    const extractionId = `${statementId}.extraction`;
+    const candidateId = `${statementId}.candidate`;
+    // Compute locator — required for non-manual-entry sources
+    // (assertProducerDiscipline throws without it). Source Locator rule:
+    // span-first, excerpt-fallback — UNCHANGED from Slice 1.
+    const locator = spanToLocator(statement.span) ?? excerptLocator(utterance, statement.excerpt);
+    const extraction = {
+        id: extractionId,
+        sourceId,
+        target: canonicalTargetKey(statement.target),
+        value: statement.value ?? null,
+        confidence: statement.confidence,
+        locator,
+        excerpt: statement.excerpt,
+        extractor: extractorName,
+        extractedAt: observedAt,
+        metadata: {
+            agentUtterance: {
+                span: statement.span,
+                excerpt: statement.excerpt,
+                extractorName,
+                confidence: statement.confidence,
+            },
+        },
+    };
+    const proposal = {
+        candidateId,
+        extractionId,
+        value: statement.value ?? null,
+        confidence: statement.confidence,
+        equivalenceKey: utteranceEquivalenceKey(statement.value),
+        metadata: {
+            span: statement.span,
+            excerpt: statement.excerpt,
+            extractorName,
+            confidence: statement.confidence,
+        },
+    };
+    return { extraction, proposal };
+}
+/**
+ * Group extraction/proposal pairs by canonical target and project each
+ * group through the Producer Profile core's `projectProposalsToCandidateSet`
+ * — one Candidate Set per target, carrying every statement's Candidate for
+ * that target. Status is `"conflict"` when the group's statements disagree
+ * under `utteranceEquivalenceKey`, `"needs-review"` otherwise (including the
+ * common single-statement case, which reproduces Slice 1's exact prior
+ * per-statement behavior).
+ *
+ * `Map` preserves insertion order, so the returned groups (and therefore the
+ * `candidateSets` array `buildUtteranceRecords` derives from them) are in
+ * deterministic first-occurrence-of-target order across the utterance's
+ * statements.
+ */
+function groupUtteranceExtractionsByTarget(sourceId, items) {
+    const order = [];
+    const byTarget = new Map();
+    for (const item of items) {
+        const key = canonicalTargetKey(item.statement.target);
+        if (!byTarget.has(key)) {
+            byTarget.set(key, []);
+            order.push(key);
+        }
+        byTarget.get(key).push(item);
+    }
+    const groups = new Map();
+    for (const targetKey of order) {
+        const groupItems = byTarget.get(targetKey);
+        const first = groupItems[0].statement.target;
+        const proposals = groupItems.map((i) => i.proposal);
+        const { candidateSet, candidates } = projectProposalsToCandidateSet(targetKey, proposals, {
+            candidateSetId: `${sourceId}.target.${targetKey}.candidate-set`,
+            candidateSetMetadata: {
+                agentUtterance: {
+                    target: {
+                        subjectType: first.subjectType,
+                        subjectId: first.subjectId,
+                        fieldOrBehavior: first.fieldOrBehavior,
+                    },
+                    statementCount: proposals.length,
+                },
+            },
+            candidateSetRationale: (status, groupProposals) => status === "conflict"
+                ? `${groupProposals.length} statement(s) disagree for ${targetKey}: ${[...new Set(groupProposals.map((p) => p.equivalenceKey))].join(", ")}`
+                : `${groupProposals.length} statement(s) agree for ${targetKey}.`,
+        });
+        // Mirrors schema-mapping's post-core convention: a winner only exists
+        // when the group agrees; a conflicting group has no selected candidate
+        // yet (nothing to select — that's the point of a Candidate Conflict,
+        // CONTEXT.md's "Candidate Conflict" entry). For a single-statement group
+        // this reproduces Slice 1's exact old behavior (selectedCandidateId ===
+        // the one candidate's id).
+        candidateSet.selectedCandidateId = candidateSet.status !== "conflict" ? candidates[0]?.id : undefined;
+        groups.set(targetKey, { targetKey, candidateSet, candidates });
+    }
+    return groups;
+}
+/**
+ * Build the full set of Survey records for every extracted statement in one
+ * utterance: per-statement Extractions/Candidates plus per-target grouped
+ * Candidate Sets. This is the shared orchestrator both `utteranceToSurveyInput`
+ * and `surveyAgentUtterance` call, so both callers derive these records
+ * identically — Slice 1's "single derivation path" invariant, preserved.
+ *
+ * `records[idx]` corresponds to `extracted[idx]` for every idx — `items` and
+ * `records` are both built via `.map` over the same `extracted[]` array in
+ * the same order; only `candidateSets` is deduped/grouped by target.
+ */
+export function buildUtteranceRecords(params) {
+    const { sourceId, utterance, extracted, extractorName, observedAt } = params;
+    const items = extracted.map((statement, idx) => {
+        const { extraction, proposal } = buildUtteranceExtraction({
+            sourceId,
+            idx,
+            statement,
+            utterance,
+            extractorName,
+            observedAt,
+        });
+        return { statement, extraction, proposal };
+    });
+    const groups = groupUtteranceExtractionsByTarget(sourceId, items);
+    const records = items.map((item) => {
+        const group = groups.get(canonicalTargetKey(item.statement.target));
+        const candidate = group.candidates.find((c) => c.id === item.proposal.candidateId);
+        return { extraction: item.extraction, candidate, candidateSet: group.candidateSet };
+    });
+    return {
+        records,
+        extractions: items.map((i) => i.extraction),
+        candidateSets: [...groups.values()].map((g) => g.candidateSet),
+    };
+}
 // ---------------------------------------------------------------------------
 // SurveyInput projection
 // ---------------------------------------------------------------------------
@@ -60,80 +231,35 @@ export function utteranceToSurveyInput(utterance, extracted, context) {
         inlineText: utterance,
         metadata: { agentId },
     };
-    const extractions = [];
-    const candidateSets = [];
-    const claims = [];
-    for (let idx = 0; idx < extracted.length; idx++) {
-        const statement = extracted[idx];
+    // Batched, per-target-grouped provenance construction (Producer Profile
+    // core) — replaces the old per-statement builder call. Claims below stay
+    // one-per-statement; `record.candidateSet.id`/`record.candidate.id` may be
+    // shared across several claims when statements share a target (legal).
+    const { records, extractions, candidateSets } = buildUtteranceRecords({
+        sourceId,
+        utterance,
+        extracted,
+        extractorName,
+        observedAt,
+    });
+    const claims = extracted.map((statement, idx) => {
         const statementId = `${sourceId}.statement.${idx}`;
-        const extractionId = `${statementId}.extraction`;
-        const candidateId = `${statementId}.candidate`;
-        const candidateSetId = `${statementId}.candidate-set`;
         const claimId = `${statementId}.claim`;
-        // Compute locator — required for non-manual-entry sources
-        // (assertProducerDiscipline throws without it)
-        const locator = spanToLocator(statement.span) ?? excerptLocator(utterance, statement.excerpt);
-        const extraction = {
-            id: extractionId,
-            sourceId,
-            target: canonicalTargetKey(statement.target),
-            value: statement.value ?? null,
-            confidence: statement.confidence,
-            locator,
-            excerpt: statement.excerpt,
-            extractor: extractorName,
-            extractedAt: observedAt,
-            metadata: {
-                agentUtterance: {
-                    span: statement.span,
-                    excerpt: statement.excerpt,
-                    extractorName,
-                    confidence: statement.confidence,
-                },
-            },
-        };
-        const candidate = {
-            id: candidateId,
-            extractionId,
-            value: statement.value ?? null,
-            confidence: statement.confidence,
-            metadata: {
-                agentUtterance: {
-                    span: statement.span,
-                    excerpt: statement.excerpt,
-                    extractorName,
-                    confidence: statement.confidence,
-                },
-            },
-        };
-        // needs-review status → statusFor returns "proposed" (no review outcome)
-        const candidateSet = {
-            id: candidateSetId,
-            target: canonicalTargetKey(statement.target),
-            candidates: [candidate],
-            selectedCandidateId: candidateId,
-            status: "needs-review",
-            metadata: {
-                agentUtterance: {
-                    subjectType: statement.target.subjectType,
-                    subjectId: statement.target.subjectId,
-                    fieldOrBehavior: statement.target.fieldOrBehavior,
-                },
-            },
-        };
-        // Unreviewed: status is omitted so statusFor() computes "proposed"
-        // assertProducerDiscipline: no verified/assumed without review → compliant
-        const claimTarget = {
+        const record = records[idx];
+        // Unreviewed: status is omitted so statusFor() computes "proposed" (or
+        // "disputed" for a claim whose shared candidateSet.status is "conflict").
+        // assertProducerDiscipline: no verified/assumed without review → compliant.
+        return {
             id: claimId,
-            candidateSetId,
-            candidateId,
+            candidateSetId: record.candidateSet.id,
+            candidateId: record.candidate.id,
             subjectType: statement.target.subjectType,
             subjectId: statement.target.subjectId,
-            surface: "agent-utterance.profile",
+            facet: "agent-utterance.profile",
             claimType: "agent-extraction",
             fieldOrBehavior: statement.target.fieldOrBehavior,
             value: statement.value,
-            // status intentionally omitted → computed as "proposed" by statusFor
+            // status intentionally omitted → computed by statusFor
             impactLevel: "low",
             collectedBy: extractorName,
             metadata: {
@@ -144,15 +270,12 @@ export function utteranceToSurveyInput(utterance, extracted, context) {
                         excerpt: statement.excerpt,
                         span: statement.span,
                         confidence: statement.confidence,
-                        locator,
+                        locator: record.extraction.locator,
                     },
                 },
             },
         };
-        extractions.push(extraction);
-        candidateSets.push(candidateSet);
-        claims.push(claimTarget);
-    }
+    });
     return {
         source,
         generatedAt: observedAt,
@@ -196,31 +319,22 @@ export async function surveyAgentUtterance(utterance, extractor, context) {
     };
     // Step 2: Extract statements
     const extracted = await Promise.resolve(extractor.extract(utterance));
+    // Batched, grouped provenance construction — kept for provenance/doc-comment
+    // fidelity across the whole utterance (grouping needs every statement of a
+    // target's group present at once; a per-statement call cannot compute it).
+    // Still not surfaced on UtteranceStatement/UtteranceTrustReport this slice
+    // (unchanged from Slice 1's own scoping note) — wiring is left for a future
+    // slice, same as before.
+    buildUtteranceRecords({
+        sourceId,
+        utterance,
+        extracted,
+        extractorName: extractor.name,
+        observedAt,
+    });
     // Step 3 & 4: Resolve each statement and build the report
     const statements = [];
     for (const statement of extracted) {
-        const statementId = `${sourceId}.statement.${statements.length}`;
-        // Build Survey records for provenance
-        const extractionId = `${statementId}.extraction`;
-        const extraction = {
-            id: extractionId,
-            sourceId,
-            target: canonicalTargetKey(statement.target),
-            value: statement.value ?? null,
-            confidence: statement.confidence,
-            locator: statement.span ? `text-span:${statement.span.start}-${statement.span.end}` : undefined,
-            excerpt: statement.excerpt,
-            extractor: extractor.name,
-            extractedAt: observedAt,
-            metadata: {
-                agentUtterance: {
-                    span: statement.span,
-                    excerpt: statement.excerpt,
-                    extractorName: extractor.name,
-                    confidence: statement.confidence,
-                },
-            },
-        };
         // Resolve the claim
         let inquiryRecord;
         if (mappings && mappings.length > 0) {
@@ -253,8 +367,6 @@ export async function surveyAgentUtterance(utterance, extractor, context) {
             inquiryRecord,
             badge,
         });
-        // Suppress unused-variable warning for extraction
-        void extraction;
     }
     return { source, statements };
 }

package/dist/src/console/review-console-server.js

@@ -15,8 +15,8 @@ import { watch } from "node:fs";
 import { readFile as readFileAsync, writeFile as writeFileAsync, rename as renameAsync } from "node:fs/promises";
 import { resolve, join, dirname, extname, normalize, sep } from "node:path";
 import { fileURLToPath } from "node:url";
-import { replayReviewSessionEvents, defaultReviewSessionName, } from "../review-workbench/review-workbench.js";
-import { createServerReviewSessionRecord, deriveServerReviewSessionApplyResult, } from "../review-workbench/server-review-session.js";
+import { defaultReviewSessionName, } from "../review-workbench/review-workbench.js";
+import { createServerReviewSessionRecord, currentSessionState, deriveServerReviewSessionApplyResult, } from "../review-workbench/server-review-session.js";
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
@@ -63,10 +63,6 @@ async function writeSessionAtomic(path, content) {
     await writeFileAsync(tmp, JSON.stringify(content, null, 2), "utf8");
     await renameAsync(tmp, path);
 }
-function currentState(content) {
-    const { snapshot, events } = content;
-    return events.length > 0 ? replayReviewSessionEvents(snapshot, events) : snapshot;
-}
 // ---------------------------------------------------------------------------
 // SSE broadcaster
 // ---------------------------------------------------------------------------
@@ -496,7 +492,7 @@ export async function startReviewConsoleServer(options) {
                     session: content.session,
                     snapshot: content.snapshot,
                     events: content.events,
-                    state: currentState(content),
+                    state: currentSessionState(content.snapshot, content.events),
                 });
                 return;
             }

package/dist/src/field-observation.d.ts

@@ -1,20 +1,6 @@
 import type { SurveyObservationInput } from "./builder.js";
-export interface FieldObservationInput<TValue> {
-    id: string;
-    field: string;
-    value: TValue;
-    rawSource: SurveyObservationInput["rawSource"];
-    extraction: Omit<SurveyObservationInput["extraction"], "target" | "value" | "excerpt"> & {
-        target?: string;
-        excerpt?: string | null;
-    };
-    reviewOutcome?: SurveyObservationInput["reviewOutcome"];
-    claim: Omit<SurveyObservationInput["claim"], "fieldOrBehavior" | "value"> & {
-        fieldOrBehavior?: string;
-    };
-    candidate?: SurveyObservationInput["candidate"];
-    candidateSet?: SurveyObservationInput["candidateSet"];
+import { type ObservationAuthoringInput } from "./observation-helper.js";
+export interface FieldObservationInput<TValue> extends ObservationAuthoringInput<TValue> {
     representation?: "scalar";
-    metadata?: Record<string, unknown>;
 }
 export declare function fieldObservation<TValue>(input: FieldObservationInput<TValue>): SurveyObservationInput;

package/dist/src/field-observation.js

@@ -1,16 +1,4 @@
-import { buildObservation } from "./observation-helper.js";
+import { buildFieldObservation } from "./observation-helper.js";
 export function fieldObservation(input) {
-    const representation = input.representation ?? "scalar";
-    return buildObservation({
-        ...input,
-        surveyMetadata: {
-            field: { representation },
-        },
-        defaultExcerpt: `${input.field}: ${valueSummary(input.value)}`,
-    });
-}
-function valueSummary(value) {
-    if (value === null || value === undefined)
-        return "<empty>";
-    return String(value);
+    return buildFieldObservation(input);
 }

package/dist/src/index.d.ts

@@ -33,7 +33,7 @@ export type { MappingProposalRecord, ReviewedMapping, SchemaMappingExtractor, Sc
 export { buildAuthorizedActionAuthorizing, buildPromptRef, isValidAuthorizing, validateAuthorizing } from "./review-authorizing.js";
 export type { BuildAuthorizedActionAuthorizingInput, BuildPromptRefInput, ReviewAuthorizingIssue, ReviewAuthorizingIssueCode, } from "./review-authorizing.js";
 export { confidenceBasisForReview, defineProductVocabulary, stableId } from "./vocabulary.js";
-export type { ConfidenceBasisForReviewInput, ProductVocabularyDefinition, } from "./vocabulary.js";
+export type { ConfidenceBasisForReviewInput, ProductVocabularyDefinition, ProductVocabularyInput, } from "./vocabulary.js";
 export { currentProposedReviewItem } from "./current-proposed-review-item.js";
 export type { CurrentProposedCandidateInput, CurrentProposedReviewItemInput, } from "./current-proposed-review-item.js";
 export { deriveOversightMetrics, mergeTrustBundleWithOversightMetrics, oversightMetricsToClaims, } from "./oversight-metrics.js";