@pellux/goodvibes-sdk 0.18.14 → 0.18.15

package/dist/_internal/platform/runtime/diagnostics/actions.js

@@ -0,0 +1,413 @@
+/**
+ * Diagnostics action system — action dispatch bindings for diagnostic entries.
+ *
+ * Defines the action types, permission model, and dispatcher that allow
+ * one-click remediation from the diagnostics UI. Actions are attached to
+ * high-severity diagnostic entries and dispatched through this system,
+ * which validates permissions before delegating to the appropriate handler.
+ *
+ * Supported action targets:
+ *  - Load replay: loads a forensics run into the replay engine
+ *  - Run policy simulation: triggers a simulation pass for a tool call
+ *  - Jump to task: navigates the UI focus to a related task entry
+ *  - Jump to agent: navigates the UI focus to a related agent entry
+ *  - Jump to tool call: navigates the UI focus to a related tool call entry
+ */
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+// ── Default permission checker ────────────────────────────────────────────────
+const DEFAULT_PERMISSION_CHECKER = (required) => {
+    return required !== 'admin';
+};
+// ── Dispatcher ────────────────────────────────────────────────────────────────
+/**
+ * DiagnosticActionDispatcher — executes diagnostic entry actions.
+ *
+ * Routes incoming DiagnosticAction values to the appropriate handler,
+ * performing a permission check before dispatch. All errors are caught
+ * and converted to ActionResult failures so callers never receive thrown
+ * exceptions from this API.
+ *
+ * Usage:
+ * ```ts
+ * const dispatcher = new DiagnosticActionDispatcher({
+ *   replayEngine,
+ *   simulator,
+ *   controlPlane,
+ *   navigateTo: (target, id) => focusPanel(target, id),
+ * });
+ *
+ * const result = await dispatcher.dispatch(action);
+ * if (!result.success) {
+ *   showError(result.message);
+ * }
+ * ```
+ */
+export class DiagnosticActionDispatcher {
+    _replayEngine;
+    _simulator;
+    _controlPlane;
+    _navigateTo;
+    _checkPermission;
+    constructor(config = {}) {
+        this._replayEngine = config.replayEngine;
+        this._simulator = config.simulator;
+        this._controlPlane = config.controlPlane;
+        this._navigateTo = config.navigateTo;
+        this._checkPermission = config.checkPermission ?? DEFAULT_PERMISSION_CHECKER;
+    }
+    /**
+     * Dispatch a diagnostic action.
+     *
+     * Performs a permission check, then delegates to the appropriate handler.
+     * All handler errors are caught and returned as failure ActionResults.
+     *
+     * @param action - The action to execute.
+     * @returns An ActionResult describing the outcome.
+     */
+    async dispatch(action) {
+        // Permission gate
+        if (!this._checkPermission(action.permission)) {
+            logger.debug('[DiagnosticActionDispatcher] permission denied', {
+                type: action.type,
+                required: action.permission,
+            });
+            return {
+                success: false,
+                message: `Permission denied: '${action.permission}' access required for action '${action.type}'.`,
+                permissionDenied: true,
+            };
+        }
+        try {
+            return await this._route(action);
+        }
+        catch (err) {
+            const message = summarizeError(err);
+            logger.debug('[DiagnosticActionDispatcher] action error', {
+                type: action.type,
+                err: message,
+            });
+            return {
+                success: false,
+                message: `Action '${action.type}' failed: ${message}`,
+            };
+        }
+    }
+    async _route(action) {
+        switch (action.type) {
+            case 'load-replay':
+                return this._handleLoadReplay(action.payload);
+            case 'run-policy-simulation':
+                return this._handlePolicySimulation(action.payload);
+            case 'jump-to-task':
+                return this._handleJump('task', action.payload.taskId);
+            case 'jump-to-agent':
+                return this._handleJump('agent', action.payload.agentId);
+            case 'jump-to-tool-call':
+                return this._handleJump('tool-call', action.payload.callId);
+            case 'retry-task':
+                return this._handleRetryTask(action.payload);
+            case 'cancel-task':
+                return this._handleCancelTask(action.payload);
+            case 'cancel-agent':
+                return this._handleCancelAgent(action.payload);
+            default: {
+                // Exhaustiveness guard — TypeScript will error if a case is missing.
+                const exhaustive = action;
+                return {
+                    success: false,
+                    message: `Unknown action type: ${String(exhaustive)}`,
+                };
+            }
+        }
+    }
+    // ── Handlers ────────────────────────────────────────────────────────────────
+    _handleLoadReplay(payload) {
+        if (!this._replayEngine) {
+            return {
+                success: false,
+                message: 'Replay engine is not available. Attach a DeterministicReplayEngine to the dispatcher.',
+            };
+        }
+        // Reset the engine to 'idle'. The caller is expected to then fetch
+        // ledger entries for the given runId and call engine.load(). The
+        // ReplayPanel will surface the updated state via subscriber notifications.
+        this._replayEngine.reset();
+        logger.debug('[DiagnosticActionDispatcher] load-replay requested', {
+            runId: payload.runId,
+        });
+        return {
+            success: true,
+            message: `Replay engine reset for run '${payload.runId}'. Load the ledger entries to begin stepping.`,
+        };
+    }
+    _handlePolicySimulation(payload) {
+        if (!this._simulator) {
+            return {
+                success: false,
+                message: 'Policy simulator is not available. Attach a PermissionSimulator to the dispatcher.',
+            };
+        }
+        const result = this._simulator.evaluate(payload.toolName, payload.args);
+        const diverged = result.diverged;
+        const actual = result.actualDecision.allowed ? 'allowed' : 'denied';
+        const simulated = result.simulatedDecision.allowed ? 'allowed' : 'denied';
+        logger.debug('[DiagnosticActionDispatcher] policy simulation complete', {
+            toolName: payload.toolName,
+            diverged,
+            actual,
+            simulated,
+        });
+        if (diverged) {
+            return {
+                success: true,
+                message: `Policy simulation diverged for '${payload.toolName}': actual=${actual}, simulated=${simulated}.`,
+            };
+        }
+        return {
+            success: true,
+            message: `Policy simulation for '${payload.toolName}': both evaluators returned ${actual}.`,
+        };
+    }
+    _handleJump(target, id) {
+        if (!this._navigateTo) {
+            return {
+                success: true,
+                message: `Jump to ${target} '${id}' requested but no navigation handler is registered.`,
+            };
+        }
+        this._navigateTo(target, id);
+        return {
+            success: true,
+            message: `Navigated to ${target} '${id}'.`,
+        };
+    }
+    _handleRetryTask(payload) {
+        if (!this._controlPlane) {
+            return {
+                success: false,
+                message: 'Ops control plane is not available. Attach an OpsControlPlane to the dispatcher.',
+            };
+        }
+        if (!this._controlPlane.canRetryTask(payload.taskId)) {
+            return {
+                success: false,
+                message: `Task '${payload.taskId}' cannot be retried in its current state.`,
+            };
+        }
+        this._controlPlane.retryTask(payload.taskId, payload.note);
+        return {
+            success: true,
+            message: `Task '${payload.taskId}' queued for retry.`,
+        };
+    }
+    _handleCancelTask(payload) {
+        if (!this._controlPlane) {
+            return {
+                success: false,
+                message: 'Ops control plane is not available. Attach an OpsControlPlane to the dispatcher.',
+            };
+        }
+        if (!this._controlPlane.canCancelTask(payload.taskId)) {
+            return {
+                success: false,
+                message: `Task '${payload.taskId}' cannot be cancelled in its current state.`,
+            };
+        }
+        this._controlPlane.cancelTask(payload.taskId, payload.note);
+        return {
+            success: true,
+            message: `Task '${payload.taskId}' cancelled.`,
+        };
+    }
+    _handleCancelAgent(payload) {
+        if (!this._controlPlane) {
+            return {
+                success: false,
+                message: 'Ops control plane is not available. Attach an OpsControlPlane to the dispatcher.',
+            };
+        }
+        if (!this._controlPlane.canCancelAgent(payload.agentId)) {
+            return {
+                success: false,
+                message: `Agent '${payload.agentId}' cannot be cancelled in its current state.`,
+            };
+        }
+        this._controlPlane.cancelAgent(payload.agentId, payload.note);
+        return {
+            success: true,
+            message: `Agent '${payload.agentId}' cancelled.`,
+        };
+    }
+}
+// ── Factory helpers ───────────────────────────────────────────────────────────
+/**
+ * Build a 'load-replay' action for a forensics run ID.
+ */
+export function buildLoadReplayAction(runId) {
+    return {
+        label: 'Load Replay',
+        type: 'load-replay',
+        permission: 'operator',
+        payload: { runId },
+    };
+}
+/**
+ * Build a 'run-policy-simulation' action for a tool call.
+ */
+export function buildRunPolicySimulationAction(toolName, args) {
+    return {
+        label: 'Run Policy Simulation',
+        type: 'run-policy-simulation',
+        permission: 'operator',
+        payload: { toolName, args },
+    };
+}
+/**
+ * Build a 'jump-to-task' action.
+ */
+export function buildJumpToTaskAction(taskId) {
+    return {
+        label: 'Jump to Task',
+        type: 'jump-to-task',
+        permission: 'read',
+        payload: { taskId },
+    };
+}
+/**
+ * Build a 'jump-to-agent' action.
+ */
+export function buildJumpToAgentAction(agentId) {
+    return {
+        label: 'Jump to Agent',
+        type: 'jump-to-agent',
+        permission: 'read',
+        payload: { agentId },
+    };
+}
+/**
+ * Build a 'jump-to-tool-call' action.
+ */
+export function buildJumpToToolCallAction(callId) {
+    return {
+        label: 'Jump to Tool Call',
+        type: 'jump-to-tool-call',
+        permission: 'read',
+        payload: { callId },
+    };
+}
+/**
+ * Build a 'retry-task' action.
+ */
+export function buildRetryTaskAction(taskId, note) {
+    return {
+        label: 'Retry Task',
+        type: 'retry-task',
+        permission: 'operator',
+        payload: { taskId, note },
+    };
+}
+/**
+ * Build a 'cancel-task' action.
+ */
+export function buildCancelTaskAction(taskId, note) {
+    return {
+        label: 'Cancel Task',
+        type: 'cancel-task',
+        permission: 'operator',
+        payload: { taskId, note },
+    };
+}
+/**
+ * Build a 'cancel-agent' action.
+ */
+export function buildCancelAgentAction(agentId, note) {
+    return {
+        label: 'Cancel Agent',
+        type: 'cancel-agent',
+        permission: 'operator',
+        payload: { agentId, note },
+    };
+}
+/**
+ * Create a HighSeverityDiagnostic from a task failure.
+ *
+ * Attaches retry and jump-to-task actions. Satisfies the acceptance criterion
+ * that every high-severity diagnostic has at least one remediation action.
+ */
+export function diagnosticFromTaskFailure(opts) {
+    return {
+        id: `task-failure:${opts.taskId}`,
+        summary: `Task failed: ${opts.description} — ${opts.error}`,
+        domain: 'tasks',
+        severity: 'error',
+        ts: opts.ts,
+        sessionId: opts.sessionId,
+        traceId: opts.traceId,
+        actions: [
+            buildRetryTaskAction(opts.taskId, 'Diagnostic retry'),
+            buildJumpToTaskAction(opts.taskId),
+        ],
+    };
+}
+/**
+ * Create a HighSeverityDiagnostic from an agent failure.
+ *
+ * Attaches cancel and jump-to-agent actions.
+ */
+export function diagnosticFromAgentFailure(opts) {
+    return {
+        id: `agent-failure:${opts.agentId}`,
+        summary: `Agent failed: ${opts.task} — ${opts.error}`,
+        domain: 'agents',
+        severity: 'error',
+        ts: opts.ts,
+        sessionId: opts.sessionId,
+        traceId: opts.traceId,
+        actions: [
+            buildCancelAgentAction(opts.agentId, 'Diagnostic cancel'),
+            buildJumpToAgentAction(opts.agentId),
+        ],
+    };
+}
+/**
+ * Create a HighSeverityDiagnostic from a tool contract violation.
+ *
+ * Attaches a policy simulation action and optionally a jump-to-tool-call action.
+ */
+export function diagnosticFromToolContractViolation(opts) {
+    const extra = opts.callId
+        ? [buildJumpToToolCallAction(opts.callId)]
+        : [];
+    const actions = [
+        buildRunPolicySimulationAction(opts.toolName, {}),
+        ...extra,
+    ];
+    return {
+        id: `tool-contract:${opts.toolName}:${opts.ts}`,
+        summary: `Tool contract violation: ${opts.toolName} — ${opts.message}`,
+        domain: 'tool-contracts',
+        severity: 'error',
+        ts: opts.ts,
+        sessionId: opts.sessionId,
+        traceId: opts.traceId,
+        actions,
+    };
+}
+/**
+ * Create a HighSeverityDiagnostic from a forensics/replay run.
+ *
+ * Attaches a load-replay action so the operator can step through the run.
+ */
+export function diagnosticFromForensicsRun(opts) {
+    return {
+        id: `forensics:${opts.runId}`,
+        summary: opts.summary,
+        domain: 'forensics',
+        severity: 'error',
+        ts: opts.ts,
+        sessionId: opts.sessionId,
+        traceId: opts.traceId,
+        actions: [buildLoadReplayAction(opts.runId)],
+    };
+}

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

