@sdods/db 0.2.0

package/dist/ingest/types.js

@@ -0,0 +1,89 @@
+/** cucumber Timestamp/Duration → ms */
+export function tsToMs(t) {
+    if (!t)
+        return null;
+    return Number(t.seconds) * 1000 + Math.round((t.nanos ?? 0) / 1e6);
+}
+export function tsToIso(t) {
+    const ms = tsToMs(t);
+    return ms === null ? null : new Date(ms).toISOString();
+}
+export function cucumberStatus(s) {
+    switch ((s ?? '').toUpperCase()) {
+        case 'PASSED':
+            return 'passed';
+        case 'FAILED':
+            return 'failed';
+        case 'SKIPPED':
+        case 'PENDING':
+        case 'UNDEFINED':
+        case 'AMBIGUOUS':
+            return 'skipped';
+        default:
+            return 'unknown';
+    }
+}
+export function runnerStatus(s) {
+    switch (s) {
+        case 'passed':
+            return 'passed';
+        case 'failed':
+            return 'failed';
+        case 'timedOut':
+            return 'timedOut';
+        case 'skipped':
+            return 'skipped';
+        case 'interrupted':
+            return 'interrupted';
+        default:
+            return 'unknown';
+    }
+}
+/** Module = first directory after `features/`, else the first directory segment. */
+export function moduleFromUri(uri) {
+    const segs = uri.replace(/\\/g, '/').split('/').filter(Boolean);
+    if (segs.length < 2)
+        return null;
+    const fi = segs.lastIndexOf('features');
+    if (fi >= 0 && fi < segs.length - 2)
+        return segs[fi + 1];
+    if (fi >= 0)
+        return null;
+    // non-feature files (recorded specs): the directory that holds the file
+    return segs[segs.length - 2];
+}
+/** Strip playwright-bdd's `[<project>]:` prefix from a feature uri. */
+export function splitUri(uri) {
+    const m = /^\[([^\]]+)\]:(.*)$/.exec(uri);
+    return m ? { runnerProject: m[1], uri: m[2] } : { runnerProject: null, uri };
+}
+const LOCATOR_PATTERNS = [
+    /locator\.\w+: Timeout[\s\S]*?waiting for (locator\([^)]*\)|getBy\w+\([^)]*\)|[^\n]+)/i,
+    /waiting for (locator\([^\n]*?\)|getBy\w+\([^\n]*?\))/i,
+    /strict mode violation: (locator\([^\n]*?\)|getBy\w+\([^\n]*?\))/i,
+    /expect\((locator\([^\n]*?\)|getBy\w+\([^\n]*?\))\)/i,
+];
+/** Extract the selector from a Playwright locator error message, if any. */
+export function selectorFromError(message) {
+    if (!message)
+        return null;
+    for (const re of LOCATOR_PATTERNS) {
+        const m = re.exec(message);
+        if (m?.[1])
+            return m[1].trim().slice(0, 300);
+    }
+    return null;
+}
+export function emptyTotals() {
+    return {
+        total: 0,
+        passed: 0,
+        failed: 0,
+        skipped: 0,
+        timedOut: 0,
+        flaky: 0,
+        healed: 0,
+        durationMs: 0,
+    };
+}
+//# sourceMappingURL=types.js.map

package/dist/insights.d.ts

