@sdods/db 0.13.2 → 0.14.1

package/dist/driver.d.ts

@@ -16,4 +16,6 @@ export declare const DEFAULT_SQLITE_PATH = ".sdods/sdods.db";
 export declare function findWorkspaceRoot(start?: string): string | null;
 /** Resolve the platform database driver from the environment (`DB_DRIVER`, `SQLITE_PATH`, `DATABASE_URL`). */
 export declare function resolveDriverConfig(env?: NodeJS.ProcessEnv): DriverConfig;
+/** A connection URL with the password masked, safe to print or return from the API. */
+export declare function redactUrl(url?: string): string;
 //# sourceMappingURL=driver.d.ts.map

package/dist/driver.js

@@ -47,4 +47,10 @@ export function resolveDriverConfig(env = process.env) {
         sqlitePath: root ? join(root, DEFAULT_SQLITE_PATH) : DEFAULT_SQLITE_PATH,
     };
 }
+/** A connection URL with the password masked, safe to print or return from the API. */
+export function redactUrl(url) {
+    if (!url)
+        return '';
+    return url.replace(/\/\/([^:/]+):[^@]+@/, '//$1:***@');
+}
 //# sourceMappingURL=driver.js.map

package/dist/index.d.ts

@@ -10,6 +10,7 @@ export * from './switch/index.js';
 export * from './insights.js';
 export * from './test-data.js';
 export * from './scopes.js';
+export * from './storage.js';
 import { type SdodsDb } from './create-db.js';
 import { type DriverConfig } from './driver.js';
 /** Open + migrate in one call (what `sdods serve` and `sdods run --ingest` do on boot). */

package/dist/index.js

@@ -10,6 +10,7 @@ export * from './switch/index.js';
 export * from './insights.js';
 export * from './test-data.js';
 export * from './scopes.js';
+export * from './storage.js';
 import { createDb } from './create-db.js';
 import { resolveDriverConfig } from './driver.js';
 import { migrateToLatest } from './migrate.js';

package/dist/migrations/0012_platform_settings.d.ts

@@ -0,0 +1,10 @@
+import type { Kysely } from 'kysely';
+import type { Col } from '../col.js';
+/**
+ * Platform-wide settings an admin changes from the UI or `sdods db retention`, keyed by name
+ * (`retention`, …). One row per key; the value is JSON so a setting can grow fields without a
+ * migration.
+ */
+export declare function up(db: Kysely<any>, c: Col): Promise<void>;
+export declare function down(db: Kysely<any>, _c: Col): Promise<void>;
+//# sourceMappingURL=0012_platform_settings.d.ts.map

package/dist/migrations/0012_platform_settings.js

@@ -0,0 +1,16 @@
+import { dropTables, index, stamps, table } from './helpers.js';
+/**
+ * Platform-wide settings an admin changes from the UI or `sdods db retention`, keyed by name
+ * (`retention`, …). One row per key; the value is JSON so a setting can grow fields without a
+ * migration.
+ */
+export async function up(db, c) {
+    await stamps(table(db, 'platform_settings', c)
+        .addColumn('key', 'text', (cb) => cb.notNull())
+        .addColumn('value_json', c.json, (cb) => cb.notNull()), c).execute();
+    await index(db, 'uq_platform_settings_key', 'platform_settings', ['key'], true);
+}
+export async function down(db, _c) {
+    await dropTables(db, ['platform_settings']);
+}
+//# sourceMappingURL=0012_platform_settings.js.map

package/dist/migrations/index.js

@@ -9,6 +9,7 @@ import * as m0008 from './0008_runner_naming.js';
 import * as m0009 from './0009_user_profile.js';
 import * as m0010 from './0010_run_params.js';
 import * as m0011 from './0011_user_preferences.js';
+import * as m0012 from './0012_platform_settings.js';
 /**
  * Static registry (bundler-friendly, no runtime file discovery). Order matters: Kysely sorts by key.
  */