@@ -0,0 +1,40 @@
+/**
+ * Diagnostics system — barrel re-exports and factory.
+ *
+ * This module provides the public API for the runtime diagnostics system.
+ * Import from here to access types, providers, and the factory function.
+ *
+ * Usage:
+ * ```ts
+ * import { createDiagnosticsProvider } from '../runtime/diagnostics/index.js';
+ *
+ * const provider = createDiagnosticsProvider({
+ *   eventBus,
+ *   healthAggregator,
+ *   domains: [...],
+ * });
+ * ```
+ */
+export type { DiagnosticFilter, DiagnosticLevel, PanelConfig, ToolCallEntry, ToolCallPhase, ToolCallPermission, AgentEntry, AgentDiagnosticState, TaskEntry, EventEntry, DomainStateEntry, RuntimeStateSnapshot, DomainHealthSummary, HealthDashboardData, } from './types.js';
+export { DEFAULT_BUFFER_LIMIT, DEFAULT_PANEL_CONFIG, applyFilter, appendBounded } from './types.js';
+export type { DiagnosticActionType, DiagnosticActionPermission, DiagnosticActionPayload, DiagnosticAction, HighSeverityDiagnostic, ActionResult, NavigateToEntryCallback, PermissionChecker, DiagnosticActionDispatcherConfig, LoadReplayPayload, RunPolicySimulationPayload, JumpToTaskPayload, JumpToAgentPayload, JumpToToolCallPayload, RetryTaskPayload, CancelTaskPayload, CancelAgentPayload, } from './actions.js';
+export { DiagnosticActionDispatcher, buildLoadReplayAction, buildRunPolicySimulationAction, buildJumpToTaskAction, buildJumpToAgentAction, buildJumpToToolCallAction, buildRetryTaskAction, buildCancelTaskAction, buildCancelAgentAction, diagnosticFromTaskFailure, diagnosticFromAgentFailure, diagnosticFromToolContractViolation, diagnosticFromForensicsRun, } from './actions.js';
+export { ToolCallsPanel } from './panels/tool-calls.js';
+export { AgentsPanel } from './panels/agents.js';
+export { TasksPanel } from './panels/tasks.js';
+export { EventsPanel } from './panels/events.js';
+export { StateInspectorPanel } from './panels/state-inspector.js';
+export type { InspectableDomain } from './panels/state-inspector.js';
+export { HealthPanel } from './panels/health.js';
+export { DiagnosticsProvider } from './provider.js';
+export type { DiagnosticsProviderConfig, DiagnosticPanelName } from './provider.js';
+import { DiagnosticsProvider, type DiagnosticsProviderConfig } from './provider.js';
+/**
+ * Factory function that creates a fully wired DiagnosticsProvider.
+ *
+ * @param config - Configuration including the event bus, health aggregator,
+ *   optional domain adapters, and optional per-panel buffer config.
+ * @returns A ready-to-use DiagnosticsProvider.
+ */
+export declare function createDiagnosticsProvider(config: DiagnosticsProviderConfig): DiagnosticsProvider;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/diagnostics/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,YAAY,EACV,gBAAgB,EAChB,eAAe,EACf,WAAW,EACX,aAAa,EACb,aAAa,EACb,kBAAkB,EAClB,UAAU,EACV,oBAAoB,EACpB,SAAS,EACT,UAAU,EACV,gBAAgB,EAChB,oBAAoB,EACpB,mBAAmB,EACnB,mBAAmB,GACpB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAGpG,YAAY,EACV,oBAAoB,EACpB,0BAA0B,EAC1B,uBAAuB,EACvB,gBAAgB,EAChB,sBAAsB,EACtB,YAAY,EACZ,uBAAuB,EACvB,iBAAiB,EACjB,gCAAgC,EAChC,iBAAiB,EACjB,0BAA0B,EAC1B,iBAAiB,EACjB,kBAAkB,EAClB,qBAAqB,EACrB,gBAAgB,EAChB,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,0BAA0B,EAC1B,qBAAqB,EACrB,8BAA8B,EAC9B,qBAAqB,EACrB,sBAAsB,EACtB,yBAAyB,EACzB,oBAAoB,EACpB,qBAAqB,EACrB,sBAAsB,EACtB,yBAAyB,EACzB,0BAA0B,EAC1B,mCAAmC,EACnC,0BAA0B,GAC3B,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAClE,YAAY,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAGjD,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACpD,YAAY,EAAE,yBAAyB,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAGpF,OAAO,EAAE,mBAAmB,EAAE,KAAK,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAEpF;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,yBAAyB,GAAG,mBAAmB,CAEhG"}

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

