@kontourai/survey 0.4.3 → 0.4.4

package/dist/examples/review-workbench/review-workbench.js

@@ -0,0 +1,488 @@
+import { candidateForDecision, currentReviewItem, currentReviewWorkbenchState, deriveQueueRowStatus, initialReviewQueueSessionState, nextUnresolvedItemName, reviewSessionSummary, selectedCandidateRole, workbenchDecisionDefinitions, } from "./review-queue-session.js";
+import { buildSurfaceProjectionPreview, formatValue, } from "./review-surface-preview.js";
+import { reviewResourceApiVersion, } from "../../src/review-resource.js";
+export { candidateForDecision, currentReviewItem, currentReviewWorkbenchState, deriveQueueRowStatus, initialReviewQueueSessionState, initialReviewWorkbenchState, nextUnresolvedItemName, reviewSessionSummary, selectedCandidateRole, workbenchDecisionDefinitions, } from "./review-queue-session.js";
+export { buildSurfaceProjectionPreview, } from "./review-surface-preview.js";
+export function buildReviewDecision(state) {
+    if (!state.decision) {
+        return undefined;
+    }
+    const definition = workbenchDecisionDefinitions[state.decision];
+    const candidate = candidateForDecision(state.item, state.decision);
+    const projection = {
+        ...candidate.projection,
+        reviewOutcomeId: candidate.projection?.reviewOutcomeId
+            ?? `${state.item.metadata.name}:${state.decision}:review-outcome`,
+    };
+    return {
+        apiVersion: reviewResourceApiVersion,
+        kind: "ReviewDecision",
+        metadata: {
+            name: `${state.item.metadata.name}-${state.decision}`,
+            labels: state.item.metadata.labels,
+            producer: state.item.metadata.producer,
+        },
+        spec: {
+            reviewItemName: state.item.metadata.name,
+            candidateId: candidate.id,
+            status: definition.status,
+            actor: {
+                id: state.actorId,
+            },
+            reviewedAt: state.reviewedAt,
+            rationale: state.note,
+            projection,
+        },
+        status: {
+            appliedToClaimIds: candidate.projection?.claimId ? [candidate.projection.claimId] : undefined,
+        },
+    };
+}
+export function renderReviewWorkbenchHtml(state) {
+    if ("items" in state) {
+        return renderReviewQueueSessionHtml(state);
+    }
+    return `
+    <section class="workbench-shell" aria-label="Survey review workbench">
+      ${renderWorkbenchHeader(state)}
+      <div class="content-grid">
+        ${renderCandidateComparison(state)}
+        ${renderDecisionColumn(state)}
+      </div>
+    </section>
+  `;
+}
+function renderReviewQueueSessionHtml(session) {
+    const state = currentReviewWorkbenchState(session);
+    return `
+    <section class="workbench-shell" aria-label="Survey review workbench">
+      ${renderWorkbenchHeader(state)}
+      <div class="queue-layout">
+        <aside class="queue-panel" aria-label="Review queue">
+          ${renderQueueRows(session)}
+          ${renderSessionSummary(session)}
+        </aside>
+        <div class="content-grid">
+          ${renderCandidateComparison(state)}
+          ${renderDecisionColumn(state)}
+        </div>
+      </div>
+    </section>
+  `;
+}
+function renderQueueRows(session) {
+    return `
+    <section class="queue-list" data-testid="review-queue">
+      <div class="queue-head">
+        <h2>Review queue</h2>
+        <button class="next-button" type="button" data-testid="next-unresolved">Next unresolved</button>
+      </div>
+      ${session.items.map((item) => renderQueueRow(item, session)).join("")}
+    </section>
+  `;
+}
+function renderQueueRow(item, session) {
+    const status = deriveQueueRowStatus(item, session);
+    const isActive = item.metadata.name === session.activeItemName;
+    return `
+    <button class="queue-row${isActive ? " is-active" : ""}" type="button" data-item-name="${escapeHtml(item.metadata.name)}" data-testid="queue-row" data-queue-status="${status}">
+      <span class="queue-row-main">
+        <span class="queue-row-title">${escapeHtml(item.metadata.name)}</span>
+        <span class="queue-row-target">${escapeHtml(item.spec.target)}</span>
+      </span>
+      <span class="state-label">${escapeHtml(status)}</span>
+    </button>
+  `;
+}
+function renderSessionSummary(session) {
+    const summary = reviewSessionSummary(session);
+    return `
+    <section class="session-summary" data-testid="session-summary">
+      <h2>Session summary</h2>
+      <dl class="summary-grid">
+        ${metaItem("Accepted", String(summary.accepted))}
+        ${metaItem("Kept current", String(summary.keptCurrent))}
+        ${metaItem("Rejected", String(summary.rejected))}
+        ${metaItem("Escalated", String(summary.escalated))}
+        ${metaItem("Unresolved", String(summary.unresolved))}
+      </dl>
+    </section>
+  `;
+}
+function renderWorkbenchHeader(state) {
+    return `
+    <header class="topbar">
+      <div>
+        <p class="eyebrow">${escapeHtml(String(state.item.metadata.producer?.displayName ?? "Survey"))}</p>
+        <h1>${escapeHtml(state.item.metadata.name)}</h1>
+      </div>
+      <dl class="meta-grid">
+        ${metaItem("Target", state.item.spec.target)}
+        ${metaItem("Status", state.item.spec.candidateSetStatus ?? "unresolved")}
+        ${metaItem("Selected", state.item.spec.selectedCandidateId ?? "none")}
+        ${metaItem("Candidate count", String(state.item.status?.observedCandidateCount ?? state.item.spec.candidates.length))}
+      </dl>
+    </header>
+  `;
+}
+function renderCandidateComparison(state) {
+    const current = candidateByRole(state.item, "current");
+    const proposed = candidateByRole(state.item, "proposed");
+    return `
+    <section class="candidate-grid" aria-label="Candidate comparison">
+      ${renderCandidateCard(current, state)}
+      ${renderCandidateCard(proposed, state)}
+    </section>
+  `;
+}
+function renderDecisionColumn(state) {
+    return `
+    <aside class="decision-column" aria-label="Review decision">
+      ${renderDecisionControls(state)}
+      ${renderSurfacePreview(state)}
+      ${renderDecisionPayload(state)}
+    </aside>
+  `;
+}
+function renderDecisionControls(state) {
+    const activeDefinition = state.decision ? workbenchDecisionDefinitions[state.decision] : undefined;
+    return `
+    <section class="decision-row">
+      <label class="field">
+        <span class="field-label">Reviewer note</span>
+        <textarea id="reviewer-note" data-testid="reviewer-note">${escapeHtml(state.note)}</textarea>
+      </label>
+      <div class="decision-buttons">
+        ${renderDecisionButtons(state)}
+      </div>
+      <div class="effect" data-testid="decision-effect">
+        <span class="field-label">Decision effect</span>
+        <span class="field-value">${escapeHtml(activeDefinition?.effect ?? "No decision selected.")}</span>
+      </div>
+      ${renderFeedbackTags(state)}
+    </section>
+  `;
+}
+function renderFeedbackTags(state) {
+    const tags = producerFeedbackTags(state.item);
+    return `
+    <div class="feedback-tags" data-testid="producer-feedback-tags">
+      <span class="field-label">Producer feedback tags</span>
+      <div class="tag-row">
+        ${tags.length === 0 ? "<span class=\"tag is-empty\">none</span>" : tags.map((tag) => `<span class="tag">${escapeHtml(tag)}</span>`).join("")}
+      </div>
+    </div>
+  `;
+}
+function renderDecisionButtons(state) {
+    return Object.entries(workbenchDecisionDefinitions).map(([key, definition]) => `
+    <button class="decision-button${state.decision === key ? " is-active" : ""}" type="button" data-decision="${key}">
+      ${escapeHtml(definition.label)}
+    </button>
+  `).join("");
+}
+function renderDecisionPayload(state) {
+    const decision = buildReviewDecision(state);
+    return `
+    <section class="payload-panel">
+      <h2 class="field-label">ReviewDecision payload</h2>
+      <pre data-testid="decision-payload">${escapeHtml(JSON.stringify(decision ?? null, null, 2))}</pre>
+    </section>
+  `;
+}
+function renderSurfacePreview(state) {
+    const preview = buildSurfaceProjectionPreview(state.item, buildReviewDecision(state));
+    return preview ? renderPopulatedSurfacePreview(preview) : renderPendingSurfacePreview();
+}
+function renderPendingSurfacePreview() {
+    return `
+    <section class="surface-preview" data-testid="surface-preview" aria-label="Surface preview">
+      <div class="surface-head">
+        <h2>Surface preview</h2>
+        <span class="state-label">pending</span>
+      </div>
+      <p class="preview-disclaimer">Choose a review decision to preview the source and review posture that would project toward Surface. Survey does not validate real-world truth.</p>
+    </section>
+  `;
+}
+function renderPopulatedSurfacePreview(preview) {
+    return `
+    <section class="surface-preview" data-testid="surface-preview" aria-label="Surface preview">
+      <div class="surface-head">
+        <h2>Surface preview</h2>
+        <span class="state-label">local preview</span>
+      </div>
+      <p class="preview-disclaimer" data-testid="surface-preview-disclaimer">${escapeHtml(preview.postureDisclaimer)}</p>
+      <div class="preview-section-grid">
+        ${renderSurfacePreviewSections(preview)}
+      </div>
+    </section>
+  `;
+}
+function renderSurfacePreviewSections(preview) {
+    return [
+        renderCanonicalClaim(preview),
+        renderCandidateHistory(preview),
+        renderSourceEvidence(preview),
+        renderReviewEvent(preview),
+        renderIntegrityPosture(preview),
+        renderAuthorityTrace(preview),
+    ].join("");
+}
+function renderCanonicalClaim(preview) {
+    return renderPreviewSection("Selected canonical claim", "surface-canonical-claim", [
+        ["Candidate", preview.canonicalClaim.candidateId],
+        ["Claim", preview.canonicalClaim.claimId],
+        ["Value", preview.canonicalClaim.value],
+        ["Review status", preview.canonicalClaim.status],
+    ]);
+}
+function renderReviewEvent(preview) {
+    return renderPreviewSection("Review event", "surface-review-event", [
+        ["Actor", preview.reviewEvent?.actor ?? "unknown"],
+        ["Reviewed at", preview.reviewEvent?.reviewedAt ?? "not recorded"],
+        ["Status", preview.reviewEvent?.status ?? "pending"],
+        ["Rationale", preview.reviewEvent?.rationale ?? "No reviewer rationale provided."],
+        ["Outcome", preview.reviewEvent?.reviewOutcomeId ?? "not provided"],
+    ]);
+}
+function renderIntegrityPosture(preview) {
+    return renderPreviewSection("Integrity posture", "surface-integrity-posture", [
+        ["Candidate set", preview.integrityPosture.candidateSetId],
+        ["Raw source", preview.integrityPosture.rawSourceId],
+        ["Extraction", preview.integrityPosture.extractionId],
+        ["Checksum", preview.integrityPosture.checksum],
+    ]);
+}
+function renderAuthorityTrace(preview) {
+    return renderPreviewSection("Authority trace", "surface-authority-trace", [
+        ["Status", preview.authorityTrace.label],
+        ["Detail", preview.authorityTrace.detail],
+    ], preview.authorityTrace.status === "empty" ? " is-neutral" : "");
+}
+function renderCandidateHistory(preview) {
+    const rows = preview.candidateHistory.length === 0
+        ? [["History", "No unselected candidates."]]
+        : preview.candidateHistory.flatMap((candidate) => [
+            ["History", candidate.historyLabel],
+            ["Candidate", candidate.candidateId],
+            ["Value", candidate.value],
+        ]);
+    return renderPreviewSection("Unselected candidate history", "surface-candidate-history", rows);
+}
+function renderSourceEvidence(preview) {
+    const rows = [
+        ["Source URL", preview.sourceEvidence.sourceRef],
+        ["Source ref", preview.sourceEvidence.sourceId],
+        ["Excerpt", preview.sourceEvidence.excerpt],
+        ["Extraction", preview.sourceEvidence.extractionId],
+        ["Extractor", preview.sourceEvidence.extractor],
+        ["Observed", preview.sourceEvidence.observedAt],
+    ];
+    if (preview.sourceEvidence.sourceAuthority) {
+        rows.push(["Source authority class", preview.sourceEvidence.sourceAuthority.authorityClass], ["Declared by", preview.sourceEvidence.sourceAuthority.declaredBy], ["Authority scope", preview.sourceEvidence.sourceAuthority.scope]);
+    }
+    return renderPreviewSection("Source evidence", "surface-source-evidence", rows);
+}
+function renderPreviewSection(title, testId, rows, extraClass = "") {
+    return `
+    <section class="preview-section${extraClass}" data-testid="${testId}">
+      <h3>${escapeHtml(title)}</h3>
+      <dl class="field-stack compact">
+        ${rows.map(([label, value]) => fieldItem(label, value)).join("")}
+      </dl>
+    </section>
+  `;
+}
+export function mountReviewWorkbench(root, startState = initialReviewQueueSessionState()) {
+    const controller = createReviewWorkbenchController(root, startState);
+    controller.renderCurrentState();
+}
+function createReviewWorkbenchController(root, startState) {
+    let session = queueSessionFromStartState(startState);
+    const applySessionUpdate = (update) => {
+        session = update(session);
+    };
+    const selectDecision = (decision) => {
+        applySessionUpdate((current) => ({
+            ...current,
+            decisionsByItemName: {
+                ...current.decisionsByItemName,
+                [currentReviewItem(current).metadata.name]: decision,
+            },
+        }));
+    };
+    const controller = {
+        currentState: () => currentReviewWorkbenchState(session),
+        goToNextUnresolved: () => applyNextUnresolvedSessionUpdate(applySessionUpdate, session),
+        renderCurrentState: () => renderCurrentState(root, session, controller),
+        selectDecision,
+        selectQueueItem: (itemName) => applySessionUpdate((current) => ({ ...current, activeItemName: itemName })),
+        updateReviewerNote: (note) => applyReviewerNoteSessionUpdate(applySessionUpdate, session, note),
+    };
+    return controller;
+}
+function applyReviewerNoteSessionUpdate(applySessionUpdate, session, note) {
+    const itemName = currentReviewItem(session).metadata.name;
+    applySessionUpdate((current) => ({
+        ...current,
+        notesByItemName: {
+            ...current.notesByItemName,
+            [itemName]: note,
+        },
+    }));
+}
+function applyNextUnresolvedSessionUpdate(applySessionUpdate, session) {
+    const next = nextUnresolvedItemName(session);
+    if (next) {
+        applySessionUpdate((current) => ({ ...current, activeItemName: next }));
+    }
+}
+function renderCurrentState(root, session, controller) {
+    root.innerHTML = renderReviewWorkbenchHtml(session);
+    bindReviewerNote(root, controller.updateReviewerNote, controller.currentState, controller.renderCurrentState);
+    bindDecisionButtons(root, (decision) => {
+        controller.selectDecision(decision);
+        controller.renderCurrentState();
+    });
+    bindQueueRows(root, (itemName) => {
+        controller.selectQueueItem(itemName);
+        controller.renderCurrentState();
+    });
+    bindNextUnresolved(root, () => {
+        controller.goToNextUnresolved();
+        controller.renderCurrentState();
+    });
+}
+function queueSessionFromStartState(startState) {
+    if ("items" in startState) {
+        return startState;
+    }
+    return {
+        items: [startState.item],
+        activeItemName: startState.item.metadata.name,
+        notesByItemName: startState.note ? { [startState.item.metadata.name]: startState.note } : {},
+        decisionsByItemName: startState.decision ? { [startState.item.metadata.name]: startState.decision } : {},
+        reviewedAt: startState.reviewedAt,
+        actorId: startState.actorId,
+    };
+}
+function bindReviewerNote(root, updateReviewerNote, currentState, renderCurrentState) {
+    root.querySelector("[data-testid='reviewer-note']")?.addEventListener("input", (event) => {
+        updateReviewerNote(event.target.value);
+        refreshDecisionOutputs(root, currentState(), renderCurrentState);
+    });
+}
+function bindDecisionButtons(root, selectDecision) {
+    root.querySelectorAll("[data-decision]").forEach((button) => {
+        button.addEventListener("click", () => {
+            selectDecision(button.dataset.decision);
+        });
+    });
+}
+function bindQueueRows(root, selectQueueItem) {
+    root.querySelectorAll("[data-item-name]").forEach((button) => {
+        button.addEventListener("click", () => {
+            selectQueueItem(button.dataset.itemName ?? "");
+        });
+    });
+}
+function bindNextUnresolved(root, goToNextUnresolved) {
+    root.querySelector("[data-testid='next-unresolved']")?.addEventListener("click", goToNextUnresolved);
+}
+function refreshDecisionOutputs(root, state, renderCurrentState) {
+    const payload = root.querySelector("[data-testid='decision-payload']");
+    if (payload) {
+        payload.textContent = JSON.stringify(buildReviewDecision(state) ?? null, null, 2);
+    }
+    const preview = root.querySelector("[data-testid='surface-preview']");
+    if (!preview) {
+        return;
+    }
+    if (typeof document === "undefined") {
+        renderCurrentState();
+        return;
+    }
+    const wrapper = document.createElement("div");
+    wrapper.innerHTML = renderSurfacePreview(state);
+    preview.replaceWith(wrapper.firstElementChild);
+}
+function producerFeedbackTags(item) {
+    const tags = item.spec.producerPolicy?.feedbackTags;
+    return Array.isArray(tags) ? tags.map(String) : [];
+}
+function renderCandidateCard(candidate, state) {
+    const selectedRole = selectedCandidateRole(state);
+    const candidateState = state.decision
+        ? candidate.role === selectedRole ? "selected" : "unselected"
+        : "pending";
+    const cssState = candidateState === "selected" ? " is-selected" : candidateState === "unselected" ? " is-unselected" : "";
+    const confidence = candidate.extraction.confidence ?? candidate.confidence;
+    return `
+    <article class="candidate-card${cssState}" data-testid="candidate-${escapeHtml(candidate.role ?? candidate.id)}" data-outcome="${candidateState}">
+      <div class="card-head">
+        <div>
+          <p class="eyebrow">${escapeHtml(candidate.id)}</p>
+          <h2 class="role">${escapeHtml(titleCase(candidate.role ?? "candidate"))}</h2>
+        </div>
+        <span class="state-label">${escapeHtml(candidateState)}</span>
+      </div>
+      <div class="candidate-value">
+        <span class="field-label">Value</span>
+        <p class="field-value">${escapeHtml(formatValue(candidate.value))}</p>
+      </div>
+      <dl class="field-stack">
+        ${fieldItem("Source URL", candidate.source.sourceRef)}
+        ${fieldItem("Source ref", candidate.source.sourceId ?? candidate.source.sourceRef)}
+        ${fieldItem("Locator", candidate.locator?.locator ?? candidate.locator?.scheme ?? "none")}
+        ${fieldItem("Excerpt", candidate.locator?.excerpt ?? "none", "excerpt")}
+        ${fieldItem("Extraction confidence", confidence === undefined ? "unknown" : formatConfidence(confidence))}
+        ${fieldItem("Extractor", candidate.extraction.extractor ?? "unknown")}
+        ${fieldItem("Claim", candidate.claimTarget.claimId ?? candidate.claimTarget.fieldOrBehavior)}
+      </dl>
+    </article>
+  `;
+}
+function candidateByRole(item, role) {
+    const candidate = item.spec.candidates.find((entry) => entry.role === role);
+    if (!candidate) {
+        throw new Error(`ReviewItem ${item.metadata.name} has no ${role} candidate.`);
+    }
+    return candidate;
+}
+function metaItem(label, value) {
+    return `
+    <div class="meta-item">
+      <dt class="field-label">${escapeHtml(label)}</dt>
+      <dd class="meta-value">${escapeHtml(value)}</dd>
+    </div>
+  `;
+}
+function fieldItem(label, value, extraClass = "") {
+    return `
+    <div class="field ${extraClass}">
+      <dt class="field-label">${escapeHtml(label)}</dt>
+      <dd class="field-value">${escapeHtml(value)}</dd>
+    </div>
+  `;
+}
+function formatConfidence(value) {
+    return `${Math.round(value * 100)}% (${value.toFixed(2)})`;
+}
+function titleCase(value) {
+    return value.slice(0, 1).toUpperCase() + value.slice(1);
+}
+function escapeHtml(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll("\"", "&quot;")
+        .replaceAll("'", "&#39;");
+}
+if (typeof document !== "undefined") {
+    const root = document.querySelector("#review-workbench");
+    if (root) {
+        mountReviewWorkbench(root);
+    }
+}

