@joewinke/jatui 0.37.0 → 0.38.0

package/dist/artifact-blocks/blocks/media-picker/MediaPickerBlock.svelte.d.ts

@@ -0,0 +1,5 @@
+import type { BlockProps } from "../../types.js";
+import type { MediaPickerParams } from "./types.js";
+declare const MediaPickerBlock: import("svelte").Component<BlockProps<MediaPickerParams>, {}, "">;
+type MediaPickerBlock = ReturnType<typeof MediaPickerBlock>;
+export default MediaPickerBlock;

package/dist/artifact-blocks/blocks/media-picker/block.d.ts

@@ -0,0 +1,24 @@
+/**
+ * media-picker — the review kit's pick-and-approve experience as a native
+ * artifact block (mos-vzame, epic mos-m1qrx).
+ *
+ * Params are DATA an agent publishes: groups of media items, each item
+ * offering one or more variants (image/video/audio by URL) the human chooses
+ * between, then approves, marks needs-work, or rejects — with an optional
+ * note. The viewer's decisions persist through `ctx.saveState` as
+ * `{ [itemId]: { verdict, variant, note, at, round?, history? } }`, the
+ * shape the artifact feedback channel (mos-41vpm) hands back to agents via
+ * `mos-artifact feedback` — the flat fields are the current round
+ * (mos-lsmve.6), so pre-rounds readers see exactly what they always did. Verdict vocabulary matches scripts/review-kit
+ * (mos-nj3am): "approve" | "redo" | "reject" — so a manifest can round-trip
+ * between the script kit and this block.
+ *
+ * Media is BY URL only (https:// or root-relative, shared params urlSchema) — never
+ * base64; the params cap (~256KB per block) and the feedback channel's 64KB
+ * state cap both assume it. 200 items max, matching the feedback API's
+ * MAX_FEEDBACK_ITEMS.
+ */
+import type { ArtifactBlockDef } from "../../types.js";
+import type { MediaPickerParams } from "./types.js";
+declare const mediaPicker: ArtifactBlockDef<MediaPickerParams>;
+export default mediaPicker;

package/dist/artifact-blocks/blocks/media-picker/block.js

