@thehammer/template-verification 0.1.0

package/README.md

@@ -0,0 +1,112 @@
+# @thehammer/template-verification
+
+A read-write **verification overlay** for rendered template apps. It overlays a
+trust layer on top of an already-rendered document template: per-data-point
+confidence/status icons, discrepancy indicators, a click-through detail modal,
+inline editing, and a recursive comparison page.
+
+The library **fetches nothing** — the host passes in the rendered `data` (with an
+embedded `__meta` sidecar) and a `saveOverride` transport via a single
+`initVerification()` call. It is backend-agnostic and unit-testable standalone.
+
+## Install
+
+```bash
+npm install @thehammer/template-verification
+```
+
+`vue` and `@thehammer/danx-ui` are peer dependencies (runtime externals) — the
+host template app already loads both.
+
+Import the stylesheet once (it carries the `@media print` rule that hides the
+overlay chrome on print/export):
+
+```ts
+import "@thehammer/template-verification/style.css"
+```
+
+## Usage
+
+Call `initVerification()` **once** at your App root (a function call — not a
+wrapping element), then drop a single `<VerificationChrome/>` as a sibling of the
+document and use `<VerifiedField>` anywhere:
+
+```vue
+<script setup lang="ts">
+import { initVerification, VerificationChrome, VerifiedField } from "@thehammer/template-verification"
+
+const props = defineProps<{ data: any }>()
+
+// Host-supplied, authenticated transport. Its presence enables inline editing.
+async function saveOverride(args) {
+  const res = await fetch(`/api/workflow-inputs/${args.workflow_input_id}/data-point-overrides`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+    body: JSON.stringify({ ...args, object_id: args.object_ids.at(-1) })
+  })
+  return res.json() // recomputed DataPointMeta
+}
+
+// Once, at root setup. Absent saveOverride ⇒ every field is read-only.
+initVerification({
+  data: props.data,
+  saveOverride,
+  workflowInputId: props.data.workflow_input_id
+})
+</script>
+
+<template>
+  <article>
+    <h1><VerifiedField :source="data.claimant" field="full_name" /></h1>
+    <div v-for="(p, i) in data.medical_providers" :key="i">
+      <VerifiedField :source="p" field="name" />
+    </div>
+  </article>
+
+  <!-- Sibling of the document, placed once. -->
+  <VerificationChrome />
+</template>
+```
+
+The backing store is a **module singleton** — safe because each rendered template
+runs as its own isolated Vue app inside its own iframe (one JS module instance,
+one app-wide config, no SSR). See `src/context.ts` for the invariant.
+
+## The `__meta` contract
+
+Each rendered object node carries a `__meta` map keyed by leaf field name. Each
+entry is a `DataPointMeta`:
+
+```ts
+interface DataPointMeta {
+  anchor: { object_ids: (number | string)[]; field: string; field_path: string }
+  candidates: {
+    override?: { value; source_choice }
+    extracted?: { value; confidence: number | null; reasoning; cited_text; cited_text_verified; sources[] }
+    claim?: { value; claim_set_label }
+  }
+  discrepancy: boolean
+  resolved: { value; source: "override" | "extracted" | "claim" | "none" }
+}
+```
+
+## Resolution + status
+
+- **Resolution priority:** `override > extracted > claim`.
+- **Status** buckets the **integer** confidence: `null → unverifiable (gray)`,
+  `≤2 → low (red)`, `==3 → medium (yellow)`, `≥4 → high (green)`.
+- **Discrepancy** is orthogonal to confidence — a high-confidence field can still
+  disagree with a differing claim/override.
+
+## Activation
+
+Fully self-contained: a fixed bottom-right settings button toggles the overlay,
+persisted to `localStorage`. No URL flags, no postMessage, no host activation prop.
+All library chrome is hidden under print/export media.
+
+## Develop
+
+```bash
+npm test          # vitest
+npm run build     # vite lib build + emitted .d.ts types
+```

package/dist/components/ComparisonPage.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/ConfidenceIcon.vue.d.ts

