deepline 0.3.284 → 0.3.286

package/dist/bundling-sources/shared_libs/play-runtime/tool-call/runtime-step-receipts-adapter.ts

@@ -48,7 +48,7 @@ export type RuntimeStepToolResultReceiptsInput = {
    */
   executionLock?: {
     required?: boolean;
-    /** Provider-operation identity; defaults to the result-cache receipt. */
+    /** Invocation/provider-operation identity; never the shared cache key. */
     key?: string;
     ttlMs?: number;
     waitMs?: number;
@@ -101,7 +101,6 @@ type OwnedReceipt = {
   executionLockOwnerId: string | null;
   executionLockKey: string | null;
   lockLost: boolean;
-  completedByAnotherOwner: ToolExecuteResult | null;
   heartbeatTimer: ReturnType<typeof setTimeout> | null;
   heartbeatInFlight: Promise<void> | null;
 };
@@ -157,14 +156,13 @@ export function createRuntimeStepToolResultReceipts(
     resultReceiptKey: string,
     source: ToolCallReceiptRecoverySource | 'owner' = 'cache',
   ): Promise<ToolExecuteResult | null> => {
-    const receipt =
-      initialReceipt?.key === resultReceiptKey
-        ? (() => {
-            const value = initialReceipt!.receipt;
-            initialReceipt = undefined;
-            return value;
-          })()
-        : await hydrate(() => input.store.get(resultReceiptKey));
+    let receipt: RuntimeStepReceipt | null;
+    if (initialReceipt?.key === resultReceiptKey) {
+      receipt = initialReceipt.receipt;
+      initialReceipt = undefined;
+    } else {
+      receipt = await hydrate(() => input.store.get(resultReceiptKey));
+    }
     const result = completedResult(receipt, resultReceiptKey);
     return result
       ? (input.recover?.({ result, resultReceiptKey, source }) ?? result)
@@ -184,7 +182,7 @@ export function createRuntimeStepToolResultReceipts(
 
   const renewExecutionLock = async (
     record: OwnedReceipt,
-  ): Promise<'active' | 'completed' | 'lost'> => {
+  ): Promise<'active' | 'lost'> => {
     if (!record.executionLockOwnerId || !input.store.acquireExecutionLock) {
       return 'active';
     }
@@ -196,16 +194,6 @@ export function createRuntimeStepToolResultReceipts(
     if (renewed?.ownerExecutionId === record.executionLockOwnerId) {
       return 'active';
     }
-    if (!record.force && input.store.enabled) {
-      const completed = await readCompleted(
-        record.resultReceiptKey,
-        'in_flight',
-      );
-      if (completed) {
-        record.completedByAnotherOwner = completed;
-        return 'completed';
-      }
-    }
     record.lockLost = true;
     return 'lost';
   };
@@ -226,11 +214,7 @@ export function createRuntimeStepToolResultReceipts(
           .then(() => undefined)
           .finally(() => {
             record.heartbeatInFlight = null;
-            if (
-              !record.lockLost &&
-              !record.completedByAnotherOwner &&
-              record.executionLockOwnerId
-            ) {
+            if (!record.lockLost && record.executionLockOwnerId) {
               schedule();
             }
           });
@@ -249,7 +233,6 @@ export function createRuntimeStepToolResultReceipts(
 
   const acquireExecutionLock = async (
     resultReceiptKey: string,
-    force: boolean,
   ): Promise<{ ownerId: string; key: string } | null> => {
     if (!lock.required || !input.store.enabled) return null;
     if (
@@ -261,8 +244,9 @@ export function createRuntimeStepToolResultReceipts(
       );
     }
 
-    const executionLockKey = lock.key || resultReceiptKey;
     const ownerExecutionId = `tool-result:${crypto.randomUUID()}`;
+    const executionLockKey =
+      lock.key || `${resultReceiptKey}:invocation:${ownerExecutionId}`;
     const deadline = Date.now() + lock.waitMs;
     while (true) {
       const acquired = await input.store.acquireExecutionLock({
@@ -271,26 +255,9 @@ export function createRuntimeStepToolResultReceipts(
         ttlMs: lock.ttlMs,
       });
       if (acquired?.ownerExecutionId === ownerExecutionId) {
-        // Recheck after acquiring: a prior holder may have completed between
-        // our cache read and lock acquisition. A forced call intentionally
-        // bypasses that immutable completed fact, matching the legacy path.
-        if (!force) {
-          const cached = await readCompleted(resultReceiptKey, 'in_flight');
-          if (cached) {
-            await input.store.releaseExecutionLock({
-              receiptKey: executionLockKey,
-              ownerExecutionId,
-            });
-            return null;
-          }
-        }
         return { ownerId: ownerExecutionId, key: executionLockKey };
       }
 
-      if (!force) {
-        const cached = await readCompleted(resultReceiptKey, 'in_flight');
-        if (cached) return null;
-      }
       if (Date.now() >= deadline) {
         throw new RuntimeReceiptWaitTimeoutError(resultReceiptKey);
       }
@@ -312,16 +279,7 @@ export function createRuntimeStepToolResultReceipts(
         if (cached) return { kind: 'completed', result: cached };
       }
 
-      const executionLock = await acquireExecutionLock(
-        resultReceiptKey,
-        candidate.force,
-      );
-      if (input.store.enabled && !candidate.force && !executionLock) {
-        const cached = await readCompleted(resultReceiptKey, 'cache');
-        if (cached) return { kind: 'completed', result: cached };
-        // The only non-lock reason to get here is a store without a lock
-        // requirement. In that case this caller is still the cache publisher.
-      }
+      const executionLock = await acquireExecutionLock(resultReceiptKey);
 
       const leaseId =
         executionLock?.ownerId ?? `tool-result:${crypto.randomUUID()}`;
@@ -332,7 +290,6 @@ export function createRuntimeStepToolResultReceipts(
         executionLockOwnerId: executionLock?.ownerId ?? null,
         executionLockKey: executionLock?.key ?? null,
         lockLost: false,
-        completedByAnotherOwner: null,
         heartbeatTimer: null,
         heartbeatInFlight: null,
       });
@@ -350,30 +307,9 @@ export function createRuntimeStepToolResultReceipts(
       if (candidate.ownerRunId !== ownerRunId) {
         throw new ToolCallReceiptLeaseLostError(resultReceiptKey);
       }
-      const maxWaitMs = candidate.source === 'in_flight' ? lock.waitMs : 0;
-      const deadline = Date.now() + maxWaitMs;
-      while (true) {
-        const receipt = await hydrate(() => input.store.get(resultReceiptKey));
-        const completed = completedResult(receipt, resultReceiptKey);
-        if (completed) {
-          return (
-            input.recover?.({
-              result: completed,
-              resultReceiptKey,
-              source: candidate.source,
-            }) ?? completed
-          );
-        }
-        if (receipt?.status === 'failed') {
-          throw new Error(
-            `Tool Result Receipt ${resultReceiptKey} failed: ${receipt.error ?? 'unknown error'}.`,
-          );
-        }
-        if (Date.now() >= deadline) {
-          throw new RuntimeReceiptWaitTimeoutError(resultReceiptKey);
-        }
-        await sleep(lock.pollMs);
-      }
+      const completed = await readCompleted(resultReceiptKey, candidate.source);
+      if (completed) return completed;
+      throw new RuntimeReceiptWaitTimeoutError(resultReceiptKey);
     },
 
     async heartbeat(candidate) {
@@ -381,13 +317,6 @@ export function createRuntimeStepToolResultReceipts(
         resultReceiptKey: candidate.resultReceiptKey,
         lease: candidate.lease,
       });
-      if (!record.force && input.store.enabled) {
-        const cached = await readCompleted(
-          record.resultReceiptKey,
-          'in_flight',
-        );
-        if (cached) return 'completed';
-      }
       if (!record.executionLockOwnerId) return 'active';
       if (record.lockLost) return 'lost';
       const renewal = await renewExecutionLock(record);
@@ -398,11 +327,6 @@ export function createRuntimeStepToolResultReceipts(
         startHeartbeat(record);
         return 'active';
       }
-      if (renewal === 'completed') return 'completed';
-      if (!record.force && input.store.enabled) {
-        const cached = await readCompleted(record.resultReceiptKey);
-        if (cached) return 'completed';
-      }
       return 'lost';
     },
 
@@ -413,9 +337,6 @@ export function createRuntimeStepToolResultReceipts(
       });
       try {
         await stopHeartbeat(record);
-        if (record.completedByAnotherOwner) {
-          return { kind: 'existing', result: record.completedByAnotherOwner };
-        }
         if (record.lockLost) {
           throw new ToolCallReceiptLeaseLostError(record.resultReceiptKey);
         }
@@ -434,53 +355,24 @@ export function createRuntimeStepToolResultReceipts(
           serializeToolExecuteResult(candidate.result),
           COMPLETED_RECEIPT_CACHE_INSERT_LEASE_ID,
         );
-        // Completion transports may acknowledge only status/ownership. A
-        // compact acknowledgement that says this insert won is complete
-        // information: the immutable stored result is the one just written, so
-        // the caller's own result is it. Nothing is read back and nothing
-        // hydrates.
-        if (
-          (persisted?.status === 'completed' ||
-            persisted?.status === 'skipped') &&
-          persisted.output === undefined &&
-          persisted.completionDisposition === 'persisted'
-        ) {
-          return { kind: 'stored', result: candidate.result };
-        }
-        // Anything else — a concurrent winner, or a gateway too old to say who
-        // won — really does need the durable row, so it decodes under the gate
-        // or is read back below.
-        const result =
-          persisted?.output === undefined
-            ? null
-            : await hydrate(async () =>
-                completedResult(persisted, record.resultReceiptKey),
-              );
-        if (result) {
-          await input.onStored?.({
-            result,
-            resultReceiptKey: record.resultReceiptKey,
-          });
-          return {
-            // The legacy storage operation returns the converged completed row
-            // for both an insert and a concurrent winner. The exact distinction
-            // is intentionally unobservable; the public invariant is the
-            // converged immutable ToolExecuteResult.
-            kind: 'stored',
-            result,
-          };
-        }
-        const converged = await readCompleted(record.resultReceiptKey, 'owner');
-        if (converged) {
-          await input.onStored?.({
-            result: converged,
-            resultReceiptKey: record.resultReceiptKey,
-          });
-          return { kind: 'existing', result: converged };
+        // Publication is immutable, but an independent miss keeps the
+        // result it actually executed. Another caller winning this cache key
+        // only affects a later cache lookup.
+        const completed =
+          persisted?.status === 'completed' || persisted?.status === 'skipped';
+        if (!completed) {
+          const stored = await input.store.get(record.resultReceiptKey);
+          if (stored?.status !== 'completed' && stored?.status !== 'skipped') {
+            throw new Error(
+              `Tool Result Receipt ${record.resultReceiptKey} could not publish a completed result.`,
+            );
+          }
         }
-        throw new Error(
-          `Tool Result Receipt ${record.resultReceiptKey} could not publish a completed result.`,
-        );
+        await input.onStored?.({
+          result: candidate.result,
+          resultReceiptKey: record.resultReceiptKey,
+        });
+        return { kind: 'stored', result: candidate.result };
       } finally {
         await stopHeartbeat(record);
         await releaseExecutionLock(record);
@@ -493,16 +385,11 @@ export function createRuntimeStepToolResultReceipts(
         resultReceiptKey: candidate.resultReceiptKey,
         lease: candidate.lease,
       });
-      try {
-        // Completed-cache-only mode has no owned in-flight row to mark failed.
-        // Recording a terminal failure would let an old owner overwrite a
-        // concurrent successful publisher. Releasing just our lock is safe;
-        // the original provider error remains the caller-visible fact.
-      } finally {
-        await stopHeartbeat(record);
-        await releaseExecutionLock(record);
-        owned.delete(candidate.lease.leaseId);
-      }
+      // A failed invocation releases only its own lock. It never publishes a
+      // failure over a concurrent successful cache entry.
+      await stopHeartbeat(record);
+      await releaseExecutionLock(record);
+      owned.delete(candidate.lease.leaseId);
     },
   };
 }

package/dist/bundling-sources/shared_libs/play-runtime/tool-result.ts

@@ -2159,3 +2159,71 @@ export function cloneToolExecuteResultWithExecution<TResult>(
     execution,
   }) as ToolExecuteResult<TResult>;
 }
+
+/**
+ * Native splitters return the logical source response; the historical adapter
+ * stores it inside an extra `{ data }` layer. Keep that immutable receipt and
+ * its legacy raw/getter projections, and select the source response only at a
+ * newly admitted Play's boundary. This is one provenance-backed projection,
+ * never recursive provider-envelope unwrapping.
+ */
+export function projectNativeBatchToolResponse(
+  value: ToolExecuteResult,
+  policy: 'legacy_envelope' | 'logical_response' = 'logical_response',
+): ToolExecuteResult {
+  const stored = value.toolResponse.rawV2;
+  const materialized = value.meta?.nativeBatchResponseMaterialized === true;
+  if (policy === 'legacy_envelope' && !materialized) return value;
+  if (policy === 'logical_response' && materialized) return value;
+  if (!materialized && (!isRecord(stored) || !Object.hasOwn(stored, 'data')))
+    return value;
+  const recordedView = value.meta?.nativeBatchResponseView;
+  let view: ToolResponseView | undefined =
+    recordedView === 'data' || recordedView === 'rawV2'
+      ? recordedView
+      : undefined;
+  if (view !== 'data' && view !== 'rawV2') {
+    // Retained BounceBan receipts predate the provenance fact. Its scalar
+    // action returns `{ data: verdict }`; only the old batch adapter adds
+    // `{ data: { data: verdict } }`. Do not apply this repair to other tools
+    // or infer it from a provider's arbitrary `data` field.
+    const source = (stored as Record<string, unknown>).data;
+    const verdict = isRecord(source) ? source.data : undefined;
+    if (
+      value._metadata.toolId !== 'bounceban_verify_single' ||
+      !isRecord(source) ||
+      !isRecord(verdict) ||
+      typeof verdict.email !== 'string' ||
+      (verdict.status !== undefined && verdict.status !== 'success') ||
+      !['deliverable', 'undeliverable', 'risky', 'unknown'].includes(
+        String(verdict.result),
+      )
+    ) {
+      return value;
+    }
+    view = 'data';
+  }
+  const response = {
+    ...value.toolResponse,
+    rawV2: materialized
+      ? { data: stored }
+      : (stored as Record<string, unknown>).data,
+    view: materialized ? ('data' as const) : view,
+  };
+  // Preserve non-enumerable metadata/aliases and live list/getter accessors.
+  // Do not mutate a result shared with another artifact or the receipt cache.
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  descriptors.toolResponse = { ...descriptors.toolResponse, value: response };
+  descriptors.toolOutput = { ...descriptors.toolOutput, value: response };
+  descriptors.meta = {
+    value: {
+      ...value.meta,
+      nativeBatchResponseView: view,
+      nativeBatchResponseMaterialized: !materialized,
+    },
+    writable: true,
+    enumerable: true,
+    configurable: true,
+  };
+  return Object.create(Object.getPrototypeOf(value), descriptors);
+}

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

@@ -1,4 +1,5 @@
 import type { PlayDocflowNodeIoState } from './docflow-node-io';
+import type { PlayMapRowActivitySource } from './run-ledger';
 
 export type PlayStagedFileRef = {
   storageKind: 'r2';
@@ -17,6 +18,13 @@ export type PlayVisualNodeProgress = {
   startedRows?: number;
   activeRows?: number;
   waitingRows?: number;
+  /** Internal row-sample authority; omitted by legacy progress writers. */
+  rowActivitySource?: PlayMapRowActivitySource;
+  /** Existing executor identity; stable through source pages and replay. */
+  mapInvocationId?: string;
+  /** Runner-owned source times, never gateway ingestion times. */
+  rowActivityStartedAt?: number;
+  rowActivityObservedAt?: number;
   completedRows?: number;
   supersededRows?: number;
   message?: string;

package/dist/bundling-sources/shared_libs/plays/authoring-contract.ts

@@ -7,10 +7,12 @@ import type { ToolExecutionErrorSchemaVersion } from './tool-execution-error';
 import type { PlayDataset, PlayDatasetInput, PlayDatasetRow } from './dataset';
 
 export const LEGACY_PLAY_AUTHORING_CONTRACT_EDITION = 1 as const;
+// Reader-first rollout: accept edition 9, but keep new bundles on edition 8
+// until the edition-9 runtime reader has completed deployment.
 export const PLAY_AUTHORING_CONTRACT_EDITION = 8 as const;
 export const PLAY_AUTHORING_INPUT_SCHEMA_SNAPSHOT_EDITION = 3 as const;
 export const SUPPORTED_PLAY_AUTHORING_CONTRACT_EDITIONS = [
-  1, 2, 3, 4, 5, 6, 7, 8,
+  1, 2, 3, 4, 5, 6, 7, 8, 9,
 ] as const;
 
 export type PlayAuthoringContractEdition =
@@ -75,6 +77,13 @@ const PLAY_AUTHORING_CONTRACT_CHANGELOG_DETAILS = [
     newWritesEnd: null,
     readerRemoval: null,
   },
+  {
+    changed:
+      'Projects native-batch rawV2 to the logical source response at the Play boundary. Editions 1–8 retain their admitted response nesting; completed tool receipts and provider identities are unchanged.',
+    compatibilityOwner: 'Plays Runtime',
+    newWritesEnd: null,
+    readerRemoval: null,
+  },
 ] as const;
 
 export const PLAY_AUTHORING_CONTRACT_CHANGELOG =

package/dist/bundling-sources/shared_libs/plays/enrich-compat-adapter.ts

@@ -1,5 +1,7 @@
 export const ENRICH_COMPAT_DEFAULT_PLAY_NAME = 'deepline-enrich-v1-compat';
 export const ENRICH_COMPAT_DEFAULT_MAP_NAME = 'deepline_enrich_rows';
+export const ENRICH_COMMAND_DEPRECATION_MESSAGE =
+  'The `deepline enrich` command is deprecated. Deepline Plays gives much better results. Run `deepline plays --help` to get started. If you still need the legacy command, submit feedback explaining why.';
 
 export type EnrichCompatibilityOptions = {
   playName?: string;