@@ -0,0 +1,137 @@
+import { mediaPickerSchema } from "./schema.js";
+import MediaPickerBlock from "./MediaPickerBlock.svelte";
+import { mediaRounds } from "./decisions.js";
+import { itemLabelOf, itemsOf, mediaThumbOf, } from "../../review/itemReview.js";
+const example = {
+    title: "Hero art — round 1",
+    intro: "Approve the hero you want shipped. Press ? for the keyboard map.",
+    groups: [
+        { id: "hero", title: "Hero illustration" },
+        { id: "loop", title: "Hover loops" },
+    ],
+    items: [
+        {
+            id: "hero-art",
+            group: "hero",
+            title: "Hero illustration",
+            subtitle: "warm still life vs. product panel",
+            meta: { placement: "home hero", aspect: "16/10" },
+            tags: ["round 1"],
+            variants: [
+                {
+                    id: "a",
+                    label: "still life",
+                    kind: "image",
+                    src: "https://media.marduk.app/demo/hero-a.png",
+                },
+                {
+                    id: "b",
+                    label: "panel",
+                    kind: "image",
+                    src: "https://media.marduk.app/demo/hero-b.png",
+                },
+            ],
+        },
+        {
+            id: "loop-toilet",
+            group: "loop",
+            title: "Toilet hover loop",
+            meta: { duration: "3s", codec: "webm" },
+            variants: [
+                {
+                    id: "v1",
+                    label: "v1",
+                    kind: "video",
+                    src: "https://media.marduk.app/demo/toilet-loop.webm",
+                    poster: "https://media.marduk.app/demo/toilet-poster.png",
+                },
+            ],
+        },
+        {
+            id: "jingle",
+            group: "loop",
+            title: "Hold-music jingle",
+            variants: [
+                {
+                    id: "take1",
+                    label: "take 1",
+                    kind: "audio",
+                    src: "https://media.marduk.app/demo/jingle.mp3",
+                },
+            ],
+        },
+        {
+            id: "audit-bathroom",
+            group: "hero",
+            // EVIDENCE, not choices (mos-9d62g): the screenshots are EXAMPLES of
+            // the problem — the card renders them as a gallery with captions and
+            // the verdict stays a plain Approve of the card.
+            evidence: true,
+            title: "Bathroom-repairs page loads with no visible headline",
+            wrong: "The headline is invisible on the bathroom repairs page.",
+            ifApproved: "The page shows its headline again.",
+            links: [
+                {
+                    label: "Open on site",
+                    url: "https://pe.example.com/bathroom-repairs",
+                },
+            ],
+            variants: [
+                {
+                    id: "ev1",
+                    label: "top of the page",
+                    kind: "image",
+                    src: "https://media.marduk.app/demo/hero-a.png",
+                },
+                {
+                    id: "ev2",
+                    label: "after scrolling",
+                    kind: "image",
+                    src: "https://media.marduk.app/demo/hero-b.png",
+                },
+            ],
+        },
+        {
+            id: "primary-decision",
+            group: "hero",
+            title: "Decision: primary button fill",
+            subtitle: "A keeps the logo's ink + yellow on every buy button; B follows the no-solid-black rule with warm-grey text.",
+            // A CHOICE, not a review: pick replaces the single Approve. With one
+            // comparison image the options are named choices; with 2+ variants
+            // each variant gets its own "Pick this" button instead.
+            pick: true,
+            choices: ["Ink + yellow", "Warm grey"],
+            variants: [
+                {
+                    id: "options",
+                    label: "A vs B",
+                    kind: "image",
+                    src: "https://media.marduk.app/demo/primary-a-vs-b.png",
+                },
+            ],
+        },
+    ],
+};
+const mediaPicker = {
+    type: "media-picker",
+    title: "Media picker (review grid)",
+    description: "A pick-and-approve review grid for media (the Gallery review view): publish groups of items (each with image, video, or audio variants addressed BY URL — https, or the artifact's own private asset store (/a/<slug>/assets/…, uploaded with `mos-artifact.mjs asset` or built for you by scripts/review-kit/build.mjs); never base64) and the human marks each card Approve / Needs work / Reject with an optional note (Needs work and Reject open the note). VARIANTS: when an item offers more than one variant the Approve button names the one the reviewer is looking at ('Approve Bamboo') and the saved verdict shows 'Approved: Bamboo' on the card and in the zoom footer — approving pins THAT variant, browsing another never moves it (the Approve button, always naming the current view, moves it deliberately). CHOICES: set `pick: true` on an item that is a choice, not a review — each variant gets a per-variant 'Pick this' button instead of a single Approve (picking saves verdict + that variant, the same shape as any approve), and Needs work / Reject stay for 'neither'. For a decision whose options live in ONE comparison image (an 'A vs B' sheet), give the single variant `choices: ['A', 'B']` (2–6 labels): the card renders a Pick button per choice and the pick saves `variant: <slug of the choice label>`. INFORMATIONAL: set `informational: true` on an item that is CONTEXT ONLY (a live-site reference shot, a spec sheet) — it renders with a 'no decision needed' chip, no verdict chrome, and is excluded from the review census so it never blocks 'Send answers'. EVIDENCE (mos-9d62g): set `evidence: true` on an item whose variants are EXAMPLES of the problem (an audit card's screenshots) — the card renders them as a gallery with numbered captions (each opens the zoom) and the Approve stays PLAIN, saving no variant: the verdict approves the card, so it never reads 'Approve bathroom-repairs light'; a variant-less approve validates on evidence items and pulls back clean. CARD COPY (mos-9d62g): write `wrong` ('What is wrong:') and `ifApproved` ('If you approve:') — two short labeled lines under the title, in plain English for a reader who has never seen the app (scripts/review-kit lint warns on sentences over 20 words and on file paths, field names and severity codes at build time). LINKS (mos-9d62g): `links: [{label, url}]` renders 'Open on site' chips under the card and in the zoom footer (new tab, https or root-relative; label defaults to 'Open on site'). APPROVE ALL: a page-level 'Approve all N' button sits beside the filter chips and a per-section one beside each section title; they approve every undecided, non-choice, non-retest item in ONE save (choice items still need a deliberate pick; retests deserve eyes). Variants sharing a `version` are VIEWS of one version; `currentVersion` names the one under review and older versions are read-only. ROUNDS: a round is the version under review, or — when you set `team: {status: 'ready', readySince: <ISO>}` on an item after fixing it — that readySince. The first verdict in a new round locks the previous verdict + note into the item's history and the new round starts blank; `team: {status: 'in_progress'}` just shows the Team status. Images AND videos open a full-size zoom view (zoom/pan, frame-step, speed) with the verdict control and note in its footer, and ←/→ past the last view (or j/k) pages to the next card, so the reviewer decides without closing. Keys (the shared review map): j/k move, a approve, x needs work, r reject, u undo, n note, [ ] older/newer version, 1-9 view, Enter full size, f next item that needs you, ? help. A progress bar and filter chips with live counts sit on top; rejected cards sink. Viewer decisions persist as {[itemId]: {verdict, variant, note, at, round?, history?: [{round, verdict, note, at}]}} through the artifact feedback channel — the flat fields are the CURRENT round, so `mos-artifact feedback` reads exactly as before. Use it for any human-in-the-loop media decision: art rounds, hover-loop picks, hold-music choices. Tip: keep item ids stable across republishes — verdicts are keyed on them.",
+    schema: mediaPickerSchema,
+    component: MediaPickerBlock,
+    // mos-8fvt9: the section's Listen + comment sit on the heading row.
+    hostsTools: (p) => Boolean(p.title || p.intro),
+    example,
+    interactive: true,
+    itemReview: {
+        vocabulary: [
+            { id: "approve", label: "Approve", tone: "success" },
+            { id: "redo", label: "Needs work", tone: "warning" },
+            { id: "reject", label: "Reject", tone: "error" },
+        ],
+        name: "Media",
+        items: (params, state) => itemsOf("media", mediaRounds, params, state),
+        itemLabel: itemLabelOf,
+        itemThumb: mediaThumbOf,
+    },
+};
+export default mediaPicker;

