@shipfox/client-workflows 13.0.0 → 14.0.0

package/src/pages/workflow-run-detail-page.tsx

@@ -2,7 +2,13 @@ import {useNavigate} from '@tanstack/react-router';
 import {useCallback} from 'react';
 import {WorkflowRunView} from '#components/workflow-run-view/index.js';
 import type {WorkflowRunSelectionInput} from '#core/workflow-run-url-state.js';
-import {type WorkflowRunsSearch, workflowRunSearchParams} from '#routes/inputs.js';
+import {
+  validateWorkflowRunsSearch,
+  type WorkflowRunsSearch,
+  type WorkflowRunTab,
+  workflowRunSearchParams,
+  workflowRunTab,
+} from '#routes/inputs.js';
 
 interface WorkflowRunDetailPageProps {
   projectId: string;
@@ -24,14 +30,33 @@ export function WorkflowRunDetailPage({
   const onSelectionChange = useCallback(
     (nextSelection: WorkflowRunSelectionInput) => {
       navigate({
-        search: workflowRunSearchParams(search, nextSelection) as never,
+        search: ((previous: Record<string, unknown>) => {
+          const current = validateWorkflowRunsSearch(previous);
+          return workflowRunSearchParams(current, nextSelection);
+        }) as never,
+        replace: true,
       });
     },
-    [navigate, search],
+    [navigate],
+  );
+  const onTabChange = useCallback(
+    (nextTab: WorkflowRunTab) => {
+      navigate({
+        search: ((previous: Record<string, unknown>) => {
+          const current = validateWorkflowRunsSearch(previous);
+          const nextSearch = workflowRunSearchParams({...current, tab: nextTab}, current);
+          return nextTab === 'summary' &&
+            (current.jobId || current.jobExecutionId || current.stepId || current.stepAttemptId)
+            ? {...nextSearch, tab: nextTab}
+            : nextSearch;
+        }) as never,
+      });
+    },
+    [navigate],
   );
 
   return (
-    <div className="flex min-h-0 flex-1 overflow-hidden bg-background-neutral-base">
+    <div className="flex min-h-0 flex-1 overflow-hidden bg-background-neutral-background">
       <WorkflowRunView
         projectId={projectId}
         workspaceSlug={workspaceSlug}
@@ -39,6 +64,8 @@ export function WorkflowRunDetailPage({
         workflowRunId={workflowRunId}
         selection={selection}
         onSelectionChange={onSelectionChange}
+        tab={workflowRunTab(search)}
+        onTabChange={onTabChange}
       />
     </div>
   );

package/src/pages/workflow-run-pages.test.tsx

@@ -40,6 +40,10 @@ const INTEGRATION_TESTS_RE = /integration-tests/u;
 const BUILD_IMAGE_RE = /build-image/u;
 const STATUS_FILTER_RE = /^Status\b.*filter$/u;
 const EXECUTION_ONE_MENU_ITEM = /Execution #1: deploy review #1/u;
+const JOBS_TAB_NAME = /^Jobs/u;
+const BUILD_JOB_BUTTON_NAME = 'build, Succeeded';
+const DEPLOY_JOB_BUTTON_NAME = 'deploy, Running';
+const LIVE_DEPLOY_JOB_BUTTON_NAME = /^deploy, Running, running /u;
 const RUN_DETAIL_PATH_RE = /^\/workflows\/runs\/([^/]+)$/u;
 const RUN_OVERRIDES = {
   id: RUN_ID,
@@ -171,25 +175,191 @@ describe('WorkflowRunPages', () => {
   test('renders the detail route without mounting the run list', async () => {
     configureApiClient({fetchImpl: createRunDetailFetch()});
 
-    renderRunPath();
+    renderRunPath('?tab=jobs');
 
-    expect(await screen.findByRole('button', {name: 'deploy, Running'})).toBeInTheDocument();
+    expect(await screen.findByRole('button', {name: DEPLOY_JOB_BUTTON_NAME})).toBeInTheDocument();
+    expect(screen.getByRole('link', {name: 'Runs'})).toHaveAttribute(
+      'href',
+      `/w/${PROJECT_TEST_WSLUG}/p/project/runs`,
+    );
     expect(screen.queryByLabelText('Workflow runs')).not.toBeInTheDocument();
   });
 
+  test('back to runs preserves list filters and drops run detail state', async () => {
+    configureApiClient({fetchImpl: createRunDetailFetch()});
+
+    renderRunPath(`?search=deploy-web&status=running&tab=jobs&job=${DEPLOY_JOB_ID}`);
+
+    expect(await screen.findByRole('link', {name: 'Runs'})).toHaveAttribute(
+      'href',
+      `/w/${PROJECT_TEST_WSLUG}/p/project/runs?search=deploy-web&status=running`,
+    );
+  });
+
+  test('defaults the detail route to the Summary tab', async () => {
+    configureApiClient({fetchImpl: createRunDetailFetch()});
+
+    const {router} = renderRunPath();
+
+    expect(await screen.findByRole('region', {name: 'deploy-web'})).toBeInTheDocument();
+    const summaryTab = screen.getByRole('tab', {name: 'Summary'});
+    expect(summaryTab).toHaveAttribute('aria-selected', 'true');
+    expect(summaryTab).toHaveAttribute('aria-controls', screen.getByRole('tabpanel').id);
+    expect(screen.queryByRole('list', {name: 'Run jobs'})).not.toBeInTheDocument();
+    expect(currentSearch(router).tab).toBeUndefined();
+  });
+
+  test('opens legacy selection-only detail URLs on the Jobs tab', async () => {
+    configureApiClient({fetchImpl: createRunDetailFetch()});
+
+    renderRunPath(`?job=${DEPLOY_JOB_ID}`);
+
+    expect(await screen.findByRole('list', {name: 'Run jobs'})).toBeInTheDocument();
+    expect(screen.getByRole('tab', {name: JOBS_TAB_NAME})).toHaveAttribute('aria-selected', 'true');
+  });
+
+  test('opens a legacy job execution URL with its owning job selected', async () => {
+    configureApiClient({
+      fetchImpl: createRunDetailFetch({details: {[RUN_ID]: retryRunDetailDto()}}),
+    });
+
+    renderRunPath(`?jobExecution=${DEPLOY_EXECUTION_TWO_ID}`);
+
+    expect(await screen.findByRole('region', {name: 'deploy review #2'})).toBeInTheDocument();
+  });
+
+  test('uses the derived execution status in a live job duration label', async () => {
+    configureApiClient({
+      fetchImpl: createRunDetailFetch({
+        details: {
+          [RUN_ID]: defaultRunDetailDto({
+            jobs: [
+              workflowJobDto({
+                id: DEPLOY_JOB_ID,
+                run_attempt_id: RUN_ID,
+                name: 'deploy',
+                status: 'running',
+                job_executions: [
+                  workflowJobExecutionDto({
+                    job_id: DEPLOY_JOB_ID,
+                    status: 'pending',
+                    started_at: '2026-08-04T00:00:00.000Z',
+                    steps: [workflowStepDto({status: 'running'})],
+                  }),
+                ],
+              }),
+            ],
+          }),
+        },
+      }),
+    });
+
+    renderRunPath(`?tab=jobs&job=${DEPLOY_JOB_ID}`);
+
+    expect(
+      await screen.findByRole('button', {name: LIVE_DEPLOY_JOB_BUTTON_NAME}),
+    ).toBeInTheDocument();
+  });
+
+  test('pushes tab changes and restores them with browser history', async () => {
+    const user = userEvent.setup();
+    configureApiClient({fetchImpl: createRunDetailFetch()});
+
+    const {router} = renderRunPath();
+    const initialHistoryLength = router.history.length;
+
+    await user.click(await screen.findByRole('tab', {name: JOBS_TAB_NAME}));
+
+    await waitFor(() => expect(currentSearch(router).tab).toBe('jobs'));
+    expect(router.history.length).toBe(initialHistoryLength + 1);
+    expect(screen.getByRole('tab', {name: JOBS_TAB_NAME})).toHaveAttribute('aria-selected', 'true');
+    expect(screen.getByRole('list', {name: 'Run jobs'})).toBeInTheDocument();
+
+    await user.click(screen.getByRole('tab', {name: 'Summary'}));
+
+    await waitFor(() => expect(currentSearch(router).tab).toBeUndefined());
+    expect(router.history.length).toBe(initialHistoryLength + 2);
+
+    await act(() => {
+      router.history.back();
+    });
+    await waitFor(() => expect(currentSearch(router).tab).toBe('jobs'));
+    expect(screen.getByRole('list', {name: 'Run jobs'})).toBeInTheDocument();
+  });
+
+  test('opens the Jobs tab and selects a job from the Summary graph', async () => {
+    const user = userEvent.setup();
+    configureApiClient({fetchImpl: createRunDetailFetch()});
+
+    const {router} = renderRunPath();
+    const initialHistoryLength = router.history.length;
+
+    await user.click(await screen.findByRole('button', {name: 'deploy, Running'}));
+
+    await waitFor(() => {
+      expect(currentSearch(router)).toMatchObject({tab: 'jobs', job: DEPLOY_JOB_ID});
+    });
+    expect(router.history.length).toBe(initialHistoryLength + 1);
+    expect(screen.getByRole('button', {name: 'deploy, Running'})).toHaveAttribute(
+      'aria-expanded',
+      'true',
+    );
+    expect(screen.getByRole('button', {name: 'deploy, Running'})).toHaveAttribute(
+      'aria-controls',
+      `job-card-${DEPLOY_JOB_ID}`,
+    );
+    expect(screen.getByRole('button', {name: BUILD_JOB_BUTTON_NAME})).not.toHaveAttribute(
+      'aria-controls',
+    );
+  });
+
+  test('preserves an explicit Summary tab with a selected job', async () => {
+    const user = userEvent.setup();
+    configureApiClient({fetchImpl: createRunDetailFetch()});
+
+    const {router} = renderRunPath(`?tab=jobs&job=${DEPLOY_JOB_ID}`);
+
+    await screen.findByRole('button', {name: DEPLOY_JOB_BUTTON_NAME});
+    await user.click(screen.getByRole('tab', {name: 'Summary'}));
+
+    await waitFor(() => {
+      expect(currentSearch(router)).toMatchObject({tab: 'summary', job: DEPLOY_JOB_ID});
+    });
+    expect(screen.getByRole('tab', {name: 'Summary'})).toHaveAttribute('aria-selected', 'true');
+    expect(screen.queryByRole('list', {name: 'Run jobs'})).not.toBeInTheDocument();
+  });
+
+  test('keeps Summary active while keyboard navigation moves graph focus', async () => {
+    const user = userEvent.setup();
+    configureApiClient({fetchImpl: createRunDetailFetch()});
+
+    const {router} = renderRunPath();
+    const build = await screen.findByRole('button', {name: BUILD_JOB_BUTTON_NAME});
+    const deploy = screen.getByRole('button', {name: DEPLOY_JOB_BUTTON_NAME});
+
+    build.focus();
+    await user.keyboard('{ArrowRight}');
+
+    expect(deploy).toHaveFocus();
+    expect(deploy).toHaveAttribute('aria-pressed', 'true');
+    expect(screen.getByRole('tab', {name: 'Summary'})).toHaveAttribute('aria-selected', 'true');
+    expect(screen.queryByRole('list', {name: 'Run jobs'})).not.toBeInTheDocument();
+    expect(currentSearch(router).job).toBeUndefined();
+  });
+
   test('restores a deep-linked job and exact attempt after data loads', async () => {
     configureApiClient({fetchImpl: createRunDetailFetch()});
 
     renderRunPath(
-      `?job=${BUILD_JOB_ID}&step=${DEPLOY_STEP_ID}&stepAttempt=${DEPLOY_ATTEMPT_TWO_ID}`,
+      `?tab=jobs&job=${BUILD_JOB_ID}&step=${DEPLOY_STEP_ID}&stepAttempt=${DEPLOY_ATTEMPT_TWO_ID}`,
     );
 
-    const deployJob = await screen.findByRole('button', {name: 'deploy, Running'});
+    const deployJob = await screen.findByRole('button', {name: DEPLOY_JOB_BUTTON_NAME});
     const deployAttempt = await screen.findByRole('button', {
       name: 'deploy, Running, attempt 2',
     });
 
-    expect(deployJob).toHaveAttribute('aria-pressed', 'true');
+    expect(deployJob).toHaveAttribute('aria-expanded', 'true');
     expect(deployAttempt).toHaveAttribute('aria-expanded', 'true');
     expect(await screen.findByText('attempt two log')).toBeInTheDocument();
   });
@@ -198,14 +368,17 @@ describe('WorkflowRunPages', () => {
     const user = userEvent.setup();
     configureApiClient({fetchImpl: createRunDetailFetch()});
     const {router} = renderRunPath(
-      `?step=${DEPLOY_STEP_ID}&stepAttempt=${DEPLOY_ATTEMPT_TWO_ID}&runAttempt=1`,
+      `?tab=jobs&step=${DEPLOY_STEP_ID}&stepAttempt=${DEPLOY_ATTEMPT_TWO_ID}&runAttempt=1`,
     );
+    const initialHistoryLength = router.history.length;
 
-    await user.click(await screen.findByRole('button', {name: 'build, Succeeded'}));
+    await user.click(await screen.findByRole('button', {name: BUILD_JOB_BUTTON_NAME}));
 
     await waitFor(() => {
       expect(currentSearch(router)).toMatchObject({job: BUILD_JOB_ID});
     });
+    expect(currentSearch(router).tab).toBe('jobs');
+    expect(router.history.length).toBe(initialHistoryLength);
     expect(currentSearch(router).step).toBeUndefined();
     expect(currentSearch(router).stepAttempt).toBeUndefined();
     expect(screen.getByRole('button', {name: 'checkout, Succeeded, attempt 1'})).toHaveAttribute(
@@ -217,7 +390,7 @@ describe('WorkflowRunPages', () => {
   test('selecting an attempt writes job, step, and attempt search state', async () => {
     const user = userEvent.setup();
     configureApiClient({fetchImpl: createRunDetailFetch()});
-    const {router} = renderRunPath(`?job=${DEPLOY_JOB_ID}`);
+    const {router} = renderRunPath(`?tab=jobs&job=${DEPLOY_JOB_ID}`);
 
     await user.click(await screen.findByRole('button', {name: 'deploy, Running, attempt 2'}));
 
@@ -235,7 +408,7 @@ describe('WorkflowRunPages', () => {
     configureApiClient({
       fetchImpl: createRunDetailFetch({details: {[RUN_ID]: retryRunDetailDto()}}),
     });
-    const {router} = renderRunPath(`?job=${DEPLOY_JOB_ID}`);
+    const {router} = renderRunPath(`?tab=jobs&job=${DEPLOY_JOB_ID}`);
 
     await user.click(
       await screen.findByRole('button', {
@@ -273,7 +446,9 @@ describe('WorkflowRunPages', () => {
   test('collapsing an attempt removes step and attempt while preserving job', async () => {
     const user = userEvent.setup();
     configureApiClient({fetchImpl: createRunDetailFetch()});
-    const {router} = renderRunPath(`?step=${DEPLOY_STEP_ID}&stepAttempt=${DEPLOY_ATTEMPT_TWO_ID}`);
+    const {router} = renderRunPath(
+      `?tab=jobs&step=${DEPLOY_STEP_ID}&stepAttempt=${DEPLOY_ATTEMPT_TWO_ID}`,
+    );
 
     const deployAttempt = await screen.findByRole('button', {
       name: 'deploy, Running, attempt 2',
@@ -288,41 +463,6 @@ describe('WorkflowRunPages', () => {
     expect(deployAttempt).toHaveAttribute('aria-expanded', 'false');
   });
 
-  test('back and forward navigation restores prior selections', async () => {
-    const user = userEvent.setup();
-    configureApiClient({fetchImpl: createRunDetailFetch()});
-    const {router} = renderRunPath(`?job=${DEPLOY_JOB_ID}`);
-
-    await user.click(await screen.findByRole('button', {name: 'deploy, Running, attempt 2'}));
-    await waitFor(() => {
-      expect(currentSearch(router).stepAttempt).toBe(DEPLOY_ATTEMPT_TWO_ID);
-    });
-
-    await act(() => {
-      router.history.back();
-    });
-    await waitFor(() => {
-      expect(currentSearch(router)).toMatchObject({job: DEPLOY_JOB_ID});
-    });
-    expect(currentSearch(router).step).toBeUndefined();
-    expect(currentSearch(router).stepAttempt).toBeUndefined();
-    expect(screen.getByRole('button', {name: 'deploy, Running, attempt 2'})).toHaveAttribute(
-      'aria-expanded',
-      'false',
-    );
-
-    await act(() => {
-      router.history.forward();
-    });
-    await waitFor(() => {
-      expect(currentSearch(router).stepAttempt).toBe(DEPLOY_ATTEMPT_TWO_ID);
-    });
-    expect(screen.getByRole('button', {name: 'deploy, Running, attempt 2'})).toHaveAttribute(
-      'aria-expanded',
-      'true',
-    );
-  });
-
   test('run list links navigate to detail and back restores list filters', async () => {
     const user = userEvent.setup();
     configureApiClient({

package/src/routes/inputs.test.ts

@@ -6,7 +6,9 @@ import {
   validateWorkflowRunsSearch,
   type WorkflowRunsSearch,
   workflowRouteParams,
+  workflowRunListSearchParams,
   workflowRunSearchParams,
+  workflowRunTab,
 } from './inputs.js';
 
 /** Everything a filter change writes, then reads back, exactly as the router would. */
@@ -21,6 +23,8 @@ describe('validateWorkflowRunsSearch', () => {
       validateWorkflowRunsSearch({
         search: ['unexpected'],
         status: 'unknown',
+        tab: 'unknown',
+        severity: 'critical',
         after: 'yesterday',
         before: '2026-13-01',
       }),
@@ -65,6 +69,28 @@ describe('validateWorkflowRunsSearch', () => {
       jobId: 'job-1',
     });
   });
+
+  test('accepts known tabs and annotation severities while dropping unknown values', () => {
+    expect(
+      validateWorkflowRunsSearch({tab: 'annotations', annotation: 'run-1', severity: 'error'}),
+    ).toEqual({tab: 'annotations', annotation: 'run-1', severity: 'error'});
+    expect(validateWorkflowRunsSearch({tab: 'unknown', severity: 'critical'})).toEqual({});
+    expect(workflowRunTab({})).toBe('summary');
+    expect(workflowRunTab({tab: 'source'})).toBe('source');
+  });
+
+  test.each([
+    ['job', {jobId: 'job-1'}],
+    ['job execution', {jobExecutionId: 'execution-1'}],
+    ['step', {stepId: 'step-1'}],
+    ['step attempt', {stepAttemptId: 'attempt-1'}],
+  ])('defaults a legacy %s selection URL to Jobs', (_selection, search) => {
+    expect(workflowRunTab(search)).toBe('jobs');
+  });
+
+  test('keeps an explicit Summary tab ahead of legacy selection inference', () => {
+    expect(workflowRunTab({tab: 'summary', jobId: 'job-1'})).toBe('summary');
+  });
 });
 
 describe('the run list URL contract', () => {
@@ -88,6 +114,9 @@ describe('the run list URL contract', () => {
       event: ['push'],
       after: '2026-05-01',
       before: '2026-05-31',
+      tab: 'annotations',
+      annotation: 'annotation-1',
+      severity: 'warning',
     };
 
     expect(roundTrip(search)).toEqual(search);
@@ -119,6 +148,24 @@ describe('the run list URL contract', () => {
     expect(stringifyAppSearch(workflowRunSearchParams({}, {}))).toBe('');
   });
 
+  test('omits the default Summary tab from the URL', () => {
+    expect(stringifyAppSearch(workflowRunSearchParams({tab: 'summary'}, {}))).toBe('');
+    expect(stringifyAppSearch(workflowRunSearchParams({tab: 'jobs'}, {}))).toBe('?tab=jobs');
+  });
+
+  test('serializes only list filters for the detail back link', () => {
+    expect(
+      workflowRunListSearchParams({
+        search: 'deploy',
+        status: ['running'],
+        tab: 'jobs',
+        annotation: 'annotation-1',
+        severity: 'error',
+        jobId: 'job-1',
+      }),
+    ).toEqual({search: 'deploy', status: ['running']});
+  });
+
   test('has no page or cursor parameter to carry', () => {
     const query = stringifyAppSearch(workflowRunSearchParams({search: 'deploy'}, {}));
 

package/src/routes/inputs.ts

@@ -8,6 +8,14 @@ export const WORKFLOW_RUN_LIST_STATUSES = ['succeeded', 'failed', 'running', 'ca
 
 export type WorkflowRunListStatus = (typeof WORKFLOW_RUN_LIST_STATUSES)[number];
 
+export const WORKFLOW_RUN_TABS = ['summary', 'jobs', 'annotations', 'source'] as const;
+
+export type WorkflowRunTab = (typeof WORKFLOW_RUN_TABS)[number];
+
+export const WORKFLOW_RUN_ANNOTATION_SEVERITIES = ['error', 'warning', 'info', 'success'] as const;
+
+export type WorkflowRunAnnotationSeverity = (typeof WORKFLOW_RUN_ANNOTATION_SEVERITIES)[number];
+
 export interface WorkflowRunsSearch extends WorkflowRunSelectionInput {
   search?: string;
   status?: WorkflowRunListStatus[];
@@ -18,9 +26,14 @@ export interface WorkflowRunsSearch extends WorkflowRunSelectionInput {
   after?: string;
   /** Inclusive upper bound on the run's local calendar date, `YYYY-MM-DD`. */
   before?: string;
+  tab?: WorkflowRunTab;
+  annotation?: string;
+  severity?: WorkflowRunAnnotationSeverity;
 }
 
 const STATUS_VALUES = new Set<string>(WORKFLOW_RUN_LIST_STATUSES);
+const TAB_VALUES = new Set<string>(WORKFLOW_RUN_TABS);
+const ANNOTATION_SEVERITY_VALUES = new Set<string>(WORKFLOW_RUN_ANNOTATION_SEVERITIES);
 const CALENDAR_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/u;
 
 /**
@@ -39,6 +52,14 @@ export function validateWorkflowRunsSearch(input: Record<string, unknown>): Work
   const after = calendarDate(input.after);
   const before = calendarDate(input.before);
   const runAttempt = positiveInteger(input.runAttempt);
+  const tabValue = string(input.tab);
+  const tab = tabValue && TAB_VALUES.has(tabValue) ? (tabValue as WorkflowRunTab) : undefined;
+  const annotation = string(input.annotation);
+  const severityValue = string(input.severity);
+  const severity =
+    severityValue && ANNOTATION_SEVERITY_VALUES.has(severityValue)
+      ? (severityValue as WorkflowRunAnnotationSeverity)
+      : undefined;
 
   return {
     ...(search ? {search} : {}),
@@ -48,6 +69,9 @@ export function validateWorkflowRunsSearch(input: Record<string, unknown>): Work
     ...(event.length > 0 ? {event} : {}),
     ...(after ? {after} : {}),
     ...(before ? {before} : {}),
+    ...(tab ? {tab} : {}),
+    ...(annotation ? {annotation} : {}),
+    ...(severity ? {severity} : {}),
     ...(string(input.job) ? {jobId: string(input.job)} : {}),
     ...(string(input.jobExecution) ? {jobExecutionId: string(input.jobExecution)} : {}),
     ...(string(input.step) ? {stepId: string(input.step)} : {}),
@@ -74,6 +98,9 @@ export function workflowRunSearchParams(
     ...(search.event?.length ? {event: search.event} : {}),
     ...(search.after ? {after: search.after} : {}),
     ...(search.before ? {before: search.before} : {}),
+    ...(search.tab && search.tab !== 'summary' ? {tab: search.tab} : {}),
+    ...(search.annotation ? {annotation: search.annotation} : {}),
+    ...(search.severity ? {severity: search.severity} : {}),
     ...(selection.jobId ? {job: selection.jobId} : {}),
     ...(selection.jobExecutionId ? {jobExecution: selection.jobExecutionId} : {}),
     ...(selection.stepId ? {step: selection.stepId} : {}),
@@ -82,6 +109,24 @@ export function workflowRunSearchParams(
   };
 }
 
+/**
+ * Resolves the detail surface for a URL. Explicit tabs win; legacy selection-only URLs belong
+ * to Jobs so their selected detail remains visible instead of silently landing on Summary.
+ */
+export function workflowRunTab(
+  search: Pick<WorkflowRunsSearch, 'tab' | 'jobId' | 'jobExecutionId' | 'stepId' | 'stepAttemptId'>,
+): WorkflowRunTab {
+  if (search.tab) return search.tab;
+  if (search.jobId || search.jobExecutionId || search.stepId || search.stepAttemptId) return 'jobs';
+  return 'summary';
+}
+
+/** Serializes only list filters when leaving a run detail page for the run list. */
+export function workflowRunListSearchParams(search: WorkflowRunsSearch) {
+  const {tab: _tab, annotation: _annotation, severity: _severity, ...listSearch} = search;
+  return workflowRunSearchParams(listSearch, {});
+}
+
 /**
  * A filter change. Each member is explicitly optional-or-undefined so that "present and
  * undefined" (clear this filter) stays distinguishable from "absent" (leave it alone) under

package/src/storybook-config.test.ts

@@ -0,0 +1,27 @@
+import {describe, expect, it} from '@shipfox/vitest/vi';
+import {withWorkspaceSource} from '../.storybook/workspace-source';
+
+describe('client-workflows Storybook Vite configuration', () => {
+  it('keeps workspace-source active for client and SSR package resolution', () => {
+    const config = withWorkspaceSource({
+      resolve: {conditions: ['browser']},
+      ssr: {resolve: {conditions: ['node']}},
+    });
+
+    expect(config.resolve?.conditions).toEqual(['browser', 'workspace-source']);
+    expect(config.ssr?.resolve?.conditions).toEqual(['node', 'workspace-source']);
+    expect(config.plugins?.map((plugin) => plugin && 'name' in plugin && plugin.name)).toContain(
+      'shipfox:workspace-source-resolver',
+    );
+  });
+
+  it('does not duplicate an existing workspace-source condition', () => {
+    const config = withWorkspaceSource({
+      resolve: {conditions: ['browser', 'workspace-source']},
+      ssr: {resolve: {conditions: ['node', 'workspace-source']}},
+    });
+
+    expect(config.resolve?.conditions).toEqual(['browser', 'workspace-source']);
+    expect(config.ssr?.resolve?.conditions).toEqual(['node', 'workspace-source']);
+  });
+});