deepline 0.1.208 → 0.1.209

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

@@ -10,3 +10,15 @@ export const PLAY_RUNNER_TIMEOUT_SECONDS = 30 * 60;
 
 /** TTL for workflow executor tokens, in seconds. */
 export const WORKFLOW_EXECUTOR_TOKEN_TTL_SECONDS = PLAY_RUNNER_TIMEOUT_SECONDS;
+
+/**
+ * Absurd run-claim lease window, in seconds. The scheduler expires a claim whose
+ * `claim_expires_at` falls this far behind, so whoever owns execution must renew
+ * within this window. Shared between the worker's own lease heartbeat and the
+ * Daytona push-execution runner (which heartbeats the receipt gateway on a
+ * `RUNTIME_CLAIM_LEASE_SECONDS / 3` cadence) so both agree on the deadline.
+ */
+export const RUNTIME_CLAIM_LEASE_SECONDS = 120;
+
+/** Heartbeat cadence divisor: renew the claim this many times per lease window. */
+export const RUNTIME_CLAIM_HEARTBEAT_DIVISOR = 3;

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

@@ -31,8 +31,38 @@ export type PlayExecutionSuspension =
         childRunId: string;
         childPlayName: string;
       }>;
+    }
+  | {
+      /**
+       * Push-execution park (B2-final): the Daytona runner command was started
+       * DETACHED and the worker parks instead of holding anything. The parked
+       * attempt wakes on the runner's pushed terminal (the gateway emits the
+       * absurd wake event) or on the ceiling timeout, then finalizes from
+       * persisted state.
+       */
+      kind: 'detached_runner';
+      boundaryId: string;
+      /** Attempt generation whose executor token the detached runner holds —
+       * the key under which its pushed terminal is recorded and its wake event
+       * is named. */
+      runnerAttempt: number;
+      sandboxId: string;
+      sessionId: string;
+      cmdId: string;
+      /** Captured output/exit-code file paths inside the sandbox, used by the
+       * timeout-wake salvage verification. */
+      outputPath: string;
+      exitCodePath: string;
+      startedAtMs: number;
+      /** Overall run ceiling; the park timeout. */
+      ceilingMs: number;
     };
 
+export type DetachedRunnerSuspension = Extract<
+  PlayExecutionSuspension,
+  { kind: 'detached_runner' }
+>;
+
 export class PlayExecutionSuspendedError extends Error {
   readonly suspension: PlayExecutionSuspension;
 
@@ -46,7 +76,9 @@ export class PlayExecutionSuspendedError extends Error {
             ? `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)}.`
-              : `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/tool-http-errors.ts

@@ -97,6 +97,16 @@ function normalizeHardBillingPayload(
   };
 }
 
+function receiptFailureKindForToolErrorPayload(
+  payload: Record<string, unknown> | null,
+): WorkReceiptFailureKind {
+  const code = getStringField(payload, 'code')?.toUpperCase();
+  // A credential connection can be added or replaced between play runs. Keep
+  // the failure terminal within its owning run, but let a later run reclaim
+  // the durable receipt instead of replaying stale authorization state.
+  return code === 'INTEGRATION_CREDENTIALS_MISSING' ? 'repairable' : 'terminal';
+}
+
 function formatHardBillingFailureMessage(input: {
   billing: Record<string, unknown>;
   toolId: string;
@@ -226,6 +236,7 @@ export function normalizeToolHttpErrorMessage(input: {
     )}`,
     billing,
     input.status,
+    receiptFailureKindForToolErrorPayload(parsed),
   );
 }
 

package/dist/bundling-sources/shared_libs/plays/artifact-kind-guard.ts

