@pellux/goodvibes-sdk 0.18.3 → 0.18.11

package/dist/platform/runtime/inspection/state-inspector/timeline.js

@@ -0,0 +1,198 @@
+import { DEFAULT_TIMELINE_BUFFER_SIZE } from './types.js';
+/**
+ * TimelineBuffer — fixed-capacity ring buffer of TimelineEvent snapshots.
+ *
+ * Indices are stable within a session (they increment monotonically via
+ * the `seq` field on each event). The cursor is an offset into the live
+ * ring: 0 = oldest retained, size-1 = newest, size = live.
+ */
+export class TimelineBuffer {
+    _maxSize;
+    _ring;
+    _head = 0; // next write position
+    _totalAppended = 0;
+    _cursor; // live by default
+    _nextSeq = 1;
+    /**
+     * @param maxSize — Maximum events to retain. Must be >= 2.
+     * @default DEFAULT_TIMELINE_BUFFER_SIZE
+     */
+    constructor(maxSize = DEFAULT_TIMELINE_BUFFER_SIZE) {
+        if (maxSize < 2)
+            throw new RangeError(`maxSize must be >= 2, got ${maxSize}`);
+        this._maxSize = maxSize;
+        this._ring = new Array(maxSize).fill(undefined);
+        this._cursor = 0; // starts at live (size === 0 initially)
+    }
+    // ── Capacity ──────────────────────────────────────────────────────────────
+    /** Maximum events retained. */
+    get maxSize() {
+        return this._maxSize;
+    }
+    /** Current number of events retained (capped at maxSize). */
+    get size() {
+        return Math.min(this._totalAppended, this._maxSize);
+    }
+    /** Total events ever appended (monotonically increasing). */
+    get totalAppended() {
+        return this._totalAppended;
+    }
+    // ── Cursor state ─────────────────────────────────────────────────────────
+    /**
+     * Whether the cursor is at the live position (past the newest event).
+     * When live, `getCurrentSnapshot()` returns undefined.
+     */
+    get isLive() {
+        return this._cursor >= this.size;
+    }
+    /** Current cursor state for display. */
+    get cursorState() {
+        const s = this.size;
+        return {
+            index: this._cursor,
+            total: s,
+            isLive: this.isLive,
+        };
+    }
+    // ── Append ────────────────────────────────────────────────────────────────
+    /**
+     * Append a new timeline event.
+     *
+     * If the cursor is live it advances with the tail (stays live).
+     * If the cursor is pinned (time-travel mode), it stays pinned.
+     *
+     * @param event — Event without `seq` (assigned here).
+     * @returns The stored TimelineEvent with its assigned `seq`.
+     */
+    append(event) {
+        const wasLive = this.isLive;
+        const stored = { ...event, seq: this._nextSeq++ };
+        this._ring[this._head] = stored;
+        this._head = (this._head + 1) % this._maxSize;
+        this._totalAppended++;
+        // Advance cursor only when live
+        if (wasLive) {
+            this._cursor = this.size; // stay at live
+        }
+        return stored;
+    }
+    // ── Random access ─────────────────────────────────────────────────────────
+    /**
+     * Return all retained events in chronological order.
+     *
+     * @returns Events oldest → newest.
+     */
+    getAll() {
+        const s = this.size;
+        if (s === 0)
+            return [];
+        const result = new Array(s);
+        if (this._totalAppended <= this._maxSize) {
+            for (let i = 0; i < s; i++) {
+                result[i] = this._ring[i];
+            }
+        }
+        else {
+            for (let i = 0; i < s; i++) {
+                result[i] = this._ring[(this._head + i) % this._maxSize];
+            }
+        }
+        return result;
+    }
+    /**
+     * Return the event at a logical index (0 = oldest, size-1 = newest).
+     *
+     * @returns TimelineEvent or undefined when out of range.
+     */
+    getAt(index) {
+        const s = this.size;
+        if (index < 0 || index >= s)
+            return undefined;
+        if (this._totalAppended <= this._maxSize) {
+            return this._ring[index];
+        }
+        return this._ring[(this._head + index) % this._maxSize];
+    }
+    // ── Time-travel controls ──────────────────────────────────────────────────
+    /**
+     * Return the event at the current cursor position, or undefined when live.
+     */
+    getCurrentEvent() {
+        if (this.isLive)
+            return undefined;
+        return this.getAt(this._cursor);
+    }
+    /**
+     * Step the cursor one event backward (toward oldest).
+     * If already at index 0, the cursor stays at 0.
+     *
+     * @returns true if the cursor moved.
+     */
+    stepBack() {
+        if (this._cursor <= 0)
+            return false;
+        this._cursor--;
+        return true;
+    }
+    /**
+     * Step the cursor one event forward (toward live).
+     * When the cursor reaches the live position (past the newest event),
+     * `isLive` becomes true.
+     *
+     * @returns true if the cursor moved.
+     */
+    stepForward() {
+        if (this.isLive)
+            return false;
+        this._cursor++;
+        return true;
+    }
+    /**
+     * Seek the cursor to an absolute logical index.
+     * Clamps to [0, size] where size === live.
+     *
+     * @param index — Target index (size = live).
+     */
+    seekTo(index) {
+        const s = this.size;
+        this._cursor = Math.max(0, Math.min(index, s));
+    }
+    /**
+     * Seek to the nearest event at or before a given epoch ms timestamp.
+     * If no events exist before the timestamp, seeks to index 0.
+     * If all events are before or equal, seeks to the newest.
+     *
+     * @param epochMs — Target timestamp.
+     */
+    seekToTime(epochMs) {
+        const all = this.getAll();
+        if (all.length === 0)
+            return;
+        let best = 0;
+        for (let i = 0; i < all.length; i++) {
+            if (all[i].capturedAt <= epochMs) {
+                best = i;
+            }
+            else {
+                break;
+            }
+        }
+        this._cursor = best;
+    }
+    /**
+     * Return the cursor to the live tail (exit time-travel mode).
+     */
+    exitTimeTravel() {
+        this._cursor = this.size;
+    }
+    /**
+     * Clear all retained events and reset to live position.
+     */
+    clear() {
+        this._ring.fill(undefined);
+        this._head = 0;
+        this._totalAppended = 0;
+        this._cursor = 0;
+        this._nextSeq = 1;
+    }
+}

