@tradejs/app 3.1.8-beta.206 → 3.1.8-beta.210

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tradejs/app",
-  "version": "3.1.8-beta.206",
+  "version": "3.1.8-beta.210",
   "description": "Installable Next.js UI for the TradeJS TypeScript framework: dashboards, backtests, charts, and runtime data.",
   "keywords": [
     "tradejs",
@@ -52,11 +52,11 @@
     "@chakra-ui/charts": "3.36.1",
     "@chakra-ui/react": "3.36.1",
     "@emotion/react": "^11.14.0",
-    "@tradejs/core": "^3.1.8-beta.206",
-    "@tradejs/indicators": "^3.1.8-beta.206",
-    "@tradejs/infra": "^3.1.8-beta.206",
-    "@tradejs/node": "^3.1.8-beta.206",
-    "@tradejs/types": "^3.1.8-beta.206",
+    "@tradejs/core": "^3.1.8-beta.210",
+    "@tradejs/indicators": "^3.1.8-beta.210",
+    "@tradejs/infra": "^3.1.8-beta.210",
+    "@tradejs/node": "^3.1.8-beta.210",
+    "@tradejs/types": "^3.1.8-beta.210",
     "@types/bcryptjs": "2.4.6",
     "@types/lodash": "4.17.24",
     "@types/node": "24.13.3",

package/src/app/api/user/runtime-deployments/[deploymentId]/strategies/[strategyName]/control/route.ts

@@ -1,9 +1,10 @@
 import { NextRequest, NextResponse } from 'next/server';
 import {
-  getRuntimeDeployment,
-  saveRuntimeDeployment,
-} from '@tradejs/infra/runtimeDeployments';
-import { recordRuntimeStrategyControlEvent } from '@tradejs/infra/runtimeStrategyReleases';
+  pauseRuntimeStrategy,
+  recordRuntimeStrategyControlEvent,
+  resumeRuntimeStrategy,
+} from '@tradejs/infra/runtimeControls';
+import { getRuntimeDeployment } from '@tradejs/node/runtimeStrategies';
 import type { RuntimeStrategyControlState } from '@tradejs/types';
 import { getCurrentUserName } from '#app/lib/currentUser';
 
@@ -21,7 +22,13 @@ export const PATCH = async (
   }
   const { deploymentId, strategyName: encodedStrategyName } = await params;
   const strategyName = decodeURIComponent(encodedStrategyName);