@@ -0,0 +1,62 @@
+import { type Kysely } from 'kysely';
+import type { Database } from './schema.js';
+export interface InsightsOptions {
+    projectSlug: string;
+    /** number of most recent runs to consider (default 30) */
+    window?: number;
+    /** thresholds */
+    flakyThreshold?: number;
+    fragilityThreshold?: number;
+    minRuns?: number;
+}
+export interface ScenarioInsight {
+    fingerprint: string;
+    runnerProject: string;
+    featureUri: string;
+    scenarioName: string;
+    module: string | null;
+    runs: number;
+    passed: number;
+    failed: number;
+    flaky: number;
+    /** (passed_on_retry + outcome flips) / runs */
+    flakinessScore: number;
+    p95DurationMs: number | null;
+    medianDurationMs: number | null;
+    instability: number | null;
+    quarantineCandidate: boolean;
+}
+export interface LocatorInsight {
+    selector: string;
+    pageHint: string | null;
+    fails: number;
+    heals: number;
+    uses: number;
+    fragility: number;
+    hot: boolean;
+    suggestedSelector: string | null;
+}
+export interface EnvInsight {
+    env: string;
+    runs: number;
+    envAttributedFailures: number;
+    stability: number;
+}
+export interface Insights {
+    projectSlug: string;
+    window: number;
+    runsConsidered: number;
+    passRate: number;
+    scenarios: ScenarioInsight[];
+    locators: LocatorInsight[];
+    envs: EnvInsight[];
+    suiteHealth: number;
+    suiteHealthTrend: number[];
+    computedAt: string;
+}
+/**
+ * Deterministic metrics over the last `window` runs of a project. Pure reads; results are
+ * returned (and written by the CLI into `flaky_stats` / `locator_stats` when asked).
+ */
+export declare function computeInsights(db: Kysely<Database>, opts: InsightsOptions): Promise<Insights>;
+//# sourceMappingURL=insights.d.ts.map

package/dist/insights.js

