@ericsanchezok/synergy-workbench 0.0.0-stage → 3.1.0

package/dist/performance/dashboard.js

@@ -0,0 +1,483 @@
+import { ResourceSources } from "@ericsanchezok/synergy-harness/observability/resource-sources";
+import { RuntimeContext } from "@ericsanchezok/synergy-harness/lifecycle/context";
+import { Cortex } from "@ericsanchezok/synergy-harness/cortex";
+import { Diagnostics } from "@ericsanchezok/synergy-harness/observability/diagnostics";
+import { ObservabilityIssues } from "@ericsanchezok/synergy-harness/observability/issues";
+import { ObservabilityStore } from "@ericsanchezok/synergy-harness/observability/store";
+import { SessionManager } from "@ericsanchezok/synergy-harness/session/manager";
+import { SessionMessageCache } from "@ericsanchezok/synergy-harness/session/message-cache";
+import { LLMTurnMemory } from "@ericsanchezok/synergy-harness/session/llm-memory";
+import { parseJson } from "@ericsanchezok/synergy-harness/util/json-parse";
+import { PerformanceProjection } from "./projection.js";
+import { PerformanceSchema } from "./schema.js";
+import { AgentTurn } from "@ericsanchezok/synergy-harness/session/agent-turn";
+import { readRuntimeStats } from "@ericsanchezok/synergy-harness/lifecycle";
+import { PolicyWorker } from "@ericsanchezok/synergy-harness/enforcement/policy-worker";
+import { ProcessRegistry } from "@ericsanchezok/synergy-harness/process/registry";
+import { SessionMemoryPressure } from "@ericsanchezok/synergy-harness/session/memory-pressure";
+export var PerformanceDashboard;
+(function (PerformanceDashboard) {
+    const SUMMARY_CACHE_MS = 1000;
+    const runtimeState = RuntimeContext.state(() => ({
+        cached: undefined,
+        labelsCache: new WeakMap(),
+    }));
+    // Ranked and latest detail can reuse the same row across several projections.
+    function metricLabels(row) {
+        const instanceState = runtimeState();
+        const cachedLabels = instanceState.labelsCache.get(row);
+        if (cachedLabels)
+            return cachedLabels;
+        const labels = parseJson(row.labels_json);
+        instanceState.labelsCache.set(row, labels);
+        return labels;
+    }
+    function summary(input = {}) {
+        const instanceState = runtimeState();
+        const key = `${input.windowMs ?? 300_000}:${input.scopeID ?? ""}`;
+        const version = ObservabilityStore.dataVersion();
+        const now = Date.now();
+        if (instanceState.cached?.key === key &&
+            (instanceState.cached.pending ||
+                (instanceState.cached.version === version && now - instanceState.cached.at < SUMMARY_CACHE_MS)))
+            return instanceState.cached.value;
+        const value = computeSummary(input);
+        const wrapped = value
+            .then((result) => {
+            if (instanceState.cached?.value === wrapped) {
+                instanceState.cached.pending = false;
+                instanceState.cached.at = Date.now();
+            }
+            return result;
+        })
+            .catch((error) => {
+            const instanceState = runtimeState();
+            if (instanceState.cached?.value === wrapped)
+                instanceState.cached = undefined;
+            throw error;
+        });
+        instanceState.cached = { key, version, pending: true, at: now, value: wrapped };
+        return wrapped;
+    }
+    PerformanceDashboard.summary = summary;
+    async function computeSummary(input = {}) {
+        const windowMs = Math.max(1000, Math.min(input.windowMs ?? 300_000, 86_400_000));
+        // Storage uses an exclusive upper bound; include observations in the current millisecond.
+        const until = Date.now() + 1;
+        const since = until - windowMs;
+        const filter = { since, until, scopeID: input.scopeID };
+        const aggregate = async (name) => (await ObservabilityStore.queryMetricBuckets({
+            since,
+            until,
+            scopeID: input.scopeID,
+            names: [name],
+            bucketMs: windowMs + 1,
+        }))[0];
+        const [requests, turnSummary, resourceSummary, counts, toolSums, activeSessions] = await Promise.all([
+            aggregate("http.request.duration"),
+            aggregate("session.turn.duration"),
+            aggregate("frontend.resource.duration"),
+            ObservabilityStore.queryMetricCounts(filter),
+            ObservabilityStore.queryMetricSums({ ...filter, names: ["tool.execution.count", "tool.execution.error"] }),
+            ObservabilityStore.countMetricSessions({ ...filter, since: Math.max(since, until - 300_000) }),
+        ]);
+        const highlightNames = counts
+            .filter((row) => (row.module === "llm" && row.name.endsWith(".duration")) ||
+            [
+                "http.request.duration",
+                "session.turn.duration",
+                "tool.execution.duration",
+                "storage.operation.duration",
+                "library.operation.duration",
+                "frontend.resource.duration",
+                "frontend.long_task.duration",
+                "frontend.web_vital",
+                "service.memory.current",
+                "service.memory.working_set",
+                "service.memory.reclaimable",
+                "service.memory.peak",
+            ].includes(row.name))
+            .map((row) => row.name);
+        const metrics = highlightNames.length
+            ? await ObservabilityStore.queryMetricHighlights({ ...filter, names: [...new Set(highlightNames)] })
+            : [];
+        const count = (name) => counts.filter((row) => row.name === name).reduce((sum, row) => sum + row.count, 0);
+        const serverFilter = { role: "server", until, limit: 1 };
+        const resources = ObservabilityStore.resourceSince(since, { ...serverFilter, newestFirst: true })[0];
+        const serverBaseline = ObservabilityStore.resourceSince(since, serverFilter)[0];
+        const currentChildRows = resources
+            ? ObservabilityStore.resourceSince(resources.time, {
+                role: "tool",
+                until: resources.time + 1,
+                limit: 50_000,
+            })
+            : [];
+        const [serverResources, childResources] = await Promise.all([
+            ObservabilityStore.resourceSummary({ since, until, role: "server" }),
+            resources
+                ? ObservabilityStore.resourceSummary({ since: resources.time, until: resources.time + 1, role: "tool" })
+                : undefined,
+        ]);
+        const childProcesses = rankChildProcesses(currentChildRows);
+        const issueCounts = ObservabilityStore.countIssues({ status: "open", scopeID: input.scopeID, since });
+        const issues = ObservabilityIssues.list({
+            status: "open",
+            scopeID: input.scopeID,
+            since,
+            limit: 20,
+        }).map(PerformanceProjection.issue);
+        const diagnostics = await Diagnostics.summary().catch(() => undefined);
+        const runtimeStats = SessionManager.runtimeStats();
+        const agentWorkers = AgentTurn.stats();
+        const policyWorkers = PolicyWorker.stats();
+        const { toolTasks } = readRuntimeStats();
+        const contributedResources = await ResourceSources.read();
+        const localProcesses = await ProcessRegistry.resourceStats();
+        const controlPlane = SessionMemoryPressure.stats();
+        const messageCacheStats = SessionMessageCache.stats();
+        const llmTurnStats = LLMTurnMemory.stats();
+        const activeLLMTurns = LLMTurnMemory.activeSnapshot(20);
+        const cortexTasks = Cortex.list();
+        const cortexStats = {
+            totalCount: cortexTasks.length,
+            byStatus: {
+                queued: cortexTasks.filter((task) => task.status === "queued").length,
+                running: cortexTasks.filter((task) => task.status === "running").length,
+                completed: cortexTasks.filter((task) => task.status === "completed").length,
+                error: cortexTasks.filter((task) => task.status === "error").length,
+                cancelled: cortexTasks.filter((task) => task.status === "cancelled").length,
+                interrupted: cortexTasks.filter((task) => task.status === "interrupted").length,
+            },
+            retainedPromptChars: cortexTasks.reduce((sum, task) => sum + task.prompt.length, 0),
+            retainedOutputChars: cortexTasks.reduce((sum, task) => {
+                if (!task.output)
+                    return sum;
+                if (task.output.mode === "summary" || task.output.mode === "final_response")
+                    return sum + task.output.value.length;
+                try {
+                    return sum + JSON.stringify(task.output.value).length;
+                }
+                catch {
+                    return sum;
+                }
+            }, 0),
+            retainedErrorChars: cortexTasks.reduce((sum, task) => sum + (task.error?.length ?? 0), 0),
+            retainedProgressToolCount: cortexTasks.reduce((sum, task) => sum + (task.progress?.recentTools?.length ?? 0), 0),
+        };
+        const http = metrics.filter((row) => row.name === "http.request.duration");
+        const turns = metrics.filter((row) => row.name === "session.turn.duration");
+        const llm = metrics.filter((row) => row.module === "llm" && row.name.endsWith(".duration"));
+        const tools = metrics.filter((row) => row.name === "tool.execution.duration");
+        const toolFailures = rankToolFailures(toolSums);
+        const storage = metrics.filter((row) => row.name === "storage.operation.duration");
+        const library = metrics.filter((row) => row.name === "library.operation.duration");
+        const frontendResources = metrics.filter((row) => row.name === "frontend.resource.duration");
+        const frontendLongTasks = metrics.filter((row) => row.name === "frontend.long_task.duration");
+        const frontendVital = (name) => metrics.find((row) => row.name === "frontend.web_vital" && metricLabels(row).name === name)?.value;
+        const criticalIssueCount = issueCounts.critical;
+        const score = Math.max(0, 100 - criticalIssueCount * 40 - issueCounts.error * 20 - issueCounts.warning * 8);
+        const status = criticalIssueCount > 0 ? "critical" : issueCounts.total > 0 ? "degraded" : "healthy";
+        const serverPeakBytes = serverResources?.peakRssBytes ?? undefined;
+        const currentServerBytes = resources?.memory_rss_bytes ?? undefined;
+        const serverBaselineBytes = serverBaseline?.memory_rss_bytes ?? undefined;
+        const latestMetric = (name) => metrics.find((row) => row.name === name)?.value;
+        const owners = [
+            {
+                owner: "control_plane",
+                processCount: 1,
+                measuredProcessCount: currentServerBytes === undefined ? 0 : 1,
+                currentBytes: currentServerBytes,
+                peakBytes: serverPeakBytes ?? currentServerBytes,
+                baselineBytes: serverBaselineBytes,
+                retainedBytes: currentServerBytes === undefined || serverBaselineBytes === undefined
+                    ? undefined
+                    : Math.max(0, currentServerBytes - serverBaselineBytes),
+                heapUsedBytes: resources?.memory_heap_used_bytes ?? undefined,
+                externalBytes: resources?.memory_external_bytes ?? undefined,
+                arrayBuffersBytes: resources?.memory_array_buffers_bytes ?? undefined,
+                source: "process_api",
+                completeness: currentServerBytes === undefined ? "unavailable" : "full",
+                attributes: {
+                    pressure: controlPlane.lastAssessment?.pressure ?? "unknown",
+                    processPressure: controlPlane.lastAssessment?.processPressure ?? "unknown",
+                    servicePressure: controlPlane.lastAssessment?.servicePressure ?? "unknown",
+                },
+                lastRecovery: controlPlane.lastRecovery,
+            },
+            {
+                owner: "agent",
+                processCount: agentWorkers.workers,
+                measuredProcessCount: agentWorkers.measuredWorkers,
+                currentBytes: agentWorkers.rssBytes,
+                peakBytes: agentWorkers.peakBytes,
+                baselineBytes: agentWorkers.baselineBytes,
+                retainedBytes: agentWorkers.retainedBytes,
+                heapUsedBytes: agentWorkers.heapUsedBytes,
+                externalBytes: agentWorkers.externalBytes,
+                arrayBuffersBytes: agentWorkers.arrayBuffersBytes,
+                source: "worker_ipc",
+                completeness: agentWorkers.workers === 0 || agentWorkers.measuredWorkers === agentWorkers.workers ? "full" : "partial",
+                attributes: { active: agentWorkers.active, queued: agentWorkers.queued },
+                lastRecovery: agentWorkers.lastRecovery,
+            },
+            {
+                owner: "policy",
+                processCount: policyWorkers.workers,
+                measuredProcessCount: policyWorkers.measuredWorkers,
+                currentBytes: policyWorkers.rssBytes,
+                peakBytes: policyWorkers.peakBytes,
+                baselineBytes: policyWorkers.baselineBytes,
+                retainedBytes: policyWorkers.retainedBytes,
+                heapUsedBytes: policyWorkers.heapUsedBytes,
+                externalBytes: policyWorkers.externalBytes,
+                arrayBuffersBytes: policyWorkers.arrayBuffersBytes,
+                source: "worker_ipc",
+                completeness: policyWorkers.workers === 0 || policyWorkers.measuredWorkers === policyWorkers.workers ? "full" : "partial",
+                attributes: { active: policyWorkers.active, queued: policyWorkers.queued },
+                lastRecovery: policyWorkers.lastRecovery,
+            },
+            ...contributedResources,
+            {
+                owner: "local_process",
+                ...localProcesses,
+                source: "process_registry",
+                completeness: localProcesses.processCount === 0 || localProcesses.measuredProcessCount === localProcesses.processCount
+                    ? "full"
+                    : "partial",
+                attributes: {
+                    stdioOpen: localProcesses.stdio.open,
+                    stdioDraining: localProcesses.stdio.draining,
+                    stdioClosed: localProcesses.stdio.closed,
+                    timedOut: localProcesses.stdio.timedOut,
+                    drainTimedOut: localProcesses.stdio.drainTimedOut,
+                    descendantPipeGraceMs: localProcesses.stdio.descendantPipeGraceMs,
+                },
+            },
+        ];
+        return PerformanceSchema.DashboardSummary.parse({
+            generatedAt: new Date().toISOString(),
+            windowMs,
+            health: { status, score, openIssueCount: issueCounts.total, criticalIssueCount },
+            backend: {
+                requestCount: requests?.count ?? 0,
+                errorRate: requests ? requests.errors / requests.count : 0,
+                p50RequestMs: requests?.p50,
+                p95RequestMs: requests?.p95,
+                p99RequestMs: requests?.p99,
+                activeSessions,
+                pendingSessions: diagnostics?.sessions.paused.length ?? 0,
+            },
+            resources: {
+                rssBytes: resources?.memory_rss_bytes ?? undefined,
+                heapUsedBytes: resources?.memory_heap_used_bytes ?? undefined,
+                heapTotalBytes: resources?.memory_heap_total_bytes ?? undefined,
+                externalBytes: resources?.memory_external_bytes ?? undefined,
+                arrayBuffersBytes: resources?.memory_array_buffers_bytes ?? undefined,
+                cpuUtilizationRatio: resources?.cpu_utilization_ratio ?? undefined,
+                eventLoopLagP95Ms: serverResources?.eventLoopLagP95Ms ?? undefined,
+                appReadBytes: resources?.app_read_bytes ?? undefined,
+                appWrittenBytes: resources?.app_written_bytes ?? undefined,
+                appReadOps: resources?.app_read_ops ?? undefined,
+                appWriteOps: resources?.app_write_ops ?? undefined,
+                childProcessCount: childResources?.count ?? 0,
+                measuredChildProcessCount: childResources?.measuredCount ?? 0,
+                serviceMemory: resources?.service_memory_source && resources.service_memory_completeness
+                    ? {
+                        rssBytes: resources.service_memory_rss_bytes ?? undefined,
+                        currentBytes: latestMetric("service.memory.current") ?? resources.service_memory_rss_bytes ?? undefined,
+                        workingSetBytes: latestMetric("service.memory.working_set"),
+                        reclaimableBytes: latestMetric("service.memory.reclaimable"),
+                        peakBytes: latestMetric("service.memory.peak"),
+                        source: resources.service_memory_source,
+                        completeness: resources.service_memory_completeness,
+                    }
+                    : undefined,
+                childProcessRssBytes: childResources?.rssBytes ?? 0,
+                owners,
+            },
+            sessions: {
+                turnCount: turnSummary?.count ?? 0,
+                p95TurnMs: turnSummary?.p95,
+                llmCallCount: counts
+                    .filter((row) => row.module === "llm" && row.name.endsWith(".duration"))
+                    .reduce((sum, row) => sum + row.count, 0),
+                toolCallCount: count("tool.execution.duration"),
+            },
+            frontend: {
+                inpMs: frontendVital("INP"),
+                lcpMs: frontendVital("LCP"),
+                cls: frontendVital("CLS"),
+                fcpMs: frontendVital("FCP"),
+                ttfbMs: frontendVital("TTFB"),
+                longTaskCount: count("frontend.long_task.duration"),
+                resourceP95Ms: resourceSummary?.p95,
+            },
+            runtime: {
+                alive: diagnostics?.lock?.inspection && typeof diagnostics.lock.inspection === "object"
+                    ? diagnostics.lock.inspection.alive
+                    : undefined,
+                healthy: diagnostics?.lock?.inspection && typeof diagnostics.lock.inspection === "object"
+                    ? diagnostics.lock.inspection.healthy
+                    : undefined,
+                pid: diagnostics?.lock?.lock && typeof diagnostics.lock.lock === "object"
+                    ? diagnostics.lock.lock.pid
+                    : undefined,
+                mode: diagnostics?.lock?.lock && typeof diagnostics.lock.lock === "object"
+                    ? diagnostics.lock.lock.mode
+                    : undefined,
+                mirrorFiles: diagnostics?.traces.files.length ?? 0,
+                traceFiles: diagnostics?.traces.files.length ?? 0,
+                recentErrors: diagnostics?.traces.recentErrors.length ?? 0,
+                pendingSessions: diagnostics?.sessions.paused.length ?? 0,
+                sessionRuntimes: runtimeStats,
+                execution: {
+                    agentWorkers,
+                    policyWorkers,
+                    toolTasks,
+                },
+                messageCache: {
+                    totalBytes: messageCacheStats.totalBytes,
+                    activeCount: messageCacheStats.activeCount,
+                    entryCount: messageCacheStats.entryCount,
+                    hits: messageCacheStats.hits,
+                    misses: messageCacheStats.misses,
+                    evictions: messageCacheStats.evictions,
+                    protectedOverbudget: messageCacheStats.protectedOverbudget,
+                    entries: messageCacheStats.entries.map((entry) => ({ estimatedBytes: entry.estimatedBytes })),
+                    truncatedEntryCount: messageCacheStats.truncatedEntryCount,
+                },
+                llmTurns: {
+                    ...llmTurnStats,
+                    turns: activeLLMTurns.map((turn) => ({
+                        ageMs: turn.ageMs,
+                        streamActive: turn.streamActive,
+                        providerID: turn.providerID,
+                        modelID: turn.modelID,
+                        historyBeforeBytes: turn.historyBeforeBytes,
+                        historyAfterBytes: turn.historyAfterBytes,
+                        requestBytes: turn.requestBytes,
+                        toolSchemaBytes: turn.toolSchemaBytes,
+                        outputChars: turn.outputChars,
+                        toolRawChars: turn.toolRawChars,
+                    })),
+                },
+                cortexTasks: {
+                    totalCount: cortexStats.totalCount,
+                    queuedCount: cortexStats.byStatus.queued,
+                    runningCount: cortexStats.byStatus.running,
+                    completedCount: cortexStats.byStatus.completed,
+                    errorCount: cortexStats.byStatus.error,
+                    cancelledCount: cortexStats.byStatus.cancelled,
+                    interruptedCount: cortexStats.byStatus.interrupted,
+                    retainedPromptChars: cortexStats.retainedPromptChars,
+                    retainedOutputChars: cortexStats.retainedOutputChars,
+                    retainedErrorChars: cortexStats.retainedErrorChars,
+                    retainedProgressToolCount: cortexStats.retainedProgressToolCount,
+                },
+            },
+            top: {
+                slowRoutes: rank(http, "path"),
+                slowSessions: rank(turns, "session_id"),
+                slowTools: rank(tools, "tool"),
+                toolFailures,
+                slowProviders: rank(llm, "providerID", "provider", "modelID", "model"),
+                slowStorage: rank(storage, "operation"),
+                slowLibrary: rank(library, "operation"),
+                childProcesses,
+                slowFrontend: rank([...frontendResources, ...frontendLongTasks], "routeName", "pathTemplate", "route", "name", "attribution"),
+            },
+            issues,
+        });
+    }
+    function rank(rows, ...labelKeys) {
+        return [...rows]
+            .sort((a, b) => b.value - a.value)
+            .slice(0, 5)
+            .map((row, index) => {
+            const label = String(firstLabel(metricLabels(row), labelKeys) ?? row.tool ?? row.session_id ?? row.name);
+            return {
+                id: `${row.metric_id}-${index}`,
+                label,
+                module: row.module,
+                value: row.value,
+                unit: row.unit,
+                traceId: row.trace_id ?? undefined,
+                sessionID: row.session_id ?? undefined,
+                tool: row.tool ?? undefined,
+            };
+        });
+    }
+    function rankToolFailures(rows) {
+        const tools = new Map();
+        for (const row of rows) {
+            if (row.name !== "tool.execution.count" && row.name !== "tool.execution.error")
+                continue;
+            const tool = row.tool ?? stringLabel(metricLabels(row).tool);
+            if (!tool)
+                continue;
+            const entry = tools.get(tool) ?? { callCount: 0, errorCount: 0, categories: new Map() };
+            if (row.name === "tool.execution.count") {
+                entry.callCount += row.value;
+            }
+            else {
+                entry.errorCount += row.value;
+                const errorClass = stringLabel(metricLabels(row).errorName) ?? "UnknownError";
+                entry.categories.set(errorClass, (entry.categories.get(errorClass) ?? 0) + row.value);
+            }
+            tools.set(tool, entry);
+        }
+        return Array.from(tools, ([tool, entry]) => ({
+            tool,
+            callCount: entry.callCount,
+            errorCount: entry.errorCount,
+            errorRate: entry.errorCount / Math.max(entry.callCount, entry.errorCount, 1),
+            categories: Array.from(entry.categories, ([errorClass, count]) => ({ errorClass, count }))
+                .sort((a, b) => b.count - a.count || a.errorClass.localeCompare(b.errorClass))
+                .slice(0, 3),
+        }))
+            .filter((entry) => entry.errorCount > 0)
+            .sort((a, b) => b.errorCount - a.errorCount || b.errorRate - a.errorRate || a.tool.localeCompare(b.tool))
+            .slice(0, 5);
+    }
+    function stringLabel(value) {
+        return typeof value === "string" && value.length > 0 ? value : undefined;
+    }
+    function rankChildProcesses(rows) {
+        const latest = new Map();
+        for (const row of rows) {
+            if (!row.process_role?.startsWith("tool"))
+                continue;
+            if (row.memory_rss_bytes === undefined || row.memory_rss_bytes === null)
+                continue;
+            const id = row.process_id ?? (row.pid === undefined || row.pid === null ? undefined : `pid:${row.pid}`);
+            if (!id)
+                continue;
+            const existing = latest.get(id);
+            if (!existing || row.time > existing.time)
+                latest.set(id, row);
+        }
+        return Array.from(latest.values())
+            .sort((a, b) => (b.memory_rss_bytes ?? 0) - (a.memory_rss_bytes ?? 0))
+            .slice(0, 5)
+            .map((row, index) => {
+            const labels = metricLabels(row);
+            return {
+                id: `${row.sample_id}-${index}`,
+                label: String(labels.command ?? labels.description ?? row.process_id ?? row.pid ?? "tool child process"),
+                module: "process",
+                value: row.memory_rss_bytes ?? 0,
+                unit: "bytes",
+                processId: row.process_id ?? undefined,
+                pid: row.pid ?? undefined,
+                status: row.process_role ?? undefined,
+            };
+        });
+    }
+    function firstLabel(labels, keys) {
+        for (const key of keys) {
+            const value = labels[key];
+            if (value !== undefined && value !== null && value !== "")
+                return value;
+        }
+    }
+})(PerformanceDashboard || (PerformanceDashboard = {}));

