@pellux/goodvibes-sdk 0.18.27 → 0.18.29

package/dist/_internal/platform/runtime/perf/component-health-monitor.d.ts

@@ -0,0 +1,98 @@
+/**
+ * ComponentHealthMonitor — enforces per-component resource contracts.
+ *
+ * Tracks update rate and render cost per component. Components that exceed their
+ * contracted budget are throttled (render gated to a minimum interval).
+ * Components with sustained violations are degraded (rendered at a fixed low rate).
+ *
+ * The monitor does NOT render components itself — callers ask canRender() before
+ * rendering and report the actual render cost via recordRender().
+ *
+ * This keeps the monitor policy-focused and the rendering path ignorant of
+ * throttling policy details.
+ *
+ * Surface-agnostic: a TUI panel, a web widget, or any other renderable unit
+ * can register with this monitor. The TUI uses componentId values that
+ * correspond to panel identifiers; other surfaces use their own naming.
+ */
+import type { ComponentResourceContract, ComponentHealthState } from './component-contracts.js';
+/**
+ * ComponentHealthMonitor — tracks component resource usage and enforces budgets.
+ *
+ * Usage:
+ * 1. Register components with register(componentId, category).
+ * 2. Before rendering: if (!monitor.canRender(componentId, now)) skip the render.
+ * 3. After rendering: monitor.recordRender(componentId, durationMs, now).
+ * 4. Read health via getHealth(componentId) or getAllHealth().
+ */
+export declare class ComponentHealthMonitor {
+    private readonly _tracks;
+    /**
+     * Register a component with the monitor.
+     *
+     * If the component is already registered, this is a no-op.
+     *
+     * @param componentId - Unique component identifier.
+     * @param category - Component category (used to select the base contract).
+     * @param contractOverrides - Optional per-component contract overrides.
+     */
+    register(componentId: string, category: string, contractOverrides?: Partial<Omit<ComponentResourceContract, 'componentId'>>): void;
+    /**
+     * Deregister a component, removing all tracking state.
+     */
+    deregister(componentId: string): void;
+    /**
+     * Check whether a component is permitted to render at the given time.
+     *
+     * Records the render request for rate tracking regardless of the outcome.
+     * If the component is not registered, renders are always permitted.
+     *
+     * @param componentId - Component to check.
+     * @param now - Current epoch ms (defaults to Date.now()).
+     * @returns true if the render is permitted; false if it should be skipped.
+     */
+    canRender(componentId: string, now?: number): boolean;
+    /**
+     * Record the actual render duration for a component.
+     *
+     * Should be called after every permitted render completes. Updates the
+     * p95 render cost and may escalate the component's throttle status if the
+     * render cost budget is violated.
+     *
+     * @param componentId - Component that rendered.
+     * @param durationMs - Actual render duration in milliseconds.
+     * @param now - Epoch ms at render completion (defaults to Date.now()).
+     */
+    recordRender(componentId: string, durationMs: number, now?: number): void;
+    /**
+     * Return the current health state for a component, or undefined if not registered.
+     */
+    getHealth(componentId: string): ComponentHealthState | undefined;
+    /**
+     * Return health states for all registered components.
+     */
+    getAllHealth(): ComponentHealthState[];
+    /**
+     * Return the resource contract for a registered component, or undefined.
+     */
+    getContract(componentId: string): ComponentResourceContract | undefined;
+    /**
+     * Forcibly reset a component's health state to normal.
+     * Useful for tests or manual operator intervention.
+     */
+    resetHealth(componentId: string): void;
+    private _rotateWindow;
+    private _applyViolation;
+    /**
+     * Dual-path recovery: `_recordClean` handles render-cost-based recovery
+     * (triggered from `recordRender` after a cheap render), while `_rotateWindow`
+     * handles rate-based recovery (triggered at window boundaries). Both paths
+     * call `_recover` once the clean-window threshold is met, so either signal
+     * alone is sufficient to restore a component to normal status.
+     */
+    private _recordClean;
+    private _recover;
+}
+/** @deprecated Use ComponentHealthMonitor */
+export { ComponentHealthMonitor as PanelHealthMonitor };
+//# sourceMappingURL=component-health-monitor.d.ts.map

