deepline 0.1.228 → 0.1.230

package/dist/bundling-sources/apps/play-runner-workers/src/workflow-retry-state.ts

@@ -1,13 +1,6 @@
 import type { ExecutionPlan } from '../../../shared_libs/play-runtime/execution-plan';
-import type {
-  PlayCallGovernanceSnapshot,
-  PlayRunInputPayload,
-} from '../../../shared_libs/play-runtime/scheduler-backend';
+import type { PlayRunInputPayload } from '../../../shared_libs/play-runtime/scheduler-backend';
 import type { PreloadedRuntimeDbSession } from '../../../shared_libs/play-runtime/db-session';
-import type {
-  PlayRuntimeManifest,
-  PlayRuntimeManifestMap,
-} from '../../../shared_libs/plays/compiler-manifest';
 
 import {
   PLAY_SUBMIT_INPUT_INLINE_MAX_BYTES,
@@ -57,8 +50,6 @@ export type WorkflowRetryPlayParams = {
   }> | null;
   contractSnapshot?: unknown;
   executionPlan?: ExecutionPlan | null;
-  childPlayManifests?: PlayRuntimeManifestMap | null;
-  playCallGovernance?: PlayCallGovernanceSnapshot | null;
   preloadedDbSessions?: PreloadedRuntimeDbSession[] | null;
   preloadedDbSessionRef?: {
     runId: string;
@@ -100,7 +91,6 @@ export function buildWorkflowRetryParams<
     ...params,
     dynamicWorkerCode: null,
     contractSnapshot: stripRetrySourceSnapshot(params.contractSnapshot),
-    childPlayManifests: stripRetryChildManifestCode(params.childPlayManifests),
     packagedFiles: stripRetryPackagedFiles(params.packagedFiles),
   } satisfies WorkflowRetryPlayParams as TParams;
   if (jsonByteLength(retryParams) <= WORKFLOW_RETRY_STATE_TARGET_BYTES) {
@@ -112,9 +102,6 @@ export function buildWorkflowRetryParams<
       retryParams.contractSnapshot,
       params,
     ),
-    childPlayManifests: stripRetryChildManifestToArtifact(
-      retryParams.childPlayManifests,
-    ),
   } satisfies WorkflowRetryPlayParams as TParams;
 }
 
@@ -175,42 +162,6 @@ function stripRetryContractSnapshotToArtifact(
   };
 }
 
-function stripRetryChildManifestCode(
-  manifests: PlayRuntimeManifestMap | null | undefined,
-): PlayRuntimeManifestMap | null {
-  if (!manifests) return null;
-  const stripped: PlayRuntimeManifestMap = {};
-  for (const [key, manifest] of Object.entries(manifests)) {
-    const rest = { ...manifest };
-    delete rest.bundledCode;
-    delete rest.sourceCode;
-    delete (rest as Record<string, unknown>).sourceMap;
-    stripped[key] = rest;
-  }
-  return stripped;
-}
-
-function stripRetryChildManifestToArtifact(
-  manifests: PlayRuntimeManifestMap | null | undefined,
-): PlayRuntimeManifestMap | null {
-  if (!manifests) return null;
-  const stripped: PlayRuntimeManifestMap = {};
-  for (const [key, manifest] of Object.entries(manifests)) {
-    stripped[key] = {
-      playName: manifest.playName,
-      graphHash: manifest.graphHash,
-      artifactStorageKey: manifest.artifactStorageKey,
-      artifactHash: manifest.artifactHash,
-      staticPipelineHash: manifest.staticPipelineHash,
-      staticPipeline: manifest.staticPipeline,
-      compiledAt: manifest.compiledAt,
-      compilerVersion: manifest.compilerVersion,
-      maxCreditsPerRun: manifest.maxCreditsPerRun,
-    };
-  }
-  return stripped;
-}
-
 function isRecord(value: unknown): value is Record<string, unknown> {
   return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }

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

