deepline 0.3.228 → 0.3.230

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';
@@ -41,6 +41,8 @@ import {
   runtimeLimitExceededFailure,
 } 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 {
@@ -1893,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(
@@ -2009,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 ?? {};
@@ -2452,7 +2459,11 @@ async function run(
               playName,
               tableNamespace,
               playInput: runtimeInputObject,
-              sheetContract,
+              sheetContract: augmentSheetContractWithDatasetFields({
+                contract: sheetContract,
+                rows: items,
+                columnTypes: mapContext.columnTypes,
+              }),
               rows: items,
               inputOffset: mapContext.inputOffset,
               mode: mapContext.mode,
@@ -2975,6 +2986,13 @@ async function run(
       );
     }
   };
+  const runtimeStats = () => ({
+    ...ctx.getStats(),
+    runtimeWorkCounterSegment: {
+      invocationSeq: workCounterInvocationSeq,
+      segmentId: workCounterSegmentId,
+    },
+  });
   options?.onRuntimeReady?.({
     log: (line) => ctx.logRunnerDiagnostic(line),
     timeoutResult: (runtimeLimitSeconds) => {
@@ -2984,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,
@@ -3002,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({
@@ -3205,7 +3247,7 @@ async function run(
       logs,
       ...(runtimeDiagnostics.length > 0 ? { runtimeDiagnostics } : {}),
       ...(rowOutcomes ? { rowOutcomes } : {}),
-      stats: ctx.getStats(),
+      stats: runtimeStats(),
       steps: ctx.getSteps(),
       checkpoint,
       tableNamespace: resultTableNamespace,
@@ -3257,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,
@@ -3293,7 +3335,7 @@ async function run(
       errors: [failure],
       logs: terminalLogsWithPhaseSummary(ctx),
       ...(rowOutcomes ? { rowOutcomes } : {}),
-      stats: ctx.getStats(),
+      stats: runtimeStats(),
       steps: ctx.getSteps(),
       checkpoint,
       tableNamespace: null,
@@ -3301,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>;