@joewinke/jatui 0.37.0 → 0.38.0

package/dist/artifact-blocks/blocks/checklist/ChecklistBlock.svelte.d.ts

@@ -0,0 +1,16 @@
+import type { BlockProps } from "../../types.js";
+declare const ChecklistBlock: import("svelte").Component<BlockProps<{
+    rows: {
+        id: string;
+        title: string;
+        url?: string | undefined;
+        owner?: string | undefined;
+        note?: string | undefined;
+        status?: "in_progress" | "blocked" | "pass" | "fail" | "untested" | "ready" | undefined;
+        retestSince?: string | undefined;
+    }[];
+    title?: string | undefined;
+    teamMode?: boolean | undefined;
+}>, {}, "">;
+type ChecklistBlock = ReturnType<typeof ChecklistBlock>;
+export default ChecklistBlock;

package/dist/artifact-blocks/blocks/checklist/Icon.svelte

@@ -0,0 +1,105 @@
+<script lang="ts" module>
+  /**
+   * The icons the content blocks draw (checklist, code, compare) — lucide
+   * paths (ISC), inline so jatui carries no icon-library dependency (MOS
+   * imported lucide-svelte). Renders the same `lucide lucide-<name>` classes
+   * the lucide components did, so selectors and tests keep working.
+   */
+  export type ContentIconName =
+    | "check"
+    | "copy"
+    | "play"
+    | "pause"
+    | "circle-check"
+    | "circle-x"
+    | "circle-pause"
+    | "circle-dashed"
+    | "circle-dot-dashed"
+    | "chevron-down"
+    | "external-link"
+    | "message-square-plus"
+    | "rotate-ccw"
+</script>
+
+<script lang="ts">
+  import type { SVGAttributes } from "svelte/elements"
+
+  let {
+    name,
+    size = 24,
+    strokeWidth = 2,
+    class: klass = "",
+    ...rest
+  }: {
+    name: ContentIconName
+    size?: number | string
+    strokeWidth?: number | string
+    class?: string
+  } & Omit<SVGAttributes<SVGSVGElement>, "class"> = $props()
+</script>
+
+<svg
+  xmlns="http://www.w3.org/2000/svg"
+  width={size}
+  height={size}
+  viewBox="0 0 24 24"
+  fill="none"
+  stroke="currentColor"
+  stroke-width={strokeWidth}
+  stroke-linecap="round"
+  stroke-linejoin="round"
+  class="lucide lucide-{name} {klass}"
+  {...rest}
+>
+  {#if name === "check"}
+    <path d="M20 6 9 17l-5-5" />
+  {:else if name === "copy"}
+    <rect width="14" height="14" x="8" y="8" rx="2" ry="2" /><path
+      d="M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2"
+    />
+  {:else if name === "play"}
+    <polygon points="6 3 20 12 6 21 6 3" />
+  {:else if name === "pause"}
+    <rect x="14" y="4" width="4" height="16" rx="1" /><rect
+      x="6"
+      y="4"
+      width="4"
+      height="16"
+      rx="1"
+    />
+  {:else if name === "circle-check"}
+    <circle cx="12" cy="12" r="10" /><path d="m9 12 2 2 4-4" />
+  {:else if name === "circle-x"}
+    <circle cx="12" cy="12" r="10" /><path d="m15 9-6 6" /><path d="m9 9 6 6" />
+  {:else if name === "circle-pause"}
+    <circle cx="12" cy="12" r="10" /><line x1="10" x2="10" y1="15" y2="9" /><line
+      x1="14"
+      x2="14"
+      y1="15"
+      y2="9"
+    />
+  {:else if name === "circle-dashed" || name === "circle-dot-dashed"}
+    <path d="M10.1 2.18a9.93 9.93 0 0 1 3.8 0" /><path
+      d="M17.6 3.71a9.95 9.95 0 0 1 2.69 2.7"
+    /><path d="M21.82 10.1a9.93 9.93 0 0 1 0 3.8" /><path
+      d="M20.29 17.6a9.95 9.95 0 0 1-2.7 2.69"
+    /><path d="M13.9 21.82a9.94 9.94 0 0 1-3.8 0" /><path
+      d="M6.4 20.29a9.95 9.95 0 0 1-2.69-2.7"
+    /><path d="M2.18 13.9a9.93 9.93 0 0 1 0-3.8" /><path
+      d="M3.71 6.4a9.95 9.95 0 0 1 2.7-2.69"
+    />
+    {#if name === "circle-dot-dashed"}<circle cx="12" cy="12" r="1" />{/if}
+  {:else if name === "chevron-down"}
+    <path d="m6 9 6 6 6-6" />
+  {:else if name === "external-link"}
+    <path d="M15 3h6v6" /><path d="M10 14 21 3" /><path
+      d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"
+    />
+  {:else if name === "message-square-plus"}
+    <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z" /><path
+      d="M12 7v6"
+    /><path d="M9 10h6" />
+  {:else}
+    <path d="M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8" /><path d="M3 3v5h5" />
+  {/if}
+</svg>

package/dist/artifact-blocks/blocks/checklist/Icon.svelte.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The icons the content blocks draw (checklist, code, compare) — lucide
+ * paths (ISC), inline so jatui carries no icon-library dependency (MOS
+ * imported lucide-svelte). Renders the same `lucide lucide-<name>` classes
+ * the lucide components did, so selectors and tests keep working.
+ */
+export type ContentIconName = "check" | "copy" | "play" | "pause" | "circle-check" | "circle-x" | "circle-pause" | "circle-dashed" | "circle-dot-dashed" | "chevron-down" | "external-link" | "message-square-plus" | "rotate-ccw";
+import type { SVGAttributes } from "svelte/elements";
+type $$ComponentProps = {
+    name: ContentIconName;
+    size?: number | string;
+    strokeWidth?: number | string;
+    class?: string;
+} & Omit<SVGAttributes<SVGSVGElement>, "class">;
+declare const Icon: import("svelte").Component<$$ComponentProps, {}, "">;
+type Icon = ReturnType<typeof Icon>;
+export default Icon;

package/dist/artifact-blocks/blocks/checklist/block.d.ts

@@ -0,0 +1,10 @@
+/**
+ * checklist block — the living UAT / test checklist: rows with title, test
+ * URL, owner, per-viewer status + note.
+ */
+import type { ArtifactBlockDef } from "../../types.js";
+import { type ChecklistParams, type ChecklistRow } from "./schema.js";
+declare const def: ArtifactBlockDef<ChecklistParams>;
+export default def;
+/** Re-exported for tests that build state payloads keyed by row. */
+export type { ChecklistRow };

package/dist/artifact-blocks/blocks/checklist/block.js

@@ -0,0 +1,63 @@
+import ChecklistBlock from "./ChecklistBlock.svelte";
+import { checklistItemReview } from "./itemReview.js";
+import { checklistSchema, } from "./schema.js";
+const EXAMPLE = {
+    title: "2026-10-08 deploy: UAT",
+    teamMode: true,
+    rows: [
+        {
+            id: "board-day-move",
+            title: "Scheduling board day-move gestures + bulk move",
+            url: "/admin/scheduling/board",
+            owner: "LateClay769",
+            note: "Drag a card to another day (spring arrows), then bulk-move 3 cards; expect the undo toast.",
+            status: "untested",
+        },
+        {
+            id: "team-roles",
+            title: "Per-member app roles (multi-role, primary)",
+            url: "/admin/team/members",
+            owner: "jw",
+            note: "Give a member two roles, change the primary, sign in as them and check the sidebar.",
+            status: "pass",
+        },
+        {
+            id: "blocks-phase1",
+            title: "Blocks artifacts render at /a/<slug>",
+            url: "/a/blocks-smoke",
+            owner: "agent",
+            note: "Publish a markdown + stats + callout page as blocks; open its URL signed in.",
+            status: "untested",
+        },
+        {
+            id: "caller-id-trusthub",
+            title: "Caller ID card shows real Trust Hub caller-NAME state",
+            url: "/admin/voice/calls",
+            owner: "agent",
+            status: "blocked",
+        },
+        {
+            id: "pe-booking-confirm",
+            title: "Booking confirmation email shows the visit window",
+            url: "/admin/scheduling/bookings",
+            owner: "agent",
+            note: "Fixed the timezone on the window; book a slot and check the email.",
+            status: "ready",
+            retestSince: "2026-10-11T15:00:00Z",
+        },
+    ],
+};
+const def = {
+    type: "checklist",
+    title: "Checklist (UAT / test rounds)",
+    description: "The living test checklist — a UAT table with URLs as a block: rows of { id, title, url, owner, note, status } where status is pass|fail|blocked|untested and url is the page that proves the row (https:// or root-relative). Viewers flip statuses and add notes on the page; that per-viewer state persists through saveState keyed on the row id, so keep row ids stable across republishes or verdicts lose their row. With teamMode:true the authored status renders as a shared 'Team' badge column (what the agents last recorded — update it by republishing the same slug, which is how agents append to the page as things deploy) beside the viewer's own private status. In teamMode the Team status also takes two team-only progress values: 'in_progress' (the team is working it) and 'ready' (fixed, ready for the viewer to retest) — pair 'ready' with retestSince (ISO timestamp of when it became ready) so a verdict saved before the fix counts as stale. A ready row the viewer has not re-verdicted shows a Retest chip and puts the page under Needs you in the host's inbox ('4 to retest'), with or without a jat task link — so record agent progress as structured statuses, never as 'READY TO RETEST' in the title. Retests are ROUNDS: when you mark a row ready with a NEW retestSince, the viewer's previous verdict and note lock into that row's history (shown read-only as 'Round 1 · Fail · …') and the new round starts blank, so a pass never sits beside a stale failure note; saved rows carry { status, note, at, statusAt, round, history[] }, where round is the retestSince the verdict answers. 1-200 rows; the progress line under the heading reads 'N of M decided · pass · fail · blocked · to retest', with filter chips (All / Needs you / Undecided / per verdict / Retest). Rows are keyboard cards: j/k move, a pass, x fail, b blocked, u undo, n note, Enter opens the test link, ? lists every key. Viewers can also sort (authored order default / status worst-first / owner / title) and group (none default / status / owner / Team-vs-You mismatch, with collapsible counted headers) — those layout choices live in the viewer's browser, not in block state. Use it for UAT lists, review rounds, deploy go/no-go boards and incident runbooks — anything a human works through top to bottom. Tip: one row per verifiable thing, link directly to the surface, put what-to-test in the note (multi-line notes render with their line breaks).",
+    schema: checklistSchema,
+    component: ChecklistBlock,
+    // mos-8fvt9: the section's Listen + comment sit on the heading row.
+    hostsTools: (p) => Boolean(p.title),
+    example: EXAMPLE,
+    interactive: true,
+    // The rows are the review units (the core census reads them here).
+    itemReview: checklistItemReview,
+};
+export default def;

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

@@ -0,0 +1,16 @@
+/**
+ * The checklist's item-review hook (jatui-zy9n5): its rows are the review
+ * units the core census, still-open walk and Send read (types.ts
+ * BlockItemReview). Ported from MOS feedbackReview.ts `reviewItemsOf`'s
+ * checklist branch, so "is this row decided?" has the answer the block
+ * renders: an unsaved row shows its authored seed (untested in teamMode,
+ * where the seed is the TEAM's verdict), and a teamMode `ready` row the
+ * viewer has not re-verdicted since is undecided ("to retest"). MOS's
+ * census still seeded teamMode rows from the team status; this follows the
+ * component instead, so the page never counts the team's answer as yours.
+ *
+ * Params and state are the STORED JSON (untrusted, server-side too) — every
+ * field is checked, nothing here trusts the schema ran.
+ */
+import type { BlockItemReview } from "../../types.js";
+export declare const checklistItemReview: BlockItemReview;

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

@@ -0,0 +1,63 @@
+import { rowAwaitsViewer, seedStatus } from "./retest.js";
+const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const ROW_STATUSES = new Set(["pass", "fail", "blocked", "untested"]);
+const VERDICT_OF = {
+    pass: "approved",
+    fail: "needs-work",
+    blocked: "needs-work",
+};
+/** Matches the schema's per-row note cap. */
+const MAX_NOTE = 2000;
+function rowsOf(params) {
+    const p = isObj(params) ? params : {};
+    return (Array.isArray(p.rows) ? p.rows : []).filter((r) => isObj(r) && typeof r.id === "string");
+}
+function items(params, state) {
+    const p = isObj(params) ? params : {};
+    const st = isObj(state) ? state : {};
+    const saved = isObj(st.rows) ? st.rows : {};
+    const out = [];
+    for (const row of rowsOf(params)) {
+        const id = row.id;
+        const teamRow = {
+            status: typeof row.status === "string" ? row.status : undefined,
+            retestSince: typeof row.retestSince === "string" ? row.retestSince : undefined,
+        };
+        const raw = saved[id];
+        const s = isObj(raw) ? raw : null;
+        const savedStatus = s && typeof s.status === "string" && ROW_STATUSES.has(s.status)
+            ? s.status
+            : null;
+        // An unsaved row: in teamMode the viewer starts untested (the Team
+        // column holds the team's verdict — ChecklistBlock viewerStatus, MOS
+        // mos-lsmve.16 F8); a solo checklist's authored status seeds it.
+        const status = savedStatus ?? (p.teamMode === true ? "untested" : seedStatus(teamRow));
+        const awaits = p.teamMode === true && rowAwaitsViewer(teamRow, s);
+        const item = {
+            id,
+            verdict: awaits ? null : (VERDICT_OF[status] ?? null),
+            raw: awaits || status === "untested" ? null : status,
+            explicit: savedStatus !== null,
+            retest: awaits,
+        };
+        if (s && typeof s.note === "string" && s.note.trim())
+            item.note = s.note.trim().slice(0, MAX_NOTE);
+        if (s && Array.isArray(s.attachments) && s.attachments.length > 0)
+            item.attachments = s.attachments;
+        out.push(item);
+    }
+    return out;
+}
+export const checklistItemReview = {
+    vocabulary: [
+        { id: "pass", label: "Pass", tone: "success" },
+        { id: "fail", label: "Fail", tone: "error" },
+        { id: "blocked", label: "Blocked", tone: "warning" },
+    ],
+    name: "Checklist",
+    items,
+    itemLabel(params, itemId) {
+        const row = rowsOf(params).find((r) => r.id === itemId);
+        return typeof row?.title === "string" ? row.title : itemId;
+    },
+};

package/dist/artifact-blocks/blocks/checklist/labels.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Checklist labels + tone maps (token classes only), shared by the component
+ * and tests. Kept out of the .svelte so both script blocks stay simple.
+ *
+ * Also home of the viewer's sort/group vocabulary (mos-iwmjz): those choices
+ * are browser-local UI preferences (localStorage), never block state — see
+ * ChecklistBlock.svelte.
+ */
+import type { VerdictOption } from "../../../actions/reviewKeys.js";
+import type { ChecklistStatus, ChecklistTeamStatus } from "./schema.js";
+/** Row ordering choices for the header Sort control (authored = default). */
+export declare const CHECKLIST_SORTS: readonly ["authored", "status", "owner", "title"];
+export type ChecklistSort = (typeof CHECKLIST_SORTS)[number];
+/** Row grouping choices for the header Group control (none = default). */
+export declare const CHECKLIST_GROUPS: readonly ["none", "status", "owner", "mismatch"];
+export type ChecklistGroup = (typeof CHECKLIST_GROUPS)[number];
+/** Priority order for status sorts and status groups: worst first. */
+export declare const STATUS_RANK: Record<ChecklistStatus, number>;
+/** The Sort / Group menu choices inside ReviewFilterBar. */
+export declare const SORT_OPTIONS: {
+    id: string;
+    label: string;
+}[];
+export declare const GROUP_OPTIONS: {
+    id: string;
+    label: string;
+}[];
+/**
+ * The viewer's verdicts, in the shared review vocabulary (Joe D4 = A): one
+ * array feeds VerdictControl (always-labelled buttons), ReviewNote
+ * (`opensNote`), reviewKeys (`key`: a pass, x fail, b blocked) and the
+ * ReviewProgress / ReviewFilterBar tones. "Untested" is not a verdict — it
+ * is what Undo returns a row to.
+ */
+export declare const VERDICT_OPTIONS: VerdictOption[];
+/**
+ * The checklist's old letters, accepted for ONE release (mos-lsmve.7) with
+ * a deprecation hint in the shortcuts modal. `u` is not here: it is Undo now.
+ * `f` is not here either (mos-lsmve.11): it is the shared "next item that
+ * needs you" key, and a reviewer who learned it on Gallery or Redline must
+ * never fail a row (and type into its note) by pressing it here.
+ */
+export declare const LEGACY_KEYS: Record<string, ChecklistStatus>;
+export declare const LABEL: Record<ChecklistStatus, string>;
+export declare const ICON_TONE: Record<ChecklistStatus, string>;
+/** The Team column's labels: the verdicts plus the team-only progress
+ * states (mos-mssz0). "Ready to retest" is the one that asks the viewer. */
+export declare const TEAM_LABEL: Record<ChecklistTeamStatus, string>;
+export declare const TEAM_ICON_TONE: Record<ChecklistTeamStatus, string>;
+/** Read-only chips. Solid for the three verdicts (DESIGN.md: solid is the
+ * only variant that clears AA on every tone); untested is the QUIET ghost
+ * chip — a solid neutral made "not checked yet" the loudest thing on the
+ * list. */
+export declare const STATUS_BADGE: Record<ChecklistStatus, string>;
+/**
+ * Row title links. No outline on focus: the link is INLINE, and an inline
+ * outline paints once per line fragment, boxing every wrapped line (Joe,
+ * 2026-10-10). Focus is a cloned highlight + a 2px primary underline instead,
+ * which wraps cleanly. The resting underline keeps a link distinguishable
+ * from a plain (url-less) title without relying on colour.
+ */
+export declare const TITLE_LINK = "underline decoration-base-content/30 underline-offset-[3px] box-decoration-clone hover:decoration-base-content focus-visible:outline-none focus-visible:bg-primary/15 focus-visible:decoration-primary focus-visible:decoration-2";

package/dist/artifact-blocks/blocks/checklist/labels.js

@@ -0,0 +1,96 @@
+/** Row ordering choices for the header Sort control (authored = default). */
+export const CHECKLIST_SORTS = ["authored", "status", "owner", "title"];
+/** Row grouping choices for the header Group control (none = default). */
+export const CHECKLIST_GROUPS = ["none", "status", "owner", "mismatch"];
+/** Priority order for status sorts and status groups: worst first. */
+export const STATUS_RANK = {
+    fail: 0,
+    blocked: 1,
+    untested: 2,
+    pass: 3,
+};
+const SORT_LABEL = {
+    authored: "Authored order",
+    status: "Status",
+    owner: "Owner",
+    title: "Title",
+};
+const GROUP_LABEL = {
+    none: "None",
+    status: "Status",
+    owner: "Owner",
+    mismatch: "Mismatch",
+};
+/** The Sort / Group menu choices inside ReviewFilterBar. */
+export const SORT_OPTIONS = CHECKLIST_SORTS.map((id) => ({ id, label: SORT_LABEL[id] }));
+export const GROUP_OPTIONS = CHECKLIST_GROUPS.map((id) => ({ id, label: GROUP_LABEL[id] }));
+/**
+ * The viewer's verdicts, in the shared review vocabulary (Joe D4 = A): one
+ * array feeds VerdictControl (always-labelled buttons), ReviewNote
+ * (`opensNote`), reviewKeys (`key`: a pass, x fail, b blocked) and the
+ * ReviewProgress / ReviewFilterBar tones. "Untested" is not a verdict — it
+ * is what Undo returns a row to.
+ */
+export const VERDICT_OPTIONS = [
+    { id: "pass", label: "Pass", tone: "success", key: "a" },
+    { id: "fail", label: "Fail", tone: "error", key: "x", opensNote: true },
+    {
+        id: "blocked",
+        label: "Blocked",
+        tone: "warning",
+        key: "b",
+        opensNote: true,
+    },
+];
+/**
+ * The checklist's old letters, accepted for ONE release (mos-lsmve.7) with
+ * a deprecation hint in the shortcuts modal. `u` is not here: it is Undo now.
+ * `f` is not here either (mos-lsmve.11): it is the shared "next item that
+ * needs you" key, and a reviewer who learned it on Gallery or Redline must
+ * never fail a row (and type into its note) by pressing it here.
+ */
+export const LEGACY_KEYS = {
+    p: "pass",
+};
+export const LABEL = {
+    pass: "Pass",
+    fail: "Fail",
+    blocked: "Blocked",
+    untested: "Untested",
+};
+export const ICON_TONE = {
+    pass: "text-success",
+    fail: "text-error",
+    blocked: "text-warning",
+    untested: "text-base-content/50",
+};
+/** The Team column's labels: the verdicts plus the team-only progress
+ * states (mos-mssz0). "Ready to retest" is the one that asks the viewer. */
+export const TEAM_LABEL = {
+    ...LABEL,
+    ready: "Ready to retest",
+    in_progress: "In progress",
+};
+export const TEAM_ICON_TONE = {
+    ...ICON_TONE,
+    ready: "text-info",
+    in_progress: "text-base-content/70",
+};
+/** Read-only chips. Solid for the three verdicts (DESIGN.md: solid is the
+ * only variant that clears AA on every tone); untested is the QUIET ghost
+ * chip — a solid neutral made "not checked yet" the loudest thing on the
+ * list. */
+export const STATUS_BADGE = {
+    pass: "badge-success",
+    fail: "badge-error",
+    blocked: "badge-warning",
+    untested: "badge-ghost",
+};
+/**
+ * Row title links. No outline on focus: the link is INLINE, and an inline
+ * outline paints once per line fragment, boxing every wrapped line (Joe,
+ * 2026-10-10). Focus is a cloned highlight + a 2px primary underline instead,
+ * which wraps cleanly. The resting underline keeps a link distinguishable
+ * from a plain (url-less) title without relying on colour.
+ */
+export const TITLE_LINK = "underline decoration-base-content/30 underline-offset-[3px] box-decoration-clone hover:decoration-base-content focus-visible:outline-none focus-visible:bg-primary/15 focus-visible:decoration-primary focus-visible:decoration-2";

package/dist/artifact-blocks/blocks/checklist/retest.d.ts

@@ -0,0 +1,43 @@
+import { type ChecklistStatus } from "./schema.js";
+/** The two authored row fields the team semantics read. Loose on purpose:
+ * the needs-you census hands in rows straight from stored spec JSON. */
+interface TeamRow {
+    status?: string;
+    retestSince?: string;
+}
+/**
+ * The checklist's round model: verdicts live in `status` ("untested" is no
+ * verdict), and `statusAt` belongs to the round. A legacy save (no `round`)
+ * is measured by its statusAt, then its at — the same reading this module
+ * always made.
+ */
+export declare const CHECKLIST_ROUNDS: {
+    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) => import("../../review/rounds.js").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>;
+};
+/** The round a row's verdict answers: its retestSince (null = no rounds). */
+export declare function rowRound(row: TeamRow): string | null;
+/**
+ * The status a viewer STARTS a row at. The authored status seeds it, except
+ * the team-only progress states (`ready`, `in_progress`): those describe the
+ * team, never a verdict, so the viewer starts untested.
+ */
+export declare function seedStatus(row: TeamRow): ChecklistStatus;
+/**
+ * Does this row wait on the viewer's (re)test? Only a `ready` team status
+ * asks. It is answered by a saved verdict other than untested in the
+ * CURRENT round: a save stamped with `round` answers it when that round is
+ * the row's retestSince (identity, so client clock skew cannot move it); an
+ * older, unstamped save answers it when its statusAt (else at) is at or
+ * after retestSince. A verdict with no timestamp at all cannot prove it is
+ * newer and leaves the row waiting.
+ *
+ * `saved` is untrusted stored JSON — every field is checked.
+ */
+export declare function rowAwaitsViewer(row: TeamRow, saved: unknown): boolean;
+export {};

package/dist/artifact-blocks/blocks/checklist/retest.js

@@ -0,0 +1,68 @@
+/**
+ * Team-status + round semantics for the checklist block (mos-mssz0,
+ * mos-lsmve.7), shared by the component and the artifact-level needs-you
+ * derivation (src/lib/modules/artifacts/needsYou.ts) so "does this row await
+ * the viewer?" has exactly one answer.
+ *
+ * Rounds (docs/review-ux/proposal.md, Joe D1 = D2 = A): a row's round is its
+ * `retestSince`. The team marking the row ready with a new retestSince opens
+ * a round; the viewer's first save in it locks the previous {status, note,
+ * at} into `history[]` and starts blank. The move happens in
+ * `CHECKLIST_ROUNDS.save` (review/rounds.ts), on the viewer's own save.
+ */
+import { useRounds } from "../../review/rounds.js";
+import { CHECKLIST_STATUSES, } from "./schema.js";
+function isViewerStatus(v) {
+    return (typeof v === "string" &&
+        CHECKLIST_STATUSES.includes(v));
+}
+/**
+ * The checklist's round model: verdicts live in `status` ("untested" is no
+ * verdict), and `statusAt` belongs to the round. A legacy save (no `round`)
+ * is measured by its statusAt, then its at — the same reading this module
+ * always made.
+ */
+export const CHECKLIST_ROUNDS = useRounds({
+    verdictKey: "status",
+    verdicts: CHECKLIST_STATUSES,
+    emptyVerdict: "untested",
+    roundFields: ["statusAt"],
+}, { stampKeys: ["statusAt", "at"] });
+/** The round a row's verdict answers: its retestSince (null = no rounds). */
+export function rowRound(row) {
+    return typeof row.retestSince === "string" && row.retestSince !== ""
+        ? row.retestSince
+        : null;
+}
+/**
+ * The status a viewer STARTS a row at. The authored status seeds it, except
+ * the team-only progress states (`ready`, `in_progress`): those describe the
+ * team, never a verdict, so the viewer starts untested.
+ */
+export function seedStatus(row) {
+    return isViewerStatus(row.status) ? row.status : "untested";
+}
+/**
+ * Does this row wait on the viewer's (re)test? Only a `ready` team status
+ * asks. It is answered by a saved verdict other than untested in the
+ * CURRENT round: a save stamped with `round` answers it when that round is
+ * the row's retestSince (identity, so client clock skew cannot move it); an
+ * older, unstamped save answers it when its statusAt (else at) is at or
+ * after retestSince. A verdict with no timestamp at all cannot prove it is
+ * newer and leaves the row waiting.
+ *
+ * `saved` is untrusted stored JSON — every field is checked.
+ */
+export function rowAwaitsViewer(row, saved) {
+    if (row.status !== "ready")
+        return false;
+    const s = typeof saved === "object" && saved !== null
+        ? saved
+        : null;
+    if (!s || !isViewerStatus(s.status) || s.status === "untested")
+        return true;
+    const round = rowRound(row);
+    if (!round || Number.isNaN(Date.parse(round)))
+        return false;
+    return CHECKLIST_ROUNDS.isStale(s, round);
+}

package/dist/artifact-blocks/blocks/checklist/schema.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Params schema for the checklist block (the living UAT / test checklist).
+ * Imported by block.ts (def), ChecklistBlock.svelte (props typing) and the
+ * tests — keeps them cycle-free.
+ */
+import { z } from "zod";
+import type { RoundLine } from "../../review/rounds.js";
+export declare const CHECKLIST_STATUSES: readonly ["pass", "fail", "blocked", "untested"];
+export type ChecklistStatus = (typeof CHECKLIST_STATUSES)[number];
+/**
+ * The TEAM status vocabulary (teamMode only, mos-mssz0): the viewer's four
+ * verdicts plus two agent-side progress states a viewer never sets —
+ * `in_progress` (the team is working the row) and `ready` (fixed, ready for
+ * the viewer to retest). A `ready` row is what makes a page "need you" on
+ * /admin/artifacts without any jat task link.
+ */
+declare const CHECKLIST_TEAM_STATUSES: readonly ["pass", "fail", "blocked", "untested", "ready", "in_progress"];
+export type ChecklistTeamStatus = (typeof CHECKLIST_TEAM_STATUSES)[number];
+declare const rowSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    url: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+    note: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        in_progress: "in_progress";
+        blocked: "blocked";
+        pass: "pass";
+        fail: "fail";
+        untested: "untested";
+        ready: "ready";
+    }>>;
+    retestSince: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$strip>;
+export declare const checklistSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    rows: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        url: z.ZodOptional<z.ZodString>;
+        owner: z.ZodOptional<z.ZodString>;
+        note: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodEnum<{
+            in_progress: "in_progress";
+            blocked: "blocked";
+            pass: "pass";
+            fail: "fail";
+            untested: "untested";
+            ready: "ready";
+        }>>;
+        retestSince: z.ZodOptional<z.ZodISODateTime>;
+    }, z.core.$strip>>;
+    teamMode: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/** Per-row state one viewer saves through ctx.saveState. */
+export interface ChecklistRowState {
+    status?: ChecklistStatus;
+    note?: string;
+    /** ISO timestamp of the last change to this row. */
+    at?: string;
+    /** ISO timestamp of the last change to this row's STATUS (a note edit
+     * leaves it alone) — what a retest is measured against. */
+    statusAt?: string;
+    /** The round this verdict answers: the row's retestSince when it was set
+     * (mos-lsmve.7). Absent = round 1 (legacy) or a row without rounds. */
+    round?: string;
+    /** Earlier rounds, locked and newest first: { round, verdict, note, at }.
+     * Written by the viewer's first save in a new round (review/rounds.ts). */
+    history?: RoundLine[];
+}
+/**
+ * Per-viewer state the checklist block saves through ctx.saveState. A type
+ * alias, not an interface: only aliases get the implicit index signature that
+ * makes them assignable to BlockState (Record<string, unknown>).
+ */
+export type ChecklistState = {
+    /** Keyed by row id; a row absent from the map uses its authored status. */
+    rows?: Record<string, ChecklistRowState>;
+    /** ISO timestamp of the last save. */
+    at?: string;
+};
+export type ChecklistRow = z.infer<typeof rowSchema>;
+export type ChecklistParams = z.infer<typeof checklistSchema>;
+export {};