package/dist/platform/runtime/inspection/state-inspector/transition-log.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Bounded transition history log for the state inspector.
+ *
+ * Maintains a ring-buffer of the most recent N state transitions.
+ * When the buffer is full, oldest entries are evicted (FIFO).
+ * All operations are O(1) amortised.
+ *
+ * State inspector transition log.
+ */
+import type { TransitionEntry } from './types.js';
+/**
+ * BoundedTransitionLog — a fixed-capacity log of state transitions.
+ *
+ * Each call to `append()` stores a new entry. When capacity is
+ * exceeded, the oldest entry is silently dropped.
+ */
+export declare class BoundedTransitionLog {
+    private readonly _maxSize;
+    /** Circular buffer storage. */
+    private readonly _entries;
+    /** Index at which the next write will occur. */
+    private _head;
+    /** Total number of entries ever appended (not capped at _maxSize). */
+    private _totalAppended;
+    /** Monotonic entry ID counter. */
+    private _nextId;
+    /**
+     * @param maxSize - Maximum number of entries to retain. Must be >= 1.
+     * @default DEFAULT_MAX_TRANSITIONS
+     */
+    constructor(maxSize?: number);
+    /** Maximum number of entries this log can retain. */
+    get maxSize(): number;
+    /** Total entries ever appended (monotonically increasing). */
+    get totalAppended(): number;
+    /** Number of entries currently retained (capped at maxSize). */
+    get size(): number;
+    /**
+     * Append a new transition to the log.
+     * Evicts the oldest entry if the buffer is full.
+     *
+     * @param entry - The transition entry to record (without an `id`).
+     *   The `id` field is assigned by the log.
+     * @returns The stored TransitionEntry with its assigned `id`.
+     */
+    append(entry: Omit<TransitionEntry, 'id'>): TransitionEntry;
+    /**
+     * Return all retained entries in chronological order (oldest → newest).
+     *
+     * Performance note: allocates a new array per call. At the default
+     * maxSize of 1000 this is acceptable for devtools use. Direct ring-buffer
+     * iteration without allocation is a follow-up optimisation if needed.
+     *
+     * @returns Ordered array of TransitionEntry.
+     */
+    getAll(): TransitionEntry[];
+    /**
+     * Return entries filtered by domain name.
+     *
+     * @param domain - Domain to filter by.
+     * @returns Ordered entries for the given domain.
+     */
+    getByDomain(domain: string): TransitionEntry[];
+    /**
+     * Return entries recorded at or after a given epoch ms timestamp.
+     *
+     * @param sinceMs - Inclusive lower bound (epoch ms).
+     * @returns Ordered entries at or after the timestamp.
+     */
+    getSince(sinceMs: number): TransitionEntry[];
+    /**
+     * Return the N most recent entries.
+     *
+     * @param n - Number of entries to return.
+     * @returns Slice of at most N entries, most recent last.
+     */
+    getLast(n: number): TransitionEntry[];
+    /**
+     * Clear all retained entries and reset counters.
+     * The capacity remains unchanged.
+     */
+    clear(): void;
+}
+//# sourceMappingURL=transition-log.d.ts.map