@@ -0,0 +1,184 @@
+import { sql } from 'kysely';
+import { readBool } from './col.js';
+const ENV_ERROR = /(ECONNREFUSED|ENOTFOUND|ETIMEDOUT|net::ERR_|502|503|504|Timeout .* exceeded|navigation timeout)/i;
+/**
+ * Deterministic metrics over the last `window` runs of a project. Pure reads; results are
+ * returned (and written by the CLI into `flaky_stats` / `locator_stats` when asked).
+ */
+export async function computeInsights(db, opts) {
+    const window = opts.window ?? 30;
+    const flakyThreshold = opts.flakyThreshold ?? 0.2;
+    const fragilityThreshold = opts.fragilityThreshold ?? 0.1;
+    const minRuns = opts.minRuns ?? 10;
+    const project = await db
+        .selectFrom('projects')
+        .select(['id'])
+        .where('slug', '=', opts.projectSlug)
+        .executeTakeFirst();
+    if (!project)
+        throw new Error(`Unknown project ${opts.projectSlug}`);
+    const runs = await db
+        .selectFrom('runs')
+        .select(['id', 'env_name', 'status', 'totals_json', 'created_at', 'started_at'])
+        .where('project_id', '=', project.id)
+        .where('status', 'in', ['passed', 'failed'])
+        .orderBy(sql `coalesce(started_at, created_at)`, 'desc')
+        .limit(window)
+        .execute();
+    const runIds = runs.map((r) => r.id);
+    const runOrder = new Map(runIds.map((id, i) => [id, i]));
+    const scenarios = runIds.length
+        ? await db
+            .selectFrom('scenarios')
+            .select([
+            'run_id',
+            'fingerprint',
+            'runner_project',
+            'feature_uri',
+            'scenario_name',
+            'module',
+            'status',
+            'flaky',
+            'duration_ms',
+            'error_message',
+        ])
+            .where('run_id', 'in', runIds)
+            .execute()
+        : [];
+    // ── scenario flakiness ────────────────────────────────────────────────
+    const groups = new Map();
+    for (const s of scenarios) {
+        const key = `${s.fingerprint}|${s.runner_project}`;
+        const list = groups.get(key) ?? [];
+        list.push(s);
+        groups.set(key, list);
+    }
+    const scenarioInsights = [];
+    for (const list of groups.values()) {
+        const ordered = [...list]
+            .sort((a, b) => (runOrder.get(a.run_id) ?? 0) - (runOrder.get(b.run_id) ?? 0))
+            .reverse(); // oldest → newest
+        const runsN = ordered.length;
+        const passed = ordered.filter((s) => s.status === 'passed' && !readBool(s.flaky)).length;
+        const failed = ordered.filter((s) => s.status === 'failed' || s.status === 'timedOut').length;
+        const flakyRetries = ordered.filter((s) => readBool(s.flaky)).length;
+        let flips = 0;
+        for (let i = 1; i < ordered.length; i++) {
+            const prev = ordered[i - 1].status === 'passed';
+            const cur = ordered[i].status === 'passed';
+            if (prev !== cur)
+                flips++;
+        }
+        const flakinessScore = runsN ? round((flakyRetries + flips) / runsN) : 0;
+        const durations = ordered
+            .map((s) => s.duration_ms)
+            .filter((d) => typeof d === 'number' && d > 0)
+            .sort((a, b) => a - b);
+        const median = durations.length ? durations[Math.floor(durations.length / 2)] : null;
+        const p95 = durations.length
+            ? durations[Math.min(durations.length - 1, Math.floor(durations.length * 0.95))]
+            : null;
+        const last = ordered[ordered.length - 1];
+        scenarioInsights.push({
+            fingerprint: last.fingerprint,
+            runnerProject: last.runner_project,
+            featureUri: last.feature_uri,
+            scenarioName: last.scenario_name,
+            module: last.module ?? null,
+            runs: runsN,
+            passed,
+            failed,
+            flaky: flakyRetries,
+            flakinessScore,
+            p95DurationMs: p95,
+            medianDurationMs: median,
+            instability: median && p95 ? round(p95 / median) : null,
+            quarantineCandidate: runsN >= minRuns && flakinessScore >= flakyThreshold,
+        });
+    }
+    scenarioInsights.sort((a, b) => b.flakinessScore - a.flakinessScore || b.failed - a.failed);
+    // ── locator fragility ─────────────────────────────────────────────────
+    const locatorRows = await db
+        .selectFrom('locator_stats')
+        .selectAll()
+        .where('project_id', '=', project.id)
+        .execute();
+    const locators = locatorRows
+        .map((l) => {
+        const uses = Math.max(l.use_count, l.fail_count + l.heal_count, 1);
+        const fragility = round((l.fail_count + 0.5 * l.heal_count) / uses);
+        return {
+            selector: l.selector,
+            pageHint: l.page_hint,
+            fails: l.fail_count,
+            heals: l.heal_count,
+            uses: l.use_count,
+            fragility,
+            hot: fragility >= fragilityThreshold && l.heal_count >= 3,
+            suggestedSelector: l.suggested_selector,
+        };
+    })
+        .sort((a, b) => b.fragility - a.fragility);
+    // ── env stability ─────────────────────────────────────────────────────
+    const envMap = new Map();
+    for (const r of runs) {
+        const e = envMap.get(r.env_name) ?? { runs: 0, envFails: 0 };
+        e.runs++;
+        const failedHere = scenarios.filter((s) => s.run_id === r.id && (s.status === 'failed' || s.status === 'timedOut'));
+        const envLike = failedHere.filter((s) => s.error_message && ENV_ERROR.test(s.error_message));
+        const distinct = new Set(envLike.map((s) => s.fingerprint)).size;
+        if (distinct >= 3)
+            e.envFails++;
+        envMap.set(r.env_name, e);
+    }
+    const envs = [...envMap.entries()].map(([env, e]) => ({
+        env,
+        runs: e.runs,
+        envAttributedFailures: e.envFails,
+        stability: e.runs ? round(1 - e.envFails / e.runs) : 1,
+    }));
+    // ── suite health ──────────────────────────────────────────────────────
+    const perRunPass = runs.map((r) => {
+        const list = scenarios.filter((s) => s.run_id === r.id);
+        if (!list.length)
+            return null;
+        return list.filter((s) => s.status === 'passed').length / list.length;
+    });
+    const validPass = perRunPass.filter((p) => p !== null);
+    const passRate = validPass.length
+        ? round(validPass.reduce((a, b) => a + b, 0) / validPass.length)
+        : 0;
+    const meanFlaky = scenarioInsights.length
+        ? scenarioInsights.reduce((a, s) => a + s.flakinessScore, 0) / scenarioInsights.length
+        : 0;
+    const meanFragility = locators.length
+        ? locators.reduce((a, l) => a + l.fragility, 0) / locators.length
+        : 0;
+    const durationCompliance = 1; // duration budgets are evaluated by the runtime; placeholder keeps the formula stable
+    const suiteHealth = round(0.5 * passRate +
+        0.2 * (1 - meanFlaky) +
+        0.2 * (1 - Math.min(1, meanFragility)) +
+        0.1 * durationCompliance);
+    const trend = [];
+    const chronological = [...validPass].reverse();
+    for (let i = 0; i < chronological.length; i++) {
+        const slice = chronological.slice(Math.max(0, i - 6), i + 1);
+        trend.push(round(slice.reduce((a, b) => a + b, 0) / slice.length));
+    }
+    return {
+        projectSlug: opts.projectSlug,
+        window,
+        runsConsidered: runs.length,
+        passRate,
+        scenarios: scenarioInsights,
+        locators,
+        envs,
+        suiteHealth,
+        suiteHealthTrend: trend,
+        computedAt: new Date().toISOString(),
+    };
+}
+function round(n) {
+    return Math.round(n * 10000) / 10000;
+}
+//# sourceMappingURL=insights.js.map