package/dist/_internal/platform/runtime/perf/component-health-monitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-health-monitor.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/perf/component-health-monitor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,yBAAyB,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAqChG;;;;;;;;GAQG;AACH,qBAAa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA0C;IAElE;;;;;;;;OAQG;IACH,QAAQ,CACN,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,EAChB,iBAAiB,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,yBAAyB,EAAE,aAAa,CAAC,CAAC,GAC1E,IAAI;IAgBP;;OAEG;IACH,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAIrC;;;;;;;;;OASG;IACH,SAAS,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,GAAE,MAAmB,GAAG,OAAO;IAmCjE;;;;;;;;;;OAUG;IACH,YAAY,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,GAAE,MAAmB,GAAG,IAAI;IA2BrF;;OAEG;IACH,SAAS,CAAC,WAAW,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS;IAIhE;;OAEG;IACH,YAAY,IAAI,oBAAoB,EAAE;IAItC;;OAEG;IACH,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,yBAAyB,GAAG,SAAS;IAIvE;;;OAGG;IACH,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAatC,OAAO,CAAC,aAAa;IA2BrB,OAAO,CAAC,eAAe;IAiBvB;;;;;;OAMG;IACH,OAAO,CAAC,YAAY;IASpB,OAAO,CAAC,QAAQ;CAOjB;AAMD,6CAA6C;AAC7C,OAAO,EAAE,sBAAsB,IAAI,kBAAkB,EAAE,CAAC"}

package/dist/_internal/platform/runtime/perf/component-health-monitor.js