package/dist/artifact-blocks/blocks/media-picker/choices.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Choice items for the media-picker (mos-lwbbt).
+ *
+ * A card can be a CHOICE rather than a review: "palm or bamboo?" — each
+ * variant is an option (`pick: true` renders a per-variant Pick button), or
+ * the options live inside ONE comparison image (`choices: ["A", "B"]` — the
+ * dirt-theme-review decision-primary case: a single "A vs B" sheet a bare
+ * Approve could never answer). Both save the SAME shape as any approve —
+ * `{verdict: "approve", variant: <id>}` — so the feedback channel, rounds
+ * and the review-kit pull read a choice exactly as they read a pick.
+ *
+ * A choice id is the slug of its label ("Ink + yellow" → "ink-yellow"),
+ * deterministic so a saved verdict keeps naming its choice across
+ * republishes. Pure: no DOM, no Svelte — the component, the schema check
+ * and the tests share it.
+ */
+import type { MediaItem } from "./types.js";
+/** The saved-state id for a named choice: label → lowercase slug. */
+export declare function choiceId(label: string, index: number): string;
+/** The choice a saved pick id names (its label), or null when it isn't one. */
+export declare function choiceLabelOf(item: MediaItem, id: string): string | null;
+/** Is this item a choice (per-variant Pick buttons or named choices)? */
+export declare function isPick(item: MediaItem): boolean;
+/** The choices as pickable options: id + display label, in listed order. */
+export declare function choicesOf(item: MediaItem): {
+    id: string;
+    label: string;
+}[];

package/dist/artifact-blocks/blocks/media-picker/choices.js

