@seed-ship/mcp-ui-solid 6.17.0 → 6.18.0

package/src/services/component-registry.ts

@@ -1,6 +1,6 @@
 /**
  * Component Registry Service
- * Phase 0: Static registry with Quickchart and Table definitions
+ * Phase 0: Static registry with Chart and Table definitions
  * Phase 1: Dynamic registry populated from /api/mcp/tools/list
  *
  * Provides component schemas for LLM prompt engineering
@@ -10,20 +10,23 @@ import type { ComponentRegistryEntry, ComponentType } from '../types'
 import { DEFAULT_RESOURCE_LIMITS } from './validation'
 
 /**
- * Quickchart Component Registry Entry
- * Based on Quickchart API documentation
+ * Chart Component Registry Entry
+ *
+ * The historical export name is retained for source compatibility. The
+ * renderer is local-first: Chart.js is the native implementation, while the
+ * external QuickChart fallback is a host-level opt-in.
  */
 export const QuickchartRegistry: ComponentRegistryEntry = {
   type: 'chart',
-  name: 'Quickchart',
+  name: 'Chart.js',
   description:
-    'Render charts using Quickchart.io API. Supports bar, line, pie, doughnut, radar, and scatter charts. Best for visualizing numerical data with 2-10 data series and up to 1000 data points.',
+    'Render charts locally with Chart.js. Supports bar, line, pie, doughnut, radar, scatter, bubble, and polarArea charts, including point and time-series data. An external QuickChart fallback is available only when the host explicitly opts in.',
   schema: {
     type: 'object',
     properties: {
       type: {
         type: 'string',
-        enum: ['bar', 'line', 'pie', 'doughnut', 'radar', 'scatter'],
+        enum: ['bar', 'line', 'pie', 'doughnut', 'radar', 'scatter', 'bubble', 'polarArea'],
         description: 'Chart type',
       },
       title: {
@@ -45,8 +48,22 @@ export const QuickchartRegistry: ComponentRegistryEntry = {
               properties: {
                 label: { type: 'string' },
                 data: {
-                  type: 'array',
-                  items: { type: 'number' },
+                  // Empty arrays match both branches; mirror Zod's inclusive union.
+                  anyOf: [
+                    { type: 'array', items: { type: 'number' } },
+                    {
+                      type: 'array',
+                      items: {
+                        type: 'object',
+                        properties: {
+                          x: { oneOf: [{ type: 'string' }, { type: 'number' }] },
+                          y: { type: 'number' },
+                          r: { type: 'number', minimum: 0 },
+                        },
+                        required: ['x', 'y'],
+                      },
+                    },
+                  ],
                 },
                 backgroundColor: {
                   oneOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }],
@@ -55,6 +72,8 @@ export const QuickchartRegistry: ComponentRegistryEntry = {
                   oneOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }],
                 },
                 borderWidth: { type: 'number' },
+                fill: { oneOf: [{ type: 'boolean' }, { type: 'string' }] },
+                tension: { type: 'number' },
               },
               required: ['label', 'data'],
             },
@@ -64,8 +83,35 @@ export const QuickchartRegistry: ComponentRegistryEntry = {
       },
       options: {
         type: 'object',
-        description: 'Chart.js options for customization',
+        description: 'Supported Chart.js options for customization',
+        properties: {
+          responsive: { type: 'boolean' },
+          maintainAspectRatio: { type: 'boolean' },
+          tension: { type: 'number' },
+          scales: {},
+          plugins: {},
+        },
+      },
+      renderer: {
+        type: 'string',
+        enum: ['native', 'iframe', 'auto'],
+        description: 'Renderer preference; external iframe use still requires host opt-in',
+      },
+      exportable: { type: 'boolean', description: 'Show the PNG export action' },
+      timeAxis: {
+        type: 'object',
+        description:
+          'Time-series x-axis configuration; the host must install and register a compatible Chart.js date adapter',
+        properties: {
+          parser: { type: 'string' },
+          unit: { type: 'string', enum: ['day', 'week', 'month', 'quarter', 'year'] },
+          tooltipFormat: { type: 'string' },
+          min: { type: 'string' },
+          max: { type: 'string' },
+        },
       },
+      height: { type: 'string', description: 'Chart container height as a CSS value' },
+      className: { type: 'string' },
     },
     required: ['type', 'data'],
   },
