deepline 0.3.229 → 0.3.231

package/dist/bundling-sources/shared_libs/play-runtime/run-ledger.ts

@@ -122,6 +122,28 @@ export type PlayRunLedgerDatasetSnapshot = {
   updatedAt: number;
 };
 
+/** Fixed-size, attempt-fenced call evidence. Counts are per scheduler attempt. */
+export type PlayRunLedgerWorkCounters = {
+  attempt: number;
+  invocationSeq: number;
+  segmentId: string;
+  logicalCalls: number;
+  providerRequests: number;
+  provider429s: number;
+  final: boolean;
+  completedLogicalCalls: number;
+  completedProviderRequests: number;
+  completedProvider429s: number;
+  completeThroughAttempt: boolean;
+  consistent: boolean;
+};
+
+/** Runner invocation which actually produced the accepted terminal result. */
+export type PlayRunLedgerTerminalWorkCounterSegment = Pick<
+  PlayRunLedgerWorkCounters,
+  'attempt' | 'invocationSeq' | 'segmentId'
+>;
+
 export type PlayRunLedgerSnapshot = {
   runId: string;
   playName?: string | null;
@@ -141,6 +163,10 @@ export type PlayRunLedgerSnapshot = {
   datasetsById: Record<string, PlayRunLedgerDatasetSnapshot>;
   orderedActivityIds: string[];
   activitiesById: Record<string, PlayActivityObservation>;
+  /** Absent for runs started before call accounting was enabled. */
+  workCounters?: PlayRunLedgerWorkCounters;
+  /** Absent on terminals produced before runner invocation evidence existed. */
+  terminalWorkCounterSegment?: PlayRunLedgerTerminalWorkCounterSegment;
   /**
    * Bounded tail of the run's log lines (last {@link LOG_TAIL_LIMIT}).
    * Full retention lives in the Run Log Stream (Convex `playRunLogChunks`);
@@ -214,12 +240,14 @@ export type PlayRunLedgerEvent =
       type: 'run.completed';
       result?: unknown;
       resultSummary?: unknown;
+      terminalWorkCounterSegment?: PlayRunLedgerTerminalWorkCounterSegment;
     })
   | (PlayRunLedgerBaseEvent & {
       type: 'run.failed';
       error?: string | null;
       result?: unknown;
       resultSummary?: unknown;
+      terminalWorkCounterSegment?: PlayRunLedgerTerminalWorkCounterSegment;
     })
   | (PlayRunLedgerBaseEvent & {
       type: 'run.cancelled';
@@ -305,6 +333,16 @@ export type PlayRunLedgerEvent =
   | (PlayRunLedgerBaseEvent & {
       type: 'activity.observed';
       observation: PlayActivityObservation;
+    })
+  | (PlayRunLedgerBaseEvent & {
+      type: 'work.counters';
+      attempt: number;
+      invocationSeq: number;
+      segmentId: string;
+      logicalCalls: number;
+      providerRequests: number;
+      provider429s: number;
+      final: boolean;
     });
 
 /**
@@ -391,6 +429,219 @@ function finiteNumber(value: unknown): number | null {
   return typeof value === 'number' && Number.isFinite(value) ? value : null;
 }
 
+function nonnegativeSafeInteger(value: unknown): value is number {
+  return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+}
+
+function isWorkCounterSegmentId(value: unknown): value is string {
+  return (
+    typeof value === 'string' &&
+    /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
+      value,
+    )
+  );
+}
+
+export function normalizePlayRunLedgerTerminalWorkCounterSegment(
+  value: unknown,
+): PlayRunLedgerTerminalWorkCounterSegment | undefined {
+  if (!isRecord(value)) return undefined;
+  if (
+    !nonnegativeSafeInteger(value.attempt) ||
+    !nonnegativeSafeInteger(value.invocationSeq) ||
+    value.invocationSeq === 0 ||
+    !isWorkCounterSegmentId(value.segmentId)
+  ) {
+    return undefined;
+  }
+  return {
+    attempt: value.attempt,
+    invocationSeq: value.invocationSeq,
+    segmentId: value.segmentId,
+  };
+}
+
+/** Final counts are exact only if the accepted terminal names the final report. */
+export function hasConfirmedPlayRunLedgerWorkCounters(
+  snapshot: PlayRunLedgerSnapshot,
+): boolean {
+  const counters = snapshot.workCounters;
+  const terminal = snapshot.terminalWorkCounterSegment;
+  return Boolean(
+    isTerminalPlayRunLedgerStatus(snapshot.status) &&
+    (snapshot.terminalSource === 'worker' ||
+      snapshot.terminalSource === 'system') &&
+    counters?.final &&
+    counters.completeThroughAttempt &&
+    counters.consistent &&
+    terminal &&
+    counters.attempt === terminal.attempt &&
+    counters.invocationSeq === terminal.invocationSeq &&
+    counters.segmentId === terminal.segmentId &&
+    Number.isSafeInteger(
+      counters.completedLogicalCalls + counters.logicalCalls,
+    ) &&
+    Number.isSafeInteger(
+      counters.completedProviderRequests + counters.providerRequests,
+    ) &&
+    Number.isSafeInteger(
+      counters.completedProvider429s + counters.provider429s,
+    ),
+  );
+}
+
+function normalizeWorkCounters(
+  value: unknown,
+): PlayRunLedgerWorkCounters | undefined {
+  if (!isRecord(value)) return undefined;
+  for (const field of [
+    'attempt',
+    'invocationSeq',
+    'logicalCalls',
+    'providerRequests',
+    'provider429s',
+    'completedLogicalCalls',
+    'completedProviderRequests',
+    'completedProvider429s',
+  ] as const) {
+    if (!nonnegativeSafeInteger(value[field])) return undefined;
+  }
+  if (
+    value.invocationSeq === 0 ||
+    !isWorkCounterSegmentId(value.segmentId) ||
+    typeof value.final !== 'boolean' ||
+    typeof value.completeThroughAttempt !== 'boolean' ||
+    typeof value.consistent !== 'boolean'
+  ) {
+    return undefined;
+  }
+  return {
+    ...value,
+    attempt: value.attempt as number,
+    invocationSeq: value.invocationSeq as number,
+    segmentId: value.segmentId,
+    logicalCalls: value.logicalCalls as number,
+    providerRequests: value.providerRequests as number,
+    provider429s: value.provider429s as number,
+    final: value.final,
+    completedLogicalCalls: value.completedLogicalCalls as number,
+    completedProviderRequests: value.completedProviderRequests as number,
+    completedProvider429s: value.completedProvider429s as number,
+    completeThroughAttempt: value.completeThroughAttempt,
+    consistent: value.consistent,
+  };
+}
+
+function advanceNextWorkCounterSegment(
+  current: PlayRunLedgerWorkCounters,
+  event: Extract<PlayRunLedgerEvent, { type: 'work.counters' }>,
+): PlayRunLedgerWorkCounters {
+  const completedLogicalCalls =
+    current.completedLogicalCalls + current.logicalCalls;
+  const completedProviderRequests =
+    current.completedProviderRequests + current.providerRequests;
+  const completedProvider429s =
+    current.completedProvider429s + current.provider429s;
+  const safe = [
+    completedLogicalCalls,
+    completedProviderRequests,
+    completedProvider429s,
+  ].every(Number.isSafeInteger);
+  const contiguous =
+    event.attempt === current.attempt
+      ? event.invocationSeq === current.invocationSeq + 1
+      : event.attempt === current.attempt + 1 && event.invocationSeq === 1;
+  return {
+    attempt: event.attempt,
+    invocationSeq: event.invocationSeq,
+    segmentId: event.segmentId,
+    logicalCalls: event.logicalCalls,
+    providerRequests: event.providerRequests,
+    provider429s: event.provider429s,
+    final: event.final === true,
+    completedLogicalCalls: Math.min(
+      completedLogicalCalls,
+      Number.MAX_SAFE_INTEGER,
+    ),
+    completedProviderRequests: Math.min(
+      completedProviderRequests,
+      Number.MAX_SAFE_INTEGER,
+    ),
+    completedProvider429s: Math.min(
+      completedProvider429s,
+      Number.MAX_SAFE_INTEGER,
+    ),
+    completeThroughAttempt:
+      current.completeThroughAttempt && current.final && contiguous,
+    consistent:
+      current.consistent && safe && event.segmentId !== current.segmentId,
+  };
+}
+
+function advanceWorkCounters(
+  current: PlayRunLedgerWorkCounters | undefined,
+  event: Extract<PlayRunLedgerEvent, { type: 'work.counters' }>,
+): PlayRunLedgerWorkCounters | undefined {
+  if (
+    !nonnegativeSafeInteger(event.attempt) ||
+    !nonnegativeSafeInteger(event.invocationSeq) ||
+    event.invocationSeq === 0 ||
+    !isWorkCounterSegmentId(event.segmentId) ||
+    !nonnegativeSafeInteger(event.logicalCalls) ||
+    !nonnegativeSafeInteger(event.providerRequests) ||
+    !nonnegativeSafeInteger(event.provider429s)
+  ) {
+    return current;
+  }
+  if (!current) {
+    return {
+      attempt: event.attempt,
+      invocationSeq: event.invocationSeq,
+      segmentId: event.segmentId,
+      logicalCalls: event.logicalCalls,
+      providerRequests: event.providerRequests,
+      provider429s: event.provider429s,
+      final: event.final === true,
+      completedLogicalCalls: 0,
+      completedProviderRequests: 0,
+      completedProvider429s: 0,
+      completeThroughAttempt: event.attempt <= 1 && event.invocationSeq === 1,
+      consistent: true,
+    };
+  }
+  if (event.attempt < current.attempt) return current;
+  if (event.attempt === current.attempt) {
+    if (event.invocationSeq < current.invocationSeq) return current;
+    if (event.invocationSeq > current.invocationSeq)
+      return advanceNextWorkCounterSegment(current, event);
+    const counters = [
+      ['logicalCalls', event.logicalCalls],
+      ['providerRequests', event.providerRequests],
+      ['provider429s', event.provider429s],
+    ] as const;
+    const finalDisagrees = counters.some(
+      ([field, value]) =>
+        (event.final && value < current[field]) ||
+        (current.final && value > current[field]),
+    );
+    return {
+      ...current,
+      logicalCalls: Math.max(current.logicalCalls, event.logicalCalls),
+      providerRequests: Math.max(
+        current.providerRequests,
+        event.providerRequests,
+      ),
+      provider429s: Math.max(current.provider429s, event.provider429s),
+      final: current.final || event.final === true,
+      consistent:
+        current.consistent &&
+        current.segmentId === event.segmentId &&
+        !finalDisagrees,
+    };
+  }
+  return advanceNextWorkCounterSegment(current, event);
+}
+
 function optionalFiniteNumber(value: unknown): number | undefined {
   const normalized = finiteNumber(value);
   return normalized === null ? undefined : normalized;
@@ -679,6 +930,11 @@ export function normalizePlayRunLedgerSnapshot(
   const logTail = Array.isArray(rawTail)
     ? rawTail.filter((line): line is string => typeof line === 'string')
     : [];
+  const workCounters = normalizeWorkCounters(value.workCounters);
+  const terminalWorkCounterSegment =
+    normalizePlayRunLedgerTerminalWorkCounterSegment(
+      value.terminalWorkCounterSegment,
+    );
   return {
     runId: optionalString(value.runId) ?? fallback.runId,
     playName:
@@ -713,6 +969,8 @@ export function normalizePlayRunLedgerSnapshot(
         typeof activityId === 'string' && Boolean(activitiesById[activityId]),
     ),
     activitiesById,
+    ...(workCounters ? { workCounters } : {}),
+    ...(terminalWorkCounterSegment ? { terminalWorkCounterSegment } : {}),
     logTail: logTail.slice(-LOG_TAIL_LIMIT),
     // Snapshots persisted before totalLogCount existed only know the retained
     // tail, so the best lower bound for the cumulative count is the tail size.
@@ -1283,6 +1541,11 @@ export function reducePlayRunLedgerEvent(
     shouldIgnoreNonTerminalAfterStickyTerminal(base);
 
   switch (event.type) {
+    case 'work.counters': {
+      const workCounters = advanceWorkCounters(base.workCounters, event);
+      if (workCounters === base.workCounters) return snapshot;
+      return withTiming({ ...base, workCounters });
+    }
     case 'run.created': {
       if (ignoreNonTerminalAfterStickyTerminal) {
         return withTiming(base);
@@ -1333,14 +1596,24 @@ export function reducePlayRunLedgerEvent(
         waitUntil: null,
         activeActivityId: null,
       });
-    case 'run.completed':
+    case 'run.completed': {
+      const terminalWorkCounterSegment =
+        (event.source === 'worker' || event.source === 'system') &&
+        (!isTerminalPlayRunLedgerStatus(base.status) ||
+          base.terminalSource === 'coordinator')
+          ? normalizePlayRunLedgerTerminalWorkCounterSegment(
+              event.terminalWorkCounterSegment,
+            )
+          : undefined;
       return (
         conflictingTerminalSnapshot(base, event.type, occurredAt, null, {
           allowStaleSameStatusPayloadMerge:
             (base.result === undefined && event.result !== undefined) ||
             canPromoteTerminalResultReference(base.result, event.result) ||
             (base.resultSummary === undefined &&
-              event.resultSummary !== undefined),
+              event.resultSummary !== undefined) ||
+            (base.terminalWorkCounterSegment === undefined &&
+              terminalWorkCounterSegment !== undefined),
         }) ??
         withTiming({
           ...settleRunningStepsOnTerminal(base, 'completed', occurredAt),
@@ -1358,10 +1631,21 @@ export function reducePlayRunLedgerEvent(
             next: event.result,
           }),
           resultSummary: event.resultSummary ?? base.resultSummary,
+          terminalWorkCounterSegment:
+            base.terminalWorkCounterSegment ?? terminalWorkCounterSegment,
           terminalSource: nextTerminalSource(base, event.source),
         })
       );
-    case 'run.failed':
+    }
+    case 'run.failed': {
+      const terminalWorkCounterSegment =
+        (event.source === 'worker' || event.source === 'system') &&
+        (!isTerminalPlayRunLedgerStatus(base.status) ||
+          base.terminalSource === 'coordinator')
+          ? normalizePlayRunLedgerTerminalWorkCounterSegment(
+              event.terminalWorkCounterSegment,
+            )
+          : undefined;
       return (
         retryablePlatformDeployFailureSnapshot(base, event.error) ??
         conflictingTerminalSnapshot(base, event.type, occurredAt, event.error, {
@@ -1370,7 +1654,9 @@ export function reducePlayRunLedgerEvent(
             (base.result === undefined && event.result !== undefined) ||
             (base.resultSummary === undefined &&
               event.resultSummary !== undefined) ||
-            canPromoteTerminalResultReference(base.result, event.result),
+            canPromoteTerminalResultReference(base.result, event.result) ||
+            (base.terminalWorkCounterSegment === undefined &&
+              terminalWorkCounterSegment !== undefined),
         }) ??
         withTiming({
           ...settleRunningStepsOnTerminal(base, 'failed', occurredAt),
@@ -1391,9 +1677,12 @@ export function reducePlayRunLedgerEvent(
             next: event.result,
           }),
           resultSummary: event.resultSummary ?? base.resultSummary,
+          terminalWorkCounterSegment:
+            base.terminalWorkCounterSegment ?? terminalWorkCounterSegment,
           terminalSource: nextTerminalSource(base, event.source),
         })
       );
+    }
     case 'run.cancelled':
       return (
         conflictingTerminalSnapshot(base, event.type, occurredAt, event.error, {

package/dist/bundling-sources/shared_libs/play-runtime/run-snapshot-stream.ts

@@ -1,6 +1,7 @@
 import { resolveTimingWindow } from './live-events';
 import {
   LOG_TAIL_LIMIT,
+  hasConfirmedPlayRunLedgerWorkCounters,
   normalizePlayRunLedgerSnapshot,
   summarizeRunRowOutcomes,
   type PlayRunLedgerSnapshot,
@@ -110,6 +111,13 @@ export type PlayRunLiveSnapshot = {
    * without row outcomes.
    */
   rowOutcomes?: PlayRunRowOutcomeSummary;
+  /** Observed run-wide call attempts. Absent for runs without counter evidence. */
+  calls?: {
+    logicalCalls: number;
+    providerRequests: number;
+    provider429s: number;
+    confirmed: boolean;
+  };
 };
 
 export function normalizePlayRunLiveStatus(value: unknown): PlayRunLiveStatus {
@@ -236,6 +244,21 @@ function buildSnapshotFromLedger(
       (terminalRowOutcomes.supersededRows ?? 0) > 0)
       ? terminalRowOutcomes
       : null;
+  const workCounters = snapshot.workCounters;
+  const calls = workCounters
+    ? {
+        logicalCalls:
+          workCounters.completedLogicalCalls + workCounters.logicalCalls,
+        providerRequests:
+          workCounters.completedProviderRequests +
+          workCounters.providerRequests,
+        provider429s:
+          workCounters.completedProvider429s + workCounters.provider429s,
+        confirmed:
+          isTerminalPlayRunLiveStatus(liveStatus) &&
+          hasConfirmedPlayRunLedgerWorkCounters(snapshot),
+      }
+    : null;
   return {
     runId: snapshot.runId,
     status: liveStatus,
@@ -268,6 +291,12 @@ function buildSnapshotFromLedger(
     nodeStates,
     activeNodeId: snapshot.activeStepId ?? null,
     ...(rowOutcomes ? { rowOutcomes } : {}),
+    ...(calls &&
+    Object.values(calls).every(
+      (value) => typeof value === 'boolean' || Number.isSafeInteger(value),
+    )
+      ? { calls }
+      : {}),
   };
 }
 

package/dist/bundling-sources/shared_libs/play-runtime/runner-app/index.ts

@@ -2,7 +2,7 @@ import { appendFileSync, createReadStream, writeFileSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { dirname, isAbsolute, resolve } from 'node:path';
 import { createRequire } from 'node:module';
-import { createHash } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { formatWithOptions } from 'node:util';
 import { compileFunction } from 'node:vm';
 import { gunzipSync } from 'node:zlib';
@@ -42,6 +42,7 @@ import {
 } from '../run-failure';
 import { createPlayContext } from '../context';
 import { augmentSheetContractWithDatasetFields } from '../../play-data-plane/sheet-contract';
+import { nextWorkCounterInvocationSeq } from '../runtime-work-counters';
 import type { RuntimeApiResponseMeta } from '../app-runtime-api';
 import { onMemoryPressure } from '../memory-pressure-signal';
 import {
@@ -1894,6 +1895,16 @@ async function run(
   options?: ExecutePlayRunnerOptions,
 ): Promise<PlayRunnerResult> {
   const runStartedAt = Date.now();
+  const runnerRunAttempt =
+    typeof config.context.runAttempt === 'number' &&
+    Number.isFinite(config.context.runAttempt)
+      ? Math.max(0, Math.floor(config.context.runAttempt))
+      : 0;
+  const workCounterInvocationSeq = nextWorkCounterInvocationSeq(
+    config.checkpoint,
+    runnerRunAttempt,
+  );
+  const workCounterSegmentId = randomUUID();
   const persistenceSignal =
     options?.signal ??
     AbortSignal.timeout(
@@ -2010,11 +2021,6 @@ async function run(
     runId: string;
     tableNamespace: string;
   }) => `${input.playName}\u0000${input.runId}\u0000${input.tableNamespace}`;
-  const runnerRunAttempt =
-    typeof config.context.runAttempt === 'number' &&
-    Number.isFinite(config.context.runAttempt)
-      ? Math.max(0, Math.floor(config.context.runAttempt))
-      : 0;
   const cachePolicy = playRunnerContextCachePolicy(config.context);
   const rateStateBackend = createRateStateBackendForConfig(config);
   const runtimeInput = config.input ?? {};
@@ -2980,6 +2986,13 @@ async function run(
       );
     }
   };
+  const runtimeStats = () => ({
+    ...ctx.getStats(),
+    runtimeWorkCounterSegment: {
+      invocationSeq: workCounterInvocationSeq,
+      segmentId: workCounterSegmentId,
+    },
+  });
   options?.onRuntimeReady?.({
     log: (line) => ctx.logRunnerDiagnostic(line),
     timeoutResult: (runtimeLimitSeconds) => {
@@ -2989,7 +3002,7 @@ async function run(
         error: runtimeLimitExceededCause(runtimeLimitSeconds),
         errors: [runtimeLimitExceededFailure(runtimeLimitSeconds)],
         logs: terminalLogsWithPhaseSummary(ctx),
-        stats: ctx.getStats(),
+        stats: runtimeStats(),
         steps: ctx.getSteps(),
         tableNamespace: null,
         totalRows,
@@ -3007,6 +3020,30 @@ async function run(
         }
       : runtimeInput;
 
+  // Sample scalar counters, not the potentially large resource snapshot. The
+  // reporter coalesces transport updates; this timer emits no event if no
+  // counter changed and cannot hold the runner process open.
+  let lastWorkCounterKey: string | null = null;
+  const emitWorkCounters = () => {
+    const counters = ctx.getRuntimeWorkCounters();
+    const key = `${counters.logicalCalls}:${counters.providerRequests}:${counters.provider429s}`;
+    if (key === lastWorkCounterKey) return;
+    lastWorkCounterKey = key;
+    emitRunnerEvent(
+      {
+        type: 'work_counters',
+        attempt: runnerRunAttempt,
+        invocationSeq: workCounterInvocationSeq,
+        segmentId: workCounterSegmentId,
+        ...counters,
+      },
+      options,
+    );
+  };
+  emitWorkCounters();
+  const workCounterTimer = setInterval(emitWorkCounters, 1_500);
+  workCounterTimer.unref();
+
   try {
     emitWorkerLog('Play started', options);
     const rawResult = await executeRuntimePlayCode({
@@ -3210,7 +3247,7 @@ async function run(
       logs,
       ...(runtimeDiagnostics.length > 0 ? { runtimeDiagnostics } : {}),
       ...(rowOutcomes ? { rowOutcomes } : {}),
-      stats: ctx.getStats(),
+      stats: runtimeStats(),
       steps: ctx.getSteps(),
       checkpoint,
       tableNamespace: resultTableNamespace,
@@ -3262,7 +3299,7 @@ async function run(
         status: 'suspended',
         suspension: error.suspension,
         logs: terminalLogsWithPhaseSummary(ctx),
-        stats: ctx.getStats(),
+        stats: runtimeStats(),
         steps: ctx.getSteps(),
         checkpoint: ctx.getCheckpoint(),
         tableNamespace: null,
@@ -3298,7 +3335,7 @@ async function run(
       errors: [failure],
       logs: terminalLogsWithPhaseSummary(ctx),
       ...(rowOutcomes ? { rowOutcomes } : {}),
-      stats: ctx.getStats(),
+      stats: runtimeStats(),
       steps: ctx.getSteps(),
       checkpoint,
       tableNamespace: null,
@@ -3306,6 +3343,9 @@ async function run(
       inserted,
       skipped,
     };
+  } finally {
+    clearInterval(workCounterTimer);
+    emitWorkCounters();
   }
 }
 

package/dist/bundling-sources/shared_libs/play-runtime/runner-app/progress-sidecar.ts

@@ -24,6 +24,7 @@ function shouldEmitProgressSidecarLog(line: string): boolean {
 export function shouldEmitProgressSidecarEvent(
   event: PlayRunnerEvent,
 ): boolean {
+  if (event.type === 'work_counters') return true;
   if (event.type === 'execution_event') {
     return event.event.type !== 'map.row.updated';
   }

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/backends/local-process.ts

@@ -509,6 +509,10 @@ export const localProcessPlayRunnerBackend: PlayRunnerBackend = {
                     }
                     if (event.type === 'execution_event') {
                       callbacks?.onExecutionEvent?.(event.event);
+                      return;
+                    }
+                    if (event.type === 'work_counters') {
+                      callbacks?.onWorkCounters?.(event);
                     }
                   },
                 },

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/types.ts

@@ -5,6 +5,7 @@ import type {
 } from '../ctx-types';
 import type {
   PlayRunnerExecutionConfig,
+  PlayRunnerEvent,
   PlayRunnerLogEvent,
   PlayRunnerResult,
 } from '../protocol';
@@ -155,6 +156,9 @@ export interface PlayRunnerCallbacks {
   onCheckpoint?: (checkpoint: PlayCheckpoint) => void;
   onRowUpdate?: (update: PlayRowUpdate) => void;
   onExecutionEvent?: (event: PlayExecutionEvent) => void;
+  onWorkCounters?: (
+    event: Extract<PlayRunnerEvent, { type: 'work_counters' }>,
+  ) => void;
   onRuntimeResourceAcquired?: (
     resource: PlayRunnerRuntimeResource,
   ) => void | Promise<void>;