@joewinke/jatui 0.37.0 → 0.38.0

package/dist/artifact-blocks/review/ItemNote.svelte

@@ -0,0 +1,193 @@
+<script lang="ts" module>
+  import type { VerdictOption } from "../../actions/reviewKeys"
+
+  /** The per-item note's ReviewNote props (MOS ReviewComposer note mode). */
+  export interface ItemNoteProps {
+    value?: string
+    verdict?: string | null
+    options?: readonly VerdictOption[]
+    round?: string | number | null
+    saveFailed?: boolean
+    onSave?: (
+      text: string,
+      ctx: { round: string | number | null },
+    ) => void | Promise<void>
+    onInput?: (text: string) => void
+    debounceMs?: number
+    returnFocusTo?: () => HTMLElement | null | undefined
+    id?: string
+    label?: string
+    placeholder?: string
+    disabled?: boolean
+  }
+</script>
+
+<script lang="ts">
+  /**
+   * ItemNote — the per-item verdict note of the item-review blocks
+   * (media-picker, diff-review). Ported from MOS ReviewComposer's `note`
+   * mode: jatui ReviewNote IS the text leg (its round model,
+   * open-on-negative-verdict and debounced save are unchanged), and an
+   * attach lane rides under it while the note is open.
+   *
+   * The upload leg is the HOST's (`HostAdapter.upload(artifactId)`): it
+   * stores the bytes first and returns the descriptor, which this hands to
+   * `onClipsChange` for the block to save on the item's entry. No upload
+   * leg → text-only, exactly like the plain composer. Recording (voice /
+   * video / screen) is the host composer's job, not this lane's.
+   */
+  import ReviewNote from "../../components/review/ReviewNote.svelte"
+  import AttachmentChip from "../AttachmentChip.svelte"
+  import { hostAdapter } from "../adapter.js"
+  import type { NoteAttachment } from "../types.js"
+
+  let {
+    artifactId,
+    note,
+    open = $bindable(false),
+    clips = [],
+    onClipsChange = undefined,
+    disabled = false,
+    maxClips = 10,
+  }: {
+    artifactId: string
+    note: ItemNoteProps
+    open?: boolean
+    /** The item's saved attachments (seed). */
+    clips?: NoteAttachment[]
+    onClipsChange?: (clips: NoteAttachment[]) => void
+    disabled?: boolean
+    maxClips?: number
+  } = $props()
+
+  const adapter = hostAdapter()
+  const upload = $derived(adapter.upload?.(artifactId))
+  const Chip = adapter.attachmentChip ?? AttachmentChip
+
+  // The local copy follows the saved list until this note changes it.
+  let local = $state<NoteAttachment[] | null>(null)
+  const shown = $derived(local ?? clips)
+  let uploading = $state(0)
+  let error = $state<string | null>(null)
+  let fileEl = $state<HTMLInputElement | null>(null)
+  const canAttach = $derived(Boolean(upload) && !disabled)
+
+  function setClips(next: NoteAttachment[]) {
+    local = next
+    onClipsChange?.(next)
+  }
+
+  async function addFiles(files: Iterable<File>) {
+    if (!upload) return
+    for (const f of files) {
+      if (shown.length + uploading >= maxClips) {
+        error = `At most ${maxClips} attachments per note.`
+        break
+      }
+      uploading++
+      error = null
+      try {
+        const clip = await upload(f, "file")
+        setClips([...shown, clip])
+      } catch (e) {
+        error =
+          e instanceof Error && e.message
+            ? e.message
+            : "Couldn't save that attachment. Please try again."
+      } finally {
+        uploading--
+      }
+    }
+  }
+
+  function onPaste(e: ClipboardEvent) {
+    if (!canAttach) return
+    const files = [...(e.clipboardData?.files ?? [])]
+    if (files.length === 0) return
+    e.preventDefault()
+    void addFiles(files)
+  }
+
+  function onDrop(e: DragEvent) {
+    if (!canAttach) return
+    const files = [...(e.dataTransfer?.files ?? [])]
+    if (files.length === 0) return
+    e.preventDefault()
+    void addFiles(files)
+  }
+</script>
+
+<div
+  role="group"
+  aria-label="Review note"
+  ondragover={(e) => canAttach && e.preventDefault()}
+  ondrop={onDrop}
+  onpaste={onPaste}
+  data-item-note
+>
+  <ReviewNote
+    bind:open
+    value={note.value ?? ""}
+    verdict={note.verdict ?? null}
+    options={note.options ?? []}
+    round={note.round ?? null}
+    saveFailed={note.saveFailed ?? false}
+    onSave={note.onSave}
+    onInput={note.onInput}
+    debounceMs={note.debounceMs}
+    returnFocusTo={note.returnFocusTo}
+    label={note.label ?? "Note"}
+    placeholder={note.placeholder ?? "What needs to change?"}
+    id={note.id}
+    disabled={note.disabled ?? disabled}
+  />
+  {#if open}
+    {#if shown.length > 0 || uploading > 0}
+      <ul class="mt-2 flex flex-wrap items-center gap-1.5" aria-label="Attachments">
+        {#each shown as clip (clip.name)}
+          <li class="flex items-center gap-0.5">
+            <Chip {clip} />
+            {#if !disabled}
+              <button
+                type="button"
+                class="btn btn-ghost btn-xs btn-circle"
+                aria-label="Remove {clip.label ?? clip.name}"
+                onclick={() => setClips(shown.filter((c) => c !== clip))}>✕</button
+              >
+            {/if}
+          </li>
+        {/each}
+        {#if uploading > 0}
+          <li class="text-base-content/60 flex items-center gap-1.5 text-xs" role="status">
+            <span class="loading loading-spinner loading-xs"></span>Attaching…
+          </li>
+        {/if}
+      </ul>
+    {/if}
+    {#if error}
+      <p role="alert" class="text-error mt-1 text-xs">{error}</p>
+    {/if}
+    {#if canAttach}
+      <div class="mt-2 flex flex-wrap items-center gap-2">
+        <input
+          bind:this={fileEl}
+          type="file"
+          multiple
+          class="hidden"
+          onchange={(e) => {
+            const input = e.currentTarget as HTMLInputElement
+            void addFiles([...(input.files ?? [])])
+            input.value = ""
+          }}
+        />
+        <button
+          type="button"
+          class="btn btn-ghost btn-xs rounded-field"
+          onclick={() => fileEl?.click()}
+        >
+          Attach file
+        </button>
+      </div>
+    {/if}
+  {/if}
+</div>

package/dist/artifact-blocks/review/ItemNote.svelte.d.ts

@@ -0,0 +1,33 @@
+import type { VerdictOption } from "../../actions/reviewKeys";
+/** The per-item note's ReviewNote props (MOS ReviewComposer note mode). */
+export interface ItemNoteProps {
+    value?: string;
+    verdict?: string | null;
+    options?: readonly VerdictOption[];
+    round?: string | number | null;
+    saveFailed?: boolean;
+    onSave?: (text: string, ctx: {
+        round: string | number | null;
+    }) => void | Promise<void>;
+    onInput?: (text: string) => void;
+    debounceMs?: number;
+    returnFocusTo?: () => HTMLElement | null | undefined;
+    id?: string;
+    label?: string;
+    placeholder?: string;
+    disabled?: boolean;
+}
+import type { NoteAttachment } from "../types.js";
+type $$ComponentProps = {
+    artifactId: string;
+    note: ItemNoteProps;
+    open?: boolean;
+    /** The item's saved attachments (seed). */
+    clips?: NoteAttachment[];
+    onClipsChange?: (clips: NoteAttachment[]) => void;
+    disabled?: boolean;
+    maxClips?: number;
+};
+declare const ItemNote: import("svelte").Component<$$ComponentProps, {}, "open">;
+type ItemNote = ReturnType<typeof ItemNote>;
+export default ItemNote;

package/dist/artifact-blocks/review/NoteToggle.svelte

@@ -0,0 +1,52 @@
+<script lang="ts">
+  /**
+   * NoteToggle — the "Note" button beside a review item's VerdictControl
+   * (media-picker, diff-review). It shows / hides the item's jatui ReviewNote
+   * and carries a marker when the current round already has a note.
+   */
+  import BlockIcon from "./BlockIcon.svelte"
+
+  let {
+    open,
+    hasNote,
+    controls,
+    itemTitle,
+    /** mos-guqgs: a surface that cannot save renders the toggle visibly
+     *  disabled — never clickable-but-useless. */
+    disabled = false,
+    onToggle,
+  }: {
+    open: boolean
+    hasNote: boolean
+    /** id of the note's textarea (ReviewNote `id`). */
+    controls: string
+    itemTitle: string
+    disabled?: boolean
+    onToggle: () => void
+  } = $props()
+</script>
+
+<button
+  type="button"
+  class="btn btn-ghost btn-sm ml-auto gap-1 rounded-field px-2 {open
+    ? 'text-base-content'
+    : 'text-base-content/75'}"
+  aria-expanded={open}
+  aria-controls={controls}
+  aria-label="Note for {itemTitle}"
+  aria-keyshortcuts="n"
+  {disabled}
+  data-has-note={hasNote ? "true" : undefined}
+  data-note-toggle
+  onclick={onToggle}
+>
+  Note
+  {#if hasNote}
+    <BlockIcon name="sticky-note"
+      size={14}
+      stroke-width={2.25}
+      class="text-primary"
+      aria-hidden="true"
+    /><span class="sr-only">(has a note)</span>
+  {/if}
+</button>

package/dist/artifact-blocks/review/NoteToggle.svelte.d.ts

@@ -0,0 +1,12 @@
+type $$ComponentProps = {
+    open: boolean;
+    hasNote: boolean;
+    /** id of the note's textarea (ReviewNote `id`). */
+    controls: string;
+    itemTitle: string;
+    disabled?: boolean;
+    onToggle: () => void;
+};
+declare const NoteToggle: import("svelte").Component<$$ComponentProps, {}, "">;
+type NoteToggle = ReturnType<typeof NoteToggle>;
+export default NoteToggle;

package/dist/artifact-blocks/review/TeamChip.svelte

@@ -0,0 +1,71 @@
+<script lang="ts">
+  /**
+   * TeamChip — an item's team status (D7, ./team.ts), rendered like the
+   * checklist's Team column: quiet "Team" label, a tone icon, the words.
+   * `retest` adds the Retest chip: a new round is open (the team marked it
+   * ready, or a new version is up) and this viewer has not decided it yet.
+   * With no `team` only the Retest chip renders.
+   */
+  import BlockIcon from "./BlockIcon.svelte"
+  import { ITEM_TEAM_LABEL, type ItemTeam } from "./team.js"
+
+  let {
+    team,
+    retest = false,
+  }: {
+    team?: ItemTeam | undefined
+    retest?: boolean
+  } = $props()
+
+  const ICON = { ready: "rotate-ccw", in_progress: "circle-dot-dashed" } as const
+  const TONE = {
+    ready: "text-info",
+    in_progress: "text-base-content/70",
+  } as const
+  const since = $derived.by(() => {
+    if (!team?.readySince) return ""
+    const t = Date.parse(team.readySince)
+    return Number.isNaN(t)
+      ? ""
+      : new Date(t).toLocaleString("en-US", {
+          month: "short",
+          day: "numeric",
+          hour: "numeric",
+          minute: "2-digit",
+        })
+  })
+</script>
+
+<span class="inline-flex flex-wrap items-center gap-1.5 text-xs">
+  {#if team}
+        <span
+      class="inline-flex items-center gap-1"
+      data-team-status={team.status}
+      title="Team status: what the last publish recorded"
+    >
+      <span class="text-base-content/70"
+        >Team<span class="sr-only">{": "}</span></span
+      >
+      <BlockIcon
+        name={ICON[team.status]}
+        size={14}
+        stroke-width={2.25}
+        class={TONE[team.status]}
+        aria-hidden="true"
+      />
+      <span class="font-medium text-base-content"
+        >{ITEM_TEAM_LABEL[team.status]}</span
+      >
+    </span>
+  {/if}
+  {#if retest}
+    <span
+      class="badge badge-sm badge-info"
+      data-retest-chip
+      title={since
+        ? `Ready since ${since}: your earlier verdict is locked below, decide again`
+        : "A new round is up: your earlier verdict is locked below, decide again"}
+      >Retest</span
+    >
+  {/if}
+</span>

package/dist/artifact-blocks/review/TeamChip.svelte.d.ts

@@ -0,0 +1,8 @@
+import { type ItemTeam } from "./team.js";
+type $$ComponentProps = {
+    team?: ItemTeam | undefined;
+    retest?: boolean;
+};
+declare const TeamChip: import("svelte").Component<$$ComponentProps, {}, "">;
+type TeamChip = ReturnType<typeof TeamChip>;
+export default TeamChip;

package/dist/artifact-blocks/review/attachments.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Reading saved note attachments back out of a block's state (untrusted
+ * stored JSON) — ported from MOS modules/artifacts/noteAttachments.ts
+ * (readNoteAttachments) for the item-review blocks. The descriptors were
+ * validated by the HOST on the write path; this only re-shapes them, and an
+ * entry that is not a descriptor drops the whole list (never half a note).
+ */
+import type { NoteAttachment } from "../types.js";
+export type { NoteAttachment };
+export declare function readNoteAttachments(raw: unknown): NoteAttachment[] | undefined;

package/dist/artifact-blocks/review/attachments.js

@@ -0,0 +1,37 @@
+const ATTACHMENT_KINDS = [
+    "screen",
+    "voice",
+    "audio",
+    "video",
+    "image",
+    "file",
+];
+const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+export function readNoteAttachments(raw) {
+    if (!Array.isArray(raw) || raw.length === 0)
+        return undefined;
+    const out = [];
+    for (const entry of raw) {
+        if (!isObj(entry))
+            return undefined;
+        if (typeof entry.name !== "string" || typeof entry.url !== "string")
+            return undefined;
+        out.push({
+            name: entry.name,
+            url: entry.url,
+            contentType: typeof entry.contentType === "string" ? entry.contentType : "",
+            sizeBytes: typeof entry.sizeBytes === "number" ? entry.sizeBytes : 0,
+            kind: ATTACHMENT_KINDS.includes(entry.kind)
+                ? entry.kind
+                : "file",
+            durationSeconds: typeof entry.durationSeconds === "number"
+                ? entry.durationSeconds
+                : null,
+            transcript: typeof entry.transcript === "string" ? entry.transcript : null,
+            ...(typeof entry.label === "string" && entry.label
+                ? { label: entry.label }
+                : {}),
+        });
+    }
+    return out;
+}

package/dist/artifact-blocks/review/bulk.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Bulk verdicts for the review blocks (mos-nv4eb, mos-u8i35): accept OR
+ * reject many items in ONE save, and keep what Undo needs to put them back.
+ *
+ * Joe 2026-10-19: "bulk accept OR reject, and then go through and flip the
+ * outliers either way." Which items a bulk may touch is the block's call
+ * (still undecided, not a retest, shown under the active filter); this module
+ * only writes the verdict through the block's own round model, so a bulk
+ * entry is byte-for-byte what a single click would have saved.
+ */
+/** The `save` of a block's `useRounds()` binding (../review/rounds.ts). */
+type RoundSave = (stored: unknown, patch: Record<string, unknown>, current: string | null | undefined) => Record<string, unknown>;
+type Entry = {
+    verdict?: string;
+    at?: string;
+};
+export type BulkTarget = {
+    id: string;
+    /** The round the item is in (its team readySince / version). */
+    round: string | null;
+    /** Extra fields saved with the verdict (a pinned variant…). */
+    patch?: Record<string, unknown>;
+};
+export type BulkUndo<D> = {
+    /** The verdict the bulk cast. */
+    verdict: string;
+    /** The one `at` stamp every bulk-written entry carries. */
+    at: string;
+    /** Each touched item's entry before the bulk (undefined = it had none). */
+    prior: Record<string, D | undefined>;
+};
+/**
+ * Cast `verdict` on every target. A non-empty `note` is the shared note a
+ * bulk reject asks for ("Why? applies to all N"); it joins each target's own
+ * draft note rather than replacing it.
+ */
+export declare function decideMany<D extends Entry>(decisions: Record<string, D>, targets: readonly BulkTarget[], opts: {
+    verdict: string;
+    at: string;
+    note?: string;
+    save: RoundSave;
+}): {
+    decisions: Record<string, D>;
+    undo: BulkUndo<D>;
+};
+/**
+ * Put every bulk-decided item back exactly as it was. An item the reviewer
+ * changed AFTER the bulk (a flip, a note — anything that re-stamps `at`)
+ * keeps that later change: Undo reverts the bulk, not their work.
+ */
+export declare function undoMany<D extends Entry>(decisions: Record<string, D>, undo: BulkUndo<D>): Record<string, D>;
+export {};

package/dist/artifact-blocks/review/bulk.js

@@ -0,0 +1,61 @@
+/**
+ * Bulk verdicts for the review blocks (mos-nv4eb, mos-u8i35): accept OR
+ * reject many items in ONE save, and keep what Undo needs to put them back.
+ *
+ * Joe 2026-10-19: "bulk accept OR reject, and then go through and flip the
+ * outliers either way." Which items a bulk may touch is the block's call
+ * (still undecided, not a retest, shown under the active filter); this module
+ * only writes the verdict through the block's own round model, so a bulk
+ * entry is byte-for-byte what a single click would have saved.
+ */
+/** Join a shared bulk note onto a line's own draft note: typing is never
+ * thrown away, the shared reason is never lost. */
+function joinNote(own, shared) {
+    const s = shared.trim();
+    if (!own?.trim())
+        return s;
+    return own.includes(s) ? own : `${own.trimEnd()}\n\n${s}`;
+}
+/**
+ * Cast `verdict` on every target. A non-empty `note` is the shared note a
+ * bulk reject asks for ("Why? applies to all N"); it joins each target's own
+ * draft note rather than replacing it.
+ */
+export function decideMany(decisions, targets, opts) {
+    const next = { ...decisions };
+    const prior = {};
+    const shared = opts.note?.trim();
+    for (const { id, round, patch } of targets) {
+        const before = decisions[id];
+        prior[id] = before;
+        const own = before?.note;
+        next[id] = opts.save(before, {
+            ...patch,
+            verdict: opts.verdict,
+            ...(shared ? { note: joinNote(own, shared) } : {}),
+            at: opts.at,
+        }, round);
+    }
+    return {
+        decisions: next,
+        undo: { verdict: opts.verdict, at: opts.at, prior },
+    };
+}
+/**
+ * Put every bulk-decided item back exactly as it was. An item the reviewer
+ * changed AFTER the bulk (a flip, a note — anything that re-stamps `at`)
+ * keeps that later change: Undo reverts the bulk, not their work.
+ */
+export function undoMany(decisions, undo) {
+    const next = { ...decisions };
+    for (const [id, before] of Object.entries(undo.prior)) {
+        const now = next[id];
+        if (!now || now.at !== undo.at || now.verdict !== undo.verdict)
+            continue;
+        if (before)
+            next[id] = before;
+        else
+            delete next[id];
+    }
+    return next;
+}

package/dist/artifact-blocks/review/itemReview.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The item-review hooks of media-picker and diff-review (jatui-n5z1x):
+ * what the core census, still-open walk and Send read through
+ * `ArtifactBlockDef.itemReview` (types.ts BlockItemReview).
+ *
+ * A faithful port of MOS modules/artifacts/feedbackReview.ts at bad16b324 —
+ * `reviewItemsOf` (the non-checklist branch), `itemRoundOf`, `itemLabelOf`
+ * and `mediaThumbOf` — so a page Send here and a desk Send in MOS count
+ * identically (CONTRACT.md "Item-review rules"). Params and state are the
+ * AUTHORED / stored JSON (untrusted): nothing here may throw.
+ */
+import type { ReviewItem } from "../types.js";
+type Rounds = {
+    isStale: (entry: unknown, current: string | null | undefined) => boolean;
+};
+/** An item's `team: { status: "ready", readySince }` round id, else null. */
+export declare function teamReadySince(it: Record<string, unknown>): string | null;
+/**
+ * The round an item is in: the team's readySince when it marked the item
+ * ready, else (media only) the version under review — `currentVersion`,
+ * else the first variant's `version`. null = the item has no rounds.
+ */
+export declare function itemRoundOf(kind: "media" | "diff", it: Record<string, unknown>): string | null;
+/** The items of one media-picker / diff-review block, in its order. */
+export declare function itemsOf(kind: "media" | "diff", rounds: Rounds, params: unknown, state: unknown): ReviewItem[];
+/** An item's title for a jump card; the item id when absent. */
+export declare function itemLabelOf(params: unknown, itemId: string): string;
+/**
+ * A media item's thumbnail: the round under review's first image (or a
+ * video's poster frame), else any image variant; undefined when none.
+ */
+export declare function mediaThumbOf(params: unknown, itemId: string): string | undefined;
+export {};

package/dist/artifact-blocks/review/itemReview.js

@@ -0,0 +1,112 @@
+const MAX_NOTE = 2000;
+const ITEM_VERDICTS = new Map([
+    ["approve", "approved"],
+    ["pass", "approved"],
+    ["accept", "approved"],
+    ["redo", "needs-work"],
+    ["modify", "needs-work"],
+    ["fail", "needs-work"],
+    ["blocked", "needs-work"],
+    ["reject", "rejected"],
+]);
+const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+/** An item's `team: { status: "ready", readySince }` round id, else null. */
+export function teamReadySince(it) {
+    const team = isObj(it.team) ? it.team : null;
+    return team?.status === "ready" &&
+        typeof team.readySince === "string" &&
+        team.readySince
+        ? team.readySince
+        : null;
+}
+/**
+ * The round an item is in: the team's readySince when it marked the item
+ * ready, else (media only) the version under review — `currentVersion`,
+ * else the first variant's `version`. null = the item has no rounds.
+ */
+export function itemRoundOf(kind, it) {
+    const ready = teamReadySince(it);
+    if (ready || kind !== "media")
+        return ready;
+    if (typeof it.currentVersion === "string" && it.currentVersion)
+        return it.currentVersion;
+    for (const v of Array.isArray(it.variants) ? it.variants : [])
+        if (isObj(v) && typeof v.version === "string" && v.version)
+            return v.version;
+    return null;
+}
+/** The items of one media-picker / diff-review block, in its order. */
+export function itemsOf(kind, rounds, params, state) {
+    const p = isObj(params) ? params : {};
+    const st = isObj(state) ? state : {};
+    const out = [];
+    for (const it of Array.isArray(p.items) ? p.items : []) {
+        if (!isObj(it) || typeof it.id !== "string")
+            continue;
+        // An informational item asks no decision: context, not a unit — it
+        // never counts and can never block a Send.
+        if (it.informational === true)
+            continue;
+        const rawItem = st[it.id];
+        const d = isObj(rawItem) ? rawItem : null;
+        const raw = d && typeof d.verdict === "string" ? d.verdict.trim().toLowerCase() : "";
+        // A verdict (and its note) from an earlier round is not this round's
+        // answer — the block shows the item blank, so nothing here counts it.
+        const stale = d !== null && rounds.isStale(d, itemRoundOf(kind, it));
+        const verdict = stale ? null : (ITEM_VERDICTS.get(raw) ?? null);
+        const item = {
+            id: it.id,
+            verdict,
+            raw: verdict ? raw : null,
+            explicit: verdict !== null,
+            retest: verdict === null && (teamReadySince(it) !== null || stale),
+        };
+        if (d && !stale) {
+            if (typeof d.note === "string" && d.note.trim())
+                item.note = d.note.trim().slice(0, MAX_NOTE);
+            if (Array.isArray(d.attachments) && d.attachments.length > 0)
+                item.attachments = d.attachments;
+        }
+        out.push(item);
+    }
+    return out;
+}
+/** An item's title for a jump card; the item id when absent. */
+export function itemLabelOf(params, itemId) {
+    const p = isObj(params) ? params : {};
+    for (const raw of Array.isArray(p.items) ? p.items : [])
+        if (isObj(raw) && raw.id === itemId && typeof raw.title === "string")
+            return raw.title;
+    return itemId;
+}
+/**
+ * A media item's thumbnail: the round under review's first image (or a
+ * video's poster frame), else any image variant; undefined when none.
+ */
+export function mediaThumbOf(params, itemId) {
+    const p = isObj(params) ? params : {};
+    for (const raw of Array.isArray(p.items) ? p.items : []) {
+        if (!isObj(raw) || raw.id !== itemId)
+            continue;
+        const variants = (Array.isArray(raw.variants) ? raw.variants : []).filter(isObj);
+        const currentVersion = typeof raw.currentVersion === "string" && raw.currentVersion
+            ? raw.currentVersion
+            : variants.find((v) => typeof v.version === "string" && v.version)
+                ?.version;
+        const inRound = (v) => currentVersion === undefined ||
+            typeof v.version !== "string" ||
+            v.version === currentVersion;
+        const img = variants.find((v) => inRound(v) && v.kind === "image" && typeof v.src === "string") ??
+            // No image in this round: a stale round's image still orients better
+            // than an empty tile.
+            variants.find((v) => v.kind === "image" && typeof v.src === "string");
+        const poster = variants.find((v) => inRound(v) && v.kind === "video" && typeof v.poster === "string");
+        const hit = img ?? poster;
+        if (!hit)
+            return undefined;
+        if (typeof hit.poster === "string" && hit.kind === "video")
+            return hit.poster;
+        return typeof hit.src === "string" ? hit.src : undefined;
+    }
+    return undefined;
+}