@@ -24,5 +25,6 @@ export const MIGRATIONS = {
     '0009_user_profile': m0009,
     '0010_run_params': m0010,
     '0011_user_preferences': m0011,
+    '0012_platform_settings': m0012,
 };
 //# sourceMappingURL=index.js.map

package/dist/repos/index.d.ts

@@ -6,4 +6,6 @@ export * from './auth.js';
 export * from './platform.js';
 export * from './hierarchy.js';
 export * from './preferences.js';
+export * from './settings.js';
+export * from './retention.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/repos/index.js

@@ -6,4 +6,6 @@ export * from './auth.js';
 export * from './platform.js';
 export * from './hierarchy.js';
 export * from './preferences.js';
+export * from './settings.js';
+export * from './retention.js';
 //# sourceMappingURL=index.js.map

package/dist/repos/retention.d.ts

@@ -0,0 +1,49 @@
+import type { SdodsDb } from '../create-db.js';
+/** A run in one of these states is still being written to; deleting it would corrupt it. */
+export declare const LIVE_RUN_STATUSES: readonly ["queued", "running"];
+export interface DeleteRunsOptions {
+    /** Where run artifact directories live (`.sdods/runs`), for runs with no `artifacts_dir`. */
+    artifactsRoot?: string;
+    actor?: {
+        userId?: string | null;
+        type?: 'user' | 'cli' | 'system' | 'token';
+        ip?: string | null;
+    };
+    /** Why: `manual`, `prune`, `retention`, `schedule-retention`. Recorded in the audit log. */
+    reason?: string;
+    dryRun?: boolean;
+}
+export interface DeletedRun {
+    id: string;
+    projectSlug: string;
+    createdAt: string;
+    bytes: number;
+}
+export interface DeleteRunsResult {
+    deleted: DeletedRun[];
+    skipped: Array<{
+        id: string;
+        reason: 'live' | 'not-found';
+    }>;
+    freedBytes: number;
+}
+/**
+ * Delete runs, their child rows and their artifact directories.
+ *
+ * - Live runs (queued / running) are skipped, never deleted.
+ * - Rows are removed in one transaction; references from tables without a foreign key
+ *   (`schedule_runs`, `user_leases`, `last_run_id` columns) are cleared so nothing dangles.
+ * - Artifact directories are removed only after the commit, and only when the directory is the
+ *   run's own (under `artifactsRoot`, or named after the run id).
+ * - Each deleted run gets a `run.delete` audit entry.
+ */
+export declare function deleteRuns(adb: SdodsDb, ids: string[], opts?: DeleteRunsOptions): Promise<DeleteRunsResult>;
+/**
+ * The artifact directory that belongs to this run, or null. A stored `artifacts_dir` is trusted
+ * only when it sits under `artifactsRoot` or its last segment is the run id, so a bad row can
+ * never point the delete at an unrelated folder.
+ */
+export declare function ownArtifactsDir(runId: string, stored: string | null, artifactsRoot?: string): string | null;
+/** Total size of the files under `path` (symlinks are not followed). */
+export declare function dirSize(path: string): number;
+//# sourceMappingURL=retention.d.ts.map

package/dist/repos/retention.js

