deepline 0.1.83 → 0.1.88

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

@@ -101,7 +101,7 @@ class WorkerStepProgram<Input, Output, ReturnValue> implements StepProgram<
   step<Name extends string, Value>(
     name: Name,
     resolver: StepResolver<Output, Value> | StepProgramResolver<Output, Value>,
-    options: StepOptions<Output>,
+    options: StepOptions<Output, Value>,
   ): StepProgram<Input, Output & Record<Name, Value | null>, ReturnValue>;
   step<Name extends string, Value>(
     name: Name,
@@ -109,7 +109,7 @@ class WorkerStepProgram<Input, Output, ReturnValue> implements StepProgram<
       | StepResolver<Output, Value>
       | ConditionalStepResolver<Output, Value>
       | StepProgramResolver<Output, Value>,
-    options?: StepOptions<Output>,
+    options?: StepOptions<Output, Value>,
   ): StepProgram<Input, Output & Record<Name, Value | null>, ReturnValue> {
     if (!name.trim()) {
       throw new Error('Step name required.');
@@ -129,7 +129,10 @@ class WorkerStepProgram<Input, Output, ReturnValue> implements StepProgram<
           name,
           resolver: stepResolver as PlayStepProgramStep['resolver'],
           ...(options?.staleAfterSeconds !== undefined
-            ? { staleAfterSeconds: options.staleAfterSeconds }
+            ? {
+                staleAfterSeconds:
+                  options.staleAfterSeconds as PlayStepProgramStep['staleAfterSeconds'],
+              }
             : {}),
         },
       ],

package/dist/repo/shared_libs/play-runtime/cell-staleness.ts

@@ -1,17 +1,66 @@
+/**
+ * Resolve the next expiry window from a completed cell value.
+ *
+ * Return a positive whole number of seconds to set the next `staleAt`, or
+ * `null` when this particular value should not expire.
+ */
+export type StaleAfterSecondsResolver<Value = unknown> = (
+  value: Value,
+) => number | null;
+
+/** Authored freshness policy: fixed TTL seconds or a value-based resolver. */
+export type AuthoredStaleAfterSeconds<Value = unknown> =
+  | number
+  | StaleAfterSecondsResolver<Value>;
+
+/** Freshness policy as written by play authors before runtime normalization. */
+export type AuthoredCellStalenessPolicy<Value = unknown> = {
+  staleAfterSeconds?: AuthoredStaleAfterSeconds<Value>;
+};
+
+/** Runtime-normalized freshness policy stored in execution plans. */
 export type CellStalenessPolicy = {
   staleAfterSeconds?: number;
+  dynamicStaleAfterSeconds?: boolean;
 };
 
+/** Stored per-cell freshness and completion metadata. */
 export type CellStalenessMeta = {
   status?: string | null;
   completedAt?: number | null;
+  staleAt?: number | null;
+  staleAfterSeconds?: number | null;
+};
+
+/**
+ * Previous durable cell value passed to object-column resolvers.
+ *
+ * The runtime supplies this when a row+column is being recomputed after a
+ * previous value existed. `value` has the same type that the column returns;
+ * freshness metadata lives beside it.
+ *
+ * @sdkReference runtime 120
+ */
+export type PreviousCell<Value = unknown> = {
+  /** Previous completed value for this row+column. */
+  value: Value;
+  /** Millisecond timestamp when the previous value completed. */
+  completedAt?: number;
+  /** Millisecond timestamp when the previous value becomes stale; `null` means no expiry. */
+  staleAt?: number | null;
+  /** Resolved numeric TTL in seconds for the previous value, when present. */
+  staleAfterSeconds?: number;
 };
 
 export type CellStalenessDecision =
   | { action: 'recompute'; reason: 'missing' | 'failed' | 'stale' }
-  | { action: 'reuse'; reason: 'fresh' | 'no_policy' };
+  | { action: 'reuse'; reason: 'fresh' | 'no_policy' | 'no_expiry' };
 
 export type CellStalenessPolicyByField = Record<string, CellStalenessPolicy>;
+export type AuthoredCellStalenessPolicyByField = Record<
+  string,
+  AuthoredCellStalenessPolicy
+>;
 
 export const DEEPLINE_CELL_META_FIELD = '__deeplineCellMeta';
 
