diff --git a/bun.lock b/bun.lock
index 4e1b8f0c446..a851742abb0 100644
--- a/bun.lock
+++ b/bun.lock
@@ -178,7 +178,7 @@
         "@fontsource/dm-mono": "5.2.7",
         "@fortawesome/fontawesome-free": "7.2.0",
         "@hey-api/client-fetch": "0.13.1",
-        "@hey-api/openapi-ts": "0.97.3",
+        "@hey-api/openapi-ts": "0.99.0",
         "@monaco-editor/loader": "1.7.0",
         "@playwright/test": "1.58.2",
         "@poppanator/sveltekit-svg": "6.0.1",
@@ -364,13 +364,13 @@
 
     "@hey-api/client-fetch": ["@hey-api/client-fetch@0.13.1", "", { "peerDependencies": { "@hey-api/openapi-ts": "< 2" } }, "sha512-29jBRYNdxVGlx5oewFgOrkulZckpIpBIRHth3uHFn1PrL2ucMy52FvWOY3U3dVx2go1Z3kUmMi6lr07iOpUqqA=="],
 
-    "@hey-api/codegen-core": ["@hey-api/codegen-core@0.8.2", "", { "dependencies": { "@hey-api/types": "0.1.4", "ansi-colors": "4.1.3", "c12": "3.3.4", "color-support": "1.1.3" } }, "sha512-R2NMf3wq97rh1mjz33WJQU8svz3F0RYUjvx/QzXucjpSqQ3O5huTdDjErG4fMxSr1X+X56NuDrqtGfHmo1TRUQ=="],
+    "@hey-api/codegen-core": ["@hey-api/codegen-core@0.9.1", "", { "dependencies": { "@hey-api/types": "0.1.4", "ansi-colors": "4.1.3", "c12": "3.3.4", "color-support": "1.1.3" } }, "sha512-s97jL1dgTMuiMHv2BZ1X4Tgd99Mf9GOvGdNqNcGwIMmnR+PgYNoraj4Zvp134MKsNCap/m7k0r0vKKnl56pj4w=="],
 
-    "@hey-api/json-schema-ref-parser": ["@hey-api/json-schema-ref-parser@1.4.2", "", { "dependencies": { "@jsdevtools/ono": "7.1.3", "@types/json-schema": "7.0.15", "js-yaml": "4.1.1" } }, "sha512-ZhCFSKI2ipZHEbgmtUHdyddvRU3wJ4elgCfYUC7T7hZa4EivSrVflTQf2w+v3TuaYxR1Y2V2kq3otqTttrrK8Q=="],
+    "@hey-api/json-schema-ref-parser": ["@hey-api/json-schema-ref-parser@1.4.4", "", { "dependencies": { "@jsdevtools/ono": "7.1.3", "@types/json-schema": "7.0.15", "js-yaml": "4.2.0" } }, "sha512-otmd+zCxbYVBIp/mlMTnGkvlNYLkVKgs3VOIq0kSnenhB1+fRwLPQIeSwyWM6E51oXhUedkYjVsVpkVexeuJOA=="],
 
-    "@hey-api/openapi-ts": ["@hey-api/openapi-ts@0.97.3", "", { "dependencies": { "@hey-api/codegen-core": "0.8.2", "@hey-api/json-schema-ref-parser": "1.4.2", "@hey-api/shared": "0.4.5", "@hey-api/spec-types": "0.2.0", "@hey-api/types": "0.1.4", "@lukeed/ms": "2.0.2", "ansi-colors": "4.1.3", "color-support": "1.1.3", "commander": "14.0.3", "get-tsconfig": "4.14.0" }, "peerDependencies": { "typescript": ">=5.5.3 || >=6.0.0 || 6.0.1-rc" }, "bin": { "openapi-ts": "./bin/run.js" } }, "sha512-4sR6/E/POuy7aPZW9DDjhObzZCq7eSJWiW0+epXeKNczoTWEwdOyWFy9Ca/CnXYlZ3oJsrv0ZD0OO+YuczT7CA=="],
+    "@hey-api/openapi-ts": ["@hey-api/openapi-ts@0.99.0", "", { "dependencies": { "@hey-api/codegen-core": "0.9.1", "@hey-api/json-schema-ref-parser": "1.4.4", "@hey-api/shared": "0.5.0", "@hey-api/spec-types": "0.2.0", "@hey-api/types": "0.1.4", "@lukeed/ms": "2.0.2", "ansi-colors": "4.1.3", "color-support": "1.1.3", "commander": "15.0.0", "get-tsconfig": "4.14.0" }, "peerDependencies": { "typescript": ">=5.5.3 || >=6.0.0 || 6.0.1-rc" }, "bin": { "openapi-ts": "./bin/run.js" } }, "sha512-SePU/5oEWWkvUBYmvzdYRctseoLuskyhs4ET0RvLIcmzc8yLQoA2R+KtBIQ8bPsoSUB0m4E5SmBnl6aGSA0szQ=="],
 
-    "@hey-api/shared": ["@hey-api/shared@0.4.5", "", { "dependencies": { "@hey-api/codegen-core": "0.8.2", "@hey-api/json-schema-ref-parser": "1.4.2", "@hey-api/spec-types": "0.2.0", "@hey-api/types": "0.1.4", "ansi-colors": "4.1.3", "cross-spawn": "7.0.6", "open": "11.0.0", "semver": "7.7.4" } }, "sha512-au4eHpBXAe1du0iMp6ESYuEaMS2jsoEyrbcT246btRhI9rMeQFEs7ZjtcMGXGsxhpaR38A8cPGNHx7QOrWAdMw=="],
+    "@hey-api/shared": ["@hey-api/shared@0.5.0", "", { "dependencies": { "@hey-api/codegen-core": "0.9.1", "@hey-api/json-schema-ref-parser": "1.4.4", "@hey-api/spec-types": "0.2.0", "@hey-api/types": "0.1.4", "ansi-colors": "4.1.3", "cross-spawn": "7.0.6", "open": "11.0.0", "semver": "7.8.4" } }, "sha512-JN/j4Ebh4cJGYIQ5cwWuqe7GeSUyQoz7oC51WqyhKOcrejK6DKZMDkshc5d1eKTRuRL+rjozuRcoUaZZn2DGPw=="],
 
     "@hey-api/spec-types": ["@hey-api/spec-types@0.2.0", "", { "dependencies": { "@hey-api/types": "0.1.4" } }, "sha512-ibQ8Is7evMavzr8GNyJCcTg975d8DpaMUyLmOrQ85UBdy1l6t1KuRAwgChAbesJsIlNV6gjmlXruWyegDX18Fg=="],
 
@@ -1014,7 +1014,7 @@
 
     "any-base": ["any-base@1.1.0", "", {}, "sha512-uMgjozySS8adZZYePpaWs8cxB9/kdzmpX6SgJZ+wbz1K5eYk5QMYDVJaZKhxyIHUdnnJkfR7SVgStgH7LkGUyg=="],
 
-    "apache-arrow": ["apache-arrow@github:Karakatiza666/arrow-js#ddba834", { "dependencies": { "@swc/helpers": "^0.5.11", "@types/command-line-args": "^5.2.3", "@types/command-line-usage": "^5.0.4", "@types/node": "^25.2.0", "command-line-args": "^6.0.1", "command-line-usage": "^7.0.1", "flatbuffers": "^25.1.24", "json-with-bigint": "^3.5.3", "tslib": "^2.6.2" }, "bin": { "arrow2csv": "bin/arrow2csv.cjs" } }, "Karakatiza666-arrow-js-ddba834", "sha512-N2H0djCXEuIXEXsZyPKGI4NT0xBhH3DdsNNP3Z273ym1h0OKHR6qrGld4l8RnxGjDwFzXhMZDEqEfN0NMFZUTA=="],
+    "apache-arrow": ["apache-arrow@github:Karakatiza666/arrow-js#ddba834", { "dependencies": { "@swc/helpers": "^0.5.11", "@types/command-line-args": "^5.2.3", "@types/command-line-usage": "^5.0.4", "@types/node": "^25.2.0", "command-line-args": "^6.0.1", "command-line-usage": "^7.0.1", "flatbuffers": "^25.1.24", "json-with-bigint": "^3.5.3", "tslib": "^2.6.2" }, "bin": { "arrow2csv": "bin/arrow2csv.cjs" } }, "Karakatiza666-arrow-js-ddba834"],
 
     "apexcharts": ["apexcharts@5.6.0", "", { "dependencies": { "@yr/monotone-cubic-spline": "^1.0.3" } }, "sha512-BZua59yedRsaDfnxkzNrkyLCvluq2c3ZDBIz4joxSKtgr0xDQXQ5dzceMhf/TpTbAjaF+2NYIpLP3BEEIG2s/w=="],
 
@@ -1120,7 +1120,7 @@
 
     "command-line-usage": ["command-line-usage@7.0.4", "", { "dependencies": { "array-back": "^6.2.2", "chalk-template": "^0.4.0", "table-layout": "^4.1.1", "typical": "^7.3.0" } }, "sha512-85UdvzTNx/+s5CkSgBm/0hzP80RFHAa7PsfeADE5ezZF3uHz3/Tqj9gIKGT9PTtpycc3Ua64T0oVulGfKxzfqg=="],
 
-    "commander": ["commander@14.0.3", "", {}, "sha512-H+y0Jo/T1RZ9qPP4Eh1pkcQcLRglraJaSLoyOtHxu6AapkjWVCy2Sit1QQ4x3Dng8qDlSsZEet7g5Pq06MvTgw=="],
+    "commander": ["commander@15.0.0", "", {}, "sha512-z67u4ZhzCL/Tydu1lJARtEZYWbWaN7oYLHbsuzocr6y4N6WZAagG3RQ4FW61V1/0+jImpj293XfrcYnd1qxtPg=="],
 
     "common-ui": ["common-ui@workspace:js-packages/common-ui"],
 
@@ -1446,7 +1446,7 @@
 
     "jpeg-js": ["jpeg-js@0.4.4", "", {}, "sha512-WZzeDOEtTOBK4Mdsar0IqEU5sMr3vSV2RqkAIzUEV2BHnUfKGyswWFPFwK5EeDo93K3FohSHbLAjj0s1Wzd+dg=="],
 
-    "js-yaml": ["js-yaml@4.1.1", "", { "dependencies": { "argparse": "^2.0.1" }, "bin": { "js-yaml": "bin/js-yaml.js" } }, "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA=="],
+    "js-yaml": ["js-yaml@4.2.0", "", { "dependencies": { "argparse": "^2.0.1" }, "bin": { "js-yaml": "bin/js-yaml.js" } }, "sha512-ePWsvanv0DWuDRsW8dnt+R4jQ31SCRCQ7hhNcPXZPsoBZiemuZNYGf7adZdqX2D86j6rvKp3RpCxVTSb8WQlOw=="],
 
     "json-buffer": ["json-buffer@3.0.1", "", {}, "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ=="],
 
@@ -2108,6 +2108,8 @@
 
     "@eslint-community/eslint-utils/eslint-visitor-keys": ["eslint-visitor-keys@3.4.3", "", {}, "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag=="],
 
