@pellux/goodvibes-sdk 0.18.3 → 0.18.12

package/dist/_internal/platform/runtime/contracts/validators/runtime-state.js

@@ -0,0 +1,101 @@
+/**
+ * Compatibility Contracts — RuntimeState Validator
+ *
+ * Performs runtime shape validation for the top-level RuntimeState snapshot schema.
+ * Returns a structured ValidationResult rather than throwing.
+ *
+ * @module contracts/validators/runtime-state
+ */
+/**
+ * Expected top-level field names for a RuntimeState snapshot.
+ * Validated as required string/object fields at the top level.
+ */
+const REQUIRED_FIELDS = ['version', 'domains'];
+/**
+ * Validates that `data` conforms to the expected RuntimeState snapshot shape.
+ *
+ * Checks:
+ * - `data` is a non-null object
+ * - `version` is present and has numeric `major`, `minor`, `patch` fields
+ * - `domains` is present and is a non-null object
+ *
+ * @param data - The raw persisted data to validate.
+ * @returns A ValidationResult with `valid: true` if the shape is correct,
+ *   or `valid: false` with a list of errors if any required field is missing or malformed.
+ */
+export function validateRuntimeState(data) {
+    const errors = [];
+    if (data === null || typeof data !== 'object') {
+        errors.push({
+            path: '',
+            message: 'RuntimeState must be a non-null object',
+            expected: 'object',
+            actual: data === null ? 'null' : typeof data,
+        });
+        return { valid: false, errors };
+    }
+    const record = data;
+    // Check all required top-level fields are present
+    for (const field of REQUIRED_FIELDS) {
+        if (!(field in record)) {
+            errors.push({
+                path: field,
+                message: `Missing required field '${field}'`,
+                expected: 'present',
+                actual: 'undefined',
+            });
+        }
+    }
+    // Validate version shape: { major: number, minor: number, patch: number }
+    let detectedVersion;
+    const versionRaw = record['version'];
+    if (versionRaw !== undefined) {
+        if (versionRaw === null || typeof versionRaw !== 'object') {
+            errors.push({
+                path: 'version',
+                message: 'Field \'version\' must be a non-null object',
+                expected: '{ major: number, minor: number, patch: number }',
+                actual: versionRaw === null ? 'null' : typeof versionRaw,
+            });
+        }
+        else {
+            const v = versionRaw;
+            const vErrors = [];
+            for (const component of ['major', 'minor', 'patch']) {
+                if (typeof v[component] !== 'number') {
+                    vErrors.push({
+                        path: `version.${component}`,
+                        message: `Field 'version.${component}' must be a number`,
+                        expected: 'number',
+                        actual: v[component] === null ? 'null' : typeof v[component],
+                    });
+                }
+            }
+            errors.push(...vErrors);
+            if (vErrors.length === 0) {
+                detectedVersion = {
+                    major: v['major'],
+                    minor: v['minor'],
+                    patch: v['patch'],
+                };
+            }
+        }
+    }
+    // Validate domains is a non-null object
+    const domainsRaw = record['domains'];
+    if (domainsRaw !== undefined) {
+        if (domainsRaw === null || typeof domainsRaw !== 'object' || Array.isArray(domainsRaw)) {
+            errors.push({
+                path: 'domains',
+                message: "Field 'domains' must be a non-null, non-array object",
+                expected: 'object',
+                actual: domainsRaw === null ? 'null' : Array.isArray(domainsRaw) ? 'array' : typeof domainsRaw,
+            });
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        version: detectedVersion,
+    };
+}

package/dist/_internal/platform/runtime/contracts/validators/session.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Compatibility Contracts — Session Validator
+ *
+ * Performs runtime shape validation for the session persistence format
+ * (messages array + meta object). Returns a structured ValidationResult.
+ *
+ * @module contracts/validators/session
+ */
+import type { ValidationResult } from '../types.js';
+/**
+ * Validates that `data` conforms to the expected session persistence shape.
+ *
+ * Checks:
+ * - `data` is a non-null object
+ * - `sessionId` is a non-empty string
+ * - `messages` is an array (contents are not deeply validated)
+ * - `meta` is a non-null, non-array object
+ * - `meta.version` (if present) has numeric `major`, `minor`, `patch` fields
+ *
+ * @param data - The raw persisted data to validate.
+ * @returns A ValidationResult with structured errors if any field is invalid.
+ */
+export declare function validateSession(data: unknown): ValidationResult;
+//# sourceMappingURL=session.d.ts.map

package/dist/_internal/platform/runtime/contracts/validators/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../../../../../src/_internal/platform/runtime/contracts/validators/session.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAkC,MAAM,aAAa,CAAC;AAEpF;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,GAAG,gBAAgB,CAmF/D"}

package/dist/_internal/platform/runtime/contracts/validators/session.js

@@ -0,0 +1,103 @@
+/**
+ * Compatibility Contracts — Session Validator
+ *
+ * Performs runtime shape validation for the session persistence format
+ * (messages array + meta object). Returns a structured ValidationResult.
+ *
+ * @module contracts/validators/session
+ */
+/**
+ * Validates that `data` conforms to the expected session persistence shape.
+ *
+ * Checks:
+ * - `data` is a non-null object
+ * - `sessionId` is a non-empty string
+ * - `messages` is an array (contents are not deeply validated)
+ * - `meta` is a non-null, non-array object
+ * - `meta.version` (if present) has numeric `major`, `minor`, `patch` fields
+ *
+ * @param data - The raw persisted data to validate.
+ * @returns A ValidationResult with structured errors if any field is invalid.
+ */
+export function validateSession(data) {
+    const errors = [];
+    if (data === null || typeof data !== 'object') {
+        errors.push({
+            path: '',
+            message: 'Session must be a non-null object',
+            expected: 'object',
+            actual: data === null ? 'null' : typeof data,
+        });
+        return { valid: false, errors };
+    }
+    const record = data;
+    // Validate sessionId: non-empty string
+    const sessionIdRaw = record['sessionId'];
+    if (typeof sessionIdRaw !== 'string' || sessionIdRaw.length === 0) {
+        errors.push({
+            path: 'sessionId',
+            message: "Field 'sessionId' must be a non-empty string",
+            expected: 'non-empty string',
+            actual: sessionIdRaw === undefined ? 'undefined' : sessionIdRaw === null ? 'null' : typeof sessionIdRaw,
+        });
+    }
+    // Validate messages: array
+    const messagesRaw = record['messages'];
+    if (!Array.isArray(messagesRaw)) {
+        errors.push({
+            path: 'messages',
+            message: "Field 'messages' must be an array",
+            expected: 'array',
+            actual: messagesRaw === undefined ? 'undefined' : messagesRaw === null ? 'null' : typeof messagesRaw,
+        });
+    }
+    // Validate meta: non-null, non-array object
+    const metaRaw = record['meta'];
+    if (metaRaw === undefined || metaRaw === null || typeof metaRaw !== 'object' || Array.isArray(metaRaw)) {
+        errors.push({
+            path: 'meta',
+            message: "Field 'meta' must be a non-null, non-array object",
+            expected: 'object',
+            actual: metaRaw === undefined ? 'undefined' : metaRaw === null ? 'null' : Array.isArray(metaRaw) ? 'array' : typeof metaRaw,
+        });
+    }
+    // Detect version from meta.version if present
+    let detectedVersion;
+    if (metaRaw !== undefined && metaRaw !== null && typeof metaRaw === 'object' && !Array.isArray(metaRaw)) {
+        const meta = metaRaw;
+        const versionRaw = meta['version'];
+        if (versionRaw !== undefined && versionRaw !== null && typeof versionRaw === 'object') {
+            const v = versionRaw;
+            const allNumeric = typeof v['major'] === 'number' &&
+                typeof v['minor'] === 'number' &&
+                typeof v['patch'] === 'number';
+            if (allNumeric) {
+                detectedVersion = {
+                    major: v['major'],
+                    minor: v['minor'],
+                    patch: v['patch'],
+                };
+            }
+            else {
+                let actualStr;
+                try {
+                    actualStr = JSON.stringify(versionRaw);
+                }
+                catch {
+                    actualStr = String(versionRaw);
+                }
+                errors.push({
+                    path: 'meta.version',
+                    message: "Field 'meta.version' must have numeric major, minor, patch components",
+                    expected: '{ major: number, minor: number, patch: number }',
+                    actual: actualStr,
+                });
+            }
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        version: detectedVersion,
+    };
+}

package/dist/_internal/platform/runtime/contracts/version.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Compatibility Contracts — Current Schema Versions
+ *
+ * Declares the authoritative current schema version for each versioned domain.
+ * Bump these when making structural changes to the corresponding schema.
+ *
+ * @module contracts/version
+ */
+/**
+ * Current schema versions for all versioned runtime domains.
+ *
+ * Rules for bumping:
+ * - Bump `major` when the change is breaking (requires migration)
+ * - Bump `minor` when adding optional fields (additive, backward-compatible)
+ * - Bump `patch` for non-structural documentation or annotation changes
+ */
+export declare const SCHEMA_VERSIONS: {
+    /** Top-level RuntimeState snapshot schema. */
+    readonly runtimeState: {
+        readonly major: 1;
+        readonly minor: 0;
+        readonly patch: 0;
+    };
+    /** RuntimeEventEnvelope schema for event persistence and replay. */
+    readonly eventEnvelope: {
+        readonly major: 1;
+        readonly minor: 0;
+        readonly patch: 0;
+    };
+    /** Session persistence format (messages + meta). */
+    readonly session: {
+        readonly major: 1;
+        readonly minor: 0;
+        readonly patch: 0;
+    };
+    /** Plugin manifest and capability descriptor schema. */
+    readonly pluginManifest: {
+        readonly major: 1;
+        readonly minor: 0;
+        readonly patch: 0;
+    };
+    /** RuntimeTask record schema used in task domain persistence. */
+    readonly taskRecord: {
+        readonly major: 1;
+        readonly minor: 0;
+        readonly patch: 0;
+    };
+};
+/**
+ * The minimum schema version supported for migration for each domain.
+ *
+ * Data older than this version cannot be migrated and must be discarded
+ * or re-initialized. This is updated when old migration steps are pruned.
+ */
+export declare const MIN_SUPPORTED_VERSIONS: {
+    readonly runtimeState: {
+        readonly major: 1;
+        readonly minor: 0;
+        readonly patch: 0;
+    };
+    readonly eventEnvelope: {
+        readonly major: 1;
+        readonly minor: 0;
+        readonly patch: 0;
+    };
+    readonly session: {
+        readonly major: 1;
+        readonly minor: 0;
+        readonly patch: 0;
+    };
+    readonly pluginManifest: {
+        readonly major: 1;
+        readonly minor: 0;
+        readonly patch: 0;
+    };
+    readonly taskRecord: {
+        readonly major: 1;
+        readonly minor: 0;
+        readonly patch: 0;
+    };
+};
+/** Union of all known contract names. */
+export type ContractName = keyof typeof SCHEMA_VERSIONS;
+//# sourceMappingURL=version.d.ts.map

package/dist/_internal/platform/runtime/contracts/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/contracts/version.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe;IAC1B,8CAA8C;;;;;;IAE9C,oEAAoE;;;;;;IAEpE,oDAAoD;;;;;;IAEpD,wDAAwD;;;;;;IAExD,iEAAiE;;;;;;CAEzD,CAAC;AAEX;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;CAMzB,CAAC;AAEX,yCAAyC;AACzC,MAAM,MAAM,YAAY,GAAG,MAAM,OAAO,eAAe,CAAC"}

package/dist/_internal/platform/runtime/contracts/version.js

@@ -0,0 +1,41 @@
+/**
+ * Compatibility Contracts — Current Schema Versions
+ *
+ * Declares the authoritative current schema version for each versioned domain.
+ * Bump these when making structural changes to the corresponding schema.
+ *
+ * @module contracts/version
+ */
+/**
+ * Current schema versions for all versioned runtime domains.
+ *
+ * Rules for bumping:
+ * - Bump `major` when the change is breaking (requires migration)
+ * - Bump `minor` when adding optional fields (additive, backward-compatible)
+ * - Bump `patch` for non-structural documentation or annotation changes
+ */
+export const SCHEMA_VERSIONS = {
+    /** Top-level RuntimeState snapshot schema. */
+    runtimeState: { major: 1, minor: 0, patch: 0 },
+    /** RuntimeEventEnvelope schema for event persistence and replay. */
+    eventEnvelope: { major: 1, minor: 0, patch: 0 },
+    /** Session persistence format (messages + meta). */
+    session: { major: 1, minor: 0, patch: 0 },
+    /** Plugin manifest and capability descriptor schema. */
+    pluginManifest: { major: 1, minor: 0, patch: 0 },
+    /** RuntimeTask record schema used in task domain persistence. */
+    taskRecord: { major: 1, minor: 0, patch: 0 },
+};
+/**
+ * The minimum schema version supported for migration for each domain.
+ *
+ * Data older than this version cannot be migrated and must be discarded
+ * or re-initialized. This is updated when old migration steps are pruned.
+ */
+export const MIN_SUPPORTED_VERSIONS = {
+    runtimeState: { major: 1, minor: 0, patch: 0 },
+    eventEnvelope: { major: 1, minor: 0, patch: 0 },
+    session: { major: 1, minor: 0, patch: 0 },
+    pluginManifest: { major: 1, minor: 0, patch: 0 },
+    taskRecord: { major: 1, minor: 0, patch: 0 },
+};

package/dist/_internal/platform/runtime/deferred-startup.d.ts

@@ -0,0 +1,12 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+export interface DeferredStartupTask {
+    readonly label: string;
+    readonly run: () => void | Promise<void>;
+    readonly onError?: (error: unknown) => void;
+}
+export interface DeferredStartupCoordinator {
+    schedule(task: DeferredStartupTask): Promise<void>;
+    drain(timeoutMs?: number): Promise<void>;
+}
+export declare function createDeferredStartupCoordinator(scheduler?: (callback: () => void) => void): DeferredStartupCoordinator;
+//# sourceMappingURL=deferred-startup.d.ts.map

package/dist/_internal/platform/runtime/deferred-startup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deferred-startup.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/runtime/deferred-startup.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAErF,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAC7C;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnD,KAAK,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1C;AAED,wBAAgB,gCAAgC,CAC9C,SAAS,GAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAA4C,GAChF,0BAA0B,CAqC5B"}

package/dist/_internal/platform/runtime/deferred-startup.js

@@ -0,0 +1,38 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+export function createDeferredStartupCoordinator(scheduler = (callback) => setTimeout(callback, 0)) {
+    const pending = new Set();
+    return {
+        schedule(task) {
+            let promise;
+            promise = new Promise((resolve) => {
+                scheduler(() => {
+                    Promise.resolve()
+                        .then(() => task.run())
+                        .catch((error) => {
+                        task.onError?.(error);
+                    })
+                        .finally(() => {
+                        pending.delete(promise);
+                        resolve();
+                    });
+                });
+            });
+            pending.add(promise);
+            return promise;
+        },
+        async drain(timeoutMs) {
+            const snapshot = [...pending];
+            if (snapshot.length === 0)
+                return;
+            const settle = Promise.allSettled(snapshot).then(() => undefined);
+            if (timeoutMs == null) {
+                await settle;
+                return;
+            }
+            await Promise.race([
+                settle,
+                new Promise((resolve) => setTimeout(resolve, timeoutMs)),
+            ]);
+        },
+    };
+}

package/dist/_internal/platform/runtime/diagnostics/panels/divergence.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Divergence diagnostics panel data provider.
+ *
+ * Wraps a `DivergenceDashboard` and exposes its state for the diagnostics
+ * view as a snapshot-based panel. Subscribers are notified whenever a new
+ * trend entry is recorded.
+ *
+ * This panel is push-passive: it does not drive the sampling timer itself.
+ * The caller (or a coordinator) must call `recordTrendEntry()` periodically.
+ */
+import type { DivergenceDashboardSnapshot, EnforceGateResult } from '../../permissions/divergence-dashboard.js';
+import { DivergenceDashboard } from '../../permissions/divergence-dashboard.js';
+import type { PanelConfig } from '../types.js';
+/**
+ * DivergencePanel — diagnostics data provider for the divergence dashboard.
+ *
+ * Usage:
+ * ```ts
+ * const panel = new DivergencePanel(dashboard);
+ * panel.subscribe(() => {
+ *   const snap = panel.getSnapshot();
+ *   render(snap);
+ * });
+ *
+ * // Drive sampling externally:
+ * setInterval(() => panel.recordTrendEntry(), 30_000);
+ *
+ * // On cleanup:
+ * panel.dispose();
+ * ```
+ */
+export declare class DivergencePanel {
+    private readonly _dashboard;
+    private readonly _config;
+    private readonly _subscribers;
+    constructor(dashboard: DivergenceDashboard, config?: PanelConfig);
+    /**
+     * recordTrendEntry — Captures a trend snapshot and notifies subscribers.
+     *
+     * Call this on a periodic timer (e.g. every 30 seconds) to build trend
+     * history. The panel respects `bufferLimit` for display purposes; the
+     * dashboard's own ring buffer governs actual retention.
+     */
+    recordTrendEntry(): void;
+    /**
+     * getSnapshot — Returns the current full dashboard snapshot.
+     *
+     * The trend is capped at `bufferLimit` entries for display.
+     */
+    getSnapshot(): DivergenceDashboardSnapshot;
+    /**
+     * checkEnforceGate — Delegates to the underlying dashboard's gate check.
+     */
+    checkEnforceGate(): EnforceGateResult;
+    /**
+     * Register a callback invoked whenever a trend entry is recorded.
+     * @returns An unsubscribe function.
+     */
+    subscribe(callback: () => void): () => void;
+    /**
+     * Release all subscriptions.
+     */
+    dispose(): void;
+    private _notify;
+}
+//# sourceMappingURL=divergence.d.ts.map

package/dist/_internal/platform/runtime/diagnostics/panels/divergence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"divergence.d.ts","sourceRoot":"","sources":["../../../../../../src/_internal/platform/runtime/diagnostics/panels/divergence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,2BAA2B,EAAE,iBAAiB,EAAE,MAAM,2CAA2C,CAAC;AAChH,OAAO,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AAChF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAsB;IACjD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAc;IACtC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAyB;gBAGpD,SAAS,EAAE,mBAAmB,EAC9B,MAAM,GAAE,WAAkC;IAM5C;;;;;;OAMG;IACI,gBAAgB,IAAI,IAAI;IAK/B;;;;OAIG;IACI,WAAW,IAAI,2BAA2B;IAQjD;;OAEG;IACI,gBAAgB,IAAI,iBAAiB;IAI5C;;;OAGG;IACI,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAKlD;;OAEG;IACI,OAAO,IAAI,IAAI;IAItB,OAAO,CAAC,OAAO;CAUhB"}

package/dist/_internal/platform/runtime/diagnostics/panels/divergence.js

@@ -0,0 +1,93 @@
+/**
+ * Divergence diagnostics panel data provider.
+ *
+ * Wraps a `DivergenceDashboard` and exposes its state for the diagnostics
+ * view as a snapshot-based panel. Subscribers are notified whenever a new
+ * trend entry is recorded.
+ *
+ * This panel is push-passive: it does not drive the sampling timer itself.
+ * The caller (or a coordinator) must call `recordTrendEntry()` periodically.
+ */
+import { DivergenceDashboard } from '../../permissions/divergence-dashboard.js';
+import { DEFAULT_PANEL_CONFIG } from '../types.js';
+/**
+ * DivergencePanel — diagnostics data provider for the divergence dashboard.
+ *
+ * Usage:
+ * ```ts
+ * const panel = new DivergencePanel(dashboard);
+ * panel.subscribe(() => {
+ *   const snap = panel.getSnapshot();
+ *   render(snap);
+ * });
+ *
+ * // Drive sampling externally:
+ * setInterval(() => panel.recordTrendEntry(), 30_000);
+ *
+ * // On cleanup:
+ * panel.dispose();
+ * ```
+ */
+export class DivergencePanel {
+    _dashboard;
+    _config;
+    _subscribers = new Set();
+    constructor(dashboard, config = DEFAULT_PANEL_CONFIG) {
+        this._dashboard = dashboard;
+        this._config = config;
+    }
+    /**
+     * recordTrendEntry — Captures a trend snapshot and notifies subscribers.
+     *
+     * Call this on a periodic timer (e.g. every 30 seconds) to build trend
+     * history. The panel respects `bufferLimit` for display purposes; the
+     * dashboard's own ring buffer governs actual retention.
+     */
+    recordTrendEntry() {
+        this._dashboard.recordTrendEntry();
+        this._notify();
+    }
+    /**
+     * getSnapshot — Returns the current full dashboard snapshot.
+     *
+     * The trend is capped at `bufferLimit` entries for display.
+     */
+    getSnapshot() {
+        const raw = this._dashboard.getSnapshot();
+        // Apply display-level buffer cap to trend history.
+        const limit = this._config.bufferLimit;
+        const trend = raw.trend.length > limit ? raw.trend.slice(-limit) : raw.trend;
+        return { ...raw, trend };
+    }
+    /**
+     * checkEnforceGate — Delegates to the underlying dashboard's gate check.
+     */
+    checkEnforceGate() {
+        return this._dashboard.checkEnforceGate();
+    }
+    /**
+     * Register a callback invoked whenever a trend entry is recorded.
+     * @returns An unsubscribe function.
+     */
+    subscribe(callback) {
+        this._subscribers.add(callback);
+        return () => this._subscribers.delete(callback);
+    }
+    /**
+     * Release all subscriptions.
+     */
+    dispose() {
+        this._subscribers.clear();
+    }
+    _notify() {
+        for (const cb of this._subscribers) {
+            try {
+                cb();
+            }
+            catch (err) {
+                // Non-fatal: subscriber errors must not crash the panel
+                console.debug('[DivergencePanel] subscriber error:', err);
+            }
+        }
+    }
+}

package/dist/_internal/platform/runtime/diagnostics/panels/forensics.d.ts

@@ -0,0 +1,38 @@
+/**
+ * ForensicsDataPanel — diagnostic data provider for the Forensics panel.
+ *
+ * Bridges the ForensicsRegistry into the panel subscription model,
+ * following the same pattern as OpsPanel and TasksPanel.
+ */
+import type { PanelConfig } from '../types.js';
+import type { FailureReport } from '../../forensics/types.js';
+import type { ForensicsRegistry } from '../../forensics/registry.js';
+export declare class ForensicsDataPanel {
+    private readonly _config;
+    private readonly _registry;
+    private readonly _subscribers;
+    private _unsub;
+    constructor(registry: ForensicsRegistry, config?: PanelConfig);
+    /**
+     * Return all reports, newest first, capped at bufferLimit.
+     */
+    getAll(): FailureReport[];
+    /**
+     * Return the most recent report.
+     */
+    latest(): FailureReport | undefined;
+    /**
+     * Return a report by ID.
+     */
+    getById(id: string): FailureReport | undefined;
+    /**
+     * Subscribe to data changes. Returns an unsubscribe function.
+     */
+    subscribe(callback: () => void): () => void;
+    /**
+     * Dispose the data panel, unsubscribing from the registry.
+     */
+    dispose(): void;
+    private _notify;
+}
+//# sourceMappingURL=forensics.d.ts.map

package/dist/_internal/platform/runtime/diagnostics/panels/forensics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forensics.d.ts","sourceRoot":"","sources":["../../../../../../src/_internal/platform/runtime/diagnostics/panels/forensics.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAErE,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAc;IACtC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAoB;IAC9C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAyB;IACtD,OAAO,CAAC,MAAM,CAA6B;gBAGzC,QAAQ,EAAE,iBAAiB,EAC3B,MAAM,GAAE,WAAkC;IAO5C;;OAEG;IACI,MAAM,IAAI,aAAa,EAAE;IAKhC;;OAEG;IACI,MAAM,IAAI,aAAa,GAAG,SAAS;IAI1C;;OAEG;IACI,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAIrD;;OAEG;IACI,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAKlD;;OAEG;IACI,OAAO,IAAI,IAAI;IAQtB,OAAO,CAAC,OAAO;CAKhB"}