package/dist/fixtures/downstream-public-directory-proposal.d.ts

@@ -0,0 +1,100 @@
+export type DownstreamProposalStatus = "PENDING" | "APPROVED" | "REJECTED" | "SKIPPED";
+export interface DownstreamFieldDiff {
+    old: unknown;
+    new: unknown;
+    confidence: number;
+    excerpt?: string;
+    sourceUrl?: string;
+    mode?: "update" | "populate" | "add_items";
+}
+export interface DownstreamPublicDirectoryProposal {
+    id: string;
+    publicRecordId: string;
+    crawlRunId: string | null;
+    createdAt: string;
+    reviewedAt: string | null;
+    reviewedBy: string | null;
+    status: DownstreamProposalStatus;
+    sourceUrl: string;
+    rawExtraction: Record<string, unknown>;
+    proposedChanges: Record<string, DownstreamFieldDiff>;
+    overallConfidence: number;
+    extractionModel: string;
+    reviewerNotes: string | null;
+    feedbackTags: string[] | null;
+    priority: number;
+    appliedFields: string[];
+    recordName?: string;
+    recordSlug?: string;
+    communitySlug?: string;
+    providerId?: string | null;
+    lastVerifiedAt?: string | null;
+    recordData?: Record<string, unknown>;
+    fieldTimeline?: Record<string, {
+        lastUpdatedAt: string | null;
+        lastAttestedAt: string | null;
+    }>;
+    crawlStartedAt?: string;
+    crawlCompletedAt?: string | null;
+    crawlTrigger?: string;
+    crawlTriggeredBy?: string | null;
+}
+export declare const downstreamPublicDirectoryProposalFixture: {
+    id: string;
+    publicRecordId: string;
+    crawlRunId: string;
+    createdAt: string;
+    reviewedAt: string;
+    reviewedBy: string;
+    status: "REJECTED";
+    sourceUrl: string;
+    rawExtraction: {
+        registrationStatus: string;
+        confidence: {
+            registrationStatus: number;
+        };
+        sourceObservedAt: string;
+    };
+    proposedChanges: {
+        registrationStatus: {
+            old: string;
+            new: string;
+            confidence: number;
+            excerpt: string;
+            sourceUrl: string;
+            mode: "update";
+        };
+    };
+    overallConfidence: number;
+    extractionModel: string;
+    reviewerNotes: string;
+    feedbackTags: string[];
+    priority: number;
+    appliedFields: never[];
+    recordName: string;
+    recordSlug: string;
+    communitySlug: string;
+    providerId: string;
+    lastVerifiedAt: string;
+    recordData: {
+        registrationStatus: string;
+        websiteUrl: string;
+        fieldSources: {
+            registrationStatus: {
+                excerpt: string;
+                sourceUrl: string;
+                approvedAt: string;
+            };
+        };
+    };
+    fieldTimeline: {
+        registrationStatus: {
+            lastUpdatedAt: string;
+            lastAttestedAt: string;
+        };
+    };
+    crawlStartedAt: string;
+    crawlCompletedAt: string;
+    crawlTrigger: string;
+    crawlTriggeredBy: null;
+};

