@joewinke/jatui 0.36.3 → 0.38.0

package/dist/artifact-blocks/BlocksArtifactView.svelte.d.ts

@@ -0,0 +1,113 @@
+import type { BlocksSpec, FoldedRound, HostAdapter, SentAnswer } from "./types.js";
+interface Props {
+    artifactId: string;
+    version: number;
+    title: string;
+    summary: string | null;
+    byline: string;
+    spec: BlocksSpec | null;
+    /** The host's services (types.ts HostAdapter). {} = read-only. */
+    adapter?: HostAdapter;
+    /** The server-rendered live-data blob ({} until a data publish). */
+    data?: Record<string, unknown>;
+    /** ISO string or null — when the data last changed. */
+    dataUpdatedAt?: string | null;
+    /**
+     * Write <title>, description and robots into <svelte:head>. Default
+     * true (a page of its own); false when the view is embedded in a host
+     * page that owns its head.
+     */
+    head?: boolean;
+    /** Robots meta for the head (a share surface adds noarchive). */
+    robotsContent?: string;
+    /**
+     * Inline chrome on the title line (mos-3q1o3): the host's Details
+     * control renders right after the page title. Omitted on the share
+     * surface.
+     */
+    titleActions?: import("svelte").Snippet;
+    /**
+     * The linked task's chip (mos-t9wr6), leading the byline row. Omitted on
+     * the share surface — a share link never shows the task.
+     */
+    taskLine?: import("svelte").Snippet;
+    /**
+     * The host's Listen player (mos-3q1o3, mos-8fvt9): a pill at the right
+     * end of the meta line; opened, its bar takes a full-width row.
+     */
+    player?: import("svelte").Snippet;
+    /**
+     * Controls for the frame this page sits in (mos-8fvt9): inside the desk
+     * drawer, "Open in new tab" + Close join the right end of the top row
+     * instead of a drawer bar of their own. Omitted everywhere else.
+     */
+    frameActions?: import("svelte").Snippet;
+    /**
+     * Where this page's answers really go (mos-guqgs): /a/<slug>. When the
+     * surface has NO save plumbing but the spec carries answer-taking
+     * content, a read-only notice renders with this link — the "Open to
+     * answer" affordance. Null hides the link.
+     */
+    answerUrl?: string | null;
+    /**
+     * The host's own wording for the read-only notice. `kind` is
+     * "read-only" (no save plumbing — a share link) or "unsent" (picks save
+     * but no review leg sends them). Default: jatui's neutral copy.
+     */
+    readOnlyNotice?: import("svelte").Snippet<[
+        {
+            kind: "read-only" | "unsent";
+            answerUrl: string | null;
+        }
+    ]>;
+    /**
+     * This page's folded earlier rounds: each with its items and every
+     * viewer's verdicts/notes, locked. Empty when the page superseded
+     * nothing (or the host's read failed).
+     */
+    foldedRounds?: FoldedRound[];
+    /** Start the folded rounds expanded (a host redirected an old slug here). */
+    foldedRoundsOpen?: boolean;
+    /** Per-block state plumbing (omitted on the read-only share surface). */
+    savedBlocks?: Record<string, unknown> | null;
+    onSaveBlock?: (payload: {
+        kind: "blocks";
+        blocks: Record<string, unknown>;
+    }) => Promise<void>;
+    /**
+     * Comments + the review moment (mos-kib2f). Omitted on the read-only
+     * share surface: no session → no drawer, no Done-reviewing button.
+     */
+    comments?: {
+        enabled: boolean;
+        counts: Record<string, number>;
+        /** This viewer already recorded review_completed for this version. */
+        reviewed: boolean;
+    };
+    /**
+     * The jat task this page serves (mos-wywa3). When set, decision cards
+     * and reviewable blocks (takesBlockVerdict) collect answers and the
+     * "Send answers" section at the foot of the page sends them as ONE
+     * answer to the task. Null → the plain "Done reviewing" moment.
+     */
+    taskId?: string | null;
+    /** Who the answer reaches (the publishing agent), for the send label. */
+    answerTo?: string | null;
+    /**
+     * The server-seeded done state (mos-7j6r5): THIS viewer's last Send on
+     * THIS version, read by the page load from the review_completed event.
+     * Null when they never sent — a first visit. This is what makes a
+     * reload remember: without it the page offered "Finish review" again
+     * after every refresh, reading as still open when the task was done.
+     */
+    reviewAnswer?: SentAnswer | null;
+    /**
+     * The linked task is closed/done (jat state, read server-side). With
+     * every item decided, the page shows the completed state — "Decided ·
+     * task closed" — even for a viewer who did not send.
+     */
+    taskClosed?: boolean;
+}
+declare const BlocksArtifactView: import("svelte").Component<Props, {}, "">;
+type BlocksArtifactView = ReturnType<typeof BlocksArtifactView>;
+export default BlocksArtifactView;