+    "@hey-api/shared/semver": ["semver@7.8.4", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-rUCObTnP32Q08R2uuIrt7r9PlEonuTmtuXYcW6s5kjdlj3xbnwe+21yXptAUYcMAABLkYYTtnmzb3w3EDZfueA=="],
+
     "@jimp/png/pngjs": ["pngjs@6.0.0", "", {}, "sha512-TRzzuFRRmEoSW/p1KVAmiOgPco2Irlah+bGFCeNfJXxxYGwSw7YwAOAcd7X28K/m5bjBWKsC29KyoMfHbypayg=="],
 
     "@opentelemetry/otlp-transformer/@opentelemetry/resources": ["@opentelemetry/resources@2.2.0", "", { "dependencies": { "@opentelemetry/core": "2.2.0", "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-1pNQf/JazQTMA0BiO5NINUzH0cbLbbl7mntLa4aJNmCCXSj0q03T5ZXXL0zw4G55TjdL9Tz32cznGClf+8zr5A=="],
diff --git a/crates/adapters/src/controller/stats.rs b/crates/adapters/src/controller/stats.rs
index b9cf8f068ab..8f28f958e29 100644
--- a/crates/adapters/src/controller/stats.rs
+++ b/crates/adapters/src/controller/stats.rs
@@ -1641,8 +1641,21 @@ impl InputEndpointMetrics {
             num_transport_errors: self.num_transport_errors.load(Ordering::Relaxed),
             num_parse_errors: self.num_parse_errors.load(Ordering::Relaxed),
             end_of_input: self.end_of_input.load(Ordering::Relaxed),
+            processing_latency_p99_micros: self.processing_latency_p99_micros(),
         }
     }
+
+    /// 99th percentile processing latency in microseconds over the sliding
+    /// histogram's window, or `None` if the endpoint has no samples. See
+    /// [`ExternalInputEndpointMetrics::processing_latency_p99_micros`] for what
+    /// the window covers.
+    fn processing_latency_p99_micros(&self) -> Option<u64> {
+        self.processing_latency_micros_histogram
+            .lock()
+            .ok()?
+            .snapshot()
+            .quantile(0.99)
+    }
 }
 
 // Latency histogram creation functions.
@@ -3026,3 +3039,85 @@ impl OutputEndpointStatus {
         self.metrics.total_processed_steps.load(Ordering::Acquire)
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::InputEndpointMetrics;
+
+    #[test]
+    fn latency_p99_absent_without_samples() {
+        let metrics = InputEndpointMetrics::default();
+        assert_eq!(metrics.to_api_type().processing_latency_p99_micros, None);
+    }
+
+    #[test]
+    fn latency_p99_reports_uniform_bucket() {
+        let metrics = InputEndpointMetrics::default();
+        {
+            let mut histogram = metrics.processing_latency_micros_histogram.lock().unwrap();
+            for _ in 0..100 {
+                histogram.record(1_500u64);
+            }
+        }
+        // Bucket [1000, 1999] holds 1_500, and `quantile` reports its lower bound.
+        assert_eq!(
+            metrics.to_api_type().processing_latency_p99_micros,
+            Some(1_000)
+        );
+    }
+
+    /// Guards against reporting the median, which hides the slow tail the
+    /// column exists to surface.
+    #[test]
+    fn latency_p99_reports_slow_tail_not_median() {
+        let metrics = InputEndpointMetrics::default();
+        {
+            let mut histogram = metrics.processing_latency_micros_histogram.lock().unwrap();
+            // 90 fast samples against 10 slow ones: the median sits in the fast
+            // band, rank 99 (ceil(0.99 * 100)) lands in the slow one.
+            for _ in 0..90 {
+                histogram.record(1_500u64);
+            }
+            for _ in 0..10 {
+                histogram.record(250_000u64);
+            }
+        }
+        // Bucket [200000, 299999] holds 250_000, and `quantile` reports its
+        // lower bound. A median would report 1_000 here.
+        assert_eq!(
+            metrics.to_api_type().processing_latency_p99_micros,
+            Some(200_000)
+        );
+    }
+
+    /// Documents the known limit of a percentile over few samples: one slow
+    /// batch in a hundred stays below rank 99.
+    #[test]
+    fn latency_p99_misses_lone_outlier() {
+        let metrics = InputEndpointMetrics::default();
+        {
+            let mut histogram = metrics.processing_latency_micros_histogram.lock().unwrap();
+            for _ in 0..99 {
+                histogram.record(1_500u64);
+            }
+            histogram.record(250_000u64);
+        }
+        assert_eq!(
+            metrics.to_api_type().processing_latency_p99_micros,
+            Some(1_000)
+        );
+    }
+
+    /// Guards against reporting the completion histogram, which tracks a
+    /// different span and would silently change the column's meaning.
+    #[test]
+    fn latency_p99_ignores_completion_histogram() {
+        let metrics = InputEndpointMetrics::default();
+        metrics
+            .completion_latency_micros_histogram
+            .lock()
+            .unwrap()
+            .record(750_000u64);
+        assert_eq!(metrics.to_api_type().processing_latency_p99_micros, None);
+    }
+}
diff --git a/crates/feldera-types/src/adapter_stats.rs b/crates/feldera-types/src/adapter_stats.rs
index fad7007c8c8..107c5557348 100644
--- a/crates/feldera-types/src/adapter_stats.rs
+++ b/crates/feldera-types/src/adapter_stats.rs
@@ -215,6 +215,23 @@ pub struct ExternalInputEndpointMetrics {
     pub num_parse_errors: u64,
     /// True if end-of-input has been signaled.
     pub end_of_input: bool,
+    /// 99th percentile processing latency (from ingesting a batch to finishing processing it) in microseconds.
+    ///
+    /// The time from ingesting a batch of records off the wire
+    /// to the circuit finishing processing them,
+    /// covering parsing, queuing, and the circuit step.
+    ///
+    /// Does not account for completion latency.
+    ///
+    /// Taken over the endpoint's sliding histogram, which holds the 10,000 most
+    /// recent samples spanning at most 10 minutes, whichever bound is reached
+    /// first. One sample is recorded per completed batch. An endpoint that stops
+    /// ingesting keeps reporting its last known latency instead of dropping to
+    /// `None`.
+    ///
+    /// `None` until the endpoint records its first sample.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub processing_latency_p99_micros: Option<u64>,
 }
 
 /// Input endpoint status information.
diff --git a/crates/storage/src/histogram.rs b/crates/storage/src/histogram.rs
index f4de7018bd7..fc777592c9d 100644
--- a/crates/storage/src/histogram.rs
+++ b/crates/storage/src/histogram.rs
@@ -115,6 +115,25 @@ impl ExponentialHistogramSnapshot {
     pub fn sum(&self) -> u64 {
         self.sum
     }
+
+    /// Approximate `q`-quantile (`q` in `0.0..=1.0`), as the lower bound of the
+    /// containing bucket. `None` if empty.
+    pub fn quantile(&self, q: f64) -> Option<u64> {
+        let total: u64 = self.buckets.iter().sum();
+        if total == 0 {
+            return None;
+        }
+        let rank = ((q.clamp(0.0, 1.0) * total as f64).ceil() as u64).clamp(1, total);
+        let mut cumulative = 0u64;
+        for (index, count) in self.buckets.iter().enumerate() {
+            cumulative += *count;
+            if cumulative >= rank {
+                return Some(*bucket_to_range(index).start());
+            }
+        }
+        // Unreachable: `cumulative` reaches `total >= rank` in the loop.
+        Some(*bucket_to_range(N_BUCKETS - 1).start())
+    }
 }
 
 pub struct Bucket {
@@ -278,7 +297,52 @@ impl SlidingHistogram {
 
 #[cfg(test)]
 mod test {
-    use crate::histogram::{N_BUCKETS, bucket_to_range, number_to_bucket};
+    use crate::histogram::{ExponentialHistogram, N_BUCKETS, bucket_to_range, number_to_bucket};
+
+    #[test]
+    fn quantile_empty() {
+        let hist = ExponentialHistogram::new();
+        assert_eq!(hist.snapshot().quantile(0.5), None);
+        assert_eq!(hist.snapshot().quantile(0.99), None);
+    }
+
+    #[test]
+    fn quantile_single_sample() {
+        let hist = ExponentialHistogram::new();
+        hist.record(42u64);
+        // 42 lands in the bucket for [40, 49]; the lower bound is 40.
+        assert_eq!(hist.snapshot().quantile(0.0), Some(40));
+        assert_eq!(hist.snapshot().quantile(0.5), Some(40));
+        assert_eq!(hist.snapshot().quantile(1.0), Some(40));
+    }
+
+    #[test]
+    fn quantile_all_same_bucket() {
+        let hist = ExponentialHistogram::new();
+        for _ in 0..100 {
+            hist.record(5u64);
+        }
+        // Values 0..=9 each occupy their own bucket, so 5 is exact.
+        assert_eq!(hist.snapshot().quantile(0.5), Some(5));
+        assert_eq!(hist.snapshot().quantile(0.99), Some(5));
+    }
+
+    #[test]
+    fn quantile_known_distribution() {
+        let hist = ExponentialHistogram::new();
+        // 99 fast samples (bucket [0,0]) and 1 slow sample (bucket [900,999]).
+        for _ in 0..99 {
+            hist.record(0u64);
+        }
+        hist.record(950u64);
+        let snap = hist.snapshot();
+        // p50 stays with the fast majority.
+        assert_eq!(snap.quantile(0.5), Some(0));
+        // p99 (ceil(0.99*100)=99th value) is still the last fast sample.
+        assert_eq!(snap.quantile(0.99), Some(0));
+        // p100 reaches the lone slow sample: bucket [900, 999], lower bound 900.
+        assert_eq!(snap.quantile(1.0), Some(900));
+    }
 
     #[test]
     fn buckets() {
diff --git a/js-packages/web-console/openapi-ts.config.ts b/js-packages/web-console/openapi-ts.config.ts
index 1f8e287e497..64a8995d5a3 100644
--- a/js-packages/web-console/openapi-ts.config.ts
+++ b/js-packages/web-console/openapi-ts.config.ts
@@ -1,8 +1,30 @@
 import { defineConfig } from '@hey-api/openapi-ts'
+import {
+  type CustomTypes,
+  customTypesPlugin,
+  overrideOpenapiType
+} from './src/lib/functions/common/openapi-ts'
+
+/**
+ * Hand-written types substituted for the generated ones, keyed by the custom
+ * `format` that marks a schema.
+ */
+const customTypes = {
+  microseconds: { module: '$lib/functions/common/duration', name: 'Microseconds' }
+} as const satisfies CustomTypes
 
 export default defineConfig({
   input: '../../openapi.json',
   output: './src/lib/services/manager',
+  parser: {
+    patch: {
+      schemas: {
+        InputEndpointMetrics: (schema) => {
+          overrideOpenapiType(schema, 'processing_latency_p99_micros', 'microseconds')
+        }
+      }
+    }
+  },
   plugins: [
     {
       name: '@hey-api/client-fetch',
@@ -12,6 +34,7 @@ export default defineConfig({
     {
       name: '@hey-api/sdk',
       responseStyle: 'data'
-    }
+    },
+    customTypesPlugin(customTypes)
   ]
 })
diff --git a/js-packages/web-console/package.json b/js-packages/web-console/package.json
index fce7a44b27f..b5c975d993e 100644
--- a/js-packages/web-console/package.json
+++ b/js-packages/web-console/package.json
@@ -10,7 +10,7 @@
     "@fontsource/dm-mono": "5.2.7",
     "@fortawesome/fontawesome-free": "7.2.0",
     "@hey-api/client-fetch": "0.13.1",
-    "@hey-api/openapi-ts": "0.97.3",
+    "@hey-api/openapi-ts": "0.99.0",
     "@monaco-editor/loader": "1.7.0",
     "@playwright/test": "1.58.2",
     "@poppanator/sveltekit-svg": "6.0.1",
diff --git a/js-packages/web-console/src/assets/icons/feldera-material-icons/circle-help.svg b/js-packages/web-console/src/assets/icons/feldera-material-icons/circle-help.svg
new file mode 100755
index 00000000000..4d290c0da59
--- /dev/null
+++ b/js-packages/web-console/src/assets/icons/feldera-material-icons/circle-help.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="none" viewBox="0 0 24 24"><path stroke="#C533B9" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3m.08 4h.01M22 12c0 5.523-4.477 10-10 10S2 17.523 2 12 6.477 2 12 2s10 4.477 10 10Z"/></svg>
\ No newline at end of file
diff --git a/js-packages/web-console/src/lib/components/pipelines/editor/performance/MetricsTables.svelte b/js-packages/web-console/src/lib/components/pipelines/editor/performance/MetricsTables.svelte
index 62aca2c1cc2..b758c9c045f 100644
--- a/js-packages/web-console/src/lib/components/pipelines/editor/performance/MetricsTables.svelte
+++ b/js-packages/web-console/src/lib/components/pipelines/editor/performance/MetricsTables.svelte
@@ -4,7 +4,12 @@
   import ClipboardCopyButton from '$lib/components/other/ClipboardCopyButton.svelte'
   import { count } from '$lib/functions/common/array'
   import { humanSize } from '$lib/functions/common/string'
-  import { formatQty } from '$lib/functions/format'
+  import { formatDuration, formatQty } from '$lib/functions/format'
+  import {
+    defaultLatencyColorSpread,
+    latencyColor,
+    latencyColorScale
+  } from '$lib/functions/latencyColor'
   import type {
     AggregatedInputEndpointMetrics,
     AggregatedMetrics,
@@ -28,6 +33,17 @@
     ) => void
   } = $props()
 
+  // Calculated from individual connectors, so that a relation's color
+  // stays comparable to the connectors it summarizes.
+  const inputLatencyScale = $derived(
+    latencyColorScale(
+      [...metrics.current.tables.values()].flatMap((data) =>
+        data.connectors.map((connector) => connector.metrics.processing_latency_p99_micros)
+      ),
+      defaultLatencyColorSpread
+    )
+  )
+
   type HealthFilter = 'all' | 'unhealthy'
   let tableHealthFilter = $state<HealthFilter>('all')
   let viewHealthFilter = $state<HealthFilter>('all')
@@ -352,6 +368,20 @@
     <th class="font-normal" rowspan="2">Transaction</th>
     <th class="pb-0! text-center! font-normal" colspan="2">Ingested</th>
     <th class="pb-0! text-center! font-normal" colspan="2">Buffered</th>
+    <th class="font-normal 2xl:text-nowrap" rowspan="2">
+      <span class="inline-flex cursor-help items-center gap-1">
+        Latency p99
+        <span
+          data-testid="box-icon-latency-help"
+          class="fd fd-circle-help text-[16px] leading-none text-surface-600-400"
+        ></span>
+      </span>
+      <Tooltip placement="top" class="max-w-sm text-wrap"
+        >99th percentile time from ingesting a batch of records to the circuit finishing processing
+        it, taken over the last 10 minutes. Colored relative to the other connectors — red marks the
+        slowest.</Tooltip
+      >
+    </th>
     <th class="font-normal 2xl:text-nowrap" rowspan="2">Parse errors</th>
     <th class="font-normal 2xl:text-nowrap" rowspan="2">Transport errors</th>
   </tr>
@@ -377,6 +407,15 @@
   >
   <td class="text-end font-dm-mono text-nowrap">{formatQty(m.buffered_records)}</td>
   <td class="text-end font-dm-mono text-nowrap">{humanSize(m.buffered_bytes)}</td>
+  <td class="text-end font-dm-mono text-nowrap" data-testid="box-input-latency-p99">
+    {#if typeof m.processing_latency_p99_micros === 'number'}
+      <span style:color={latencyColor(m.processing_latency_p99_micros, inputLatencyScale)}>
+        {formatDuration(m.processing_latency_p99_micros)}
+      </span>
+    {:else}
+      <span class="text-surface-500">—</span>
+    {/if}
+  </td>
   <td class="text-end font-dm-mono text-nowrap {m.num_parse_errors > 0 ? 'text-error-500' : ''}">
     {#if m.num_parse_errors > 0 && relation && connectorEndpointName}
       <button
@@ -579,7 +618,7 @@
   metricsCells: Snippet<[EndpointMetrics, boolean | undefined, string?, string?]>,
   testId: string
 )}
-  <div class="scrollbar w-full overflow-x-auto {maxWidth}" data-testid={testId}>
+  <div class="latency-colors scrollbar w-full overflow-x-auto {maxWidth}" data-testid={testId}>
     <table class="bg-white-dark table h-min rounded text-base">
       <thead>
         {@render columnHeaders()}
@@ -661,3 +700,19 @@
     'box-output-views'
   )}
 {/if}
+
+<style>
+  /* Endpoints of the latency column's color scale, consumed by `latencyColor()`
+     through the inherited custom-property cascade. Skeleton's dual-tone
+     `surface-950-50` variable cannot be used directly: its nested
+     `light-dark()` resolves to `transparent` inside `color-mix()`. So the two
+     tones are bound separately and switched on `.dark`, which the root layout
+     sets on the `html` element. */
+  .latency-colors {
+    --latency-fast: var(--color-surface-950);
+    --latency-slow: var(--color-error-500);
+  }
+  :global(.dark) .latency-colors {
+    --latency-fast: var(--color-surface-50);
+  }
+</style>
diff --git a/js-packages/web-console/src/lib/components/pipelines/editor/performance/MetricsTables.svelte.spec.ts b/js-packages/web-console/src/lib/components/pipelines/editor/performance/MetricsTables.svelte.spec.ts
index b6ea301e951..95df5a3f55d 100644
--- a/js-packages/web-console/src/lib/components/pipelines/editor/performance/MetricsTables.svelte.spec.ts
+++ b/js-packages/web-console/src/lib/components/pipelines/editor/performance/MetricsTables.svelte.spec.ts
@@ -2,6 +2,7 @@ import { describe, expect, it, vi } from 'vitest'
 
 import { page } from 'vitest/browser'
 import { render } from 'vitest-browser-svelte'
+import { microseconds } from '$lib/functions/common/duration'
 import type { PipelineMetrics } from '$lib/functions/pipelineMetrics'
 import { accumulatePipelineMetrics } from '$lib/functions/pipelineMetrics'
 import type {
@@ -833,4 +834,119 @@ describe('MetricsTables.svelte', () => {
       expect(badge.length).toBeGreaterThanOrEqual(1)
     })
   })
+
+  describe('K. Latency p99 column', () => {
+    // Percentage of `--latency-slow` mixed into a latency cell's text color.
+    // 0 means the fastest connector's plain color, 100 means fully error red.
+    // The browser reserializes the inline style, so both "5%" and "5.00%" parse.
+    const slowPercents = () =>
+      page
+        .getByTestId('box-input-latency-p99')
+        .elements()
+        .map((cell) => {
+          const style = cell.querySelector('span[style]')?.getAttribute('style') ?? ''
+          const match = style.match(/--latency-slow\)\s*([\d.]+)%/)
+          return match ? Number(match[1]) : null
+        })
+
+    it('places the column header between Buffered and Parse errors', async () => {
+      await renderComponent(buildMetrics(makeStatus([], [makeInputStatus('orders')])))
+      const html = page.getByTestId('box-input-tables').element().innerHTML
+      expect(html).toContain('Latency p99')
+      expect(html.indexOf('Latency p99')).toBeGreaterThan(html.indexOf('Buffered'))
+      expect(html.indexOf('Latency p99')).toBeLessThan(html.indexOf('Parse errors'))
+    })
+
+    it('puts the help icon in the same hover group as the label', async () => {
+      await renderComponent(buildMetrics(makeStatus([], [makeInputStatus('orders')])))
+      const icon = page.getByTestId('box-icon-latency-help')
+      await expect.element(icon).toBeInTheDocument()
+      // Label and icon must share one element so either one triggers the tooltip.
+      const group = icon.element().closest('span.cursor-help')
+      expect(group).not.toBeNull()
+      expect(group!.textContent).toContain('Latency p99')
+    })
+
+    it('formats the latency with an adaptive unit', async () => {
+      const status = makeStatus(
+        [],
+        [
+          makeInputStatus('orders', {
+            metrics: makeInputMetrics({ processing_latency_p99_micros: microseconds(12_500) })
+          })
+        ]
+      )
+      await renderComponent(buildMetrics(status))
+      await expect.element(page.getByText('12.5 ms')).toBeInTheDocument()
+    })
+
+    it('shows an em dash for a connector without latency samples', async () => {
+      await renderComponent(buildMetrics(makeStatus([], [makeInputStatus('orders')])))
+      const cell = page.getByTestId('box-input-latency-p99').first()
+      await expect.element(cell).toHaveTextContent('—')
+      // No color is applied when there is nothing to compare.
+      expect(cell.element().querySelector('span[style]')).toBeNull()
+    })
+
+    it('leaves the fastest connector uncolored and saturates the slowest', async () => {
+      const status = makeStatus(
+        [],
+        [
+          makeInputStatus('fast', {
+            endpoint_name: 'c-fast',
+            metrics: makeInputMetrics({ processing_latency_p99_micros: microseconds(1_000) })
+          }),
+          makeInputStatus('slow', {
+            endpoint_name: 'c-slow',
+            metrics: makeInputMetrics({ processing_latency_p99_micros: microseconds(9_000) })
+          })
+        ]
+      )
+      await renderComponent(buildMetrics(status))
+      expect(slowPercents()).toEqual([0, 100])
+    })
+
+    it('keeps clustered connectors near the fast end via the spread floor', async () => {
+      // 1100µs is 10% above the fastest, so the default 3x floor keeps it at ~5%
+      // rather than painting it fully red for being the slowest of the two.
+      const status = makeStatus(
+        [],
+        [
+          makeInputStatus('fast', {
+            endpoint_name: 'c-fast',
+            metrics: makeInputMetrics({ processing_latency_p99_micros: microseconds(1_000) })
+          }),
+          makeInputStatus('slow', {
+            endpoint_name: 'c-slow',
+            metrics: makeInputMetrics({ processing_latency_p99_micros: microseconds(1_100) })
+          })
+        ]
+      )
+      await renderComponent(buildMetrics(status))
+      const [fast, slow] = slowPercents()
+      expect(fast).toBe(0)
+      expect(slow).toBeGreaterThan(0)
+      expect(slow).toBeLessThan(10)
+    })
+
+    it('reports the slowest connector on a collapsed relation row', async () => {
+      const status = makeStatus(
+        [],
+        [
+          makeInputStatus('orders', {
+            endpoint_name: 'c1',
+            metrics: makeInputMetrics({ processing_latency_p99_micros: microseconds(2_000) })
+          }),
+          makeInputStatus('orders', {
+            endpoint_name: 'c2',
+            metrics: makeInputMetrics({ processing_latency_p99_micros: microseconds(8_000) })
+          })
+        ]
+      )
+      await renderComponent(buildMetrics(status))
+      // The single row is the relation aggregate; it must not sum the percentiles.
+      await expect.element(page.getByText('8 ms')).toBeInTheDocument()
+      expect(page.getByText('10 ms').elements()).toHaveLength(0)
+    })
+  })
 })
