deepline 0.1.206 → 0.1.208

package/dist/bundling-sources/shared_libs/play-runtime/ctx-types.ts

@@ -12,7 +12,10 @@ import type {
   PlayQueueHint,
   RateStateBackend,
 } from './governor/rate-state-backend';
-import type { GovernanceSnapshot } from './governor/governor';
+import type {
+  GovernanceSnapshot,
+  PlayExecutionGovernor,
+} from './governor/governor';
 import type { BudgetStateBackend } from './governor/budget-state-backend';
 import type { RuntimeMapMemoryLimits } from './map-memory-limits';
 import type { AnyBatchOperationStrategy } from './batching-types';
@@ -20,6 +23,7 @@ import type { ToolResultMetadataInput } from './tool-result';
 import type { PreviousCell } from './cell-staleness';
 import type { MapRowOutcome } from './durability-store';
 import type { WorkReceiptFailureKind } from './work-receipts';
+import type { RunExecutionScope } from './run-execution-scope';
 
 export interface RowState {
   results: Map<string, unknown>;
@@ -470,6 +474,8 @@ export type IntegrationEventWaitHandler = {
 };
 
 export interface ContextOptions {
+  /** Immutable logical and physical execution identity for this context. */
+  executionScope?: RunExecutionScope;
   /** Short-lived HMAC-signed internal token for tool callbacks. Required for cloud execution. */
   executorToken?: string;
   baseUrl?: string;
@@ -568,6 +574,10 @@ export interface ContextOptions {
   }) => Promise<void>;
   playId?: string;
   runId?: string;
+  /** Physical executor run that owns leases for an inline child context. */
+  runtimeReceiptOwnerRunId?: string;
+  /** Logical invocation scope for nested step/fetch/runPlay receipt identity. */
+  runtimeReceiptScope?: string;
   runAttempt?: number | null;
   /**
    * Optional shared provider-rate state for fleet substrates. Local/test
@@ -695,6 +705,8 @@ export interface ContextOptions {
    * guards accumulate across the nested-play tree. Only set on child contexts.
    */
   governance?: GovernanceSnapshot;
+  /** Internal in-process child view sharing the root run's resource governor. */
+  executionGovernor?: PlayExecutionGovernor;
 }
 
 export interface PlayCheckpoint {

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

@@ -95,8 +95,8 @@ export function createInMemoryAdaptiveAdmission(
     finitePositive(options.maxRequestsPerSecond, initialRequestsPerSecond),
   );
   const additiveIncreasePerWindow = finitePositive(
-    options.additiveIncreasePerWindow ?? 5,
-    5,
+    options.additiveIncreasePerWindow ?? 1,
+    1,
   );
   const cleanWindowMs = finitePositive(options.cleanWindowMs ?? 1_000, 1_000);
   const states = new Map<string, ProviderState>();
@@ -192,14 +192,26 @@ export function createInMemoryAdaptiveAdmission(
     observeProviderBackpressure(input) {
       const state = getExistingState(input.orgId, input.provider);
       if (!state) return;
+      const currentTime = now();
       state.rateLimitCount += 1;
+      const nextRetryAfterUntilMs =
+        currentTime + Math.max(0, input.retryAfterMs);
+      if (
+        state.retryAfterUntilMs != null &&
+        state.retryAfterUntilMs > currentTime
+      ) {
+        state.retryAfterUntilMs = Math.max(
+          state.retryAfterUntilMs,
+          nextRetryAfterUntilMs,
+        );
+        return;
+      }
       state.hasSeenBackpressure = true;
       state.currentRequestsPerSecond = Math.max(
         minRequestsPerSecond,
         Math.floor(state.currentRequestsPerSecond / 2),
       );
-      const currentTime = now();
-      state.retryAfterUntilMs = currentTime + Math.max(0, input.retryAfterMs);
+      state.retryAfterUntilMs = nextRetryAfterUntilMs;
       state.lastIncreaseAtMs = currentTime;
       state.successCountAtLastIncrease = state.successCount;
     },

package/dist/bundling-sources/shared_libs/play-runtime/governor/app-runtime-rate-state-backend.ts

@@ -18,7 +18,8 @@ import {
  * stale-block over-issue to 8 x live runner processes per bucket/window.
  */
 export const APP_RUNTIME_RATE_STATE_LEASE_BLOCK_SIZE = 8;
-const LEASE_BLOCK_TTL_MS = 250;
+const LEASE_BLOCK_MIN_TTL_MS = 250;
+const LEASE_BLOCK_MAX_TTL_MS = 5_000;
 const MAX_ACQUIRE_SLEEP_MS = 5_000;
 const STORE_FAILURE_RETRY_DELAYS_MS = [100, 250] as const;
 
@@ -42,6 +43,13 @@ interface LeasedBlock {
   rules: PacingRule[];
 }
 
+interface PendingRelease {
+  bucketId: string;
+  rules: PacingRule[];
+  leaseIds: string[];
+  flushing: boolean;
+}
+
 interface Options {
   schedulerSchema?: string | null;
   now?: () => number;
@@ -59,6 +67,8 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
     error: string;
   }) => void;
   private readonly blocks = new Map<string, LeasedBlock>();
+  private readonly acquisitionTails = new Map<string, Promise<void>>();
+  private readonly pendingReleases = new Map<string, PendingRelease>();
   private pendingReleaseFailure: Error | null = null;
 
   constructor(context: WorkerRuntimeApiContext, options: Options = {}) {
@@ -86,80 +96,101 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
 
     const ordered = [...rules].sort((a, b) => a.ruleId.localeCompare(b.ruleId));
     const rulesKey = rulesSignature(ordered);
-    const localPermit = this.drawFromBlock(bucketId, rulesKey);
-    if (localPermit) return localPermit;
+    return await this.withBucketAcquisitionLock(bucketId, async () => {
+      const localPermit = this.drawFromBlock(bucketId, rulesKey);
+      if (localPermit) return localPermit;
 
-    let consecutiveFailures = 0;
-    while (true) {
-      if (signal?.aborted) {
-        throw signal.reason instanceof Error
-          ? signal.reason
-          : new Error('Rate-state acquire aborted.');
-      }
-      try {
-        const response = await acquireRateStateViaAppRuntime(this.context, {
-          bucketId,
-          rules: ordered,
-          requested: APP_RUNTIME_RATE_STATE_LEASE_BLOCK_SIZE,
-          schedulerSchema: this.schedulerSchema,
-        });
-        consecutiveFailures = 0;
-        if (response.granted > 0) {
-          const hasConcurrency = ordered.some(
-            (rule) => rule.maxConcurrency != null,
-          );
-          const leaseIds = Array.isArray(response.leaseIds)
-            ? response.leaseIds.filter(
-                (leaseId): leaseId is string =>
-                  typeof leaseId === 'string' && leaseId.trim().length > 0,
-              )
-            : [];
-          if (hasConcurrency && leaseIds.length !== response.granted) {
-            throw new Error(
-              `Rate-state store granted ${response.granted} concurrency permits for ${bucketId} with ${leaseIds.length} lease tokens.`,
+      let consecutiveFailures = 0;
+      while (true) {
+        if (signal?.aborted) {
+          throw signal.reason instanceof Error
+            ? signal.reason
+            : new Error('Rate-state acquire aborted.');
+        }
+        try {
+          const response = await acquireRateStateViaAppRuntime(this.context, {
+            bucketId,
+            rules: ordered,
+            requested: APP_RUNTIME_RATE_STATE_LEASE_BLOCK_SIZE,
+            schedulerSchema: this.schedulerSchema,
+          });
+          consecutiveFailures = 0;
+          if (response.granted > 0) {
+            const hasConcurrency = ordered.some(
+              (rule) => rule.maxConcurrency != null,
             );
+            const leaseIds = Array.isArray(response.leaseIds)
+              ? response.leaseIds.filter(
+                  (leaseId): leaseId is string =>
+                    typeof leaseId === 'string' && leaseId.trim().length > 0,
+                )
+              : [];
+            if (hasConcurrency && leaseIds.length !== response.granted) {
+              throw new Error(
+                `Rate-state store granted ${response.granted} concurrency permits for ${bucketId} with ${leaseIds.length} lease tokens.`,
+              );
+            }
+            if (!hasConcurrency && leaseIds.length > 0) {
+              throw new Error(
+                `Rate-state store returned ${leaseIds.length} lease tokens for pure-rate bucket ${bucketId}.`,
+              );
+            }
+            const currentLeaseId = hasConcurrency ? leaseIds[0]! : null;
+            const remainingLeaseIds = hasConcurrency ? leaseIds.slice(1) : [];
+            const remainingWindowPermits = hasConcurrency
+              ? 0
+              : response.granted - 1;
+            if (remainingLeaseIds.length > 0 || remainingWindowPermits > 0) {
+              this.mergeBlock(
+                bucketId,
+                remainingLeaseIds,
+                remainingWindowPermits,
+                rulesKey,
+                ordered,
+              );
+            }
+            return this.permitFor(bucketId, ordered, currentLeaseId);
           }
-          if (!hasConcurrency && leaseIds.length > 0) {
+          await this.sleep(
+            Math.max(1, Math.min(response.waitMs, MAX_ACQUIRE_SLEEP_MS)),
+          );
+        } catch (error) {
+          // Fail closed. A degraded rate-state store must not grant unlimited
+          // provider calls; after this bounded retry ladder the run fails loudly.
+          consecutiveFailures += 1;
+          const normalized = normalizeError(error);
+          this.onStoreFailure({ bucketId, error: normalized.message });
+          if (consecutiveFailures > STORE_FAILURE_RETRY_DELAYS_MS.length) {
             throw new Error(
-              `Rate-state store returned ${leaseIds.length} lease tokens for pure-rate bucket ${bucketId}.`,
+              `Rate-state store unavailable for ${bucketId}; failing closed after ${consecutiveFailures} acquire attempts: ${normalized.message}`,
             );
           }
-          // Serve this acquire from the grant, then cache the rest so the whole
-          // block amortizes into a single round trip. Concurrency rules draw a
-          // lease token (needs release); pure-rate rules draw a window permit
-          // (already decremented server-side, no release).
-          const currentLeaseId = hasConcurrency ? leaseIds[0]! : null;
-          const remainingLeaseIds = hasConcurrency ? leaseIds.slice(1) : [];
-          const remainingWindowPermits = hasConcurrency
-            ? 0
-            : response.granted - 1;
-          if (remainingLeaseIds.length > 0 || remainingWindowPermits > 0)
-            this.mergeBlock(
-              bucketId,
-              remainingLeaseIds,
-              remainingWindowPermits,
-              rulesKey,
-              ordered,
-            );
-          return this.permitFor(bucketId, ordered, currentLeaseId);
-        }
-        await this.sleep(
-          Math.max(1, Math.min(response.waitMs, MAX_ACQUIRE_SLEEP_MS)),
-        );
-      } catch (error) {
-        // Fail closed. A degraded rate-state store must not grant unlimited
-        // provider calls; after this bounded retry ladder the run fails loudly.
-        consecutiveFailures += 1;
-        const normalized = normalizeError(error);
-        this.onStoreFailure({ bucketId, error: normalized.message });
-        if (consecutiveFailures > STORE_FAILURE_RETRY_DELAYS_MS.length) {
-          throw new Error(
-            `Rate-state store unavailable for ${bucketId}; failing closed after ${consecutiveFailures} acquire attempts: ${normalized.message}`,
+          await this.sleep(
+            STORE_FAILURE_RETRY_DELAYS_MS[consecutiveFailures - 1] ?? 250,
           );
         }
-        await this.sleep(
-          STORE_FAILURE_RETRY_DELAYS_MS[consecutiveFailures - 1] ?? 250,
-        );
+      }
+    });
+  }
+
+  private async withBucketAcquisitionLock<T>(
+    bucketId: string,
+    operation: () => Promise<T>,
+  ): Promise<T> {
+    const previous = this.acquisitionTails.get(bucketId) ?? Promise.resolve();
+    let unlock!: () => void;
+    const gate = new Promise<void>((resolve) => {
+      unlock = resolve;
+    });
+    const tail = previous.then(() => gate);
+    this.acquisitionTails.set(bucketId, tail);
+    await previous;
+    try {
+      return await operation();
+    } finally {
+      unlock();
+      if (this.acquisitionTails.get(bucketId) === tail) {
+        this.acquisitionTails.delete(bucketId);
       }
     }
   }
@@ -208,7 +239,7 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
     rulesKey: string,
     rules: PacingRule[],
   ): void {
-    const freshExpiresAt = this.now() + LEASE_BLOCK_TTL_MS;
+    const freshExpiresAt = this.now() + leasedBlockTtlMs(rules);
     const existing = this.blocks.get(bucketId);
     if (
       existing &&
@@ -240,8 +271,8 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
     if (block.rulesKey !== rulesKey || block.expiresAt <= this.now()) {
       this.blocks.delete(bucketId);
       // Unused window permits are forfeited on TTL expiry (the server already
-      // decremented the provider window for them, and the LEASE_BLOCK_TTL_MS
-      // window is short so at most one block's worth is stranded per bucket).
+      // decremented the provider window for them, and the rule-scoped TTL is
+      // capped so at most one block's worth is stranded per bucket/window).
       // Concurrency leases must be released so the shared slot count drains.
       this.releaseReserved(bucketId, block.rules, block.leaseIds);
       return null;
@@ -275,18 +306,54 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
       !rules.some((rule) => rule.maxConcurrency != null)
     )
       return;
-    void releaseRateStateViaAppRuntime(this.context, {
+    const ordered = [...rules].sort((a, b) => a.ruleId.localeCompare(b.ruleId));
+    const key = `${bucketId}\0${rulesSignature(ordered)}`;
+    const pending = this.pendingReleases.get(key) ?? {
       bucketId,
-      rules: [...rules],
-      leaseIds: [...leaseIds],
-      schedulerSchema: this.schedulerSchema,
-    }).catch((error) => {
-      const normalized = normalizeError(error);
-      this.pendingReleaseFailure = new Error(
-        `Rate-state release failed for ${bucketId}: ${normalized.message}`,
-      );
-      this.onStoreFailure({ bucketId, error: normalized.message });
-    });
+      rules: ordered,
+      leaseIds: [],
+      flushing: false,
+    };
+    pending.leaseIds.push(...leaseIds);
+    this.pendingReleases.set(key, pending);
+    if (pending.flushing) return;
+    pending.flushing = true;
+    queueMicrotask(() => void this.flushReleases(key, pending));
+  }
+
+  private async flushReleases(
+    key: string,
+    pending: PendingRelease,
+  ): Promise<void> {
+    while (pending.leaseIds.length > 0) {
+      const leaseIds = pending.leaseIds.splice(0);
+      try {
+        await releaseRateStateViaAppRuntime(this.context, {
+          bucketId: pending.bucketId,
+          rules: pending.rules,
+          leaseIds,
+          schedulerSchema: this.schedulerSchema,
+        });
+      } catch (error) {
+        const normalized = normalizeError(error);
+        this.pendingReleaseFailure = new Error(
+          `Rate-state release failed for ${pending.bucketId}: ${normalized.message}`,
+        );
+        this.onStoreFailure({
+          bucketId: pending.bucketId,
+          error: normalized.message,
+        });
+      }
+    }
+    pending.flushing = false;
+    if (pending.leaseIds.length > 0) {
+      pending.flushing = true;
+      queueMicrotask(() => void this.flushReleases(key, pending));
+      return;
+    }
+    if (this.pendingReleases.get(key) === pending) {
+      this.pendingReleases.delete(key);
+    }
   }
 
   private throwPendingReleaseFailure(): void {
@@ -307,6 +374,19 @@ function rulesSignature(rules: readonly PacingRule[]): string {
     .join('|');
 }
 
+function leasedBlockTtlMs(rules: readonly PacingRule[]): number {
+  const shortestWindowMs = Math.min(
+    ...rules
+      .map((rule) => rule.windowMs)
+      .filter((windowMs) => Number.isFinite(windowMs) && windowMs > 0),
+  );
+  if (!Number.isFinite(shortestWindowMs)) return LEASE_BLOCK_MIN_TTL_MS;
+  return Math.max(
+    LEASE_BLOCK_MIN_TTL_MS,
+    Math.min(LEASE_BLOCK_MAX_TTL_MS, Math.floor(shortestWindowMs)),
+  );
+}
+
 function normalizeError(error: unknown): Error {
   return error instanceof Error ? error : new Error(String(error));
 }

package/dist/bundling-sources/shared_libs/play-runtime/governor/coordinator-rate-state-backend.ts

@@ -21,9 +21,9 @@ import {
  * hello-world latency baseline. Instead the backend LEASES SMALL PERMIT BLOCKS:
  * one `/rate-acquire` round-trip debits up to {@link LEASE_BLOCK_SIZE} permits
  * from the global window, and subsequent acquires draw from the local block
- * until it is exhausted or its short TTL expires. This bounds round-trips to
- * roughly `calls / LEASE_BLOCK_SIZE` while keeping over-issuance bounded by one
- * block per isolate per window.
+ * until it is exhausted or its rule-scoped TTL expires. This bounds round-trips
+ * to roughly `calls / LEASE_BLOCK_SIZE` while keeping over-issuance bounded by
+ * one block per isolate per window.
  *
  * Fail-open: if the coordinator is unreachable the backend logs once and
  * PROCEEDS (grants the permit) rather than stalling the run, matching the
@@ -35,11 +35,14 @@ import {
 /** Permits leased per round-trip. Tuned to amortize the DO hop, not to batch. */
 const LEASE_BLOCK_SIZE = 16;
 /**
- * Max age of a leased block. A leased permit debited the global window already,
- * but if it is held past roughly one window it could let an isolate run ahead
- * of a rolled-over window. Discarding stale blocks bounds that to sub-window.
+ * Min/max age of a leased block. A leased permit debited the global window
+ * already, but if it is held well past the provider window it could let an
+ * isolate run ahead of a rolled-over window. The effective TTL is derived from
+ * the shortest rule window so low-RPS pure-rate providers can draw already-
+ * debited permits throughout a normal window instead of burning most blocks.
  */
-const LEASE_BLOCK_TTL_MS = 250;
+const LEASE_BLOCK_MIN_TTL_MS = 250;
+const LEASE_BLOCK_MAX_TTL_MS = 5_000;
 /** Cap one coordinator-provided sleep hint; total wait is bounded by run timeout. */
 const MAX_ACQUIRE_SLEEP_MS = 5_000;
 
@@ -148,7 +151,7 @@ export class CoordinatorRateStateBackend implements RateStateBackend {
         // Consume one for this call; cache the rest as a short-lived block.
         const remaining = response.granted - 1;
         if (remaining > 0) {
-          this.mergeBlock(bucketId, remaining, rulesKey);
+          this.mergeBlock(bucketId, remaining, rulesKey, rules);
         }
         return noopPacingPermit();
       }
@@ -196,8 +199,9 @@ export class CoordinatorRateStateBackend implements RateStateBackend {
     bucketId: string,
     remaining: number,
     rulesKey: string,
+    rules: readonly PacingRule[],
   ): void {
-    const freshExpiresAt = this.now() + LEASE_BLOCK_TTL_MS;
+    const freshExpiresAt = this.now() + leasedBlockTtlMs(rules);
     const existing = this.blocks.get(bucketId);
     if (
       existing &&
@@ -229,3 +233,16 @@ export class CoordinatorRateStateBackend implements RateStateBackend {
     return true;
   }
 }
+
+function leasedBlockTtlMs(rules: readonly PacingRule[]): number {
+  const shortestWindowMs = Math.min(
+    ...rules
+      .map((rule) => rule.windowMs)
+      .filter((windowMs) => Number.isFinite(windowMs) && windowMs > 0),
+  );
+  if (!Number.isFinite(shortestWindowMs)) return LEASE_BLOCK_MIN_TTL_MS;
+  return Math.max(
+    LEASE_BLOCK_MIN_TTL_MS,
+    Math.min(LEASE_BLOCK_MAX_TTL_MS, Math.floor(shortestWindowMs)),
+  );
+}

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

@@ -147,6 +147,16 @@ export interface PlayExecutionGovernor {
     childRunId: string;
   }): Promise<GovernanceSnapshot>;
 
+  /**
+   * Fork an in-process child view. The child gets its own lineage while sharing
+   * the parent's row/tool/child semaphores, adaptive admission, and global
+   * budget counters.
+   */
+  forkInlineChild(input: {
+    childPlayName: string;
+    childRunId: string;
+  }): Promise<PlayExecutionGovernor>;
+
   /** Effective row concurrency: explicit request clamped to [1, rowMax], else default. */
   resolveRowConcurrency(requested?: number): number;
 
@@ -364,7 +374,7 @@ export function createPlayExecutionGovernor(
     }
   }
 
-  return {
+  const governor: PlayExecutionGovernor = {
     adapter: input.adapter,
     policy,
 
@@ -510,6 +520,13 @@ export function createPlayExecutionGovernor(
       };
     },
 
+    async forkInlineChild(childInput) {
+      return createInlineChildGovernor(
+        governor,
+        await governor.forkChild(childInput),
+      );
+    },
+
     resolveRowConcurrency: (requested) =>
       resolveRowConcurrency(policy, requested),
 
@@ -551,4 +568,95 @@ export function createPlayExecutionGovernor(
       parentChildCalls: { ...state.parentChildCalls },
     }),
   };
+  return governor;
+}
+
+function createInlineChildGovernor(
+  root: PlayExecutionGovernor,
+  initial: GovernanceSnapshot,
+): PlayExecutionGovernor {
+  const lineage = {
+    rootRunId: initial.rootRunId,
+    currentRunId: initial.currentRunId,
+    currentPlayId: initial.currentPlayId,
+    ancestryPlayIds: [...initial.ancestryPlayIds],
+    ancestryRunIds: [...initial.ancestryRunIds],
+    callDepth: initial.callDepth,
+    parentChildCalls: { ...initial.parentChildCalls },
+  };
+
+  const child: PlayExecutionGovernor = {
+    adapter: root.adapter,
+    policy: root.policy,
+    acquireRowSlot: (opts) => root.acquireRowSlot(opts),
+    acquireChildSubmitSlot: (opts) => root.acquireChildSubmitSlot(opts),
+    acquireToolSlot: (toolId, opts) => root.acquireToolSlot(toolId, opts),
+    suggestedParallelism: (toolId, fallback) =>
+      root.suggestedParallelism(toolId, fallback),
+    chargeBudget: (kind, amount) => root.chargeBudget(kind, amount),
+    resolveRowConcurrency: (requested) => root.resolveRowConcurrency(requested),
+    reportProviderBackpressure: (input) =>
+      root.reportProviderBackpressure(input),
+    observeProviderSuccess: (input) => root.observeProviderSuccess(input),
+    observeToolSuccess: (input) => root.observeToolSuccess(input),
+    async forkChild(input) {
+      if (lineage.ancestryPlayIds.includes(input.childPlayName)) {
+        throw new Error(
+          `Recursive play graph detected: ${[
+            ...lineage.ancestryPlayIds,
+            input.childPlayName,
+          ].join(' -> ')}`,
+        );
+      }
+      const nextDepth = lineage.callDepth + 1;
+      if (nextDepth > child.policy.budgets.maxPlayCallDepth) {
+        throw new GovernorBudgetError(
+          'playDepth',
+          nextDepth,
+          child.policy.budgets.maxPlayCallDepth,
+        );
+      }
+      const nextParent =
+        (lineage.parentChildCalls[lineage.currentPlayId] ?? 0) + 1;
+      if (nextParent > child.policy.budgets.maxChildPlayCallsPerParent) {
+        throw new GovernorBudgetError(
+          'childPerParent',
+          nextParent,
+          child.policy.budgets.maxChildPlayCallsPerParent,
+        );
+      }
+      await root.chargeBudget('playCall');
+      await root.chargeBudget('descendant');
+      lineage.parentChildCalls[lineage.currentPlayId] = nextParent;
+      const counters = root.snapshot();
+      return {
+        rootRunId: lineage.rootRunId,
+        currentRunId: input.childRunId,
+        currentPlayId: input.childPlayName,
+        ancestryPlayIds: [...lineage.ancestryPlayIds, input.childPlayName],
+        ancestryRunIds: [...lineage.ancestryRunIds, input.childRunId],
+        callDepth: nextDepth,
+        playCallCount: counters.playCallCount,
+        toolCallCount: counters.toolCallCount,
+        retryCount: counters.retryCount,
+        descendantCount: counters.descendantCount,
+        waterfallStepExecutions: counters.waterfallStepExecutions,
+        parentChildCalls: {},
+      };
+    },
+    async forkInlineChild(input) {
+      return createInlineChildGovernor(child, await child.forkChild(input));
+    },
+    snapshot() {
+      const counters = root.snapshot();
+      return {
+        ...counters,
+        ...lineage,
+        ancestryPlayIds: [...lineage.ancestryPlayIds],
+        ancestryRunIds: [...lineage.ancestryRunIds],
+        parentChildCalls: { ...lineage.parentChildCalls },
+      };
+    },
+  };
+  return child;
 }

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

@@ -70,6 +70,7 @@ export interface PlayRunnerContextConfig {
   executorToken?: string;
   baseUrl?: string;
   receiptGatewayBaseUrl?: string | null;
+  runtimeTestFaultHeader?: string | null;
   vercelProtectionBypassToken?: string | null;
   integrationMode?: 'live' | 'eval_stub' | 'fixture';
   orgId?: string;

package/dist/bundling-sources/shared_libs/play-runtime/receipt-completion-sink.ts

@@ -141,6 +141,13 @@ export class RuntimeReceiptCompletionSink<TInput, TOutput> {
     return await Promise.all(outputPromises);
   }
 
+  async addManyAndFlush(inputs: readonly TInput[]): Promise<TOutput[]> {
+    const outputsPromise = this.addMany(inputs);
+    const flushPromise = this.flush();
+    const [outputs] = await Promise.all([outputsPromise, flushPromise]);
+    return outputs;
+  }
+
   async flush(): Promise<void> {
     if (this.#failure) throw this.#failure;
     this.#clearFlushTimer();