-  const deployment = await getRuntimeDeployment(userName, deploymentId);
+  const projectRoot =
+    String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+  const deployment = await getRuntimeDeployment({
+    userName,
+    projectRoot,
+    deploymentId,
+  });
   if (!deployment) {
     return NextResponse.json(
       { error: 'Deployment not found' },
@@ -44,7 +51,7 @@ export const PATCH = async (
   );
   if (!reference) {
     return NextResponse.json(
-      { error: 'Pause/resume requires a versioned strategy release' },
+      { error: 'Strategy is not declared in tradejs.config.ts' },
       { status: 400 },
     );
   }
@@ -52,19 +59,35 @@ export const PATCH = async (
   if (previousState === controlState) {
     return NextResponse.json({ deployment, controlState });
   }
-  const updated = await saveRuntimeDeployment(userName, {
-    ...deployment,
-    strategies: deployment.strategies.map((strategy) =>
-      strategy.strategyName === strategyName
-        ? { ...strategy, controlState }
-        : strategy,
-    ),
+  if (
+    controlState === 'active' &&
+    (!deployment.enabled || !reference.enabled)
+  ) {
+    return NextResponse.json(
+      { error: 'Strategy is disabled in tradejs.config.ts' },
+      { status: 409 },
+    );
+  }
+  if (controlState === 'entries_paused') {
+    await pauseRuntimeStrategy({
+      userName,
+      deploymentId,
+      strategyName,
+      updatedBy: userName,
+    });
+  } else {
+    await resumeRuntimeStrategy({ userName, deploymentId, strategyName });
+  }
+  const updated = await getRuntimeDeployment({
+    userName,
+    projectRoot,
+    deploymentId,
   });
   const event = await recordRuntimeStrategyControlEvent({
     userName,
     deploymentId: deployment.id,
     strategyName,
-    releaseVersion: reference.releaseVersion,
+    version: reference.version,
     previousState,
     nextState: controlState,
     createdBy: userName,

package/src/app/api/user/runtime-deployments/route.ts

@@ -1,44 +1,18 @@
-import { NextRequest, NextResponse } from 'next/server';
-import {
-  getRuntimeDeploymentHeartbeat,
-  listRuntimeDeployments,
-  saveRuntimeDeployment,
-} from '@tradejs/infra/runtimeDeployments';
-import { getTradingAccount } from '@tradejs/infra/tradingAccounts';
-import { getRuntimeStrategyRelease } from '@tradejs/infra/runtimeStrategyReleases';
-import type {
-  MarketUniverse,
-  RuntimeDeployment,
-  RuntimeDeploymentStrategy,
-} from '@tradejs/types';
+import { NextResponse } from 'next/server';
+import { getRuntimeDeploymentHeartbeat } from '@tradejs/infra/runtimeHeartbeats';
+import { listRuntimeDeployments } from '@tradejs/node/runtimeStrategies';
 import { getCurrentUserName } from '#app/lib/currentUser';
 
 export const dynamic = 'force-dynamic';
 
-const isRuntimeStrategyReference = (
-  value: unknown,
-): value is RuntimeDeploymentStrategy => {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
-  const record = value as Record<string, unknown>;
-  return (
-    typeof record.strategyName === 'string' &&
-    record.strategyName.trim().length > 0 &&
-    Number.isSafeInteger(record.releaseVersion) &&
-    Number(record.releaseVersion) > 0 &&
-    (record.controlState === 'active' ||
-      record.controlState === 'entries_paused') &&
-    Object.keys(record).every((key) =>
-      ['strategyName', 'releaseVersion', 'controlState'].includes(key),
-    )
-  );
-};
-
 export const GET = async () => {
   const userName = await getCurrentUserName();
   if (!userName) {
     return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
   }
-  const deployments = await listRuntimeDeployments(userName);
+  const projectRoot =
+    String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+  const deployments = await listRuntimeDeployments({ userName, projectRoot });
   const withHeartbeats = await Promise.all(
     deployments.map(async (deployment) => ({
       ...deployment,
@@ -47,90 +21,3 @@ export const GET = async () => {
   );
   return NextResponse.json({ deployments: withHeartbeats });
 };
-
-export const POST = async (request: NextRequest) => {
-  const userName = await getCurrentUserName();
-  if (!userName) {
-    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
-  }
-  try {
-    const body = (await request.json()) as Partial<RuntimeDeployment>;
-    if (
-      !Array.isArray(body.strategies) ||
-      !body.strategies.length ||
-      !body.strategies.every(isRuntimeStrategyReference)
-    ) {
-      return NextResponse.json(
-        { error: 'Invalid runtime strategy reference' },
-        { status: 400 },
-      );
-    }
-    const releases = await Promise.all(
-      body.strategies.map(async (strategy) => {
-        const release = await getRuntimeStrategyRelease(
-          userName,
-          strategy.strategyName,
-          strategy.releaseVersion,
-        );
-        if (!release) {
-          throw new Error(
-            `Release not found: ${strategy.strategyName} v${strategy.releaseVersion}`,
-          );
-        }
-        return release;
-      }),
-    );
-    if (
-      !body.id ||
-      !body.label ||
-      !body.connectorName ||
-      !body.provider ||
-      !body.accountId ||
-      typeof body.enabled !== 'boolean'
-    ) {
-      return NextResponse.json(
-        { error: 'Invalid runtime deployment' },
-        { status: 400 },
-      );
-    }
-    const account = await getTradingAccount(userName, body.accountId);
-    if (
-      !account ||
-      !account.enabled ||
-      account.provider !== body.provider.toLowerCase()
-    ) {
-      return NextResponse.json(
-        { error: 'Deployment trading account is unavailable' },
-        { status: 400 },
-      );
-    }
-    const unsupportedUniverse = releases
-      .map((release) => release.config.UNIVERSE as MarketUniverse)
-      .find((universe) => !account.universes.includes(universe));
-    if (unsupportedUniverse) {
-      return NextResponse.json(
-        {
-          error: `Account ${account.id} does not support ${unsupportedUniverse}`,
-        },
-        { status: 400 },
-      );
-    }
-    const deployment = await saveRuntimeDeployment(userName, {
-      id: body.id,
-      label: body.label,
-      connectorName: body.connectorName,
-      provider: body.provider,
-      accountId: body.accountId,
-      enabled: body.enabled,
-      strategies: body.strategies,
-      assetClasses: body.assetClasses,
-      tickers: body.tickers,
-    });
-    return NextResponse.json({ deployment });
-  } catch (error) {
-    return NextResponse.json(
-      { error: error instanceof Error ? error.message : String(error) },
-      { status: 400 },
-    );
-  }
-};

package/src/app/api/user/trading-accounts/[accountId]/route.ts

@@ -3,7 +3,7 @@ import {
   deleteTradingAccount,
   getTradingAccount,
 } from '@tradejs/infra/tradingAccounts';
-import { listRuntimeDeployments } from '@tradejs/infra/runtimeDeployments';
+import { listRuntimeDeployments } from '@tradejs/node/runtimeStrategies';
 import { getCurrentUserName } from '#app/lib/currentUser';
 
 export const DELETE = async (
@@ -19,9 +19,11 @@ export const DELETE = async (
   if (!account) {
     return NextResponse.json({ error: 'Account not found' }, { status: 404 });
   }
-  const referencedBy = (await listRuntimeDeployments(userName)).filter(
-    (deployment) => deployment.accountId === account.id,
-  );
+  const projectRoot =
+    String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+  const referencedBy = (
+    await listRuntimeDeployments({ userName, projectRoot })
+  ).filter((deployment) => deployment.accountId === account.id);
   if (referencedBy.length) {
     return NextResponse.json(
       {

package/src/app/components/Strategies/RuntimeStrategyCard.tsx

@@ -135,7 +135,7 @@ export const RuntimeStrategyCard = ({
           TF: {strategy.interval}m
         </Badge>
         <Badge colorPalette="gray" variant="outline">
-          release: v{strategy.releaseVersion}
+          version: v{strategy.version}
         </Badge>
         {strategy.accountId ? (
           <Badge colorPalette="purple" variant="outline">
@@ -258,7 +258,6 @@ export const RuntimeStrategyCard = ({
       <RuntimeStrategyChart
         orderLog={strategy.orderLog}
         stat={strategy.stat}
-        evidenceTimeline={strategy.evidenceTimeline}
         startTimestamp={startTimestamp}
         endTimestamp={endTimestamp}
       />

package/src/app/components/Strategies/RuntimeStrategyChart.tsx

@@ -1,6 +1,6 @@
 'use client';
 
-import { useMemo, useState } from 'react';
+import { useMemo } from 'react';
 import { Box, Flex, Text } from '@chakra-ui/react';
 import { Chart, useChart } from '@chakra-ui/charts';
 import {
@@ -13,24 +13,13 @@ import {
   YAxis,
 } from 'recharts';
 import { getFormatted } from '@tradejs/core/backtest';
-import type {
-  SimpleOrderLogData,
-  StrategyEvidenceMarkerType,
-  StrategyEvidenceTimeline,
-  TestStat,
-} from '@tradejs/types';
+import type { SimpleOrderLogData, TestStat } from '@tradejs/types';
 import { formatTimeSeriesTooltipTimestamp } from '#app/lib/timeSeriesChart';
 import { TimeSeriesXAxis } from '#shared/Charts/TimeSeriesXAxis';
-import {
-  filterStrategyEvidenceMarkers,
-  STRATEGY_EVIDENCE_MARKER_PRESENTATION,
-  StrategyEvidencePopover,
-} from './StrategyEvidencePopover';
 
 interface RuntimeStrategyChartProps {
   orderLog: SimpleOrderLogData;
   stat: TestStat;
-  evidenceTimeline: StrategyEvidenceTimeline;
   startTimestamp: number;
   endTimestamp: number;
   height?: string | number;
@@ -39,13 +28,10 @@ interface RuntimeStrategyChartProps {
 export const RuntimeStrategyChart = ({
   orderLog,
   stat,
-  evidenceTimeline,
   startTimestamp,
   endTimestamp,
   height = '350px',
 }: RuntimeStrategyChartProps) => {
-  const [showParity, setShowParity] = useState(true);
-  const [showRecommendations, setShowRecommendations] = useState(true);
   const chartData = useMemo(
     () => ({
       data: orderLog.map(([timestamp, amount]) => ({
@@ -65,31 +51,8 @@ export const RuntimeStrategyChart = ({
   const chart = useChart(chartData as any);
   const { formatted: maxAmount } = getFormatted(stat, 'maxAmount');
   const { formatted: minAmount } = getFormatted(stat, 'minAmount');
-  const visibleEvidenceMarkers = filterStrategyEvidenceMarkers({
-    markers:
-      evidenceTimeline.status === 'verified' ? evidenceTimeline.markers : [],
-    showParity,
-    showRecommendations,
-  });
-  const markerColor = (type: StrategyEvidenceMarkerType) =>
-    chart.color(STRATEGY_EVIDENCE_MARKER_PRESENTATION[type].color);
-  const markerDash = (type: StrategyEvidenceMarkerType) => {
-    if (type === 'L') return '7 4';
-    if (type === 'P' || type === 'R') return '2 5';
-    return '3 5';
-  };
-
   return (
     <Box w="100%" minW="600px" h={height} display="flex" flexDirection="column">
-      <Flex minH="32px" px={2} justify="flex-end" align="center" flexShrink={0}>
-        <StrategyEvidencePopover
-          timeline={evidenceTimeline}
-          showParity={showParity}
-          showRecommendations={showRecommendations}
-          onShowParityChange={setShowParity}
-          onShowRecommendationsChange={setShowRecommendations}
-        />
-      </Flex>
       <Box flex="1" minH={0} pr={2}>
         {orderLog.length ? (
           <ResponsiveContainer width="100%" height="100%">
@@ -126,24 +89,6 @@ export const RuntimeStrategyChart = ({
                     position: 'bottom',
                   }}
                 />
-                {visibleEvidenceMarkers.map((marker, index) => (
-                  <ReferenceLine
-                    key={marker.id}
-                    x={marker.timestamp}
-                    stroke={markerColor(marker.type)}
-                    strokeDasharray={markerDash(marker.type)}
-                    strokeWidth={1.5}
-                    label={{
-                      value: marker.type,
-                      fill: markerColor(marker.type),
-                      fontSize: 10,
-                      fontWeight: 600,
-                      offset: 6,
-                      position:
-                        index % 2 === 0 ? 'insideTopRight' : 'insideTopLeft',
-                    }}
-                  />
-                ))}
                 <TimeSeriesXAxis
                   startTimestamp={startTimestamp}
                   endTimestamp={endTimestamp}

package/src/app/components/Strategies/RuntimeStrategyConfigDrawer.tsx

@@ -30,7 +30,7 @@ export const RuntimeStrategyConfigDrawer = ({
         <Drawer.Content bg="gray.950">
           <Drawer.Header>
             <Drawer.Title>
-              {strategy.strategyName} release v{strategy.releaseVersion}
+              {strategy.strategyName} version v{strategy.version}
             </Drawer.Title>
             <Drawer.CloseTrigger asChild>
               <CloseButton size="sm" />
@@ -38,8 +38,8 @@ export const RuntimeStrategyConfigDrawer = ({
           </Drawer.Header>
           <Drawer.Body display="flex" flexDirection="column" gap={4}>
             <Text color="gray.400">
-              Published releases are immutable. Roll out a new release to change
-              this configuration.
+              This configuration is read-only here. Change it in
+              tradejs.config.ts and deploy a new Project image.
             </Text>
             <Textarea
               value={JSON.stringify(strategy.config, null, 2)}

package/src/app/api/user/runtime-deployments/[deploymentId]/route.ts

@@ -1,25 +0,0 @@
-import { NextResponse } from 'next/server';
-import {
-  deleteRuntimeDeployment,
-  getRuntimeDeployment,
-} from '@tradejs/infra/runtimeDeployments';
-import { getCurrentUserName } from '#app/lib/currentUser';
-
-export const DELETE = async (
-  _request: Request,
-  { params }: { params: Promise<{ deploymentId: string }> },
-) => {
-  const userName = await getCurrentUserName();
-  if (!userName) {
-    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
-  }
-  const { deploymentId } = await params;
-  if (!(await getRuntimeDeployment(userName, deploymentId))) {
-    return NextResponse.json(
-      { error: 'Deployment not found' },
-      { status: 404 },
-    );
-  }
-  await deleteRuntimeDeployment(userName, deploymentId);
-  return NextResponse.json({ deleted: true });
-};

package/src/app/components/Strategies/StrategyEvidencePopover.tsx

@@ -1,261 +0,0 @@
-'use client';
-
-import {
-  Badge,
-  Box,
-  Button,
-  Checkbox,
-  Flex,
-  Popover,
-  Portal,
-  Text,
-} from '@chakra-ui/react';
-import type {
-  StrategyEvidenceMarker,
-  StrategyEvidenceMarkerType,
-  StrategyEvidenceTimeline,
-} from '@tradejs/types';
-import { formatTimeSeriesTooltipTimestamp } from '#app/lib/timeSeriesChart';
-
-export const STRATEGY_EVIDENCE_MARKER_PRESENTATION: Record<
-  StrategyEvidenceMarkerType,
-  { name: string; color: string; optional: boolean }
-> = {
-  G: { name: 'Composition / gate', color: 'purple.400', optional: false },
-  L: { name: 'MAX_LOSS_VALUE', color: 'orange.400', optional: false },
-  E: { name: 'Evidence boundary', color: 'teal.400', optional: false },
-  D: { name: 'Deployment', color: 'blue.400', optional: false },
-  P: { name: 'Runtime parity', color: 'cyan.400', optional: true },
-  R: { name: 'Recommendation', color: 'pink.400', optional: true },
-};
-
-const MARKER_TYPES = Object.keys(
-  STRATEGY_EVIDENCE_MARKER_PRESENTATION,
-) as StrategyEvidenceMarkerType[];
-
-export const filterStrategyEvidenceMarkers = ({
-  markers,
-  showParity,
-  showRecommendations,
-}: {
-  markers: StrategyEvidenceMarker[];
-  showParity: boolean;
-  showRecommendations: boolean;
-}) =>
-  markers.filter(
-    (marker) =>
-      (marker.type !== 'P' || showParity) &&
-      (marker.type !== 'R' || showRecommendations),
-  );
-
-const statusColor = (status: StrategyEvidenceTimeline['status']) => {
-  if (status === 'verified') return 'teal';
-  if (status === 'invalid') return 'red';
-  return 'orange';
-};
-
-const uniqueProvenance = (markers: StrategyEvidenceMarker[]) => {
-  const seen = new Set<string>();
-  return markers.filter((marker) => {
-    const key = `${marker.artifactId}:${marker.artifactSha256}`;
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-};
-
-const FilterCheckbox = ({
-  checked,
-  label,
-  onChange,
-}: {
-  checked: boolean;
-  label: string;
-  onChange: (checked: boolean) => void;
-}) => (
-  <Checkbox.Root
-    size="sm"
-    checked={checked}
-    onCheckedChange={({ checked: nextChecked }) =>
-      onChange(nextChecked === true)
-    }
-  >
-    <Checkbox.HiddenInput />
-    <Checkbox.Control>
-      <Checkbox.Indicator />
-    </Checkbox.Control>
-    <Checkbox.Label>{label}</Checkbox.Label>
-  </Checkbox.Root>
-);
-
-export const StrategyEvidencePopover = ({
-  timeline,
-  showParity,
-  showRecommendations,
-  onShowParityChange,
-  onShowRecommendationsChange,
-}: {
-  timeline: StrategyEvidenceTimeline;
-  showParity: boolean;
-  showRecommendations: boolean;
-  onShowParityChange: (checked: boolean) => void;
-  onShowRecommendationsChange: (checked: boolean) => void;
-}) => {
-  const provenance =
-    timeline.status === 'verified' ? uniqueProvenance(timeline.markers) : [];
-
-  return (
-    <Popover.Root positioning={{ placement: 'bottom-end' }} lazyMount>
-      <Popover.Trigger asChild>
-        <Button
-          size="xs"
-          variant="outline"
-          aria-label={`Evidence: ${timeline.status}`}
-        >
-          Evidence
-          <Badge size="xs" colorPalette={statusColor(timeline.status)}>
-            {timeline.status === 'verified'
-              ? `${timeline.markers.length}`
-              : timeline.status}
-          </Badge>
-        </Button>
-      </Popover.Trigger>
-      <Portal>
-        <Popover.Positioner>
-          <Popover.Content width="min(430px, calc(100vw - 24px))">
-            <Popover.Arrow />
-            <Popover.Body>
-              <Flex direction="column" gap={3}>
-                <Box>
-                  <Text fontWeight="semibold">Immutable evidence</Text>
-                  <Text fontSize="xs" color="gray.500">
-                    {timeline.status === 'verified'
-                      ? timeline.observedFrom == null
-                        ? 'Verified artifact; no observation boundary supplied.'
-                        : `Verified from ${formatTimeSeriesTooltipTimestamp(
-                            timeline.observedFrom,
-                          )}.`
-                      : timeline.status === 'invalid'
-                        ? 'Evidence failed checksum, identity, or structure verification. No markers are rendered.'
-                        : timeline.status === 'not_attached'
-                          ? 'The runtime release is published, but no checksum-verified research artifact is attached yet.'
-                          : 'No checksum-verified evidence artifact is available. No mutable fallback is used.'}
-                  </Text>
-                </Box>
-
-                <Box>
-                  <Text fontSize="xs" fontWeight="semibold" mb={1}>
-                    Legend
-                  </Text>
-                  <Flex wrap="wrap" gapX={3} gapY={1}>
-                    {MARKER_TYPES.map((type) => (
-                      <Flex key={type} align="center" gap={1}>
-                        <Text
-                          color={
-                            STRATEGY_EVIDENCE_MARKER_PRESENTATION[type].color
-                          }
-                          fontWeight="bold"
-                          fontSize="xs"
-                        >
-                          {type}
-                        </Text>
-                        <Text fontSize="xs" color="gray.500">
-                          {STRATEGY_EVIDENCE_MARKER_PRESENTATION[type].name}
-                        </Text>
-                      </Flex>
-                    ))}
-                  </Flex>
-                </Box>
-
-                <Box>
-                  <Text fontSize="xs" fontWeight="semibold" mb={1}>
-                    Optional markers
-                  </Text>
-                  <Flex gap={4}>
-                    <FilterCheckbox
-                      checked={showParity}
-                      label="Parity (P)"
-                      onChange={onShowParityChange}
-                    />
-                    <FilterCheckbox
-                      checked={showRecommendations}
-                      label="Recommendations (R)"
-                      onChange={onShowRecommendationsChange}
-                    />
-                  </Flex>
-                </Box>
-
-                <Box>
-                  <Text fontSize="xs" fontWeight="semibold" mb={1}>
-                    Events and provenance
-                  </Text>
-                  {timeline.status === 'verified' && timeline.markers.length ? (
-                    <Flex
-                      direction="column"
-                      gap={2}
-                      maxH="220px"
-                      overflowY="auto"
-                    >
-                      {timeline.markers.map((marker) => (
-                        <Box key={marker.id}>
-                          <Flex align="baseline" gap={2}>
-                            <Text
-                              color={
-                                STRATEGY_EVIDENCE_MARKER_PRESENTATION[
-                                  marker.type
-                                ].color
-                              }
-                              fontWeight="bold"
-                              fontSize="xs"
-                            >
-                              {marker.type}
-                            </Text>
-                            <Text fontSize="xs" fontWeight="semibold">
-                              {marker.label}
-                            </Text>
-                            <Text fontSize="xs" color="gray.500">
-                              {formatTimeSeriesTooltipTimestamp(
-                                marker.timestamp,
-                              )}
-                            </Text>
-                          </Flex>
-                          <Text fontSize="xs" color="gray.500">
-                            {marker.summary}
-                          </Text>
-                        </Box>
-                      ))}
-                    </Flex>
-                  ) : (
-                    <Text fontSize="xs" color="gray.500">
-                      No verified events in the selected window.
-                    </Text>
-                  )}
-                </Box>
-
-                {provenance.length ? (
-                  <Box>
-                    <Text fontSize="xs" fontWeight="semibold" mb={1}>
-                      Artifact provenance
-                    </Text>
-                    {provenance.map((marker) => (
-                      <Text
-                        key={`${marker.artifactId}:${marker.artifactSha256}`}
-                        fontSize="xs"
-                        color="gray.500"
-                        fontFamily="mono"
-                        title={marker.artifactSha256}
-                      >
-                        {marker.artifactId} ·{' '}
-                        {marker.artifactSha256.slice(0, 12)}
-                      </Text>
-                    ))}
-                  </Box>
-                ) : null}
-              </Flex>
-            </Popover.Body>
-          </Popover.Content>
-        </Popover.Positioner>
-      </Portal>
-    </Popover.Root>
-  );
-};