diff --git a/js-packages/web-console/src/lib/functions/common/duration.spec.ts b/js-packages/web-console/src/lib/functions/common/duration.spec.ts
new file mode 100644
index 00000000000..72e6ad6db3a
--- /dev/null
+++ b/js-packages/web-console/src/lib/functions/common/duration.spec.ts
@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest'
+import { type Microseconds, microseconds } from './duration'
+
+describe('microseconds', () => {
+  it('carries the value through unchanged', () => {
+    // The brand is erased at runtime: only the type distinguishes the unit.
+    expect(microseconds(1_200)).toBe(1_200)
+  })
+
+  it('keeps a missing value missing', () => {
+    expect(microseconds(null)).toBeNull()
+    expect(microseconds(undefined)).toBeUndefined()
+  })
+
+  it('brands a number and passes null through at the type level', () => {
+    // Both lines typecheck only while `SameNullability` maps a number to
+    // `Microseconds` and leaves `null` alone.
+    const branded: Microseconds = microseconds(1_200)
+    const missing: null = microseconds(null)
+    expect([branded, missing]).toEqual([1_200, null])
+  })
+})
diff --git a/js-packages/web-console/src/lib/functions/common/duration.ts b/js-packages/web-console/src/lib/functions/common/duration.ts
new file mode 100644
index 00000000000..32f49778840
--- /dev/null
+++ b/js-packages/web-console/src/lib/functions/common/duration.ts
@@ -0,0 +1,16 @@
+import type { SameNullability } from '$lib/types/common/nullable'
+
+declare const microsecondsBrand: unique symbol
+
+/**
+ * A duration in microseconds.
+ */
+export type Microseconds = number & { readonly [microsecondsBrand]: true }
+
+/**
+ * Marks `micros` as a duration in microseconds, passing a missing value through
+ * unchanged.
+ */
+export const microseconds = <T extends number | null | undefined>(
+  micros: T
+): SameNullability<Microseconds, T> => micros as SameNullability<Microseconds, T>
diff --git a/js-packages/web-console/src/lib/functions/common/openapi-ts.ts b/js-packages/web-console/src/lib/functions/common/openapi-ts.ts
new file mode 100644
index 00000000000..1f4800893b9
--- /dev/null
+++ b/js-packages/web-console/src/lib/functions/common/openapi-ts.ts
@@ -0,0 +1,73 @@
+/**
+ * Helpers for `openapi-ts.config.ts` that replace a generated type with a
+ * hand-written one.
+ *
+ * The generator maps every schema to a structural TypeScript type, so a value
+ * that carries a unit or an identity in the domain arrives as a bare `number`
+ * or `string`. Overriding takes two steps: mark the schema with a custom
+ * `format`, then resolve that format to an imported type.
+ */
+
+import type { OpenApiSchemaObject, UserConfig } from '@hey-api/openapi-ts'
+
+/** Hand-written type substituted for a marked schema. */
+export type CustomType = {
+  /** Module the type is imported from, as written in the generated file. */
+  module: string
+  /** Exported name of the type. */
+  name: string
+}
+
+/** Custom types keyed by the `format` that marks a schema as using them. */
+export type CustomTypes = Readonly<Record<string, CustomType>>
+
+type Plugins = NonNullable<UserConfig['plugins']>[number]
+type TypeScriptPlugin = Extract<Plugins, { name: '@hey-api/typescript' }>
+
+/** The schema a `parser.patch.schemas` callback receives, across spec versions. */
+type PatchedSchema =
+  | OpenApiSchemaObject.V2_0_X
+  | OpenApiSchemaObject.V3_0_X
+  | OpenApiSchemaObject.V3_1_X
+
+/**
+ * Marks `property` of `schema` with a custom `format`, so that
+ * [`typescriptPluginWithCustomTypes`] substitutes the matching type.
+ *
+ * Throws when the property is absent, which is how a renamed field surfaces:
+ * silently generating `number` again would drop the override without a trace.
+ */
+export const overrideOpenapiType = (schema: PatchedSchema, property: string, format: string) => {
+  const properties = (schema as { properties?: Record<string, { format?: string }> }).properties
+  const target = properties?.[property]
+  if (!target) {
+    throw new Error(`Cannot mark '${property}' as '${format}': the property is missing`)
+  }
+  target.format = format
+}
+
+/**
+ * The TypeScript plugin, resolving every schema marked with a custom `format`
+ * to the corresponding type instead of the structural default. The generated
+ * file imports the type from its module.
+ *
+ * Only numeric schemas are covered; extend with the `string` resolver when a
+ * custom type is needed there.
+ */
+export const customTypesPlugin = (customTypes: CustomTypes): TypeScriptPlugin => ({
+  name: '@hey-api/typescript',
+  $resolvers: {
+    number: (ctx) => {
+      const customType = customTypes[ctx.schema.format as string]
+      if (!customType) {
+        return undefined
+      }
+      const symbol = ctx.plugin.symbolFactory.register(customType.name, {
+        external: customType.module,
+        importKind: 'named',
+        kind: 'type'
+      })
+      return ctx.$.type(symbol)
+    }
+  }
+})
diff --git a/js-packages/web-console/src/lib/functions/format.spec.ts b/js-packages/web-console/src/lib/functions/format.spec.ts
index f9e98d22a1f..271fb1aef8b 100644
--- a/js-packages/web-console/src/lib/functions/format.spec.ts
+++ b/js-packages/web-console/src/lib/functions/format.spec.ts
@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest'
-import { formatQty } from './format'
+import { microseconds } from './common/duration'
+import { formatDuration, formatQty } from './format'
 
 describe('formatQty', () => {
   it('returns em dash for null', () => {
@@ -50,3 +51,49 @@ describe('formatQty', () => {
     expect(formatQty(1500000, 'rounded')).toBe('1.50M')
   })
 })
+
+describe('formatDuration', () => {
+  it('renders zero without a unit', () => {
+    expect(formatDuration(microseconds(0))).toBe('0')
+  })
+
+  it('uses microseconds below 1ms', () => {
+    expect(formatDuration(microseconds(340))).toBe('340 µs')
+    expect(formatDuration(microseconds(999))).toBe('999 µs')
+  })
+
+  it('switches to milliseconds at 1000µs', () => {
+    expect(formatDuration(microseconds(1_000))).toBe('1 ms')
+    expect(formatDuration(microseconds(1_200))).toBe('1.2 ms')
+    expect(formatDuration(microseconds(12_500))).toBe('12.5 ms')
+    expect(formatDuration(microseconds(340_000))).toBe('340 ms')
+  })
+
+  it('switches to seconds at 1_000_000µs', () => {
+    expect(formatDuration(microseconds(1_000_000))).toBe('1 s')
+    expect(formatDuration(microseconds(2_100_000))).toBe('2.1 s')
+    expect(formatDuration(microseconds(90_000_000))).toBe('90 s')
+  })
+
+  it('returns an em dash for non-finite input', () => {
+    expect(formatDuration(undefined)).toBe('—')
+    expect(formatDuration(null)).toBe('—')
+    expect(formatDuration(microseconds(NaN))).toBe('—')
+  })
+
+  it('passes a missing latency through to the em dash', () => {
+    // `microseconds` keeps null and undefined, so callers brand a nullable
+    // field without unwrapping it first.
+    expect(formatDuration(microseconds(null))).toBe('—')
+    expect(formatDuration(microseconds(undefined))).toBe('—')
+  })
+
+  it('rejects an unbranded number', () => {
+    // @ts-expect-error - durations must be branded with `microseconds`
+    const formatted = formatDuration(1_200)
+    // The rejection is compile-time only, so the call still formats. The guard
+    // is the directive above: svelte-check fails on an unused @ts-expect-error,
+    // which is what a widened signature would produce.
+    expect(formatted).toBe('1.2 ms')
+  })
+})
diff --git a/js-packages/web-console/src/lib/functions/format.ts b/js-packages/web-console/src/lib/functions/format.ts
index dc98a08c073..ed53d30150f 100644
--- a/js-packages/web-console/src/lib/functions/format.ts
+++ b/js-packages/web-console/src/lib/functions/format.ts
@@ -1,5 +1,6 @@
 import { format } from 'd3-format'
 import Dayjs from 'dayjs'
+import type { Microseconds } from '$lib/functions/common/duration'
 
 export const formatDateTime = (
   timestamp: Date | Dayjs.Dayjs | { ms: number },
@@ -32,3 +33,31 @@ export const formatQty = (v: number | null | undefined, rounded?: 'rounded') =>
   typeof v === 'number' && Number.isFinite(v)
     ? format(v >= 1000 && rounded ? '.3s' : ',.0f')(v)
     : '—'
+
+const trimZeros = (s: string) => (s.includes('.') ? s.replace(/\.?0+$/, '') : s)
+
+/**
+ * Format a duration using an adaptive unit (µs / ms / s) with roughly three
+ * significant figures. Zero is rendered bare, without a unit.
+ *
+ *   formatDuration(microseconds(0))         -> "0"
+ *   formatDuration(microseconds(340))       -> "340 µs"
+ *   formatDuration(microseconds(1_200))     -> "1.2 ms"
+ *   formatDuration(microseconds(2_100_000)) -> "2.1 s"
+ */
+export const formatDuration = (micros: Microseconds | null | undefined): string => {
+  if (typeof micros !== 'number' || !Number.isFinite(micros)) {
+    return '—'
+  }
+  if (micros === 0) {
+    return '0'
+  }
+  const [value, unit] =
+    micros < 1_000
+      ? [micros, 'µs']
+      : micros < 1_000_000
+        ? [micros / 1_000, 'ms']
+        : [micros / 1_000_000, 's']
+  const digits = value >= 100 ? 0 : value >= 10 ? 1 : 2
+  return `${trimZeros(value.toFixed(digits))} ${unit}`
+}
diff --git a/js-packages/web-console/src/lib/functions/latencyColor.spec.ts b/js-packages/web-console/src/lib/functions/latencyColor.spec.ts
new file mode 100644
index 00000000000..47f0b2c47c5
--- /dev/null
+++ b/js-packages/web-console/src/lib/functions/latencyColor.spec.ts
@@ -0,0 +1,123 @@
+import { describe, expect, it } from 'vitest'
+import {
+  defaultLatencyColorSpread,
+  latencyColor,
+  latencyColorFraction,
+  latencyColorScale
+} from './latencyColor'
+
+describe('latencyColorScale', () => {
+  it('returns undefined when no connector reports a latency', () => {
+    expect(latencyColorScale([])).toBeUndefined()
+    expect(latencyColorScale([null, undefined])).toBeUndefined()
+  })
+
+  it('ignores connectors without samples', () => {
+    expect(latencyColorScale([null, 1_000, undefined, 9_000])).toEqual({ min: 1_000, max: 9_000 })
+  })
+
+  it('ignores non-finite and negative values', () => {
+    expect(latencyColorScale([NaN, -5, 1_000, 9_000])).toEqual({ min: 1_000, max: 9_000 })
+  })
+
+  it('keeps the observed max when it exceeds the spread floor', () => {
+    // 9000 is 9x the minimum, well above the 3x floor.
+    expect(latencyColorScale([1_000, 9_000])).toEqual({ min: 1_000, max: 9_000 })
+  })
+
+  it('raises the max to the spread floor when connectors are clustered', () => {
+    // Observed max is only 10% above the min, so the floor takes over.
+    expect(latencyColorScale([1_000, 1_100])).toEqual({ min: 1_000, max: 5_000 })
+  })
+
+  it('applies the floor exactly at the spread multiple', () => {
+    expect(latencyColorScale([1_000, 5_000])).toEqual({ min: 1_000, max: 5_000 })
+  })
+
+  it('honors a configured spread', () => {
+    expect(latencyColorScale([1_000, 1_100], 10)).toEqual({ min: 1_000, max: 10_000 })
+    expect(latencyColorScale([1_000, 1_100], 1)).toEqual({ min: 1_000, max: 1_100 })
+  })
+
+  it('rejects a spread below 1, which would invert the scale', () => {
+    expect(() => latencyColorScale([1_000, 1_100], 0.5)).toThrow(/spread cannot be less than 1/)
+  })
+
+  it('defaults to a 500% spread', () => {
+    expect(defaultLatencyColorSpread).toBe(5)
+    expect(latencyColorScale([500])).toEqual({ min: 500, max: 2_500 })
+  })
+
+  it('collapses to a zero-width scale when every latency is zero', () => {
+    expect(latencyColorScale([0, 0])).toEqual({ min: 0, max: 0 })
+  })
+})
+
+describe('latencyColorFraction', () => {
+  const scale = latencyColorScale([1_000, 9_000])
+
+  it('is 0 at the bottom of the scale and 1 at the top', () => {
+    expect(latencyColorFraction(1_000, scale)).toBe(0)
+    expect(latencyColorFraction(9_000, scale)).toBe(1)
+  })
+
+  it('interpolates linearly in between', () => {
+    expect(latencyColorFraction(5_000, scale)).toBeCloseTo(0.5)
+  })
+
+  it('clamps values outside the scale', () => {
+    expect(latencyColorFraction(10, scale)).toBe(0)
+    expect(latencyColorFraction(1_000_000, scale)).toBe(1)
+  })
+
+  it('leaves a lone connector at the bottom of the scale', () => {
+    // A single connector cannot be an outlier relative to itself: the spread
+    // floor puts the top of the scale at 3x its own latency.
+    expect(latencyColorFraction(2_000, latencyColorScale([2_000]))).toBe(0)
+  })
+
+  it('keeps a tight cluster near the bottom rather than spanning to red', () => {
+    const clustered = latencyColorScale([1_000, 1_100])
+    // 1100 is 10% above the fastest, so it must stay well below saturation.
+    expect(latencyColorFraction(1_100, clustered)).toBeCloseTo(0.025)
+  })
+
+  it('is 0 without a scale or a latency', () => {
+    expect(latencyColorFraction(1_000, undefined)).toBe(0)
+    expect(latencyColorFraction(null, scale)).toBe(0)
+    expect(latencyColorFraction(undefined, scale)).toBe(0)
+    expect(latencyColorFraction(NaN, scale)).toBe(0)
+  })
+
+  it('is 0 for a zero-width scale', () => {
+    expect(latencyColorFraction(0, latencyColorScale([0, 0]))).toBe(0)
+  })
+})
+
+describe('latencyColor', () => {
+  const scale = latencyColorScale([1_000, 9_000])
+
+  it('is fully the fast token at the bottom of the scale', () => {
+    expect(latencyColor(1_000, scale)).toBe(
+      'color-mix(in oklab, var(--latency-fast) 100.00%, var(--latency-slow) 0.00%)'
+    )
+  })
+
+  it('is fully the slow token at the top of the scale', () => {
+    expect(latencyColor(9_000, scale)).toBe(
+      'color-mix(in oklab, var(--latency-fast) 0.00%, var(--latency-slow) 100.00%)'
+    )
+  })
+
+  it('blends the two tokens in between', () => {
+    expect(latencyColor(5_000, scale)).toBe(
+      'color-mix(in oklab, var(--latency-fast) 50.00%, var(--latency-slow) 50.00%)'
+    )
+  })
+
+  it('falls back to the fast token when there is no scale', () => {
+    expect(latencyColor(1_000, undefined)).toBe(
+      'color-mix(in oklab, var(--latency-fast) 100.00%, var(--latency-slow) 0.00%)'
+    )
+  })
+})
diff --git a/js-packages/web-console/src/lib/functions/latencyColor.ts b/js-packages/web-console/src/lib/functions/latencyColor.ts
new file mode 100644
index 00000000000..eaf4a032a0a
--- /dev/null
+++ b/js-packages/web-console/src/lib/functions/latencyColor.ts
@@ -0,0 +1,84 @@
+/**
+ * Color scale for the input connectors' latency column.
+ *
+ * The scale spans the connectors that currently report a latency: the fastest
+ * keeps the default text color, the slowest turns error red, and the rest land
+ * on a blend between the two.
+ */
+
+import invariant from 'tiny-invariant'
+
+/**
+ * Lower bound on the scale's spread, as a multiple of the fastest connector's
+ * latency: the top of the scale never sits below `min * spread`.
+ *
+ * At the default of 5 - a connector must be at least
+ * five times slower than the fastest one to saturate its color.
+ */
+export const defaultLatencyColorSpread = 5
+
+export type LatencyColorScale = {
+  /** Fastest connector's latency in microseconds; drawn in the base color. */
+  min: number
+  /** Latency in microseconds at which the color saturates. */
+  max: number
+}
+
+const finiteLatencies = (latencies: ReadonlyArray<number | null | undefined>) =>
+  latencies.filter(
+    (latency): latency is number =>
+      typeof latency === 'number' && Number.isFinite(latency) && latency >= 0
+  )
+
+/**
+ * Builds the scale from every connector's latency, skipping connectors without
+ * samples. Returns `undefined` when no connector reports one, which callers
+ * render as uncolored text.
+ */
+export const latencyColorScale = (
+  latencies: ReadonlyArray<number | null | undefined>,
+  spread: number = defaultLatencyColorSpread
+): LatencyColorScale | undefined => {
+  invariant(spread >= 1, 'Minimum latency spread cannot be less than 1')
+  const values = finiteLatencies(latencies)
+  if (values.length === 0) {
+    return undefined
+  }
+  const min = Math.min(...values)
+  const observedMax = Math.max(...values)
+  return { min, max: Math.max(observedMax, min * spread) }
+}
+
+/**
+ * Position of `latency` on `scale`, clamped to `[0, 1]`.
+ */
+export const latencyColorFraction = (
+  latency: number | null | undefined,
+  scale: LatencyColorScale | undefined
+): number => {
+  if (!scale || typeof latency !== 'number' || !Number.isFinite(latency)) {
+    return 0
+  }
+  const span = scale.max - scale.min
+  if (span <= 0) {
+    return 0
+  }
+  return Math.min(1, Math.max(0, (latency - scale.min) / span))
+}
+
+/**
+ * CSS color for `latency`: the `--latency-fast` token at the bottom of the
+ * scale, `--latency-slow` at the top.
+ *
+ * The consuming component defines both tokens as single-tone Skeleton colors
+ * with a `.dark` override. Skeleton's dual-tone `*-950-50` variables cannot be
+ * used directly, because their nested `light-dark()` resolves to `transparent`
+ * inside `color-mix()`.
+ */
+export const latencyColor = (
+  latency: number | null | undefined,
+  scale: LatencyColorScale | undefined
+): string => {
+  const slow = latencyColorFraction(latency, scale) * 100
+  return `color-mix(in oklab, var(--latency-fast) ${(100 - slow).toFixed(2)}%, var(--latency-slow) ${slow.toFixed(2)}%)`
+}
diff --git a/js-packages/web-console/src/lib/functions/pipelineMetrics.spec.ts b/js-packages/web-console/src/lib/functions/pipelineMetrics.spec.ts
index 7b90ac4a888..f443593eed6 100644
--- a/js-packages/web-console/src/lib/functions/pipelineMetrics.spec.ts
+++ b/js-packages/web-console/src/lib/functions/pipelineMetrics.spec.ts
@@ -1,6 +1,12 @@
 import { describe, expect, it } from 'vitest'
+import type { ControllerStatus, InputEndpointStatus } from '$lib/services/manager'
 import type { TimeSeriesEntry } from '$lib/types/pipelineManager'
-import { multihostMemoryLimitMb, timeSeriesAxisMax } from './pipelineMetrics'
+import { formatDuration } from './format'
+import {
+  accumulatePipelineMetrics,
+  multihostMemoryLimitMb,
+  timeSeriesAxisMax
+} from './pipelineMetrics'
 
 const sampleAt = (timeMs: number): TimeSeriesEntry => ({
   t: timeMs,
@@ -44,3 +50,68 @@ describe('multihostMemoryLimitMb', () => {
     expect(multihostMemoryLimitMb(0, 3)).toBeUndefined()
   })
 })
+
+describe('accumulatePipelineMetrics latency aggregate', () => {
+  const inputStatus = (
+    stream: string,
+    endpointName: string,
+    latency?: number
+  ): InputEndpointStatus =>
+    ({
+      config: { stream },
+      endpoint_name: endpointName,
+      metrics: {
+        total_bytes: 0,
+        total_records: 0,
+        buffered_bytes: 0,
+        buffered_records: 0,
+        num_transport_errors: 0,
+        num_parse_errors: 0,
+        end_of_input: false,
+        processing_latency_p99_micros: latency
+      },
+      paused: false,
+      barrier: false,
+      health: null,
+      fatal_error: null
+    }) as InputEndpointStatus
+
+  const aggregateLatency = (inputs: InputEndpointStatus[], relation = 'orders') =>
+    accumulatePipelineMetrics(0)(undefined, {
+      status: {
+        global_metrics: {
+          transaction_initiators: { initiated_by_connectors: {} }
+        },
+        inputs,
+        outputs: []
+      } as unknown as ControllerStatus
+    })!.tables.get(relation)!.aggregate.metrics.processing_latency_p99_micros
+
+  it('reports the slowest connector rather than the sum of percentiles', () => {
+    const latency = aggregateLatency([
+      inputStatus('orders', 'c1', 2_000),
+      inputStatus('orders', 'c2', 8_000)
+    ])
+    expect(latency).toBe(8_000)
+  })
+
+  it('ignores connectors without samples', () => {
+    expect(
+      aggregateLatency([inputStatus('orders', 'c1'), inputStatus('orders', 'c2', 3_000)])
+    ).toBe(3_000)
+  })
+
+  it('is undefined when no connector has samples', () => {
+    expect(aggregateLatency([inputStatus('orders', 'c1')])).toBeUndefined()
+  })
+
+  it('passes the latency of a single connector through unchanged', () => {
+    expect(aggregateLatency([inputStatus('orders', 'c1', 4_200)])).toBe(4_200)
+  })
+
+  it('brands the aggregate as a duration', () => {
+    // Typechecks only while the aggregate carries its unit: `formatDuration`
+    // takes `Microseconds`, not a bare number.
+    expect(formatDuration(aggregateLatency([inputStatus('orders', 'c1', 2_000)]))).toBe('2 ms')
+  })
+})
diff --git a/js-packages/web-console/src/lib/functions/pipelineMetrics.ts b/js-packages/web-console/src/lib/functions/pipelineMetrics.ts
index 68b8e38814f..d6b993b58d7 100644
--- a/js-packages/web-console/src/lib/functions/pipelineMetrics.ts
+++ b/js-packages/web-console/src/lib/functions/pipelineMetrics.ts
@@ -1,5 +1,6 @@
 import { ServerDate } from '$lib/compositions/serverTime'
 import { groupBy } from '$lib/functions/common/array'
+import { type Microseconds, microseconds } from '$lib/functions/common/duration'
 import { nonNull } from '$lib/functions/common/function'
 import { discreteDerivative } from '$lib/functions/common/math'
 import { tuple } from '$lib/functions/common/tuple'
@@ -51,6 +52,23 @@ export const emptyPipelineMetrics = {
 
 export type PipelineMetrics = typeof emptyPipelineMetrics & { lastTimestamp?: number }
 
+/**
+ * Higher of two connector latencies, ignoring connectors without samples.
+ *
+ * A relation's row summarizes its connectors, and percentiles cannot be summed
+ * or averaged into another percentile. The slowest connector is reported
+ * instead.
+ */
+const slowestLatency = (
+  a: Microseconds | null | undefined,
+  b: Microseconds | null | undefined
+): Microseconds | undefined => {
+  if (typeof a !== 'number') {
+    return typeof b === 'number' ? b : undefined
+  }
+  return typeof b === 'number' ? microseconds(Math.max(a, b)) : a
+}
+
 const addZeroMetrics = (previous: PipelineMetrics) => ({
   ...previous,
   tables: new Map(),
@@ -111,7 +129,11 @@ export const accumulatePipelineMetrics =
                       num_transport_errors: acc.num_transport_errors + metrics.num_transport_errors,
                       num_parse_errors: acc.num_parse_errors + metrics.num_parse_errors,
                       end_of_input: acc.end_of_input && metrics.end_of_input,
-                      buffered_bytes: acc.buffered_bytes + metrics.buffered_bytes
+                      buffered_bytes: acc.buffered_bytes + metrics.buffered_bytes,
+                      processing_latency_p99_micros: slowestLatency(
+                        acc.processing_latency_p99_micros,
+                        metrics.processing_latency_p99_micros
+                      )
                     }
                   },
                   {
@@ -121,7 +143,8 @@ export const accumulatePipelineMetrics =
                     buffered_records: 0,
                     num_transport_errors: 0,
                     num_parse_errors: 0,
-                    end_of_input: true
+                    end_of_input: true,
+                    processing_latency_p99_micros: undefined
                   }
                 )
               }
diff --git a/js-packages/web-console/src/lib/services/manager/client.gen.ts b/js-packages/web-console/src/lib/services/manager/client.gen.ts
index edbe269f3ba..297a47e163c 100644
--- a/js-packages/web-console/src/lib/services/manager/client.gen.ts
+++ b/js-packages/web-console/src/lib/services/manager/client.gen.ts
@@ -2,7 +2,7 @@
 
 import { createClientConfig } from '$lib/compositions/setupHttpClient'
 
-import { type ClientOptions, type Config, createClient, createConfig } from './client'
+import { type Client, type ClientOptions, type Config, createClient, createConfig } from './client'
 import type { ClientOptions as ClientOptions2 } from './types.gen'
 
 /**
@@ -17,6 +17,6 @@ export type CreateClientConfig<T extends ClientOptions = ClientOptions2> = (
   override?: Config<ClientOptions & T>
 ) => Config<Required<ClientOptions> & T>
 
-export const client = createClient(
+export const client: Client = createClient(
   createClientConfig(createConfig<ClientOptions2>({ throwOnError: true }))
 )
diff --git a/js-packages/web-console/src/lib/services/manager/client/index.ts b/js-packages/web-console/src/lib/services/manager/client/index.ts
index 13cdecb8026..d92351673ec 100644
--- a/js-packages/web-console/src/lib/services/manager/client/index.ts
+++ b/js-packages/web-console/src/lib/services/manager/client/index.ts
@@ -9,6 +9,8 @@ export {
 } from '../core/bodySerializer.gen'
 export { buildClientParams } from '../core/params.gen'
 export { serializeQueryKeyValue } from '../core/queryKeySerializer.gen'
+export type { ServerSentEventsResult } from '../core/serverSentEvents.gen'
+export type { ClientMeta } from '../core/types.gen'
 export { createClient } from './client.gen'
 export type {
   Client,
diff --git a/js-packages/web-console/src/lib/services/manager/client/utils.gen.ts b/js-packages/web-console/src/lib/services/manager/client/utils.gen.ts
index 5f99e00dd7b..d363eb76f95 100644
--- a/js-packages/web-console/src/lib/services/manager/client/utils.gen.ts
+++ b/js-packages/web-console/src/lib/services/manager/client/utils.gen.ts
@@ -14,8 +14,8 @@ import type { Client, ClientOptions, Config, RequestOptions } from './types.gen'
 export const createQuerySerializer = <T = unknown>({
   parameters = {},
   ...args
-}: QuerySerializerOptions = {}) => {
-  const querySerializer = (queryParams: T) => {
+}: QuerySerializerOptions = {}): ((queryParams: T) => string) => {
+  const querySerializer = (queryParams: T): string => {
     const search: string[] = []
     if (queryParams && typeof queryParams === 'object') {
       for (const name in queryParams) {
diff --git a/js-packages/web-console/src/lib/services/manager/core/auth.gen.ts b/js-packages/web-console/src/lib/services/manager/core/auth.gen.ts
index dc8ff61977e..cbeab22fb89 100644
--- a/js-packages/web-console/src/lib/services/manager/core/auth.gen.ts
+++ b/js-packages/web-console/src/lib/services/manager/core/auth.gen.ts
@@ -9,6 +9,13 @@ export interface Auth {
    * @default 'header'
    */
   in?: 'header' | 'query' | 'cookie'
+  /**
+   * A unique identifier for the security scheme.
+   *
+   * Defined only when there are multiple security schemes whose `Auth`
+   * shape would otherwise be identical.
+   */
+  key?: string
   /**
    * Header or query parameter name.
    *
diff --git a/js-packages/web-console/src/lib/services/manager/core/params.gen.ts b/js-packages/web-console/src/lib/services/manager/core/params.gen.ts
index 8d544292448..9bfbc7c55ca 100644
--- a/js-packages/web-console/src/lib/services/manager/core/params.gen.ts
+++ b/js-packages/web-console/src/lib/services/manager/core/params.gen.ts
@@ -62,7 +62,7 @@ type KeyMap = Map<
     }
 >
 
-const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
+function buildKeyMap(fields: FieldsConfig, map?: KeyMap): KeyMap {
   if (!map) {
     map = new Map()
   }
@@ -88,23 +88,25 @@ const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
 }
 
 interface Params {
-  body: unknown
+  body?: unknown
   headers: Record<string, unknown>
   path: Record<string, unknown>
   query: Record<string, unknown>
 }
 
-const stripEmptySlots = (params: Params) => {
+function stripEmptySlots(params: Params): void {
   for (const [slot, value] of Object.entries(params)) {
+    if (slot === 'body') {
+      continue
+    }
     if (value && typeof value === 'object' && !Array.isArray(value) && !Object.keys(value).length) {
       delete params[slot as Slot]
     }
   }
 }
 
-export const buildClientParams = (args: ReadonlyArray<unknown>, fields: FieldsConfig) => {
+export function buildClientParams(args: ReadonlyArray<unknown>, fields: FieldsConfig): Params {
   const params: Params = {
-    body: Object.create(null),
     headers: Object.create(null),
     path: Object.create(null),
     query: Object.create(null)
@@ -112,6 +114,15 @@ export const buildClientParams = (args: ReadonlyArray<unknown>, fields: FieldsCo
 
   const map = buildKeyMap(fields)
 
+  function writeSlot(slot: Slot, key: string, value: unknown): void {
+    let record = params[slot] as Record<string, unknown> | undefined
+    if (record === undefined) {
+      record = Object.create(null) as Record<string, unknown>
+      params[slot] = record
+    }
+    record[key] = value
+  }
+
   let config: FieldsConfig[number] | undefined
 
   for (const [index, arg] of args.entries()) {
@@ -128,7 +139,7 @@ export const buildClientParams = (args: ReadonlyArray<unknown>, fields: FieldsCo
         const field = map.get(config.key)!
         const name = field.map || config.key
         if (field.in) {
-          ;(params[field.in] as Record<string, unknown>)[name] = arg
+          writeSlot(field.in, name, arg)
         }
       } else {
         params.body = arg
@@ -140,7 +151,7 @@ export const buildClientParams = (args: ReadonlyArray<unknown>, fields: FieldsCo
         if (field) {
           if (field.in) {
             const name = field.map || key
-            ;(params[field.in] as Record<string, unknown>)[name] = value
+            writeSlot(field.in, name, value)
           } else {
             params[field.map] = value
           }
@@ -149,11 +160,11 @@ export const buildClientParams = (args: ReadonlyArray<unknown>, fields: FieldsCo
 
           if (extra) {
             const [prefix, slot] = extra
-            ;(params[slot] as Record<string, unknown>)[key.slice(prefix.length)] = value
+            writeSlot(slot, key.slice(prefix.length), value)
           } else if ('allowExtra' in config && config.allowExtra) {
             for (const [slot, allowed] of Object.entries(config.allowExtra)) {
               if (allowed) {
-                ;(params[slot as Slot] as Record<string, unknown>)[key] = value
+                writeSlot(slot as Slot, key, value)
                 break
               }
             }
diff --git a/js-packages/web-console/src/lib/services/manager/core/pathSerializer.gen.ts b/js-packages/web-console/src/lib/services/manager/core/pathSerializer.gen.ts
index acc13672eee..36379f8151d 100644
--- a/js-packages/web-console/src/lib/services/manager/core/pathSerializer.gen.ts
+++ b/js-packages/web-console/src/lib/services/manager/core/pathSerializer.gen.ts
@@ -25,7 +25,7 @@ interface SerializePrimitiveParam extends SerializePrimitiveOptions {
   value: string
 }
 
-export const separatorArrayExplode = (style: ArraySeparatorStyle) => {
+export const separatorArrayExplode = (style: ArraySeparatorStyle): '.' | ';' | ',' | '&' => {
   switch (style) {
     case 'label':
       return '.'
@@ -38,7 +38,7 @@ export const separatorArrayExplode = (style: ArraySeparatorStyle) => {
   }
 }
 
-export const separatorArrayNoExplode = (style: ArraySeparatorStyle) => {
+export const separatorArrayNoExplode = (style: ArraySeparatorStyle): ',' | '|' | '%20' => {
   switch (style) {
     case 'form':
       return ','
@@ -51,7 +51,7 @@ export const separatorArrayNoExplode = (style: ArraySeparatorStyle) => {
   }
 }
 
-export const separatorObjectExplode = (style: ObjectSeparatorStyle) => {
+export const separatorObjectExplode = (style: ObjectSeparatorStyle): '.' | ';' | ',' | '&' => {
   switch (style) {
     case 'label':
       return '.'
@@ -72,7 +72,7 @@ export const serializeArrayParam = ({
   value
 }: SerializeOptions<ArraySeparatorStyle> & {
   value: unknown[]
-}) => {
+}): string => {
   if (!explode) {
     const joinedValues = (
       allowReserved ? value : value.map((v) => encodeURIComponent(v as string))
@@ -110,7 +110,7 @@ export const serializePrimitiveParam = ({
   allowReserved,
   name,
   value
-}: SerializePrimitiveParam) => {
+}: SerializePrimitiveParam): string => {
   if (value === undefined || value === null) {
     return ''
   }
@@ -134,7 +134,7 @@ export const serializeObjectParam = ({
 }: SerializeOptions<ObjectSeparatorStyle> & {
   value: Record<string, unknown> | Date
   valueOnly?: boolean
-}) => {
+}): string => {
   if (value instanceof Date) {
     return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`
   }
diff --git a/js-packages/web-console/src/lib/services/manager/core/queryKeySerializer.gen.ts b/js-packages/web-console/src/lib/services/manager/core/queryKeySerializer.gen.ts
index 7e9d0d1ec85..f5aabf8664c 100644
--- a/js-packages/web-console/src/lib/services/manager/core/queryKeySerializer.gen.ts
+++ b/js-packages/web-console/src/lib/services/manager/core/queryKeySerializer.gen.ts
@@ -14,7 +14,7 @@ export type JsonValue =
 /**
  * Replacer that converts non-JSON values (bigint, Date, etc.) to safe substitutes.
  */
-export const queryKeyJsonReplacer = (_key: string, value: unknown) => {
+export const queryKeyJsonReplacer = (_key: string, value: unknown): unknown | undefined => {
   if (value === undefined || typeof value === 'function' || typeof value === 'symbol') {
     return undefined
   }
diff --git a/js-packages/web-console/src/lib/services/manager/core/types.gen.ts b/js-packages/web-console/src/lib/services/manager/core/types.gen.ts
index 909605fc518..41dcf0220d3 100644
--- a/js-packages/web-console/src/lib/services/manager/core/types.gen.ts
+++ b/js-packages/web-console/src/lib/services/manager/core/types.gen.ts
@@ -91,6 +91,12 @@ export interface Config {
   responseValidator?: (data: unknown) => Promise<unknown>
 }
 
+/**
+ * Arbitrary metadata passed through the `meta` request option.
+ */
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export type ClientMeta = {}
+
 type IsExactlyNeverOrNeverUndefined<T> = [T] extends [never]
   ? true
   : [T] extends [never | undefined]
diff --git a/js-packages/web-console/src/lib/services/manager/core/utils.gen.ts b/js-packages/web-console/src/lib/services/manager/core/utils.gen.ts
index b5f418d461d..ed5bad37dd5 100644
--- a/js-packages/web-console/src/lib/services/manager/core/utils.gen.ts
+++ b/js-packages/web-console/src/lib/services/manager/core/utils.gen.ts
@@ -13,9 +13,9 @@ export interface PathSerializer {
   url: string
 }
 
-export const PATH_PARAM_RE = /\{[^{}]+\}/g
+export const PATH_PARAM_RE: RegExp = /\{[^{}]+\}/g
 
-export const defaultPathSerializer = ({ path, url: _url }: PathSerializer) => {
+export const defaultPathSerializer = ({ path, url: _url }: PathSerializer): string => {
   let url = _url
   const matches = _url.match(PATH_PARAM_RE)
   if (matches) {
@@ -94,7 +94,7 @@ export const getUrl = ({
   query?: Record<string, unknown>
   querySerializer: QuerySerializer
   url: string
-}) => {
+}): string => {
   const pathUrl = _url.startsWith('/') ? _url : `/${_url}`
   let url = (baseUrl ?? '') + pathUrl
   if (path) {
@@ -114,7 +114,7 @@ export function getValidRequestBody(options: {
   body?: unknown
   bodySerializer?: BodySerializer | null
   serializedBody?: unknown
-}) {
+}): unknown {
   const hasBody = options.body !== undefined
   const isSerializedBody = hasBody && options.bodySerializer
 
diff --git a/js-packages/web-console/src/lib/services/manager/sdk.gen.ts b/js-packages/web-console/src/lib/services/manager/sdk.gen.ts
index 272db2ffed5..04f9e989d01 100644
--- a/js-packages/web-console/src/lib/services/manager/sdk.gen.ts
+++ b/js-packages/web-console/src/lib/services/manager/sdk.gen.ts
@@ -1,6 +1,6 @@
 // This file is auto-generated by @hey-api/openapi-ts
 
-import type { Client, Options as Options2, TDataShape } from './client'
+import type { Client, ClientMeta, Options as Options2, RequestResult, TDataShape } from './client'
 import { client } from './client.gen'
 import type {
   AddTenantUserData,
@@ -247,7 +247,7 @@ export type Options<
    * You can pass arbitrary values through the `meta` object. This can be
    * used to access values that aren't defined as part of the SDK function.
    */
-  meta?: Record<string, unknown>
+  meta?: keyof ClientMeta extends never ? Record<string, unknown> : ClientMeta
 }
 
 /**
@@ -257,7 +257,12 @@ export type Options<
  */
 export const getConfigAuthentication = <ThrowOnError extends boolean = true>(
   options?: Options<GetConfigAuthenticationData, ThrowOnError>
-) =>
+): RequestResult<
+  GetConfigAuthenticationResponses,
+  GetConfigAuthenticationErrors,
+  ThrowOnError,
+  'data'
+> =>
   (options?.client ?? client).get<
     GetConfigAuthenticationResponses,
     GetConfigAuthenticationErrors,
@@ -278,7 +283,7 @@ export const getConfigAuthentication = <ThrowOnError extends boolean = true>(
  */
 export const listApiKeys = <ThrowOnError extends boolean = true>(
   options?: Options<ListApiKeysData, ThrowOnError>
-) =>
+): RequestResult<ListApiKeysResponses, ListApiKeysErrors, ThrowOnError, 'data'> =>
   (options?.client ?? client).get<ListApiKeysResponses, ListApiKeysErrors, ThrowOnError, 'data'>({
     responseStyle: 'data',
     security: [{ scheme: 'bearer', type: 'http' }],
@@ -296,7 +301,7 @@ export const listApiKeys = <ThrowOnError extends boolean = true>(
  */
 export const postApiKey = <ThrowOnError extends boolean = true>(
   options: Options<PostApiKeyData, ThrowOnError>
-) =>
+): RequestResult<PostApiKeyResponses, PostApiKeyErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).post<PostApiKeyResponses, PostApiKeyErrors, ThrowOnError, 'data'>({
     responseStyle: 'data',
     security: [{ scheme: 'bearer', type: 'http' }],
@@ -317,7 +322,7 @@ export const postApiKey = <ThrowOnError extends boolean = true>(
  */
 export const deleteApiKey = <ThrowOnError extends boolean = true>(
   options: Options<DeleteApiKeyData, ThrowOnError>
-) =>
+): RequestResult<DeleteApiKeyResponses, DeleteApiKeyErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).delete<
     DeleteApiKeyResponses,
     DeleteApiKeyErrors,
@@ -339,7 +344,7 @@ export const deleteApiKey = <ThrowOnError extends boolean = true>(
  */
 export const getApiKey = <ThrowOnError extends boolean = true>(
   options: Options<GetApiKeyData, ThrowOnError>
-) =>
+): RequestResult<GetApiKeyResponses, GetApiKeyErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).get<GetApiKeyResponses, GetApiKeyErrors, ThrowOnError, 'data'>({
     responseStyle: 'data',
     security: [{ scheme: 'bearer', type: 'http' }],
@@ -365,7 +370,7 @@ export const getApiKey = <ThrowOnError extends boolean = true>(
  */
 export const listClusterEvents = <ThrowOnError extends boolean = true>(
   options?: Options<ListClusterEventsData, ThrowOnError>
-) =>
+): RequestResult<ListClusterEventsResponses, ListClusterEventsErrors, ThrowOnError, 'data'> =>
   (options?.client ?? client).get<
     ListClusterEventsResponses,
     ListClusterEventsErrors,
@@ -392,7 +397,7 @@ export const listClusterEvents = <ThrowOnError extends boolean = true>(
  */
 export const getClusterEvent = <ThrowOnError extends boolean = true>(
   options: Options<GetClusterEventData, ThrowOnError>
-) =>
+): RequestResult<GetClusterEventResponses, GetClusterEventErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).get<
     GetClusterEventResponses,
     GetClusterEventErrors,
@@ -414,7 +419,7 @@ export const getClusterEvent = <ThrowOnError extends boolean = true>(
  */
 export const getClusterHealth = <ThrowOnError extends boolean = true>(
   options?: Options<GetClusterHealthData, ThrowOnError>
-) =>
+): RequestResult<GetClusterHealthResponses, GetClusterHealthErrors, ThrowOnError, 'data'> =>
   (options?.client ?? client).get<
     GetClusterHealthResponses,
     GetClusterHealthErrors,
@@ -436,7 +441,7 @@ export const getClusterHealth = <ThrowOnError extends boolean = true>(
  */
 export const getConfig = <ThrowOnError extends boolean = true>(
   options?: Options<GetConfigData, ThrowOnError>
-) =>
+): RequestResult<GetConfigResponses, GetConfigErrors, ThrowOnError, 'data'> =>
   (options?.client ?? client).get<GetConfigResponses, GetConfigErrors, ThrowOnError, 'data'>({
     responseStyle: 'data',
     security: [{ scheme: 'bearer', type: 'http' }],
@@ -453,7 +458,7 @@ export const getConfig = <ThrowOnError extends boolean = true>(
  */
 export const getConfigDemos = <ThrowOnError extends boolean = true>(
   options?: Options<GetConfigDemosData, ThrowOnError>
-) =>
+): RequestResult<GetConfigDemosResponses, GetConfigDemosErrors, ThrowOnError, 'data'> =>
   (options?.client ?? client).get<
     GetConfigDemosResponses,
     GetConfigDemosErrors,
@@ -478,7 +483,7 @@ export const getConfigDemos = <ThrowOnError extends boolean = true>(
  */
 export const getConfigOwners = <ThrowOnError extends boolean = true>(
   options?: Options<GetConfigOwnersData, ThrowOnError>
-) =>
+): RequestResult<GetConfigOwnersResponses, GetConfigOwnersErrors, ThrowOnError, 'data'> =>
   (options?.client ?? client).get<
     GetConfigOwnersResponses,
     GetConfigOwnersErrors,
@@ -505,7 +510,7 @@ export const getConfigOwners = <ThrowOnError extends boolean = true>(
  */
 export const getConfigSession = <ThrowOnError extends boolean = true>(
   options?: Options<GetConfigSessionData, ThrowOnError>
-) =>
+): RequestResult<GetConfigSessionResponses, GetConfigSessionErrors, ThrowOnError, 'data'> =>
   (options?.client ?? client).get<
     GetConfigSessionResponses,
     GetConfigSessionErrors,
@@ -531,7 +536,7 @@ export const getConfigSession = <ThrowOnError extends boolean = true>(
  */
 export const getMetrics = <ThrowOnError extends boolean = true>(
   options?: Options<GetMetricsData, ThrowOnError>
-) =>
+): RequestResult<GetMetricsResponses, unknown, ThrowOnError, 'data'> =>
   (options?.client ?? client).get<GetMetricsResponses, unknown, ThrowOnError, 'data'>({
     responseStyle: 'data',
     security: [{ scheme: 'bearer', type: 'http' }],
@@ -546,7 +551,7 @@ export const getMetrics = <ThrowOnError extends boolean = true>(
  */
 export const listOidcTrust = <ThrowOnError extends boolean = true>(
   options?: Options<ListOidcTrustData, ThrowOnError>
-) =>
+): RequestResult<ListOidcTrustResponses, ListOidcTrustErrors, ThrowOnError, 'data'> =>
   (options?.client ?? client).get<
     ListOidcTrustResponses,
     ListOidcTrustErrors,
@@ -566,7 +571,7 @@ export const listOidcTrust = <ThrowOnError extends boolean = true>(
  */
 export const postOidcTrust = <ThrowOnError extends boolean = true>(
   options: Options<PostOidcTrustData, ThrowOnError>
-) =>
+): RequestResult<PostOidcTrustResponses, PostOidcTrustErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).post<
     PostOidcTrustResponses,
     PostOidcTrustErrors,
@@ -590,7 +595,7 @@ export const postOidcTrust = <ThrowOnError extends boolean = true>(
  */
 export const deleteOidcTrust = <ThrowOnError extends boolean = true>(
   options: Options<DeleteOidcTrustData, ThrowOnError>
-) =>
+): RequestResult<DeleteOidcTrustResponses, DeleteOidcTrustErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).delete<
     DeleteOidcTrustResponses,
     DeleteOidcTrustErrors,
@@ -614,7 +619,7 @@ export const deleteOidcTrust = <ThrowOnError extends boolean = true>(
  */
 export const getOidcTrust = <ThrowOnError extends boolean = true>(
   options: Options<GetOidcTrustData, ThrowOnError>
-) =>
+): RequestResult<GetOidcTrustResponses, GetOidcTrustErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).get<GetOidcTrustResponses, GetOidcTrustErrors, ThrowOnError, 'data'>({
     responseStyle: 'data',
     security: [{ scheme: 'bearer', type: 'http' }],
@@ -632,7 +637,7 @@ export const getOidcTrust = <ThrowOnError extends boolean = true>(
  */
 export const listPipelines = <ThrowOnError extends boolean = true>(
   options?: Options<ListPipelinesData, ThrowOnError>
-) =>
+): RequestResult<ListPipelinesResponses, ListPipelinesErrors, ThrowOnError, 'data'> =>
   (options?.client ?? client).get<
     ListPipelinesResponses,
     ListPipelinesErrors,
@@ -654,7 +659,7 @@ export const listPipelines = <ThrowOnError extends boolean = true>(
  */
 export const postPipeline = <ThrowOnError extends boolean = true>(
   options: Options<PostPipelineData, ThrowOnError>
-) =>
+): RequestResult<PostPipelineResponses, PostPipelineErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).post<PostPipelineResponses, PostPipelineErrors, ThrowOnError, 'data'>({
     responseStyle: 'data',
     security: [{ scheme: 'bearer', type: 'http' }],
@@ -675,7 +680,7 @@ export const postPipeline = <ThrowOnError extends boolean = true>(
  */
 export const deletePipeline = <ThrowOnError extends boolean = true>(
   options: Options<DeletePipelineData, ThrowOnError>
-) =>
+): RequestResult<DeletePipelineResponses, DeletePipelineErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).delete<
     DeletePipelineResponses,
     DeletePipelineErrors,
@@ -698,7 +703,7 @@ export const deletePipeline = <ThrowOnError extends boolean = true>(
  */
 export const getPipeline = <ThrowOnError extends boolean = true>(
   options: Options<GetPipelineData, ThrowOnError>
-) =>
+): RequestResult<GetPipelineResponses, GetPipelineErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).get<GetPipelineResponses, GetPipelineErrors, ThrowOnError, 'data'>({
     responseStyle: 'data',
     security: [{ scheme: 'bearer', type: 'http' }],
@@ -715,7 +720,7 @@ export const getPipeline = <ThrowOnError extends boolean = true>(
  */
 export const patchPipeline = <ThrowOnError extends boolean = true>(
   options: Options<PatchPipelineData, ThrowOnError>
-) =>
+): RequestResult<PatchPipelineResponses, PatchPipelineErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).patch<
     PatchPipelineResponses,
     PatchPipelineErrors,
@@ -741,7 +746,7 @@ export const patchPipeline = <ThrowOnError extends boolean = true>(
  */
 export const putPipeline = <ThrowOnError extends boolean = true>(
   options: Options<PutPipelineData, ThrowOnError>
-) =>
+): RequestResult<PutPipelineResponses, PutPipelineErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).put<PutPipelineResponses, PutPipelineErrors, ThrowOnError, 'data'>({
     responseStyle: 'data',
     security: [{ scheme: 'bearer', type: 'http' }],
@@ -768,7 +773,7 @@ export const putPipeline = <ThrowOnError extends boolean = true>(
  */
 export const postPipelineActivate = <ThrowOnError extends boolean = true>(
   options: Options<PostPipelineActivateData, ThrowOnError>
-) =>
+): RequestResult<PostPipelineActivateResponses, PostPipelineActivateErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).post<
     PostPipelineActivateResponses,
     PostPipelineActivateErrors,
@@ -796,7 +801,7 @@ export const postPipelineActivate = <ThrowOnError extends boolean = true>(
  */
 export const postPipelineApprove = <ThrowOnError extends boolean = true>(
   options: Options<PostPipelineApproveData, ThrowOnError>
-) =>
+): RequestResult<PostPipelineApproveResponses, PostPipelineApproveErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).post<
     PostPipelineApproveResponses,
     PostPipelineApproveErrors,
@@ -821,7 +826,7 @@ export const postPipelineApprove = <ThrowOnError extends boolean = true>(
  */
 export const checkpointPipeline = <ThrowOnError extends boolean = true>(
   options: Options<CheckpointPipelineData, ThrowOnError>
-) =>
+): RequestResult<CheckpointPipelineResponses, CheckpointPipelineErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).post<
     CheckpointPipelineResponses,
     CheckpointPipelineErrors,
@@ -843,7 +848,7 @@ export const checkpointPipeline = <ThrowOnError extends boolean = true>(
  */
 export const syncCheckpoint = <ThrowOnError extends boolean = true>(
   options: Options<SyncCheckpointData, ThrowOnError>
-) =>
+): RequestResult<SyncCheckpointResponses, SyncCheckpointErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).post<
     SyncCheckpointResponses,
     SyncCheckpointErrors,
@@ -865,7 +870,12 @@ export const syncCheckpoint = <ThrowOnError extends boolean = true>(
  */
 export const getCheckpointSyncStatus = <ThrowOnError extends boolean = true>(
   options: Options<GetCheckpointSyncStatusData, ThrowOnError>
-) =>
+): RequestResult<
+  GetCheckpointSyncStatusResponses,
+  GetCheckpointSyncStatusErrors,
+  ThrowOnError,
+  'data'
+> =>
   (options.client ?? client).get<
     GetCheckpointSyncStatusResponses,
     GetCheckpointSyncStatusErrors,
@@ -887,7 +897,7 @@ export const getCheckpointSyncStatus = <ThrowOnError extends boolean = true>(
  */
 export const getCheckpointStatus = <ThrowOnError extends boolean = true>(
   options: Options<GetCheckpointStatusData, ThrowOnError>
-) =>
+): RequestResult<GetCheckpointStatusResponses, GetCheckpointStatusErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).get<
     GetCheckpointStatusResponses,
     GetCheckpointStatusErrors,
@@ -913,7 +923,7 @@ export const getCheckpointStatus = <ThrowOnError extends boolean = true>(
  */
 export const getCheckpoints = <ThrowOnError extends boolean = true>(
   options: Options<GetCheckpointsData, ThrowOnError>
-) =>
+): RequestResult<GetCheckpointsResponses, GetCheckpointsErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).get<
     GetCheckpointsResponses,
     GetCheckpointsErrors,
@@ -937,7 +947,7 @@ export const getCheckpoints = <ThrowOnError extends boolean = true>(
  */
 export const getRemoteCheckpoints = <ThrowOnError extends boolean = true>(
   options: Options<GetRemoteCheckpointsData, ThrowOnError>
-) =>
+): RequestResult<GetRemoteCheckpointsResponses, GetRemoteCheckpointsErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).get<
     GetRemoteCheckpointsResponses,
     GetRemoteCheckpointsErrors,
@@ -959,7 +969,12 @@ export const getRemoteCheckpoints = <ThrowOnError extends boolean = true>(
  */
 export const getPipelineCircuitJsonProfile = <ThrowOnError extends boolean = true>(
   options: Options<GetPipelineCircuitJsonProfileData, ThrowOnError>
-) =>
+): RequestResult<
+  GetPipelineCircuitJsonProfileResponses,
+  GetPipelineCircuitJsonProfileErrors,
+  ThrowOnError,
+  'data'
+> =>
   (options.client ?? client).get<
     GetPipelineCircuitJsonProfileResponses,
     GetPipelineCircuitJsonProfileErrors,
@@ -981,7 +996,12 @@ export const getPipelineCircuitJsonProfile = <ThrowOnError extends boolean = tru
  */
 export const getPipelineCircuitProfile = <ThrowOnError extends boolean = true>(
   options: Options<GetPipelineCircuitProfileData, ThrowOnError>
-) =>
+): RequestResult<
+  GetPipelineCircuitProfileResponses,
+  GetPipelineCircuitProfileErrors,
+  ThrowOnError,
+  'data'
+> =>
   (options.client ?? client).get<
     GetPipelineCircuitProfileResponses,
     GetPipelineCircuitProfileErrors,
@@ -1010,7 +1030,7 @@ export const getPipelineCircuitProfile = <ThrowOnError extends boolean = true>(
  */
 export const postPipelineClear = <ThrowOnError extends boolean = true>(
   options: Options<PostPipelineClearData, ThrowOnError>
-) =>
+): RequestResult<PostPipelineClearResponses, PostPipelineClearErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).post<
     PostPipelineClearResponses,
     PostPipelineClearErrors,
@@ -1046,7 +1066,7 @@ export const postPipelineClear = <ThrowOnError extends boolean = true>(
  */
 export const clockAdvance = <ThrowOnError extends boolean = true>(
   options: Options<ClockAdvanceData, ThrowOnError>
-) =>
+): RequestResult<ClockAdvanceResponses, ClockAdvanceErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).post<ClockAdvanceResponses, ClockAdvanceErrors, ThrowOnError, 'data'>({
     responseStyle: 'data',
     security: [{ scheme: 'bearer', type: 'http' }],
@@ -1067,7 +1087,7 @@ export const clockAdvance = <ThrowOnError extends boolean = true>(
  */
 export const commitTransaction = <ThrowOnError extends boolean = true>(
   options: Options<CommitTransactionData, ThrowOnError>
-) =>
+): RequestResult<CommitTransactionResponses, CommitTransactionErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).post<
     CommitTransactionResponses,
     CommitTransactionErrors,
@@ -1090,7 +1110,7 @@ export const commitTransaction = <ThrowOnError extends boolean = true>(
  */
 export const completionStatus = <ThrowOnError extends boolean = true>(
   options: Options<CompletionStatusData, ThrowOnError>
-) =>
+): RequestResult<CompletionStatusResponses, CompletionStatusErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).get<
     CompletionStatusResponses,
     CompletionStatusErrors,
@@ -1114,7 +1134,12 @@ export const completionStatus = <ThrowOnError extends boolean = true>(
  */
 export const getPipelineDataflowGraph = <ThrowOnError extends boolean = true>(
   options: Options<GetPipelineDataflowGraphData, ThrowOnError>
-) =>
+): RequestResult<
+  GetPipelineDataflowGraphResponses,
+  GetPipelineDataflowGraphErrors,
+  ThrowOnError,
+  'data'
+> =>
   (options.client ?? client).get<
     GetPipelineDataflowGraphResponses,
     GetPipelineDataflowGraphErrors,
@@ -1145,7 +1170,7 @@ export const getPipelineDataflowGraph = <ThrowOnError extends boolean = true>(
  */
 export const postPipelineDiff = <ThrowOnError extends boolean = true>(
   options: Options<PostPipelineDiffData, ThrowOnError>
-) =>
+): RequestResult<PostPipelineDiffResponses, PostPipelineDiffErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).post<
     PostPipelineDiffResponses,
     PostPipelineDiffErrors,
@@ -1174,7 +1199,12 @@ export const postPipelineDiff = <ThrowOnError extends boolean = true>(
  */
 export const postPipelineDismissError = <ThrowOnError extends boolean = true>(
   options: Options<PostPipelineDismissErrorData, ThrowOnError>
-) =>
+): RequestResult<
+  PostPipelineDismissErrorResponses,
+  PostPipelineDismissErrorErrors,
+  ThrowOnError,
+  'data'
+> =>
   (options.client ?? client).post<
     PostPipelineDismissErrorResponses,
     PostPipelineDismissErrorErrors,
@@ -1214,7 +1244,7 @@ export const postPipelineDismissError = <ThrowOnError extends boolean = true>(
  */
 export const httpOutput = <ThrowOnError extends boolean = true>(
   options: Options<HttpOutputData, ThrowOnError>
-) =>
+): RequestResult<HttpOutputResponses, HttpOutputErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).post<HttpOutputResponses, HttpOutputErrors, ThrowOnError, 'data'>({
     responseStyle: 'data',
     security: [{ scheme: 'bearer', type: 'http' }],
@@ -1240,7 +1270,7 @@ export const httpOutput = <ThrowOnError extends boolean = true>(
  */
 export const listPipelineEvents = <ThrowOnError extends boolean = true>(
   options: Options<ListPipelineEventsData, ThrowOnError>
-) =>
+): RequestResult<ListPipelineEventsResponses, ListPipelineEventsErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).get<
     ListPipelineEventsResponses,
     ListPipelineEventsErrors,
@@ -1266,7 +1296,7 @@ export const listPipelineEvents = <ThrowOnError extends boolean = true>(
  */
 export const getPipelineEvent = <ThrowOnError extends boolean = true>(
   options: Options<GetPipelineEventData, ThrowOnError>
-) =>
+): RequestResult<GetPipelineEventResponses, GetPipelineEventErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).get<
     GetPipelineEventResponses,
     GetPipelineEventErrors,
@@ -1288,7 +1318,12 @@ export const getPipelineEvent = <ThrowOnError extends boolean = true>(
  */
 export const getPipelineHeapProfile = <ThrowOnError extends boolean = true>(
   options: Options<GetPipelineHeapProfileData, ThrowOnError>
-) =>
+): RequestResult<
+  GetPipelineHeapProfileResponses,
+  GetPipelineHeapProfileErrors,
+  ThrowOnError,
+  'data'
+> =>
   (options.client ?? client).get<
     GetPipelineHeapProfileResponses,
     GetPipelineHeapProfileErrors,
@@ -1322,7 +1357,7 @@ export const getPipelineHeapProfile = <ThrowOnError extends boolean = true>(
  */
 export const httpInput = <ThrowOnError extends boolean = true>(
   options: Options<HttpInputData, ThrowOnError>
-) =>
+): RequestResult<HttpInputResponses, HttpInputErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).post<HttpInputResponses, HttpInputErrors, ThrowOnError, 'data'>({
     bodySerializer: null,
     responseStyle: 'data',
@@ -1356,7 +1391,7 @@ export const httpInput = <ThrowOnError extends boolean = true>(
  */
 export const getPipelineLogs = <ThrowOnError extends boolean = true>(
   options: Options<GetPipelineLogsData, ThrowOnError>
-) =>
+): RequestResult<GetPipelineLogsResponses, GetPipelineLogsErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).get<
     GetPipelineLogsResponses,
     GetPipelineLogsErrors,
@@ -1378,7 +1413,7 @@ export const getPipelineLogs = <ThrowOnError extends boolean = true>(
  */
 export const getPipelineMetrics = <ThrowOnError extends boolean = true>(
   options: Options<GetPipelineMetricsData, ThrowOnError>
-) =>
+): RequestResult<GetPipelineMetricsResponses, GetPipelineMetricsErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).get<
     GetPipelineMetricsResponses,
     GetPipelineMetricsErrors,