@@ -0,0 +1,134 @@
+import { existsSync, lstatSync, readdirSync, rmSync } from 'node:fs';
+import { join, relative, resolve, sep, isAbsolute } from 'node:path';
+import { audit } from './platform.js';
+import { deleteRun } from './runs.js';
+/** A run in one of these states is still being written to; deleting it would corrupt it. */
+export const LIVE_RUN_STATUSES = ['queued', 'running'];
+/**
+ * Delete runs, their child rows and their artifact directories.
+ *
+ * - Live runs (queued / running) are skipped, never deleted.
+ * - Rows are removed in one transaction; references from tables without a foreign key
+ *   (`schedule_runs`, `user_leases`, `last_run_id` columns) are cleared so nothing dangles.
+ * - Artifact directories are removed only after the commit, and only when the directory is the
+ *   run's own (under `artifactsRoot`, or named after the run id).
+ * - Each deleted run gets a `run.delete` audit entry.
+ */
+export async function deleteRuns(adb, ids, opts = {}) {
+    const unique = [...new Set(ids)].filter(Boolean);
+    if (unique.length === 0)
+        return { deleted: [], skipped: [], freedBytes: 0 };
+    const rows = await adb.db
+        .selectFrom('runs')
+        .leftJoin('projects', 'projects.id', 'runs.project_id')
+        .select([
+        'runs.id as id',
+        'runs.status as status',
+        'runs.created_at as created_at',
+        'runs.artifacts_dir as artifacts_dir',
+        'projects.slug as slug',
+    ])
+        .where('runs.id', 'in', unique)
+        .execute();
+    const byId = new Map(rows.map((r) => [r.id, r]));
+    const skipped = [];
+    const victims = [];
+    for (const id of unique) {
+        const r = byId.get(id);
+        if (!r) {
+            skipped.push({ id, reason: 'not-found' });
+            continue;
+        }
+        if (LIVE_RUN_STATUSES.includes(r.status)) {
+            skipped.push({ id, reason: 'live' });
+            continue;
+        }
+        const dir = ownArtifactsDir(id, r.artifacts_dir, opts.artifactsRoot);
+        victims.push({
+            id,
+            projectSlug: r.slug ?? '',
+            createdAt: String(r.created_at),
+            bytes: dir ? dirSize(dir) : 0,
+            dir,
+        });
+    }
+    const freedBytes = victims.reduce((n, v) => n + v.bytes, 0);
+    const result = {
+        deleted: victims.map(({ dir: _dir, ...v }) => v),
+        skipped,
+        freedBytes,
+    };
+    if (opts.dryRun || victims.length === 0)
+        return result;
+    const victimIds = victims.map((v) => v.id);
+    await adb.db.transaction().execute(async (trx) => {
+        await trx
+            .updateTable('schedule_runs')
+            .set({ run_id: null })
+            .where('run_id', 'in', victimIds)
+            .execute();
+        await trx
+            .updateTable('user_leases')
+            .set({ run_id: null })
+            .where('run_id', 'in', victimIds)
+            .execute();
+        for (const t of ['schedules', 'processes', 'flaky_stats', 'issue_links']) {
+            await trx
+                .updateTable(t)
+                .set({ last_run_id: null })
+                .where('last_run_id', 'in', victimIds)
+                .execute();
+        }
+        for (const v of victims) {
+            await deleteRun(trx, v.id);
+            await audit(trx, {
+                actorUserId: opts.actor?.userId ?? null,
+                actorType: opts.actor?.type ?? 'system',
+                action: 'run.delete',
+                targetType: 'run',
+                targetId: v.id,
+                details: { project: v.projectSlug, reason: opts.reason ?? 'manual', bytes: v.bytes },
+                ip: opts.actor?.ip ?? null,
+            });
+        }
+    });
+    for (const v of victims) {
+        if (v.dir && existsSync(v.dir))
+            rmSync(v.dir, { recursive: true, force: true });
+    }
+    return result;
+}
+/**
+ * The artifact directory that belongs to this run, or null. A stored `artifacts_dir` is trusted
+ * only when it sits under `artifactsRoot` or its last segment is the run id, so a bad row can
+ * never point the delete at an unrelated folder.
+ */
+export function ownArtifactsDir(runId, stored, artifactsRoot) {
+    const root = artifactsRoot ? resolve(artifactsRoot) : null;
+    const candidates = [stored, root ? join(root, runId) : null].filter(Boolean);
+    for (const c of candidates) {
+        const dir = resolve(c);
+        const underRoot = root ? isInside(root, dir) && dir !== root : false;
+        const named = dir.split(sep).pop() === runId;
+        if ((underRoot || named) && existsSync(dir))
+            return dir;
+    }
+    return null;
+}
+function isInside(parent, child) {
+    const rel = relative(parent, child);
+    return rel !== '' && !rel.startsWith('..') && !isAbsolute(rel);
+}
+/** Total size of the files under `path` (symlinks are not followed). */
+export function dirSize(path) {
+    if (!existsSync(path))
+        return 0;
+    const st = lstatSync(path);
+    if (!st.isDirectory())
+        return st.isFile() ? st.size : 0;
+    let total = 0;
+    for (const name of readdirSync(path))
+        total += dirSize(join(path, name));
+    return total;
+}
+//# sourceMappingURL=retention.js.map

