deepline 0.3.271 → 0.3.272

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

@@ -98,6 +98,15 @@ import {
   type PlayRunLedgerIngressEvent,
   type PlayRunLedgerTerminalWorkCounterSegment,
 } from '../run-ledger';
+import {
+  RUN_EVENT_KIND_SQL_LITERAL,
+  RUN_EVENT_KIND,
+  RUN_SCHEDULER_OUTBOX_START_EVENT_TYPES,
+  RUN_SCHEDULER_OUTBOX_EVENT_TYPE,
+  RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL,
+  RUN_SCHEDULER_OUTBOX_PREFIX_STOP_EVENT_TYPES,
+  RUN_SCHEDULER_OUTBOX_TERMINAL_EVENT_TYPES,
+} from '../run-event-catalog';
 import { stableStringify } from '../../plays/row-identity';
 import {
   runtimeWorkCountersFromResources,
@@ -928,13 +937,13 @@ export const POSTGRES_SCHEDULER_OUTBOX_DELIVERED_RETENTION_BATCH_LIMIT = 1_000;
 // eligibility test, including present-but-null log fields.
 const DELIVERED_OUTBOX_RAW_LOG_BODY_PREDICATE = `
   (
-    (event_type = 'run.events'
+    (event_type = ${RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL.runEvents}
       AND jsonb_typeof(payload_json->'events') = 'array'
-      AND payload_json @? 'strict $.events[*] ? (@.type == "log.appended" && (exists(@.lines) || exists(@.lineContexts)))'::jsonpath)
-    OR (event_type IN ('run.completed', 'run.failed')
+      AND payload_json @? 'strict $.events[*] ? (@.type == "${RUN_EVENT_KIND.logAppended}" && (exists(@.lines) || exists(@.lineContexts)))'::jsonpath)
+    OR (event_type IN (${RUN_EVENT_KIND_SQL_LITERAL.runCompleted}, ${RUN_EVENT_KIND_SQL_LITERAL.runFailed})
       AND (payload_json ? 'terminalLogLines'
         OR (jsonb_typeof(payload_json->'terminalProgressEvents') = 'array'
-          AND payload_json @? 'strict $.terminalProgressEvents[*] ? (@.type == "log.appended" && (exists(@.lines) || exists(@.lineContexts)))'::jsonpath)))
+          AND payload_json @? 'strict $.terminalProgressEvents[*] ? (@.type == "${RUN_EVENT_KIND.logAppended}" && (exists(@.lines) || exists(@.lineContexts)))'::jsonpath)))
   )`;
 const RUN_LEDGER_DISPATCH_TOKEN_TIMEOUT_MS = 15_000;
 const COMPUTE_BILLING_DISPATCH_TOKEN_TIMEOUT_MS = 15_000;
@@ -2252,7 +2261,7 @@ async function ensurePostgresSchedulerTerminalComputeBillingOutboxTrigger(
     LANGUAGE plpgsql
     AS $$
     BEGIN
-      IF NEW.event_type NOT IN ('run.completed', 'run.failed', 'run.cancelled') THEN
+      IF NEW.event_type NOT IN (${RUN_EVENT_KIND_SQL_LITERAL.runCompleted}, ${RUN_EVENT_KIND_SQL_LITERAL.runFailed}, ${RUN_EVENT_KIND_SQL_LITERAL.runCancelled}) THEN
         RETURN NEW;
       END IF;
 
@@ -3907,7 +3916,7 @@ export async function ensurePostgresSchedulerSchema(
       await client.query(`
         CREATE INDEX IF NOT EXISTS runtime_scheduler_outbox_admission_pending_idx
           ON ${tableName('outbox', options)} (
-            (CASE WHEN event_type = 'run.created' THEN 0 ELSE 1 END),
+            (CASE WHEN event_type = ${RUN_EVENT_KIND_SQL_LITERAL.runCreated} THEN 0 ELSE 1 END),
             coalesce(next_attempt_at, created_at),
             created_at,
             event_id
@@ -3923,7 +3932,7 @@ export async function ensurePostgresSchedulerSchema(
         CREATE INDEX IF NOT EXISTS runtime_scheduler_outbox_run_pending_order_idx
           ON ${tableName('outbox', options)} (
             run_id,
-            (CASE event_type WHEN 'run.created' THEN 0 WHEN 'run.started' THEN 1 ELSE 2 END),
+            (CASE event_type WHEN ${RUN_EVENT_KIND_SQL_LITERAL.runCreated} THEN 0 WHEN ${RUN_EVENT_KIND_SQL_LITERAL.runStarted} THEN 1 ELSE 2 END),
             created_at,
             event_id
           )
@@ -4075,7 +4084,7 @@ const POSTGRES_SCHEDULER_RUNTIME_ADMIN_INDEXES = [
     name: 'runtime_scheduler_outbox_run_pending_order_idx',
     table: 'outbox',
     definition: `(run_id,
-      (CASE event_type WHEN 'run.created' THEN 0 WHEN 'run.started' THEN 1 ELSE 2 END),
+      (CASE event_type WHEN ${RUN_EVENT_KIND_SQL_LITERAL.runCreated} THEN 0 WHEN ${RUN_EVENT_KIND_SQL_LITERAL.runStarted} THEN 1 ELSE 2 END),
       created_at, event_id)
       WHERE delivered_at IS NULL`,
   },
@@ -4105,7 +4114,7 @@ const POSTGRES_SCHEDULER_RUNTIME_ADMIN_INDEXES = [
     name: 'runtime_scheduler_outbox_admission_pending_idx',
     table: 'outbox',
     definition: `(
-      (CASE WHEN event_type = 'run.created' THEN 0 ELSE 1 END),
+      (CASE WHEN event_type = ${RUN_EVENT_KIND_SQL_LITERAL.runCreated} THEN 0 ELSE 1 END),
       coalesce(next_attempt_at, created_at),
       created_at,
       event_id
@@ -5145,7 +5154,7 @@ async function submitPostgresSchedulerRunTransaction(
         SELECT
           'run-created:' || run_insert.run_id,
           run_insert.run_id,
-          'run.created',
+          ${RUN_EVENT_KIND_SQL_LITERAL.runCreated},
           jsonb_strip_nulls(jsonb_build_object(
             'orgId', $2::text,
             'playId', $3::text,
@@ -6232,7 +6241,7 @@ export async function firePostgresSchedulerCronSchedule(
         SELECT
           'run-created:' || run_insert.run_id,
           run_insert.run_id,
-          'run.created',
+          ${RUN_EVENT_KIND_SQL_LITERAL.runCreated},
           jsonb_strip_nulls(jsonb_build_object(
             'orgId', launch_payload.launch_json ->> 'orgId',
             'playId', launch_payload.launch_json ->> 'playId',
@@ -7247,7 +7256,7 @@ export async function resumePostgresSchedulerDetachedRunnerAttempt(
         INSERT INTO ${tableName('outbox', options)} (
           event_id, run_id, event_type, payload_json, created_at
         )
-        SELECT $4, run_id, 'run.waiting', jsonb_build_object('kind', 'detached_runner'),
+        SELECT $4, run_id, ${RUN_EVENT_KIND_SQL_LITERAL.runWaiting}, jsonb_build_object('kind', 'detached_runner'),
                ${causalOutboxCreatedAt('restored_run.run_id', options)}
         FROM restored_run
         RETURNING run_id
@@ -7386,7 +7395,7 @@ export async function markPostgresSchedulerAttemptWaiting(
         SELECT
           $6,
           waiting_run.run_id,
-          'run.waiting',
+          ${RUN_EVENT_KIND_SQL_LITERAL.runWaiting},
           jsonb_strip_nulls(jsonb_build_object(
             'kind', NULLIF(btrim($4::jsonb ->> 'kind'), ''),
             'eventKey', NULLIF($7::text, ''),
@@ -7532,7 +7541,7 @@ export async function markPostgresSchedulerAttemptRunning(
         SELECT
           $4,
           running_run.run_id,
-          'run.resumed',
+          ${RUN_EVENT_KIND_SQL_LITERAL.runResumed},
           jsonb_strip_nulls(jsonb_build_object(
             'kind', NULLIF(btrim(running_run.suspension_json ->> 'kind'), ''),
             'eventKey',
@@ -7630,7 +7639,7 @@ export async function claimPostgresSchedulerCompletedDetachedRunnerTerminal(
         SELECT
           $3,
           run_id,
-          'run.resumed',
+          ${RUN_EVENT_KIND_SQL_LITERAL.runResumed},
           jsonb_build_object(
             'kind', 'detached_runner',
             'eventKey', 'detached_runner_terminal'
@@ -7776,7 +7785,7 @@ export async function claimPostgresSchedulerOverdueDetachedRunnerCeilings(
         SELECT
           $3 || ':' || running_runs.run_id,
           running_runs.run_id,
-          'run.resumed',
+          ${RUN_EVENT_KIND_SQL_LITERAL.runResumed},
           jsonb_build_object(
             'kind', 'detached_runner',
             'eventKey', 'detached_runner_hard_ceiling'
@@ -8037,7 +8046,7 @@ export async function failPostgresSchedulerScheduledChildWaits(
         SELECT
           'run-terminal:' || run_id,
           terminal_runs.run_id,
-          'run.failed',
+          ${RUN_EVENT_KIND_SQL_LITERAL.runFailed},
           jsonb_build_object('error', $2::text),
           ${causalOutboxCreatedAt('terminal_runs.run_id', options)}
         FROM terminal_runs
@@ -8303,7 +8312,7 @@ export async function claimPostgresSchedulerWaitingDetachedAttemptForTerminal(
         SELECT
           $4,
           running_run.run_id,
-          'run.resumed',
+          ${RUN_EVENT_KIND_SQL_LITERAL.runResumed},
           jsonb_build_object(
             'kind', 'detached_runner',
             'eventKey', 'detached_runner_terminal_salvage'
@@ -8712,7 +8721,7 @@ export async function handoffPostgresSchedulerAttemptContinuation(
         SELECT
           $6,
           continuation_run.run_id,
-          'run.resumed',
+          ${RUN_EVENT_KIND_SQL_LITERAL.runResumed},
           jsonb_strip_nulls(jsonb_build_object(
             'kind', NULLIF(btrim(continuation_run.suspension_json ->> 'kind'), ''),
             'eventKey',
@@ -10632,7 +10641,7 @@ export async function directCompletePostgresSchedulerRunnerTerminal(
         SELECT
           'run-terminal:' || run_id,
           run_terminal.run_id,
-          'run.completed',
+          ${RUN_EVENT_KIND_SQL_LITERAL.runCompleted},
           jsonb_build_object(
             'output', $6::jsonb,
             'producerAttempt', $2::integer,
@@ -13089,7 +13098,7 @@ export async function completePostgresSchedulerAttempt(
         SELECT
           'run-terminal:' || run_id,
           run_terminal.run_id,
-          'run.completed',
+          ${RUN_EVENT_KIND_SQL_LITERAL.runCompleted},
           jsonb_build_object(
             'output', $9::jsonb,
             'producerAttempt', $2::integer,
@@ -13425,7 +13434,7 @@ export async function failPostgresSchedulerAttempt(
         SELECT
           'run-terminal:' || run_id,
           run_terminal.run_id,
-          'run.failed',
+          ${RUN_EVENT_KIND_SQL_LITERAL.runFailed},
           jsonb_build_object(
             'error', $4::jsonb ->> 'message',
             'result', $8::jsonb,
@@ -13683,7 +13692,7 @@ export async function cancelPostgresSchedulerRun(
         SELECT
           'run-terminal:' || run_id,
           cancelled_run.run_id,
-          'run.cancelled',
+          ${RUN_EVENT_KIND_SQL_LITERAL.runCancelled},
           jsonb_build_object('error', $5::text),
           ${causalOutboxCreatedAt('cancelled_run.run_id', options)},
           NULL,
@@ -17071,7 +17080,12 @@ export async function appendPostgresRunLedgerEvents(
   const eventId = `run-events:${input.runId}:${createHash('sha256').update(payload).digest('hex')}`;
   return appendRunLedgerOutboxFact(
     client,
-    { ...input, eventId, eventType: 'run.events', payload },
+    {
+      ...input,
+      eventId,
+      eventType: RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runEvents,
+      payload,
+    },
     options,
   );
 }
@@ -17096,7 +17110,7 @@ export async function appendPostgresRunLedgerStart(
       orgId: input.orgId,
       runId: input.runId,
       eventId: `run-start-callback:${input.runId}`,
-      eventType: 'run.started',
+      eventType: RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runStarted,
       payload: stableStringify(
         prepareRetainedPlayPipelinesForTransport(input.start),
       ),
@@ -17111,7 +17125,9 @@ async function appendRunLedgerOutboxFact(
     orgId: string;
     runId: string;
     eventId: string;
-    eventType: 'run.events' | 'run.started';
+    eventType:
+      | typeof RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runEvents
+      | typeof RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runStarted;
     payload: string;
   },
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
@@ -17249,14 +17265,16 @@ export async function assertPostgresRunLedgerDelivery(
       prefixStopReason = 'predecessor_failed';
       break;
     }
-    if (prefix.length > 0 && row.event_type === 'run.events') break;
+    if (
+      prefix.length > 0 &&
+      row.event_type === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runEvents
+    )
+      break;
     prefix.push(row);
 
     const first = prefix[0]!;
     const terminal = prefix.find((candidate) =>
-      ['run.completed', 'run.failed', 'run.cancelled'].includes(
-        candidate.event_type,
-      ),
+      RUN_SCHEDULER_OUTBOX_TERMINAL_EVENT_TYPES.includes(candidate.event_type),
     );
     const prefixDigest = createHash('sha256')
       .update(prefix.map((candidate) => candidate.delivery_key).join('\n'))
@@ -17269,7 +17287,7 @@ export async function assertPostgresRunLedgerDelivery(
       });
     } else if (
       prefix.length === 1 &&
-      ['run.created', 'run.started'].includes(first.event_type)
+      RUN_SCHEDULER_OUTBOX_START_EVENT_TYPES.includes(first.event_type)
     ) {
       expectedKey = buildRunLedgerStartIdempotencyKey({
         runId: input.runId,
@@ -17292,7 +17310,7 @@ export async function assertPostgresRunLedgerDelivery(
     // Preserve the old singleton key for non-start, nonterminal facts.
     const legacySingletonKey =
       prefix.length === 1 &&
-      !['run.created', 'run.started'].includes(first.event_type) &&
+      !RUN_SCHEDULER_OUTBOX_START_EVENT_TYPES.includes(first.event_type) &&
       input.idempotencyKey ===
         buildRunLedgerTerminalIdempotencyKey({
           runId: input.runId,
@@ -17343,7 +17361,7 @@ export async function assertPostgresRunLedgerDelivery(
 
     if (
       prefix.length === 1 &&
-      ['run.created', 'run.started', 'run.events'].includes(first.event_type)
+      RUN_SCHEDULER_OUTBOX_PREFIX_STOP_EVENT_TYPES.includes(first.event_type)
     ) {
       break;
     }
@@ -17370,7 +17388,7 @@ function runLedgerPositionSql(alias: string): string {
 }
 
 function runLedgerOrderSql(alias: string): string {
-  return `CASE ${alias}.event_type WHEN 'run.created' THEN 0 WHEN 'run.started' THEN 1 ELSE 2 END, ${alias}.created_at, ${alias}.event_id`;
+  return `CASE ${alias}.event_type WHEN ${RUN_EVENT_KIND_SQL_LITERAL.runCreated} THEN 0 WHEN ${RUN_EVENT_KIND_SQL_LITERAL.runStarted} THEN 1 ELSE 2 END, ${alias}.created_at, ${alias}.event_id`;
 }
 
 /**
@@ -17453,7 +17471,7 @@ export async function readPendingPostgresSchedulerOutboxEvents(
         -- commit to first claim while the projector drained continuously).
         ORDER BY
           CASE
-            WHEN candidate.event_type = 'run.created' THEN 0
+            WHEN candidate.event_type = ${RUN_EVENT_KIND_SQL_LITERAL.runCreated} THEN 0
             WHEN candidate.event_id LIKE 'run-terminal:%' THEN 1
             ELSE 2
           END,
@@ -17471,12 +17489,12 @@ export async function readPendingPostgresSchedulerOutboxEvents(
           -- Admission is causally first and must be projected alone. A later
           -- start/terminal append may not leapfrog a delayed queued row.
           AND (
-            head.event_type NOT IN ('run.created', 'run.started', 'run.events')
+            head.event_type NOT IN (${RUN_EVENT_KIND_SQL_LITERAL.runCreated}, ${RUN_EVENT_KIND_SQL_LITERAL.runStarted}, ${RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL.runEvents})
             OR outbox.event_id = head.event_id
           )
           -- An ingress row already contains a producer's bounded batch. Keep
           -- its receipt stable independently of the recovery caller's limit.
-          AND (outbox.event_type <> 'run.events' OR outbox.event_id = head.event_id)
+          AND (outbox.event_type <> ${RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL.runEvents} OR outbox.event_id = head.event_id)
           AND coalesce(outbox.next_attempt_at, outbox.created_at) <= now()
           AND (
             $3::text IS NULL
@@ -17506,7 +17524,7 @@ export async function readPendingPostgresSchedulerOutboxEvents(
                   : 'true'
               }
               AND terminal_predecessor.event_type IN (
-                'run.completed', 'run.failed', 'run.cancelled'
+                ${RUN_EVENT_KIND_SQL_LITERAL.runCompleted}, ${RUN_EVENT_KIND_SQL_LITERAL.runFailed}, ${RUN_EVENT_KIND_SQL_LITERAL.runCancelled}
               )
               AND ${runLedgerPrecedesSql('terminal_predecessor', 'outbox')}
           )
@@ -17519,7 +17537,7 @@ export async function readPendingPostgresSchedulerOutboxEvents(
               AND predecessor.delivered_at IS NULL
               AND ${runLedgerPrecedesSql('predecessor', 'outbox')}
               AND (
-                predecessor.event_type = 'run.events'
+                predecessor.event_type = ${RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL.runEvents}
                 OR predecessor.failed_at IS NOT NULL
                 OR coalesce(predecessor.next_attempt_at, predecessor.created_at) > now()
                 OR (
@@ -17538,7 +17556,7 @@ export async function readPendingPostgresSchedulerOutboxEvents(
           SELECT 1
           FROM ${tableName('outbox', options)} AS candidate
           JOIN candidates ON candidates.event_id = candidate.event_id
-          WHERE candidate.event_type IN ('run.completed', 'run.failed', 'run.cancelled')
+          WHERE candidate.event_type IN (${RUN_EVENT_KIND_SQL_LITERAL.runCompleted}, ${RUN_EVENT_KIND_SQL_LITERAL.runFailed}, ${RUN_EVENT_KIND_SQL_LITERAL.runCancelled})
         ) AS has_terminal
       ), claimed AS (
         UPDATE ${tableName('outbox', options)} outbox
@@ -17861,11 +17879,11 @@ export async function purgePostgresSchedulerDeliveredOutboxRetentionBatch(
        )
        UPDATE ${tableName('outbox', options)} AS outbox
           SET payload_json = CASE
-            WHEN outbox.event_type = 'run.events' THEN jsonb_set(
+            WHEN outbox.event_type = ${RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL.runEvents} THEN jsonb_set(
               outbox.payload_json,
               '{events}',
               (SELECT jsonb_agg(
-                 CASE WHEN item.value->>'type' = 'log.appended'
+                 CASE WHEN item.value->>'type' = ${RUN_EVENT_KIND_SQL_LITERAL.logAppended}
                    THEN item.value - 'lines' - 'lineContexts'
                    ELSE item.value
                  END ORDER BY item.ordinality
@@ -17882,7 +17900,7 @@ export async function purgePostgresSchedulerDeliveredOutboxRetentionBatch(
                 outbox.payload_json - 'terminalLogLines' - 'terminalLogContexts',
                 '{terminalProgressEvents}',
                 coalesce((SELECT jsonb_agg(
-                   CASE WHEN item.value->>'type' = 'log.appended'
+                   CASE WHEN item.value->>'type' = ${RUN_EVENT_KIND_SQL_LITERAL.logAppended}
                      THEN item.value - 'lines' - 'lineContexts'
                      ELSE item.value
                    END ORDER BY item.ordinality
@@ -18237,7 +18255,10 @@ export async function releasePostgresSchedulerOutboxLease(
 function normalizeOutboxIngressPreview(
   event: PlayRunLedgerIngressEvent,
 ): PlayRunLedgerIngressEvent {
-  if (event.type !== 'step.progress' && event.key !== 'step.progress') {
+  if (
+    event.type !== RUN_EVENT_KIND.stepProgress &&
+    event.key !== RUN_EVENT_KIND.stepProgress
+  ) {
     return event;
   }
   const progress = recordPayload(event.progress);
@@ -18253,7 +18274,7 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
   event: PostgresSchedulerOutboxEvent,
 ): PlayRunLedgerIngressEvent[] {
   const occurredAt = event.createdAt.getTime();
-  if (event.eventType === 'run.events') {
+  if (event.eventType === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runEvents) {
     const events = payloadField(event.payload, 'events');
     const logsStored =
       payloadField(event.payload, 'logBodyStore') === 'planet_scale';
@@ -18281,10 +18302,10 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
       normalizeOutboxIngressPreview,
     );
   }
-  if (event.eventType === 'run.started') {
+  if (event.eventType === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runStarted) {
     return [
       {
-        type: 'run.started',
+        type: RUN_EVENT_KIND.runStarted,
         runId: event.runId,
         occurredAt,
         source: 'system',
@@ -18293,7 +18314,7 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
       },
     ];
   }
-  if (event.eventType === 'run.completed') {
+  if (event.eventType === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runCompleted) {
     const terminalWorkCounterSegment =
       normalizePlayRunLedgerTerminalWorkCounterSegment(
         payloadField(event.payload, 'terminalWorkCounterSegment'),
@@ -18312,7 +18333,7 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
         ? []
         : [
             {
-              type: 'log.appended',
+              type: RUN_EVENT_KIND.logAppended,
               runId: event.runId,
               occurredAt,
               source: 'worker',
@@ -18321,7 +18342,7 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
             } as PlayRunLedgerEvent,
           ]),
       {
-        type: 'run.completed',
+        type: RUN_EVENT_KIND.runCompleted,
         runId: event.runId,
         occurredAt,
         source: 'system',
@@ -18335,7 +18356,7 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
       },
     ];
   }
-  if (event.eventType === 'run.failed') {
+  if (event.eventType === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runFailed) {
     const terminalWorkCounterSegment =
       normalizePlayRunLedgerTerminalWorkCounterSegment(
         payloadField(event.payload, 'terminalWorkCounterSegment'),
@@ -18357,7 +18378,7 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
         ? []
         : [
             {
-              type: 'log.appended',
+              type: RUN_EVENT_KIND.logAppended,
               runId: event.runId,
               occurredAt,
               source: 'worker',
@@ -18366,7 +18387,7 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
             } as PlayRunLedgerEvent,
           ]),
       {
-        type: 'run.failed',
+        type: RUN_EVENT_KIND.runFailed,
         runId: event.runId,
         occurredAt,
         source: 'system',
@@ -18379,10 +18400,10 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
       },
     ];
   }
-  if (event.eventType === 'run.cancelled') {
+  if (event.eventType === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runCancelled) {
     return [
       {
-        type: 'run.cancelled',
+        type: RUN_EVENT_KIND.runCancelled,
         runId: event.runId,
         occurredAt,
         source: 'system',
@@ -18390,7 +18411,10 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
       } as PlayRunLedgerEvent,
     ];
   }
-  if (event.eventType === 'run.waiting' || event.eventType === 'run.resumed') {
+  if (
+    event.eventType === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runWaiting ||
+    event.eventType === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runResumed
+  ) {
     const waitKind = stringPayloadField(event.payload, 'kind');
     // A detached runner is still actively executing in a managed sandbox.
     // The scheduler parks its worker claim as an internal transport detail;
@@ -18404,10 +18428,12 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
       runId: event.runId,
       occurredAt,
       source: 'system',
-      ...(event.eventType === 'run.waiting' && waitKind !== null
+      ...(event.eventType === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runWaiting &&
+      waitKind !== null
         ? { waitKind }
         : {}),
-      ...(event.eventType === 'run.waiting' && waitUntil !== null
+      ...(event.eventType === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runWaiting &&
+      waitUntil !== null
         ? { waitUntil }
         : {}),
     } as PlayRunLedgerEvent;
@@ -18426,13 +18452,13 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
     if (waitKind !== null && !eventKey) return [lifecycle];
     const renderedEventKey = eventKey ?? 'event';
     const line =
-      event.eventType === 'run.waiting'
+      event.eventType === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runWaiting
         ? `Waiting for integration_event:${renderedEventKey}.`
         : `Resumed integration_event:${renderedEventKey}.`;
     return [
       lifecycle,
       {
-        type: 'log.appended',
+        type: RUN_EVENT_KIND.logAppended,
         runId: event.runId,
         occurredAt,
         source: 'system',
@@ -18440,11 +18466,11 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
       } as PlayRunLedgerEvent,
     ];
   }
-  if (event.eventType === 'run.wait_timeout') {
+  if (event.eventType === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runWaitTimeout) {
     const eventKey = stringPayloadField(event.payload, 'eventKey') ?? 'event';
     return [
       {
-        type: 'log.appended',
+        type: RUN_EVENT_KIND.logAppended,
         runId: event.runId,
         occurredAt,
         source: 'system',
@@ -18482,15 +18508,15 @@ export type PostgresSchedulerOutboxMaterializationPlan = {
   failureCode: string | null;
 };
 
-const RUN_LEDGER_KNOWN_OUTBOX_EVENT_TYPES = new Set([
-  'run.events',
-  'run.started',
-  'run.completed',
-  'run.failed',
-  'run.cancelled',
-  'run.waiting',
-  'run.resumed',
-  'run.wait_timeout',
+const RUN_LEDGER_KNOWN_OUTBOX_EVENT_TYPES: ReadonlySet<string> = new Set([
+  RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runEvents,
+  RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runStarted,
+  RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runCompleted,
+  RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runFailed,
+  RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runCancelled,
+  RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runWaiting,
+  RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runResumed,
+  RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runWaitTimeout,
 ]);
 
 /**
@@ -18508,7 +18534,8 @@ export function planPostgresSchedulerOutboxMaterialization(
   const projected = buildRunLedgerEventsFromPostgresSchedulerOutbox(event);
   const terminalRef = projected.some(
     (candidate) =>
-      (candidate.type === 'run.completed' || candidate.type === 'run.failed') &&
+      (candidate.type === RUN_EVENT_KIND.runCompleted ||
+        candidate.type === RUN_EVENT_KIND.runFailed) &&
       isLedgerTerminalResultRef(candidate.result),
   );
   const delivery = terminalRef
@@ -18967,7 +18994,7 @@ export async function dispatchRunLedgerOutboxToLedgerBatchOnceWithClientScope(
               input.headPriority === 'oldest_ready'
                 ? ''
                 : `CASE
-                       WHEN head.event_type = 'run.created' THEN 0
+                       WHEN head.event_type = ${RUN_EVENT_KIND_SQL_LITERAL.runCreated} THEN 0
                        WHEN head.event_id LIKE 'run-terminal:%' THEN 1
                        ELSE 2
                      END,`
@@ -19080,9 +19107,9 @@ export async function dispatchRunLedgerOutboxToLedgerBatchOnceWithClientScope(
     // A pending start is always claimed alone because later events require its
     // snapshot. It cannot share the append endpoint, so retain that mutation
     // as its own exact delivery.
-    if (first.eventType === 'run.created') {
+    if (first.eventType === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runCreated) {
       await projectPostgresSchedulerCreatedEvent(runtimeApi, first);
-    } else if (first.eventType === 'run.started') {
+    } else if (first.eventType === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runStarted) {
       const leaseOwner = first.leaseOwner;
       const launch = leaseOwner
         ? await withClient((client) =>
@@ -19106,9 +19133,7 @@ export async function dispatchRunLedgerOutboxToLedgerBatchOnceWithClientScope(
         const terminal = [...events]
           .reverse()
           .find((event) =>
-            ['run.completed', 'run.failed', 'run.cancelled'].includes(
-              event.eventType,
-            ),
+            RUN_SCHEDULER_OUTBOX_TERMINAL_EVENT_TYPES.includes(event.eventType),
           );
         const batchDeliveryKey = createHash('sha256')
           .update(events.map((event) => event.deliveryKey).join('\n'))