deepline 0.1.0 → 0.1.1

package/dist/repo/shared_libs/plays/row-identity.ts

@@ -0,0 +1,302 @@
+export const POSTGRES_IDENTIFIER_MAX_LENGTH = 63;
+export const PLAY_NAME_MAX_LENGTH = POSTGRES_IDENTIFIER_MAX_LENGTH;
+export const MAP_KEY_NAMESPACE_MAX_LENGTH = POSTGRES_IDENTIFIER_MAX_LENGTH;
+export const DEFAULT_TABLE_NAMESPACE = 'sheet';
+export const DEFAULT_INTERNAL_TABLE_NAMESPACE = '_key';
+
+const SHA256_INITIAL_HASH: number[] = [
+  0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c,
+  0x1f83d9ab, 0x5be0cd19,
+];
+
+const SHA256_ROUND_CONSTANTS: number[] = [
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
+  0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+  0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
+  0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
+  0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+  0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
+  0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
+  0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+  0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+];
+
+function stableValue(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map((entry) => stableValue(entry));
+  }
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(
+      Object.entries(value as Record<string, unknown>)
+        .filter(([, entry]) => entry !== undefined)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, entry]) => [key, stableValue(entry)]),
+    );
+  }
+  return value;
+}
+
+function stableStringify(value: unknown): string {
+  return JSON.stringify(stableValue(value));
+}
+
+function rightRotate32(value: number, bits: number): number {
+  return (value >>> bits) | (value << (32 - bits));
+}
+
+function sha256Hex(input: string): string {
+  const bytes = Array.from(new TextEncoder().encode(input));
+  const bitLength = bytes.length * 8;
+  bytes.push(0x80);
+  while (bytes.length % 64 !== 56) {
+    bytes.push(0);
+  }
+
+  const highBits = Math.floor(bitLength / 0x100000000);
+  const lowBits = bitLength >>> 0;
+  bytes.push(
+    (highBits >>> 24) & 0xff,
+    (highBits >>> 16) & 0xff,
+    (highBits >>> 8) & 0xff,
+    highBits & 0xff,
+    (lowBits >>> 24) & 0xff,
+    (lowBits >>> 16) & 0xff,
+    (lowBits >>> 8) & 0xff,
+    lowBits & 0xff,
+  );
+
+  const hash = [...SHA256_INITIAL_HASH];
+  const words = new Array<number>(64).fill(0);
+
+  for (let offset = 0; offset < bytes.length; offset += 64) {
+    for (let index = 0; index < 16; index += 1) {
+      const wordOffset = offset + index * 4;
+      words[index] =
+        ((bytes[wordOffset] ?? 0) << 24) |
+        ((bytes[wordOffset + 1] ?? 0) << 16) |
+        ((bytes[wordOffset + 2] ?? 0) << 8) |
+        (bytes[wordOffset + 3] ?? 0);
+    }
+
+    for (let index = 16; index < 64; index += 1) {
+      const s0 =
+        rightRotate32(words[index - 15], 7) ^
+        rightRotate32(words[index - 15], 18) ^
+        (words[index - 15] >>> 3);
+      const s1 =
+        rightRotate32(words[index - 2], 17) ^
+        rightRotate32(words[index - 2], 19) ^
+        (words[index - 2] >>> 10);
+      words[index] = (words[index - 16] + s0 + words[index - 7] + s1) >>> 0;
+    }
+
+    let [a, b, c, d, e, f, g, h] = hash;
+    for (let index = 0; index < 64; index += 1) {
+      const s1 =
+        rightRotate32(e, 6) ^ rightRotate32(e, 11) ^ rightRotate32(e, 25);
+      const ch = (e & f) ^ (~e & g);
+      const temp1 =
+        (h + s1 + ch + SHA256_ROUND_CONSTANTS[index] + words[index]) >>> 0;
+      const s0 =
+        rightRotate32(a, 2) ^ rightRotate32(a, 13) ^ rightRotate32(a, 22);
+      const maj = (a & b) ^ (a & c) ^ (b & c);
+      const temp2 = (s0 + maj) >>> 0;
+
+      h = g;
+      g = f;
+      f = e;
+      e = (d + temp1) >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = (temp1 + temp2) >>> 0;
+    }
+
+    hash[0] = (hash[0] + a) >>> 0;
+    hash[1] = (hash[1] + b) >>> 0;
+    hash[2] = (hash[2] + c) >>> 0;
+    hash[3] = (hash[3] + d) >>> 0;
+    hash[4] = (hash[4] + e) >>> 0;
+    hash[5] = (hash[5] + f) >>> 0;
+    hash[6] = (hash[6] + g) >>> 0;
+    hash[7] = (hash[7] + h) >>> 0;
+  }
+
+  return hash.map((word) => word.toString(16).padStart(8, '0')).join('');
+}
+
+function sanitizeIdentifierPart(value: string): string {
+  return value
+    .trim()
+    .replace(/[^a-z0-9]+/gi, '_')
+    .replace(/_+/g, '_')
+    .replace(/^_+|_+$/g, '')
+    .toLowerCase();
+}
+
+function validateIdentifierPart(
+  rawValue: string,
+  label: string,
+  maxLength: number,
+): string {
+  const sanitized = sanitizeIdentifierPart(rawValue);
+  if (!sanitized) {
+    throw new Error(
+      `${label} must contain at least one letter or number after normalization. ` +
+        `Use only letters, numbers, underscores, or hyphens.`,
+    );
+  }
+
+  if (sanitized.length > maxLength) {
+    throw new Error(
+      `${label} is too long after normalization (${sanitized.length}/${maxLength}). ` +
+        `Shorten it to ${maxLength} characters or fewer. ` +
+        `Normalized value: "${sanitized}".`,
+    );
+  }
+
+  return sanitized;
+}
+
+export function normalizePlayName(value: string): string {
+  if (value.includes('/')) {
+    throw new Error(
+      'Play name cannot contain "/". Slash is reserved for qualified play references like "prebuilt/example" or "self/example".',
+    );
+  }
+  return validateIdentifierPart(value, 'Play name', PLAY_NAME_MAX_LENGTH);
+}
+
+export function normalizePlayNameForSheet(value: string): string {
+  if (!value.includes('/')) {
+    return normalizePlayName(value);
+  }
+  const digest = sha256Hex(value).slice(0, 12);
+  const normalizedReference = sanitizeIdentifierPart(
+    value.replace(/\//g, '__'),
+  );
+  const prefixLength = Math.max(1, PLAY_NAME_MAX_LENGTH - digest.length - 1);
+  const prefix =
+    normalizedReference.slice(0, prefixLength).replace(/_+$/g, '') ||
+    'qualified_play';
+  return `${prefix}_${digest}`;
+}
+
+export function normalizeTableNamespace(value: string): string {
+  return validateIdentifierPart(
+    value,
+    'ctx.map() key',
+    MAP_KEY_NAMESPACE_MAX_LENGTH,
+  );
+}
+
+export function resolveStaleMapTableNamespace(
+  mapKey: string,
+  staleAfterSeconds?: number | null,
+  nowMs: number = Date.now(),
+): string {
+  const normalizedMapKey = normalizeTableNamespace(mapKey);
+  if (staleAfterSeconds === undefined || staleAfterSeconds === null) {
+    return normalizedMapKey;
+  }
+
+  if (
+    !Number.isFinite(staleAfterSeconds) ||
+    !Number.isInteger(staleAfterSeconds) ||
+    staleAfterSeconds <= 0
+  ) {
+    throw new Error(
+      'ctx.map() staleAfterSeconds must be a positive whole number of seconds.',
+    );
+  }
+
+  const bucket = Math.floor(nowMs / (staleAfterSeconds * 1000));
+  const stalePartitionKey = `stale_${staleAfterSeconds}_${bucket}`;
+  const candidate = `${normalizedMapKey}_${stalePartitionKey}`;
+  if (candidate.length <= MAP_KEY_NAMESPACE_MAX_LENGTH) {
+    return candidate;
+  }
+
+  const digest = sha256Hex(`${normalizedMapKey}\n${stalePartitionKey}`).slice(
+    0,
+    12,
+  );
+  const prefixLength = Math.max(
+    1,
+    MAP_KEY_NAMESPACE_MAX_LENGTH - digest.length - 1,
+  );
+  const prefix =
+    normalizedMapKey.slice(0, prefixLength).replace(/_+$/g, '') || 'map';
+  return `${prefix}_${digest}`;
+}
+
+export function maxArtifactTableNamespaceLength(
+  playName?: string | null,
+): number {
+  if (!playName?.trim()) {
+    return POSTGRES_IDENTIFIER_MAX_LENGTH;
+  }
+
+  const normalizedPlayName = normalizePlayNameForSheet(playName);
+  return Math.max(
+    1,
+    POSTGRES_IDENTIFIER_MAX_LENGTH - normalizedPlayName.length - 1,
+  );
+}
+
+export function validatePlaySheetTableName(
+  playName: string,
+  tableNamespace: string,
+): string {
+  const playSegment = normalizePlayNameForSheet(playName);
+  const keySegment = normalizeTableNamespace(tableNamespace);
+  const resolved = `${playSegment}_${keySegment}`;
+  if (resolved.length > POSTGRES_IDENTIFIER_MAX_LENGTH) {
+    throw new Error(
+      `Play sheet table name is too long after normalization (${resolved.length}/63). ` +
+        `Shorten the play name or ctx.map() key. ` +
+        `Resolved table name: "${resolved}".`,
+    );
+  }
+  return resolved;
+}
+
+export function resolvePlayRunTableNamespace(
+  tableNamespace: string,
+  _input?: Record<string, unknown> | null,
+  _options?: {
+    playName?: string | null;
+  },
+): string {
+  return normalizeTableNamespace(tableNamespace);
+}
+
+export function derivePlayRowIdentity(
+  row: Record<string, unknown>,
+  tableNamespace: string,
+): string {
+  const normalizedNamespace = normalizeTableNamespace(tableNamespace);
+  const canonicalRow = stableStringify(row);
+  const digest = sha256Hex(`${normalizedNamespace}\n${canonicalRow}`);
+  return `${normalizedNamespace}:${digest}`;
+}
+
+/**
+ * Build a stable row identity from an explicit user-provided key string.
+ *
+ * Use when the caller wants to pin row identity to a primary column
+ * (e.g. row.email) instead of hashing the full row contents — so harmless
+ * mutations to other columns don't invalidate the cache.
+ */
+export function derivePlayRowIdentityFromKey(
+  key: string,
+  tableNamespace: string,
+): string {
+  const normalizedNamespace = normalizeTableNamespace(tableNamespace);
+  const digest = sha256Hex(`${normalizedNamespace}\nkey:${key}`);
+  return `${normalizedNamespace}:${digest}`;
+}
+
+export const normalizeMapKeyNamespace = normalizeTableNamespace;

package/dist/repo/shared_libs/plays/runtime-validation.ts

@@ -0,0 +1,415 @@
+import * as acorn from 'acorn';
+import { fullAncestor as walkFullAncestor } from 'acorn-walk';
+import type { PlayBundleArtifact } from './artifact-types';
+import type { PlayStructuredDefinition } from './definition';
+import { validatePlayStructuredDefinition } from './definition';
+import {
+  MAP_KEY_NAMESPACE_MAX_LENGTH,
+  normalizeTableNamespace,
+} from './row-identity';
+import { DISALLOWED_RUN_JAVASCRIPT_TOOL_MESSAGE } from '../play-runtime/runtime-constraints';
+
+export async function validatePlay(
+  code: string | null | undefined,
+  definition?: PlayStructuredDefinition | null,
+  codeFormat: 'function' | 'cjs_module' | 'esm_module' = 'function',
+  validationSource?: string | null,
+  artifact?: PlayBundleArtifact | null,
+): Promise<{ valid: boolean; errors: string[] }> {
+  const errors: string[] = [];
+
+  if (definition) {
+    return validatePlayStructuredDefinition(definition);
+  }
+
+  const sourceForValidation = validationSource ?? code ?? '';
+
+  if (!sourceForValidation.trim()) {
+    return { valid: false, errors: ['Play code is required.'] };
+  }
+
+  try {
+    if (codeFormat === 'cjs_module' && code?.trim()) {
+      new Function('module', 'exports', 'require', code);
+    } else if (codeFormat === 'esm_module' && code?.trim()) {
+      // esm_module bundles target Cloudflare Workers; their top-level uses
+      // import/export which `new Function` rejects. Skip the in-host parse
+      // check — the bundler already typechecked + esbuild parsed the source.
+      // The play Worker runtime catches any actual runtime errors.
+    } else if (codeFormat !== 'cjs_module') {
+      new Function('ctx', 'input', `return (${code})(ctx, input)`);
+    }
+  } catch (e) {
+    errors.push(`Parse error: ${e instanceof Error ? e.message : String(e)}`);
+  }
+
+  errors.push(...validatePlayMapStructure(sourceForValidation));
+  errors.push(...validateRuntimeSyntax(sourceForValidation));
+
+  if (
+    artifact &&
+    artifact.codeFormat !== 'cjs_module' &&
+    artifact.codeFormat !== 'esm_module'
+  ) {
+    errors.push(
+      'Play artifact codeFormat must be "cjs_module" or "esm_module".',
+    );
+  }
+
+  return { valid: errors.length === 0, errors };
+}
+
+function validatePlayMapStructure(code: string): string[] {
+  const errors: string[] = [];
+  const calledPlayNames = new Set<string>();
+  let ast: acorn.Node;
+
+  try {
+    ast = parsePlayAst(code);
+  } catch {
+    return errors;
+  }
+
+  walkFullAncestor(ast, (node, _state, ancestors) => {
+    if (
+      node.type === 'CallExpression' &&
+      usesDisallowedRunJavascriptTool(node as acorn.CallExpression) &&
+      hasMapResolverAncestor(ancestors)
+    ) {
+      errors.push(DISALLOWED_RUN_JAVASCRIPT_TOOL_MESSAGE);
+    }
+
+    if (!isCtxMapCall(node)) {
+      const callExpression =
+        (node as acorn.Node).type === 'CallExpression'
+          ? (node as unknown as acorn.CallExpression)
+          : null;
+      if (
+        callExpression &&
+        callExpression.callee.type === 'MemberExpression' &&
+        callExpression.callee.property.type === 'Identifier' &&
+        callExpression.callee.property.name === 'runPlay'
+      ) {
+        const firstArgument = callExpression.arguments[0];
+        if (
+          firstArgument?.type === 'Literal' &&
+          typeof firstArgument.value === 'string'
+        ) {
+          calledPlayNames.add(firstArgument.value);
+        }
+      }
+      if (
+        callExpression &&
+        callExpression.callee.type === 'MemberExpression' &&
+        callExpression.callee.property.type === 'Identifier' &&
+        callExpression.callee.property.name === 'waterfall'
+      ) {
+        const firstArgument = callExpression.arguments[0];
+        if (firstArgument?.type === 'ObjectExpression') {
+          const minResultsProperty = firstArgument.properties.find(
+            (prop) =>
+              prop.type === 'Property' &&
+              prop.key.type === 'Identifier' &&
+              prop.key.name === 'minResults',
+          );
+          if (!minResultsProperty) {
+            errors.push(
+              'Inline ctx.waterfall({...}) calls must declare minResults.',
+            );
+          }
+        }
+      }
+      return;
+    }
+
+    if (hasMapResolverAncestor(ancestors)) {
+      errors.push(
+        'Nested ctx.map() is not supported. Flatten work into a single map definition.',
+      );
+      return;
+    }
+
+    extractValidatedMapTableNamespace(node, errors);
+  });
+
+  const playNameMatch = code.match(
+    /define(?:Play|Workflow)\s*\(\s*['"`]([^'"`]+)['"`]/,
+  );
+  const definedPlayName = playNameMatch?.[1]?.trim();
+  if (definedPlayName && calledPlayNames.has(definedPlayName)) {
+    errors.push(
+      `Recursive play graph detected: ${definedPlayName} -> ${definedPlayName}. Use a different child play or refactor the shared logic.`,
+    );
+  }
+
+  return [...new Set(errors)];
+}
+
+function validateRuntimeSyntax(code: string): string[] {
+  const errors: string[] = [];
+  let ast: acorn.Node;
+
+  try {
+    ast = parsePlayAst(code);
+  } catch {
+    return errors;
+  }
+
+  walkFullAncestor(ast, (node) => {
+    if (node.type === 'ImportExpression') {
+      errors.push(
+        'Dynamic import() is not allowed in plays. Use static imports instead.',
+      );
+      return;
+    }
+
+    if (node.type !== 'CallExpression') {
+      return;
+    }
+
+    const callNode = node as acorn.CallExpression;
+    if (
+      callNode.callee.type !== 'Identifier' ||
+      callNode.callee.name !== 'require'
+    ) {
+      return;
+    }
+
+    const firstArgument = callNode.arguments[0];
+    const isLiteralString =
+      firstArgument?.type === 'Literal' &&
+      typeof firstArgument.value === 'string';
+
+    if (!isLiteralString) {
+      errors.push(
+        'Dynamic require() is not allowed in plays. Use require("literal") only.',
+      );
+    }
+  });
+
+  return [...new Set(errors)];
+}
+
+function parsePlayAst(code: string): acorn.Node {
+  try {
+    return acorn.parse(code, {
+      ecmaVersion: 'latest',
+      sourceType: 'module',
+      allowAwaitOutsideFunction: true,
+    }) as acorn.Node;
+  } catch {
+    return acorn.parse(`const __play = ${code};`, {
+      ecmaVersion: 'latest',
+      sourceType: 'module',
+    }) as acorn.Node;
+  }
+}
+
+function usesDisallowedRunJavascriptTool(node: acorn.CallExpression): boolean {
+  const callee = node.callee;
+  if (callee.type !== 'MemberExpression') {
+    return false;
+  }
+
+  if (
+    callee.property.type !== 'Identifier' ||
+    callee.property.name !== 'tool'
+  ) {
+    return false;
+  }
+
+  const firstArgument = node.arguments[0];
+  return (
+    firstArgument?.type === 'Literal' &&
+    firstArgument.value === 'run_javascript'
+  );
+}
+
+function extractValidatedMapTableNamespace(
+  node: acorn.CallExpression,
+  errors: string[],
+): string | null {
+  const keyArgument = node.arguments[0];
+  const rowsArgument = node.arguments[1];
+  if (!keyArgument) {
+    errors.push(
+      'ctx.map() requires a string literal map key as the first argument, e.g. ctx.map("leads", rows, { key: "lead_id" }).step("company", row => row.domain).run(...).',
+    );
+    return null;
+  }
+
+  if (!rowsArgument) {
+    errors.push(
+      'ctx.map() requires rows as the second argument, e.g. ctx.map("leads", rows, { key: "lead_id" }).step("company", row => row.domain).run(...).',
+    );
+    return null;
+  }
+
+  if (keyArgument.type !== 'Literal' || typeof keyArgument.value !== 'string') {
+    errors.push(
+      'ctx.map() requires a string literal key as the first argument so Deepline can precompute idempotency.',
+    );
+    return null;
+  }
+
+  if (!keyArgument.value.trim()) {
+    errors.push(
+      'ctx.map() requires a non-empty string key as the first argument.',
+    );
+    return null;
+  }
+
+  try {
+    normalizeTableNamespace(keyArgument.value);
+  } catch (error) {
+    errors.push(
+      error instanceof Error
+        ? `${error.message} Example: ctx.map("leads", rows, { key: "lead_id" }).step("company", row => row.domain).run({ description: "..." }).`
+        : `ctx.map() key must normalize to <= ${MAP_KEY_NAMESPACE_MAX_LENGTH} characters.`,
+    );
+    return null;
+  }
+
+  if (rowsArgument.type === 'ObjectExpression') {
+    errors.push(
+      'ctx.map() key must not be an object. Use ctx.map("leads", rows, { key: "lead_id" }).step(...).run(...).',
+    );
+    return null;
+  }
+  if (
+    rowsArgument.type === 'FunctionExpression' ||
+    isFunctionNode(rowsArgument)
+  ) {
+    errors.push('ctx.map() requires rows as the second argument.');
+    return null;
+  }
+
+  const optionsArgument = node.arguments[2];
+  if (optionsArgument && !isMapDefinitionOptionsNode(optionsArgument)) {
+    errors.push('ctx.map() accepts key, rows, and map options only.');
+    return null;
+  }
+
+  return keyArgument.value.trim();
+}
+
+function isMapDefinitionOptionsNode(node: acorn.Node): boolean {
+  if (node.type !== 'ObjectExpression') return false;
+  const properties = (
+    node as acorn.Node & {
+      properties: acorn.Node[];
+    }
+  ).properties;
+  return properties.every((property) => {
+    if (property.type !== 'Property') return false;
+    const key = (property as acorn.Node & { key: acorn.Node }).key as
+      | (acorn.Node & { type: 'Identifier'; name: string })
+      | (acorn.Node & { type: 'Literal'; value: unknown });
+    const name =
+      key.type === 'Identifier'
+        ? key.name
+        : key.type === 'Literal' && typeof key.value === 'string'
+          ? key.value
+          : null;
+    return name === 'key' || name === 'staleAfterSeconds';
+  });
+}
+
+function isCtxMapCall(node: acorn.Node): node is acorn.CallExpression {
+  if (node.type !== 'CallExpression') {
+    return false;
+  }
+  const callee = (node as acorn.CallExpression).callee;
+  if (callee.type !== 'MemberExpression') {
+    return false;
+  }
+  if (callee.property.type !== 'Identifier' || callee.property.name !== 'map') {
+    return false;
+  }
+  if (callee.object.type !== 'Identifier') {
+    return false;
+  }
+  return callee.object.name === 'ctx' || callee.object.name.endsWith('Ctx');
+}
+
+function isFunctionNode(
+  node: acorn.Node | null | undefined,
+): node is
+  | acorn.FunctionDeclaration
+  | acorn.FunctionExpression
+  | acorn.ArrowFunctionExpression {
+  return Boolean(
+    node &&
+    (node.type === 'FunctionDeclaration' ||
+      node.type === 'FunctionExpression' ||
+      node.type === 'ArrowFunctionExpression'),
+  );
+}
+
+function hasMapResolverAncestor(ancestors: acorn.Node[]): boolean {
+  for (let index = 0; index < ancestors.length; index += 1) {
+    const node = ancestors[index];
+    if (!isFunctionNode(node)) {
+      continue;
+    }
+
+    const parent = index >= 1 ? ancestors[index - 1] : null;
+    const grandparent = index >= 2 ? ancestors[index - 2] : null;
+    const greatGrandparent = index >= 3 ? ancestors[index - 3] : null;
+
+    if (
+      parent?.type === 'CallExpression' &&
+      isCtxMapCall(parent) &&
+      parent.arguments[2] === node
+    ) {
+      return true;
+    }
+
+    if (
+      parent?.type === 'CallExpression' &&
+      isMapBuilderStepCall(parent) &&
+      parent.arguments[1] === node
+    ) {
+      return true;
+    }
+
+    if (
+      parent?.type === 'Property' &&
+      (parent as acorn.Property).value === node &&
+      grandparent?.type === 'ObjectExpression' &&
+      greatGrandparent?.type === 'CallExpression' &&
+      isCtxMapCall(greatGrandparent) &&
+      greatGrandparent.arguments[2] === grandparent
+    ) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function isMapBuilderStepCall(node: acorn.Node): node is acorn.CallExpression {
+  if (node.type !== 'CallExpression') return false;
+  const callee = (node as acorn.CallExpression).callee;
+  if (callee.type !== 'MemberExpression') return false;
+  if (
+    callee.property.type !== 'Identifier' ||
+    callee.property.name !== 'step'
+  ) {
+    return false;
+  }
+  let current: acorn.Node = callee.object as acorn.Node;
+  while (current.type === 'CallExpression') {
+    if (isCtxMapCall(current)) return true;
+    const nestedCallee = (current as acorn.CallExpression).callee;
+    if (
+      nestedCallee.type !== 'MemberExpression' ||
+      nestedCallee.property.type !== 'Identifier' ||
+      nestedCallee.property.name !== 'step'
+    ) {
+      return false;
+    }
+    current = nestedCallee.object as acorn.Node;
+  }
+  return false;
+}