package/dist/repos/settings.d.ts

@@ -0,0 +1,18 @@
+import type { Kysely } from 'kysely';
+import type { Database } from '../schema.js';
+export declare function getPlatformSetting<T = unknown>(db: Kysely<Database>, key: string): Promise<T | null>;
+/** Insert or replace one platform setting. */
+export declare function setPlatformSetting<T = unknown>(db: Kysely<Database>, key: string, value: T): Promise<void>;
+/**
+ * How much run history to keep. `keepRuns` is per project; `keepDays` is by age; either may be
+ * null (no limit). `auto` makes the server apply them once a day.
+ */
+export interface RetentionSettings {
+    keepRuns: number | null;
+    keepDays: number | null;
+    auto: boolean;
+}
+export declare const DEFAULT_RETENTION: RetentionSettings;
+export declare function getRetentionSettings(db: Kysely<Database>): Promise<RetentionSettings>;
+export declare function setRetentionSettings(db: Kysely<Database>, value: Partial<RetentionSettings>): Promise<RetentionSettings>;
+//# sourceMappingURL=settings.d.ts.map

package/dist/repos/settings.js

@@ -0,0 +1,43 @@
+import { enc, nowIso, readJson } from '../col.js';
+import { newId } from '../ids.js';
+export async function getPlatformSetting(db, key) {
+    const row = await db
+        .selectFrom('platform_settings')
+        .select('value_json')
+        .where('key', '=', key)
+        .executeTakeFirst();
+    return row ? readJson(row.value_json) : null;
+}
+/** Insert or replace one platform setting. */
+export async function setPlatformSetting(db, key, value) {
+    const now = nowIso();
+    const existing = await db
+        .selectFrom('platform_settings')
+        .select('id')
+        .where('key', '=', key)
+        .executeTakeFirst();
+    if (existing) {
+        await db
+            .updateTable('platform_settings')
+            .set({ value_json: enc.json(value), updated_at: now })
+            .where('id', '=', existing.id)
+            .execute();
+    }
+    else {
+        await db
+            .insertInto('platform_settings')
+            .values({ id: newId(), key, value_json: enc.json(value), created_at: now, updated_at: now })
+            .execute();
+    }
+}
+export const DEFAULT_RETENTION = { keepRuns: null, keepDays: null, auto: false };
+export async function getRetentionSettings(db) {
+    const v = await getPlatformSetting(db, 'retention');
+    return { ...DEFAULT_RETENTION, ...(v ?? {}) };
+}
+export async function setRetentionSettings(db, value) {
+    const next = { ...(await getRetentionSettings(db)), ...value };
+    await setPlatformSetting(db, 'retention', next);
+    return next;
+}
+//# sourceMappingURL=settings.js.map

package/dist/schema.d.ts

@@ -485,6 +485,13 @@ export interface UserPreferencesTable {
     created_at: Ts;
     updated_at: Ts;
 }
