deepline 0.3.392 → 0.3.394

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';
@@ -354,6 +357,7 @@ export function playRunnerReceiptStoreAdapterOptions() {
 type RuntimeStepReceiptHandlers = RuntimeReceiptStoreHandlers;
 
 type RuntimeToolMetadata = {
+  reusableResult?: { supported: boolean; unavailableReason: string | null };
   provider?: string | null;
   operation?: string | null;
   extractors?: ToolResultMetadataInput['extractors'];
@@ -379,6 +383,8 @@ type RuntimeToolMetadata = {
 
 type RuntimeToolAuthScope = {
   digest?: unknown;
+  managedAsyncExecutionRecovery?: unknown;
+  managedAsyncExecutionRecoveryOrigin?: unknown;
   rateScope?: {
     bucketId?: unknown;
     provider?: unknown;
@@ -534,7 +540,7 @@ export function runtimeSheetTerminalMapCounts(
 }
 
 async function vercelBypassHeaders(
-  config: PlayRunnerExecutionConfig,
+  config: Pick<PlayRunnerExecutionConfig, 'context'>,
 ): Promise<Record<string, string>> {
   return vercelProtectionBypassHeader(
     config.context.vercelProtectionBypassToken,
@@ -723,9 +729,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 +794,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 +816,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 +831,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 +1203,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 +1231,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 +2293,7 @@ async function run(
       writeVersion?: number;
     }
   >();
+  const membershipCapturingMaps = new Set<string>();
   const runtimeMapDatasetSettlements = new Map<
     string,
     {
@@ -2421,6 +2511,15 @@ async function run(
         ? 'invocation'
         : null;
     },
+    getToolReusableResultSupport: async (toolId) => {
+      const support = (await getRuntimeToolMetadata(toolId)).reusableResult;
+      if (!support) {
+        throw new Error(
+          `Tool ${toolId} has no reusable-result capability metadata. Deploy the runtime metadata reader before admitting explicit-freshness artifacts.`,
+        );
+      }
+      return support;
+    },
     getToolRetryPolicy: async (toolId) => {
       const metadata = await getRuntimeToolMetadata(toolId);
       return {
@@ -2449,6 +2548,8 @@ async function run(
       ];
     },
     getToolAuthScopeDigest: getRuntimeToolAuthScopeDigest,
+    getToolAsyncExecutionRecovery:
+      getRuntimeToolAuthScopeDigest.asyncExecutionRecovery,
     getToolRateScope: getRuntimeToolAuthScopeDigest.rateScope,
     invalidateToolAuthScopeDigest: (toolId) =>
       getRuntimeToolAuthScopeDigest.invalidate?.(toolId),
@@ -2734,6 +2835,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 +2992,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(

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

@@ -46,6 +46,11 @@ import {
 } from '../play-data-plane/sheet-column-storage';
 import {
   RUNTIME_SHEET_CELL_META_COLUMN,
+  RUNTIME_SHEET_RUN_MEMBERSHIP_TABLE,
+  RUNTIME_SHEET_RUN_MEMBERSHIP_WRITES_ENABLED,
+  appendRuntimeSheetRunRowMembershipBatch,
+  isRuntimeSheetRunMembershipStorageAvailable,
+  type RuntimeSheetRunRowMembership,
   runtimeSheetResultFreshnessSql,
   runtimeSheetResultAdmissionSql,
 } from '../play-data-plane/runtime-sheet-storage-contract';
@@ -66,6 +71,7 @@ import type {
 } from './db-session';
 import {
   derivePlayRowIdentity,
+  stableStringify,
   normalizePlayNameForSheet,
   normalizeTableNamespace,
 } from '../plays/row-identity';
@@ -503,6 +509,8 @@ export type PrepareRuntimeSheetResult = {
   attemptExpiresAt?: string;
   attemptSeq?: number;
   writeVersion?: number;
+  /** Optional reader-first capture capability; absent retains legacy behavior. */
+  membershipCapture?: boolean;
 };
 
 export type RuntimeSheetTiming = {
@@ -645,6 +653,10 @@ type RuntimeApiActionRequest =
       action: keyof typeof RUNTIME_SHEET_ADMISSION_CAPABILITIES;
       input: Parameters<typeof startRuntimeSheetDataset>[1];
     }
+  | {
+      action: 'runtime_sheet_finish_membership';
+      input: Parameters<typeof finishRuntimeSheetRunMembership>[1];
+    }
   | {
       action: 'runtime_sheet_complete_map_rows';
       input: Parameters<typeof completeRuntimeMapRows>[1];
@@ -2872,6 +2884,151 @@ async function registerRuntimeDataset(
   );
 }
 
+async function runtimeSheetMembershipCaptureAvailable(
+  client: RuntimeQueryClient,
+  session: RuntimePostgresSession,
+): Promise<boolean> {
+  if (!RUNTIME_SHEET_RUN_MEMBERSHIP_WRITES_ENABLED) return false;
+  return isRuntimeSheetRunMembershipStorageAvailable(
+    async <Row>(sql: string, params?: readonly unknown[]) => {
+      const result = await client.query(sql, params ? [...params] : undefined);
+      return { rows: result.rows as Row[] };
+    },
+    session.postgres.schema,
+    true,
+  );
+}
+
+async function persistRuntimeSheetMembershipBatch(
+  client: RuntimeQueryClient,
+  session: RuntimePostgresSession,
+  rows: Array<Omit<RuntimeSheetRunRowMembership, 'recordedAt'>>,
+) {
+  await appendRuntimeSheetRunRowMembershipBatch(
+    async <Row>(sql: string, params?: readonly unknown[]) => {
+      const result = await client.query(sql, params ? [...params] : undefined);
+      return { rows: result.rows as Row[] };
+    },
+    rows,
+    session.postgres.schema,
+  );
+}
+
+async function captureRuntimeSheetTerminalMembership(
+  client: RuntimeQueryClient,
+  session: RuntimePostgresSession,
+  input: {
+    runId: string;
+    tableNamespace: string;
+    sheetContract: PlaySheetContract;
+    keys: string[];
+  },
+): Promise<void> {
+  if (input.keys.length === 0) return;
+  const datasetId = createRuntimeDatasetId(
+    session.playName,
+    input.tableNamespace,
+  );
+  // Read canonical values AFTER the fenced mutation, inside its transaction.
+  // A stale submitted body must never become a fabricated historical result.
+  const result = await client.query<Record<string, unknown>>(
+    `SELECT target.*, admission.input_digest AS membership_input_digest, admission.source_ref AS membership_source_ref
+    FROM ${sheetTable(session)} target
+    JOIN ${fqRuntimeTable(session, RUNTIME_SHEET_RUN_MEMBERSHIP_TABLE)} admission
+      ON admission.run_id = $1 AND admission.dataset_id = $2 AND admission.row_key = target._key AND admission.phase = 'admitted'
+    WHERE target._key = ANY($3::text[]) AND target._run_id = $1 AND target._status IN ('enriched', 'failed')`,
+    [input.runId, datasetId, input.keys],
+  );
+  const snapshots = result.rows.map((raw) => {
+    const attemptSeq =
+      raw._attempt_seq == null ? null : Number(raw._attempt_seq);
+    const rowVersion = Number(raw._version);
+    const data = mapRuntimePostgresRow({
+      raw,
+      sheetContract: input.sheetContract,
+    }).data;
+    delete data[DEEPLINE_CELL_META_FIELD];
+    return {
+      runId: input.runId,
+      datasetId,
+      rowKey: String(raw._key),
+      phase: 'terminal' as const,
+      generation: `attempt:${attemptSeq ?? 'legacy'}:version:${rowVersion}`,
+      attemptSeq,
+      rowVersion,
+      inputIndex: raw._input_index == null ? null : Number(raw._input_index),
+      inputDigest: String(raw.membership_input_digest),
+      status: raw._status as 'enriched' | 'failed',
+      data,
+      source: {
+        ...(raw.membership_source_ref as Record<string, unknown>),
+        ...(raw._error == null ? {} : { rowError: String(raw._error) }),
+      },
+    };
+  });
+  await persistRuntimeSheetMembershipBatch(client, session, snapshots);
+}
+
+/** Named completion is called only after admission advertised capture. */
+export async function finishRuntimeSheetRunMembership(
+  context: RuntimeApiContext & { playName: string },
+  input: {
+    runId: string;
+    tableNamespace: string;
+    sheetContract: PlaySheetContract;
+    expectedRows: number;
+  },
+): Promise<{ captured: boolean; complete: boolean }> {
+  if (!Number.isSafeInteger(input.expectedRows) || input.expectedRows < 0)
+    throw new Error('Membership expectedRows must be a non-negative integer.');
+  if (context.dbSessionStrategy === 'gateway_only')
+    return postRuntimeApi(context, {
+      action: 'runtime_sheet_finish_membership',
+      input,
+    });
+  const session = requireRuntimePostgresSession(
+    await getRuntimeDbSession(context, {
+      tableNamespace: input.tableNamespace,
+      logicalTable: 'sheet_rows',
+      operations: ['rows.read', 'rows.upsert'],
+      limits: {},
+    }),
+  );
+  return withRuntimeSheetQueryClient(
+    context,
+    session,
+    {
+      playName: context.playName,
+      tableNamespace: input.tableNamespace,
+      sheetContract: input.sheetContract,
+      transactional: true,
+    },
+    async (client) => {
+      if (!(await runtimeSheetMembershipCaptureAvailable(client, session)))
+        return { captured: false, complete: false };
+      const datasetId = createRuntimeDatasetId(
+        session.playName,
+        input.tableNamespace,
+      );
+      const result = await client.query<{ complete: boolean }>(
+        `UPDATE ${runDatasetCatalogTable(session)} catalog
+      SET membership_expected_rows = $3,
+          membership_completed_at = CASE WHEN
+            (SELECT count(*) FROM ${fqRuntimeTable(session, RUNTIME_SHEET_RUN_MEMBERSHIP_TABLE)} WHERE run_id = $1 AND dataset_id = $2 AND phase = 'admitted') = $3
+            AND (SELECT count(DISTINCT row_key) FROM ${fqRuntimeTable(session, RUNTIME_SHEET_RUN_MEMBERSHIP_TABLE)} WHERE run_id = $1 AND dataset_id = $2 AND phase = 'terminal') = $3
+          THEN coalesce(catalog.membership_completed_at, now()) ELSE NULL END
+      WHERE run_id = $1 AND dataset_id = $2 AND membership_started_at IS NOT NULL
+      RETURNING membership_completed_at IS NOT NULL AS complete`,
+        [input.runId, datasetId, input.expectedRows],
+      );
+      return {
+        captured: result.rows.length === 1,
+        complete: result.rows[0]?.complete === true,
+      };
+    },
+  );
+}
+
 function workReceiptTable(session: RuntimePostgresSession): string {
   return fqRuntimeTable(
     session,
@@ -6877,9 +7034,16 @@ export async function startRuntimeSheetDataset(
   const normalizeStartedAt = Date.now();
   const uniqueRows = new Map<
     string,
-    { row: Record<string, unknown>; inputIndex: number | null }
+    {
+      row: Record<string, unknown>;
+      inputIndex: number | null;
+      sourceRowIndex: number | null;
+      source: Record<string, unknown>;
+      rowOffset: number;
+    }
   >();
-  for (const row of input.rows) {
+  for (let rowOffset = 0; rowOffset < input.rows.length; rowOffset += 1) {
+    const row = input.rows[rowOffset]!;
     // Materializes projected CSV aliases as visible cells and drops internal
     // __deepline* keys — a plain spread would silently lose the
     // non-enumerable alias fields on the JSON payload boundary.
@@ -6887,23 +7051,37 @@ export async function startRuntimeSheetDataset(
     const key =
       resolveMapRowOutcomeKey(row) ??
       derivePlayRowIdentity(cleanedRow, input.tableNamespace);
+    const source =
+      row.__deeplineSourceRow && typeof row.__deeplineSourceRow === 'object'
+        ? (sanitizePostgresJsonValue(row.__deeplineSourceRow) as Record<
+            string,
+            unknown
+          >)
+        : {};
+    const sourceRowIndex = normalizeRuntimeMapInputIndex(source.rowIndex);
     if (key && !uniqueRows.has(key)) {
       uniqueRows.set(key, {
         row: sanitizePostgresJsonValue(cleanedRow),
+        source,
+        sourceRowIndex,
         inputIndex: normalizeRuntimeMapInputIndex(
           row[MAP_ROW_OUTCOME_RUNTIME_FIELDS.inputIndex],
         ),
+        rowOffset,
       });
     }
   }
   const inputOffset = Math.max(0, Math.floor(input.inputOffset ?? 0));
-  const rowEntries = [...uniqueRows.entries()].map(
-    ([key, entry], inputIndex) => ({
-      key,
-      row: entry.row,
-      inputIndex: entry.inputIndex ?? inputOffset + inputIndex,
-    }),
-  );
+  const rowEntries = [...uniqueRows.entries()].map(([key, entry]) => ({
+    key,
+    row: entry.row,
+    source: entry.source,
+    // A CSV transformation may filter or reorder the physical source rows.
+    // Its source ordinal must win over the compacted input index stamped by
+    // ctx.dataset while preparing this page.
+    inputIndex:
+      entry.sourceRowIndex ?? entry.inputIndex ?? inputOffset + entry.rowOffset,
+  }));
   timings.push({
     phase: 'normalize_rows',
     ms: Date.now() - normalizeStartedAt,
@@ -7135,6 +7313,60 @@ export async function startRuntimeSheetDataset(
         force: input.force === true,
         ...prepared,
       });
+      const membershipCapture = await runtimeSheetMembershipCaptureAvailable(
+        client,
+        session,
+      );
+      if (membershipCapture) {
+        const dispositions = new Set(
+          prepared.rowDispositions
+            .filter(
+              (row) =>
+                row.disposition === 'pending' ||
+                row.disposition === 'completed',
+            )
+            .map((row) => row.key),
+        );
+        const admitted = rowEntries.filter((entry) =>
+          dispositions.has(entry.key),
+        );
+        await client.query(
+          `UPDATE ${runDatasetCatalogTable(session)} SET membership_started_at = coalesce(membership_started_at, now()) WHERE run_id = $1 AND dataset_id = $2`,
+          [
+            input.runId,
+            createRuntimeDatasetId(session.playName, input.tableNamespace),
+          ],
+        );
+        await persistRuntimeSheetMembershipBatch(
+          client,
+          session,
+          admitted.map((entry) => ({
+            runId: input.runId,
+            datasetId: createRuntimeDatasetId(
+              session.playName,
+              input.tableNamespace,
+            ),
+            rowKey: entry.key,
+            phase: 'admitted',
+            generation: 'admitted',
+            attemptSeq: null,
+            rowVersion: null,
+            inputIndex: entry.inputIndex,
+            inputDigest: createHash('sha256')
+              .update(stableStringify(entry.row))
+              .digest('hex'),
+            status: 'pending',
+            data: entry.row,
+            source: entry.source,
+          })),
+        );
+        await captureRuntimeSheetTerminalMembership(client, session, {
+          runId: input.runId,
+          tableNamespace: input.tableNamespace,
+          sheetContract: input.sheetContract,
+          keys: admitted.map((entry) => entry.key),
+        });
+      }
       timings.push({
         phase: 'build_result',
         ms: Date.now() - buildStartedAt,
@@ -7146,6 +7378,7 @@ export async function startRuntimeSheetDataset(
       });
       return {
         ...built,
+        membershipCapture,
         attemptExpiresAt,
         attemptSeq,
         writeVersion,
@@ -8982,11 +9215,20 @@ export async function completeRuntimeMapRows(
                 }),
             )
           : { updated: 0, fencedRows: [] };
-      return classifyRuntimeMapRowsWrite({
+      const classified = classifyRuntimeMapRowsWrite({
         submittedKeys: uniqueRows.keys(),
         updated: completed.updated + failed.updated,
         fencedRows: [...completed.fencedRows, ...failed.fencedRows],
       });
+      if (await runtimeSheetMembershipCaptureAvailable(client, session)) {
+        await captureRuntimeSheetTerminalMembership(client, session, {
+          runId: input.runId,
+          tableNamespace: input.tableNamespace,
+          sheetContract,
+          keys: classified.committedKeys,
+        });
+      }
+      return classified;
     },
   )
     .then((result) => {