@shipfox/client-workflows 18.0.0 → 19.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/client-workflows",
   "license": "MIT",
-  "version": "18.0.0",
+  "version": "19.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -29,7 +29,7 @@
     "date-fns": "^4.1.0",
     "@shipfox/annotations-dto": "12.3.0",
     "@shipfox/api-definitions-dto": "12.3.0",
-    "@shipfox/api-workflows-dto": "12.5.0",
+    "@shipfox/api-workflows-dto": "12.6.0",
     "@shipfox/client-api": "6.0.1",
     "@shipfox/client-logs": "17.0.0",
     "@shipfox/client-projects": "17.0.0",

package/src/components/job-graph/job-node.test.tsx

@@ -332,7 +332,7 @@ describe('JobNode status indicator', () => {
     expect(screen.getByRole('button', {name: 'deploy-prod, Succeeded'})).toBeInTheDocument();
   });
 
-  test('shows a running lifecycle without a running step as pending', () => {
+  test('shows a running lifecycle without a running step as running', () => {
     const node = makeNode({
       name: 'deploy',
       status: 'pending',
@@ -341,7 +341,7 @@ describe('JobNode status indicator', () => {
 
     renderNode(node);
 
-    expect(screen.getByRole('button', {name: 'deploy, Pending'})).toBeInTheDocument();
+    expect(screen.getByRole('button', {name: 'deploy, Running'})).toBeInTheDocument();
   });
 
   test('shows a pending lifecycle as running while a step is active', () => {

package/src/components/workflow-run-list/job-status-strip.tsx

@@ -3,7 +3,8 @@ import {Code, Text} from '@shipfox/react-ui/typography';
 import {cn} from '@shipfox/react-ui/utils';
 import {getWorkflowStatusVisual} from '#components/workflow-status/status-visuals.js';
 import {WorkflowStatusIcon} from '#components/workflow-status/workflow-status-icon.js';
-import type {JobStatus, WorkflowRunJobSummary, WorkflowRunJobs} from '#core/workflow-run.js';
+import {deriveJobDisplayStatus, type JobDisplayStatus} from '#core/entities/job.js';
+import type {WorkflowRunJobSummary, WorkflowRunJobs} from '#core/workflow-run.js';
 
 /**
  * How many glyphs fit the strip's column before it starts costing the run name width.
@@ -33,16 +34,17 @@ const COMPACT_COUNT_FORMAT = new Intl.NumberFormat('en', {
 
 // Worst-first, so the overflow glyph reports the most alarming thing it is standing in for.
 // A strip that hides a failure behind eight green discs would be worse than no strip at all.
-const STATUS_SEVERITY: Record<JobStatus, number> = {
+const STATUS_SEVERITY: Record<JobDisplayStatus, number> = {
   failed: 5,
   running: 4,
+  listening: 4,
   pending: 3,
   cancelled: 2,
   skipped: 1,
   succeeded: 0,
 };
 
-const NOTABLE_STATUSES: readonly JobStatus[] = ['failed', 'running'];
+const NOTABLE_STATUSES: readonly JobDisplayStatus[] = ['failed', 'running', 'listening'];
 
 export interface JobStatusStripProps {
   jobs: WorkflowRunJobs;
@@ -80,7 +82,7 @@ export function JobStatusStrip({jobs, className}: JobStatusStripProps) {
             {visible.map((job) => (
               <WorkflowStatusIcon
                 key={job.id}
-                status={job.status}
+                status={displayStatus(job)}
                 size={GLYPH_SIZE}
                 // One ripple per running job, on every row, would turn a calm list into a
                 // field of pulses. The run's own glyph already carries the live edge.
@@ -121,7 +123,7 @@ function JobStatusStripTooltip({jobs, summary}: {jobs: WorkflowRunJobs; summary:
   // can be named, but the count of those left over is read off the totals, so a failure past
   // the preview is still accounted for rather than silently missing.
   const named = jobs.preview
-    .filter((job) => NOTABLE_STATUSES.includes(job.status))
+    .filter((job) => NOTABLE_STATUSES.includes(displayStatus(job)))
     .slice(0, MAX_TOOLTIP_JOB_NAMES);
   const notableTotal = NOTABLE_STATUSES.reduce((total, status) => total + countOf(jobs, status), 0);
   const remaining = notableTotal - named.length;
@@ -133,7 +135,7 @@ function JobStatusStripTooltip({jobs, summary}: {jobs: WorkflowRunJobs; summary:
       </Text>
       {named.map((job) => (
         <Code as="span" variant="label" key={job.id} className="block truncate">
-          {getWorkflowStatusVisual(job.status).label.toLowerCase()} · {job.name ?? job.key}
+          {getWorkflowStatusVisual(displayStatus(job)).label.toLowerCase()} · {job.name ?? job.key}
         </Code>
       ))}
       {remaining > 0 ? (
@@ -162,15 +164,16 @@ export function jobStatusSummary(jobs: WorkflowRunJobs): string {
 function worstHiddenStatus(
   jobs: WorkflowRunJobs,
   visible: readonly WorkflowRunJobSummary[],
-): JobStatus | null {
+): JobDisplayStatus | null {
   const hidden = new Map(jobs.statusCounts.map(({status, count}) => [status, count]));
   for (const job of visible) {
-    const remaining = (hidden.get(job.status) ?? 0) - 1;
-    if (remaining > 0) hidden.set(job.status, remaining);
-    else hidden.delete(job.status);
+    const status = displayStatus(job);
+    const remaining = (hidden.get(status) ?? 0) - 1;
+    if (remaining > 0) hidden.set(status, remaining);
+    else hidden.delete(status);
   }
 
-  let worst: JobStatus | null = null;
+  let worst: JobDisplayStatus | null = null;
   for (const [status, count] of hidden) {
     if (count <= 0) continue;
     if (worst === null || STATUS_SEVERITY[status] > STATUS_SEVERITY[worst]) worst = status;
@@ -184,6 +187,16 @@ export function overflowCountLabel(hiddenCount: number): string {
     : COMPACT_COUNT_FORMAT.format(hiddenCount);
 }
 
-function countOf(jobs: WorkflowRunJobs, status: JobStatus): number {
+function countOf(jobs: WorkflowRunJobs, status: JobDisplayStatus): number {
   return jobs.statusCounts.find((entry) => entry.status === status)?.count ?? 0;
 }
+
+function displayStatus(job: WorkflowRunJobSummary): JobDisplayStatus {
+  return deriveJobDisplayStatus({
+    mode: job.mode,
+    status: job.status,
+    listenerStatus: job.listenerStatus,
+    executionStatus: job.executionStatus,
+    jobExecutions: [],
+  });
+}

package/src/components/workflow-run-list/workflow-run-list-view.test.tsx

@@ -307,6 +307,53 @@ describe('WorkflowRunListView', () => {
       ).toBeInTheDocument();
     });
 
+    test('shows an executing one-shot job instead of its pending verdict', async () => {
+      const {jobs} = workflowRunJobsFixture(['pending']);
+      renderListView([
+        run('running', 'deploy-web', 'run-1', {
+          jobs: jobs.map((job) => ({...job, execution_status: 'running'})),
+          job_status_counts: [{status: 'pending', count: 1}],
+          job_display_status_counts: [{status: 'running', count: 1}],
+        }),
+      ]);
+
+      const strip = await screen.findByRole('img', {name: '1 job: 1 running'});
+      expect(within(strip).getByLabelText('Running')).toBeInTheDocument();
+    });
+
+    test('shows an active listener as listening in the job strip', async () => {
+      const {jobs} = workflowRunJobsFixture(['running']);
+      renderListView([
+        run('running', 'event-driven', 'run-1', {
+          jobs: jobs.map((job) => ({
+            ...job,
+            mode: 'listening',
+            listener_status: 'listening',
+            execution_status: null,
+          })),
+          job_status_counts: [{status: 'running', count: 1}],
+          job_display_status_counts: [{status: 'listening', count: 1}],
+        }),
+      ]);
+
+      const strip = await screen.findByRole('img', {name: '1 job: 1 listening'});
+      expect(within(strip).getByLabelText('Listening')).toBeInTheDocument();
+    });
+
+    test('shows a failed execution when the job verdict is still pending', async () => {
+      const {jobs} = workflowRunJobsFixture(['pending']);
+      renderListView([
+        run('running', 'deploy-web', 'run-1', {
+          jobs: jobs.map((job) => ({...job, execution_status: 'failed'})),
+          job_status_counts: [{status: 'pending', count: 1}],
+          job_display_status_counts: [{status: 'failed', count: 1}],
+        }),
+      ]);
+
+      const strip = await screen.findByRole('img', {name: '1 job: 1 failed'});
+      expect(within(strip).getByLabelText('Failed')).toBeInTheDocument();
+    });
+
     // The link's aria-label replaces its contents, so the strip's own label is not spoken
     // when the row is announced as a link. Where a run failed has to survive that.
     test('carries the job breakdown into the row link name', async () => {
@@ -355,6 +402,32 @@ describe('WorkflowRunListView', () => {
       expect(within(strip).getByLabelText('Failed')).toBeInTheDocument();
     });
 
+    test('reports listening jobs in the overflow glyph and tooltip', async () => {
+      const {jobs} = workflowRunJobsFixture(
+        Array.from({length: 16}, () => 'pending') as JobStatusDto[],
+      );
+      renderListView([
+        run('running', 'event-driven', 'run-listener', {
+          jobs: jobs.map((job) => ({
+            ...job,
+            mode: 'listening',
+            listener_status: 'listening',
+            execution_status: null,
+          })),
+          job_status_counts: [{status: 'pending', count: 20}],
+          job_display_status_counts: [{status: 'listening', count: 20}],
+        }),
+      ]);
+
+      const strip = await screen.findByRole('img', {name: '20 jobs: 20 listening'});
+      expect(screen.getByText('+13')).toBeInTheDocument();
+      expect(within(strip).getAllByLabelText('Listening')).toHaveLength(8);
+
+      const user = userEvent.setup();
+      await user.hover(strip);
+      expect(await screen.findByRole('tooltip')).toHaveTextContent('and 14 more');
+    });
+
     // Nothing caps a workflow's job count, so an exact overflow count is unbounded in width
     // and would eventually paint over the duration column beside it.
     test('abbreviates an overflow count too wide to print exactly', async () => {

package/src/components/workflow-run-list/workflow-run-list.stories.tsx

@@ -101,6 +101,12 @@ type Story = StoryObj<typeof meta>;
 
 export const Playground: Story = {};
 
+export const ExecutionStates: Story = {
+  args: {
+    runs: [makeExecutionStateRun(), makeListeningStateRun()],
+  },
+};
+
 /**
  * The row under its one-line threshold, at the 720px a 768px viewport leaves the column.
  *
@@ -229,3 +235,28 @@ function StateExample({label, children}: {label: string; children: ReactNode}) {
     </div>
   );
 }
+
+function makeExecutionStateRun(): WorkflowRunListItem {
+  const fixture = workflowRunJobsFixture(['pending']);
+  return sequencedWorkflowRunListItem('running', 'one-shot-executing', 1, {
+    ...fixture,
+    jobs: fixture.jobs.map((job) => ({...job, execution_status: 'running'})),
+    job_status_counts: [{status: 'pending', count: 1}],
+    job_display_status_counts: [{status: 'running', count: 1}],
+  });
+}
+
+function makeListeningStateRun(): WorkflowRunListItem {
+  const fixture = workflowRunJobsFixture(['pending']);
+  return sequencedWorkflowRunListItem('running', 'event-driven-listener', 3, {
+    ...fixture,
+    jobs: fixture.jobs.map((job) => ({
+      ...job,
+      mode: 'listening',
+      listener_status: 'listening',
+      execution_status: null,
+    })),
+    job_status_counts: [{status: 'pending', count: 1}],
+    job_display_status_counts: [{status: 'listening', count: 1}],
+  });
+}

package/src/core/entities/job-status.test.ts

@@ -42,7 +42,7 @@ describe('deriveJobDisplayStatus', () => {
     const statuses: Array<[JobExecutionStatus, string[], JobDisplayStatus]> = [
       ['pending', [], 'pending'],
       ['pending', ['running'], 'running'],
-      ['running', [], 'pending'],
+      ['running', [], 'running'],
       ['running', ['running'], 'running'],
     ];
 
@@ -91,6 +91,52 @@ describe('deriveJobDisplayStatus', () => {
     ).toBe('listening');
   });
 
+  test.each([
+    ['pending', 'pending'],
+    ['failed', 'failed'],
+    [null, 'pending'],
+  ] as const)('uses list execution evidence for %s', (executionStatus, expected) => {
+    expect(
+      deriveJobDisplayStatus({
+        mode: 'one_shot',
+        status: 'pending',
+        listenerStatus: 'inactive',
+        executionStatus,
+        jobExecutions: [],
+      }),
+    ).toBe(expected);
+  });
+
+  test('does not infer execution from a running verdict without execution evidence', () => {
+    expect(
+      deriveJobDisplayStatus({
+        mode: 'one_shot',
+        status: 'running',
+        listenerStatus: 'inactive',
+        executionStatus: null,
+        jobExecutions: [],
+      }),
+    ).toBe('pending');
+  });
+
+  test('uses the same running execution evidence with and without a step tree', () => {
+    const detailStatus = deriveJobDisplayStatus({
+      mode: 'one_shot',
+      status: 'pending',
+      listenerStatus: 'inactive',
+      jobExecutions: [{status: 'running', steps: [], sequence: 1}] as never,
+    });
+    const listStatus = deriveJobDisplayStatus({
+      mode: 'one_shot',
+      status: 'pending',
+      listenerStatus: 'inactive',
+      executionStatus: 'running',
+      jobExecutions: [],
+    });
+
+    expect(listStatus).toBe(detailStatus);
+  });
+
   test('uses the terminal job status when an active listener has resolved', () => {
     expect(
       deriveJobDisplayStatus({

package/src/core/entities/job.ts

@@ -2,6 +2,7 @@ import {
   deriveJobExecutionDisplayStatus,
   type JobExecution,
   type JobExecutionDisplayDuration,
+  type JobExecutionStatus,
 } from './job-execution.js';
 import type {EvaluationTraceEntry} from './step-attempt.js';
 
@@ -140,12 +141,23 @@ export function isTerminalJobStatus(status: JobStatus): boolean {
 }
 
 export function deriveJobDisplayStatus(
-  job: Pick<Job, 'mode' | 'status' | 'listenerStatus' | 'jobExecutions'>,
+  job: Pick<Job, 'mode' | 'status' | 'listenerStatus' | 'jobExecutions'> & {
+    /** List previews carry the selected execution state without its step tree. */
+    executionStatus?: JobExecutionStatus | null | undefined;
+  },
 ): JobDisplayStatus {
   if (isTerminalJobStatus(job.status)) return job.status;
   if (job.mode === 'listening' && job.listenerStatus === 'listening') return 'listening';
-
-  const execution = defaultJobExecution(job);
+  const execution =
+    job.executionStatus === undefined
+      ? defaultJobExecution(job)
+      : job.executionStatus === null
+        ? undefined
+        : {status: job.executionStatus, steps: []};
+  // A running execution is the shared display rule for both list previews and detail jobs.
+  // The list has no step tree, while the detail path can still use the execution's steps for
+  // other non-running states.
+  if (execution?.status === 'running') return 'running';
   return execution ? deriveJobExecutionDisplayStatus(execution) : 'pending';
 }
 

package/src/core/entities/workflow-run-display.test.ts

@@ -100,6 +100,34 @@ describe('workflowRunListItemDisplay', () => {
     expect(display.status).toBe('running');
     expect(display.duration).toMatchObject({kind: 'run'});
   });
+
+  test('uses execution-derived running counts for the row headline', () => {
+    const run = workflowRunListItem({
+      status: 'running',
+      ...workflowRunJobsFixture(['pending']),
+      job_display_status_counts: [{status: 'running', count: 1}],
+      started_at: ATTEMPT_STARTED_AT,
+    });
+
+    const display = workflowRunListItemDisplay(run);
+
+    expect(display.status).toBe('running');
+    expect(display.duration).toMatchObject({kind: 'run'});
+  });
+
+  test('uses execution-derived listening counts as started work', () => {
+    const run = workflowRunListItem({
+      status: 'running',
+      ...workflowRunJobsFixture(['pending']),
+      job_display_status_counts: [{status: 'listening', count: 1}],
+      started_at: ATTEMPT_STARTED_AT,
+    });
+
+    const display = workflowRunListItemDisplay(run);
+
+    expect(display.status).toBe('running');
+    expect(display.duration).toMatchObject({kind: 'run'});
+  });
 });
 
 describe('workflowRunBlockingJob', () => {

package/src/core/entities/workflow-run.ts

@@ -1,5 +1,16 @@
-import {type Job, type JobStatus, WORKFLOW_JOB_STATUSES} from './job.js';
-import {elapsedTimeFromTimestamps, type JobExecutionDisplayDuration} from './job-execution.js';
+import {
+  type Job,
+  type JobDisplayStatus,
+  type JobMode,
+  type JobStatus,
+  type ListenerStatus,
+  WORKFLOW_JOB_STATUSES,
+} from './job.js';
+import {
+  elapsedTimeFromTimestamps,
+  type JobExecutionDisplayDuration,
+  type JobExecutionStatus,
+} from './job-execution.js';
 import type {WorkflowRunAttempt, WorkflowRunAttemptSummary} from './workflow-run-attempt.js';
 
 export type WorkflowRunStatus = 'pending' | 'running' | 'succeeded' | 'failed' | 'cancelled';
@@ -60,11 +71,14 @@ export interface WorkflowRunJobSummary {
   key: string;
   name: string | null;
   status: JobStatus;
+  mode: JobMode;
+  listenerStatus: ListenerStatus;
+  executionStatus: JobExecutionStatus | null;
   position: number;
 }
 
 export interface WorkflowRunJobStatusCount {
-  status: JobStatus;
+  status: JobDisplayStatus;
   count: number;
 }
 
@@ -209,7 +223,7 @@ export interface WorkflowRunProgress {
   runStatus: WorkflowRunStatus;
   startedAt: string | null;
   finishedAt: string | null;
-  jobStatuses: JobStatus[];
+  jobStatuses: JobDisplayStatus[];
   firstStartedAt?: string | null | undefined;
 }
 

package/src/core/workflow-run.test.ts

@@ -12,6 +12,7 @@ import {
   workflowRunAttemptDto,
   workflowRunDetailDto,
   workflowRunDto,
+  workflowRunJobSummaryDto,
   workflowRunListResponseDto,
   workflowStepAttemptDto,
   workflowStepDto,
@@ -127,6 +128,18 @@ describe('workflow run model mapping', () => {
     });
   });
 
+  test('keeps legacy raw-status counts aligned with preview glyphs', () => {
+    const {job_display_status_counts: _displayCounts, ...legacyDto} = workflowRunDto({
+      jobs: [workflowRunJobSummaryDto({status: 'running', execution_status: null})],
+      job_status_counts: [{status: 'running', count: 1}],
+    });
+
+    const run = toWorkflowRunListItem(legacyDto);
+
+    expect(run.jobs.preview[0]?.executionStatus).toBe('running');
+    expect(run.jobs.statusCounts).toEqual([{status: 'running', count: 1}]);
+  });
+
   test('maps run list pagination fields', () => {
     const dto = workflowRunListResponseDto({
       runs: [

package/src/hooks/api/workflow-run-mapper.ts

@@ -96,7 +96,10 @@ export function toWorkflowRunRecord(dto: WorkflowRunResponseDto): WorkflowRunRec
 }
 
 export function toWorkflowRunListItem(dto: WorkflowRunListItemDto): WorkflowRunListItem {
-  const statusCounts = dto.job_status_counts.map(({status, count}) => ({status, count}));
+  const hasDisplayStatusCounts = dto.job_display_status_counts !== undefined;
+  const statusCounts = (dto.job_display_status_counts ?? dto.job_status_counts).map(
+    ({status, count}) => ({status, count}),
+  );
   return {
     ...toWorkflowRunRecord(dto),
     jobs: {
@@ -105,6 +108,14 @@ export function toWorkflowRunListItem(dto: WorkflowRunListItemDto): WorkflowRunL
         key: job.key,
         name: job.name,
         status: job.status,
+        mode: job.mode ?? 'one_shot',
+        listenerStatus: job.listener_status ?? 'inactive',
+        // The optional display-count field is the rollout capability signal. Pre-display API
+        // responses only carry raw verdict counts, so mirror their non-terminal verdict into
+        // execution evidence to keep each legacy glyph aligned with those fallback counts.
+        executionStatus: hasDisplayStatusCounts
+          ? (job.execution_status ?? null)
+          : legacyExecutionStatus(job.status),
         position: job.position,
       })),
       statusCounts,
@@ -115,6 +126,12 @@ export function toWorkflowRunListItem(dto: WorkflowRunListItemDto): WorkflowRunL
   };
 }
 
+function legacyExecutionStatus(
+  status: WorkflowRunListItemDto['jobs'][number]['status'],
+): 'pending' | 'running' | null {
+  return status === 'pending' || status === 'running' ? status : null;
+}
+
 export function toWorkflowRunListPage(dto: WorkflowRunListResponseDto): WorkflowRunListPage {
   return {
     runs: dto.runs.map(toWorkflowRunListItem),

package/test/fixtures/workflow-run.ts

@@ -81,6 +81,7 @@ export function workflowRunDto(
     finished_at: null,
     jobs: [],
     job_status_counts: [],
+    job_display_status_counts: [],
     ...overrides,
   };
 }
@@ -89,11 +90,15 @@ export function workflowRunJobSummaryDto(
   overrides: Partial<WorkflowRunJobSummaryDto> = {},
 ): WorkflowRunJobSummaryDto {
   jobSummarySequence += 1;
+  const status = overrides.status ?? 'succeeded';
   return {
     id: `${JOB_SUMMARY_ID_PREFIX}${String(jobSummarySequence).padStart(11, '0')}`,
     key: `job-${jobSummarySequence}`,
     name: null,
-    status: 'succeeded',
+    status,
+    mode: 'one_shot',
+    listener_status: 'inactive',
+    execution_status: executionStatusForFixtureStatus(status),
     position: jobSummarySequence - 1,
     ...overrides,
   };
@@ -104,13 +109,25 @@ export function workflowRunJobSummaryDtos(
   count: number,
   statuses: readonly JobStatusDto[] = [],
 ): WorkflowRunJobSummaryDto[] {
-  return Array.from({length: count}, (_, index) =>
-    workflowRunJobSummaryDto({
+  return Array.from({length: count}, (_, index) => {
+    const status = statuses[index];
+    return workflowRunJobSummaryDto({
       key: `job-${index + 1}`,
       position: index,
-      ...(statuses[index] ? {status: statuses[index]} : {}),
-    }),
-  );
+      ...(status
+        ? {
+            status,
+            execution_status: executionStatusForFixtureStatus(status),
+          }
+        : {}),
+    });
+  });
+}
+
+function executionStatusForFixtureStatus(
+  status: JobStatusDto,
+): WorkflowRunJobSummaryDto['execution_status'] {
+  return status === 'pending' || status === 'running' ? status : null;
 }
 
 /**
@@ -122,16 +139,19 @@ export function workflowRunJobSummaryDtos(
  */
 export function workflowRunJobsFixture(
   statuses: readonly JobStatusDto[],
-): Pick<WorkflowRunListItemDto, 'jobs' | 'job_status_counts'> {
+): Pick<WorkflowRunListItemDto, 'jobs' | 'job_status_counts' | 'job_display_status_counts'> {
   const counts = new Map<JobStatusDto, number>();
   for (const status of statuses) counts.set(status, (counts.get(status) ?? 0) + 1);
 
+  const preview = workflowRunJobSummaryDtos(
+    Math.min(statuses.length, WORKFLOW_RUN_JOB_PREVIEW_LIMIT),
+    statuses,
+  );
+
   return {
-    jobs: workflowRunJobSummaryDtos(
-      Math.min(statuses.length, WORKFLOW_RUN_JOB_PREVIEW_LIMIT),
-      statuses,
-    ),
+    jobs: preview,
     job_status_counts: [...counts.entries()].map(([status, count]) => ({status, count})),
+    job_display_status_counts: [...counts.entries()].map(([status, count]) => ({status, count})),
   };
 }
 
@@ -139,7 +159,7 @@ export function workflowRunJobsFixture(
 export function workflowRunJobsOfStatus(
   count: number,
   status: JobStatusDto = 'succeeded',
-): Pick<WorkflowRunListItemDto, 'jobs' | 'job_status_counts'> {
+): Pick<WorkflowRunListItemDto, 'jobs' | 'job_status_counts' | 'job_display_status_counts'> {
   return workflowRunJobsFixture(Array.from({length: count}, () => status));
 }