@@ -0,0 +1,248 @@
+/**
+ * ComponentHealthMonitor — enforces per-component resource contracts.
+ *
+ * Tracks update rate and render cost per component. Components that exceed their
+ * contracted budget are throttled (render gated to a minimum interval).
+ * Components with sustained violations are degraded (rendered at a fixed low rate).
+ *
+ * The monitor does NOT render components itself — callers ask canRender() before
+ * rendering and report the actual render cost via recordRender().
+ *
+ * This keeps the monitor policy-focused and the rendering path ignorant of
+ * throttling policy details.
+ *
+ * Surface-agnostic: a TUI panel, a web widget, or any other renderable unit
+ * can register with this monitor. The TUI uses componentId values that
+ * correspond to panel identifiers; other surfaces use their own naming.
+ */
+import { CATEGORY_CONTRACTS, buildContract, createInitialComponentHealthState, } from './component-contracts.js';
+/** Measurement window for update-rate enforcement (ms). */
+const RATE_WINDOW_MS = 1000;
+/** Number of recent render durations to keep for p95 calculation. */
+const RENDER_SAMPLE_CAPACITY = 20;
+/** Recovery: violations reset to 0 after this many consecutive clean windows. */
+const RECOVERY_CLEAN_WINDOWS = 3;
+/**
+ * ComponentHealthMonitor — tracks component resource usage and enforces budgets.
+ *
+ * Usage:
+ * 1. Register components with register(componentId, category).
+ * 2. Before rendering: if (!monitor.canRender(componentId, now)) skip the render.
+ * 3. After rendering: monitor.recordRender(componentId, durationMs, now).
+ * 4. Read health via getHealth(componentId) or getAllHealth().
+ */
+export class ComponentHealthMonitor {
+    _tracks = new Map();
+    /**
+     * Register a component with the monitor.
+     *
+     * If the component is already registered, this is a no-op.
+     *
+     * @param componentId - Unique component identifier.
+     * @param category - Component category (used to select the base contract).
+     * @param contractOverrides - Optional per-component contract overrides.
+     */
+    register(componentId, category, contractOverrides) {
+        if (this._tracks.has(componentId))
+            return;
+        const contract = buildContract(componentId, category, contractOverrides);
+        const health = createInitialComponentHealthState(componentId);
+        this._tracks.set(componentId, {
+            contract,
+            health,
+            renderSamples: { buf: new Array(RENDER_SAMPLE_CAPACITY), head: 0, size: 0 },
+            windowRequests: [],
+            cleanWindows: 0,
+            windowStart: 0,
+        });
+    }
+    /**
+     * Deregister a component, removing all tracking state.
+     */
+    deregister(componentId) {
+        this._tracks.delete(componentId);
+    }
+    /**
+     * Check whether a component is permitted to render at the given time.
+     *
+     * Records the render request for rate tracking regardless of the outcome.
+     * If the component is not registered, renders are always permitted.
+     *
+     * @param componentId - Component to check.
+     * @param now - Current epoch ms (defaults to Date.now()).
+     * @returns true if the render is permitted; false if it should be skipped.
+     */
+    canRender(componentId, now = Date.now()) {
+        const track = this._tracks.get(componentId);
+        if (!track)
+            return true; // unregistered components are always permitted
+        // Rotate the measurement window if needed
+        this._rotateWindow(track, now);
+        // Gate on throttle/degrade interval
+        if (now < track.health.nextAllowedAt) {
+            track.health.totalSuppressed++;
+            return false;
+        }
+        // Record this request in the current window
+        track.windowRequests.push(now);
+        // Check update rate limit
+        let requestsInWindow = 0;
+        for (const t of track.windowRequests) {
+            if (now - t < RATE_WINDOW_MS)
+                requestsInWindow++;
+        }
+        // Note: stale entries older than RATE_WINDOW_MS are pruned at window rotation, not here
+        const maxPerWindow = track.contract.maxUpdatesPerSecond;
+        if (requestsInWindow > maxPerWindow) {
+            // Rate exceeded: throttle or degrade
+            this._applyViolation(track, now);
+            track.health.totalSuppressed++;
+            return false;
+        }
+        track.health.totalPermitted++;
+        return true;
+    }
+    /**
+     * Record the actual render duration for a component.
+     *
+     * Should be called after every permitted render completes. Updates the
+     * p95 render cost and may escalate the component's throttle status if the
+     * render cost budget is violated.
+     *
+     * @param componentId - Component that rendered.
+     * @param durationMs - Actual render duration in milliseconds.
+     * @param now - Epoch ms at render completion (defaults to Date.now()).
+     */
+    recordRender(componentId, durationMs, now = Date.now()) {
+        const track = this._tracks.get(componentId);
+        if (!track)
+            return;
+        // Add sample to ring buffer (O(1) modular index — no shift/realloc)
+        const rb = track.renderSamples;
+        rb.buf[rb.head] = durationMs;
+        rb.head = (rb.head + 1) % RENDER_SAMPLE_CAPACITY;
+        if (rb.size < RENDER_SAMPLE_CAPACITY)
+            rb.size++;
+        // Update p95
+        const samples = rb.buf.slice(0, rb.size);
+        samples.sort((a, b) => a - b); // sort in-place, no second copy
+        const p95Val = samples[Math.ceil(samples.length * 0.95) - 1] ?? 0;
+        track.health.renderP95Ms = p95Val;
+        track.health.lastRenderAt = now;
+        track.health.rendersInWindow++;
+        // Check render cost budget
+        if (track.health.renderP95Ms > track.contract.maxRenderMs) {
+            this._applyViolation(track, now);
+        }
+        else {
+            // Render cost within budget — count as a clean observation
+            this._recordClean(track);
+        }
+    }
+    /**
+     * Return the current health state for a component, or undefined if not registered.
+     */
+    getHealth(componentId) {
+        return this._tracks.get(componentId)?.health;
+    }
+    /**
+     * Return health states for all registered components.
+     */
+    getAllHealth() {
+        return Array.from(this._tracks.values()).map((t) => ({ ...t.health }));
+    }
+    /**
+     * Return the resource contract for a registered component, or undefined.
+     */
+    getContract(componentId) {
+        return this._tracks.get(componentId)?.contract;
+    }
+    /**
+     * Forcibly reset a component's health state to normal.
+     * Useful for tests or manual operator intervention.
+     */
+    resetHealth(componentId) {
+        const track = this._tracks.get(componentId);
+        if (!track)
+            return;
+        track.health = createInitialComponentHealthState(componentId);
+        track.renderSamples = { buf: new Array(RENDER_SAMPLE_CAPACITY), head: 0, size: 0 };
+        track.windowRequests = [];
+        track.cleanWindows = 0;
+    }
+    // ---------------------------------------------------------------------------
+    // Private helpers
+    // ---------------------------------------------------------------------------
+    _rotateWindow(track, now) {
+        if (track.windowStart === 0) {
+            track.windowStart = now;
+            return;
+        }
+        if (now - track.windowStart >= RATE_WINDOW_MS) {
+            // Check for recovery
+            let requestsLastWindow = 0;
+            for (const t of track.windowRequests) {
+                if (t >= track.windowStart && t < track.windowStart + RATE_WINDOW_MS)
+                    requestsLastWindow++;
+            }
+            const withinBudget = requestsLastWindow <= track.contract.maxUpdatesPerSecond;
+            if (withinBudget) {
+                track.cleanWindows++;
+                if (track.cleanWindows >= RECOVERY_CLEAN_WINDOWS) {
+                    this._recover(track);
+                }
+            }
+            else {
+                track.cleanWindows = 0;
+            }
+            // Discard old requests
+            track.windowRequests = track.windowRequests.filter((t) => now - t < RATE_WINDOW_MS);
+            track.windowStart = now;
+            track.health.rendersInWindow = 0;
+        }
+    }
+    _applyViolation(track, now) {
+        track.health.consecutiveViolations++;
+        track.cleanWindows = 0;
+        if (track.health.consecutiveViolations >= track.contract.degradeAfterViolations) {
+            // Escalate to degraded
+            track.health.throttleStatus = 'degraded';
+            track.health.healthStatus = 'overloaded';
+            track.health.nextAllowedAt = now + track.contract.degradedIntervalMs;
+        }
+        else {
+            // Apply standard throttle
+            track.health.throttleStatus = 'throttled';
+            track.health.healthStatus = 'warning';
+            track.health.nextAllowedAt = now + track.contract.throttleIntervalMs;
+        }
+    }
+    /**
+     * Dual-path recovery: `_recordClean` handles render-cost-based recovery
+     * (triggered from `recordRender` after a cheap render), while `_rotateWindow`
+     * handles rate-based recovery (triggered at window boundaries). Both paths
+     * call `_recover` once the clean-window threshold is met, so either signal
+     * alone is sufficient to restore a component to normal status.
+     */
+    _recordClean(track) {
+        // Only advance recovery if we're already throttled/degraded
+        if (track.health.throttleStatus === 'normal')
+            return;
+        track.cleanWindows++;
+        if (track.cleanWindows >= RECOVERY_CLEAN_WINDOWS) {
+            this._recover(track);
+        }
+    }
+    _recover(track) {
+        track.health.throttleStatus = 'normal';
+        track.health.healthStatus = 'healthy';
+        track.health.consecutiveViolations = 0;
+        track.health.nextAllowedAt = 0;
+        track.cleanWindows = 0;
+    }
+}
+// ---------------------------------------------------------------------------
+// Backward-compatible alias
+// ---------------------------------------------------------------------------
+/** @deprecated Use ComponentHealthMonitor */
+export { ComponentHealthMonitor as PanelHealthMonitor };