package/dist/performance/error.js

@@ -0,0 +1,15 @@
+export class PerformanceError extends Error {
+    code;
+    status;
+    data;
+    constructor(code, message, status, data = {}) {
+        super(message);
+        this.code = code;
+        this.status = status;
+        this.data = data;
+        this.name = "PerformanceError";
+    }
+    toResponse() {
+        return { code: this.code, message: this.message, ...this.data };
+    }
+}

package/dist/performance/index.js

@@ -0,0 +1,6 @@
+export { PerformanceDashboard } from "./dashboard.js";
+export { PerformanceError } from "./error.js";
+export { PerformanceInflight } from "./inflight.js";
+export { PerformanceSchema } from "./schema.js";
+export { PerformanceTimeline } from "./timeline.js";
+export { PerformanceTraceDetail } from "./trace-detail.js";

package/dist/performance/inflight.js

@@ -0,0 +1,43 @@
+import { ObservabilityStore } from "@ericsanchezok/synergy-harness/observability/store";
+import { PerformanceSchema } from "./schema.js";
+import { parseJson } from "@ericsanchezok/synergy-harness/util/json-parse";
+export var PerformanceInflight;
+(function (PerformanceInflight) {
+    function get(input = {}) {
+        const spans = ObservabilityStore.queryInflight(input).map((row) => PerformanceSchema.InflightSpan.parse({
+            traceId: row.trace_id,
+            correlationId: row.correlation_id ?? undefined,
+            spanId: row.span_id,
+            parentSpanId: row.parent_span_id ?? undefined,
+            kind: row.kind,
+            name: row.name,
+            module: row.module,
+            source: row.source,
+            startTime: row.start_time,
+            endTime: row.end_time ?? undefined,
+            durationMs: row.duration_ms ?? undefined,
+            status: row.status,
+            lastActivityTime: row.last_activity_time ?? undefined,
+            heartbeatTime: row.heartbeat_time ?? undefined,
+            heartbeatCount: row.heartbeat_count ?? undefined,
+            stalled: row.stalled ? true : undefined,
+            errorCode: row.error_code ?? undefined,
+            errorMessage: row.error_message ?? undefined,
+            scopeID: row.scope_id ?? undefined,
+            sessionID: row.session_id ?? undefined,
+            messageID: row.message_id ?? undefined,
+            callID: row.call_id ?? undefined,
+            rid: row.rid ?? undefined,
+            processId: row.process_id ?? undefined,
+            pid: row.pid ?? undefined,
+            tool: row.tool ?? undefined,
+            attributes: parseJson(row.attributes_json),
+            ageMs: row.age_ms,
+            idleMs: row.idle_ms,
+            stale: row.stale,
+            activeSince: row.last_activity_time ?? row.start_time,
+        }));
+        return PerformanceSchema.Inflight.parse({ generatedAt: new Date().toISOString(), spans });
+    }
+    PerformanceInflight.get = get;
+})(PerformanceInflight || (PerformanceInflight = {}));