deepline 0.3.392 → 0.3.393

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

@@ -345,10 +345,12 @@ export interface RuntimeDatasetOptions<TItem = Record<string, unknown>> {
    * row. Use this to pin identity to primary columns (e.g. `{ key: "email" }`
    * or `{ key: ["first_name", "last_name", "domain"] }`) so harmless
    * mutations to other columns don't invalidate the cache.
+   * Providing a key selects key identity for non-CSV sources and retained
+   * authoring editions.
    *
    * Must return a non-empty string (numbers are coerced). Empty keys throw
    * loudly before any provider work runs. Rows whose keys duplicate an earlier
-   * row are silently deduped (first occurrence wins) and logged, never failing
+   * row are deduped (first occurrence wins) and counted, never failing
    * the run. The key function should reference *input*
    * columns only — values produced by this dataset's field resolvers are stripped
    * before identity is computed.
@@ -357,6 +359,14 @@ export interface RuntimeDatasetOptions<TItem = Record<string, unknown>> {
     | (keyof TItem & string)
     | readonly (keyof TItem & string)[]
     | ((row: TItem, index: number) => string | number | readonly unknown[]);
+  /**
+   * Edition 11 CSV inputs always use source_row: the original CSV record
+   * ordinal distinguishes equal records and every occurrence is processed,
+   * even when key or rowIdentity: 'key' is supplied. For non-CSV sources and
+   * retained editions, rowIdentity: 'key' keeps the existing first-wins
+   * dedupe behavior.
+   */
+  rowIdentity?: 'source_row' | 'key';
   /**
    * Row failure policy for this dataset run.
    *
@@ -400,7 +410,12 @@ export type RuntimeDatasetDefinitionOptions<TItem = Record<string, unknown>> =
 
 export type RuntimeDatasetRunOptions<TItem = Record<string, unknown>> = Pick<
   RuntimeDatasetOptions<TItem>,
-  'description' | 'key' | 'onRowError' | 'mode' | 'undrawnColumns'
+  | 'description'
+  | 'key'
+  | 'rowIdentity'
+  | 'onRowError'
+  | 'mode'
+  | 'undrawnColumns'
 >;
 
 /** Runtime-only receipt recovery bit; never part of the customer authoring API. */
@@ -500,6 +515,11 @@ export interface MapExecutionFrame {
   suspendedInputRows?: Array<{
     inputIndex: number;
     data: Record<string, unknown>;
+    /** Original admission input, separate from restored execution/output cells. */
+    authoredInput?: {
+      data: Record<string, unknown>;
+      source?: Readonly<{ datasetId: string; rowIndex: number }>;
+    };
     /** Digest of the authored input before Runtime Sheet outputs were merged. */
     authoredInputDigest?: string;
   }>;
@@ -507,6 +527,13 @@ export interface MapExecutionFrame {
   completedRowsCount?: number;
   pendingRowsCount?: number;
   failedRowsCount?: number;
+  /** Original source cardinality retained across pending-only checkpoint replay. */
+  inputCardinality?: {
+    sourceRows: number;
+    uniqueInputRows: number;
+    duplicateOccurrences: number;
+    rowIdentity: 'source_row' | 'key';
+  };
   /** Bounded final-row causes, additive for checkpoint compatibility. */
   failureCounts?: import('./row-failure-summary').RowFailureCounts;
   /** Terminal rows omitted from this run's latest view because a newer write won. */
@@ -988,7 +1015,9 @@ export interface ContextOptions {
     tableNamespace: string;
     succeededRows: number;
     failedRows: number;
-  }) => void;
+    expectedRows?: number;
+    staticPipeline?: PlayStaticPipeline | null;
+  }) => void | Promise<void>;
   /**
    * Persists coalesced, non-terminal row patches before a map suspends.
    * Terminal rows use onMapRowsCompleted; this narrow seam only preserves
@@ -1071,6 +1100,10 @@ export interface ContextOptions {
     toolId: string,
   ) => Promise<string[]> | string[];
   getToolAuthScopeDigest?: (toolId: string) => Promise<string> | string;
+  /** Absent on older app readers; only the declared async boundary may opt in. */
+  getToolAsyncExecutionRecovery?: (
+    toolId: string,
+  ) => Promise<{ origin: string } | null>;
   /** Original run for an explicit customer rerun, never an automatic retry. */
   replayedFromRunId?: string | null;
   getToolRateScope?: (

package/dist/bundling-sources/shared_libs/play-runtime/durable-invocation-fence.ts

@@ -1,3 +1,39 @@
+import { sha256Hex } from '../plays/row-identity';
+
+export const RUNTIME_EXECUTION_RECOVERY_KEY_PREFIX = 'runtime-gateway:';
+export const RUNTIME_EXECUTION_RECOVERY_SUPPORTED_HEADER =
+  'x-deepline-idempotency-supported';
+export const RUNTIME_EXECUTION_RECOVERY_ONLY_HEADER =
+  'x-deepline-execution-recovery-only';
+/** Gateway-owned support for forwarding a keyed async call and its app ACK. */
+export const RUNTIME_ASYNC_EXECUTION_RECOVERY_TRANSPORT_HEADER =
+  'x-deepline-async-execution-recovery-transport';
+
+/** Same-run delivery recovery must not coalesce separate Play runs. */
+export function buildRuntimeExecutionRecoveryKey(input: {
+  parentRunId: string;
+  invocationKey: string;
+}): string {
+  if (!input.parentRunId.trim() || !input.invocationKey.trim()) {
+    throw new Error(
+      'Runtime execution recovery requires run and invocation identities.',
+    );
+  }
+  return `${RUNTIME_EXECUTION_RECOVERY_KEY_PREFIX}${sha256Hex(input.parentRunId)}:${sha256Hex(input.invocationKey)}`;
+}
+
+/** A known key is not authority to read another executor run's response. */
+export function isRuntimeExecutionRecoveryKeyForRun(
+  key: string,
+  runId: string,
+): boolean {
+  if (!runId.trim()) return false;
+  const prefix = `${RUNTIME_EXECUTION_RECOVERY_KEY_PREFIX}${sha256Hex(runId)}:`;
+  return (
+    key.startsWith(prefix) && /^[a-f0-9]{64}$/.test(key.slice(prefix.length))
+  );
+}
+
 /**
  * `execute-fenced-v2` is the first operation that requires semantic provider
  * identity. It is intentionally a named operation rather than a runtime-wide

package/dist/bundling-sources/shared_libs/play-runtime/map-execution-frame.ts

@@ -24,10 +24,18 @@ export function cloneMapFrame(frame: MapExecutionFrame): MapExecutionFrame {
     ...(frame.suspendedInputRows
       ? {
           suspendedInputRows: frame.suspendedInputRows.map((row) => ({
-            inputIndex: row.inputIndex,
+            ...row,
             data: cloneCsvAliasedRow(row.data),
-            ...(row.authoredInputDigest
-              ? { authoredInputDigest: row.authoredInputDigest }
+            ...(row.authoredInput
+              ? {
+                  authoredInput: {
+                    ...row.authoredInput,
+                    data: cloneCsvAliasedRow(row.authoredInput.data),
+                    ...(row.authoredInput.source
+                      ? { source: { ...row.authoredInput.source } }
+                      : {}),
+                  },
+                }
               : {}),
           })),
         }

package/dist/bundling-sources/shared_libs/play-runtime/play-runs/projection/gateway-adapter.ts

@@ -35,6 +35,7 @@ export function createGatewayRunLedgerProjectionAdapter(
     runId: input.runId,
     runtimeApi: input.runtimeApi,
     tokenAuthority: 'gateway' as const,
+    ...(input.runtimeApi.signal ? { signal: input.runtimeApi.signal } : {}),
   };
   return {
     async deliver(request) {

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

@@ -1,6 +1,7 @@
 import {
   normalizePlayAuthoringContractEdition,
   playToolListGetterMode,
+  playCsvDatasetRowIdentity,
   type PlayAuthoringContractEdition,
 } from '../plays/authoring-contract';
 
@@ -50,11 +51,12 @@ export type PlayRuntimeSemantics = Readonly<{
   slackHitl: Readonly<{
     defaultTimeoutMs: number;
   }>;
+  datasets: Readonly<{ csvRowIdentity: 'source_row' | 'key' }>;
 }>;
 
 type PlayRuntimeSemanticsTemplate = Omit<
   PlayRuntimeSemantics,
-  'authoringContractEdition' | 'tools'
+  'authoringContractEdition' | 'tools' | 'datasets'
 > & { tools: Omit<PlayRuntimeSemantics['tools'], 'listGetters'> };
 
 function definePlayRuntimeSemantics(
@@ -72,6 +74,11 @@ function definePlayRuntimeSemantics(
       listGetters: playToolListGetterMode(semantics.authoringContractEdition),
     }),
     slackHitl: Object.freeze({ ...semantics.slackHitl }),
+    datasets: Object.freeze({
+      csvRowIdentity: playCsvDatasetRowIdentity(
+        semantics.authoringContractEdition,
+      ),
+    }),
   });
 }
 
@@ -198,6 +205,17 @@ const PLAY_RUNTIME_SEMANTICS_BY_AUTHORING = {
     tools: { nativeBatchResponse: 'logical_response' },
     slackHitl: WEEK_LONG_SLACK_HITL_SEMANTICS,
   },
+  11: {
+    ...PLAINTEXT_SECRET_SEMANTICS,
+    fetch: {
+      httpFailure: 'throw_typed_error',
+      persistHttpFailure: false,
+      receiptIdentityEdition: FETCH_RECEIPT_IDENTITIES.typedHttpFailure,
+    },
+    inlineChild: { runtimeOnly: true },
+    tools: { nativeBatchResponse: 'logical_response' },
+    slackHitl: WEEK_LONG_SLACK_HITL_SEMANTICS,
+  },
 } satisfies Record<PlayAuthoringContractEdition, PlayRuntimeSemanticsTemplate>;
 
 const PLAY_RUNTIME_SEMANTICS = Object.fromEntries(

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

@@ -90,6 +90,32 @@ export function buildPlayWorkflowId(
   return `play/${familyKey}/run/${buildPlayWorkflowRunSuffix(timestamp)}${entropy}`;
 }
 
+/** Caller-owned identity binds the complete submitted JSON before admission. */
+export function buildCallerPlayWorkflowId(
+  playName: string,
+  request: Record<string, unknown>,
+  now?: Date,
+): string {
+  const { workflowId: _ignored, ...intent } = request;
+  const wireIntent = JSON.parse(JSON.stringify(intent));
+  return `${buildPlayWorkflowId(playName, now, { unique: true })}-caller-${sha256Hex(stableStringify(wireIntent))}`;
+}
+
+export function callerPlayWorkflowIdMatchesRequest(
+  workflowId: string,
+  request: Record<string, unknown>,
+): boolean {
+  const match =
+    /^play\/[a-z0-9/-]+\/run\/\d{8}t\d{6}-\d{3}-[a-z0-9]{8}-caller-([a-f0-9]{64})$/.exec(
+      workflowId,
+    );
+  if (!match || canonicalPlayRunStartedAtMs(workflowId) === null) return false;
+  const { workflowId: _ignored, ...intent } = request;
+  return (
+    match[1] === sha256Hex(stableStringify(JSON.parse(JSON.stringify(intent))))
+  );
+}
+
 export type PlayRunIdentity = {
   workflowId: string;
   runId: string;

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

@@ -19,6 +19,7 @@ import { csvInputTextOptions } from '../../plays/csv-text-repair';
 import { install as installSourceMapSupport } from 'source-map-support';
 import {
   createDeferredPlayDataset,
+  setPlayDatasetSourceRowIdentity,
   isPlayDataset,
   isSerializedPlayDataset,
   iteratePlayDatasetInputPages,
@@ -128,6 +129,7 @@ import {
 import {
   resolveRuntimeReferencedPlay,
   createCompleteRuntimeMapRowsOperation,
+  finishRuntimeSheetRunMembership,
   createRuntimeSheetDatasetPageReader,
   type RuntimeSheetDatasetPageReader,
   readRuntimeSheetDatasetRowKeys,
@@ -140,6 +142,7 @@ import {
 } from '../runtime-api';
 import { installPgRuntimePoolDriver } from '../runtime-pg-driver-pg';
 import { createRuntimeToolAuthScopeDigestResolver } from '../auth-scope-resolver';
+import { RUNTIME_ASYNC_EXECUTION_RECOVERY_TRANSPORT_HEADER } from '../durable-invocation-fence';
 import { createRunScopedChildPlayResolver } from './child-play-resolver';
 import { normalizePlayContractCompatibility } from '../../plays/contracts';
 import { ToolExecutionError } from '../../plays/tool-execution-error';
@@ -379,6 +382,8 @@ type RuntimeToolMetadata = {
 
 type RuntimeToolAuthScope = {
   digest?: unknown;
+  managedAsyncExecutionRecovery?: unknown;
+  managedAsyncExecutionRecoveryOrigin?: unknown;
   rateScope?: {
     bucketId?: unknown;
     provider?: unknown;
@@ -534,7 +539,7 @@ export function runtimeSheetTerminalMapCounts(
 }
 
 async function vercelBypassHeaders(
-  config: PlayRunnerExecutionConfig,
+  config: Pick<PlayRunnerExecutionConfig, 'context'>,
 ): Promise<Record<string, string>> {
   return vercelProtectionBypassHeader(
     config.context.vercelProtectionBypassToken,
@@ -723,9 +728,14 @@ function createRuntimeToolMetadataResolver(config: PlayRunnerExecutionConfig) {
   };
 }
 
-function createAppRuntimeToolAuthScopeDigestResolver(
-  config: PlayRunnerExecutionConfig,
+export function createAppRuntimeToolAuthScopeDigestResolver(
+  config: Pick<PlayRunnerExecutionConfig, 'context'>,
 ) {
+  const asyncRecoveryOrigins = new Map<string, string>();
+  const executionRelayRecovery = new Map<
+    string,
+    Promise<{ origin: string } | null>
+  >();
   const rateScopes = new Map<
     string,
     { bucketId: string; provider: string; token: string }
@@ -783,6 +793,18 @@ function createAppRuntimeToolAuthScopeDigestResolver(
         );
       }
       rateScopes.set(normalizedToolId, { bucketId, provider, token });
+      if (
+        response.headers.get(
+          RUNTIME_ASYNC_EXECUTION_RECOVERY_TRANSPORT_HEADER,
+        ) === 'true' &&
+        body.managedAsyncExecutionRecovery === true &&
+        typeof body.managedAsyncExecutionRecoveryOrigin === 'string'
+      ) {
+        asyncRecoveryOrigins.set(
+          normalizedToolId,
+          body.managedAsyncExecutionRecoveryOrigin,
+        );
+      }
       return digest;
     },
   });
@@ -793,6 +815,10 @@ function createAppRuntimeToolAuthScopeDigestResolver(
       const normalized = String(toolId || '').trim();
       if (normalized) rateScopes.delete(normalized);
       else rateScopes.clear();
+      if (normalized) asyncRecoveryOrigins.delete(normalized);
+      else asyncRecoveryOrigins.clear();
+      if (normalized) executionRelayRecovery.delete(normalized);
+      else executionRelayRecovery.clear();
     },
     rateScope: async (toolId: string, expectedProvider: string) => {
       await digestResolver(toolId);
@@ -804,6 +830,60 @@ function createAppRuntimeToolAuthScopeDigestResolver(
       }
       return { bucketId: scope.bucketId, token: scope.token };
     },
+    asyncExecutionRecovery: async (toolId: string) => {
+      const normalized = toolId.trim();
+      const digest = await digestResolver(normalized);
+      const receiptBase = config.context.baseUrl!.trim().replace(/\/$/, '');
+      const executionBase =
+        config.context.executionGatewayBaseUrl?.trim().replace(/\/$/, '') ||
+        receiptBase;
+      if (executionBase === receiptBase) {
+        const origin = asyncRecoveryOrigins.get(normalized);
+        return origin ? { origin } : null;
+      }
+      // Receipt and execution fleets roll independently. Keep canonical
+      // digest/rate truth on the receipt owner, but never treat its transport
+      // capability as proof that the execution relay forwards the app ACK.
+      let proof = executionRelayRecovery.get(normalized);
+      if (!proof) {
+        proof = (async () => {
+          const response = await fetchRunnerRuntimeControl({
+            url: `${executionBase}/api/v2/plays/runtime-tools/${encodeURIComponent(normalized)}/auth-scope`,
+            description: `Runtime async recovery capability for tool ${normalized}`,
+            retrySafe: true,
+            init: {
+              method: 'GET',
+              headers: {
+                Authorization: `Bearer ${config.context.executorToken}`,
+                ...(await vercelBypassHeaders(config)),
+              },
+            },
+          });
+          if (
+            !response.ok ||
+            response.headers.get(
+              RUNTIME_ASYNC_EXECUTION_RECOVERY_TRANSPORT_HEADER,
+            ) !== 'true'
+          )
+            return null;
+          const body = (await response.json()) as RuntimeToolAuthScope;
+          return body.digest === digest &&
+            body.managedAsyncExecutionRecovery === true &&
+            typeof body.managedAsyncExecutionRecoveryOrigin === 'string'
+            ? { origin: body.managedAsyncExecutionRecoveryOrigin }
+            : null;
+        })().catch(() => {
+          // This optional capability cannot authorize replay on an unavailable
+          // hop. Preserve the existing unkeyed path and allow later discovery.
+          if (executionRelayRecovery.get(normalized) === proof) {
+            executionRelayRecovery.delete(normalized);
+          }
+          return null;
+        });
+        executionRelayRecovery.set(normalized, proof);
+      }
+      return await proof;
+    },
   });
 }
 
@@ -1122,11 +1202,19 @@ async function createStreamingCsvDataset(input: {
   options?: CsvRenameOptions;
 }): Promise<PlayDataset<Record<string, unknown>>> {
   let cachedCount: number | null = null;
+  const datasetId = createRuntimeDatasetId(
+    input.playName,
+    input.tableNamespace,
+  );
   const iterateProjected = () =>
     ({
       async *[Symbol.asyncIterator]() {
+        let rowIndex = 0;
         for await (const row of input.source.iterate()) {
-          yield applyCsvRenameProjection([row], input.options)[0]!;
+          yield setPlayDatasetSourceRowIdentity(
+            applyCsvRenameProjection([row], input.options)[0]!,
+            { datasetId, rowIndex: rowIndex++ },
+          );
         }
       },
     }) as AsyncIterable<Record<string, unknown>>;
@@ -1142,7 +1230,7 @@ async function createStreamingCsvDataset(input: {
   const previewRows = await collect(10);
   return createDeferredPlayDataset({
     datasetKind: 'csv',
-    datasetId: createRuntimeDatasetId(input.playName, input.tableNamespace),
+    datasetId,
     count: 0,
     knownCount: null,
     previewRows,
@@ -2204,6 +2292,7 @@ async function run(
       writeVersion?: number;
     }
   >();
+  const membershipCapturingMaps = new Set<string>();
   const runtimeMapDatasetSettlements = new Map<
     string,
     {
@@ -2449,6 +2538,8 @@ async function run(
       ];
     },
     getToolAuthScopeDigest: getRuntimeToolAuthScopeDigest,
+    getToolAsyncExecutionRecovery:
+      getRuntimeToolAuthScopeDigest.asyncExecutionRecovery,
     getToolRateScope: getRuntimeToolAuthScopeDigest.rateScope,
     invalidateToolAuthScopeDigest: (toolId) =>
       getRuntimeToolAuthScopeDigest.invalidate?.(toolId),
@@ -2734,6 +2825,8 @@ async function run(
             },
           ),
       });
+      if (mapStartResult.membershipCapture === true)
+        membershipCapturingMaps.add(attemptKey);
       const datasetId = createRuntimeDatasetId(playName, tableNamespace);
       const datasetPath = `datasets.${tableNamespace}`;
       const settlement = runtimeMapDatasetSettlements.get(datasetId) ?? {
@@ -2889,11 +2982,66 @@ async function run(
           ),
       });
     },
-    onMapRowsSettled: (input) => {
-      const datasetId = createRuntimeDatasetId(
-        input.playName ?? config.context.playName!,
-        input.tableNamespace,
-      );
+    onMapRowsSettled: async (input) => {
+      const playName = input.playName ?? config.context.playName!;
+      const runId =
+        input.runId ??
+        config.context.runId ??
+        config.context.workflowId ??
+        'anonymous-run';
+      const mapKey = runtimeSheetAttemptKey({
+        playName,
+        runId,
+        tableNamespace: input.tableNamespace,
+      });
+      if (
+        membershipCapturingMaps.has(mapKey) &&
+        input.expectedRows !== undefined
+      ) {
+        const sheetContract = resolveSheetContractForTableNamespace(
+          input.staticPipeline ?? config.context.staticPipeline,
+          input.tableNamespace,
+        );
+        if (!sheetContract)
+          throw new Error(
+            `Missing sheet contract while finishing membership for ${input.tableNamespace}.`,
+          );
+        const canUseRoot =
+          runId === (config.context.runId ?? config.context.workflowId);
+        await retryRuntimeSheetPersistence({
+          description: `runtime membership finish table=${input.tableNamespace}`,
+          log: (line) => emitWorkerLog(line, options),
+          signal: persistenceSignal,
+          run: () =>
+            finishRuntimeSheetRunMembership(
+              {
+                executorToken: config.context.executorToken,
+                baseUrl: config.context.baseUrl!,
+                orgId: config.context.orgId!,
+                playName,
+                runId,
+                userEmail: config.context.userEmail,
+                vercelProtectionBypassToken:
+                  config.context.vercelProtectionBypassToken,
+                dbSessionStrategy: config.context.dbSessionStrategy,
+                preloadedDbSessions: canUseRoot
+                  ? runtimePreloadedDbSessions
+                  : undefined,
+                postgresSessionUnwrapKey: canUseRoot
+                  ? runtimePostgresSessionUnwrapKey
+                  : config.context.executorToken,
+                abortSignal: persistenceSignal,
+              },
+              {
+                runId,
+                tableNamespace: input.tableNamespace,
+                sheetContract,
+                expectedRows: input.expectedRows!,
+              },
+            ),
+        });
+      }
+      const datasetId = createRuntimeDatasetId(playName, input.tableNamespace);
       const settlement = runtimeMapDatasetSettlements.get(datasetId);
       if (settlement && (!input.runId || settlement.runId === input.runId)) {
         Object.assign(