deepline 0.3.311 → 0.3.313

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

@@ -1748,7 +1748,13 @@ export function definePlay<TInput, TOutput extends PlayReturnObject>(
       : {
           name: nameOrConfig.id,
           fn: nameOrConfig.run,
-          bindings: nameOrConfig.bindings,
+          bindings:
+            nameOrConfig.displayName !== undefined
+              ? {
+                  ...nameOrConfig.bindings,
+                  displayName: nameOrConfig.displayName,
+                }
+              : nameOrConfig.bindings,
           description: nameOrConfig.description,
           inputSchema: nameOrConfig.input.schema,
           billing: nameOrConfig.billing,

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

@@ -200,7 +200,7 @@ export const SDK_RELEASE = {
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
   // 0.3.90 is the first deliberately versioned SDK release for API v3.
-  version: '0.3.311',
+  version: '0.3.313',
   updateSummary:
     'Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.',
   packageCapabilities: {

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

@@ -354,8 +354,10 @@ const POSTGRES_SCHEDULER_SCHEMA_INIT_STATEMENT_TIMEOUT_MS = 60_000;
 // v60 indexes all sandbox leases by Run, including released custody history.
 // v61 adds an operator-owned new-run projection cutover and admission pin.
 // Existing namespace mode values and unpinned runs keep their behavior.
+// v62 adds a deploy-owned index for per-run active outbox lease exclusion.
+// Failed facts remain indexed: their live leases still fence the run.
 // This marker records deployment work, never a runtime schema floor.
-export const POSTGRES_SCHEDULER_SCHEMA_VERSION = 61;
+export const POSTGRES_SCHEDULER_SCHEMA_VERSION = 62;
 const POSTGRES_SCHEDULER_SCHEMA_MIGRATIONS_TABLE =
   'scheduler_schema_migrations';
 export const POSTGRES_SCHEDULER_OPEN_RECOVERY_INDEX =
@@ -1986,6 +1988,15 @@ export async function hasCurrentPostgresSchedulerSchemaShape(
             AND index_row.indrelid = to_regclass($3)
             AND index_row.indisready AND index_row.indisvalid
         )
+        AND EXISTS (
+          SELECT 1 FROM pg_index AS index_row
+          JOIN pg_class AS index_class ON index_class.oid = index_row.indexrelid
+          JOIN pg_namespace AS index_namespace ON index_namespace.oid = index_class.relnamespace
+          WHERE index_namespace.nspname = $1
+            AND index_class.relname = 'runtime_scheduler_outbox_run_lease_idx'
+            AND index_row.indrelid = to_regclass($3)
+            AND index_row.indisready AND index_row.indisvalid
+        )
         AND EXISTS (
           SELECT 1 FROM pg_index AS index_row
           JOIN pg_class AS index_class ON index_class.oid = index_row.indexrelid
@@ -4018,6 +4029,11 @@ export async function ensurePostgresSchedulerSchema(
           )
           WHERE delivered_at IS NULL AND ${searchLaneSql('outbox')} = true
       `);
+      await client.query(`
+        CREATE INDEX IF NOT EXISTS runtime_scheduler_outbox_run_lease_idx
+          ON ${tableName('outbox', options)} (run_id, lease_expires_at)
+          WHERE delivered_at IS NULL AND lease_owner IS NOT NULL
+      `);
       await client.query(`
         CREATE INDEX IF NOT EXISTS runtime_scheduler_outbox_lease_health_idx
           ON ${tableName('outbox', options)}
@@ -4194,6 +4210,12 @@ const POSTGRES_SCHEDULER_RUNTIME_ADMIN_INDEXES = [
       created_at, event_id)
       WHERE delivered_at IS NULL AND ${searchLaneSql('outbox')} = true`,
   },
+  {
+    name: 'runtime_scheduler_outbox_run_lease_idx',
+    table: 'outbox',
+    definition: `(run_id, lease_expires_at)
+      WHERE delivered_at IS NULL AND lease_owner IS NOT NULL`,
+  },
   {
     name: 'runtime_scheduler_outbox_lease_health_idx',
     table: 'outbox',
@@ -17982,8 +18004,11 @@ function runLedgerPrecedesSql(
   predecessor: string,
   successor: string,
   inclusive = false,
+  searchOnly?: boolean,
 ): string {
-  return `(${searchLaneSql(predecessor)} = ${searchLaneSql(successor)} AND ${runLedgerPositionSql(predecessor)} ${inclusive ? '<=' : '<'} ${runLedgerPositionSql(successor)})`;
+  const lane =
+    searchOnly === undefined ? searchLaneSql(successor) : String(searchOnly);
+  return `(${searchLaneSql(predecessor)} = ${lane} AND ${runLedgerPositionSql(predecessor)} ${inclusive ? '<=' : '<'} ${runLedgerPositionSql(successor)})`;
 }
 
 function searchLaneSql(alias: string): string {
@@ -18014,30 +18039,28 @@ function runLedgerTerminalPendingSql(
   )`;
 }
 
-function runLedgerWaitingRunsSql(
+function runLedgerWaitingPendingSql(
+  alias: string,
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
-  runIdParameter?: string,
+  runIdSql = `${alias}.run_id`,
 ): string {
-  return `SELECT DISTINCT waiting_event.run_id
+  return `EXISTS (SELECT 1
     FROM ${tableName('outbox', options)} AS waiting_event
-    WHERE waiting_event.event_type = ${RUN_EVENT_KIND_SQL_LITERAL.runWaiting}
+    WHERE waiting_event.run_id = ${runIdSql}
+      AND waiting_event.event_type = ${RUN_EVENT_KIND_SQL_LITERAL.runWaiting}
       -- Detached runner parks are transport-only and project no public wait.
       AND waiting_event.payload_json->>'kind' IS DISTINCT FROM 'detached_runner'
       AND waiting_event.delivered_at IS NULL
       AND waiting_event.failed_at IS NULL
-      AND coalesce(waiting_event.next_attempt_at, waiting_event.created_at) <= now()
-      ${runIdParameter ? `AND (${runIdParameter}::text IS NULL OR waiting_event.run_id = ${runIdParameter}::text)` : ''}`;
-}
-
-function runLedgerWaitingPendingSql(alias: string): string {
-  return `(${alias}.run_id IN (SELECT run_id FROM waiting_runs))`;
+      AND coalesce(waiting_event.next_attempt_at, waiting_event.created_at) <= now())`;
 }
 
 function runLedgerUrgentLifecyclePendingSql(
   alias: string,
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
+  runIdSql?: string,
 ): string {
-  return `(${runLedgerTerminalPendingSql(alias, options)} OR ${runLedgerWaitingPendingSql(alias)})`;
+  return `(${runLedgerTerminalPendingSql(alias, options)} OR ${runLedgerWaitingPendingSql(alias, options, runIdSql)})`;
 }
 
 /**
@@ -18060,6 +18083,8 @@ export async function readPendingPostgresSchedulerOutboxEvents(
     extendOwnedHead?: string;
     /** The dispatcher owns a short, exclusive claim transaction. */
     inTransaction?: boolean;
+    /** The owner rolls back and restarts the whole claim on the old-schema adapter. */
+    restartTransactionOnMissingMarker?: boolean;
   } = {},
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
 ): Promise<PostgresSchedulerOutboxEvent[]> {
@@ -18100,11 +18125,23 @@ async function claimPostgresSchedulerOutboxPrefix(
     `${alias}.delivered_at IS NULL${
       acknowledgement ? ` AND NOT (${alias}.event_id = ANY($5::text[]))` : ''
     }`;
+  // The dispatcher already chose this run. Seek its oldest pending fact
+  // before eligibility checks; comparing every candidate with every earlier
+  // fact makes a single run's burst quadratic. Failed/delayed heads must
+  // remain in this seek so they still block their causal successors.
+  const seekRunHead = runId !== null && !input.extendOwnedHead;
   const claim = async (supportsTerminalBatchMarker: boolean) => {
     const urgentLifecyclePendingSql = (alias: string) =>
       input.searchOnly === true
         ? runLedgerTerminalPendingSql(alias, options)
-        : runLedgerUrgentLifecyclePendingSql(alias, options);
+        : runLedgerUrgentLifecyclePendingSql(
+            alias,
+            options,
+            // Every claimed row belongs to the selected run. An independent
+            // wait probe evaluates once, instead of scanning its backlog for
+            // each row whose delivery batch is being frozen.
+            runId !== null ? '$2::text' : undefined,
+          );
     // Search is locally indexed and acknowledged; it has no remote ingress
     // receipt to freeze. Preserve causal ordering/due/lease checks, but admit
     // its full prefix instead of inheriting lifecycle's singleton transport.
@@ -18132,11 +18169,17 @@ async function claimPostgresSchedulerOutboxPrefix(
       ),`
           : ''
       } ${
-        input.searchOnly === true
-          ? ''
-          : `waiting_runs AS MATERIALIZED (
-        ${runLedgerWaitingRunsSql(options, '$2')}
-      ), `
+        seekRunHead
+          ? `pending_head AS MATERIALIZED (
+        SELECT pending.event_id
+        FROM ${tableName('outbox', options)} AS pending
+        WHERE pending.run_id = $2
+          AND ${pending('pending')}
+          AND ${searchLaneSql('pending')} = ${input.searchOnly === true ? 'true' : 'false'}
+        ORDER BY ${runLedgerOrderSql('pending')}
+        LIMIT 1
+      ),`
+          : ''
       }${
         input.extendOwnedHead
           ? `owned_run AS MATERIALIZED (
@@ -18152,6 +18195,7 @@ async function claimPostgresSchedulerOutboxPrefix(
         SELECT candidate.event_id, candidate.run_id, candidate.event_type,
                ${supportsTerminalBatchMarker ? 'candidate.delivery_batch_started_at' : 'NULL::timestamptz'} AS delivery_batch_started_at
         FROM ${tableName('outbox', options)} AS candidate
+        ${seekRunHead ? 'JOIN pending_head ON pending_head.event_id = candidate.event_id' : ''}
         ${input.extendOwnedHead ? 'JOIN owned_run ON owned_run.run_id = candidate.run_id' : ''}
         WHERE ${pending('candidate')}
           AND ${searchLaneSql('candidate')} = ${input.searchOnly === true ? 'true' : 'false'}
@@ -18187,7 +18231,7 @@ async function claimPostgresSchedulerOutboxPrefix(
             SELECT 1 FROM ${tableName('outbox', options)} AS active
             WHERE active.run_id = candidate.run_id
               AND ${pending('active')}
-              AND ${searchLaneSql('active')} = ${searchLaneSql('candidate')}
+              AND ${searchLaneSql('active')} = ${input.searchOnly === true ? 'true' : 'false'}
               AND active.lease_owner IS NOT NULL
               AND active.lease_expires_at > now()
               AND active.lease_owner IS DISTINCT FROM $3::text
@@ -18195,13 +18239,17 @@ async function claimPostgresSchedulerOutboxPrefix(
           -- Competing projectors acquire one run through its oldest event.
           -- Locking this head prevents another projector from splitting the
           -- run while still letting it skip to unrelated runs.
-          AND NOT EXISTS (
+          ${
+            seekRunHead
+              ? ''
+              : `AND NOT EXISTS (
             SELECT 1
             FROM ${tableName('outbox', options)} AS predecessor
             WHERE predecessor.run_id = candidate.run_id
               AND ${pending('predecessor')}
-              AND ${runLedgerPrecedesSql('predecessor', 'candidate')}
-          )
+              AND ${runLedgerPrecedesSql('predecessor', 'candidate', false, input.searchOnly === true)}
+          )`
+          }
         -- A new durable admission has no causal dependency on unrelated
         -- terminal facts. Project it first so a lifecycle backlog cannot make
         -- an accepted run invisible; per-run predecessor checks above retain
@@ -18210,16 +18258,20 @@ async function claimPostgresSchedulerOutboxPrefix(
         -- predecessors. Giving priority only to a terminal head leaves a
         -- finished run's earlier progress behind unrelated progress. The
         -- predecessor checks still forbid skipping any fact within the run.
-        ORDER BY
+        ${
+          runId !== null
+            ? ''
+            : `ORDER BY
           CASE
             WHEN candidate.event_type = ${RUN_EVENT_KIND_SQL_LITERAL.runCreated} THEN 0
             WHEN ${runLedgerTerminalPendingSql('candidate', options)} THEN 1
-            ${input.searchOnly === true ? '' : `WHEN ${runLedgerWaitingPendingSql('candidate')} THEN 2`}
+            ${input.searchOnly === true ? '' : `WHEN ${runLedgerWaitingPendingSql('candidate', options)} THEN 2`}
             ELSE 3
           END,
           coalesce(candidate.next_attempt_at, candidate.created_at),
           candidate.created_at,
-          candidate.event_id
+          candidate.event_id`
+        }
         FOR UPDATE SKIP LOCKED
         LIMIT 1
       ), candidates AS MATERIALIZED (
@@ -18227,6 +18279,7 @@ async function claimPostgresSchedulerOutboxPrefix(
         FROM ${tableName('outbox', options)} AS outbox
         JOIN head ON head.run_id = outbox.run_id
         WHERE ${pending('outbox')}
+          ${runId !== null ? 'AND outbox.run_id = $2::text' : ''}
           AND ${searchLaneSql('outbox')} = ${input.searchOnly === true ? 'true' : 'false'}
           AND outbox.failed_at IS NULL
           -- Admission is causally first and must be projected alone. A later
@@ -18278,7 +18331,7 @@ async function claimPostgresSchedulerOutboxPrefix(
               AND terminal_predecessor.event_type IN (
                 ${RUN_EVENT_KIND_SQL_LITERAL.runCompleted}, ${RUN_EVENT_KIND_SQL_LITERAL.runFailed}, ${RUN_EVENT_KIND_SQL_LITERAL.runCancelled}
               )
-              AND ${runLedgerPrecedesSql('terminal_predecessor', 'outbox')}
+              AND ${runLedgerPrecedesSql('terminal_predecessor', 'outbox', false, input.searchOnly === true)}
           )
           -- Claim only the contiguous due prefix. A delayed, leased, or failed
           -- predecessor retains ownership of everything that follows it.
@@ -18287,7 +18340,7 @@ async function claimPostgresSchedulerOutboxPrefix(
             FROM ${tableName('outbox', options)} AS predecessor
             WHERE predecessor.run_id = outbox.run_id
               AND ${pending('predecessor')}
-              AND ${runLedgerPrecedesSql('predecessor', 'outbox')}
+              AND ${runLedgerPrecedesSql('predecessor', 'outbox', false, input.searchOnly === true)}
               AND (
                 (predecessor.event_type = ${RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL.runEvents}
                  AND NOT (${ingressPrefixSql}))
@@ -18383,7 +18436,9 @@ async function claimPostgresSchedulerOutboxPrefix(
     );
   };
   let result;
-  if (input.inTransaction) await client.query('SAVEPOINT run_ledger_claim');
+  const useSavepoint =
+    input.inTransaction && !input.restartTransactionOnMissingMarker;
+  if (useSavepoint) await client.query('SAVEPOINT run_ledger_claim');
   if (supportsOutboxDeliveryBatchMarker(options)) {
     try {
       result = await claim(true);
@@ -18393,16 +18448,16 @@ async function claimPostgresSchedulerOutboxPrefix(
       // The ACK caller owns the whole short transaction. Roll it back and
       // repeat only this missing-column adapter, avoiding two SAVEPOINT round
       // trips on every successful acknowledgement.
-      if (acknowledgement) throw error;
-      if (input.inTransaction)
+      if (acknowledgement || input.restartTransactionOnMissingMarker)
+        throw error;
+      if (useSavepoint)
         await client.query('ROLLBACK TO SAVEPOINT run_ledger_claim');
       result = await claim(false);
     }
   } else {
     result = await claim(false);
   }
-  if (input.inTransaction)
-    await client.query('RELEASE SAVEPOINT run_ledger_claim');
+  if (useSavepoint) await client.query('RELEASE SAVEPOINT run_ledger_claim');
   const events = result.rows
     .filter((row) => row.row_kind === 'claimed')
     .map((row) => {
@@ -19871,7 +19926,7 @@ export async function dispatchRunLedgerOutboxToLedgerBatchOnceWithClientScope(
 }
 
 async function dispatchRunLedgerOutboxBatchWithScope(
-  withClient: RunLedgerOutboxWithClient,
+  acquireClient: RunLedgerOutboxWithClient,
   input: RunLedgerOutboxDispatchInput & { waitForRunLock?: boolean },
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
   scope?: RunLedgerOutboxDrainScope,
@@ -19879,6 +19934,25 @@ async function dispatchRunLedgerOutboxBatchWithScope(
   remainingEvents: number | null = null,
 ): Promise<PostgresSchedulerOutboxProjectionResult> {
   const dispatchStartedAtMs = Date.now();
+  // A committed terminal is running-work control traffic. Use the existing
+  // alternating critical admission lane so its short lease operations do not
+  // sit behind a full ordinary-work backlog; capacity is unchanged.
+  const terminalRunId =
+    scope && scope.targetEventId === `run-terminal:${scope.runId}`
+      ? scope.runId
+      : null;
+  const withClient: RunLedgerOutboxWithClient = (operation, trace) =>
+    acquireClient(
+      operation,
+      trace ??
+        (terminalRunId
+          ? {
+              runId: terminalRunId,
+              phase: 'run_ledger_outbox_terminal_delivery',
+              priority: 'critical',
+            }
+          : undefined),
+    );
   const tokenAuthority = input.tokenAuthority ?? 'local_mint';
   const leaseOwner =
     input.leaseOwner?.trim() || `run-ledger-outbox-dispatch:${randomUUID()}`;
@@ -19930,6 +20004,9 @@ async function dispatchRunLedgerOutboxBatchWithScope(
     await client.query('BEGIN');
     try {
       const targetRunId = input.runId?.trim() || null;
+      let lockedRun: {
+        rows: { run_id: string; dispatch_launch_json: unknown }[];
+      } | null = null;
       if (input.waitForRunLock && targetRunId) {
         // A synchronous drain must not mistake a busy run for an empty
         // outbox. In particular, cancellation owns its pending prefix lease,
@@ -19945,8 +20022,14 @@ async function dispatchRunLedgerOutboxBatchWithScope(
             `${RUNTIME_SCHEDULER_CANCEL_STATEMENT_TIMEOUT_MS}ms`,
           ],
         );
-        await client.query(
-          `SELECT run_id FROM ${tableName('runs', options)} WHERE run_id = $1 FOR UPDATE`,
+        lockedRun = await client.query<{
+          run_id: string;
+          dispatch_launch_json: unknown;
+        }>(
+          `SELECT runs.run_id,
+                  ${needsLaunch ? runLedgerDispatchLaunchSql('runs') : 'NULL::jsonb'} AS dispatch_launch_json
+           FROM ${tableName('runs', options)} AS runs
+           WHERE runs.run_id = $1 FOR UPDATE`,
           [targetRunId],
         );
       }
@@ -19955,17 +20038,19 @@ async function dispatchRunLedgerOutboxBatchWithScope(
       // nullable predicate made PostgreSQL materialize every pending run head
       // for each lifecycle transition. Only the two dedicated projectors may
       // perform the global distinct-head scan below.
-      const selected = targetRunId
-        ? await client.query<{
-            run_id: string;
-            dispatch_launch_json: unknown;
-          }>(
-            `
+      const selected =
+        (input.headEventId ? null : lockedRun) ??
+        (targetRunId
+          ? await client.query<{
+              run_id: string;
+              dispatch_launch_json: unknown;
+            }>(
+              `
             WITH head AS MATERIALIZED (
               SELECT pending.run_id,
                      pending.event_id,
                      pending.event_type,
-                     pending.payload_json,
+                     ${needsLaunch ? 'pending.payload_json,' : ''}
                      pending.created_at,
                      pending.next_attempt_at,
                      pending.failed_at
@@ -19993,24 +20078,18 @@ async function dispatchRunLedgerOutboxBatchWithScope(
               )
             FOR UPDATE OF runs SKIP LOCKED
           `,
-            [targetRunId, leaseOwner, input.headEventId?.trim() || null],
-          )
-        : await client.query<{
-            run_id: string;
-            dispatch_launch_json: unknown;
-          }>(`
-            WITH ${
-              input.searchOnly === true
-                ? ''
-                : `waiting_runs AS MATERIALIZED (
-              ${runLedgerWaitingRunsSql(options)}
-            ), `
-            }heads AS MATERIALIZED (
+              [targetRunId, leaseOwner, input.headEventId?.trim() || null],
+            )
+          : await client.query<{
+              run_id: string;
+              dispatch_launch_json: unknown;
+            }>(`
+            WITH heads AS MATERIALIZED (
               SELECT DISTINCT ON (pending.run_id)
                 pending.run_id,
                 pending.event_id,
                 pending.event_type,
-                pending.payload_json,
+                ${needsLaunch ? 'pending.payload_json,' : ''}
                 pending.created_at,
                 pending.next_attempt_at,
                 pending.failed_at
@@ -20042,13 +20121,13 @@ async function dispatchRunLedgerOutboxBatchWithScope(
                 : `CASE
                        WHEN head.event_type = ${RUN_EVENT_KIND_SQL_LITERAL.runCreated} THEN 0
                        WHEN ${runLedgerTerminalPendingSql('head', options)} THEN 1
-                       ${input.searchOnly === true ? '' : `WHEN ${runLedgerWaitingPendingSql('head')} THEN 2`}
+                       ${input.searchOnly === true ? '' : `WHEN ${runLedgerWaitingPendingSql('head', options)} THEN 2`}
                        ELSE 3
                      END,`
             }
                      head.created_at, runs.run_id
             FOR UPDATE OF runs SKIP LOCKED LIMIT 1
-          `);
+          `));
       const runId = selected.rows[0]?.run_id;
       const claimed = runId
         ? await readPendingPostgresSchedulerOutboxEvents(
@@ -20059,6 +20138,7 @@ async function dispatchRunLedgerOutboxBatchWithScope(
               leaseOwner,
               leaseSeconds: input.leaseSeconds ?? 120,
               inTransaction: true,
+              restartTransactionOnMissingMarker: true,
               searchOnly: input.searchOnly,
             },
             options,
@@ -20083,7 +20163,16 @@ async function dispatchRunLedgerOutboxBatchWithScope(
     : null;
   const claimed = preclaimed
     ? { events: preclaimed, launchJson: null }
-    : await withClient(claimEvents);
+    : await withClient(async (client) => {
+        try {
+          return await claimEvents(client);
+        } catch (error) {
+          if (!isMissingOutboxDeliveryBatchMarker(error)) throw error;
+          // claimEvents rolled back. Reacquire the run fence and its fresh
+          // snapshot using only the named missing-column compatibility path.
+          return claimEvents(client);
+        }
+      });
   const { launchJson } = claimed;
   let events = claimed.events;
   if (events.length === 0) {
@@ -20391,7 +20480,7 @@ async function dispatchRunLedgerOutboxBatchWithScope(
       events.length === 1 &&
       first.eventType === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runEvents
     ) {
-      const widened = await withClient(async (client) => {
+      const widen = async (client: PostgresSchedulerQueryClient) => {
         await client.query('BEGIN');
         try {
           await client.query(
@@ -20422,6 +20511,7 @@ async function dispatchRunLedgerOutboxBatchWithScope(
               allowIngressPrefix: true,
               extendOwnedHead: first.eventId,
               inTransaction: true,
+              restartTransactionOnMissingMarker: true,
             },
             options,
           );
@@ -20431,6 +20521,14 @@ async function dispatchRunLedgerOutboxBatchWithScope(
           await client.query('ROLLBACK');
           throw error;
         }
+      };
+      const widened = await withClient(async (client) => {
+        try {
+          return await widen(client);
+        } catch (error) {
+          if (!isMissingOutboxDeliveryBatchMarker(error)) throw error;
+          return widen(client);
+        }
       });
       if (widened[0]?.eventId !== first.eventId) {
         throw new RunLedgerProjectionLeaseLostError(

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/run-ledger-outbox-recovery.ts

@@ -345,6 +345,7 @@ export function startRunLedgerOutboxRecovery(
     const pendingObservability = new Set<symbol>();
     const deliveries: Delivery[] = [];
     let refill = false;
+    let observabilityRefill = false;
     let dispatchFailed = false;
     let completed = 0;
     let attempted = 0;
@@ -420,11 +421,7 @@ export function startRunLedgerOutboxRecovery(
         // cannot consume a notification that arrived after its query began.
         if (canProbeObservability()) {
           observabilityRequested = false;
-          while (
-            pendingObservability.size < observabilityParallelism &&
-            pending.size < parallelism
-          )
-            launch(true);
+          launch(true);
         }
         if (canProbeLifecycle()) {
           requested = false;
@@ -432,6 +429,14 @@ export function startRunLedgerOutboxRecovery(
         }
         // Productive completion permits immediate use of every free slot.
         // Empty results grant no refill, so idle work cannot spin on scans.
+        if (observabilityRefill) {
+          while (
+            pendingObservability.size < observabilityParallelism &&
+            pending.size < parallelism
+          )
+            launch(true);
+          observabilityRefill = false;
+        }
         if (refill) {
           while (
             pending.size < parallelism &&
@@ -477,7 +482,7 @@ export function startRunLedgerOutboxRecovery(
       // Retryable rows own durable retry clocks. The SQL claim keeps their
       // run ordered while successful slots keep unrelated runs moving.
       if (delivery.observability) {
-        if (result.attempted > 0) observabilityRequested = true;
+        observabilityRefill = result.attempted > 0;
       } else refill = result.attempted > 0;
     }
   };

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

@@ -717,6 +717,7 @@ export type PlayAuthoringAstSqlListenerDeclaration = {
   operations: string[];
 };
 export type PlayAuthoringAstBindings = {
+  displayName?: string;
   webhook?: {
     hmac?: {
       algorithm?: 'sha256';
@@ -745,6 +746,7 @@ export type PlayAuthoringAstBindings = {
  */
 export const PLAY_AUTHORING_BINDING_FIELDS = {
   root: [
+    'displayName',
     'billing',
     'compatibility',
     'cron',
@@ -792,6 +794,7 @@ export type PlayAuthoringCronInput<TInput> = TInput extends readonly unknown[]
 
 /** The one public type for options accepted by definePlay. */
 export type PlayAuthoringBindings<TInput = Record<string, unknown>> = {
+  displayName?: string;
   description?: string;
   compatibility?: {
     toolErrorSchemaVersion?: ToolExecutionErrorSchemaVersion;
@@ -929,6 +932,7 @@ export type PlayAuthoringDefineConfig<
 > = {
   id: string;
   description?: string;
+  displayName?: string;
   input: PlayAuthoringInputContract<TInput>;
   run: (ctx: TContext, input: TInput) => Promise<TOutput>;
   bindings?: PlayAuthoringBindings<TInput>;
@@ -1644,6 +1648,23 @@ const SqlListenerFilterScalarSchema = Type.Union([
 ]);
 
 export const PLAY_AUTHORING_FIELD_REGISTRY = {
+  displayName: {
+    schema: Type.String(),
+    fixtures: {
+      valid: 'Find verified emails',
+      invalid: 42,
+      absent: undefined,
+      unresolved: { expression: 'displayName' },
+      edition1: 'Legacy play',
+    },
+    referenceType: 'string',
+    required: false,
+    resolution: 'static-required',
+    issueCode: 'play_authoring_binding_invalid',
+    description:
+      'Optional human-readable Play name; empty uses the derived identifier.',
+    errorMessage: 'displayName must be a static string.',
+  },
   description: {
     schema: Type.String({ minLength: 1 }),
     fixtures: {
@@ -3198,6 +3219,7 @@ export const PLAY_AUTHORING_CLOUD_TYPE_DECLARATIONS = [
   '};',
   'export type PlayCronInput<TInput> = TInput extends readonly unknown[] ? never : TInput extends object ? TInput : never;',
   'export type PlayBindings<TInput = Record<string, unknown>> = {',
+  `  displayName?: ${cloudReferenceType('displayName')};`,
   `  description?: ${cloudReferenceType('description')};`,
   `  compatibility?: { toolErrorSchemaVersion?: ${cloudReferenceType('compatibility.toolErrorSchemaVersion')}; toolResponseReceiptRevision?: ${cloudReferenceType('compatibility.toolResponseReceiptRevision')} };`,
   `  inline?: ${cloudReferenceType('inline')};`,
@@ -3276,7 +3298,7 @@ export const PLAY_AUTHORING_CLOUD_TYPE_DECLARATIONS = [
   "  log(message: string, options?: { level?: 'debug' | 'info' | 'warn' | 'error'; context?: Readonly<Record<string, string | number | boolean>> }): void;",
   `  sleep(ms: ${cloudReferenceType('ctx.sleep.ms')}): Promise<void>;`,
   '}',
-  "export type DefinePlayConfig<TInput, TOutput extends PlayReturnObject> = { id: string; description?: string; input: PlayInputContract<TInput>; run: (ctx: DeeplinePlayRuntimeContext, input: TInput) => Promise<TOutput>; bindings?: PlayBindings<TInput>; billing?: PlayBindings<TInput>['billing']; runtime?: PlayBindings<TInput>['runtime']; compatibility?: PlayBindings<TInput>['compatibility'] };",
+  "export type DefinePlayConfig<TInput, TOutput extends PlayReturnObject> = { id: string; displayName?: string; description?: string; input: PlayInputContract<TInput>; run: (ctx: DeeplinePlayRuntimeContext, input: TInput) => Promise<TOutput>; bindings?: PlayBindings<TInput>; billing?: PlayBindings<TInput>['billing']; runtime?: PlayBindings<TInput>['runtime']; compatibility?: PlayBindings<TInput>['compatibility'] };",
   "export type DefinedPlay<TInput, TOutput extends PlayReturnObject> = ((ctx: DeeplinePlayRuntimeContext, input: TInput) => Promise<TOutput>) & { readonly name: string; readonly __inputType?: TInput; readonly __outputType?: TOutput; readonly bindings?: PlayBindings<TInput>; readonly runtime?: PlayBindings<TInput>['runtime']; readonly compatibility?: PlayBindings<TInput>['compatibility'] };",
   'export type PlayHandlerInput<THandler> = THandler extends (context: DeeplinePlayRuntimeContext, input: infer TInput) => Promise<PlayReturnObject> ? TInput : never;',
   'export type PlayHandlerOutput<THandler> = THandler extends (context: DeeplinePlayRuntimeContext, input: unknown) => Promise<infer TOutput extends PlayReturnObject> ? TOutput : never;',

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

@@ -358,7 +358,13 @@ export function createDefinedPlay<
       : {
           name: nameOrConfig.id,
           fn: nameOrConfig.run,
-          bindings: nameOrConfig.bindings,
+          bindings:
+            nameOrConfig.displayName !== undefined
+              ? {
+                  ...nameOrConfig.bindings,
+                  displayName: nameOrConfig.displayName,
+                }
+              : nameOrConfig.bindings,
           description: nameOrConfig.description,
           inputSchema: nameOrConfig.input.schema,
           billing: nameOrConfig.billing,