deepline 0.3.247 → 0.3.248

package/dist/bundling-sources/shared_libs/play-runtime/deployment/fly-machines.ts

@@ -235,6 +235,10 @@ export type FlyMachine = {
     init?: {
       exec?: string[];
     };
+    stop_config?: {
+      signal?: string;
+      timeout?: string;
+    };
   };
   checks?: FlyMachineCheck[];
 };
@@ -398,6 +402,12 @@ export function buildBootMachineConfig(input: {
       init: {
         exec: [...ABSURD_RUNTIME_WORKER_EXEC],
       },
+      // Direct Machines API creation does not load the worker fly.toml.
+      // Fly encodes this timeout as a duration string, unlike TOML seconds.
+      stop_config: {
+        signal: DEFAULT_LANE_REPLACEMENT_STOP_SIGNAL,
+        timeout: DEFAULT_LANE_REPLACEMENT_STOP_TIMEOUT,
+      },
       restart: {
         policy: 'on-failure',
         max_retries: 3,
@@ -534,6 +544,13 @@ export function buildWorkerSlotCapUpdateConfig(machine: FlyMachine): {
         ...(existing.init ?? {}),
         exec: [...ABSURD_RUNTIME_WORKER_EXEC],
       },
+      // Config updates replace the complete Machine config. Apply the same
+      // stop policy to reused historical workers while preserving other fields.
+      stop_config: {
+        ...(existing.stop_config ?? {}),
+        signal: DEFAULT_LANE_REPLACEMENT_STOP_SIGNAL,
+        timeout: DEFAULT_LANE_REPLACEMENT_STOP_TIMEOUT,
+      },
     },
   };
 }

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

@@ -0,0 +1,105 @@
+/**
+ * Small, flat log context values copied into the org-scoped event search
+ * document. Keep this contract stable across the runner and gateway packages.
+ */
+export type PlayLogContextValue = string | number | boolean;
+export type PlayLogContext = Readonly<Record<string, PlayLogContextValue>>;
+
+export const PLAY_LOG_CONTEXT_LIMITS = {
+  fields: 8,
+  keyBytes: 64,
+  stringValueBytes: 256,
+  totalBytes: 2_048,
+} as const;
+
+const CONTEXT_KEY = /^[A-Za-z_][A-Za-z0-9_]{0,63}$/;
+const FORBIDDEN_CONTEXT_KEYS = new Set([
+  '__proto__',
+  'constructor',
+  'prototype',
+]);
+const utf8 = new TextEncoder();
+
+/** Validate and return a detached, key-sorted JSON-safe context object. */
+export function normalizePlayLogContext(value: unknown): PlayLogContext | null {
+  if (value === undefined || value === null) return null;
+  if (
+    !value ||
+    typeof value !== 'object' ||
+    Array.isArray(value) ||
+    ![Object.prototype, null].includes(Object.getPrototypeOf(value))
+  ) {
+    throw new TypeError('ctx.log context must be a flat key/value object.');
+  }
+
+  const ownKeys = Reflect.ownKeys(value);
+  if (ownKeys.some((key) => typeof key !== 'string')) {
+    throw new TypeError('ctx.log context keys must be strings.');
+  }
+  const entries: Array<[string, unknown]> = [];
+  for (const key of ownKeys as string[]) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (
+      !descriptor?.enumerable ||
+      !Object.prototype.hasOwnProperty.call(descriptor, 'value')
+    ) {
+      throw new TypeError(
+        'ctx.log context fields must be enumerable data properties.',
+      );
+    }
+    entries.push([key, descriptor.value]);
+  }
+  if (entries.length > PLAY_LOG_CONTEXT_LIMITS.fields) {
+    throw new TypeError(
+      `ctx.log context supports at most ${PLAY_LOG_CONTEXT_LIMITS.fields} fields.`,
+    );
+  }
+
+  const normalized: Record<string, PlayLogContextValue> = {};
+  for (const [key, entry] of entries.sort(([left], [right]) =>
+    left < right ? -1 : left > right ? 1 : 0,
+  )) {
+    if (
+      !CONTEXT_KEY.test(key) ||
+      utf8.encode(key).byteLength > PLAY_LOG_CONTEXT_LIMITS.keyBytes ||
+      FORBIDDEN_CONTEXT_KEYS.has(key)
+    ) {
+      throw new TypeError(
+        `ctx.log context key ${JSON.stringify(key)} is not supported.`,
+      );
+    }
+    if (typeof entry === 'string') {
+      if (
+        utf8.encode(entry).byteLength > PLAY_LOG_CONTEXT_LIMITS.stringValueBytes
+      ) {
+        throw new TypeError(
+          `ctx.log context value for ${key} exceeds ${PLAY_LOG_CONTEXT_LIMITS.stringValueBytes} UTF-8 bytes.`,
+        );
+      }
+      normalized[key] = entry;
+      continue;
+    }
+    if (typeof entry === 'boolean') {
+      normalized[key] = entry;
+      continue;
+    }
+    if (typeof entry === 'number' && Number.isFinite(entry)) {
+      normalized[key] = entry;
+      continue;
+    }
+    throw new TypeError(
+      `ctx.log context value for ${key} must be a string, finite number, or boolean.`,
+    );
+  }
+
+  if (entries.length === 0) return null;
+  if (
+    utf8.encode(JSON.stringify(normalized)).byteLength >
+    PLAY_LOG_CONTEXT_LIMITS.totalBytes
+  ) {
+    throw new TypeError(
+      `ctx.log context exceeds ${PLAY_LOG_CONTEXT_LIMITS.totalBytes} UTF-8 bytes.`,
+    );
+  }
+  return normalized;
+}