@@ -32,12 +81,83 @@ export function validateStaleAfterSeconds(
 }
 
 export function normalizeCellStalenessPolicy(
-  policy: CellStalenessPolicy | undefined,
+  policy: AuthoredCellStalenessPolicy | undefined,
 ): CellStalenessPolicy {
-  validateStaleAfterSeconds(policy?.staleAfterSeconds);
-  return policy?.staleAfterSeconds === undefined
-    ? {}
-    : { staleAfterSeconds: policy.staleAfterSeconds };
+  const staleAfterSeconds = policy?.staleAfterSeconds;
+  if (staleAfterSeconds === undefined) {
+    return {};
+  }
+  if (typeof staleAfterSeconds === 'function') {
+    return { dynamicStaleAfterSeconds: true };
+  }
+  validateStaleAfterSeconds(staleAfterSeconds);
+  return { staleAfterSeconds };
+}
+
+export function resolveCompletedCellStalenessMeta<Value>(input: {
+  policy?: AuthoredCellStalenessPolicy<Value>;
+  value: Value;
+  completedAt: number;
+}): Pick<CellStalenessMeta, 'staleAfterSeconds' | 'staleAt'> {
+  const staleAfterSeconds = input.policy?.staleAfterSeconds;
+  if (staleAfterSeconds === undefined) {
+    return {};
+  }
+
+  const resolved =
+    typeof staleAfterSeconds === 'function'
+      ? staleAfterSeconds(input.value)
+      : staleAfterSeconds;
+  if (resolved === null) {
+    return { staleAt: null };
+  }
+  if (typeof resolved !== 'number') {
+    throw new Error(
+      'staleAfterSeconds(value) must return a positive whole number of seconds or null.',
+    );
+  }
+  validateStaleAfterSeconds(resolved, 'staleAfterSeconds(value)');
+  return {
+    staleAfterSeconds: resolved,
+    staleAt: input.completedAt + resolved * 1000,
+  };
+}
+
+export function previousCellFromValue<Value>(input: {
+  hasValue: boolean;
+  value: Value;
+  meta?: CellStalenessMeta | null;
+}): PreviousCell<Value> | undefined {
+  if (!input.hasValue) {
+    return undefined;
+  }
+
+  const previous: PreviousCell<Value> = {
+    value: input.value,
+  };
+  if (
+    typeof input.meta?.completedAt === 'number' &&
+    Number.isFinite(input.meta.completedAt)
+  ) {
+    previous.completedAt = input.meta.completedAt;
+  }
+  if (
+    input.meta &&
+    Object.prototype.hasOwnProperty.call(input.meta, 'staleAt')
+  ) {
+    previous.staleAt =
+      typeof input.meta.staleAt === 'number' &&
+      Number.isFinite(input.meta.staleAt)
+        ? input.meta.staleAt
+        : null;
+  }
+  if (
+    typeof input.meta?.staleAfterSeconds === 'number' &&
+    Number.isFinite(input.meta.staleAfterSeconds)
+  ) {
+    previous.staleAfterSeconds = input.meta.staleAfterSeconds;
+  }
+  return previous;
 }
 
 export function shouldRecomputeCell(input: {
@@ -55,6 +175,23 @@ export function shouldRecomputeCell(input: {
     return { action: 'recompute', reason: 'failed' };
   }
 
+  const staleAt =
+    input.meta && Object.prototype.hasOwnProperty.call(input.meta, 'staleAt')
+      ? input.meta.staleAt
+      : undefined;
+  if (staleAt === null) {
+    return { action: 'reuse', reason: 'no_expiry' };
+  }
+  if (typeof staleAt === 'number' && Number.isFinite(staleAt)) {
+    return (input.nowMs ?? Date.now()) > staleAt
+      ? { action: 'recompute', reason: 'stale' }
+      : { action: 'reuse', reason: 'fresh' };
+  }
+
+  if (input.policy?.dynamicStaleAfterSeconds) {
+    return { action: 'recompute', reason: 'stale' };
+  }
+
   const staleAfterSeconds = input.policy?.staleAfterSeconds;
   validateStaleAfterSeconds(staleAfterSeconds);
   if (staleAfterSeconds === undefined) {
@@ -76,6 +213,37 @@ export function shouldRecomputeCell(input: {
     : { action: 'reuse', reason: 'fresh' };
 }
 
+export function resolveReusableCellMetaForCurrentPolicy<Value>(input: {
+  hasValue: boolean;
+  value: Value;
+  meta?: CellStalenessMeta | null;
+  policy?: AuthoredCellStalenessPolicy<Value>;
+}): Pick<CellStalenessMeta, 'staleAfterSeconds' | 'staleAt'> {
+  if (
+    !input.hasValue ||
+    typeof input.policy?.staleAfterSeconds !== 'function'
+  ) {
+    return {};
+  }
+  const status = String(input.meta?.status ?? '').trim();
+  if (status === 'failed') {
+    return {};
+  }
+  const completedAt =
+    typeof input.meta?.completedAt === 'number' &&
+    Number.isFinite(input.meta.completedAt)
+      ? input.meta.completedAt
+      : null;
+  if (completedAt === null) {
+    return {};
+  }
+  return resolveCompletedCellStalenessMeta({
+    policy: input.policy,
+    value: input.value,
+    completedAt,
+  });
+}
+
 export function cellPolicyFields(
   policies: CellStalenessPolicyByField | undefined,
 ): string[] {
@@ -83,6 +251,10 @@ export function cellPolicyFields(
     return [];
   }
   return Object.entries(policies)
-    .filter(([, policy]) => policy.staleAfterSeconds !== undefined)
+    .filter(
+      ([, policy]) =>
+        policy.staleAfterSeconds !== undefined ||
+        policy.dynamicStaleAfterSeconds === true,
+    )
     .map(([field]) => field);
 }

package/dist/repo/shared_libs/play-runtime/coordinator-headers.ts

@@ -24,6 +24,16 @@ export const COORDINATOR_RUN_SCOPE_HEADER = 'x-deepline-run-scope';
 export const COORDINATOR_URL_OVERRIDE_HEADER = 'x-deepline-coordinator-url';
 export const WORKER_CALLBACK_URL_OVERRIDE_HEADER =
   'x-deepline-worker-callback-url';
+/**
+ * CLI→app marker (NOT a coordinator header — it lives here only because both
+ * the SDK HTTP client and the run route already import this module). Set by
+ * automated test harnesses (e.g. `tests/v2-plays`) so their intentionally
+ * failing plays — depth-guard probes, error-path scenarios — do not page the
+ * SDK CLI error channel as if a real customer run had failed. The run route
+ * honors it ONLY in non-prod (see run/route.ts); a forged header from a real
+ * prod customer can never suppress their own failure alerts.
+ */
+export const SYNTHETIC_RUN_HEADER = 'x-deepline-synthetic-run';
 
 let warnedAboutMissingInternalToken = false;
 

package/dist/repo/shared_libs/play-runtime/execution-plan.ts

@@ -1,5 +1,5 @@
 import {
-  getCompiledPipelineSubsteps,
+  flattenStaticPipeline,
   type PlayStaticPipeline,
   type PlayStaticSubstep,
 } from '../plays/static-pipeline';
@@ -189,7 +189,7 @@ function extractPlanMaps(
   pipeline: PlayStaticPipeline | null,
 ): ExecutionPlanMap[] {
   if (!pipeline) return [];
-  const substeps = getCompiledPipelineSubsteps(pipeline);
+  const substeps = flattenStaticPipeline(pipeline);
   const fallbackWaterfalls = substeps.filter(
     (substep): substep is Extract<PlayStaticSubstep, { type: 'waterfall' }> =>
       substep.type === 'waterfall',
@@ -252,7 +252,7 @@ function extractToolDeclarations(
   if (!pipeline) return [];
   const seen = new Set<string>();
   const declarations: ExecutionPlan['toolDeclarations'] = [];
-  for (const substep of getCompiledPipelineSubsteps(pipeline)) {
+  for (const substep of flattenStaticPipeline(pipeline)) {
     if (substep.type === 'tool') {
       const key = `${substep.toolId}:${substep.field}`;
       if (!seen.has(key)) {

package/dist/repo/shared_libs/play-runtime/extractor-targets.ts

@@ -0,0 +1,106 @@
+import type { EmailStatus, EmailStatusValue } from './email-status';
+
+export const JOB_CHANGE_STATUS_VALUES = [
+  'moved',
+  'no_change',
+  'left_company',
+  'unknown',
+  'profile_unavailable',
+  'no_new_company',
+] as const;
+
+export type JobChangeStatus = (typeof JOB_CHANGE_STATUS_VALUES)[number];
+
+export type JobChangeGetterValue = {
+  status: JobChangeStatus;
+  date: string | null;
+  new_company: string | null;
+  new_title: string | null;
+};
+
+export const PHONE_STATUS_VALUES = ['valid', 'invalid', 'unknown'] as const;
+
+export type PhoneStatus = (typeof PHONE_STATUS_VALUES)[number];
+
+export const DEEPLINE_EXTRACTOR_TARGET_DEFINITIONS = {
+  id: { identity: true, valueKind: 'string' },
+  name: { identity: true, valueKind: 'string' },
+  email: { identity: true, valueKind: 'string' },
+  personal_email: { identity: true, valueKind: 'string' },
+  phone: { identity: true, valueKind: 'string' },
+  linkedin: { identity: true, valueKind: 'string' },
+  linkedin_url: { identity: true, valueKind: 'string' },
+  domain: { identity: true, valueKind: 'string' },
+  website: { identity: true, valueKind: 'string' },
+  first_name: { identity: true, valueKind: 'string' },
+  last_name: { identity: true, valueKind: 'string' },
+  full_name: { identity: true, valueKind: 'string' },
+  company: { identity: true, valueKind: 'string' },
+  company_name: { identity: true, valueKind: 'string' },
+  organization_name: { identity: true, valueKind: 'string' },
+  company_domain: { identity: true, valueKind: 'string' },
+  company_website: { identity: true, valueKind: 'string' },
+  company_linkedin_url: { identity: true, valueKind: 'string' },
+  title: { identity: false, valueKind: 'string' },
+  industry: { identity: false, valueKind: 'string' },
+  status: { identity: false, valueKind: 'string' },
+  job_change: { identity: false, valueKind: 'job_change' },
+  job_change_status: {
+    identity: false,
+    valueKind: 'job_change_status',
+    enum: JOB_CHANGE_STATUS_VALUES,
+  },
+  email_status: { identity: false, valueKind: 'email_status' },
+  phone_status: {
+    identity: false,
+    valueKind: 'phone_status',
+    enum: PHONE_STATUS_VALUES,
+  },
+} as const;
+
+export type DeeplineExtractorTarget =
+  keyof typeof DEEPLINE_EXTRACTOR_TARGET_DEFINITIONS;
+
+export const DEEPLINE_EXTRACTOR_TARGETS = Object.keys(
+  DEEPLINE_EXTRACTOR_TARGET_DEFINITIONS,
+) as DeeplineExtractorTarget[];
+
+export type DeeplineEmailStatusGetterValue = EmailStatus | EmailStatusValue;
+
+export type DeeplineGetterValueMap = {
+  id: string;
+  name: string;
+  email: string;
+  personal_email: string;
+  phone: string;
+  linkedin: string;
+  linkedin_url: string;
+  domain: string;
+  website: string;
+  first_name: string;
+  last_name: string;
+  full_name: string;
+  company: string;
+  company_name: string;
+  organization_name: string;
+  company_domain: string;
+  company_website: string;
+  company_linkedin_url: string;
+  title: string;
+  industry: string;
+  status: string;
+  job_change: JobChangeGetterValue;
+  job_change_status: JobChangeStatus;
+  email_status: DeeplineEmailStatusGetterValue;
+  phone_status: PhoneStatus;
+};
+
+export type DeeplineGetterValue<
+  TTarget extends DeeplineExtractorTarget = DeeplineExtractorTarget,
+> = DeeplineGetterValueMap[TTarget];
+
+export function isDeeplineExtractorTarget(
+  value: string,
+): value is DeeplineExtractorTarget {
+  return value in DEEPLINE_EXTRACTOR_TARGET_DEFINITIONS;
+}

package/dist/repo/shared_libs/play-runtime/providers.ts

@@ -12,6 +12,9 @@ import {
 
 export const PLAY_RUNTIME_PROVIDER_IDS = {
   workersEdge: 'workers_edge',
+  postgresFast: 'postgres_fast',
+  postgresFastSandbox: 'postgres_fast_sandbox',
+  postgresFastWorkers: 'postgres_fast_workers',
   local: 'local',
 } as const;
 
@@ -39,6 +42,31 @@ export const PLAY_RUNTIME_PROVIDERS: Record<
     artifactKind: PLAY_ARTIFACT_KINDS.esmWorkers,
     label: 'Cloudflare Dynamic Workflows + Dynamic Workers + DO dedup',
   },
+  postgres_fast: {
+    id: PLAY_RUNTIME_PROVIDER_IDS.postgresFast,
+    scheduler: PLAY_SCHEDULER_BACKENDS.postgres,
+    runner: PLAY_RUNTIME_BACKENDS.daytona,
+    dedup: PLAY_DEDUP_BACKENDS.durableObject,
+    artifactKind: PLAY_ARTIFACT_KINDS.cjsNode20,
+    label: 'Experimental Postgres Scheduler + warm sandbox runner + DO dedup',
+  },
+  postgres_fast_sandbox: {
+    id: PLAY_RUNTIME_PROVIDER_IDS.postgresFastSandbox,
+    scheduler: PLAY_SCHEDULER_BACKENDS.postgres,
+    runner: PLAY_RUNTIME_BACKENDS.daytona,
+    dedup: PLAY_DEDUP_BACKENDS.durableObject,
+    artifactKind: PLAY_ARTIFACT_KINDS.cjsNode20,
+    label: 'Experimental Postgres Scheduler + warm sandbox runner + DO dedup',
+  },
+  postgres_fast_workers: {
+    id: PLAY_RUNTIME_PROVIDER_IDS.postgresFastWorkers,
+    scheduler: PLAY_SCHEDULER_BACKENDS.postgres,
+    runner: PLAY_RUNTIME_BACKENDS.cloudflareWorkers,
+    dedup: PLAY_DEDUP_BACKENDS.durableObject,
+    artifactKind: PLAY_ARTIFACT_KINDS.esmWorkers,
+    label:
+      'Experimental Postgres Scheduler + Queue/DO-woken Workers + DO dedup',
+  },
   local: {
     id: PLAY_RUNTIME_PROVIDER_IDS.local,
     scheduler: PLAY_SCHEDULER_BACKENDS.temporal,

package/dist/repo/shared_libs/play-runtime/scheduler-backend.ts

@@ -22,6 +22,7 @@ import type { PreloadedRuntimeDbSession } from './db-session';
 export const PLAY_SCHEDULER_BACKENDS = {
   temporal: 'temporal',
   cfWorkflows: 'cf-workflows',
+  postgres: 'postgres',
   inProcess: 'in-process',
 } as const;
 
@@ -65,6 +66,7 @@ export type PlaySchedulerSubmitInput = {
   runId: string;
   playId: string;
   playName: string;
+  workflowFamilyKey?: string | null;
   artifactStorageKey: string;
   /**
    * Optional inline artifact for schedulers that run the legacy Temporal
@@ -119,6 +121,8 @@ export type PlaySchedulerSubmitInput = {
   orgId: string;
   userEmail: string;
   userId?: string | null;
+  source?: 'published' | 'ad_hoc' | 'draft';
+  executionProfile?: string | null;
   /** runner backend to use for executing attempts */
   runtimeBackend: string;
   /** dedup backend for cross-attempt cross-process idempotency */
@@ -132,7 +136,16 @@ export type PlaySchedulerSubmitInput = {
 };
 
 export type PlaySchedulerProgressEvent =
-  | { type: 'status'; status: string; logs?: string[]; ts: number }
+  | {
+      type: 'status';
+      status: string;
+      logs?: string[];
+      ts: number;
+      activeNodeId?: string | null;
+      activeArtifactTableNamespace?: string | null;
+      updatedAt?: number | null;
+      liveNodeProgress?: unknown;
+    }
   | { type: 'log'; line: string; ts: number }
   | { type: 'row'; update: PlayRowUpdate; ts: number }
   | { type: 'execution_event'; event: PlayExecutionEvent; ts: number }
@@ -200,6 +213,13 @@ export function normalizePlaySchedulerBackend(
   if (normalized === 'cf-workflows' || normalized === 'cf_workflows') {
     return PLAY_SCHEDULER_BACKENDS.cfWorkflows;
   }
+  if (
+    normalized === 'postgres' ||
+    normalized === 'postgres-scheduler' ||
+    normalized === 'postgres_scheduler'
+  ) {
+    return PLAY_SCHEDULER_BACKENDS.postgres;
+  }
   if (normalized === 'in-process' || normalized === 'in_process') {
     return PLAY_SCHEDULER_BACKENDS.inProcess;
   }

package/dist/repo/shared_libs/play-runtime/step-program-dataset-builder.ts

@@ -1,15 +1,55 @@
+import type { AuthoredStaleAfterSeconds, PreviousCell } from './cell-staleness';
+
 export type StepProgramDatasetOptions = {
   runIf?: (
     row: Record<string, unknown>,
     index: number,
   ) => boolean | Promise<boolean>;
-  staleAfterSeconds?: number;
+  staleAfterSeconds?: AuthoredStaleAfterSeconds;
+};
+
+export type StepProgramDatasetColumnRunInput<Value = unknown> = {
+  row: Record<string, unknown>;
+  ctx: unknown;
+  index: number;
+  previousCell?: PreviousCell<Value>;
 };
 
+export type StepProgramDatasetColumnDefinition<Value = unknown> =
+  StepProgramDatasetOptions & {
+    run: (
+      input: StepProgramDatasetColumnRunInput<Value>,
+    ) => Value | Promise<Value>;
+  };
+
+export type StepProgramDatasetColumnInput<TResolver> =
+  | TResolver
+  | StepProgramDatasetColumnDefinition;
+
+function isStepProgramDatasetColumnDefinition(
+  value: unknown,
+): value is StepProgramDatasetColumnDefinition {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    typeof (value as { run?: unknown }).run === 'function'
+  );
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function isPreviousCell(value: unknown): value is PreviousCell {
+  return (
+    isRecord(value) && Object.prototype.hasOwnProperty.call(value, 'value')
+  );
+}
+
 export type StepProgramDatasetStep<TResolver> = {
   name: string;
   resolver: TResolver;
-  staleAfterSeconds?: number;
+  staleAfterSeconds?: AuthoredStaleAfterSeconds;
 };
 
 export type StepProgramDatasetProgram<TStep> = {
@@ -75,19 +115,23 @@ export class StepProgramDatasetBuilder<
 
   withColumn(
     name: string,
-    resolver: TResolver,
+    columnInput: StepProgramDatasetColumnInput<TResolver>,
     options?: StepProgramDatasetOptions,
   ): this {
     if (!name.trim()) {
       throw new Error(this.messages.emptyColumnName);
     }
+    const normalized = this.normalizeColumnInput(columnInput, options);
     this.program.steps = [
       ...this.program.steps,
       {
         name,
-        resolver: this.applyDerivationOptions(resolver, options),
-        ...(options?.staleAfterSeconds !== undefined
-          ? { staleAfterSeconds: options.staleAfterSeconds }
+        resolver: this.applyDerivationOptions(
+          normalized.resolver,
+          normalized.options,
+        ),
+        ...(normalized.options?.staleAfterSeconds !== undefined
+          ? { staleAfterSeconds: normalized.options.staleAfterSeconds }
           : {}),
       } as TStep,
     ];
@@ -127,4 +171,50 @@ export class StepProgramDatasetBuilder<
       elseValue: null,
     } as TResolver;
   }
+
+  private normalizeColumnInput(
+    columnInput: StepProgramDatasetColumnInput<TResolver>,
+    options?: StepProgramDatasetOptions,
+  ): { resolver: TResolver; options?: StepProgramDatasetOptions } {
+    if (!isStepProgramDatasetColumnDefinition(columnInput)) {
+      return { resolver: columnInput, options };
+    }
+
+    const { run, ...definitionOptions } = columnInput;
+    const resolver = ((
+      row: Record<string, unknown>,
+      ctx: unknown,
+      third?: unknown,
+      fourth?: unknown,
+      fifth?: unknown,
+    ) => {
+      const index =
+        typeof third === 'number'
+          ? third
+          : typeof fourth === 'number'
+            ? fourth
+            : 0;
+      const rowForRun =
+        isRecord(third) && typeof fourth === 'number' ? third : row;
+      const previousCell = isPreviousCell(fifth)
+        ? fifth
+        : isPreviousCell(fourth)
+          ? fourth
+          : undefined;
+      return run({
+        row: rowForRun,
+        ctx,
+        index,
+        ...(previousCell ? { previousCell } : {}),
+      });
+    }) as TResolver;
+
+    return {
+      resolver,
+      options: {
+        ...definitionOptions,
+        ...(options ?? {}),
+      },
+    };
+  }
 }