@@ -0,0 +1,35 @@
+/** The saved-state id for a named choice: label → lowercase slug. */
+export function choiceId(label, index) {
+    const slug = label
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 64)
+        .replace(/^-+|-+$/g, "");
+    // ID_RE-compatible (leading a-z0-9); a label that slugs to nothing gets a
+    // positional fallback — stable as long as the choice order is.
+    if (slug && /^[a-z0-9]/.test(slug))
+        return slug;
+    return `choice-${index + 1}`;
+}
+/** The choice a saved pick id names (its label), or null when it isn't one. */
+export function choiceLabelOf(item, id) {
+    if (!item.choices?.length)
+        return null;
+    for (let i = 0; i < item.choices.length; i++)
+        if (choiceId(item.choices[i], i) === id)
+            return item.choices[i];
+    return null;
+}
+/** Is this item a choice (per-variant Pick buttons or named choices)? */
+export function isPick(item) {
+    return item.pick === true || (item.choices?.length ?? 0) > 0;
+}
+/** The choices as pickable options: id + display label, in listed order. */
+export function choicesOf(item) {
+    return (item.choices ?? []).map((label, i) => ({
+        id: choiceId(label, i),
+        label,
+    }));
+}

package/dist/artifact-blocks/blocks/media-picker/decisions.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Viewer decisions for the media-picker block (mos-vzame).
+ *
+ * Lives beside the component (not inside block.ts) so the component never
+ * imports the def module back — block.ts already imports the component, and
+ * a runtime cycle is exactly the kind of cleverness a registry imports
+ * eagerly on the server.
+ *
+ * The saved shape is the feedback channel's contract:
+ * `{ [itemId]: { verdict, variant, note, at?, round?, history? } }` — verdict
+ * vocabulary matches scripts/review-kit (mos-nj3am): "approve" | "redo" |
+ * "reject". The flat fields are the CURRENT round (mos-lsmve.6); `round` is
+ * the version (or team readySince) they answer and `history[]` holds the
+ * locked earlier rounds (../../review/rounds.ts). An entry saved before
+ * rounds existed has neither and reads exactly as it always did.
+ */
+import { type RoundLine } from "../../review/rounds.js";
+import { type NoteAttachment } from "../../review/attachments.js";
+export type MediaVerdict = "approve" | "redo" | "reject";
+export type MediaDecision = {
+    verdict?: MediaVerdict;
+    variant?: string | null;
+    note?: string;
+    /** The note's voice/video/screen/file attachments (mos-rccb5). */
+    attachments?: NoteAttachment[];
+    /** When this round's verdict/note was last saved (ISO). */
+    at?: string;
+    /** The round the flat fields answer (a version id or a readySince). */
+    round?: string;
+    /** Locked earlier rounds, newest first. */
+    history?: RoundLine[];
+};
+/** The media-picker's round model: `variant` (the approved pick) belongs to
+ * a round too — a new version starts with no pick. */
+export declare const mediaRounds: {
+    roundOf: (entry: unknown) => string | null;
+    roundLabel: (round: string | null | undefined) => string;
+    sameRound: (a: string | null | undefined, b: string | null | undefined) => boolean;
+    isStale: (entry: unknown, current: string | null | undefined) => boolean;
+    parseHistory: (raw: unknown) => RoundLine[];
+    view: (raw: unknown, current: string | null | undefined, publisherHistory?: unknown) => import("../../review/rounds.js").RoundView;
+    save: (stored: unknown, patch: Record<string, unknown>, current: string | null | undefined) => Record<string, unknown>;
+};
+/** Defensively validate one saved-state entry (untrusted stored JSON). */
+export declare function parseDecision(raw: unknown): MediaDecision | null;
+/** An entry carrying nothing worth keeping — locked history counts: an Undo
+ * in a new round must never drop the rounds before it. A note's attachments
+ * count as content too (a photo-only note is a real answer, mos-rccb5). */
+export declare function isEmptyDecision(d: MediaDecision | null | undefined): boolean;
+/** Parse the whole saved-state blob into decisions for THIS picker. */
+export declare function parseDecisions(state: Record<string, unknown> | null): Record<string, MediaDecision>;

