tinybeeai 0.0.0-stage → 0.16.1

package/dist/test-runs.js

@@ -0,0 +1,662 @@
+// Test runs (docs/DATA-MODEL.md section 2.3). A test run is a planned pass over a set of cases, not a dot run.
+// A person creates a manual test run from a suite, a selection, or a plan (one test run per plan configuration), and
+// works its run items one by one: each result is an attempt with step results, the newest attempt sets the item's
+// state, and a retest opens the next attempt. A dot run that reports results for cases fills its own automated test
+// run, one per Playwright project, linked by dotRunId; those are read only. Routes: src/routes/test-runs.ts.
+import { CASE_RESULTS, CaseInputError, ensureVersion, isObj, oneOf, ownsSpec, text, caseVersion, refs } from './cases.js';
+import { db, get, insert, list, update } from './db.js';
+import { teamIds } from './lead.js';
+import { needsReviewFlags } from './impact/store.js';
+import { resultAdded, testRunStarted, testRunStatusChanged } from './true/events.js';
+import { caseIdsOf, configLabel, configOf, getPlan, getSuite, readPlan, readSuite } from './suites.js';
+export const TEST_RUN_STATUSES = ['open', 'in_progress', 'done', 'cancelled'];
+export const TEST_RUN_SOURCES = ['manual', 'automated'];
+export const RUN_ITEM_STATES = ['untested', 'passed', 'failed', 'blocked', 'retest', 'skipped'];
+const MAX_NAME = 200;
+const MAX_NOTES = 4000;
+const MAX_ACTUAL = 4000;
+const MAX_DEFECTS = 20;
+const MAX_EVIDENCE = 50;
+const SHA = /^[0-9a-f]{7,40}$/i;
+const now = () => new Date().toISOString();
+// ---------- reads ----------
+export function getTestRun(dotId, id) {
+    const t = get('test_runs', id);
+    return t && t.dotId === dotId ? t : undefined;
+}
+export function getRunItem(testRun, id) {
+    const i = get('run_items', id);
+    return i && i.testRunId === testRun.id ? i : undefined;
+}
+const emptyProgress = () => ({ total: 0, untested: 0, passed: 0, failed: 0, blocked: 0, retest: 0, skipped: 0 });
+function progressOf(ids) {
+    const out = new Map();
+    if (!ids.length)
+        return out;
+    const rows = db
+        .prepare(`SELECT testRunId, state, COUNT(*) AS n FROM run_items WHERE testRunId IN (${ids.map(() => '?').join(', ')}) GROUP BY testRunId, state`)
+        .all(...ids);
+    for (const r of rows) {
+        const p = out.get(r.testRunId) ?? emptyProgress();
+        const n = Number(r.n);
+        if (RUN_ITEM_STATES.includes(r.state))
+            p[r.state] += n;
+        p.total += n;
+        out.set(r.testRunId, p);
+    }
+    return out;
+}
+function viewsOf(runs) {
+    const progress = progressOf(runs.map((r) => r.id));
+    const names = new Map();
+    const nameOf = (table, id) => {
+        if (!id)
+            return undefined;
+        const k = `${table}:${id}`;
+        if (!names.has(k))
+            names.set(k, get(table, id)?.name);
+        return names.get(k);
+    };
+    return runs.map((r) => {
+        const planName = nameOf('plans', r.planId);
+        const suiteName = nameOf('suites', r.suiteId);
+        return { ...r, progress: progress.get(r.id) ?? emptyProgress(), ...(planName ? { planName } : {}), ...(suiteName ? { suiteName } : {}) };
+    });
+}
+/** Test runs of a dot, newest first. Throws CaseInputError for an unknown filter value. */
+export function listTestRuns(w, f = {}) {
+    const status = oneOf(f.status, TEST_RUN_STATUSES, 'Status');
+    const source = oneOf(f.source, TEST_RUN_SOURCES, 'Source');
+    const limit = Math.max(1, Math.min(500, Math.floor(f.limit ?? 100)));
+    return viewsOf(list('test_runs', { dotId: w.id, status, source }, { orderBy: 'id DESC', limit }));
+}
+export function testRunView(t) {
+    return viewsOf([t])[0];
+}
+/** The newest result of each item of a test run. */
+function latestOfItems(testRunId) {
+    const out = new Map();
+    for (const r of list('case_results', { testRunId }, { orderBy: 'at ASC, id ASC' }))
+        if (r.runItemId)
+            out.set(r.runItemId, r);
+    return out;
+}
+function itemView(item, c, latest, flags) {
+    const v = caseVersion(item.caseId, item.caseVersion)?.snapshot;
+    const src = v ?? c;
+    return {
+        ...item,
+        attempt: item.attempt ?? 1,
+        key: c?.key ?? '?',
+        title: src?.title ?? 'Deleted case',
+        kind: src?.kind ?? 'manual',
+        steps: src?.steps ?? [],
+        ...(src?.specPath ? { specPath: src.specPath } : {}),
+        latest: latest ?? null,
+        // A ticket review proposed a change to this case, or its retirement, and a person has not decided (KAT-304).
+        ...(flags?.get(item.caseId) ? { needsReview: flags.get(item.caseId) } : {}),
+    };
+}
+export function testRunDetail(t) {
+    const items = list('run_items', { testRunId: t.id }, { orderBy: 'position ASC, id ASC' });
+    const cases = new Map(list('test_cases', { id: [...new Set(items.map((i) => i.caseId))] }).map((c) => [c.id, c]));
+    const latest = latestOfItems(t.id);
+    const flags = needsReviewFlags(t.dotId);
+    return { ...testRunView(t), items: items.map((i) => itemView(i, cases.get(i.caseId), latest.get(i.id), flags)) };
+}
+export function runItemDetail(item) {
+    const c = get('test_cases', item.caseId);
+    const results = list('case_results', { runItemId: item.id }, { orderBy: 'at DESC, id DESC' });
+    return { ...itemView(item, c, results[0], needsReviewFlags(item.dotId)), results, newerVersion: !!c && (c.revision ?? 1) > item.caseVersion };
+}
+// ---------- create and update ----------
+function readSha(v) {
+    const s = text(v, 'Build', 40);
+    if (!s)
+        return undefined;
+    if (!SHA.test(s))
+        throw new CaseInputError('Build must be a commit sha: 7 to 40 hex characters.');
+    return s.toLowerCase();
+}
+function addItems(testRun, caseIds) {
+    const at = now();
+    caseIds.forEach((id, i) => {
+        const c = get('test_cases', id);
+        if (!c)
+            return;
+        insert('run_items', {
+            testRunId: testRun.id,
+            dotId: testRun.dotId,
+            caseId: c.id,
+            caseVersion: ensureVersion(c),
+            position: i + 1,
+            state: 'untested',
+            attempt: 1,
+            updatedAt: at,
+            createdAt: at,
+        });
+    });
+}
+/** In one transaction, so a failed insert leaves no half test run. */
+function inTx(fn) {
+    db.exec('SAVEPOINT test_runs_tx');
+    try {
+        const out = fn();
+        db.exec('RELEASE test_runs_tx');
+        return out;
+    }
+    catch (err) {
+        db.exec('ROLLBACK TO test_runs_tx');
+        db.exec('RELEASE test_runs_tx');
+        throw err;
+    }
+}
+/**
+ * Creates manual test runs from exactly one of: `suiteId`, `caseIds` (a selection), or `planId`. A plan makes one
+ * test run per configuration. Returns the test runs it made.
+ */
+export function createTestRuns(w, body) {
+    return startTestRuns(w, body).runs;
+}
+/** As createTestRuns, plus a note for each suite or plan reference that was gone and left out. */
+export function startTestRuns(w, body) {
+    if (!isObj(body))
+        throw new CaseInputError('Send the test run as a JSON object.');
+    const sources = ['suiteId', 'caseIds', 'planId'].filter((k) => body[k] !== undefined && body[k] !== null && body[k] !== '');
+    if (sources.length !== 1)
+        throw new CaseInputError('Start a test run from one of: a suite, a selection of cases, or a plan.');
+    const environment = text(body.environment, 'Environment', 80);
+    const assignee = text(body.assignee, 'Assignee', 80);
+    const buildSha = readSha(body.buildSha);
+    const config = configOf(body.config);
+    let givenName = text(body.name, 'Name', MAX_NAME);
+    let caseIds;
+    let configs = [config];
+    let base = {};
+    let label;
+    let notes = [];
+    if (sources[0] === 'suiteId') {
+        const s = typeof body.suiteId === 'string' ? getSuite(w.id, body.suiteId) : undefined;
+        if (!s)
+            throw new CaseInputError('That suite does not belong to this dot.');
+        const r = readSuite(w, s);
+        caseIds = r.cases.map((c) => c.id);
+        notes = r.notes;
+        base = { suiteId: s.id };
+        label = s.name;
+    }
+    else if (sources[0] === 'planId') {
+        const p = typeof body.planId === 'string' ? getPlan(w.id, body.planId) : undefined;
+        if (!p)
+            throw new CaseInputError('That plan does not belong to this dot.');
+        const r = readPlan(w, p);
+        caseIds = r.caseIds;
+        notes = r.notes;
+        if (!config && p.configs?.length)
+            configs = p.configs;
+        base = { planId: p.id, ...(p.environment && !environment ? { environment: p.environment } : {}) };
+        label = p.name;
+    }
+    else {
+        caseIds = caseIdsOf(w.id, body.caseIds);
+        label = `Test run ${new Date().toISOString().slice(0, 10)}`;
+    }
+    if (!caseIds.length)
+        throw new CaseInputError(`No draft or ready cases to run. Add cases first.${notes.length ? ` ${notes.join(' ')}` : ''}`);
+    givenName ??= label;
+    const runs = inTx(() => configs.map((cfg) => {
+        const at = now();
+        const suffix = configs.length > 1 && cfg ? ` (${configLabel(cfg)})` : '';
+        const t = insert('test_runs', {
+            dotId: w.id,
+            name: `${givenName}${suffix}`.slice(0, MAX_NAME),
+            source: 'manual',
+            status: 'open',
+            ...base,
+            ...(environment ? { environment } : {}),
+            ...(cfg ? { config: cfg } : {}),
+            ...(buildSha ? { buildSha } : {}),
+            ...(assignee ? { assignee } : {}),
+            createdAt: at,
+            updatedAt: at,
+        });
+        addItems(t, caseIds);
+        return t;
+    }));
+    // After the transaction: True Platform hears about each manual test run once its items are stored (KAT-406).
+    for (const t of runs)
+        testRunStarted(t);
+    return { runs, notes };
+}
+function readOnly(t) {
+    if (t.source === 'automated')
+        throw new CaseInputError('This test run is automated. Its results come from its dot run, so it is read only.');
+}
+/** Edits a manual test run: status, name, environment, configuration, build, assignee. */
+export function updateTestRun(t, body) {
+    readOnly(t);
+    if (!isObj(body))
+        throw new CaseInputError('Send the change as a JSON object.');
+    const patch = { updatedAt: now() };
+    const status = oneOf(body.status, TEST_RUN_STATUSES, 'Status');
+    if (status && status !== t.status) {
+        patch.status = status;
+        if (status === 'done' || status === 'cancelled')
+            patch.finishedAt = now();
+        else
+            patch.finishedAt = null;
+        if (status === 'in_progress' && !t.startedAt)
+            patch.startedAt = now();
+    }
+    if (body.name !== undefined) {
+        const n = text(body.name, 'Name', MAX_NAME);
+        if (!n)
+            throw new CaseInputError('A test run needs a name.');
+        patch.name = n;
+    }
+    if (body.environment !== undefined)
+        patch.environment = text(body.environment, 'Environment', 80) || null;
+    if (body.assignee !== undefined)
+        patch.assignee = text(body.assignee, 'Assignee', 80) || null;
+    if (body.buildSha !== undefined)
+        patch.buildSha = readSha(body.buildSha) ?? null;
+    if (body.config !== undefined)
+        patch.config = configOf(body.config) ?? null;
+    update('test_runs', t.id, patch);
+    const saved = get('test_runs', t.id);
+    if (status && status !== t.status)
+        testRunStatusChanged(saved, t.status, status);
+    return saved;
+}
+/** Sets the assignee of a run item. */
+export function updateRunItem(t, item, body) {
+    readOnly(t);
+    if (!isObj(body))
+        throw new CaseInputError('Send the change as a JSON object.');
+    if (body.assignee === undefined)
+        throw new CaseInputError('Nothing to change. Send an assignee.');
+    update('run_items', item.id, { assignee: text(body.assignee, 'Assignee', 80) || null, updatedAt: now() });
+    return get('run_items', item.id);
+}
+// ---------- manual results ----------
+function writable(t) {
+    readOnly(t);
+    if (t.status === 'done' || t.status === 'cancelled')
+        throw new CaseInputError('This test run is closed. Reopen it to add results.');
+}
+function stepResults(v, stepCount) {
+    if (v === undefined || v === null)
+        return [];
+    if (!Array.isArray(v))
+        throw new CaseInputError('Step results must be a list.');
+    const seen = new Set();
+    const out = [];
+    for (const raw of v) {
+        if (!isObj(raw))
+            throw new CaseInputError('Each step result needs an index and a result.');
+        const index = raw.index;
+        if (typeof index !== 'number' || !Number.isInteger(index) || index < 0 || index >= stepCount)
+            throw new CaseInputError(stepCount ? `Step index must be from 0 to ${stepCount - 1}.` : 'This case has no steps.');
+        if (seen.has(index))
+            throw new CaseInputError(`Step ${index + 1} has two results.`);
+        seen.add(index);
+        const result = oneOf(raw.result, CASE_RESULTS, `Result of step ${index + 1}`);
+        if (!result)
+            throw new CaseInputError(`Step ${index + 1} needs a result.`);
+        const actual = text(raw.actual, `Actual result of step ${index + 1}`, MAX_ACTUAL);
+        out.push({ index, result, ...(actual ? { actual } : {}) });
+    }
+    return out.sort((a, b) => a.index - b.index);
+}
+function defectsOf(v, stepCount) {
+    if (v === undefined || v === null)
+        return [];
+    if (!Array.isArray(v))
+        throw new CaseInputError('Defects must be a list.');
+    if (v.length > MAX_DEFECTS)
+        throw new CaseInputError(`A result links at most ${MAX_DEFECTS} defects.`);
+    return v.map((raw) => {
+        const o = typeof raw === 'string' ? { ref: raw } : isObj(raw) ? raw : {};
+        const ref = refs([o.ref])?.[0];
+        if (!ref)
+            throw new CaseInputError('Each defect needs a key such as SHOP-12, or owner/name#12.');
+        if (o.stepIndex === undefined || o.stepIndex === null)
+            return { ref };
+        const i = o.stepIndex;
+        if (typeof i !== 'number' || !Number.isInteger(i) || i < 0 || i >= stepCount)
+            throw new CaseInputError(`Defect ${ref} names a step the case does not have.`);
+        return { ref, stepIndex: i };
+    });
+}
+/** A person's result on a run item: the next row of the item's current attempt. */
+export function addRunResult(t, item, body, actor) {
+    writable(t);
+    if (!isObj(body))
+        throw new CaseInputError('Send the result as a JSON object.');
+    const result = oneOf(body.result, CASE_RESULTS, 'Result');
+    if (!result)
+        throw new CaseInputError(`Result must be one of: ${CASE_RESULTS.join(', ')}.`);
+    // The case may belong to another member of the run's team (a case Ticket Reviewer designed, in a merge run of Regression Runner,
+    // KAT-405). The result is written on the case, under the dot that owns it.
+    const owner = get('test_cases', item.caseId);
+    if (owner && owner.dotId !== t.dotId && !teamIds(t.dotId).includes(owner.dotId))
+        throw new CaseInputError('That case belongs to a dot outside this team.');
+    const stepCount = itemView(item, undefined, undefined).steps.length;
+    const steps = stepResults(body.steps, stepCount);
+    const failedStep = steps.find((s) => s.result === 'failed');
+    if (result === 'passed' && failedStep)
+        throw new CaseInputError(`A result cannot pass when step ${failedStep.index + 1} failed.`);
+    const notes = text(body.notes, 'Notes', MAX_NOTES);
+    const defects = defectsOf(body.defects, stepCount);
+    let durationMs;
+    if (body.durationMs !== undefined) {
+        if (typeof body.durationMs !== 'number' || !Number.isFinite(body.durationMs) || body.durationMs < 0 || body.durationMs > 864e5)
+            throw new CaseInputError('Duration must be a number of milliseconds, at most one day.');
+        durationMs = Math.round(body.durationMs);
+    }
+    const executedBy = text(body.executedBy, 'Executed by', 80) || actor;
+    const at = now();
+    const saved = inTx(() => {
+        const row = insert('case_results', {
+            caseId: item.caseId,
+            dotId: owner?.dotId ?? t.dotId,
+            result,
+            ...(notes ? { notes } : {}),
+            evidence: [],
+            source: 'manual',
+            runItemId: item.id,
+            testRunId: t.id,
+            attempt: item.attempt ?? 1,
+            engine: 'manual',
+            ...(durationMs !== undefined ? { durationMs } : {}),
+            ...(t.buildSha ? { sha: t.buildSha } : {}),
+            ...(t.environment ? { environment: t.environment } : {}),
+            ...(t.config ? { config: t.config } : {}),
+            ...(executedBy ? { executedBy } : {}),
+            steps,
+            defects,
+            at,
+            createdAt: at,
+        });
+        update('run_items', item.id, { state: result, updatedAt: at });
+        if (t.status === 'open')
+            update('test_runs', t.id, { status: 'in_progress', startedAt: t.startedAt ?? at, updatedAt: at });
+        else
+            update('test_runs', t.id, { updatedAt: at });
+        return row;
+    });
+    resultAdded(get('test_runs', t.id) ?? t, item, saved);
+    return saved;
+}
+/** Opens the next attempt of a run item. Its earlier results stay; the item shows Retest until a new result. */
+export function retestItem(t, item) {
+    writable(t);
+    if (item.state === 'untested' || item.state === 'retest')
+        throw new CaseInputError('This item has no result to retest yet.');
+    const at = now();
+    update('run_items', item.id, { state: 'retest', attempt: (item.attempt ?? 1) + 1, updatedAt: at });
+    if (t.status === 'open')
+        update('test_runs', t.id, { status: 'in_progress', startedAt: t.startedAt ?? at, updatedAt: at });
+    return get('run_items', item.id);
+}
+// ---------- automated test runs from dot runs ----------
+const ANSI = /\u001b\[[0-9;]*m/g;
+const plural = (n, one) => `${n} ${one}${n === 1 ? '' : 's'}`;
+const PROJECT = /^\[([^\]]{1,80})\] /;
+/** The Playwright project of a test, from the `[project] ` title prefix the report reader adds when there are several. */
+export function projectOf(t) {
+    return PROJECT.exec(t.title)?.[1] ?? '';
+}
+function shaOf(run) {
+    const tr = run.trigger;
+    const sha = tr?.pr?.mergeSha ?? tr?.push?.after ?? tr?.pr?.headSha ?? tr?.ci?.headSha;
+    return sha && SHA.test(sha) ? sha.toLowerCase() : undefined;
+}
+function environmentOf(report) {
+    if (!report.baseUrl)
+        return report.mode === 'demo' ? 'Sample shop' : undefined;
+    try {
+        return new URL(report.baseUrl).host;
+    }
+    catch {
+        return undefined;
+    }
+}
+function automatedName(run, project) {
+    const head = run.trigger?.title?.trim() || 'Dot run';
+    return (project ? `${head} (${project})` : head).slice(0, MAX_NAME);
+}
+/** The automated test run of a dot run and project, made when missing. */
+function automatedRun(run, project, report) {
+    const found = list('test_runs', { dotRunId: run.id, configKey: project }, { limit: 1 })[0];
+    const at = now();
+    const fields = {
+        status: 'done',
+        finishedAt: at,
+        ...(environmentOf(report) ? { environment: environmentOf(report) } : {}),
+        ...(shaOf(run) ? { buildSha: shaOf(run) } : {}),
+    };
+    if (found) {
+        update('test_runs', found.id, { ...fields, updatedAt: at });
+        return get('test_runs', found.id);
+    }
+    return insert('test_runs', {
+        dotId: run.watchId,
+        name: automatedName(run, project),
+        source: 'automated',
+        ...fields,
+        ...(project ? { config: { project } } : {}),
+        dotRunId: run.id,
+        configKey: project,
+        startedAt: run.createdAt ?? report.startedAt ?? at,
+        createdAt: at,
+        updatedAt: at,
+    });
+}
+function engineOf(c, hits = []) {
+    if (hits.length && hits.every((t) => t.file.startsWith('aivision/')))
+        return 'aivision';
+    return c.kind === 'aivision' ? 'aivision' : 'playwright';
+}
+/** The report file an AI-Vision run of a designed case writes (src/runner/aivision/cases.ts caseResultFile). */
+const aivisionFileOf = (c) => `aivision/${c.id}.yaml`;
+/** One case's result from the tests of one project that ran its spec. */
+function summarize(hits) {
+    const failed = hits.filter((t) => t.status === 'failed' || t.status === 'timedOut');
+    const skipped = hits.filter((t) => t.status === 'skipped');
+    const flaky = hits.filter((t) => t.status === 'flaky');
+    const result = failed.length ? 'failed' : skipped.length === hits.length ? 'skipped' : 'passed';
+    const counts = [
+        hits.length - failed.length - skipped.length ? `${hits.length - failed.length - skipped.length} passed` : '',
+        failed.length ? `${failed.length} failed` : '',
+        skipped.length ? `${skipped.length} skipped` : '',
+    ]
+        .filter(Boolean)
+        .join(', ');
+    let notes = `${plural(hits.length, 'test')} in ${hits[0].file}: ${counts}.`;
+    if (flaky.length)
+        notes += ` ${plural(flaky.length, 'test')} passed on a retry.`;
+    const err = failed.find((t) => t.error)?.error;
+    if (err)
+        notes += ` ${failed[0].title.replace(PROJECT, '')}: ${err.replace(ANSI, '').split('\n')[0].trim().slice(0, 300)}`;
+    const evidence = [
+        ...new Set(hits.flatMap((t) => [...(t.evidence?.screenshots ?? []).map((s) => s.name), t.evidence?.video, t.evidence?.trace].filter((x) => !!x))),
+    ].slice(0, MAX_EVIDENCE);
+    return { result, notes, evidence, durationMs: hits.reduce((n, t) => n + (t.durationMs || 0), 0) };
+}
+/**
+ * True when the case owns the reported file. A report path cut at Playwright's testDir ("coupon.spec.ts") matches
+ * every case whose spec ends with it; when more than one spec path matches and none is exactly the file, the owner
+ * is unknown and nobody gets the result (KAT-278).
+ */
+function ownsFile(c, file, all) {
+    return ownsSpec(c.specPath, file, all.map((o) => o.specPath));
+}
+/**
+ * The cases that own a reported test: the case whose AI-Vision file it is, or whose spec it is when no other spec ends with the same path.
+ * linkRunResults uses the same rule to write results; the True Platform sync names a test after its owner (KAT-406).
+ */
+export function casesOwning(test, cases) {
+    const live = cases.filter((c) => c.status !== 'retired');
+    const specCases = live.filter((c) => !!c.specPath);
+    return live.filter((c) => test.file === aivisionFileOf(c) || (!!c.specPath && ownsFile(c, test.file, specCases)));
+}
+/**
+ * Writes the results of a dot run's report into its automated test runs: one per Playwright project, with one run
+ * item per case whose spec ran. Called each time the dot run saves its report, so a retry pass updates the rows the
+ * first save wrote instead of adding more. Retired cases get no results. Returns the number of results written.
+ */
+export function linkRunResults(run, report) {
+    const tests = report?.cases ?? [];
+    if (!report || !tests.length)
+        return 0;
+    // The team's cases (KAT-405): the run's own dot first, so a spec that two members hold maps to the run's own case, then the other
+    // members' in key order. A result of PR Reviewer or Regression Runner lands on the Ticket Reviewer case that owns the spec or the file.
+    const team = teamIds(run.watchId);
+    const dots = [run.watchId, ...team.filter((id) => id !== run.watchId)];
+    const cases = list('test_cases', { dotId: dots })
+        .filter((c) => c.status !== 'retired')
+        .sort((a, b) => dots.indexOf(a.dotId) - dots.indexOf(b.dotId) || Number(a.key.slice(3)) - Number(b.key.slice(3)));
+    const projects = [...new Set(tests.map(projectOf))].sort();
+    const rawStage = run.stage;
+    const stage = typeof rawStage === 'string' ? rawStage : undefined;
+    let written = 0;
+    inTx(() => {
+        for (const project of projects) {
+            const group = tests.filter((t) => projectOf(t) === project);
+            // A result belongs to a case when it ran the case's AI-Vision file, or its spec and no other case owns that file (KAT-278).
+            // A spec path two members hold counts once, for the first case (the run's own).
+            const specSeen = new Set();
+            const specCases = cases.filter((o) => !!o.specPath && !specSeen.has(o.specPath) && !!specSeen.add(o.specPath));
+            const hitsByCase = cases
+                .map((c) => [c, group.filter((t) => t.file === aivisionFileOf(c) || (!!c.specPath && specCases.includes(c) && ownsFile(c, t.file, specCases)))])
+                .filter(([, h]) => h.length);
+            if (!hitsByCase.length)
+                continue;
+            const t = automatedRun(run, project, report);
+            const items = new Map(list('run_items', { testRunId: t.id }).map((i) => [i.caseId, i]));
+            let position = items.size;
+            for (const [c, hits] of hitsByCase) {
+                const at = now();
+                const s = summarize(hits);
+                let item = items.get(c.id);
+                if (!item) {
+                    item = insert('run_items', {
+                        testRunId: t.id,
+                        dotId: t.dotId,
+                        caseId: c.id,
+                        caseVersion: ensureVersion(c),
+                        position: ++position,
+                        state: s.result,
+                        attempt: 1,
+                        updatedAt: at,
+                        createdAt: at,
+                    });
+                }
+                else
+                    update('run_items', item.id, { state: s.result, updatedAt: at });
+                const row = {
+                    result: s.result,
+                    notes: s.notes,
+                    evidence: s.evidence,
+                    durationMs: s.durationMs,
+                    engine: engineOf(c, hits),
+                    ...(t.buildSha ? { sha: t.buildSha } : {}),
+                    ...(t.environment ? { environment: t.environment } : {}),
+                    ...(t.config ? { config: t.config } : {}),
+                    ...(stage ? { stage } : {}),
+                    at,
+                };
+                const prev = list('case_results', { runItemId: item.id, dotRunId: run.id }, { limit: 1 })[0];
+                if (prev)
+                    update('case_results', prev.id, row);
+                else
+                    insert('case_results', {
+                        caseId: c.id,
+                        dotId: c.dotId,
+                        runId: run.id,
+                        dotRunId: run.id,
+                        source: 'run',
+                        runItemId: item.id,
+                        testRunId: t.id,
+                        attempt: 1,
+                        steps: [],
+                        defects: [],
+                        ...row,
+                        createdAt: at,
+                    });
+                written++;
+            }
+        }
+    });
+    return written;
+}
+// ---------- backfill ----------
+/**
+ * Gives every dot-run result written before test runs existed its automated test run: one per dot run, one run item
+ * per case (the newest result wins the item state), so the history shows in Test runs. Idempotent: it only reads
+ * results that have no test run yet. Results added by hand outside a dot run stay outside any test run.
+ */
+export function backfillTestRuns() {
+    const groups = db
+        .prepare(`SELECT DISTINCT dotId, runId FROM case_results WHERE testRunId IS NULL AND runId IS NOT NULL AND source = 'run' ORDER BY runId`)
+        .all();
+    let testRuns = 0;
+    let items = 0;
+    for (const g of groups) {
+        inTx(() => {
+            const rows = list('case_results', { dotId: g.dotId, runId: g.runId, source: 'run', testRunId: null }, { orderBy: 'at ASC, id ASC' });
+            if (!rows.length)
+                return;
+            const run = get('runs', g.runId);
+            const at = rows.at(-1).at ?? now();
+            let t = list('test_runs', { dotRunId: g.runId, configKey: '' }, { limit: 1 })[0];
+            if (!t) {
+                const sha = run ? shaOf(run) : undefined;
+                const env = run?.report ? environmentOf(run.report) : undefined;
+                t = insert('test_runs', {
+                    dotId: g.dotId,
+                    name: run ? automatedName(run, '') : 'Earlier dot run',
+                    source: 'automated',
+                    status: 'done',
+                    dotRunId: g.runId,
+                    configKey: '',
+                    ...(sha ? { buildSha: sha } : {}),
+                    ...(env ? { environment: env } : {}),
+                    startedAt: run?.createdAt ?? rows[0].at,
+                    finishedAt: run?.finishedAt ?? at,
+                    createdAt: rows[0].createdAt ?? at,
+                    updatedAt: at,
+                });
+                testRuns++;
+            }
+            const byCase = new Map();
+            for (const r of rows)
+                byCase.set(r.caseId, [...(byCase.get(r.caseId) ?? []), r]);
+            let position = list('run_items', { testRunId: t.id }).length;
+            for (const [caseId, results] of byCase) {
+                const c = get('test_cases', caseId);
+                const newest = results.at(-1);
+                let item = list('run_items', { testRunId: t.id, caseId }, { limit: 1 })[0];
+                if (!item) {
+                    item = insert('run_items', {
+                        testRunId: t.id,
+                        dotId: g.dotId,
+                        caseId,
+                        caseVersion: c ? ensureVersion(c) : 1,
+                        position: ++position,
+                        state: newest.result,
+                        attempt: 1,
+                        updatedAt: newest.at,
+                        createdAt: newest.at,
+                    });
+                    items++;
+                }
+                for (const r of results)
+                    update('case_results', r.id, { testRunId: t.id, runItemId: item.id, attempt: 1, dotRunId: g.runId, ...(c ? { engine: engineOf(c) } : {}) });
+            }
+        });
+    }
+    return { testRuns, items };
+}
+//# sourceMappingURL=test-runs.js.map