@happyvertical/smrt-ingestion 0.57.20 → 0.57.21

package/dist/svelte/components/ReviewView.svelte

@@ -4,85 +4,164 @@ import { useI18n } from '@happyvertical/smrt-ui/i18n';
 import { Button } from '@happyvertical/smrt-ui/ui';
 import { onDestroy, onMount } from 'svelte';
 import type { EvidenceLocation } from '../../extraction-types.js';
+import type { GeneratedSuggestion } from '../../proposal-dto.js';
 import type { IntakeReviewHost, ItemReviewView } from '../../review-dto.js';
 import { M } from '../i18n.js';
-import { evidenceUrl, extractedContent, pageGroups } from '../view-utils.js';
+import {
+  argumentsObject,
+  evidenceUrl,
+  extractedContent,
+  missingRequired,
+  pageGroups,
+} from '../view-utils.js';
 import ActionReview from './ActionReview.svelte';
+import CandidatePicker from './CandidatePicker.svelte';
 import EvidenceViewer from './EvidenceViewer.svelte';
 export interface Props {
   host: IntakeReviewHost;
   itemId: string;
+  /** Reload interval while the host reports the item as processing. */
+  pollMs?: number;
 }
-let { host, itemId }: Props = $props();
+let { host, itemId, pollMs = 2000 }: Props = $props();
 const { t } = useI18n();
 let view = $state<ItemReviewView>(),
   pending = $state(false),
   error = $state(false),
   splits = $state<Record<string, string>>({}),
+  instruction = $state(''),
+  refreshFailed = $state(false),
+  instructionBusy = $state(false),
+  // The draft the server refused as invalid; the note stays until it changes.
+  invalidDraft = $state<string>(),
+  // The draft a stale result left unrecorded; the note stays until the
+  // reviewer edits or resubmits it.
+  unrecordedDraft = $state<string>(),
+  // Human drafts for `needs_review` suggestions, keyed by `attemptId:index`.
+  // They survive refresh, failures and actions on other cards and are cleared
+  // only by a successful preview of their own card.
+  drafts = $state<Record<string, string>>({}),
+  // Drafts the reviewer tried to preview while unparsable; the alert clears
+  // as soon as the draft parses again.
+  invalidDrafts = $state<Record<string, true>>({}),
+  // Suggestion whose last preview the host rejected; its draft is kept.
+  previewRejected = $state<number>(),
   invalid = $state(false);
+/** Same ceiling the server enforces (REVIEWER_INSTRUCTION_MAX_LENGTH). */
+const INSTRUCTION_MAX_LENGTH = 4000;
+const instructionValid = $derived(
+  !!instruction.trim() && instruction.length <= INSTRUCTION_MAX_LENGTH,
+);
+// The busy note after a stale click stays only while the item is still in
+// flight; any reload (including the one answering the click) that shows it
+// settled clears it.
+function settleBusy() {
+  if (instructionBusy && !inFlight(view)) instructionBusy = false;
+}
+/** Consecutive thrown poll ticks tolerated before failing closed. */
+const MAX_POLL_FAILURES = 3;
 let alive = true,
   epoch = 0,
-  loadedPages = 1;
+  loadedPages = 1,
+  poll: ReturnType<typeof setTimeout> | undefined,
+  pollTicks = 0,
+  pollFailures = 0;
 onDestroy(() => {
   alive = false;
   epoch++;
+  clearTimeout(poll);
 });