package/dist/platform/runtime/inspection/state-inspector/transition-log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transition-log.d.ts","sourceRoot":"","sources":["../../../../../src/platform/runtime/inspection/state-inspector/transition-log.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAGlD;;;;;GAKG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,+BAA+B;IAC/B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkC;IAC3D,gDAAgD;IAChD,OAAO,CAAC,KAAK,CAAa;IAC1B,sEAAsE;IACtE,OAAO,CAAC,cAAc,CAAa;IACnC,kCAAkC;IAClC,OAAO,CAAC,OAAO,CAAa;IAE5B;;;OAGG;gBACS,OAAO,GAAE,MAAgC;IAMrD,qDAAqD;IACrD,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,8DAA8D;IAC9D,IAAI,aAAa,IAAI,MAAM,CAE1B;IAED,gEAAgE;IAChE,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;;;;;OAOG;IACI,MAAM,CACX,KAAK,EAAE,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,GACjC,eAAe;IAQlB;;;;;;;;OAQG;IACI,MAAM,IAAI,eAAe,EAAE;IAqBlC;;;;;OAKG;IACI,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,EAAE;IAIrD;;;;;OAKG;IACI,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,EAAE;IAInD;;;;;OAKG;IACI,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,eAAe,EAAE;IAK5C;;;OAGG;IACI,KAAK,IAAI,IAAI;CAMrB"}

package/dist/platform/runtime/inspection/state-inspector/transition-log.js

