deepline 0.3.361 → 0.3.363

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.361',
+  version: '0.3.363',
   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/scheduler-backends/postgres.ts

@@ -18788,6 +18788,8 @@ export async function readPostgresSchedulerOutboxNextDueAt(
   client: PostgresSchedulerQueryClient,
   options?: Pick<PostgresSchedulerOptions, 'schema'> & {
     lane?: 'lifecycle' | 'observability';
+    /** Read one notified run's clock instead of enumerating every pending run. */
+    runId?: string;
   },
 ): Promise<Date | null> {
   const lanes =
@@ -18796,10 +18798,18 @@ export async function readPostgresSchedulerOutboxNextDueAt(
       : options?.lane === 'observability'
         ? [true]
         : [false, true];
+  const runId = options?.runId?.trim() || null;
   const result = await client.query<{ due_at: Date | string | null }>(
     `
       -- Seek distinct run identities without reading their pending fact tails.
-      WITH RECURSIVE ${runLedgerPendingRunsSql(options, options?.lane === undefined ? undefined : lanes[0])}, heads AS MATERIALIZED (
+      WITH RECURSIVE ${
+        runId
+          ? 'pending_runs AS (SELECT $1::text AS run_id)'
+          : runLedgerPendingRunsSql(
+              options,
+              options?.lane === undefined ? undefined : lanes[0],
+            )
+      }, heads AS MATERIALIZED (
         ${lanes
           .map(
             (
@@ -18836,6 +18846,7 @@ export async function readPostgresSchedulerOutboxNextDueAt(
       -- A failed head quarantines its lane; never wake on its successor.
       WHERE candidate.failed_at IS NULL
     `,
+    runId ? [runId] : undefined,
   );
   const value = result.rows[0]?.due_at;
   if (value instanceof Date) return value;

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/run-ledger-outbox-recovery.ts

@@ -99,8 +99,14 @@ export type RunLedgerOutboxRecoveryDeps = {
     runId?: string,
   ) => Promise<PostgresSchedulerOutboxProjectionResult>;
   observabilityParallelism?: number;
-  /** Earliest pending retry time or active lease expiry in the durable outbox. */
-  readNextDueAt: (lane?: 'lifecycle' | 'observability') => Promise<Date | null>;
+  /**
+   * Earliest pending retry time or active lease expiry in the durable outbox,
+   * or in one run's lane when `runId` names it.
+   */
+  readNextDueAt: (
+    lane?: 'lifecycle' | 'observability',
+    runId?: string,
+  ) => Promise<Date | null>;
   /** A direct LISTEN connection. It is a hint only; a null lease is safe. */
   acquireNotifyHub: () => PgNotifyHubLease | null;
   /** Bounded number of independent runs this replica may deliver at once. */
@@ -207,9 +213,10 @@ export function startRunLedgerOutboxRecovery(
   let dueClockRefreshRequested = false;
   let dueClockReadGeneration = 0;
   let dueClockKnownLane: 'both' | 'lifecycle' | 'observability' | null = null;
-  let producerHintGeneration = 0;
-  let dueClockReadHintGeneration = 0;
-  let dueClockKnownHintGeneration = -1;
+  // Earliest run clock learned while a global read was in flight. That read's
+  // snapshot may predate the run's lease, so it must not arm a later wake.
+  let runDueDuringGlobalReadMs: number | null = null;
+  const runDueReads = new Set<Promise<void>>();
   let drainPromise: Promise<void> | null = null;
   let wakeActiveDrain: (() => void) | null = null;
   let cooldownUntilMs: number | null = null;
@@ -217,31 +224,26 @@ export function startRunLedgerOutboxRecovery(
   let unsubscribeNotify: (() => void) | undefined;
   let unsubscribeState: (() => void) | undefined;
   let requestDrain: (reason: string, runId?: string) => void = () => undefined;
-  // A producer hint may reveal a lease that the claim cannot acquire. A
-  // successful scoped claim's continuation does not force a metadata query
-  // while other deliveries keep the drain busy. Zero marks that continuation.
-  const lifecycleRunHints = new Map<string, number>();
-  const observabilityRunHints = new Map<string, number>();
+  const lifecycleRunHints = new Set<string>();
+  const observabilityRunHints = new Set<string>();
   const hasRequests = () =>
     requested ||
     observabilityRequested ||
     lifecycleRunHints.size > 0 ||
     observabilityRunHints.size > 0;
-  const addRunHint = (
-    hints: Map<string, number>,
-    runId: string,
-    discoveryGeneration = producerHintGeneration,
-  ) => {
-    hints.set(runId, Math.max(discoveryGeneration, hints.get(runId) ?? 0));
+  const addRunHint = (hints: Set<string>, runId: string) => {
+    hints.add(runId);
     if (hints.size <= MAX_NOTIFICATION_RUN_HINTS) return true;
+    // The caller turns the dropped runs into a global request, whose empty
+    // claim must still rediscover their clocks.
     hints.clear();
+    dueClockKnownLane = null;
     return false;
   };
-  const takeRunHint = (hints: Map<string, number>) => {
-    const hint = hints.entries().next().value;
-    if (!hint) return undefined;
-    hints.delete(hint[0]);
-    return { runId: hint[0], discoveryGeneration: hint[1] };
+  const takeRunHint = (hints: Set<string>) => {
+    const runId = hints.values().next().value;
+    if (runId !== undefined) hints.delete(runId);
+    return runId;
   };
   const inFlightStartedAt = new Map<number, number>();
   let nextDispatchId = 0;
@@ -326,11 +328,10 @@ export function startRunLedgerOutboxRecovery(
 
   requestDrain = (reason: string, runId?: string) => {
     if (closed) return;
-    // Tag producer hints so a later missed claim can reject an older empty
-    // snapshot. Productive hints need no metadata refresh while work is busy.
-    producerHintGeneration += 1;
-    dueClockKnownLane = null;
+    // A named run cannot change another run's clock. Its scoped claim reads
+    // that run's clock if it comes back empty.
     if (runId === undefined) {
+      dueClockKnownLane = null;
       requested = true;
       observabilityRequested = !!deps.dispatchObservabilityOnce;
       lifecycleRunHints.clear();
@@ -430,7 +431,6 @@ export function startRunLedgerOutboxRecovery(
   const readNextDueClock = async (
     generation: number,
     lane: Exclude<ReturnType<typeof dueClockLane>, null>,
-    hintGeneration: number,
   ): Promise<void> => {
     let dueAt: Date | null;
     try {
@@ -467,8 +467,40 @@ export function startRunLedgerOutboxRecovery(
     }
     failureCount = 0;
     dueClockKnownLane = lane;
-    dueClockKnownHintGeneration = hintGeneration;
-    scheduleDueWake(dueAt);
+    const runDueMs = runDueDuringGlobalReadMs;
+    scheduleDueWake(
+      runDueMs !== null && (dueAt === null || runDueMs < dueAt.getTime())
+        ? new Date(runDueMs)
+        : dueAt,
+    );
+  };
+
+  const readRunDueClock = async (
+    lane: 'lifecycle' | 'observability',
+    runId: string,
+  ): Promise<void> => {
+    if (closed || cooldownUntilMs !== null) return;
+    let dueAt: Date | null;
+    try {
+      dueAt = await deps.readNextDueAt(lane, runId);
+    } catch (error) {
+      if (closed || cooldownUntilMs !== null) return;
+      // The global read covers this run; its own failure owns the cooldown.
+      logger.warn('[run-ledger-outbox.recovery_retry]', {
+        stage: 'run_due',
+        error: error instanceof Error ? error.message : String(error),
+      });
+      dueClockKnownLane = null;
+      if (!drainPromise) void scheduleNextDue();
+      return;
+    }
+    if (closed || cooldownUntilMs !== null || !dueAt) return;
+    if (dueClockRead)
+      runDueDuringGlobalReadMs = Math.min(
+        runDueDuringGlobalReadMs ?? Infinity,
+        dueAt.getTime(),
+      );
+    scheduleDueWake(dueAt, true);
   };
 
   const scheduleNextDue = (refresh = false): Promise<void> => {
@@ -484,18 +516,16 @@ export function startRunLedgerOutboxRecovery(
     if (lane === null || (dueClockKnownLane === lane && !refresh))
       return Promise.resolve();
     dueClockReadGeneration = dueClockGeneration;
-    dueClockReadHintGeneration = producerHintGeneration;
-    dueClockRead = readNextDueClock(
-      dueClockReadGeneration,
-      lane,
-      dueClockReadHintGeneration,
-    ).finally(() => {
-      dueClockRead = null;
-      if (dueClockRefreshRequested) {
-        dueClockRefreshRequested = false;
-        if (!closed && cooldownUntilMs === null) void scheduleNextDue(true);
-      }
-    });
+    runDueDuringGlobalReadMs = null;
+    dueClockRead = readNextDueClock(dueClockReadGeneration, lane).finally(
+      () => {
+        dueClockRead = null;
+        if (dueClockRefreshRequested) {
+          dueClockRefreshRequested = false;
+          if (!closed && cooldownUntilMs === null) void scheduleNextDue(true);
+        }
+      },
+    );
     return dueClockRead;
   };
 
@@ -504,7 +534,6 @@ export function startRunLedgerOutboxRecovery(
       id: symbol;
       observability: boolean;
       runId?: string;
-      discoveryGeneration: number;
       result:
         | PromiseSettledResult<PostgresSchedulerOutboxProjectionResult>
         | { status: 'skipped' };
@@ -539,11 +568,7 @@ export function startRunLedgerOutboxRecovery(
       completed = attempted = projected = retrying = blocked = 0;
     };
 
-    const launch = (
-      observability = false,
-      runId?: string,
-      discoveryGeneration = producerHintGeneration,
-    ) => {
+    const launch = (observability = false, runId?: string) => {
       const id = Symbol();
       pending.add(id);
       if (observability) pendingObservability.add(id);
@@ -552,13 +577,7 @@ export function startRunLedgerOutboxRecovery(
           dispatchFailed = true;
           scheduleFailureRetry('dispatch', result.reason);
         }
-        deliveries.push({
-          id,
-          observability,
-          runId,
-          discoveryGeneration,
-          result,
-        });
+        deliveries.push({ id, observability, runId, result });
         wakeActiveDrain?.();
       };
       // Subscribe once per delivery. Repeated Promise.race calls would retain
@@ -600,16 +619,16 @@ export function startRunLedgerOutboxRecovery(
         // still delivering. Keep it pending when full so an empty result
         // cannot consume a notification that arrived after its query began.
         if (canProbeObservability()) {
-          const hint = observabilityRequested
+          const runId = observabilityRequested
             ? undefined
             : takeRunHint(observabilityRunHints);
           observabilityRequested = false;
-          launch(true, hint?.runId, hint?.discoveryGeneration);
+          launch(true, runId);
         }
         if (canProbeLifecycle()) {
-          const hint = requested ? undefined : takeRunHint(lifecycleRunHints);
+          const runId = requested ? undefined : takeRunHint(lifecycleRunHints);
           requested = false;
-          launch(false, hint?.runId, hint?.discoveryGeneration);
+          launch(false, runId);
         }
         // Productive completion permits immediate use of every free slot.
         // Empty results grant no refill, so idle work cannot spin on scans.
@@ -659,22 +678,22 @@ export function startRunLedgerOutboxRecovery(
         continue;
       }
       const result = delivery.result.value;
-      const hintLane = delivery.observability ? 'observability' : 'lifecycle';
-      const missedProducerHint =
-        delivery.discoveryGeneration > 0 &&
-        result.attempted === 0 &&
-        (dueClockKnownHintGeneration < delivery.discoveryGeneration ||
-          (dueClockKnownLane !== 'both' && dueClockKnownLane !== hintLane));
-      if (result.attempted > 0 || missedProducerHint) dueClockKnownLane = null;
-      // A claim returning empty may have lost to an inline owner. If its
-      // notification followed the pending metadata snapshot, retain discovery
-      // debt so that snapshot cannot cache an obsolete empty result.
+      // An empty scoped claim lost to another owner's lease, a delayed retry
+      // or a quarantined head of that run alone. Its clock is a run-scoped
+      // index read. The global read re-proves every pending run, so running
+      // it here once per outbox insert kept the database CPU-bound.
+      if (delivery.runId !== undefined && result.attempted === 0) {
+        const read = readRunDueClock(
+          delivery.observability ? 'observability' : 'lifecycle',
+          delivery.runId,
+        ).finally(() => runDueReads.delete(read));
+        runDueReads.add(read);
+      }
       if (
-        missedProducerHint &&
-        dueClockRead &&
-        dueClockReadHintGeneration < delivery.discoveryGeneration
+        result.retrying > 0 ||
+        (delivery.runId === undefined && result.attempted > 0)
       )
-        dueClockRefreshRequested = true;
+        dueClockKnownLane = null;
       if (result.retrying > 0) dueClockGeneration += 1;
       completed += 1;
       attempted += result.attempted;
@@ -684,16 +703,12 @@ export function startRunLedgerOutboxRecovery(
       if (completed >= parallelism) reportDeliveries();
       // Discovery cannot wait for every independent HTTP delivery to finish.
       // A retry commits a new clock; an empty global probe can expose that
-      // clock while another slot remains busy. A missed producer hint may
-      // expose an inline owner's lease; one later snapshot covers all earlier
-      // hints. Scoped success keeps its cheap continuation, and the idle drain
-      // still refreshes metadata after those continuations settle.
+      // clock while another slot remains busy.
       if (
         !closed &&
         !dispatchFailed &&
         pending.size > deliveries.length &&
         (result.retrying > 0 ||
-          missedProducerHint ||
           ((timer === null || dueClockKnownLane !== dueClockLane()) &&
             delivery.runId === undefined &&
             result.attempted === 0))
@@ -708,12 +723,12 @@ export function startRunLedgerOutboxRecovery(
           if (delivery.observability) {
             if (
               !observabilityRequested &&
-              !addRunHint(observabilityRunHints, delivery.runId, 0)
+              !addRunHint(observabilityRunHints, delivery.runId)
             )
               observabilityRequested = true;
           } else if (
             !requested &&
-            !addRunHint(lifecycleRunHints, delivery.runId, 0)
+            !addRunHint(lifecycleRunHints, delivery.runId)
           )
             requested = true;
         }
@@ -756,6 +771,7 @@ export function startRunLedgerOutboxRecovery(
       unsubscribeState?.();
       await drainPromise;
       await dueClockRead;
+      await Promise.all(runDueReads);
       hubLease?.release();
     },
   };
@@ -1056,11 +1072,12 @@ export function startRunLedgerOutboxRecoveryController(input: {
     notifyUnavailableSafetyWakeMs: runLedgerOutboxNotifySafetyWakeMs(
       schedulerOptions.schema,
     ),
-    readNextDueAt: (lane) =>
+    readNextDueAt: (lane, runId) =>
       withRuntimeSchedulerClient(input.poolOptions, (client) =>
         readPostgresSchedulerOutboxNextDueAt(client, {
           ...schedulerOptions,
           lane,
+          runId,
         }),
       ),
   });

package/dist/bundling-sources/shared_libs/product-notifications/catalog.ts

@@ -773,7 +773,7 @@ const PRODUCT_NOTIFICATION_TYPE_REGISTRY = [
         },
       }),
       present: ({ payload }) => ({
-        title: `${payload.isFirstPurchase === true ? '🎉 First credit purchase' : 'Credit purchase'}: $${(Number(payload.amountPaidCents) / 100).toFixed(2)}`,
+        title: `${payload.isFirstPurchase === true ? '🎉 First credit purchase' : 'Credit purchase'}${payload.isAutoTopup === true ? ' (Auto top-up)' : ''}: $${(Number(payload.amountPaidCents) / 100).toFixed(2)}`,
         summary: [
           { workspace: true },
           ` purchased ${formatCredits(Number(payload.credits))} credits.`,

package/dist/bundling-sources/shared_libs/product-notifications/events.ts

@@ -213,6 +213,7 @@ export const PRODUCT_NOTIFICATION_EVENT_DEFINITIONS: readonly ProductNotificatio
         amountPaidCents: 'number',
         currency: 'string',
         isFirstPurchase: 'boolean',
+        isAutoTopup: 'boolean',
       },
       orderingSubjectFact: 'accountId',
       allowedTriggers: ['threshold_crossing'],

package/dist/cli/{auth-W3XF4IVK.mjs → auth-4X5IPPQY.mjs}

@@ -10,12 +10,12 @@ import {
   registerAuthCommands,
   reportSetupCompleted,
   resolvePendingAuthClaimForResume
-} from "./chunk-BTUYN2YZ.mjs";
-import "./chunk-TSMUWVJW.mjs";
-import "./chunk-VR5AT72F.mjs";
+} from "./chunk-CLXZXGJD.mjs";
+import "./chunk-NWHXW4M4.mjs";
+import "./chunk-6453ELCN.mjs";
 import "./chunk-DLIRSHV6.mjs";
 import "./chunk-NXGCO4JB.mjs";
-import "./chunk-2UQLI6U7.mjs";
+import "./chunk-TVMGRV4A.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";
 export {

package/dist/cli/auth-IIY7PILQ.js

@@ -0,0 +1,33 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+var _chunkKNQ3PNZ7js = require('./chunk-KNQ3PNZ7.js');
+require('./chunk-VTKCTJWG.js');
+require('./chunk-VID352NP.js');
+require('./chunk-XNYIZMNQ.js');
+require('./chunk-7P5AA3SN.js');
+require('./chunk-BTPEPEJR.js');
+require('./chunk-OG64RBAC.js');
+require('./chunk-COGTRVWW.js');
+
+
+
+
+
+
+
+
+
+
+
+
+exports.EXIT_WORKSPACE_MISMATCH = _chunkKNQ3PNZ7js.EXIT_WORKSPACE_MISMATCH; exports.authStatusLine = _chunkKNQ3PNZ7js.authStatusLine; exports.clearPendingClaim = _chunkKNQ3PNZ7js.clearPendingClaim; exports.clearSatisfiedPendingClaim = _chunkKNQ3PNZ7js.clearSatisfiedPendingClaim; exports.handleRegister = _chunkKNQ3PNZ7js.handleRegister; exports.handleStatus = _chunkKNQ3PNZ7js.handleStatus; exports.handleWait = _chunkKNQ3PNZ7js.handleWait; exports.readPendingAuthClaim = _chunkKNQ3PNZ7js.readPendingAuthClaim; exports.registerAuthCommands = _chunkKNQ3PNZ7js.registerAuthCommands; exports.reportSetupCompleted = _chunkKNQ3PNZ7js.reportSetupCompleted; exports.resolvePendingAuthClaimForResume = _chunkKNQ3PNZ7js.resolvePendingAuthClaimForResume;