@@ -1402,7 +1437,7 @@ export const getPipelineMetrics = <ThrowOnError extends boolean = true>(
  */
 export const postPipelinePause = <ThrowOnError extends boolean = true>(
   options: Options<PostPipelinePauseData, ThrowOnError>
-) =>
+): RequestResult<PostPipelinePauseResponses, PostPipelinePauseErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).post<
     PostPipelinePauseResponses,
     PostPipelinePauseErrors,
@@ -1426,7 +1461,7 @@ export const postPipelinePause = <ThrowOnError extends boolean = true>(
  */
 export const pipelineAdhocSql = <ThrowOnError extends boolean = true>(
   options: Options<PipelineAdhocSqlData, ThrowOnError>
-) =>
+): RequestResult<PipelineAdhocSqlResponses, PipelineAdhocSqlErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).get<
     PipelineAdhocSqlResponses,
     PipelineAdhocSqlErrors,
@@ -1452,7 +1487,12 @@ export const pipelineAdhocSql = <ThrowOnError extends boolean = true>(
  */
 export const postPipelineRebalance = <ThrowOnError extends boolean = true>(
   options: Options<PostPipelineRebalanceData, ThrowOnError>
-) =>
+): RequestResult<
+  PostPipelineRebalanceResponses,
+  PostPipelineRebalanceErrors,
+  ThrowOnError,
+  'data'
+> =>
   (options.client ?? client).post<
     PostPipelineRebalanceResponses,
     PostPipelineRebalanceErrors,
