deepline 0.1.214 → 0.1.216

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

@@ -38,7 +38,7 @@ import {
   PLAY_RUNTIME_CONTRACT,
   PLAY_RUNTIME_CONTRACT_HEADER,
 } from '@shared_libs/play-runtime/runtime-contract';
-import { PLAY_RUNTIME_API_COMPAT_PATH } from '@shared_libs/play-runtime/runtime-api-paths';
+import { PLAY_RUNTIME_API_CURRENT_PATH } from '@shared_libs/play-runtime/runtime-api-paths';
 import { PLAY_RUNTIME_TEST_FAULT_HEADER } from '@shared_libs/play-runtime/test-runtime-seams';
 import { vercelProtectionBypassHeaders } from '@shared_libs/play-runtime/vercel-protection';
 
@@ -569,6 +569,19 @@ function summarizeAppRuntimeErrorBody(body: string): string {
   return trimmed.length > 500 ? `${trimmed.slice(0, 500)}...` : trimmed;
 }
 
+function appRuntimeErrorCode(response: Response, body: string): string | null {
+  const header = response.headers.get('x-deepline-error-code')?.trim();
+  if (header) return header;
+  try {
+    const parsed = JSON.parse(body) as { code?: unknown };
+    return typeof parsed?.code === 'string' && parsed.code.trim()
+      ? parsed.code.trim()
+      : null;
+  } catch {
+    return null;
+  }
+}
+
 export function isTransientAppRuntimeFailureBody(body: string): boolean {
   return /WorkerOverloaded|"\s*code\s*"\s*:\s*"\s*InternalServerError\s*"|Your request couldn't be completed\. Try again later\.|timeout exceeded when trying to connect|timed out|fetch failed|ECONNRESET|ECONNREFUSED|UND_ERR_CONNECT_TIMEOUT|tuple concurrently updated|RUNTIME_SCHEDULER_SATURATED|Runtime scheduler DB pool is saturated|Runtime scheduler DB circuit breaker is open|OptimisticConcurrencyControlFailure|changed while this mutation was being run|Documents read from or written to the .* table changed while this mutation/i.test(
     body,
@@ -775,7 +788,7 @@ export class AppRuntimeApiTransportError extends Error {
 
 function resolveAppRuntimeApiUrl(context: WorkerRuntimeApiContext): string {
   const baseUrl = context.baseUrl.trim().replace(/\/$/, '');
-  return `${baseUrl}${PLAY_RUNTIME_API_COMPAT_PATH}`;
+  return `${baseUrl}${PLAY_RUNTIME_API_CURRENT_PATH}`;
 }
 
 async function postAppRuntimeApi<TResponse>(
@@ -892,8 +905,13 @@ async function postAppRuntimeApi<TResponse>(
       );
       continue;
     }
+    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}: ${summarizeAppRuntimeErrorBody(responseText)}`,
+      `App runtime API ${body.action} failed with status ${response.status}` +
+        `${code ? ` code=${code}` : ''}` +
+        `${requestId ? ` request_id=${requestId}` : ''}: ` +
+        summarizeAppRuntimeErrorBody(responseText),
     );
   }
 

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

@@ -47,10 +47,7 @@ import {
   RUNTIME_SCHEDULER_SCHEMA_OVERRIDE_HEADER,
   SYNTHETIC_RUN_HEADER,
 } from './coordinator-headers';
-import {
-  PLAY_RUNTIME_API_COMPAT_PATH,
-  PLAY_RUNTIME_CHILD_EXECUTOR_TOKEN_COMPAT_PATH,
-} from './runtime-api-paths';
+import { PLAY_RUNTIME_API_CURRENT_PATH } from './runtime-api-paths';
 import {
   createRootRunExecutionScope,
   deriveChildRunExecutionScope,
@@ -262,6 +259,15 @@ const rowContext = new AsyncLocalStorage<{
   rowKey?: string;
   mapScope?: MapExecutionScope;
 }>();
+type InlineCompositionStore = {
+  context: PlayContextImpl;
+  executionScope: RunExecutionScope;
+  governor: PlayExecutionGovernor;
+  playName: string;
+  staticPipeline: ContextOptions['staticPipeline'];
+};
+const inlineCompositionContext =
+  new AsyncLocalStorage<InlineCompositionStore>();
 const toolExecutionOverrides = new AsyncLocalStorage<{ force: boolean }>();
 const PROGRESS_HEARTBEAT_INTERVAL_MS = 1_000;
 const PURE_JS_HEARTBEAT_ROW_INTERVAL = 250;
@@ -1270,12 +1276,6 @@ export class PlayContextImpl {
    */
   private readonly governor: PlayExecutionGovernor;
   private readonly resourceGovernor: RuntimeResourceGovernor;
-  /**
-   * Lineage identity for this context (run/play ids + ancestry). Seeded from the
-   * Governor snapshot; used only for receipt keys, durable-boundary scoping, and
-   * child run-id derivation. All policy lives in {@link governor}.
-   */
-  private readonly governance: GovernanceSnapshot;
   private readonly resolvedPlayExecutorCache = new Map<
     string,
     Promise<ResolvedPlayExecutor>
@@ -1443,7 +1443,6 @@ export class PlayContextImpl {
     this.resourceGovernor = createRuntimeResourceGovernor({
       executionGovernor: this.governor,
     });
-    this.governance = this.governor.snapshot();
   }
 
   private durableBoundaryId(localId: string): string {
@@ -1451,7 +1450,33 @@ export class PlayContextImpl {
     // Nested plays and concurrent child calls therefore need a stable run scope
     // in the key, otherwise two children can both produce e.g. "sleep-0-25"
     // and replay the wrong boundary or never observe completion.
-    return `${this.governance.currentRunId}:${localId}`;
+    return `${this.currentGovernance.currentRunId}:${localId}`;
+  }
+
+  private get activeInlineComposition(): InlineCompositionStore | null {
+    const active = inlineCompositionContext.getStore();
+    return active?.context === this ? active : null;
+  }
+
+  private get currentExecutionScope(): RunExecutionScope {
+    return this.activeInlineComposition?.executionScope ?? this.executionScope;
+  }
+
+  private get currentExecutionGovernor(): PlayExecutionGovernor {
+    return this.activeInlineComposition?.governor ?? this.governor;
+  }
+
+  private get currentGovernance(): GovernanceSnapshot {
+    return this.currentExecutionGovernor.snapshot();
+  }
+
+  private get currentPlayName(): string | undefined {
+    return this.activeInlineComposition?.playName ?? this.#options.playName;
+  }
+
+  private get currentStaticPipeline(): ContextOptions['staticPipeline'] {
+    const active = this.activeInlineComposition;
+    return active ? active.staticPipeline : this.#options.staticPipeline;
   }
 
   private shouldLaunchChildPlaysThroughScheduler(): boolean {
@@ -1617,17 +1642,18 @@ export class PlayContextImpl {
     childInput: Record<string, unknown>;
     description?: string | null;
   }): Promise<void> {
+    const parentGovernance = this.currentGovernance;
     const parentPlayName =
-      this.governance.currentPlayId ||
-      this.#options.playName ||
+      parentGovernance.currentPlayId ||
+      this.currentPlayName ||
       this.#options.playId ||
       'anonymous-play';
     const governance: PlayCallGovernanceSnapshot = {
-      rootRunId: this.governance.rootRunId,
-      parentRunId: this.governance.currentRunId,
+      rootRunId: parentGovernance.rootRunId,
+      parentRunId: parentGovernance.currentRunId,
       parentPlayName,
       key: input.key,
-      ancestryPlayIds: [...this.governance.ancestryPlayIds],
+      ancestryPlayIds: [...parentGovernance.ancestryPlayIds],
       callDepth: input.childGovernance.callDepth,
       playCallCount: input.childGovernance.playCallCount,
       toolCallCount: input.childGovernance.toolCallCount,
@@ -1702,13 +1728,13 @@ export class PlayContextImpl {
     | null
   > {
     const response = await fetch(
-      `${this.runtimeApiBaseUrl()}${PLAY_RUNTIME_API_COMPAT_PATH}`,
+      `${this.runtimeApiBaseUrl()}${PLAY_RUNTIME_API_CURRENT_PATH}`,
       {
         method: 'POST',
         headers: await this.runtimeApiHeaders(),
         body: JSON.stringify({
           action: 'read_child_run_terminal_snapshot',
-          parentRunId: this.governance.currentRunId,
+          parentRunId: this.currentGovernance.currentRunId,
           childRunId: input.childRunId,
           childPlayName: input.childPlayName,
         }),
@@ -1817,7 +1843,7 @@ export class PlayContextImpl {
       this.#options.runId
     ) {
       const response = await fetch(
-        `${this.#options.baseUrl.replace(/\/$/, '')}${PLAY_RUNTIME_API_COMPAT_PATH}`,
+        `${this.#options.baseUrl.replace(/\/$/, '')}${PLAY_RUNTIME_API_CURRENT_PATH}`,
         {
           method: 'POST',
           headers: {
@@ -2716,7 +2742,7 @@ export class PlayContextImpl {
   }): Promise<string> {
     return await this.durableToolCallCacheKeyForScope({
       ...input,
-      playLocalScope: this.governance.currentPlayId,
+      playLocalScope: this.currentGovernance.currentPlayId,
     });
   }
 
@@ -2871,7 +2897,7 @@ export class PlayContextImpl {
       opts.receiptKey?.trim() ||
       durableCtxKey({
         orgId: this.#options.orgId,
-        playId: this.executionScope.receipt.namespace,
+        playId: this.currentExecutionScope.receipt.namespace,
         operation,
         id,
         semanticKey: opts.semanticKey,
@@ -2905,15 +2931,15 @@ export class PlayContextImpl {
   }
 
   private get currentRunId(): string {
-    return this.executionScope.logical.runId;
+    return this.currentExecutionScope.logical.runId;
   }
 
   private get currentReceiptOwnerRunId(): string {
-    return this.executionScope.receipt.ownerRunId;
+    return this.currentExecutionScope.receipt.ownerRunId;
   }
 
   private get currentRunAttempt(): number {
-    return this.executionScope.receipt.ownerAttempt;
+    return this.currentExecutionScope.receipt.ownerAttempt;
   }
 
   private emitScopedFieldMetaUpdate(input: {
@@ -3193,7 +3219,8 @@ export class PlayContextImpl {
     rowKey?: string;
     callId?: string;
   }): string {
-    const scope = this.governance.currentRunId || this.#options.runId || 'run';
+    const scope =
+      this.currentGovernance.currentRunId || this.#options.runId || 'run';
     if (input.callId?.trim()) {
       return `${scope}:${input.callId.trim()}`;
     }
@@ -3961,16 +3988,16 @@ export class PlayContextImpl {
             const flushStartedAt = Date.now();
             try {
               await this.#options.onMapRowsCompleted!({
-                playName: this.#options.playName,
-                playId: this.#options.playId,
-                runId: this.#options.runId,
+                playName: this.currentPlayName,
+                playId: this.currentExecutionScope.logical.playId,
+                runId: this.currentRunId,
                 executorToken: this.#options.executorToken,
                 tableNamespace: resolvedTableNamespace,
                 rows: chunk,
                 outputFields: datasetColumnNames.filter((field) =>
                   shouldPersistMapCellField(field),
                 ),
-                staticPipeline: this.#options.staticPipeline ?? null,
+                staticPipeline: this.currentStaticPipeline ?? null,
               });
               this.resourceGovernor.observe({
                 sheetFlushBytes: chunkBytes,
@@ -4037,11 +4064,11 @@ export class PlayContextImpl {
           pageStartRows,
           resolvedTableNamespace,
           {
-            playName: this.#options.playName,
-            playId: this.#options.playId,
-            runId: this.#options.runId,
+            playName: this.currentPlayName,
+            playId: this.currentExecutionScope.logical.playId,
+            runId: this.currentRunId,
             executorToken: this.#options.executorToken,
-            staticPipeline: this.#options.staticPipeline,
+            staticPipeline: this.currentStaticPipeline,
             forceRefresh: this.#options.cachePolicy?.forceToolRefresh === true,
             inputOffset: page.offset,
           },
@@ -4472,11 +4499,11 @@ export class PlayContextImpl {
         mapStartRows,
         resolvedTableNamespace,
         {
-          playName: this.#options.playName,
-          playId: this.#options.playId,
-          runId: this.#options.runId,
+          playName: this.currentPlayName,
+          playId: this.currentExecutionScope.logical.playId,
+          runId: this.currentRunId,
           executorToken: this.#options.executorToken,
-          staticPipeline: this.#options.staticPipeline,
+          staticPipeline: this.currentStaticPipeline,
           forceRefresh: this.#options.cachePolicy?.forceToolRefresh === true,
         },
       );
@@ -4620,16 +4647,16 @@ export class PlayContextImpl {
           const flushStartedAt = Date.now();
           try {
             const writeResult = await this.#options.onMapRowsCompleted!({
-              playName: this.#options.playName,
-              playId: this.#options.playId,
-              runId: this.#options.runId,
+              playName: this.currentPlayName,
+              playId: this.currentExecutionScope.logical.playId,
+              runId: this.currentRunId,
               executorToken: this.#options.executorToken,
               tableNamespace: resolvedTableNamespace,
               rows: chunk,
               outputFields: datasetColumnNames.filter((field) =>
                 shouldPersistMapCellField(field),
               ),
-              staticPipeline: this.#options.staticPipeline ?? null,
+              staticPipeline: this.currentStaticPipeline ?? null,
             });
             if (writeResult) {
               for (const key of writeResult.staleDroppedKeys ?? []) {
@@ -6158,6 +6185,7 @@ export class PlayContextImpl {
     input: Record<string, unknown>,
     options?: ToolCallOptions,
   ): Promise<unknown> {
+    const executionScope = this.currentExecutionScope;
     const normalizedKey = this.normalizeContextKey(key, 'tool');
     const toolCachePolicy = this.effectiveToolCallCachePolicy(options);
     const toolRequestIdentity = deriveToolRequestIdentity({
@@ -6303,6 +6331,7 @@ export class PlayContextImpl {
       const rowId = store.rowId;
       const fieldName = store.fieldName;
       const callId = [
+        executionScope.receipt.namespace,
         store.tableNamespace?.trim() || 'map',
         store.rowKey?.trim() || String(rowId),
         normalizedKey,
@@ -6669,10 +6698,10 @@ export class PlayContextImpl {
       });
 
       const executePlayCall = async (): Promise<TOutput> => {
-        // Reserve depth + per-parent + descendant/play-call budget on the parent
-        // and fork the lineage-global snapshot for the child. forkChild owns the
-        // cycle guard, depth cap, per-parent cap, and play/descendant charges, so
-        // a recovered receipt (which skips this body) never consumes budget.
+        // Scheduled children reserve the parent's durable play/descendant
+        // budgets. Inline scalar children are function composition: their
+        // Governor view changes only local lineage for recursion/depth checks
+        // and delegates tool admission, pacing, and tool budgets to the parent.
         //
         // The SCHEDULED substrate still allocates a durable child run id (through
         // the shared canonical builder so in-process and the workers_edge
@@ -6682,9 +6711,10 @@ export class PlayContextImpl {
         // settlement. Their only identity is a replay-stable, call-site scoped
         // composition namespace (`child:<playName>#<ordinal>`) used to scope tool
         // receipts under the PARENT run. See child-composition-namespace below.
+        const parentGovernor = this.currentExecutionGovernor;
         const inlineChildGovernor = launchThroughScheduler
           ? null
-          : await this.governor.forkInlineChild({
+          : await parentGovernor.forkInlineChild({
               childPlayName: resolvedName,
               childRunId: this.inlineChildCompositionNamespace(
                 resolvedName,
@@ -6692,7 +6722,7 @@ export class PlayContextImpl {
               ),
             });
         const childGovernance = launchThroughScheduler
-          ? await this.governor.forkChild({
+          ? await parentGovernor.forkChild({
               childPlayName: resolvedName,
               childRunId: buildChildRunId({
                 childPlayName: resolvedName,
@@ -6706,7 +6736,7 @@ export class PlayContextImpl {
             })
           : inlineChildGovernor!.snapshot();
         const childPlaySlot = launchThroughScheduler
-          ? await this.governor.acquireChildSubmitSlot()
+          ? await parentGovernor.acquireChildSubmitSlot()
           : null;
         const rowStore = rowContext.getStore();
         const producer = {
@@ -6840,7 +6870,7 @@ export class PlayContextImpl {
           // per-row inline-invocation sanity cap at creation).
           const compositionNamespace = childGovernance.currentRunId;
           const childExecutionScope = deriveChildRunExecutionScope(
-            this.executionScope,
+            this.currentExecutionScope,
             {
               placement: 'inline',
               runId: compositionNamespace,
@@ -6849,49 +6879,22 @@ export class PlayContextImpl {
             },
           );
           this.inlineChildAggregates.total += 1;
-          const inlineScalarChild =
-            childExecutionDecision.reason === 'scalar_child';
-          const childContext = createPlayContext({
-            ...this.#options,
-            executionScope: childExecutionScope,
-            playId: resolvedName,
-            playName: resolvedName,
-            runId: compositionNamespace,
-            executorToken: inlineScalarChild
-              ? this.#options.executorToken
-              : await this.mintChildExecutorToken({
-                  parentRunId: this.currentRunId,
-                  parentPlayName: this.#options.playName,
-                  childRunId: compositionNamespace,
-                  childPlayName: resolvedName,
-                }),
-            staticPipeline: resolvedPlay.staticPipeline ?? null,
-            checkpoint: this.checkpoint,
-            governance: undefined,
-            executionGovernor: inlineChildGovernor!,
-            ...(inlineScalarChild
-              ? {}
-              : {
-                  getRuntimeStepReceipt: undefined,
-                  getRuntimeStepReceipts: undefined,
-                  claimRuntimeStepReceipt: undefined,
-                  claimRuntimeStepReceipts: undefined,
-                  completeRuntimeStepReceipt: undefined,
-                  completeRuntimeStepReceipts: undefined,
-                  failRuntimeStepReceipt: undefined,
-                  failRuntimeStepReceipts: undefined,
-                  heartbeatRuntimeStepReceipts: undefined,
-                  skipRuntimeStepReceipt: undefined,
-                }),
-          });
           try {
-            const childExecution = this.executeResolvedPlay(
-              resolvedPlay,
-              childContext,
-              input,
+            // A scalar child is a normal function call on the parent's context.
+            // Async-local identity changes receipt and recursion scope without
+            // allocating another PlayContext, tool queue, drain loop, resource
+            // governor, or receipt client. Calls from every concurrent child
+            // therefore reach the same proven parent batching path.
+            const result = await inlineCompositionContext.run(
+              {
+                context: this,
+                executionScope: childExecutionScope,
+                governor: inlineChildGovernor!,
+                playName: resolvedName,
+                staticPipeline: resolvedPlay.staticPipeline ?? null,
+              },
+              () => this.executeResolvedPlay(resolvedPlay, this, input),
             );
-            await childContext.drainQueuedWork([childExecution]);
-            const result = await childExecution;
             this.inlineChildAggregates.ok += 1;
             if (rowStore) {
               this.emitScopedFieldMetaUpdate({
@@ -6912,7 +6915,6 @@ export class PlayContextImpl {
               playId: resolvedName,
               execution: options?.execution,
               description: options?.description,
-              nestedSteps: childContext.getSteps(),
             });
             return result as TOutput;
           } catch (childError) {
@@ -6950,57 +6952,6 @@ export class PlayContextImpl {
     }
   }
 
-  private async mintChildExecutorToken(input: {
-    parentRunId: string;
-    parentPlayName?: string | null;
-    childRunId: string;
-    childPlayName: string;
-  }): Promise<string | undefined> {
-    if (!this.#options.executorToken || !this.#options.baseUrl) {
-      return this.#options.executorToken;
-    }
-    const parentPlayName = input.parentPlayName?.trim();
-    if (!parentPlayName) {
-      return this.#options.executorToken;
-    }
-    const response = await fetch(
-      `${this.#options.baseUrl.replace(/\/$/, '')}${PLAY_RUNTIME_CHILD_EXECUTOR_TOKEN_COMPAT_PATH}`,
-      {
-        method: 'POST',
-        headers: {
-          Authorization: `Bearer ${this.#options.executorToken}`,
-          'Content-Type': 'application/json',
-          ...(await this.vercelProtectionHeaders()),
-        },
-        body: JSON.stringify({
-          parentRunId: input.parentRunId,
-          parentPlayName,
-          childRunId: input.childRunId,
-          childPlayName: input.childPlayName,
-        }),
-      },
-    );
-    const body = (await response.json().catch(() => null)) as {
-      executorToken?: unknown;
-      error?: unknown;
-    } | null;
-    if (!response.ok) {
-      const message =
-        typeof body?.error === 'string' && body.error.trim()
-          ? body.error.trim()
-          : response.statusText;
-      throw new Error(
-        `ctx.runPlay failed to mint child executor token for "${input.childPlayName}": ${message} (status ${response.status}).`,
-      );
-    }
-    if (typeof body?.executorToken !== 'string' || !body.executorToken.trim()) {
-      throw new Error(
-        `ctx.runPlay failed to mint child executor token for "${input.childPlayName}": response did not include executorToken.`,
-      );
-    }
-    return body.executorToken.trim();
-  }
-
   /**
    * Replay-stable composition namespace for one inline `ctx.runPlay`
    * invocation. Format `child:<playName>#<callKey>[@<rowScope>]`:
@@ -7358,7 +7309,7 @@ export class PlayContextImpl {
 
     const rowStore = rowContext.getStore();
     const scope = rowStore ? `row-${rowStore.rowId}` : 'workflow';
-    const callIndexKey = `${scope}:${normalizedKey}`;
+    const callIndexKey = `${this.currentExecutionScope.receipt.namespace}:${scope}:${normalizedKey}`;
     const callIndex = this.stepCallIndexByKey.get(callIndexKey) ?? 0;
     this.stepCallIndexByKey.set(callIndexKey, callIndex + 1);
     const boundarySuffix = callIndex === 0 ? '' : `:${callIndex}`;

package/dist/bundling-sources/shared_libs/play-runtime/durable-receipt-execution.ts

@@ -429,7 +429,11 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
     receipt: RuntimeStepReceipt,
     source: DurableReceiptRecoverySource = 'cache',
   ): Promise<T> => {
-    input.log(`ctx.${input.operation}(${input.id}): reused completed work`);
+    input.log(
+      source === 'owner'
+        ? `ctx.${input.operation}(${input.id}): executed and converged through immutable publication`
+        : `ctx.${input.operation}(${input.id}): reused completed work`,
+    );
     if (receipt.output === undefined) {
       return receipt.output as T;
     }
@@ -489,8 +493,7 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
       const afterLock = await input.store.get(input.receiptKey);
       if (
         input.force !== true &&
-        (afterLock?.status === 'completed' ||
-          afterLock?.status === 'skipped')
+        (afterLock?.status === 'completed' || afterLock?.status === 'skipped')
       ) {
         await input.store.releaseExecutionLock({
           receiptKey: input.receiptKey,
@@ -566,6 +569,10 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
         completed?.status === 'completed' ||
         completed?.status === 'skipped'
       ) {
+        // Completion is a compact acknowledgement. This execution already
+        // owns the just-produced value; only a later receipt read needs the
+        // persisted payload for replay.
+        if (completed.output === undefined) return result;
         return await recoverCompletedReceipt(completed, 'owner');
       }
       const winner = await input.store.get(input.receiptKey);
@@ -828,6 +835,10 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
     (completed.status === 'completed' || completed.status === 'skipped')
   ) {
     logPhase('total', lifecycleStartedAt);
+    // Completion endpoints acknowledge ownership and status only. The caller
+    // already owns the live value; replay reads are the only path that needs
+    // the receipt payload returned over the transport.
+    if (completed.output === undefined) return result;
     return await recoverCompletedReceipt(completed, 'owner');
   }
   if (input.store.canPersistCompletion) {

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

@@ -540,7 +540,7 @@ export function createPlayExecutionGovernor(
     async forkInlineChild(childInput) {
       return createInlineChildGovernor(
         governor,
-        await governor.forkChild(childInput),
+        deriveInlineChildSnapshot(state, childInput, policy),
       );
     },
 
@@ -593,6 +593,38 @@ export function createPlayExecutionGovernor(
   return governor;
 }
 
+function deriveInlineChildSnapshot(
+  parent: GovernanceSnapshot,
+  input: { childPlayName: string; childRunId: string },
+  policy: ResolvedExecutionPolicy,
+): GovernanceSnapshot {
+  if (parent.ancestryPlayIds.includes(input.childPlayName)) {
+    throw new Error(
+      `Recursive play graph detected: ${[
+        ...parent.ancestryPlayIds,
+        input.childPlayName,
+      ].join(' -> ')}`,
+    );
+  }
+  const nextDepth = parent.callDepth + 1;
+  if (nextDepth > policy.budgets.maxPlayCallDepth) {
+    throw new GovernorBudgetError(
+      'playDepth',
+      nextDepth,
+      policy.budgets.maxPlayCallDepth,
+    );
+  }
+  return {
+    ...parent,
+    currentRunId: input.childRunId,
+    currentPlayId: input.childPlayName,
+    ancestryPlayIds: [...parent.ancestryPlayIds, input.childPlayName],
+    ancestryRunIds: [...parent.ancestryRunIds, input.childRunId],
+    callDepth: nextDepth,
+    parentChildCalls: {},
+  };
+}
+
 function createInlineChildGovernor(
   root: PlayExecutionGovernor,
   initial: GovernanceSnapshot,
@@ -667,7 +699,10 @@ function createInlineChildGovernor(
       };
     },
     async forkInlineChild(input) {
-      return createInlineChildGovernor(child, await child.forkChild(input));
+      return createInlineChildGovernor(
+        child,
+        deriveInlineChildSnapshot(child.snapshot(), input, child.policy),
+      );
     },
     snapshot() {
       const counters = root.snapshot();

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

@@ -6,6 +6,7 @@ import {
   PLAY_RUNTIME_PROVIDERS,
   PLAY_RUNTIME_PROVIDER_IDS,
   defaultPlayRuntimeProvider,
+  resolveEnabledPlayRuntimeProvider,
   resolvePlayRuntimeProvider,
   type PlayRuntimeProviderId,
 } from './providers';
@@ -50,3 +51,24 @@ export function resolveExecutionProfile(
     throw error;
   }
 }
+
+export function resolveEnabledExecutionProfile(
+  override?: string | null,
+): PlayExecutionProfile {
+  try {
+    return resolveEnabledPlayRuntimeProvider(override);
+  } catch (error) {
+    if (
+      override?.trim() &&
+      error instanceof Error &&
+      /Unsupported play runtime provider/.test(error.message)
+    ) {
+      throw new Error(
+        `Unknown execution profile "${override.trim()}". Expected one of: ${Object.keys(
+          PLAY_EXECUTION_PROFILES,
+        ).join(', ')}.`,
+      );
+    }
+    throw error;
+  }
+}