@doxbrix/doxloop 0.1.4 → 0.2.0

package/dist/content-links.d.ts

@@ -0,0 +1,10 @@
+/** Literal links in Markdown/MDX, HTML and reStructuredText. Never execute components. */
+export declare function contentLinks(raw: string): string[];
+/**
+ * A link target is a URL or a path. Text that only looks like `[x](y)`
+ * because it is a regular expression, a JSX expression, or a template —
+ * `[a-z]([a-z0-9-]{0,34})`, `{props.href}`, `${base}/x` — is not one, and
+ * reporting it as a broken link sent a real run's page to a fix session.
+ */
+export declare function looksLikeLinkTarget(value: string): boolean;
+//# sourceMappingURL=content-links.d.ts.map

package/dist/content-links.js

@@ -0,0 +1,49 @@
+/** Literal links in Markdown/MDX, HTML and reStructuredText. Never execute components. */
+export function contentLinks(raw) {
+    const text = raw.replace(/```[^\n]*\n[\s\S]*?```|~~~[^\n]*\n[\s\S]*?~~~/g, '').replace(/<!--[\s\S]*?-->/g, '').replace(/<(?:script|style)\b[^>]*>[\s\S]*?<\/(?:script|style)>/gi, '');
+    // Inline code is literal text: `[a-z]([a-z0-9-]{0,34}[a-z0-9])` is a
+    // pattern, not a link. The reStructuredText forms below are written with
+    // backticks themselves, so they read the unmasked text.
+    const markdown = text.replace(/(`+)(?:(?!\1)[^\n])+?\1/g, '');
+    const links = new Set();
+    const markdownPatterns = [
+        /!?\[[^\]]*\]\(<?([^\s)>]+)>?(?:\s+["'][^"']*["'])?\)/g,
+        /^\s{0,3}\[[^\]]+\]:\s*<?([^\s>]+)>?/gm,
+        /\b(?:href|src)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>"'=]+))/gi,
+        /<(https?:\/\/[^>\s]+)>/gi,
+    ];
+    const restructuredPatterns = [
+        /`[^`<>]*<([^<>]+)>`_?_/g,
+        /^\s*\.\.\s+_[^:]+:\s+(\S+)/gm,
+        /^\s*\.\.\s+(?:image|figure)::\s+(\S+)/gm,
+        /:doc:`(?:[^`<>]*<)?([^`<>]+)>?`/g,
+    ];
+    const collect = (source, patterns) => {
+        for (const pattern of patterns)
+            for (const match of source.matchAll(pattern)) {
+                const value = (match[1] ?? match[2] ?? match[3])?.trim().replace(/&amp;/g, '&');
+                if (value && looksLikeLinkTarget(value))
+                    links.add(value);
+            }
+    };
+    collect(markdown, markdownPatterns);
+    collect(text, restructuredPatterns);
+    return [...links];
+}
+/**
+ * A link target is a URL or a path. Text that only looks like `[x](y)`
+ * because it is a regular expression, a JSX expression, or a template —
+ * `[a-z]([a-z0-9-]{0,34})`, `{props.href}`, `${base}/x` — is not one, and
+ * reporting it as a broken link sent a real run's page to a fix session.
+ */
+export function looksLikeLinkTarget(value) {
+    if (value.startsWith('{'))
+        return false;
+    if (/\s/.test(value))
+        return false;
+    // Brackets, braces, pipes, backslashes, carets and backticks never appear
+    // unescaped in a URL a writer means as a link; they are regex or template
+    // syntax.
+    return !/[[\]{}|\\^`]/.test(value);
+}
+//# sourceMappingURL=content-links.js.map

package/dist/contract-validation.d.ts

@@ -0,0 +1,4 @@
+export type PublicContract = 'quality-report-v1' | 'evaluation-v1' | 'coverage-v1';
+/** Validate output at its public boundary so an incompatible report is never persisted. */
+export declare function assertPublicContract(contract: PublicContract, value: unknown): Promise<void>;
+//# sourceMappingURL=contract-validation.d.ts.map

package/dist/contract-validation.js

@@ -0,0 +1,25 @@
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { Ajv2020 } from 'ajv/dist/2020.js';
+import addFormatsModule from 'ajv-formats';
+import { DoxloopError } from './errors.js';
+const validators = new Map();
+/** Validate output at its public boundary so an incompatible report is never persisted. */
+export async function assertPublicContract(contract, value) {
+    let validate = validators.get(contract);
+    if (!validate) {
+        const path = fileURLToPath(new URL(`../contracts/${contract}.schema.json`, import.meta.url));
+        const schema = JSON.parse(await readFile(path, 'utf8'));
+        const ajv = new Ajv2020({ allErrors: true, strict: true });
+        const addFormats = addFormatsModule;
+        addFormats(ajv);
+        const compiled = ajv.compile(schema);
+        validators.set(contract, compiled);
+        validate = compiled;
+    }
+    if (validate(value))
+        return;
+    const detail = validate.errors?.map((error) => `${error.instancePath || '/'} ${error.message ?? 'is invalid'}`).join('; ') ?? 'unknown schema error';
+    throw new DoxloopError(`Doxloop refused to write an invalid ${contract} payload: ${detail}`);
+}
+//# sourceMappingURL=contract-validation.js.map

package/dist/coverage-actions.d.ts

@@ -0,0 +1,8 @@
+export type CoverageResolutionAction = 'link' | 'exclude' | 'needs-human' | 'remove-priority' | 'reset';
+export declare function resolveCoverageItem(root: string, input: {
+    id: string;
+    action: CoverageResolutionAction;
+    page?: string;
+    reason?: string;
+}): Promise<void>;
+//# sourceMappingURL=coverage-actions.d.ts.map

package/dist/coverage-actions.js

@@ -0,0 +1,71 @@
+import { withProjectLock } from './project-lock.js';
+import { writeCoverageResolution } from './coverage-resolutions.js';
+import { DoxloopError } from './errors.js';
+import { readEvidenceMap, writeEvidenceMap } from './evidence.js';
+import { loadProject, saveProjectSettings } from './project.js';
+import { buildSourceIntelligence } from './source-intelligence.js';
+export async function resolveCoverageItem(root, input) {
+    return withProjectLock(root, 'write', () => resolveCoverageItemLocked(root, input));
+}
+async function resolveCoverageItemLocked(root, input) {
+    const report = await buildSourceIntelligence(root);
+    const item = report.coverage.metrics.flatMap((metric) => metric.items).find((candidate) => candidate.id === input.id);
+    if (!item)
+        throw new DoxloopError('The requested coverage item no longer exists. Refresh coverage and try again.');
+    const reason = input.reason?.trim();
+    if (input.action === 'reset') {
+        await writeCoverageResolution(root, item.id);
+        return;
+    }
+    if (input.action === 'needs-human') {
+        await writeCoverageResolution(root, item.id, { disposition: 'needs-human', ...(reason ? { reason } : {}) });
+        return;
+    }
+    if (input.action === 'exclude') {
+        if (item.surface === 'verified-pages')
+            throw new DoxloopError('Page verification cannot be excluded. Reverify the page or decide later.');
+        if (item.surface === 'reader-journeys')
+            throw new DoxloopError('Remove a reader journey from priority outcomes instead of excluding it as a product surface.');
+        if (!reason)
+            throw new DoxloopError('Explain why this item is not part of the supported public surface.');
+        await writeCoverageResolution(root, item.id, { disposition: 'excluded', reason });
+        return;
+    }
+    if (input.action === 'remove-priority') {
+        if (item.surface !== 'reader-journeys')
+            throw new DoxloopError('Only reader journeys can be removed from priority outcomes.');
+        const project = await loadProject(root);
+        const priorityOutcomes = (project.documentation.priorityOutcomes ?? []).filter((outcome) => outcome !== item.label);
+        await saveProjectSettings(root, { documentation: { ...project.documentation, priorityOutcomes } });
+        await writeCoverageResolution(root, item.id);
+        return;
+    }
+    if (input.action === 'link') {
+        const page = input.page?.trim();
+        if (!page || !report.coverage.pages.includes(page))
+            throw new DoxloopError('Choose an existing evidence-mapped documentation page.');
+        if (item.surface === 'reader-journeys') {
+            await writeCoverageResolution(root, item.id, { disposition: 'documented', page, ...(reason ? { reason } : {}) });
+            return;
+        }
+        if (!item.source)
+            throw new DoxloopError('This coverage item cannot be linked to source evidence.');
+        const map = await readEvidenceMap(root);
+        if (!map?.pages[page])
+            throw new DoxloopError('The selected documentation page is not present in the evidence map.');
+        const evidence = map.pages[page];
+        const identifier = item.kind === 'export' && item.label.startsWith('Schema ')
+            ? `schema:${item.label.replace(/^Schema /, '')}`
+            : item.label;
+        const existing = evidence.sources.find((entry) => entry.source === item.source);
+        if (existing)
+            existing.operations = [...new Set([...(existing.operations ?? []), identifier])];
+        else
+            evidence.sources.push({ source: item.source, operations: [identifier] });
+        await writeEvidenceMap(root, map);
+        await writeCoverageResolution(root, item.id);
+        return;
+    }
+    throw new DoxloopError('Unsupported coverage resolution action.');
+}
+//# sourceMappingURL=coverage-actions.js.map

package/dist/coverage-resolutions.d.ts

@@ -0,0 +1,16 @@
+export type CoverageResolution = {
+    disposition: 'documented' | 'excluded' | 'needs-human';
+    page?: string;
+    reason?: string;
+    updatedAt: string;
+};
+export type CoverageResolutions = {
+    schemaVersion: 1;
+    items: Record<string, CoverageResolution>;
+};
+export declare function coverageSignalId(source: string, kind: string, path: string, label: string): string;
+export declare function coveragePageId(page: string): string;
+export declare function coverageJourneyId(outcome: string): string;
+export declare function readCoverageResolutions(root: string): Promise<CoverageResolutions>;
+export declare function writeCoverageResolution(root: string, id: string, resolution?: Omit<CoverageResolution, 'updatedAt'>): Promise<void>;
+//# sourceMappingURL=coverage-resolutions.d.ts.map

package/dist/coverage-resolutions.js

@@ -0,0 +1,58 @@
+import { withProjectLock } from './project-lock.js';
+import { createHash } from 'node:crypto';
+import { mkdir, rename, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { DoxloopError } from './errors.js';
+import { pathExists, readJson } from './fs.js';
+const COVERAGE_RESOLUTIONS_FILE = join('.doxloop', 'coverage-resolutions.json');
+export function coverageSignalId(source, kind, path, label) {
+    return `signal-${createHash('sha256').update(`${source}\0${kind}\0${path}\0${label}`).digest('hex').slice(0, 16)}`;
+}
+export function coveragePageId(page) { return `page-${createHash('sha256').update(page).digest('hex').slice(0, 16)}`; }
+export function coverageJourneyId(outcome) {
+    return `journey-${createHash('sha256').update(normalize(outcome)).digest('hex').slice(0, 16)}`;
+}
+export async function readCoverageResolutions(root) {
+    const path = join(root, COVERAGE_RESOLUTIONS_FILE);
+    if (!(await pathExists(path)))
+        return { schemaVersion: 1, items: {} };
+    const raw = await readJson(path);
+    if (!isCoverageResolutions(raw))
+        throw new DoxloopError(`${COVERAGE_RESOLUTIONS_FILE} has an unsupported format.`);
+    return raw;
+}
+export async function writeCoverageResolution(root, id, resolution) {
+    return withProjectLock(root, 'write', () => writeCoverageResolutionLocked(root, id, resolution));
+}
+async function writeCoverageResolutionLocked(root, id, resolution) {
+    if (!/^(signal|journey|page)-[a-f0-9]{16}$/.test(id))
+        throw new DoxloopError('The requested coverage item is invalid.');
+    const current = await readCoverageResolutions(root);
+    const items = { ...current.items };
+    if (resolution)
+        items[id] = { ...resolution, updatedAt: new Date().toISOString() };
+    else
+        delete items[id];
+    const path = join(root, COVERAGE_RESOLUTIONS_FILE);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(`${path}.tmp`, `${JSON.stringify({ schemaVersion: 1, items }, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+    await rename(`${path}.tmp`, path);
+}
+function isCoverageResolutions(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const candidate = value;
+    if (candidate.schemaVersion !== 1 || !candidate.items || typeof candidate.items !== 'object' || Array.isArray(candidate.items))
+        return false;
+    return Object.entries(candidate.items).every(([id, item]) => {
+        if (!/^(signal|journey|page)-[a-f0-9]{16}$/.test(id) || !item || typeof item !== 'object' || Array.isArray(item))
+            return false;
+        const resolution = item;
+        return ['documented', 'excluded', 'needs-human'].includes(String(resolution.disposition)) &&
+            (resolution.page === undefined || typeof resolution.page === 'string') &&
+            (resolution.reason === undefined || typeof resolution.reason === 'string') &&
+            typeof resolution.updatedAt === 'string';
+    });
+}
+function normalize(value) { return value.trim().toLowerCase(); }
+//# sourceMappingURL=coverage-resolutions.js.map

package/dist/db.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Local history storage.
+ *
+ * Doxloop ships without a native database dependency: history uses `node:sqlite`
+ * from the required Node.js 22.13+ runtime. `DOXLOOP_NO_HISTORY=1` remains an
+ * explicit privacy/diagnostic opt-out. Documentation stays in git; this database
+ * is a derived audit index that can be deleted and rebuilt at any time.
+ */
+export declare const DATABASE_FILE: string;
+/** The subset of `node:sqlite` this module relies on. */
+export interface Statement {
+    run(...params: unknown[]): unknown;
+    get(...params: unknown[]): unknown;
+    all(...params: unknown[]): unknown[];
+}
+export interface Database {
+    exec(sql: string): void;
+    prepare(sql: string): Statement;
+    close(): void;
+}
+/** The schema version a freshly migrated database reports via `PRAGMA user_version`. */
+export declare const SCHEMA_VERSION: number;
+/**
+ * Open (and migrate) the history database for a project. Returns `undefined`
+ * when history is unavailable, which callers must treat as "skip recording".
+ */
+export declare function openHistory(root: string): Promise<Database | undefined>;
+/** Run a write against the history database, never failing the caller. */
+export declare function withHistory<T>(root: string, action: (database: Database) => T): Promise<T | undefined>;
+export declare function closeHistory(root?: string): void;
+/** True when the runtime can store history at all. */
+export declare function historyAvailable(): Promise<boolean>;
+export declare function historyRuntimeStatus(version: string): {
+    available: boolean;
+    detail: string;
+};
+//# sourceMappingURL=db.d.ts.map

package/dist/db.js

@@ -0,0 +1,288 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+/**
+ * Local history storage.
+ *
+ * Doxloop ships without a native database dependency: history uses `node:sqlite`
+ * from the required Node.js 22.13+ runtime. `DOXLOOP_NO_HISTORY=1` remains an
+ * explicit privacy/diagnostic opt-out. Documentation stays in git; this database
+ * is a derived audit index that can be deleted and rebuilt at any time.
+ */
+export const DATABASE_FILE = join('.doxloop', 'doxloop.db');
+const SCHEMA = [
+    // 1 — requests, the pages they touched, the page registry, deployments, baselines.
+    `
+  CREATE TABLE requests (
+    id                  TEXT PRIMARY KEY,
+    created_at          TEXT NOT NULL,
+    finished_at         TEXT,
+    duration_ms         INTEGER,
+    kind                TEXT NOT NULL,
+    trigger             TEXT NOT NULL,
+    request_text        TEXT,
+    agent               TEXT,
+    model               TEXT,
+    reasoning_effort    TEXT,
+    status              TEXT NOT NULL,
+    pages_changed       INTEGER NOT NULL DEFAULT 0,
+    lines_added         INTEGER NOT NULL DEFAULT 0,
+    lines_removed       INTEGER NOT NULL DEFAULT 0,
+    validation_pages    INTEGER,
+    validation_errors   INTEGER,
+    validation_warnings INTEGER,
+    source_summary      TEXT,
+    stale_pages_count   INTEGER NOT NULL DEFAULT 0,
+    error_message       TEXT,
+    run_dir             TEXT
+  );
+  CREATE INDEX requests_created_at ON requests (created_at DESC);
+  CREATE INDEX requests_status ON requests (status);
+
+  CREATE TABLE request_pages (
+    request_id    TEXT NOT NULL REFERENCES requests (id) ON DELETE CASCADE,
+    path          TEXT NOT NULL,
+    title         TEXT,
+    change_kind   TEXT NOT NULL,
+    category      TEXT NOT NULL,
+    decision      TEXT NOT NULL DEFAULT 'pending',
+    decided_at    TEXT,
+    lines_added   INTEGER NOT NULL DEFAULT 0,
+    lines_removed INTEGER NOT NULL DEFAULT 0,
+    PRIMARY KEY (request_id, path)
+  );
+  CREATE INDEX request_pages_path ON request_pages (path, request_id);
+
+  CREATE TABLE pages (
+    path                TEXT PRIMARY KEY,
+    title               TEXT,
+    created_at          TEXT NOT NULL,
+    updated_at          TEXT NOT NULL,
+    last_request_id     TEXT,
+    content_hash        TEXT,
+    change_count        INTEGER NOT NULL DEFAULT 0,
+    evidence_confidence TEXT,
+    status              TEXT NOT NULL DEFAULT 'active'
+  );
+
+  CREATE TABLE deployments (
+    id            INTEGER PRIMARY KEY AUTOINCREMENT,
+    started_at    TEXT NOT NULL,
+    finished_at   TEXT,
+    duration_ms   INTEGER,
+    target        TEXT NOT NULL,
+    name          TEXT,
+    slug          TEXT,
+    visibility    TEXT,
+    url           TEXT,
+    status        TEXT NOT NULL,
+    pages_count   INTEGER,
+    media_count   INTEGER,
+    bytes         INTEGER,
+    pages_created INTEGER,
+    pages_updated INTEGER,
+    pages_deleted INTEGER,
+    git_commit    TEXT,
+    error_message TEXT
+  );
+  CREATE INDEX deployments_started_at ON deployments (started_at DESC);
+
+  CREATE TABLE source_syncs (
+    id           INTEGER PRIMARY KEY AUTOINCREMENT,
+    source_name  TEXT NOT NULL,
+    -- SQLite treats NULLs as distinct in a UNIQUE constraint, so a source with
+    -- no fingerprint would append a duplicate row on every run. Empty strings
+    -- keep "already recorded" comparable.
+    commit_hash  TEXT NOT NULL DEFAULT '',
+    fingerprint  TEXT NOT NULL DEFAULT '',
+    recorded_at  TEXT NOT NULL,
+    request_id   TEXT,
+    UNIQUE (source_name, commit_hash, fingerprint)
+  );
+  CREATE INDEX source_syncs_name ON source_syncs (source_name, recorded_at DESC);
+
+  CREATE TABLE meta (
+    key   TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+  );
+  `,
+    // 2 — agent token usage per request. Nullable: rows from before this version
+    // and agents that report no usage leave them empty.
+    `
+  ALTER TABLE requests ADD COLUMN input_tokens INTEGER;
+  ALTER TABLE requests ADD COLUMN output_tokens INTEGER;
+  ALTER TABLE requests ADD COLUMN cache_read_tokens INTEGER;
+  ALTER TABLE requests ADD COLUMN cache_creation_tokens INTEGER;
+  ALTER TABLE requests ADD COLUMN cost_usd REAL;
+  ALTER TABLE requests ADD COLUMN agent_turns INTEGER;
+  ALTER TABLE requests ADD COLUMN agent_sessions INTEGER;
+  ALTER TABLE requests ADD COLUMN max_context_tokens INTEGER;
+  `,
+];
+/** The schema version a freshly migrated database reports via `PRAGMA user_version`. */
+export const SCHEMA_VERSION = SCHEMA.length;
+let sqlite;
+const connections = new Map();
+/**
+ * Node prints an experimental warning the first time `node:sqlite` loads. The
+ * filter is narrow so every other warning still reaches the user, and it stays
+ * installed because `process.emitWarning` defers to the next tick.
+ */
+function silenceSqliteWarning() {
+    const emit = process.emit.bind(process);
+    const filtered = (name, ...rest) => {
+        const warning = rest[0];
+        if (name === 'warning' &&
+            warning instanceof Error &&
+            warning.name === 'ExperimentalWarning' &&
+            warning.message.includes('SQLite')) {
+            return false;
+        }
+        return emit(name, ...rest);
+    };
+    process.emit = filtered;
+}
+async function loadSqlite() {
+    if (sqlite !== undefined)
+        return sqlite;
+    try {
+        silenceSqliteWarning();
+        sqlite = (await import('node:sqlite'));
+    }
+    catch {
+        // Node 20 and early Node 22 have no built-in SQLite. History is optional.
+        sqlite = null;
+    }
+    return sqlite;
+}
+/**
+ * Open (and migrate) the history database for a project. Returns `undefined`
+ * when history is unavailable, which callers must treat as "skip recording".
+ */
+export async function openHistory(root) {
+    if (process.env.DOXLOOP_NO_HISTORY === '1')
+        return undefined;
+    const cached = connections.get(root);
+    if (cached !== undefined)
+        return cached ?? undefined;
+    const loaded = await loadSqlite();
+    if (!loaded) {
+        connections.set(root, null);
+        return undefined;
+    }
+    try {
+        const path = join(root, DATABASE_FILE);
+        mkdirSync(join(root, '.doxloop'), { recursive: true });
+        ensureIgnored(root);
+        const database = new loaded.DatabaseSync(path);
+        configure(database);
+        migrate(database);
+        try {
+            // History can contain source paths and request text. Keep it owner-only.
+            chmodSync(path, 0o600);
+        }
+        catch {
+            // Windows and some network filesystems do not support POSIX modes.
+        }
+        connections.set(root, database);
+        return database;
+    }
+    catch (error) {
+        debug('open', error);
+        connections.set(root, null);
+        return undefined;
+    }
+}
+/**
+ * Projects created before history existed have no ignore rule for it. The
+ * database is machine-local and must never reach a commit.
+ */
+function ensureIgnored(root) {
+    const entries = [
+        '.doxloop/doxloop.db',
+        '.doxloop/doxloop.db-wal',
+        '.doxloop/doxloop.db-shm',
+    ];
+    try {
+        const path = join(root, '.gitignore');
+        const existing = existsSync(path) ? readFileSync(path, 'utf8') : '';
+        const lines = existing.split(/\r?\n/);
+        const missing = entries.filter((entry) => !lines.includes(entry));
+        if (missing.length === 0)
+            return;
+        const prefix = existing && !existing.endsWith('\n') ? '\n' : '';
+        writeFileSync(path, `${existing}${prefix}${missing.join('\n')}\n`, 'utf8');
+    }
+    catch {
+        // A read-only checkout still gets history; it just cannot self-ignore.
+    }
+}
+function configure(database) {
+    // WAL lets the UI server read while a CLI job writes; the timeout absorbs the
+    // brief lock contention that remains.
+    database.exec('PRAGMA journal_mode = WAL');
+    database.exec('PRAGMA busy_timeout = 5000');
+    database.exec('PRAGMA foreign_keys = ON');
+    database.exec('PRAGMA synchronous = NORMAL');
+}
+function migrate(database) {
+    const row = database.prepare('PRAGMA user_version').get();
+    const current = Number(row?.user_version ?? 0);
+    if (current >= SCHEMA.length)
+        return;
+    for (let version = current; version < SCHEMA.length; version += 1) {
+        database.exec('BEGIN');
+        try {
+            database.exec(SCHEMA[version]);
+            database.exec(`PRAGMA user_version = ${version + 1}`);
+            database.exec('COMMIT');
+        }
+        catch (error) {
+            database.exec('ROLLBACK');
+            throw error;
+        }
+    }
+}
+/** Run a write against the history database, never failing the caller. */
+export async function withHistory(root, action) {
+    const database = await openHistory(root);
+    if (!database)
+        return undefined;
+    try {
+        return action(database);
+    }
+    catch (error) {
+        debug('write', error);
+        return undefined;
+    }
+}
+export function closeHistory(root) {
+    for (const [key, database] of connections) {
+        if (root !== undefined && key !== root)
+            continue;
+        try {
+            database?.close();
+        }
+        catch {
+            // A database closed twice is not worth reporting.
+        }
+        connections.delete(key);
+    }
+}
+/** True when the runtime can store history at all. */
+export async function historyAvailable() {
+    return process.env.DOXLOOP_NO_HISTORY !== '1' && (await loadSqlite()) !== null;
+}
+export function historyRuntimeStatus(version) {
+    const match = /^(\d+)\.(\d+)\.(\d+)/.exec(version);
+    const supported = Boolean(match && (Number(match[1]) > 22 || (Number(match[1]) === 22 && (Number(match[2]) > 13 || (Number(match[2]) === 13 && Number(match[3]) >= 0)))));
+    return supported
+        ? { available: true, detail: `Node.js ${version} includes the SQLite history runtime required by Doxloop.` }
+        : { available: false, detail: `Node.js ${version} is too old for request history. Upgrade to Node.js 22.13 or newer before the first documentation run.` };
+}
+function debug(stage, error) {
+    if (process.env.DOXLOOP_DEBUG !== '1')
+        return;
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`doxloop: history ${stage} failed: ${message}\n`);
+}
+//# sourceMappingURL=db.js.map

package/dist/demo.d.ts

@@ -0,0 +1,12 @@
+import type { DocumentationPlan, DocumentationReviewReport, ValidationResult } from './types.js';
+export interface DemoWorkspace {
+    parent: string;
+    root: string;
+    plan: DocumentationPlan;
+    review: DocumentationReviewReport;
+    validation: ValidationResult;
+    cleanup(): Promise<void>;
+}
+/** Build a deterministic showcase in an isolated temporary directory. */
+export declare function createDemoWorkspace(): Promise<DemoWorkspace>;
+//# sourceMappingURL=demo.d.ts.map