+export interface PlatformSettingsTable {
+    id: string;
+    key: string;
+    value_json: Json<unknown>;
+    created_at: Ts;
+    updated_at: Ts;
+}
 export interface Database {
     organizations: OrganizationsTable;
     workspaces: WorkspacesTable;
@@ -518,6 +525,7 @@ export interface Database {
     schedule_runs: ScheduleRunsTable;
     audit_log: AuditLogTable;
     user_preferences: UserPreferencesTable;
+    platform_settings: PlatformSettingsTable;
 }
 /** Platform tables in foreign-key order (parents first). Used by export/import/switch/prune. */
 export declare const TABLES_IN_FK_ORDER: Array<keyof Database>;

package/dist/schema.js

@@ -32,6 +32,7 @@ export const TABLES_IN_FK_ORDER = [
     'schedules',
     'schedule_runs',
     'audit_log',
+    'platform_settings',
 ];
 export const MIGRATION_TABLE = 'sdods_migrations';
 export const MIGRATION_LOCK_TABLE = 'sdods_migrations_lock';

package/dist/storage.d.ts

@@ -0,0 +1,23 @@
+import type { SdodsDb } from './create-db.js';
+export interface StorageStats {
+    driver: 'sqlite' | 'postgres';
+    /** SQLite file path, or the Postgres URL with the password masked. */
+    location: string;
+    /** Database size in bytes (SQLite: file + WAL; Postgres: pg_database_size). Null when unknown. */
+    dbBytes: number | null;
+    artifactsDir: string | null;
+    artifactsBytes: number;
+    counts: Record<'runs' | 'scenarios' | 'artifacts' | 'auditLog' | 'users' | 'projects', number>;
+    oldestRunAt: string | null;
+    newestRunAt: string | null;
+    migrations: {
+        applied: number;
+        pending: number;
+        latest: string | null;
+    };
+}
+/** What the database holds and how much space it and the run artifacts take. */
+export declare function storageStats(adb: SdodsDb, opts?: {
+    artifactsRoot?: string;
+}): Promise<StorageStats>;
+//# sourceMappingURL=storage.d.ts.map

package/dist/storage.js

@@ -0,0 +1,76 @@
+import { existsSync, statSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { sql } from 'kysely';
+import { redactUrl } from './driver.js';
+import { migrationStatus } from './migrate.js';
+import { dirSize } from './repos/retention.js';
+import { countRows } from './switch/export.js';
+/** What the database holds and how much space it and the run artifacts take. */
+export async function storageStats(adb, opts = {}) {
+    const sqlite = adb.driver === 'sqlite';
+    const path = adb.config.sqlitePath;
+    let dbBytes;
+    if (sqlite) {
+        if (path && path !== ':memory:') {
+            const abs = resolve(path);
+            dbBytes = [abs, `${abs}-wal`]
+                .filter((f) => existsSync(f))
+                .reduce((n, f) => n + statSync(f).size, 0);
+        }
+        else {
+            const res = await sql `select page_count * page_size as n from pragma_page_count(), pragma_page_size()`.execute(adb.db);
+            dbBytes = Number(res.rows[0]?.n ?? 0);
+        }
+    }
+    else {
+        const res = await sql `select pg_database_size(current_database()) as n`
+            .execute(adb.db)
+            .catch(() => null);
+        dbBytes = res ? Number(res.rows[0]?.n ?? 0) : null;
+    }
+    const count = (t) => countRows(adb, t);
+    const counts = {
+        runs: await count('runs'),
+        scenarios: await count('scenarios'),
+        artifacts: await count('artifacts'),
+        auditLog: await count('audit_log'),
+        users: await count('users'),
+        projects: await count('projects'),
+    };
+    const range = await adb.db
+        .selectFrom('runs')
+        .select([
+        sql `min(coalesce(started_at, created_at))`.as('oldest'),
+        sql `max(coalesce(started_at, created_at))`.as('newest'),
+    ])
+        .executeTakeFirst();
+    const mig = await migrationStatus(adb);
+    const applied = mig.filter((m) => m.executedAt);
+    const artifactsDir = opts.artifactsRoot ? resolve(opts.artifactsRoot) : null;
+    return {
+        driver: adb.driver,
+        location: sqlite
+            ? path && path !== ':memory:'
+                ? resolve(path)
+                : ':memory:'
+            : redactUrl(adb.config.databaseUrl),
+        dbBytes,
+        artifactsDir,
+        artifactsBytes: artifactsDir ? dirSize(artifactsDir) : 0,
+        counts,
+        oldestRunAt: toIso(range?.oldest),
+        newestRunAt: toIso(range?.newest),
+        migrations: {
+            applied: applied.length,
+            pending: mig.length - applied.length,
+            latest: applied.at(-1)?.name ?? null,
+        },
+    };
+}
+function toIso(v) {
+    if (v == null)
+        return null;
+    const d = v instanceof Date ? v : new Date(String(v));
+    return Number.isNaN(d.getTime()) ? null : d.toISOString();
+}
+//# sourceMappingURL=storage.js.map

package/dist/switch/backup.d.ts

@@ -0,0 +1,42 @@
+import type { SdodsDb } from '../create-db.js';
+import { type ImportResult } from './import.js';
+export interface BackupManifest {
+    id: string;
+    createdAt: string;
+    driver: 'sqlite' | 'postgres';
+    /** Free text: `manual`, `pre-restore`, … */
+    label: string;
+    sdodsVersion: string | null;
+    tables: Array<{
+        table: string;
+        rows: number;
+    }>;
+}
+export interface BackupInfo extends BackupManifest {
+    dir: string;
+    bytes: number;
+    rows: number;
+}
+export declare function isBackupId(id: string): boolean;
+/** Export every table to `<root>/<id>/` (JSONL, the same format as `sdods db export`) + manifest. */
+export declare function createBackup(adb: SdodsDb, root: string, opts?: {
+    label?: string;
+    sdodsVersion?: string | null;
+}): Promise<BackupInfo>;
+/** Backups under `root`, newest first. Folders without a readable manifest are ignored. */
+export declare function listBackups(root: string): BackupInfo[];
+export declare function getBackup(root: string, id: string): BackupInfo | null;
+export declare function deleteBackup(root: string, id: string): boolean;
+/**
+ * Replace the database contents with a backup (or any `sdods db export` folder). Takes a
+ * `pre-restore` backup of the current data into `safetyRoot` first, then empties every platform
+ * and td_* table and imports the backup. Migrations must already be at the latest version.
+ */
+export declare function restoreBackup(adb: SdodsDb, dir: string, opts?: {
+    safetyRoot?: string;
+    sdodsVersion?: string | null;
+}): Promise<{
+    safety: BackupInfo | null;
+    imported: ImportResult;
+}>;
+//# sourceMappingURL=backup.d.ts.map

package/dist/switch/backup.js

@@ -0,0 +1,97 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { dirSize } from '../repos/retention.js';
+import { TABLES_IN_FK_ORDER } from '../schema.js';
+import { listTdTables } from '../test-data.js';
+import { exportAll } from './export.js';
+import { importAll } from './import.js';
+/** Backup ids are timestamps (`2026-10-14T21-03-22-123Z`), so they sort and are safe in a path. */
+const ID_RE = /^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z(?:-[a-z0-9-]{1,32})?$/;
+export function isBackupId(id) {
+    return ID_RE.test(id);
+}
+/** Export every table to `<root>/<id>/` (JSONL, the same format as `sdods db export`) + manifest. */
+export async function createBackup(adb, root, opts = {}) {
+    const createdAt = new Date().toISOString();
+    const id = createdAt.replace(/[:.]/g, '-');
+    const dir = join(resolve(root), id);
+    mkdirSync(dir, { recursive: true });
+    const res = await exportAll(adb, dir);
+    const manifest = {
+        id,
+        createdAt,
+        driver: adb.driver,
+        label: opts.label ?? 'manual',
+        sdodsVersion: opts.sdodsVersion ?? null,
+        tables: res.tables.map((t) => ({ table: t.table, rows: t.rows })),
+    };
+    writeFileSync(join(dir, 'manifest.json'), JSON.stringify(manifest, null, 2) + '\n');
+    return toInfo(dir, manifest);
+}
+/** Backups under `root`, newest first. Folders without a readable manifest are ignored. */
+export function listBackups(root) {
+    const base = resolve(root);
+    if (!existsSync(base))
+        return [];
+    const out = [];
+    for (const name of readdirSync(base)) {
+        if (!isBackupId(name))
+            continue;
+        const manifest = readManifest(join(base, name));
+        if (manifest)
+            out.push(toInfo(join(base, name), manifest));
+    }
+    return out.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+}
+export function getBackup(root, id) {
+    if (!isBackupId(id))
+        return null;
+    const dir = join(resolve(root), id);
+    const manifest = readManifest(dir);
+    return manifest ? toInfo(dir, manifest) : null;
+}
+export function deleteBackup(root, id) {
+    const b = getBackup(root, id);
+    if (!b)
+        return false;
+    rmSync(b.dir, { recursive: true, force: true });
+    return true;
+}
+/**
+ * Replace the database contents with a backup (or any `sdods db export` folder). Takes a
+ * `pre-restore` backup of the current data into `safetyRoot` first, then empties every platform
+ * and td_* table and imports the backup. Migrations must already be at the latest version.
+ */
+export async function restoreBackup(adb, dir, opts = {}) {
+    const src = resolve(dir);
+    if (!existsSync(src) || !readdirSync(src).some((f) => f.endsWith('.jsonl')))
+        throw new Error(`${src} is not a backup: no <table>.jsonl files in it.`);
+    const safety = opts.safetyRoot
+        ? await createBackup(adb, opts.safetyRoot, {
+            label: 'pre-restore',
+            sdodsVersion: opts.sdodsVersion,
+        })
+        : null;
+    const td = await listTdTables(adb.db, adb.driver);
+    await adb.db.transaction().execute(async (trx) => {
+        for (const t of [...td, ...[...TABLES_IN_FK_ORDER].reverse()])
+            await trx.deleteFrom(t).execute();
+    });
+    const imported = await importAll(adb, src);
+    return { safety, imported };
+}
+function readManifest(dir) {
+    const file = join(dir, 'manifest.json');
+    if (!existsSync(file))
+        return null;
+    try {
+        return JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function toInfo(dir, m) {
+    return { ...m, dir, bytes: dirSize(dir), rows: m.tables.reduce((n, t) => n + t.rows, 0) };
+}
+//# sourceMappingURL=backup.js.map

package/dist/switch/index.d.ts

@@ -2,4 +2,5 @@ export * from './export.js';
 export * from './import.js';
 export * from './switch.js';
 export * from './prune.js';
+export * from './backup.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/switch/index.js

@@ -2,4 +2,5 @@ export * from './export.js';
 export * from './import.js';
 export * from './switch.js';
 export * from './prune.js';
+export * from './backup.js';
 //# sourceMappingURL=index.js.map

package/dist/switch/prune.d.ts

@@ -1,10 +1,14 @@
 import type { SdodsDb } from '../create-db.js';
+import { type DeleteRunsOptions } from '../repos/retention.js';
 export interface PruneOptions {
     keepRuns?: number;
     keepDays?: number;
     projectSlug?: string;
     artifactsRoot?: string;
     dryRun?: boolean;
+    /** Recorded in the audit log (`prune` by default; the scheduler passes `retention`). */
+    reason?: string;
+    actor?: DeleteRunsOptions['actor'];
 }
 export interface PruneResult {
     deleted: Array<{
@@ -13,7 +17,17 @@ export interface PruneResult {
         createdAt: string;
     }>;
     kept: number;
+    /** Runs that matched but were left alone because they are still queued or running. */
+    skipped: Array<{
+        id: string;
+        reason: string;
+    }>;
+    freedBytes: number;
 }
-/** Delete old runs (and their artifact directories) beyond `keepRuns` per project or older than `keepDays`. */
+/**
+ * Delete old runs (and their artifact directories) beyond `keepRuns` per project or older than
+ * `keepDays`. Live runs are never deleted. Goes through {@link deleteRuns}, so it is
+ * transactional, audited and clears references to the deleted runs.
+ */
 export declare function prune(adb: SdodsDb, opts: PruneOptions): Promise<PruneResult>;
 //# sourceMappingURL=prune.d.ts.map