package/dist/artifact-blocks/blocks/media-picker/decisions.js

@@ -0,0 +1,75 @@
+/**
+ * Viewer decisions for the media-picker block (mos-vzame).
+ *
+ * Lives beside the component (not inside block.ts) so the component never
+ * imports the def module back — block.ts already imports the component, and
+ * a runtime cycle is exactly the kind of cleverness a registry imports
+ * eagerly on the server.
+ *
+ * The saved shape is the feedback channel's contract:
+ * `{ [itemId]: { verdict, variant, note, at?, round?, history? } }` — verdict
+ * vocabulary matches scripts/review-kit (mos-nj3am): "approve" | "redo" |
+ * "reject". The flat fields are the CURRENT round (mos-lsmve.6); `round` is
+ * the version (or team readySince) they answer and `history[]` holds the
+ * locked earlier rounds (../../review/rounds.ts). An entry saved before
+ * rounds existed has neither and reads exactly as it always did.
+ */
+import { useRounds } from "../../review/rounds.js";
+import { readNoteAttachments, } from "../../review/attachments.js";
+const MEDIA_VERDICTS = ["approve", "redo", "reject"];
+/** The media-picker's round model: `variant` (the approved pick) belongs to
+ * a round too — a new version starts with no pick. */
+export const mediaRounds = useRounds({
+    verdictKey: "verdict",
+    verdicts: MEDIA_VERDICTS,
+    roundFields: ["variant"],
+});
+/** Defensively validate one saved-state entry (untrusted stored JSON). */
+export function parseDecision(raw) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+        return null;
+    const r = raw;
+    const out = {};
+    if (typeof r.verdict === "string" &&
+        MEDIA_VERDICTS.includes(r.verdict)) {
+        out.verdict = r.verdict;
+    }
+    if (typeof r.variant === "string" && r.variant)
+        out.variant = r.variant;
+    if (typeof r.note === "string" && r.note)
+        out.note = r.note;
+    const attachments = readNoteAttachments(r.attachments);
+    if (attachments)
+        out.attachments = attachments;
+    if (typeof r.at === "string" && r.at)
+        out.at = r.at.slice(0, 64);
+    if (typeof r.round === "string" && r.round)
+        out.round = r.round.slice(0, 200);
+    const history = mediaRounds.parseHistory(r.history);
+    if (history.length > 0)
+        out.history = history;
+    return isEmptyDecision(out) ? null : out;
+}
+/** An entry carrying nothing worth keeping — locked history counts: an Undo
+ * in a new round must never drop the rounds before it. A note's attachments
+ * count as content too (a photo-only note is a real answer, mos-rccb5). */
+export function isEmptyDecision(d) {
+    return (!d ||
+        (!d.verdict &&
+            !d.variant &&
+            !d.note &&
+            !d.attachments?.length &&
+            !d.history?.length));
+}
+/** Parse the whole saved-state blob into decisions for THIS picker. */
+export function parseDecisions(state) {
+    const out = {};
+    if (!state)
+        return out;
+    for (const [id, raw] of Object.entries(state)) {
+        const d = parseDecision(raw);
+        if (d)
+            out[id] = d;
+    }
+    return out;
+}

package/dist/artifact-blocks/blocks/media-picker/schema.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Params schema for the media-picker block (the review kit's pick-and-approve
+ * grid). Imported by block.ts (def) and the tests — keeps them cycle-free.
+ */
+import { z } from "zod";
+import type { MediaPickerParams } from "./types.js";
+export declare const mediaPickerSchema: z.ZodType<MediaPickerParams>;

package/dist/artifact-blocks/blocks/media-picker/schema.js