+function inFlight(current: ItemReviewView | undefined) {
+  return (
+    current?.availability === 'available' &&
+    (current.entry.state === 'processing' ||
+      ['queued', 'running'].includes(current.entry.item.processingState) ||
+      // The server's own predicate, which also covers the gap between a
+      // completed extraction and its not-yet-appended interpretation.
+      !!current.instruction?.reinterpreting)
+  );
+}
+/** Prefer the server's retry binding; otherwise the displayed generation. */
+function instructionBinding(current: ItemReviewView | undefined) {
+  if (current?.instruction?.binding) return current.instruction.binding;
+  return current?.generation && current.analysis
+    ? {
+        attemptId: current.analysis.attemptId,
+        expectedRevision: current.analysis.revision,
+      }
+    : undefined;
+}
+// Background stages (reinterpretation after an instruction) finish without a
+// push channel; the authenticated load is repeated and patched in place so
+// drafts, focus and the evidence viewer survive. The delay backs off to 5x.
+function schedulePoll(ticket: number) {
+  clearTimeout(poll);
+  if (!inFlight(view)) {
+    pollTicks = 0;
+    return;
+  }
+  const delay = Math.min(pollMs * 1.5 ** pollTicks, pollMs * 5);
+  pollTicks++;
+  poll = setTimeout(() => {
+    if (alive && ticket === epoch && !pending) void refresh(ticket);
+  }, delay);
+}
 function deny() {
   epoch++;
+  clearTimeout(poll);
   view = undefined;
   splits = {};
+  // Drafts are the reviewer's own typed text, never host data: they are kept
+  // in memory (nothing renders while the view is denied) so a failed refresh
+  // or a failed action on another card does not discard them.
   error = true;
   pending = false;
 }
