deepline 0.3.89 → 0.3.91

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

@@ -0,0 +1,67 @@
+import {
+  deployed,
+  type DeployedOperationContract,
+} from '@deepline/deployed-contracts';
+import type { RuntimeExecutionCapability } from './execution-capabilities';
+
+/**
+ * One declarative owner for the runtime action → authority relationship. The
+ * route still owns authentication and execution; callers can add an action in
+ * one obvious place and CI will prevent removing/changing an existing one.
+ */
+export const RUNTIME_OPERATION_CAPABILITIES = {
+  create_signed_artifact_url: 'artifact.read',
+  resolve_play: 'artifact.read',
+  create_signed_staged_file_url: 'file.read',
+  get_runtime_step_receipt: 'receipt.read',
+  get_runtime_step_receipts: 'receipt.read',
+  acquire_runtime_receipt_execution_lock: 'receipt.write',
+  release_runtime_receipt_execution_lock: 'receipt.write',
+  claim_runtime_step_receipt: 'receipt.write',
+  claim_runtime_step_receipts: 'receipt.write',
+  mark_runtime_step_receipt_running: 'receipt.write',
+  mark_runtime_step_receipts_running: 'receipt.write',
+  mark_runtime_step_receipts_queued: 'receipt.write',
+  complete_runtime_step_receipt: 'receipt.write',
+  complete_runtime_step_receipts: 'receipt.write',
+  release_runtime_step_receipt: 'receipt.write',
+  fail_runtime_step_receipt: 'receipt.write',
+  fail_runtime_step_receipts: 'receipt.write',
+  heartbeat_runtime_step_receipts: 'receipt.write',
+  skip_runtime_step_receipt: 'receipt.write',
+  ensure_sheet: 'sheet.write',
+  apply_row_updates: 'sheet.write',
+  create_db_session: 'db.session',
+  repair_runtime_storage_grants: 'sheet.write',
+  append_run_events: 'run.progress',
+  save_results: 'run.progress',
+  start_run: 'run.progress',
+  record_first_claim_latency: 'run.progress',
+  project_run_created: 'run.progress',
+  launch_play_async: 'run.child',
+  compute_billing_upsert: 'billing.write',
+  compute_billing_record_item: 'billing.write',
+  compute_billing_finalize: 'billing.write',
+  rate_state_acquire: 'rate.acquire',
+  rate_state_release: 'rate.acquire',
+  rate_state_penalize: 'rate.acquire',
+  get_runtime_traffic_policy: 'rate.acquire',
+  governor_budget_charge: 'budget.charge',
+  resolve_secret: 'secret.resolve',
+} as const satisfies Readonly<Record<string, RuntimeExecutionCapability>>;
+
+export const RUNTIME_OPERATION_CONTRACT: DeployedOperationContract =
+  deployed.operation({
+    id: 'runtime-api-actions',
+    actions: RUNTIME_OPERATION_CAPABILITIES,
+  });
+
+export function runtimeOperationCapability(
+  action: string,
+): RuntimeExecutionCapability | null {
+  return (
+    RUNTIME_OPERATION_CAPABILITIES[
+      action as keyof typeof RUNTIME_OPERATION_CAPABILITIES
+    ] ?? null
+  );
+}

package/dist/bundling-sources/shared_libs/play-runtime/runtime-release-environment.ts

@@ -0,0 +1,2 @@
+/** Runtime estate owning one attested Runtime Release Bundle. */
+export type RuntimeReleaseEnvironment = 'preview' | 'production';

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

