deepline 0.3.422 → 0.3.423

package/dist/bundling-sources/sdk/src/client.ts

@@ -630,7 +630,7 @@ export type RunsGetOptions = {
 };
 
 export type RunsChildrenOptions = {
-  /** Required authored `ctx.runPlayAsync` launch key. */
+  /** Required authored `deepline.runPlayAsync` launch key. */
   launchKey: string;
   /** Opaque cursor returned by the preceding page. */
   cursor?: string;
@@ -4911,7 +4911,7 @@ export class DeeplineClient {
   /**
    * Export persisted runtime-sheet rows for a play dataset/table namespace.
    *
-   * This is the SDK form of exporting `ctx.dataset(...).run()` output for a
+   * This is the SDK form of exporting `deepline.dataset(...).run()` output for a
    * specific play and optional run id.
    */
   async getPlaySheetRows(input: {

package/dist/bundling-sources/sdk/src/index.ts

@@ -299,6 +299,8 @@ export {
   readList,
   steps,
 } from './play';
+export { deepline as default, deepline, runScriptPlay } from './play';
+export type { ScriptPlayContext } from './play';
 
 // ——— Tool output processing ———
 export {

package/dist/bundling-sources/sdk/src/play.ts

@@ -8,9 +8,8 @@
  *
  * ## Core concepts
  *
- * - **{@link definePlay}** — Define a play as a typed async function. The returned
- *   value is both callable (for server-side execution) and has methods for
- *   remote lifecycle management (run, get, publish, tail).
+ * - **{@link deepline}** — The play runtime. A play is a `.play.ts` file of
+ *   top-level code that imports it; see {@link ScriptPlayContext}.
  *
  * - **{@link Deepline.connect}** — Create a client context for programmatic SDK
  *   usage. Returns a {@link DeeplineContext} with tool and play handles.
@@ -20,60 +19,39 @@
  *
  * ## Usage patterns
  *
- * ### Define and run a play (file-backed)
+ * ### Write and run a play
  *
  * ```typescript
- * // my-play.play.ts
- * import { definePlay } from 'deepline';
- *
- * export default definePlay('my-play', async (ctx, input: { domain: string }) => {
- *   ctx.log(`Looking up ${input.domain}`);
- *   const company = await ctx.tools.execute({
+ * // lookup.play.ts
+ * import deepline from 'deepline';
+ *
+ * export default async function ({ domain }: { domain: string }) {
+ *   const company = await deepline.tools.execute({
+ *     id: 'company',
+ *     tool: 'company_lookup',
+ *     input: { domain },
+ *     description: 'Look up the company.',
  *     staleAfterSeconds: 0,
- *     id: 'company_search',
- *     tool: 'test_company_search',
- *     input: { domain: input.domain },
- *     description: 'Look up company details by domain.',
  *   });
- *   return company;
- * });
+ *   return { company };
+ * }
  * ```
  *
- * Then run via the CLI:
- * `deepline plays run --file my-play.play.ts`.
- * Installed npm CLIs can also run saved or prebuilt plays by name.
+ * Run it with `deepline plays run lookup.play.ts --input '{"domain":"stripe.com"}'`.
  *
  * ### Programmatic usage
  *
  * ```typescript
  * import { Deepline } from 'deepline';
  *
- * const deepline = await Deepline.connect();
- * const job = await deepline.play('my-play').run({ domain: 'stripe.com' });
+ * const client = await Deepline.connect();
+ * const job = await client.play('lookup').run({ domain: 'stripe.com' });
  * const result = await job.get(); // Polls until complete
  * ```
  *
- * ### With bindings (cron, webhook)
- *
- * ```typescript
- * import { definePlay } from 'deepline';
- *
- * export default definePlay('daily-sync', async (ctx) => {
- *   const data = await ctx.tools.execute({
- *     staleAfterSeconds: 0,
- *     id: 'crm_export',
- *     tool: 'crm_export',
- *     input: {},
- *     description: 'Export CRM records for the daily sync.',
- *   });
- *   return data;
- * }, {
- *   cron: { schedule: '0 9 * * *', timezone: 'America/New_York' },
- * });
- * ```
- *
  * @module
  */
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { DeeplineClient } from './client';
 import { createPlayClient, type PlayClientOperations } from './plays/client';
 import { DeeplineError } from './errors';
@@ -189,10 +167,13 @@ export type FetchOptions = PlayAuthoringFetchOptions;
 export type PlayFetchResponse = PlayAuthoringFetchResponse;
 
 /**
- * Optional Play configuration, including triggers and runtime limits.
+ * Optional Play configuration, declared once at the top of the play file as
+ * an object literal: `export const config = { ... };`. Settings: `name`
+ * (defaults to the file name), `description`, `displayName`, `cron`,
+ * `webhook`, `sqlListeners`, `runtime`, `billing`, `compatibility`. It is
+ * read without running the play, so its values must be literals.
  *
- * A play can be triggered three ways, declared as the third argument to
- * {@link definePlay}:
+ * A play can be triggered three ways:
  * - `webhook` — an inbound HTTP call (with optional legacy HMAC or Standard
  *   Webhooks signature verification).
  * - `cron` — a schedule.
@@ -201,17 +182,17 @@ export type PlayFetchResponse = PlayAuthoringFetchResponse;
  *   (e.g. run enrichment every time a watched company posts a new job). Each
  *   listener binds to a monitor tool id + one of its output stream keys (see
  *   `deepline monitors available <id>` for a tool's streams and row columns).
- *   The changed row is delivered to the handler as the listener event's `after`.
+ *   The changed row is delivered as the listener event's `after` in the play function's input.
  *
  * The default Play runtime is 30 minutes. For bounded long-running batches, add
  * `runtime: { timeout: '90m', size: 'standard' }`; duration values are whole minutes or hours, up to `4h`.
- * It differs from `ctx.tools.execute({ timeoutMs })`, which limits one provider call.
+ * It differs from `deepline.tools.execute({ timeoutMs })`, which limits one provider call.
  *
  * @example Webhook with HMAC verification. `secretEnv` is the Deepline Secret
  * name configured with `deepline secrets set`, retained as the legacy field
  * name for SDK compatibility.
  * ```typescript
- * definePlay('webhook-handler', handler, {
+ * export const config = {
  *   webhook: {
  *     hmac: {
  *       algorithm: 'sha256',
@@ -221,12 +202,12 @@ export type PlayFetchResponse = PlayAuthoringFetchResponse;
  *       secretEnv: 'WEBHOOK_SECRET',
  *     },
  *   },
- * });
+ * };
  * ```
  *
  * @example Svix / Standard Webhooks verification with Deepline Secrets
  * ```typescript
- * definePlay('visitor-webhook', handler, {
+ * export const config = {
  *   webhook: {
  *     auth: {
  *       type: 'standard-webhooks',
@@ -234,19 +215,17 @@ export type PlayFetchResponse = PlayAuthoringFetchResponse;
  *       signingSecrets: ['VECTOR_WEBHOOK_SECRET'],
  *     },
  *   },
- * });
+ * };
  * ```
  *
  * @example Cron schedule
  * ```typescript
- * definePlay('nightly-sync', handler, {
- *   cron: { schedule: '0 2 * * *', timezone: 'UTC' },
- * });
+ * export const config = { cron: { schedule: '0 2 * * *', timezone: 'UTC' } };
  * ```
  *
  * @example Monitor-triggered (run a play on a monitor's output)
  * ```typescript
- * definePlay('on-new-job-opening', handler, {
+ * export const config = {
  *   sqlListeners: [
  *     {
  *       id: 'jobs',
@@ -255,10 +234,10 @@ export type PlayFetchResponse = PlayAuthoringFetchResponse;
  *       operations: ['INSERT'],
  *     },
  *   ],
- * });
+ * };
  * ```
  *
- * @sdkReference runtime 030
+ * @sdkReference runtime 006 export const config
  */
 export type PlayBindings<TInput = Record<string, unknown>> =
   PlayAuthoringBindings<TInput>;
@@ -270,7 +249,7 @@ export type SqlListenerDeclaration = PlaySqlListenerDeclaration;
 export type SqlListenerEvent<T extends object = Record<string, unknown>> =
   PlaySqlListenerEvent<T>;
 
-/** @deprecated Pass a SQL string directly to ctx.customerDb.query. */
+/** @deprecated Pass a SQL string directly to deepline.customerDb.query. */
 export type SqlQuery = PlaySqlQuery;
 export type SecretHandle = PlaySecretHandle;
 export type SecretPromise = PlaySecretPromise;
@@ -311,7 +290,7 @@ export type {
 export type { PreviousCell } from '../../shared_libs/plays/cell-staleness.js';
 
 /**
- * Keyword-style request object for `ctx.tools.execute(...)`.
+ * Keyword-style request object for `deepline.tools.execute(...)`.
  *
  * The `tool` value comes from live tool discovery. The `id` is the stable
  * logical call name used for logs, metadata, and result-cache identity. Provider
@@ -397,7 +376,7 @@ export type RunnableStepProgram<TInput, TOutput> = Pick<
 > & { readonly __inputType?: (input: TInput) => void };
 
 /**
- * Builder returned by `ctx.dataset(...)` for row-level durable columns.
+ * Builder returned by `deepline.dataset(...)` for row-level durable columns.
  *
  * @sdkReference runtime 070 .dataset(...).withColumn(name, resolver).run(options)
  */
@@ -438,58 +417,195 @@ export type CsvInput<TRow extends object = Record<string, unknown>> =
 export type ColumnMap<TRow extends object> = PlayAuthoringColumnMap<TRow>;
 
 /**
- * Options for loading a staged CSV with `ctx.csv(...)`.
+ * Options for loading a staged CSV with `deepline.csv(...)`.
  *
  * @sdkReference runtime 050
  */
 export type CsvOptions = PlayAuthoringCsvOptions;
 
 /**
- * Runtime context available inside a play function.
- *
- * Provides methods for calling tools, processing data, and emitting logs.
- * This context is injected by the Temporal worker — you never construct it directly.
+ * The play runtime: every member of `deepline` except `config`, `input` and
+ * `output`. Use it to type a helper module's parameter; pass `deepline` in.
  *
  * @example
  * ```typescript
- * definePlay('example', async (ctx, input: { domain: string; csv: string }) => {
- *   // Call a tool
- *   const company = await ctx.tools.execute({
- *     id: 'company_search',
- *     tool: 'test_company_search',
+ * // enrich.ts
+ * import type { DeeplinePlayRuntimeContext } from 'deepline';
+ *
+ * export function lookUp(deepline: DeeplinePlayRuntimeContext, domain: string) {
+ *   return deepline.tools.execute({
+ *     id: 'company',
+ *     tool: 'company_lookup',
+ *     input: { domain },
+ *     description: 'Look up the company.',
+ *   });
+ * }
+ * ```
+ */
+export type DeeplinePlayRuntimeContext = PlayAuthoringRuntimeContext<'array'>;
+
+/**
+ * `import deepline from 'deepline'` — the play runtime. A play is a
+ * `.play.ts` file that default-exports an async function of its input; the
+ * file name is the play name. The parameter's type is the input contract and
+ * the returned object is the result. Every
+ * runtime call below is `deepline.<name>`, including inside dataset resolvers
+ * and step bodies.
+ *
+ * ```ts
+ * import deepline from 'deepline';
+ *
+ * export default async function (input: { domain: string }) {
+ *   const company = await deepline.tools.execute({
+ *     id: 'company',
+ *     tool: 'company_lookup',
  *     input: { domain: input.domain },
- *     description: 'Look up company details by domain.',
+ *     description: 'Look up the company.',
+ *     staleAfterSeconds: 0,
  *   });
+ *   return { company };
+ * }
+ * ```
  *
- *   // Fan-out: process items with named columns
- *   const enriched = await ctx
- *     .dataset('companies', [{ domain: 'a.com' }, { domain: 'b.com' }])
- *     .withColumn('company', (row, rowCtx) =>
- *       rowCtx.tools.execute({
- *         id: 'company_search',
- *         tool: 'test_company_search',
- *         input: { domain: row.domain },
- *         description: 'Look up company details by domain.',
- *       }))
- *     .run({ description: 'Look up company details.' });
- *
- *   // Load CSV data from a submitted play input field.
- *   const leads = await ctx.csv(input.csv);
- *
- *   // Emit a log line (visible in `play tail`)
- *   ctx.log(`Loaded ${await leads.count()} leads`);
+ * ```bash
+ * deepline plays run lookup.play.ts --input '{"domain":"stripe.com"}'
+ * deepline plays run -e 'deepline.log("hello"); return { ok: true };'
+ * ```
  *
- *   // Wait at least one second before continuing.
- *   await ctx.sleep(1000);
+ * Compose with `import child from './child.play'` and
+ * `await deepline.runPlay('key', child, input, { description })`, or by name.
+ * `deepline` works only in the play file; pass it to helper modules as an
+ * argument typed {@link DeeplinePlayRuntimeContext}. The file exports only
+ * the play function and, optionally, its `config`.
  *
- *   // Access submitted input through the handler's second argument.
- *   ctx.log(`Running for ${input.domain}`);
+ * @sdkReference runtime 005 deepline
+ */
+export type ScriptPlayContext = DeeplinePlayRuntimeContext & {
+  /** The same settings as `export const config = { ... }`. */
+  config(config: PlayBindings & { name?: string }): void;
+  /**
+   * The run's input. A play function receives it as its parameter instead;
+   * this is not called at the top of a play file.
+   */
+  input<TInput = Record<string, unknown>>(): TInput;
+  /**
+   * Sets the play's result; deepline calls after it fail. A play function
+   * returns its result instead; this is not called at the top of a play file.
+   */
+  output(result: PlayReturnObject): void;
+};
+
+/** The run a script play is executing in: its context, input and result. */
+type ScriptRun = {
+  readonly context: DeeplinePlayRuntimeContext;
+  readonly input: unknown;
+  /** Set by `deepline.output`, the run's last deepline call. */
+  result: PlayReturnObject | null;
+};
+
+const scriptRuns = new AsyncLocalStorage<ScriptRun>();
+
+/**
+ * The run whose context a callback the runtime invokes outside the play's
+ * async flow belongs to, such as a dataset `key` function called while rows
+ * persist. Each play artifact bundles its own SDK and the runner builds an
+ * artifact module per run, so it is the last run started outside any run: a
+ * nested inline run must not hand the outer run's callbacks its context.
+ */
+let latestScriptRun: ScriptRun | null = null;
+
+/** The three script calls; every other member is the run's context. */
+const scriptCalls = {
+  // Read statically before the run; nothing to do while it executes.
+  config: () => () => undefined,
+  input: (run: ScriptRun) => () => run.input,
+  // Returns the value so an `$output` diagram node observes the result.
+  output: (run: ScriptRun) => (result: PlayReturnObject) =>
+    (run.result = playResult(result, 'deepline.output(...)')),
+} satisfies Record<string, (run: ScriptRun) => unknown>;
+
+/**
+ * Runs a play module's body with `deepline` bound to this run. The bundler
+ * wraps the module's code, and the dispatch to its default-exported play
+ * function, in this call, so the artifact keeps the runner's
+ * `(context, input) => result` contract.
  *
- *   return { company, enriched };
- * });
- * ```
+ * @internal
  */
-export type DeeplinePlayRuntimeContext = PlayAuthoringRuntimeContext<'array'>;
+export async function runScriptPlay(
+  context: DeeplinePlayRuntimeContext,
+  input: unknown,
+  body: () => Promise<unknown>,
+): Promise<PlayReturnObject> {
+  const run: ScriptRun = { context, input, result: null };
+  if (!scriptRuns.getStore()) latestScriptRun = run;
+  // The play function's return, or a top-level `return value`, is the
+  // result, as `return` is in a definePlay handler; otherwise output set it.
+  const returned = await scriptRuns.run(run, body);
+  if (returned !== undefined)
+    return playResult(returned, "A play's return value");
+  return run.result ?? {};
+}
+
+/** A play's result is a plain object, from `return` or `deepline.output`. */
+function playResult(value: unknown, source: string): PlayReturnObject {
+  const prototype =
+    value !== null && typeof value === 'object'
+      ? Object.getPrototypeOf(value)
+      : undefined;
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw new Error(
+      `${source} must be a plain object, such as { company }; got ${Array.isArray(value) ? 'an array' : value === null ? 'null' : typeof value}.`,
+    );
+  }
+  return value as PlayReturnObject;
+}
+
+/**
+ * The live play runtime for a script play. Inside a run it is that run's
+ * context (bound per async flow, so concurrent rows and steps keep their own
+ * scope); anywhere else, using it is a mistake worth a clear error.
+ */
+export const deepline: ScriptPlayContext = new Proxy({} as ScriptPlayContext, {
+  get(_target, property) {
+    if (typeof property !== 'string' || property === 'then') return undefined;
+    // Config is read statically; its call does nothing at run time.
+    if (property === 'config') return scriptCalls.config();
+    const run = scriptRuns.getStore();
+    if (!run) {
+      if (!latestScriptRun) {
+        throw new Error(
+          `deepline.${property} is only available while a play runs. Run the file with: deepline plays run <file>.play.ts`,
+        );
+      }
+      if (Object.hasOwn(scriptCalls, property)) {
+        throw new Error(
+          `deepline.${property}() belongs in the play's own code, not in a callback the runtime calls later.`,
+        );
+      }
+      return contextMember(latestScriptRun.context, property);
+    }
+    if (run.result !== null) {
+      // Code after output still runs; a deepline call there would do work the
+      // result no longer reflects. A `return` ends a play early.
+      throw new Error(
+        `deepline.${property} was called after deepline.output(...). Return the play's result from its function instead: return { ... }.`,
+      );
+    }
+    if (Object.hasOwn(scriptCalls, property)) {
+      return scriptCalls[property as keyof typeof scriptCalls](run);
+    }
+    return contextMember(run.context, property);
+  },
+});
+
+function contextMember(
+  context: DeeplinePlayRuntimeContext,
+  property: string,
+): unknown {
+  const value: unknown = Reflect.get(context, property);
+  return typeof value === 'function' ? value.bind(context) : value;
+}
 
 /**
  * Handle to a Play execution: inspect status, stream logs, await output, or cancel.
@@ -501,7 +617,8 @@ export type DeeplinePlayRuntimeContext = PlayAuthoringRuntimeContext<'array'>;
  *
  * @example
  * ```typescript
- * const job: PlayJob = await ctx.play('my-play').run({ domain: 'stripe.com' });
+ * const client = await Deepline.connect();
+ * const job: PlayJob = await client.play('my-play').run({ domain: 'stripe.com' });
  *
  * // Poll status
  * const status = await job.status();
@@ -572,8 +689,8 @@ export interface PlayJob<TOutput = unknown> {
  *
  * @example
  * ```typescript
- * const ctx = await Deepline.connect();
- * const play = ctx.play<{ domain: string }, Company>('company-lookup');
+ * const client = await Deepline.connect();
+ * const play = client.play<{ domain: string }, Company>('company-lookup');
  *
  * // Get play definition
  * const detail = await play.get();
@@ -659,8 +776,8 @@ export type DeeplineToolCallOptions = Pick<
  * Tool/provider operations available from a connected {@link DeeplineContext}.
  *
  * This namespace is for regular SDK callers outside a play runtime. Inside a
- * `definePlay(...)` body, use `ctx.tools.execute({ id, tool, input, ... })`
- * so provider calls become durable runtime checkpoints.
+ * play, use `deepline.tools.execute({ id, tool, input, ... })` so provider
+ * calls become durable runtime checkpoints.
  *
  * @sdkReference tools 010 DeeplineContext.tools
  */
@@ -678,7 +795,7 @@ export type DeeplineToolsNamespace = {
   /**
    * Execute a provider-backed tool from a regular SDK process.
    *
-   * For durable play code, prefer `ctx.tools.execute(...)` because the play
+   * For durable play code, prefer `deepline.tools.execute(...)` because the play
    * runtime records the call under a stable id.
    */
   execute(
@@ -722,7 +839,7 @@ export type PlayReferenceLike<
   TInput extends Record<string, unknown> = Record<string, unknown>,
 > = PlayAuthoringReferenceLike<TInput>;
 
-/** Branded durable identity returned by ctx.runPlayAsync. */
+/** Branded durable identity returned by deepline.runPlayAsync. */
 export type PlayRunId = PlayAuthoringRunId;
 
 /** Serializable reference to an independently scheduled Play Run. */
@@ -741,14 +858,9 @@ export type PlayReturnObject = PlayAuthoringReturnObject;
 export type PlayInputContract<TInput> = PlayAuthoringInputContract<TInput>;
 
 /**
- * Object-form play definition accepted by `definePlay(config)`.
+ * Object-form config accepted by the older `definePlay(config)` form. Files
+ * that export `definePlay(...)` keep working; new plays use {@link deepline}.
  *
- * Use this form when the input contract should be explicit at definition time
- * through `defineInput<T>(schema)`, or when configuration reads clearer as one
- * object. The shorthand `definePlay(name, fn, bindings?)` is equivalent for
- * simple file-backed plays.
- *
- * @sdkReference runtime 020
  */
 export type DefinePlayConfig<
   TInput,
@@ -1150,7 +1262,7 @@ export class DeeplineContext {
    * Play discovery and named-play handles.
    *
    * Use `plays.list()` for discovery and `plays.get(name)` when you prefer a
-   * namespace spelling over `ctx.play(name)`.
+   * namespace spelling over `play(name)`.
    */
   get plays(): DeeplinePlaysNamespace {
     return {
@@ -1166,7 +1278,7 @@ export class DeeplineContext {
    *
    * Known prebuilts are exposed by camel-cased aliases. Any other property is
    * converted into `prebuilt/<property>` so callers can pass the reference to
-   * `ctx.runPlay(...)`.
+   * `deepline.runPlay(...)` inside a play.
    */
   get prebuilt(): Record<string, PrebuiltPlayRef> {
     const explicit = {
@@ -1217,7 +1329,7 @@ export class DeeplineContext {
    *
    * @example
    * ```typescript
-   * const play = ctx.play<{ domain: string }>('email-waterfall');
+   * const play = client.play<{ domain: string }>('email-waterfall');
    * const job = await play.run({ domain: 'stripe.com' });
    * const result = await job.get();
    * ```
@@ -1231,8 +1343,8 @@ export class DeeplineContext {
   /**
    * Run a named or prebuilt play and wait for its output.
    *
-   * This is the high-level SDK equivalent of `ctx.play(name).runSync(input)`.
-   * Inside a Play, prefer `ctx.runPlay(key, playRef, input, options)`.
+   * This is the high-level SDK equivalent of `client.play(name).runSync(input)`.
+   * Inside a play, use `deepline.runPlay(key, playRef, input, options)`.
    * The runtime checkpoints the child run under a stable key.
    *
    * @param playOrRef - Play name or prebuilt/reference object.
@@ -1641,12 +1753,8 @@ export function defineInput<TInput>(
 }
 
 /**
- * Define a play — a composable TypeScript workflow for the Deepline platform.
- *
- * The returned value is both a callable function and a named Play handle.
- * The Deepline runtime calls the function with a runtime context.
- * The handle provides `.run()`, `.versions()`, `.get()`, and `.publish()` for remote lifecycle operations.
- * Plays define repeatable data pipelines. The runtime executes them durably with automatic retries and timeouts.
+ * The older play form. Files that export `definePlay(...)` keep working; new
+ * plays are scripts that use {@link deepline}.
  *
  * @typeParam TInput - The input type accepted by the play
  * @typeParam TOutput - The return type of the play
@@ -1655,70 +1763,6 @@ export function defineInput<TInput>(
  * @param fn - Play function.
  * @param bindings - Play configuration, including runtime limits and triggers.
  * @returns A {@link DefinedPlay} that is both callable and has lifecycle methods
- *
- * @example Basic play
- * ```typescript
- * import { definePlay } from 'deepline';
- *
- * export default definePlay('company-lookup', async (ctx, input: { domain: string }) => {
- *   ctx.log(`Searching for ${input.domain}`);
- *   const company = await ctx.tools.execute({
- *     id: 'company_search',
- *     tool: 'test_company_search',
- *     input: { domain: input.domain },
- *     description: 'Look up company details by domain.',
- *   });
- *   return company;
- * });
- * ```
- *
- * @example CSV processing play
- * ```typescript
- * export default definePlay('bulk-enrich', async (ctx, input: { csv: string }) => {
- *   const leads = await ctx.csv(input.csv);
- *   ctx.log(`Processing ${await leads.count()} rows`);
- *   const results = await ctx
- *     .dataset('companies', leads)
- *     .withColumn('company', (row, ctx) =>
- *       ctx.tools.execute({
- *         id: 'company_search',
- *         tool: 'test_company_search',
- *         input: { domain: row.domain },
- *         description: 'Look up company details by domain.',
- *       }))
- *     .run({ description: 'Enrich lead companies.' });
- *   return results;
- * });
- * ```
- *
- * @example With cron binding
- * ```typescript
- * export default definePlay('daily-report', async (ctx) => {
- *   const data = await ctx.tools.execute({
- *     id: 'crm_export',
- *     tool: 'crm_export',
- *     input: { since: 'yesterday' },
- *     description: 'Export yesterday CRM records.',
- *   });
- *   return data;
- * }, {
- *   cron: { schedule: '0 9 * * *', timezone: 'America/New_York' },
- * });
- * ```
- *
- * @example Programmatic lifecycle
- * ```typescript
- * const myPlay = definePlay('my-play', handler);
- *
- * // Get play definition:
- * const detail = await myPlay.get();
- *
- * // Run remotely:
- * const result = await myPlay.runSync({ domain: 'stripe.com' });
- *
- * // Make the current draft live:
- * await myPlay.publish();
- * ```
  */
 export function definePlay<TInput, TOutput extends PlayReturnObject>(
   config: DefinePlayConfig<TInput, TOutput>,
@@ -1752,7 +1796,6 @@ export function definePlay<
 ): DefinedPlay<PlayHandlerInput<THandler>, PlayHandlerOutput<THandler>>;
 /* eslint-enable @typescript-eslint/no-explicit-any */
 /**
- * @sdkReference runtime 010
  */
 export function definePlay<TInput, TOutput extends PlayReturnObject>(
   nameOrConfig: string | DefinePlayConfig<TInput, TOutput>,