@@ -1476,7 +1516,7 @@ export const postPipelineRebalance = <ThrowOnError extends boolean = true>(
  */
 export const postPipelineResume = <ThrowOnError extends boolean = true>(
   options: Options<PostPipelineResumeData, ThrowOnError>
-) =>
+): RequestResult<PostPipelineResumeResponses, PostPipelineResumeErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).post<
     PostPipelineResumeResponses,
     PostPipelineResumeErrors,
@@ -1499,7 +1539,12 @@ export const postPipelineResume = <ThrowOnError extends boolean = true>(
  */
 export const getPipelineSamplyProfile = <ThrowOnError extends boolean = true>(
   options: Options<GetPipelineSamplyProfileData, ThrowOnError>
-) =>
+): RequestResult<
+  GetPipelineSamplyProfileResponses,
+  GetPipelineSamplyProfileErrors,
+  ThrowOnError,
+  'data'
+> =>
   (options.client ?? client).get<
     GetPipelineSamplyProfileResponses,
     GetPipelineSamplyProfileErrors,
@@ -1521,7 +1566,7 @@ export const getPipelineSamplyProfile = <ThrowOnError extends boolean = true>(
  */
 export const startSamplyProfile = <ThrowOnError extends boolean = true>(
   options: Options<StartSamplyProfileData, ThrowOnError>
-) =>
+): RequestResult<StartSamplyProfileResponses, StartSamplyProfileErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).post<
     StartSamplyProfileResponses,
     StartSamplyProfileErrors,
