@ericsanchezok/synergy-workbench 0.0.0-stage → 3.1.0

package/dist/performance/schema.js

@@ -0,0 +1,628 @@
+import { ObservabilityConfig } from "@ericsanchezok/synergy-harness/observability/config";
+import { ObservabilitySchema } from "@ericsanchezok/synergy-harness/observability/schema";
+import { SessionManager } from "@ericsanchezok/synergy-harness/session/manager";
+import z from "zod";
+export var PerformanceSchema;
+(function (PerformanceSchema) {
+    PerformanceSchema.Source = ObservabilitySchema.Source.meta({ ref: "PerfSource" });
+    PerformanceSchema.Module = ObservabilitySchema.Module.meta({ ref: "PerfModule" });
+    PerformanceSchema.Unit = ObservabilitySchema.Unit.meta({ ref: "PerfUnit" });
+    PerformanceSchema.LabelValue = ObservabilitySchema.LabelValue.meta({ ref: "PerfLabelValue" });
+    PerformanceSchema.Labels = ObservabilitySchema.Labels.meta({ ref: "PerfLabels" });
+    PerformanceSchema.Metric = z
+        .object({
+        metricId: z.string(),
+        time: z.number(),
+        iso: z.string(),
+        name: z.string(),
+        value: z.number(),
+        unit: PerformanceSchema.Unit,
+        source: PerformanceSchema.Source,
+        module: PerformanceSchema.Module,
+        correlationId: z.string().optional(),
+        scopeID: z.string().optional(),
+        sessionID: z.string().optional(),
+        messageID: z.string().optional(),
+        callID: z.string().optional(),
+        traceId: z.string().optional(),
+        spanId: z.string().optional(),
+        parentSpanId: z.string().optional(),
+        rid: z.string().optional(),
+        processId: z.string().optional(),
+        pid: z.number().int().optional(),
+        tool: z.string().optional(),
+        labels: PerformanceSchema.Labels,
+        sampleRate: z.number().min(0).max(1).default(1),
+    })
+        .meta({ ref: "PerfMetric" });
+    PerformanceSchema.SpanStatus = z
+        .enum(["running", "ok", "error", "cancelled", "timeout", "interrupted"])
+        .meta({ ref: "PerfSpanStatus" });
+    PerformanceSchema.Span = z
+        .object({
+        traceId: z.string(),
+        correlationId: z.string().optional(),
+        spanId: z.string(),
+        parentSpanId: z.string().optional(),
+        kind: z.string().optional(),
+        name: z.string(),
+        module: PerformanceSchema.Module,
+        source: PerformanceSchema.Source,
+        startTime: z.number(),
+        endTime: z.number().optional(),
+        durationMs: z.number().optional(),
+        status: PerformanceSchema.SpanStatus.default("ok"),
+        lastActivityTime: z.number().optional(),
+        heartbeatTime: z.number().optional(),
+        heartbeatCount: z.number().int().optional(),
+        stalled: z.boolean().optional(),
+        errorCode: z.string().optional(),
+        errorMessage: z.string().optional(),
+        scopeID: z.string().optional(),
+        sessionID: z.string().optional(),
+        messageID: z.string().optional(),
+        callID: z.string().optional(),
+        rid: z.string().optional(),
+        processId: z.string().optional(),
+        pid: z.number().int().optional(),
+        tool: z.string().optional(),
+        attributes: PerformanceSchema.Labels,
+    })
+        .meta({ ref: "PerfSpan" });
+    PerformanceSchema.ResourceSample = z
+        .object({
+        sampleId: z.string(),
+        time: z.number(),
+        iso: z.string(),
+        source: PerformanceSchema.Source,
+        process: z.object({ pid: z.number().int().optional(), processId: z.string().optional(), role: z.string() }),
+        cpu: z
+            .object({
+            userMicros: z.number().optional(),
+            systemMicros: z.number().optional(),
+            utilizationRatio: z
+                .number()
+                .describe("Process CPU time per wall-clock time; 1 is one fully used CPU core and values may exceed 1")
+                .optional(),
+        })
+            .default({}),
+        memory: z
+            .object({
+            rssBytes: z.number().optional(),
+            heapTotalBytes: z.number().optional(),
+            heapUsedBytes: z.number().optional(),
+            externalBytes: z.number().optional(),
+            arrayBuffersBytes: z.number().optional(),
+        })
+            .default({}),
+        cgroup: z
+            .object({
+            currentBytes: z.number().optional(),
+            highBytes: z.number().optional(),
+            maxBytes: z.number().optional(),
+            peakBytes: z.number().optional(),
+            oomCount: z.number().optional(),
+            oomKillCount: z.number().optional(),
+        })
+            .optional(),
+        serviceMemory: z
+            .object({
+            rssBytes: z.number().optional(),
+            source: z.enum(["cgroup_v2", "process_api"]),
+            completeness: z.enum(["full", "partial"]),
+        })
+            .optional(),
+        eventLoop: z.object({ lagMs: z.number().optional(), sampleWindowMs: z.number() }),
+        io: z
+            .object({
+            appReadBytes: z.number().optional(),
+            appWrittenBytes: z.number().optional(),
+            appReadOps: z.number().optional(),
+            appWriteOps: z.number().optional(),
+            osReadBytes: z.number().optional(),
+            osWrittenBytes: z.number().optional(),
+            osAvailable: z.boolean().default(false),
+        })
+            .default({ osAvailable: false }),
+        correlationId: z.string().optional(),
+        scopeID: z.string().optional(),
+        sessionID: z.string().optional(),
+        traceId: z.string().optional(),
+        labels: PerformanceSchema.Labels,
+    })
+        .meta({ ref: "PerfResourceSample" });
+    PerformanceSchema.IssueSeverity = z.enum(["info", "warning", "error", "critical"]).meta({ ref: "PerfIssueSeverity" });
+    PerformanceSchema.IssueStatus = z.enum(["open", "resolved", "suppressed"]).meta({ ref: "PerfIssueStatus" });
+    PerformanceSchema.Issue = z
+        .object({
+        issueId: z.string(),
+        time: z.number(),
+        iso: z.string(),
+        severity: PerformanceSchema.IssueSeverity,
+        status: PerformanceSchema.IssueStatus.default("open"),
+        code: z.string(),
+        title: z.string(),
+        message: z.string(),
+        recommendation: z.string().optional(),
+        module: PerformanceSchema.Module,
+        correlationId: z.string().optional(),
+        scopeID: z.string().optional(),
+        traceId: z.string().optional(),
+        spanId: z.string().optional(),
+        sessionID: z.string().optional(),
+        messageID: z.string().optional(),
+        callID: z.string().optional(),
+        rid: z.string().optional(),
+        evidence: PerformanceSchema.Labels,
+        firstSeenTime: z.number(),
+        lastSeenTime: z.number(),
+        occurrenceCount: z.number().int(),
+        fingerprint: z.string(),
+    })
+        .meta({ ref: "PerfIssue" });
+    PerformanceSchema.RankedItem = z
+        .object({
+        id: z.string(),
+        label: z.string(),
+        module: PerformanceSchema.Module.optional(),
+        value: z.number(),
+        unit: PerformanceSchema.Unit,
+        traceId: z.string().optional(),
+        sessionID: z.string().optional(),
+        tool: z.string().optional(),
+        status: z.string().optional(),
+        processId: z.string().optional(),
+        pid: z.number().int().optional(),
+    })
+        .meta({ ref: "PerfRankedItem" });
+    PerformanceSchema.ToolFailureCategory = z
+        .object({
+        errorClass: z.string(),
+        count: z.number().int().nonnegative(),
+    })
+        .meta({ ref: "PerfToolFailureCategory" });
+    PerformanceSchema.ToolFailureItem = z
+        .object({
+        tool: z.string(),
+        callCount: z.number().int().nonnegative(),
+        errorCount: z.number().int().nonnegative(),
+        errorRate: z.number().min(0).max(1),
+        categories: z.array(PerformanceSchema.ToolFailureCategory),
+    })
+        .meta({ ref: "PerfToolFailureItem" });
+    PerformanceSchema.TimelineQuality = z
+        .object({
+        truncated: z.boolean().optional(),
+        sampled: z.boolean().optional(),
+        partial: z.boolean().optional(),
+        retentionLimited: z.boolean().optional(),
+        unavailableReason: z.string().optional(),
+    })
+        .meta({ ref: "PerfTimelineQuality" });
+    PerformanceSchema.ResourceOwnerKind = z
+        .enum(["control_plane", "agent", "policy", "plugin", "browser", "mcp", "local_process"])
+        .meta({ ref: "PerfResourceOwnerKind" });
+    PerformanceSchema.ResourceRecovery = z
+        .object({
+        action: z.enum(["gc", "recycle", "idle_retire", "close"]),
+        reason: z.string(),
+        at: z.number(),
+        beforeBytes: z.number().nonnegative().optional(),
+        afterBytes: z.number().nonnegative().optional(),
+        reclaimedBytes: z.number().nonnegative().optional(),
+        timedOut: z.boolean().optional(),
+    })
+        .meta({ ref: "PerfResourceRecovery" });
+    PerformanceSchema.ResourceOwner = z
+        .object({
+        owner: PerformanceSchema.ResourceOwnerKind,
+        processCount: z.number().int().nonnegative(),
+        measuredProcessCount: z.number().int().nonnegative(),
+        currentBytes: z.number().nonnegative().optional(),
+        peakBytes: z.number().nonnegative().optional(),
+        baselineBytes: z.number().nonnegative().optional(),
+        retainedBytes: z.number().nonnegative().optional(),
+        heapUsedBytes: z.number().nonnegative().optional(),
+        externalBytes: z.number().nonnegative().optional(),
+        arrayBuffersBytes: z.number().nonnegative().optional(),
+        source: z.enum([
+            "process_api",
+            "worker_ipc",
+            "plugin_monitor",
+            "browser_runtime",
+            "mcp_stdio",
+            "process_registry",
+        ]),
+        completeness: z.enum(["full", "partial", "unavailable"]),
+        attributes: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])).default({}),
+        lastRecovery: PerformanceSchema.ResourceRecovery.optional(),
+    })
+        .meta({ ref: "PerfResourceOwner" });
+    PerformanceSchema.DashboardSummary = z
+        .object({
+        generatedAt: z.string(),
+        windowMs: z.number(),
+        quality: PerformanceSchema.TimelineQuality.optional(),
+        health: z.object({
+            status: z.enum(["healthy", "degraded", "critical", "unknown"]),
+            score: z.number(),
+            openIssueCount: z.number().int(),
+            criticalIssueCount: z.number().int(),
+        }),
+        backend: z.object({
+            requestCount: z.number().int(),
+            errorRate: z.number(),
+            p50RequestMs: z.number().optional(),
+            p95RequestMs: z.number().optional(),
+            p99RequestMs: z.number().optional(),
+            activeSessions: z.number().int(),
+            pendingSessions: z.number().int(),
+        }),
+        resources: z.object({
+            rssBytes: z.number().optional(),
+            heapUsedBytes: z.number().optional(),
+            heapTotalBytes: z.number().optional(),
+            externalBytes: z.number().optional(),
+            arrayBuffersBytes: z.number().optional(),
+            cpuUtilizationRatio: z
+                .number()
+                .describe("Process CPU time per wall-clock time; 1 is one fully used CPU core and values may exceed 1")
+                .optional(),
+            eventLoopLagP95Ms: z.number().optional(),
+            appReadBytes: z.number().optional(),
+            appWrittenBytes: z.number().optional(),
+            appReadOps: z.number().int().optional(),
+            appWriteOps: z.number().int().optional(),
+            childProcessCount: z.number().int().optional(),
+            measuredChildProcessCount: z.number().int().optional(),
+            serviceMemory: z
+                .object({
+                rssBytes: z.number().optional(),
+                currentBytes: z.number().optional(),
+                workingSetBytes: z.number().optional(),
+                reclaimableBytes: z.number().optional(),
+                peakBytes: z.number().optional(),
+                source: z.enum(["cgroup_v2", "process_api"]),
+                completeness: z.enum(["full", "partial"]),
+            })
+                .optional(),
+            childProcessRssBytes: z.number().optional(),
+            owners: z.array(PerformanceSchema.ResourceOwner),
+        }),
+        sessions: z.object({
+            turnCount: z.number().int(),
+            p95TurnMs: z.number().optional(),
+            llmCallCount: z.number().int(),
+            toolCallCount: z.number().int(),
+        }),
+        frontend: z.object({
+            inpMs: z.number().optional(),
+            lcpMs: z.number().optional(),
+            cls: z.number().optional(),
+            fcpMs: z.number().optional(),
+            ttfbMs: z.number().optional(),
+            longTaskCount: z.number().int(),
+            resourceP95Ms: z.number().optional(),
+        }),
+        runtime: z.object({
+            alive: z.boolean().optional(),
+            healthy: z.boolean().optional(),
+            pid: z.number().int().optional(),
+            mode: z.string().optional(),
+            mirrorFiles: z.number().int(),
+            traceFiles: z.number().int().optional(),
+            recentErrors: z.number().int(),
+            pendingSessions: z.number().int(),
+            sessionRuntimes: z.object({
+                totalCount: z.number().int(),
+                runningCount: z.number().int(),
+                idleCount: z.number().int(),
+                childCount: z.number().int(),
+                userCount: z.number().int(),
+                waiterCount: z.number().int(),
+                executionPhases: z.partialRecord(SessionManager.ExecutionPhase, z.number().int().nonnegative()).optional(),
+            }),
+            execution: z
+                .object({
+                agentWorkers: z.object({
+                    configured: z.number().int().positive(),
+                    minIdle: z.number().int().nonnegative(),
+                    idleTimeoutMs: z.number().int().positive(),
+                    maxQueued: z.number().int().nonnegative(),
+                    maxQueuedBytes: z.number().int().positive(),
+                    workers: z.number().int().nonnegative(),
+                    ready: z.number().int().nonnegative(),
+                    active: z.number().int().nonnegative(),
+                    queued: z.number().int().nonnegative(),
+                    queuedBytes: z.number().int().nonnegative(),
+                    rssBytes: z.number().int().nonnegative(),
+                    heapUsedBytes: z.number().int().nonnegative(),
+                    heapTotalBytes: z.number().int().nonnegative(),
+                    externalBytes: z.number().int().nonnegative(),
+                    arrayBuffersBytes: z.number().int().nonnegative(),
+                }),
+                policyWorkers: z.object({
+                    configured: z.number().int().positive(),
+                    maxQueued: z.number().int().nonnegative(),
+                    maxQueuedBytes: z.number().int().positive(),
+                    workers: z.number().int().nonnegative(),
+                    ready: z.number().int().nonnegative(),
+                    active: z.number().int().nonnegative(),
+                    queued: z.number().int().nonnegative(),
+                    queuedBytes: z.number().int().nonnegative(),
+                    rssBytes: z.number().int().nonnegative(),
+                    heapUsedBytes: z.number().int().nonnegative(),
+                    heapTotalBytes: z.number().int().nonnegative(),
+                    externalBytes: z.number().int().nonnegative(),
+                    arrayBuffersBytes: z.number().int().nonnegative(),
+                }),
+                toolTasks: z.object({
+                    active: z.number().int().nonnegative(),
+                    queued: z.number().int().nonnegative(),
+                    tracked: z.number().int().nonnegative(),
+                    queuedBytes: z.number().int().nonnegative(),
+                    maxConcurrent: z.number().int().positive(),
+                    maxQueued: z.number().int().nonnegative(),
+                    maxQueuedBytes: z.number().int().positive().optional(),
+                    byExecutor: z
+                        .partialRecord(z.enum(["local_process", "file", "plugin", "mcp", "browser", "control_plane"]), z.object({
+                        active: z.number().int().nonnegative(),
+                        queued: z.number().int().nonnegative(),
+                        limit: z.number().int().positive(),
+                    }))
+                        .optional(),
+                }),
+            })
+                .optional(),
+            messageCache: z
+                .object({
+                totalBytes: z.number().int().nonnegative(),
+                activeCount: z.number().int().nonnegative(),
+                entryCount: z.number().int().nonnegative(),
+                hits: z.number().int().nonnegative(),
+                misses: z.number().int().nonnegative(),
+                evictions: z.number().int().nonnegative(),
+                protectedOverbudget: z.number().int().nonnegative(),
+                entries: z.array(z.object({ estimatedBytes: z.number().int().nonnegative() })),
+                truncatedEntryCount: z.number().int().nonnegative(),
+            })
+                .optional(),
+            llmTurns: z
+                .object({
+                activeTurnCount: z.number().int().nonnegative(),
+                activeStreamCount: z.number().int().nonnegative(),
+                turns: z.array(z.object({
+                    ageMs: z.number().nonnegative(),
+                    streamActive: z.boolean(),
+                    providerID: z.string(),
+                    modelID: z.string(),
+                    historyBeforeBytes: z.number().int().nonnegative(),
+                    historyAfterBytes: z.number().int().nonnegative(),
+                    requestBytes: z.number().int().nonnegative(),
+                    toolSchemaBytes: z.number().int().nonnegative(),
+                    outputChars: z.number().int().nonnegative(),
+                    toolRawChars: z.number().int().nonnegative(),
+                })),
+            })
+                .optional(),
+            cortexTasks: z.object({
+                totalCount: z.number().int(),
+                queuedCount: z.number().int(),
+                runningCount: z.number().int(),
+                completedCount: z.number().int(),
+                errorCount: z.number().int(),
+                cancelledCount: z.number().int(),
+                interruptedCount: z.number().int(),
+                retainedPromptChars: z.number().int(),
+                retainedOutputChars: z.number().int(),
+                retainedErrorChars: z.number().int(),
+                retainedProgressToolCount: z.number().int(),
+            }),
+        }),
+        top: z.object({
+            slowRoutes: z.array(PerformanceSchema.RankedItem),
+            slowSessions: z.array(PerformanceSchema.RankedItem),
+            slowTools: z.array(PerformanceSchema.RankedItem),
+            toolFailures: z.array(PerformanceSchema.ToolFailureItem),
+            slowProviders: z.array(PerformanceSchema.RankedItem),
+            slowStorage: z.array(PerformanceSchema.RankedItem),
+            slowLibrary: z.array(PerformanceSchema.RankedItem),
+            childProcesses: z.array(PerformanceSchema.RankedItem),
+            slowFrontend: z.array(PerformanceSchema.RankedItem),
+        }),
+        issues: z.array(PerformanceSchema.Issue),
+    })
+        .meta({ ref: "PerfDashboardSummary" });
+    PerformanceSchema.TimelineQuery = z
+        .object({
+        from: z.string().optional(),
+        to: z.string().optional(),
+        bucketMs: z.coerce.number().int().positive().optional(),
+        metric: z.union([z.string(), z.array(z.string())]).optional(),
+        stat: z.enum(["avg", "latest", "sum", "rate", "p50", "p95", "p99", "max"]).optional(),
+        scopeID: z.string().optional(),
+        sessionID: z.string().optional(),
+        tool: z.string().optional(),
+        providerID: z.string().optional(),
+        module: PerformanceSchema.Module.optional(),
+        windowMs: z.coerce.number().int().positive().optional(),
+    })
+        .meta({ ref: "PerfTimelineQuery" });
+    PerformanceSchema.TimelineStat = z
+        .enum(["avg", "latest", "sum", "rate", "p50", "p95", "p99", "max"])
+        .meta({ ref: "PerfTimelineStat" });
+    PerformanceSchema.MetricKind = z
+        .enum(["duration", "gauge", "counter", "rate", "size", "ratio"])
+        .meta({ ref: "PerfMetricKind" });
+    PerformanceSchema.TimelinePoint = z
+        .object({ time: z.number(), value: z.number().nullable(), sampleCount: z.number().int().optional() })
+        .meta({ ref: "PerfTimelinePoint" });
+    PerformanceSchema.TimelineSeries = z
+        .object({
+        name: z.string(),
+        label: z.string().optional(),
+        unit: PerformanceSchema.Unit,
+        kind: PerformanceSchema.MetricKind.optional(),
+        stat: PerformanceSchema.TimelineStat.optional(),
+        sampleCount: z.number().int().optional(),
+        module: PerformanceSchema.Module.optional(),
+        source: PerformanceSchema.Source.optional(),
+        quality: PerformanceSchema.TimelineQuality.optional(),
+        points: z.array(PerformanceSchema.TimelinePoint),
+    })
+        .meta({ ref: "PerfTimelineSeries" });
+    PerformanceSchema.Timeline = z
+        .object({
+        generatedAt: z.string(),
+        from: z.number(),
+        to: z.number(),
+        bucketMs: z.number(),
+        quality: PerformanceSchema.TimelineQuality.optional(),
+        series: z.array(PerformanceSchema.TimelineSeries),
+    })
+        .meta({ ref: "PerfTimeline" });
+    PerformanceSchema.TraceListQuery = z
+        .object({
+        from: z.string().optional(),
+        to: z.string().optional(),
+        limit: z.coerce.number().int().positive().max(200).optional(),
+        cursor: z.string().optional(),
+        kind: z
+            .enum(["request", "session", "tool", "provider", "runtime", "storage", "frontend", "mcp", "plugin", "channel"])
+            .optional(),
+        status: PerformanceSchema.SpanStatus.optional(),
+        minDurationMs: z.coerce.number().nonnegative().optional(),
+        scopeID: z.string().optional(),
+        sessionID: z.string().optional(),
+    })
+        .meta({ ref: "PerfTraceListQuery" });
+    PerformanceSchema.TraceListItem = z
+        .object({
+        traceId: z.string(),
+        correlationId: z.string().optional(),
+        kind: z.string(),
+        name: z.string(),
+        status: PerformanceSchema.SpanStatus,
+        startedAt: z.string(),
+        endedAt: z.string().optional(),
+        durationMs: z.number().optional(),
+        module: PerformanceSchema.Module,
+        source: PerformanceSchema.Source,
+        sessionID: z.string().optional(),
+        scopeID: z.string().optional(),
+        rid: z.string().optional(),
+        tool: z.string().optional(),
+        errorCode: z.string().optional(),
+        redactionApplied: z.boolean(),
+    })
+        .meta({ ref: "PerfTraceListItem" });
+    PerformanceSchema.TraceList = z
+        .object({ generatedAt: z.string(), items: z.array(PerformanceSchema.TraceListItem), nextCursor: z.string().optional() })
+        .meta({ ref: "PerfTraceList" });
+    PerformanceSchema.InflightSpan = PerformanceSchema.Span.extend({
+        ageMs: z.number(),
+        idleMs: z.number(),
+        stale: z.boolean(),
+        activeSince: z.number().optional(),
+    }).meta({ ref: "PerfInflightSpan" });
+    PerformanceSchema.Inflight = z
+        .object({ generatedAt: z.string(), spans: z.array(PerformanceSchema.InflightSpan) })
+        .meta({ ref: "PerfInflight" });
+    PerformanceSchema.AnalysisRequest = z
+        .object({
+        windowMs: z.coerce.number().int().min(1000).max(86_400_000).default(900_000),
+    })
+        .meta({ ref: "PerformanceAnalysisRequest" });
+    PerformanceSchema.AnalysisStatus = z
+        .enum(["queued", "running", "completed", "error", "cancelled", "interrupted"])
+        .meta({ ref: "PerformanceAnalysisStatus" });
+    PerformanceSchema.AnalysisView = z
+        .object({
+        sessionID: z.string(),
+        status: PerformanceSchema.AnalysisStatus,
+        startedAt: z.number(),
+        completedAt: z.number().optional(),
+        result: z.string().optional(),
+        error: z.string().optional(),
+    })
+        .meta({ ref: "PerformanceAnalysisView" });
+    PerformanceSchema.TraceEvent = z
+        .object({
+        time: z.number(),
+        iso: z.string(),
+        type: z.string(),
+        level: z.string().optional(),
+        traceId: z.string().optional(),
+        correlationId: z.string().optional(),
+        sessionID: z.string().optional(),
+        messageID: z.string().optional(),
+        callID: z.string().optional(),
+        rid: z.string().optional(),
+        tool: z.string().optional(),
+        processId: z.string().optional(),
+        pid: z.number().int().optional(),
+        dataKeys: z.array(z.string()).default([]),
+        redactionApplied: z.boolean(),
+    })
+        .meta({ ref: "PerfTraceEvent" });
+    PerformanceSchema.TraceDetail = z
+        .object({
+        generatedAt: z.string(),
+        traceId: z.string(),
+        root: PerformanceSchema.Span.optional(),
+        spans: z.array(PerformanceSchema.Span),
+        events: z.array(PerformanceSchema.TraceEvent),
+        redaction: z.object({ applied: z.boolean(), omittedAttributes: z.number().int() }),
+    })
+        .meta({ ref: "PerfTraceDetail" });
+    PerformanceSchema.BrowserMetric = z
+        .object({
+        name: z.string().max(96),
+        value: z.number(),
+        unit: PerformanceSchema.Unit,
+        time: z.number().optional(),
+        labels: PerformanceSchema.Labels.optional(),
+    })
+        .meta({ ref: "PerfBrowserMetric" });
+    PerformanceSchema.BrowserMetricBatch = z
+        .object({
+        batchId: z.string().max(128).optional(),
+        sentAt: z.number(),
+        page: z
+            .object({
+            routeName: z.string().max(256).optional(),
+            pathTemplate: z.string().max(512).optional(),
+            sessionID: z.string().max(128).optional(),
+            scopeID: z.string().max(128).optional(),
+            correlationId: z.string().max(128).optional(),
+            navigationId: z.string().max(128).optional(),
+            sessionSwitchId: z.string().max(128).optional(),
+        })
+            .default({}),
+        metrics: z.array(PerformanceSchema.BrowserMetric).max(100),
+        resourceEntries: z
+            .array(z.object({
+            name: z.string().max(2048),
+            initiatorType: z.string().max(64).optional(),
+            startTime: z.number(),
+            duration: z.number(),
+            transferSize: z.number().optional(),
+            encodedBodySize: z.number().optional(),
+            decodedBodySize: z.number().optional(),
+            requestStart: z.number().finite().nonnegative().optional(),
+            responseStart: z.number().finite().nonnegative().optional(),
+            responseEnd: z.number().finite().nonnegative().optional(),
+        }))
+            .max(100)
+            .optional(),
+        longTasks: z
+            .array(z.object({ startTime: z.number(), duration: z.number(), attribution: z.string().max(128).optional() }))
+            .max(100)
+            .optional(),
+    })
+        .meta({ ref: "PerfBrowserMetricBatch" });
+    PerformanceSchema.BrowserMetricIngestResult = z
+        .object({ batchId: z.string(), accepted: z.number().int(), rejected: z.number().int(), receivedAt: z.string() })
+        .meta({ ref: "PerfBrowserMetricIngestResult" });
+    PerformanceSchema.Config = ObservabilityConfig.Schema.meta({ ref: "PerfConfig" });
+})(PerformanceSchema || (PerformanceSchema = {}));