deepline 0.1.199 → 0.1.200

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

@@ -0,0 +1,12 @@
+/** Maximum active user-code runtime for a standard play, in seconds. */
+export const STANDARD_PLAY_RUNTIME_LIMIT_SECONDS = 20 * 60;
+export const STANDARD_PLAY_RUNTIME_LIMIT_LABEL = '20 minutes';
+
+/**
+ * Runner timeout includes setup, cleanup, and billing headroom after the
+ * user-code runtime cap.
+ */
+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;

package/dist/bundling-sources/shared_libs/play-runtime/runtime-infra-mode.ts

@@ -0,0 +1,23 @@
+export const DEEPLINE_V2_INFRA_MODE_ENV = 'DEEPLINE_V2_INFRA_MODE';
+
+function currentRuntimeInfraMode(): string {
+  return process.env[DEEPLINE_V2_INFRA_MODE_ENV]?.trim().toLowerCase() ?? '';
+}
+
+export function isPreviewPlaysDeployment(): boolean {
+  const mode = currentRuntimeInfraMode();
+  return (
+    mode === 'external' ||
+    mode === 'preview' ||
+    mode === 'absurd-preview' ||
+    mode === 'absurd:preview'
+  );
+}
+
+export function isCloudflarePlaysDeployment(): boolean {
+  return currentRuntimeInfraMode() === 'cloudflare';
+}
+
+export function requiresPublicCallbackBaseUrl(): boolean {
+  return isPreviewPlaysDeployment() || isCloudflarePlaysDeployment();
+}

package/dist/bundling-sources/shared_libs/play-runtime/runtime-sheet-attempt-state-machine.ts

@@ -57,6 +57,20 @@ function normalizeAttemptSeq(value: number | null | undefined): number {
   return Number.isFinite(value) ? Math.trunc(value as number) : 0;
 }
 