@@ -0,0 +1,68 @@
+import { deployed, readDeployedObject } from '@deepline/deployed-contracts';
+
+export type RuntimeSandboxProviderId = 'daytona' | 'modal';
+
+export type RuntimeSandboxRef = {
+  /** Internal normalized form; persisted writer markers are diagnostic only. */
+  schemaVersion: 1;
+  provider: RuntimeSandboxProviderId;
+  resourceId: string;
+  routingDomain: string | null;
+};
+
+/**
+ * This ref lives in a durable suspension. Its provider and resource identity
+ * fence cleanup; its writer marker never decides whether a known sandbox can
+ * be reconciled by a different deployment.
+ */
+export const RUNTIME_SANDBOX_REF_CONTRACT = deployed.object({
+  id: 'runtime-sandbox-ref',
+  unknown: 'preserve',
+  fields: {
+    provider: deployed.openEnum(),
+    resourceId: deployed.string(),
+    routingDomain: deployed.json(),
+    schemaVersion: deployed.optional(deployed.diagnostic.number(), {
+      whenAbsent: 'diagnostic unavailable',
+    }),
+  },
+});
+
+export function readPersistedRuntimeSandboxRef(input: {
+  raw: unknown;
+  expectedSandboxId: string;
+  expectedProvider?: unknown;
+}): RuntimeSandboxRef {
+  const invalid = () =>
+    new Error(
+      `Persisted Runtime Sandbox Ref is invalid or inconsistent for sandbox ${input.expectedSandboxId}.`,
+    );
+  let value: Record<string, unknown>;
+  try {
+    value = readDeployedObject(RUNTIME_SANDBOX_REF_CONTRACT, input.raw).value;
+  } catch {
+    throw invalid();
+  }
+  const provider = value.provider;
+  const resourceId =
+    typeof value.resourceId === 'string' ? value.resourceId.trim() : '';
+  const routingDomain = value.routingDomain;
+  if (
+    (provider !== 'daytona' && provider !== 'modal') ||
+    !resourceId ||
+    resourceId !== input.expectedSandboxId.trim() ||
+    (routingDomain !== null && typeof routingDomain !== 'string') ||
+    (typeof routingDomain === 'string' && !routingDomain.trim()) ||
+    (input.expectedProvider !== undefined &&
+      input.expectedProvider !== provider)
+  ) {
+    throw invalid();
+  }
+  return {
+    schemaVersion: 1,
+    provider,
+    resourceId,
+    routingDomain:
+      typeof routingDomain === 'string' ? routingDomain.trim() : null,
+  };
+}

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

@@ -1,6 +1,6 @@
 /**
  * Runtime-scheduler topology predicate shared by the app-side lane helpers
- * (`src/lib/plays/scheduler-backends/absurd-shared.ts`) and the runner
+ * (`packages/play-runtime/scheduler-backends/absurd-shared.ts`) and the runner
  * backends (`runner-backends/backends/daytona-lifecycle.ts`).
  *
  * ONE distinction drives several guards: a run whose scheduler schema is the
@@ -8,7 +8,7 @@
  * production egress policy), while any other schema is an ISOLATED topology —
  * a per-PR preview fleet or a per-worktree dev fleet running synthetic
  * internal test plays. Keeping the predicate here (dependency-free) lets
- * shared_libs code use it without importing the app-side scheduler stack.
+ * package code uses it without importing the app-side scheduler stack.
  */
 export const PROD_DEFAULT_RUNTIME_SCHEDULER_SCHEMA = 'runtime_scheduler';
 
@@ -48,3 +48,15 @@ export function isIsolatedRuntimeSchedulerSchema(
   const schema = schedulerSchema?.trim();
   return Boolean(schema) && schema !== PROD_DEFAULT_RUNTIME_SCHEDULER_SCHEMA;
 }
+
+/**
+ * PostgreSQL LISTEN only improves wake-up latency; durable polling owns
+ * correctness. Isolated schemas deliberately share a small direct-connection
+ * budget across preview workers, so they use that polling path and leave
+ * direct sessions to the production topology.
+ */
+export function shouldUseRuntimeSchedulerDirectNotify(
+  schedulerSchema: string | null | undefined,
+): boolean {
+  return !isIsolatedRuntimeSchedulerSchema(schedulerSchema);
+}

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

