deepline 0.3.223 → 0.3.225

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.223',
+  version: '0.3.225',
   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/app-runtime-api.ts

@@ -51,9 +51,11 @@ import {
 import { PLAY_RUNTIME_API_COMPAT_PATH } from './/runtime-api-paths';
 import {
   buildRunLedgerEventsIdempotencyKey,
+  isRunLedgerProjectionMismatchDiagnostic,
   isRunLedgerProjectionLeaseLostReason,
   type RunLedgerProjectionChunk,
   type RunLedgerProjectionLeaseLostReason,
+  type RunLedgerProjectionMismatchDiagnostic,
 } from './run-ledger-projection-contract';
 import { partitionRunEventsForAppRuntime } from './run-ledger-event-transport';
 import {
@@ -851,6 +853,21 @@ function appRuntimeFailureReason(
   }
 }
 
+function appRuntimeProjectionMismatch(
+  responseCode: string | null,
+  body: string,
+): RunLedgerProjectionMismatchDiagnostic | null {
+  if (responseCode !== 'RUN_LEDGER_DELIVERY_LEASE_LOST') return null;
+  try {
+    const parsed = JSON.parse(body) as { projectionMismatch?: unknown };
+    return isRunLedgerProjectionMismatchDiagnostic(parsed.projectionMismatch)
+      ? parsed.projectionMismatch
+      : null;
+  } catch {
+    return null;
+  }
+}
+
 export function isTransientAppRuntimeFailureBody(body: string): boolean {
   return /WorkerOverloaded|"\s*code\s*"\s*:\s*"\s*InternalServerError\s*"|Your request couldn't be completed\. Try again later\.|timeout exceeded when trying to connect|timed out|fetch failed|ECONNRESET|ECONNREFUSED|UND_ERR_CONNECT_TIMEOUT|tuple concurrently updated|RUNTIME_SCHEDULER_(?:SATURATED|UNAVAILABLE|SCHEMA_NOT_READY)|Runtime scheduler DB pool is saturated|Runtime scheduler DB circuit breaker is open|Runtime scheduler schema .* is not ready|OptimisticConcurrencyControlFailure|changed while this mutation was being run|Documents read from or written to the .* table changed while this mutation/i.test(
     body,
@@ -1264,6 +1281,7 @@ export class AppRuntimeApiResponseError extends Error {
   readonly status: number;
   readonly code: string | null;
   readonly failureReason: RunLedgerProjectionLeaseLostReason | null;
+  readonly projectionMismatch: RunLedgerProjectionMismatchDiagnostic | null;
   readonly requestId: string | null;
   readonly retryable: boolean;
   /** Server-requested delay, retained for durable callers after local retries end. */
@@ -1275,6 +1293,7 @@ export class AppRuntimeApiResponseError extends Error {
     status: number;
     code?: string | null;
     failureReason?: RunLedgerProjectionLeaseLostReason | null;
+    projectionMismatch?: RunLedgerProjectionMismatchDiagnostic | null;
     requestId?: string | null;
     retryable: boolean;
     retryAfterMs?: number | null;
@@ -1292,6 +1311,7 @@ export class AppRuntimeApiResponseError extends Error {
     this.status = input.status;
     this.code = input.code?.trim() || null;
     this.failureReason = input.failureReason ?? null;
+    this.projectionMismatch = input.projectionMismatch ?? null;
     this.requestId = input.requestId?.trim() || null;
     this.retryable = input.retryable;
     this.retryAfterMs =
@@ -1757,6 +1777,7 @@ async function postAppRuntimeApi<TResponse>(
       status: response.status,
       code,
       failureReason: appRuntimeFailureReason(code, responseText),
+      projectionMismatch: appRuntimeProjectionMismatch(code, responseText),
       requestId,
       // The structured response is authoritative even for a 5xx. Retrying an
       // explicitly deterministic database failure here turns one rejected SQL

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

@@ -1,4 +1,5 @@
 import type { PlayRunLedgerIngressEvent } from './run-ledger';
+import type { RunLedgerProjectionChunk } from './run-ledger-projection-contract';
 
 const APP_RUNTIME_LOG_EVENT_MAX_JSON_BYTES = 128 * 1024;
 const APP_RUNTIME_EVENT_BATCH_MAX_JSON_BYTES = 512 * 1024;
@@ -108,3 +109,26 @@ export function partitionRunEventsForAppRuntime(
   if (current.length > 0) batches.push(current);
   return batches;
 }
+
+/**
+ * Select a projection chunk from the raw canonical prefix. Callers must apply
+ * route sanitization only after this boundary is selected, because sanitizing
+ * event payloads can change their encoded sizes and shift transport chunks.
+ */
+export function selectRunEventsForAppRuntimeProjectionChunk(
+  events: readonly PlayRunLedgerIngressEvent[],
+  chunk: RunLedgerProjectionChunk,
+): PlayRunLedgerIngressEvent[] | undefined {
+  if (
+    !Number.isSafeInteger(chunk.index) ||
+    !Number.isSafeInteger(chunk.count) ||
+    chunk.index < 0 ||
+    chunk.count < 2 ||
+    chunk.index >= chunk.count
+  ) {
+    return undefined;
+  }
+
+  const batches = partitionRunEventsForAppRuntime(events);
+  return batches.length === chunk.count ? batches[chunk.index] : undefined;
+}

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

@@ -45,6 +45,124 @@ export const RUN_LEDGER_PROJECTION_LEASE_LOST_REASONS = [
   'projected_events_mismatch',
 ] as const;
 
+export const RUN_LEDGER_PROJECTION_MISMATCH_KINDS = [
+  'expected_chunk_unavailable',
+  'event_count_mismatch',
+  'event_content_mismatch',
+] as const;
+
+export const RUN_LEDGER_PROJECTION_MISMATCH_FIELDS = [
+  'type',
+  'runId',
+  'occurredAt',
+  'source',
+  'opaque',
+  'payload',
+  'seq',
+  'status',
+  'playName',
+  'runtimeBackend',
+  'triggerSource',
+  'inputSummary',
+  'definitionScope',
+  'result',
+  'resultSummary',
+  'error',
+  'errorSummary',
+  'retryAfterMs',
+  'waitKind',
+  'waitUntil',
+  'nodeId',
+  'progress',
+  'stepId',
+  'toolId',
+  'provider',
+  'operation',
+  'lines',
+  'channelOffset',
+  'producerAttempt',
+  'other',
+] as const;
+
+export type RunLedgerProjectionMismatchKind =
+  (typeof RUN_LEDGER_PROJECTION_MISMATCH_KINDS)[number];
+
+export type RunLedgerProjectionMismatchField =
+  (typeof RUN_LEDGER_PROJECTION_MISMATCH_FIELDS)[number];
+
+/** Payload-free comparison facts safe to persist in the operator diagnostics. */
+export type RunLedgerProjectionMismatchDiagnostic = {
+  kind: RunLedgerProjectionMismatchKind;
+  expectedEventCount: number | null;
+  projectedEventCount: number;
+  chunkIndex: number | null;
+  chunkCount: number | null;
+  firstMismatchIndex: number | null;
+  eventTypeMatches: boolean | null;
+  mismatchedFields: RunLedgerProjectionMismatchField[];
+};
+
+export function isRunLedgerProjectionMismatchDiagnostic(
+  value: unknown,
+): value is RunLedgerProjectionMismatchDiagnostic {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const candidate = value as Record<string, unknown>;
+  const diagnosticKeys = [
+    'kind',
+    'expectedEventCount',
+    'projectedEventCount',
+    'chunkIndex',
+    'chunkCount',
+    'firstMismatchIndex',
+    'eventTypeMatches',
+    'mismatchedFields',
+  ];
+  const keys = Object.keys(candidate);
+  if (
+    keys.length !== diagnosticKeys.length ||
+    keys.some((key) => !diagnosticKeys.includes(key))
+  ) {
+    return false;
+  }
+  return (
+    typeof candidate.kind === 'string' &&
+    RUN_LEDGER_PROJECTION_MISMATCH_KINDS.includes(
+      candidate.kind as RunLedgerProjectionMismatchKind,
+    ) &&
+    (candidate.expectedEventCount === null ||
+      (Number.isSafeInteger(candidate.expectedEventCount) &&
+        Number(candidate.expectedEventCount) >= 0)) &&
+    Number.isSafeInteger(candidate.projectedEventCount) &&
+    Number(candidate.projectedEventCount) >= 0 &&
+    (candidate.chunkIndex === null ||
+      (Number.isSafeInteger(candidate.chunkIndex) &&
+        Number(candidate.chunkIndex) >= 0)) &&
+    (candidate.chunkCount === null ||
+      (Number.isSafeInteger(candidate.chunkCount) &&
+        Number(candidate.chunkCount) > 1)) &&
+    ((candidate.chunkIndex === null && candidate.chunkCount === null) ||
+      (Number.isSafeInteger(candidate.chunkIndex) &&
+        Number.isSafeInteger(candidate.chunkCount) &&
+        Number(candidate.chunkIndex) < Number(candidate.chunkCount))) &&
+    (candidate.firstMismatchIndex === null ||
+      (Number.isSafeInteger(candidate.firstMismatchIndex) &&
+        Number(candidate.firstMismatchIndex) >= 0)) &&
+    (candidate.eventTypeMatches === null ||
+      typeof candidate.eventTypeMatches === 'boolean') &&
+    Array.isArray(candidate.mismatchedFields) &&
+    candidate.mismatchedFields.length <= 8 &&
+    candidate.mismatchedFields.every(
+      (field) =>
+        typeof field === 'string' &&
+        RUN_LEDGER_PROJECTION_MISMATCH_FIELDS.includes(
+          field as RunLedgerProjectionMismatchField,
+        ),
+    ) &&
+    new Set(candidate.mismatchedFields).size ===
+      candidate.mismatchedFields.length
+  );
+}
+
 export type RunLedgerProjectionLeaseLostReason =
   (typeof RUN_LEDGER_PROJECTION_LEASE_LOST_REASONS)[number];
 
@@ -61,13 +179,16 @@ export function isRunLedgerProjectionLeaseLostReason(
 
 export class RunLedgerProjectionLeaseLostError extends Error {
   readonly reason: RunLedgerProjectionLeaseLostReason;
+  readonly projectionMismatch: RunLedgerProjectionMismatchDiagnostic | null;
 
   constructor(
     reason: RunLedgerProjectionLeaseLostReason = 'delivery_lease_not_current',
+    projectionMismatch: RunLedgerProjectionMismatchDiagnostic | null = null,
   ) {
     super('Run Ledger projection requires the current outbox delivery lease.');
     this.name = 'RunLedgerProjectionLeaseLostError';
     this.reason = reason;
+    this.projectionMismatch = projectionMismatch;
   }
 }
 

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

@@ -0,0 +1,151 @@
+import { stableStringify } from '../plays/row-identity';
+import type {
+  AcceptedPlayRunLedgerEvent,
+  PlayRunLedgerIngressEvent,
+} from './run-ledger';
+import { isPlayRunLedgerOpaqueEvent } from './run-ledger';
+import {
+  RUN_LEDGER_PROJECTION_MISMATCH_FIELDS,
+  type RunLedgerProjectionChunk,
+  type RunLedgerProjectionMismatchDiagnostic,
+  type RunLedgerProjectionMismatchField,
+} from './run-ledger-projection-contract';
+
+type ComparableRunLedgerEvent =
+  | AcceptedPlayRunLedgerEvent
+  | PlayRunLedgerIngressEvent;
+
+/**
+ * A newer app may receive a projection from a worker that predates optional
+ * wait metadata. Normalize only those absent fields before the exact compare.
+ */
+function normalizeLegacyRunWaitingProjectionFields(
+  projectedEvents: readonly AcceptedPlayRunLedgerEvent[],
+  expectedEvents: readonly ComparableRunLedgerEvent[],
+): AcceptedPlayRunLedgerEvent[] {
+  return projectedEvents.map((event, index) => {
+    const expected = expectedEvents[index];
+    if (
+      isPlayRunLedgerOpaqueEvent(event) ||
+      event.type !== 'run.waiting' ||
+      expected?.type !== 'run.waiting' ||
+      ('opaque' in expected && expected.opaque === true)
+    ) {
+      return event;
+    }
+    const expectedEvent = expected as Record<string, unknown>;
+    const expectedWaitKind = expectedEvent.waitKind;
+    const expectedWaitUntil = expectedEvent.waitUntil;
+    return {
+      ...event,
+      ...(event.waitKind === undefined &&
+      (typeof expectedWaitKind === 'string' || expectedWaitKind === null)
+        ? { waitKind: expectedWaitKind }
+        : {}),
+      ...(event.waitUntil === undefined &&
+      (typeof expectedWaitUntil === 'number' || expectedWaitUntil === null)
+        ? { waitUntil: expectedWaitUntil }
+        : {}),
+    };
+  });
+}
+
+function eventType(event: ComparableRunLedgerEvent | undefined): string | null {
+  if (!event) return null;
+  return typeof event.type === 'string'
+    ? event.type
+    : typeof event.key === 'string'
+      ? event.key
+      : null;
+}
+
+function safeMismatchedFields(
+  projected: ComparableRunLedgerEvent,
+  expected: ComparableRunLedgerEvent,
+): RunLedgerProjectionMismatchField[] {
+  const projectedRecord = projected as Record<string, unknown>;
+  const expectedRecord = expected as Record<string, unknown>;
+  const allowedFields = new Set<string>(RUN_LEDGER_PROJECTION_MISMATCH_FIELDS);
+  const fields = new Set<RunLedgerProjectionMismatchField>();
+  const keys = new Set([
+    ...Object.keys(projectedRecord),
+    ...Object.keys(expectedRecord),
+  ]);
+  for (const key of [...keys].sort()) {
+    if (
+      stableStringify(projectedRecord[key]) ===
+      stableStringify(expectedRecord[key])
+    ) {
+      continue;
+    }
+    fields.add(
+      allowedFields.has(key)
+        ? (key as RunLedgerProjectionMismatchField)
+        : 'other',
+    );
+    if (fields.size === 8) break;
+  }
+  return [...fields];
+}
+
+/**
+ * Compare one received chunk with its canonical outbox slice and return only
+ * bounded structural facts. Event values, IDs, and opaque payload keys never
+ * leave this module.
+ */
+export function runLedgerProjectionMismatch(input: {
+  projectedEvents: readonly AcceptedPlayRunLedgerEvent[];
+  expectedEvents: readonly ComparableRunLedgerEvent[] | null;
+  chunk?: RunLedgerProjectionChunk;
+}): RunLedgerProjectionMismatchDiagnostic | null {
+  const chunkIndex = input.chunk?.index ?? null;
+  const chunkCount = input.chunk?.count ?? null;
+  const projectedEventCount = input.projectedEvents.length;
+  if (input.expectedEvents === null) {
+    return {
+      kind: 'expected_chunk_unavailable',
+      expectedEventCount: null,
+      projectedEventCount,
+      chunkIndex,
+      chunkCount,
+      firstMismatchIndex: null,
+      eventTypeMatches: null,
+      mismatchedFields: [],
+    };
+  }
+
+  const normalizedProjectedEvents = normalizeLegacyRunWaitingProjectionFields(
+    input.projectedEvents,
+    input.expectedEvents,
+  );
+  const expectedEventCount = input.expectedEvents.length;
+  const sharedEventCount = Math.min(projectedEventCount, expectedEventCount);
+  for (let index = 0; index < sharedEventCount; index += 1) {
+    const projected = normalizedProjectedEvents[index]!;
+    const expected = input.expectedEvents[index]!;
+    if (stableStringify(projected) === stableStringify(expected)) continue;
+    return {
+      kind: 'event_content_mismatch',
+      expectedEventCount,
+      projectedEventCount,
+      chunkIndex,
+      chunkCount,
+      firstMismatchIndex: index,
+      eventTypeMatches: eventType(projected) === eventType(expected),
+      mismatchedFields: safeMismatchedFields(projected, expected),
+    };
+  }
+  if (projectedEventCount !== expectedEventCount) {
+    return {
+      kind: 'event_count_mismatch',
+      expectedEventCount,
+      projectedEventCount,
+      chunkIndex,
+      chunkCount,
+      firstMismatchIndex: sharedEventCount,
+      eventTypeMatches: null,
+      mismatchedFields: [],
+    };
+  }
+  return null;
+}

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

@@ -78,7 +78,6 @@ import {
 } from '../work-receipts';
 import type { PlayStaticPipeline } from '../../plays/static-pipeline';
 import {
-  isPlayRunLedgerOpaqueEvent,
   LOG_TAIL_LIMIT,
   type AcceptedPlayRunLedgerEvent,
   type PlayRunLedgerEvent,
@@ -98,10 +97,12 @@ import {
   RunLedgerProjectionLeaseLostError,
   type RunLedgerProjectionChunk,
   type RunLedgerProjectionLeaseLostReason,
+  type RunLedgerProjectionMismatchDiagnostic,
   buildRunLedgerStartIdempotencyKey,
   buildRunLedgerTerminalIdempotencyKey,
 } from '../run-ledger-projection-contract';
-import { partitionRunEventsForAppRuntime } from '../run-ledger-event-transport';
+import { runLedgerProjectionMismatch } from '../run-ledger-projection-diagnostics';
+import { selectRunEventsForAppRuntimeProjectionChunk } from '../run-ledger-event-transport';
 import {
   assertTerminalRunResultWithinLimit,
   isLedgerTerminalResultRef,
@@ -15938,64 +15939,6 @@ async function appendRunLedgerOutboxFact(
 
 export { RunLedgerProjectionLeaseLostError } from '../run-ledger-projection-contract';
 
-/**
- * A newer app can receive a projection from a worker that predates optional
- * wait metadata. Treat only those absent fields as their canonical values;
- * lease identity, event ordering, and every field the worker did send remain
- * exact.
- */
-function normalizeLegacyRunWaitingProjectionFields(
-  projectedEvents: readonly AcceptedPlayRunLedgerEvent[],
-  expectedEvents: readonly (
-    | AcceptedPlayRunLedgerEvent
-    | PlayRunLedgerIngressEvent
-  )[],
-): AcceptedPlayRunLedgerEvent[] {
-  return projectedEvents.map((event, index) => {
-    const expected = expectedEvents[index];
-    if (
-      isPlayRunLedgerOpaqueEvent(event) ||
-      event.type !== 'run.waiting' ||
-      expected?.type !== 'run.waiting' ||
-      ('opaque' in expected && expected.opaque === true)
-    ) {
-      return event;
-    }
-    const expectedEvent = expected as Record<string, unknown>;
-    const expectedWaitKind = expectedEvent.waitKind;
-    const expectedWaitUntil = expectedEvent.waitUntil;
-    return {
-      ...event,
-      ...(event.waitKind === undefined &&
-      (typeof expectedWaitKind === 'string' || expectedWaitKind === null)
-        ? { waitKind: expectedWaitKind }
-        : {}),
-      ...(event.waitUntil === undefined &&
-      (typeof expectedWaitUntil === 'number' || expectedWaitUntil === null)
-        ? { waitUntil: expectedWaitUntil }
-        : {}),
-    };
-  });
-}
-
-function runLedgerProjectionMatchesCanonicalPrefix(
-  projectedEvents: readonly AcceptedPlayRunLedgerEvent[],
-  expectedEvents: readonly (
-    | AcceptedPlayRunLedgerEvent
-    | PlayRunLedgerIngressEvent
-  )[],
-): boolean {
-  if (projectedEvents.length !== expectedEvents.length) return false;
-  return (
-    stableStringify(
-      normalizeLegacyRunWaitingProjectionFields(
-        projectedEvents,
-        expectedEvents,
-      ),
-    ) === stableStringify(expectedEvents)
-  );
-}
-
 /** Extend only our still-live lease before another bounded transport piece. */
 export async function renewPostgresRunLedgerDelivery(
   client: PostgresSchedulerQueryClient,
@@ -16030,7 +15973,7 @@ export async function assertPostgresRunLedgerDelivery(
     leaseOwner?: string;
     projectedEvents?: readonly AcceptedPlayRunLedgerEvent[];
     projectionChunk?: RunLedgerProjectionChunk;
-    normalizeProjectedEvents?: (
+    sanitizeExpectedProjectionEvents?: (
       events: readonly PlayRunLedgerIngressEvent[],
     ) => readonly AcceptedPlayRunLedgerEvent[];
   },
@@ -16163,35 +16106,37 @@ export async function assertPostgresRunLedgerDelivery(
           }),
         );
       }
-      const comparablePrefixEvents: readonly (
-        | AcceptedPlayRunLedgerEvent
-        | PlayRunLedgerIngressEvent
-      )[] = input.normalizeProjectedEvents
-        ? input.normalizeProjectedEvents(prefixEvents)
-        : prefixEvents;
       let expectedProjectionEvents:
         | readonly (AcceptedPlayRunLedgerEvent | PlayRunLedgerIngressEvent)[]
-        | undefined = comparablePrefixEvents;
+        | undefined;
       if (input.projectionChunk) {
         const chunk = input.projectionChunk;
-        const chunks = isRunLedgerProjectionChunk(chunk)
-          ? partitionRunEventsForAppRuntime(
-              comparablePrefixEvents as readonly PlayRunLedgerIngressEvent[],
-            )
-          : [];
+        // The sender partitions ingress events before the route sanitizes each chunk.
+        const expectedTransportChunk = isRunLedgerProjectionChunk(chunk)
+          ? selectRunEventsForAppRuntimeProjectionChunk(prefixEvents, chunk)
+          : undefined;
         expectedProjectionEvents =
-          chunks.length === chunk.count ? chunks[chunk.index] : undefined;
-      }
-      if (
-        expectedProjectionEvents !== undefined &&
-        runLedgerProjectionMatchesCanonicalPrefix(
-          input.projectedEvents,
-          expectedProjectionEvents,
-        )
-      ) {
-        return;
+          expectedTransportChunk === undefined
+            ? undefined
+            : input.sanitizeExpectedProjectionEvents
+              ? input.sanitizeExpectedProjectionEvents(expectedTransportChunk)
+              : expectedTransportChunk;
+      } else {
+        expectedProjectionEvents = input.sanitizeExpectedProjectionEvents
+          ? input.sanitizeExpectedProjectionEvents(prefixEvents)
+          : prefixEvents;
       }
-      throw new RunLedgerProjectionLeaseLostError('projected_events_mismatch');
+      const projectionMismatch: RunLedgerProjectionMismatchDiagnostic | null =
+        runLedgerProjectionMismatch({
+          projectedEvents: input.projectedEvents,
+          expectedEvents: expectedProjectionEvents ?? null,
+          ...(input.projectionChunk ? { chunk: input.projectionChunk } : {}),
+        });
+      if (projectionMismatch === null) return;
+      throw new RunLedgerProjectionLeaseLostError(
+        'projected_events_mismatch',
+        projectionMismatch,
+      );
     }
 
     if (
@@ -16727,6 +16672,7 @@ function runLedgerDeliveryFailure(input: { error: unknown }): {
   status: number | null;
   retryable: boolean;
   failureReason: RunLedgerProjectionLeaseLostReason | null;
+  projectionMismatch: RunLedgerProjectionMismatchDiagnostic | null;
   retryAfterMs: number | null;
 } {
   if (input.error instanceof AppRuntimeApiResponseError) {
@@ -16747,6 +16693,7 @@ function runLedgerDeliveryFailure(input: { error: unknown }): {
       status: input.error.status,
       retryable,
       failureReason: input.error.failureReason,
+      projectionMismatch: input.error.projectionMismatch,
       retryAfterMs:
         input.error.retryAfterMs === null
           ? null
@@ -16763,6 +16710,7 @@ function runLedgerDeliveryFailure(input: { error: unknown }): {
       status: null,
       retryable: true,
       failureReason: null,
+      projectionMismatch: null,
       retryAfterMs: null,
     };
   }
@@ -16774,6 +16722,7 @@ function runLedgerDeliveryFailure(input: { error: unknown }): {
     status: null,
     retryable: true,
     failureReason: null,
+    projectionMismatch: null,
     retryAfterMs: null,
   };
 }
@@ -16873,6 +16822,9 @@ export async function settlePostgresSchedulerOutboxFailure(
         ...(failure.failureReason
           ? { failureReason: failure.failureReason }
           : {}),
+        ...(failure.projectionMismatch
+          ? { projectionMismatch: failure.projectionMismatch }
+          : {}),
         retryAfterMs: failure.retryAfterMs,
         recordedAt: new Date().toISOString(),
       }),

package/dist/cli/index.js

@@ -3051,7 +3051,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.223",
+  version: "0.3.225",
   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

@@ -3046,7 +3046,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.223",
+  version: "0.3.225",
   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

@@ -864,7 +864,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.223",
+  version: "0.3.225",
   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

@@ -768,7 +768,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.223",
+  version: "0.3.225",
   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/install-integrity.json

@@ -295,6 +295,7 @@
     "dist/bundling-sources/shared_libs/play-runtime/run-identity.ts",
     "dist/bundling-sources/shared_libs/play-runtime/run-ledger-event-transport.ts",
     "dist/bundling-sources/shared_libs/play-runtime/run-ledger-projection-contract.ts",
+    "dist/bundling-sources/shared_libs/play-runtime/run-ledger-projection-diagnostics.ts",
     "dist/bundling-sources/shared_libs/play-runtime/run-ledger.ts",
     "dist/bundling-sources/shared_libs/play-runtime/run-lifecycle-policy.ts",
     "dist/bundling-sources/shared_libs/play-runtime/run-log-buffer.ts",

package/dist/release.d.mts

@@ -149,7 +149,7 @@ type SdkRelease = {
     supportPolicy: SdkSupportPolicy;
 };
 declare const SDK_RELEASE: {
-    readonly version: "0.3.223";
+    readonly version: "0.3.225";
     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.223";
+    readonly version: "0.3.225";
     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.223",
+  version: "0.3.225",
   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.223",
+  version: "0.3.225",
   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.223",
+  "version": "0.3.225",
   "description": "GTM data CLI and TypeScript SDK for coding agents",
   "license": "MIT",
   "homepage": "https://code.deepline.com",