@@ -0,0 +1,120 @@
+import { DEFAULT_MAX_TRANSITIONS } from './types.js';
+/**
+ * BoundedTransitionLog — a fixed-capacity log of state transitions.
+ *
+ * Each call to `append()` stores a new entry. When capacity is
+ * exceeded, the oldest entry is silently dropped.
+ */
+export class BoundedTransitionLog {
+    _maxSize;
+    /** Circular buffer storage. */
+    _entries;
+    /** Index at which the next write will occur. */
+    _head = 0;
+    /** Total number of entries ever appended (not capped at _maxSize). */
+    _totalAppended = 0;
+    /** Monotonic entry ID counter. */
+    _nextId = 1;
+    /**
+     * @param maxSize - Maximum number of entries to retain. Must be >= 1.
+     * @default DEFAULT_MAX_TRANSITIONS
+     */
+    constructor(maxSize = DEFAULT_MAX_TRANSITIONS) {
+        if (maxSize < 1)
+            throw new RangeError(`maxSize must be >= 1, got ${maxSize}`);
+        this._maxSize = maxSize;
+        this._entries = new Array(maxSize).fill(undefined);
+    }
+    /** Maximum number of entries this log can retain. */
+    get maxSize() {
+        return this._maxSize;
+    }
+    /** Total entries ever appended (monotonically increasing). */
+    get totalAppended() {
+        return this._totalAppended;
+    }
+    /** Number of entries currently retained (capped at maxSize). */
+    get size() {
+        return Math.min(this._totalAppended, this._maxSize);
+    }
+    /**
+     * Append a new transition to the log.
+     * Evicts the oldest entry if the buffer is full.
+     *
+     * @param entry - The transition entry to record (without an `id`).
+     *   The `id` field is assigned by the log.
+     * @returns The stored TransitionEntry with its assigned `id`.
+     */
+    append(entry) {
+        const stored = { ...entry, id: this._nextId++ };
+        this._entries[this._head] = stored;
+        this._head = (this._head + 1) % this._maxSize;
+        this._totalAppended++;
+        return stored;
+    }
+    /**
+     * Return all retained entries in chronological order (oldest → newest).
+     *
+     * Performance note: allocates a new array per call. At the default
+     * maxSize of 1000 this is acceptable for devtools use. Direct ring-buffer
+     * iteration without allocation is a follow-up optimisation if needed.
+     *
+     * @returns Ordered array of TransitionEntry.
+     */
+    getAll() {
+        if (this._totalAppended === 0)
+            return [];
+        const count = this.size;
+        const result = new Array(count);
+        // If buffer not yet full, entries are in order from index 0
+        if (this._totalAppended <= this._maxSize) {
+            for (let i = 0; i < count; i++) {
+                result[i] = this._entries[i];
+            }
+            return result;
+        }
+        // Buffer is full: oldest entry is at _head (next write position)
+        for (let i = 0; i < count; i++) {
+            result[i] = this._entries[(this._head + i) % this._maxSize];
+        }
+        return result;
+    }
+    /**
+     * Return entries filtered by domain name.
+     *
+     * @param domain - Domain to filter by.
+     * @returns Ordered entries for the given domain.
+     */
+    getByDomain(domain) {
+        return this.getAll().filter((e) => e.domain === domain);
+    }
+    /**
+     * Return entries recorded at or after a given epoch ms timestamp.
+     *
+     * @param sinceMs - Inclusive lower bound (epoch ms).
+     * @returns Ordered entries at or after the timestamp.
+     */
+    getSince(sinceMs) {
+        return this.getAll().filter((e) => e.recordedAt >= sinceMs);
+    }
+    /**
+     * Return the N most recent entries.
+     *
+     * @param n - Number of entries to return.
+     * @returns Slice of at most N entries, most recent last.
+     */
+    getLast(n) {
+        const all = this.getAll();
+        return n >= all.length ? all : all.slice(all.length - n);
+    }
+    /**
+     * Clear all retained entries and reset counters.
+     * The capacity remains unchanged.
+     */
+    clear() {
+        this._entries.fill(undefined);
+        this._head = 0;
+        this._totalAppended = 0;
+        this._nextId = 1;
+    }
+}

package/dist/platform/runtime/inspection/state-inspector/types.d.ts