package/dist/_internal/platform/runtime/perf/index.d.ts

@@ -18,9 +18,12 @@ export { PerfMonitor } from '@pellux/goodvibes-sdk/platform/runtime/perf/monitor
 export type { PerfSnapshot } from '@pellux/goodvibes-sdk/platform/runtime/perf/monitor';
 export { formatReport, exitCode } from '@pellux/goodvibes-sdk/platform/runtime/perf/reporter';
 export { SloCollector, SLO_METRICS } from './slo-collector.js';
-export type { PanelResourceContract, PanelHealthState, PanelThrottleStatus, PanelHealthStatus, } from '@pellux/goodvibes-sdk/platform/runtime/perf/panel-contracts';
-export { CATEGORY_CONTRACTS, buildContract, createInitialPanelHealthState, } from '@pellux/goodvibes-sdk/platform/runtime/perf/panel-contracts';
-export { PanelHealthMonitor, } from '@pellux/goodvibes-sdk/platform/runtime/perf/panel-health-monitor';
+export type { ComponentResourceContract, ComponentHealthState, ComponentThrottleStatus, ComponentHealthStatus, } from '@pellux/goodvibes-sdk/platform/runtime/perf/component-contracts';
+export { CATEGORY_CONTRACTS, buildContract, createInitialComponentHealthState, } from '@pellux/goodvibes-sdk/platform/runtime/perf/component-contracts';
+export { ComponentHealthMonitor } from '@pellux/goodvibes-sdk/platform/runtime/perf/component-health-monitor';
+export type { PanelResourceContract, PanelHealthState, PanelThrottleStatus, PanelHealthStatus, } from '@pellux/goodvibes-sdk/platform/runtime/perf/component-contracts';
+export { createInitialPanelHealthState, } from '@pellux/goodvibes-sdk/platform/runtime/perf/component-contracts';
+export { PanelHealthMonitor, } from '@pellux/goodvibes-sdk/platform/runtime/perf/component-health-monitor';
 import { PerfMonitor } from '@pellux/goodvibes-sdk/platform/runtime/perf/monitor';
 import type { PerfBudget } from '@pellux/goodvibes-sdk/platform/runtime/perf/types';
 /**

package/dist/_internal/platform/runtime/perf/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/perf/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,YAAY,EACV,UAAU,EACV,UAAU,EACV,eAAe,EACf,UAAU,EACV,QAAQ,GACT,MAAM,mDAAmD,CAAC;AAE3D,OAAO,EAAE,eAAe,EAAE,MAAM,qDAAqD,CAAC;AACtF,OAAO,EAAE,WAAW,EAAE,MAAM,qDAAqD,CAAC;AAClF,YAAY,EAAE,YAAY,EAAE,MAAM,qDAAqD,CAAC;AACxF,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,sDAAsD,CAAC;AAC9F,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAC/D,YAAY,EACV,qBAAqB,EACrB,gBAAgB,EAChB,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,6DAA6D,CAAC;AACrE,OAAO,EACL,kBAAkB,EAClB,aAAa,EACb,6BAA6B,GAC9B,MAAM,6DAA6D,CAAC;AACrE,OAAO,EACL,kBAAkB,GACnB,MAAM,kEAAkE,CAAC;AAE1E,OAAO,EAAE,WAAW,EAAE,MAAM,qDAAqD,CAAC;AAClF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mDAAmD,CAAC;AAGpF;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,UAAU,EAAoB,GAAG,WAAW,CAEtF"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/perf/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,YAAY,EACV,UAAU,EACV,UAAU,EACV,eAAe,EACf,UAAU,EACV,QAAQ,GACT,MAAM,mDAAmD,CAAC;AAE3D,OAAO,EAAE,eAAe,EAAE,MAAM,qDAAqD,CAAC;AACtF,OAAO,EAAE,WAAW,EAAE,MAAM,qDAAqD,CAAC;AAClF,YAAY,EAAE,YAAY,EAAE,MAAM,qDAAqD,CAAC;AACxF,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,sDAAsD,CAAC;AAC9F,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAE/D,YAAY,EACV,yBAAyB,EACzB,oBAAoB,EACpB,uBAAuB,EACvB,qBAAqB,GACtB,MAAM,iEAAiE,CAAC;AACzE,OAAO,EACL,kBAAkB,EAClB,aAAa,EACb,iCAAiC,GAClC,MAAM,iEAAiE,CAAC;AACzE,OAAO,EAAE,sBAAsB,EAAE,MAAM,sEAAsE,CAAC;AAG9G,YAAY,EACV,qBAAqB,EACrB,gBAAgB,EAChB,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,iEAAiE,CAAC;AACzE,OAAO,EACL,6BAA6B,GAC9B,MAAM,iEAAiE,CAAC;AACzE,OAAO,EACL,kBAAkB,GACnB,MAAM,sEAAsE,CAAC;AAE9E,OAAO,EAAE,WAAW,EAAE,MAAM,qDAAqD,CAAC;AAClF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mDAAmD,CAAC;AAGpF;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,UAAU,EAAoB,GAAG,WAAW,CAEtF"}

package/dist/_internal/platform/runtime/perf/index.js

@@ -16,8 +16,10 @@ export { DEFAULT_BUDGETS } from '@pellux/goodvibes-sdk/platform/runtime/perf/bud
 export { PerfMonitor } from '@pellux/goodvibes-sdk/platform/runtime/perf/monitor';
 export { formatReport, exitCode } from '@pellux/goodvibes-sdk/platform/runtime/perf/reporter';
 export { SloCollector, SLO_METRICS } from './slo-collector.js';
-export { CATEGORY_CONTRACTS, buildContract, createInitialPanelHealthState, } from '@pellux/goodvibes-sdk/platform/runtime/perf/panel-contracts';
-export { PanelHealthMonitor, } from '@pellux/goodvibes-sdk/platform/runtime/perf/panel-health-monitor';
+export { CATEGORY_CONTRACTS, buildContract, createInitialComponentHealthState, } from '@pellux/goodvibes-sdk/platform/runtime/perf/component-contracts';
+export { ComponentHealthMonitor } from '@pellux/goodvibes-sdk/platform/runtime/perf/component-health-monitor';
+export { createInitialPanelHealthState, } from '@pellux/goodvibes-sdk/platform/runtime/perf/component-contracts';
+export { PanelHealthMonitor, } from '@pellux/goodvibes-sdk/platform/runtime/perf/component-health-monitor';
 import { PerfMonitor } from '@pellux/goodvibes-sdk/platform/runtime/perf/monitor';
 import { DEFAULT_BUDGETS } from '@pellux/goodvibes-sdk/platform/runtime/perf/budgets';
 /**

package/dist/_internal/platform/runtime/perf/panel-contracts.d.ts

@@ -1,94 +1,10 @@
-/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
 /**
- * Panel resource contracts — per-panel CPU/IO/update budget definitions.
+ * @deprecated This module has been renamed. Import from component-contracts.js instead.
  *
- * Each panel declares a resource contract describing its acceptable update
- * rate and render cost. The PanelHealthMonitor enforces these contracts at
- * runtime, throttling or degrading panels that exceed their budgets.
+ * This file is a backward-compatibility shim. All types and functions are
+ * re-exported from component-contracts.ts under their original Panel* names.
  */