package/dist/fixtures/downstream-public-directory-proposal.js

@@ -0,0 +1,59 @@
+export const downstreamPublicDirectoryProposalFixture = {
+    id: "proposal-public-456",
+    publicRecordId: "record-123",
+    crawlRunId: "crawl-run-2026-05-31",
+    createdAt: "2026-05-31T15:00:00.000Z",
+    reviewedAt: "2026-06-01T17:20:00.000Z",
+    reviewedBy: "review-operator-7",
+    status: "REJECTED",
+    sourceUrl: "https://example.test/listings/example-program",
+    rawExtraction: {
+        registrationStatus: "WAITLIST",
+        confidence: {
+            registrationStatus: 0.82,
+        },
+        sourceObservedAt: "2026-05-31T15:00:00.000Z",
+    },
+    proposedChanges: {
+        registrationStatus: {
+            old: "OPEN",
+            new: "WAITLIST",
+            confidence: 0.82,
+            excerpt: "Join the waitlist for this listing.",
+            sourceUrl: "https://example.test/listings/example-program",
+            mode: "update",
+        },
+    },
+    overallConfidence: 0.82,
+    extractionModel: "example-directory-extractor-2026-05",
+    reviewerNotes: "Rejected proposed registration status; retained the current reviewed value.",
+    feedbackTags: ["source-text-ambiguous"],
+    priority: 0,
+    appliedFields: [],
+    recordName: "Example Program",
+    recordSlug: "example-program",
+    communitySlug: "example-community",
+    providerId: "provider-789",
+    lastVerifiedAt: "2026-05-30T18:00:00.000Z",
+    recordData: {
+        registrationStatus: "OPEN",
+        websiteUrl: "https://example.test/listings/example-program",
+        fieldSources: {
+            registrationStatus: {
+                excerpt: "Registration is open for the example program.",
+                sourceUrl: "https://example.test/listings/example-program",
+                approvedAt: "2026-05-30T18:00:00.000Z",
+            },
+        },
+    },
+    fieldTimeline: {
+        registrationStatus: {
+            lastUpdatedAt: "2026-05-30T18:05:00.000Z",
+            lastAttestedAt: "2026-05-30T18:05:00.000Z",
+        },
+    },
+    crawlStartedAt: "2026-05-31T14:58:00.000Z",
+    crawlCompletedAt: "2026-05-31T15:03:00.000Z",
+    crawlTrigger: "SCHEDULED",
+    crawlTriggeredBy: null,
+};