deepline 0.3.185 → 0.3.187

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

@@ -88,7 +88,6 @@ import {
   activeRuntimeSheetAttemptFenceSql,
   newerTerminalRuntimeSheetRowSql,
   releasableRuntimeSheetAttemptFenceSql,
-  sameOwnerTerminalAttemptEpochSql,
 } from './sheet-attempt-sql';
 import type { MapRowOutcome } from './durability-store';
 import { RUNTIME_CAPACITY_POLICY } from './runtime-capacity-policy';
@@ -7120,7 +7119,6 @@ export type RuntimeMapRowsWriteResult = {
 type RuntimeMapRowsMutationResult = {
   updated: number;
   fencedRows: RuntimeMapRowsStaleRow[];
-  conflictKeys: string[];
 };
 
 const RUNTIME_MAP_ROWS_STALE_REASONS: ReadonlySet<RuntimeMapRowsStaleReason> =
@@ -7310,7 +7308,6 @@ async function completeRuntimeMapRowChunks(
 ): Promise<RuntimeMapRowsMutationResult> {
   let updated = 0;
   const fencedRows: RuntimeMapRowsStaleRow[] = [];
-  const conflictKeys: string[] = [];
   for (const chunk of input.chunks) {
     const chunkKeys = chunk.map((row) => row.key);
     const chunkInputIndexes = chunk.map((row) => row.input_index);
@@ -7338,7 +7335,6 @@ async function completeRuntimeMapRowChunks(
       updated: number;
       matched_keys: string[];
       fenced_rows: unknown;
-      conflict_keys: string[];
     }>(
       `WITH updates AS (
          SELECT key_values._key,
@@ -7355,6 +7351,7 @@ async function completeRuntimeMapRowChunks(
        ),
        matched_updates AS (
          SELECT target._key AS matched_key,
+                updates._key AS submitted_key,
                 target._status AS prev_status,
                 target._cell_meta AS prev_cell_meta,
                 updates.input_index,
@@ -7364,40 +7361,6 @@ async function completeRuntimeMapRowChunks(
            JOIN ${sheetTable(session)} AS target
              ON target._key = updates._key
        ),
-       same_version_conflicts AS (
-         SELECT updates.matched_key AS _key
-           FROM matched_updates AS updates
-           JOIN ${sheetTable(session)} AS target
-             ON target._key = updates.matched_key
-          WHERE $13::bigint IS NOT NULL
-            AND target._write_version = $13::bigint
-            AND target._run_id = $5::text
-            AND target._status IN ('enriched', 'failed')
-            AND (
-              EXISTS (
-                SELECT 1
-                  FROM unnest($8::text[]) AS field_values(field)
-                 WHERE target._cell_meta -> field_values.field ->> 'runId' = $5::text
-              )
-              OR (
-                coalesce(target._attempt_owner_run_id, target._run_id) = $10::text
-                AND COALESCE(target._attempt_seq, 0) = $12::integer
-              )
-            )
-            AND (
-              target._status <> 'enriched'
-              OR (${targetChangedPatchedCellSql})
-            )
-            -- First terminal wins: suppress conflict for same owner+epoch already-terminal row.
-            -- Durable replay (omitted_terminal_replay) from same attempt epoch is idempotent.
-            AND NOT (
-              $10::text IS NOT NULL
-              AND $12::integer IS NOT NULL
-              AND target._status = 'enriched'
-              AND coalesce(target._attempt_owner_run_id, target._run_id) = $10::text
-              AND COALESCE(target._attempt_seq, 0) = $12::integer
-            )
-       ),
        applied_rows AS (
          UPDATE ${sheetTable(session)} AS target
          SET _status = 'enriched',
@@ -7414,7 +7377,6 @@ async function completeRuntimeMapRowChunks(
              _cell_meta = ${mergeRuntimeCellMetaPatchSql('target._cell_meta', 'updates.cell_meta_patch')}${input.physicalUpdateSetSql}
          FROM matched_updates AS updates
          WHERE target._key = updates.matched_key
-                   AND NOT EXISTS (SELECT 1 FROM same_version_conflicts)
 		           AND ($13::bigint IS NULL OR target._write_version = $13::bigint)
                    AND ($13::bigint IS NOT NULL OR target._status <> 'enriched')
 		           AND NOT (${newerTerminalRuntimeSheetRowSql('target', '$11::timestamptz', '$12::integer', '$9::text', '$10::text')})
@@ -7424,14 +7386,27 @@ async function completeRuntimeMapRowChunks(
              OR ($9::text IS NOT NULL AND ${activeRuntimeSheetAttemptFenceSql('target', '$9::text', '$10::text', '$11::timestamptz', '$12::integer')})
 		             OR ($9::text IS NOT NULL AND ${writableEnrichedAttemptSql})
            )
-           -- First terminal wins: skip UPDATE for already-terminal same-owner+epoch row.
-           -- Even though we excluded from conflicts, we still no-op here for idempotency.
+           -- A same-version enriched row is already the durable result for this
+           -- logical run. Provider retries may produce a different payload or
+           -- timestamp; preserve the first terminal value. Input-index repair
+           -- remains writable when the submitted key itself changed.
            AND NOT (
-             $10::text IS NOT NULL
-             AND $12::integer IS NOT NULL
+             $13::bigint IS NOT NULL
+             AND target._write_version = $13::bigint
+             AND target._run_id = $5::text
              AND target._status = 'enriched'
-             AND coalesce(target._attempt_owner_run_id, target._run_id) = $10::text
-             AND COALESCE(target._attempt_seq, 0) = $12::integer
+             AND updates.submitted_key = target._key
+             AND (
+               EXISTS (
+                 SELECT 1
+                   FROM unnest($8::text[]) AS field_values(field)
+                  WHERE target._cell_meta -> field_values.field ->> 'runId' = $5::text
+               )
+               OR (
+                 $10::text IS NOT NULL
+                 AND target._attempt_owner_run_id IS NOT DISTINCT FROM $10::text
+               )
+             )
            )
            AND (
              target._status <> 'enriched'
@@ -7564,7 +7539,6 @@ async function completeRuntimeMapRowChunks(
          (SELECT count(*)::int FROM applied_rows) AS updated,
          coalesce((SELECT array_agg(matched_key) FROM matched_updates), '{}'::text[]) AS matched_keys,
          coalesce((SELECT jsonb_agg(jsonb_build_object('key', _key, 'reason', reason, 'rowVersionStamp', row_write_version)) FROM fenced_rows), '[]'::jsonb) AS fenced_rows,
-         coalesce((SELECT array_agg(_key) FROM same_version_conflicts), '{}'::text[]) AS conflict_keys,
          (SELECT count(*)::int FROM summary_delta) AS summary_delta_count,
          (SELECT count(*)::int FROM column_delta) AS column_delta_count`,
       [
@@ -7585,19 +7559,12 @@ async function completeRuntimeMapRowChunks(
     );
     const matchedKeys = new Set(rows[0]?.matched_keys ?? []);
     const chunkFencedRows = parseRuntimeMapRowsFencedRows(rows[0]?.fenced_rows);
-    const chunkConflictKeys = rows[0]?.conflict_keys ?? [];
     // An exact-version replay that already produced the same terminal value is
     // accepted idempotently even when SQL has no physical mutation to apply.
     // Stale versions remain excluded through fenced_rows.
     const appliedCount = Number(rows[0]?.updated ?? 0);
     updated += appliedCount;
     fencedRows.push(...chunkFencedRows);
-    conflictKeys.push(...chunkConflictKeys);
-
-    if (chunkConflictKeys.length > 0) {
-      continue;
-    }
-
     if (matchedKeys.size === chunk.length) {
       continue;
     }
@@ -7615,9 +7582,8 @@ async function completeRuntimeMapRowChunks(
     );
     updated += repaired.updated;
     fencedRows.push(...repaired.fencedRows);
-    conflictKeys.push(...repaired.conflictKeys);
   }
-  return { updated, fencedRows, conflictKeys };
+  return { updated, fencedRows };
 }
 
 async function completeRuntimeMapRowChunksWithInputIndexRepair(
@@ -7627,7 +7593,6 @@ async function completeRuntimeMapRowChunksWithInputIndexRepair(
 ): Promise<RuntimeMapRowsMutationResult> {
   let updated = 0;
   const fencedRows: RuntimeMapRowsStaleRow[] = [];
-  const conflictKeys: string[] = [];
   for (const chunk of input.chunks) {
     const chunkKeys = chunk.map((row) => row.key);
     const chunkInputIndexes = chunk.map((row) => row.input_index);
@@ -7647,7 +7612,6 @@ async function completeRuntimeMapRowChunksWithInputIndexRepair(
     const { rows } = await client.query<{
       _key?: string;
       fenced_rows?: unknown;
-      conflict_keys?: string[];
       updated?: number;
     }>(
       `WITH updates AS (
@@ -7679,40 +7643,6 @@ async function completeRuntimeMapRowChunksWithInputIndexRepair(
              )
           ORDER BY target._key, (target._key = updates._key) DESC
        ),
-       same_version_conflicts AS (
-         SELECT updates.submitted_key AS _key
-           FROM matched_updates AS updates
-           JOIN ${sheetTable(session)} AS target
-             ON target._key = updates.matched_key
-          WHERE $13::bigint IS NOT NULL
-            AND target._write_version = $13::bigint
-            AND target._run_id = $5::text
-            AND target._status IN ('enriched', 'failed')
-            AND (
-              EXISTS (
-                SELECT 1
-                  FROM unnest($8::text[]) AS field_values(field)
-                 WHERE target._cell_meta -> field_values.field ->> 'runId' = $5::text
-              )
-              OR (
-                coalesce(target._attempt_owner_run_id, target._run_id) = $10::text
-                AND COALESCE(target._attempt_seq, 0) = $12::integer
-              )
-            )
-            AND (
-              target._status <> 'enriched'
-              OR (${targetChangedPatchedCellSql})
-            )
-            -- First terminal wins: suppress conflict for same owner+epoch already-terminal row.
-            -- Durable replay (omitted_terminal_replay) from same attempt epoch is idempotent.
-            AND NOT (
-              $10::text IS NOT NULL
-              AND $12::integer IS NOT NULL
-              AND target._status = 'enriched'
-              AND coalesce(target._attempt_owner_run_id, target._run_id) = $10::text
-              AND COALESCE(target._attempt_seq, 0) = $12::integer
-            )
-       ),
        applied_rows AS (
          UPDATE ${sheetTable(session)} AS target
          SET _status = 'enriched',
@@ -7730,14 +7660,31 @@ async function completeRuntimeMapRowChunksWithInputIndexRepair(
          FROM matched_updates AS updates, ${sheetTable(session)} AS prev
          WHERE target._key = updates.matched_key
            AND prev._key = target._key
-           AND NOT EXISTS (SELECT 1 FROM same_version_conflicts)
            AND ($13::bigint IS NULL OR target._write_version = $13::bigint)
            AND ($13::bigint IS NOT NULL OR target._status <> 'enriched')
 		           AND NOT (${newerTerminalRuntimeSheetRowSql('target', '$11::timestamptz', '$12::integer', '$9::text', '$10::text')})
            AND (
              ($9::text IS NULL AND target._run_id = $5::text)
              OR ($9::text IS NOT NULL AND ${activeRuntimeSheetAttemptFenceSql('target', '$9::text', '$10::text', '$11::timestamptz', '$12::integer')})
-		             OR ($9::text IS NOT NULL AND ${writableEnrichedAttemptSql})
+           OR ($9::text IS NOT NULL AND ${writableEnrichedAttemptSql})
+           )
+           AND NOT (
+             $13::bigint IS NOT NULL
+             AND target._write_version = $13::bigint
+             AND target._run_id = $5::text
+             AND target._status = 'enriched'
+             AND updates.submitted_key = target._key
+             AND (
+               EXISTS (
+                 SELECT 1
+                   FROM unnest($8::text[]) AS field_values(field)
+                  WHERE target._cell_meta -> field_values.field ->> 'runId' = $5::text
+               )
+               OR (
+                 $10::text IS NOT NULL
+                 AND target._attempt_owner_run_id IS NOT DISTINCT FROM $10::text
+               )
+             )
            )
            AND (
              target._status <> 'enriched'
@@ -7866,8 +7813,7 @@ async function completeRuntimeMapRowChunksWithInputIndexRepair(
        )
        SELECT
          (SELECT count(*)::int FROM applied_rows) AS updated,
-         coalesce((SELECT jsonb_agg(jsonb_build_object('key', _key, 'reason', reason, 'rowVersionStamp', row_write_version)) FROM fenced_rows), '[]'::jsonb) AS fenced_rows,
-         coalesce((SELECT array_agg(_key) FROM same_version_conflicts), '{}'::text[]) AS conflict_keys`,
+         coalesce((SELECT jsonb_agg(jsonb_build_object('key', _key, 'reason', reason, 'rowVersionStamp', row_write_version)) FROM fenced_rows), '[]'::jsonb) AS fenced_rows`,
       [
         chunkKeys,
         chunkInputIndexes,
@@ -7886,9 +7832,8 @@ async function completeRuntimeMapRowChunksWithInputIndexRepair(
     );
     updated += Number(rows[0]?.updated ?? 0);
     fencedRows.push(...parseRuntimeMapRowsFencedRows(rows[0]?.fenced_rows));
-    conflictKeys.push(...(rows[0]?.conflict_keys ?? []));
   }
-  return { updated, fencedRows, conflictKeys };
+  return { updated, fencedRows };
 }
 
 async function insertMissingCompletedMapRowChunks(
@@ -8084,7 +8029,6 @@ async function failRuntimeMapRowChunks(
 ): Promise<RuntimeMapRowsMutationResult> {
   let updated = 0;
   const fencedRows: RuntimeMapRowsStaleRow[] = [];
-  const conflictKeys: string[] = [];
   for (const chunk of input.chunks) {
     const chunkKeys = chunk.map((row) => row.key);
     const chunkInputIndexes = chunk.map((row) => row.input_index);
@@ -8117,7 +8061,6 @@ async function failRuntimeMapRowChunks(
     const { rows } = await client.query<{
       updated?: number;
       fenced_rows?: unknown;
-      conflict_keys?: string[];
     }>(
       `WITH updates AS (
          SELECT key_values._key,
@@ -8138,6 +8081,7 @@ async function failRuntimeMapRowChunks(
        matched_updates AS (
          SELECT DISTINCT ON (target._key)
                 target._key AS matched_key,
+                updates._key AS submitted_key,
                 updates.data_patch,
                 updates.cell_meta_patch,
                 updates.error
@@ -8151,42 +8095,6 @@ async function failRuntimeMapRowChunks(
              )
           ORDER BY target._key, (target._key = updates._key) DESC
        ),
-       same_version_conflicts AS (
-         SELECT updates.matched_key AS _key
-           FROM matched_updates AS updates
-           JOIN ${sheetTable(session)} AS target
-             ON target._key = updates.matched_key
-          WHERE $16::bigint IS NOT NULL
-            AND target._write_version = $16::bigint
-            AND target._run_id = $6::text
-            AND target._status IN ('enriched', 'failed')
-            AND (
-              EXISTS (
-                SELECT 1
-                  FROM unnest($9::text[]) AS field_values(field)
-                 WHERE target._cell_meta -> field_values.field ->> 'runId' = $6::text
-              )
-              OR (
-                coalesce(target._attempt_owner_run_id, target._run_id) = $12::text
-                AND COALESCE(target._attempt_seq, 0) = $14::integer
-              )
-            )
-            AND (
-              target._status <> 'failed'
-              OR target._error IS DISTINCT FROM updates.error
-              OR (${targetChangedPatchedCellSql})
-            )
-            -- Same-owner terminal replay is not a conflict. Normal replay
-            -- preserves the first value below; explicit force-failure may update it.
-            -- Different owners and attempt epochs still conflict.
-            AND NOT (
-              $12::text IS NOT NULL
-              AND $14::integer IS NOT NULL
-              AND target._status IN ('failed', 'enriched')
-              AND coalesce(target._attempt_owner_run_id, target._run_id) = $12::text
-              AND COALESCE(target._attempt_seq, 0) = $14::integer
-            )
-       ),
        applied_rows AS (
          UPDATE ${sheetTable(session)} AS target
          SET _status = 'failed',
@@ -8203,7 +8111,6 @@ async function failRuntimeMapRowChunks(
              _cell_meta = ${mergeRuntimeCellMetaPatchSql('target._cell_meta', 'updates.cell_meta_patch')}${input.physicalUpdateSetSql}
          FROM matched_updates AS updates, ${sheetTable(session)} AS prev
          WHERE target._key = updates.matched_key
-           AND NOT EXISTS (SELECT 1 FROM same_version_conflicts)
            AND ($16::bigint IS NULL OR target._write_version = $16::bigint)
            AND prev._key = target._key
            AND ($15::boolean OR target._status <> 'enriched')
@@ -8212,15 +8119,16 @@ async function failRuntimeMapRowChunks(
              ($11::text IS NULL AND target._run_id = $6::text)
              OR ($11::text IS NOT NULL AND ${activeRuntimeSheetAttemptFenceSql('target', '$11::text', '$12::text', '$13::timestamptz', '$14::integer')})
 	           )
-           -- First terminal wins for failed rows too, BUT only when NOT force-failing.
-           -- Normal replay: no-op when already-failed OR already-enriched from same owner+epoch.
+           -- Normal replay preserves the first terminal value for an exact
+           -- same-version key. Force-failure is the explicit teardown escape
+           -- hatch and may still overwrite it.
            AND NOT (
              $15::boolean = FALSE
-             AND $12::text IS NOT NULL
-             AND $14::integer IS NOT NULL
+             AND $16::bigint IS NOT NULL
+             AND target._write_version = $16::bigint
+             AND target._run_id = $6::text
              AND target._status IN ('failed', 'enriched')
-             AND coalesce(target._attempt_owner_run_id, target._run_id) = $12::text
-             AND COALESCE(target._attempt_seq, 0) = $14::integer
+             AND updates.submitted_key = target._key
            )
          RETURNING target._key, prev._status AS prev_status
        ),
@@ -8317,8 +8225,7 @@ async function failRuntimeMapRowChunks(
        )
        SELECT
          (SELECT count(*)::int FROM applied_rows) AS updated,
-         coalesce((SELECT jsonb_agg(jsonb_build_object('key', _key, 'reason', reason, 'rowVersionStamp', row_write_version)) FROM fenced_rows), '[]'::jsonb) AS fenced_rows,
-         coalesce((SELECT array_agg(_key) FROM same_version_conflicts), '{}'::text[]) AS conflict_keys`,
+         coalesce((SELECT jsonb_agg(jsonb_build_object('key', _key, 'reason', reason, 'rowVersionStamp', row_write_version)) FROM fenced_rows), '[]'::jsonb) AS fenced_rows`,
       [
         chunkKeys,
         chunkInputIndexes,
@@ -8340,12 +8247,10 @@ async function failRuntimeMapRowChunks(
     );
     const appliedCount = Number(rows[0]?.updated ?? 0);
     const chunkFencedRows = parseRuntimeMapRowsFencedRows(rows[0]?.fenced_rows);
-    const chunkConflictKeys = rows[0]?.conflict_keys ?? [];
     updated += appliedCount;
     fencedRows.push(...chunkFencedRows);
-    conflictKeys.push(...chunkConflictKeys);
   }
-  return { updated, fencedRows, conflictKeys };
+  return { updated, fencedRows };
 }
 
 /**
@@ -8556,10 +8461,9 @@ export async function completeRuntimeMapRows(
               return {
                 updated: updated.updated + inserted.inserted,
                 fencedRows: updated.fencedRows,
-                conflictKeys: updated.conflictKeys,
               };
             })()
-          : { updated: 0, fencedRows: [], conflictKeys: [] };
+          : { updated: 0, fencedRows: [] };
       const failed =
         failedRows.length > 0
           ? await failRuntimeMapRowChunks(client, session, {
@@ -8578,17 +8482,7 @@ export async function completeRuntimeMapRows(
                 input.tableNamespace,
               ),
             })
-          : { updated: 0, fencedRows: [], conflictKeys: [] };
-      const conflictKeys = [...completed.conflictKeys, ...failed.conflictKeys];
-      if (conflictKeys.length > 0) {
-        throw new Error(
-          `Runtime Sheet received the same write version with a different terminal payload for row(s): ${[
-            ...new Set(conflictKeys),
-          ]
-            .slice(0, 10)
-            .join(', ')}.`,
-        );
-      }
+          : { updated: 0, fencedRows: [] };
       return classifyRuntimeMapRowsWrite({
         submittedKeys: uniqueRows.keys(),
         updated: completed.updated + failed.updated,

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

@@ -41,6 +41,12 @@ export type PlayRunLaunchConflictTelemetryInput = {
   artifactHash?: string | null;
   graphHash?: string | null;
   inputSha256?: string | null;
+  /** Named-intent digest of the incoming durable launch envelope. */
+  launchIdentityDigest?: string | null;
+  /** Admission-side conflict classification when available. */
+  conflictReason?: string | null;
+  /** Named launch-intent fields that differed, when the persisted envelope is available. */
+  conflictingFields?: readonly string[] | null;
   error?: unknown;
 };
 
@@ -113,6 +119,9 @@ export function buildPlayRunLaunchConflictTelemetry(
       revisionId: input.revisionId ?? null,
       artifactHash: input.artifactHash ?? null,
       graphHash: input.graphHash ?? null,
+      launchIdentityDigest: input.launchIdentityDigest ?? null,
+      conflictReason: input.conflictReason ?? null,
+      conflictingFields: input.conflictingFields ?? null,
       triage:
         level === 'error'
           ? {

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

@@ -216,6 +216,13 @@ export type PlaySchedulerSubmitInput = {
   runtimeTestFaultHeader?: string | null;
   /** Request-scoped, dev-only runtime policy overrides for black-box durability tests. */
   testPolicyOverrides?: RuntimeTestPolicyOverrides | null;
+  /**
+   * Digest of the named intent behind this launch. Runtime admission compares
+   * this optional field instead of treating transport and execution details as
+   * immutable identity. Older persisted rows omit it and keep the legacy
+   * comparison until they are gone.
+   */
+  launchIdentityDigest?: string | null;
   /** Millisecond epoch timestamp captured immediately before scheduler submit. */
   submittedAtMs?: number;
   /** Scheduler backend that owns orchestration for this run. */