package/dist/migrate.d.ts

@@ -0,0 +1,30 @@
+import { type Kysely } from 'kysely';
+import { Migrator } from 'kysely/migration';
+import { type Col } from './col.js';
+import type { Driver } from './driver.js';
+import type { SdodsDb } from './create-db.js';
+export interface SdodsMigration {
+    up(db: Kysely<any>, c: Col, driver: Driver): Promise<void>;
+    down?(db: Kysely<any>, c: Col, driver: Driver): Promise<void>;
+}
+/**
+ * Move a pre-rename ledger into place before the migrator reads it. Safe to call on every
+ * start: it does nothing unless the old ledger exists and actually records migrations.
+ *
+ * A start that already failed this way leaves an empty ledger under the current name behind,
+ * so an empty one is dropped rather than treated as authoritative. An empty ledger records
+ * nothing, so nothing is lost; a non-empty one is left untouched and adoption is declined.
+ */
+export declare function adoptLegacyLedger({ db }: SdodsDb): Promise<string[]>;
+export declare function createMigrator({ db, driver }: SdodsDb): Migrator;
+export declare function migrateToLatest(adb: SdodsDb): Promise<import("kysely/migration").MigrationResult[]>;
+export declare function migrateDown(adb: SdodsDb): Promise<import("kysely/migration").MigrationResult[]>;
+export declare function migrateTo(adb: SdodsDb, name: string): Promise<import("kysely/migration").MigrationResult[]>;
+export declare function migrationStatus(adb: SdodsDb): Promise<{
+    name: string;
+    executedAt: string | null;
+}[]>;
+/** Drop every SDODS table (sqlite only, guarded by the CLI `--yes`). */
+export declare function resetDatabase(adb: SdodsDb): Promise<void>;
+export declare const MIGRATION_NAMES: string[];
+//# sourceMappingURL=migrate.d.ts.map

package/dist/migrate.js