package/dist/artifact-blocks/CONTRACT.md

@@ -0,0 +1,225 @@
+# Artifact blocks — contract (`jatui/artifact-blocks`)
+
+Blocks artifacts are **data, not code**. `{ kind: "blocks", spec: BlocksSpec }`
+is stored by the host; jatui renders each block with its Svelte component.
+Origin: MOS epic mos-ab\* (moved into jatui by jatui-vsuzi so MOS and the jat
+IDE render ONE thing). Types: `types.ts`. Catalog + validation: `registry.ts`.
+
+## Adding a block (block workers)
+
+- **A block task touches ONE shared file: its group barrel.** The blocks are
+  partitioned by task so the four block tasks never collide:
+
+  | Barrel | Task | Types |
+  |---|---|---|
+  | `blocks/group-data.ts` | jatui-d4lyd | chart, stats, table, timeline |
+  | `blocks/group-content.ts` | jatui-zy9n5 | checklist, code, diff, transcript, program, compare |
+  | `blocks/group-visual.ts` | jatui-399p2 | diagram, collage, map, explainer, mockup |
+  | `blocks/group-review.ts` | jatui-n5z1x | callout, actions, diff-review, media-picker |
+
+  Create `blocks/<type>/` (`block.ts` default-exporting an
+  `ArtifactBlockDef`, `<Type>Block.svelte` with props `{ params, ctx }`,
+  `schema.ts`), then in YOUR barrel import the def, append it to `BLOCKS`
+  and drop the type from that barrel's `PENDING`. Never edit `builtins.ts`
+  (it concatenates the four barrels), `registry.ts`, another group's barrel
+  or a core file — ask the core owner instead. jatui cannot glob folders at
+  runtime the way a Vite app can, hence the barrels.
+- Tests (yours, in your own files): the schema accepts `example` and rejects
+  bad params (`tests/unit/artifact-blocks/<type>.test.ts`, node vitest —
+  `npm run test:advisors`), and the component renders from the BUILT
+  package (`tests/built/artifact-blocks-<type>.test.ts`, Chromium —
+  `npm run package && npm run test:dist`).
+- Showcase: nothing to edit. `/showcase/artifact-blocks/<group>` renders
+  every def in your barrel from its own `example`, light + dark — so make
+  `example` a realistic, complete demo.
+- Imports stay inside jatui: relative paths to `../../types.js`,
+  `../../params.js`, `../../Markdown.svelte`, `../../NoteComposer.svelte`,
+  `../../SectionTools.svelte`, jatui components by relative path. **Never**
+  a host module. Anything a host must provide comes from `ctx.services` or
+  the adapter (below).
+- Params are untrusted agent input: every string is rendered as text (never
+  `{@html}`) except through the shared markdown renderer
+  (`blocks/markdown/render.ts`, or the `<Markdown>` component that wraps it
+  with the shared prose styles). Resource URLs (img/video/frame src):
+  `https://` or root-relative only — `urlSchema` from `./params.ts`.
+  Navigation links (`<a href>`) may also be `http://` — `linkUrlSchema`
+  (a jat control plane serves task links over plain http on the tailnet).
+- The component receives the schema-PARSED params (defaults applied, unknown
+  keys stripped), never the raw published input: a publish stores the spec
+  verbatim — history is truth — so anything the schema fills or inherits
+  must reach the component through the parse.
+- Theming token-only (DaisyUI semantic classes / `--color-*` vars, jatui
+  radius tokens), light + dark + phone (390px) verified, reduced motion
+  respected. DaisyUI classes are internal skin; never a block prop.
+- Interactive blocks read `ctx.state` and call `ctx.saveState()`; they must
+  render correctly when `saveState` is undefined (read-only / share link).
+- A save failure is NEVER silent and never a block's problem: the renderer
+  wraps the save path so any failure (sync throw or rejected save) shows a
+  visible "Not saved — Retry" strip on the failing block and clears on a
+  successful retry. Build state to survive a failed save: keep the
+  optimistic local copy; the next save retries.
+- Pass state up through `$state.snapshot()` (or plain spreads of
+  primitives) — never `structuredClone` a `$state` proxy (DataCloneError).
+- Notes inside a block use `<NoteComposer {artifactId} …>` (the host's
+  composer, or jatui's text composer). Attachments are `NoteAttachment`
+  descriptors the host stored; render them with `AttachmentChip` or the
+  host's `adapter.attachmentChip`.
+- Item-review blocks (checklist, media-picker, diff-review) declare
+  `itemReview` on their def: `vocabulary`, `name`, `items(params, state)`,
+  optional `itemLabel` / `itemThumb`. The census, the still-open walk, the
+  Send and the progress bar read items ONLY through it (`review.ts`). The
+  hook gets AUTHORED params (untrusted JSON) and must not throw. It must
+  reproduce MOS `feedbackReview.ts reviewItemsOf` exactly (see "Item-review
+  rules" below) — the counts a viewer sees and the answer a host sends both
+  come from it.
+- Work-product blocks that take the block-level verdict strip by default
+  set `reviewableByDefault: true` (mockup, compare, collage and diff are
+  also known by name in `review.ts`). A spec overrides either way with
+  `params.reviewable: true|false`.
+- `description` is written FOR AN AGENT: when to use the block, what each
+  param means, limits, one-line tip.
+- Size limits: keep params under ~256KB per block; media by URL, never
+  base64 blobs.
+- A block that renders `BlockRenderer` itself (program) imports it lazily or
+  at component level — `registry.ts` seeds itself from `builtins.ts` at
+  module init, so a module-level cycle back into the registry would read
+  the builtins list before it exists.
+
+## Item-review rules (what `itemReview.items` must return)
+
+Ported from MOS `modules/artifacts/feedbackReview.ts` (`reviewItemsOf`,
+`itemLabelOf`, `mediaThumbOf`, `itemRoundOf`) — the block tasks own the code,
+these are the rules. Each item is a `ReviewItem` `{ id, verdict, raw,
+explicit, retest, note?, attachments? }`, in the block's own order.
+
+- **Buckets.** A block's raw word maps to a bucket: approve / pass /
+  accept → `approved`; redo / modify / fail / blocked → `needs-work`;
+  reject → `rejected`. `raw` keeps the block's own word (it labels the
+  progress line and rides the answer); `verdict` is the bucket or null.
+- **Notes.** `note` = the saved entry's trimmed note, capped at 2000 chars;
+  `attachments` = the saved entry's descriptors as-is. Both are dropped when
+  the verdict is stale (below).
+- **checklist** — items are `params.rows[]` (each with an `id`); state is
+  `{ rows: { [rowId]: { status, note?, attachments? } } }`.
+  - The viewer's saved `status` (one of pass / fail / blocked / untested)
+    wins; with none saved, the row's AUTHORED seed applies (`seedStatus`:
+    the row's own `status` when it is a viewer status — pass / fail /
+    blocked / untested — else untested).
+  - `teamMode: true` and a row the team marked `status: "ready"` awaits the
+    viewer (`rowAwaitsViewer`) when the viewer has no saved status, saved
+    `untested`, or saved a verdict that is stale for the row's round (its
+    `retestSince`, compared by the checklist rounds helper) →
+    `verdict: null, raw: null, retest: true`.
+  - `untested` → `raw: null` (undecided). `explicit` = the viewer saved a
+    status (a seed is never the viewer's answer).
+- **media-picker / diff-review** — items are `params.items[]`; state is
+  `{ [itemId]: { verdict, note?, attachments? } }` (verdict lower-cased).
+  - `informational: true` items are context, not units: SKIP them entirely
+    (they never count and never block a Send).
+  - Rounds: an item's round is its team `readySince` when
+    `team: { status: "ready", readySince }`, else (media-picker only) the
+    version under review — `currentVersion`, else the first variant's
+    `version`; null = no rounds. A saved verdict from an EARLIER round is
+    stale (`mediaRounds` / `diffRounds.isStale`): `verdict: null`, no note.
+  - `retest` = undecided AND (team-ready OR stale). `explicit` = a
+    current-round verdict exists.
+- **Labels and thumbnails** (`itemLabel`, `itemThumb`): the row's / item's
+  `title`, else its id. media-picker thumb = the first `image` variant of
+  the round under review, else any image variant, else that round's video
+  `poster`; none → undefined.
+
+## The renderer
+
+- `BlockRenderer` renders a spec IN the host page (no iframe). Unknown type
+  and invalid params render a visible error card, never a throw and never a
+  silent skip; a type still being ported says so (`PENDING_BLOCK_TYPES`).
+- Every block renders inside a per-block error boundary that is ACTIVE ONLY
+  AT SSR: a component that throws while server-rendering degrades to a
+  quiet notice; one bad block never fails the page. On the client the
+  boundary is transparent (Svelte cannot tell a render error from an effect
+  error, and a harmless effect hiccup must never blank a block) — so blocks
+  GUARD effect-side browser-API calls. The boundary is the last line of
+  defense, not a permission.
+- **Groups** (PARAMS-SPEC §5): a block whose authored params carry
+  `group: { key: [a-z0-9-]{1,32}, label ≤60, quiet? }` sits under a header the
+  renderer draws between cards when the key changes — sticky label + card
+  count, anchored `#group-<key>` (first run of a key), collapsible; a
+  `quiet` group starts collapsed. Collapsing HIDES the cards (they keep their
+  state); the open-item walk, a Finish card and a `#block-<id>` link expand
+  the group first (`BlockRenderer.revealBlock`). Collapse is keyed by group
+  key. Set `--artifact-sticky-top` to clear a host's sticky header.
+- Decision cards (`callout` variant `decision`) arrive from the provider
+  contract's `decision` block through `normalizeContractBlocks`
+  (`contractBlocks.ts`). The NEEDS YOU fields — `title`, `meta[]`,
+  `sections[]`, `primaryAction`, `group` — pass through validated with the
+  limits exported there (`decisionMetaSchema` …); a malformed one is DROPPED
+  and returned in `warnings`, never a refused publish. None of them is
+  answerable: links navigate, they never post a verdict.
+
+## The host adapter
+
+ONE typed object (`HostAdapter`, `types.ts`) carries everything that used to
+be a MOS import. Pass it to `BlocksArtifactView` (`adapter={…}`) or to a bare
+`BlockRenderer`; components below read it from the Svelte context
+(`adapter.ts`). **Every key is optional, and a missing key degrades to
+read-only, loudly** — the control disappears or the read-only notice shows;
+nothing looks live and silently drops input.
+
+| Key | What jatui calls | Absent → |
+|---|---|---|
+| `composer` | `Component<NoteComposerProps>` for verdict notes, comments, the Finish note, block notes (MOS: `ReviewComposer`) | jatui `PlainComposer` (text; files when `upload` is set) |
+| `upload(artifactId)` | `ComposerUpload` — store bytes FIRST, return the `NoteAttachment` descriptor | text-only notes |
+| `attachmentChip` | `Component<{ clip }>` | jatui `AttachmentChip` (labelled link) |
+| `comments` | `load / post / setResolved` per block thread | no comment pills, no drawer |
+| `review.send` | Finish review: ONE answer `{ version, taskId, blockTasks, verdicts, text?, attachments? }` → `{ answered, sentTo?, delivery? }`. `version` is the version this tab answered (a stale tab is detectable); `blockTasks` maps P11-linked blocks to `{ taskId, decisionId }` | no Finish review |
+| `review.markReviewed` | "Done reviewing" `{ version, taskId }`; throw a human-readable Error on failure (shown beside the control) | no Done-reviewing control, no auto-send |
+| `review.deliveryStatus` | poll a queued Send's delivery stamp | every Send reads as delivered once `send` resolves |
+| `review.draftNote(blocks)` | a host-kept draft (`{ note, label }`) that pre-fills the Finish note (MOS: the desk's `desk:note`) | no prefill |
+| `history` | `timeline()` + `at(instant)` for the scrubber | no History control |
+| `liveData` | `fetch()` → `{ data, dataUpdatedAt }`, every `intervalMs` (30s) while visible; throw `{ status: 429 }` when rate limited (keeps the data, says "refresh pending") | the page shows the data it was rendered with and never claims "live" |
+| `listen` | `Snippet<[{ group, label, anchor }]>` per prose block (jatui `ListenControl` fits) | no Listen |
+| `crumb` | header crumb snippet | empty crumb row |
+| `nextActions` | `Snippet<[{ compact, autofocus, nextKey }]>` in the done states (MOS: `DeskNextActions`) | nothing |
+| `titleMenu` | `{ header?, items: ContextMenuItem[] }` on the title's right-click | no menu |
+| `services` | block services: `loadGoogleMaps`, `explorer3d`, `sandboxAttr`, `teamLookup`, … (`ctx.services`) | each block's own quiet fallback |
+
+View props that are not adapter keys stay props: `onSaveBlock` + `savedBlocks`
+(per-block state plumbing; omit → blocks get no `saveState`), `comments`
+(`{ enabled, counts, reviewed }`), `taskId`, `answerTo`, `reviewAnswer`
+(the seeded done state), `taskClosed`, `foldedRounds`, `data` /
+`dataUpdatedAt`, `answerUrl`, and the snippets `titleActions`, `taskLine`,
+`player`, `frameActions`, `readOnlyNotice`. `head={false}` when the host owns
+`<svelte:head>`.
+
+**The answer must go somewhere, or the page says so.** A page that carries
+answerable content (decision cards, item-review blocks, verdict-taking
+blocks, actions) shows a notice instead of controls that look live:
+
+- **read-only** — no `onSaveBlock` (a share link): "Answers aren't saved on
+  this view", with `answerUrl` as "Open to answer";
+- **unsent** — `onSaveBlock` is set, but no review leg can carry the picks
+  (no `review.send` for a linked task, no `review.markReviewed` + comments
+  for Done reviewing): the picks save for the viewer and the notice says
+  nobody is notified.
+
+`readOnlyNotice` (`{ kind, answerUrl }`) replaces the wording; it never
+removes the notice.
+
+## Host-side (never in jatui)
+
+A host that serves blocks pages must provide, server-side:
+
+- **Storage**: the spec per version, per-viewer block state (`savedBlocks`,
+  including the reserved `review:<blockId>` keys), comments, note assets,
+  live data and its history trail.
+- **Publish validation**: `normalizeContractBlocks(spec)` then
+  `validateBlocksSpec(spec)`; refuse on errors, surface `warnings`.
+- **The review answer**: validating an untrusted review body against the
+  current version, composing the answer comment, recording it, and routing
+  it to the page OWNER (MOS: `feedbackReview.ts`, `owner-routing.ts`,
+  `alerts.server.ts`). The pure census (`review.ts`) is shared, so a desk
+  Send and a page Send count identically.
+- **Owner routing**: `BlockInstance.owner` (and checklist row owners) is read
+  server-side only; the client never names an owner.
+- **Auth**: who may comment, save, send; read-only surfaces simply omit the
+  adapter keys and `onSaveBlock`.

package/dist/artifact-blocks/CommentPill.svelte

@@ -0,0 +1,49 @@
+<script lang="ts">
+  /**
+   * The per-block comment trigger (origin mos-kib2f): an icon + unresolved
+   * count, or a quiet "comment" when there are none. One component for both
+   * placements: BlockComments' own row above a block, and a block's heading
+   * row via SectionTools — so the two never drift.
+   */
+
+  interface Props {
+    /** The block's label, completing "Comments on <label>". */
+    label: string
+    unresolved: number
+    open: boolean
+    onclick: () => void
+  }
+
+  let { label, unresolved, open, onclick }: Props = $props()
+</script>
+
+<button
+  type="button"
+  class="text-base-content/50 hover:border-primary hover:text-primary border-base-content/20 inline-flex shrink-0 items-center gap-1.5 rounded-field border px-2.5 py-1 text-xs transition-colors motion-reduce:transition-none"
+  aria-expanded={open}
+  aria-label="Comments on {label}{unresolved > 0
+    ? ` (${unresolved} unresolved)`
+    : ''}"
+  {onclick}
+  data-comment-pill
+>
+  <!-- Speech bubble (lucide message-circle path), inline: jatui carries no
+       icon-library dependency. -->
+  <svg
+    width="13"
+    height="13"
+    viewBox="0 0 24 24"
+    fill="none"
+    stroke="currentColor"
+    stroke-width="2"
+    stroke-linecap="round"
+    stroke-linejoin="round"
+    aria-hidden="true"
+    ><path d="M7.9 20A9 9 0 1 0 4 16.1L2 22Z" /></svg
+  >
+  {#if unresolved > 0}
+    <span class="tabular-nums">{unresolved}</span>
+  {:else}
+    <span class="text-base-content/40">comment</span>
+  {/if}
+</button>

package/dist/artifact-blocks/CommentPill.svelte.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The per-block comment trigger (origin mos-kib2f): an icon + unresolved
+ * count, or a quiet "comment" when there are none. One component for both
+ * placements: BlockComments' own row above a block, and a block's heading
+ * row via SectionTools — so the two never drift.
+ */
+interface Props {
+    /** The block's label, completing "Comments on <label>". */
+    label: string;
+    unresolved: number;
+    open: boolean;
+    onclick: () => void;
+}
+declare const CommentPill: import("svelte").Component<Props, {}, "">;
+type CommentPill = ReturnType<typeof CommentPill>;
+export default CommentPill;

package/dist/artifact-blocks/FoldedRounds.svelte

@@ -0,0 +1,95 @@
+<script lang="ts">
+  /**
+   * FoldedRounds (origin mos-guqgs) — the "▸ N earlier rounds" section on a
+   * page that superseded older rounds (--supersedes). Each folded round
+   * renders its items and EVERY viewer's verdicts/notes as locked, read-only
+   * lines (jatui RoundHistory — the lock icon is the point: a prior decision
+   * is history, not an editable control), newest round first. A host that
+   * redirects an old slug here (MOS: ?rounds=open) passes `initiallyOpen`,
+   * so following a stale link lands with the history already showing.
+   */
+  import RoundHistory from "../components/review/RoundHistory.svelte"
+  import type { ReviewVerdictDef } from "../components/review/reviewSummary"
+  import type { FoldedRound } from "./types.js"
+
+  interface Props {
+    rounds?: FoldedRound[]
+    /** Start expanded (the host read its own "open the rounds" signal). */
+    initiallyOpen?: boolean
+  }
+
+  let { rounds = [], initiallyOpen = false }: Props = $props()
+
+  // svelte-ignore state_referenced_locally
+  let open = $state(initiallyOpen)
+
+  const VERDICTS: ReviewVerdictDef[] = [
+    { id: "approve", label: "Approved", tone: "success" },
+    { id: "redo", label: "Needs work", tone: "warning" },
+    { id: "reject", label: "Rejected", tone: "error" },
+    { id: "modify", label: "Modify", tone: "warning" },
+  ]
+
+  function roundDate(at: string): string {
+    const t = Date.parse(at)
+    return Number.isFinite(t) ? new Date(t).toLocaleDateString() : ""
+  }
+</script>
+
+{#if rounds.length > 0}
+  <section
+    class="border-base-content/10 bg-base-200/40 rounded-box mb-4 border p-4"
+    aria-label="Earlier rounds folded into this page"
+  >
+    <button
+      type="button"
+      class="text-base-content/70 hover:text-base-content flex items-center gap-1.5 text-sm font-medium"
+      aria-expanded={open}
+      onclick={() => (open = !open)}
+    >
+      <span
+        class="inline-block transition-transform {open ? 'rotate-90' : ''}"
+        aria-hidden="true">▸</span
+      >
+      {rounds.length}
+      {rounds.length === 1 ? "earlier round" : "earlier rounds"} folded into this
+      page
+    </button>
+
+    {#if open}
+      <div class="mt-3 flex flex-col gap-4">
+        {#each rounds as round (round.slug)}
+          <article class="border-base-content/10 rounded-box border p-3">
+            <header class="flex flex-wrap items-baseline gap-x-2 text-sm">
+              <span class="font-medium">{round.title}</span>
+              <span class="text-base-content/50 text-xs">
+                v{round.version} · {round.publishedBy} ·
+                {roundDate(round.publishedAt)}
+              </span>
+              {#if round.reason}
+                <span class="text-base-content/40 text-xs"
+                  >({round.reason})</span
+                >
+              {/if}
+            </header>
+            {#if round.entries.length > 0}
+              <div class="mt-2">
+                <RoundHistory
+                  rounds={round.entries}
+                  verdicts={VERDICTS}
+                  open={true}
+                  toggleLabel={(n) =>
+                    `${n} locked ${n === 1 ? "decision" : "decisions"}`}
+                />
+              </div>
+            {:else}
+              <p class="text-base-content/50 mt-2 text-xs">
+                No verdicts were cast on this round.
+              </p>
+            {/if}
+          </article>
+        {/each}
+      </div>
+    {/if}
+  </section>
+{/if}

package/dist/artifact-blocks/FoldedRounds.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { FoldedRound } from "./types.js";
+interface Props {
+    rounds?: FoldedRound[];
+    /** Start expanded (the host read its own "open the rounds" signal). */
+    initiallyOpen?: boolean;
+}
+declare const FoldedRounds: import("svelte").Component<Props, {}, "">;
+type FoldedRounds = ReturnType<typeof FoldedRounds>;
+export default FoldedRounds;

package/dist/artifact-blocks/Glyph.svelte

@@ -0,0 +1,54 @@
+<script lang="ts" module>
+  /** The glyphs the artifact view draws (lucide paths, ISC), inline so jatui
+   * carries no icon-library dependency. */
+  export type GlyphName =
+    | "chevron-up"
+    | "chevron-down"
+    | "list-checks"
+    | "images"
+    | "file-diff"
+    | "circle-help"
+    | "badge-check"
+</script>
+
+<script lang="ts">
+  let { name, size = 16 }: { name: GlyphName; size?: number } = $props()
+</script>
+
+<svg
+  width={size}
+  height={size}
+  viewBox="0 0 24 24"
+  fill="none"
+  stroke="currentColor"
+  stroke-width="2"
+  stroke-linecap="round"
+  stroke-linejoin="round"
+  aria-hidden="true"
+>
+  {#if name === "chevron-up"}
+    <path d="m18 15-6-6-6 6" />
+  {:else if name === "chevron-down"}
+    <path d="m6 9 6 6 6-6" />
+  {:else if name === "list-checks"}
+    <path d="m3 17 2 2 4-4" /><path d="m3 7 2 2 4-4" /><path d="M13 6h8" /><path
+      d="M13 12h8"
+    /><path d="M13 18h8" />
+  {:else if name === "images"}
+    <path d="M18 22H4a2 2 0 0 1-2-2V6" /><path
+      d="m22 13-1.296-1.296a2.41 2.41 0 0 0-3.408 0L11 18"
+    /><circle cx="12" cy="8" r="2" /><rect width="16" height="16" x="6" y="2" rx="2" />
+  {:else if name === "file-diff"}
+    <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z" /><path
+      d="M9 10h6"
+    /><path d="M12 13V7" /><path d="M9 17h6" />
+  {:else if name === "circle-help"}
+    <circle cx="12" cy="12" r="10" /><path d="M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3" /><path
+      d="M12 17h.01"
+    />
+  {:else}
+    <path
+      d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"
+    /><path d="m9 12 2 2 4-4" />
+  {/if}
+</svg>

package/dist/artifact-blocks/Glyph.svelte.d.ts

@@ -0,0 +1,10 @@
+/** The glyphs the artifact view draws (lucide paths, ISC), inline so jatui
+ * carries no icon-library dependency. */
+export type GlyphName = "chevron-up" | "chevron-down" | "list-checks" | "images" | "file-diff" | "circle-help" | "badge-check";
+type $$ComponentProps = {
+    name: GlyphName;
+    size?: number;
+};
+declare const Glyph: import("svelte").Component<$$ComponentProps, {}, "">;
+type Glyph = ReturnType<typeof Glyph>;
+export default Glyph;