@@ -0,0 +1,193 @@
+/**
+ * State inspector types — data structures for the StateInspectorProvider.
+ *
+ * These are purely data-oriented. No UI rendering logic lives here.
+ * All values are JSON-safe unless explicitly noted.
+ *
+ * Types used by the state inspector subsystem.
+ */
+/**
+ * A point-in-time snapshot of a single domain's state.
+ * Maps and Sets are serialized to plain objects/arrays at capture time.
+ */
+export interface DomainSnapshot {
+    /** Domain identifier (matches RuntimeState domain key). */
+    readonly domain: string;
+    /** Monotonic revision counter at the time of capture. */
+    readonly revision: number;
+    /** Epoch ms timestamp of last mutation. */
+    readonly lastUpdatedAt: number;
+    /** The serialized domain state — JSON-safe. */
+    readonly state: Record<string, unknown>;
+}
+/**
+ * A point-in-time snapshot of the full RuntimeState across all domains.
+ * Produced by `StateInspectorProvider.getSnapshot()`.
+ */
+export interface StateSnapshot {
+    /** Epoch ms when this snapshot was captured. */
+    readonly capturedAt: number;
+    /** Snapshot of each registered domain. */
+    readonly domains: readonly DomainSnapshot[];
+    /** Total number of domains captured. */
+    readonly domainCount: number;
+    /** Optional filter applied when capturing (undefined = all domains). */
+    readonly domainFilter?: readonly string[];
+}
+/**
+ * A single state transition recorded in the bounded transition history.
+ * Captures the diff between two consecutive domain revisions.
+ */
+export interface TransitionEntry {
+    /** Unique sequential ID for this transition (monotonic, starts at 1). */
+    readonly id: number;
+    /** Domain that transitioned. */
+    readonly domain: string;
+    /** Revision number before this transition. */
+    readonly fromRevision: number;
+    /** Revision number after this transition. */
+    readonly toRevision: number;
+    /** Epoch ms when the transition was recorded. */
+    readonly recordedAt: number;
+    /** The mutation source string from the domain state. */
+    readonly source: string;
+    /** The new domain state after transition (JSON-safe). */
+    readonly state: Record<string, unknown>;
+}
+/**
+ * Metadata describing an active subscription to the state inspector.
+ */
+export interface SubscriptionInfo {
+    /** Unique subscription identifier. */
+    readonly id: string;
+    /** Human-readable label for the subscriber (e.g. panel name, component name). */
+    readonly label: string;
+    /** Epoch ms when this subscription was registered. */
+    readonly registeredAt: number;
+    /** Domain filter for this subscription — undefined means all domains. */
+    readonly domainFilter?: readonly string[];
+    /** Number of notifications delivered to this subscriber. */
+    readonly notificationCount: number;
+    /** Epoch ms of the last notification delivered. */
+    readonly lastNotifiedAt?: number;
+    /** Number of errors thrown by this subscriber's callback. */
+    readonly errorCount?: number;
+    /** Last error message thrown by this subscriber's callback. */
+    readonly lastError?: string;
+}
+/**
+ * Configuration for the StateInspectorProvider.
+ */
+export interface StateInspectorConfig {
+    /**
+     * Maximum number of transition entries retained in history.
+     * Oldest entries are evicted when the limit is reached.
+     * @default 1000
+     */
+    readonly maxTransitions?: number;
+    /**
+     * Maximum number of timeline events retained for time-travel.
+     * Each event stores a full domain snapshot.
+     * @default DEFAULT_TIMELINE_BUFFER_SIZE (500)
+     */
+    readonly timelineBufferSize?: number;
+    /**
+     * Optional set of domain names to observe.
+     * When provided, only listed domains will be tracked.
+     * Undefined means all registered domains.
+     */
+    readonly observedDomains?: readonly string[];
+}
+/** Default maximum transition history size. */
+export declare const DEFAULT_MAX_TRANSITIONS = 1000;
+/**
+ * A single event stored in the inspector timeline buffer.
+ * Each event captures a full point-in-time snapshot for time-travel replay.
+ */
+export interface TimelineEvent {
+    /** Monotonically increasing sequence number within this session. */
+    readonly seq: number;
+    /** Epoch ms when this event was captured. */
+    readonly capturedAt: number;
+    /** Domain that caused this timeline event. */
+    readonly domain: string;
+    /** Transition ID that triggered this snapshot (references TransitionEntry.id). */
+    readonly transitionId: number;
+    /** Full domain state at this point in time (JSON-safe). */
+    readonly snapshot: Record<string, unknown>;
+    /** Optional label for display (e.g. mutation source). */
+    readonly label?: string;
+}
+/**
+ * Cursor state representing the current time-travel position.
+ */
+export interface TimeTravelCursor {
+    /** Current logical index in the timeline (0 = oldest, total-1 = newest). */
+    readonly index: number;
+    /** Total number of events retained. */
+    readonly total: number;
+    /** Whether the cursor is at the live position (past the newest event). */
+    readonly isLive: boolean;
+}
+/** Default maximum timeline events retained in the ring buffer. */
+export declare const DEFAULT_TIMELINE_BUFFER_SIZE = 500;
+/**
+ * Metrics for a single selector key tracked by the hotspot sampler.
+ */
+export interface SelectorHotspot {
+    /** Selector name / identifier. */
+    readonly key: string;
+    /** Number of calls within the current sliding window. */
+    readonly callsInWindow: number;
+    /** Calls per second within the current window. */
+    readonly callsPerSecond: number;
+    /** Total lifetime calls (not windowed). */
+    readonly totalCalls: number;
+    /** Average execution duration within window (ms). */
+    readonly avgMs: number;
+    /** p50 execution latency within window (ms). */
+    readonly p50Ms: number;
+    /** p95 execution latency within window (ms). */
+    readonly p95Ms: number;
+    /** p99 execution latency within window (ms). */
+    readonly p99Ms: number;
+    /** Maximum execution duration within window (ms). */
+    readonly maxMs: number;
+    /** True when calls/sec exceeds the churn threshold (> 10/sec). */
+    readonly isChurnHotspot: boolean;
+    /** True when p95 exceeds the latency threshold (> 5ms). */
+    readonly isLatencyHotspot: boolean;
+}
+/**
+ * Full hotspot analysis report produced by SelectorHotspotSampler.getReport().
+ */
+export interface HotspotReport {
+    /** Epoch ms when this report was generated. */
+    readonly generatedAt: number;
+    /** Sliding window duration used for this report (ms). */
+    readonly windowMs: number;
+    /** All tracked selectors, sorted by callsInWindow descending. */
+    readonly hotspots: readonly SelectorHotspot[];
+}
+/**
+ * Configuration for SelectorHotspotSampler.
+ */
+export interface HotspotSamplerConfig {
+    /**
+     * Sliding window duration in milliseconds.
+     * Samples older than this are dropped on each record().
+     * @default DEFAULT_HOTSPOT_WINDOW_MS
+     */
+    readonly windowMs?: number;
+    /**
+     * Maximum number of raw samples retained per selector key.
+     * Oldest samples are dropped when the cap is reached.
+     * @default DEFAULT_HOTSPOT_MAX_SAMPLES_PER_KEY
+     */
+    readonly maxSamplesPerKey?: number;
+}
+/** Default sliding window duration for hotspot analysis (10 seconds). */
+export declare const DEFAULT_HOTSPOT_WINDOW_MS = 10000;
+/** Default per-key sample cap to bound memory usage. */
+export declare const DEFAULT_HOTSPOT_MAX_SAMPLES_PER_KEY = 200;
+//# sourceMappingURL=types.d.ts.map