@@ -1554,7 +1599,7 @@ export const startSamplyProfile = <ThrowOnError extends boolean = true>(
  */
 export const postPipelineStart = <ThrowOnError extends boolean = true>(
   options: Options<PostPipelineStartData, ThrowOnError>
-) =>
+): RequestResult<PostPipelineStartResponses, PostPipelineStartErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).post<
     PostPipelineStartResponses,
     PostPipelineStartErrors,
@@ -1576,7 +1621,12 @@ export const postPipelineStart = <ThrowOnError extends boolean = true>(
  */
 export const postPipelineStartCompaction = <ThrowOnError extends boolean = true>(
   options: Options<PostPipelineStartCompactionData, ThrowOnError>
-) =>
+): RequestResult<
+  PostPipelineStartCompactionResponses,
+  PostPipelineStartCompactionErrors,
+  ThrowOnError,
+  'data'
+> =>
   (options.client ?? client).post<
     PostPipelineStartCompactionResponses,
     PostPipelineStartCompactionErrors,
@@ -1598,7 +1648,7 @@ export const postPipelineStartCompaction = <ThrowOnError extends boolean = true>
  */
 export const startTransaction = <ThrowOnError extends boolean = true>(
   options: Options<StartTransactionData, ThrowOnError>
-) =>
+): RequestResult<StartTransactionResponses, StartTransactionErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).post<
     StartTransactionResponses,
     StartTransactionErrors,