@@ -108,10 +108,10 @@ export const SDK_RELEASE = {
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
   // 0.1.220 deprecates SDK CLI versions below 0.1.219 and updates them
   // automatically without blocking their current command.
-  version: '0.1.228',
+  version: '0.1.230',
   apiContract: '2026-06-dataset-handle-results-hard-cutover',
   supportPolicy: {
-    latest: '0.1.228',
+    latest: '0.1.230',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.219',
     commandMinimumSupported: [

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

@@ -129,13 +129,10 @@ type RuntimeApiRequest =
       idempotencyKey?: string;
     }
   | {
-      action: 'start_inline_child_run';
+      action: 'start_run';
       idempotencyKey?: string;
       playName: string;
       runId: string;
-      parentRunId?: string | null;
-      rootRunId?: string | null;
-      workflowFamilyKey?: string | null;
       artifactStorageKey?: string | null;
       artifactHash?: string | null;
       graphHash?: string | null;
@@ -506,6 +503,20 @@ function isRetryableAppRuntimeResponse(input: {
   if (!isRetryableAppRuntimeAction(input.action)) {
     return false;
   }
+  // The app runtime may explicitly classify an otherwise-client-error status
+  // as transient. Keep the structured delivery contract authoritative rather
+  // than reducing every 4xx to permanent at the worker boundary.
+  try {
+    const parsed = JSON.parse(input.body) as unknown;
+    if (
+      parsed &&
+      typeof parsed === 'object' &&
+      !Array.isArray(parsed) &&
+      (parsed as { retryable?: unknown }).retryable === true
+    ) {
+      return true;
+    }
+  } catch {}
   if (
     input.action === 'append_run_events' &&
     input.status === 500 &&
@@ -659,7 +670,7 @@ function isRetryableAppRuntimeAction(
     action === 'release_runtime_step_receipt' ||
     action === 'save_results' ||
     action === 'skip_runtime_step_receipt' ||
-    action === 'start_inline_child_run'
+    action === 'start_run'
   );
 }
 
@@ -943,6 +954,40 @@ export class AppRuntimeApiTransportError extends Error {
   }
 }
 
+/**
+ * A non-2xx response from the app runtime boundary.
+ *
+ * Keep the response contract structured here so durable callers can decide
+ * whether to retry or block a delivery without parsing an error message.
+ */
+export class AppRuntimeApiResponseError extends Error {
+  readonly status: number;
+  readonly code: string | null;
+  readonly requestId: string | null;
+  readonly retryable: boolean;
+
+  constructor(input: {
+    action: RuntimeApiRequest['action'];
+    status: number;
+    code?: string | null;
+    requestId?: string | null;
+    retryable: boolean;
+    detail: string;
+  }) {
+    super(
+      `App runtime API ${input.action} failed with status ${input.status}` +
+        `${input.code ? ` code=${input.code}` : ''}` +
+        `${input.requestId ? ` request_id=${input.requestId}` : ''}: ` +
+        input.detail,
+    );
+    this.name = 'AppRuntimeApiResponseError';
+    this.status = input.status;
+    this.code = input.code?.trim() || null;
+    this.requestId = input.requestId?.trim() || null;
+    this.retryable = input.retryable;
+  }
+}
+
 function resolveAppRuntimeApiUrl(context: WorkerRuntimeApiContext): string {
   const baseUrl = context.baseUrl.trim().replace(/\/$/, '');
   return `${baseUrl}${PLAY_RUNTIME_API_COMPAT_PATH}`;
@@ -1155,12 +1200,22 @@ async function postAppRuntimeApi<TResponse>(
     });
     const code = appRuntimeErrorCode(response, responseText);
     const requestId = response.headers.get('x-deepline-request-id')?.trim();
-    throw new Error(
-      `App runtime API ${body.action} failed with status ${response.status}` +
-        `${code ? ` code=${code}` : ''}` +
-        `${requestId ? ` request_id=${requestId}` : ''}: ` +
-        summarizeAppRuntimeErrorBody(responseText),
-    );
+    throw new AppRuntimeApiResponseError({
+      action: body.action,
+      status: response.status,
+      code,
+      requestId,
+      // Immediate request retries are intentionally selective, but durable
+      // delivery must never classify an unrecognized upstream 5xx as poison.
+      retryable:
+        response.status >= 500 ||
+        isRetryableAppRuntimeResponse({
+          action: body.action,
+          status: response.status,
+          body: responseText,
+        }),
+      detail: summarizeAppRuntimeErrorBody(responseText),
+    });
   }
 
   throw new Error(`App runtime API ${body.action} failed after retries.`);
@@ -1557,9 +1612,6 @@ export async function startRunViaAppRuntime(
   input: {
     playName: string;
     runId: string;
-    parentRunId?: string | null;
-    rootRunId?: string | null;
-    workflowFamilyKey?: string | null;
     artifactStorageKey?: string | null;
     artifactHash?: string | null;
     graphHash?: string | null;
@@ -1574,7 +1626,7 @@ export async function startRunViaAppRuntime(
   },
 ): Promise<void> {
   await postAppRuntimeApi<{ ok: true }>(context, {
-    action: 'start_inline_child_run',
+    action: 'start_run',
     ...input,
   });
 }

package/dist/bundling-sources/shared_libs/play-runtime/child-execution-strategy.ts

@@ -3,101 +3,106 @@ import {
   type PlayStaticPipeline,
 } from '../plays/static-pipeline';
 import type { PlayCallExecution } from './play-call-execution';
-import { resolveChildExecutionPlacement } from './child-execution-placement';
 
-export type ChildExecutionStrategy = 'inline' | 'scheduled';
+/**
+ * `ctx.runPlay` is function composition.  It has exactly one execution
+ * placement: inline in the caller's run.  Do not add a scheduler fallback
+ * here: children that need their own run lifecycle must be top-level plays.
+ */
+export type ChildExecutionStrategy = 'inline';
 
 export type ChildExecutionDecision = {
   strategy: ChildExecutionStrategy;
-  reason:
-    | 'scalar_child'
-    | 'missing_static_contract'
-    | 'dataset_child'
-    | 'event_wait_child'
-    | 'explicit_timeout'
-    | 'explicit_inline'
-    | 'explicit_child_workflow';
+  reason: 'scalar_child' | 'explicit_inline';
 };
 
+export type CtxRunPlayInlineOnlyReason =
+  | 'missing_static_contract'
+  | 'dataset_child'
+  | 'event_wait_child'
+  | 'suspending_child'
+  | 'explicit_timeout'
+  | 'explicit_child_workflow';
+
+/** Stable machine-readable prefix for every rejected ctx.runPlay shape. */
+export const CTX_RUN_PLAY_INLINE_ONLY = 'CTX_RUN_PLAY_INLINE_ONLY';
+
+/**
+ * One public error for every unsupported child contract. The checker and
+ * runtime deliberately call this same helper so a dynamic child fails with
+ * the same actionable error as a statically known child.
+ */
+export function ctxRunPlayInlineOnlyMessage(
+  childPlayName: string,
+  reason: CtxRunPlayInlineOnlyReason,
+): string {
+  const detail: Record<CtxRunPlayInlineOnlyReason, string> = {
+    missing_static_contract: 'its static contract could not be resolved',
+    dataset_child: 'it uses ctx.dataset(), ctx.csv(), or a Runtime Sheet',
+    event_wait_child: 'it waits for an event',
+    suspending_child: 'it attempted to suspend the parent execution',
+    explicit_timeout: 'it sets an explicit timeout',
+    explicit_child_workflow: 'it requests execution: "child-workflow"',
+  };
+  return (
+    `${CTX_RUN_PLAY_INLINE_ONLY}: ctx.runPlay("${childPlayName}") only composes a resolved scalar child; ` +
+    `${detail[reason]}. Move that work to a top-level play and compose only the scalar result.`
+  );
+}
+
 /**
- * Choose execution placement from the child's authored contract. Scalar child
- * plays are ordinary function composition. Dataset and event-wait children own
- * independent durable state, so they remain scheduler jobs.
+ * Resolve an authored child contract. Any shape that would need a second run,
+ * durable scheduler state, or a suspension is rejected before invocation.
  */
 export function resolveChildExecutionStrategy(input: {
   pipeline: PlayStaticPipeline | null | undefined;
   timeoutMs?: number | null;
-  execution?: PlayCallExecution | null;
+  hasExplicitTimeout?: boolean;
+  /** `child-workflow` remains accepted as parsed legacy source solely to emit
+   * the canonical migration error rather than silently scheduling it. */
+  execution?: PlayCallExecution | 'child-workflow' | null;
   childPlayName?: string | null;
 }): ChildExecutionDecision {
+  const childPlayName = input.childPlayName?.trim() || 'child';
   if (input.execution === 'child-workflow') {
-    return { strategy: 'scheduled', reason: 'explicit_child_workflow' };
+    throw new Error(
+      ctxRunPlayInlineOnlyMessage(childPlayName, 'explicit_child_workflow'),
+    );
   }
-  const steps = input.pipeline ? flattenStaticPipeline(input.pipeline) : [];
-  const authoredDecision: ChildExecutionDecision =
-    input.timeoutMs != null
-      ? { strategy: 'scheduled', reason: 'explicit_timeout' }
-      : !input.pipeline
-        ? { strategy: 'scheduled', reason: 'missing_static_contract' }
-        : input.pipeline.tableNamespace ||
-            input.pipeline.sheetContract ||
-            steps.some((step) => step.type === 'dataset' || step.type === 'csv')
-          ? { strategy: 'scheduled', reason: 'dataset_child' }
-          : steps.some(
-                (step) =>
-                  step.type === 'tool' &&
-                  (step.isEventWait || step.toolId === 'test_wait_for_event'),
-              )
-            ? { strategy: 'scheduled', reason: 'event_wait_child' }
-            : { strategy: 'inline', reason: 'scalar_child' };
-  if (input.execution === 'inline') {
-    if (
-      authoredDecision.strategy === 'scheduled' &&
-      authoredDecision.reason !== 'missing_static_contract'
-    ) {
-      throw new Error(
-        inlineExecutionRequiresScalarChildMessage(
-          input.childPlayName?.trim() || 'child',
-          authoredDecision.reason,
-        ),
-      );
-    }
-    return { strategy: 'inline', reason: 'explicit_inline' };
+  if (!input.pipeline) {
+    throw new Error(
+      ctxRunPlayInlineOnlyMessage(childPlayName, 'missing_static_contract'),
+    );
   }
-  const placement = resolveChildExecutionPlacement({
-    requiresWorkflow: authoredDecision.strategy === 'scheduled',
-    execution: input.execution,
-  });
-  if (placement.strategy === 'inline') {
-    return { strategy: 'inline', reason: 'scalar_child' };
+  if (input.hasExplicitTimeout === true || input.timeoutMs != null) {
+    throw new Error(
+      ctxRunPlayInlineOnlyMessage(childPlayName, 'explicit_timeout'),
+    );
   }
-  return authoredDecision;
-}
 
-export function inlineExecutionRequiresScalarChildMessage(
-  childPlayName: string,
-  reason: ChildExecutionDecision['reason'],
-): string {
-  return (
-    `ctx.runPlay("${childPlayName}") requested execution: "inline", but the child requires a child workflow ` +
-    `(${reason}). Remove the explicit execution option or use execution: "child-workflow".`
-  );
-}
-
-/**
- * Verbatim rejection message for a scheduling-required child invoked per row.
- * Shared by the static preflight (`plays check`/publish gate) and the runtime
- * launch guard so a dynamically-named child fails with the EXACT same text as a
- * statically-provable one. See ADR 0013.
- */
-export function inlineChildScheduledInRowMessage(
-  childPlayName: string,
-  rowContextField: string,
-): string {
-  return (
-    `ctx.runPlay("${childPlayName}") runs per row in the "${rowContextField}" batch, ` +
-    'but it is a scheduling-required child (it uses ctx.dataset()/ctx.csv(), waits on an ' +
-    'event, sets an explicit timeout, or explicitly requests a child workflow). Row-scoped children must be scalar. ' +
-    'Give the batch ONE dataset child at play level instead of fanning a scheduled run out per row.'
-  );
+  const steps = flattenStaticPipeline(input.pipeline);
+  if (
+    input.pipeline.tableNamespace ||
+    input.pipeline.sheetContract ||
+    steps.some((step) => step.type === 'dataset' || step.type === 'csv')
+  ) {
+    throw new Error(
+      ctxRunPlayInlineOnlyMessage(childPlayName, 'dataset_child'),
+    );
+  }
+  if (
+    steps.some(
+      (step) =>
+        step.type === 'tool' &&
+        (step.isEventWait || step.toolId === 'test_wait_for_event'),
+    )
+  ) {
+    throw new Error(
+      ctxRunPlayInlineOnlyMessage(childPlayName, 'event_wait_child'),
+    );
+  }
+  return {
+    strategy: 'inline',
+    reason: input.execution === 'inline' ? 'explicit_inline' : 'scalar_child',
+  };
 }