@@ -0,0 +1,14 @@
+import type { VerificationStatus } from "../types";
+/**
+ * Pure presentational confidence/status glyph. Given either a raw integer
+ * confidence (1-5) or an explicit status, renders a colored glyph and optional
+ * label. Buckets the INTEGER — never string-matches the confidence (see
+ * {@link bucketConfidence}). No interactivity.
+ */
+type __VLS_Props = {
+    confidence?: number | null;
+    status?: VerificationStatus;
+    showLabel?: boolean;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/VerificationChrome.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/VerificationModal.vue.d.ts

@@ -0,0 +1,25 @@
+import type { DataPointMeta, SourceChoice } from "../types";
+/**
+ * Per-data-point detail dialog (danx-ui {@link DanxDialog}, not hand-rolled).
+ * Shows the resolved value + winning source, every candidate side-by-side with
+ * any discrepancy called out, the extracted candidate's confidence / reasoning /
+ * cited text (+ verification flag) / grouped source pages, and a resolution
+ * control whose three actions create or update the override via the injected save.
+ *
+ * `save` is null when the field is read-only (no transport / no anchor) — the
+ * resolution control is hidden in that case.
+ */
+type __VLS_Props = {
+    modelValue: boolean;
+    meta: DataPointMeta;
+    label?: string;
+    save?: ((value: string | null, sourceChoice: SourceChoice) => Promise<DataPointMeta>) | null;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+    saved: (meta: DataPointMeta) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    onSaved?: ((meta: DataPointMeta) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/VerifiedField.vue.d.ts

@@ -0,0 +1,30 @@
+import type { MetaCarrier } from "../types";
+/**
+ * Wraps a single rendered value. Reads the data point's `__meta` from the bound
+ * `source` object at `field` (`source.__meta[field]`), renders the RESOLVED value
+ * (override > extracted > claim), and — when the overlay is enabled via
+ * `useVerification()` — overlays a confidence/status icon plus a discrepancy
+ * indicator (orthogonal to confidence), click-through to the detail modal.
+ * Supports inline contenteditable editing whenever a `saveOverride` transport was
+ * passed to `initVerification`; absent it, read-only. With no meta/source it
+ * degrades to a bare value — and with no `initVerification` call at all it still
+ * renders the bare value and never throws.
+ */
+type __VLS_Props = {
+    source?: MetaCarrier;
+    field?: string;
+    original?: string | number | null;
+    format?: (value: unknown) => string;
+};
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: ((props: {
+        value: unknown;
+        formatted: string;
+    }) => any) | undefined;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/constants.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Class applied to EVERY piece of library chrome (settings button + panel,
+ * overlay icons, discrepancy indicators, comparison-page trigger, modal). A single
+ * `@media print` rule hides all of it so the host template prints/exports clean —
+ * the library never touches the host's own content. Kept as a constant so
+ * components and the print-chrome regression test agree on one source of truth.
+ */
+export declare const CHROME_CLASS = "tv-chrome";
+/** localStorage key holding the persisted overlay enabled/disabled state. */
+export declare const ENABLED_STORAGE_KEY = "template-verification:enabled";

package/dist/context.d.ts

@@ -0,0 +1,68 @@
+import { type Ref } from "vue";
+import type { SaveOverrideFn } from "./types";
+/**
+ * The verification module — a composable + module-singleton replacement for the
+ * old Vue provide/inject `<VerificationProvider>`.
+ *
+ * MODULE-SINGLETON INVARIANT
+ * --------------------------
+ * The backing store is a single module-scoped value, so EVERY `useVerification()`
+ * call in the app shares ONE config. This is safe ONLY because each rendered
+ * template runs as its own isolated, client-only Vue app inside its own iframe =
+ * its own JS module instance. There is exactly one app-wide verification config
+ * per module, no SSR, and no second scope — the cases where provide/inject earns
+ * its keep (subtree scoping, multiple scopes, SSR-safe singletons) do not apply.
+ *
+ * If that ever changed — two templates sharing one JS context — this singleton
+ * would leak state across them. The fix is to store a per-`app` instance (keyed
+ * off the active Vue app instance) behind the SAME `useVerification()` surface;
+ * the public API below survives the change, only the storage seam moves.
+ */
+/** Config passed once to {@link initVerification} at App.vue root setup. */
+export interface InitVerificationConfig {
+    /** The bound data tree (carries per-node `__meta`). */
+    data: Record<string, unknown>;
+    /** Host transport; absent ⇒ all fields read-only. */
+    saveOverride?: SaveOverrideFn;
+    /** Opaque workflow input id echoed back in saves. */
+    workflowInputId?: number | string | null;
+    /** Seeds the overlay toggle ONLY when localStorage holds no prior value. */
+    defaultEnabled?: boolean;
+}
+/** The live verification state returned by {@link useVerification}. */
+export interface Verification {
+    /** App-wide overlay toggle, persisted to localStorage. */
+    enabled: Ref<boolean>;
+    /** The bound data tree (carries per-node `__meta`). */
+    data: Record<string, unknown>;
+    /** Host transport; absent ⇒ all fields read-only. */
+    saveOverride?: SaveOverrideFn;
+    /** Opaque workflow input id echoed back in saves. */
+    workflowInputId?: number | string | null;
+    /** Open the comparison page (rendered by `<VerificationChrome>`). */
+    openComparison: () => void;
+}
+/**
+ * Establish the app-wide verification config. Call ONCE at App.vue root setup —
+ * it is a function call, NOT a wrapping element. Replaces any prior store so the
+ * latest config wins (and so tests start clean per init).
+ */
+export declare function initVerification(config: InitVerificationConfig): void;
+/**
+ * Consume the live verification state. Returns a default (empty data, disabled,
+ * no transport) when {@link initVerification} was never called, so a
+ * `<VerifiedField>` used standalone degrades to a bare value instead of throwing.
+ * Consumed internally by `VerifiedField` + `VerificationChrome`; exported for
+ * advanced hosts.
+ */
+export declare function useVerification(): Verification;
+/**
+ * @internal Binds the comparison dialog's open-state for `<VerificationChrome>`.
+ * Not part of the public surface — chrome and `openComparison()` share one ref.
+ */
+export declare function useComparisonDialog(): Ref<boolean>;
+/**
+ * @internal Test-only: clear the module singleton so each test starts from the
+ * uninitialized state. Not exported from the package entry point.
+ */
+export declare function resetVerification(): void;

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @thehammer/template-verification — read-write verification overlay for rendered
+ * template apps. Consumes the host's `__meta` sidecar (override > extracted >
+ * claim resolution + discrepancy), overlays confidence/status icons, a
+ * click-through detail modal with inline + modal-driven override editing, and a
+ * recursive comparison page. Fetches nothing — the host calls `initVerification`
+ * once with `data` and an optional `saveOverride` transport.
+ */
+export { initVerification, useVerification } from "./context";
+export type { InitVerificationConfig, Verification } from "./context";
+export { default as VerifiedField } from "./components/VerifiedField.vue";
+export { default as VerificationChrome } from "./components/VerificationChrome.vue";
+export { default as ConfidenceIcon } from "./components/ConfidenceIcon.vue";
+export { default as VerificationModal } from "./components/VerificationModal.vue";
+export { default as ComparisonPage } from "./components/ComparisonPage.vue";
+export { bucketConfidence, STATUS_COLORS, STATUS_LABELS } from "./lib/confidence";
+export { resolveDataPoint, resolveCandidates, reasoningOf, citedTextOf, RESOLUTION_PRIORITY } from "./lib/resolveDataPoint";
+export { hasDiscrepancy, candidatesDisagree } from "./lib/discrepancy";
+export { walkDataPoints } from "./lib/walk";
+export type { WalkedDataPoint } from "./lib/walk";
+export { groupSources, sourceRowLabel } from "./lib/sources";
+export type { SourceGroup } from "./lib/sources";
+export { CHROME_CLASS, ENABLED_STORAGE_KEY } from "./constants";
+export type { VerificationStatus, ResolvedSource, SourceChoice, VerificationSource, ExtractedCandidate, OverrideCandidate, ClaimCandidate, CandidateSet, DataPointAnchor, ResolvedValue, DataPointMeta, MetaCarrier, SaveOverrideArgs, SaveOverrideFn } from "./types";

package/dist/lib/confidence.d.ts

@@ -0,0 +1,19 @@
+import type { VerificationStatus } from "../types";
+/**
+ * Bucket the INTEGER confidence (1-5) into a verification status.
+ *
+ *   null / undefined → unverifiable   (no extraction provenance)
+ *   <= 2             → low
+ *   == 3             → medium
+ *   >= 4             → high
+ *
+ * IMPORTANT: this buckets the NUMBER. The host app once shipped a confidence
+ * component that string-matched "high"/"medium"/"low"; real data is the integer
+ * 1-5, so that component silently fell through to "none" for every value. Do NOT
+ * reintroduce string matching here — bucket the integer.
+ */
+export declare function bucketConfidence(confidence?: number | null): VerificationStatus;
+/** Tailwind/text color token per status, for the icon + label. */
+export declare const STATUS_COLORS: Record<VerificationStatus, string>;
+/** Human-readable status label. */
+export declare const STATUS_LABELS: Record<VerificationStatus, string>;

package/dist/lib/discrepancy.d.ts

@@ -0,0 +1,14 @@
+import type { CandidateSet, DataPointMeta } from "../types";
+/**
+ * A data point is in discrepancy when two or more PRESENT candidates hold
+ * differing values. A single candidate (or none) can never disagree with itself.
+ *
+ * Discrepancy is ORTHOGONAL to confidence — a high-confidence (>=4) extracted
+ * field can still be in discrepancy with a differing claim or override.
+ *
+ * Prefers the host-computed `meta.discrepancy` flag when present, otherwise
+ * derives it from the candidate set per the contract.
+ */
+export declare function hasDiscrepancy(meta?: DataPointMeta | null): boolean;
+/** True when >=2 present candidates hold differing values. */
+export declare function candidatesDisagree(candidates?: CandidateSet | null): boolean;

package/dist/lib/resolveDataPoint.d.ts

@@ -0,0 +1,29 @@
+import type { CandidateSet, DataPointMeta, ResolvedValue } from "../types";
+/**
+ * Candidate resolution priority: a saved override always wins, then the extracted
+ * pipeline value, then a claim. Mirrors the host's `RESOLUTION_PRIORITY`. Typed as
+ * the candidate keys (excludes the `none` sentinel) so it safely indexes a
+ * {@link CandidateSet}.
+ */
+export declare const RESOLUTION_PRIORITY: Array<keyof CandidateSet>;
+/**
+ * Resolve a data point to its winning `{ value, source }`.
+ *
+ * Prefers the host-computed `meta.resolved` when present (the authoritative live
+ * shape), otherwise derives it from the candidate set by priority
+ * (override > extracted > claim), falling back to `{ value: null, source: 'none' }`
+ * when no candidate exists. Either input shape resolves identically.
+ */
+export declare function resolveDataPoint(meta?: DataPointMeta | null): ResolvedValue;
+/** Derive the winning resolution purely from a candidate set, by priority. */
+export declare function resolveCandidates(candidates?: CandidateSet | null): ResolvedValue;
+/**
+ * The extracted candidate's reasoning, normalized to a non-empty string or null.
+ * Reasoning is frequently `""`/null — callers render a quiet empty state, never throw.
+ */
+export declare function reasoningOf(meta?: DataPointMeta | null): string | null;
+/**
+ * The extracted candidate's cited text, normalized to a non-empty string or null.
+ * Like reasoning, cited_text is graceful-empty.
+ */
+export declare function citedTextOf(meta?: DataPointMeta | null): string | null;

package/dist/lib/sources.d.ts

@@ -0,0 +1,18 @@
+import type { VerificationSource } from "../types";
+/** A set of sources sharing one file identity, for grouped rendering in the modal. */
+export interface SourceGroup {
+    /** Display label for the file (file_name, then a derived id, then a fallback). */
+    fileLabel: string;
+    /** A view/download URL when the host resolved one; the group links only when set. */
+    fileUrl?: string;
+    /** The sources belonging to this file. */
+    sources: VerificationSource[];
+}
+/**
+ * Group an extracted candidate's sources by file identity so the modal can render
+ * one block per file with its pages beneath. Links a group only when a `file_url`
+ * is present on any of its sources.
+ */
+export declare function groupSources(sources?: VerificationSource[] | null): SourceGroup[];
+/** Human page/citation label for a single source row. */
+export declare function sourceRowLabel(source: VerificationSource): string;

package/dist/lib/walk.d.ts

@@ -0,0 +1,24 @@
+import type { DataPointMeta } from "../types";
+/** A flattened data point discovered by walking the `data` tree. */
+export interface WalkedDataPoint {
+    /** Dotted display path, e.g. `medical_providers[0].name`. */
+    path: string;
+    /** Leaf field/label. */
+    label: string;
+    /** The verification meta when the point is anchored to a source; null when unanchored. */
+    meta: DataPointMeta | null;
+    /** The raw rendered value (used for unanchored / not-from-source points). */
+    value: unknown;
+    /** True when the point has no `__meta` entry (a generated/artifact value, not from source). */
+    unanchored: boolean;
+}
+/**
+ * Depth-first walk of a rendered `data` tree, flattening every data point.
+ *
+ * For each object node, its `__meta` map yields the ANCHORED data points (one per
+ * keyed field). Scalar fields present in `data` but absent from `__meta` (and not
+ * the structural `name`/`type` keys) are emitted as UNANCHORED points — values not
+ * traceable to a source (generated/artifact output). Recurses into nested objects
+ * and arrays. A childless/empty tree yields an empty list without error.
+ */
+export declare function walkDataPoints(data: unknown, basePath?: string): WalkedDataPoint[];

package/dist/style.css

@@ -0,0 +1 @@
+@media print{.tv-chrome{display:none!important}}

package/dist/template-verification.js

@@ -0,0 +1,648 @@
+import { ref as U, watch as ce, defineComponent as M, computed as v, openBlock as l, createElementBlock as s, normalizeClass as L, createElementVNode as n, toDisplayString as f, createCommentVNode as b, createBlock as W, unref as g, withCtx as X, createVNode as A, Fragment as V, renderList as T, createTextVNode as K, withDirectives as Z, vModelText as de, withKeys as ve, withModifiers as fe, renderSlot as pe, isRef as J, vModelCheckbox as me } from "vue";
+import { DanxDialog as ee, DanxIcon as _e, gearIcon as xe } from "@thehammer/danx-ui";
+const D = "tv-chrome", te = "template-verification:enabled";
+let P = null;
+function ye(e) {
+  var t;
+  try {
+    return ((t = globalThis.localStorage) == null ? void 0 : t.getItem(e)) ?? null;
+  } catch {
+    return null;
+  }
+}
+function ge(e, t) {
+  var a;
+  try {
+    (a = globalThis.localStorage) == null || a.setItem(e, t);
+  } catch {
+  }
+}
+function he(e) {
+  const t = ye(te);
+  return t === null ? e : t === "true";
+}
+function ae(e) {
+  const t = U(he((e == null ? void 0 : e.defaultEnabled) ?? !1));
+  return ce(t, (a) => ge(te, a ? "true" : "false")), {
+    enabled: t,
+    data: (e == null ? void 0 : e.data) ?? {},
+    saveOverride: e == null ? void 0 : e.saveOverride,
+    workflowInputId: e == null ? void 0 : e.workflowInputId,
+    comparisonOpen: U(!1)
+  };
+}
+function ne() {
+  return P || (P = ae()), P;
+}
+function At(e) {
+  P = ae(e);
+}
+function Y() {
+  const e = ne();
+  return {
+    enabled: e.enabled,
+    data: e.data,
+    saveOverride: e.saveOverride,
+    workflowInputId: e.workflowInputId,
+    openComparison: () => {
+      e.comparisonOpen.value = !0;
+    }
+  };
+}
+function be() {
+  return ne().comparisonOpen;
+}
+function G(e) {
+  return typeof e != "number" || Number.isNaN(e) ? "unverifiable" : e <= 2 ? "low" : e === 3 ? "medium" : "high";
+}
+const ke = {
+  high: "text-green-600",
+  medium: "text-yellow-500",
+  low: "text-red-600",
+  unverifiable: "text-gray-400"
+}, we = {
+  high: "High",
+  medium: "Medium",
+  low: "Low",
+  unverifiable: "Unverifiable"
+}, le = ["override", "extracted", "claim"];
+function H(e) {
+  return e ? e.resolved && e.resolved.source && e.resolved.source !== "none" ? e.resolved : Se(e.candidates) : { value: null, source: "none" };
+}
+function Se(e) {
+  if (e)
+    for (const t of le) {
+      const a = e[t];
+      if (a != null)
+        return { value: a.value, source: t };
+    }
+  return { value: null, source: "none" };
+}
+function B(e) {
+  var c, o;
+  const t = (o = (c = e == null ? void 0 : e.candidates) == null ? void 0 : c.extracted) == null ? void 0 : o.reasoning;
+  if (t == null) return null;
+  const a = String(t).trim();
+  return a === "" ? null : a;
+}
+function F(e) {
+  var c, o;
+  const t = (o = (c = e == null ? void 0 : e.candidates) == null ? void 0 : c.extracted) == null ? void 0 : o.cited_text;
+  if (t == null) return null;
+  const a = String(t).trim();
+  return a === "" ? null : a;
+}
+function se(e) {
+  return e ? typeof e.discrepancy == "boolean" ? e.discrepancy : $e(e.candidates) : !1;
+}
+function $e(e) {
+  if (!e) return !1;
+  const t = le.map((a) => e[a]).filter((a) => a != null).map((a) => Ce(a.value));
+  return t.length < 2 ? !1 : new Set(t).size > 1;
+}
+function Ce(e) {
+  return JSON.stringify(e ?? null);
+}
+function Ve(e, t, a) {
+  var r;
+  const c = (r = t.value) == null ? void 0 : r.anchor;
+  if (!e.saveOverride || !c) return null;
+  const o = e.saveOverride;
+  return async (u, p) => {
+    const _ = await o({
+      workflow_input_id: e.workflowInputId,
+      object_ids: c.object_ids,
+      field: c.field,
+      field_path: c.field_path,
+      value: u,
+      source_choice: p
+    });
+    return a(_), _;
+  };
+}
+const Oe = ["data-status", "title"], Ie = {
+  class: "tv-confidence-glyph",
+  "aria-hidden": "true"
+}, Le = {
+  key: 0,
+  class: "tv-confidence-label text-xs font-medium"
+}, j = /* @__PURE__ */ M({
+  __name: "ConfidenceIcon",
+  props: {
+    confidence: {},
+    status: {},
+    showLabel: { type: Boolean }
+  },
+  setup(e) {
+    const t = e, a = v(
+      () => t.status ?? G(t.confidence)
+    ), c = {
+      high: "✔",
+      // check
+      medium: "⚠",
+      // warning triangle
+      low: "✕",
+      // x
+      unverifiable: "?"
+    }, o = v(() => c[a.value]), r = v(() => ke[a.value]), u = v(() => we[a.value]);
+    return (p, _) => (l(), s("span", {
+      class: L(["tv-confidence-icon inline-flex items-center gap-1", r.value]),
+      "data-status": a.value,
+      title: u.value
+    }, [
+      n("span", Ie, f(o.value), 1),
+      e.showLabel ? (l(), s("span", Le, f(u.value), 1)) : b("", !0)
+    ], 10, Oe));
+  }
+});
+function oe(e) {
+  if (!e || e.length === 0) return [];
+  const t = /* @__PURE__ */ new Map();
+  for (const a of e) {
+    const c = Ue(a);
+    let o = t.get(c);
+    o || (o = { fileLabel: Ee(a), fileUrl: a.file_url, sources: [] }, t.set(c, o)), !o.fileUrl && a.file_url && (o.fileUrl = a.file_url), o.sources.push(a);
+  }
+  return [...t.values()];
+}
+function Ue(e) {
+  const t = e.file_name ?? e.file_id ?? e.stored_file_id ?? e.source_id ?? e.id;
+  return t != null ? String(t) : "__unknown__";
+}
+function Ee(e) {
+  return e.file_name ? e.file_name : e.file_id !== void 0 && e.file_id !== null ? `File ${e.file_id}` : e.stored_file_id !== void 0 && e.stored_file_id !== null ? `File ${e.stored_file_id}` : e.source_type ? e.source_type : "Source";
+}
+function ie(e) {
+  return e.page !== void 0 && e.page !== null ? `Page ${e.page}` : e.explanation ? String(e.explanation) : e.source_type ? String(e.source_type) : "Citation";
+}
+const Te = { class: "tv-modal flex flex-col gap-4 text-sm" }, Ae = { class: "tv-modal-resolved" }, De = { class: "flex items-center gap-2" }, Ne = { class: "tv-resolved-value font-semibold" }, Me = { class: "tv-resolved-source text-xs text-gray-500" }, Re = {
+  key: 0,
+  class: "tv-discrepancy text-xs font-medium text-amber-600"
+}, Pe = { class: "tv-modal-candidates" }, je = { class: "w-full" }, Be = { class: "py-1 pr-2 font-medium" }, Fe = { class: "py-1 pr-2" }, ze = { class: "py-1 text-xs text-gray-500" }, Ke = {
+  key: 0,
+  class: "tv-modal-provenance flex flex-col gap-1"
+}, Ye = { class: "tv-confidence-value" }, Ge = { class: "tv-reasoning whitespace-pre-line" }, He = { class: "tv-cited-text border-l-2 border-gray-200 pl-2 italic" }, qe = { class: "tv-modal-sources" }, Je = {
+  key: 0,
+  class: "tv-no-source text-gray-400"
+}, Qe = { class: "font-medium" }, We = ["href"], Xe = {
+  key: 1,
+  class: "tv-source-name"
+}, Ze = { class: "ml-3 list-disc" }, et = {
+  key: 1,
+  class: "tv-modal-resolution flex flex-col gap-2 border-t border-gray-200 pt-3"
+}, tt = { class: "flex flex-wrap gap-2" }, at = ["disabled"], nt = ["disabled"], lt = { class: "flex items-center gap-2" }, st = ["disabled"], ot = /* @__PURE__ */ M({
+  __name: "VerificationModal",
+  props: {
+    modelValue: { type: Boolean },
+    meta: {},
+    label: {},
+    save: { type: [Function, null] }
+  },
+  emits: ["update:modelValue", "saved"],
+  setup(e, { emit: t }) {
+    const a = e, c = t, o = v({
+      get: () => a.modelValue,
+      set: (i) => c("update:modelValue", i)
+    }), r = v(() => H(a.meta)), u = v(() => a.meta.candidates.extracted), p = v(() => a.meta.candidates.claim), _ = v(() => a.meta.candidates.override), k = v(() => {
+      var i;
+      return G((i = u.value) == null ? void 0 : i.confidence);
+    }), m = v(() => B(a.meta)), d = v(() => F(a.meta)), $ = v(() => {
+      var i;
+      return oe((i = u.value) == null ? void 0 : i.sources);
+    }), O = v(() => {
+      const i = [];
+      return _.value && i.push({ source: "Override", value: _.value.value, detail: _.value.source_choice ? `via ${_.value.source_choice}` : void 0 }), u.value && i.push({ source: "Extracted", value: u.value.value, detail: E(u.value.confidence) }), p.value && i.push({ source: "Claim", value: p.value.value, detail: p.value.claim_set_label ?? void 0 }), i;
+    }), I = U(""), x = U(!1);
+    function E(i) {
+      return i == null ? "Unverifiable" : `${i}/5`;
+    }
+    function R(i) {
+      return i == null ? "" : String(i);
+    }
+    async function N(i, y) {
+      if (!(!a.save || x.value)) {
+        x.value = !0;
+        try {
+          const w = await a.save(i, y);
+          c("saved", w);
+        } finally {
+          x.value = !1;
+        }
+      }
+    }
+    const h = () => {
+      var i;
+      return N(q((i = u.value) == null ? void 0 : i.value), "extracted");
+    }, S = () => {
+      var i;
+      return N(q((i = p.value) == null ? void 0 : i.value), "claim");
+    }, C = () => N(I.value, "custom");
+    function q(i) {
+      return i == null ? null : String(i);
+    }
+    return (i, y) => (l(), W(g(ee), {
+      modelValue: o.value,
+      "onUpdate:modelValue": y[1] || (y[1] = (w) => o.value = w),
+      title: e.label || "Verification detail",
+      "close-x": "",
+      class: L(g(D))
+    }, {
+      default: X(() => [
+        n("div", Te, [
+          n("section", Ae, [
+            y[2] || (y[2] = n("div", { class: "text-xs uppercase tracking-wide text-gray-500" }, "Resolved value", -1)),
+            n("div", De, [
+              n("span", Ne, f(R(r.value.value)), 1),
+              n("span", Me, "(" + f(r.value.source) + ")", 1),
+              A(j, {
+                status: k.value,
+                "show-label": ""
+              }, null, 8, ["status"])
+            ]),
+            e.meta.discrepancy ? (l(), s("div", Re, " ⚠ Sources disagree ")) : b("", !0)
+          ]),
+          n("section", Pe, [
+            y[3] || (y[3] = n("div", { class: "text-xs uppercase tracking-wide text-gray-500" }, "Candidates", -1)),
+            n("table", je, [
+              n("tbody", null, [
+                (l(!0), s(V, null, T(O.value, (w) => (l(), s("tr", {
+                  key: w.source,
+                  class: "tv-candidate-row border-t border-gray-100"
+                }, [
+                  n("td", Be, f(w.source), 1),
+                  n("td", Fe, f(R(w.value)), 1),
+                  n("td", ze, f(w.detail), 1)
+                ]))), 128))
+              ])
+            ])
+          ]),
+          u.value ? (l(), s("section", Ke, [
+            y[6] || (y[6] = n("div", { class: "text-xs uppercase tracking-wide text-gray-500" }, "Confidence", -1)),
+            n("div", Ye, f(E(u.value.confidence)), 1),
+            m.value ? (l(), s(V, { key: 0 }, [
+              y[4] || (y[4] = n("div", { class: "text-xs uppercase tracking-wide text-gray-500" }, "Reasoning", -1)),
+              n("p", Ge, f(m.value), 1)
+            ], 64)) : b("", !0),
+            d.value ? (l(), s(V, { key: 1 }, [
+              y[5] || (y[5] = n("div", { class: "text-xs uppercase tracking-wide text-gray-500" }, "Cited text", -1)),
+              n("blockquote", He, [
+                K(f(d.value) + " ", 1),
+                n("span", {
+                  class: L(["tv-cited-verified ml-1 text-xs", u.value.cited_text_verified ? "text-green-600" : "text-gray-400"])
+                }, f(u.value.cited_text_verified ? "✔ verified" : "unverified"), 3)
+              ])
+            ], 64)) : b("", !0)
+          ])) : b("", !0),
+          n("section", qe, [
+            y[7] || (y[7] = n("div", { class: "text-xs uppercase tracking-wide text-gray-500" }, "Sources", -1)),
+            $.value.length === 0 ? (l(), s("div", Je, "No source recorded")) : b("", !0),
+            (l(!0), s(V, null, T($.value, (w) => (l(), s("div", {
+              key: w.fileLabel,
+              class: "tv-source-group"
+            }, [
+              n("div", Qe, [
+                w.fileUrl ? (l(), s("a", {
+                  key: 0,
+                  href: w.fileUrl,
+                  class: "tv-source-link text-blue-600 underline",
+                  target: "_blank",
+                  rel: "noopener"
+                }, f(w.fileLabel), 9, We)) : (l(), s("span", Xe, f(w.fileLabel), 1))
+              ]),
+              n("ul", Ze, [
+                (l(!0), s(V, null, T(w.sources, (re, ue) => (l(), s("li", {
+                  key: ue,
+                  class: "tv-source-row text-xs text-gray-600"
+                }, f(g(ie)(re)), 1))), 128))
+              ])
+            ]))), 128))
+          ]),
+          e.save ? (l(), s("section", et, [
+            y[8] || (y[8] = n("div", { class: "text-xs uppercase tracking-wide text-gray-500" }, "Resolve", -1)),
+            n("div", tt, [
+              u.value ? (l(), s("button", {
+                key: 0,
+                type: "button",
+                class: "tv-accept-extracted rounded border px-2 py-1",
+                disabled: x.value,
+                onClick: h
+              }, "Accept extracted", 8, at)) : b("", !0),
+              p.value ? (l(), s("button", {
+                key: 1,
+                type: "button",
+                class: "tv-accept-claim rounded border px-2 py-1",
+                disabled: x.value,
+                onClick: S
+              }, "Accept claim", 8, nt)) : b("", !0)
+            ]),
+            n("div", lt, [
+              Z(n("input", {
+                "onUpdate:modelValue": y[0] || (y[0] = (w) => I.value = w),
+                type: "text",
+                class: "tv-custom-input flex-1 rounded border px-2 py-1",
+                placeholder: "Type a custom value"
+              }, null, 512), [
+                [de, I.value]
+              ]),
+              n("button", {
+                type: "button",
+                class: "tv-accept-custom rounded border px-2 py-1",
+                disabled: x.value,
+                onClick: C
+              }, "Type custom", 8, st)
+            ])
+          ])) : b("", !0)
+        ])
+      ]),
+      _: 1
+    }, 8, ["modelValue", "title", "class"]));
+  }
+}), it = { class: "tv-field inline-flex items-center gap-1" }, rt = ["contenteditable", "data-editable"], ut = {
+  key: 0,
+  class: "tv-discrepancy-indicator ml-0.5 text-amber-600",
+  title: "Sources disagree",
+  "aria-label": "discrepancy"
+}, Dt = /* @__PURE__ */ M({
+  __name: "VerifiedField",
+  props: {
+    source: {},
+    field: {},
+    original: {},
+    format: { type: Function }
+  },
+  setup(e) {
+    const t = e, a = Y(), c = v(() => a.enabled.value), o = U(null), r = v(() => {
+      var h;
+      return o.value ? o.value : t.source && t.field ? ((h = t.source.__meta) == null ? void 0 : h[t.field]) ?? null : null;
+    }), u = v(() => H(r.value)), p = v(() => {
+      if (t.original !== void 0 && t.original !== null) return t.original;
+      if (r.value) return u.value.value;
+      if (t.source && t.field) return t.source[t.field];
+    }), _ = v(() => {
+      const h = p.value;
+      return h == null ? "" : t.format ? t.format(h) : String(h);
+    }), k = v(() => {
+      var h, S, C;
+      return G((C = (S = (h = r.value) == null ? void 0 : h.candidates) == null ? void 0 : S.extracted) == null ? void 0 : C.confidence);
+    }), m = v(() => se(r.value)), d = v(() => c.value && !!r.value);
+    function $(h) {
+      var S;
+      o.value = h, (S = t.source) != null && S.__meta && t.field && (t.source.__meta[t.field] = h);
+    }
+    const O = v(() => Ve(a, r, $)), I = v(() => !!O.value), x = U(!1), E = U(!1);
+    function R() {
+      r.value && (x.value = !0);
+    }
+    async function N(h) {
+      E.value = !1;
+      const C = (h.target.textContent ?? "").trim();
+      !O.value || C === _.value || await O.value(C, "custom");
+    }
+    return (h, S) => (l(), s("span", it, [
+      n("span", {
+        class: "tv-field-value",
+        contenteditable: I.value,
+        "data-editable": I.value ? "true" : "false",
+        onFocus: S[0] || (S[0] = (C) => E.value = !0),
+        onBlur: N,
+        onKeydown: S[1] || (S[1] = ve(fe((C) => C.target.blur(), ["prevent"]), ["enter"]))
+      }, [
+        pe(h.$slots, "default", {
+          value: p.value,
+          formatted: _.value
+        }, () => [
+          K(f(_.value), 1)
+        ])
+      ], 40, rt),
+      d.value ? (l(), s("button", {
+        key: 0,
+        type: "button",
+        class: L(["tv-overlay ml-1 inline-flex items-center", g(D)]),
+        title: "View verification detail",
+        onClick: R
+      }, [
+        A(j, { status: k.value }, null, 8, ["status"]),
+        m.value ? (l(), s("span", ut, "⚠")) : b("", !0)
+      ], 2)) : b("", !0),
+      r.value ? (l(), W(ot, {
+        key: 1,
+        modelValue: x.value,
+        "onUpdate:modelValue": S[2] || (S[2] = (C) => x.value = C),
+        meta: r.value,
+        label: e.field,
+        save: O.value
+      }, null, 8, ["modelValue", "meta", "label", "save"])) : b("", !0)
+    ]));
+  }
+}), ct = /* @__PURE__ */ new Set(["name", "type"]);
+function dt(e, t = "") {
+  const a = [];
+  return z(e, t, a), a;
+}
+function z(e, t, a) {
+  if (Array.isArray(e)) {
+    e.forEach((r, u) => z(r, `${t}[${u}]`, a));
+    return;
+  }
+  if (!Q(e)) return;
+  const o = e.__meta ?? {};
+  for (const [r, u] of Object.entries(e)) {
+    if (r === "__meta") continue;
+    const p = t ? `${t}.${r}` : r;
+    if (Array.isArray(u) || Q(u)) {
+      z(u, p, a);
+      continue;
+    }
+    const _ = o[r];
+    !_ && ct.has(r) || a.push({
+      path: p,
+      label: r,
+      meta: _ ?? null,
+      value: u,
+      unanchored: !_
+    });
+  }
+}
+function Q(e) {
+  return typeof e == "object" && e !== null && !Array.isArray(e);
+}
+const vt = { class: "tv-comparison-page flex flex-col gap-4" }, ft = {
+  key: 0,
+  class: "tv-comparison-empty text-gray-400"
+}, pt = {
+  key: 1,
+  class: "tv-anchored-group flex flex-col gap-3"
+}, mt = { class: "flex items-center gap-2" }, _t = { class: "tv-datapoint-path font-mono text-xs text-gray-500" }, xt = { class: "tv-datapoint-resolved font-medium" }, yt = {
+  key: 0,
+  class: "tv-datapoint-discrepancy text-xs font-medium text-amber-600"
+}, gt = { class: "tv-datapoint-candidates ml-4 text-xs text-gray-600" }, ht = { class: "font-medium" }, bt = {
+  key: 0,
+  class: "tv-datapoint-reasoning ml-4 text-xs italic text-gray-500"
+}, kt = {
+  key: 1,
+  class: "tv-datapoint-cited ml-4 text-xs text-gray-500"
+}, wt = { class: "tv-datapoint-sources ml-4 text-xs text-gray-500" }, St = ["href"], $t = { key: 1 }, Ct = { class: "ml-1" }, Vt = {
+  key: 2,
+  class: "tv-unanchored-group flex flex-col gap-1"
+}, Ot = { class: "tv-datapoint-path font-mono text-xs text-gray-500" }, It = { class: "tv-datapoint-value" }, Lt = /* @__PURE__ */ M({
+  __name: "ComparisonPage",
+  setup(e) {
+    const t = Y(), a = v(() => dt(t.data)), c = v(() => a.value.filter((k) => !k.unanchored)), o = v(() => a.value.filter((k) => k.unanchored));
+    function r(k) {
+      const m = H(k).value;
+      return m == null ? "" : String(m);
+    }
+    function u(k) {
+      return k == null ? "" : String(k);
+    }
+    function p(k) {
+      var m, d, $;
+      return ($ = (d = (m = k.meta) == null ? void 0 : m.candidates) == null ? void 0 : d.extracted) == null ? void 0 : $.confidence;
+    }
+    function _(k) {
+      var $;
+      const m = ($ = k.meta) == null ? void 0 : $.candidates;
+      if (!m) return [];
+      const d = [];
+      return m.override && d.push({ source: "override", value: m.override.value }), m.extracted && d.push({ source: "extracted", value: m.extracted.value }), m.claim && d.push({ source: "claim", value: m.claim.value }), d;
+    }
+    return (k, m) => (l(), s("div", vt, [
+      m[1] || (m[1] = n("h2", { class: "tv-comparison-title text-lg font-semibold" }, "Verification comparison", -1)),
+      a.value.length === 0 ? (l(), s("p", ft, " No data points to compare. ")) : b("", !0),
+      c.value.length ? (l(), s("section", pt, [
+        (l(!0), s(V, null, T(c.value, (d) => {
+          var $, O, I;
+          return l(), s("div", {
+            key: d.path,
+            class: "tv-datapoint border-t border-gray-100 pt-2"
+          }, [
+            n("div", mt, [
+              n("span", _t, f(d.path), 1),
+              n("span", xt, f(r(d.meta)), 1),
+              A(j, {
+                confidence: p(d),
+                "show-label": ""
+              }, null, 8, ["confidence"]),
+              g(se)(d.meta) ? (l(), s("span", yt, "⚠ discrepancy")) : b("", !0)
+            ]),
+            n("ul", gt, [
+              (l(!0), s(V, null, T(_(d), (x) => (l(), s("li", {
+                key: x.source,
+                class: "tv-candidate"
+              }, [
+                n("span", ht, f(x.source) + ":", 1),
+                K(" " + f(u(x.value)), 1)
+              ]))), 128))
+            ]),
+            g(B)(d.meta) ? (l(), s("p", bt, f(g(B)(d.meta)), 1)) : b("", !0),
+            g(F)(d.meta) ? (l(), s("p", kt, " “" + f(g(F)(d.meta)) + "” ", 1)) : b("", !0),
+            n("ul", wt, [
+              (l(!0), s(V, null, T(g(oe)((I = (O = ($ = d.meta) == null ? void 0 : $.candidates) == null ? void 0 : O.extracted) == null ? void 0 : I.sources), (x, E) => (l(), s("li", {
+                key: E,
+                class: "tv-source-group"
+              }, [
+                x.fileUrl ? (l(), s("a", {
+                  key: 0,
+                  href: x.fileUrl,
+                  class: "tv-source-link text-blue-600 underline",
+                  target: "_blank",
+                  rel: "noopener"
+                }, f(x.fileLabel), 9, St)) : (l(), s("span", $t, f(x.fileLabel), 1)),
+                n("span", Ct, "(" + f(x.sources.map(g(ie)).join(", ")) + ")", 1)
+              ]))), 128))
+            ])
+          ]);
+        }), 128))
+      ])) : b("", !0),
+      o.value.length ? (l(), s("section", Vt, [
+        m[0] || (m[0] = n("h3", { class: "tv-unanchored-title text-sm font-semibold text-gray-500" }, " Unanchored / not from source ", -1)),
+        (l(!0), s(V, null, T(o.value, (d) => (l(), s("div", {
+          key: d.path,
+          class: "tv-unanchored-datapoint flex items-center gap-2 text-sm"
+        }, [
+          n("span", Ot, f(d.path), 1),
+          n("span", It, f(u(d.value)), 1),
+          A(j, { status: "unverifiable" })
+        ]))), 128))
+      ])) : b("", !0)
+    ]));
+  }
+}), Ut = { class: "tv-enable-toggle flex items-center justify-between text-sm" }, Nt = /* @__PURE__ */ M({
+  __name: "VerificationChrome",
+  setup(e) {
+    const { enabled: t, openComparison: a } = Y(), c = be(), o = U(!1);
+    function r() {
+      a(), o.value = !1;
+    }
+    return (u, p) => (l(), s(V, null, [
+      n("button", {
+        type: "button",
+        class: L(["tv-settings-button fixed bottom-4 right-4 z-50 flex h-10 w-10 items-center justify-center rounded-full bg-gray-800 text-white shadow-lg", g(D)]),
+        title: "Verification settings",
+        onClick: p[0] || (p[0] = (_) => o.value = !o.value)
+      }, [
+        A(g(_e), {
+          icon: g(xe),
+          class: "h-5 w-5"
+        }, null, 8, ["icon"])
+      ], 2),
+      o.value ? (l(), s("div", {
+        key: 0,
+        class: L(["tv-settings-panel fixed bottom-16 right-4 z-50 flex w-56 flex-col gap-3 rounded-lg bg-white p-4 shadow-xl ring-1 ring-gray-200", g(D)])
+      }, [
+        n("label", Ut, [
+          p[3] || (p[3] = n("span", null, "Verification overlay", -1)),
+          Z(n("input", {
+            "onUpdate:modelValue": p[1] || (p[1] = (_) => J(t) ? t.value = _ : null),
+            type: "checkbox",
+            class: "tv-enable-checkbox"
+          }, null, 512), [
+            [me, g(t)]
+          ])
+        ]),
+        n("button", {
+          type: "button",
+          class: L(["tv-open-comparison rounded border px-2 py-1 text-sm", g(D)]),
+          onClick: r
+        }, "Open comparison page", 2)
+      ], 2)) : b("", !0),
+      A(g(ee), {
+        modelValue: g(c),
+        "onUpdate:modelValue": p[2] || (p[2] = (_) => J(c) ? c.value = _ : null),
+        title: "Verification comparison",
+        width: 80,
+        "close-x": "",
+        class: L(g(D))
+      }, {
+        default: X(() => [
+          A(Lt)
+        ]),
+        _: 1
+      }, 8, ["modelValue", "class"])
+    ], 64));
+  }
+});
+export {
+  D as CHROME_CLASS,
+  Lt as ComparisonPage,
+  j as ConfidenceIcon,
+  te as ENABLED_STORAGE_KEY,
+  le as RESOLUTION_PRIORITY,
+  ke as STATUS_COLORS,
+  we as STATUS_LABELS,
+  Nt as VerificationChrome,
+  ot as VerificationModal,
+  Dt as VerifiedField,
+  G as bucketConfidence,
+  $e as candidatesDisagree,
+  F as citedTextOf,
+  oe as groupSources,
+  se as hasDiscrepancy,
+  At as initVerification,
+  B as reasoningOf,
+  Se as resolveCandidates,
+  H as resolveDataPoint,
+  ie as sourceRowLabel,
+  Y as useVerification,
+  dt as walkDataPoints
+};

package/dist/types.d.ts

@@ -0,0 +1,98 @@
+/**
+ * The verification data contract — the `__meta` sidecar the host emits per data
+ * point (see gpt-manager `TemplateDataResource`). The library consumes this shape
+ * and NEVER fetches it: the host passes `data` (with embedded `__meta`) and a
+ * `saveOverride` transport in via props/provide.
+ *
+ * A rendered object node carries a `__meta` MAP keyed by leaf field name; each
+ * entry is a {@link DataPointMeta} describing that one field's verification state.
+ */
+/** Status bucket derived from the integer 1-5 confidence (orthogonal to discrepancy). */
+export type VerificationStatus = "high" | "medium" | "low" | "unverifiable";
+/** The winning candidate key for a resolved data point, or `none` when no candidate exists. */
+export type ResolvedSource = "override" | "extracted" | "claim" | "none";
+/** The basis a user picked when saving an override. */
+export type SourceChoice = "extracted" | "claim" | "custom";
+/**
+ * One citation source for an extracted candidate. The live host shape carries
+ * `id`/`source_type`/`stored_file_id`/`explanation`; the optional `file_*`/`page`
+ * fields cover the idealized document-page shape. Grouping + linking tolerate
+ * either: group by file identity, link only when `file_url` is present.
+ */
+export interface VerificationSource {
+    id?: number | string;
+    source_type?: string | null;
+    source_id?: number | string | null;
+    explanation?: string | null;
+    stored_file_id?: number | string | null;
+    agent_thread_message_id?: number | string | null;
+    file_id?: number | string;
+    page?: number;
+    file_url?: string;
+    file_name?: string;
+}
+/** The extracted (pipeline) candidate — carries provenance: confidence, reasoning, citation. */
+export interface ExtractedCandidate {
+    value: unknown;
+    confidence: number | null;
+    reasoning?: string | null;
+    cited_text?: string | null;
+    cited_text_verified?: boolean | null;
+    sources?: VerificationSource[];
+}
+/** A user-saved override candidate — always the highest-priority resolution. */
+export interface OverrideCandidate {
+    value: unknown;
+    source_choice?: SourceChoice | string;
+    set_by?: number | string | null;
+    set_at?: string | null;
+}
+/** A claim candidate asserted by an example/reference output — lowest priority. */
+export interface ClaimCandidate {
+    value: unknown;
+    claim_set_id?: number | string | null;
+    claim_set_label?: string | null;
+}
+/** The candidate set present for a data point, keyed by source. */
+export interface CandidateSet {
+    override?: OverrideCandidate;
+    extracted?: ExtractedCandidate;
+    claim?: ClaimCandidate;
+}
+/** The anchor identifying a data point within the host's TeamObject tree. */
+export interface DataPointAnchor {
+    object_ids: Array<number | string>;
+    field: string;
+    field_path: string;
+}
+/** The resolved value + winning source for a data point. */
+export interface ResolvedValue {
+    value: unknown;
+    source: ResolvedSource;
+}
+/** The per-data-point verification metadata (one `__meta` map entry). */
+export interface DataPointMeta {
+    anchor: DataPointAnchor;
+    candidates: CandidateSet;
+    discrepancy: boolean;
+    resolved: ResolvedValue;
+}
+/** An object node in the rendered `data` tree carrying a keyed `__meta` map. */
+export type MetaCarrier = Record<string, unknown> & {
+    __meta?: Record<string, DataPointMeta>;
+};
+/** Arguments the library passes to the host-injected save transport (guide §7.4). */
+export interface SaveOverrideArgs {
+    workflow_input_id: number | string | null | undefined;
+    object_ids: Array<number | string>;
+    field: string;
+    field_path: string;
+    value: string | null;
+    source_choice: SourceChoice;
+}
+/**
+ * The host-injected save transport. Backend-agnostic: the host supplies the
+ * authenticated request and returns the recomputed {@link DataPointMeta}. Its mere
+ * presence means edits are authorized; absence makes every field read-only.
+ */
+export type SaveOverrideFn = (args: SaveOverrideArgs) => Promise<DataPointMeta> | DataPointMeta;

package/dist/useSaveDataPoint.d.ts

@@ -0,0 +1,17 @@
+import type { Ref } from "vue";
+import type { Verification } from "./context";
+import type { DataPointMeta, SourceChoice } from "./types";
+/** A bound save: commit an override (pinned candidate or custom value). */
+export type SaveDataPointFn = (value: string | null, sourceChoice: SourceChoice) => Promise<DataPointMeta>;
+/** The transport-bearing slice of the verification state a save needs. */
+export type SaveContext = Pick<Verification, "saveOverride" | "workflowInputId">;
+/**
+ * Build a save function for one data point, bound to its anchor + the host
+ * transport. Reads the anchor from the CURRENT meta, commits an override, and
+ * hands the host's recomputed {@link DataPointMeta} to `onSaved` so the caller can
+ * update its writable state and re-render the new resolution.
+ *
+ * Returns null when no transport was passed to `initVerification` OR the meta
+ * carries no anchor — both mean the field is read-only.
+ */
+export declare function useSaveDataPoint(verification: SaveContext, currentMeta: Ref<DataPointMeta | null | undefined>, onSaved: (meta: DataPointMeta) => void): SaveDataPointFn | null;

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@thehammer/template-verification",
+  "version": "0.1.0",
+  "description": "Read-write verification overlay for rendered template apps — per-data-point confidence, discrepancy, 3-source resolution (override > extracted > claim), inline edit, and a recursive comparison page. Consumes the host's __meta sidecar; fetches nothing.",
+  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/newms87/gpt-manager.git",
+    "directory": "template-verification"
+  },
+  "main": "dist/template-verification.js",
+  "module": "dist/template-verification.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/template-verification.js"
+    },
+    "./style.css": "./dist/style.css"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "sideEffects": false,
+  "scripts": {
+    "build": "vite build && vue-tsc --declaration --emitDeclarationOnly -p tsconfig.build.json",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "type-check": "vue-tsc --noEmit -p tsconfig.json"
+  },
+  "peerDependencies": {
+    "@thehammer/danx-ui": ">=0.8.0",
+    "vue": "^3.4.0"
+  },
+  "devDependencies": {
+    "@thehammer/danx-ui": "^0.8.16",
+    "@vitejs/plugin-vue": "^5.0.0",
+    "@vue/test-utils": "^2.4.6",
+    "happy-dom": "^20.3.9",
+    "typescript": "~5.4.0",
+    "vite": "^5.4.0",
+    "vitest": "^2.1.0",
+    "vue": "^3.4.21",
+    "vue-tsc": "^2.0.11"
+  }
+}