-/** Throttle status for a panel. */
-export type PanelThrottleStatus = 'normal' | 'throttled' | 'degraded';
-/** Health of a single panel based on contract compliance. */
-export type PanelHealthStatus = 'healthy' | 'warning' | 'overloaded';
-/**
- * Resource contract for a single panel.
- *
- * Defines the maximum acceptable update rate and render cost budget.
- * Violations trigger throttling; sustained violations trigger degradation.
- */
-export interface PanelResourceContract {
-    /** Panel id this contract applies to. */
-    panelId: string;
-    /**
-     * Maximum updates per second the panel is allowed to request.
-     * Panels that exceed this rate are throttled.
-     */
-    maxUpdatesPerSecond: number;
-    /**
-     * Maximum acceptable render duration in milliseconds (p95).
-     * Panels that consistently exceed this are degraded.
-     */
-    maxRenderMs: number;
-    /**
-     * Minimum interval in milliseconds between renders when throttled.
-     * The monitor enforces this floor when the panel exceeds its update rate.
-     */
-    throttleIntervalMs: number;
-    /**
-     * Number of consecutive budget violations before moving to 'degraded' status.
-     * Degraded panels render at a fixed reduced rate regardless of update requests.
-     */
-    degradeAfterViolations: number;
-    /**
-     * Fixed render interval in milliseconds when the panel is degraded.
-     * Replaces throttleIntervalMs for severely overloaded panels.
-     */
-    degradedIntervalMs: number;
-}
-/**
- * Live health state for a single panel, maintained by the PanelHealthMonitor.
- */
-export interface PanelHealthState {
-    /** Panel id. */
-    panelId: string;
-    /** Current throttle status. */
-    throttleStatus: PanelThrottleStatus;
-    /** Current health status. */
-    healthStatus: PanelHealthStatus;
-    /** Observed render count over the last measurement window. */
-    rendersInWindow: number;
-    /** p95 render duration in ms over the last measurement window. */
-    renderP95Ms: number;
-    /** Number of consecutive contract violations (update rate or render cost). */
-    consecutiveViolations: number;
-    /** Epoch ms when the panel was last allowed to render. */
-    lastRenderAt: number;
-    /** Epoch ms of next allowed render (0 = no restriction). */
-    nextAllowedAt: number;
-    /** Total renders suppressed due to throttle or degradation since monitor start. */
-    totalSuppressed: number;
-    /** Total renders permitted since monitor start. */
-    totalPermitted: number;
-}
-/**
- * Default resource contracts by panel category.
- *
- * Panels without an explicit contract inherit from their category default.
- * Active/interactive panels get more generous budgets; monitoring panels
- * are throttled aggressively to prevent render storms.
- */
-export declare const CATEGORY_CONTRACTS: Record<string, Omit<PanelResourceContract, 'panelId'>>;
-/**
- * Build a PanelResourceContract for a panel, merging category defaults
- * with any per-panel overrides.
- *
- * @param panelId - The panel's unique id.
- * @param category - The panel's category (used to select the base contract).
- * @param overrides - Optional per-panel overrides applied on top of the category contract.
- */
-export declare function buildContract(panelId: string, category: string, overrides?: Partial<Omit<PanelResourceContract, 'panelId'>>): PanelResourceContract;
-/**
- * Create an initial (clean) PanelHealthState for a panel.
- */
-export declare function createInitialPanelHealthState(panelId: string): PanelHealthState;
+export type { ComponentThrottleStatus, ComponentHealthStatus, ComponentResourceContract, ComponentHealthState, } from './component-contracts.js';
+export type { PanelThrottleStatus, PanelHealthStatus, PanelResourceContract, PanelHealthState, } from './component-contracts.js';
+export { CATEGORY_CONTRACTS, buildContract, createInitialComponentHealthState, createInitialPanelHealthState, } from './component-contracts.js';
 //# sourceMappingURL=panel-contracts.d.ts.map

