deepline 0.3.149 → 0.3.151

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

@@ -1,5 +1,5 @@
 import { createWriteStream } from 'node:fs';
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { stat } from 'node:fs/promises';
 import { Readable } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
@@ -47,6 +47,7 @@ import {
   LEGACY_RUNTIME_RECEIPT_WIRE_HEADER,
 } from './/runtime-contract';
 import { PLAY_RUNTIME_API_COMPAT_PATH } from './/runtime-api-paths';
+import { buildRunLedgerEventsIdempotencyKey } from './run-ledger-projection-contract';
 import {
   RUNTIME_API_ACCEPTS_HEADER,
   gzipRuntimeApiRequestBody,
@@ -157,15 +158,21 @@ type RuntimeApiRequest =
       action: 'create_db_session';
     } & CreateDbSessionRequest)
   | {
-      action: 'append_run_events';
+      action: 'append_run_events' | 'project_run_events';
       playId: string;
       events: PlayRunLedgerIngressEvent[];
       idempotencyKey?: string;
+      deliveryIdempotencyKey?: string;
+      deliveryLeaseOwner?: string;
     }
   | {
       action: 'start_run';
+      deliveryLeaseOwner?: string;
       idempotencyKey?: string;
       playName: string;
+      playReference?: string | null;
+      definitionScope?: 'org' | 'system';
+      revisionId?: string | null;
       runId: string;
       artifactStorageKey?: string | null;
       artifactHash?: string | null;
@@ -200,6 +207,7 @@ type RuntimeApiRequest =
     }
   | {
       action: 'project_run_created';
+      deliveryLeaseOwner?: string;
       idempotencyKey: string;
       playName: string;
       playReference?: string | null;
@@ -736,7 +744,8 @@ function isRetryableAppRuntimeResponse(input: {
   // projection. Do not make every 403 retryable: only this exact Vercel HTML
   // response on a replay-safe action is an intermediary failure.
   if (
-    input.action === 'append_run_events' &&
+    (input.action === 'append_run_events' ||
+      input.action === 'project_run_events') &&
     isVercelSecurityCheckpointResponse(input)
   ) {
     return true;
@@ -964,6 +973,9 @@ function isRetryableAppRuntimeAction(
 ): boolean {
   return (
     action === 'append_run_events' ||
+    // Classification remains replay-safe for the durable outbox even though
+    // projectRunEventsViaAppRuntime disables in-process transport retries.
+    action === 'project_run_events' ||
     action === 'apply_row_updates' ||
     action === 'compute_billing_finalize' ||
     action === 'compute_billing_record_item' ||
@@ -2312,6 +2324,85 @@ async function appendRunEventsViaAppRuntimeRaw(
   });
 }
 
+/** Leased delivery only. Every transport piece has its own stable receipt. */
+export async function projectRunEventsViaAppRuntime(
+  context: WorkerRuntimeApiContext,
+  input: {
+    playId: string;
+    events: PlayRunLedgerIngressEvent[];
+    idempotencyKey: string;
+    deliveryLeaseOwner: string;
+    beforeBatch: () => Promise<void>;
+  },
+): Promise<void> {
+  const batches = partitionRunEventsForAppRuntime(input.events);
+  const receiptBatch = runLedgerReceiptBatchIndex(batches);
+  for (const [index, events] of batches.entries()) {
+    await input.beforeBatch();
+    // Retain the original receipt for the terminal (or final) piece so an acknowledged
+    // legacy delivery stays acknowledged across the reader rollout.
+    const idempotencyKey =
+      index === receiptBatch
+        ? input.idempotencyKey
+        : buildRunLedgerEventsIdempotencyKey({
+            runId: input.playId,
+            deliveryDigest: createHash('sha256')
+              .update(JSON.stringify([input.idempotencyKey, index, events]))
+              .digest('hex'),
+          });
+    const request = {
+      playId: input.playId,
+      events,
+      idempotencyKey,
+      deliveryIdempotencyKey: input.idempotencyKey,
+      deliveryLeaseOwner: input.deliveryLeaseOwner,
+    };
+    // The durable outbox owns recovery; this helper does not retry OCCs or
+    // other delivery failures inside an already-leased invocation.
+    const deliveryContext = { ...context, retryPolicy: 'none' as const };
+    try {
+      await postAppRuntimeApi(deliveryContext, {
+        action: 'project_run_events',
+        ...request,
+      });
+    } catch (error) {
+      if (
+        !(error instanceof AppRuntimeApiResponseError) ||
+        !isLegacyProjectRunCreatedUnsupportedActionResponse({
+          status: error.status,
+          body: error.detail,
+        })
+      )
+        throw error;
+      // Launch-pinned old apps already implement equivalent keyed projection.
+      // A real auth refusal never selects this compatibility adapter.
+      // The capability probe was a network round trip. Re-check ownership
+      // before the legacy request too; reclamation must stop a stale sender.
+      await input.beforeBatch();
+      await postAppRuntimeApi(deliveryContext, {
+        action: 'append_run_events',
+        ...request,
+      });
+    }
+  }
+}
+
+function runLedgerReceiptBatchIndex(
+  batches: PlayRunLedgerIngressEvent[][],
+): number {
+  for (let index = batches.length - 1; index >= 0; index -= 1) {
+    if (
+      batches[index]!.some((event) =>
+        ['run.completed', 'run.failed', 'run.cancelled'].includes(
+          event.key ?? event.type ?? '',
+        ),
+      )
+    )
+      return index;
+  }
+  return batches.length - 1;
+}
+
 /**
  * Append Run Ledger events through the bounded transport used by every runtime
  * producer. Scheduler terminal outbox events can carry a complete log replay,
@@ -2368,7 +2459,11 @@ export async function appendRunEventsViaAppRuntime(
 export async function startRunViaAppRuntime(
   context: WorkerRuntimeApiContext,
   input: {
+    deliveryLeaseOwner?: string;
     playName: string;
+    playReference?: string | null;
+    definitionScope?: 'org' | 'system';
+    revisionId?: string | null;
     runId: string;
     artifactStorageKey?: string | null;
     artifactHash?: string | null;

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

@@ -10,6 +10,13 @@ const UUID_PATTERN =
   /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 const SHA256_HEX_PATTERN = /^[0-9a-f]{64}$/i;
 
+export class RunLedgerProjectionLeaseLostError extends Error {
+  constructor() {
+    super('Run Ledger projection requires the current outbox delivery lease.');
+    this.name = 'RunLedgerProjectionLeaseLostError';
+  }
+}
+
 function requireRunId(runId: string): void {
   if (!runId.trim()) {
     throw new Error('Run Ledger projection idempotency key requires a run id.');

package/dist/bundling-sources/shared_libs/play-runtime/run-ledger.ts

@@ -760,6 +760,12 @@ function mergeMonotonicStepProgress(input: {
 }): PlayRunLedgerStepProgress {
   const current = input.current ?? {};
   const next = input.next;
+  const supersededRows = maxProgressNumber(
+    current.supersededRows,
+    next.supersededRows === undefined
+      ? undefined
+      : Math.max(0, next.supersededRows),
+  );
   return {
     ...current,
     ...next,
@@ -786,11 +792,7 @@ function mergeMonotonicStepProgress(input: {
           ),
         }
       : {}),
-    ...(next.supersededRows !== undefined
-      ? { supersededRows: Math.max(0, next.supersededRows) }
-      : current.supersededRows !== undefined
-        ? { supersededRows: current.supersededRows }
-        : {}),
+    ...(supersededRows !== undefined ? { supersededRows } : {}),
   };
 }
 

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

@@ -35,6 +35,7 @@ export const RUNTIME_OPERATION_CAPABILITIES = {
   create_db_session: 'db.session',
   repair_runtime_storage_grants: 'sheet.write',
   append_run_events: 'run.progress',
+  project_run_events: 'run.progress',
   save_results: 'run.progress',
   start_run: 'run.progress',
   record_first_claim_latency: 'run.progress',
@@ -56,6 +57,10 @@ export const RUNTIME_OPERATION_CONTRACT: DeployedOperationContract =
     id: 'runtime-api-actions',
     actions: RUNTIME_OPERATION_CAPABILITIES,
     olderReceiver: {
+      project_run_events: {
+        kind: 'equivalent-fallback',
+        action: 'append_run_events',
+      },
       // The runner retains the complete result before attempting this
       // compact completion. An older app receiver reports the action as
       // unsupported, and the adapter retries the established full-payload

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

@@ -250,7 +250,7 @@ export type PlaySchedulerRunHandle = {
     signal?: AbortSignal;
   }): AsyncIterable<PlaySchedulerProgressEvent>;
   /** Cooperatively cancel the run. */
-  cancel(): Promise<void>;
+  cancel(reason?: string): Promise<void>;
   /** Inject an external event (HITL, webhook). */
   signal(payload: PlaySchedulerSignalPayload): Promise<void>;
   /** Block until terminal state and return final envelope. */

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

@@ -216,14 +216,14 @@ function absurdRunHandle(input: {
     return error;
   };
 
-  const requestCancellation = async () => {
+  const requestCancellation = async (reason?: string) => {
     await runCancellationSingleFlight(cancellationKey, async () => {
       // First move the durable engine task into its cancellation lane. If the
       // scheduler tables are briefly locked, the worker reconciler can finish
       // the terminal write later without another user request piling up.
       await cancelAbsurdTask();
       try {
-        await delegate.cancel();
+        await delegate.cancel(reason);
       } catch (error) {
         throw cancellationPendingError(error);
       }