@@ -0,0 +1,40 @@
+/**
+ * Diagnostics system — barrel re-exports and factory.
+ *
+ * This module provides the public API for the runtime diagnostics system.
+ * Import from here to access types, providers, and the factory function.
+ *
+ * Usage:
+ * ```ts
+ * import { createDiagnosticsProvider } from '../runtime/diagnostics/index.js';
+ *
+ * const provider = createDiagnosticsProvider({
+ *   eventBus,
+ *   healthAggregator,
+ *   domains: [...],
+ * });
+ * ```
+ */
+export { DEFAULT_BUFFER_LIMIT, DEFAULT_PANEL_CONFIG, applyFilter, appendBounded } from './types.js';
+export { DiagnosticActionDispatcher, buildLoadReplayAction, buildRunPolicySimulationAction, buildJumpToTaskAction, buildJumpToAgentAction, buildJumpToToolCallAction, buildRetryTaskAction, buildCancelTaskAction, buildCancelAgentAction, diagnosticFromTaskFailure, diagnosticFromAgentFailure, diagnosticFromToolContractViolation, diagnosticFromForensicsRun, } from './actions.js';
+// ── Panel data providers ─────────────────────────────────────────────────────
+export { ToolCallsPanel } from './panels/tool-calls.js';
+export { AgentsPanel } from './panels/agents.js';
+export { TasksPanel } from './panels/tasks.js';
+export { EventsPanel } from './panels/events.js';
+export { StateInspectorPanel } from './panels/state-inspector.js';
+export { HealthPanel } from './panels/health.js';
+// ── Provider ─────────────────────────────────────────────────────────────────
+export { DiagnosticsProvider } from './provider.js';
+// ── Factory ───────────────────────────────────────────────────────────────────
+import { DiagnosticsProvider } from './provider.js';
+/**
+ * Factory function that creates a fully wired DiagnosticsProvider.
+ *
+ * @param config - Configuration including the event bus, health aggregator,
+ *   optional domain adapters, and optional per-panel buffer config.
+ * @returns A ready-to-use DiagnosticsProvider.
+ */
+export function createDiagnosticsProvider(config) {
+    return new DiagnosticsProvider(config);
+}

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

