@evomap/evolver-webui 2.0.0-beta.2 → 2.0.0-beta.22

package/dist/eventSnapshot.d.ts

@@ -1,13 +1,19 @@
 import { events as ev } from '@evomap/evolver-core';
+type Awaitable<T> = T | PromiseLike<T>;
+export type EventSnapshotReader = (eventsPath: string) => Awaitable<readonly ev.ReportEvent[]>;
 export interface EventSnapshotSource {
-    version(): string;
-    read(): readonly ev.ReportEvent[];
+    version(): Awaitable<string>;
+    read(): Awaitable<readonly ev.ReportEvent[]>;
 }
-export declare function fileEventSnapshotSource(eventsPath: string): EventSnapshotSource;
-/** Reuses a parsed append-only event snapshot only when the file identity is stable across the read. */
+export declare function fileEventSnapshotSource(eventsPath: string, readEvents?: EventSnapshotReader): EventSnapshotSource;
+/** Reuses a parsed event history only when the active file and archive segments stay stable across the read. */
 export declare class EventSnapshotCache {
     private readonly source;
     private cached;
+    private inFlight;
     constructor(source: EventSnapshotSource);
-    read(): readonly ev.ReportEvent[];
-}
+    read(): Promise<readonly ev.ReportEvent[]>;
+    private readOnce;
+    private readVersioned;
+}
+export {};

package/dist/eventSnapshot.js