@@ -1620,7 +1670,7 @@ export const startTransaction = <ThrowOnError extends boolean = true>(
  */
 export const getPipelineStats = <ThrowOnError extends boolean = true>(
   options: Options<GetPipelineStatsData, ThrowOnError>
-) =>
+): RequestResult<GetPipelineStatsResponses, GetPipelineStatsErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).get<
     GetPipelineStatsResponses,
     GetPipelineStatsErrors,
@@ -1665,7 +1715,7 @@ export const getPipelineStats = <ThrowOnError extends boolean = true>(
  */
 export const postPipelineStop = <ThrowOnError extends boolean = true>(
   options: Options<PostPipelineStopData, ThrowOnError>
-) =>
+): RequestResult<PostPipelineStopResponses, PostPipelineStopErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).post<
     PostPipelineStopResponses,
     PostPipelineStopErrors,
@@ -1691,7 +1741,12 @@ export const postPipelineStop = <ThrowOnError extends boolean = true>(
  */
 export const getPipelineSupportBundle = <ThrowOnError extends boolean = true>(
   options: Options<GetPipelineSupportBundleData, ThrowOnError>
-) =>
+): RequestResult<
+  GetPipelineSupportBundleResponses,
+  GetPipelineSupportBundleErrors,
+  ThrowOnError,
+  'data'
+> =>
   (options.client ?? client).get<
     GetPipelineSupportBundleResponses,
     GetPipelineSupportBundleErrors,
