tinybeeai 0.0.0-stage → 0.16.1

package/dist/chat-blocks.js

@@ -0,0 +1,709 @@
+// Validation for chat answer blocks (KAT-136, docs/CHAT-UI.md). Shared by the server, which checks
+// what the model emits before it streams a block, and the client, which checks again before it
+// renders. Pure and dependency free.
+//
+// Rules: a known kind keeps its valid rows and drops the rest. A known kind whose rows all fail, and
+// any unknown kind that still carries rows, becomes a `table` block. Anything else is rejected and
+// the answer stays text only. Strings are trimmed and capped; links must be http or https.
+import { clean, isObj, num, oneOf, safeHttpUrl, str } from './chat-parse-util.js';
+import { parseViewTree, rawNodes } from './view-spec.js';
+export { safeHttpUrl };
+export const CHAT_BLOCK_KINDS = [
+    'runs',
+    'pulls',
+    'approvals',
+    'defects',
+    'probes',
+    'memory',
+    'ticket_review',
+    'test_cases',
+    'triage',
+    'cards',
+    'table',
+    'stats',
+    'chart',
+    'view',
+    'release_call',
+];
+/** Rows kept per block. The rest count toward `more`. */
+export const MAX_BLOCK_ROWS = 50;
+/** Columns kept in a fallback table. */
+export const MAX_TABLE_COLUMNS = 6;
+/** Tiles kept in a stats block. */
+export const MAX_STAT_TILES = 8;
+/** Categories or points kept in a chart, and series kept per chart. */
+export const MAX_CHART_LABELS = 31;
+export const MAX_CHART_SERIES = 4;
+const MAX_CHART_NAME = 60;
+const MAX_FINDING = 240;
+const MAX_LONG_TEXT = 4000;
+function strList(v, max = 20) {
+    if (!Array.isArray(v))
+        return undefined;
+    const out = v.map((x) => str(x)).filter((x) => Boolean(x));
+    return out.length ? out.slice(0, max) : undefined;
+}
+const RUN_STATUS = ['running', 'done', 'failed', 'interrupted', 'cancelled'];
+const JOB_KINDS = ['pr_check', 'post_merge', 'ci_failure', 'ticket_review', 'outage', 'recovery', 'digest', 'rerun', 'test_design', 'nightly_run'];
+const OUTCOMES = ['pass', 'product_failure', 'test_failure', 'environment_failure', 'flaky', 'needs_attention', 'info'];
+const APPROVAL_STATUS = ['pending', 'approved', 'rejected', 'executed', 'expired', 'superseded'];
+const MEMORY_KINDS = ['flaky_spec', 'env_quirk', 'convention', 'decision', 'note'];
+function runRow(o) {
+    const id = str(o.id, 200);
+    if (!id)
+        return null;
+    return clean({
+        id,
+        kind: oneOf(o.kind, JOB_KINDS),
+        status: oneOf(o.status, RUN_STATUS),
+        outcome: oneOf(o.outcome, OUTCOMES),
+        title: str(o.title),
+        dotName: str(o.dotName, 120),
+        startedAt: str(o.startedAt, 40),
+        durationMs: num(o.durationMs),
+        passed: num(o.passed),
+        failed: num(o.failed),
+    });
+}
+function pullRow(o) {
+    const n = num(o.number);
+    if (n === undefined || n <= 0 || !Number.isInteger(n))
+        return null;
+    return clean({
+        number: n,
+        title: str(o.title),
+        state: oneOf(o.state, ['open', 'draft', 'merged', 'closed']),
+        author: str(o.author, 120),
+        branch: str(o.branch, 200),
+        url: safeHttpUrl(o.url),
+        checks: oneOf(o.checks, ['passing', 'failing', 'pending', 'none']),
+        lastReport: str(o.lastReport),
+        lastReportRunId: str(o.lastReportRunId, 200),
+        updatedAt: str(o.updatedAt, 40),
+    });
+}
+function defectRow(o) {
+    const key = str(o.key, 60);
+    if (!key)
+        return null;
+    return clean({
+        key,
+        title: str(o.title),
+        severity: oneOf(o.severity, ['low', 'medium', 'high', 'critical']),
+        status: str(o.status, 60),
+        url: safeHttpUrl(o.url),
+        runId: str(o.runId, 200),
+    });
+}
+function probeRow(o) {
+    const name = str(o.name, 120);
+    if (!name)
+        return null;
+    return clean({
+        name,
+        url: safeHttpUrl(o.url),
+        status: oneOf(o.status, ['up', 'down', 'degraded', 'unknown']),
+        httpStatus: num(o.httpStatus),
+        latencyMs: num(o.latencyMs),
+        checkedAt: str(o.checkedAt, 40),
+        error: str(o.error),
+    });
+}
+function memoryRow(o) {
+    const id = str(o.id, 200);
+    const text = str(o.text, MAX_LONG_TEXT);
+    if (!id || !text)
+        return null;
+    return {
+        id,
+        watchId: str(o.watchId, 200) ?? '',
+        kind: oneOf(o.kind, MEMORY_KINDS) ?? 'note',
+        text,
+        source: o.source === 'agent' ? 'agent' : 'user',
+        createdAt: str(o.createdAt, 40) ?? '',
+    };
+}
+function approvalRow(o) {
+    const id = str(o.id, 200);
+    const status = oneOf(o.status, APPROVAL_STATUS);
+    const a = isObj(o.action) ? o.action : null;
+    if (!id || !status || !a || typeof a.kind !== 'string' || typeof a.body !== 'string')
+        return null;
+    // The card reads the full record, so keep it as sent once the fields it relies on check out.
+    return o;
+}
+function testCaseRow(o) {
+    const id = str(o.id, 120);
+    const title = str(o.title) ?? str(o.scenario);
+    if (!id || !title)
+        return null;
+    return clean({
+        id,
+        title,
+        priority: str(o.priority, 40),
+        tested: typeof o.tested === 'boolean' ? o.tested : undefined,
+        result: oneOf(o.result, ['passed', 'failed', 'skipped']),
+        resultSource: oneOf(o.resultSource, ['runner', 'manual']),
+        status: oneOf(o.status, ['draft', 'ready', 'retired']),
+    });
+}
+function ticketReview(v) {
+    if (!isObj(v))
+        return null;
+    const key = str(v.key, 60);
+    if (!key)
+        return null;
+    return clean({
+        key,
+        title: str(v.title),
+        url: safeHttpUrl(v.url),
+        risk: oneOf(v.risk, ['low', 'medium', 'high']),
+        risks: strList(v.risks),
+        testIdeas: strList(v.testIdeas),
+        openQuestions: strList(v.openQuestions),
+        runId: str(v.runId, 200),
+        approvalId: str(v.approvalId, 200),
+    });
+}
+const TILE_TONES = ['ok', 'attention', 'bad'];
+const CHART_TYPES = ['bar', 'stacked_bar', 'line'];
+function statTile(o) {
+    const label = str(o.label, 60);
+    const value = typeof o.value === 'number' && Number.isFinite(o.value) ? String(o.value) : str(o.value, 24);
+    if (!label || !value)
+        return null;
+    return clean({ label, value, sub: str(o.sub, 120), tone: oneOf(o.tone, TILE_TONES) });
+}
+/** Runs a block points at; the client shows each as a titled RefChip. */
+function blockRuns(v) {
+    if (!Array.isArray(v))
+        return undefined;
+    const out = [];
+    for (const r of v) {
+        if (!isObj(r))
+            continue;
+        const runId = str(r.runId, 200);
+        const title = str(r.title, 120);
+        if (runId && title)
+            out.push({ runId, title });
+    }
+    return out.length ? out.slice(0, 6) : undefined;
+}
+/** Series of a chart, cut to the labels it names. Missing and non-numeric values become gaps. */
+function chartSeries(v, count) {
+    if (!Array.isArray(v))
+        return [];
+    const out = [];
+    for (const s of v) {
+        if (!isObj(s) || !Array.isArray(s.values))
+            continue;
+        const name = str(s.name, MAX_CHART_NAME);
+        if (!name)
+            continue;
+        const values = Array.from({ length: count }, (_, i) => num(s.values[i]) ?? null);
+        out.push({ name, values });
+    }
+    return out.slice(0, MAX_CHART_SERIES);
+}
+/** A chart as table rows, for the fallback: one row per label, one column per series. */
+function chartRows(raw) {
+    const labels = Array.isArray(raw.labels) ? raw.labels : [];
+    const series = Array.isArray(raw.series) ? raw.series.filter(isObj) : [];
+    if (!labels.length || !series.length)
+        return undefined;
+    return labels.slice(0, MAX_CHART_LABELS).map((l, i) => {
+        const row = { Label: str(l, 80) ?? '' };
+        for (const s of series.slice(0, MAX_CHART_SERIES))
+            row[str(s.name, MAX_CHART_NAME) ?? 'Value'] = Array.isArray(s.values) ? (num(s.values[i]) ?? null) : null;
+        return row;
+    });
+}
+const TRIAGE_CAUSES = ['review', 'product', 'test', 'environment', 'flaky'];
+function triageRow(o) {
+    const id = str(o.id, 600);
+    const test = str(o.test);
+    const runId = str(o.runId, 200);
+    const cause = oneOf(o.cause, TRIAGE_CAUSES);
+    // A row without its run cannot be acted on, and one without a cause cannot be grouped.
+    if (!id || !test || !runId || !cause)
+        return null;
+    const count = (v) => {
+        const n = num(v);
+        return n !== undefined && n >= 0 ? Math.floor(n) : undefined;
+    };
+    const pr = isObj(o.pr) ? o.pr : null;
+    const prNumber = pr ? num(pr.number) : undefined;
+    return clean({
+        id,
+        test,
+        file: str(o.file, 300),
+        cause,
+        source: o.source === 'review' ? 'review' : undefined,
+        severity: oneOf(o.severity, ['critical', 'high', 'medium', 'low']),
+        bugKey: str(o.bugKey, 100),
+        ref: str(o.ref, 320),
+        last: oneOf(o.last, ['failed', 'flaky', 'passed']),
+        failedRuns: count(o.failedRuns),
+        ofRuns: count(o.ofRuns),
+        runId,
+        runTitle: str(o.runTitle, 200),
+        pr: pr && prNumber !== undefined && prNumber > 0 && Number.isInteger(prNumber)
+            ? clean({ number: prNumber, title: str(pr.title, 200), url: safeHttpUrl(pr.url) })
+            : undefined,
+        dotId: str(o.dotId, 200),
+        error: str(o.error),
+        rerun: o.rerun === true ? true : undefined,
+        flakyMarked: o.flakyMarked === true ? true : undefined,
+        defect: oneOf(o.defect, ['drafted', 'filed', 'rejected']),
+        defectUrl: safeHttpUrl(o.defectUrl),
+    });
+}
+// Object cards (KAT-136 part 3). One validator for the chat block and for the lookup route's answer.
+const CARD_KINDS = ['github_pr', 'github_issue', 'jira', 'linear'];
+const PULL_STATES = ['open', 'draft', 'merged', 'closed'];
+const STATUS_KINDS = ['backlog', 'todo', 'active', 'done', 'canceled'];
+const RISKS = ['low', 'medium', 'high'];
+const PRIORITY_LEVELS = ['urgent', 'high', 'medium', 'low', 'none'];
+const MAX_CARDS = 10;
+const MAX_CARD_DESCRIPTION = 400;
+const MAX_CARD_CHECKS = 12;
+function count(v) {
+    const n = num(v);
+    return n !== undefined && n >= 0 ? Math.floor(n) : undefined;
+}
+function cardLabels(v) {
+    if (!Array.isArray(v))
+        return undefined;
+    const out = [];
+    for (const l of v) {
+        const o = typeof l === 'string' ? { name: l } : isObj(l) ? l : null;
+        const name = o ? str(o.name, 60) : undefined;
+        if (!o || !name)
+            continue;
+        const color = typeof o.color === 'string' && /^#?[0-9a-fA-F]{6}$/.test(o.color.trim()) ? o.color.trim().replace(/^#/, '').toLowerCase() : undefined;
+        out.push(clean({ name, color }));
+    }
+    return out.length ? out.slice(0, 8) : undefined;
+}
+function linkedPulls(v) {
+    if (!Array.isArray(v))
+        return undefined;
+    const out = [];
+    for (const p of v) {
+        if (!isObj(p))
+            continue;
+        const repo = str(p.repo, 200);
+        const number = num(p.number);
+        if (!repo || number === undefined || number <= 0 || !Number.isInteger(number))
+            continue;
+        out.push(clean({ repo, number, title: str(p.title, 200), state: oneOf(p.state, PULL_STATES), url: safeHttpUrl(p.url) }));
+    }
+    return out.length ? out.slice(0, 5) : undefined;
+}
+function ticketReviewOf(v) {
+    if (!isObj(v))
+        return undefined;
+    const runId = str(v.runId, 200);
+    const at = str(v.at, 40);
+    if (!runId || !at)
+        return undefined;
+    return clean({ runId, at, headline: str(v.headline, 300), risk: oneOf(v.risk, RISKS), comment: oneOf(v.comment, ['none', 'waiting', 'posted']) });
+}
+function cardStatus(v) {
+    if (!isObj(v))
+        return null;
+    const name = str(v.name, 60);
+    return name ? { name, kind: oneOf(v.kind, STATUS_KINDS) ?? 'todo' } : null;
+}
+function pullCard(o, base) {
+    const repo = str(o.repo, 200);
+    const number = num(o.number);
+    const state = oneOf(o.state, PULL_STATES);
+    if (!repo || number === undefined || number <= 0 || !Number.isInteger(number) || !state)
+        return null;
+    const c = isObj(o.checks) ? o.checks : null;
+    const checkState = c ? oneOf(c.state, ['passing', 'failing', 'pending', 'none']) : undefined;
+    const checkItems = [];
+    for (const it of c && Array.isArray(c.items) ? c.items : []) {
+        const name = isObj(it) ? str(it.name, 100) : undefined;
+        const state = isObj(it) ? oneOf(it.state, ['passed', 'failed', 'pending']) : undefined;
+        if (name && state)
+            checkItems.push({ name, state });
+    }
+    const r = isObj(o.report) ? o.report : null;
+    const reportRun = r ? str(r.runId, 200) : undefined;
+    const reportHeadline = r ? str(r.headline, 300) : undefined;
+    const reportAt = r ? str(r.at, 40) : undefined;
+    return clean({
+        ...base,
+        kind: 'github_pr',
+        repo,
+        number,
+        state,
+        base: str(o.base, 200),
+        head: str(o.head, 200),
+        author: str(o.author, 120),
+        additions: count(o.additions),
+        deletions: count(o.deletions),
+        files: count(o.files),
+        checks: c && checkState
+            ? clean({
+                state: checkState,
+                passed: count(c.passed) ?? 0,
+                failed: count(c.failed) ?? 0,
+                pending: count(c.pending) ?? 0,
+                items: checkItems.length ? checkItems.slice(0, MAX_CARD_CHECKS) : undefined,
+            })
+            : undefined,
+        review: oneOf(o.review, ['approved', 'changes_requested', 'review_required', 'none']),
+        labels: cardLabels(o.labels),
+        report: reportRun && reportHeadline && reportAt
+            ? clean({ runId: reportRun, headline: reportHeadline, outcome: oneOf(r.outcome, OUTCOMES), risk: oneOf(r.risk, RISKS), at: reportAt })
+            : undefined,
+    });
+}
+function ticketCard(o, kind, base) {
+    const key = str(o.key, 200);
+    const status = cardStatus(o.status);
+    if (!key || !status)
+        return null;
+    const p = isObj(o.priority) ? o.priority : null;
+    const priorityName = p ? str(p.name, 40) : undefined;
+    const number = num(o.number);
+    const desc = str(typeof o.description === 'string' ? o.description.replace(/\s+/g, ' ') : undefined, MAX_CARD_DESCRIPTION);
+    return clean({
+        ...base,
+        kind,
+        key,
+        repo: str(o.repo, 200),
+        number: number !== undefined && number > 0 && Number.isInteger(number) ? number : undefined,
+        issueType: str(o.issueType, 60),
+        status,
+        priority: priorityName ? { name: priorityName, level: oneOf(p.level, PRIORITY_LEVELS) ?? 'none' } : undefined,
+        assignee: str(o.assignee, 120),
+        author: str(o.author, 120),
+        labels: cardLabels(o.labels),
+        description: desc,
+        linkedPulls: linkedPulls(o.linkedPulls),
+        review: ticketReviewOf(o.review),
+    });
+}
+/** Checks one object card. Null when it is not a card the client can draw: no kind, no ref, no title, or the fields its kind needs. */
+export function parseObjectCard(raw) {
+    if (!isObj(raw))
+        return null;
+    const kind = oneOf(raw.kind, CARD_KINDS);
+    const ref = str(raw.ref, 300);
+    const title = str(raw.title, 300);
+    if (!kind || !ref || !title)
+        return null;
+    const base = clean({ ref, title, url: safeHttpUrl(raw.url), dotId: str(raw.dotId, 200), updatedAt: str(raw.updatedAt, 40) });
+    return kind === 'github_pr' ? pullCard(raw, base) : ticketCard(raw, kind, base);
+}
+function rows(raw, fn) {
+    if (!Array.isArray(raw))
+        return null;
+    const valid = [];
+    let dropped = 0;
+    for (const r of raw) {
+        const v = isObj(r) ? fn(r) : null;
+        if (v)
+            valid.push(v);
+        else
+            dropped++;
+    }
+    const extra = Math.max(0, valid.length - MAX_BLOCK_ROWS);
+    return { rows: valid.slice(0, MAX_BLOCK_ROWS), dropped, extra };
+}
+function cell(v) {
+    if (v === null || v === undefined)
+        return null;
+    if (typeof v === 'string')
+        return str(v) ?? '';
+    if (typeof v === 'number')
+        return Number.isFinite(v) ? v : null;
+    if (typeof v === 'boolean')
+        return v;
+    if (Array.isArray(v))
+        return str(v.map((x) => (isObj(x) || Array.isArray(x) ? JSON.stringify(x) : String(x))).join(', ')) ?? '';
+    try {
+        return str(JSON.stringify(v)) ?? '';
+    }
+    catch {
+        return '';
+    }
+}
+/** Builds a table from any list of objects, or from one object as a two-column key and value table. */
+export function toTable(raw, base) {
+    const list = Array.isArray(raw) ? raw.filter(isObj) : isObj(raw) ? null : [];
+    if (list === null) {
+        const entries = Object.entries(raw).filter(([k]) => k !== 'id' && k !== 'kind');
+        if (!entries.length)
+            return null;
+        return { ...base, kind: 'table', columns: ['Field', 'Value'], rows: entries.slice(0, MAX_BLOCK_ROWS).map(([k, v]) => ({ Field: k, Value: cell(v) })) };
+    }
+    if (!list.length)
+        return null;
+    const columns = [];
+    for (const r of list)
+        for (const k of Object.keys(r))
+            if (!columns.includes(k) && columns.length < MAX_TABLE_COLUMNS)
+                columns.push(k);
+    if (!columns.length)
+        return null;
+    const out = list.slice(0, MAX_BLOCK_ROWS).map((r) => Object.fromEntries(columns.map((c) => [c, cell(r[c])])));
+    const extra = list.length - out.length;
+    return { ...base, kind: 'table', columns, rows: out, ...(extra > 0 ? { more: (base.more ?? 0) + extra } : {}) };
+}
+const RELEASE_ANSWERS = ['ready', 'ready_with_risk', 'not_ready', 'no_tickets'];
+/** A link a release reason may carry: an http or https address, or an app link such as `#/inbox`. Anything else is dropped. */
+function releaseHref(v) {
+    const s = str(v, 600);
+    if (!s)
+        return undefined;
+    return /^#\/[\w\-./%?=&#:@]*$/.test(s) ? s : safeHttpUrl(s);
+}
+/** The release call of a lead as a block carries it (KAT-405). Strings are cut, links are checked, counts are whole numbers. */
+function releaseCall(v) {
+    if (!isObj(v))
+        return null;
+    const answer = oneOf(v.answer, RELEASE_ANSWERS);
+    if (!answer)
+        return null;
+    const count = (x) => {
+        const n = num(x);
+        return n !== undefined && n >= 0 ? Math.floor(n) : 0;
+    };
+    const c = isObj(v.counts) ? v.counts : {};
+    const reasons = (Array.isArray(v.reasons) ? v.reasons : [])
+        .filter(isObj)
+        .map((r) => {
+        const text = str(r.text, 400);
+        const level = oneOf(r.level, ['blocker', 'risk']);
+        if (!text || !level)
+            return null;
+        return clean({
+            level,
+            text,
+            ref: str(r.ref, 200),
+            href: releaseHref(r.href),
+            memberId: str(r.memberId, 200) ?? '',
+            memberName: str(r.memberName, 120),
+            openLabel: oneOf(r.openLabel, ['See them', 'Review']),
+        });
+    })
+        .filter((r) => !!r)
+        .slice(0, MAX_BLOCK_ROWS);
+    return {
+        milestone: str(v.milestone, 120) ?? '',
+        answer,
+        summary: str(v.summary, 400) ?? '',
+        counts: {
+            total: count(c.total),
+            passing: count(c.passing),
+            failing: count(c.failing),
+            notTested: count(c.notTested),
+            partlyTested: count(c.partlyTested),
+            outOfDate: count(c.outOfDate),
+        },
+        reasons,
+        milestones: strList(v.milestones, 40) ?? [],
+        rule: str(v.rule, 400) ?? '',
+        builtAt: str(v.builtAt, 40) ?? '',
+    };
+}
+/** The first array of objects on a block that is not one we understand. */
+function firstRows(o) {
+    for (const k of ['rows', 'items', 'data', 'results'])
+        if (Array.isArray(o[k]))
+            return o[k];
+    for (const v of Object.values(o))
+        if (Array.isArray(v) && v.some(isObj))
+            return v;
+    if (isObj(o.data))
+        return o.data;
+    // No rows: show the block's own fields as a key and value table.
+    const rest = Object.fromEntries(Object.entries(o).filter(([k]) => !BASE_KEYS.has(k)));
+    return Object.keys(rest).length ? rest : undefined;
+}
+const BASE_KEYS = new Set(['id', 'v', 'kind', 'title', 'dotId', 'state', 'more', 'tool']);
+/**
+ * Validates one block. `fallbackId` names a block that arrived without an id (the transcript passes
+ * a local id), so a model that forgets ids still renders.
+ */
+export function parseChatBlock(raw, fallbackId) {
+    if (!isObj(raw))
+        return { ok: false, reason: 'block is not an object' };
+    const id = str(raw.id, 200) ?? fallbackId;
+    if (!id)
+        return { ok: false, reason: 'block has no id' };
+    const more = num(raw.more);
+    const base = clean({
+        id,
+        v: 1,
+        title: str(raw.title, 160),
+        dotId: str(raw.dotId, 200),
+        state: oneOf(raw.state, ['loading', 'ready']),
+        more: more !== undefined && more > 0 ? Math.floor(more) : undefined,
+        tool: str(raw.tool, 200),
+    });
+    const kind = typeof raw.kind === 'string' ? raw.kind : '';
+    const withMore = (b, extra) => (extra > 0 ? { ...b, more: (b.more ?? 0) + extra } : b);
+    const list = (key, fn, make) => {
+        const r = rows(raw[key], fn);
+        if (!r) {
+            // A loading block may arrive before its rows.
+            if (base.state === 'loading')
+                return { ok: true, block: make([]), dropped: 0, fallback: false };
+            return toFallback(`${kind} block has no ${key} list`);
+        }
+        if (!r.rows.length && r.dropped > 0)
+            return toFallback(`no valid ${key}`, raw[key]);
+        return { ok: true, block: withMore(make(r.rows), r.extra), dropped: r.dropped, fallback: false };
+    };
+    const toFallback = (reason, data = firstRows(raw)) => {
+        const t = toTable(data, base);
+        return t ? { ok: true, block: t, dropped: 0, fallback: true } : { ok: false, reason };
+    };
+    switch (kind) {
+        case 'runs':
+            return list('runs', runRow, (runs) => ({ ...base, kind: 'runs', runs }));
+        case 'pulls':
+            return list('pulls', pullRow, (pulls) => ({ ...base, kind: 'pulls', ...(str(raw.repo, 200) ? { repo: str(raw.repo, 200) } : {}), pulls }));
+        case 'approvals':
+            return list('approvals', approvalRow, (approvals) => ({ ...base, kind: 'approvals', approvals }));
+        case 'defects':
+            return list('defects', defectRow, (defects) => ({ ...base, kind: 'defects', defects }));
+        case 'probes':
+            return list('probes', probeRow, (probes) => ({ ...base, kind: 'probes', probes }));
+        case 'memory':
+            return list('items', memoryRow, (items) => ({ ...base, kind: 'memory', items }));
+        case 'test_cases':
+            return list('cases', testCaseRow, (cases) => ({ ...base, kind: 'test_cases', ...(str(raw.runId, 200) ? { runId: str(raw.runId, 200) } : {}), cases }));
+        case 'triage': {
+            const checked = num(raw.runsChecked);
+            const runsChecked = checked !== undefined && checked >= 0 ? Math.floor(checked) : undefined;
+            const window = oneOf(raw.window, ['last_merge', 'today', 'recent']);
+            const sinceRaw = str(raw.since, 40);
+            const since = sinceRaw && !Number.isNaN(Date.parse(sinceRaw)) ? sinceRaw : undefined;
+            const mb = num(raw.moreBugs);
+            const moreBugs = mb !== undefined && mb > 0 ? Math.floor(mb) : undefined;
+            return list('rows', triageRow, (rows) => ({
+                ...base,
+                kind: 'triage',
+                ...(moreBugs ? { moreBugs } : {}),
+                ...(runsChecked !== undefined ? { runsChecked } : {}),
+                ...(window ? { window } : {}),
+                ...(since ? { since } : {}),
+                rows,
+            }));
+        }
+        case 'cards': {
+            const r = rows(raw.cards, parseObjectCard);
+            if (!r) {
+                if (base.state === 'loading')
+                    return { ok: true, block: { ...base, kind: 'cards', cards: [] }, dropped: 0, fallback: false };
+                return toFallback('cards block has no cards list');
+            }
+            const cards = r.rows.slice(0, MAX_CARDS);
+            if (!cards.length && r.dropped > 0)
+                return toFallback('no valid cards', raw.cards);
+            return { ok: true, block: withMore({ ...base, kind: 'cards', cards }, r.rows.length - cards.length + r.extra), dropped: r.dropped, fallback: false };
+        }
+        case 'release_call': {
+            const call = releaseCall(raw.call);
+            if (call)
+                return { ok: true, block: { ...base, kind: 'release_call', call }, dropped: 0, fallback: false };
+            return toFallback('release_call block has no call with an answer', raw.call);
+        }
+        case 'ticket_review': {
+            const review = ticketReview(raw.review);
+            if (review)
+                return { ok: true, block: { ...base, kind: 'ticket_review', review }, dropped: 0, fallback: false };
+            return toFallback('ticket_review block has no review with a key', raw.review);
+        }
+        case 'table': {
+            const t = toTable(raw.rows, base);
+            if (!t)
+                return { ok: false, reason: 'table block has no rows' };
+            const cols = strList(raw.columns, MAX_TABLE_COLUMNS);
+            // Keep the author's column order when it names columns the rows have.
+            if (Array.isArray(raw.rows) && cols && cols.every((c) => t.rows.some((r) => c in r))) {
+                const rowsIn = raw.rows.filter(isObj).slice(0, MAX_BLOCK_ROWS);
+                return {
+                    ok: true,
+                    block: { ...t, columns: cols, rows: rowsIn.map((r) => Object.fromEntries(cols.map((c) => [c, cell(r[c])]))) },
+                    dropped: 0,
+                    fallback: false,
+                };
+            }
+            return { ok: true, block: t, dropped: 0, fallback: false };
+        }
+        case 'stats': {
+            const extra = { ...(blockRuns(raw.runs) ? { runs: blockRuns(raw.runs) } : {}), ...(str(raw.runsLabel, 60) ? { runsLabel: str(raw.runsLabel, 60) } : {}) };
+            const r = rows(raw.tiles, statTile);
+            if (!r) {
+                if (base.state === 'loading')
+                    return { ok: true, block: { ...base, kind: 'stats', tiles: [] }, dropped: 0, fallback: false };
+                return toFallback('stats block has no tiles list');
+            }
+            const tiles = r.rows.slice(0, MAX_STAT_TILES);
+            if (!tiles.length)
+                return toFallback('no valid tiles', raw.tiles);
+            return { ok: true, block: { ...base, kind: 'stats', tiles, ...extra }, dropped: r.dropped + (r.rows.length - tiles.length), fallback: false };
+        }
+        case 'chart': {
+            const chartType = oneOf(raw.chartType, CHART_TYPES);
+            const labels = (Array.isArray(raw.labels) ? raw.labels : []).slice(0, MAX_CHART_LABELS).map((l) => str(l, 80) ?? '');
+            const series = chartSeries(raw.series, labels.length);
+            if (!chartType || !labels.length || !series.length) {
+                if (base.state === 'loading')
+                    return { ok: true, block: { ...base, kind: 'chart', chartType: chartType ?? 'bar', labels: [], series: [] }, dropped: 0, fallback: false };
+                return toFallback(!chartType ? 'chart block has no valid chartType' : 'chart block has no labels or series', chartRows(raw) ?? null);
+            }
+            const block = clean({
+                ...base,
+                kind: 'chart',
+                chartType,
+                labels,
+                series,
+                unit: str(raw.unit, 12),
+                // A run of whitespace is one space, except a no-break space, which keeps a number and its unit on one line.
+                finding: str(typeof raw.finding === 'string' ? raw.finding.replace(/[^\S\u00a0]+/g, ' ') : undefined, MAX_FINDING),
+                runs: blockRuns(raw.runs),
+                runsLabel: str(raw.runsLabel, 60),
+            });
+            return { ok: true, block, dropped: 0, fallback: false };
+        }
+        case 'view':
+            return parseViewBlock(raw, base);
+        default:
+            return toFallback(kind ? `unknown block kind ${kind}` : 'block has no kind');
+    }
+}
+/** The block of a node in a bound view: it must pass parseChatBlock as it is, never through the table fallback. */
+export function parseEmbeddedBlock(raw) {
+    const r = parseChatBlock(raw);
+    return r.ok && !r.fallback ? r.block : null;
+}
+/**
+ * A composed view (KAT-366). The view is checked by parseViewTree with the same rules as any block. A view that fails falls back
+ * to the blocks it contains in a plain column, and when it holds none the block is refused and the answer stays text.
+ */
+function parseViewBlock(raw, base) {
+    const parsed = isObj(raw.view)
+        ? parseViewTree(raw.view, { bound: true, parseBlock: parseEmbeddedBlock })
+        : base.state === 'loading'
+            ? parseViewTree({ root: { type: 'column', children: [] } }, { bound: true, parseBlock: parseEmbeddedBlock })
+            : { ok: false, reason: 'view block has no view', notes: [] };
+    if (parsed.ok)
+        return { ok: true, block: { ...base, kind: 'view', view: parsed.view }, dropped: parsed.notes.length, fallback: false };
+    const blocks = rawNodes(raw.view)
+        .map((n) => parseEmbeddedBlock(n.block))
+        .filter((b) => b !== null && b.kind !== 'view');
+    if (!blocks.length)
+        return { ok: false, reason: parsed.reason };
+    const children = blocks.map((b) => ({ type: b.kind, block: b }));
+    return { ok: true, block: { ...base, kind: 'view', view: { v: 1, root: { type: 'column', children } } }, dropped: 0, fallback: true };
+}
+//# sourceMappingURL=chat-blocks.js.map