package/dist/_internal/platform/runtime/perf/panel-contracts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"panel-contracts.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/perf/panel-contracts.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAErF;;;;;;GAMG;AAEH,mCAAmC;AACnC,MAAM,MAAM,mBAAmB,GAAG,QAAQ,GAAG,WAAW,GAAG,UAAU,CAAC;AAEtE,6DAA6D;AAC7D,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG,SAAS,GAAG,YAAY,CAAC;AAErE;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,yCAAyC;IACzC,OAAO,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,mBAAmB,EAAE,MAAM,CAAC;IAE5B;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,kBAAkB,EAAE,MAAM,CAAC;IAE3B;;;OAGG;IACH,sBAAsB,EAAE,MAAM,CAAC;IAE/B;;;OAGG;IACH,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,gBAAgB;IAChB,OAAO,EAAE,MAAM,CAAC;IAEhB,+BAA+B;IAC/B,cAAc,EAAE,mBAAmB,CAAC;IAEpC,6BAA6B;IAC7B,YAAY,EAAE,iBAAiB,CAAC;IAEhC,8DAA8D;IAC9D,eAAe,EAAE,MAAM,CAAC;IAExB,kEAAkE;IAClE,WAAW,EAAE,MAAM,CAAC;IAEpB,8EAA8E;IAC9E,qBAAqB,EAAE,MAAM,CAAC;IAE9B,0DAA0D;IAC1D,YAAY,EAAE,MAAM,CAAC;IAErB,4DAA4D;IAC5D,aAAa,EAAE,MAAM,CAAC;IAEtB,mFAAmF;IACnF,eAAe,EAAE,MAAM,CAAC;IAExB,mDAAmD;IACnD,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,qBAAqB,EAAE,SAAS,CAAC,CA4CrF,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,SAAS,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,qBAAqB,EAAE,SAAS,CAAC,CAAC,GAC1D,qBAAqB,CAOvB;AAED;;GAEG;AACH,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,MAAM,GAAG,gBAAgB,CAa/E"}
+{"version":3,"file":"panel-contracts.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/perf/panel-contracts.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,YAAY,EACV,uBAAuB,EACvB,qBAAqB,EACrB,yBAAyB,EACzB,oBAAoB,GACrB,MAAM,0BAA0B,CAAC;AAElC,YAAY,EACV,mBAAmB,EACnB,iBAAiB,EACjB,qBAAqB,EACrB,gBAAgB,GACjB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACL,kBAAkB,EAClB,aAAa,EACb,iCAAiC,EACjC,6BAA6B,GAC9B,MAAM,0BAA0B,CAAC"}