@@ -0,0 +1,108 @@
+import { createTelemetry } from '../observability/telemetry';
+
+type PlayRuntimeTelemetryInput = {
+  phase: string;
+  status: string;
+  orgId?: string | null;
+  runId?: string | null;
+  playName?: string | null;
+  graphHash?: string | null;
+  triggerSource?: string | null;
+  ms?: number;
+  errorCode?: string;
+};
+
+const playRuntimeTelemetry = createTelemetry({
+  service: 'deepline-api',
+  component: 'play-runtime',
+});
+
+type PlayTelemetryLevel = 'debug' | 'info' | 'warn' | 'error';
+
+function stringField(
+  fields: Record<string, unknown>,
+  ...keys: readonly string[]
+): string | null {
+  for (const key of keys) {
+    const value = fields[key];
+    if (typeof value === 'string' && value.trim()) return value.trim();
+  }
+  return null;
+}
+
+export function emitPlayTelemetry(input: {
+  level: PlayTelemetryLevel;
+  event: string;
+  tag: string;
+  fields?: Record<string, unknown>;
+  error?: unknown;
+}): void {
+  const fields = input.fields ?? {};
+  const telemetry = playRuntimeTelemetry.child({
+    context: {
+      orgId: stringField(fields, 'orgId', 'org_id'),
+      orgName: stringField(fields, 'orgName', 'org_name'),
+      requestId: stringField(fields, 'requestId', 'request_id'),
+      runId: stringField(fields, 'runId', 'run_id'),
+      workflowId: stringField(fields, 'workflowId', 'workflow_id', 'runId'),
+      playName: stringField(fields, 'playName', 'play_name'),
+    },
+  });
+  const options = { tag: input.tag };
+  if (input.level === 'error') {
+    void telemetry.error(input.event, input.error, fields, options);
+  } else {
+    void telemetry[input.level](input.event, fields, options);
+  }
+}
+
+/**
+ * Emit the stable play.runtime.span event consumed by Axiom dashboards.
+ * Domain fields stay unchanged while the shared telemetry envelope supplies
+ * consistent service, context, severity, and schema metadata.
+ */
+export function emitPlayRuntimeSpan(input: PlayRuntimeTelemetryInput): void {
+  emitPlayTelemetry({
+    level: 'info',
+    event: 'play.runtime.span',
+    tag: '[play.runtime.span]',
+    fields: {
+      orgId: input.orgId,
+      runId: input.runId,
+      workflowId: input.runId,
+      playName: input.playName,
+      phase: input.phase,
+      status: input.status,
+      graphHash: input.graphHash,
+      triggerSource: input.triggerSource,
+      ms: input.ms,
+      errorCode: input.errorCode,
+    },
+  });
+}
+
+export function emitRecoveredSecretResolutionRetry(input: {
+  orgId: string;
+  runId?: string | null;
+  playName?: string | null;
+  requestId: string;
+  operationId: string;
+  attempt: number;
+  httpStatus: number;
+}): void {
+  emitPlayTelemetry({
+    level: 'warn',
+    event: 'play.runtime.secret_resolution_retry_recovered',
+    tag: '[play.runtime.secret_resolution_retry_recovered]',
+    fields: {
+      orgId: input.orgId,
+      runId: input.runId,
+      workflowId: input.runId,
+      playName: input.playName,
+      requestId: input.requestId,
+      operationId: input.operationId,
+      attempt: input.attempt,
+      httpStatus: input.httpStatus,
+    },
+  });
+}

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

@@ -230,6 +230,8 @@ export type SandboxExecutionAdmission = {
         leaseId: string;
         /** Stable provider correlation for operation-first managed creates. */
         providerOperationToken?: string | null;
+        /** Resume the existing durable provider operation before any new create. */
+        resumeExistingProviderOperation?: boolean;
       }
     | { kind: 'pre_code_deferred'; reason: SandboxPreCodeDeferralReason }
   >;
@@ -293,6 +295,8 @@ export type SandboxExecutionLifecycle = {
         leaseId: string;
         /** Stable provider correlation for operation-first managed creates. */
         providerOperationToken?: string | null;
+        /** Resume the existing durable provider operation before any new create. */
+        resumeExistingProviderOperation?: boolean;
       }
     | { kind: 'pre_code_deferred'; reason: SandboxPreCodeDeferralReason }
   >;

package/dist/bundling-sources/shared_libs/play-runtime/sandbox-runs/runner-backend-adapter.ts

