deepline 0.3.128 → 0.3.129

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/postgres-progress.ts

@@ -19,12 +19,18 @@ import {
 } from '../app-runtime-api';
 import type { PlayVisualNodeProgressMap } from '../worker-api-types';
 import type { PlayExecutionEvent } from '../ctx-types';
+import type { PlayActivityObservation } from '../activity-observation';
 import type {
   PlayRunnerLogEvent,
   PlayRunnerResult,
 } from '../protocol';
 import type { PlaySchedulerSubmitInput } from '../scheduler-backend';
 import type { DocflowObservationRecord } from '../docflow-observation';
+import {
+  buildPlayRunLedgerEventsFromStatusPatch,
+  createEmptyPlayRunLedgerSnapshot,
+  type PlayRunLedgerEvent,
+} from '../run-ledger';
 import {
   getTopLevelPipelineSubsteps,
   type PlayStaticPipeline,
@@ -248,7 +254,16 @@ function shouldPublishTerminalResultLog(
   mode: PostgresSchedulerDurableLogMode,
   line: string,
 ): boolean {
-  return mode !== 'direct_worker' || CTX_LOG_TIMESTAMP_PREFIX_RE.test(line);
+  // Direct workers keep host lifecycle noise out of the customer Run Log
+  // Stream. The resource summary is one bounded, machine-readable terminal
+  // diagnostic rather than a host log, though: the fixture harness needs it
+  // after the runner has gone away and the normal terminal result is no longer
+  // available through the status projection.
+  return (
+    mode !== 'direct_worker' ||
+    CTX_LOG_TIMESTAMP_PREFIX_RE.test(line) ||
+    line.startsWith('[runtime.phase_summary] ')
+  );
 }
 
 type TerminalLogReplayPayload = NonNullable<
@@ -323,14 +338,34 @@ export function createPostgresSchedulerProgressReporter(input: {
   durableLogMode?: PostgresSchedulerDurableLogMode;
   producerAttempt?: number;
   isCurrentAttempt?: () => boolean | Promise<boolean>;
+  /**
+   * The caller already read the durable attempt fence for THIS request and it
+   * was current. The first projection flush then reuses that read instead of
+   * paying a second identical round trip. A reporter lives for exactly one
+   * request, and the credit is consumed by the first flush, so a later flush —
+   * and every other request — re-reads the fence.
+   */
+  attemptAlreadyVerified?: boolean;
   /** Durable log position before this reporter's first event. Push runners own
    * this cursor so successive batches may land on different gateway Machines. */
   initialLiveLogTotalCount?: number;
+  /** Override the app-runtime transport when a caller needs to capture the
+   * folded terminal patch for a durable scheduler outbox instead of posting
+   * it synchronously. */
+  publishStatusUpdate?: (update: RuntimeStatusUpdate) => Promise<void>;
 }): PostgresSchedulerProgressReporter {
   const launch = input.launch;
   const durableLogMode = input.durableLogMode ?? 'progress_reporter';
   const producerAttempt = input.producerAttempt;
-  const isCurrentAttempt = input.isCurrentAttempt ?? (() => true);
+  const readAttemptFence = input.isCurrentAttempt ?? (() => true);
+  let verifiedAttemptCredit = input.attemptAlreadyVerified === true;
+  const isCurrentAttempt = async (): Promise<boolean> => {
+    if (verifiedAttemptCredit) {
+      verifiedAttemptCredit = false;
+      return true;
+    }
+    return await readAttemptFence();
+  };
   const orderedNodes = buildOrderedNodeList(launch.contractSnapshot);
   const mapNodeLookup = buildMapNodeLookup(launch.contractSnapshot);
   const runtimeApi = {
@@ -338,6 +373,10 @@ export function createPostgresSchedulerProgressReporter(input: {
     executorToken: launch.executorToken,
     vercelProtectionBypassToken: launch.vercelProtectionBypassToken ?? null,
   };
+  const publishStatusUpdate =
+    input.publishStatusUpdate ??
+    ((update: RuntimeStatusUpdate) =>
+      updateRunStatusViaAppRuntime(runtimeApi, update));
 
   let liveNodeProgress: PlayVisualNodeProgressMap = {};
   let liveNodeProgressDirty = false;
@@ -427,7 +466,7 @@ export function createPostgresSchedulerProgressReporter(input: {
 
           try {
             if (await isCurrentAttempt()) {
-              await updateRunStatusViaAppRuntime(runtimeApi, {
+              await publishStatusUpdate({
                 playId: launch.runId,
                 status: request.status,
                 liveNodeProgress: nextProgress,
@@ -1246,10 +1285,102 @@ export const createDirectWorkerProgressReporter = (input: {
   launch: PlaySchedulerSubmitInput;
   producerAttempt?: number;
   isCurrentAttempt?: () => boolean | Promise<boolean>;
+  /** See `createPostgresSchedulerProgressReporter`: one request, one credit. */
+  attemptAlreadyVerified?: boolean;
   initialLiveLogTotalCount?: number;
+  publishStatusUpdate?: (update: RuntimeStatusUpdate) => Promise<void>;
 }) =>
   createPostgresSchedulerProgressReporter({
     ...input,
     durableLogMode: 'direct_worker',
   });
 export type DirectWorkerProgressReporter = PostgresSchedulerProgressReporter;
+
+/**
+ * Fold a detached runner's final progress without crossing the app-runtime
+ * network boundary. The returned events are stored in the same Postgres
+ * terminal outbox row as `run.completed`, so the projector can append the
+ * final step/log/activity facts and the terminal fact in one ordered Convex
+ * mutation. This is the completed-run fast path; failed/suspended runs retain
+ * the compatibility projection until their parked worker resumes.
+ */
+export async function collectGatewayRunnerTerminalProgressLedgerEvents(input: {
+  launch: PlaySchedulerSubmitInput;
+  attempt: number;
+  result: PlayRunnerResult;
+  events: unknown[];
+  liveLogOffset: number;
+}): Promise<PlayRunLedgerEvent[]> {
+  const captured: { update?: RuntimeStatusUpdate } = {};
+  const reporter = createDirectWorkerProgressReporter({
+    launch: input.launch,
+    producerAttempt: input.attempt,
+    initialLiveLogTotalCount: input.liveLogOffset,
+    isCurrentAttempt: () => true,
+    attemptAlreadyVerified: true,
+    publishStatusUpdate: async (update) => {
+      captured.update = update;
+    },
+  });
+  for (const event of input.events) reporter.onRunnerEvent(event);
+  await reporter.finalize(input.result, {
+    status: 'running',
+    required: true,
+    skipTerminalLogReplay: true,
+    terminalLogProducerAttempt: input.attempt,
+  });
+  const finalUpdate = captured.update;
+  if (!finalUpdate) return [];
+
+  const liveLogs = finalUpdate.liveLogs ?? [];
+  const liveLogTotalCount =
+    finalUpdate.liveLogTotalCount ?? liveLogs.length + input.liveLogOffset;
+  const progressEvents = buildPlayRunLedgerEventsFromStatusPatch({
+    patch: {
+      runId: input.launch.runId,
+      status: 'running',
+      lastCheckpointAt: finalUpdate.lastCheckpointAt,
+      liveNodeProgress: finalUpdate.liveNodeProgress,
+      liveLogs,
+      liveLogsChannelOffset: Math.max(0, liveLogTotalCount - liveLogs.length),
+      liveLogsProducerAttempt:
+        finalUpdate.liveLogProducerAttempt ?? input.attempt,
+    },
+    previousSnapshot: createEmptyPlayRunLedgerSnapshot({
+      runId: input.launch.runId,
+      status: 'queued',
+    }),
+    source: 'worker',
+  });
+  const datasetEvents: PlayRunLedgerEvent[] = (
+    finalUpdate.datasetLifecycleEvents ?? []
+  ).map((event) => ({
+    type: 'dataset.lifecycle',
+    runId: input.launch.runId,
+    source: 'worker',
+    occurredAt: event.at,
+    datasetId: event.datasetId,
+    path: event.path,
+    tableNamespace: event.tableNamespace,
+    phase: event.phase,
+    ...(event.persistedRows === undefined
+      ? {}
+      : { persistedRows: event.persistedRows }),
+    ...(event.succeededRows === undefined
+      ? {}
+      : { succeededRows: event.succeededRows }),
+    ...(event.failedRows === undefined ? {} : { failedRows: event.failedRows }),
+    ...(event.complete === undefined ? {} : { complete: event.complete }),
+    ...(event.bornFrom === undefined ? {} : { bornFrom: event.bornFrom }),
+  }));
+  const activityEvents: PlayRunLedgerEvent[] = (
+    finalUpdate.activityObservations ?? []
+  ).map((observation: PlayActivityObservation) => ({
+    type: 'activity.observed',
+    runId: input.launch.runId,
+    source: 'worker',
+    occurredAt: observation.observedAt,
+    observation,
+  }));
+  return [...progressEvents, ...datasetEvents, ...activityEvents];
+}