package/dist/_internal/platform/runtime/perf/panel-contracts.js

@@ -1,86 +1,7 @@
-/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
 /**
- * Default resource contracts by panel category.
+ * @deprecated This module has been renamed. Import from component-contracts.js instead.
  *
- * Panels without an explicit contract inherit from their category default.
- * Active/interactive panels get more generous budgets; monitoring panels
- * are throttled aggressively to prevent render storms.
+ * This file is a backward-compatibility shim. All types and functions are
+ * re-exported from component-contracts.ts under their original Panel* names.
  */
-export const CATEGORY_CONTRACTS = {
-    development: {
-        maxUpdatesPerSecond: 10,
-        maxRenderMs: 20,
-        throttleIntervalMs: 100,
-        degradeAfterViolations: 5,
-        degradedIntervalMs: 500,
-    },
-    agent: {
-        maxUpdatesPerSecond: 5,
-        maxRenderMs: 30,
-        throttleIntervalMs: 200,
-        degradeAfterViolations: 5,
-        degradedIntervalMs: 1000,
-    },
-    monitoring: {
-        maxUpdatesPerSecond: 2,
-        maxRenderMs: 50,
-        throttleIntervalMs: 500,
-        degradeAfterViolations: 3,
-        degradedIntervalMs: 2000,
-    },
-    session: {
-        maxUpdatesPerSecond: 4,
-        maxRenderMs: 25,
-        throttleIntervalMs: 250,
-        degradeAfterViolations: 5,
-        degradedIntervalMs: 1000,
-    },
-    ai: {
-        maxUpdatesPerSecond: 8,
-        maxRenderMs: 20,
-        throttleIntervalMs: 125,
-        degradeAfterViolations: 5,
-        degradedIntervalMs: 500,
-    },
-    /** Fallback for unrecognised categories. */
-    default: {
-        maxUpdatesPerSecond: 5,
-        maxRenderMs: 30,
-        throttleIntervalMs: 200,
-        degradeAfterViolations: 5,
-        degradedIntervalMs: 1000,
-    },
-};
-/**
- * Build a PanelResourceContract for a panel, merging category defaults
- * with any per-panel overrides.
- *
- * @param panelId - The panel's unique id.
- * @param category - The panel's category (used to select the base contract).
- * @param overrides - Optional per-panel overrides applied on top of the category contract.
- */
-export function buildContract(panelId, category, overrides) {
-    const base = CATEGORY_CONTRACTS[category] ?? CATEGORY_CONTRACTS['default'];
-    return {
-        panelId,
-        ...base,
-        ...overrides,
-    };
-}
-/**
- * Create an initial (clean) PanelHealthState for a panel.
- */
-export function createInitialPanelHealthState(panelId) {
-    return {
-        panelId,
-        throttleStatus: 'normal',
-        healthStatus: 'healthy',
-        rendersInWindow: 0,
-        renderP95Ms: 0,
-        consecutiveViolations: 0,
-        lastRenderAt: 0,
-        nextAllowedAt: 0,
-        totalSuppressed: 0,
-        totalPermitted: 0,
-    };
-}
+export { CATEGORY_CONTRACTS, buildContract, createInitialComponentHealthState, createInitialPanelHealthState, } from './component-contracts.js';