package/dist/platform/runtime/inspection/state-inspector/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/platform/runtime/inspection/state-inspector/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,2DAA2D;IAC3D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,yDAAyD;IACzD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,2CAA2C;IAC3C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,+CAA+C;IAC/C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACzC;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,gDAAgD;IAChD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,0CAA0C;IAC1C,QAAQ,CAAC,OAAO,EAAE,SAAS,cAAc,EAAE,CAAC;IAC5C,wCAAwC;IACxC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,wEAAwE;IACxE,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3C;AAID;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,yEAAyE;IACzE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,gCAAgC;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,8CAA8C;IAC9C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,6CAA6C;IAC7C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,iDAAiD;IACjD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,wDAAwD;IACxD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,yDAAyD;IACzD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACzC;AAID;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,sCAAsC;IACtC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,iFAAiF;IACjF,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,sDAAsD;IACtD,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,yEAAyE;IACzE,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C,4DAA4D;IAC5D,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,mDAAmD;IACnD,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,6DAA6D;IAC7D,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,+DAA+D;IAC/D,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAID;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC;;;;OAIG;IACH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IACrC;;;;OAIG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9C;AAED,+CAA+C;AAC/C,eAAO,MAAM,uBAAuB,OAAO,CAAC;AAI5C;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,oEAAoE;IACpE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,6CAA6C;IAC7C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,8CAA8C;IAC9C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,kFAAkF;IAClF,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,2DAA2D;IAC3D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC3C,yDAAyD;IACzD,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,4EAA4E;IAC5E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,uCAAuC;IACvC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,0EAA0E;IAC1E,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B;AAED,mEAAmE;AACnE,eAAO,MAAM,4BAA4B,MAAM,CAAC;AAIhD;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,kCAAkC;IAClC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,yDAAyD;IACzD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,kDAAkD;IAClD,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,2CAA2C;IAC3C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,qDAAqD;IACrD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,gDAAgD;IAChD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,gDAAgD;IAChD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,gDAAgD;IAChD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,qDAAqD;IACrD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,kEAAkE;IAClE,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC,2DAA2D;IAC3D,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;CACpC;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,+CAA+C;IAC/C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,yDAAyD;IACzD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,iEAAiE;IACjE,QAAQ,CAAC,QAAQ,EAAE,SAAS,eAAe,EAAE,CAAC;CAC/C;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CACpC;AAED,yEAAyE;AACzE,eAAO,MAAM,yBAAyB,QAAS,CAAC;AAEhD,wDAAwD;AACxD,eAAO,MAAM,mCAAmC,MAAM,CAAC"}

