deepline 0.3.290 → 0.3.291

package/dist/bundling-sources/shared_libs/play-runtime/log-context.ts

@@ -5,6 +5,42 @@
 export type PlayLogContextValue = string | number | boolean;
 export type PlayLogContext = Readonly<Record<string, PlayLogContextValue>>;
 
+/** Producer-owned facts for one line, separate from authored context. */
+export type PlayLogMetadata = {
+  level: 'debug' | 'info' | 'warn' | 'error';
+  occurredAt: number;
+  stepId?: string;
+};
+
+export function normalizePlayLogMetadata(
+  value: unknown,
+): PlayLogMetadata | null {
+  if (value === undefined || value === null) return null;
+  if (typeof value !== 'object' || Array.isArray(value)) {
+    throw new TypeError('Run log metadata must be an object.');
+  }
+  const entry = value as Record<string, unknown>;
+  if (
+    !['debug', 'info', 'warn', 'error'].includes(String(entry.level)) ||
+    typeof entry.occurredAt !== 'number' ||
+    !Number.isSafeInteger(entry.occurredAt) ||
+    entry.occurredAt <= 0 ||
+    (entry.stepId !== undefined &&
+      (typeof entry.stepId !== 'string' ||
+        !entry.stepId.trim() ||
+        entry.stepId.length > 256))
+  ) {
+    throw new TypeError(
+      'Run log metadata requires a severity, timestamp and optional step ID.',
+    );
+  }
+  return {
+    level: entry.level as PlayLogMetadata['level'],
+    occurredAt: entry.occurredAt,
+    ...(typeof entry.stepId === 'string' ? { stepId: entry.stepId } : {}),
+  };
+}
+
 export const PLAY_LOG_CONTEXT_LIMITS = {
   fields: 8,
   keyBytes: 64,

package/dist/bundling-sources/shared_libs/play-runtime/log-provenance.ts

@@ -341,7 +341,8 @@ export function classifyLegacyLogLine(line: string): LogProvenance {
 
   // Scheduler / sandbox / worker internals.
   if (
-    /^\[perf\] runtime (?:map|state)\b/i.test(message) ||
+    /^\[perf\]/i.test(message) ||
+    /^\[runtime\.(?:phase_summary|logs|log_transport)\]/i.test(message) ||
     /\[worker\] picked up run\b/.test(message) ||
     /\[worker\] heartbeat\b/.test(message) ||
     /\[worker\] progress completedRows=\d+ totalRows=\d+ rowUpdates=\d+/.test(

package/dist/bundling-sources/shared_libs/play-runtime/protocol.ts

@@ -14,7 +14,7 @@ import type {
 import type { PlayExecutionSuspension } from './suspension';
 import type { PlayStaticPipeline } from '../plays/static-pipeline';
 import type { PlayLiveEventSource } from './live-events';
-import type { PlayLogContext } from './log-context';
+import type { PlayLogContext, PlayLogMetadata } from './log-context';
 import type { PreloadedRuntimeDbSession } from './db-session';
 import type { PacingRule } from './governor/rate-state-backend';
 import type { GovernanceSnapshot } from './governor/governor';
@@ -326,6 +326,7 @@ export type PlayRunnerLogEvent = {
   entryId?: string;
   /** Search-only context; omitted before the compatible Convex projection. */
   context?: PlayLogContext;
+  metadata?: PlayLogMetadata;
 };
 
 export type PlayRunnerEvent =
@@ -418,6 +419,7 @@ export type PlayRunnerResult =
       logIds?: string[];
       /** Search-only context aligned to logs; omitted when every entry is null. */
       logContexts?: Array<PlayLogContext | null>;
+      logMetadata?: Array<PlayLogMetadata | null>;
       stats: Record<string, unknown>;
       steps: PlayStep[];
       checkpoint: PlayCheckpoint;
@@ -434,6 +436,7 @@ export type PlayRunnerResult =
       logIds?: string[];
       /** Search-only context aligned to logs; omitted when every entry is null. */
       logContexts?: Array<PlayLogContext | null>;
+      logMetadata?: Array<PlayLogMetadata | null>;
       stats: Record<string, unknown>;
       steps: PlayStep[];
       checkpoint: PlayCheckpoint;
@@ -451,6 +454,7 @@ export type PlayRunnerResult =
       logIds?: string[];
       /** Search-only context aligned to logs; omitted when every entry is null. */
       logContexts?: Array<PlayLogContext | null>;
+      logMetadata?: Array<PlayLogMetadata | null>;
       stats: Record<string, unknown>;
       steps: PlayStep[];
       checkpoint?: PlayCheckpoint | null;

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

@@ -1,7 +1,6 @@
 import { normalizeRunLogIds } from './run-log-buffer';
 import { RUN_EVENT_KIND } from './run-event-catalog';
 import type { PlayRunLedgerIngressEvent } from './run-ledger';
-import type { PlayLogContext } from './log-context';
 import type { RunLedgerProjectionChunk } from './run-ledger-projection-contract';
 
 const APP_RUNTIME_LOG_EVENT_MAX_JSON_BYTES = 128 * 1024;
@@ -30,25 +29,27 @@ function splitRunEventForAppRuntime(
     : [];
   if (eventType !== RUN_EVENT_KIND.logAppended || lines.length === 0)
     return [event];
-  const payloadOwnsLineContexts =
-    payload !== null && Object.hasOwn(payload, 'lineContexts');
-  const eventOwnsLineContexts = Object.hasOwn(event, 'lineContexts');
-  if (payloadOwnsLineContexts && eventOwnsLineContexts) {
-    throw new TypeError('Run log contexts must have one event owner.');
-  }
-  const rawLineContexts = payloadOwnsLineContexts
-    ? payload?.lineContexts
-    : event.lineContexts;
-  const hasLineContexts = payloadOwnsLineContexts || eventOwnsLineContexts;
-  if (
-    hasLineContexts &&
-    (!Array.isArray(rawLineContexts) || rawLineContexts.length !== lines.length)
-  ) {
-    throw new TypeError('Run log contexts must align with their lines.');
-  }
-  const lineContexts = hasLineContexts
-    ? (rawLineContexts as Array<PlayLogContext | null>)
-    : null;
+  const alignedFields = ['lineContexts', 'lineMetadata'] as const;
+  const aligned = alignedFields.map((key) => {
+    const label = key === 'lineContexts' ? 'contexts' : 'metadata';
+    const inPayload = payload !== null && Object.hasOwn(payload, key);
+    const inEvent = Object.hasOwn(event, key);
+    if (inPayload && inEvent)
+      throw new TypeError(`Run log ${label} must have one event owner.`);
+    const value = inPayload ? payload?.[key] : event[key];
+    if (
+      (inPayload || inEvent) &&
+      (!Array.isArray(value) || value.length !== lines.length)
+    ) {
+      throw new TypeError(`Run log ${label} must align with their lines.`);
+    }
+    return {
+      key,
+      inPayload,
+      inEvent,
+      value: Array.isArray(value) ? value : undefined,
+    };
+  });
   const payloadOwnsLineIds =
     payload !== null && Object.hasOwn(payload, 'lineIds');
   if (payloadOwnsLineIds && Object.hasOwn(event, 'lineIds'))
@@ -67,6 +68,7 @@ function splitRunEventForAppRuntime(
   const {
     lines: _outerLines,
     lineContexts: _outerLineContexts,
+    lineMetadata: _outerLineMetadata,
     lineIds: _outerLineIds,
     ...eventWithoutOuterLines
   } = event;
@@ -75,18 +77,20 @@ function splitRunEventForAppRuntime(
     const start = index;
     let bytes = 2;
     while (index < lines.length) {
-      const lineBytes = appRuntimeTextEncoder.encode(
-        JSON.stringify(lines[index]!),
-      ).length;
-      const metadataBytes =
-        (lineContexts
-          ? appRuntimeTextEncoder.encode(JSON.stringify(lineContexts[index]))
-              .length + 1
-          : 0) +
-        (lineIds
-          ? appRuntimeTextEncoder.encode(JSON.stringify(lineIds[index]))
-              .length + 1
-          : 0);
+      const lineBytes =
+        appRuntimeTextEncoder.encode(JSON.stringify(lines[index]!)).length +
+        aligned.reduce(
+          (total, field) =>
+            total +
+            (field.value
+              ? appRuntimeTextEncoder.encode(JSON.stringify(field.value[index]))
+                  .length + 1
+              : 0),
+          0,
+        );
+      const metadataBytes = lineIds
+        ? appRuntimeTextEncoder.encode(JSON.stringify(lineIds[index])).length + 1
+        : 0;
       if (
         index > start &&
         bytes + lineBytes + metadataBytes + 1 >
@@ -98,15 +102,22 @@ function splitRunEventForAppRuntime(
       index += 1;
     }
     const batchLines = lines.slice(start, index);
-    const batchLineContexts = lineContexts?.slice(start, index);
     const batchLineIds = lineIds?.slice(start, index);
+    const eventFields = Object.fromEntries(
+      aligned
+        .filter((field) => field.inEvent)
+        .map((field) => [field.key, field.value!.slice(start, index)]),
+    );
+    const payloadFields = Object.fromEntries(
+      aligned
+        .filter((field) => field.inPayload)
+        .map((field) => [field.key, field.value!.slice(start, index)]),
+    );
     split.push(
       payload
         ? {
             ...eventWithoutOuterLines,
-            ...(eventOwnsLineContexts && batchLineContexts
-              ? { lineContexts: batchLineContexts }
-              : {}),
+            ...eventFields,
             ...(payloadOwnsLines ? {} : { lines: batchLines }),
             ...(!payloadOwnsLineIds && batchLineIds
               ? { lineIds: batchLineIds }
@@ -114,16 +125,18 @@ function splitRunEventForAppRuntime(
             payload: {
               ...Object.fromEntries(
                 Object.entries(payload).filter(
-                  ([key]) => key !== 'lineContexts' && key !== 'lineIds',
+                  ([key]) =>
+                    key !== 'lineIds' &&
+                    !alignedFields.includes(
+                      key as (typeof alignedFields)[number],
+                    ),
                 ),
               ),
               ...(payloadOwnsLines ? { lines: batchLines } : {}),
+              ...payloadFields,
               ...(payloadOwnsLineIds && batchLineIds
                 ? { lineIds: batchLineIds }
                 : {}),
-              ...(payloadOwnsLineContexts && batchLineContexts
-                ? { lineContexts: batchLineContexts }
-                : {}),
               ...(payloadChannelOffset === undefined
                 ? {}
                 : { channelOffset: payloadChannelOffset + start }),
@@ -135,7 +148,7 @@ function splitRunEventForAppRuntime(
         : {
             ...eventWithoutOuterLines,
             lines: batchLines,
-            ...(batchLineContexts ? { lineContexts: batchLineContexts } : {}),
+            ...eventFields,
             ...(batchLineIds ? { lineIds: batchLineIds } : {}),
             ...(eventChannelOffset === undefined
               ? {}

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

@@ -24,7 +24,7 @@ import {
   type PlayConditionCounts,
 } from './cell-provenance';
 import { isLedgerTerminalResultRef } from './output-size-limits';
-import type { PlayLogContext } from './log-context';
+import type { PlayLogContext, PlayLogMetadata } from './log-context';
 import { RUN_EVENT_KIND, type RunEventSource } from './run-event-catalog';
 
 export type PlayRunLedgerStatus =
@@ -100,6 +100,8 @@ export type PlayRunLedgerStepProgress = {
   completedAt?: number | null;
   updatedAt?: number | null;
   nodeIo?: PlayDocflowNodeIoState;
+  /** Error reported by this step, distinct from a run stopping other work. */
+  error?: string;
   conditionCounts?: PlayConditionCounts;
 };
 
@@ -320,6 +322,7 @@ export type PlayRunLedgerEvent =
       lines: string[];
       /** Search-only context aligned to `lines`; stripped before Convex. */
       lineContexts?: Array<PlayLogContext | null>;
+      lineMetadata?: Array<PlayLogMetadata | null>;
       lineIds?: Array<string | null>;
       /**
        * Absolute per-run sequence (1-based) of `lines[0]`. Assigned by Run
@@ -431,6 +434,7 @@ export type PlayRunLedgerStatusPatch = {
   liveLogs?: readonly string[] | null;
   /** Search-only context aligned to `liveLogs`; stripped before Convex. */
   liveLogContexts?: readonly (PlayLogContext | null)[] | null;
+  liveLogMetadata?: readonly (PlayLogMetadata | null)[] | null;
   liveLogIds?: readonly (string | null)[] | null;
   /**
    * Positional cursor for `liveLogs[0]` on this producer's log channel (the
@@ -1383,6 +1387,9 @@ function normalizeStepProgress(
     ...(optionalFiniteNumber(value.supersededRows) !== undefined
       ? { supersededRows: optionalFiniteNumber(value.supersededRows) }
       : {}),
+    ...(optionalString(value.error)
+      ? { error: optionalString(value.error) }
+      : {}),
     ...(optionalString(value.message)
       ? { message: optionalString(value.message) }
       : {}),
@@ -2329,6 +2336,7 @@ function progressSignature(
     completedRows: progress?.completedRows ?? null,
     supersededRows: progress?.supersededRows ?? null,
     message: progress?.message ?? null,
+    error: progress?.error ?? null,
     artifactTableNamespace: progress?.artifactTableNamespace ?? null,
     startedAt: progress?.startedAt ?? null,
     completedAt: progress?.completedAt ?? null,
@@ -2371,6 +2379,7 @@ function terminalEventTypeForStatus(
 export function slicePositionalLogLines(input: {
   bufferLines: readonly string[];
   bufferContexts?: readonly (PlayLogContext | null)[];
+  bufferMetadata?: readonly (PlayLogMetadata | null)[];
   bufferIds?: readonly (string | null)[];
   bufferTotalCount: number;
   sentCount: number;
@@ -2378,6 +2387,7 @@ export function slicePositionalLogLines(input: {
   lines: string[];
   channelOffset: number;
   lineContexts?: Array<PlayLogContext | null>;
+  lineMetadata?: Array<PlayLogMetadata | null>;
   lineIds?: Array<string | null>;
 } | null {
   if (
@@ -2386,6 +2396,11 @@ export function slicePositionalLogLines(input: {
   ) {
     throw new TypeError('Run log contexts must align with the retained lines.');
   }
+  if (
+    input.bufferMetadata !== undefined &&
+    input.bufferMetadata.length !== input.bufferLines.length
+  )
+    throw new TypeError('Run log metadata must align with lines.');
   if (input.bufferIds && input.bufferIds.length !== input.bufferLines.length) {
     throw new TypeError('Run log identities must align with retained lines.');
   }
@@ -2402,11 +2417,13 @@ export function slicePositionalLogLines(input: {
   }
   const start = sendFromOffset - bufferFirstOffset;
   const lineContexts = input.bufferContexts?.slice(start);
+  const lineMetadata = input.bufferMetadata?.slice(start);
   return {
     lines: [...lines],
     channelOffset: sendFromOffset,
     ...(input.bufferIds ? { lineIds: input.bufferIds.slice(start) } : {}),
     ...(lineContexts?.some(Boolean) ? { lineContexts: [...lineContexts] } : {}),
+    ...(lineMetadata?.some(Boolean) ? { lineMetadata: [...lineMetadata] } : {}),
   };
 }
 
@@ -2435,6 +2452,7 @@ export function buildPlayRunLedgerEventsFromLogLines(input: {
   runId: string;
   lines: readonly string[];
   lineContexts?: readonly (PlayLogContext | null)[];
+  lineMetadata?: readonly (PlayLogMetadata | null)[];
   lineIds?: readonly (string | null)[];
   source?: PlayRunLedgerEventSource;
   occurredAt?: number;
@@ -2457,6 +2475,11 @@ export function buildPlayRunLedgerEventsFromLogLines(input: {
   ) {
     throw new TypeError('Run log contexts must align with their lines.');
   }
+  if (
+    input.lineMetadata !== undefined &&
+    input.lineMetadata.length !== input.lines.length
+  )
+    throw new TypeError('Run log metadata must align with lines.');
   if (input.lineIds && input.lineIds.length !== input.lines.length) {
     throw new TypeError('Run log identities must align with their lines.');
   }
@@ -2464,6 +2487,7 @@ export function buildPlayRunLedgerEventsFromLogLines(input: {
     .map((line, index) => ({
       line: positional ? line.trim() || '(blank log line)' : line.trim(),
       context: input.lineContexts?.[index] ?? null,
+      metadata: input.lineMetadata?.[index] ?? null,
       entryId: input.lineIds?.[index] ?? null,
     }))
     .filter((entry) => positional || entry.line.length > 0);
@@ -2499,6 +2523,15 @@ export function buildPlayRunLedgerEventsFromLogLines(input: {
               .map((entry) => entry.context),
           }
         : {}),
+      ...(entries
+        .slice(index, index + MAX_LEDGER_LOG_LINES_PER_EVENT)
+        .some((entry) => entry.metadata)
+        ? {
+            lineMetadata: entries
+              .slice(index, index + MAX_LEDGER_LOG_LINES_PER_EVENT)
+              .map((entry) => entry.metadata),
+          }
+        : {}),
       ...(positional ? { channelOffset: input.channelOffset! + index } : {}),
       ...(positional &&
       typeof input.producerAttempt === 'number' &&
@@ -2527,6 +2560,7 @@ export function buildTerminalLogReplayEvents(input: {
   runId: string;
   lines: readonly string[];
   lineContexts?: readonly (PlayLogContext | null)[];
+  lineMetadata?: readonly (PlayLogMetadata | null)[];
   lineIds?: readonly (string | null)[];
   source?: PlayRunLedgerEventSource;
   occurredAt?: number;
@@ -2542,6 +2576,7 @@ export function buildTerminalLogReplayEvents(input: {
     runId: input.runId,
     lines: input.lines,
     lineContexts: input.lineContexts,
+    lineMetadata: input.lineMetadata,
     lineIds: input.lineIds,
     source: 'coordinator',
     occurredAt: input.occurredAt,
@@ -2584,6 +2619,7 @@ export function buildPlayRunLedgerEventsFromStatusPatch(input: {
         runId: patch.runId,
         lines: patch.liveLogs,
         lineContexts: patch.liveLogContexts ?? undefined,
+        lineMetadata: patch.liveLogMetadata ?? undefined,
         lineIds: patch.liveLogIds ?? undefined,
         source,
         occurredAt: checkpointAt,
@@ -2666,6 +2702,7 @@ export function buildPlayRunLedgerEventsFromStatusPatch(input: {
         ? { supersededRows: progress.supersededRows }
         : {}),
       ...(progress.message !== undefined ? { message: progress.message } : {}),
+      ...(progress.error !== undefined ? { error: progress.error } : {}),
       ...(progress.artifactTableNamespace !== undefined
         ? { artifactTableNamespace: progress.artifactTableNamespace }
         : {}),
@@ -2692,6 +2729,7 @@ export function buildPlayRunLedgerEventsFromStatusPatch(input: {
         occurredAt: progress.updatedAt ?? checkpointAt,
         stepId,
         status:
+          typeof progress.error === 'string' ||
           typeof progress.nodeIo?.error === 'string'
             ? 'failed'
             : typeof progress.completedAt === 'number'
@@ -2703,9 +2741,18 @@ export function buildPlayRunLedgerEventsFromStatusPatch(input: {
       });
     }
 
-    if (progress.completedAt && !previousStep?.completedAt) {
+    const stepError = progress.error ?? progress.nodeIo?.error;
+    if (
+      progress.completedAt &&
+      (!previousStep?.completedAt ||
+        (typeof stepError === 'string' && previousStep.status !== 'failed'))
+    ) {
       events.push({
-        type: RUN_EVENT_KIND.stepCompleted,
+        type:
+          typeof stepError === 'string'
+            ? RUN_EVENT_KIND.stepFailed
+            : RUN_EVENT_KIND.stepCompleted,
+        ...(typeof stepError === 'string' ? { error: stepError } : {}),
         runId: patch.runId,
         source,
         occurredAt: progress.completedAt,

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

@@ -1,5 +1,8 @@
-import type { PlayLogContext } from './log-context';
-import { normalizePlayLogContext } from './log-context';
+import type { PlayLogContext, PlayLogMetadata } from './log-context';
+import {
+  normalizePlayLogContext,
+  normalizePlayLogMetadata,
+} from './log-context';
 
 /** Limits apply before logs enter runner memory or a transport request. */
 export const RUNNER_LOG_MAX_CHARS = 2_000;
@@ -28,6 +31,7 @@ export class RunLogBuffer {
   readonly ids: string[] = [];
   private readonly origin = crypto.randomUUID();
   readonly contexts: Array<PlayLogContext | null> = [];
+  readonly metadata: Array<PlayLogMetadata | null> = [];
   private bytes = 0;
   private contextBytes = 0;
   private omittedContexts = 0;
@@ -38,10 +42,12 @@ export class RunLogBuffer {
     raw: string,
     terminal = false,
     context?: PlayLogContext | null,
+    metadata?: PlayLogMetadata | null,
   ): string[] {
     const line = boundRunLogLine(raw);
     const bytes = encoder.encode(line).byteLength;
     const normalizedContext = normalizePlayLogContext(context);
+    const normalizedMetadata = normalizePlayLogMetadata(metadata);
     const contextBytes = normalizedContext
       ? encoder.encode(JSON.stringify(normalizedContext)).byteLength
       : 0;
@@ -60,6 +66,7 @@ export class RunLogBuffer {
     }
     this.ids.push(`${this.origin}:${this.lines.length}`);
     this.lines.push(line);
+    this.metadata.push(normalizedMetadata);
     const retainContext =
       normalizedContext !== null &&
       this.contextBytes + contextBytes <= RUNNER_LOG_CONTEXT_MAX_BYTES;

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

@@ -36,7 +36,10 @@ import {
   DURABLE_INVOCATION_FENCE_ATTESTATION_VALUE,
 } from '../durable-invocation-fence';
 import type { PlayRunInputPayload } from '../play-input';
-import type { PlayLogContext } from '../log-context';
+import type {
+  PlayLogContext,
+  PlayLogMetadata,
+} from '../log-context';
 import { playRunInputObjectView } from '../play-input';
 import {
   normalizePlayRunFailure,
@@ -1737,6 +1740,13 @@ async function executeRuntimePlayCode(input: {
 }
 
 const CAPTURED_CONSOLE_MAX_CHARS = 2_000;
+const CAPTURED_CONSOLE_PREFIX_RESERVE_CHARS = 64;
+const CAPTURED_CONSOLE_SHORTENED_MARKER =
+  '… [log shortened; save complete values in a dataset and use runs export]';
+const CAPTURED_CONSOLE_MAX_MESSAGE_CHARS =
+  CAPTURED_CONSOLE_MAX_CHARS - CAPTURED_CONSOLE_PREFIX_RESERVE_CHARS;
+const CAPTURED_CONSOLE_FORMAT_TRUNCATION =
+  /(\.\.\.|…)\s*\d+\s+more\s+(?:characters?|items?)/i;
 
 function logLevelForCapturedConsoleMethod(
   method: string,
@@ -1763,14 +1773,20 @@ function createCapturedCustomerConsole(
           compact: true,
           depth: 4,
           maxArrayLength: 20,
-          maxStringLength: 2_000,
+          maxStringLength: CAPTURED_CONSOLE_MAX_MESSAGE_CHARS,
         },
         ...args,
       );
-      const message =
-        formatted.length > CAPTURED_CONSOLE_MAX_CHARS
-          ? `${formatted.slice(0, CAPTURED_CONSOLE_MAX_CHARS - 1)}…`
-          : formatted;
+      const shortened =
+        formatted.length > CAPTURED_CONSOLE_MAX_MESSAGE_CHARS ||
+        CAPTURED_CONSOLE_FORMAT_TRUNCATION.test(formatted);
+      const message = shortened
+        ? `${formatted.slice(
+            0,
+            CAPTURED_CONSOLE_MAX_MESSAGE_CHARS -
+              CAPTURED_CONSOLE_SHORTENED_MARKER.length,
+          )}${CAPTURED_CONSOLE_SHORTENED_MARKER}`
+        : formatted;
       ctx.log(`[console.${method}] ${message}`, {
         level: logLevelForCapturedConsoleMethod(method),
       });
@@ -1923,6 +1939,13 @@ function terminalLogsWithPhaseSummary(ctx: {
   ];
 }
 
+function terminalLogMetadataWithPhaseSummary(ctx: {
+  getLogMetadata(): Array<PlayLogMetadata | null>;
+}): Array<PlayLogMetadata | null> | undefined {
+  const metadata = ctx.getLogMetadata();
+  return metadata.some(Boolean) ? [...metadata, null, null] : undefined;
+}
+
 function terminalLogContextsWithPhaseSummary(ctx: {
   getLogContexts(): Array<PlayLogContext | null>;
 }): Array<PlayLogContext | null> | undefined {
@@ -2496,7 +2519,7 @@ async function run(
             });
           }
         : undefined,
-    onLog: (line, context, entryId) => {
+    onLog: (line, context, entryId, metadata) => {
       const timestampMatch = line.match(/^\[([^\]]+)\]/);
       const timestamp = timestampMatch?.[1];
       const at =
@@ -2513,6 +2536,7 @@ async function run(
             ? { entryId }
             : {}),
           ...(context ? { context } : {}),
+          ...(metadata ? { metadata } : {}),
         },
         options,
       );
@@ -3143,6 +3167,7 @@ async function run(
           ? { logIds: terminalLogIdsWithPhaseSummary(ctx) }
           : {}),
         logContexts: terminalLogContextsWithPhaseSummary(ctx),
+        logMetadata: terminalLogMetadataWithPhaseSummary(ctx),
         stats: runtimeStats(),
         steps: ctx.getSteps(),
         tableNamespace: null,
@@ -3390,6 +3415,7 @@ async function run(
         ? { logIds: terminalLogIdsWithPhaseSummary(ctx) }
         : {}),
       logContexts: terminalLogContextsWithPhaseSummary(ctx),
+      logMetadata: terminalLogMetadataWithPhaseSummary(ctx),
       ...(runtimeDiagnostics.length > 0 ? { runtimeDiagnostics } : {}),
       ...(rowOutcomes ? { rowOutcomes } : {}),
       stats: runtimeStats(),
@@ -3448,6 +3474,7 @@ async function run(
           ? { logIds: terminalLogIdsWithPhaseSummary(ctx) }
           : {}),
         logContexts: terminalLogContextsWithPhaseSummary(ctx),
+        logMetadata: terminalLogMetadataWithPhaseSummary(ctx),
         stats: runtimeStats(),
         steps: ctx.getSteps(),
         checkpoint: ctx.getCheckpoint(),
@@ -3487,6 +3514,7 @@ async function run(
         ? { logIds: terminalLogIdsWithPhaseSummary(ctx) }
         : {}),
       logContexts: terminalLogContextsWithPhaseSummary(ctx),
+      logMetadata: terminalLogMetadataWithPhaseSummary(ctx),
       ...(rowOutcomes ? { rowOutcomes } : {}),
       stats: runtimeStats(),
       steps: ctx.getSteps(),