@@ -0,0 +1,114 @@
+import { sql } from 'kysely';
+import { Migrator, } from 'kysely/migration';
+import { col } from './col.js';
+import { MIGRATIONS } from './migrations/index.js';
+import { MIGRATION_LOCK_TABLE, MIGRATION_TABLE } from './schema.js';
+/** Binds the driver into every migration so one file serves both dialects. */
+class DriverBoundProvider {
+    driver;
+    constructor(driver) {
+        this.driver = driver;
+    }
+    async getMigrations() {
+        const c = col(this.driver);
+        const out = {};
+        for (const [name, m] of Object.entries(MIGRATIONS)) {
+            out[name] = {
+                up: (db) => m.up(db, c, this.driver),
+                down: m.down ? (db) => m.down(db, c, this.driver) : undefined,
+            };
+        }
+        return out;
+    }
+}
+/**
+ * Ledger tables the platform used before it was renamed. A database created under the old
+ * name is fully migrated, but the migrator cannot see its ledger, so it would replay every
+ * migration and fail on the first CREATE TABLE. Renaming the ledger adopts the database.
+ */
+const LEGACY_MIGRATION_TABLE = 'automax_migrations';
+const LEGACY_LOCK_TABLE = 'automax_migrations_lock';
+async function tableExists(db, name) {
+    const tables = await db.introspection.getTables();
+    return tables.some((t) => t.name === name);
+}
+async function rowCount(db, name) {
+    const rows = await sql `select count(*) as n from ${sql.ref(name)}`.execute(db);
+    return Number(rows.rows[0]?.n ?? 0);
+}
+/**
+ * Move a pre-rename ledger into place before the migrator reads it. Safe to call on every
+ * start: it does nothing unless the old ledger exists and actually records migrations.
+ *
+ * A start that already failed this way leaves an empty ledger under the current name behind,
+ * so an empty one is dropped rather than treated as authoritative. An empty ledger records
+ * nothing, so nothing is lost; a non-empty one is left untouched and adoption is declined.
+ */
+export async function adoptLegacyLedger({ db }) {
+    if (!(await tableExists(db, LEGACY_MIGRATION_TABLE)))
+        return [];
+    if ((await rowCount(db, LEGACY_MIGRATION_TABLE)) === 0)
+        return [];
+    if (await tableExists(db, MIGRATION_TABLE)) {
+        if ((await rowCount(db, MIGRATION_TABLE)) > 0)
+            return [];
+        await sql `drop table ${sql.ref(MIGRATION_TABLE)}`.execute(db);
+    }
+    await sql `alter table ${sql.ref(LEGACY_MIGRATION_TABLE)} rename to ${sql.ref(MIGRATION_TABLE)}`.execute(db);
+    const renamed = [`${LEGACY_MIGRATION_TABLE} -> ${MIGRATION_TABLE}`];
+    // The lock table holds no history, so whichever one is in place will do.
+    if (await tableExists(db, LEGACY_LOCK_TABLE)) {
+        if (await tableExists(db, MIGRATION_LOCK_TABLE)) {
+            await sql `drop table ${sql.ref(LEGACY_LOCK_TABLE)}`.execute(db);
+        }
+        else {
+            await sql `alter table ${sql.ref(LEGACY_LOCK_TABLE)} rename to ${sql.ref(MIGRATION_LOCK_TABLE)}`.execute(db);
+            renamed.push(`${LEGACY_LOCK_TABLE} -> ${MIGRATION_LOCK_TABLE}`);
+        }
+    }
+    return renamed;
+}
+export function createMigrator({ db, driver }) {
+    return new Migrator({
+        db,
+        provider: new DriverBoundProvider(driver),
+        migrationTableName: MIGRATION_TABLE,
+        migrationLockTableName: MIGRATION_LOCK_TABLE,
+    });
+}
+function assertOk(result) {
+    if (result.error)
+        throw result.error instanceof Error ? result.error : new Error(String(result.error));
+    return result.results ?? [];
+}
+export async function migrateToLatest(adb) {
+    await adoptLegacyLedger(adb);
+    return assertOk(await createMigrator(adb).migrateToLatest());
+}
+export async function migrateDown(adb) {
+    await adoptLegacyLedger(adb);
+    return assertOk(await createMigrator(adb).migrateDown());
+}
+export async function migrateTo(adb, name) {
+    await adoptLegacyLedger(adb);
+    return assertOk(await createMigrator(adb).migrateTo(name));
+}
+export async function migrationStatus(adb) {
+    await adoptLegacyLedger(adb);
+    const list = await createMigrator(adb).getMigrations();
+    return list.map((m) => ({
+        name: m.name,
+        executedAt: m.executedAt ? m.executedAt.toISOString() : null,
+    }));
+}
+/** Drop every SDODS table (sqlite only, guarded by the CLI `--yes`). */
+export async function resetDatabase(adb) {
+    if (adb.driver !== 'sqlite')
+        throw new Error('reset is only supported on sqlite; drop the Postgres database yourself.');
+    const migrator = createMigrator(adb);
+    const applied = (await migrator.getMigrations()).filter((m) => m.executedAt);
+    for (let i = 0; i < applied.length; i++)
+        assertOk(await migrator.migrateDown());
+}
+export const MIGRATION_NAMES = Object.keys(MIGRATIONS);
+//# sourceMappingURL=migrate.js.map

package/dist/migrations/0001_platform_init.d.ts

