deepline 0.1.74 → 0.1.77

package/dist/index.mjs

@@ -179,10 +179,10 @@ import { join as join2 } from "path";
 
 // src/release.ts
 var SDK_RELEASE = {
-  version: "0.1.74",
-  apiContract: "2026-06-dataset-column-syntax-cutover",
+  version: "0.1.77",
+  apiContract: "2026-06-dataset-column-cell-stale-hard-cutover",
   supportPolicy: {
-    latest: "0.1.74",
+    latest: "0.1.77",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53"
   }
@@ -1065,6 +1065,9 @@ var DeeplineClient = class {
   async checkPlayArtifact(input) {
     return this.http.post("/api/v2/plays/check", input);
   }
+  async compileEnrichPlan(input) {
+    return this.http.post("/api/v2/enrich/compile", input);
+  }
   async startPlayRunFromBundle(input) {
     const compilerManifest = input.compilerManifest ?? await this.compilePlayManifest({
       name: input.name,
@@ -1841,6 +1844,160 @@ function formatPlayBootstrapFinderKindsForSentence() {
   return `${allButLast.join(", ")} or ${last}`;
 }
 
+// ../shared_libs/play-runtime/email-status.ts
+var DEFAULT_STATUS_MAP = {
+  verified: { status: "valid", verdict: "send", verified: true },
+  valid: { status: "valid", verdict: "send", verified: true },
+  deliverable: { status: "valid", verdict: "send", verified: true },
+  true: { status: "valid", verdict: "send", verified: true },
+  invalid: { status: "invalid", verdict: "drop", verified: false },
+  undeliverable: { status: "invalid", verdict: "drop", verified: false },
+  false: { status: "invalid", verdict: "drop", verified: false },
+  "catch-all": {
+    status: "catch_all",
+    verdict: "verify_next",
+    verified: false
+  },
+  catch_all: {
+    status: "catch_all",
+    verdict: "verify_next",
+    verified: false
+  },
+  valid_catch_all: {
+    status: "valid_catch_all",
+    verdict: "send_with_caution",
+    verified: true
+  },
+  accept_all: {
+    status: "catch_all",
+    verdict: "verify_next",
+    verified: false
+  },
+  unknown: { status: "unknown", verdict: "hold", verified: false },
+  unavailable: { status: "unknown", verdict: "hold", verified: false },
+  do_not_mail: { status: "do_not_mail", verdict: "drop", verified: false },
+  spamtrap: { status: "spamtrap", verdict: "drop", verified: false },
+  abuse: { status: "abuse", verdict: "drop", verified: false },
+  disposable: { status: "disposable", verdict: "drop", verified: false }
+};
+function normalizeKey(value) {
+  if (value == null) return null;
+  if (typeof value === "boolean") return String(value);
+  const normalized = String(value).trim().toLowerCase().replace(/\s+/g, "_");
+  return normalized || null;
+}
+function boolish(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return value === 1 ? true : value === 0 ? false : null;
+  if (typeof value !== "string") return null;
+  const normalized = value.trim().toLowerCase();
+  if (["true", "yes", "y", "1"].includes(normalized)) return true;
+  if (["false", "no", "n", "0"].includes(normalized)) return false;
+  return null;
+}
+function numberish(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value !== "string" || value.trim() === "") return null;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function stringish(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function deliverability(value) {
+  const normalized = normalizeKey(value);
+  return normalized === "high" || normalized === "medium" || normalized === "low" ? normalized : "unknown";
+}
+function mxClass(mxProvider, mxRecord) {
+  const haystack = `${stringish(mxProvider) ?? ""} ${stringish(mxRecord) ?? ""}`.toLowerCase();
+  if (!haystack.trim()) return "unknown";
+  if (/proofpoint|pphosted|mimecast|barracuda|ess\.barracudanetworks|ironport|cisco|iphmx|messagelabs|symantec/.test(
+    haystack
+  )) {
+    return "security_gateway";
+  }
+  if (/aspmx\.l\.google|google|g-suite|google workspace/.test(haystack)) {
+    return "workspace_mailbox";
+  }
+  if (/protection\.outlook|office365|microsoft|outlook|exchange online/.test(haystack)) {
+    return "workspace_mailbox";
+  }
+  if (/gmail|yahoo|icloud|aol|hotmail/.test(haystack)) return "consumer_mailbox";
+  if (/postfix|exim|sendmail|zimbra|plesk|cpanel|mail\./.test(haystack)) return "on_prem";
+  return "unknown";
+}
+function entryForStatus(key, map) {
+  if (!key) return null;
+  return map?.[key] ?? DEFAULT_STATUS_MAP[key] ?? null;
+}
+function read(values, name) {
+  return values[name];
+}
+function matchesRule(rule, values) {
+  return Object.entries(rule.when).every(([key, expected]) => {
+    const actual = read(values, key);
+    if (key.endsWith("Lt")) {
+      const source = numberish(read(values, key.slice(0, -2)));
+      return typeof expected === "number" && source != null && source < expected;
+    }
+    if (typeof expected === "boolean") return boolish(actual) === expected;
+    if (typeof expected === "number") return numberish(actual) === expected;
+    return normalizeKey(actual) === normalizeKey(expected);
+  });
+}
+function buildEmailStatus({
+  config,
+  values
+}) {
+  const rawStatus = read(values, "rawStatus");
+  const rawScore = numberish(read(values, "rawScore"));
+  const valid = boolish(read(values, "valid"));
+  const catchAll = boolish(read(values, "catchAll"));
+  const disposable = boolish(read(values, "disposable"));
+  const abuse = boolish(read(values, "abuse"));
+  const spamtrap = boolish(read(values, "spamtrap"));
+  const suspect = boolish(read(values, "suspect"));
+  const rawKey = normalizeKey(rawStatus);
+  const mapped = config.rules?.find((rule) => matchesRule(rule, values)) ?? entryForStatus(rawKey, config.statusMap) ?? entryForStatus(valid == null ? null : String(valid), config.statusMap);
+  const status = mapped?.status ?? (disposable ? "disposable" : abuse ? "abuse" : spamtrap ? "spamtrap" : catchAll ? "catch_all" : valid === true ? "valid" : valid === false ? "invalid" : "unknown");
+  const defaultVerdict = status === "valid" ? "send" : status === "valid_catch_all" ? "send_with_caution" : status === "catch_all" ? "verify_next" : status === "unknown" ? "hold" : "drop";
+  const verdict = mapped?.verdict ?? defaultVerdict;
+  const verified = mapped?.verified ?? (status === "valid" || status === "valid_catch_all" || verdict === "send");
+  const reasons = [
+    mapped?.reason,
+    catchAll ? "catch_all_domain" : null,
+    mxClass(read(values, "mxProvider"), read(values, "mxRecord")) === "security_gateway" ? "security_gateway_mx" : null,
+    suspect ? "provider_marked_suspect" : null
+  ].filter((reason) => typeof reason === "string");
+  return {
+    verdict,
+    status,
+    verified,
+    confidence: rawScore,
+    reasons,
+    signals: {
+      catch_all: catchAll,
+      deliverability: deliverability(read(values, "deliverability")),
+      mx_class: mxClass(read(values, "mxProvider"), read(values, "mxRecord")),
+      mx_provider: stringish(read(values, "mxProvider")),
+      mx_record: stringish(read(values, "mxRecord")),
+      fraud_score: numberish(read(values, "fraudScore")),
+      disposable,
+      role_based: boolish(read(values, "roleBased")),
+      free_email: boolish(read(values, "freeEmail")),
+      abuse,
+      spamtrap,
+      suspect,
+      valid
+    },
+    provider: {
+      name: config.provider,
+      raw_status: typeof rawStatus === "string" || typeof rawStatus === "boolean" || typeof rawStatus === "number" ? rawStatus : null,
+      raw_score: rawScore
+    }
+  };
+}
+
 // ../shared_libs/play-runtime/tool-result.ts
 var TARGET_FALLBACK_KEYS = {
   email: [/^email$/i, /^address$/i, /email/i],
@@ -2024,6 +2181,42 @@ function findFirstTargetByPath(result, paths) {
   }
   return null;
 }
+function firstValueForPaths(result, paths) {
+  return findFirstTargetByPath(result, paths);
+}
+function buildEmailStatusTarget(result, descriptor) {
+  const config = descriptor.emailStatus;
+  if (!config) return null;
+  const values = {};
+  const pathSets = {
+    rawStatus: config.rawStatus,
+    rawScore: config.rawScore,
+    valid: config.valid,
+    deliverability: config.deliverability,
+    catchAll: config.catchAll,
+    mxProvider: config.mxProvider,
+    mxRecord: config.mxRecord,
+    fraudScore: config.fraudScore,
+    disposable: config.disposable,
+    roleBased: config.roleBased,
+    freeEmail: config.freeEmail,
+    abuse: config.abuse,
+    spamtrap: config.spamtrap,
+    suspect: config.suspect
+  };
+  let firstPath = null;
+  for (const [name, paths] of Object.entries(pathSets)) {
+    const match = firstValueForPaths(result, paths);
+    if (!match) continue;
+    values[name] = match.value;
+    firstPath ??= match.path;
+  }
+  if (!firstPath) return null;
+  return {
+    path: firstPath,
+    value: buildEmailStatus({ config, values })
+  };
+}
 function findFirstTargetByKey(result, target, depth = 0, path = []) {
   if (depth > 6) return null;
   if (Array.isArray(result)) {
@@ -2173,6 +2366,11 @@ function deriveListKeys(input) {
 function buildTargets(result, extractors, targetGetters) {
   const targets = {};
   for (const [target, descriptor] of Object.entries(extractors ?? {})) {
+    const emailStatusTarget = buildEmailStatusTarget(result, descriptor);
+    if (emailStatusTarget) {
+      targets[target] = emailStatusTarget;
+      continue;
+    }
     const fromExtractor = findFirstTargetByPath(result, descriptor.paths);
     if (!fromExtractor) continue;
     const transformed = coerceToEnum(

package/dist/repo/apps/play-runner-workers/src/entry.ts

@@ -155,6 +155,10 @@ import {
   StepProgramDatasetBuilder,
   type StepProgramDatasetOptions,
 } from '../../../shared_libs/play-runtime/step-program-dataset-builder';
+import {
+  DEEPLINE_CELL_META_FIELD,
+  shouldRecomputeCell,
+} from '../../../shared_libs/play-runtime/cell-staleness';
 
 // The play's default export. The bundler injects this — see bundle-play-file.ts.
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -2032,6 +2036,7 @@ type WorkerConditionalStepResolver = {
 
 type WorkerStepProgramStep = {
   name: string;
+  staleAfterSeconds?: number;
   resolver:
     | WorkerStepResolver
     | WorkerConditionalStepResolver
@@ -3049,6 +3054,7 @@ async function prepareMapRows(input: {
   tableNamespace: string;
   rows: Record<string, unknown>[];
   outputFields: string[];
+  cellPolicies?: Record<string, { staleAfterSeconds?: number }>;
 }): Promise<{
   inserted: number;
   skipped: number;
@@ -3073,6 +3079,7 @@ async function prepareMapRows(input: {
     rows: input.rows.map((row) => ({ ...row })),
     runId: input.req.runId,
     userEmail: input.req.userEmail,
+    cellPolicies: input.cellPolicies,
   });
   for (const timing of result.timings ?? []) {
     const phase =
@@ -3221,12 +3228,16 @@ function createMinimalWorkerCtx(
       },
     );
     if (!response.ok) {
-      throw new Error(`Secret ${auth.secret.name} is not available to this run.`);
+      throw new Error(
+        `Secret ${auth.secret.name} is not available to this run.`,
+      );
     }
     const payload = (await response.json()) as { value?: unknown };
     const value = typeof payload.value === 'string' ? payload.value : null;
     if (!value) {
-      throw new Error(`Secret ${auth.secret.name} is not available to this run.`);
+      throw new Error(
+        `Secret ${auth.secret.name} is not available to this run.`,
+      );
     }
     secretRedactor.register(value);
     return auth.kind === 'bearer'
@@ -3359,6 +3370,7 @@ function createMinimalWorkerCtx(
           index: number,
         ) => Promise<unknown> | unknown)
     >,
+    cellPolicies?: Record<string, { staleAfterSeconds?: number }>,
     opts?: WorkerMapOptions,
   ): Promise<unknown> => {
     const mapStartedAt = nowMs();
@@ -3498,6 +3510,7 @@ function createMinimalWorkerCtx(
         req,
         tableNamespace: name,
         outputFields,
+        cellPolicies,
         rows: chunkEntries.map(({ row, rowKey }) => ({
           ...row,
           __deeplineRowKey: rowKey,
@@ -3572,10 +3585,11 @@ function createMinimalWorkerCtx(
         | Record<
             string,
             {
-              status: 'cached' | 'skipped';
+              status: 'cached' | 'skipped' | 'completed';
               stage?: string | null;
               reused?: boolean;
               runId?: string;
+              completedAt?: number;
             }
           >
         | undefined
@@ -3604,10 +3618,11 @@ function createMinimalWorkerCtx(
               const cellMetaPatch: Record<
                 string,
                 {
-                  status: 'cached' | 'skipped';
+                  status: 'cached' | 'skipped' | 'completed';
                   stage?: string | null;
                   reused?: boolean;
                   runId?: string;
+                  completedAt?: number;
                 }
               > = {};
               const waterfallOutputs: RecordedWaterfallOutput[] = [];
@@ -3643,7 +3658,28 @@ function createMinimalWorkerCtx(
                   ),
               };
               for (const [key, value] of fieldEntries) {
-                if (isCompletedWorkerFieldValue(enriched[key])) {
+                const rawCellMeta =
+                  enriched[DEEPLINE_CELL_META_FIELD] &&
+                  typeof enriched[DEEPLINE_CELL_META_FIELD] === 'object'
+                    ? (
+                        enriched[DEEPLINE_CELL_META_FIELD] as Record<
+                          string,
+                          unknown
+                        >
+                      )[key]
+                    : null;
+                const reuseDecision = shouldRecomputeCell({
+                  hasValue: isCompletedWorkerFieldValue(enriched[key]),
+                  meta:
+                    rawCellMeta && typeof rawCellMeta === 'object'
+                      ? (rawCellMeta as {
+                          status?: string;
+                          completedAt?: number;
+                        })
+                      : null,
+                  policy: cellPolicies?.[key],
+                });
+                if (reuseDecision.action === 'reuse') {
                   cellMetaPatch[key] = {
                     status: 'cached',
                     stage: key,
@@ -3673,6 +3709,13 @@ function createMinimalWorkerCtx(
                     stage: key,
                     runId: req.runId,
                   };
+                } else {
+                  cellMetaPatch[key] = {
+                    status: 'completed',
+                    stage: key,
+                    runId: req.runId,
+                    completedAt: nowMs(),
+                  };
                 }
               }
               for (const stepOutput of stepProgramOutputs) {
@@ -4037,7 +4080,15 @@ function createMinimalWorkerCtx(
           const fields = Object.fromEntries(
             program.steps.map((step) => [step.name, step.resolver]),
           );
-          return runMap(this.name, this.rows, fields, opts);
+          const cellPolicies = Object.fromEntries(
+            program.steps.map((step) => [
+              step.name,
+              step.staleAfterSeconds === undefined
+                ? {}
+                : { staleAfterSeconds: step.staleAfterSeconds },
+            ]),
+          );
+          return runMap(this.name, this.rows, fields, cellPolicies, opts);
         },
         {
           emptyColumnName:
@@ -4255,7 +4306,15 @@ function createMinimalWorkerCtx(
         const fields = Object.fromEntries(
           fieldsDef.steps.map((step) => [step.name, step.resolver]),
         );
-        return runMap(name, rows, fields, opts);
+        const cellPolicies = Object.fromEntries(
+          fieldsDef.steps.map((step) => [
+            step.name,
+            step.staleAfterSeconds === undefined
+              ? {}
+              : { staleAfterSeconds: step.staleAfterSeconds },
+          ]),
+        );
+        return runMap(name, rows, fields, cellPolicies, opts);
       }
       throw new Error(
         'ctx.dataset(key, rows, fields, options) is not supported. Use ctx.dataset(key, rows).withColumn(...).run(options).',
@@ -4266,11 +4325,11 @@ function createMinimalWorkerCtx(
         'ctx.map(...) has been replaced by ctx.dataset(...). Use ctx.dataset(key, rows).withColumn(...).run(options).',
       );
     },
-	    tools: {
-	      async execute(requestArg: unknown): Promise<unknown> {
+    tools: {
+      async execute(requestArg: unknown): Promise<unknown> {
         assertNotAborted(abortSignal);
         const request = normalizeToolExecuteArgs(requestArg);
-	        assertNoSecretTaint(request.input, 'ctx.tools.execute input');
+        assertNoSecretTaint(request.input, 'ctx.tools.execute input');
         return await executeWithRuntimeReceipt(
           `tool:${request.id}:${deriveToolRequestIdentity({
             toolId: request.toolId,
@@ -4340,9 +4399,9 @@ function createMinimalWorkerCtx(
         timeoutMs?: number;
         staleAfterSeconds?: number;
       },
-	    ): Promise<unknown> {
-	      const normalizedKey = normalizeContextKey(key, 'runPlay');
-	      const resolvedName = resolvePlayRefName(playRef);
+    ): Promise<unknown> {
+      const normalizedKey = normalizeContextKey(key, 'runPlay');
+      const resolvedName = resolvePlayRefName(playRef);
       assertNoSecretTaint(input, 'ctx.runPlay input');
       if (!resolvedName) {
         throw new Error('ctx.runPlay(...) requires a resolvable play name.');
@@ -4582,18 +4641,15 @@ function createMinimalWorkerCtx(
         }
       });
     },
-	    async fetch(
-	      key: string,
-	      input: string | URL,
-	      init: SecretAwareRequestInit = {},
-	      options?: { staleAfterSeconds?: number },
-	    ): Promise<WorkerFetchResponse> {
-	      assertNotAborted(abortSignal);
-	      const normalizedKey = normalizeContextKey(key, 'fetch');
-      if (
-        valueContainsSecret(input) ||
-        valueContainsSecret(init.body)
-      ) {
+    async fetch(
+      key: string,
+      input: string | URL,
+      init: SecretAwareRequestInit = {},
+      options?: { staleAfterSeconds?: number },
+    ): Promise<WorkerFetchResponse> {
+      assertNotAborted(abortSignal);
+      const normalizedKey = normalizeContextKey(key, 'fetch');
+      if (valueContainsSecret(input) || valueContainsSecret(init.body)) {
         throw new Error(
           'ctx.fetch does not allow secrets in the URL or body. Use an approved secret auth helper.',
         );
@@ -4606,10 +4662,10 @@ function createMinimalWorkerCtx(
       if (init.auth !== undefined && !isSecretAuth(init.auth)) {
         throw new Error('ctx.fetch auth must come from ctx.secrets.');
       }
-	      const url = input.toString();
-	      const method = (init.method ?? 'GET').toUpperCase();
+      const url = input.toString();
+      const method = (init.method ?? 'GET').toUpperCase();
       const secretHeaderMarkers = secretAuthHeaderMarkers(init.auth);
-	      const safeHeaders = {
+      const safeHeaders = {
         ...normalizeFetchHeaders(init.headers),
         ...secretHeaderMarkers,
       };
@@ -4628,7 +4684,7 @@ function createMinimalWorkerCtx(
         safeHeaders,
         url,
       })}${staleRuntimeSuffix(options?.staleAfterSeconds)}`;
-	      return await executeWithRuntimeReceipt(receiptKey, async () => {
+      return await executeWithRuntimeReceipt(receiptKey, async () => {
         const secretHeaders = await resolveSecretAuth(init.auth);
         const headers = {
           ...normalizeFetchHeaders(init.headers),
@@ -4636,23 +4692,23 @@ function createMinimalWorkerCtx(
         };
         const fetchInit = { ...init, headers };
         delete fetchInit.auth;
-	        const response = await fetch(url, fetchInit);
-	        assertNotAborted(abortSignal);
-	        const bodyText = await response.text();
+        const response = await fetch(url, fetchInit);
+        assertNotAborted(abortSignal);
+        const bodyText = await response.text();
         const redactedBodyText = secretRedactor.redactString(bodyText);
-	        return {
-	          ok: response.ok,
-	          status: response.status,
-	          statusText: response.statusText,
-	          url: response.url,
-	          headers: secretRedactor.redact(
-              Object.fromEntries(response.headers.entries()),
-            ) as Record<string, string>,
-	          bodyText: redactedBodyText,
-	          json: secretRedactor.redact(parseFetchJsonOrNull(bodyText)),
-	        };
-	      });
-	    },
+        return {
+          ok: response.ok,
+          status: response.status,
+          statusText: response.statusText,
+          url: response.url,
+          headers: secretRedactor.redact(
+            Object.fromEntries(response.headers.entries()),
+          ) as Record<string, string>,
+          bodyText: redactedBodyText,
+          json: secretRedactor.redact(parseFetchJsonOrNull(bodyText)),
+        };
+      });
+    },
     secrets: {
       get(name: string): SecretHandle {
         if (typeof name !== 'string' || !name.trim()) {

package/dist/repo/sdk/src/client.ts

@@ -68,6 +68,7 @@ import type {
 } from './types.js';
 import type { PlayStagedFileRef } from './plays/local-file-discovery.js';
 import type { PlayCompilerManifest } from '../../shared_libs/plays/compiler-manifest.js';
+import type { EnrichCompiledConfig } from './cli/enrich-play-compiler.js';
 
 const TERMINAL_PLAY_STATUSES = new Set(['completed', 'failed', 'cancelled']);
 const INCLUDE_TOOL_METADATA_HEADER = 'x-deepline-include-tool-metadata';
@@ -1019,6 +1020,13 @@ export class DeeplineClient {
     return this.http.post('/api/v2/plays/check', input);
   }
 
+  async compileEnrichPlan(input: {
+    plan_args?: string[];
+    config?: unknown;
+  }): Promise<{ config: EnrichCompiledConfig }> {
+    return this.http.post('/api/v2/enrich/compile', input);
+  }
+
   async startPlayRunFromBundle(input: {
     name: string;
     sourceCode: string;

package/dist/repo/sdk/src/play.ts

@@ -224,6 +224,7 @@ export type ConditionalStepResolver<Row, Value, Else = null> = {
 
 export type StepOptions<Row> = {
   readonly runIf?: (row: Row, index: number) => boolean | Promise<boolean>;
+  readonly staleAfterSeconds?: number;
 };
 
 export type StepProgram<Input, Output, Return = Output> = {
@@ -257,6 +258,7 @@ export type StepProgramResolver<Input, Return> = {
 
 export type PlayStepProgramStep = {
   readonly name: string;
+  readonly staleAfterSeconds?: number;
   readonly resolver:
     | StepResolver<Record<string, unknown>, unknown>
     | ConditionalStepResolver<Record<string, unknown>, unknown>
@@ -318,7 +320,6 @@ export type DatasetBuilder<
    */
   run(options?: {
     description?: string;
-    staleAfterSeconds?: number;
     key?:
       | (keyof InputRow & string)
       | readonly (keyof InputRow & string)[]

package/dist/repo/sdk/src/plays/harness-stub.ts

@@ -191,6 +191,7 @@ export async function harnessStartSheetDataset(input: {
   runId: string;
   inputOffset?: number;
   userEmail?: string | null;
+  cellPolicies?: Record<string, { staleAfterSeconds?: number }>;
 }): Promise<{
   inserted: number;
   skipped: number;

package/dist/repo/sdk/src/release.ts

@@ -50,10 +50,10 @@ export type SdkRelease = {
 };
 
 export const SDK_RELEASE = {
-  version: '0.1.74',
-  apiContract: '2026-06-dataset-column-syntax-cutover',
+  version: '0.1.77',
+  apiContract: '2026-06-dataset-column-cell-stale-hard-cutover',
   supportPolicy: {
-    latest: '0.1.74',
+    latest: '0.1.77',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
   },

package/dist/repo/sdk/src/worker-play-entry.ts

@@ -128,6 +128,9 @@ class WorkerStepProgram<Input, Output, ReturnValue> implements StepProgram<
         {
           name,
           resolver: stepResolver as PlayStepProgramStep['resolver'],
+          ...(options?.staleAfterSeconds !== undefined
+            ? { staleAfterSeconds: options.staleAfterSeconds }
+            : {}),
         },
       ],
       this.returnResolver as StepResolver<