@joewinke/jatui 0.37.0 → 0.38.0

package/dist/artifact-blocks/review.js

@@ -0,0 +1,716 @@
+/**
+ * The review math of a blocks page (ported from MOS
+ * modules/artifacts/feedbackReview.ts, jatui-vsuzi) — the census, the
+ * still-open walk, the verdicts a Send carries and the changed-after-send
+ * diff. PURE and isomorphic: the view reads it in the browser, and a host
+ * server may run the same functions over a stored spec so a desk Send and a
+ * page Send answer identically.
+ *
+ * What stays HOST-side (not here): validating an untrusted review body,
+ * composing the answer comment, routing it to the owner, delivery. Those
+ * need the host's store and its jat binding.
+ *
+ * Where per-block verdicts live between visits: the viewer's saved blocks
+ * map, under the reserved key `review:<blockId>` (reviewKey). Block ids are
+ * `[a-z0-9_-]`, so the colon can never collide with a block's own state.
+ *
+ * Item-review blocks (checklist, media-picker, diff-review) carry their
+ * verdicts PER ITEM inside their own state; the core reads them through the
+ * block def's `itemReview` hook (types.ts BlockItemReview), never by
+ * knowing the block's internals.
+ */
+import { blockDef } from "./registry.js";
+const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+// ---------------------------------------------------------------------------
+// Specs
+// ---------------------------------------------------------------------------
+/**
+ * A stored spec, defensively: untrusted JSON → a BlocksSpec, or null when it
+ * is not one. NOT registry validation — rendering must degrade per block,
+ * not refuse the whole page. A JSON string (a double-encoded jsonb scalar)
+ * is decoded first.
+ */
+export function coerceBlocksSpec(input) {
+    let raw = input;
+    if (typeof raw === "string") {
+        try {
+            raw = JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (!isObj(raw))
+        return null;
+    if (raw.version !== 1)
+        return null;
+    if (typeof raw.title !== "string")
+        return null;
+    if (!Array.isArray(raw.blocks))
+        return null;
+    const blocks = [];
+    for (const b of raw.blocks) {
+        if (!isObj(b))
+            return null;
+        if (typeof b.id !== "string" || typeof b.type !== "string")
+            return null;
+        const inst = { id: b.id, type: b.type, params: b.params ?? {} };
+        if (typeof b.owner === "string")
+            inst.owner = b.owner;
+        if (typeof b.taskId === "string")
+            inst.taskId = b.taskId;
+        if (typeof b.decisionId === "string")
+            inst.decisionId = b.decisionId;
+        blocks.push(inst);
+    }
+    return {
+        version: 1,
+        title: raw.title,
+        summary: typeof raw.summary === "string" ? raw.summary : undefined,
+        blocks,
+    };
+}
+// ---------------------------------------------------------------------------
+// Which blocks are review units
+// ---------------------------------------------------------------------------
+/** Reserved blocks-map key for a block's chrome verdict. */
+const REVIEW_KEY_PREFIX = "review:";
+export function reviewKey(blockId) {
+    return `${REVIEW_KEY_PREFIX}${blockId}`;
+}
+/**
+ * Block types whose verdicts are per ITEM inside their own state. Known by
+ * name so the census holds even before a host registers the block (it then
+ * counts zero items and never offers a block-level verdict); a registered
+ * block with an `itemReview` hook joins automatically.
+ */
+export const ITEM_REVIEW_BLOCK_TYPES = new Set([
+    "media-picker",
+    "diff-review",
+    "checklist",
+]);
+export function isItemReviewBlock(type) {
+    return ITEM_REVIEW_BLOCK_TYPES.has(type) || Boolean(blockDef(type)?.itemReview);
+}
+/**
+ * Block types that present a WORK PRODUCT to judge and so take the
+ * block-level approve / needs-a-pass strip by default. Every other ordinary
+ * block — stats, table, chart, markdown, a plain callout, a map… — is
+ * INFORMATION: no strip, not a review unit. A registered def can join with
+ * `reviewableByDefault: true`.
+ */
+const REVIEWABLE_BY_DEFAULT = new Set(["mockup", "compare", "collage", "diff"]);
+/** The id of a decision callout's free-text "Other" choice. */
+export const OTHER_ID = "__other__";
+/** A decision callout: answered by its own pick, never by a verdict strip. */
+export function isDecisionBlock(type, params) {
+    return type === "callout" && isObj(params) && params.variant === "decision";
+}
+/**
+ * Does this block take the block-level verdict strip (and count as one
+ * review unit)? Never an item-review block or a decision callout.
+ * Otherwise the spec decides with `params.reviewable: true|false` (a page
+ * intro sets `reviewable: false` explicitly — PARAMS-SPEC §3); absent that,
+ * only the work-product types do.
+ */
+export function takesBlockVerdict(type, params) {
+    if (isItemReviewBlock(type))
+        return false;
+    if (isDecisionBlock(type, params))
+        return false;
+    if (isObj(params) && typeof params.reviewable === "boolean")
+        return params.reviewable;
+    return (REVIEWABLE_BY_DEFAULT.has(type) ||
+        blockDef(type)?.reviewableByDefault === true);
+}
+// ---------------------------------------------------------------------------
+// Decision cards
+// ---------------------------------------------------------------------------
+const OPTION_RE = /^[A-Z]$/;
+/**
+ * The page's decision cards: `callout` blocks with variant `decision`.
+ * Answered with a LETTER: options get A, B, C… by position unless they
+ * carry their own, and an `allowOther` card's "Other" takes the next free
+ * letter.
+ */
+export function decisionCardsOf(spec) {
+    const out = new Map();
+    for (const b of coerceBlocksSpec(spec)?.blocks ?? []) {
+        if (b.type !== "callout" || !isObj(b.params))
+            continue;
+        const p = b.params;
+        if (p.variant !== "decision" || !Array.isArray(p.options))
+            continue;
+        const options = [];
+        for (const o of p.options) {
+            if (!isObj(o) || typeof o.id !== "string")
+                continue;
+            options.push({
+                letter: typeof o.letter === "string" && OPTION_RE.test(o.letter)
+                    ? o.letter
+                    : String.fromCharCode(65 + options.length),
+                id: o.id,
+                label: typeof o.label === "string" ? o.label : o.id,
+            });
+        }
+        if (p.allowOther === true) {
+            const used = new Set(options.map((o) => o.letter));
+            let code = 65 + options.length;
+            while (used.has(String.fromCharCode(code)) && code < 90)
+                code++;
+            options.push({
+                letter: String.fromCharCode(code),
+                id: OTHER_ID,
+                label: "Other",
+            });
+        }
+        out.set(b.id, {
+            question: typeof p.question === "string"
+                ? p.question
+                : typeof p.title === "string"
+                    ? p.title
+                    : b.id,
+            options,
+        });
+    }
+    return out;
+}
+/** The letter a saved callout pick stands for, or null. */
+function letterForPick(card, pick) {
+    if (typeof pick !== "string")
+        return null;
+    return card.options.find((o) => o.id === pick)?.letter ?? null;
+}
+/**
+ * The contract verdicts a Send carries, read from a viewer's blocks map:
+ * each decision card's pick as `chose` + its letter, and each
+ * verdict-taking block's `review:<id>` entry. Item-review blocks carry
+ * their verdicts per item (itemVerdictsOf), never here.
+ */
+export function verdictsFromBlocks(spec, blocks) {
+    const out = {};
+    const parsed = coerceBlocksSpec(spec);
+    if (!parsed || !blocks)
+        return out;
+    const cards = decisionCardsOf(parsed);
+    for (const b of parsed.blocks) {
+        if (isItemReviewBlock(b.type))
+            continue;
+        const card = cards.get(b.id);
+        if (!card && !takesBlockVerdict(b.type, b.params))
+            continue;
+        if (card) {
+            const st = blocks[b.id];
+            const letter = isObj(st) ? letterForPick(card, st.pick) : null;
+            if (!letter)
+                continue;
+            const e = { verdict: "chose", option: letter };
+            if (isObj(st) && typeof st.comment === "string" && st.comment.trim())
+                e.note = st.comment.trim();
+            if (isObj(st) && Array.isArray(st.attachments) && st.attachments.length)
+                e.attachments = st.attachments;
+            out[b.id] = e;
+            continue;
+        }
+        const rv = blocks[reviewKey(b.id)];
+        if (!isObj(rv))
+            continue;
+        if (rv.verdict !== "approved" && rv.verdict !== "needs-pass")
+            continue;
+        const e = { verdict: rv.verdict };
+        if (typeof rv.note === "string" && rv.note.trim())
+            e.note = rv.note.trim();
+        if (Array.isArray(rv.attachments) && rv.attachments.length)
+            e.attachments = rv.attachments;
+        out[b.id] = e;
+    }
+    return out;
+}
+/** A saved chrome verdict, defensively. */
+export function blockReviewStateOf(blocks, blockId) {
+    const s = blocks[reviewKey(blockId)];
+    return isObj(s) ? s : null;
+}
+// ---------------------------------------------------------------------------
+// Items inside item-review blocks
+// ---------------------------------------------------------------------------
+/** The items of one item-review block (through its def's hook). Empty when
+ * the block is unregistered or declares no hook. */
+export function reviewItemsOf(type, params, state) {
+    const hook = blockDef(type)?.itemReview;
+    if (!hook)
+        return [];
+    try {
+        return hook.items(params, state);
+    }
+    catch {
+        // Untrusted stored JSON: a hook that trips over it counts nothing
+        // rather than taking the page down.
+        return [];
+    }
+}
+/** Every block-local word normalized to a bucket (the sent-summary line). */
+const ITEM_VERDICTS = new Map([
+    ["approve", "approved"],
+    ["approved", "approved"],
+    ["pass", "approved"],
+    ["accept", "approved"],
+    ["redo", "needs-work"],
+    ["modify", "needs-work"],
+    ["fail", "needs-work"],
+    ["blocked", "needs-work"],
+    ["needs-work", "needs-work"],
+    ["needs-pass", "needs-work"],
+    ["reject", "rejected"],
+    ["rejected", "rejected"],
+]);
+/** The chrome vocabulary: per-block verdicts plus decision picks. */
+export const BLOCKS_VOCABULARY = [
+    { id: "approved", label: "Approve", tone: "success" },
+    { id: "needs-pass", label: "Needs a pass", tone: "warning" },
+    { id: "chose", label: "Chosen", tone: "info" },
+];
+const TONE_OF_BUCKET = {
+    approved: "success",
+    "needs-work": "warning",
+    "needs-pass": "warning",
+    rejected: "error",
+    chose: "info",
+};
+/**
+ * The word a stored verdict shows in `vocab`. `raw` is the block's own id;
+ * a spelling the vocabulary does not know falls back to the vocabulary's
+ * word for the same bucket. null = no word.
+ */
+export function wordFor(vocab, raw, bucket) {
+    const exact = raw ? vocab.find((w) => w.id === raw) : undefined;
+    if (exact)
+        return exact;
+    const tone = bucket ? TONE_OF_BUCKET[bucket] : undefined;
+    return (tone && vocab.find((w) => w.tone === tone)) || null;
+}
+/** An item-review block's vocabulary key + words. */
+function vocabularyOf(type) {
+    const hook = blockDef(type)?.itemReview;
+    return hook
+        ? { key: type, words: hook.vocabulary }
+        : { key: "blocks", words: BLOCKS_VOCABULARY };
+}
+/** A block's label in jump cards / progress lines. */
+function itemBlockTitle(b) {
+    const p = isObj(b.params) ? b.params : {};
+    if (typeof p.title === "string" && p.title.trim())
+        return p.title.trim();
+    return blockDef(b.type)?.itemReview?.name ?? blockDef(b.type)?.title ?? b.type;
+}
+const bump = (counts, id) => {
+    counts[id] = (counts[id] ?? 0) + 1;
+};
+/**
+ * Count one viewer's reviewable units: every item of an item-review block,
+ * every decision callout, and the approve / needs-a-pass of every block that
+ * takes one. Information blocks are not units. `blocks` is the viewer's
+ * saved blocks map.
+ */
+export function countReviewUnits(spec, blocks) {
+    const c = {
+        total: 0,
+        approved: 0,
+        needsWork: 0,
+        rejected: 0,
+        chose: 0,
+        retest: 0,
+        itemBlocks: 0,
+        lines: [],
+    };
+    const cards = decisionCardsOf(spec);
+    let other = null;
+    for (const b of coerceBlocksSpec(spec)?.blocks ?? []) {
+        if (isItemReviewBlock(b.type)) {
+            c.itemBlocks++;
+            const vocab = vocabularyOf(b.type);
+            const line = {
+                key: b.id,
+                vocab: vocab.key,
+                words: vocab.words,
+                title: itemBlockTitle(b),
+                counts: {},
+                total: 0,
+                retest: 0,
+            };
+            c.lines.push(line);
+            for (const it of reviewItemsOf(b.type, b.params, blocks[b.id])) {
+                c.total++;
+                line.total++;
+                if (it.verdict === "approved")
+                    c.approved++;
+                else if (it.verdict === "needs-work")
+                    c.needsWork++;
+                else if (it.verdict === "rejected")
+                    c.rejected++;
+                else if (it.retest) {
+                    c.retest++;
+                    line.retest++;
+                }
+                const word = it.verdict ? wordFor(vocab.words, it.raw, it.verdict) : null;
+                if (word)
+                    bump(line.counts, word.id);
+            }
+            continue;
+        }
+        const card = cards.get(b.id);
+        if (!card && !takesBlockVerdict(b.type, b.params))
+            continue;
+        c.total++;
+        if (!other) {
+            other = {
+                key: "blocks",
+                vocab: "blocks",
+                words: BLOCKS_VOCABULARY,
+                title: "Blocks",
+                counts: {},
+                total: 0,
+                retest: 0,
+            };
+            c.lines.push(other);
+        }
+        other.total++;
+        if (card) {
+            const st = blocks[b.id];
+            if (isObj(st) && letterForPick(card, st.pick)) {
+                c.chose++;
+                bump(other.counts, "chose");
+            }
+            continue;
+        }
+        const rv = blocks[reviewKey(b.id)];
+        if (!isObj(rv))
+            continue;
+        if (rv.verdict === "approved")
+            c.approved++;
+        else if (rv.verdict === "needs-pass")
+            c.needsWork++;
+        else
+            continue;
+        bump(other.counts, rv.verdict);
+    }
+    return c;
+}
+/**
+ * The Finish review bar's progress, aggregated by tone but LABELLED with
+ * the page's own words: one vocabulary → one sentence; mixed vocabularies
+ * → each block keeps its own sentence. Never folds one word into another.
+ */
+export function pageReviewProgress(c) {
+    const vocabs = new Set(c.lines.map((l) => l.vocab));
+    const decided = c.lines.reduce((n, l) => n + Object.values(l.counts).reduce((a, b) => a + b, 0), 0);
+    const headline = [
+        `${decided} of ${c.total} decided`,
+        ...(c.retest ? [`${c.retest} to retest`] : []),
+    ].join(" · ");
+    if (vocabs.size <= 1) {
+        const counts = {};
+        for (const l of c.lines)
+            for (const [id, n] of Object.entries(l.counts))
+                counts[id] = (counts[id] ?? 0) + n;
+        return {
+            verdicts: c.lines[0]?.words ?? BLOCKS_VOCABULARY,
+            counts,
+            total: c.total,
+            retest: c.retest,
+            decidedWord: "decided",
+            lines: [],
+            headline,
+        };
+    }
+    const tones = [
+        { id: "success", label: "success", tone: "success" },
+        { id: "warning", label: "warning", tone: "warning" },
+        { id: "error", label: "error", tone: "error" },
+        { id: "info", label: "info", tone: "info" },
+    ];
+    const byTone = {};
+    for (const l of c.lines)
+        for (const w of l.words)
+            if (l.counts[w.id])
+                byTone[w.tone] = (byTone[w.tone] ?? 0) + l.counts[w.id];
+    return {
+        verdicts: tones,
+        counts: byTone,
+        total: c.total,
+        retest: c.retest,
+        decidedWord: "decided",
+        lines: c.lines.map((l) => ({
+            key: l.key,
+            title: l.title,
+            verdicts: l.words,
+            counts: l.counts,
+            total: l.total,
+            retest: l.retest,
+            decidedWord: "decided",
+        })),
+        headline,
+    };
+}
+/**
+ * The page's still-open review units, in page order — the census walk with
+ * IDENTITY, so `openReviewUnits(...).length` is exactly the page's
+ * undecided count.
+ */
+export function openReviewUnits(spec, blocks) {
+    const out = [];
+    const cards = decisionCardsOf(spec);
+    for (const b of coerceBlocksSpec(spec)?.blocks ?? []) {
+        if (isItemReviewBlock(b.type)) {
+            const hook = blockDef(b.type)?.itemReview;
+            const context = itemBlockTitle(b);
+            for (const it of reviewItemsOf(b.type, b.params, blocks[b.id])) {
+                if (it.verdict !== null)
+                    continue;
+                let label = it.id;
+                let thumb;
+                try {
+                    label = hook?.itemLabel?.(b.params, it.id) ?? it.id;
+                    thumb = hook?.itemThumb?.(b.params, it.id);
+                }
+                catch {
+                    // A hook that trips over untrusted JSON keeps the id as the label.
+                }
+                out.push({
+                    key: `${b.id}:${it.id}`,
+                    blockId: b.id,
+                    type: b.type,
+                    itemId: it.id,
+                    label,
+                    context,
+                    ...(thumb ? { thumb } : {}),
+                    retest: it.retest,
+                });
+            }
+            continue;
+        }
+        const card = cards.get(b.id);
+        if (!card && !takesBlockVerdict(b.type, b.params))
+            continue;
+        if (card) {
+            const st = blocks[b.id];
+            if (isObj(st) && letterForPick(card, st.pick))
+                continue;
+            out.push({
+                key: b.id,
+                blockId: b.id,
+                type: b.type,
+                label: card.question,
+                retest: false,
+            });
+            continue;
+        }
+        const rv = blocks[reviewKey(b.id)];
+        if (isObj(rv) && (rv.verdict === "approved" || rv.verdict === "needs-pass"))
+            continue;
+        const p = isObj(b.params) ? b.params : {};
+        out.push({
+            key: b.id,
+            blockId: b.id,
+            type: b.type,
+            label: typeof p.title === "string" && p.title.trim() ? p.title.trim() : "",
+            retest: false,
+        });
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// Item verdicts, the sent state and the changed-after-send diff
+// ---------------------------------------------------------------------------
+/**
+ * Item verdicts from item-review blocks in the viewer's saved state, only
+ * items the viewer gave a verdict (an authored seed is not theirs). The
+ * page's changed-after-send diff runs this SAME read on both sides.
+ */
+export function itemVerdictsOf(saved, spec) {
+    const out = {};
+    if (!saved)
+        return out;
+    for (const b of coerceBlocksSpec(spec)?.blocks ?? []) {
+        if (!isItemReviewBlock(b.type))
+            continue;
+        const items = {};
+        for (const it of reviewItemsOf(b.type, b.params, saved[b.id])) {
+            if (!it.explicit || !it.raw)
+                continue;
+            const e = { verdict: it.raw };
+            if (it.note)
+                e.note = it.note;
+            if (it.attachments?.length)
+                e.attachments = it.attachments;
+            items[it.id] = e;
+        }
+        if (Object.keys(items).length > 0)
+            out[b.id] = items;
+    }
+    return out;
+}
+const VERDICT_VALUES = new Set(["approved", "needs-pass", "chose"]);
+function coerceVerdictEntry(v) {
+    if (!isObj(v))
+        return null;
+    if (typeof v.verdict !== "string" || !VERDICT_VALUES.has(v.verdict))
+        return null;
+    const e = { verdict: v.verdict };
+    if (v.option !== undefined) {
+        if (typeof v.option !== "string")
+            return null;
+        e.option = v.option;
+    }
+    if (v.note !== undefined) {
+        if (typeof v.note !== "string")
+            return null;
+        e.note = v.note;
+    }
+    if (v.attachments !== undefined) {
+        if (!Array.isArray(v.attachments))
+            return null;
+        e.attachments = v.attachments;
+    }
+    return e;
+}
+function coerceVerdictsMap(v) {
+    if (!isObj(v))
+        return undefined;
+    const out = {};
+    for (const [id, raw] of Object.entries(v)) {
+        const e = coerceVerdictEntry(raw);
+        if (!e)
+            return undefined;
+        out[id] = e;
+    }
+    return out;
+}
+function coerceItemsMap(v) {
+    if (!isObj(v))
+        return undefined;
+    const out = {};
+    for (const [blockId, byItem] of Object.entries(v)) {
+        if (!isObj(byItem))
+            return undefined;
+        const items = {};
+        for (const [itemId, raw] of Object.entries(byItem)) {
+            if (!isObj(raw) || typeof raw.verdict !== "string")
+                return undefined;
+            items[itemId] = raw;
+        }
+        out[blockId] = items;
+    }
+    return out;
+}
+/**
+ * The seeded done state from a stored event payload (`sentVerdicts`,
+ * `sentItems`). Untrusted JSON: an entry that does not parse DROPS the
+ * whole map — the page then reads "sent, details unknown" — never a wrong
+ * changed-state from a malformed row.
+ */
+export function coerceSentAnswer(input) {
+    const verdicts = coerceVerdictsMap(input.payload.sentVerdicts);
+    const items = coerceItemsMap(input.payload.sentItems);
+    return {
+        sentAt: input.sentAt,
+        sentTo: input.sentTo,
+        ...(input.eventId ? { eventId: input.eventId } : {}),
+        ...(input.deliveredAt !== undefined
+            ? { deliveredAt: input.deliveredAt }
+            : {}),
+        ...(input.deliverable !== undefined
+            ? { deliverable: input.deliverable }
+            : {}),
+        ...(verdicts ? { verdicts } : {}),
+        ...(items ? { items } : {}),
+    };
+}
+/** Canonical JSON: object keys sorted, so a jsonb round trip can never fake
+ * a difference. */
+function canonical(value) {
+    if (Array.isArray(value))
+        return value.map(canonical);
+    if (isObj(value)) {
+        const out = {};
+        for (const k of Object.keys(value).sort())
+            out[k] = canonical(value[k]);
+        return out;
+    }
+    return value;
+}
+const entryJson = (v) => JSON.stringify(canonical(v ?? null));
+/**
+ * Which sent entries differ from the viewer's current decisions. Sent maps
+ * ABSENT → all zeros: unknown is never reported as changed.
+ */
+export function changedSinceSend(sentVerdicts, currentVerdicts, sentItems, currentItems) {
+    if (!sentVerdicts && !sentItems)
+        return { blocks: 0, items: 0, total: 0 };
+    let blocks = 0;
+    const ids = new Set([
+        ...Object.keys(sentVerdicts ?? {}),
+        ...Object.keys(currentVerdicts),
+    ]);
+    for (const id of ids)
+        if (entryJson(sentVerdicts?.[id]) !== entryJson(currentVerdicts[id]))
+            blocks++;
+    let items = 0;
+    const blockIds = new Set([
+        ...Object.keys(sentItems ?? {}),
+        ...Object.keys(currentItems),
+    ]);
+    for (const b of blockIds) {
+        const sent = sentItems?.[b] ?? {};
+        const cur = currentItems[b] ?? {};
+        const itemIds = new Set([...Object.keys(sent), ...Object.keys(cur)]);
+        for (const i of itemIds) {
+            if (entryJson(sent[i]) !== entryJson(cur[i])) {
+                items++;
+                break;
+            }
+        }
+    }
+    return { blocks, items, total: blocks + items };
+}
+/** The one-line "what was sent" of the done state. "" for a note-only answer. */
+export function sentAnswerLine(verdicts, items) {
+    let approved = 0;
+    let needsPass = 0;
+    let chose = 0;
+    for (const v of Object.values(verdicts ?? {})) {
+        if (v.verdict === "approved")
+            approved++;
+        else if (v.verdict === "needs-pass")
+            needsPass++;
+        else if (v.verdict === "chose")
+            chose++;
+    }
+    let itemApproved = 0;
+    let itemNeedsWork = 0;
+    let itemRejected = 0;
+    for (const byItem of Object.values(items ?? {}))
+        for (const v of Object.values(byItem)) {
+            const t = ITEM_VERDICTS.get(v.verdict.trim().toLowerCase());
+            if (t === "approved")
+                itemApproved++;
+            else if (t === "needs-work")
+                itemNeedsWork++;
+            else if (t === "rejected")
+                itemRejected++;
+        }
+    const parts = [];
+    if (chose)
+        parts.push(`${chose} decision${chose === 1 ? "" : "s"} answered`);
+    if (approved)
+        parts.push(`${approved} approved`);
+    if (needsPass)
+        parts.push(`${needsPass} need${needsPass === 1 ? "s" : ""} another pass`);
+    if (itemApproved)
+        parts.push(`${itemApproved} item${itemApproved === 1 ? "" : "s"} approved`);
+    if (itemNeedsWork)
+        parts.push(`${itemNeedsWork} to redo`);
+    if (itemRejected)
+        parts.push(`${itemRejected} rejected`);
+    return parts.join(" · ");
+}