@@ -0,0 +1,5 @@
+import type { Kysely } from 'kysely';
+import type { Col } from '../col.js';
+export declare function up(db: Kysely<any>, c: Col): Promise<void>;
+export declare function down(db: Kysely<any>): Promise<void>;
+//# sourceMappingURL=0001_platform_init.d.ts.map

package/dist/migrations/0001_platform_init.js

@@ -0,0 +1,48 @@
+import { dropTables, fk, index, stamps, table } from './helpers.js';
+export async function up(db, c) {
+    await stamps(table(db, 'roles', c)
+        .addColumn('name', 'text', (cb) => cb.notNull().unique())
+        .addColumn('permissions_json', c.json, (cb) => cb.notNull()), c, false).execute();
+    await stamps(fk(table(db, 'users', c)
+        .addColumn('username', 'text', (cb) => cb.notNull().unique())
+        .addColumn('email', 'text')
+        .addColumn('password_hash', 'text', (cb) => cb.notNull()), 'role_id', 'roles', c, { onDelete: 'restrict' })
+        .addColumn('active', c.bool, (cb) => cb.notNull().defaultTo(c.pg ? true : 1))
+        .addColumn('auth_provider', 'text', (cb) => cb.notNull().defaultTo('local'))
+        .addColumn('external_id', 'text')
+        .addColumn('last_login_at', c.ts), c).execute();
+    await fk(table(db, 'sessions', c), 'user_id', 'users', c)
+        .addColumn('csrf_token', 'text', (cb) => cb.notNull())
+        .addColumn('ip', 'text')
+        .addColumn('user_agent', 'text')
+        .addColumn('created_at', c.ts, (cb) => cb.notNull().defaultTo(c.now))
+        .addColumn('expires_at', c.ts, (cb) => cb.notNull())
+        .addColumn('last_seen_at', c.ts, (cb) => cb.notNull().defaultTo(c.now))
+        .execute();
+    await index(db, 'idx_sessions_user', 'sessions', ['user_id']);
+    await index(db, 'idx_sessions_expires', 'sessions', ['expires_at']);
+    await stamps(table(db, 'projects', c)
+        .addColumn('slug', 'text', (cb) => cb.notNull().unique())
+        .addColumn('name', 'text', (cb) => cb.notNull())
+        .addColumn('description', 'text')
+        .addColumn('root_path', 'text')
+        .addColumn('config_json', c.json, (cb) => cb.notNull())
+        .addColumn('config_hash', 'text')
+        .addColumn('layers_json', c.json, (cb) => cb.notNull())
+        .addColumn('browsers_json', c.json, (cb) => cb.notNull())
+        .addColumn('tags_policy_json', c.json, (cb) => cb.notNull())
+        .addColumn('screenshot_policy_json', c.json, (cb) => cb.notNull())
+        .addColumn('archived', c.bool, (cb) => cb.notNull().defaultTo(c.pg ? false : 0)), c).execute();
+    await stamps(fk(table(db, 'environments', c), 'project_id', 'projects', c)
+        .addColumn('name', 'text', (cb) => cb.notNull())
+        .addColumn('base_url', 'text')
+        .addColumn('api_base_url', 'text')
+        .addColumn('config_json', c.json, (cb) => cb.notNull())
+        .addColumn('secret_keys_json', c.json, (cb) => cb.notNull())
+        .addColumn('is_default', c.bool, (cb) => cb.notNull().defaultTo(c.pg ? false : 0)), c).execute();
+    await index(db, 'uq_environments_project_name', 'environments', ['project_id', 'name'], true);
+}
+export async function down(db) {
+    await dropTables(db, ['environments', 'projects', 'sessions', 'users', 'roles']);
+}
+//# sourceMappingURL=0001_platform_init.js.map

package/dist/migrations/0002_results.d.ts

@@ -0,0 +1,5 @@
+import type { Kysely } from 'kysely';
+import type { Col } from '../col.js';
+export declare function up(db: Kysely<any>, c: Col): Promise<void>;
+export declare function down(db: Kysely<any>): Promise<void>;
+//# sourceMappingURL=0002_results.d.ts.map

package/dist/migrations/0002_results.js