package/dist/platform/runtime/inspection/state-inspector/types.js

@@ -0,0 +1,16 @@
+/**
+ * State inspector types — data structures for the StateInspectorProvider.
+ *
+ * These are purely data-oriented. No UI rendering logic lives here.
+ * All values are JSON-safe unless explicitly noted.
+ *
+ * Types used by the state inspector subsystem.
+ */
+/** Default maximum transition history size. */
+export const DEFAULT_MAX_TRANSITIONS = 1000;
+/** Default maximum timeline events retained in the ring buffer. */
+export const DEFAULT_TIMELINE_BUFFER_SIZE = 500;
+/** Default sliding window duration for hotspot analysis (10 seconds). */
+export const DEFAULT_HOTSPOT_WINDOW_MS = 10_000;
+/** Default per-key sample cap to bound memory usage. */
+export const DEFAULT_HOTSPOT_MAX_SAMPLES_PER_KEY = 200;

package/dist/platform/runtime/mcp/lifecycle.d.ts

@@ -0,0 +1,54 @@
+/**
+ * MCP server lifecycle state machine.
+ *
+ * Pure transition logic — no side effects, no I/O.
+ * All state changes flow through `applyTransition()`.
+ */
+import type { McpServerState } from './types.js';
+/**
+ * Returns `true` if transitioning from `from` to `to` is permitted by the
+ * state machine definition.
+ *
+ * @param from - Current state
+ * @param to   - Proposed next state
+ */
+export declare function canTransition(from: McpServerState, to: McpServerState): boolean;
+/**
+ * Returns all states reachable from the given state.
+ *
+ * @param from - Current state
+ */
+export declare function reachableFrom(from: McpServerState): ReadonlySet<McpServerState>;
+/** Result of attempting a state transition. */
+export type TransitionResult = {
+    success: true;
+    previous: McpServerState;
+    next: McpServerState;
+} | {
+    success: false;
+    reason: string;
+};
+/**
+ * Attempt to apply a state transition.
+ *
+ * Returns `{ success: true, previous, next }` if the transition is valid,
+ * or `{ success: false, reason }` if it is not.
+ *
+ * This function is pure — callers are responsible for updating the entry.
+ *
+ * @param current  - The current state of the server
+ * @param target   - The desired next state
+ */
+export declare function applyTransition(current: McpServerState, target: McpServerState): TransitionResult;
+/**
+ * Returns `true` if the state represents an active/usable server.
+ *
+ * Both `connected` and `degraded` allow tool calls to proceed.
+ */
+export declare function isOperational(state: McpServerState): boolean;
+/**
+ * Returns `true` if the state is terminal for a reconnect cycle
+ * (i.e., the manager should not attempt further reconnects automatically).
+ */
+export declare function isTerminal(state: McpServerState): boolean;
+//# sourceMappingURL=lifecycle.d.ts.map

package/dist/platform/runtime/mcp/lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../../../src/platform/runtime/mcp/lifecycle.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAqBjD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,cAAc,EAAE,EAAE,EAAE,cAAc,GAAG,OAAO,CAE/E;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,cAAc,GAAG,WAAW,CAAC,cAAc,CAAC,CAE/E;AAID,+CAA+C;AAC/C,MAAM,MAAM,gBAAgB,GACxB;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,QAAQ,EAAE,cAAc,CAAC;IAAC,IAAI,EAAE,cAAc,CAAA;CAAE,GACjE;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvC;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,cAAc,EACvB,MAAM,EAAE,cAAc,GACrB,gBAAgB,CAWlB;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAE5D;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAEzD"}