@@ -0,0 +1,112 @@
+import type { PlayArtifactKind, PlayBundleArtifact } from './artifact-types';
+
+/**
+ * Loud, directional guard that stops a Cloudflare-Workers (`esm_workers`)
+ * bundle from reaching a Node/Daytona (`cjs_node20`) runner.
+ *
+ * The Node runner loads play code with `Module._compile`, which cannot resolve
+ * `cloudflare:workers` scheme imports and dies with the opaque
+ * `ERR_UNSUPPORTED_ESM_URL_SCHEME: Received protocol 'cloudflare:'`. Those
+ * imports only exist in the Cloudflare Workers harness apps
+ * (`apps/play-runner-workers/`, `apps/play-harness-worker/`) baked into
+ * `esm_workers` artifacts. When the wrong artifact kind is targeted for a node
+ * profile (e.g. the absurd/Daytona scheduler falling back to a verbatim stored
+ * `esm_workers` bundle), this guard fires at the targeting/load seam with a
+ * message that names the mismatch instead of surfacing the ESM scheme error.
+ */
+
+/**
+ * Legacy artifacts predate the `artifactKind` field; they are always
+ * `cjs_node20` (the only kind that existed before the workers split). Mirror the
+ * default documented on `PlayBundleArtifact.artifactKind`.
+ */
+export function artifactKindOf(artifact: PlayBundleArtifact): PlayArtifactKind {
+  return artifact.artifactKind ?? 'cjs_node20';
+}
+
+/**
+ * Detect `cloudflare:` scheme imports in bundled code. Matches both static
+ * `import ... from 'cloudflare:workers'` and `require('cloudflare:...')` forms,
+ * with single or double quotes. This is the exact shape the Node runner cannot
+ * load.
+ */
+const CLOUDFLARE_SCHEME_IMPORT =
+  /(?:\bfrom\s*|\bimport\s*|\brequire\s*\(\s*)['"]cloudflare:[^'"]*['"]/;
+
+export function bundledCodeHasCloudflareSchemeImport(
+  bundledCode: string,
+): boolean {
+  return CLOUDFLARE_SCHEME_IMPORT.test(bundledCode);
+}
+
+export class PlayArtifactKindMismatchError extends Error {
+  readonly expectedKind: PlayArtifactKind;
+  readonly actualKind: PlayArtifactKind;
+  readonly reason: 'kind_mismatch' | 'cloudflare_scheme_import';
+
+  constructor(input: {
+    expectedKind: PlayArtifactKind;
+    actualKind: PlayArtifactKind;
+    reason: 'kind_mismatch' | 'cloudflare_scheme_import';
+    message: string;
+  }) {
+    super(input.message);
+    this.name = 'PlayArtifactKindMismatchError';
+    this.expectedKind = input.expectedKind;
+    this.actualKind = input.actualKind;
+    this.reason = input.reason;
+  }
+}
+
+/**
+ * Assert an artifact is loadable by the Node (`cjs_node20`) runner. Throws a
+ * `PlayArtifactKindMismatchError` naming the run/profile and expected vs actual
+ * kind if the artifact is an `esm_workers` bundle or carries `cloudflare:`
+ * scheme imports.
+ *
+ * `context` is a short human-readable locator (run id, play name, submit path)
+ * woven into the error so the failure points at the wrong targeting decision,
+ * not the downstream ESM scheme error.
+ */
+export function assertNodeRunnableArtifact(input: {
+  artifact: PlayBundleArtifact;
+  expectedKind: PlayArtifactKind;
+  context: string;
+}): void {
+  const { artifact, expectedKind, context } = input;
+  if (expectedKind !== 'cjs_node20') {
+    // This helper only guards the node runner. A workers-edge target never
+    // reaches the Node/Daytona load path, so there is nothing to assert.
+    return;
+  }
+
+  const actualKind = artifactKindOf(artifact);
+  if (actualKind !== 'cjs_node20') {
+    throw new PlayArtifactKindMismatchError({
+      expectedKind,
+      actualKind,
+      reason: 'kind_mismatch',
+      message:
+        `Node runner (${context}) received a "${actualKind}" play artifact but ` +
+        `requires "cjs_node20". An "esm_workers" bundle embeds the Cloudflare ` +
+        `Workers harness (cloudflare:workers imports) and cannot load under ` +
+        `Module._compile. Rebundle/republish the play for the node runner ` +
+        `(profile=absurd / backend=daytona|local_process) instead of serving ` +
+        `the stored workers artifact verbatim.`,
+    });
+  }
+
+  if (bundledCodeHasCloudflareSchemeImport(artifact.bundledCode)) {
+    throw new PlayArtifactKindMismatchError({
+      expectedKind,
+      actualKind,
+      reason: 'cloudflare_scheme_import',
+      message:
+        `Node runner (${context}) received a play artifact tagged ` +
+        `"cjs_node20" whose bundledCode still contains a cloudflare: scheme ` +
+        `import. This bundle would die with ERR_UNSUPPORTED_ESM_URL_SCHEME ` +
+        `under Module._compile. The artifact was mis-tagged or mis-targeted; ` +
+        `rebundle for the node runner.`,
+    });
+  }
+}

package/dist/cli/index.js

@@ -623,10 +623,10 @@ var SDK_RELEASE = {
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
-  version: "0.1.208",
+  version: "0.1.209",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.208",
+    latest: "0.1.209",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -1408,6 +1408,25 @@ function normalizePlayRunLedgerStatus(value) {
       return "unknown";
   }
 }
+function summarizeRunRowOutcomes(snapshot) {
+  let completedRows = 0;
+  let failedRows = 0;
+  let totalRows = 0;
+  for (const step of Object.values(snapshot.stepsById)) {
+    const progress = step.progress;
+    if (!progress) continue;
+    completedRows += Math.max(0, finiteNumber(progress.completed) ?? 0);
+    failedRows += Math.max(0, finiteNumber(progress.failed) ?? 0);
+    const stepTotal = finiteNumber(progress.total);
+    totalRows += stepTotal !== null && stepTotal >= 0 ? stepTotal : Math.max(0, finiteNumber(progress.completed) ?? 0) + Math.max(0, finiteNumber(progress.failed) ?? 0);
+  }
+  return {
+    completedRows,
+    failedRows,
+    totalRows,
+    hasRowFailures: failedRows > 0
+  };
+}
 function createEmptyPlayRunLedgerSnapshot(input2) {
   const status = normalizePlayRunLedgerStatus(input2.status ?? "unknown");
   const startedAt = finiteNumber(input2.startedAt) ?? null;
@@ -1627,9 +1646,11 @@ function buildSnapshotFromLedger(snapshot) {
     completedAt: step.completedAt ?? null,
     updatedAt: step.updatedAt ?? null
   }));