@@ -0,0 +1,124 @@
+import { dropTables, fk, index, stamps, table } from './helpers.js';
+export async function up(db, c) {
+    await stamps(fk(fk(table(db, 'runs', c), 'project_id', 'projects', c), 'environment_id', 'environments', c, {
+        nullable: true,
+        onDelete: 'set null',
+    })
+        .addColumn('env_name', 'text', (cb) => cb.notNull())
+        .addColumn('trigger', 'text', (cb) => cb.notNull().defaultTo('cli'))
+        .addColumn('status', 'text', (cb) => cb.notNull().defaultTo('queued'))
+        .addColumn('suite_tag', 'text')
+        .addColumn('tags_expr', 'text')
+        .addColumn('layers_json', c.json, (cb) => cb.notNull())
+        .addColumn('browsers_json', c.json, (cb) => cb.notNull())
+        .addColumn('shard_total', c.int)
+        .addColumn('shards_ingested', c.int, (cb) => cb.notNull().defaultTo(0))
+        .addColumn('git_sha', 'text')
+        .addColumn('git_branch', 'text')
+        .addColumn('ci_provider', 'text')
+        .addColumn('ci_run_id', 'text')
+        .addColumn('ci_url', 'text')
+        .addColumn('started_by', 'text')
+        .addColumn('command', 'text')
+        .addColumn('started_at', c.ts)
+        .addColumn('finished_at', c.ts)
+        .addColumn('duration_ms', c.int)
+        .addColumn('totals_json', c.json, (cb) => cb.notNull())
+        .addColumn('artifacts_dir', 'text')
+        .addColumn('pw_report_rel', 'text')
+        .addColumn('exit_code', c.int)
+        .addColumn('error_text', 'text'), c).execute();
+    await index(db, 'idx_runs_project_started', 'runs', ['project_id', 'started_at']);
+    await index(db, 'idx_runs_status', 'runs', ['status']);
+    await index(db, 'idx_runs_ci_run', 'runs', ['ci_run_id']);
+    await stamps(fk(fk(table(db, 'scenarios', c), 'run_id', 'runs', c), 'project_id', 'projects', c)
+        .addColumn('natural_key', 'text', (cb) => cb.notNull())
+        .addColumn('fingerprint', 'text', (cb) => cb.notNull())
+        .addColumn('source', 'text', (cb) => cb.notNull().defaultTo('gherkin'))
+        .addColumn('feature_uri', 'text', (cb) => cb.notNull())
+        .addColumn('feature_name', 'text')
+        .addColumn('scenario_name', 'text', (cb) => cb.notNull())
+        .addColumn('examples_row', c.int)
+        .addColumn('pw_project', 'text', (cb) => cb.notNull())
+        .addColumn('layer', 'text', (cb) => cb.notNull())
+        .addColumn('browser', 'text')
+        .addColumn('suite_tag', 'text')
+        .addColumn('tags_json', c.json, (cb) => cb.notNull())
+        .addColumn('jira_keys_json', c.json, (cb) => cb.notNull())
+        .addColumn('status', 'text', (cb) => cb.notNull().defaultTo('unknown'))
+        .addColumn('attempts_count', c.int, (cb) => cb.notNull().defaultTo(0))
+        .addColumn('flaky', c.bool, (cb) => cb.notNull().defaultTo(c.pg ? false : 0))
+        .addColumn('duration_ms', c.int)
+        .addColumn('error_message', 'text')
+        .addColumn('error_stack', 'text')
+        .addColumn('started_at', c.ts)
+        .addColumn('finished_at', c.ts), c).execute();
+    await index(db, 'uq_scenarios_run_natural', 'scenarios', ['run_id', 'natural_key'], true);
+    await index(db, 'idx_scenarios_fingerprint', 'scenarios', ['fingerprint']);
+    await index(db, 'idx_scenarios_run_status', 'scenarios', ['run_id', 'status']);
+    await index(db, 'idx_scenarios_project_fp', 'scenarios', ['project_id', 'fingerprint']);
+    await fk(fk(table(db, 'scenario_attempts', c), 'scenario_id', 'scenarios', c), 'run_id', 'runs', c)
+        .addColumn('attempt', c.int, (cb) => cb.notNull().defaultTo(0))
+        .addColumn('test_case_started_id', 'text', (cb) => cb.notNull())
+        .addColumn('status', 'text', (cb) => cb.notNull().defaultTo('unknown'))
+        .addColumn('duration_ms', c.int)
+        .addColumn('error_message', 'text')
+        .addColumn('error_stack', 'text')
+        .addColumn('will_be_retried', c.bool, (cb) => cb.notNull().defaultTo(c.pg ? false : 0))
+        .addColumn('worker_index', c.int)
+        .addColumn('started_at', c.ts)
+        .addColumn('finished_at', c.ts)
+        .addColumn('created_at', c.ts, (cb) => cb.notNull().defaultTo(c.now))
+        .execute();
+    await index(db, 'uq_attempts_run_tcs', 'scenario_attempts', ['run_id', 'test_case_started_id'], true);
+    await index(db, 'idx_attempts_scenario', 'scenario_attempts', ['scenario_id', 'attempt']);
+    await fk(fk(fk(table(db, 'steps', c), 'attempt_id', 'scenario_attempts', c), 'scenario_id', 'scenarios', c), 'run_id', 'runs', c)
+        .addColumn('step_index', c.int, (cb) => cb.notNull())
+        .addColumn('kind', 'text', (cb) => cb.notNull().defaultTo('step'))
+        .addColumn('hook_type', 'text')
+        .addColumn('keyword', 'text')
+        .addColumn('text', 'text', (cb) => cb.notNull())
+        .addColumn('argument_json', c.json)
+        .addColumn('status', 'text', (cb) => cb.notNull().defaultTo('unknown'))
+        .addColumn('duration_ms', c.int)
+        .addColumn('error_message', 'text')
+        .addColumn('error_stack', 'text')
+        .addColumn('definition_location', 'text')
+        .addColumn('test_step_id', 'text', (cb) => cb.notNull())
+        .addColumn('pickle_step_id', 'text')
+        .addColumn('layer_hint', 'text')
+        .addColumn('api_snapshot_json', c.json)
+        .addColumn('perf_json', c.json)
+        .addColumn('started_at', c.ts)
+        .addColumn('finished_at', c.ts)
+        .addColumn('created_at', c.ts, (cb) => cb.notNull().defaultTo(c.now))
+        .execute();
+    await index(db, 'uq_steps_attempt_test_step', 'steps', ['attempt_id', 'test_step_id'], true);
+    await index(db, 'idx_steps_scenario_index', 'steps', ['scenario_id', 'step_index']);
+    await fk(fk(fk(fk(table(db, 'artifacts', c), 'run_id', 'runs', c), 'scenario_id', 'scenarios', c, {
+        nullable: true,
+    }), 'attempt_id', 'scenario_attempts', c, { nullable: true }), 'step_id', 'steps', c, { nullable: true, onDelete: 'set null' })
+        .addColumn('step_index', c.int)
+        .addColumn('kind', 'text', (cb) => cb.notNull())
+        .addColumn('phase', 'text')
+        .addColumn('media_type', 'text', (cb) => cb.notNull().defaultTo('application/octet-stream'))
+        .addColumn('file_name', 'text', (cb) => cb.notNull())
+        .addColumn('rel_path', 'text', (cb) => cb.notNull().unique())
+        .addColumn('size_bytes', c.int, (cb) => cb.notNull().defaultTo(0))
+        .addColumn('sha256', 'text')
+        .addColumn('width', c.int)
+        .addColumn('height', c.int)
+        .addColumn('meta_json', c.json)
+        .addColumn('created_at', c.ts, (cb) => cb.notNull().defaultTo(c.now))
+        .execute();
+    await index(db, 'idx_artifacts_attempt_step_phase', 'artifacts', [
+        'attempt_id',
+        'step_index',
+        'phase',
+    ]);
+    await index(db, 'idx_artifacts_scenario_kind', 'artifacts', ['scenario_id', 'kind']);
+}
+export async function down(db) {
+    await dropTables(db, ['artifacts', 'steps', 'scenario_attempts', 'scenarios', 'runs']);
+}
+//# sourceMappingURL=0002_results.js.map