@@ -128,7 +174,7 @@ export const TableRegistry: ComponentRegistryEntry = {
   type: 'table',
   name: 'DataTable',
   description:
-    'Render tabular data with sortable columns and pagination. Best for displaying structured records with up to 100 rows. Supports column width customization and cell formatting.',
+    'Render tabular data with sortable columns, client-side search, context-aware paging, virtualization, and export controls. Best for structured records with up to 100 rows per payload.',
   schema: {
     type: 'object',
     properties: {
@@ -160,12 +206,68 @@ export const TableRegistry: ComponentRegistryEntry = {
       },
       pagination: {
         type: 'object',
+        description: 'Legacy server-pagination metadata',
         properties: {
           currentPage: { type: 'number' },
           pageSize: { type: 'number' },
           totalRows: { type: 'number' },
         },
       },
+      searchable: {
+        type: 'boolean',
+        description: 'Show the client-side search field (default: true)',
+      },
+      searchPlaceholder: { type: 'string', description: 'Search field placeholder' },
+      pageSize: {
+        type: 'integer',
+        minimum: 0,
+        description: 'Rows per page in expanded mode (default: 25; 0 disables client paging)',
+      },
+      chatPageSize: {
+        type: 'integer',
+        minimum: 0,
+        description: 'Rows per page in chat mode (default: min(10, pageSize); 0 disables client paging)',
+      },
+      initialPage: {
+        type: 'integer',
+        minimum: 0,
+        description: 'Initial zero-based client page',
+      },
+      virtualize: {
+        oneOf: [
+          { type: 'boolean' },
+          {
+            type: 'object',
+            properties: {
+              enabled: { type: 'boolean' },
+              rowHeight: { type: 'integer', minimum: 1 },
+              overscan: { type: 'integer', minimum: 0 },
+              threshold: { type: 'integer', minimum: 1 },
+            },
+          },
+        ],
+      },
+      exportable: {
+        oneOf: [
+          { type: 'boolean' },
+          {
+            type: 'object',
+            properties: {
+              formats: {
+                type: 'array',
+                items: { type: 'string', enum: ['csv', 'tsv', 'json'] },
+              },
+              filename: { type: 'string' },
+            },
+          },
+        ],
+      },
+      className: { type: 'string' },
+      citationMap: { type: 'object', description: 'Citation metadata keyed by marker id' },
+      maxHeight: {
+        oneOf: [{ type: 'string' }, { type: 'number' }],
+        description: "Inline table height cap; use 'auto' to disable it",
+      },
     },
     required: ['columns', 'rows'],
   },
@@ -868,19 +970,36 @@ export const GraphRegistry: ComponentRegistryEntry = {
   type: 'graph',
   name: 'NodeLinkGraph',
   description:
-    'Render a node-link graph (entities and their relationships) with @antv/g6. Best for provenance/source chains, dependency or process graphs, and ontology-lite entity/relation views. Degrades to an edge table when the graph engine is unavailable.',
+    'Render a node-link graph (entities and their relationships) with the optional @antv/g6 peer. Best for provenance/source chains, dependency or process graphs, and ontology-lite entity/relation views.',
   schema: {
     type: 'object',
     properties: {
+      title: { type: 'string' },
       nodes: {
         type: 'array',
         description: 'Graph nodes (at least one required)',
+        minItems: 1,
         items: {
           type: 'object',
           properties: {
-            id: { type: 'string' },
+            id: { type: 'string', minLength: 1 },
             label: { type: 'string' },
-            group: { type: 'string' },
+            type: { type: 'string' },
+            size: {
+              oneOf: [
+                { type: 'number' },
+                {
+                  type: 'array',
+                  items: [{ type: 'number' }, { type: 'number' }],
+                  additionalItems: false,
+                  minItems: 2,
+                  maxItems: 2,
+                },
+              ],
+            },
+            weight: { type: 'number' },
+            style: { type: 'object' },
+            data: { type: 'object' },
           },
           required: ['id'],
         },
@@ -891,20 +1010,46 @@ export const GraphRegistry: ComponentRegistryEntry = {
         items: {
           type: 'object',
           properties: {
-            source: { type: 'string' },
-            target: { type: 'string' },
+            source: { type: 'string', minLength: 1 },
+            target: { type: 'string', minLength: 1 },
             label: { type: 'string' },
+            type: { type: 'string' },
             weight: { type: 'number' },
+            style: { type: 'object' },
+            data: { type: 'object' },
           },
           required: ['source', 'target'],
         },
       },
       layout: {
-        type: 'string',
-        enum: ['force', 'radial', 'grid', 'dagre', 'circular'],
-        description: 'Layout algorithm (default: force)',
-      },
-      directed: { type: 'boolean', description: 'Render edges as directed (arrows)' },
+        oneOf: [
+          {
+            type: 'string',
+            enum: ['force', 'dagre', 'mindmap', 'tree', 'circular', 'grid', 'concentric'],
+          },
+          {
+            type: 'object',
+            properties: {
+              type: {
+                type: 'string',
+                enum: ['force', 'dagre', 'mindmap', 'tree', 'circular', 'grid', 'concentric'],
+              },
+              options: { type: 'object' },
+            },
+            required: ['type'],
+          },
+        ],
+        description: 'Layout shorthand or layout-plus-options object',
+      },
+      height: { type: 'string' },
+      width: { type: 'string' },
+      rendererPref: { type: 'string', enum: ['canvas'] },
+      fitView: { type: 'boolean' },
+      enableZoom: { type: 'boolean' },
+      enableDrag: { type: 'boolean' },
+      enableSelect: { type: 'boolean' },
+      tooltip: { type: 'boolean' },
+      className: { type: 'string' },
     },
     required: ['nodes'],
   },
@@ -916,11 +1061,10 @@ export const GraphRegistry: ComponentRegistryEntry = {
         type: 'graph',
         position: { colStart: 1, colSpan: 12 },
         params: {
-          directed: true,
           layout: 'dagre',
           nodes: [
-            { id: 'claim', label: 'Population = 522 250', group: 'claim' },
-            { id: 'source', label: 'INSEE 2021', group: 'source' },
+            { id: 'claim', label: 'Population = 522 250', weight: 2 },
+            { id: 'source', label: 'INSEE 2021', weight: 1 },
           ],
           edges: [{ source: 'claim', target: 'source', label: 'derived from' }],
         },

package/src/services/telemetry.ts

@@ -110,7 +110,7 @@ export function createTelemetryDispatcher(
       const result = sink(batch)
       // Promise rejections are silenced too (fail-open, §M.6.1).
       if (result && typeof (result as Promise<void>).then === 'function') {
-        ;(result as Promise<void>).catch(() => {
+        (result as Promise<void>).catch(() => {
           /* silent */
         })
       }

package/src/services/validation.test.ts

@@ -5,7 +5,7 @@
  * without UNKNOWN_COMPONENT_TYPE errors.
  */
 
-import { describe, it, expect, vi } from 'vitest';
+import { describe, it, expect } from 'vitest';
 import {
   validateComponent,
   validateChartComponent,
@@ -27,19 +27,6 @@ function makeComponent(type: ComponentType, params: Record<string, any> = {}): U
   };
 }
 
-/** Types that have explicit validation cases in validateComponent */
-const VALIDATED_TYPES: ComponentType[] = [
-  'chart',
-  'table',
-  'metric',
-  'text',
-  'iframe',
-  'image',
-  'link',
-  'action',
-  'artifact',
-];
-
 /** Types that hit the default case (no specific validation) */
 const PASSTHROUGH_TYPES: ComponentType[] = [
   'code',

package/src/services/validation.ts

@@ -417,9 +417,12 @@ export function validateChartComponent(
   }
   // Detect point-based charts (scatter/bubble) or object data (time-series line)
   const chartType = params.type || 'bar';
-  const firstDataPoint = params.data.datasets[0]?.data?.[0];
-  const hasObjectData =
-    typeof firstDataPoint === 'object' && firstDataPoint !== null && 'x' in firstDataPoint;
+  const usesPoints = (data: unknown[]) => data.some(value =>
+    typeof value === 'object' && value !== null && 'x' in value
+  );
+  const hasObjectData = params.data.datasets.some(dataset =>
+    Array.isArray(dataset.data) && usesPoints(dataset.data)
+  );
   const isPointChart = chartType === 'scatter' || chartType === 'bubble' || hasObjectData;
 
   // Labels required only for categorical charts (not scatter/bubble/time-series)
@@ -453,11 +456,12 @@ export function validateChartComponent(
   }
 
   // Length mismatch check — only for categorical charts, skip empty datasets
-  if (!isPointChart && Array.isArray(params.data.labels)) {
+  if (chartType !== 'scatter' && chartType !== 'bubble' && Array.isArray(params.data.labels)) {
     const expectedLength = params.data.labels.length;
     for (const [index, dataset] of params.data.datasets.entries()) {
       if (
         Array.isArray(dataset.data) &&
+        !usesPoints(dataset.data) &&
         dataset.data.length > 0 &&
         dataset.data.length !== expectedLength
       ) {
@@ -473,14 +477,16 @@ export function validateChartComponent(
   // Data type validation — numbers for categorical, {x,y} objects for point charts
   for (const [index, dataset] of params.data.datasets.entries()) {
     if (!Array.isArray(dataset.data)) continue;
+    const datasetIsPointChart = chartType === 'scatter' || chartType === 'bubble' || usesPoints(dataset.data);
     for (const [dataIndex, value] of dataset.data.entries()) {
-      if (isPointChart) {
+      if (datasetIsPointChart) {
         const vObj = value as any;
         if (
           typeof value !== 'object' ||
           value === null ||
           vObj.x == null ||
-          typeof vObj.y !== 'number'
+          typeof vObj.y !== 'number' ||
+          (vObj.r !== undefined && (typeof vObj.r !== 'number' || !Number.isFinite(vObj.r) || vObj.r < 0))
         ) {
           errors.push({
             path: `params.data.datasets[${index}].data[${dataIndex}]`,
@@ -515,6 +521,17 @@ export function validateTableComponent(
 ): ValidationResult {
   const errors: ValidationResult['errors'] = [];
 
+  for (const key of ['pageSize', 'chatPageSize', 'initialPage'] as const) {
+    const value = params[key];
+    if (value !== undefined && (typeof value !== 'number' || !Number.isInteger(value) || value < 0)) {
+      errors.push({
+        path: `params.${key}`,
+        message: `${key} must be a nonnegative integer`,
+        code: 'INVALID_PAGINATION',
+      });
+    }
+  }
+
   // Validate row count
   if (params.rows.length > limits.maxTableRows) {
     errors.push({

package/src/services/visualization-validation.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from 'vitest'
+import { validateComponent } from './validation'
+import type { UIComponent } from '../types'
+
+describe('visualization rendering boundary', () => {
+  it.each([false, true])('validates each dataset independently (points first: %s)', pointsFirst => {
+    const numeric = { label: 'Numeric', data: [1, 2] }
+    const points = { label: 'Points', data: [{ x: 1, y: 2, r: 3 }] }
+    const component: UIComponent = {
+      id: 'mixed-chart', type: 'chart', position: { colStart: 1, colSpan: 12 },
+      params: { type: 'line', data: { labels: ['A', 'B'], datasets: pointsFirst ? [points, numeric] : [numeric, points] } },
+    }
+    expect(validateComponent(component).valid).toBe(true)
+    points.data[0].r = -1
+    expect(validateComponent(component).valid).toBe(false)
+  })
+  for (const key of ['pageSize', 'chatPageSize', 'initialPage']) {
+    it.each([-1, 1.5, NaN, Infinity, '10'])(`rejects invalid ${key}: %s`, value => {
+      const component = {
+        id: 'table-bounds', type: 'table', position: { colStart: 1, colSpan: 12 },
+        params: { columns: [{ key: 'name', label: 'Name' }], rows: [], [key]: value },
+      } as UIComponent
+      const result = validateComponent(component)
+      expect(result.valid).toBe(false)
+      expect(result.errors).toContainEqual(expect.objectContaining({ path: `params.${key}` }))
+    })
+  }
+  it.each([-1, NaN, Infinity, '3', null])('rejects invalid bubble radius: %s', r => {
+    const component = {
+      id: 'bubble-bounds', type: 'chart', position: { colStart: 1, colSpan: 12 },
+      params: { type: 'bubble', data: { datasets: [{ label: 'Bubbles', data: [{ x: 1, y: 2, r }] }] } },
+    } as unknown as UIComponent
+    expect(validateComponent(component).valid).toBe(false)
+  })
+  it.each([undefined, 0, 4])('accepts optional/nonnegative bubble radius: %s', r => {
+    const component: UIComponent = {
+      id: 'bubble-valid', type: 'chart', position: { colStart: 1, colSpan: 12 },
+      params: { type: 'bubble', data: { datasets: [{ label: 'Bubbles', data: [{ x: 1, y: 2, r }] }] } },
+    }
+    expect(validateComponent(component).valid).toBe(true)
+  })
+})

package/src/types/index.ts

@@ -17,7 +17,7 @@ import type { ComponentType, LatLngPoint } from '@seed-ship/mcp-ui-spec'
 export type { ComponentType, LatLngPoint }
 
 /**
- * Chart types (powered by Quickchart)
+ * Chart types rendered natively with Chart.js.
  */
 export type ChartType = 'bar' | 'line' | 'pie' | 'doughnut' | 'radar' | 'scatter' | 'bubble' | 'polarArea'
 
@@ -81,7 +81,7 @@ export interface ChartComponentParams {
     labels: string[]
     datasets: Array<{
       label: string
-      data: number[] | Array<{ x: string | number; y: number }>
+      data: number[] | Array<{ x: string | number; y: number; r?: number }>
       backgroundColor?: string | string[]
       borderColor?: string | string[]
       borderWidth?: number
@@ -101,8 +101,9 @@ export interface ChartComponentParams {
   /**
    * Force renderer type (Sprint 4)
    * - 'native': Use Chart.js directly (requires chart.js peer dependency)
-   * - 'iframe': Use Quickchart.io iframe (default fallback)
-   * - 'auto': Use native if Chart.js is available, otherwise iframe (default)
+   * - 'iframe': Request the external QuickChart renderer (requires host opt-in)
+   * - 'auto': Use native Chart.js when available; otherwise degrade locally
+   *   unless the host explicitly enables the external fallback (default)
    */
   renderer?: 'native' | 'iframe' | 'auto'
   /**
@@ -112,6 +113,7 @@ export interface ChartComponentParams {
   /**
    * Time-series axis configuration (v3.1.0).
    * When set, x-axis labels are parsed as dates.
+   * The host must install and register a compatible Chart.js date adapter.
    */
   timeAxis?: {
     /** Date format for parsing labels (Chart.js adapter format, e.g. 'yyyy-MM-dd') */
@@ -190,6 +192,16 @@ export interface TableComponentParams {
     pageSize: number
     totalRows: number
   }
+  /** Show the accent-insensitive client-side search field (default: true). */
+  searchable?: boolean
+  /** Placeholder displayed in the client-side search field. */
+  searchPlaceholder?: string
+  /** Rows per page in expanded mode (default: 25). Set 0 to disable paging. */
+  pageSize?: number
+  /** Rows per page in chat mode (default: min(10, pageSize)). Set 0 to disable paging. */
+  chatPageSize?: number
+  /** Initial zero-based page for client-side paging. */
+  initialPage?: number
   /**
    * Enable table virtualization for large datasets (Sprint Ultimate U.3)
    * - true: Enable with default options
@@ -1019,7 +1031,11 @@ export interface GraphNode {
   /** Stable node id — referenced by edges. */
   id: string
   label?: string
-  /** Optional grouping/category key (drives default coloring). */
+  type?: string
+  size?: number | [number, number]
+  style?: Record<string, unknown>
+  data?: Record<string, unknown>
+  /** @deprecated Compatibility field outside the canonical graph spec. */
   group?: string
   /** Generic ranking/importance signal (opaque to the lib). */
   weight?: number
@@ -1033,31 +1049,56 @@ export interface GraphEdge {
   /** Must match a `GraphNode.id`. */
   target: string
   label?: string
+  type?: string
   weight?: number
+  style?: Record<string, unknown>
+  data?: Record<string, unknown>
   /** Passthrough G6 edge props (style, data, …). */
   [key: string]: unknown
 }
 
-export type GraphLayout = 'force' | 'radial' | 'grid' | 'dagre' | 'circular' | 'concentric'
+/** Canonical layout names shared with `GraphLayoutNameSchema`. */
+export type GraphLayoutName =
+  | 'force'
+  | 'dagre'
+  | 'mindmap'
+  | 'tree'
+  | 'circular'
+  | 'grid'
+  | 'concentric'
+
+export type GraphLayout =
+  | GraphLayoutName
+  | { type: GraphLayoutName; options?: Record<string, unknown> }
+  /** @deprecated `radial` predates the public spec; retained for source compatibility. */
+  | 'radial'
 
 /**
  * Generic node-link graph component params. Domain-neutral by design — the
  * meaning of `weight`/`group` is decided by the consumer.
  */
 export interface GraphComponentParams {
+  title?: string
   /** Nodes (at least one expected at runtime). */
   nodes: GraphNode[]
   edges?: GraphEdge[]
   layout?: GraphLayout
-  /** Render edges as directed (arrows). */
+  /** @deprecated Accepted for source compatibility but not used by the renderer. */
   directed?: boolean
   /**
    * Rendering hint only — NOT wired; the renderer always uses the G6 canvas
    * default (cf. audit P0). Kept for forward-compat with the spec.
    */
   rendererPref?: 'canvas' | 'svg'
-  height?: number
-  width?: number
+  /** CSS length in the canonical spec; numeric values remain for source compatibility. */
+  height?: string | number
+  /** CSS length in the canonical spec; numeric values remain for source compatibility. */
+  width?: string | number
+  fitView?: boolean
+  enableZoom?: boolean
+  enableDrag?: boolean
+  enableSelect?: boolean
+  tooltip?: boolean
   /** Custom CSS class. */
   className?: string
   /** Passthrough for forward-compat graph options. */

package/src/types/visualization-contracts.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from 'vitest'
+import type {
+  ChartComponentParams,
+  ChartType,
+  GraphComponentParams,
+  GraphLayout,
+  GraphLayoutName,
+  TableComponentParams,
+} from './index'
+
+describe('public visualization contracts', () => {
+  it('types all eight chart variants, point data, and time-axis options', () => {
+    const chartTypes: ChartType[] = [
+      'bar',
+      'line',
+      'pie',
+      'doughnut',
+      'radar',
+      'scatter',
+      'bubble',
+      'polarArea',
+    ]
+    const params: ChartComponentParams = {
+      type: 'bubble',
+      data: {
+        labels: [],
+        datasets: [{ label: 'Points', data: [{ x: '2026-09-14', y: 3, r: 8 }] }],
+      },
+      timeAxis: { unit: 'day', parser: 'yyyy-MM-dd' },
+    }
+
+    expect(chartTypes).toHaveLength(8)
+    expect(params.timeAxis?.unit).toBe('day')
+  })
+
+  it('types the table search and context-aware paging controls', () => {
+    const params: TableComponentParams = {
+      columns: [{ key: 'name', label: 'Name', sortable: true }],
+      rows: [{ name: 'Ada' }],
+      searchable: true,
+      searchPlaceholder: 'Filter records',
+      pageSize: 30,
+      chatPageSize: 10,
+      initialPage: 0,
+    }
+
+    expect(params).toMatchObject({ searchable: true, pageSize: 30, chatPageSize: 10 })
+  })
+
+  it('types the seven canonical graph layouts and object-form options', () => {
+    const canonical: GraphLayoutName[] = [
+      'force',
+      'dagre',
+      'mindmap',
+      'tree',
+      'circular',
+      'grid',
+      'concentric',
+    ]
+    const layout: GraphLayout = { type: 'dagre', options: { rankdir: 'TB' } }
+    const params: GraphComponentParams = { nodes: [{ id: 'root' }], layout }
+
+    expect(canonical).toHaveLength(7)
+    expect(params.layout).toEqual(layout)
+  })
+})

package/src/utils/perf.test.ts

@@ -47,13 +47,13 @@ describe('performance marks (v5.4.0 — B.4)', () => {
   })
 
   it('mark functions are no-ops when performance is undefined (SSR-safe)', () => {
-    const originalPerf = (globalThis as any).performance
-    ;(globalThis as any).performance = undefined
+    const originalPerf = (globalThis as any).performance;
+    (globalThis as any).performance = undefined
     try {
       expect(() => markRenderStart('ssr')).not.toThrow()
       expect(() => markRenderEnd('ssr')).not.toThrow()
     } finally {
-      ;(globalThis as any).performance = originalPerf
+      (globalThis as any).performance = originalPerf
     }
   })
 })