@@ -180,6 +180,9 @@ function createRunnerCallbacks(input: {
       return {
         leaseId: outcome.leaseId,
         providerOperationToken: outcome.providerOperationToken ?? null,
+        ...(outcome.resumeExistingProviderOperation === true
+          ? { resumeExistingProviderOperation: true }
+          : {}),
       };
     },
     releaseSandboxCapacity: async (leaseId) => {

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

@@ -47,6 +47,13 @@ export type PlaySchedulerSubmitInput = {
   asyncLaunchKey?: string | null;
   asyncInvocationKey?: string | null;
   asyncRequestFingerprint?: string | null;
+  /**
+   * Ephemeral proof carried only into atomic async-child admission. It is never
+   * persisted on the child launch; the child receives its own authority.
+   */
+  asyncParentRunAttempt?: number | null;
+  asyncParentRunLeaseToken?: string | null;
+  asyncParentAttemptRequired?: boolean | null;
   /** Full play ancestry for a scheduled child, including this play. */
   asyncAncestryPlayIds?: string[] | null;
   playId: string;

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/absurd-deadline-reconciliation.ts

@@ -0,0 +1,88 @@
+import { cancelPostgresSchedulerRun } from './postgres';
+import type {
+  PostgresSchedulerOptions,
+  PostgresSchedulerQueryClient,
+} from './postgres';
+import { ABSURD_PLAY_RUN_TASK } from './absurd-shared';
+import { resolveRuntimeSchedulerSchemaEnv } from './runtime-scheduler-schema';
+
+/** Bound deadline reconciliation just like Absurd's own cancellation sweep. */
+export const ABSURD_CANCELLED_DEADLINE_RECONCILE_LIMIT = 100;
+
+function quoteAbsurdTable(table: string): string {
+  return `"${table.replaceAll('"', '""')}"`;
+}
+
+/**
+ * Project a play task cancelled by Absurd's indexed `max_delay` sweep into the
+ * scheduler's authoritative run state.
+ *
+ * The engine can cancel an overdue task before or after a worker claims its
+ * handler. A cancelled task has no handler path left to write the normal
+ * terminal state. This reconciler
+ * closes that gap: `cancelPostgresSchedulerRun` atomically writes the runtime
+ * terminal and its run-ledger outbox event, and is idempotent if a user cancel
+ * or a racing worker already terminalized the run. The next empty claim invokes
+ * it immediately after Absurd performs its bounded cancellation sweep.
+ */
+export async function reconcileAbsurdRuntimeMaxDelayCancellations(input: {
+  client: PostgresSchedulerQueryClient;
+  queue: string;
+  schedulerOptions?: Pick<PostgresSchedulerOptions, 'schema'>;
+  limit?: number;
+}): Promise<{ reconciled: number; skipped: number }> {
+  const requestedLimit = Math.floor(
+    input.limit ?? ABSURD_CANCELLED_DEADLINE_RECONCILE_LIMIT,
+  );
+  const limit = Number.isFinite(requestedLimit)
+    ? Math.max(
+        1,
+        Math.min(ABSURD_CANCELLED_DEADLINE_RECONCILE_LIMIT, requestedLimit),
+      )
+    : ABSURD_CANCELLED_DEADLINE_RECONCILE_LIMIT;
+  const taskTable = quoteAbsurdTable(`t_${input.queue}`);
+  const schedulerSchema = quoteAbsurdTable(
+    input.schedulerOptions?.schema?.trim() ||
+      resolveRuntimeSchedulerSchemaEnv() ||
+      'runtime_scheduler',
+  );
+  const cancelled = await input.client.query<{ run_id: string | null }>(
+    `
+      SELECT task.params ->> 'runId' AS run_id
+      FROM absurd.${taskTable} AS task
+      JOIN ${schedulerSchema}.runs AS run
+        ON run.run_id = task.params ->> 'runId'
+       AND run.status IN ('queued', 'running', 'waiting')
+      WHERE task.state = 'cancelled'
+        AND task.task_name = $1
+        AND task.cancellation ? 'max_delay'
+        AND task.cancel_at IS NOT NULL
+        AND task.cancelled_at >= task.cancel_at
+      ORDER BY task.cancelled_at ASC NULLS LAST, task.task_id ASC
+      LIMIT $2
+    `,
+    [ABSURD_PLAY_RUN_TASK, limit],
+  );
+
+  let reconciled = 0;
+  let skipped = 0;
+  for (const row of cancelled.rows) {
+    const runId = row.run_id?.trim();
+    if (!runId) {
+      skipped += 1;
+      continue;
+    }
+    const didCancel = await cancelPostgresSchedulerRun(
+      input.client,
+      {
+        runId,
+        reason:
+          'Run did not start within its configured scheduler queue deadline.',
+      },
+      input.schedulerOptions,
+    );
+    if (didCancel) reconciled += 1;
+    else skipped += 1;
+  }
+  return { reconciled, skipped };
+}

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/absurd-play-deploy-task.ts

@@ -0,0 +1,124 @@
+import type { RetryStrategy } from '@deepline/absurd/sdk';
+import {
+  createAbsurdRuntimeClient,
+  resolveAbsurdPoolOptions,
+  resolveAbsurdQueueSuffix,
+} from './absurd-shared';
+import { ensureAbsurdSchema } from './postgres';
+import { withRuntimeSchedulerClient } from './postgres-pool';
+
+/**
+ * GitHub deploy-on-push build tasks ride their own fixed Absurd queue,
+ * deliberately OUTSIDE the release-lane model: builds are not versioned by
+ * play-runtime release, so pinning them to a `runs_<release>` lane would
+ * strand queued deploys on lane retirement. A plain rolling deploy of the
+ * deploy worker is correct.
+ */
+export const PLAY_DEPLOY_QUEUE = 'deploys';
+export const PLAY_DEPLOY_TASK_NAME = 'play-deploy';
+
+/**
+ * The queue this process submits to / drains. Production and plain local
+ * dev use the fixed base name; a worktree/preview with
+ * DEEPLINE_ABSURD_QUEUE_SUFFIX gets `deploys_<suffix>` so multiple local
+ * stacks sharing one docker Postgres never consume each other's builds
+ * (Absurd partitions its engine tables BY QUEUE, same as the runs lanes).
+ */
+export function playDeployQueueName(): string {
+  const suffix = resolveAbsurdQueueSuffix();
+  return suffix ? `${PLAY_DEPLOY_QUEUE}_${suffix}` : PLAY_DEPLOY_QUEUE;
+}
+export const PLAY_DEPLOY_MAX_ATTEMPTS = 5;
+export const PLAY_DEPLOY_RETRY_STRATEGY: RetryStrategy = {
+  kind: 'exponential',
+  baseSeconds: 5,
+  maxSeconds: 60,
+};
+/**
+ * Retained deploy rows are bounded like the runs queue: a stuck or finished
+ * deploy task must not accumulate forever.
+ *
+ * NOTE: this queue previously set a per-org claim cap. Upstream Absurd
+ * removed account-level caps from queue policy (see the comment on the runs
+ * queue in absurd-shared.ts: parked work holds no slot and fair claim
+ * ordering picks the next runnable task). Build parallelism is now bounded
+ * by worker slots, not per-org policy. If per-org fairness is wanted again
+ * it has to be expressed at claim time, not here.
+ */
+export const PLAY_DEPLOY_CLEANUP_TTL = '6 hours';
+export const PLAY_DEPLOY_CLEANUP_LIMIT = 1_000;
+
+/**
+ * Task payload stays tiny (32 KiB control-plane cap): the deploy token plus
+ * addressing. The worker fetches everything else — repo, commit, project
+ * settings, a GitHub installation token — from the app API with the token,
+ * so state is always read fresh (supersession, disabled projects).
+ */
+export type PlayDeployTaskParams = {
+  deploymentId: string;
+  orgId: string;
+  playProjectId: string;
+  deployToken: string;
+  appBaseUrl: string;
+};
+
+const deployQueueReadyPromises = new Map<string, Promise<void>>();
+
+/**
+ * Ensure the deploys queue exists with its policy. Idempotent per process;
+ * a failure evicts the memo so the next caller retries loudly. Deliberately
+ * NOT ensureAbsurdRuntimeReady — that helper hardcodes the runs-lane
+ * derivation and its policies.
+ */
+export function ensurePlayDeployQueueReady(input?: {
+  url?: string | null;
+  schema?: string | null;
+}): Promise<void> {
+  const poolOptions = resolveAbsurdPoolOptions(input?.url);
+  const schema = input?.schema?.trim() ?? '';
+  const queueName = playDeployQueueName();
+  const key = `${poolOptions.url}::${schema}::${queueName}`;
+  const existing = deployQueueReadyPromises.get(key);
+  if (existing) return existing;
+  const promise = (async () => {
+    await withRuntimeSchedulerClient(poolOptions, (client) =>
+      ensureAbsurdSchema(client),
+    );
+    const absurd = createAbsurdRuntimeClient(poolOptions, queueName);
+    const existingQueues = new Set(await absurd.listQueues());
+    if (!existingQueues.has(queueName)) {
+      await absurd.createQueue(queueName);
+    }
+    await absurd.setQueuePolicy(queueName, {
+      cleanupTtl: PLAY_DEPLOY_CLEANUP_TTL,
+      cleanupLimit: PLAY_DEPLOY_CLEANUP_LIMIT,
+    });
+  })().catch((error) => {
+    deployQueueReadyPromises.delete(key);
+    throw error;
+  });
+  deployQueueReadyPromises.set(key, promise);
+  return promise;
+}
+
+/**
+ * Enqueue one deploy build task, idempotent on the deployment id. Called by
+ * the webhook receiver AFTER the Convex playDeployments row exists and
+ * BEFORE the delivery is marked processed — a crash in between lets
+ * GitHub's redelivery re-run both steps safely.
+ */
+export async function enqueuePlayDeployTask(
+  params: PlayDeployTaskParams,
+): Promise<void> {
+  const poolOptions = resolveAbsurdPoolOptions();
+  await ensurePlayDeployQueueReady();
+  const queueName = playDeployQueueName();
+  const absurd = createAbsurdRuntimeClient(poolOptions, queueName);
+  await absurd.spawn(PLAY_DEPLOY_TASK_NAME, params, {
+    queue: queueName,
+    idempotencyKey: `play-deploy:${params.deploymentId}`,
+    orgKey: params.orgId,
+    maxAttempts: PLAY_DEPLOY_MAX_ATTEMPTS,
+    retryStrategy: PLAY_DEPLOY_RETRY_STRATEGY,
+  });
+}

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/absurd-play-run-task.ts

@@ -0,0 +1,68 @@
+import type { RetryStrategy } from '@deepline/absurd/sdk';
+import type { PlaySchedulerSubmitInput } from '../scheduler-backend';
+import { RUNTIME_RELIABILITY_POLICY } from '../runtime-reliability-policy';
+
+export const ABSURD_PLAY_RUN_TASK = 'play-run';
+
+export const ABSURD_PLAY_RUN_RETRY_STRATEGY: RetryStrategy = {
+  kind: 'exponential',
+  baseSeconds: RUNTIME_RELIABILITY_POLICY.engine.retryBaseSeconds,
+  factor: 2,
+  maxSeconds: RUNTIME_RELIABILITY_POLICY.engine.retryMaxSeconds,
+};
+
+export const ABSURD_PLAY_RUN_MAX_ATTEMPTS =
+  RUNTIME_RELIABILITY_POLICY.engine.maxAttempts;
+
+export type AbsurdPlayRunTaskParams = {
+  runId: string;
+  orgId: string;
+  /**
+   * Retained release lanes may still validate this field before loading the
+   * launch row. Every newly submitted task is a root.
+   */
+  nestingDepth: number;
+  schedulerSchema?: string | null;
+};
+
+/**
+ * The one task ABI for an ordinary Play Run.
+ *
+ * Callers choose only the release queue. Task identity, fairness, retries, and
+ * queue-delay policy stay inside the scheduler adapter.
+ */
+export function buildAbsurdPlayRunTask(input: {
+  launch: Pick<
+    PlaySchedulerSubmitInput,
+    'runId' | 'orgId' | 'queueMaxDelaySeconds' | 'queuePriority'
+  >;
+  schedulerSchema?: string | null;
+}) {
+  const params: AbsurdPlayRunTaskParams = {
+    runId: input.launch.runId,
+    orgId: input.launch.orgId,
+    nestingDepth: 0,
+    schedulerSchema: input.schedulerSchema ?? null,
+  };
+  const maxDelaySeconds = input.launch.queueMaxDelaySeconds;
+  const priority = input.launch.queuePriority;
+  return {
+    taskName: ABSURD_PLAY_RUN_TASK,
+    params,
+    options: {
+      idempotency_key: input.launch.runId,
+      org_key: input.launch.orgId,
+      max_attempts: ABSURD_PLAY_RUN_MAX_ATTEMPTS,
+      retry_strategy: {
+        kind: ABSURD_PLAY_RUN_RETRY_STRATEGY.kind,
+        base_seconds: ABSURD_PLAY_RUN_RETRY_STRATEGY.baseSeconds,
+        factor: ABSURD_PLAY_RUN_RETRY_STRATEGY.factor,
+        max_seconds: ABSURD_PLAY_RUN_RETRY_STRATEGY.maxSeconds,
+      },
+      ...(typeof priority === 'number' ? { priority } : {}),
+      ...(typeof maxDelaySeconds === 'number'
+        ? { cancellation: { max_delay: maxDelaySeconds } }
+        : {}),
+    },
+  };
+}