+  const liveStatus = normalizePlayRunLiveStatus(snapshot.status);
+  const rowOutcomes = isTerminalPlayRunLiveStatus(liveStatus) && Object.keys(snapshot.stepsById).length > 0 ? summarizeRunRowOutcomes(snapshot) : null;
   return {
     runId: snapshot.runId,
-    status: normalizePlayRunLiveStatus(snapshot.status),
+    status: liveStatus,
     createdAt: snapshot.createdAt ?? null,
     startedAt: snapshot.startedAt ?? null,
     finishedAt: snapshot.finishedAt ?? null,
@@ -1641,7 +1662,8 @@ function buildSnapshotFromLedger(snapshot) {
     activeArtifactTableNamespace: snapshot.activeArtifactTableNamespace ?? null,
     resultTableNamespace: snapshot.resultTableNamespace ?? null,
     nodeStates,
-    activeNodeId: snapshot.activeStepId ?? null
+    activeNodeId: snapshot.activeStepId ?? null,
+    ...rowOutcomes ? { rowOutcomes } : {}
   };
 }
 function buildPlayRunStatusSnapshot(input2) {
@@ -14599,12 +14621,18 @@ async function handlePlayCheck(args) {
   }
   const client2 = new DeeplineClient();
   const integrationMode = resolveEvalIntegrationMode();
+  const importedPlays = [...graph.nodes.values()].filter((node) => node.filePath !== graph.root.filePath).map((node) => ({
+    playName: node.playName,
+    sourceCode: node.sourceCode,
+    sourcePath: node.filePath
+  }));
   const result = await client2.checkPlayArtifact({
     name: playName,
     sourceCode: graph.root.sourceCode,
     sourceFiles: graph.root.sourceFiles,
     description: graph.root.playDescription ?? void 0,
     artifact: graph.root.artifact,
+    ...importedPlays.length > 0 ? { importedPlays } : {},
     ...integrationMode ? { integrationMode } : {}
   });
   const enrichedResult = {

package/dist/cli/index.mjs

@@ -608,10 +608,10 @@ var SDK_RELEASE = {
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
-  version: "0.1.208",
+  version: "0.1.209",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.208",
+    latest: "0.1.209",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -1393,6 +1393,25 @@ function normalizePlayRunLedgerStatus(value) {
       return "unknown";
   }
 }
+function summarizeRunRowOutcomes(snapshot) {
+  let completedRows = 0;
+  let failedRows = 0;
+  let totalRows = 0;
+  for (const step of Object.values(snapshot.stepsById)) {
+    const progress = step.progress;
+    if (!progress) continue;
+    completedRows += Math.max(0, finiteNumber(progress.completed) ?? 0);
+    failedRows += Math.max(0, finiteNumber(progress.failed) ?? 0);
+    const stepTotal = finiteNumber(progress.total);
+    totalRows += stepTotal !== null && stepTotal >= 0 ? stepTotal : Math.max(0, finiteNumber(progress.completed) ?? 0) + Math.max(0, finiteNumber(progress.failed) ?? 0);
+  }
+  return {
+    completedRows,
+    failedRows,
+    totalRows,
+    hasRowFailures: failedRows > 0
+  };
+}
 function createEmptyPlayRunLedgerSnapshot(input2) {
   const status = normalizePlayRunLedgerStatus(input2.status ?? "unknown");
   const startedAt = finiteNumber(input2.startedAt) ?? null;
@@ -1612,9 +1631,11 @@ function buildSnapshotFromLedger(snapshot) {
     completedAt: step.completedAt ?? null,
     updatedAt: step.updatedAt ?? null
   }));
+  const liveStatus = normalizePlayRunLiveStatus(snapshot.status);
+  const rowOutcomes = isTerminalPlayRunLiveStatus(liveStatus) && Object.keys(snapshot.stepsById).length > 0 ? summarizeRunRowOutcomes(snapshot) : null;
   return {
     runId: snapshot.runId,
-    status: normalizePlayRunLiveStatus(snapshot.status),
+    status: liveStatus,
     createdAt: snapshot.createdAt ?? null,
     startedAt: snapshot.startedAt ?? null,
     finishedAt: snapshot.finishedAt ?? null,
@@ -1626,7 +1647,8 @@ function buildSnapshotFromLedger(snapshot) {
     activeArtifactTableNamespace: snapshot.activeArtifactTableNamespace ?? null,
     resultTableNamespace: snapshot.resultTableNamespace ?? null,
     nodeStates,
-    activeNodeId: snapshot.activeStepId ?? null
+    activeNodeId: snapshot.activeStepId ?? null,
+    ...rowOutcomes ? { rowOutcomes } : {}
   };
 }
 function buildPlayRunStatusSnapshot(input2) {
@@ -14628,12 +14650,18 @@ async function handlePlayCheck(args) {
   }
   const client2 = new DeeplineClient();
   const integrationMode = resolveEvalIntegrationMode();
+  const importedPlays = [...graph.nodes.values()].filter((node) => node.filePath !== graph.root.filePath).map((node) => ({
+    playName: node.playName,
+    sourceCode: node.sourceCode,
+    sourcePath: node.filePath
+  }));
   const result = await client2.checkPlayArtifact({
     name: playName,
     sourceCode: graph.root.sourceCode,
     sourceFiles: graph.root.sourceFiles,
     description: graph.root.playDescription ?? void 0,
     artifact: graph.root.artifact,
+    ...importedPlays.length > 0 ? { importedPlays } : {},
     ...integrationMode ? { integrationMode } : {}
   });
   const enrichedResult = {

package/dist/index.d.mts

@@ -1811,6 +1811,16 @@ declare class DeeplineClient {
         description?: string;
         artifact: Record<string, unknown>;
         integrationMode?: 'live' | 'eval_stub' | 'fixture';
+        /**
+         * Sibling plays from the same local bundle graph. Lets the server splice
+         * unpublished local children into the checked plan and enforce the
+         * row-scoped batch rule (ADR 0013).
+         */
+        importedPlays?: Array<{
+            playName?: string | null;
+            sourceCode: string;
+            sourcePath?: string | null;
+        }>;
     }): Promise<PlayCheckResult>;
     /**
      * Compile legacy enrich command arguments into a runtime plan.

package/dist/index.d.ts

@@ -1811,6 +1811,16 @@ declare class DeeplineClient {
         description?: string;
         artifact: Record<string, unknown>;
         integrationMode?: 'live' | 'eval_stub' | 'fixture';
+        /**
+         * Sibling plays from the same local bundle graph. Lets the server splice
+         * unpublished local children into the checked plan and enforce the
+         * row-scoped batch rule (ADR 0013).
+         */
+        importedPlays?: Array<{
+            playName?: string | null;
+            sourceCode: string;
+            sourcePath?: string | null;
+        }>;
     }): Promise<PlayCheckResult>;
     /**
      * Compile legacy enrich command arguments into a runtime plan.

package/dist/index.js

@@ -422,10 +422,10 @@ var SDK_RELEASE = {
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
-  version: "0.1.208",
+  version: "0.1.209",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.208",
+    latest: "0.1.209",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -1207,6 +1207,25 @@ function normalizePlayRunLedgerStatus(value) {
       return "unknown";
   }
 }
+function summarizeRunRowOutcomes(snapshot) {
+  let completedRows = 0;
+  let failedRows = 0;
+  let totalRows = 0;
+  for (const step of Object.values(snapshot.stepsById)) {
+    const progress = step.progress;
+    if (!progress) continue;
+    completedRows += Math.max(0, finiteNumber(progress.completed) ?? 0);
+    failedRows += Math.max(0, finiteNumber(progress.failed) ?? 0);
+    const stepTotal = finiteNumber(progress.total);
+    totalRows += stepTotal !== null && stepTotal >= 0 ? stepTotal : Math.max(0, finiteNumber(progress.completed) ?? 0) + Math.max(0, finiteNumber(progress.failed) ?? 0);
+  }
+  return {
+    completedRows,
+    failedRows,
+    totalRows,
+    hasRowFailures: failedRows > 0
+  };
+}
 function createEmptyPlayRunLedgerSnapshot(input) {
   const status = normalizePlayRunLedgerStatus(input.status ?? "unknown");
   const startedAt = finiteNumber(input.startedAt) ?? null;
@@ -1426,9 +1445,11 @@ function buildSnapshotFromLedger(snapshot) {
     completedAt: step.completedAt ?? null,
     updatedAt: step.updatedAt ?? null
   }));
+  const liveStatus = normalizePlayRunLiveStatus(snapshot.status);
+  const rowOutcomes = isTerminalPlayRunLiveStatus(liveStatus) && Object.keys(snapshot.stepsById).length > 0 ? summarizeRunRowOutcomes(snapshot) : null;
   return {
     runId: snapshot.runId,
-    status: normalizePlayRunLiveStatus(snapshot.status),
+    status: liveStatus,
     createdAt: snapshot.createdAt ?? null,
     startedAt: snapshot.startedAt ?? null,
     finishedAt: snapshot.finishedAt ?? null,
@@ -1440,7 +1461,8 @@ function buildSnapshotFromLedger(snapshot) {
     activeArtifactTableNamespace: snapshot.activeArtifactTableNamespace ?? null,
     resultTableNamespace: snapshot.resultTableNamespace ?? null,
     nodeStates,
-    activeNodeId: snapshot.activeStepId ?? null
+    activeNodeId: snapshot.activeStepId ?? null,
+    ...rowOutcomes ? { rowOutcomes } : {}
   };
 }
 function buildPlayRunStatusSnapshot(input) {

package/dist/index.mjs

@@ -352,10 +352,10 @@ var SDK_RELEASE = {
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
-  version: "0.1.208",
+  version: "0.1.209",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.208",
+    latest: "0.1.209",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -1137,6 +1137,25 @@ function normalizePlayRunLedgerStatus(value) {
       return "unknown";
   }
 }
+function summarizeRunRowOutcomes(snapshot) {
+  let completedRows = 0;
+  let failedRows = 0;
+  let totalRows = 0;
+  for (const step of Object.values(snapshot.stepsById)) {
+    const progress = step.progress;
+    if (!progress) continue;
+    completedRows += Math.max(0, finiteNumber(progress.completed) ?? 0);
+    failedRows += Math.max(0, finiteNumber(progress.failed) ?? 0);
+    const stepTotal = finiteNumber(progress.total);
+    totalRows += stepTotal !== null && stepTotal >= 0 ? stepTotal : Math.max(0, finiteNumber(progress.completed) ?? 0) + Math.max(0, finiteNumber(progress.failed) ?? 0);
+  }
+  return {
+    completedRows,
+    failedRows,
+    totalRows,
+    hasRowFailures: failedRows > 0
+  };
+}
 function createEmptyPlayRunLedgerSnapshot(input) {
   const status = normalizePlayRunLedgerStatus(input.status ?? "unknown");
   const startedAt = finiteNumber(input.startedAt) ?? null;
@@ -1356,9 +1375,11 @@ function buildSnapshotFromLedger(snapshot) {
     completedAt: step.completedAt ?? null,
     updatedAt: step.updatedAt ?? null
   }));
+  const liveStatus = normalizePlayRunLiveStatus(snapshot.status);
+  const rowOutcomes = isTerminalPlayRunLiveStatus(liveStatus) && Object.keys(snapshot.stepsById).length > 0 ? summarizeRunRowOutcomes(snapshot) : null;
   return {
     runId: snapshot.runId,
-    status: normalizePlayRunLiveStatus(snapshot.status),
+    status: liveStatus,
     createdAt: snapshot.createdAt ?? null,
     startedAt: snapshot.startedAt ?? null,
     finishedAt: snapshot.finishedAt ?? null,
@@ -1370,7 +1391,8 @@ function buildSnapshotFromLedger(snapshot) {
     activeArtifactTableNamespace: snapshot.activeArtifactTableNamespace ?? null,
     resultTableNamespace: snapshot.resultTableNamespace ?? null,
     nodeStates,
-    activeNodeId: snapshot.activeStepId ?? null
+    activeNodeId: snapshot.activeStepId ?? null,
+    ...rowOutcomes ? { rowOutcomes } : {}
   };
 }
 function buildPlayRunStatusSnapshot(input) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepline",
-  "version": "0.1.208",
+  "version": "0.1.209",
   "description": "Deepline SDK + CLI — B2B data enrichment powered by durable cloud execution",
   "license": "MIT",
   "repository": {

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

@@ -1,70 +0,0 @@
-import type { RunExecutionScope } from './run-execution-scope';
-
-export type ChildRunPlacement = 'inline' | 'scheduled';
-
-export interface ChildRunLifecycleMetadata {
-  placement: ChildRunPlacement;
-}
-
-export interface ChildRunLifecycleAdapter<
-  Metadata extends ChildRunLifecycleMetadata,
-  Result,
-> {
-  open(scope: RunExecutionScope, metadata: Metadata): Promise<void> | void;
-  started(scope: RunExecutionScope, metadata: Metadata): Promise<void> | void;
-  complete(
-    scope: RunExecutionScope,
-    metadata: Metadata,
-    result: Result,
-  ): Promise<void> | void;
-  fail(
-    scope: RunExecutionScope,
-    metadata: Metadata,
-    error: unknown,
-  ): Promise<void> | void;
-}
-
-export interface ExecuteChildRunLifecycleInput<
-  Metadata extends ChildRunLifecycleMetadata,
-  Result,
-> {
-  scope: RunExecutionScope;
-  metadata: Metadata;
-  adapter: ChildRunLifecycleAdapter<Metadata, Result>;
-  execute(
-    scope: RunExecutionScope,
-    metadata: Metadata,
-  ): Promise<Result> | Result;
-}
-
-/**
- * Projects one logical child execution through its lifecycle. Placement is
- * descriptive metadata; inline and scheduled children use the same protocol.
- */
-export async function executeChildRunLifecycle<
-  Metadata extends ChildRunLifecycleMetadata,
-  Result,
->(input: ExecuteChildRunLifecycleInput<Metadata, Result>): Promise<Result> {
-  const { adapter, execute, metadata, scope } = input;
-
-  let result: Result;
-  try {
-    await adapter.open(scope, metadata);
-    await adapter.started(scope, metadata);
-    result = await execute(scope, metadata);
-  } catch (executionError) {
-    try {
-      await adapter.fail(scope, metadata, executionError);
-    } catch (failureProjectionError) {
-      throw new AggregateError(
-        [executionError, failureProjectionError],
-        'Child run execution and failure projection both failed',
-        { cause: executionError },
-      );
-    }
-    throw executionError;
-  }
-
-  await adapter.complete(scope, metadata, result);
-  return result;
-}