deepline 0.3.87 → 0.3.89

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/backends/daytona-start-admission.ts

@@ -0,0 +1,68 @@
+import { RUNTIME_CAPACITY_POLICY } from '../../runtime-capacity-policy';
+
+export type DaytonaSandboxStartAdmission = {
+  run<T>(operation: () => Promise<T>): Promise<T>;
+};
+
+/**
+ * Daytona sandbox starts are control-plane transitions, not execution work.
+ * Keep their admission independent from Absurd worker slots so a run burst can
+ * still multiplex started sandboxes without stampeding the provider's create
+ * transition. A permit covers timeout reconciliation too: releasing it when
+ * `create` times out would admit another create while the first named sandbox
+ * is still transitioning, recreating the unsafe overlap this gate prevents.
+ */
+export function createDaytonaSandboxStartAdmission(
+  concurrency =
+    RUNTIME_CAPACITY_POLICY.sandboxAcquisition
+      .daytonaConcurrentStartsPerProcess,
+): DaytonaSandboxStartAdmission {
+  if (!Number.isInteger(concurrency) || concurrency <= 0) {
+    throw new Error(
+      'Daytona sandbox-start concurrency must be a positive integer.',
+    );
+  }
+
+  let active = 0;
+  const waiters: Array<(release: () => void) => void> = [];
+
+  const createRelease = (): (() => void) => {
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      const next = waiters.shift();
+      if (next) {
+        // Transfer the occupied permit directly. Keeping `active` unchanged
+        // prevents a new eager caller from jumping ahead of the FIFO waiter.
+        next(createRelease());
+        return;
+      }
+      active -= 1;
+    };
+  };
+
+  return {
+    async run<T>(operation: () => Promise<T>): Promise<T> {
+      // Preserve eager prepare semantics when capacity is free: the provider
+      // create begins in this turn, just as it did before admission existed.
+      // Only contended callers cross an asynchronous queue boundary.
+      const release =
+        active < concurrency
+          ? (() => {
+              active += 1;
+              return createRelease();
+            })()
+          : await new Promise<() => void>((resolve) => waiters.push(resolve));
+      try {
+        return await operation();
+      } finally {
+        release();
+      }
+    },
+  };
+}
+
+/** One admission queue per worker process; all run slots share it. */
+export const daytonaSandboxStartAdmission =
+  createDaytonaSandboxStartAdmission();

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/backends/daytona.ts

@@ -43,6 +43,7 @@ import {
   prepareDetachedDaytonaRunner,
 } from './daytona-session-execution';
 import { RUNTIME_RELIABILITY_POLICY } from '../../runtime-reliability-policy';
+import { daytonaSandboxStartAdmission } from './daytona-start-admission';
 
 const DAYTONA_COMMAND_RECOVERY_TIMEOUT_MS =
   RUNTIME_RELIABILITY_POLICY.sandbox.daytonaCommandRecoveryTimeoutMs;