@@ -0,0 +1,199 @@
+/**
+ * Params schema for the media-picker block (the review kit's pick-and-approve
+ * grid). Imported by block.ts (def) and the tests — keeps them cycle-free.
+ */
+import { z } from "zod";
+import { urlSchema } from "../../params.js";
+import { itemTeamSchema } from "../../review/team.js";
+import { choiceId } from "./choices.js";
+const ID_RE = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+const idSchema = z
+    .string()
+    .regex(ID_RE, "id must be lowercase a-z0-9_- (max 64, leading a-z0-9)");
+const variantSchema = z.object({
+    id: idSchema,
+    label: z.string().max(80).optional(),
+    kind: z.enum(["image", "video", "audio"]),
+    src: urlSchema,
+    /** Poster frame URL for video variants (same rules as src). */
+    poster: urlSchema.optional(),
+    /** Round this variant belongs to; same-version variants are its views. */
+    version: z.string().min(1).max(40).optional(),
+});
+const historySchema = z.object({
+    version: z.string().min(1).max(40),
+    verdict: z.enum(["approve", "redo", "reject"]).optional(),
+    note: z.string().max(2000).optional(),
+});
+const itemSchema = z.object({
+    id: idSchema,
+    title: z.string().min(1, "title is required").max(200),
+    /** Group id from `groups[]` below. Omitted items flow to an implicit group. */
+    group: idSchema.optional(),
+    subtitle: z.string().max(300).optional(),
+    /** Small key:value lines shown under the title (e.g. size, owner). */
+    meta: z.record(z.string().max(60), z.string().max(120)).optional(),
+    tags: z.array(z.string().max(40)).max(8).optional(),
+    variants: z.array(variantSchema).min(1, "at least one variant").max(12),
+    /** The version under review (defaults to the first variant's version). */
+    currentVersion: z.string().min(1).max(40).optional(),
+    /** Read-only verdicts from earlier versions, shown when one is opened. */
+    history: z.array(historySchema).max(12).optional(),
+    /** Team status: in_progress, or ready + readySince (opens a new round). */
+    team: itemTeamSchema.optional(),
+    /** Choice item: each variant is an option, picked per variant. */
+    pick: z.boolean().optional(),
+    /** Named options of a decision shown in one comparison image (2–6). */
+    choices: z.array(z.string().min(1).max(80)).min(2).max(6).optional(),
+    /** The variants are EXAMPLES of the problem, not choices (mos-9d62g):
+     * gallery rendering, plain Approve, verdict saved without a variant. */
+    evidence: z.boolean().optional(),
+    /** Plain-English card copy: what is wrong / what happens if approved. */
+    wrong: z.string().min(1).max(300).optional(),
+    ifApproved: z.string().min(1).max(300).optional(),
+    /** "Open on site" chips (new tab), https or root-relative URLs. */
+    links: z
+        .array(z.object({
+        label: z.string().min(1).max(40),
+        url: urlSchema,
+    }))
+        .max(6)
+        .optional(),
+    /** Context only: no verdict asked, excluded from the review census. */
+    informational: z.boolean().optional(),
+    /** text: the card is words, not media — no zoom chrome; `text` renders
+     * on a themed surface in place of the image (mos-bk1k8). */
+    kind: z.enum(["media", "text"]).optional(),
+    text: z.string().min(1).max(4000).optional(),
+});
+const groupSchema = z.object({
+    id: idSchema,
+    title: z.string().min(1).max(120),
+});
+export const mediaPickerSchema = z
+    .object({
+    title: z.string().max(200).optional(),
+    /** Instructions shown above the grid: rendered as markdown when the text
+     * carries markdown syntax (paragraphs, lists, bold, links), plain text
+     * renders unchanged (mos-8vdg9). */
+    intro: z.string().max(2000).optional(),
+    /** Optional named sections, in display order. */
+    groups: z.array(groupSchema).max(20).optional(),
+    items: z.array(itemSchema).max(200),
+})
+    .check((ctx) => {
+    // Cross-array rules zod's per-field checks can't express: unique item ids
+    // (state keys on them), unique variant ids inside an item, and every
+    // item's group must exist in groups[] (or be omitted).
+    const value = ctx.value;
+    const itemIds = new Set();
+    value.items.forEach((it, i) => {
+        if (itemIds.has(it.id)) {
+            ctx.issues.push({
+                code: "custom",
+                input: it,
+                path: ["items", i, "id"],
+                message: `duplicate item id "${it.id}"`,
+            });
+        }
+        itemIds.add(it.id);
+        const vIds = new Set();
+        it.variants.forEach((v, vi) => {
+            if (vIds.has(v.id)) {
+                ctx.issues.push({
+                    code: "custom",
+                    input: v,
+                    path: ["items", i, "variants", vi, "id"],
+                    message: `duplicate variant id "${v.id}" in item "${it.id}"`,
+                });
+            }
+            vIds.add(v.id);
+        });
+        if (it.currentVersion &&
+            !it.variants.some((v) => v.version === it.currentVersion)) {
+            ctx.issues.push({
+                code: "custom",
+                input: it,
+                path: ["items", i, "currentVersion"],
+                message: `currentVersion "${it.currentVersion}" is not the version of any variant in item "${it.id}"`,
+            });
+        }
+        if (it.choices) {
+            if (it.variants.length !== 1) {
+                ctx.issues.push({
+                    code: "custom",
+                    input: it,
+                    path: ["items", i, "choices"],
+                    message: `choices names the options of ONE comparison image — item "${it.id}" has ${it.variants.length} variants; give each option its own variant and pick: true instead`,
+                });
+            }
+            const cIds = new Set();
+            it.choices.forEach((c, ci) => {
+                const cid = choiceId(c, ci);
+                if (cIds.has(cid)) {
+                    ctx.issues.push({
+                        code: "custom",
+                        input: it,
+                        path: ["items", i, "choices", ci],
+                        message: `duplicate choice id "${cid}" in item "${it.id}"`,
+                    });
+                }
+                cIds.add(cid);
+                if (it.variants.some((v) => v.id === cid)) {
+                    ctx.issues.push({
+                        code: "custom",
+                        input: it,
+                        path: ["items", i, "choices", ci],
+                        message: `choice "${cid}" collides with a variant id in item "${it.id}"`,
+                    });
+                }
+            });
+        }
+        if (it.informational && (it.pick || it.choices)) {
+            ctx.issues.push({
+                code: "custom",
+                input: it,
+                path: ["items", i, "informational"],
+                message: `informational item "${it.id}" asks no decision — it cannot also be pick or carry choices`,
+            });
+        }
+        // mos-9d62g: an evidence card's verdict approves the CARD (the images
+        // are examples of the problem) — it cannot also be a choice.
+        if (it.evidence && (it.pick || it.choices)) {
+            ctx.issues.push({
+                code: "custom",
+                input: it,
+                path: ["items", i, "evidence"],
+                message: `evidence item "${it.id}" is not a choice — the examples show the problem and the Approve answers the card; move the options to pick/choices on a separate item`,
+            });
+        }
+        if (it.text && it.kind !== "text") {
+            ctx.issues.push({
+                code: "custom",
+                input: it,
+                path: ["items", i, "text"],
+                message: `item "${it.id}" carries text but is not kind: "text" — set kind: "text" so the card renders the words`,
+            });
+        }
+        if (it.group && !value.groups?.some((g) => g.id === it.group)) {
+            ctx.issues.push({
+                code: "custom",
+                input: it,
+                path: ["items", i, "group"],
+                message: `group "${it.group}" is not in groups[]`,
+            });
+        }
+    });
+    const groupIds = new Set();
+    value.groups?.forEach((g, i) => {
+        if (groupIds.has(g.id)) {
+            ctx.issues.push({
+                code: "custom",
+                input: g,
+                path: ["groups", i, "id"],
+                message: `duplicate group id "${g.id}"`,
+            });
+        }
+        groupIds.add(g.id);
+    });
+});

