deepline 0.3.240 → 0.3.241

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.240',
+  version: '0.3.241',
   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/deployment/runtime-topology.ts

@@ -187,8 +187,16 @@ export const RUNTIME_TOPOLOGY = {
           dockerfile: 'deploy/fly/runtime-worker/Dockerfile.absurd-scaler',
         },
         processGroups: {
-          app: { desiredStarted: 1, healthCheck: 'scaler_ready' },
-          projector: { desiredStarted: 2, healthCheck: 'projector_ready' },
+          app: {
+            desiredStarted: 1,
+            healthCheck: 'scaler_ready',
+            guest: { cpu_kind: 'shared', cpus: 1, memory_mb: 256 },
+          },
+          projector: {
+            desiredStarted: 2,
+            healthCheck: 'projector_ready',
+            guest: { cpu_kind: 'shared', cpus: 1, memory_mb: 1024 },
+          },
         },
       },
       workerLogShipper: {

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

@@ -4686,10 +4686,10 @@ async function submitPostgresSchedulerRunTransaction(
   const taskSpawnCtes = absurdTask
     ? `task_request AS (
         SELECT
-          $21::text AS queue_name,
-          $22::text AS task_name,
-          $23::jsonb AS params,
-          $24::jsonb AS options
+          $20::text AS queue_name,
+          $21::text AS task_name,
+          $22::jsonb AS params,
+          $23::jsonb AS options
         FROM admission
         WHERE (
           NOT admission.existing_run
@@ -4753,10 +4753,15 @@ async function submitPostgresSchedulerRunTransaction(
         SELECT pg_advisory_xact_lock_shared(
           ${POSTGRES_SCHEDULER_RELEASE_ADMISSION_LOCK_NAMESPACE},
           ${quoteIdent(schemaName(options))}.runtime_release_admission_lock_id(
-            coalesce($13::text, 'non-absurd')
+            coalesce($12::text, 'non-absurd')
           )
         )
         FROM run_lock
+      ), launch_payload AS MATERIALIZED (
+        -- Keep the bound document behind one materialization boundary. A
+        -- custom plan otherwise copies its JSON constant into every field
+        -- extraction and can consume hundreds of MiB during admission.
+        SELECT $8::jsonb AS launch_json
       ), parent_run AS MATERIALIZED (
         SELECT runs.run_id,
                runs.status,
@@ -4774,8 +4779,8 @@ async function submitPostgresSchedulerRunTransaction(
                ) AS root_run_id
         FROM admission_lock
         JOIN ${tableName('runs', options)} AS runs
-          ON runs.run_id = $16::text
-        WHERE $16::text IS NOT NULL
+          ON runs.run_id = $15::text
+        WHERE $15::text IS NOT NULL
         FOR UPDATE
       ), existing_run AS (
         SELECT
@@ -4783,13 +4788,14 @@ async function submitPostgresSchedulerRunTransaction(
             ${existingLaunchIntentMatchesSql}
             OR ${quoteIdent(schemaName(options))}.runtime_launch_admission_matches(
               coalesce(runs.admission_json, runs.launch_json),
-              $8::jsonb
+              launch_payload.launch_json
             )
           ) AS matches_launch,
           coalesce(runs.admission_json, runs.launch_json) AS launch_json,
           runs.absurd_task_id,
           runs.status
         FROM admission_lock
+        CROSS JOIN launch_payload
         JOIN ${tableName('runs', options)} AS runs
           ON runs.run_id = $1
       ), parent_attempt AS MATERIALIZED (
@@ -4797,8 +4803,8 @@ async function submitPostgresSchedulerRunTransaction(
         FROM parent_run
         JOIN ${tableName('attempts', options)} AS attempts
           ON attempts.run_id = parent_run.run_id
-        WHERE attempts.attempt = $18::integer
-          AND attempts.lease_token = $19::text
+        WHERE attempts.attempt = $17::integer
+          AND attempts.lease_token = $18::text
           AND attempts.status IN ('claimed', 'running', 'waiting')
           AND NOT EXISTS (
             SELECT 1
@@ -4809,7 +4815,7 @@ async function submitPostgresSchedulerRunTransaction(
       ), admission AS (
         SELECT EXISTS (SELECT 1 FROM existing_run) AS existing_run,
         CASE
-          WHEN $16::text IS NULL THEN true
+          WHEN $15::text IS NULL THEN true
           ELSE EXISTS (
             SELECT 1
             FROM parent_run
@@ -4819,21 +4825,21 @@ async function submitPostgresSchedulerRunTransaction(
               )
               AND (
                 parent_run.release_id IS NULL
-                OR $12::text IS NULL
-                OR parent_run.release_id = $15::text
+                OR $11::text IS NULL
+                OR parent_run.release_id = $14::text
               )
-              AND parent_run.root_run_id = $17::text
+              AND parent_run.root_run_id = $16::text
               AND (
-                ($20::boolean = false AND $18::integer IS NULL AND $19::text IS NULL)
+                ($19::boolean = false AND $17::integer IS NULL AND $18::text IS NULL)
                 OR EXISTS (SELECT 1 FROM parent_attempt)
               )
           )
         END AS parent_accepting,
         CASE
-          WHEN $16::text IS NULL THEN true
-          WHEN $20::boolean = false
-            AND $18::integer IS NULL
-            AND $19::text IS NULL THEN true
+          WHEN $15::text IS NULL THEN true
+          WHEN $19::boolean = false
+            AND $17::integer IS NULL
+            AND $18::text IS NULL THEN true
           ELSE EXISTS (SELECT 1 FROM parent_attempt)
         END AS parent_attempt_current,
         EXISTS (
@@ -4844,13 +4850,13 @@ async function submitPostgresSchedulerRunTransaction(
         CASE
           -- A live descendant stays on its parent's pinned release even after
           -- that lane stops accepting unrelated new roots.
-          WHEN $16::text IS NOT NULL THEN true
-          WHEN $12::text IS NULL THEN true
+          WHEN $15::text IS NOT NULL THEN true
+          WHEN $11::text IS NULL THEN true
           ELSE coalesce((
             SELECT accepting
             FROM ${tableName('runtime_release_admission', options)}
-            WHERE release_id = $12
-               OR ($14::boolean AND release_id = $15)
+            WHERE release_id = $11
+               OR ($13::boolean AND release_id = $14)
             ORDER BY admission_epoch DESC, accepting ASC
             LIMIT 1
           ), true)
@@ -4873,9 +4879,9 @@ async function submitPostgresSchedulerRunTransaction(
           absurd_task_id,
           admission_json
         )
-        SELECT $1, $2, $3, $4, $5, $6, $7, $8::jsonb, $9::jsonb, 'queued',
+        SELECT $1, $2, $3, $4, $5, $6, $7, launch_payload.launch_json, coalesce(nullif(launch_payload.launch_json -> 'input', 'null'::jsonb), '{}'::jsonb), 'queued',
                (SELECT task_id FROM task_spawn),
-               $8::jsonb - ARRAY[
+               launch_payload.launch_json - ARRAY[
                  'executorToken',
                  'preloadedDbSessionUnwrapKey',
                  'preloadedDbSessions',
@@ -4885,6 +4891,7 @@ async function submitPostgresSchedulerRunTransaction(
                  'vercelProtectionBypassToken'
                ]::text[]
         FROM admission
+        CROSS JOIN launch_payload
         WHERE NOT existing_run
           AND accepting_new
           AND parent_accepting
@@ -4921,48 +4928,49 @@ async function submitPostgresSchedulerRunTransaction(
             'playName', $4::text,
             -- Optional lineage makes a projected async child discoverable
             -- from its terminal parent. Older envelopes omit these keys.
-            'parentRunId', $8::jsonb ->> 'parentRunId',
-            'rootRunId', $8::jsonb ->> 'rootRunId',
-            'asyncLaunchKey', $8::jsonb ->> 'asyncLaunchKey',
-            'asyncInvocationKey', $8::jsonb ->> 'asyncInvocationKey',
-            'asyncRequestFingerprint', $8::jsonb ->> 'asyncRequestFingerprint',
-            'asyncAncestryPlayIds', $8::jsonb -> 'asyncAncestryPlayIds',
-            'definitionName', $8::jsonb ->> 'definitionName',
-            'playReference', $8::jsonb ->> 'playReference',
-            'definitionScope', $8::jsonb ->> 'definitionScope',
-            'revisionId', $8::jsonb ->> 'revisionId',
-            'workflowFamilyKey', $8::jsonb ->> 'workflowFamilyKey',
+            'parentRunId', launch_payload.launch_json ->> 'parentRunId',
+            'rootRunId', launch_payload.launch_json ->> 'rootRunId',
+            'asyncLaunchKey', launch_payload.launch_json ->> 'asyncLaunchKey',
+            'asyncInvocationKey', launch_payload.launch_json ->> 'asyncInvocationKey',
+            'asyncRequestFingerprint', launch_payload.launch_json ->> 'asyncRequestFingerprint',
+            'asyncAncestryPlayIds', launch_payload.launch_json -> 'asyncAncestryPlayIds',
+            'definitionName', launch_payload.launch_json ->> 'definitionName',
+            'playReference', launch_payload.launch_json ->> 'playReference',
+            'definitionScope', launch_payload.launch_json ->> 'definitionScope',
+            'revisionId', launch_payload.launch_json ->> 'revisionId',
+            'workflowFamilyKey', launch_payload.launch_json ->> 'workflowFamilyKey',
             'artifactStorageKey', $7::text,
-            'artifactHash', $8::jsonb ->> 'artifactHash',
+            'artifactHash', launch_payload.launch_json ->> 'artifactHash',
             'graphHash', $5::text,
             'runtimeBackend', $6::text,
-            'schedulerBackend', $8::jsonb ->> 'schedulerBackend',
-            'schedulerSchema', $8::jsonb ->> 'schedulerSchema',
-            'executionProfile', $8::jsonb ->> 'executionProfile',
-            'runtimeReleaseId', $8::jsonb ->> 'runtimeReleaseId',
-            'runtimeDeployVersion', $8::jsonb ->> 'runtimeDeployVersion',
-            'runtimeCallbackBaseUrl', $8::jsonb ->> 'runtimeCallbackBaseUrl',
-            'coordinatorUrl', $8::jsonb ->> 'coordinatorUrl',
-            'coordinatorWorkerName', $8::jsonb ->> 'coordinatorWorkerName',
-            'runtimeWorkflowName', $8::jsonb ->> 'runtimeWorkflowName',
-            'runtimeHarnessWorkerName', $8::jsonb ->> 'runtimeHarnessWorkerName',
-            'maxCreditsPerRun', $8::jsonb -> 'maxCreditsPerRun',
-            'staticPipeline', $8::jsonb -> 'staticPipeline',
-            'source', $8::jsonb ->> 'source',
-            'triggerSource', $8::jsonb ->> 'triggerSource',
-            'inputFileId', $8::jsonb ->> 'inputFileId',
-            'inputBytes', $8::jsonb -> 'inputBytes',
-            'inputSha256', $8::jsonb ->> 'inputSha256',
-            'replayedFromRunId', $8::jsonb ->> 'replayedFromRunId',
-            'secretRefs', $8::jsonb -> 'secretRefs',
-            'inputSummary', $8::jsonb -> 'inputSummary'
+            'schedulerBackend', launch_payload.launch_json ->> 'schedulerBackend',
+            'schedulerSchema', launch_payload.launch_json ->> 'schedulerSchema',
+            'executionProfile', launch_payload.launch_json ->> 'executionProfile',
+            'runtimeReleaseId', launch_payload.launch_json ->> 'runtimeReleaseId',
+            'runtimeDeployVersion', launch_payload.launch_json ->> 'runtimeDeployVersion',
+            'runtimeCallbackBaseUrl', launch_payload.launch_json ->> 'runtimeCallbackBaseUrl',
+            'coordinatorUrl', launch_payload.launch_json ->> 'coordinatorUrl',
+            'coordinatorWorkerName', launch_payload.launch_json ->> 'coordinatorWorkerName',
+            'runtimeWorkflowName', launch_payload.launch_json ->> 'runtimeWorkflowName',
+            'runtimeHarnessWorkerName', launch_payload.launch_json ->> 'runtimeHarnessWorkerName',
+            'maxCreditsPerRun', launch_payload.launch_json -> 'maxCreditsPerRun',
+            'staticPipeline', launch_payload.launch_json -> 'staticPipeline',
+            'source', launch_payload.launch_json ->> 'source',
+            'triggerSource', launch_payload.launch_json ->> 'triggerSource',
+            'inputFileId', launch_payload.launch_json ->> 'inputFileId',
+            'inputBytes', launch_payload.launch_json -> 'inputBytes',
+            'inputSha256', launch_payload.launch_json ->> 'inputSha256',
+            'replayedFromRunId', launch_payload.launch_json ->> 'replayedFromRunId',
+            'secretRefs', launch_payload.launch_json -> 'secretRefs',
+            'inputSummary', launch_payload.launch_json -> 'inputSummary'
           )),
           ${causalOutboxCreatedAt('run_insert.run_id', options)}
         FROM run_insert
+        CROSS JOIN launch_payload
         -- Old Vercel launchers do not carry the immutable admission envelope.
         -- During a Convex-first rollout they retain their established start
         -- projection; only the new launcher opts into queued projection.
-        WHERE $8::jsonb ? 'playReference'
+        WHERE launch_payload.launch_json ? 'playReference'
         ON CONFLICT (event_id) DO NOTHING
         RETURNING run_id
       )
@@ -4996,7 +5004,7 @@ async function submitPostgresSchedulerRunTransaction(
              (SELECT launch_json FROM existing_run) AS existing_launch_json,
              CASE WHEN EXISTS (SELECT 1 FROM run_insert)
                          OR EXISTS (SELECT 1 FROM run_recovery)
-               THEN pg_notify($10, $11)
+               THEN pg_notify($9, $10)
              END
       FROM admission
     `,
@@ -5009,7 +5017,6 @@ async function submitPostgresSchedulerRunTransaction(
       input.runtimeBackend,
       input.artifactStorageKey,
       stringifyPostgresJson(input),
-      stringifyPostgresJson(input.input ?? {}),
       postgresSchedulerNotifyChannel('queue', options),
       JSON.stringify({ runId: input.runId, playName: input.playName }),
       releaseAdmissionKey,
@@ -5879,6 +5886,10 @@ export async function firePostgresSchedulerCronSchedule(
             'cron-schedule:' || $1::text
           )
         )
+      ), launch_payload AS MATERIALIZED (
+        -- The same payload boundary as ordinary admission: no large JSON
+        -- constants repeated through the occurrence and outbox query plan.
+        SELECT $6::jsonb AS launch_json
       ), matching_schedule AS MATERIALIZED (
         SELECT schedule.schedule_id
         FROM schedule_lock
@@ -5897,9 +5908,10 @@ export async function firePostgresSchedulerCronSchedule(
                coalesce(runs.admission_json, runs.launch_json) AS launch_json,
                ${quoteIdent(schemaName(options))}.runtime_launch_admission_matches(
                  coalesce(runs.admission_json, runs.launch_json),
-                 $6::jsonb
+                 launch_payload.launch_json
                ) AS matches_launch
         FROM matching_schedule
+        CROSS JOIN launch_payload
         JOIN ${tableName('runs', options)} AS runs ON runs.run_id = $5::text
       ), occurrence AS MATERIALIZED (
         SELECT EXISTS (SELECT 1 FROM matching_schedule) AS schedule_current,
@@ -5932,17 +5944,17 @@ export async function firePostgresSchedulerCronSchedule(
           absurd_task_id, admission_json
         )
         SELECT $5::text,
-               $6::jsonb ->> 'orgId',
-               NULLIF($6::jsonb ->> 'playId', ''),
-               $6::jsonb ->> 'playName',
-               $6::jsonb ->> 'graphHash',
-               $6::jsonb ->> 'runtimeBackend',
-               $6::jsonb ->> 'artifactStorageKey',
-               $6::jsonb,
-               coalesce($6::jsonb -> 'input', '{}'::jsonb),
+               launch_payload.launch_json ->> 'orgId',
+               NULLIF(launch_payload.launch_json ->> 'playId', ''),
+               launch_payload.launch_json ->> 'playName',
+               launch_payload.launch_json ->> 'graphHash',
+               launch_payload.launch_json ->> 'runtimeBackend',
+               launch_payload.launch_json ->> 'artifactStorageKey',
+               launch_payload.launch_json,
+               coalesce(launch_payload.launch_json -> 'input', '{}'::jsonb),
                'queued',
                (SELECT task_id FROM play_task_spawn),
-               $6::jsonb - ARRAY[
+               launch_payload.launch_json - ARRAY[
                  'executorToken',
                  'preloadedDbSessionUnwrapKey',
                  'preloadedDbSessions',
@@ -5952,6 +5964,7 @@ export async function firePostgresSchedulerCronSchedule(
                  'vercelProtectionBypassToken'
                ]::text[]
         FROM occurrence
+        CROSS JOIN launch_payload
         WHERE occurrence.schedule_current
           AND NOT occurrence.existing_run
         RETURNING run_id
@@ -5987,47 +6000,48 @@ export async function firePostgresSchedulerCronSchedule(
           run_insert.run_id,
           'run.created',
           jsonb_strip_nulls(jsonb_build_object(
-            'orgId', $6::jsonb ->> 'orgId',
-            'playId', $6::jsonb ->> 'playId',
-            'playName', $6::jsonb ->> 'playName',
-            'definitionName', $6::jsonb ->> 'definitionName',
-            'playReference', $6::jsonb ->> 'playReference',
-            'definitionScope', $6::jsonb ->> 'definitionScope',
-            'revisionId', $6::jsonb ->> 'revisionId',
-            'workflowFamilyKey', $6::jsonb ->> 'workflowFamilyKey',
-            'artifactStorageKey', $6::jsonb ->> 'artifactStorageKey',
-            'artifactHash', $6::jsonb ->> 'artifactHash',
-            'graphHash', $6::jsonb ->> 'graphHash',
-            'runtimeBackend', $6::jsonb ->> 'runtimeBackend',
-            'schedulerBackend', $6::jsonb ->> 'schedulerBackend',
-            'schedulerSchema', $6::jsonb ->> 'schedulerSchema',
-            'executionProfile', $6::jsonb ->> 'executionProfile',
-            'runtimeReleaseId', $6::jsonb ->> 'runtimeReleaseId',
-            'runtimeDeployVersion', $6::jsonb ->> 'runtimeDeployVersion',
-            'runtimeCallbackBaseUrl', $6::jsonb ->> 'runtimeCallbackBaseUrl',
-            'coordinatorUrl', $6::jsonb ->> 'coordinatorUrl',
-            'coordinatorWorkerName', $6::jsonb ->> 'coordinatorWorkerName',
-            'runtimeWorkflowName', $6::jsonb ->> 'runtimeWorkflowName',
-            'runtimeHarnessWorkerName', $6::jsonb ->> 'runtimeHarnessWorkerName',
-            'maxCreditsPerRun', $6::jsonb -> 'maxCreditsPerRun',
-            'triggerSource', $6::jsonb ->> 'triggerSource',
-            'source', $6::jsonb ->> 'source',
-            'staticPipeline', $6::jsonb -> 'staticPipeline',
-            'inputFileId', $6::jsonb ->> 'inputFileId',
-            'inputBytes', $6::jsonb -> 'inputBytes',
-            'inputSha256', $6::jsonb ->> 'inputSha256',
-            'replayedFromRunId', $6::jsonb ->> 'replayedFromRunId',
-            'parentRunId', $6::jsonb ->> 'parentRunId',
-            'rootRunId', $6::jsonb ->> 'rootRunId',
-            'asyncLaunchKey', $6::jsonb ->> 'asyncLaunchKey',
-            'asyncInvocationKey', $6::jsonb ->> 'asyncInvocationKey',
-            'asyncRequestFingerprint', $6::jsonb ->> 'asyncRequestFingerprint',
-            'asyncAncestryPlayIds', $6::jsonb -> 'asyncAncestryPlayIds',
-            'secretRefs', $6::jsonb -> 'secretRefs',
-            'inputSummary', $6::jsonb -> 'inputSummary'
+            'orgId', launch_payload.launch_json ->> 'orgId',
+            'playId', launch_payload.launch_json ->> 'playId',
+            'playName', launch_payload.launch_json ->> 'playName',
+            'definitionName', launch_payload.launch_json ->> 'definitionName',
+            'playReference', launch_payload.launch_json ->> 'playReference',
+            'definitionScope', launch_payload.launch_json ->> 'definitionScope',
+            'revisionId', launch_payload.launch_json ->> 'revisionId',
+            'workflowFamilyKey', launch_payload.launch_json ->> 'workflowFamilyKey',
+            'artifactStorageKey', launch_payload.launch_json ->> 'artifactStorageKey',
+            'artifactHash', launch_payload.launch_json ->> 'artifactHash',
+            'graphHash', launch_payload.launch_json ->> 'graphHash',
+            'runtimeBackend', launch_payload.launch_json ->> 'runtimeBackend',
+            'schedulerBackend', launch_payload.launch_json ->> 'schedulerBackend',
+            'schedulerSchema', launch_payload.launch_json ->> 'schedulerSchema',
+            'executionProfile', launch_payload.launch_json ->> 'executionProfile',
+            'runtimeReleaseId', launch_payload.launch_json ->> 'runtimeReleaseId',
+            'runtimeDeployVersion', launch_payload.launch_json ->> 'runtimeDeployVersion',
+            'runtimeCallbackBaseUrl', launch_payload.launch_json ->> 'runtimeCallbackBaseUrl',
+            'coordinatorUrl', launch_payload.launch_json ->> 'coordinatorUrl',
+            'coordinatorWorkerName', launch_payload.launch_json ->> 'coordinatorWorkerName',
+            'runtimeWorkflowName', launch_payload.launch_json ->> 'runtimeWorkflowName',
+            'runtimeHarnessWorkerName', launch_payload.launch_json ->> 'runtimeHarnessWorkerName',
+            'maxCreditsPerRun', launch_payload.launch_json -> 'maxCreditsPerRun',
+            'triggerSource', launch_payload.launch_json ->> 'triggerSource',
+            'source', launch_payload.launch_json ->> 'source',
+            'staticPipeline', launch_payload.launch_json -> 'staticPipeline',
+            'inputFileId', launch_payload.launch_json ->> 'inputFileId',
+            'inputBytes', launch_payload.launch_json -> 'inputBytes',
+            'inputSha256', launch_payload.launch_json ->> 'inputSha256',
+            'replayedFromRunId', launch_payload.launch_json ->> 'replayedFromRunId',
+            'parentRunId', launch_payload.launch_json ->> 'parentRunId',
+            'rootRunId', launch_payload.launch_json ->> 'rootRunId',
+            'asyncLaunchKey', launch_payload.launch_json ->> 'asyncLaunchKey',
+            'asyncInvocationKey', launch_payload.launch_json ->> 'asyncInvocationKey',
+            'asyncRequestFingerprint', launch_payload.launch_json ->> 'asyncRequestFingerprint',
+            'asyncAncestryPlayIds', launch_payload.launch_json -> 'asyncAncestryPlayIds',
+            'secretRefs', launch_payload.launch_json -> 'secretRefs',
+            'inputSummary', launch_payload.launch_json -> 'inputSummary'
           )),
           ${causalOutboxCreatedAt('run_insert.run_id', options)}
         FROM run_insert
+        CROSS JOIN launch_payload
         ON CONFLICT (event_id) DO NOTHING
       ), schedule_advance AS (
         UPDATE ${tableName(POSTGRES_SCHEDULER_CRON_SCHEDULES_TABLE, options)} AS schedule
@@ -8192,6 +8206,99 @@ export async function handoffPostgresSchedulerAttemptContinuation(
   return row ? { runId: row.run_id, eventId: row.event_id } : null;
 }
 
+/** Fixed-shape authority and callback data used by the execution relay. */
+const POSTGRES_SCHEDULER_LAUNCH_ROUTING_FIELDS = [
+  'runId',
+  'orgId',
+  'playName',
+  'userId',
+  'userEmail',
+  'baseUrl',
+  'runtimeApiBaseUrl',
+  'vercelProtectionBypassToken',
+  'absurdReleaseId',
+] as const;
+
+export type PostgresSchedulerLaunchRouting = Pick<
+  PlaySchedulerSubmitInput,
+  (typeof POSTGRES_SCHEDULER_LAUNCH_ROUTING_FIELDS)[number]
+>;
+
+/**
+ * The relay needs identity and routing, never customer input or the execution
+ * graph. Decode each stored document once and merge only the named scalars.
+ * Presence is separate from value: an admitted null must still override a
+ * repaired launch field, exactly as the complete JSONB merge does.
+ */
+export async function readPostgresSchedulerLaunchRouting(
+  client: PostgresSchedulerQueryClient,
+  runId: string,
+  options?: Pick<PostgresSchedulerOptions, 'schema'>,
+): Promise<PostgresSchedulerLaunchRouting | null> {
+  const fields = POSTGRES_SCHEDULER_LAUNCH_ROUTING_FIELDS;
+  const columns = fields.map((field) => `${quoteIdent(field)} text`).join(', ');
+  const startedAt = performance.now();
+  try {
+    const result = await client.query<PostgresSchedulerLaunchRouting>(
+      `
+        WITH routing AS MATERIALIZED (
+          SELECT ${fields
+            .flatMap((field) => [
+              `launch.${quoteIdent(field)} AS ${quoteIdent(`launch_${field}`)}`,
+              `admitted.${quoteIdent(field)} AS ${quoteIdent(`admitted_${field}`)}`,
+            ])
+            .join(', ')},
+            ARRAY(SELECT jsonb_object_keys(coalesce(runs.admission_json, '{}'::jsonb)))
+              AS admitted_fields
+          FROM ${tableName('runs', options)} AS runs
+          CROSS JOIN LATERAL jsonb_to_record(runs.launch_json) AS launch(${columns})
+          CROSS JOIN LATERAL jsonb_to_record(coalesce(runs.admission_json, '{}'::jsonb))
+            AS admitted(${columns})
+          WHERE runs.run_id = $1
+        )
+        SELECT ${fields
+          .map(
+            (field) =>
+              `CASE WHEN '${field}' = ANY(admitted_fields)
+                THEN ${quoteIdent(`admitted_${field}`)}
+                ELSE ${quoteIdent(`launch_${field}`)}
+              END AS ${quoteIdent(field)}`,
+          )
+          .join(', ')}
+        FROM routing
+      `,
+      [runId],
+    );
+    const routing = result.rows[0] ?? null;
+    if (
+      routing &&
+      (!routing.runId ||
+        !routing.orgId ||
+        !routing.playName ||
+        !routing.baseUrl)
+    ) {
+      throw new Error(
+        'Postgres scheduler launch routing is missing required fields.',
+      );
+    }
+    recordSchedulerLaunchRead({
+      caller: 'execution_gateway_routing',
+      releaseId: routing?.absurdReleaseId ?? null,
+      durationMs: performance.now() - startedAt,
+      outcome: routing ? 'found' : 'missing',
+    });
+    return routing;
+  } catch (error) {
+    recordSchedulerLaunchRead({
+      caller: 'execution_gateway_routing',
+      releaseId: null,
+      durationMs: performance.now() - startedAt,
+      outcome: 'error',
+    });
+    throw error;
+  }
+}
+
 export async function readPostgresSchedulerLaunch(
   client: PostgresSchedulerQueryClient,
   runId: string,
@@ -17807,32 +17914,28 @@ export async function dispatchRunLedgerOutboxToLedgerBatchOnceWithClientScope(
     const tokenAuthority = input.tokenAuthority ?? 'local_mint';
     const gatewayRuntimeApi =
       tokenAuthority === 'gateway'
-        ? await withClient((client) =>
-            loadPostgresSchedulerRuntimeApiForRun(
-              client,
-              first.runId,
-              first.leaseOwner
-                ? { eventId: first.eventId, leaseOwner: first.leaseOwner }
-                : null,
-              tokenAuthority,
-              options,
-              input.runtimeApi?.signal,
-            ),
+        ? await loadPostgresSchedulerRuntimeApiForRun(
+            withClient,
+            first.runId,
+            first.leaseOwner
+              ? { eventId: first.eventId, leaseOwner: first.leaseOwner }
+              : null,
+            tokenAuthority,
+            options,
+            input.runtimeApi?.signal,
           )
         : null;
     const resolvedRuntimeApi =
       gatewayRuntimeApi ??
       input.runtimeApi ??
-      (await withClient((client) =>
-        loadPostgresSchedulerRuntimeApiForRun(
-          client,
-          first.runId,
-          first.leaseOwner
-            ? { eventId: first.eventId, leaseOwner: first.leaseOwner }
-            : null,
-          tokenAuthority,
-          options,
-        ),
+      (await loadPostgresSchedulerRuntimeApiForRun(
+        withClient,
+        first.runId,
+        first.leaseOwner
+          ? { eventId: first.eventId, leaseOwner: first.leaseOwner }
+          : null,
+        tokenAuthority,
+        options,
       ));
     const runtimeApi = {
       ...resolvedRuntimeApi,
@@ -18111,24 +18214,64 @@ async function projectPostgresSchedulerStartEvent(
   });
 }
 
+export type RunLedgerDispatchLaunch = Pick<
+  PlaySchedulerSubmitInput,
+  | 'runId'
+  | 'playId'
+  | 'playName'
+  | 'executorToken'
+  | 'baseUrl'
+  | 'runtimeApiBaseUrl'
+  | 'runtimeTokenOrigin'
+  | 'orgId'
+  | 'runtimeAuthority'
+  | 'vercelProtectionBypassToken'
+>;
+
+/** Authority reads never transfer customer input, artifacts or execution graphs. */
+function runLedgerDispatchLaunchSql(alias: string): string {
+  const fields: (keyof RunLedgerDispatchLaunch)[] = [
+    'runId',
+    'playId',
+    'playName',
+    'executorToken',
+    'baseUrl',
+    'runtimeApiBaseUrl',
+    'runtimeTokenOrigin',
+    'orgId',
+    'runtimeAuthority',
+    'vercelProtectionBypassToken',
+  ];
+  return `jsonb_build_object(${fields
+    .map((field) => `'${field}', ${alias}.launch_json->'${field}'`)
+    .join(', ')})`;
+}
+
 async function loadPostgresSchedulerRuntimeApiForRun(
-  client: PostgresSchedulerQueryClient,
+  withClient: <T>(
+    operation: (client: PostgresSchedulerQueryClient) => Promise<T>,
+  ) => Promise<T>,
   runId: string,
   dispatchLease: { eventId: string; leaseOwner: string } | null,
   tokenAuthority: RunLedgerOutboxTokenAuthority,
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
   signal?: AbortSignal,
 ): Promise<WorkerRuntimeApiContext> {
-  const result = await client.query<{ launch_json: unknown }>(
-    `
-      SELECT launch_json
-      FROM ${tableName('runs', options)}
-      WHERE run_id = $1
-      LIMIT 1
-    `,
-    [runId],
+  // Release the scarce scheduler checkout before the token authority hop.
+  // A slow gateway must not retain either projector pool client, and its
+  // launch context must not hydrate customer execution graphs.
+  const result = await withClient((client) =>
+    client.query<{ launch_json: unknown }>(
+      `SELECT ${runLedgerDispatchLaunchSql('runs')} AS launch_json
+       FROM ${tableName('runs', options)} AS runs
+       WHERE run_id = $1
+       LIMIT 1`,
+      [runId],
+    ),
+  );
+  const launch: RunLedgerDispatchLaunch = parseLaunchJson(
+    result.rows[0]?.launch_json,
   );
-  const launch = parseLaunchJson(result.rows[0]?.launch_json);
   if (!launch?.baseUrl) {
     throw new Error(
       `Run-ledger outbox dispatcher cannot resolve runtime API context for ${runId}.`,
@@ -18169,7 +18312,7 @@ async function loadPostgresSchedulerRuntimeApiForRun(
 }
 
 async function requestRunLedgerDispatchToken(input: {
-  launch: PlaySchedulerSubmitInput;
+  launch: RunLedgerDispatchLaunch;
   eventId: string;
   leaseOwner: string;
   schedulerSchema: string | null;
@@ -18324,6 +18467,28 @@ export async function requestComputeBillingDispatchToken(input: {
   return body.executorToken;
 }
 
+/** Read only the immutable authority/routing fields under the same lease fence. */
+export async function readRunLedgerDispatchAuthorityForLease(
+  client: PostgresSchedulerQueryClient,
+  input: { runId: string; eventId: string; leaseOwner: string },
+  options?: Pick<PostgresSchedulerOptions, 'schema'>,
+): Promise<RunLedgerDispatchLaunch | null> {
+  const result = await client.query<{ launch_json: unknown }>(
+    `SELECT ${runLedgerDispatchLaunchSql('runs')} AS launch_json
+     FROM ${tableName('outbox', options)} outbox
+     JOIN ${tableName('runs', options)} runs ON runs.run_id = outbox.run_id
+     WHERE outbox.event_id = $1
+       AND outbox.run_id = $2
+       AND outbox.lease_owner = $3
+       AND outbox.lease_expires_at > now()
+       AND outbox.delivered_at IS NULL
+       AND outbox.failed_at IS NULL
+     LIMIT 1`,
+    [input.eventId, input.runId, input.leaseOwner],
+  );
+  return result.rows[0] ? parseLaunchJson(result.rows[0].launch_json) : null;
+}
+
 export async function readRunLedgerDispatchLaunchForLease(
   client: PostgresSchedulerQueryClient,
   input: { runId: string; eventId: string; leaseOwner: string },

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/scheduler-launch-read-observability.ts

@@ -12,6 +12,7 @@ export type SchedulerLaunchReadCaller =
   | 'runtime_worker_outbox_projection'
   | 'receipt_gateway_auth'
   | 'receipt_gateway_lazy'
+  | 'execution_gateway_routing'
   | 'test';
 
 export type SchedulerLaunchReadOutcome = 'found' | 'missing' | 'error';

package/dist/cli/index.js

@@ -3463,7 +3463,7 @@ var 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.240",
+  version: "0.3.241",
   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: {
     updatePreferences: 1

package/dist/cli/index.mjs

@@ -3458,7 +3458,7 @@ var 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.240",
+  version: "0.3.241",
   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: {
     updatePreferences: 1

package/dist/index.js

@@ -1276,7 +1276,7 @@ var 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.240",
+  version: "0.3.241",
   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: {
     updatePreferences: 1

package/dist/index.mjs

@@ -1180,7 +1180,7 @@ var 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.240",
+  version: "0.3.241",
   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: {
     updatePreferences: 1

package/dist/release.d.mts

@@ -149,7 +149,7 @@ type SdkRelease = {
     supportPolicy: SdkSupportPolicy;
 };
 declare const SDK_RELEASE: {
-    readonly version: "0.3.240";
+    readonly version: "0.3.241";
     readonly 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.";
     readonly packageCapabilities: {
         readonly updatePreferences: 1;

package/dist/release.d.ts

@@ -149,7 +149,7 @@ type SdkRelease = {
     supportPolicy: SdkSupportPolicy;
 };
 declare const SDK_RELEASE: {
-    readonly version: "0.3.240";
+    readonly version: "0.3.241";
     readonly 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.";
     readonly packageCapabilities: {
         readonly updatePreferences: 1;

package/dist/release.js

@@ -74,7 +74,7 @@ var 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.240",
+  version: "0.3.241",
   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: {
     updatePreferences: 1

package/dist/release.mjs

@@ -48,7 +48,7 @@ var 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.240",
+  version: "0.3.241",
   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: {
     updatePreferences: 1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepline",
-  "version": "0.3.240",
+  "version": "0.3.241",
   "description": "GTM data CLI and TypeScript SDK for coding agents",
   "license": "MIT",
   "homepage": "https://code.deepline.com",