@@ -973,6 +974,7 @@ function prepareDaytonaExecution(
           callbacks.reserveSandboxCapacity!('daytona', providerAttempt)
       : undefined,
     releaseSandboxCapacity: callbacks?.releaseSandboxCapacity,
+    startAdmission: daytonaSandboxStartAdmission,
   });
   return {
     kind: 'daytona',

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/runtime-sandbox-reconciliation.ts

@@ -11,6 +11,7 @@ import type { DetachedRunnerSuspension } from '../suspension';
 export type RuntimeSandboxProviderId = 'daytona' | 'modal';
 
 export type RuntimeSandboxRef = {
+  /** Frozen at 1: persisted in suspension_json, so readers must keep taking 1. */
   schemaVersion: 1;
   provider: RuntimeSandboxProviderId;
   resourceId: string;

package/dist/bundling-sources/shared_libs/play-runtime/runtime-api.ts

@@ -3361,8 +3361,8 @@ async function writeRuntimeRows(
         const insertedRowsCte =
           input.mode === 'upsert'
             ? `inserted_rows AS (
-                INSERT INTO ${sheetTable(session)} (_key, _status, _run_id, _input_index${physicalInsertColumnsSql})
-                SELECT _key, 'pending', $4::text, _input_index${physicalInsertValuesSql}
+                INSERT INTO ${sheetTable(session)} (_key, _status, _run_id, _input_index, _created_at${physicalInsertColumnsSql})
+                SELECT _key, 'pending', $4::text, _input_index, now()${physicalInsertValuesSql}
                 FROM input_rows
                 ON CONFLICT (_key) DO UPDATE SET
                   _status = 'pending',
@@ -3374,8 +3374,8 @@ async function writeRuntimeRows(
                 RETURNING _key
               ),`
             : `inserted_rows AS (
-                INSERT INTO ${sheetTable(session)} (_key, _status, _run_id, _input_index${physicalInsertColumnsSql})
-                SELECT _key, 'pending', $4::text, _input_index${physicalInsertValuesSql}
+                INSERT INTO ${sheetTable(session)} (_key, _status, _run_id, _input_index, _created_at${physicalInsertColumnsSql})
+                SELECT _key, 'pending', $4::text, _input_index, now()${physicalInsertValuesSql}
                 FROM input_rows
                 RETURNING _key
               ),`;
@@ -3660,8 +3660,8 @@ async function prepareRuntimeSheetDatasetRows(
           RETURNING target._key
         ),
         inserted_rows AS (
-          INSERT INTO ${sheetTable(session)} (_key, _status, _run_id, _input_index, _attempt_id, _attempt_owner_run_id, _attempt_expires_at, _attempt_seq, _write_version, _writer_run_id${input.physicalInsertColumnsSql})
-          SELECT _key, 'pending', $4::text, _input_index, $7::text, $8::text, $9::timestamptz, $10::integer, $12::bigint, $4::text${input.physicalInsertValuesSql}
+          INSERT INTO ${sheetTable(session)} (_key, _status, _run_id, _input_index, _attempt_id, _attempt_owner_run_id, _attempt_expires_at, _attempt_seq, _write_version, _writer_run_id, _created_at${input.physicalInsertColumnsSql})
+          SELECT _key, 'pending', $4::text, _input_index, $7::text, $8::text, $9::timestamptz, $10::integer, $12::bigint, $4::text, now()${input.physicalInsertValuesSql}
           FROM input_rows
           ON CONFLICT (_key) DO UPDATE SET
             _status = 'pending',
@@ -3991,9 +3991,9 @@ async function prepareNetNewRuntimeSheetDatasetRows(
        inserted_rows AS (
          INSERT INTO ${sheetTable(session)}
          (_key, _status, _run_id, _input_index, _attempt_id, _attempt_owner_run_id,
-          _attempt_expires_at, _attempt_seq, _write_version, _writer_run_id${input.physicalInsertColumnsSql})
+          _attempt_expires_at, _attempt_seq, _write_version, _writer_run_id, _created_at${input.physicalInsertColumnsSql})
        SELECT _key, 'pending', $4::text, _input_index, $5::text, $6::text,
-              $7::timestamptz, $8::integer, $9::bigint, $4::text${input.physicalInsertValuesSql}
+              $7::timestamptz, $8::integer, $9::bigint, $4::text, now()${input.physicalInsertValuesSql}
        FROM input_rows
        ON CONFLICT (_key) DO NOTHING
        RETURNING _key
@@ -7642,6 +7642,7 @@ async function insertMissingCompletedMapRowChunks(
            _attempt_owner_run_id,
            _attempt_expires_at,
            _attempt_seq,
+           _created_at,
            _cell_meta${physicalInsertColumnsSql}
          )
          SELECT _key,
@@ -7652,6 +7653,7 @@ async function insertMissingCompletedMapRowChunks(
                 $9::text,
                 $10::timestamptz,
                 $11::integer,
+                now(),
                 cell_meta_patch${physicalInsertValuesSql}
            FROM missing_rows
          ON CONFLICT (_key) DO NOTHING

package/dist/bundling-sources/shared_libs/play-runtime/runtime-capacity-policy.ts

@@ -26,6 +26,14 @@ export const RUNTIME_CAPACITY_POLICY = {
     claimOperationTimeoutMs: 20_000,
     requestTimeoutMs: 30_000,
   },
+  sandboxAcquisition: {
+    /**
+     * Starting a Daytona sandbox is a provider control-plane transition, not
+     * an Absurd execution slot. Serialize starts within each worker process;
+     * once started, all eight execution slots may run concurrently.
+     */
+    daytonaConcurrentStartsPerProcess: 1,
+  },
 } as const;
 
 export const ABSURD_GLOBAL_RUN_CONCURRENCY =
@@ -96,6 +104,18 @@ function nonNegativeNumber(value: number): number {
 }
 
 export function assertRuntimeCapacityPolicy(): void {
+  if (
+    !Number.isInteger(
+      RUNTIME_CAPACITY_POLICY.sandboxAcquisition
+        .daytonaConcurrentStartsPerProcess,
+    ) ||
+    RUNTIME_CAPACITY_POLICY.sandboxAcquisition
+      .daytonaConcurrentStartsPerProcess <= 0
+  ) {
+    throw new Error(
+      'Daytona sandbox-start concurrency must be a positive integer.',
+    );
+  }
   if (
     RUNTIME_CAPACITY_POLICY.receiptGateway.requestTimeoutMs <=
     RUNTIME_CAPACITY_POLICY.receiptGateway.admissionTimeoutMs

package/dist/bundling-sources/shared_libs/play-runtime/runtime-contract.ts

@@ -3,11 +3,17 @@
  * receipt presentations. New operations must not use this as a version gate.
  */
 export const LEGACY_RUNTIME_RECEIPT_WIRE_HEADER = 'x-deepline-runtime-contract';
+// Frozen: production lane main-9281ae259f still sends wire format 2. Delete
+// this and `resolveLegacyRuntimeReceiptWireFormat` after that lane retires.
 export const LEGACY_RUNTIME_RECEIPT_WIRE_FORMAT = 3 as const;
 /**
  * Historical workers validate this readiness range before they claim work.
  * It is an output-only compatibility presentation; current callers use named
  * operation capabilities and do not treat it as a global admission contract.
+ *
+ * Frozen: a lane built before the global compatibility gate was removed calls
+ * /readyz at boot and throws when this range is absent. Delete after every such
+ * lane has retired.
  */
 export const LEGACY_RUNTIME_READINESS_MIN_SUPPORTED = 1 as const;
 export const LEGACY_RUNTIME_READINESS_CURRENT = 6 as const;

package/dist/bundling-sources/shared_libs/play-runtime/runtime-scheduler-topology.ts

@@ -12,6 +12,30 @@
  */
 export const PROD_DEFAULT_RUNTIME_SCHEDULER_SCHEMA = 'runtime_scheduler';
 
+/** A wire-safe Postgres schema name that identifies one runtime topology. */
+export const RUNTIME_SCHEDULER_SCHEMA_RE = /^[a-z_][a-z0-9_]{0,62}$/;
+
+export function normalizeRuntimeSchedulerSchema(value: unknown): string | null {
+  if (typeof value !== 'string') return null;
+  const schema = value.trim();
+  return RUNTIME_SCHEDULER_SCHEMA_RE.test(schema) ? schema : null;
+}
+
+/**
+ * The one release-id shape. A release id is minted by the release controller
+ * and doubles as the lane's queue suffix (`runs_<releaseId>`) and the
+ * `DEEPLINE_RUNTIME_DEPLOY_VERSION` on every Machine in the lane, so it must be
+ * a stable lowercase engine-safe slug: no uppercase, no underscore, no repeated
+ * or trailing hyphen, 6 to 64 characters.
+ *
+ * It lives here, dependency-free, because the Fly lane operator, the release
+ * controller, the internal registry route, and the admin routes must all agree
+ * on it — a second copy is how one surface silently starts accepting an id the
+ * queue cannot name.
+ */
+export const ABSURD_RELEASE_ID_RE =
+  /^[a-z0-9](?:[a-z0-9]|-(?=[a-z0-9])){5,63}$/;
+
 /**
  * True when the scheduler schema names an isolated (preview CI / worktree)
  * topology. Null/empty/prod-default => false (production topology). Callers

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backend.ts

@@ -41,10 +41,36 @@ export type { PlayRunInputPayload };
 
 export type PlaySchedulerSubmitInput = {
   runId: string;
+  /** First-class async-child lineage. Absent for root launches. */
+  parentRunId?: string | null;
+  rootRunId?: string | null;
+  asyncLaunchKey?: string | null;
+  asyncInvocationKey?: string | null;
+  asyncRequestFingerprint?: string | null;
+  /** Full play ancestry for a scheduled child, including this play. */
+  asyncAncestryPlayIds?: string[] | null;
   playId: string;
   playName: string;
+  playReference?: string | null;
+  /**
+   * Immutable scheduler namespace for this admission. The durable
+   * `run.created` projector persists it onto the Play Run so replay/control
+   * paths stay on the original runtime lane instead of falling back to a host
+   * default.
+   */
+  schedulerSchema?: string | null;
+  definitionScope?: 'org' | 'system' | null;
+  revisionId?: string | null;
   workflowFamilyKey?: string | null;
   artifactStorageKey: string;
+  /**
+   * The runtime PostgreSQL admission path committed this launch before its
+   * Convex `run.created` projection exists. The worker must deliver that
+   * causal fact before it can claim an execution attempt.
+   *
+   * Omitted for legacy launches whose Play Run row was persisted synchronously.
+   */
+  requiresRunCreatedProjection?: boolean;
   /** Optional inline artifact for the Node scheduler. */
   runtimeArtifact?: unknown;
   artifactHash: string;
@@ -52,6 +78,9 @@ export type PlaySchedulerSubmitInput = {
   /** Immutable scheduler/worker/runner ABI snapshot (not a Git SHA). */
   runtimeProtocolVersion?: PlayRuntimeProtocolVersion | null;
   input: PlayRunInputPayload;
+  /** Bounded launch metadata used only by the asynchronous ledger projector. */
+  staticPipeline?: unknown;
+  inputSummary?: Record<string, unknown>;
   /** Convex metadata for the exact input saved before scheduler submission. */
   inputFileId?: string;
   inputBytes?: number;
@@ -127,7 +156,7 @@ export type PlaySchedulerSubmitInput = {
   userId?: string | null;
   source?: 'published' | 'ad_hoc' | 'draft';
   /** Invocation origin, distinct from the artifact source above. */
-  triggerSource?: 'api' | 'webhook' | 'cron' | 'sql_listener';
+  triggerSource?: 'api' | 'webhook' | 'cron' | 'sql_listener' | 'async_child';
   /** Null lets a durable trigger wait for capacity; a number bounds queue delay. */
   queueMaxDelaySeconds?: number | null;
   /**

package/dist/bundling-sources/shared_libs/plays/artifact-types.ts

@@ -20,10 +20,13 @@ export type PlayRuntimeFeature =
   | 'packaged_files';
 
 export type PlayArtifactCompatibility = {
-  apiVersion: number;
+  /** Historical marker carried by stored artifacts. Nothing branches on it. */
+  apiVersion?: number;
   artifactVersion: number;
-  minRunnerVersion: number;
-  runtimeFeatures: PlayRuntimeFeature[];
+  /** Historical marker carried by stored artifacts. Every runner reads every artifact. */
+  minRunnerVersion?: number;
+  /** Historical marker carried by stored artifacts. Capabilities are named per operation. */
+  runtimeFeatures?: PlayRuntimeFeature[];
   runtimeBackend?: string | null;
   /** Missing preserves the legacy schema used before this field existed. */
   toolErrorSchemaVersion?: ToolExecutionErrorSchemaVersion;

package/dist/bundling-sources/shared_libs/plays/authoring-contract.ts

@@ -7,10 +7,10 @@ import type { ToolExecutionErrorSchemaVersion } from './tool-execution-error';
 import type { PlayDataset, PlayDatasetInput, PlayDatasetRow } from './dataset';
 
 export const LEGACY_PLAY_AUTHORING_CONTRACT_EDITION = 1 as const;
-export const PLAY_AUTHORING_CONTRACT_EDITION = 6 as const;
+export const PLAY_AUTHORING_CONTRACT_EDITION = 7 as const;
 export const PLAY_AUTHORING_INPUT_SCHEMA_SNAPSHOT_EDITION = 3 as const;
 export const SUPPORTED_PLAY_AUTHORING_CONTRACT_EDITIONS = [
-  1, 2, 3, 4, 5, 6,
+  1, 2, 3, 4, 5, 6, 7,
 ] as const;
 
 export type PlayAuthoringContractEdition =
@@ -67,6 +67,14 @@ export const PLAY_AUTHORING_CONTRACT_CHANGELOG = [
     newWritesEnd: null,
     readerRemoval: null,
   },
+  {
+    edition: 7,
+    changed:
+      'Slack HITL calls that omit timeout wait one week. Editions 1–6 retain the historical 24-hour default.',
+    compatibilityOwner: 'Plays Runtime',
+    newWritesEnd: null,
+    readerRemoval: null,
+  },
 ] as const;
 
 /**
@@ -917,6 +925,8 @@ export type PlayAuthoringDefinedPlay<
     readonly runtime?: PlayAuthoringBindings<TInput>['runtime'];
     readonly compatibility?: PlayAuthoringBindings<TInput>['compatibility'];
     readonly playName: string;
+    /** Type-only input carrier used by typed Play-reference consumers. */
+    readonly __inputType?: TInput;
   };
 
 /** Canonical resolver shape for a customer-authored durable step. */
@@ -1153,20 +1163,14 @@ export type PlayAuthoringDatasetBuilder<
     TContext
   >;
   /** Add all columns declared by one reusable step program. */
-  withColumns<
-    Program extends PlayAuthoringStepProgram<
+  withColumns<ProgramOutput extends OutputRow, Return>(
+    program: PlayAuthoringStepProgram<
       OutputRow,
-      object,
+      ProgramOutput,
       TContext,
-      unknown
+      Return
     >,
-  >(
-    program: Program,
-  ): PlayAuthoringDatasetBuilder<
-    InputRow,
-    PlayAuthoringStepProgramOutput<Program>,
-    TContext
-  >;
+  ): PlayAuthoringDatasetBuilder<InputRow, ProgramOutput, TContext>;
   /** @deprecated Dataset `.step(...)` was replaced by `.withColumn(...)`. */
   step<Name extends string, Value>(
     name: Name,
@@ -1183,9 +1187,34 @@ export type PlayAuthoringDatasetBuilder<
   ): Promise<PlayDataset<OutputRow>>;
 };
 
-export type PlayAuthoringReferenceLike =
+export type PlayAuthoringReferenceLike<
+  TInput extends Record<string, unknown> = Record<string, unknown>,
+> = (
   | { readonly playName: string; readonly name?: string }
-  | { readonly name: string; readonly playName?: string };
+  | { readonly name: string; readonly playName?: string }
+) & {
+  /** Type-only input carrier used by ctx.runPlayAsync. */
+  readonly __inputType?: TInput;
+};
+
+declare const PLAY_RUN_ID_BRAND: unique symbol;
+
+/** Branded run identity returned inside {@link AsyncPlayRunRef}. */
+export type PlayRunId = string & {
+  readonly [PLAY_RUN_ID_BRAND]: 'PlayRunId';
+};
+
+/**
+ * Serializable reference returned after an async child Run is durable.
+ * @sdkReference runtime 143 AsyncPlayRunRef
+ */
+export type AsyncPlayRunRef = Readonly<{
+  runId: PlayRunId;
+}>;
+
+export type PlayAuthoringAsyncCallOptions = Readonly<{
+  description: string;
+}>;
 
 /** Discoverable, non-deprecated Runtime Context members shown to Play authors. */
 export const PLAY_AUTHORING_RUNTIME_CONTEXT_MEMBERS = [
@@ -1196,6 +1225,7 @@ export const PLAY_AUTHORING_RUNTIME_CONTEXT_MEMBERS = [
   'log',
   'run',
   'runPlay',
+  'runPlayAsync',
   'runSteps',
   'secrets',
   'sleep',
@@ -1541,6 +1571,27 @@ export interface PlayAuthoringRuntimeContext {
     options: PlayAuthoringCallOptions,
   ): Promise<TOutput>;
 
+  /**
+   * Admit an independent scalar Play Run and return its durable identity after scheduler admission, before child completion.
+   * @sdkReference runtime 141 ctx.runPlayAsync(key, playRef, input, options)
+   */
+  runPlayAsync<TInput extends Record<string, unknown>>(
+    /** Replay-stable identity for this launch site and row scope. */
+    key: string,
+    /** Independently published Play name or definePlay handle carrying its input type. */
+    playRef: PlayAuthoringReferenceLike<TInput>,
+    /** Input checked against the referenced definePlay handle when available. */
+    input: NoInfer<TInput>,
+    /** Human-readable launch purpose recorded in the parent's step history. */
+    options: PlayAuthoringAsyncCallOptions,
+  ): Promise<AsyncPlayRunRef>;
+  runPlayAsync(
+    key: string,
+    playRef: string,
+    input: Record<string, unknown>,
+    options: PlayAuthoringAsyncCallOptions,
+  ): Promise<AsyncPlayRunRef>;
+
   /**
    * Write a customer-safe line to the durable Run Log Stream. Omitting level
    * preserves the historical info-level behavior.
@@ -2600,6 +2651,84 @@ export const PLAY_AUTHORING_FIELD_REGISTRY = {
     errorMessage:
       'ctx.runPlay timeoutMs is unsupported because child Plays execute inline.',
   },
+  'ctx.runPlayAsync.key': {
+    schema: Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: 'request-approval',
+      invalid: '',
+      absent: undefined,
+      unresolved: { expression: 'callKey' },
+      edition1: 'request-approval',
+    },
+    referenceType: 'string',
+    required: true,
+    resolution: 'runtime-dynamic',
+    issueCode: 'play_authoring_run_play_option_invalid',
+    description: 'Stable identity for one independent child Play Run.',
+    errorMessage: 'ctx.runPlayAsync key must be a non-empty string.',
+  },
+  'ctx.runPlayAsync.playRef': {
+    schema: Type.Union([
+      Type.String({ minLength: 1 }),
+      Type.Union([
+        Type.Object(
+          { playName: Type.String({ minLength: 1 }) },
+          { additionalProperties: true },
+        ),
+        Type.Object(
+          { name: Type.String({ minLength: 1 }) },
+          { additionalProperties: true },
+        ),
+      ]),
+    ]),
+    fixtures: {
+      valid: 'request-approval',
+      invalid: {},
+      absent: undefined,
+      unresolved: { expression: 'playRef' },
+      edition1: 'request-approval',
+    },
+    referenceType: 'string | PlayReferenceLike',
+    required: true,
+    resolution: 'runtime-dynamic',
+    issueCode: 'play_authoring_run_play_option_invalid',
+    description:
+      'Independently published scalar child Play name or strongly typed definition handle.',
+    errorMessage:
+      'ctx.runPlayAsync playRef must be a non-empty Play name or definition handle.',
+  },
+  'ctx.runPlayAsync.input': {
+    schema: Type.Record(Type.String(), Type.Unknown()),
+    fixtures: {
+      valid: { draftId: 'draft-1' },
+      invalid: 'draft-1',
+      absent: undefined,
+      unresolved: 'childInput',
+      edition1: {},
+    },
+    referenceType: 'Record<string, unknown>',
+    required: true,
+    resolution: 'runtime-dynamic',
+    issueCode: 'play_authoring_run_play_option_invalid',
+    description: 'Scalar input object submitted to the independent child Run.',
+    errorMessage: 'ctx.runPlayAsync input must be an object.',
+  },
+  'ctx.runPlayAsync.options.description': {
+    schema: Type.String({ minLength: 1 }),
+    fixtures: {
+      valid: 'Request approval.',
+      invalid: '',
+      absent: undefined,
+      unresolved: { expression: 'description' },
+      edition1: 'Request approval.',
+    },
+    referenceType: 'string',
+    required: true,
+    resolution: 'runtime-dynamic',
+    issueCode: 'play_authoring_run_play_option_invalid',
+    description: 'Non-empty purpose for one independent child Play Run.',
+    errorMessage: 'ctx.runPlayAsync options.description must be non-empty.',
+  },
   'runtime.timeout': {
     schema: Type.String({ pattern: '^\\d+\\s*[mh]$' }),
     fixtures: {
@@ -3049,6 +3178,10 @@ export const PLAY_AUTHORING_CLOUD_TYPE_DECLARATIONS = [
   `export type CsvOptions = { description?: ${cloudReferenceType('ctx.csv.options.description')}; columns?: ${cloudReferenceType('ctx.csv.options.columns')}; rename?: ${cloudReferenceType('ctx.csv.options.rename')}; required?: ${cloudReferenceType('ctx.csv.options.required')} };`,
   "export type PlayCallExecution = 'inline';",
   `export type PlayCallOptions = { description: ${cloudReferenceType('ctx.runPlay.options.description')}; execution?: ${cloudReferenceType('ctx.runPlay.options.execution')}; timeoutMs?: ${cloudReferenceType('ctx.runPlay.options.timeoutMs')} };`,
+  `export type PlayAsyncCallOptions = { description: ${cloudReferenceType('ctx.runPlayAsync.options.description')} };`,
+  'declare const PLAY_RUN_ID_BRAND: unique symbol;',
+  "export type PlayRunId = string & { readonly [PLAY_RUN_ID_BRAND]: 'PlayRunId' };",
+  'export type AsyncPlayRunRef = Readonly<{ runId: PlayRunId }>;',
   `export type RuntimeStepOptions = { semanticKey?: ${cloudReferenceType('ctx.step.semanticKey')}; staleAfterSeconds?: ${cloudReferenceType('ctx.step.staleAfterSeconds')} };`,
   `export type FetchOptions = { staleAfterSeconds?: ${cloudReferenceType('ctx.fetch.staleAfterSeconds')}; transient?: boolean };`,
   'export type PlayFetchResponse = { ok: boolean; status: number; statusText: string; url: string; headers: Record<string, string>; bodyText: string; json: unknown | null };',
@@ -3074,11 +3207,11 @@ export const PLAY_AUTHORING_CLOUD_TYPE_DECLARATIONS = [
   '  withColumn<Name extends string, Value>(name: Name, definition: DatasetColumnDefinition<OutputRow, Value> & { readonly runIf: (row: OutputRow, index: number) => boolean | Promise<boolean> }): DatasetBuilder<InputRow, OutputRow & Record<Name, Value | null>>;',
   '  withColumn<Name extends string, Value>(name: Name, definition: DatasetColumnDefinition<OutputRow, Value>): DatasetBuilder<InputRow, OutputRow & Record<Name, Value>>;',
   '  withColumn<Name extends string, Value>(name: Name, resolver: StepResolver<OutputRow, Value> | RunnableColumnStepProgram<Value>, options: StepOptions<OutputRow, Value>): DatasetBuilder<InputRow, OutputRow & Record<Name, Value | null>>;',
-  '  withColumns<Program extends StepProgram<OutputRow, object, unknown>>(program: Program): DatasetBuilder<InputRow, StepProgramOutput<Program>>;',
+  '  withColumns<ProgramOutput extends OutputRow, Return>(program: StepProgram<OutputRow, ProgramOutput, Return>): DatasetBuilder<InputRow, ProgramOutput>;',
   '  step<Name extends string, Value>(name: Name, resolver: ColumnResolver<OutputRow, Value>): never;',
   '  run(options?: DatasetRunOptions<InputRow>): Promise<PlayDataset<OutputRow>>;',
   '};',
-  'export type PlayReferenceLike = { readonly playName: string; readonly name?: string } | { readonly name: string; readonly playName?: string };',
+  'export type PlayReferenceLike<TInput extends Record<string, unknown> = Record<string, unknown>> = ({ readonly playName: string; readonly name?: string } | { readonly name: string; readonly playName?: string }) & { readonly __inputType?: TInput };',
   'export interface DeeplinePlayRuntimeContext {',
   '  csv<T = Record<string, unknown>>(path: string | CsvInput<T & object>, options?: CsvOptions): Promise<PlayDataset<T>>;',
   '  dataset<TSource extends PlayDatasetInput<object>>(key: string, items: TSource): DatasetBuilder<PlayDatasetRow<TSource> & object, PlayDatasetRow<TSource> & object>;',
@@ -3092,6 +3225,8 @@ export const PLAY_AUTHORING_CLOUD_TYPE_DECLARATIONS = [
   "  fetch(key: string, url: string | URL, init?: RequestInit & { headers?: HeadersInit & { 'Idempotency-Key'?: string; 'X-Idempotency-Key'?: string }; auth?: SecretAuthInput }, options?: FetchOptions): Promise<PlayFetchResponse>;",
   '  secrets: { get(name: string): SecretPromise; bearer(secret: string | SecretPromise | SecretHandle): SecretAuth; header(header: string, secret: string | SecretPromise | SecretHandle): SecretAuth };',
   `  runPlay<TOutput = unknown>(key: string, playRef: ${cloudReferenceType('ctx.runPlay.playRef')}, input: ${cloudReferenceType('ctx.runPlay.input')}, options: PlayCallOptions): Promise<TOutput>;`,
+  '  runPlayAsync<TInput extends Record<string, unknown>>(key: string, playRef: PlayReferenceLike<TInput>, input: NoInfer<TInput>, options: PlayAsyncCallOptions): Promise<AsyncPlayRunRef>;',
+  '  runPlayAsync(key: string, playRef: string, input: Record<string, unknown>, options: PlayAsyncCallOptions): Promise<AsyncPlayRunRef>;',
   "  log(message: string, options?: { level?: 'debug' | 'info' | 'warn' | 'error' }): void;",
   `  sleep(ms: ${cloudReferenceType('ctx.sleep.ms')}): Promise<void>;`,
   '}',

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

@@ -63,7 +63,7 @@ import { PLAY_AUTHORING_CONTRACT_EDITION } from '../authoring-contract';
 // of the artifact bytes. Do not reuse a local bundle cached before either
 // compatibility selection or docflow instrumentation entered graph analysis.
 // Keep this aligned with the app and SDK adapters' cache namespace.
-const PLAY_BUNDLE_CACHE_VERSION = 36;
+const PLAY_BUNDLE_CACHE_VERSION = 37;
 const PLAY_ARTIFACT_CACHE_DIR = join(
   tmpdir(),
   `deepline-play-artifacts-v${PLAY_BUNDLE_CACHE_VERSION}`,
@@ -122,7 +122,12 @@ export type PlayLocalFileDiscoveryResult = {
 
 export type PlayBundlingAdapter = {
   projectRoot: string;
-  /** Optional root used only to make source-graph identity independent of temporary absolute paths. */
+  /**
+   * Optional root that makes the artifact independent of where it was built:
+   * source paths in the graph hash and esbuild's working directory (which it
+   * writes into every module-header comment, and so into `artifactHash`) are
+   * both taken relative to it instead of to the build's absolute location.
+   */
   sourceIdentityRoot?: string;
   nodeModulesDir: string;
   cacheDir?: string;
@@ -2247,6 +2252,7 @@ async function runEsbuildForCjsNode(
   importedPlayDependencies: ImportedPlayDependency[],
   adapter: PlayBundlingAdapter,
   exportName: string,
+  bundleRoot: string,
 ): Promise<EsbuildBundleOutput | string[]> {
   const sdkAliasPlugin = localSdkAliasPlugin(adapter);
   const playProxyPlugin = importedPlayProxyPlugin(importedPlayDependencies);
@@ -2269,7 +2275,14 @@ async function runEsbuildForCjsNode(
           },
         }
       : { entryPoints: [entryFile] }),
-    absWorkingDir: adapter.projectRoot,
+    // esbuild writes `// <path relative to absWorkingDir>` above every module
+    // it inlines, and artifactHash is sha256 of those bytes. Rooting the build
+    // at the identity root keeps the customer's own files repo-relative, so a
+    // deploy worker building the same commit in a fresh temp directory each
+    // time produces the same bytes. Files outside the root (the SDK on the
+    // worker image) come out as a `..`-prefixed path whose shape depends only
+    // on the image's layout, which is fixed, not on the build's name.
+    absWorkingDir: bundleRoot,
     bundle: true,
     format: 'cjs',
     nodePaths: [adapter.nodeModulesDir],
@@ -2416,12 +2429,14 @@ export async function bundlePlayFile(
       };
     }
 
+    const bundleRoot = resolve(sourceIdentityRoot ?? adapter.projectRoot);
     const buildOutcome = await runEsbuildForCjsNode(
       absolutePath,
       analysis.importPolicy.localFiles,
       analysis.importedPlayDependencies,
       adapter,
       exportName,
+      bundleRoot,
     );
     if (Array.isArray(buildOutcome)) {
       return {
@@ -2434,7 +2449,7 @@ export async function bundlePlayFile(
 
     const normalizedSourceMap = normalizeSourceMapForRuntime(
       sourceMapText,
-      resolve(adapter.projectRoot),
+      bundleRoot,
     );
     const virtualBaseName =
       exportName === 'default'