@@ -0,0 +1,51 @@
+/**
+ * Agents diagnostic panel data provider.
+ *
+ * Subscribes to agent lifecycle events via the RuntimeEventBus and maintains
+ * a bounded buffer of AgentEntry records. Provides filtered snapshots
+ * for the agents/cohorts diagnostics panel.
+ *
+ * Tracks state, ownership, blockers, and completion status for each agent.
+ */
+import type { RuntimeEventBus } from '../../events/index.js';
+import { type AgentEntry, type DiagnosticFilter, type PanelConfig } from '@pellux/goodvibes-sdk/platform/runtime/diagnostics/types';
+/**
+ * AgentsPanel — diagnostic data provider for agent lifecycle telemetry.
+ *
+ * Active agents are tracked in a live map; terminal agents are moved
+ * to the history buffer for filtering and display.
+ */
+export declare class AgentsPanel {
+    private readonly _config;
+    private readonly _eventBus;
+    /** Active agents keyed by agentId. */
+    private readonly _active;
+    /** Completed agent history (oldest first). */
+    private readonly _history;
+    /** Registered change notification callbacks. */
+    private readonly _subscribers;
+    /** Unsubscribe function from the event bus. */
+    private _unsub;
+    constructor(eventBus: RuntimeEventBus, config?: PanelConfig);
+    private _start;
+    private _handleEnvelope;
+    private _finalize;
+    /**
+     * Return a filtered snapshot combining active agents and completed history.
+     * Ordered most-recent first.
+     *
+     * @param filter - Optional filter to restrict entries.
+     */
+    getSnapshot(filter?: DiagnosticFilter): AgentEntry[];
+    /**
+     * Register a callback invoked whenever the data changes.
+     * @returns An unsubscribe function.
+     */
+    subscribe(callback: () => void): () => void;
+    /**
+     * Release all event bus subscriptions and clear internal state.
+     */
+    dispose(): void;
+    private _notify;
+}
+//# sourceMappingURL=agents.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../../../../../../src/_internal/platform/runtime/diagnostics/panels/agents.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,eAAe,EAAoB,MAAM,uBAAuB,CAAC;AAG/E,OAAO,EACL,KAAK,UAAU,EAEf,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAIjB,MAAM,0DAA0D,CAAC;AAkBlE;;;;;GAKG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAc;IACtC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAkB;IAC5C,sCAAsC;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyC;IACjE,8CAA8C;IAC9C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoB;IAC7C,gDAAgD;IAChD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAyB;IACtD,+CAA+C;IAC/C,OAAO,CAAC,MAAM,CAA6B;gBAE/B,QAAQ,EAAE,eAAe,EAAE,MAAM,GAAE,WAAkC;IAMjF,OAAO,CAAC,MAAM;IASd,OAAO,CAAC,eAAe;IAuGvB,OAAO,CAAC,SAAS;IAoBjB;;;;;OAKG;IACI,WAAW,CAAC,MAAM,CAAC,EAAE,gBAAgB,GAAG,UAAU,EAAE;IAsB3D;;;OAGG;IACI,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAKlD;;OAEG;IACI,OAAO,IAAI,IAAI;IAQtB,OAAO,CAAC,OAAO;CAShB"}