+function isSameOwnerOlderRequest(input: {
+  row: RuntimeSheetRowAttemptInput;
+  request: RuntimeSheetAttemptIdentity;
+}): boolean {
+  const rowOwner =
+    normalize(input.row.attemptOwnerRunId) ?? normalize(input.row.runId);
+  const requestOwner = normalize(input.request.attemptOwnerRunId);
+  return (
+    Boolean(rowOwner && requestOwner && rowOwner === requestOwner) &&
+    normalizeAttemptSeq(input.request.attemptSeq) <
+      normalizeAttemptSeq(input.row.attemptSeq)
+  );
+}
+
 export function classifyRuntimeSheetAttemptRelation(input: {
   row: RuntimeSheetRowAttemptInput;
   request: RuntimeSheetAttemptIdentity;
@@ -103,13 +117,14 @@ export function decideRuntimeSheetPrepare(input: {
   }
   const relation = classifyRuntimeSheetAttemptRelation(input);
   if (input.row.status === 'pending' || input.row.status === 'running') {
-    return relation.kind === 'other_active_owner' || relation.kind === 'malformed'
+    return (relation.kind !== 'expired' && isSameOwnerOlderRequest(input)) ||
+      relation.kind === 'malformed'
       ? { kind: 'blocked_by_active_owner' }
       : { kind: 'claim_executable' };
   }
   if (input.row.status === 'enriched') {
     if (!input.missingRequiredOutput) return { kind: 'reuse_completed' };
-    return relation.kind === 'same_owner_stale_attempt' ||
+    return (relation.kind !== 'expired' && isSameOwnerOlderRequest(input)) ||
       relation.kind === 'malformed'
       ? { kind: 'blocked_by_active_owner' }
       : { kind: 'claim_executable' };
@@ -123,6 +138,12 @@ export function decideRuntimeSheetTerminalWrite(input: {
   nowMs?: number;
 }): RuntimeSheetTerminalDecision {
   const relation = classifyRuntimeSheetAttemptRelation(input);
+  if (input.row.status !== 'enriched') {
+    return (relation.kind !== 'expired' && isSameOwnerOlderRequest(input)) ||
+      relation.kind === 'malformed'
+      ? { kind: 'reject_stale_attempt' }
+      : { kind: 'write_terminal' };
+  }
   if (
     relation.kind === 'unowned' ||
     relation.kind === 'same_attempt' ||

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

@@ -5,7 +5,7 @@
  * Selected per-run via PlayExecutionProfile.
  *
  * Cloudflare Workflows is the default production scheduler through the
- * workers_edge profile. Hatchet is selected explicitly by the hatchet profile.
+ * workers_edge profile. Absurd is the durable Daytona-backed scheduler.
  *
  * Customer plays are unaffected — this is purely the orchestration layer.
  */
@@ -20,23 +20,25 @@ import type { PlayRuntimeManifestMap } from '../plays/compiler-manifest';
 import type { PreloadedRuntimeDbSession } from './db-session';
 import type { PlayRunnerRuntimeTiming } from './protocol';
 import type { RuntimeTestPolicyOverrides } from './test-runtime-seams';
+import type { PlayRunInputPayload } from './play-input';
 
 export const PLAY_SCHEDULER_BACKENDS = {
-  temporal: 'temporal',
   cfWorkflows: 'cf-workflows',
+  /** Private legacy id retained only so old persisted rows can be interpreted. */
+  postgres: 'postgres',
   /**
-   * Private legacy id retained only so old persisted rows can be interpreted.
-   * It is not a selectable scheduler backend after the Hatchet hard cutover.
+   * Postgres-native durable-execution scheduler (vendored Absurd engine). Runs
+   * on the battle-tested run-state store without an external workflow engine.
+   * Selected explicitly by the `absurd` profile.
    */
-  postgres: 'postgres',
-  hatchet: 'hatchet',
+  absurd: 'absurd',
   inProcess: 'in-process',
 } as const;
 
 export type PlaySchedulerBackendId =
   (typeof PLAY_SCHEDULER_BACKENDS)[keyof typeof PLAY_SCHEDULER_BACKENDS];
 
-export type PlayRunInputPayload = Record<string, unknown> | unknown[];
+export type { PlayRunInputPayload };
 
 export type PlayCallGovernanceSnapshot = {
   rootRunId: string;
@@ -78,9 +80,8 @@ export type PlaySchedulerSubmitInput = {
   workflowFamilyKey?: string | null;
   artifactStorageKey: string;
   /**
-   * Optional inline artifact for schedulers that run the legacy Temporal
-   * workflow path. Workers-edge schedulers use artifactStorageKey plus
-   * dynamicWorkerCode instead.
+   * Optional inline artifact for node-compatible schedulers. Workers-edge
+   * schedulers use artifactStorageKey plus dynamicWorkerCode instead.
    */
   runtimeArtifact?: unknown;
   artifactHash: string;
@@ -101,11 +102,6 @@ export type PlaySchedulerSubmitInput = {
     bytes?: number;
   } | null;
   inlineCsv?: { name: string; rows: Record<string, unknown>[] } | null;
-  /**
-   * Temporal-only escape hatch for small legacy inputs. Workers-edge CSV
-   * inputs must be staged and streamed by handle instead of carried as raw
-   * scheduler payload bytes.
-   */
   inlineInputFile?: {
     logicalPath: string;
     fileName: string;
@@ -143,8 +139,6 @@ export type PlaySchedulerSubmitInput = {
   userId?: string | null;
   source?: 'published' | 'ad_hoc' | 'draft';
   executionProfile?: string | null;
-  /** Durable per-workspace active run cap enforced when the run row is projected. */
-  activeRunLimit?: number | null;
   /** runner backend to use for executing attempts */
   runtimeBackend: string;
   /** dedup backend for cross-attempt cross-process idempotency */
@@ -244,24 +238,22 @@ export function normalizePlaySchedulerBackend(
   value?: string | null,
 ): PlaySchedulerBackendId {
   const normalized = value?.trim().toLowerCase();
-  if (!normalized || normalized === 'temporal') {
-    return PLAY_SCHEDULER_BACKENDS.temporal;
+  if (!normalized) {
+    return PLAY_SCHEDULER_BACKENDS.cfWorkflows;
   }
   if (normalized === 'cf-workflows' || normalized === 'cf_workflows') {
     return PLAY_SCHEDULER_BACKENDS.cfWorkflows;
   }
-  if (normalized === 'hatchet' || normalized === 'hatchet-scheduler') {
-    return PLAY_SCHEDULER_BACKENDS.hatchet;
+  if (normalized === 'absurd' || normalized === 'absurd-scheduler') {
+    return PLAY_SCHEDULER_BACKENDS.absurd;
   }
   if (normalized === 'in-process' || normalized === 'in_process') {
     return PLAY_SCHEDULER_BACKENDS.inProcess;
   }
   throw new Error(
     `Unsupported scheduler backend "${normalized}". Expected one of: ${[
-      PLAY_SCHEDULER_BACKENDS.temporal,
       PLAY_SCHEDULER_BACKENDS.cfWorkflows,
-      PLAY_SCHEDULER_BACKENDS.hatchet,
-      PLAY_SCHEDULER_BACKENDS.inProcess,
+      PLAY_SCHEDULER_BACKENDS.absurd,
     ].join(', ')}.`,
   );
 }

package/dist/bundling-sources/shared_libs/play-runtime/serial-task-queue.ts

@@ -0,0 +1,26 @@
+export interface SerialTaskQueue {
+  enqueue<T>(task: () => Promise<T>): Promise<T>;
+  idle(): Promise<void>;
+}
+
+/**
+ * Runs asynchronous tasks one at a time in enqueue order. A rejected task is
+ * returned to its caller but does not poison the queue for later work.
+ */
+export function createSerialTaskQueue(): SerialTaskQueue {
+  let tail: Promise<void> = Promise.resolve();
+
+  return {
+    enqueue<T>(task: () => Promise<T>): Promise<T> {
+      const result = tail.then(task);
+      tail = result.then(
+        () => undefined,
+        () => undefined,
+      );
+      return result;
+    },
+    idle(): Promise<void> {
+      return tail;
+    },
+  };
+}

package/dist/bundling-sources/shared_libs/play-runtime/submit-limits.ts

@@ -13,7 +13,7 @@
  * (and the workflow event history). Larger inputs must be staged via
  * `POST /api/v2/plays/files/stage` and referenced by handle.
  */
-export const MAX_TEMPORAL_INLINE_INPUT_FILE_BYTES = 64 * 1024;
+export const MAX_SUBMITTED_INLINE_INPUT_FILE_BYTES = 64 * 1024;
 
 /**
  * Max time the run route will block waiting for a play to finish before

package/dist/bundling-sources/shared_libs/play-runtime/vercel-protection.ts

@@ -0,0 +1,81 @@
+type FetchLike = typeof fetch;
+
+const vercelProtectionCookieCache = new Map<string, Promise<string | null>>();
+
+export function addVercelProtectionBypassSearchParams(
+  url: URL,
+  token: string | null | undefined,
+): void {
+  const normalized = token?.trim();
+  if (!normalized) return;
+  url.searchParams.set('x-vercel-set-bypass-cookie', 'true');
+  url.searchParams.set('x-vercel-protection-bypass', normalized);
+}
+
+export function vercelProtectionBypassHeader(
+  token: string | null | undefined,
+): Record<string, string> {
+  const normalized = token?.trim();
+  return normalized ? { 'x-vercel-protection-bypass': normalized } : {};
+}
+
+function setCookieHeaders(headers: Headers): string[] {
+  const getter = (headers as Headers & { getSetCookie?: () => string[] })
+    .getSetCookie;
+  if (typeof getter === 'function') {
+    return getter.call(headers);
+  }
+  const single = headers.get('set-cookie');
+  return single ? [single] : [];
+}
+
+export function cookieHeaderFromSetCookie(headers: Headers): string | null {
+  const cookies = setCookieHeaders(headers)
+    .flatMap((header) => header.split(/,(?=\s*[^;,=]+=[^;,]+)/g))
+    .map((header) => header.split(';', 1)[0]?.trim() ?? '')
+    .filter(Boolean);
+  return cookies.length > 0 ? cookies.join('; ') : null;
+}
+
+export async function resolveVercelProtectionBypassCookie(input: {
+  baseUrl: string | null | undefined;
+  token: string | null | undefined;
+  fetchImpl?: FetchLike;
+}): Promise<string | null> {
+  const token = input.token?.trim();
+  const baseUrl = input.baseUrl?.trim().replace(/\/$/, '');
+  if (!token || !baseUrl) return null;
+
+  const cacheKey = `${baseUrl}\n${token}`;
+  const cached = vercelProtectionCookieCache.get(cacheKey);
+  if (cached) return await cached;
+
+  const promise = (async () => {
+    const url = new URL(`${baseUrl}/api/v2/health`);
+    addVercelProtectionBypassSearchParams(url, token);
+    const response = await (input.fetchImpl ?? fetch)(url.toString(), {
+      headers: { 'x-vercel-protection-bypass': token },
+    }).catch(() => null);
+    return response ? cookieHeaderFromSetCookie(response.headers) : null;
+  })();
+  vercelProtectionCookieCache.set(cacheKey, promise);
+  return await promise;
+}
+
+export async function vercelProtectionBypassHeaders(input: {
+  baseUrl: string | null | undefined;
+  token: string | null | undefined;
+  fetchImpl?: FetchLike;
+}): Promise<Record<string, string>> {
+  const token = input.token?.trim();
+  if (!token) return {};
+  const cookie = await resolveVercelProtectionBypassCookie({
+    baseUrl: input.baseUrl,
+    token,
+    fetchImpl: input.fetchImpl,
+  });
+  return {
+    ...vercelProtectionBypassHeader(token),
+    ...(cookie ? { cookie } : {}),
+  };
+}

package/dist/bundling-sources/shared_libs/play-runtime/work-receipt-state-machine.ts

@@ -1,4 +1,5 @@
 export type WorkReceiptStateStatus =
+  | 'queued'
   | 'pending'
   | 'running'
   | 'completed'
@@ -51,6 +52,12 @@ export type WorkReceiptInvalidLeaseReason = Extract<
 >['reason'];
 
 export type WorkReceiptState =
+  | {
+      kind: 'queued';
+      terminal: false;
+      reusable: false;
+      lease: WorkReceiptLeaseState;
+    }
   | {
       kind: 'pending';
       terminal: false;
@@ -209,7 +216,8 @@ export function classifyWorkReceiptState(
   const lease = classifyWorkReceiptLeaseState(receipt, nowMs);
   switch (receipt.status) {
     case 'pending':
-      return { kind: 'pending', terminal: false, reusable: false, lease };
+    case 'queued':
+      return { kind: 'queued', terminal: false, reusable: false, lease };
     case 'running':
       return { kind: 'running', terminal: false, reusable: false, lease };
     case 'completed':
@@ -255,7 +263,11 @@ export function decideWorkReceiptClaim(input: {
     }
     return { kind: 'blocked_failed' };
   }
-  if (state.kind === 'pending' || state.kind === 'running') {
+  if (
+    state.kind === 'pending' ||
+    state.kind === 'queued' ||
+    state.kind === 'running'
+  ) {
     if (state.lease.kind === 'active') {
       if (
         (state.kind !== 'running' ||
@@ -284,7 +296,7 @@ export function decideWorkReceiptClaim(input: {
     if (input.forceRefresh === true && input.reclaimRunning === true) {
       return { kind: 'claim' };
     }
-    if (state.kind === 'pending') {
+    if (state.kind === 'pending' || state.kind === 'queued') {
       return { kind: 'claim' };
     }
     if (
@@ -364,6 +376,32 @@ function baseRunningOwnerDecision(
   return { kind: 'allow' };
 }
 
+function baseActiveOwnerDecision(
+  input: WorkReceiptOwnerOperationInput,
+): WorkReceiptOwnerOperationDecision {
+  if (!input.receipt) {
+    return { kind: 'reject', reason: 'missing_receipt' };
+  }
+  if (
+    input.receipt.status !== 'queued' &&
+    input.receipt.status !== 'pending' &&
+    input.receipt.status !== 'running'
+  ) {
+    return { kind: 'reject', reason: 'not_running' };
+  }
+  const ownerRunId = normalize(input.ownerRunId);
+  if (!ownerRunId || ownerRunIdForReceipt(input.receipt) !== ownerRunId) {
+    return { kind: 'reject', reason: 'owner_mismatch' };
+  }
+  if (
+    normalizeAttempt(input.receipt.leaseOwnerAttempt) !==
+    normalizeAttempt(input.ownerRunAttempt)
+  ) {
+    return { kind: 'reject', reason: 'attempt_mismatch' };
+  }
+  return { kind: 'allow' };
+}
+
 /**
  * Law for complete/fail/skip. A terminal write may only be made by the
  * running receipt owner for the same attempt. When the receipt has a lease id,
@@ -385,14 +423,21 @@ export function decideWorkReceiptTerminalWrite(
 }
 
 /**
- * Law for a single suspended receipt release. It uses the same ownership fence
- * as terminal writes: only the running owner can release, and a leased receipt
- * requires the exact lease id.
+ * Law for a single suspended receipt release. The owner may release queued or
+ * running work, and a leased receipt requires the exact lease id.
  */
 export function decideWorkReceiptExactRelease(
   input: WorkReceiptOwnerOperationInput,
 ): WorkReceiptOwnerOperationDecision {
-  return decideWorkReceiptTerminalWrite(input);
+  const ownerDecision = baseActiveOwnerDecision(input);
+  if (ownerDecision.kind === 'reject') return ownerDecision;
+
+  const receiptLeaseId = normalize(input.receipt?.leaseId);
+  if (!receiptLeaseId) return { kind: 'allow' };
+  if (receiptLeaseId !== normalize(input.leaseId)) {
+    return { kind: 'reject', reason: 'lease_mismatch' };
+  }
+  return { kind: 'allow' };
 }
 
 /**
@@ -403,7 +448,7 @@ export function decideWorkReceiptExactRelease(
 export function decideWorkReceiptOwnerRelease(
   input: WorkReceiptOwnerOperationInput,
 ): WorkReceiptOwnerOperationDecision {
-  return baseRunningOwnerDecision(input);
+  return baseActiveOwnerDecision(input);
 }
 
 /**
@@ -413,7 +458,7 @@ export function decideWorkReceiptOwnerRelease(
 export function decideWorkReceiptHeartbeat(
   input: WorkReceiptOwnerOperationInput,
 ): WorkReceiptOwnerOperationDecision {
-  const ownerDecision = baseRunningOwnerDecision(input);
+  const ownerDecision = baseActiveOwnerDecision(input);
   if (ownerDecision.kind === 'reject') return ownerDecision;
 
   const requestLeaseId = normalize(input.leaseId);

package/dist/bundling-sources/shared_libs/play-runtime/work-receipts.ts

@@ -25,6 +25,7 @@ export function workReceiptFailureKindCode(
 }
 
 export type WorkReceiptStatus =
+  | 'queued'
   | 'pending'
   | 'running'
   | 'completed'
@@ -102,6 +103,17 @@ export type WorkReceiptBatchHeartbeatCommand = {
   leaseTtlMs?: number | null;
 };
 
+export type WorkReceiptBatchMarkRunningCommand = {
+  playName: string;
+  receipts: Array<{
+    runId: string;
+    key: string;
+    leaseId?: string | null;
+    runAttempt?: number | null;
+  }>;
+  leaseTtlMs?: number | null;
+};
+
 export type WorkReceiptGetCommand = {
   playName: string;
   key: string;
@@ -111,6 +123,7 @@ export type WorkReceiptClaim =
   | {
       disposition: 'claimed';
       receipt: WorkReceipt;
+      wasFailed?: boolean;
     }
   | {
       disposition: 'reused';
@@ -135,6 +148,9 @@ export type WorkReceiptStore = {
   claimReceipts?(
     input: WorkReceiptBatchClaimCommand,
   ): Promise<WorkReceiptClaim[]>;
+  markReceiptsRunning?(
+    input: WorkReceiptBatchMarkRunningCommand,
+  ): Promise<Array<WorkReceipt | null>>;
   completeReceipt(
     input: WorkReceiptCommand & { output: unknown },
   ): Promise<WorkReceipt | null>;
@@ -150,9 +166,7 @@ export type WorkReceiptStore = {
   failReceipts?(
     input: WorkReceiptBatchFailCommand,
   ): Promise<Array<WorkReceipt | null>>;
-  releaseReceipt?(
-    input: WorkReceiptCommand,
-  ): Promise<WorkReceipt | null>;
+  releaseReceipt?(input: WorkReceiptCommand): Promise<WorkReceipt | null>;
   heartbeatReceipts?(
     input: WorkReceiptBatchHeartbeatCommand,
   ): Promise<Array<WorkReceipt | null>>;

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

@@ -41,10 +41,6 @@ const DAYTONA_COMPUTE_PRICING_USD = {
   includedStorageGiB: 5,
 } as const;
 
-const TEMPORAL_COMPUTE_PRICING_USD = {
-  action: 50 / 1_000_000,
-} as const;
-
 const NEON_COMPUTE_PRICING_USD = {
   cuHour: 0.106,
   defaultCu: 1,
@@ -97,22 +93,6 @@ export function resolveDaytonaSandboxComputeItem(input: {
   };
 }
 
-export function resolveTemporalComputeItem(input: {
-  itemId: string;
-  actions: number;
-  metadata?: unknown;
-}): ComputeBillingItem {
-  const actions = Math.max(0, Math.ceil(input.actions));
-  return {
-    itemId: input.itemId,
-    source: 'temporal',
-    unit: 'action',
-    units: actions,
-    providerCostUsd: roundUsd(actions * TEMPORAL_COMPUTE_PRICING_USD.action),
-    metadata: input.metadata,
-  };
-}
-
 export function resolveNeonComputeItem(input: {
   itemId: string;
   activeSeconds: number;

package/dist/bundling-sources/shared_libs/plays/dataset.ts

@@ -3,6 +3,7 @@ import type { PlayExecutionFileRef } from './file-refs';
 const PLAY_DATASET_BRAND = Symbol.for('deepline.play.dataset');
 const NODE_INSPECT_CUSTOM = Symbol.for('nodejs.util.inspect.custom');
 const DEFAULT_MATERIALIZE_LIMIT = 10_000;
+export const PLAY_DATASET_EXECUTION_PAGE_ROWS = 1_000;
 
 export type PlayDatasetKind = 'csv' | 'map';
 
@@ -538,19 +539,119 @@ export function createPlayDataset<T>(
   });
 }
 
+export type MaterializePlayDatasetInputOptions<T> = {
+  onRow?: (row: T, index: number) => void;
+};
+
+export type IteratePlayDatasetInputPagesOptions<T> = {
+  pageSize?: number;
+  onRow?: (row: T, index: number) => void;
+};
+
+function normalizeDatasetExecutionPageSize(value: number | undefined): number {
+  if (typeof value !== 'number' || !Number.isFinite(value)) {
+    return PLAY_DATASET_EXECUTION_PAGE_ROWS;
+  }
+  return Math.max(1, Math.floor(value));
+}
+
+export async function* iteratePlayDatasetInputPages<T>(
+  input: PlayDatasetInput<T>,
+  options?: IteratePlayDatasetInputPagesOptions<T>,
+): AsyncIterable<{ rows: T[]; offset: number }> {
+  const pageSize = normalizeDatasetExecutionPageSize(options?.pageSize);
+  let page: T[] = [];
+  let offset = 0;
+  let index = 0;
+  const pushRow = (row: T): { rows: T[]; offset: number } | null => {
+    options?.onRow?.(row, index);
+    index += 1;
+    page.push(row);
+    if (page.length < pageSize) {
+      return null;
+    }
+    const fullPage = page;
+    const fullOffset = offset;
+    page = [];
+    offset += fullPage.length;
+    return { rows: fullPage, offset: fullOffset };
+  };
+
+  const flush = (): { rows: T[]; offset: number } | null => {
+    if (page.length === 0) return null;
+    const finalPage = page;
+    const finalOffset = offset;
+    page = [];
+    offset += finalPage.length;
+    return { rows: finalPage, offset: finalOffset };
+  };
+
+  const emitRow = async function* (row: T) {
+    const ready = pushRow(row);
+    if (ready) yield ready;
+  };
+
+  if (isPlayDataset(input)) {
+    for await (const row of input) {
+      yield* emitRow(row);
+    }
+    const finalPage = flush();
+    if (finalPage) yield finalPage;
+    return;
+  }
+
+  if (Array.isArray(input)) {
+    for (const row of input) {
+      yield* emitRow(row);
+    }
+    const finalPage = flush();
+    if (finalPage) yield finalPage;
+    return;
+  }
+
+  if (
+    input != null &&
+    typeof input === 'object' &&
+    Symbol.asyncIterator in input
+  ) {
+    for await (const row of input as AsyncIterable<T>) {
+      yield* emitRow(row);
+    }
+    const finalPage = flush();
+    if (finalPage) yield finalPage;
+    return;
+  }
+
+  for (const row of input as Iterable<T>) {
+    yield* emitRow(row);
+  }
+  const finalPage = flush();
+  if (finalPage) yield finalPage;
+}
+
 export async function materializePlayDatasetInput<T>(
   input: PlayDatasetInput<T>,
+  options?: MaterializePlayDatasetInputOptions<T>,
 ): Promise<T[]> {
+  const pushRow = (rows: T[], row: T): void => {
+    options?.onRow?.(row, rows.length);
+    rows.push(row);
+  };
+
   if (isPlayDataset(input)) {
     const rows: T[] = [];
     for await (const row of input) {
-      rows.push(row);
+      pushRow(rows, row);
     }
     return rows;
   }
 
   if (Array.isArray(input)) {
-    return [...input];
+    const rows: T[] = [];
+    for (const row of input) {
+      pushRow(rows, row);
+    }
+    return rows;
   }
 
   const rows: T[] = [];
@@ -560,13 +661,13 @@ export async function materializePlayDatasetInput<T>(
     Symbol.asyncIterator in input
   ) {
     for await (const row of input as AsyncIterable<T>) {
-      rows.push(row);
+      pushRow(rows, row);
     }
     return rows;
   }
 
   for (const row of input as Iterable<T>) {
-    rows.push(row);
+    pushRow(rows, row);
   }
   return rows;
 }