-async function load(pageCount = loadedPages) {
-  const ticket = ++epoch;
-  view = undefined;
-  splits = {};
-  pending = true;
-  error = false;
-  invalid = false;
-  try {
-    let cursor: string | undefined;
-    let result: ItemReviewView | undefined;
-    const actions: ItemReviewView['reviews']['actions'] = [];
-    const actionIds = new Set<string>();
-    const cursors = new Set<string>();
-    let refreshedPages = 0;
-    for (let index = 0; index < pageCount; index++) {
-      const page = await host.load(itemId, cursor);
-      if (!alive || ticket !== epoch) return;
-      if (page.availability !== 'available') {
-        result = page;
-        break;
-      }
-      if (
-        result &&
-        page.entry.item.analysisRevision !== result.entry.item.analysisRevision
-      )
-        throw new Error('Review changed during pagination');
-      result ??= page;
-      for (const action of page.reviews.actions) {
-        if (!actionIds.has(action.review.actionId)) {
-          actionIds.add(action.review.actionId);
-          actions.push(action);
-        }
-      }
-      refreshedPages++;
-      cursor = page.reviews.nextCursor;
-      if (!cursor) break;
-      if (cursors.has(cursor)) throw new Error('Repeated review cursor');
-      cursors.add(cursor);
+/** Aggregate the displayed pages with fresh cursors; returns undefined when fenced. */
+async function fetchView(
+  ticket: number,
+  pageCount: number,
+): Promise<{ result: ItemReviewView; pages: number } | undefined> {
+  let cursor: string | undefined;
+  let result: ItemReviewView | undefined;
+  const actions: ItemReviewView['reviews']['actions'] = [];
+  const actionIds = new Set<string>();
+  const cursors = new Set<string>();
+  let refreshedPages = 0;
+  for (let index = 0; index < pageCount; index++) {
+    const page = await host.load(itemId, cursor);
+    if (!alive || ticket !== epoch) return undefined;
+    if (page.availability !== 'available') {
+      result = page;
+      break;
     }
-    if (!result) throw new Error('Missing review page');
-    if (result.availability === 'available') {
-      result = {
-        ...result,
-        reviews: { ...result.reviews, actions, nextCursor: cursor },
-      };
-      loadedPages = refreshedPages;
+    if (
+      result &&
+      page.entry.item.analysisRevision !== result.entry.item.analysisRevision
+    )
+      throw new Error('Review changed during pagination');
+    result ??= page;
+    for (const action of page.reviews.actions) {
+      if (!actionIds.has(action.review.actionId)) {
+        actionIds.add(action.review.actionId);
+        actions.push(action);
+      }
     }
-    // A host denial must not leave any original, candidate, or argument in the DOM.
-    view =
+    refreshedPages++;
+    cursor = page.reviews.nextCursor;
+    if (!cursor) break;
+    if (cursors.has(cursor)) throw new Error('Repeated review cursor');
+    cursors.add(cursor);
+  }
+  if (!result) throw new Error('Missing review page');
+  if (result.availability === 'available')
+    result = {
+      ...result,
+      reviews: { ...result.reviews, actions, nextCursor: cursor },
+    };
+  // A host denial must not leave any original, candidate, or argument in the DOM.
+  return {
+    result:
       result.availability === 'available'
         ? result
         : {
@@ -90,22 +169,128 @@ async function load(pageCount = loadedPages) {
             evidence: [],
             reviews: { actions: [] },
             availability: result.availability,
-          };
-    splits = Object.fromEntries(
-      (view.generation?.splits ?? []).map((split) => [
-        split.evidenceId,
-        JSON.stringify(split.groups),
-      ]),
-    );
+          },
+    pages: refreshedPages,
+  };
+}
+/** Keep only drafts the reviewer edited; untouched ones follow the new generation. */
+function splitDrafts(
+  next: ItemReviewView,
+  keep: Record<string, string>,
+  previous?: ItemReviewView,
+) {
+  const generated = new Map(
+    (previous?.generation?.splits ?? []).map((split) => [
+      split.evidenceId,
+      JSON.stringify(split.groups),
+    ]),
+  );
+  return Object.fromEntries(
+    (next.generation?.splits ?? []).map((split) => {
+      const draft = keep[split.evidenceId];
+      const edited =
+        draft !== undefined && draft !== generated.get(split.evidenceId);
+      return [split.evidenceId, edited ? draft : JSON.stringify(split.groups)];
+    }),
+  );
+}
+function syncSuggestionDrafts(current: ItemReviewView) {
+  // Drafts follow availability: revoked or expired access discards them;
+  // a transient `unavailable` or `stale` result keeps them (nothing renders
+  // meanwhile) so the reviewer's typing survives until the view returns;
+  // an available view prunes drafts of attempts or cards no longer offered.
+  if (
+    current.availability === 'revoked' ||
+    current.availability === 'expired'
+  ) {
+    drafts = {};
+    invalidDrafts = {};
+  } else if (current.availability === 'available') {
+    const attemptId = current.analysis?.attemptId;
+    const keys = new Set<string>();
+    (current.generation?.suggestions ?? []).forEach((suggestion, index) => {
+      if (!attemptId || suggestion.disposition !== 'needs_review') return;
+      const key = `${attemptId}:${index}`;
+      keys.add(key);
+      drafts[key] ??= JSON.stringify(suggestion.args, null, 2);
+    });
+    for (const key of Object.keys(drafts))
+      if (!keys.has(key)) {
+        delete drafts[key];
+        delete invalidDrafts[key];
+      }
+  }
+}
+async function load(pageCount = loadedPages) {
+  const ticket = ++epoch;
+  clearTimeout(poll);
+  pollTicks = 0;
+  pollFailures = 0;
+  refreshFailed = false;
+  view = undefined;
+  splits = {};
+  previewRejected = undefined;
+  pending = true;
+  error = false;
+  invalid = false;
+  try {
+    const fetched = await fetchView(ticket, pageCount);
+    if (!fetched) return;
+    if (fetched.result.availability === 'available')
+      loadedPages = fetched.pages;
+    view = fetched.result;
+    syncSuggestionDrafts(view);
+    splits = splitDrafts(view, {});
+    settleBusy();
   } catch {
     if (alive && ticket === epoch) deny();
   } finally {
-    if (alive && ticket === epoch) pending = false;
+    if (alive && ticket === epoch) {
+      pending = false;
+      schedulePoll(ticket);
+    }
+  }
+}
+/** Poll tick: patch the view in place without blanking it or resetting drafts. */
+async function refresh(ticket: number) {
+  try {
+    const fetched = await fetchView(ticket, loadedPages);
+    if (!fetched || !alive || ticket !== epoch) return;
+    pollFailures = 0;
+    refreshFailed = false;
+    // An explicit host denial fails closed at once.
+    if (fetched.result.availability !== 'available') {
+      view = fetched.result;
+      syncSuggestionDrafts(view);
+      splits = {};
+      return;
+    }
+    if (JSON.stringify(fetched.result) !== JSON.stringify(view)) {
+      loadedPages = fetched.pages;
+      splits = splitDrafts(fetched.result, splits, view);
+      view = fetched.result;
+      syncSuggestionDrafts(view);
+    }
+    settleBusy();
+  } catch {
+    if (!alive || ticket !== epoch) return;
+    // A thrown tick may be transient: keep the view and keep backing off, but
+    // a host may also throw for revoked access, so fail closed after a bound.
+    pollFailures++;
+    if (pollFailures >= MAX_POLL_FAILURES) {
+      refreshFailed = false;
+      deny();
+      return;
+    }
+    refreshFailed = true;
+  } finally {
+    if (alive && ticket === epoch && !pending) schedulePoll(ticket);
   }
 }
 async function run(operation: () => Promise<unknown>) {
   if (pending) return;
   const ticket = ++epoch;
+  clearTimeout(poll);
   pending = true;
   error = false;
   view = undefined;
@@ -117,17 +302,120 @@ async function run(operation: () => Promise<unknown>) {
     if (alive && ticket === epoch) deny();
   }
 }
-function preview(index: number) {
+function offeredHandler(suggestion: GeneratedSuggestion) {
+  return view?.generation?.offered.find(
+    (entry) =>
+      entry.handler.id === suggestion.handlerId &&
+      entry.handler.version === suggestion.handlerVersion,
+  )?.handler;
+}
+// Presentation only: the host rechecks stage, outcome, handler and authority.
+function previewable(suggestion: GeneratedSuggestion) {
+  return (
+    !!view?.analysis &&
+    view.generation?.outcome !== 'provider_error' &&
+    ['ready_for_review', 'needs_review'].includes(suggestion.disposition)
+  );
+}
+function draftKey(index: number) {
+  return `${view?.analysis?.attemptId ?? ''}:${index}`;
+}
+function parseable(draft: string | undefined) {
+  if (draft === undefined) return false;
+  try {
+    argumentsObject(draft);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function edited(index: number) {
+  const suggestion = view?.generation?.suggestions[index];
+  const draft = drafts[draftKey(index)];
+  return (
+    !!suggestion &&
+    draft !== undefined &&
+    draft !== JSON.stringify(suggestion.args, null, 2)
+  );
+}
+// Every schema-required argument must be present in the draft before preview;
+// the host and handler still validate the published arguments.
+function canPreview(index: number) {
+  const suggestion = view?.generation?.suggestions[index];
+  if (!suggestion || !previewable(suggestion)) return false;
+  if (suggestion.disposition !== 'needs_review') return true;
+  const draft = drafts[draftKey(index)];
+  if (draft === undefined) return false;
+  if (suggestion.missingFields.length && !edited(index)) return false;
+  const handler = offeredHandler(suggestion);
+  return !handler || !missingRequired(handler.argsSchema, draft).length;
+}
+async function preview(index: number) {
   const analysis = view?.analysis;
   const suggestion = view?.generation?.suggestions[index];
-  if (!analysis || suggestion?.disposition !== 'ready_for_review') return;
+  if (pending || !analysis || !suggestion || !canPreview(index)) return;
+  let args: Record<string, unknown> | undefined;
+  const key = draftKey(index);
+  if (suggestion.disposition === 'needs_review' && edited(index)) {
+    try {
+      args = argumentsObject(drafts[key]);
+    } catch {
+      invalidDrafts[key] = true;
+      return;
+    }
+  }
   const input = {
     itemId,
     attemptId: analysis.attemptId,
     index,
     requestId: crypto.randomUUID(),
+    ...(args ? { args } : {}),
+  };
+  // Only the handler's validation refusal stays inline and keeps the view:
+  // a resolved `{ rejected: 'invalid' }` or a thrown error named
+  // `HandlerArgumentsInvalidError`. Anything else fails closed.
+  const ticket = ++epoch;
+  pending = true;
+  error = false;
+  previewRejected = undefined;
+  try {
+    const outcome = await host.preview(input);
+    if (!alive || ticket !== epoch) return;
+    if (outcome?.rejected === 'invalid') {
+      previewRejected = index;
+      pending = false;
+      return;
+    }
+    // Only a successful preview of this card consumes its draft.
+    delete drafts[key];
+    delete invalidDrafts[key];
+    await load();
+  } catch (error) {
+    if (!alive || ticket !== epoch) return;
+    if (
+      (error as { name?: unknown } | null)?.name ===
+      'HandlerArgumentsInvalidError'
+    ) {
+      previewRejected = index;
+      pending = false;
+      return;
+    }
+    deny();
+  }
+}
+function chooseFor(index: number) {
+  return (field: string, id: string) => {
+    const key = draftKey(index);
+    try {
+      drafts[key] = JSON.stringify(
+        { ...argumentsObject(drafts[key] ?? '{}'), [field]: id },
+        null,
+        2,
+      );
+    } catch {
+      invalidDrafts[key] = true;
+    }
   };
-  void run(() => host.preview(input));
 }
 function split(evidenceId: string) {
   const analysis = view?.analysis;
@@ -149,6 +437,36 @@ function split(evidenceId: string) {
   };
   void run(() => host.split(input));
 }
+function instruct() {
+  const binding = instructionBinding(view);
+  const text = instruction.trim();
+  const operation = host.instruct;
+  if (!binding || !instructionValid || !operation || inFlight(view)) return;
+  instructionBusy = false;
+  invalidDraft = undefined;
+  unrecordedDraft = undefined;
+  const input = {
+    itemId,
+    ...binding,
+    text,
+    requestId: crypto.randomUUID(),
+  };
+  // A stale result is a refresh-and-retry signal: run() reloads the view and
+  // the draft is kept; it is never treated as a denial.
+  void run(async () => {
+    const result = await operation(input);
+    if (result && 'stale' in result && result.stale === true) {
+      instructionBusy = true;
+      unrecordedDraft = instruction;
+      return;
+    }
+    if (result && 'invalid' in result && result.invalid === true) {
+      invalidDraft = instruction;
+      return;
+    }
+    instruction = '';
+  });
+}
 function locationLabel(location: EvidenceLocation) {
   switch (location.kind) {
     case 'page':
@@ -199,12 +517,25 @@ onMount(() => {
 <header><h1>{t(M['ingestion.review'])}</h1><Button onclick={() => load()} disabled={pending}>{t(M['ingestion.refresh'])}</Button></header>
 {#if pending}<p role="status">{t(M['ingestion.loading'])}</p>{/if}
 {#if error}<p role="alert">{t(M['ingestion.error'])}</p>{/if}
+{#if refreshFailed}<p role="status" data-testid="refresh-retrying">{t(M['ingestion.refreshRetrying'])}</p>{/if}
 {#if view}
 {#if view.availability !== 'available'}<p role="alert">{t(M[`ingestion.${view.availability}`])}</p>
 {:else}
 {@const extracted = view.analysis ? extractedContent(view.analysis.result.output) : []}
 <h2>{view.entry.label}</h2><p>{t(M[`ingestion.${view.entry.state}`])}</p>
 <div class="review-grid"><EvidenceViewer evidence={view.evidence} /><div class="details">
+{#if view.instruction}
+{@const applied = view.instruction.applied}{@const current = view.instruction.current}
+{#if inFlight(view) && current}<p role="status" data-testid="reinterpreting">{t(M['ingestion.reinterpreting'])}</p>{/if}
+{#if view.instruction.failure === 'not_started'}<p role="alert" data-testid="instruction-failure">{t(M['ingestion.reinterpretNotStarted'])}</p>{:else if view.instruction.failure}<p role="alert" data-testid="instruction-failure">{t(M['ingestion.reinterpretFailed'])} ({view.instruction.failure})</p>{/if}
+{#if applied}<p data-testid="applied-instruction">{t(M['ingestion.appliedInstruction'])}: <q>{applied.text}</q></p>{#if view.instruction.stale}<p role="status" data-testid="instruction-stale">{t(M['ingestion.instructionStale'])}</p>{/if}{/if}
+{#if current && current.id !== applied?.id}<p data-testid="pending-instruction">{t(M['ingestion.pendingInstruction'])}: <q>{current.text}</q></p>{/if}
+{#if view.instruction.dropped}<p role="status" data-testid="dropped-instruction">{t(M['ingestion.droppedInstruction'])}: <q>{view.instruction.dropped.text}</q></p>{/if}
+{/if}
+{#if instructionBusy}<p role="status" data-testid="instruction-busy">{t(M['ingestion.instructionBusy'])}</p>{:else if unrecordedDraft !== undefined && unrecordedDraft === instruction}<p role="status" data-testid="instruction-not-recorded">{t(M['ingestion.instructionNotRecorded'])}</p>{/if}
+{#if host.instruct && instructionBinding(view)}
+<div><Textarea aria-label={t(M['ingestion.instructions'])} aria-describedby="instruction-length" maxlength={INSTRUCTION_MAX_LENGTH} bind:value={instruction} /><p id="instruction-length" data-testid="instruction-length">{t(M['ingestion.instructionLength'], { count: instruction.length, max: INSTRUCTION_MAX_LENGTH })}</p>{#if invalidDraft !== undefined && invalidDraft === instruction}<p role="alert" data-testid="instruction-invalid">{t(M['ingestion.instructionInvalid'], { max: INSTRUCTION_MAX_LENGTH })}</p>{/if}<Button disabled={!instructionValid || inFlight(view)} onclick={instruct}>{t(M['ingestion.reinterpret'])}</Button></div>
+{/if}
 {#if extracted.length}
 <h2>{t(M['ingestion.extracted'])}</h2>
 {#each extracted as segment}
@@ -224,7 +555,17 @@ onMount(() => {
 {#if suggestion.alternatives.length}<h4>{t(M['ingestion.alternatives'])}</h4><ul>{#each suggestion.alternatives as alternative}<li>{alternative}</li>{/each}</ul>{/if}
 {#if suggestion.missingFields.length}<h4>{t(M['ingestion.missing'])}</h4><ul>{#each suggestion.missingFields as missing}<li>{missing}</li>{/each}</ul>{/if}
 <ul>{#each suggestion.evidence as reference}{@const url = locationUrl(reference.evidenceId,reference.location)}<li>{#if url}<Button href={url} target="_blank" rel="noopener noreferrer">{locationLabel(reference.location)}</Button>{:else}{locationLabel(reference.location)}{/if}</li>{/each}</ul>
-<Button disabled={suggestion.disposition !== 'ready_for_review' || !view.analysis} onclick={() => preview(index)}>{t(M['ingestion.preview'])}</Button>
+{#if suggestion.disposition === 'needs_review' && previewable(suggestion)}
+{@const handler = offeredHandler(suggestion)}
+{@const key = draftKey(index)}
+<p>{t(M['ingestion.completeSuggestion'])}</p>
+<Textarea aria-label={t(M['ingestion.suggestionArgs'])} bind:value={drafts[key]} rows={6} />
+{#if handler}<CandidatePicker {host} {itemId} catalog={handler} {deny} onchoose={chooseFor(index)} />{/if}
+{#if edited(index)}<p>{t(M['ingestion.reviewAgain'])}</p>{/if}
+{#if invalidDrafts[key] && !parseable(drafts[key])}<p role="alert">{t(M['ingestion.invalid'])}</p>{/if}
+{/if}
+{#if previewRejected === index}<p role="alert">{t(M['ingestion.previewRejected'])}</p>{/if}
+<Button disabled={!canPreview(index)} onclick={() => preview(index)}>{t(M['ingestion.preview'])}</Button>
 </article>
 {/each}
 {#each generation.splits as proposed (proposed.evidenceId)}<div><Textarea aria-label={`${t(M['ingestion.split'])}: ${proposed.evidenceId}`} bind:value={splits[proposed.evidenceId]} /><Button disabled={!view.analysis} onclick={() => split(proposed.evidenceId)}>{t(M['ingestion.saveSplit'])}</Button></div>{/each}

package/dist/svelte/components/ReviewView.svelte.d.ts

@@ -2,6 +2,8 @@ import type { IntakeReviewHost } from '../../review-dto.js';
 export interface Props {
     host: IntakeReviewHost;
     itemId: string;
+    /** Reload interval while the host reports the item as processing. */
+    pollMs?: number;
 }
 declare const ReviewView: import("svelte").Component<Props, {}, "">;
 type ReviewView = ReturnType<typeof ReviewView>;

package/dist/svelte/components/ReviewView.svelte.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ReviewView.svelte.d.ts","sourceRoot":"","sources":["../../../src/svelte/components/ReviewView.svelte.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,gBAAgB,EAAkB,MAAM,qBAAqB,CAAC;AAM5E,MAAM,WAAW,KAAK;IACpB,IAAI,EAAE,gBAAgB,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;CAChB;AAkPD,QAAA,MAAM,UAAU,2CAAwC,CAAC;AACzD,KAAK,UAAU,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC;AAChD,eAAe,UAAU,CAAC"}
+{"version":3,"file":"ReviewView.svelte.d.ts","sourceRoot":"","sources":["../../../src/svelte/components/ReviewView.svelte.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,gBAAgB,EAAkB,MAAM,qBAAqB,CAAC;AAa5E,MAAM,WAAW,KAAK;IACpB,IAAI,EAAE,gBAAgB,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,qEAAqE;IACrE,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AA+jBD,QAAA,MAAM,UAAU,2CAAwC,CAAC;AACzD,KAAK,UAAU,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC;AAChD,eAAe,UAAU,CAAC"}

package/dist/svelte/i18n.d.ts

@@ -33,6 +33,9 @@ export declare const M: {
     readonly 'ingestion.proposals': "ingestion.proposals";
     readonly 'ingestion.preview': "ingestion.preview";
     readonly 'ingestion.args': "ingestion.args";
+    readonly 'ingestion.suggestionArgs': "ingestion.suggestionArgs";
+    readonly 'ingestion.previewRejected': "ingestion.previewRejected";
+    readonly 'ingestion.completeSuggestion': "ingestion.completeSuggestion";
     readonly 'ingestion.effects': "ingestion.effects";
     readonly 'ingestion.approve': "ingestion.approve";
     readonly 'ingestion.reject': "ingestion.reject";
@@ -49,6 +52,20 @@ export declare const M: {
     readonly 'ingestion.choose': "ingestion.choose";
     readonly 'ingestion.split': "ingestion.split";
     readonly 'ingestion.saveSplit': "ingestion.saveSplit";
+    readonly 'ingestion.instructions': "ingestion.instructions";
+    readonly 'ingestion.reinterpret': "ingestion.reinterpret";
+    readonly 'ingestion.reinterpreting': "ingestion.reinterpreting";
+    readonly 'ingestion.appliedInstruction': "ingestion.appliedInstruction";
+    readonly 'ingestion.pendingInstruction': "ingestion.pendingInstruction";
+    readonly 'ingestion.refreshRetrying': "ingestion.refreshRetrying";
+    readonly 'ingestion.instructionNotRecorded': "ingestion.instructionNotRecorded";
+    readonly 'ingestion.instructionLength': "ingestion.instructionLength";
+    readonly 'ingestion.instructionInvalid': "ingestion.instructionInvalid";
+    readonly 'ingestion.droppedInstruction': "ingestion.droppedInstruction";
+    readonly 'ingestion.reinterpretNotStarted': "ingestion.reinterpretNotStarted";
+    readonly 'ingestion.instructionBusy': "ingestion.instructionBusy";
+    readonly 'ingestion.reinterpretFailed': "ingestion.reinterpretFailed";
+    readonly 'ingestion.instructionStale': "ingestion.instructionStale";
     readonly 'ingestion.result': "ingestion.result";
     readonly 'ingestion.stale': "ingestion.stale";
     readonly 'ingestion.revoked': "ingestion.revoked";

package/dist/svelte/i18n.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../../src/svelte/i18n.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuEZ,CAAC"}
+{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../../src/svelte/i18n.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkGZ,CAAC"}

package/dist/svelte/i18n.js

@@ -34,6 +34,9 @@ export const M = defineMessages({
     'ingestion.proposals': 'Proposed actions',
     'ingestion.preview': 'Prepare review',
     'ingestion.args': 'Exact arguments (JSON)',
+    'ingestion.suggestionArgs': 'Suggested arguments (JSON)',
+    'ingestion.previewRejected': 'These arguments did not pass the handler validation. Correct them and prepare review again.',
+    'ingestion.completeSuggestion': 'This suggestion needs review. Complete or confirm its arguments, then prepare review.',
     'ingestion.effects': 'Proposed effects',
     'ingestion.approve': 'Approve',
     'ingestion.reject': 'Reject',
@@ -50,6 +53,20 @@ export const M = defineMessages({
     'ingestion.choose': 'Choose destination',
     'ingestion.split': 'Logical page groups (JSON)',
     'ingestion.saveSplit': 'Save split and reprocess',
+    'ingestion.instructions': 'Instructions for the assistant',
+    'ingestion.reinterpret': 'Re-read with these instructions',
+    'ingestion.reinterpreting': 'Reinterpreting…',
+    'ingestion.appliedInstruction': 'Suggestions were produced under this instruction',
+    'ingestion.pendingInstruction': 'Latest instruction, not yet applied',
+    'ingestion.refreshRetrying': "Couldn't refresh; retrying.",
+    'ingestion.instructionNotRecorded': 'This item changed while you were writing; your instruction was not recorded.',
+    'ingestion.instructionLength': '{count} / {max} characters',
+    'ingestion.instructionInvalid': 'Enter an instruction of 1 to {max} characters. It was not recorded.',
+    'ingestion.droppedInstruction': "A reprocess replaced this item's extraction, so this instruction no longer applies. Re-record it to use it",
+    'ingestion.reinterpretNotStarted': 'The reinterpretation did not start. Re-read again to retry.',
+    'ingestion.instructionBusy': 'This item changed or is still being re-read. It has been refreshed; try again when it finishes.',
+    'ingestion.reinterpretFailed': 'The reinterpretation did not complete. Adjust the instruction or re-read again.',
+    'ingestion.instructionStale': 'Superseded: the current suggestions do not reflect the latest instruction.',
     'ingestion.result': 'Result',
     'ingestion.stale': 'Stale',
     'ingestion.revoked': 'Access revoked',

package/dist/svelte/index.d.ts

@@ -1,4 +1,4 @@
-export type { Assignment, EvidenceView, InboxEntry, InboxState, IntakeReviewHost, ItemReviewView, LogicalSplitInput, ReviewAction, ReviewPage, } from '../review-dto.js';
+export type { Assignment, EvidenceView, InboxEntry, InboxEvidence, InboxState, IntakeReviewHost, ItemReviewView, LogicalSplitInput, PreviewRejection, ReviewAction, ReviewerInstruction, ReviewerInstructionInput, ReviewerInstructionView, ReviewPage, } from '../review-dto.js';
 export { default as EvidenceViewer } from './components/EvidenceViewer.svelte';
 export { default as IntakeInbox } from './components/IntakeInbox.svelte';
 export { default as IntakeReview } from './components/IntakeReview.svelte';

package/dist/svelte/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/svelte/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,UAAU,EACV,YAAY,EACZ,UAAU,EACV,UAAU,EACV,gBAAgB,EAChB,cAAc,EACd,iBAAiB,EACjB,YAAY,EACZ,UAAU,GACX,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAC/E,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,kCAAkC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/svelte/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,UAAU,EACV,YAAY,EACZ,UAAU,EACV,aAAa,EACb,UAAU,EACV,gBAAgB,EAChB,cAAc,EACd,iBAAiB,EACjB,gBAAgB,EAChB,YAAY,EACZ,mBAAmB,EACnB,wBAAwB,EACxB,uBAAuB,EACvB,UAAU,GACX,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAC/E,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,kCAAkC,CAAC"}

package/dist/svelte/view-utils.d.ts

@@ -2,6 +2,8 @@ import type { EvidenceLocation } from '../extraction-types.js';
 /** Only host-authorized same-origin HTTP URLs may reach original media elements. */
 export declare function evidenceUrl(value?: string, origin?: string): string | undefined;
 export declare function argumentsObject(value: string): Record<string, unknown>;
+/** Required top-level handler arguments missing from a JSON draft; unparsable drafts report none. */
+export declare function missingRequired(schema: Record<string, unknown>, draft: string): string[];
 export declare function pageGroups(value: string): number[][];
 /** Project useful extraction content; never present internal configuration/provenance JSON. */
 export declare function extractedContent(output: Record<string, unknown>): Array<{