deepline 0.1.210 → 0.1.212

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

@@ -9,16 +9,25 @@ import type {
   PlayRunnerResult,
 } from '@shared_libs/play-runtime/protocol';
 
-export type PlayRunnerRuntimeResource =
-  | {
-      kind: 'daytona_sandbox';
-      sandboxId: string;
-      billingStartedAt: number;
-      billingEndedAt?: number | null;
-      cpu?: number | null;
-      memoryGiB?: number | null;
-      diskGiB?: number | null;
-    };
+export type PlayRunnerRuntimeResource = {
+  kind: 'daytona_sandbox';
+  sandboxId: string;
+  billingStartedAt: number;
+  billingEndedAt?: number | null;
+  terminalReason?: RuntimeResourceTerminalReason | null;
+  terminalAt?: number | null;
+  cpu?: number | null;
+  memoryGiB?: number | null;
+  diskGiB?: number | null;
+};
+
+export type RuntimeResourceTerminalReason =
+  | 'completed'
+  | 'runner_failed'
+  | 'sandbox_missing'
+  | 'sandbox_oom'
+  | 'cancelled'
+  | 'lease_expired';
 
 export class RuntimeResourceFenceLostError extends Error {
   constructor(message: string) {

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

@@ -127,6 +127,8 @@ type RuntimeApiContext = {
   postgresSessionUnwrapKey?: string | null;
 };
 
+const RUNTIME_RUN_DATASET_CATALOG_TABLE = '_deepline_run_datasets';
+
 type DirectRuntimeTestFaultState = {
   headerValue: string;
   counts: Partial<Record<RuntimeTestFaultName, number>>;
@@ -1572,8 +1574,17 @@ async function withRuntimePostgres<T>(
         requestLocalPool = pool;
       }
       client = await connectRuntimePostgresPool(pool);
+      if (session.executionRole) {
+        await client.query(
+          `SET ROLE ${quoteIdentifier(session.executionRole)}`,
+        );
+      }
       break;
     } catch (error) {
+      if (client) {
+        client.release();
+        client = null;
+      }
       if (cachePool) {
         const pool = postgresPools.get(session.postgresUrl);
         postgresPools.delete(session.postgresUrl);
@@ -1604,7 +1615,13 @@ async function withRuntimePostgres<T>(
   try {
     return await fn(client);
   } finally {
-    client.release();
+    try {
+      if (session.executionRole) {
+        await client.query('RESET ROLE');
+      }
+    } finally {
+      client.release();
+    }
     if (requestLocalPool) {
       await Promise.resolve(requestLocalPool.end()).catch(() => {});
     }
@@ -1833,6 +1850,38 @@ function columnSummaryTable(session: RuntimePostgresSession): string {
   return fqRuntimeTable(session, session.postgres.columnSummaryTable);
 }
 
+function runDatasetCatalogTable(session: RuntimePostgresSession): string {
+  return fqRuntimeTable(session, RUNTIME_RUN_DATASET_CATALOG_TABLE);
+}
+
+async function registerRuntimeDataset(
+  session: RuntimePostgresSession,
+  input: { playName: string; tableNamespace: string; runId: string },
+): Promise<void> {
+  const tableNamespace = normalizeTableNamespace(input.tableNamespace);
+  const playName = normalizePlayNameForSheet(input.playName);
+  const datasetId = createRuntimeDatasetId(playName, tableNamespace);
+  await withRuntimePostgres(session, async (client) => {
+    await client.query(
+      `INSERT INTO ${runDatasetCatalogTable(session)} (
+         run_id, dataset_id, play_name, table_namespace, public_path
+       ) VALUES ($1, $2, $3, $4, $5)
+       ON CONFLICT (run_id, dataset_id) DO UPDATE SET
+         play_name = EXCLUDED.play_name,
+         table_namespace = EXCLUDED.table_namespace,
+         public_path = EXCLUDED.public_path,
+         updated_at = now()`,
+      [
+        input.runId,
+        datasetId,
+        playName,
+        tableNamespace,
+        `datasets.${tableNamespace}`,
+      ],
+    );
+  });
+}
+
 function workReceiptTable(session: RuntimePostgresSession): string {
   return fqRuntimeTable(
     session,
@@ -2022,8 +2071,11 @@ async function withRuntimeWorkReceiptClient<T>(
 ): Promise<T> {
   // Receipt tables are part of customer Postgres bootstrap, so the hot path
   // should not pay DDL on every fresh runtime isolate. Try the receipt query
-  // first, then self-heal once on a missing relation/column. A genuinely
-  // missing schema, permission error, or second failure still rethrows loudly.
+  // first, then self-heal once on a missing relation/column. Permission loss
+  // during an operational receipt query must fail loud: silently repairing it
+  // can let provider work continue after durable receipt persistence is gone.
+  // Only the schema-migration branch below may repair ownership before its
+  // retry. A genuinely missing schema or second failure also rethrows loudly.
   const runWithSelfHeal = async (client: RuntimeQueryClient): Promise<T> => {
     try {
       return await operation(client);
@@ -2048,10 +2100,6 @@ async function withRuntimeWorkReceiptClient<T>(
             playName: context.playName?.trim() || session.playName,
           });
         }
-      } else if (isPostgresPermissionDeniedError(error)) {
-        await repairRuntimeStorageGrants(context, {
-          playName: context.playName?.trim() || session.playName,
-        });
       } else {
         throw error;
       }
@@ -5188,6 +5236,14 @@ export async function startRuntimeSheetDataset(
     ms: Date.now() - sessionStartedAt,
     rows: input.rows.length,
   });
+  // Register the exact run-scoped Dataset Handle before any row can become
+  // durable. A crash after a later sheet write can therefore never leave
+  // customer data discoverable only through static pipeline inference.
+  await registerRuntimeDataset(session, {
+    playName,
+    tableNamespace: input.tableNamespace,
+    runId: input.runId,
+  });
   const normalizeStartedAt = Date.now();
   const uniqueRows = new Map<
     string,

package/dist/bundling-sources/shared_libs/play-runtime/secret-capability.ts

@@ -39,10 +39,24 @@ export function isSecretAuth(value: unknown): value is SecretAuth {
 }
 
 export function valueContainsSecret(value: unknown): boolean {
-  if (isSecretHandle(value) || isSecretAuth(value)) return true;
-  if (typeof value === 'string') return SECRET_HANDLE_MARKER_RE.test(value);
-  if (Array.isArray(value)) return value.some(valueContainsSecret);
-  if (isRecord(value)) return Object.values(value).some(valueContainsSecret);
+  const pending: unknown[] = [value];
+  const seen = new WeakSet<object>();
+  while (pending.length > 0) {
+    const candidate = pending.pop();
+    if (isSecretHandle(candidate) || isSecretAuth(candidate)) return true;
+    if (typeof candidate === 'string') {
+      if (SECRET_HANDLE_MARKER_RE.test(candidate)) return true;
+      continue;
+    }
+    if (!candidate || typeof candidate !== 'object') continue;
+    if (seen.has(candidate)) continue;
+    seen.add(candidate);
+    if (Array.isArray(candidate)) {
+      for (const entry of candidate) pending.push(entry);
+    } else if (isRecord(candidate)) {
+      for (const entry of Object.values(candidate)) pending.push(entry);
+    }
+  }
   return false;
 }
 

package/dist/bundling-sources/shared_libs/play-runtime/single-flight.ts

@@ -0,0 +1,31 @@
+export type SingleFlight<K, V> = {
+  run(key: K, create: () => Promise<V>): Promise<V>;
+  has(key: K): boolean;
+  activeCount(): number;
+};
+
+/** Coalesce concurrent work for one key without caching its settled result. */
+export function createSingleFlight<K, V>(): SingleFlight<K, V> {
+  const active = new Map<K, Promise<V>>();
+
+  return {
+    run(key, create) {
+      const existing = active.get(key);
+      if (existing) return existing;
+
+      const pending = Promise.resolve().then(create);
+      active.set(key, pending);
+      const clear = () => {
+        if (active.get(key) === pending) active.delete(key);
+      };
+      void pending.then(clear, clear);
+      return pending;
+    },
+    has(key) {
+      return active.has(key);
+    },
+    activeCount() {
+      return active.size;
+    },
+  };
+}

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

@@ -34,6 +34,8 @@ type ValidatedRuntimeTestFaultHeader =
   | { ok: false; status: 400 | 403; error: string };
 
 export type RuntimeTestPolicyOverrides = {
+  /** Opt-in bounded runner map latency profile for local/preview diagnosis. */
+  mapLatencyProfile?: boolean;
   receiptLeaseTtlMs?: number;
   sheetAttemptLeaseMs?: number;
   heartbeatIntervalMs?: number;
@@ -170,7 +172,8 @@ function parseRuntimeTestPolicyOverrides(
   const unknownKeys = Object.keys(record).filter(
     (key) =>
       !RUNTIME_TEST_POLICY_MS_FIELDS.has(key) &&
-      key !== 'workBudgetYieldLimits',
+      key !== 'workBudgetYieldLimits' &&
+      key !== 'mapLatencyProfile',
   );
   if (unknownKeys.length > 0) {
     return {
@@ -179,6 +182,14 @@ function parseRuntimeTestPolicyOverrides(
   }
 
   const overrides: RuntimeTestPolicyOverrides = {};
+  if ('mapLatencyProfile' in record) {
+    if (typeof record.mapLatencyProfile !== 'boolean') {
+      return {
+        error: 'testPolicyOverrides.mapLatencyProfile must be a boolean.',
+      };
+    }
+    overrides.mapLatencyProfile = record.mapLatencyProfile;
+  }
   for (const field of RUNTIME_TEST_POLICY_MS_FIELDS) {
     if (!(field in record)) continue;
     const parsed = readPositiveIntegerField({

package/dist/bundling-sources/shared_libs/play-runtime/tool-execute-retry-policy.ts

@@ -88,14 +88,15 @@ function decideToolExecuteHttpRetry(input: {
   hasRetryAfterHeader?: boolean;
   transientHttpRetrySafe?: boolean;
 }): ToolExecuteHttpRetryDecision {
+  if (input.hardBillingFailure) {
+    return {
+      retryable: false,
+      attemptCap:
+        input.status === 429 ? TOOL_EXECUTE_RATE_LIMIT_MAX_ATTEMPTS : 1,
+      reason: 'hard_billing_error',
+    };
+  }
   if (input.status === 429) {
-    if (input.hardBillingFailure) {
-      return {
-        retryable: false,
-        attemptCap: TOOL_EXECUTE_RATE_LIMIT_MAX_ATTEMPTS,
-        reason: 'hard_billing_error',
-      };
-    }
     if (!input.hasRetryAfterHeader) {
       return {
         retryable: true,
@@ -178,6 +179,7 @@ export function classifyToolExecuteHttpFailure(input: {
   bodyText: string;
   retryAfterHeader?: string | null;
   transientHttpRetrySafe?: boolean;
+  providerLatencyMs?: number;
   nowMs?: number;
 }): ToolExecuteHttpFailureOutcome {
   const transientHttpRetrySafe = input.transientHttpRetrySafe === true;
@@ -196,15 +198,33 @@ export function classifyToolExecuteHttpFailure(input: {
     maxAttempts: initialRetryDecision.attemptCap,
     bodyText: input.bodyText,
   });
+  if (
+    typeof input.providerLatencyMs === 'number' &&
+    Number.isFinite(input.providerLatencyMs) &&
+    input.providerLatencyMs >= 0
+  ) {
+    error.message = `${error.message} (provider call ${Math.round(input.providerLatencyMs)}ms)`;
+  }
+  const hardBillingFailure = isHardBillingToolHttpError(error);
   const retryDecision = decideToolExecuteHttpRetry({
     status: input.status,
-    hardBillingFailure: isHardBillingToolHttpError(error),
+    hardBillingFailure,
     hasRetryAfterHeader,
     transientHttpRetrySafe,
   });
   const shouldRetry =
     retryDecision.retryable && input.attempt < retryDecision.attemptCap;
-  if (retryDecision.retryable) error.receiptFailureKind = 'repairable';
+  // In-attempt retry safety and later-run repairability are different
+  // decisions. A non-idempotent 5xx must not be repeated automatically inside
+  // this execution attempt, but an explicit later `plays run` must be able to
+  // repair that failed work while completed calls remain reusable. Otherwise
+  // one provider gateway failure poisons the semantic call forever.
+  if (
+    !hardBillingFailure &&
+    (retryDecision.retryable || (input.status >= 500 && input.status < 600))
+  ) {
+    error.receiptFailureKind = 'repairable';
+  }
   const retryAfterMs = parseToolExecuteRetryAfterMs(
     input.retryAfterHeader,
     input.nowMs,

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

@@ -9,6 +9,7 @@ export type WorkReceiptStateStatus =
 export type WorkReceiptStateInput = {
   status: WorkReceiptStateStatus;
   runId?: string | null;
+  error?: string | null;
   failureKind?: 'terminal' | 'repairable' | null;
   leaseId?: string | null;
   leaseOwnerRunId?: string | null;
@@ -16,6 +17,25 @@ export type WorkReceiptStateInput = {
   leaseExpiresAt?: string | null;
 };
 
+export function isLegacyRepairableWorkReceiptError(
+  error: string | null | undefined,
+): boolean {
+  const message = error?.trim().toLowerCase() ?? '';
+  if (!message) return false;
+  if (
+    message.includes('billing cap') ||
+    message.includes('insufficient credits') ||
+    message.includes('monthly billing limit')
+  ) {
+    return false;
+  }
+  return (
+    /(?:^|\D)5\d\d(?:\D|$)/.test(message) ||
+    message.includes('transport failed calling') ||
+    message.includes('runtime api call timed out')
+  );
+}
+
 export type WorkReceiptLeaseState =
   | { kind: 'none' }
   | {
@@ -254,7 +274,8 @@ export function decideWorkReceiptClaim(input: {
     const claimantRunAttempt = normalizeAttempt(input.claimantRunAttempt);
     const ownerAttempt = normalizeAttempt(input.receipt.leaseOwnerAttempt);
     if (
-      input.receipt.failureKind === 'repairable' &&
+      (input.receipt.failureKind === 'repairable' ||
+        isLegacyRepairableWorkReceiptError(input.receipt.error)) &&
       claimantRunId !== null &&
       ownerRunId !== null &&
       (claimantRunId !== ownerRunId || ownerAttempt < claimantRunAttempt)

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

@@ -31,7 +31,7 @@ import { buildPlayContractCompatibility } from '../contracts';
 import { validatePlaySourceFilesHaveNoInlineSecrets } from '../secret-guardrails';
 import { MAX_ESM_WORKERS_BUNDLE_BYTES, MAX_PLAY_BUNDLE_BYTES } from './limits';
 
-const PLAY_BUNDLE_CACHE_VERSION = 24;
+const PLAY_BUNDLE_CACHE_VERSION = 25;
 const PLAY_ARTIFACT_CACHE_DIR = join(
   tmpdir(),
   `deepline-play-artifacts-v${PLAY_BUNDLE_CACHE_VERSION}`,
@@ -1223,6 +1223,72 @@ function workersPlayEntryAliasPlugin(playFilePath: string): Plugin {
   };
 }
 
+const CUSTOMER_CONSOLE_CAPTURE_GLOBAL = '__deeplineCaptureCustomerConsole';
+
+function sourceLoaderForPath(path: string): 'ts' | 'tsx' | 'js' | 'jsx' {
+  const extension = extname(path).toLowerCase();
+  if (extension === '.tsx') return 'tsx';
+  if (extension === '.jsx') return 'jsx';
+  if (extension === '.js' || extension === '.mjs' || extension === '.cjs') {
+    return 'js';
+  }
+  return 'ts';
+}
+
+/**
+ * Give the customer's entry module a lexical console without replacing the
+ * Worker's process-wide console. Runtime diagnostics therefore keep flowing
+ * to Cloudflare while console.* calls authored in the play join its Run Log
+ * Stream. The lazy global lookup is required because ESM dependencies are
+ * evaluated before the harness installs the request-scoped capture function.
+ */
+function workersCustomerConsolePlugin(
+  customerSourceFilePaths: readonly string[],
+): Plugin {
+  const customerSourceFiles = new Set(
+    customerSourceFilePaths
+      .filter((path) => extname(path).toLowerCase() !== '.json')
+      .map((path) => resolve(path)),
+  );
+  return {
+    name: 'deepline-workers-customer-console',
+    setup(buildContext) {
+      buildContext.onLoad({ filter: /./ }, (args) => {
+        if (!customerSourceFiles.has(resolve(args.path))) return undefined;
+        const source = readFileSync(args.path, 'utf8');
+        const declaresOwnConsole =
+          /(?:^|\n)\s*(?:(?:const|let|var|class|function)\s+console\b|import[^\n]*\bconsole\b)/m.test(
+            source,
+          );
+        if (declaresOwnConsole) {
+          return {
+            contents: source,
+            loader: sourceLoaderForPath(args.path),
+            resolveDir: dirname(args.path),
+          };
+        }
+        const prelude = `
+const console = new Proxy(globalThis.console, {
+  get(target, property) {
+    const capture = globalThis.${CUSTOMER_CONSOLE_CAPTURE_GLOBAL};
+    if (typeof capture === 'function') {
+      return (...args) => capture(String(property), args);
+    }
+    const value = Reflect.get(target, property);
+    return typeof value === 'function' ? value.bind(target) : value;
+  },
+});
+`;
+        return {
+          contents: `${prelude}\n${source}`,
+          loader: sourceLoaderForPath(args.path),
+          resolveDir: dirname(args.path),
+        };
+      });
+    },
+  };
+}
+
 function workersNamedPlayEntryAliasPlugin(
   playFilePath: string,
   exportName: string,
@@ -1989,6 +2055,7 @@ type PlayArtifactTargetAdapter = {
   includeWorkersHarnessInGraphHash: boolean;
   runEsbuild(input: {
     entryFile: string;
+    customerSourceFilePaths: string[];
     importedPlayDependencies: ImportedPlayDependency[];
     adapter: PlayBundlingAdapter;
     exportName: string;
@@ -1997,6 +2064,7 @@ type PlayArtifactTargetAdapter = {
 
 async function runEsbuildForCjsNode(
   entryFile: string,
+  _customerSourceFilePaths: string[],
   importedPlayDependencies: ImportedPlayDependency[],
   adapter: PlayBundlingAdapter,
   exportName: string,
@@ -2048,6 +2116,7 @@ async function runEsbuildForCjsNode(
 
 async function runEsbuildForEsmWorkers(
   playEntryFile: string,
+  customerSourceFilePaths: string[],
   importedPlayDependencies: ImportedPlayDependency[],
   adapter: PlayBundlingAdapter,
   exportName: string,
@@ -2058,6 +2127,9 @@ async function runEsbuildForEsmWorkers(
     exportName === 'default'
       ? workersPlayEntryAliasPlugin(playEntryFile)
       : workersNamedPlayEntryAliasPlugin(playEntryFile, exportName);
+  const customerConsolePlugin = workersCustomerConsolePlugin(
+    customerSourceFilePaths,
+  );
   const result = await build({
     // Entry is the Workers harness; it imports the play via the virtual
     // `deepline-play-entry` alias resolved by workersPlayEntryAliasPlugin.
@@ -2102,6 +2174,7 @@ async function runEsbuildForEsmWorkers(
       sdkAliasPlugin,
       playProxyPlugin,
       playEntryAlias,
+      customerConsolePlugin,
       workersNodeBuiltinStubPlugin(),
       // Strip non-English zod locale data from the bundle. zod's locales
       // are re-exported as a static namespace from `zod/v4/core`, so
@@ -2136,12 +2209,14 @@ const PLAY_ARTIFACT_TARGET_ADAPTERS: Record<
     includeWorkersHarnessInGraphHash: false,
     runEsbuild: ({
       entryFile,
+      customerSourceFilePaths,
       importedPlayDependencies,
       adapter,
       exportName,
     }) =>
       runEsbuildForCjsNode(
         entryFile,
+        customerSourceFilePaths,
         importedPlayDependencies,
         adapter,
         exportName,
@@ -2153,12 +2228,14 @@ const PLAY_ARTIFACT_TARGET_ADAPTERS: Record<
     includeWorkersHarnessInGraphHash: true,
     runEsbuild: ({
       entryFile,
+      customerSourceFilePaths,
       importedPlayDependencies,
       adapter,
       exportName,
     }) =>
       runEsbuildForEsmWorkers(
         entryFile,
+        customerSourceFilePaths,
         importedPlayDependencies,
         adapter,
         exportName,
@@ -2288,6 +2365,7 @@ export async function bundlePlayFile(
 
     const buildOutcome = await targetAdapter.runEsbuild({
       entryFile: absolutePath,
+      customerSourceFilePaths: analysis.importPolicy.localFiles,
       importedPlayDependencies: analysis.importedPlayDependencies,
       adapter,
       exportName,

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

@@ -125,7 +125,7 @@ export interface PlayDataset<T> extends AsyncIterable<T> {
    * Large datasets should flow by handle through Neon-backed storage, not
    * through worker memory as giant arrays.
    */
-  materialize(limit?: number): Promise<T[]>;
+  materialize(options?: number | PlayDatasetMaterializeOptions): Promise<T[]>;
   toJSON(): {
     kind: 'dataset';
     datasetKind: PlayDatasetKind;
@@ -146,9 +146,19 @@ type PlayDatasetResolvers<T> = {
   count: () => Promise<number>;
   peek: (limit: number) => Promise<T[]>;
   materialize: (limit?: number) => Promise<T[]>;
+  materializeFullPersistedDataset?: (limit?: number) => Promise<T[]>;
   iterate: () => AsyncIterable<T>;
 };
 
+export type PlayDatasetMaterializeScope = 'result' | 'full_persisted_dataset';
+
+export type PlayDatasetMaterializeOptions = {
+  /** Rows returned by this operation, or every current row in its persisted dataset. */
+  scope?: PlayDatasetMaterializeScope;
+  /** Maximum number of rows to load into memory. */
+  limit?: number;
+};
+
 type PlayDatasetTransform<T, U = T> =
   | {
       kind: 'map';
@@ -164,7 +174,7 @@ type PlayDatasetTransform<T, U = T> =
       end?: number;
     };
 
-function resolveMaterializeLimitCap(): number {
+export function resolveMaterializeLimitCap(): number {
   const raw = process.env.DEEPLINE_PLAY_DATASET_MATERIALIZE_LIMIT;
   const parsed = raw ? Number(raw) : NaN;
   if (Number.isFinite(parsed) && parsed > 0) {
@@ -301,10 +311,25 @@ class DeferredPlayDataset<T> implements PlayDataset<T> {
     return this.slice(0, limit, options);
   }
 
-  async materialize(limit?: number): Promise<T[]> {
+  async materialize(
+    options?: number | PlayDatasetMaterializeOptions,
+  ): Promise<T[]> {
+    const scope =
+      typeof options === 'object' ? (options.scope ?? 'result') : 'result';
+    const limit = typeof options === 'number' ? options : options?.limit;
     const requestedLimit =
       limit !== undefined ? Math.max(0, Math.floor(limit)) : undefined;
     const cap = resolveMaterializeLimitCap();
+    const materialize =
+      scope === 'full_persisted_dataset'
+        ? this.resolvers.materializeFullPersistedDataset
+        : this.resolvers.materialize;
+    if (!materialize) {
+      throw new Error(
+        'PlayDataset.materialize({ scope: "full_persisted_dataset" }) is only available ' +
+          'for a persisted dataset returned by ctx.dataset(...).run().',
+      );
+    }
     if (requestedLimit !== undefined) {
       if (requestedLimit > cap) {
         throw new Error(
@@ -312,7 +337,18 @@ class DeferredPlayDataset<T> implements PlayDataset<T> {
             'Return the dataset handle instead, or request a smaller bounded slice.',
         );
       }
-      return await this.resolvers.materialize(requestedLimit);
+      return await materialize(requestedLimit);
+    }
+
+    if (scope === 'full_persisted_dataset') {
+      const rows = await materialize(cap + 1);
+      if (rows.length > cap) {
+        throw new Error(
+          'PlayDataset.materialize({ scope: "full_persisted_dataset" }) refuses to load ' +
+            `more than ${cap} rows into memory. Pass an explicit bounded limit.`,
+        );
+      }
+      return rows;
     }
 
     const count = await this.count();
@@ -322,7 +358,7 @@ class DeferredPlayDataset<T> implements PlayDataset<T> {
           `The hard limit is ${cap}. Return the dataset handle instead or call materialize(limit).`,
       );
     }
-    return await this.resolvers.materialize();
+    return await materialize();
   }
 
   async *[Symbol.asyncIterator](): AsyncIterator<T> {