deepline 0.3.421 → 0.3.423

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

@@ -60,6 +60,14 @@ import type { ToolExecutionErrorSchemaVersion } from '../tool-execution-error';
 import type { PlaySandboxRuntimeDeclaration } from '../sandbox-runtime-limits';
 import { validatePlaySourceFilesHaveNoInlineSecrets } from '../secret-guardrails';
 import { MAX_PLAY_BUNDLE_BYTES } from './limits';
+import {
+  parseScriptPlay,
+  PLAY_FILE_PATTERN,
+  playNameFromPath,
+  SCRIPT_PLAY_MODULE_DECLARATION,
+  validateScriptPlay,
+  wrapScriptPlay,
+} from '../script-entry';
 import {
   extractPlaySourceAuthoringEdition,
   resolvePlaySourceAuthoringContractEdition,
@@ -83,7 +91,6 @@ const SOURCE_EXTENSIONS = [
   '.cjs',
   '.json',
 ];
-const PLAY_SOURCE_FILE_PATTERN = /\.play\.(?:[cm]?[jt]sx?)$/i;
 const TEXT_IMPORT_EXTENSIONS = new Set(['.md', '.txt']);
 const EXPLICIT_IMPORT_EXTENSIONS = new Set([
   ...SOURCE_EXTENSIONS,
@@ -143,13 +150,17 @@ export type PlayBundlingAdapter = {
   sdkPackageJson: string;
   sdkEntryFile: string;
   sdkTypesEntryFile?: string;
+  /** Reads through the sources the build analyzed. */
   discoverPackagedLocalFiles(
     filePath: string,
+    analyzedSources: Readonly<Record<string, string>>,
   ): Promise<PlayLocalFileDiscoveryResult>;
   typecheckPlaySource?(input: {
     sourceCode: string;
     sourcePath: string;
     importedFilePaths: string[];
+    /** File contents to use instead of the disk; an imported script play is its declaration. */
+    sourceFiles: Record<string, string>;
   }): Promise<string[]> | string[];
   warnAboutNonDevelopmentBundling?(filePath: string): void;
 };
@@ -219,6 +230,10 @@ type SourceGraphAnalysis = {
   sourceAuthoringEdition: PlaySourceAuthoringEdition;
   sourceHasLocalPlayExport: boolean;
   importedPlayDependencies: ImportedPlayDependency[];
+  /** Imported play files as typecheck reads them instead of the disk: a script play as a play declaration. */
+  importedPlaySources: Record<string, string>;
+  /** The entry when it is a script play; esbuild bundles it wrapped, not rewritten. */
+  entryScript: string | null;
 };
 
 type PlayWorkspace = {
@@ -332,7 +347,7 @@ function getPackageName(specifier: string): string {
 }
 
 function isPlaySourceFile(filePath: string): boolean {
-  return PLAY_SOURCE_FILE_PATTERN.test(filePath);
+  return PLAY_FILE_PATTERN.test(filePath);
 }
 
 function stripCommentsToSpaces(source: string): string {
@@ -557,8 +572,15 @@ function findMatchingBrace(source: string, openIndex: number): number {
   return -1;
 }
 
-export function extractDefinedPlayName(sourceCode: string): string | null {
-  return extractDefinedPlayMetadata(sourceCode, null)?.name ?? null;
+/**
+ * The play name a file defines. For a script play this is `config.name`, else
+ * the file name when `filePath` is given (`lookup.play.ts` → `lookup`).
+ */
+export function extractDefinedPlayName(
+  sourceCode: string,
+  filePath?: string,
+): string | null {
+  return extractDefinedPlayMetadata(sourceCode, null, filePath)?.name ?? null;
 }
 
 export function extractDefinedPlayNameForExport(
@@ -606,6 +628,8 @@ function parsePlaySourceAst(sourceCode: string): AstNode | null {
       ecmaVersion: 'latest',
       sourceType: 'module',
       allowHashBang: true,
+      // Script plays may end early with a top-level `return`.
+      allowReturnOutsideFunction: true,
     }) as unknown as AstNode;
   } catch {
     try {
@@ -620,6 +644,8 @@ function parsePlaySourceAst(sourceCode: string): AstNode | null {
         ecmaVersion: 'latest',
         sourceType: 'module',
         allowHashBang: true,
+        // Script plays may end early with a top-level `return`.
+        allowReturnOutsideFunction: true,
       }) as unknown as AstNode;
     } catch {
       return null;
@@ -1247,6 +1273,40 @@ function playMetadataFromDefinePlayCall(
   };
 }
 
+/** A script's config object read like definePlay's options. */
+function playMetadataFromScriptConfig(
+  config: AstNode | null,
+  context: PlayMetadataExtractionContext,
+  filePath: string | undefined,
+): ExtractedPlayMetadata {
+  const toolErrorSchemaVersion = toolErrorSchemaVersionFromOptions(
+    config,
+    context,
+  );
+  const toolResponseReceiptRevision = toolResponseReceiptRevisionFromOptions(
+    config,
+    context,
+  );
+  return {
+    name:
+      stringPropertyFromObjectExpression(config, 'name', context) ??
+      (filePath ? playNameFromPath(filePath) : null),
+    description: stringPropertyFromObjectExpression(
+      config,
+      'description',
+      context,
+    ),
+    sandboxRuntimeDeclaration: sandboxRuntimeDeclarationFromOptions(
+      config,
+      context,
+    ),
+    toolErrorSchemaVersion: toolErrorSchemaVersion ?? null,
+    toolErrorSchemaVersionUnknown: toolErrorSchemaVersion === null,
+    toolResponseReceiptRevision: toolResponseReceiptRevision ?? null,
+    toolResponseReceiptRevisionUnknown: toolResponseReceiptRevision === null,
+  };
+}
+
 function resolveExportExpression(
   exportName: string | null,
   context: PlayMetadataExtractionContext,
@@ -1295,11 +1355,21 @@ function resolveExportExpression(
 function extractDefinedPlayMetadata(
   sourceCode: string,
   exportName: string | null,
+  filePath?: string,
 ): ExtractedPlayMetadata | null {
   const ast = parsePlaySourceAst(sourceCode);
   if (!ast) return null;
   const context = buildPlayMetadataContext(ast);
 
+  // A script play is one play, the default export; parseScriptPlay only
+  // throws on source that failed to parse above, which already returned.
+  const script =
+    exportName === null || exportName === 'default'
+      ? parseScriptPlay(sourceCode)
+      : null;
+  if (script)
+    return playMetadataFromScriptConfig(script.config, context, filePath);
+
   const exportedExpression = resolveExportExpression(exportName, context);
   const exportedMetadata = playMetadataFromDefinePlayCall(
     exportedExpression,
@@ -1745,19 +1815,23 @@ export function instrumentPlayDocflowRuntimeHits(sourceCode: string): string {
 
   // Build the parent index once so every binding's symbol resolution reuses it.
   const parents = buildDocflowParentIndex(ast);
+  // A script play has no run function: its module-level runtime is the context.
+  const scriptContext = parseScriptPlay(sourceCode)?.contextName ?? null;
   for (const binding of parsed.bindings) {
     // ADR 0016 rule 1: prefer the statement the `out:` symbol names; fall back
     // to positional resolution. Instrumentation and `plays check` share this
     // resolver, so the observed statement and the lint agree.
     const resolution = resolveDocflowBinding(ast, binding, lineStarts, parents);
-    const context = findDocflowContext({
-      ast,
-      sourceCode,
-      statement: resolution.statement,
-      bindingLine: binding.line,
-      lineStarts,
-      parents,
-    });
+    const context =
+      findDocflowContext({
+        ast,
+        sourceCode,
+        statement: resolution.statement,
+        bindingLine: binding.line,
+        lineStarts,
+        parents,
+      }) ??
+      (scriptContext ? { kind: 'named' as const, name: scriptContext } : null);
     // No owning definePlay: the binding is in a module-level helper with no
     // context in scope, so it is observed through its caller's bindings.
     if (!context) continue;
@@ -1893,30 +1967,41 @@ export function instrumentPlayDocflowRuntimeHits(sourceCode: string): string {
     );
 }
 
+/**
+ * Serves esbuild the exact sources the graph analysis read, so what is
+ * bundled is what was hashed and checked.
+ */
 function docflowRuntimeInstrumentationPlugin(
-  customerSourceFilePaths: readonly string[],
+  analyzedSources: Readonly<Record<string, string>>,
+  scriptEntry: { path: string; source: string } | null,
 ): Plugin {
-  const customerSourceFiles = new Set(
-    customerSourceFilePaths
-      .filter((path) => extname(path).toLowerCase() !== '.json')
-      .map((path) => resolve(path)),
+  const customerSourceFiles = new Map(
+    Object.entries(analyzedSources)
+      .filter(([path]) => extname(path).toLowerCase() !== '.json')
+      .map(([path, contents]) => [resolve(path), contents]),
   );
   return {
     name: 'deepline-docflow-runtime-instrumentation',
     setup(buildContext) {
       buildContext.onLoad({ filter: /./ }, (args) => {
-        if (!customerSourceFiles.has(resolve(args.path))) return undefined;
+        if (scriptEntry && resolve(args.path) === resolve(scriptEntry.path)) {
+          return {
+            contents: scriptEntryModule(scriptEntry.source, args.path),
+            loader: sourceLoaderForPath(args.path),
+            resolveDir: dirname(args.path),
+          };
+        }
+        const contents = customerSourceFiles.get(resolve(args.path));
+        if (contents === undefined) return undefined;
         if (isTextImportFile(args.path)) {
           return {
-            contents: readFileSync(args.path, 'utf8'),
+            contents,
             loader: 'text',
             resolveDir: dirname(args.path),
           };
         }
         return {
-          contents: instrumentPlayDocflowRuntimeHits(
-            readFileSync(args.path, 'utf8'),
-          ),
+          contents: instrumentPlayDocflowRuntimeHits(contents),
           loader: sourceLoaderForPath(args.path),
           resolveDir: dirname(args.path),
         };
@@ -1925,6 +2010,24 @@ function docflowRuntimeInstrumentationPlugin(
   };
 }
 
+/**
+ * A script-play entry, instrumented, as the function the runner calls: the
+ * module body runs inside the run and its default-exported play function, if
+ * any, is dispatched (see `wrapScriptPlay`).
+ */
+function scriptEntryModule(source: string, path: string): string {
+  const instrumented = instrumentPlayDocflowRuntimeHits(source);
+  const script = parseScriptPlay(instrumented);
+  if (!script) {
+    throw new Error(
+      'Docflow instrumentation turned a script play into a non-script.',
+    );
+  }
+  return wrapScriptPlay(instrumented, script, {
+    typed: /^tsx?$/.test(sourceLoaderForPath(path)),
+  });
+}
+
 function buildImportedPlayProxyModule(playName: string): string {
   const serializedName = JSON.stringify(playName);
   return `
@@ -2109,6 +2212,8 @@ async function analyzeSourceGraph(
   const nodeBuiltins = new Set<string>();
   const packages = new Map<string, string | null>();
   const importedPlayDependencies = new Map<string, ImportedPlayDependency>();
+  const importedPlaySources = new Map<string, string>();
+  let entryScript: string | null = null;
   const visited = new Set<string>();
   const importViolations: string[] = [];
 
@@ -2123,6 +2228,13 @@ async function analyzeSourceGraph(
       /* turbopackIgnore: true */ absolutePath,
       'utf-8',
     );
+    if (absolutePath === absoluteEntryFile) {
+      const script = parseScriptPlay(sourceCode);
+      if (script) {
+        validateScriptPlay(sourceCode, script);
+        entryScript = sourceCode;
+      }
+    }
     localFiles.set(absolutePath, sourceCode);
 
     if (
@@ -2166,10 +2278,20 @@ async function analyzeSourceGraph(
             /* turbopackIgnore: true */ resolved,
             'utf-8',
           );
-          const importedPlayName = extractDefinedPlayName(importedSource);
+          const importedScript = parseScriptPlay(importedSource);
+          if (importedScript)
+            validateScriptPlay(importedSource, importedScript);
+          // A script play has no module shape to type-check against: give the
+          // checker a play reference. A definePlay module is checked as usual.
+          if (importedScript)
+            importedPlaySources.set(resolved, SCRIPT_PLAY_MODULE_DECLARATION);
+          const importedPlayName = extractDefinedPlayName(
+            importedSource,
+            resolved,
+          );
           if (!importedPlayName) {
             throw new Error(
-              `${absolutePath}:${line}:${column} Imported play file "${specifier}" must export definePlay(...) so it can be runtime-composed.`,
+              `${absolutePath}:${line}:${column} Imported play file "${specifier}" is not a play: write it as a script play (import deepline from 'deepline') or default-export a play function, so it can be runtime-composed.`,
             );
           }
           importedPlayDependencies.set(resolved, {
@@ -2243,6 +2365,8 @@ async function analyzeSourceGraph(
         .sort((left, right) => left.filePath.localeCompare(right.filePath)),
     }),
   );
+  // Read the author's file: a script's metadata comes from its config.
+  const authoredSource: string = sourceCode;
   const sourceAst = parsePlaySourceAst(sourceCode);
   if (!sourceAst)
     throw new Error(
@@ -2258,9 +2382,13 @@ async function analyzeSourceGraph(
           selection.definition,
           buildPlayMetadataContext(sourceAst),
         )
-      : extractDefinedPlayMetadata(sourceCode, exportName)) ??
+      : extractDefinedPlayMetadata(
+          authoredSource,
+          exportName,
+          absoluteEntryFile,
+        )) ??
     (exportName === 'default'
-      ? extractDefinedPlayMetadata(sourceCode, null)
+      ? extractDefinedPlayMetadata(authoredSource, null, absoluteEntryFile)
       : null);
   const compatibilityDiagnostic = metadata?.toolErrorSchemaVersionUnknown
     ? 'definePlay compatibility.toolErrorSchemaVersion must be the static literal 0 or 1.'
@@ -2310,6 +2438,8 @@ async function analyzeSourceGraph(
     importedPlayDependencies: [...importedPlayDependencies.values()].sort(
       (left, right) => left.filePath.localeCompare(right.filePath),
     ),
+    importedPlaySources: Object.fromEntries(importedPlaySources),
+    entryScript,
   };
 }
 
@@ -2434,7 +2564,8 @@ type EsbuildBundleOutput = {
 
 async function runEsbuildForCjsNode(
   entryFile: string,
-  customerSourceFilePaths: string[],
+  analyzedSources: Readonly<Record<string, string>>,
+  entryScript: string | null,
   importedPlayDependencies: ImportedPlayDependency[],
   adapter: PlayBundlingAdapter,
   exportName: string,
@@ -2442,14 +2573,14 @@ async function runEsbuildForCjsNode(
 ): Promise<EsbuildBundleOutput | string[]> {
   const sdkAliasPlugin = localSdkAliasPlugin(adapter);
   const playProxyPlugin = importedPlayProxyPlugin(importedPlayDependencies);
-  const docflowPlugin = docflowRuntimeInstrumentationPlugin([
-    entryFile,
-    ...customerSourceFilePaths,
-  ]);
+  const docflowPlugin = docflowRuntimeInstrumentationPlugin(
+    analyzedSources,
+    entryScript === null ? null : { path: entryFile, source: entryScript },
+  );
   const namedExportShim =
-    exportName === 'default'
-      ? null
-      : `export { ${exportName} as default } from ${JSON.stringify(entryFile)};\n`;
+    exportName !== 'default'
+      ? `export { ${exportName} as default } from ${JSON.stringify(entryFile)};\n`
+      : null;
   const result = await build({
     ...(namedExportShim
       ? {
@@ -2539,7 +2670,10 @@ export async function bundlePlayFile(
       );
     }
     analysis.graphHash = sha256(
-      `${analysis.graphHash}\nentry-export:${exportName}\nauthoring-contract-edition:${edition}${edition >= 10 ? '\nimported-proxy-options:description' : ''}${preservedCompatibility === undefined ? '\ndataset-row-input:current_run' : `\npreserved-compatibility:${JSON.stringify(preservedCompatibility)}`}`,
+      `${analysis.graphHash}\nentry-export:${exportName}\nauthoring-contract-edition:${edition}${edition >= 10 ? '\nimported-proxy-options:description' : ''}${preservedCompatibility === undefined ? '\ndataset-row-input:current_run' : `\npreserved-compatibility:${JSON.stringify(preservedCompatibility)}`}` +
+        // A script entry is bundled wrapped; keep its artifacts apart.
+        // definePlay plays keep their existing hash.
+        (analysis.entryScript === null ? '' : '\nentry-form:script-v2'),
     );
     const sourceFiles = Object.fromEntries(
       Object.entries(analysis.sourceFiles).map(([sourcePath, sourceCode]) => [
@@ -2573,6 +2707,10 @@ export async function bundlePlayFile(
             (dependency) => dependency.filePath,
           ),
         ],
+        sourceFiles: {
+          ...analysis.sourceFiles,
+          ...analysis.importedPlaySources,
+        },
       })) ?? []),
     ];
     if (typecheckErrors.length > 0) {
@@ -2591,8 +2729,10 @@ export async function bundlePlayFile(
       target,
       adapter,
     );
-    const discoveredFiles =
-      await adapter.discoverPackagedLocalFiles(absolutePath);
+    const discoveredFiles = await adapter.discoverPackagedLocalFiles(
+      absolutePath,
+      analysis.sourceFiles,
+    );
     if (cachedArtifact) {
       const cachedArtifactSizeError = getBundleSizeError(
         absolutePath,
@@ -2642,7 +2782,8 @@ export async function bundlePlayFile(
     const bundleRoot = resolve(sourceIdentityRoot ?? adapter.projectRoot);
     const buildOutcome = await runEsbuildForCjsNode(
       absolutePath,
-      analysis.importPolicy.localFiles,
+      analysis.sourceFiles,
+      analysis.entryScript,
       analysis.importedPlayDependencies,
       adapter,
       exportName,

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

@@ -217,13 +217,13 @@ export type PlayDatasetTransformOptions = {
 };
 
 /**
- * Durable handle for rows produced by `ctx.csv(...)` or `ctx.dataset(...).run()`.
+ * Durable handle for rows produced by `deepline.csv(...)` or `deepline.dataset(...).run()`.
  *
  * A `PlayDataset` is not a normal in-memory array. It points at runtime-managed
  * rows, usually backed by persisted sheet storage, and carries metadata such as
  * dataset kind, dataset id, table namespace, count, and preview rows.
  *
- * Pass dataset handles directly into later `ctx.dataset(...)` stages by default so
+ * Pass dataset handles directly into later `deepline.dataset(...)` stages by default so
  * Deepline keeps row progress, retries, memory use, and table output under
  * runtime control. Use `count()` and `peek()` for bounded inspection. Use
  * `materialize(limit)` or async iteration only when the dataset is intentionally

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

@@ -1288,6 +1288,10 @@ function attachBindingsToBlocks(
   const exportRanges = playExportSourceRanges(sourceCode);
   for (const binding of bindings) {
     let owners = blocks.filter((block) => block.nodes.has(binding.nodeId));
+    // A helper module can serve several plays, each drawing only its own
+    // boxes, so an imported annotation this play's diagram does not draw is
+    // another play's. An annotation in the play's own file must name a node.
+    if (owners.length === 0 && binding.sourcePath) continue;
     if (owners.length === 0) {
       errors.push(
         `Docflow annotation "${binding.nodeId}" does not name a graph node.`,

package/dist/bundling-sources/shared_libs/plays/fetch-http-error.ts

@@ -1,7 +1,7 @@
 import type { PlayAuthoringFetchResponse } from './authoring-contract';
 
 /**
- * Edition 5+ `ctx.fetch` error for a non-2xx response. Its full readable body is secret-redacted; editions 1–4 retain `PlayFetchResponse { ok: false }`.
+ * Edition 5+ `deepline.fetch` error for a non-2xx response. Its full readable body is secret-redacted; editions 1–4 retain `PlayFetchResponse { ok: false }`.
  *
  * @sdkReference runtime 178 CtxFetchHttpError
  */

package/dist/bundling-sources/shared_libs/plays/local-file-discovery.ts

@@ -9,6 +9,7 @@ import {
   relative,
 } from 'node:path';
 import * as ts from 'typescript';
+import { isRuntimeReceiver, playRuntimeNames } from './script-entry';
 
 export interface PlayLocalFileReference {
   sourceFragment: string;
@@ -63,14 +64,18 @@ function contentTypeForFile(filePath: string): string {
   return 'application/octet-stream';
 }
 
-function isCtxCsvCall(node: ts.CallExpression): boolean {
+/** `ctx.csv(...)`, `*Ctx.csv(...)`, or a script's `deepline.csv(...)`. */
+function isCtxCsvCall(
+  node: ts.CallExpression,
+  runtimeNames: ReadonlySet<string>,
+): boolean {
   if (!ts.isPropertyAccessExpression(node.expression)) {
     return false;
   }
   const target = node.expression.expression;
   return (
     ts.isIdentifier(target) &&
-    (target.text === 'ctx' || target.text.endsWith('Ctx')) &&
+    isRuntimeReceiver(target.text, runtimeNames) &&
     node.expression.name.text === 'csv'
   );
 }
@@ -257,6 +262,7 @@ async function resolveLocalImport(
 
 export async function discoverPackagedLocalFiles(
   entryFile: string,
+  analyzedSources: Readonly<Record<string, string>> = {},
 ): Promise<PlayLocalFileDiscoveryResult> {
   const absoluteEntryFile = resolve(entryFile);
   const packagingRoot = dirname(absoluteEntryFile);
@@ -271,7 +277,8 @@ export async function discoverPackagedLocalFiles(
     }
     visitedFiles.add(absolutePath);
 
-    const sourceCode = await readFile(absolutePath, 'utf-8');
+    const sourceCode =
+      analyzedSources[absolutePath] ?? (await readFile(absolutePath, 'utf-8'));
     if (isTextImportFile(absolutePath)) {
       return;
     }
@@ -283,10 +290,11 @@ export async function discoverPackagedLocalFiles(
       ts.ScriptKind.TS,
     );
     const constants = collectTopLevelStringConstants(sourceFile);
+    const runtimeNames = playRuntimeNames(sourceCode);
     const childVisits: Promise<void>[] = [];
 
     const visitNode = async (node: ts.Node): Promise<void> => {
-      if (ts.isCallExpression(node) && isCtxCsvCall(node)) {
+      if (ts.isCallExpression(node) && isCtxCsvCall(node, runtimeNames)) {
         const argument = node.arguments[0];
         if (!argument) {
           unresolved.push({

package/dist/bundling-sources/shared_libs/plays/play-exports.ts

@@ -19,6 +19,7 @@ import {
   parsePlaySourceForAnalysis,
   type AstNode,
 } from './ts-ast';
+import { parseScriptPlay } from './script-entry';
 
 /** The export name the runtime, the registry and the CLI all use for a file's
  *  default play. Aliases resolve to it, never the other way round. */
@@ -111,8 +112,16 @@ function definePlayName(node: AstNode | null): string | null {
     astArray(expression.arguments)[0] ?? null,
   );
   if (first?.type !== 'ObjectExpression') return stringLiteralValue(first);
-  let id: string | null = null;
-  for (const property of astArray(first.properties)) {
+  return objectStringProperty(first, 'id');
+}
+
+/** The literal string `propertyName` of an object literal, when it is one. */
+function objectStringProperty(
+  object: AstNode | null,
+  propertyName: string,
+): string | null {
+  let value: string | null = null;
+  for (const property of astArray(object?.properties)) {
     if (property.type !== 'Property' || property.computed) continue;
     const key = isAstNode(property.key) ? property.key : null;
     const keyName =
@@ -120,10 +129,12 @@ function definePlayName(node: AstNode | null): string | null {
       (key?.type === 'Literal' && typeof key.value === 'string'
         ? key.value
         : null);
-    if (keyName !== 'id') continue;
-    id = stringLiteralValue(isAstNode(property.value) ? property.value : null);
+    if (keyName !== propertyName) continue;
+    value = stringLiteralValue(
+      isAstNode(property.value) ? property.value : null,
+    );
   }
-  return id;
+  return value;
 }
 
 /**
@@ -137,6 +148,17 @@ export function listPlayFileExports(
 ): PlayFileExport[] | null {
   const ast = parsePlaySourceForAnalysis(sourceCode);
   if (!ast) return null;
+  // A script play is one play, the default; its name is `config.name`.
+  const script = parseScriptPlay(sourceCode);
+  if (script) {
+    return [
+      {
+        name: PLAY_DEFAULT_EXPORT,
+        aliases: [],
+        playName: objectStringProperty(script.config, 'name'),
+      },
+    ];
+  }
 
   /** Local const/let/var name -> its initializer, for resolving `export { x }`
    *  and `export default x` back to the `definePlay` call they name. */