package/dist/bundling-sources/shared_libs/play-runtime/output-size-limits.ts

@@ -491,7 +491,14 @@ export function buildRunDatasetPreview(
   const previewRows: unknown[] = [];
   let truncated = rows.length > RUN_RESPONSE_PREVIEW_LIMITS.maxRows;
   for (const row of rows.slice(0, RUN_RESPONSE_PREVIEW_LIMITS.maxRows)) {
-    const compacted = compactRunOutputPreviewValue(row, 0);
+    // Debug columns remain persisted/exportable; exclude them before budgeting.
+    const visibleRow =
+      row && typeof row === 'object' && !Array.isArray(row)
+        ? Object.fromEntries(
+            Object.entries(row).filter(([name]) => !name.startsWith('_')),
+          )
+        : row;
+    const compacted = compactRunOutputPreviewValue(visibleRow, 0);
     truncated ||= compacted.truncated;
     const nextRows = [...previewRows, compacted.value];
     if (jsonSize(nextRows) > RUN_RESPONSE_PREVIEW_LIMITS.maxBytes) {

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

@@ -14,6 +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 { PreloadedRuntimeDbSession } from './db-session';
 import type { PacingRule } from './governor/rate-state-backend';
 import type { GovernanceSnapshot } from './governor/governor';
@@ -319,6 +320,8 @@ export type PlayRunnerLogEvent = {
   at: string;
   source: PlayLiveEventSource;
   line: string;
+  /** Search-only context; omitted before the compatible Convex projection. */
+  context?: PlayLogContext;
 };
 
 export type PlayRunnerEvent =
@@ -408,6 +411,8 @@ export type PlayRunnerResult =
       outputRowCount?: number;
       rowOutcomes?: PlayRunnerRowOutcomeSummary;
       logs: string[];
+      /** Search-only context aligned to logs; omitted when every entry is null. */
+      logContexts?: Array<PlayLogContext | null>;
       stats: Record<string, unknown>;
       steps: PlayStep[];
       checkpoint: PlayCheckpoint;
@@ -421,6 +426,8 @@ export type PlayRunnerResult =
       status: 'suspended';
       suspension: PlayExecutionSuspension;
       logs: string[];
+      /** Search-only context aligned to logs; omitted when every entry is null. */
+      logContexts?: Array<PlayLogContext | null>;
       stats: Record<string, unknown>;
       steps: PlayStep[];
       checkpoint: PlayCheckpoint;
@@ -435,6 +442,8 @@ export type PlayRunnerResult =
       error: string;
       errors?: PlayRunFailureDetails[];
       logs: string[];
+      /** Search-only context aligned to logs; omitted when every entry is null. */
+      logContexts?: Array<PlayLogContext | null>;
       stats: Record<string, unknown>;
       steps: PlayStep[];
       checkpoint?: PlayCheckpoint | null;

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

@@ -1,4 +1,5 @@
 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;
@@ -26,6 +27,25 @@ function splitRunEventForAppRuntime(
     ? rawLines.filter((line): line is string => typeof line === 'string')
     : [];
   if (eventType !== 'log.appended' || 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 payloadChannelOffset =
     typeof payload?.channelOffset === 'number'
       ? payload.channelOffset
@@ -33,7 +53,11 @@ function splitRunEventForAppRuntime(
   const eventChannelOffset =
     typeof event.channelOffset === 'number' ? event.channelOffset : undefined;
   const split: PlayRunLedgerIngressEvent[] = [];
-  const { lines: _outerLines, ...eventWithoutOuterLines } = event;
+  const {
+    lines: _outerLines,
+    lineContexts: _outerLineContexts,
+    ...eventWithoutOuterLines
+  } = event;
   let index = 0;
   while (index < lines.length) {
     const start = index;
@@ -52,14 +76,25 @@ function splitRunEventForAppRuntime(
       index += 1;
     }
     const batchLines = lines.slice(start, index);
+    const batchLineContexts = lineContexts?.slice(start, index);
     split.push(
       payload
         ? {
             ...eventWithoutOuterLines,
+            ...(eventOwnsLineContexts && batchLineContexts
+              ? { lineContexts: batchLineContexts }
+              : {}),
             ...(payloadOwnsLines ? {} : { lines: batchLines }),
             payload: {
-              ...payload,
+              ...Object.fromEntries(
+                Object.entries(payload).filter(
+                  ([key]) => key !== 'lineContexts',
+                ),
+              ),
               ...(payloadOwnsLines ? { lines: batchLines } : {}),
+              ...(payloadOwnsLineContexts && batchLineContexts
+                ? { lineContexts: batchLineContexts }
+                : {}),
               ...(payloadChannelOffset === undefined
                 ? {}
                 : { channelOffset: payloadChannelOffset + start }),
@@ -69,8 +104,9 @@ function splitRunEventForAppRuntime(
               : { channelOffset: eventChannelOffset + start }),
           }
         : {
-            ...event,
+            ...eventWithoutOuterLines,
             lines: batchLines,
+            ...(batchLineContexts ? { lineContexts: batchLineContexts } : {}),
             ...(eventChannelOffset === undefined
               ? {}
               : { channelOffset: eventChannelOffset + start }),
@@ -81,7 +117,7 @@ function splitRunEventForAppRuntime(
 }
 
 /**
- * Reproduce the exact event and byte boundaries used by the App Runtime API.
+ * Reproduce the exact event, KV and byte boundaries used by the App Runtime API.
  * The outbox lease verifier uses this same function to validate each chunk
  * against its canonical event prefix before accepting a projection.
  */

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

@@ -21,6 +21,7 @@ import {
   type PlayDatasetBornFrom,
 } from './cell-provenance';
 import { isLedgerTerminalResultRef } from './output-size-limits';
+import type { PlayLogContext } from './log-context';
 
 export type PlayRunLedgerStatus =
   | 'queued'
@@ -294,6 +295,8 @@ export type PlayRunLedgerEvent =
   | (PlayRunLedgerBaseEvent & {
       type: 'log.appended';
       lines: string[];
+      /** Search-only context aligned to `lines`; stripped before Convex. */
+      lineContexts?: Array<PlayLogContext | null>;
       /**
        * Absolute per-run sequence (1-based) of `lines[0]`. Assigned by Run
        * Log Stream ingestion in Convex only; producers never set it.
@@ -402,6 +405,8 @@ export type PlayRunLedgerStatusPatch = {
   runtimeBackend?: string | null;
   lastCheckpointAt?: number | null;
   liveLogs?: readonly string[] | null;
+  /** Search-only context aligned to `liveLogs`; stripped before Convex. */
+  liveLogContexts?: readonly (PlayLogContext | null)[] | null;
   /**
    * Positional cursor for `liveLogs[0]` on this producer's log channel (the
    * count of lines emitted before it). Computed by the producer-side cursor
@@ -2064,9 +2069,20 @@ function terminalEventTypeForStatus(
  */
 export function slicePositionalLogLines(input: {
   bufferLines: readonly string[];
+  bufferContexts?: readonly (PlayLogContext | null)[];
   bufferTotalCount: number;
   sentCount: number;
-}): { lines: string[]; channelOffset: number } | null {
+}): {
+  lines: string[];
+  channelOffset: number;
+  lineContexts?: Array<PlayLogContext | null>;
+} | null {
+  if (
+    input.bufferContexts !== undefined &&
+    input.bufferContexts.length !== input.bufferLines.length
+  ) {
+    throw new TypeError('Run log contexts must align with the retained lines.');
+  }
   const total = Math.max(input.bufferTotalCount, input.bufferLines.length);
   const sent = Math.max(0, input.sentCount);
   if (total <= sent) {
@@ -2078,7 +2094,13 @@ export function slicePositionalLogLines(input: {
   if (lines.length === 0) {
     return null;
   }
-  return { lines: [...lines], channelOffset: sendFromOffset };
+  const start = sendFromOffset - bufferFirstOffset;
+  const lineContexts = input.bufferContexts?.slice(start);
+  return {
+    lines: [...lines],
+    channelOffset: sendFromOffset,
+    ...(lineContexts?.some(Boolean) ? { lineContexts: [...lineContexts] } : {}),
+  };
 }
 
 function terminalLogReplayChannelOffset(input: {
@@ -2105,6 +2127,7 @@ function terminalLogReplayChannelOffset(input: {
 export function buildPlayRunLedgerEventsFromLogLines(input: {
   runId: string;
   lines: readonly string[];
+  lineContexts?: readonly (PlayLogContext | null)[];
   source?: PlayRunLedgerEventSource;
   occurredAt?: number;
   channelOffset?: number | null;
@@ -2120,9 +2143,19 @@ export function buildPlayRunLedgerEventsFromLogLines(input: {
     Number.isFinite(input.channelOffset);
   // Positional batches must keep one entry per emitted line — dropping a
   // blank would shift every later line off its channel position.
-  const newLines = positional
-    ? input.lines.map((line) => line.trim() || '(blank log line)')
-    : input.lines.map((line) => line.trim()).filter((line) => line.length > 0);
+  if (
+    input.lineContexts !== undefined &&
+    input.lineContexts.length !== input.lines.length
+  ) {
+    throw new TypeError('Run log contexts must align with their lines.');
+  }
+  const entries = input.lines
+    .map((line, index) => ({
+      line: positional ? line.trim() || '(blank log line)' : line.trim(),
+      context: input.lineContexts?.[index] ?? null,
+    }))
+    .filter((entry) => positional || entry.line.length > 0);
+  const newLines = entries.map((entry) => entry.line);
   if (newLines.length === 0 || input.includeLogAppend === false) {
     return [];
   }
@@ -2138,6 +2171,15 @@ export function buildPlayRunLedgerEventsFromLogLines(input: {
       source,
       occurredAt,
       lines: newLines.slice(index, index + MAX_LEDGER_LOG_LINES_PER_EVENT),
+      ...(entries
+        .slice(index, index + MAX_LEDGER_LOG_LINES_PER_EVENT)
+        .some((entry) => entry.context)
+        ? {
+            lineContexts: entries
+              .slice(index, index + MAX_LEDGER_LOG_LINES_PER_EVENT)
+              .map((entry) => entry.context),
+          }
+        : {}),
       ...(positional ? { channelOffset: input.channelOffset! + index } : {}),
       ...(positional &&
       typeof input.producerAttempt === 'number' &&
@@ -2165,6 +2207,7 @@ export function buildPlayRunLedgerEventsFromLogLines(input: {
 export function buildTerminalLogReplayEvents(input: {
   runId: string;
   lines: readonly string[];
+  lineContexts?: readonly (PlayLogContext | null)[];
   source?: PlayRunLedgerEventSource;
   occurredAt?: number;
   liveLogTotalCount?: number;
@@ -2178,6 +2221,7 @@ export function buildTerminalLogReplayEvents(input: {
   return buildPlayRunLedgerEventsFromLogLines({
     runId: input.runId,
     lines: input.lines,
+    lineContexts: input.lineContexts,
     source: 'coordinator',
     occurredAt: input.occurredAt,
     channelOffset,
@@ -2218,6 +2262,7 @@ export function buildPlayRunLedgerEventsFromStatusPatch(input: {
     ? buildPlayRunLedgerEventsFromLogLines({
         runId: patch.runId,
         lines: patch.liveLogs,
+        lineContexts: patch.liveLogContexts ?? undefined,
         source,
         occurredAt: checkpointAt,
         channelOffset: patch.liveLogsChannelOffset ?? null,

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

@@ -117,5 +117,7 @@ export function isRecoverableDatasetRowStatus(status: unknown): boolean {
 export function datasetSummaryRowModeForRunStatus(
   status: unknown,
 ): 'output' | 'all' {
-  return isRecoverableDatasetRowStatus(status) ? 'all' : 'output';
+  // Completed is a run lifecycle, not proof that every row succeeded. Terminal
+  // summaries must count the same persisted successful AND failed rows as export.
+  return isTerminalPlayRunLifecycleStatus(status) ? 'all' : 'output';
 }

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

@@ -1,7 +1,12 @@
+import type { PlayLogContext } from './log-context';
+import { normalizePlayLogContext } from './log-context';
+
 /** Limits apply before logs enter runner memory or a transport request. */
 export const RUNNER_LOG_MAX_CHARS = 2_000;
 export const RUNNER_LOG_MAX_BYTES = 5 * 1024 * 1024;
 export const RUNNER_LOG_MAX_LINES = 25_000;
+/** Keep structured metadata from multiplying the per-run text-log budget. */
+export const RUNNER_LOG_CONTEXT_MAX_BYTES = 128 * 1024;
 const TERMINAL_RESERVE_BYTES = 64 * 1024;
 const TERMINAL_RESERVE_LINES = 32;
 const encoder = new TextEncoder();
@@ -20,13 +25,24 @@ export function boundRunLogLine(line: string): string {
  */
 export class RunLogBuffer {
   readonly lines: string[] = [];
+  readonly contexts: Array<PlayLogContext | null> = [];
   private bytes = 0;
+  private contextBytes = 0;
+  private omittedContexts = 0;
   private omitted = 0;
   private marked = false;
 
-  append(raw: string, terminal = false): string[] {
+  append(
+    raw: string,
+    terminal = false,
+    context?: PlayLogContext | null,
+  ): string[] {
     const line = boundRunLogLine(raw);
     const bytes = encoder.encode(line).byteLength;
+    const normalizedContext = normalizePlayLogContext(context);
+    const contextBytes = normalizedContext
+      ? encoder.encode(JSON.stringify(normalizedContext)).byteLength
+      : 0;
     const byteLimit =
       RUNNER_LOG_MAX_BYTES - (terminal ? 0 : TERMINAL_RESERVE_BYTES);
     const lineLimit =
@@ -41,13 +57,24 @@ export class RunLogBuffer {
       );
     }
     this.lines.push(line);
+    const retainContext =
+      normalizedContext !== null &&
+      this.contextBytes + contextBytes <= RUNNER_LOG_CONTEXT_MAX_BYTES;
+    this.contexts.push(retainContext ? normalizedContext : null);
     this.bytes += bytes;
+    if (retainContext) {
+      this.contextBytes += contextBytes;
+    } else if (normalizedContext !== null) {
+      this.omittedContexts += 1;
+    }
     return [line];
   }
 
   snapshot() {
     return {
       retainedBytes: this.bytes,
+      retainedContextBytes: this.contextBytes,
+      omittedContexts: this.omittedContexts,
       retainedLines: this.lines.length,
       omittedLines: this.omitted,
     };

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

@@ -35,6 +35,7 @@ import {
   DURABLE_INVOCATION_FENCE_ATTESTATION_VALUE,
 } from '../durable-invocation-fence';
 import type { PlayRunInputPayload } from '../play-input';
+import type { PlayLogContext } from '../log-context';
 import { playRunInputObjectView } from '../play-input';
 import {
   normalizePlayRunFailure,
@@ -1856,6 +1857,13 @@ function terminalLogsWithPhaseSummary(ctx: {
   ];
 }
 
+function terminalLogContextsWithPhaseSummary(ctx: {
+  getLogContexts(): Array<PlayLogContext | null>;
+}): Array<PlayLogContext | null> | undefined {
+  const contexts = ctx.getLogContexts();
+  return contexts.some(Boolean) ? [...contexts, null, null] : undefined;
+}
+
 function rowOutcomesFromCheckpoint(checkpoint: {
   mapFrames?: Record<
     string,
@@ -2422,7 +2430,7 @@ async function run(
             });
           }
         : undefined,
-    onLog: (line) => {
+    onLog: (line, context) => {
       const timestampMatch = line.match(/^\[([^\]]+)\]/);
       const timestamp = timestampMatch?.[1];
       const at =
@@ -2435,6 +2443,7 @@ async function run(
           at,
           source: 'play',
           line,
+          ...(context ? { context } : {}),
         },
         options,
       );
@@ -3060,6 +3069,7 @@ async function run(
         error: runtimeLimitExceededCause(runtimeLimitSeconds),
         errors: [runtimeLimitExceededFailure(runtimeLimitSeconds)],
         logs: terminalLogsWithPhaseSummary(ctx),
+        logContexts: terminalLogContextsWithPhaseSummary(ctx),
         stats: runtimeStats(),
         steps: ctx.getSteps(),
         tableNamespace: null,
@@ -3303,6 +3313,7 @@ async function run(
         : {}),
       outputRowCount,
       logs,
+      logContexts: terminalLogContextsWithPhaseSummary(ctx),
       ...(runtimeDiagnostics.length > 0 ? { runtimeDiagnostics } : {}),
       ...(rowOutcomes ? { rowOutcomes } : {}),
       stats: runtimeStats(),
@@ -3357,6 +3368,7 @@ async function run(
         status: 'suspended',
         suspension: error.suspension,
         logs: terminalLogsWithPhaseSummary(ctx),
+        logContexts: terminalLogContextsWithPhaseSummary(ctx),
         stats: runtimeStats(),
         steps: ctx.getSteps(),
         checkpoint: ctx.getCheckpoint(),
@@ -3392,6 +3404,7 @@ async function run(
       error: formatRunnerFailure(error),
       errors: [failure],
       logs: terminalLogsWithPhaseSummary(ctx),
+      logContexts: terminalLogContextsWithPhaseSummary(ctx),
       ...(rowOutcomes ? { rowOutcomes } : {}),
       stats: runtimeStats(),
       steps: ctx.getSteps(),