package/dist/artifact-blocks/blocks/media-picker/types.d.ts

@@ -0,0 +1,92 @@
+/**
+ * media-picker param types (mos-vzame) — the hand-written mirror of the zod
+ * schema in block.ts. The def annotates `schema: z.ZodType<MediaPickerParams>`,
+ * so any drift between schema and these interfaces is a compile error, and
+ * the Svelte component can import types WITHOUT importing the def module
+ * (block.ts imports the component; the edge must stay one-way).
+ */
+import type { ItemTeam } from "../../review/team.js";
+import type { MediaDecision } from "./decisions.js";
+export type MediaVariant = {
+    id: string;
+    label?: string | undefined;
+    kind: "image" | "video" | "audio";
+    src: string;
+    poster?: string | undefined;
+    /** Which round this variant belongs to (e.g. "v6"). Variants sharing a
+     * version are VIEWS of it (the loop, a strip, a map). mos-0wvol. */
+    version?: string | undefined;
+};
+/** A verdict recorded on an EARLIER version of an item (read-only). */
+export type MediaVersionVerdict = {
+    version: string;
+    verdict?: "approve" | "redo" | "reject" | undefined;
+    note?: string | undefined;
+};
+export type MediaItem = {
+    id: string;
+    title: string;
+    group?: string | undefined;
+    subtitle?: string | undefined;
+    meta?: Record<string, string> | undefined;
+    tags?: string[] | undefined;
+    variants: MediaVariant[];
+    /** The version under review; defaults to the first variant's version. */
+    currentVersion?: string | undefined;
+    /** Verdicts the viewer left on earlier versions (review-kit history). */
+    history?: MediaVersionVerdict[] | undefined;
+    /** Team status (D7): `ready` + readySince opens a new review round. */
+    team?: ItemTeam | undefined;
+    /** This item is a CHOICE, not a review: each variant is an option and a
+     * per-variant "Pick this" button replaces the single Approve (mos-lwbbt).
+     * The pick saves exactly what an approve saves — verdict + variant. */
+    pick?: boolean | undefined;
+    /** Named options of a decision shown in ONE comparison image (the "A vs
+     * B" sheet): renders a Pick button per choice; the pick is saved as
+     * `variant: <choice id>` — the slug of the choice's label. Requires a
+     * single variant; multi-variant options belong in `variants[]` with
+     * `pick: true`. */
+    choices?: string[] | undefined;
+    /** The variants are EXAMPLES of the problem (an audit card's screenshots),
+     * not choices (mos-9d62g): the card renders them as a gallery with
+     * captions and the verdict stays a plain Approve — of the CARD, saved
+     * with NO variant, so it never reads "Approve <image name>". */
+    evidence?: boolean | undefined;
+    /** Plain-English card copy, one labeled line each (mos-9d62g): what is
+     * wrong, and what happens if you approve. Written for a reader who has
+     * never seen the app — the build lints both for length and jargon. */
+    wrong?: string | undefined;
+    ifApproved?: string | undefined;
+    /** "Open on site" chips under the card (mos-9d62g): where to see the
+     * thing being judged, in a new tab. Label defaults to "Open on site". */
+    links?: MediaItemLink[] | undefined;
+    /** Context only — no verdict is asked (a live-site reference shot, a
+     * spec sheet). Renders without any verdict chrome and is excluded from
+     * the page's review census, so it never blocks "Send answers"
+     * (mos-lwbbt, Joe's steer). */
+    informational?: boolean | undefined;
+    /** `text`: the card is WORDS (a transcript, a copy line), not media
+     * (mos-bk1k8). The full-size view drops the zoom chrome, and when `text`
+     * is given the words render on a themed surface instead of the image —
+     * never a white slab in dark mode. Default `media`. */
+    kind?: "media" | "text" | undefined;
+    /** The words of a `kind: "text"` card, shown in place of its image. */
+    text?: string | undefined;
+};
+export type MediaGroup = {
+    id: string;
+    title: string;
+};
+/** One "Open on site" chip: an https:// or root-relative URL (mos-9d62g). */
+export type MediaItemLink = {
+    label: string;
+    url: string;
+};
+export type MediaPickerParams = {
+    title?: string | undefined;
+    intro?: string | undefined;
+    groups?: MediaGroup[] | undefined;
+    items: MediaItem[];
+};
+/** Re-exported for hosts that want one import surface. */
+export type { MediaDecision };