deepline 0.1.228 → 0.1.230

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

@@ -2,10 +2,6 @@ export const PLAY_RUNTIME_API_COMPAT_PATH = '/api/v2/plays/internal/runtime';
 export const PLAY_RUNTIME_API_CURRENT_PATH = '/api/v2/internal/play-runtime';
 export const PLAY_RUNTIME_ATTEMPT_EXECUTOR_TOKEN_PATH =
   '/api/v2/internal/play-runtime/executor-token';
-export const PLAY_RUNTIME_CHILD_EXECUTOR_TOKEN_COMPAT_PATH =
-  '/api/v2/plays/internal/child-executor-token';
-export const PLAY_RUNTIME_CHILD_EXECUTOR_TOKEN_CURRENT_PATH =
-  '/api/v2/internal/play-runtime/child-executor-token';
 export const PLAY_RUNTIME_TAIL_LOG_COMPAT_PATH =
   '/api/v2/plays/internal/tail-log';
 export const PLAY_RUNTIME_TAIL_LOG_CURRENT_PATH =

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

@@ -371,7 +371,22 @@ export type ResolvedRuntimePlay = {
   sourceCode?: string | null;
   artifact?: PlayBundleArtifact | null;
   codeFormat?: 'function' | 'cjs_module' | 'esm_module';
+  /**
+   * The runtime must receive the child contract with its artifact. Inline
+   * composition rejects unresolved or dataset-backed children before running
+   * their code, so dropping this field at the API boundary makes valid scalar
+   * children indistinguishable from unknown ones.
+   */
+  staticPipeline?: PlayStaticPipeline | null;
   contractSnapshot?: Record<string, unknown> | null;
+  /** Preview-only contract propagation evidence, emitted by the server and
+   * logged by the runner while diagnosing a cross-runtime child resolution
+   * failure. It intentionally contains no source, inputs, or credentials. */
+  resolutionDiagnostics?: {
+    serverPlayPipeline: boolean;
+    manifestPipeline: boolean;
+    responsePipeline: boolean;
+  } | null;
 };
 
 export type PrepareRuntimeSheetResult = {
@@ -2951,15 +2966,28 @@ export async function resolveRuntimeReferencedPlay(
   playRef: string,
   options?: { artifactKind?: PlayArtifactKind },
 ): Promise<ResolvedRuntimePlay | null> {
-  const response = await postRuntimeApi<{ play: ResolvedRuntimePlay | null }>(
-    context,
-    {
-      action: 'resolve_play',
-      playRef,
-      ...(options?.artifactKind ? { artifactKind: options.artifactKind } : {}),
-    },
-  );
-  return response.play;
+  const response = await postRuntimeApi<{
+    play: ResolvedRuntimePlay | null;
+    manifest?: { staticPipeline?: PlayStaticPipeline | null } | null;
+  }>(context, {
+    action: 'resolve_play',
+    playRef,
+    ...(options?.artifactKind ? { artifactKind: options.artifactKind } : {}),
+  });
+  if (!response.play) {
+    return null;
+  }
+
+  // The server builds the manifest and child artifact together. Its manifest
+  // carries the canonical empty scalar contract when a published scalar's
+  // revision snapshot has no pipeline. Keep that contract on the object the
+  // runner passes to ctx.runPlay; otherwise a valid scalar leaf arrives as an
+  // indistinguishable "missing static contract" at runtime.
+  return {
+    ...response.play,
+    staticPipeline:
+      response.play.staticPipeline ?? response.manifest?.staticPipeline ?? null,
+  };
 }
 
 export async function ensureRuntimeSheet(

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backend.ts

@@ -17,7 +17,6 @@ import type {
   PlayRowUpdate,
 } from './ctx-types';
 import type { ExecutionPlan } from './execution-plan';
-import type { PlayRuntimeManifestMap } from '../plays/compiler-manifest';
 import type { PreloadedRuntimeDbSession } from './db-session';
 import type { RuntimeAuthorityDescriptor } from './execution-capabilities';
 import type { PlayRunnerRuntimeTiming } from './protocol';
@@ -42,39 +41,6 @@ export type PlaySchedulerBackendId =
 
 export type { PlayRunInputPayload };
 
-export type PlayCallGovernanceSnapshot = {
-  rootRunId: string;
-  parentRunId: string;
-  parentPlayName: string;
-  key: string;
-  ancestryPlayIds: string[];
-  callDepth: number;
-  /**
-   * Cumulative lineage-global budget counters consumed by ancestors at the
-   * moment this child was launched. The child seeds its own counters from these
-   * so the corresponding budgets (`maxPlayCallCount`, `maxToolCallCount`,
-   * `maxRetryCount`, `maxDescendants`, `maxWaterfallStepExecutions`) accumulate
-   * down the dispatch lineage instead of resetting to 0 in each worker isolate —
-   * matching the cjs forkChild path, which threads all of them. The Governor
-   * documents these budgets as global across the nested-play tree, not
-   * per-worker (see policy.ts / rate-state-backend.ts); threading them here is
-   * what makes that true on `esm_workers`.
-   *
-   * `descendantCount` is load-bearing for fan-out: forkChild charges
-   * `descendant` on every child launch, so without threading it a deep/wide tree
-   * would reset descendant accounting at each isolate and never converge on the
-   * lineage-global cap.
-   *
-   * All optional and fail-safe: if absent (older callers / dropped in transit)
-   * the child falls back to 0, i.e. prior behavior.
-   */
-  playCallCount?: number;
-  toolCallCount?: number;
-  retryCount?: number;
-  descendantCount?: number;
-  waterfallStepExecutions?: number;
-};
-
 export type PlaySchedulerSubmitInput = {
   runId: string;
   playId: string;
@@ -122,8 +88,6 @@ export type PlaySchedulerSubmitInput = {
   }> | null;
   contractSnapshot?: unknown;
   executionPlan?: ExecutionPlan | null;
-  childPlayManifests?: PlayRuntimeManifestMap | null;
-  playCallGovernance?: PlayCallGovernanceSnapshot | null;
   preloadedDbSessions?: PreloadedRuntimeDbSession[] | null;
   /**
    * Secret that decrypts `preloadedDbSessions` postgres URLs. Equals the run's

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

@@ -18,20 +18,6 @@ export type PlayExecutionSuspension =
         timeoutMs: number;
       }>;
     }
-  | {
-      kind: 'child_play';
-      boundaryId: string;
-      childRunId: string;
-      childPlayName: string;
-    }
-  | {
-      kind: 'child_play_batch';
-      boundaries: Array<{
-        boundaryId: string;
-        childRunId: string;
-        childPlayName: string;
-      }>;
-    }
   | {
       /**
        * Push-execution park (B2-final): the Daytona runner command was started
@@ -72,13 +58,9 @@ export class PlayExecutionSuspendedError extends Error {
         ? `Play execution suspended for durable sleep (${suspension.delayMs}ms).`
         : suspension.kind === 'integration_event_batch'
           ? `Play execution suspended waiting for ${suspension.boundaries.length} integration events.`
-          : suspension.kind === 'child_play_batch'
-            ? `Play execution suspended waiting for ${suspension.boundaries.length} child plays.`
-            : suspension.kind === 'child_play'
-              ? `Play execution suspended waiting for child play ${JSON.stringify(suspension.childPlayName)}.`
-              : suspension.kind === 'detached_runner'
-                ? `Play execution parked on detached runner ${suspension.cmdId} (sandbox ${suspension.sandboxId}).`
-                : `Play execution suspended waiting for integration event ${JSON.stringify(suspension.eventKey)}.`,
+          : suspension.kind === 'detached_runner'
+            ? `Play execution parked on detached runner ${suspension.cmdId} (sandbox ${suspension.sandboxId}).`
+            : `Play execution suspended waiting for integration event ${JSON.stringify(suspension.eventKey)}.`,
     );
     this.name = 'PlayExecutionSuspendedError';
     this.suspension = suspension;

package/dist/bundling-sources/shared_libs/play-runtime/test-runtime-seams.ts

@@ -5,7 +5,14 @@ export const PLAY_RUNTIME_TEST_FAULT_HEADER = 'x-deepline-test-fault';
 export type RuntimeTestFaultName =
   | 'receipt_complete_write_fail'
   | 'receipt_fail_write_fail'
-  | 'worker_receipt_complete_write_fail';
+  | 'worker_receipt_complete_write_fail'
+  /**
+   * Holds an already checked-out receipt-gateway scheduler client for the
+   * supplied bounded millisecond value. Preview/CI only: this creates a
+   * deterministic real-Pg-pool pressure window without changing an action's
+   * SQL or outcome.
+   */
+  | 'receipt_gateway_hold_ms';
 
 export type RuntimeTestFaultRegistry = {
   consume(name: RuntimeTestFaultName): boolean;
@@ -63,6 +70,7 @@ const SUPPORTED_RUNTIME_TEST_FAULTS = new Set<RuntimeTestFaultName>([
   'receipt_complete_write_fail',
   'receipt_fail_write_fail',
   'worker_receipt_complete_write_fail',
+  'receipt_gateway_hold_ms',
 ]);
 
 const RUNTIME_TEST_POLICY_MS_FIELDS = new Set([

package/dist/bundling-sources/shared_libs/plays/static-pipeline.ts

@@ -586,6 +586,8 @@ export type PlayStaticSubstep = PlayStaticSubstepMetadata &
         type: 'play_call';
         playId: string;
         execution?: 'inline' | 'child-workflow';
+        timeoutMs?: number;
+        hasExplicitTimeout?: boolean;
         field: string;
         inLoop?: boolean;
         pipeline?: PlayStaticPipeline | null;

package/dist/cli/index.js

@@ -625,10 +625,10 @@ var 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: [
@@ -17886,8 +17886,6 @@ function renderExecuteStep(command, options = {
     force: true` : "";
   const legacyEnvelope = options.legacyEnvelope ? `,
     legacyEnvelope: true` : "";
-  const waterfallSoftFail = options.waterfallSoftFail ? `,
-    waterfallSoftFail: true` : "";
   return [
     `async (row, stepCtx) => {`,
     ...options.precheck ? [`  if (${options.precheck}) return null;`] : [],
@@ -17899,7 +17897,7 @@ function renderExecuteStep(command, options = {
     `    extract: ${extractJs},`,
     `    runIf: ${runIfJs},`,
     `    row,`,
-    `    stepCtx${description}${force}${legacyEnvelope}${waterfallSoftFail}`,
+    `    stepCtx${description}${force}${legacyEnvelope}`,
     `  });`,
     `}`
   ].join("\n");
@@ -17959,18 +17957,14 @@ function renderIdiomaticExecuteStep(command, options) {
     `async (row, ctx) => {`,
     ...options.precheck ? [`  if (${options.precheck}) return null;`] : [],
     ...runIfLines,
-    `  let result: any;`,
-    `  try {`,
-    `    result = await ctx.tools.execute({`,
-    `      id: ${callId},`,
-    `      tool: ${tool},`,
-    `      input: ${input2} as any,`,
-    `      description: ${stringLiteral((command.description ?? "").trim() || `Run ${command.alias} via ${command.tool}.`)},`,
+    `  const result: any = await ctx.tools.execute({`,
+    `    id: ${callId},`,
+    `    tool: ${tool},`,
+    `    input: ${input2} as any,`,
+    `    description: ${stringLiteral((command.description ?? "").trim() || `Run ${command.alias} via ${command.tool}.`)},`,
     ...options.force ? [`      force: true,`] : [],
-    `    });`,
-    `  } catch (error) {`,
-    ...options.waterfallSoftFail ? [`    return __dlWaterfallToolFailure(error);`] : [`    throw error;`],
-    `  }`,
+    `  });`,
+    `  __dlAssertSuccessfulToolResult(result);`,
     `  return ${extraction};`,
     `}`
   ].join("\n");
@@ -17994,21 +17988,19 @@ function renderPlayStep(command, options) {
     ...runIfLines,
     `  const payload = __dlTemplate(${payload}, templateRow) as Record<string, unknown>;`,
     `  if (__dlShouldSkipBlankPlayPayload(payload)) return null;`,
-    `  let result: unknown;`,
-    `  try {`,
+    `  const result: unknown = `,
     ...inlineHandler ? [
       // Enrich validates and normalizes this payload against the certified
       // prebuilt contract before code generation. The attachment retains
       // its concrete input type, while generated payloads are records.
-      `    result = await __dlRunInlinePlay(${inlineHandler}, stepCtx, payload as never, ${options.force});`
+      `    await __dlRunInlinePlay(${inlineHandler}, stepCtx, payload as never, ${options.force});`
     ] : [
-      `    result = await stepCtx.runPlay(${callId}, ${playRef}, payload, {`,
-      `        description: ${stringLiteral(command.description ?? command.alias)}`,
+      `    await stepCtx.runPlay(${callId}, ${playRef}, payload, {`,
+      `      description: ${stringLiteral(command.description ?? command.alias)}`,
       `    });`
     ],
-    `  } catch (error) {`,
-    ...options.waterfallSoftFail ? [`    return __dlWaterfallToolFailure(error);`] : [`    throw error;`],
-    `  }`,
+    ``,
+    `  __dlAssertSuccessfulToolResult(result);`,
     `  return __dlPlayResultValue(${alias}, result);`,
     `}`
   ].join("\n");
@@ -18042,23 +18034,17 @@ function renderInlineJavascriptStep(command, options) {
     `async (row) => {`,
     ...options.precheck ? [`  if (${options.precheck}) return null;`] : [],
     ...runIfLines,
-    ...options.waterfallSoftFail ? [`  try {`] : [],
-    `${options.waterfallSoftFail ? "    " : "  "}const __dlPayload = __dlRuntimePayload('run_javascript', __dlTemplate(${payload}, row as Record<string, unknown>) as Record<string, unknown>, row as Record<string, unknown>);`,
-    `${options.waterfallSoftFail ? "    " : "  "}const rawResult = ((row: Record<string, any>, input: Record<string, any>, context: Record<string, any>) => {`,
-    `${options.waterfallSoftFail ? "    " : "  "}  const payload = __dlPayload as Record<string, any>;`,
-    `${options.waterfallSoftFail ? "    " : "  "}  const extract = __dlInlineExtract;`,
-    `${options.waterfallSoftFail ? "    " : "  "}  const extractList = __dlInlineExtractList;`,
-    `${options.waterfallSoftFail ? "    " : "  "}  return (() => {`,
+    `  const __dlPayload = __dlRuntimePayload('run_javascript', __dlTemplate(${payload}, row as Record<string, unknown>) as Record<string, unknown>, row as Record<string, unknown>);`,
+    `  const rawResult = ((row: Record<string, any>, input: Record<string, any>, context: Record<string, any>) => {`,
+    `    const payload = __dlPayload as Record<string, any>;`,
+    `    const extract = __dlInlineExtract;`,
+    `    const extractList = __dlInlineExtractList;`,
+    `    return (() => {`,
     indent(renderJavascriptBody(code), 4),
-    `${options.waterfallSoftFail ? "    " : "  "}  })();`,
-    `${options.waterfallSoftFail ? "    " : "  "}})(row as Record<string, any>, row as Record<string, any>, row as Record<string, any>);`,
-    `${options.waterfallSoftFail ? "    " : "  "}const result = await Promise.resolve(rawResult);`,
-    `${options.waterfallSoftFail ? "    " : "  "}return ${resultExpression};`,
-    ...options.waterfallSoftFail ? [
-      `  } catch (error) {`,
-      `    return __dlExtractorFailure(error);`,
-      `  }`
-    ] : [],
+    `    })();`,
+    `  })(row as Record<string, any>, row as Record<string, any>, row as Record<string, any>);`,
+    `  const result = await Promise.resolve(rawResult);`,
+    `  return ${resultExpression};`,
     `}`
   ].join("\n");
 }
@@ -18192,7 +18178,6 @@ function renderWaterfallColumns(command, forceAliases, inlineRunJavascript, idio
         legacyEnvelope: Boolean(nested.extract_js),
         inlineRunJavascript,
         idiomaticGetters,
-        waterfallSoftFail: true,
         nativeRunIf: Boolean(runIfSource)
       }),
       {
@@ -18526,6 +18511,14 @@ function helperSource() {
     `  return status === 'error' || status === 'failed' || (typeof record.error === 'string' && record.error.trim() !== '') || (typeof resultError === 'string' && resultError.trim() !== '');`,
     `}`,
     ``,
+    `function __dlAssertSuccessfulToolResult(value: unknown): void {`,
+    `  if (!__dlErrorPayload(value)) return;`,
+    `  const record = value as Record<string, unknown>;`,
+    `  const result = record.result && typeof record.result === 'object' && !Array.isArray(record.result) ? record.result as Record<string, unknown> : null;`,
+    `  const message = typeof record.error === 'string' ? record.error : typeof result?.error === 'string' ? result.error : typeof result?.message === 'string' ? result.message : 'Tool returned an error-shaped result.';`,
+    `  throw new Error(message);`,
+    `}`,
+    ``,
     `function __dlGeneratedCellError(value: unknown): boolean {`,
     `  if (typeof value === 'string') {`,
     `    const lower = value.trim().toLowerCase();`,
@@ -18916,37 +18909,6 @@ function helperSource() {
     `  return keys ? __dlProjectListRows(rows, keys, payload) : rows;`,
     `}`,
     ``,
-    `function __dlErrorMessage(error: unknown): string {`,
-    `  if (error instanceof Error && error.message) return error.message;`,
-    `  if (typeof error === 'string' && error.trim()) return error.trim();`,
-    `  return 'Extractor failed';`,
-    `}`,
-    ``,
-    `function __dlErrorDetail(error: unknown): string {`,
-    `  const message = __dlErrorMessage(error);`,
-    `  if (!__dlRecord(error)) return message;`,
-    `  try {`,
-    `    return message + ' ' + JSON.stringify(error);`,
-    `  } catch {`,
-    `    return message;`,
-    `  }`,
-    `}`,
-    ``,
-    `function __dlRecoverableWaterfallToolError(error: unknown): boolean {`,
-    `  const detail = __dlErrorDetail(error).toLowerCase();`,
-    `  return /\\b5\\d\\d\\b/.test(detail) || detail.includes('upstream_failure') || detail.includes('"error_category":"upstream"') || (detail.includes('"failure_origin":"provider"') && detail.includes('"status":5')) || detail.includes('bad gateway') || detail.includes('gateway time-out') || detail.includes('gateway timeout') || detail.includes('service unavailable');`,
-    `}`,
-    ``,
-    `function __dlWaterfallToolFailure(error: unknown, tool?: string): unknown {`,
-    `  if (tool === 'run_javascript' || __dlRecoverableWaterfallToolError(error)) return __dlExtractorFailure(error);`,
-    `  throw error;`,
-    `}`,
-    ``,
-    `function __dlExtractorFailure(error: unknown): unknown {`,
-    `  const message = __dlErrorMessage(error);`,
-    `  return { matched_result: null, result: { error: message, message } };`,
-    `}`,
-    ``,
     `function __dlExtract(alias: string, result: unknown, row: Record<string, unknown>, extractor: ((args: __DlExtractorHelpers) => unknown) | null, legacyEnvelope = false): unknown {`,
     `  const raw = __dlRawToolOutput(result);`,
     `  if (!extractor) return raw;`,
@@ -18987,12 +18949,8 @@ function helperSource() {
     `  };`,
     `  const get = (path: string): unknown => __dlExtractedValue(result, path) ?? __dlFirstByPaths(raw, path);`,
     `  let resolved: unknown;`,
-    `  try {`,
-    `    const extracted = extractor({ row, result, data: raw, raw, pick, extract, extractList, target: pick, get });`,
-    `    resolved = typeof extracted === 'function' ? (extracted as (outputData: unknown) => unknown)(__dlLegacyOutputData(result, raw)) : extracted;`,
-    `  } catch (error) {`,
-    `    return __dlExtractorFailure(error);`,
-    `  }`,
+    `  const extracted = extractor({ row, result, data: raw, raw, pick, extract, extractList, target: pick, get });`,
+    `  resolved = typeof extracted === 'function' ? (extracted as (outputData: unknown) => unknown)(__dlLegacyOutputData(result, raw)) : extracted;`,
     `  if (resolved && typeof resolved === 'object' && !Array.isArray(resolved) && alias in (resolved as Record<string, unknown>)) {`,
     `    const aliasValue = (resolved as Record<string, unknown>)[alias];`,
     `    return legacyEnvelope && __dlMeaningful(aliasValue) ? __dlLegacyMatchedEnvelope(aliasValue, raw) : aliasValue;`,
@@ -19082,26 +19040,21 @@ function helperSource() {
     `  return result;`,
     `}`,
     ``,
-    `async function __dlRunCommand(input: { alias: string; callId: string; tool: string; payload: Record<string, unknown>; extract: ((args: __DlExtractorHelpers) => unknown) | null; runIf: ((row: Record<string, unknown>) => unknown) | null; row: Record<string, unknown>; stepCtx: { tools: { execute: (request: Record<string, unknown>) => Promise<unknown> } }; description?: string; force?: boolean; legacyEnvelope?: boolean; waterfallSoftFail?: boolean }): Promise<unknown> {`,
+    `async function __dlRunCommand(input: { alias: string; callId: string; tool: string; payload: Record<string, unknown>; extract: ((args: __DlExtractorHelpers) => unknown) | null; runIf: ((row: Record<string, unknown>) => unknown) | null; row: Record<string, unknown>; stepCtx: { tools: { execute: (request: Record<string, unknown>) => Promise<unknown> } }; description?: string; force?: boolean; legacyEnvelope?: boolean }): Promise<unknown> {`,
     `  if (input.runIf) {`,
     `    const shouldRun = input.runIf(input.row);`,
     `    if (!shouldRun) return null;`,
     `  }`,
     `  const payload = __dlRuntimePayload(input.tool, __dlTemplate(input.payload, input.row) as Record<string, unknown>, input.row);`,
     `  if (__dlShouldSkipEmptyPayload(input.tool, payload)) return null;`,
-    `  let result: unknown;`,
-    `  try {`,
-    `    result = await input.stepCtx.tools.execute({`,
-    `      id: input.callId,`,
-    `      tool: input.tool,`,
-    `      input: payload,`,
-    `      ...(input.description ? { description: input.description } : {}),`,
-    `      ...(input.force ? { force: true } : {}),`,
-    `    });`,
-    `  } catch (error) {`,
-    `    if (input.waterfallSoftFail) return __dlWaterfallToolFailure(error, input.tool);`,
-    `    throw error;`,
-    `  }`,
+    `  const result = await input.stepCtx.tools.execute({`,
+    `    id: input.callId,`,
+    `    tool: input.tool,`,
+    `    input: payload,`,
+    `    ...(input.description ? { description: input.description } : {}),`,
+    `    ...(input.force ? { force: true } : {}),`,
+    `  });`,
+    `  __dlAssertSuccessfulToolResult(result);`,
     `  return __dlExtract(input.alias, result, input.row, input.extract, Boolean(input.legacyEnvelope));`,
     `}`
   ].join("\n");