@@ -1717,7 +1772,7 @@ export const getPipelineSupportBundle = <ThrowOnError extends boolean = true>(
  */
 export const completionToken = <ThrowOnError extends boolean = true>(
   options: Options<CompletionTokenData, ThrowOnError>
-) =>
+): RequestResult<CompletionTokenResponses, CompletionTokenErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).get<
     CompletionTokenResponses,
     CompletionTokenErrors,
@@ -1739,7 +1794,12 @@ export const completionToken = <ThrowOnError extends boolean = true>(
  */
 export const getPipelineInputConnectorStatus = <ThrowOnError extends boolean = true>(
   options: Options<GetPipelineInputConnectorStatusData, ThrowOnError>
-) =>
+): RequestResult<
+  GetPipelineInputConnectorStatusResponses,
+  GetPipelineInputConnectorStatusErrors,
+  ThrowOnError,
+  'data'
+> =>
   (options.client ?? client).get<
     GetPipelineInputConnectorStatusResponses,
     GetPipelineInputConnectorStatusErrors,
@@ -1787,7 +1847,12 @@ export const getPipelineInputConnectorStatus = <ThrowOnError extends boolean = t
  */
 export const postPipelineInputConnectorAction = <ThrowOnError extends boolean = true>(
   options: Options<PostPipelineInputConnectorActionData, ThrowOnError>
-) =>
+): RequestResult<
+  PostPipelineInputConnectorActionResponses,
+  PostPipelineInputConnectorActionErrors,
+  ThrowOnError,
+  'data'
+> =>
   (options.client ?? client).post<
     PostPipelineInputConnectorActionResponses,
     PostPipelineInputConnectorActionErrors,
@@ -1809,7 +1874,12 @@ export const postPipelineInputConnectorAction = <ThrowOnError extends boolean =
  */
 export const getPipelineTimeSeries = <ThrowOnError extends boolean = true>(
   options: Options<GetPipelineTimeSeriesData, ThrowOnError>
-) =>
+): RequestResult<
+  GetPipelineTimeSeriesResponses,
+  GetPipelineTimeSeriesErrors,
+  ThrowOnError,
+  'data'
+> =>
   (options.client ?? client).get<
     GetPipelineTimeSeriesResponses,
     GetPipelineTimeSeriesErrors,
@@ -1836,7 +1906,12 @@ export const getPipelineTimeSeries = <ThrowOnError extends boolean = true>(
  */
 export const getPipelineTimeSeriesStream = <ThrowOnError extends boolean = true>(
   options: Options<GetPipelineTimeSeriesStreamData, ThrowOnError>
-) =>
+): RequestResult<
+  GetPipelineTimeSeriesStreamResponses,
+  GetPipelineTimeSeriesStreamErrors,
+  ThrowOnError,
+  'data'
+> =>
   (options.client ?? client).get<
     GetPipelineTimeSeriesStreamResponses,
     GetPipelineTimeSeriesStreamErrors,
@@ -1878,7 +1953,7 @@ export const getPipelineTimeSeriesStream = <ThrowOnError extends boolean = true>
  */
 export const postUpdateRuntime = <ThrowOnError extends boolean = true>(
   options: Options<PostUpdateRuntimeData, ThrowOnError>
-) =>
+): RequestResult<PostUpdateRuntimeResponses, PostUpdateRuntimeErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).post<
     PostUpdateRuntimeResponses,
     PostUpdateRuntimeErrors,
@@ -1900,7 +1975,12 @@ export const postUpdateRuntime = <ThrowOnError extends boolean = true>(
  */
 export const getPipelineOutputConnectorStatus = <ThrowOnError extends boolean = true>(
   options: Options<GetPipelineOutputConnectorStatusData, ThrowOnError>
-) =>
+): RequestResult<
+  GetPipelineOutputConnectorStatusResponses,
+  GetPipelineOutputConnectorStatusErrors,
+  ThrowOnError,
+  'data'
+> =>
   (options.client ?? client).get<
     GetPipelineOutputConnectorStatusResponses,
     GetPipelineOutputConnectorStatusErrors,
@@ -1922,7 +2002,7 @@ export const getPipelineOutputConnectorStatus = <ThrowOnError extends boolean =
  */
 export const listTenantUsers = <ThrowOnError extends boolean = true>(
   options?: Options<ListTenantUsersData, ThrowOnError>
-) =>
+): RequestResult<ListTenantUsersResponses, ListTenantUsersErrors, ThrowOnError, 'data'> =>
   (options?.client ?? client).get<
     ListTenantUsersResponses,
     ListTenantUsersErrors,
@@ -1949,7 +2029,7 @@ export const listTenantUsers = <ThrowOnError extends boolean = true>(
  */
 export const addTenantUser = <ThrowOnError extends boolean = true>(
   options: Options<AddTenantUserData, ThrowOnError>
-) =>
+): RequestResult<AddTenantUserResponses, AddTenantUserErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).post<
     AddTenantUserResponses,
     AddTenantUserErrors,
@@ -1978,7 +2058,7 @@ export const addTenantUser = <ThrowOnError extends boolean = true>(
  */
 export const deleteTenantUser = <ThrowOnError extends boolean = true>(
   options: Options<DeleteTenantUserData, ThrowOnError>
-) =>
+): RequestResult<DeleteTenantUserResponses, DeleteTenantUserErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).delete<
     DeleteTenantUserResponses,
     DeleteTenantUserErrors,
@@ -2001,7 +2081,7 @@ export const deleteTenantUser = <ThrowOnError extends boolean = true>(
  */
 export const putTenantUser = <ThrowOnError extends boolean = true>(
   options: Options<PutTenantUserData, ThrowOnError>
-) =>
+): RequestResult<PutTenantUserResponses, PutTenantUserErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).put<PutTenantUserResponses, PutTenantUserErrors, ThrowOnError, 'data'>(
     {
       responseStyle: 'data',
@@ -2024,7 +2104,7 @@ export const putTenantUser = <ThrowOnError extends boolean = true>(
  */
 export const listTenants = <ThrowOnError extends boolean = true>(
   options?: Options<ListTenantsData, ThrowOnError>
-) =>
+): RequestResult<ListTenantsResponses, ListTenantsErrors, ThrowOnError, 'data'> =>
   (options?.client ?? client).get<ListTenantsResponses, ListTenantsErrors, ThrowOnError, 'data'>({
     responseStyle: 'data',
     security: [{ scheme: 'bearer', type: 'http' }],
@@ -2043,7 +2123,7 @@ export const listTenants = <ThrowOnError extends boolean = true>(
  */
 export const createTenant = <ThrowOnError extends boolean = true>(
   options: Options<CreateTenantData, ThrowOnError>
-) =>
+): RequestResult<CreateTenantResponses, CreateTenantErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).post<CreateTenantResponses, CreateTenantErrors, ThrowOnError, 'data'>({
     responseStyle: 'data',
     security: [{ scheme: 'bearer', type: 'http' }],
@@ -2071,7 +2151,7 @@ export const createTenant = <ThrowOnError extends boolean = true>(
  */
 export const deleteTenant = <ThrowOnError extends boolean = true>(
   options: Options<DeleteTenantData, ThrowOnError>
-) =>
+): RequestResult<DeleteTenantResponses, DeleteTenantErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).delete<
     DeleteTenantResponses,
     DeleteTenantErrors,
@@ -2094,7 +2174,7 @@ export const deleteTenant = <ThrowOnError extends boolean = true>(
  */
 export const getTenant = <ThrowOnError extends boolean = true>(
   options: Options<GetTenantData, ThrowOnError>
-) =>
+): RequestResult<GetTenantResponses, GetTenantErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).get<GetTenantResponses, GetTenantErrors, ThrowOnError, 'data'>({
     responseStyle: 'data',
     security: [{ scheme: 'bearer', type: 'http' }],
@@ -2118,7 +2198,7 @@ export const getTenant = <ThrowOnError extends boolean = true>(
  */
 export const patchTenant = <ThrowOnError extends boolean = true>(
   options: Options<PatchTenantData, ThrowOnError>
-) =>
+): RequestResult<PatchTenantResponses, PatchTenantErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).patch<PatchTenantResponses, PatchTenantErrors, ThrowOnError, 'data'>({
     responseStyle: 'data',
     security: [{ scheme: 'bearer', type: 'http' }],
@@ -2145,7 +2225,7 @@ export const patchTenant = <ThrowOnError extends boolean = true>(
  */
 export const postValidateProgram = <ThrowOnError extends boolean = true>(
   options: Options<PostValidateProgramData, ThrowOnError>
-) =>
+): RequestResult<PostValidateProgramResponses, PostValidateProgramErrors, ThrowOnError, 'data'> =>
   (options.client ?? client).post<
     PostValidateProgramResponses,
     PostValidateProgramErrors,
diff --git a/js-packages/web-console/src/lib/services/manager/types.gen.ts b/js-packages/web-console/src/lib/services/manager/types.gen.ts
index 7ddf00942fa..21f2b209259 100644
--- a/js-packages/web-console/src/lib/services/manager/types.gen.ts
+++ b/js-packages/web-console/src/lib/services/manager/types.gen.ts
@@ -1,5 +1,7 @@
 // This file is auto-generated by @hey-api/openapi-ts
 
+import type { Microseconds } from '$lib/functions/common/duration'
+
 export type ClientOptions = {
   baseUrl: `${string}://${string}` | (string & {})
 }
@@ -2722,6 +2724,24 @@ export type InputEndpointMetrics = {
    * Number of transport errors.
    */
   num_transport_errors: number
+  /**
+   * 99th percentile processing latency (from ingesting a batch to finishing processing it) in microseconds.
+   *
+   * The time from ingesting a batch of records off the wire
+   * to the circuit finishing processing them,
+   * covering parsing, queuing, and the circuit step.
+   *
+   * Does not account for completion latency.
+   *
+   * Taken over the endpoint's sliding histogram, which holds the 10,000 most
+   * recent samples spanning at most 10 minutes, whichever bound is reached
+   * first. One sample is recorded per completed batch. An endpoint that stops
+   * ingesting keeps reporting its last known latency instead of dropping to
+   * `None`.
+   *
+   * `None` until the endpoint records its first sample.
+   */
+  processing_latency_p99_micros?: Microseconds | null
   /**
    * Total bytes pushed to the endpoint since it was created.
    */
diff --git a/js-packages/web-console/src/lib/types/common/nullable.ts b/js-packages/web-console/src/lib/types/common/nullable.ts
new file mode 100644
index 00000000000..260ee196461
--- /dev/null
+++ b/js-packages/web-console/src/lib/types/common/nullable.ts
@@ -0,0 +1,12 @@
+/**
+ * `Value`, carrying the nullability of `Source`: `null` stays `null` and
+ * `undefined` stays `undefined`, so a mapping function can accept a nullable
+ * argument without the caller unwrapping it first.
+ *
+ * @example
+ * ```ts
+ * type A = SameNullability<Microseconds, number>              // Microseconds
+ * type B = SameNullability<Microseconds, number | undefined>  // Microseconds | undefined
+ * ```
+ */
+export type SameNullability<Value, Source> = Source extends null | undefined ? Source : Value
diff --git a/openapi.json b/openapi.json
index bc1b04bac81..2dc5666be83 100644
--- a/openapi.json
+++ b/openapi.json
@@ -11159,6 +11159,13 @@
             "description": "Number of transport errors.",
             "minimum": 0
           },
+          "processing_latency_p99_micros": {
+            "type": "integer",
+            "format": "int64",
+            "description": "99th percentile processing latency (from ingesting a batch to finishing processing it) in microseconds.\n\nThe time from ingesting a batch of records off the wire\nto the circuit finishing processing them,\ncovering parsing, queuing, and the circuit step.\n\nDoes not account for completion latency.\n\nTaken over the endpoint's sliding histogram, which holds the 10,000 most\nrecent samples spanning at most 10 minutes, whichever bound is reached\nfirst. One sample is recorded per completed batch. An endpoint that stops\ningesting keeps reporting its last known latency instead of dropping to\n`None`.\n\n`None` until the endpoint records its first sample.",
+            "nullable": true,
+            "minimum": 0
+          },
           "total_bytes": {
             "type": "integer",
             "format": "int64",