deepline 0.3.344 → 0.3.346

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.344',
+  version: '0.3.346',
   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/runtime-api.ts

@@ -520,6 +520,68 @@ export type RuntimeSheetTiming = {
   error?: string;
 };
 
+type RuntimeMapCompletionPhase =
+  | 'dbSessionAcquire'
+  | 'poolAcquire'
+  | 'transactionBegin'
+  | 'mapRowsUpdate'
+  | 'missingRowsInsert'
+  | 'failedRowsUpdate'
+  | 'transactionCommit'
+  | 'queryClient';
+
+type RuntimeMapCompletionDiagnostics = Record<
+  `${RuntimeMapCompletionPhase}Ms` | `${RuntimeMapCompletionPhase}Failures`,
+  number
+> & {
+  operationAttempts: number;
+  provisioningRetryAttempts: number;
+};
+
+function createRuntimeMapCompletionDiagnostics(): RuntimeMapCompletionDiagnostics {
+  return {
+    dbSessionAcquireMs: 0,
+    dbSessionAcquireFailures: 0,
+    poolAcquireMs: 0,
+    poolAcquireFailures: 0,
+    transactionBeginMs: 0,
+    transactionBeginFailures: 0,
+    mapRowsUpdateMs: 0,
+    mapRowsUpdateFailures: 0,
+    missingRowsInsertMs: 0,
+    missingRowsInsertFailures: 0,
+    failedRowsUpdateMs: 0,
+    failedRowsUpdateFailures: 0,
+    transactionCommitMs: 0,
+    transactionCommitFailures: 0,
+    queryClientMs: 0,
+    queryClientFailures: 0,
+    operationAttempts: 0,
+    provisioningRetryAttempts: 0,
+  };
+}
+
+async function measureRuntimeSheetPhase<T>(
+  diagnostics: RuntimeMapCompletionDiagnostics | undefined,
+  phase: RuntimeMapCompletionPhase,
+  operation: () => Promise<T>,
+): Promise<T> {
+  if (!diagnostics) return await operation();
+  const startedAt = Date.now();
+  let failed = false;
+  try {
+    return await operation();
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    const msKey = `${phase}Ms` as const;
+    const failuresKey = `${phase}Failures` as const;
+    diagnostics[msKey] += Date.now() - startedAt;
+    diagnostics[failuresKey] += Number(failed);
+  }
+}
+
 export type RuntimeSheetAttemptHeartbeatResult = {
   renewed: number;
   renewedKeys: string[];
@@ -2314,6 +2376,7 @@ async function withRuntimePostgres<T>(
     maxConnectAttempts?: number;
     operationTimeoutMs?: number;
     signal?: AbortSignal | null;
+    completionDiagnostics?: RuntimeMapCompletionDiagnostics;
   } = {},
 ): Promise<T> {
   let client: RuntimePoolClient | null = null;
@@ -2336,24 +2399,35 @@ async function withRuntimePostgres<T>(
       if (!cachePool) {
         requestLocalPool = pool;
       }
-      client = await connectRuntimePostgresPool(
-        pool,
-        admission,
-        lane,
-        session.postgresUrl,
-        options.signal,
+      client = await measureRuntimeSheetPhase(
+        options.completionDiagnostics,
+        'poolAcquire',
+        () =>
+          connectRuntimePostgresPool(
+            pool,
+            admission,
+            lane,
+            session.postgresUrl,
+            options.signal,
+          ),
       );
       operationDeadlineAt =
         options.operationTimeoutMs === undefined
           ? null
           : Date.now() + Math.max(1, Math.floor(options.operationTimeoutMs));
       if (session.executionRole) {
-        await awaitRuntimePostgresOperation({
-          client,
-          deadlineAt: operationDeadlineAt,
-          operation: client.query('BEGIN'),
-          signal: options.signal,
-        });
+        const roleClient = client;
+        await measureRuntimeSheetPhase(
+          options.completionDiagnostics,
+          'transactionBegin',
+          () =>
+            awaitRuntimePostgresOperation({
+              client: roleClient,
+              deadlineAt: operationDeadlineAt,
+              operation: roleClient.query('BEGIN'),
+              signal: options.signal,
+            }),
+        );
         roleTransactionStarted = true;
         await awaitRuntimePostgresOperation({
           client,
@@ -2419,12 +2493,18 @@ async function withRuntimePostgres<T>(
       signal: options.signal,
     });
     if (roleTransactionStarted) {
-      await awaitRuntimePostgresOperation({
-        client,
-        deadlineAt: operationDeadlineAt,
-        operation: client.query('COMMIT'),
-        signal: options.signal,
-      });
+      const roleClient = client;
+      await measureRuntimeSheetPhase(
+        options.completionDiagnostics,
+        'transactionCommit',
+        () =>
+          awaitRuntimePostgresOperation({
+            client: roleClient,
+            deadlineAt: operationDeadlineAt,
+            operation: roleClient.query('COMMIT'),
+            signal: options.signal,
+          }),
+      );
       roleTransactionStarted = false;
     }
     return result;
@@ -2549,10 +2629,14 @@ async function withRuntimeSheetProvisioningRetry<T>(
     sheetContract: PlaySheetContract;
     session: RuntimePostgresSession;
     timings?: RuntimeSheetTiming[];
+    completionDiagnostics?: RuntimeMapCompletionDiagnostics;
   },
   operation: () => Promise<T>,
 ): Promise<T> {
   const firstAttemptStartedAt = Date.now();
+  if (input.completionDiagnostics) {
+    input.completionDiagnostics.operationAttempts += 1;
+  }
   try {
     const result = await operation();
     input.timings?.push({
@@ -2610,6 +2694,10 @@ async function withRuntimeSheetProvisioningRetry<T>(
     } else {
       throw error;
     }
+    if (input.completionDiagnostics) {
+      input.completionDiagnostics.provisioningRetryAttempts += 1;
+      input.completionDiagnostics.operationAttempts += 1;
+    }
     const retryStartedAt = Date.now();
     const result = await operation();
     input.timings?.push({
@@ -2631,11 +2719,12 @@ async function withRuntimeSheetQueryClient<T>(
     transactional: boolean;
     statementTimeoutMs?: number;
     timings?: RuntimeSheetTiming[];
+    completionDiagnostics?: RuntimeMapCompletionDiagnostics;
   },
   operation: (client: RuntimeQueryClient) => Promise<T>,
 ): Promise<T> {
-  const totalStartedAt = Date.now();
-  const result = await withRuntimeSheetProvisioningRetry(
+  const resultStartedAt = Date.now();
+  const resultPromise = withRuntimeSheetProvisioningRetry(
     context,
     { ...input, session },
     async () => {
@@ -2661,7 +2750,13 @@ async function withRuntimeSheetQueryClient<T>(
           const managesTransaction =
             (input.transactional || input.statementTimeoutMs !== undefined) &&
             !transaction.active;
-          if (managesTransaction) await client.query('BEGIN');
+          if (managesTransaction) {
+            await measureRuntimeSheetPhase(
+              input.completionDiagnostics,
+              'transactionBegin',
+              () => client.query('BEGIN'),
+            );
+          }
           try {
             if (input.statementTimeoutMs !== undefined) {
               await client.query(
@@ -2669,7 +2764,13 @@ async function withRuntimeSheetQueryClient<T>(
               );
             }
             const result = await operation(client);
-            if (managesTransaction) await client.query('COMMIT');
+            if (managesTransaction) {
+              await measureRuntimeSheetPhase(
+                input.completionDiagnostics,
+                'transactionCommit',
+                () => client.query('COMMIT'),
+              );
+            }
             return result;
           } catch (error) {
             if (managesTransaction) {
@@ -2687,13 +2788,22 @@ async function withRuntimeSheetQueryClient<T>(
               ? undefined
               : RUNTIME_SHEET_COMPLETION_SERVER_OPERATION_TIMEOUT_MS,
           signal: context.abortSignal,
+          completionDiagnostics: input.completionDiagnostics,
         },
       );
     },
   );
+  if (input.completionDiagnostics) {
+    return await measureRuntimeSheetPhase(
+      input.completionDiagnostics,
+      'queryClient',
+      () => resultPromise,
+    );
+  }
+  const result = await resultPromise;
   input.timings?.push({
     phase: 'query_client_total',
-    ms: Date.now() - totalStartedAt,
+    ms: Date.now() - resultStartedAt,
   });
   return result;
 }
@@ -8686,24 +8796,62 @@ export async function completeRuntimeMapRows(
     rows: input.rows.map((row) => row.data),
     outputFields: input.outputFields,
   });
-  const session = requireRuntimePostgresSession(
-    await getRuntimeDbSession(
-      {
-        ...context,
-        playName: context.playName,
-        runId: context.runId ?? input.runId,
-      },
-      {
-        tableNamespace: input.tableNamespace,
-        logicalTable: 'sheet_rows',
-        operations: ['rows.read', 'rows.upsert'],
-        limits: {
-          maxRows: runtimeDbSessionRowLimit(input.rows.length),
-        },
-        sheetContract,
-      },
-    ),
-  );
+  const completionDiagnostics = createRuntimeMapCompletionDiagnostics();
+  const completionStartedAt = Date.now();
+  let completionOutcome: 'succeeded' | 'failed' = 'failed';
+  let uniqueRowCount = 0;
+  let completedRowCount = 0;
+  let failedRowCount = 0;
+  let chunkCount = 0;
+  let updatedRowCount = 0;
+  let fencedRowCount = 0;
+  const logCompletion = () => {
+    console.info(
+      '[runtime-sheet-map-completion]',
+      JSON.stringify({
+        event: 'finished',
+        outcome: completionOutcome,
+        inputRows: input.rows.length,
+        uniqueRows: uniqueRowCount,
+        completedRows: completedRowCount,
+        failedRows: failedRowCount,
+        chunks: chunkCount,
+        updatedRows: updatedRowCount,
+        fencedRows: fencedRowCount,
+        ...completionDiagnostics,
+        totalMs: Date.now() - completionStartedAt,
+      }),
+    );
+  };
+  let session: RuntimePostgresSession;
+  try {
+    session = await measureRuntimeSheetPhase(
+      completionDiagnostics,
+      'dbSessionAcquire',
+      async () =>
+        requireRuntimePostgresSession(
+          await getRuntimeDbSession(
+            {
+              ...context,
+              playName: context.playName,
+              runId: context.runId ?? input.runId,
+            },
+            {
+              tableNamespace: input.tableNamespace,
+              logicalTable: 'sheet_rows',
+              operations: ['rows.read', 'rows.upsert'],
+              limits: {
+                maxRows: runtimeDbSessionRowLimit(input.rows.length),
+              },
+              sheetContract,
+            },
+          ),
+        ),
+    );
+  } catch (error) {
+    logCompletion();
+    throw error;
+  }
 
   // Dedupe by key. Last write wins on payload, status, and error.
   const uniqueRows = new Map<string, RuntimeApiRowRecord>();
@@ -8718,7 +8866,10 @@ export async function completeRuntimeMapRows(
     if (!resolvedKey) continue;
     uniqueRows.set(resolvedKey, { ...row, key: resolvedKey });
   }
+  uniqueRowCount = uniqueRows.size;
   if (uniqueRows.size === 0) {
+    completionOutcome = 'succeeded';
+    logCompletion();
     return classifyRuntimeMapRowsWrite({
       submittedKeys: [],
       updated: 0,
@@ -8735,6 +8886,9 @@ export async function completeRuntimeMapRows(
   });
   const chunks = chunkValues(completedRows, DIRECT_POSTGRES_BATCH_SIZE);
   const failedChunks = chunkValues(failedRows, DIRECT_POSTGRES_BATCH_SIZE);
+  completedRowCount = completedRows.length;
+  failedRowCount = failedRows.length;
+  chunkCount = chunks.length + failedChunks.length;
   const needsTransaction = true;
   const outputFields = [...new Set(input.outputFields ?? [])];
   const attemptId = input.attemptId?.trim() || null;
@@ -8752,7 +8906,7 @@ export async function completeRuntimeMapRows(
     );
   }
 
-  return await withRuntimeSheetQueryClient(
+  return withRuntimeSheetQueryClient(
     context,
     session,
     {
@@ -8761,6 +8915,7 @@ export async function completeRuntimeMapRows(
       sheetContract,
       transactional: needsTransaction,
       statementTimeoutMs: RUNTIME_SHEET_COMPLETION_STATEMENT_TIMEOUT_MS,
+      completionDiagnostics,
     },
     async (client) => {
       const completed =
@@ -8781,15 +8936,20 @@ export async function completeRuntimeMapRows(
                 ),
                 outputFields,
               };
-              const updated = await completeRuntimeMapRowChunks(
-                client,
-                session,
-                chunkInput,
+              const updated = await measureRuntimeSheetPhase(
+                completionDiagnostics,
+                'mapRowsUpdate',
+                () => completeRuntimeMapRowChunks(client, session, chunkInput),
               );
-              const inserted = await insertMissingCompletedMapRowChunks(
-                client,
-                session,
-                chunkInput,
+              const inserted = await measureRuntimeSheetPhase(
+                completionDiagnostics,
+                'missingRowsInsert',
+                () =>
+                  insertMissingCompletedMapRowChunks(
+                    client,
+                    session,
+                    chunkInput,
+                  ),
               );
               return {
                 updated: updated.updated + inserted.inserted,
@@ -8799,21 +8959,28 @@ export async function completeRuntimeMapRows(
           : { updated: 0, fencedRows: [] };
       const failed =
         failedRows.length > 0
-          ? await failRuntimeMapRowChunks(client, session, {
-              chunks: failedChunks,
-              physicalColumnProjections: projections,
-              forceTerminal: input.forceFailedRows === true,
-              runId: input.runId,
-              attemptId,
-              attemptOwnerRunId,
-              attemptExpiresAt,
-              attemptSeq,
-              writeVersion,
-              normalizedPlayName: normalizePlayNameForSheet(session.playName),
-              normalizedTableNamespace: normalizeTableNamespace(
-                input.tableNamespace,
-              ),
-            })
+          ? await measureRuntimeSheetPhase(
+              completionDiagnostics,
+              'failedRowsUpdate',
+              () =>
+                failRuntimeMapRowChunks(client, session, {
+                  chunks: failedChunks,
+                  physicalColumnProjections: projections,
+                  forceTerminal: input.forceFailedRows === true,
+                  runId: input.runId,
+                  attemptId,
+                  attemptOwnerRunId,
+                  attemptExpiresAt,
+                  attemptSeq,
+                  writeVersion,
+                  normalizedPlayName: normalizePlayNameForSheet(
+                    session.playName,
+                  ),
+                  normalizedTableNamespace: normalizeTableNamespace(
+                    input.tableNamespace,
+                  ),
+                }),
+            )
           : { updated: 0, fencedRows: [] };
       return classifyRuntimeMapRowsWrite({
         submittedKeys: uniqueRows.keys(),
@@ -8821,7 +8988,14 @@ export async function completeRuntimeMapRows(
         fencedRows: [...completed.fencedRows, ...failed.fencedRows],
       });
     },
-  );
+  )
+    .then((result) => {
+      updatedRowCount = result.updated;
+      fencedRowCount = result.fencedKeys.length;
+      completionOutcome = 'succeeded';
+      return result;
+    })
+    .finally(logCompletion);
 }
 
 /**

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

@@ -20173,6 +20173,18 @@ async function dispatchRunLedgerOutboxBatchWithScope(
           : undefined),
     );
   const tokenAuthority = input.tokenAuthority ?? 'local_mint';
+  const reuseMarginMs =
+    Math.max(
+      1,
+      Math.floor(
+        input.runtimeApi?.requestTimeoutMs ??
+          RUNTIME_CAPACITY_POLICY.receiptGateway.requestTimeoutMs,
+      ),
+    ) + RUNTIME_RELIABILITY_POLICY.schedulerDatabase.queryTimeoutMs;
+  const ingressPrefixLimit = Math.min(
+    RUN_LEDGER_PROJECTION_PREFIX_MAX_FACTS,
+    remainingEvents ?? RUN_LEDGER_PROJECTION_PREFIX_MAX_FACTS,
+  );
   const leaseOwner =
     input.leaseOwner?.trim() || `run-ledger-outbox-dispatch:${randomUUID()}`;
   const needsLaunch =
@@ -20249,7 +20261,8 @@ async function dispatchRunLedgerOutboxBatchWithScope(
       const unclaimed: {
         events: PostgresSchedulerOutboxEvent[];
         launchJson: unknown;
-      } = { events: [], launchJson: undefined };
+        ingressPrefixClaimed: boolean;
+      } = { events: [], launchJson: undefined, ingressPrefixClaimed: false };
       return unclaimed;
     }
     // A re-invocation with no named head claims again under the same owner,
@@ -20386,6 +20399,25 @@ async function dispatchRunLedgerOutboxBatchWithScope(
             FOR UPDATE OF runs SKIP LOCKED LIMIT 1
           `));
       const runId = selected.rows[0]?.run_id;
+      let ingressPrefixClaimed = false;
+      if (
+        runId &&
+        tokenAuthority === 'gateway' &&
+        !input.searchOnly &&
+        (input.limit ?? 1) === ingressPrefixLimit
+      ) {
+        try {
+          const launch = parseRunLedgerDispatchLaunch(
+            selected.rows[0]?.dispatch_launch_json,
+          );
+          ingressPrefixClaimed =
+            launch.runId === runId &&
+            usableRunLedgerExecutorToken(launch, reuseMarginMs, options)
+              ?.runLedgerIngressPrefixBatching === true;
+        } catch {
+          // Malformed launches retain the existing post-claim failure policy.
+        }
+      }
       const claimed = runId
         ? await readPendingPostgresSchedulerOutboxEvents(
             client,
@@ -20397,6 +20429,7 @@ async function dispatchRunLedgerOutboxBatchWithScope(
               inTransaction: true,
               restartTransactionOnMissingMarker: true,
               searchOnly: input.searchOnly,
+              allowIngressPrefix: ingressPrefixClaimed,
             },
             options,
           )
@@ -20409,6 +20442,7 @@ async function dispatchRunLedgerOutboxBatchWithScope(
       return {
         events: claimed,
         launchJson: selected.rows[0]?.dispatch_launch_json,
+        ingressPrefixClaimed,
       };
     } catch (error) {
       await client.query('ROLLBACK');
@@ -20419,7 +20453,7 @@ async function dispatchRunLedgerOutboxBatchWithScope(
     ? scope.nextClaimed.splice(0)
     : null;
   const claimed = preclaimed
-    ? { events: preclaimed, launchJson: null }
+    ? { events: preclaimed, launchJson: null, ingressPrefixClaimed: false }
     : await withClient(async (client) => {
         try {
           return await claimEvents(client);
@@ -20661,14 +20695,6 @@ async function dispatchRunLedgerOutboxBatchWithScope(
     }
     const needsRuntimeApi = ledgerEvents === null || ledgerEvents.length > 0;
     let runtimeApi: WorkerRuntimeApiContext | null = null;
-    const reuseMarginMs =
-      Math.max(
-        1,
-        Math.floor(
-          input.runtimeApi?.requestTimeoutMs ??
-            RUNTIME_CAPACITY_POLICY.receiptGateway.requestTimeoutMs,
-        ),
-      ) + RUNTIME_RELIABILITY_POLICY.schedulerDatabase.queryTimeoutMs;
     const cachedAuthority = authorityScope.authority;
     const observeDispatchTokenResponse = (
       observation: RunLedgerDispatchTokenObservation,
@@ -20787,11 +20813,10 @@ async function dispatchRunLedgerOutboxBatchWithScope(
       }
       authorityReadyAtMs = Date.now();
     }
-    // The initial claim deliberately uses the old contract until its immutable
-    // launch receiver advertises support. Widen under the same run/owner fence
-    // before the first HTTP append, so an already-finished run need not pay one
-    // authority/append/ACK round trip for every ingress predecessor.
+    // A prefix-capable initial claim freezes even a singleton receipt. Only
+    // widen when receiver support was not already used by that claim.
     if (
+      !claimed.ingressPrefixClaimed &&
       runtimeApi?.runLedgerIngressPrefixBatching === true &&
       events.length === 1 &&
       first.eventType === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runEvents
@@ -20820,10 +20845,7 @@ async function dispatchRunLedgerOutboxBatchWithScope(
               runId: first.runId,
               leaseOwner,
               leaseSeconds: input.leaseSeconds ?? 120,
-              limit: Math.min(
-                RUN_LEDGER_PROJECTION_PREFIX_MAX_FACTS,
-                remainingEvents ?? RUN_LEDGER_PROJECTION_PREFIX_MAX_FACTS,
-              ),
+              limit: ingressPrefixLimit,
               allowIngressPrefix: true,
               extendOwnedHead: first.eventId,
               inTransaction: true,

package/dist/cli/auth-5YTC2XH2.js

@@ -0,0 +1,31 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+var _chunkEJ2NVO5Kjs = require('./chunk-EJ2NVO5K.js');
+require('./chunk-4Q572AVS.js');
+require('./chunk-22GXXUTB.js');
+require('./chunk-XNYIZMNQ.js');
+require('./chunk-GGSLHWTB.js');
+require('./chunk-7P5AA3SN.js');
+require('./chunk-OG64RBAC.js');
+require('./chunk-COGTRVWW.js');
+
+
+
+
+
+
+
+
+
+
+
+exports.EXIT_WORKSPACE_MISMATCH = _chunkEJ2NVO5Kjs.EXIT_WORKSPACE_MISMATCH; exports.clearPendingClaim = _chunkEJ2NVO5Kjs.clearPendingClaim; exports.clearSatisfiedPendingClaim = _chunkEJ2NVO5Kjs.clearSatisfiedPendingClaim; exports.handleRegister = _chunkEJ2NVO5Kjs.handleRegister; exports.handleStatus = _chunkEJ2NVO5Kjs.handleStatus; exports.handleWait = _chunkEJ2NVO5Kjs.handleWait; exports.readPendingAuthClaim = _chunkEJ2NVO5Kjs.readPendingAuthClaim; exports.registerAuthCommands = _chunkEJ2NVO5Kjs.registerAuthCommands; exports.reportSetupCompleted = _chunkEJ2NVO5Kjs.reportSetupCompleted; exports.resolvePendingAuthClaimForResume = _chunkEJ2NVO5Kjs.resolvePendingAuthClaimForResume;

package/dist/cli/{auth-KHHPB2DO.mjs → auth-HTWHQNMY.mjs}

@@ -9,11 +9,11 @@ import {
   registerAuthCommands,
   reportSetupCompleted,
   resolvePendingAuthClaimForResume
-} from "./chunk-XRZUDK6O.mjs";
-import "./chunk-DRHVFFMJ.mjs";
-import "./chunk-J5NN6XCF.mjs";
+} from "./chunk-XAM3XOUA.mjs";
+import "./chunk-2GRMXCLZ.mjs";
+import "./chunk-VC7M2QR7.mjs";
 import "./chunk-DLIRSHV6.mjs";
-import "./chunk-RN7NIZIL.mjs";
+import "./chunk-MOVEHSNM.mjs";
 import "./chunk-NXGCO4JB.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";