deepline 0.1.144 → 0.1.146

package/dist/bundling-sources/apps/play-runner-workers/src/coordinator-entry.ts

@@ -640,6 +640,8 @@ type DynamicWorkflowMetadata = {
 const SUBMIT_INITIAL_STATE_MAX_WAIT_MS = 0;
 const SUBMIT_INITIAL_STATE_POLL_MS = 50;
 const WORKFLOW_RETRY_STATE_TTL_MS = 60 * 60 * 1000;
+const COORDINATOR_WORKER_MEMORY_LIMIT_MESSAGE =
+  'Worker memory limit hit before the run could finish. For CSV enrich, use --output or --in-place for automatic batches; otherwise rerun smaller --rows ranges.';
 
 function buildDynamicWorkflowMetadata(
   params: PlayWorkflowParams,
@@ -1052,6 +1054,27 @@ function readWorkflowPayload(event: unknown): Record<string, unknown> | null {
   return isRecord(payload.params) ? payload.params : payload;
 }
 
+function isCoordinatorWorkerMemoryLimitError(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.toLowerCase().includes('worker exceeded memory limit');
+}
+
+function normalizeCoordinatorWorkflowRuntimeFailure(
+  error: unknown,
+): ReturnType<typeof normalizePlayRunFailure> {
+  const failure = normalizePlayRunFailure(error);
+  if (!isCoordinatorWorkerMemoryLimitError(error)) {
+    return failure;
+  }
+  return {
+    ...failure,
+    code: 'WORKER_MEMORY_LIMIT_EXCEEDED',
+    message: COORDINATOR_WORKER_MEMORY_LIMIT_MESSAGE,
+    retryable: false,
+    cause: failure.message,
+  };
+}
+
 async function markWorkflowRuntimeFailure(input: {
   env: CoordinatorEnv;
   event: unknown;
@@ -1074,6 +1097,16 @@ async function markWorkflowRuntimeFailure(input: {
     input.error instanceof Error && typeof input.error.stack === 'string'
       ? input.error.stack.split('\n').slice(0, 12).join('\n')
       : null;
+  const failure = normalizeCoordinatorWorkflowRuntimeFailure(input.error);
+  const shouldPreserveRawError =
+    failure.code === 'RUN_FAILED' ||
+    (failure.cause !== undefined && failure.message === failure.cause);
+  const normalizedError =
+    shouldPreserveRawError
+      ? `DynamicWorkflow runner failed: ${errorName}: ${errorMessage}${
+          errorStack ? `\n${errorStack}` : ''
+        }`
+      : `DynamicWorkflow runner failed: ${failure.message}`;
   const headers = new Headers({
     authorization: `Bearer ${executorToken}`,
     'content-type': 'application/json',
@@ -1089,9 +1122,7 @@ async function markWorkflowRuntimeFailure(input: {
         runId,
         source: 'coordinator',
         occurredAt: Date.now(),
-        error: `DynamicWorkflow runner failed: ${errorName}: ${errorMessage}${
-          errorStack ? `\n${errorStack}` : ''
-        }`,
+        error: normalizedError,
       } satisfies PlayRunLedgerEvent,
     ],
   });
@@ -3062,7 +3093,8 @@ export class DynamicWorkflow extends WorkflowEntrypoint<
                 });
                 return result;
               } catch (innerError) {
-                const failure = normalizePlayRunFailure(innerError);
+                const failure =
+                  normalizeCoordinatorWorkflowRuntimeFailure(innerError);
                 console.error(
                   '[coordinator] DynamicWorkflow runner.run threw',
                   {

package/dist/bundling-sources/apps/play-runner-workers/src/entry.ts

@@ -43,7 +43,10 @@ import {
   type ChunkExecutionResult,
 } from '../../../shared_libs/play-runtime/batch-runtime';
 import { getPlayRuntimeBatchStrategy } from '../../../shared_libs/play-runtime/play-runtime-batching-registry';
-import { STANDARD_PLAY_RUNTIME_LIMIT_SECONDS } from '../../../shared_libs/temporal/constants';
+import {
+  STANDARD_PLAY_RUNTIME_LIMIT_LABEL,
+  STANDARD_PLAY_RUNTIME_LIMIT_SECONDS,
+} from '../../../shared_libs/temporal/constants';
 import {
   createPlayExecutionGovernor,
   type GovernanceSnapshot,
@@ -6341,7 +6344,7 @@ async function executeRunRequest(
     runtimeLimitExceeded = true;
     if (!abortSignal.aborted) {
       abortController.abort(
-        `Play runtime limit exceeded after ${STANDARD_PLAY_RUNTIME_LIMIT_SECONDS}s.`,
+        `Based on this plan, max runtime is ${STANDARD_PLAY_RUNTIME_LIMIT_LABEL}. Use smaller batches; ask for runtime.`,
       );
     }
   }, STANDARD_PLAY_RUNTIME_LIMIT_SECONDS * 1000);

package/dist/bundling-sources/sdk/src/client.ts

@@ -320,6 +320,7 @@ export type RunsNamespace = {
     runId?: string;
     limit?: number;
     offset?: number;
+    rowMode?: 'output' | 'all';
   }) => Promise<PlaySheetRowsResult>;
   /** Stop a running/waiting run. */
   stop: (
@@ -2434,6 +2435,7 @@ export class DeeplineClient {
     runId?: string;
     limit?: number;
     offset?: number;
+    rowMode?: 'output' | 'all';
   }): Promise<PlaySheetRowsResult> {
     const params = new URLSearchParams({
       tableNamespace: input.tableNamespace,
@@ -2443,6 +2445,9 @@ export class DeeplineClient {
     if (input.runId?.trim()) {
       params.set('runId', input.runId.trim());
     }
+    if (input.rowMode === 'all') {
+      params.set('rowMode', 'all');
+    }
     return await this.http.get<PlaySheetRowsResult>(
       `/api/v2/plays/${encodeURIComponent(input.playName)}/sheet?${params.toString()}`,
     );

package/dist/bundling-sources/sdk/src/release.ts

@@ -101,10 +101,10 @@ export const SDK_RELEASE = {
   // 0.1.108 ships explicit dataset column/tool recompute policy and removes
   // the SDK enrich generator's one-second stale policy.
   // 0.1.110 ships authored V2 prebuilts and required top-level play descriptions.
-  version: '0.1.144',
+  version: '0.1.146',
   apiContract: '2026-06-dataset-column-cell-stale-hard-cutover',
   supportPolicy: {
-    latest: '0.1.144',
+    latest: '0.1.146',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
     commandMinimumSupported: [

package/dist/bundling-sources/shared_libs/temporal/constants.ts

@@ -18,13 +18,14 @@ export const LOCAL_TEMPORAL_ADDRESS = `127.0.0.1:${LOCAL_TEMPORAL_FRONTEND_PORT}
 export const LOCAL_TEMPORAL_UI_URL = `http://127.0.0.1:${LOCAL_TEMPORAL_UI_PORT}`;
 
 /** Maximum active user-code runtime for a standard play, in seconds. */
-export const STANDARD_PLAY_RUNTIME_LIMIT_SECONDS = 10 * 60; // 10 minutes
+export const STANDARD_PLAY_RUNTIME_LIMIT_SECONDS = 20 * 60; // 20 minutes
+export const STANDARD_PLAY_RUNTIME_LIMIT_LABEL = '20 minutes';
 
 /**
- * Activity timeout includes cleanup/billing headroom after the 10 minute
+ * Activity timeout includes setup, cleanup, and billing headroom after the 20 minute
  * user-code runtime cap. Keep this higher than STANDARD_PLAY_RUNTIME_LIMIT_SECONDS.
  */
-export const PLAY_ACTIVITY_TIMEOUT_SECONDS = 12 * 60; // 12 minutes
+export const PLAY_ACTIVITY_TIMEOUT_SECONDS = 30 * 60; // 30 minutes
 
 /** Heartbeat cadence for the long-running play execution activity. */
 export const PLAY_EXECUTE_ACTIVITY_HEARTBEAT_INTERVAL_SECONDS = 15;