@@ -1,51 +1,157 @@
-import { statSync } from 'node:fs';
+import { readdir, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { Worker } from 'node:worker_threads';
 import { events as ev } from '@evomap/evolver-core';
+const ARCHIVE_SEGMENT_PATTERN = /^root-events-\d{16}-\d{16}\.jsonl$/;
+const MAX_VERSIONED_READ_ATTEMPTS = 2;
+const EVENT_SNAPSHOT_WORKER_SOURCE = `
+import { parentPort, workerData } from 'node:worker_threads';
+
+try {
+  const core = await import(workerData.coreModuleUrl);
+  const events = core.events.readEvents(workerData.eventsPath);
+  parentPort.postMessage({ ok: true, events });
+} catch (error) {
+  parentPort.postMessage({
+    ok: false,
+    error: {
+      name: error instanceof Error ? error.name : 'Error',
+      message: error instanceof Error ? error.message : String(error),
+      code: error && typeof error === 'object' && 'code' in error ? error.code : undefined,
+    },
+  });
+}
+`;
+const EVENT_SNAPSHOT_WORKER_URL = new URL(`data:text/javascript,${encodeURIComponent(EVENT_SNAPSHOT_WORKER_SOURCE)}`);
 function isMissing(error) {
     return typeof error === 'object' && error !== null && 'code' in error && error.code === 'ENOENT';
 }
-export function fileEventSnapshotSource(eventsPath) {
+function statFingerprint(value) {
+    return `${value.dev}:${value.ino}:${value.size}:${value.mtimeNs}:${value.ctimeNs}`;
+}
+async function pathFingerprint(path) {
+    try {
+        return statFingerprint(await stat(path, { bigint: true }));
+    }
+    catch (error) {
+        if (isMissing(error))
+            return 'missing';
+        throw error;
+    }
+}
+async function archiveFingerprint(eventsPath) {
+    const archiveDir = ev.rootEventArchiveDir(eventsPath);
+    let entries;
+    try {
+        entries = (await readdir(archiveDir)).filter((entry) => ARCHIVE_SEGMENT_PATTERN.test(entry)).sort();
+    }
+    catch (error) {
+        if (isMissing(error))
+            return 'missing';
+        throw error;
+    }
+    const fingerprints = [];
+    for (const entry of entries) {
+        fingerprints.push(`${entry}:${await pathFingerprint(join(archiveDir, entry))}`);
+    }
+    return `${await pathFingerprint(archiveDir)}:[${fingerprints.join(',')}]`;
+}
+async function fileSnapshotVersion(eventsPath) {
+    const [active, archive] = await Promise.all([
+        pathFingerprint(eventsPath),
+        archiveFingerprint(eventsPath),
+    ]);
+    return `active=${active};archive=${archive}`;
+}
+function workerFailure(error) {
+    const restored = new Error(error.message);
+    restored.name = error.name;
+    if (error.code !== undefined)
+        Object.assign(restored, { code: error.code });
+    return restored;
+}
+function readEventsInWorker(eventsPath) {
+    return new Promise((resolve, reject) => {
+        const worker = new Worker(EVENT_SNAPSHOT_WORKER_URL, {
+            workerData: {
+                eventsPath,
+                coreModuleUrl: new URL('../../evolver-core/dist/index.js', import.meta.url).href,
+            },
+        });
+        let settled = false;
+        const settle = (action) => {
+            if (settled)
+                return;
+            settled = true;
+            action();
+        };
+        worker.once('message', (response) => {
+            settle(() => {
+                if (response.ok)
+                    resolve(response.events);
+                else
+                    reject(workerFailure(response.error));
+            });
+        });
+        worker.once('error', (error) => settle(() => reject(error)));
+        worker.once('exit', (code) => {
+            settle(() => reject(new Error(code === 0
+                ? 'event snapshot worker exited without a response'
+                : `event snapshot worker exited with code ${code}`)));
+        });
+    });
+}
+export function fileEventSnapshotSource(eventsPath, readEvents = readEventsInWorker) {
     return {
-        version: () => {
-            try {
-                const stat = statSync(eventsPath, { bigint: true });
-                return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
-            }
-            catch (error) {
-                if (isMissing(error))
-                    return 'missing';
-                throw error;
-            }
-        },
-        read: () => ev.readEvents(eventsPath),
+        version: () => fileSnapshotVersion(eventsPath),
+        read: () => readEvents(eventsPath),
     };
 }
-/** Reuses a parsed append-only event snapshot only when the file identity is stable across the read. */
+/** Reuses a parsed event history only when the active file and archive segments stay stable across the read. */
 export class EventSnapshotCache {
     source;
     cached;
+    inFlight;
     constructor(source) {
         this.source = source;
     }
     read() {
+        if (this.inFlight !== undefined)
+            return this.inFlight;
+        const pending = this.readOnce().finally(() => {
+            if (this.inFlight === pending)
+                this.inFlight = undefined;
+        });
+        this.inFlight = pending;
+        return pending;
+    }
+    async readOnce() {
         let before;
         try {
-            before = this.source.version();
+            before = await this.source.version();
         }
         catch {
-            return this.source.read();
+            return await this.source.read();
         }
+        return await this.readVersioned(before, MAX_VERSIONED_READ_ATTEMPTS);
+    }
+    async readVersioned(before, attemptsRemaining) {
         if (this.cached?.version === before)
             return this.cached.events;
-        const events = this.source.read();
+        const events = await this.source.read();
         let after;
         try {
-            after = this.source.version();
+            after = await this.source.version();
         }
         catch {
             return events;
         }
-        if (before === after)
+        if (before === after) {
             this.cached = { version: after, events };
-        return events;
+            return events;
+        }
+        if (attemptsRemaining === 1)
+            return events;
+        return await this.readVersioned(after, attemptsRemaining - 1);
     }
 }

package/dist/githubPrDiagnostics.d.ts

@@ -0,0 +1,57 @@
+export declare const GITHUB_PR_TIMEOUT_MS = 15000;
+export declare const GITHUB_PR_MAX_BUFFER_BYTES: number;
+export declare const GITHUB_PR_CACHE_TTL_MS = 45000;
+export declare const GITHUB_PR_MAX_ITEMS = 50;
+export interface GithubPrCheckCounts {
+    total: number;
+    passed: number;
+    failed: number;
+    pending: number;
+}
+export interface GithubPrDiagnosticRow {
+    number: number;
+    title: string;
+    url: string;
+    state: 'OPEN' | 'CLOSED' | 'MERGED' | 'UNKNOWN';
+    isDraft: boolean;
+    head: string;
+    base: string;
+    updatedAt: string | null;
+    reviewDecision: 'APPROVED' | 'CHANGES_REQUESTED' | 'REVIEW_REQUIRED' | 'UNKNOWN' | null;
+    checks: GithubPrCheckCounts;
+}
+export interface GithubPrDiagnosticData {
+    prs: GithubPrDiagnosticRow[];
+    truncated: boolean;
+    refreshedAt: string;
+}
+export type GithubPrDiagnosticsResult = {
+    available: true;
+    data: GithubPrDiagnosticData;
+} | {
+    available: false;
+    error: 'github_pr_unavailable' | 'github_pr_invalid_response';
+};
+export interface GithubPrRunnerOptions {
+    cwd?: string;
+    timeoutMs: number;
+    maxBufferBytes: number;
+    shell: false;
+}
+export interface GithubPrRunnerResult {
+    code: number;
+    stdout: string;
+}
+export type GithubPrRunner = (command: string, args: readonly string[], options: GithubPrRunnerOptions) => Promise<GithubPrRunnerResult>;
+export interface GithubPrDiagnosticsProvider {
+    read(): Promise<GithubPrDiagnosticsResult>;
+}
+export interface GithubPrDiagnosticsProviderOptions {
+    cwd?: string;
+    runner?: GithubPrRunner;
+    now?: () => number;
+    ttlMs?: number;
+    maxItems?: number;
+}
+export declare const defaultGithubPrRunner: GithubPrRunner;
+export declare function createGithubPrDiagnosticsProvider(options?: GithubPrDiagnosticsProviderOptions): GithubPrDiagnosticsProvider;

package/dist/githubPrDiagnostics.js

@@ -0,0 +1,164 @@
+import { execFile } from 'node:child_process';
+import { redactDiagnosticText } from './diagnosticSanitize.js';
+export const GITHUB_PR_TIMEOUT_MS = 15_000;
+export const GITHUB_PR_MAX_BUFFER_BYTES = 512 * 1024;
+export const GITHUB_PR_CACHE_TTL_MS = 45_000;
+export const GITHUB_PR_MAX_ITEMS = 50;
+const GH_FIELDS = 'number,title,url,state,isDraft,headRefName,baseRefName,updatedAt,reviewDecision,statusCheckRollup';
+export const defaultGithubPrRunner = async (command, args, options) => new Promise((resolve) => {
+    execFile(command, [...args], {
+        ...(options.cwd ? { cwd: options.cwd } : {}),
+        encoding: 'utf8',
+        timeout: options.timeoutMs,
+        maxBuffer: options.maxBufferBytes,
+        shell: options.shell,
+        windowsHide: true,
+    }, (error, stdout) => {
+        const code = error && typeof error.code === 'number' ? error.code : error ? 1 : 0;
+        resolve({ code, stdout: typeof stdout === 'string' ? stdout : '' });
+    });
+});
+function boundedInteger(value, fallback, maximum) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return fallback;
+    return Math.max(1, Math.min(maximum, Math.floor(value)));
+}
+function safeText(value, maxChars) {
+    return redactDiagnosticText(value, maxChars);
+}
+function safeGithubUrl(value) {
+    if (typeof value !== 'string' || value.length > 2_000)
+        return null;
+    try {
+        const url = new URL(value);
+        const hostname = url.hostname.toLowerCase();
+        if (url.protocol !== 'https:' || url.port || (hostname !== 'github.com' && !hostname.endsWith('.github.com')))
+            return null;
+        url.username = '';
+        url.password = '';
+        url.hash = '';
+        url.search = '';
+        return url.toString().slice(0, 2_000);
+    }
+    catch {
+        return null;
+    }
+}
+function safeState(value) {
+    const state = String(value ?? '').toUpperCase();
+    return state === 'OPEN' || state === 'CLOSED' || state === 'MERGED' ? state : 'UNKNOWN';
+}
+function safeReviewDecision(value) {
+    if (value === null || value === undefined || value === '')
+        return null;
+    const decision = String(value).toUpperCase();
+    return decision === 'APPROVED' || decision === 'CHANGES_REQUESTED' || decision === 'REVIEW_REQUIRED'
+        ? decision
+        : 'UNKNOWN';
+}
+function safeTimestamp(value) {
+    if (typeof value !== 'string')
+        return null;
+    const text = safeText(value, 64);
+    return Number.isNaN(Date.parse(text)) ? null : text;
+}
+function checkCounts(value) {
+    const counts = { total: 0, passed: 0, failed: 0, pending: 0 };
+    if (!Array.isArray(value))
+        return counts;
+    for (const raw of value.slice(0, 200)) {
+        const record = raw && typeof raw === 'object' ? raw : {};
+        const status = String(record['conclusion'] ?? record['state'] ?? record['status'] ?? '').toUpperCase();
+        counts.total += 1;
+        if (['SUCCESS', 'NEUTRAL', 'SKIPPED'].includes(status))
+            counts.passed += 1;
+        else if (['FAILURE', 'ERROR', 'CANCELLED', 'TIMED_OUT', 'ACTION_REQUIRED', 'STARTUP_FAILURE'].includes(status))
+            counts.failed += 1;
+        else
+            counts.pending += 1;
+    }
+    return counts;
+}
+function parsePr(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const record = raw;
+    const number = typeof record['number'] === 'number' ? Math.floor(record['number']) : Number.NaN;
+    const url = safeGithubUrl(record['url']);
+    if (!Number.isSafeInteger(number) || number <= 0 || !url)
+        return null;
+    return {
+        number,
+        title: safeText(record['title'], 300),
+        url,
+        state: safeState(record['state']),
+        isDraft: record['isDraft'] === true,
+        head: safeText(record['headRefName'], 200),
+        base: safeText(record['baseRefName'], 200),
+        updatedAt: safeTimestamp(record['updatedAt']),
+        reviewDecision: safeReviewDecision(record['reviewDecision']),
+        checks: checkCounts(record['statusCheckRollup']),
+    };
+}
+async function loadGithubPrDiagnostics(runner, options) {
+    try {
+        const result = await runner('gh', [
+            'pr', 'list', '--state', 'all', '--limit', String(options.maxItems), '--json', GH_FIELDS,
+        ], {
+            ...(options.cwd ? { cwd: options.cwd } : {}),
+            timeoutMs: GITHUB_PR_TIMEOUT_MS,
+            maxBufferBytes: GITHUB_PR_MAX_BUFFER_BYTES,
+            shell: false,
+        });
+        if (result.code !== 0)
+            return { available: false, error: 'github_pr_unavailable' };
+        let raw;
+        try {
+            raw = JSON.parse(result.stdout || '[]');
+        }
+        catch {
+            return { available: false, error: 'github_pr_invalid_response' };
+        }
+        if (!Array.isArray(raw))
+            return { available: false, error: 'github_pr_invalid_response' };
+        const selected = raw.slice(0, options.maxItems);
+        const prs = selected.map(parsePr).filter((row) => row !== null);
+        return {
+            available: true,
+            data: {
+                prs,
+                truncated: raw.length > selected.length || prs.length < selected.length,
+                refreshedAt: new Date(options.now()).toISOString(),
+            },
+        };
+    }
+    catch {
+        return { available: false, error: 'github_pr_unavailable' };
+    }
+}
+export function createGithubPrDiagnosticsProvider(options = {}) {
+    const runner = options.runner ?? defaultGithubPrRunner;
+    const now = options.now ?? Date.now;
+    const requestedTtl = boundedInteger(options.ttlMs, GITHUB_PR_CACHE_TTL_MS, 60_000);
+    const ttlMs = Math.max(30_000, requestedTtl);
+    const maxItems = boundedInteger(options.maxItems, GITHUB_PR_MAX_ITEMS, GITHUB_PR_MAX_ITEMS);
+    let cached = null;
+    let inflight = null;
+    return {
+        read() {
+            const current = now();
+            if (cached && current - cached.at < ttlMs)
+                return Promise.resolve(cached.value);
+            if (inflight)
+                return inflight;
+            inflight = loadGithubPrDiagnostics(runner, { cwd: options.cwd, now, maxItems })
+                .then((value) => {
+                if (value.available)
+                    cached = { at: now(), value };
+                return value;
+            })
+                .finally(() => { inflight = null; });
+            return inflight;
+        },
+    };
+}

package/dist/index.d.ts

@@ -1,3 +1,6 @@
 export declare const PACKAGE = "@evomap/evolver-webui";
 export * from './server.js';
-export { CONSOLE_HTML } from './console.js';
+export { CONSOLE_HTML } from './console.js';
+export * from './personalityDiagnostics.js';
+export * from './logDiagnostics.js';
+export * from './githubPrDiagnostics.js';

package/dist/index.js

@@ -1,3 +1,6 @@
 export const PACKAGE = '@evomap/evolver-webui';
 export * from './server.js';
-export { CONSOLE_HTML } from './console.js';
+export { CONSOLE_HTML } from './console.js';
+export * from './personalityDiagnostics.js';
+export * from './logDiagnostics.js';
+export * from './githubPrDiagnostics.js';

package/dist/jsoncScannerShim.d.ts

@@ -0,0 +1,7 @@
+export interface JsoncScanner {
+    scan(): number;
+    getTokenOffset(): number;
+    getTokenLength(): number;
+    getTokenValue(): string;
+}
+export declare const createScanner: (text: string, ignoreTrivia?: boolean) => JsoncScanner;

package/dist/jsoncScannerShim.js

@@ -0,0 +1,10 @@
+// jsonc-parser's main entry is a UMD wrapper whose shadowed `require` leaves
+// './impl/format' unresolved inside bun standalone binaries, and its ESM entry
+// uses extensionless imports that Node ESM rejects. Depend on the scanner impl
+// directly: it has no sibling dependencies, so bundlers can inline it safely.
+// Use a default import because the impl is CommonJS and named CJS exports are
+// not reliably detected by Node's ESM loader. The explicit JsoncScanner type
+// keeps the emitted .d.ts self-contained so consumers never resolve the deep
+// specifier.
+import scannerImpl from 'jsonc-parser/lib/umd/impl/scanner.js';
+export const createScanner = scannerImpl.createScanner;

package/dist/logDiagnostics.d.ts

@@ -0,0 +1,18 @@
+export declare const LOG_DIAGNOSTICS_MAX_BYTES: number;
+export declare const LOG_DIAGNOSTICS_MAX_LINES = 200;
+export interface LogDiagnosticsData {
+    lines: string[];
+    truncated: boolean;
+}
+export type LogDiagnosticsResult = {
+    available: true;
+    data: LogDiagnosticsData;
+} | {
+    available: false;
+    error: 'log_not_found' | 'log_unavailable';
+};
+export interface LogDiagnosticsOptions {
+    maxBytes?: number;
+    maxLines?: number;
+}
+export declare function readLogDiagnostics(logFile: string, options?: LogDiagnosticsOptions): LogDiagnosticsResult;

package/dist/logDiagnostics.js

@@ -0,0 +1,103 @@
+import { closeSync, constants, fstatSync, lstatSync, openSync, readSync } from 'node:fs';
+import { hub } from '@evomap/evolver-core';
+import { redactSensitiveHttpHeaders } from './diagnosticSanitize.js';
+export const LOG_DIAGNOSTICS_MAX_BYTES = 128 * 1024;
+export const LOG_DIAGNOSTICS_MAX_LINES = 200;
+const LOG_DIAGNOSTICS_HARD_MAX_BYTES = 1024 * 1024;
+const LOG_DIAGNOSTICS_HARD_MAX_LINES = 1_000;
+const MAX_LINE_CHARS = 4_000;
+function boundedInteger(value, fallback, maximum) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return fallback;
+    return Math.max(1, Math.min(maximum, Math.floor(value)));
+}
+function redactSecrets(input) {
+    let text = replaceUnsafeControls(input);
+    text = text.replace(/-----BEGIN(?: [A-Z0-9]+)* PRIVATE KEY-----[\s\S]*?-----END(?: [A-Z0-9]+)* PRIVATE KEY-----/gi, '[redacted private key]');
+    text = text.replace(/-----BEGIN(?: [A-Z0-9]+)* PRIVATE KEY-----[\s\S]*$/gi, '[redacted private key]');
+    text = text.replace(/\bBearer\s+[^\s,;"']+/gi, 'Bearer [redacted]');
+    text = text.replace(/\b(proxy[-_]?authorization|authorization)\b(\s*=\s*)(?!(?:"|')?\[redacted\](?:"|')?)(?:"[^"]*"|'[^']*'|[^\s,;"']+)/gi, '$1$2[redacted]');
+    text = text.replace(/\b(cookie|set[-_]?cookie)\b(\s*=\s*)(?!(?:"|')?\[redacted\](?:"|')?)(?:"[^"]*"|'[^']*'|[^\s,;"']+)/gi, '$1$2[redacted]');
+    text = text.replace(/\b(api[_ -]?key|token|access[_ -]?token|refresh[_ -]?token|password|passwd)\b(\s*[=:]\s*)(?!(?:"|')?\[redacted\](?:"|')?)(?:"[^"]*"|'[^']*'|[^\s,;"']+)/gi, '$1$2[redacted]');
+    text = text.replace(/([?&](?:api[_-]?key|token|access_token|password)=)[^&\s]+/gi, '$1[redacted]');
+    text = text.replace(/\b(id[_ -]?token|private[_ -]?key|node[_ -]?secret|account[_ -]?key|instrumentation[_ -]?key)\b(\s*[=:]\s*)[^\s,;]+/gi, '$1$2[redacted]');
+    return text
+        .split('[redacted]')
+        .map((segment) => hub.redactString(segment))
+        .join('[redacted]');
+}
+function replaceUnsafeControls(value) {
+    let out = '';
+    for (const char of value) {
+        const code = char.codePointAt(0) ?? 0;
+        out += code >= 0x20 || code === 0x09 || code === 0x0a || code === 0x0d ? char : ' ';
+    }
+    return out;
+}
+function safeLine(line) {
+    const normalized = replaceUnsafeControls(line);
+    if (/^[A-Za-z0-9+/]{40,}={0,2}$/.test(normalized.trim()))
+        return '[redacted private key material]';
+    return normalized.slice(0, MAX_LINE_CHARS);
+}
+function redactTruncatedLeadingContinuations(value) {
+    return value.replace(/^(?:[ \t]+[^\r\n]*(?:\r?\n|$))+/, '[redacted truncated continuation]\n');
+}
+export function readLogDiagnostics(logFile, options = {}) {
+    const maxBytes = boundedInteger(options.maxBytes, LOG_DIAGNOSTICS_MAX_BYTES, LOG_DIAGNOSTICS_HARD_MAX_BYTES);
+    const maxLines = boundedInteger(options.maxLines, LOG_DIAGNOSTICS_MAX_LINES, LOG_DIAGNOSTICS_HARD_MAX_LINES);
+    let fd;
+    try {
+        const before = lstatSync(logFile);
+        if (before.isSymbolicLink() || !before.isFile())
+            return { available: false, error: 'log_unavailable' };
+        const noFollow = constants.O_NOFOLLOW ?? 0;
+        fd = openSync(logFile, constants.O_RDONLY | noFollow);
+        const stats = fstatSync(fd);
+        const current = lstatSync(logFile);
+        if (current.isSymbolicLink() || !current.isFile() || !stats.isFile()
+            || current.dev !== stats.dev || current.ino !== stats.ino) {
+            return { available: false, error: 'log_unavailable' };
+        }
+        const size = stats.size;
+        const bytes = Math.min(size, maxBytes);
+        const start = Math.max(0, size - bytes);
+        const buffer = Buffer.alloc(bytes);
+        if (bytes > 0)
+            readSync(fd, buffer, 0, bytes, start);
+        let startsAtLineBoundary = start === 0;
+        if (start > 0) {
+            const previous = Buffer.allocUnsafe(1);
+            startsAtLineBoundary = readSync(fd, previous, 0, 1, start - 1) === 1 && previous[0] === 0x0a;
+        }
+        let text = buffer.toString('utf8');
+        if (start > 0) {
+            if (!startsAtLineBoundary) {
+                const firstNewline = text.indexOf('\n');
+                text = firstNewline >= 0 ? text.slice(firstNewline + 1) : '';
+            }
+            text = redactTruncatedLeadingContinuations(replaceUnsafeControls(redactSensitiveHttpHeaders(text)));
+        }
+        else {
+            text = replaceUnsafeControls(redactSensitiveHttpHeaders(text));
+        }
+        const redacted = redactSecrets(text);
+        const allLines = redacted.split(/\r?\n/).filter((line) => line.length > 0);
+        const lineTruncated = allLines.length > maxLines;
+        return {
+            available: true,
+            data: {
+                lines: allLines.slice(-maxLines).map(safeLine),
+                truncated: start > 0 || lineTruncated,
+            },
+        };
+    }
+    catch (error) {
+        const code = error && typeof error === 'object' ? error.code : undefined;
+        return { available: false, error: code === 'ENOENT' ? 'log_not_found' : 'log_unavailable' };
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+    }
+}

package/dist/observabilityRelations.d.ts

@@ -0,0 +1,22 @@
+import type { events as ev } from '@evomap/evolver-core';
+export interface AssetRelation {
+    id: string;
+    assetId: string;
+    type: string;
+}
+export interface TrajectoryRelation {
+    traceId: string;
+    sessionId: string;
+}
+export interface PullRequestRelation {
+    number: number | null;
+    url: string;
+    repo: string;
+}
+export interface ObservabilityRelations {
+    assets: AssetRelation[];
+    trajectories: TrajectoryRelation[];
+    pullRequests: PullRequestRelation[];
+}
+export declare function eventRelations(event: ev.ReportEvent): ObservabilityRelations;
+export declare function eventListRelations(events: readonly ev.ReportEvent[]): ObservabilityRelations;