deepline 0.3.468 → 0.3.470

package/dist/bundling-sources/sdk/src/release.ts

@@ -205,7 +205,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.468',
+  version: '0.3.470',
   updateSummary: {
     introducedIn: '0.3.90',
     summary:

package/dist/bundling-sources/shared_libs/monitors/http-error-response.ts

@@ -1,7 +1,5 @@
 import { NextResponse } from 'next/server';
 
-import { MAX_PRIORITY_MONITORS_PER_ORG } from '@deepline/monitors/provider-monitor-priority-execution';
-
 export const MONITOR_ERROR_FALLBACK_NEXT_ACTION =
   "Do not retry blindly. Read the deepline-monitors skill's 'Recover from errors by code' section, inspect the returned message and relevant state, then diagnose this failure.";
 
@@ -191,9 +189,6 @@ export function monitorErrorNextAction(payload: MonitorErrorPayload): string {
   if (code === 'monitor_entitlement_limit_exceeded') {
     return 'Run `deepline monitors list --status all`; reuse or disable an existing monitor, or ask the user to change entitlement before retrying.';
   }
-  if (code === 'priority_monitor_limit_exceeded') {
-    return `This workspace already has ${MAX_PRIORITY_MONITORS_PER_ORG} priority radars. Delete or update an existing priority radar only after confirming it is no longer needed, then retry the urgent preview.`;
-  }
   if (code === 'monitor_already_exists') {
     const existingMonitor = asRecord(nestedError(payload)?.existing_monitor);
     const existing = existingMonitor?.key;

package/dist/bundling-sources/shared_libs/monitors/provider-monitor-errors.ts

@@ -130,12 +130,3 @@ export class ProviderMonitorStoppedAfterSubmitError extends Error {
     this.name = 'ProviderMonitorStoppedAfterSubmitError';
   }
 }
-
-export class PriorityMonitorExecutionLimitError extends Error {
-  constructor(readonly max: number) {
-    super(
-      `This workspace already has ${max} priority radars. Remove priority from a radar that is no longer urgent before creating another one.`,
-    );
-    this.name = 'PriorityMonitorExecutionLimitError';
-  }
-}

package/dist/bundling-sources/shared_libs/monitors/provider-monitor-identity-claims.ts

@@ -1,6 +1,5 @@
 import { randomUUID } from 'node:crypto';
 import {
-  PriorityMonitorExecutionLimitError,
   ProviderMonitorCapacityBackfillInProgressError,
   ProviderMonitorCapacityCleanupRequiredError,
   ProviderMonitorIdentityBackfillInProgressError,
@@ -8,7 +7,6 @@ import {
   ProviderMonitorOrgLimitExceededError,
   type ProviderMonitorCapacitySnapshot,
 } from '@deepline/monitors/provider-monitor-errors';
-import { MAX_PRIORITY_MONITORS_PER_ORG } from '@deepline/monitors/provider-monitor-priority-execution';
 import { internal } from '@deepline/convex-client/function-references';
 import { getRequiredInternalConvexClient } from '@deepline/convex-client/internal-client';
 import { providerMonitorConflictIdentity } from '@deepline/monitors/provider-monitor-conflicts';
@@ -235,20 +233,6 @@ export function providerMonitorIdentityProvisioningForMonitor(input: {
   );
 }
 
-export function priorityMonitorExecutionLimitFromLifecycleError(
-  error: unknown,
-) {
-  if (
-    error instanceof Error &&
-    error.message.includes('PRIORITY_MONITOR_LIMIT_EXCEEDED')
-  ) {
-    return new PriorityMonitorExecutionLimitError(
-      MAX_PRIORITY_MONITORS_PER_ORG,
-    );
-  }
-  return null;
-}
-
 // Convex retries mutations itself. This is the bounded outer retry for the
 // rare case in which that budget is exhausted while the short capacity-fold
 // mutation is updating the same organization fence. Lifecycle admission is
@@ -335,23 +319,10 @@ export async function beginProviderMonitorLifecycleReservation(input: {
         ? { requiredMonitorStatus: input.requiredMonitorStatus }
         : {}),
     });
-  // A priority-slot refusal arrives as a thrown lifecycle error, while the
-  // capacity outcomes below arrive as a returned kind. Both paths have to work
-  // on the same call, and the backfill retry has to re-run the same request.
-  const attempt = async () => {
-    try {
-      return await request();
-    } catch (error) {
-      const priorityLimit =
-        priorityMonitorExecutionLimitFromLifecycleError(error);
-      if (priorityLimit) throw priorityLimit;
-      throw error;
-    }
-  };
-  let result = await retryProviderMonitorLifecycleAdmission(attempt);
+  let result = await retryProviderMonitorLifecycleAdmission(request);
   if (result.kind === 'backfill_required') {
     await ensureProviderMonitorCapacityBackfill({ auth: input.auth });
-    result = await retryProviderMonitorLifecycleAdmission(attempt);
+    result = await retryProviderMonitorLifecycleAdmission(request);
   }
   if (result.kind === 'limit_exceeded') {
     throw new ProviderMonitorOrgLimitExceededError(result.capacity);

package/dist/bundling-sources/shared_libs/monitors/provider-monitor-priority-execution.ts

@@ -1,26 +1,6 @@
 import type { ProviderMonitorCapabilityDefinition } from '@deepline/monitors/provider-monitor-capability';
-import type { ProviderMonitorStatus } from './provider-monitor-status';
 
 export const PRIORITY_MONITOR_EXECUTION_TYPE = 'priority' as const;
-export const MAX_PRIORITY_MONITORS_PER_ORG = 10;
-
-export const PRIORITY_MONITOR_SLOT_STATUSES = [
-  'active',
-  // A billing suspension writes disabled before upstream deprovisioning. Keep
-  // the slot occupied until that delete confirms success and clears the
-  // projection; a failed cleanup can leave the priority radar live.
-  'disabled',
-  'deleting',
-  'error',
-  'deleted',
-  // A fleet monitor holds its priority reservation from the commit that
-  // records the desired state, not from the provider create that follows it.
-  'pending_create',
-] as const satisfies readonly ProviderMonitorStatus[];
-
-const PRIORITY_MONITOR_SLOT_STATUS_SET = new Set<ProviderMonitorStatus>(
-  PRIORITY_MONITOR_SLOT_STATUSES,
-);
 
 export function requestedPriorityMonitorExecution(definition: {
   controls?: Record<string, unknown>;
@@ -35,22 +15,3 @@ export function priorityMonitorExecutionIsSupported(
 ) {
   return capability.provider === 'deepline_native';
 }
-
-export function priorityMonitorConsumesSlot(input: {
-  priorityExecution: boolean;
-  status: ProviderMonitorStatus;
-}) {
-  return (
-    input.priorityExecution &&
-    PRIORITY_MONITOR_SLOT_STATUS_SET.has(input.status)
-  );
-}
-
-export function priorityMonitorReservedSlotCount(input: {
-  priorityExecution: boolean;
-  status: ProviderMonitorStatus;
-  priorityExecutionSlots?: number;
-}) {
-  if (!priorityMonitorConsumesSlot(input)) return 0;
-  return input.priorityExecutionSlots === 2 ? 2 : 1;
-}

package/dist/bundling-sources/shared_libs/play-runtime/play-runs/admission/postgres-adapter.ts

@@ -21,6 +21,8 @@ import { emitPlayRunLaunchConflictTelemetry } from '../../runtime-telemetry';
 export function createPostgresPlayRunAdmissionPorts(input: {
   client: PostgresSchedulerQueryClient;
   schema?: string;
+  /** The admitting app will immediately attempt its leased local projection. */
+  reserveCreatedProjection?: boolean;
 }): PlayRunAdmissionPorts {
   const options = input.schema ? { schema: input.schema } : undefined;
   return {
@@ -35,6 +37,7 @@ export function createPostgresPlayRunAdmissionPorts(input: {
             options,
             admission.queueName,
             admission.recoverExistingTask === true,
+            { reserveCreatedProjection: input.reserveCreatedProjection },
           );
         } catch (error) {
           if (isLaunchConflict(error)) {

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

@@ -453,6 +453,9 @@ export function createAbsurdSchedulerBackend(
                   createPostgresPlayRunAdmissionPorts({
                     client,
                     schema: normalizedSchedulerOptions.schema,
+                    reserveCreatedProjection: Boolean(
+                      process.env.VERCEL?.trim(),
+                    ),
                   }),
                 ).admit({
                   launch: input,

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

@@ -5007,6 +5007,7 @@ export async function submitPostgresAbsurdPlayRun(
   options: Pick<PostgresSchedulerOptions, 'schema'> | undefined,
   queueName: string,
   recoverExistingTask = false,
+  projection?: { reserveCreatedProjection?: boolean },
 ): Promise<{
   taskId: string | null;
   runCreated: boolean;
@@ -5030,6 +5031,7 @@ export async function submitPostgresAbsurdPlayRun(
       queueName,
       ...task,
       recoverExistingTask,
+      reserveCreatedProjection: projection?.reserveCreatedProjection === true,
     },
   );
   const taskId = submitted.absurdTaskId;
@@ -5125,6 +5127,7 @@ async function submitPostgresSchedulerRunTransaction(
     params: unknown;
     options: unknown;
     recoverExistingTask?: boolean;
+    reserveCreatedProjection?: boolean;
   },
   /**
    * Set only on the single re-admission after the current build proved the
@@ -5138,6 +5141,11 @@ async function submitPostgresSchedulerRunTransaction(
   taskRecoveryRequired: boolean;
 }> {
   const requestedInput = input;
+  const createdProjectionLease =
+    absurdTask?.reserveCreatedProjection === true &&
+    input.requiresRunCreatedProjection === true
+      ? postgresSchedulerInlineCreatedProjectionLease(input.runId)
+      : null;
   // Persist the ABI with every new launch. Null is reserved for genuinely
   // historic rows already in storage, where readers interpret it as legacy.
   input = {
@@ -5445,7 +5453,8 @@ async function submitPostgresSchedulerRunTransaction(
         -- durable run, its task, and the launch envelope together. Persist the
         -- causal run.created fact here; projection is deliberately async.
         INSERT INTO ${tableName('outbox', options)} (
-          event_id, run_id, event_type, payload_json, created_at
+          event_id, run_id, event_type, payload_json, created_at,
+          lease_owner, lease_expires_at
         )
         SELECT
           'run-created:' || run_insert.run_id,
@@ -5498,7 +5507,9 @@ async function submitPostgresSchedulerRunTransaction(
           )) || CASE WHEN launch_payload.launch_json ? 'retainedPipelineGraph'
             THEN jsonb_build_object('retainedPipelineGraph', launch_payload.launch_json -> 'retainedPipelineGraph')
             ELSE '{}'::jsonb END,
-          ${causalOutboxCreatedAt('run_insert.run_id', options)}
+          ${causalOutboxCreatedAt('run_insert.run_id', options)},
+          ${createdProjectionLease ? escapeLiteral(createdProjectionLease.leaseOwner) : 'NULL::text'},
+          ${createdProjectionLease ? `now() + interval '${createdProjectionLease.leaseSeconds} seconds'` : 'NULL::timestamptz'}
         FROM run_insert
         CROSS JOIN launch_payload
         -- Old Vercel launchers do not carry the immutable admission envelope.
@@ -22182,6 +22193,29 @@ export function postgresSchedulerCancellationOutboxLease(runId: string): {
   };
 }
 
+/**
+ * The admitting app can project its own run.created without an HTTP round trip.
+ * Reserve that first delivery in the admission commit, before NOTIFY lets the
+ * remote projector race it. An app lost before delivery leaves at most this
+ * short lease; ordinary inline claims retain their existing deadline/release.
+ * This is delivery ownership only, never execution admission or authority.
+ */
+export function postgresSchedulerInlineCreatedProjectionLease(runId: string): {
+  leaseOwner: string;
+  leaseSeconds: number;
+} {
+  const normalizedRunId = runId.trim();
+  if (!normalizedRunId) {
+    throw new Error('Inline created projection requires a run id.');
+  }
+  return {
+    leaseOwner: `run-created-inline:${createHash('sha256')
+      .update(normalizedRunId)
+      .digest('hex')}`,
+    leaseSeconds: 2,
+  };
+}
+
 export type RunLedgerOutboxDispatchInput = {
   /** App-owned transport; launch authority and routing still come from the lease. */
   appRuntimeFetch?: typeof fetch;
@@ -22842,14 +22876,12 @@ async function dispatchRunLedgerOutboxBatchWithScope(
       // The caller's deadline elapsed while this checkout was queued. Its
       // attempt is already abandoned, so taking a lease now could only keep
       // the durable projector off the row until that lease expires. Claim
-      // nothing: the row stays pending and unleased for its next owner.
-      if (claimInvocations > 1 && abandonedHeadEventId) {
-        // An earlier invocation's COMMIT may have reached the server before
-        // its connection failed, so this owner can already hold the named
-        // head. Hand it back here, fenced to this owner; returning empty
-        // would leave that lease with nobody to release it. After a rolled
-        // back invocation it matches no row. A failure propagates, so the
-        // attempt is never reported as settled.
+      // nothing, and hand back any initial reservation of the named head.
+      if (abandonedHeadEventId) {
+        // Admission may already have reserved this head, even on the first
+        // checkout. A retried checkout can also follow an ambiguous COMMIT.
+        // Release only this owner's lease; an absent or replaced owner is a
+        // no-op. Failure propagates so the attempt cannot report settlement.
         await releasePostgresSchedulerOutboxLease(
           client,
           [abandonedHeadEventId],

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

@@ -14,6 +14,7 @@ import {
   postgresSchedulerNotifyChannel,
   readPostgresSchedulerOutboxAdmissionHints,
   readPostgresSchedulerOutboxNextDueAt,
+  postgresSchedulerInlineCreatedProjectionLease,
   type PostgresSchedulerOptions,
   type PostgresSchedulerOutboxProjectionResult,
   type RunLedgerOutboxDeliveredRow,
@@ -76,6 +77,12 @@ export const RUN_LEDGER_OUTBOX_RECOVERY_MAX_IN_FLIGHT = 32;
 // The higher exported ceiling remains available to isolated recovery callers,
 // but it is not the steady-state production setting.
 const RUN_LEDGER_OUTBOX_RECOVERY_PRODUCTION_IN_FLIGHT = 8;
+// This is a total budget shared by lifecycle and indexing lanes. Preview's
+// former 32 slots left 24 for lifecycle delivery and queued 25 short SQL
+// operations behind a two-connection pool. Sixteen total slots retain eight
+// lifecycle and eight indexing deliveries, matching both Production replicas
+// combined. Isolated callers retain the larger hard ceiling above.
+const RUN_LEDGER_OUTBOX_RECOVERY_PREVIEW_IN_FLIGHT = 16;
 // Production runs two projector replicas, so four index deliveries per
 // replica provide eight shared slots. Preview has one projector replica; give
 // it the same total bounded search-index capacity.
@@ -131,17 +138,17 @@ export type RunLedgerOutboxRecoveryDeps = {
 };
 
 /**
- * Production runs two projector replicas at eight deliveries each. An
- * isolated Preview estate has one replica, so use the existing bounded
- * 32-delivery ceiling there to keep fixture admission and its catalog
- * projection inside the same latency budget. This does not change Production
- * capacity or the controller's hard maximum.
+ * Production runs two projector replicas at eight total deliveries each:
+ * four lifecycle and four indexing slots. One Preview replica uses sixteen
+ * total slots, retaining eight per lane. Extra in-flight network deliveries
+ * also fan out claim, renewal and acknowledgement checkouts. Production
+ * capacity and the controller's hard maximum remain unchanged.
  */
 export function runLedgerOutboxRecoveryParallelism(
   environment: 'preview' | 'production',
 ): number {
   return environment === 'preview'
-    ? RUN_LEDGER_OUTBOX_RECOVERY_MAX_IN_FLIGHT
+    ? RUN_LEDGER_OUTBOX_RECOVERY_PREVIEW_IN_FLIGHT
     : RUN_LEDGER_OUTBOX_RECOVERY_PRODUCTION_IN_FLIGHT;
 }
 
@@ -1054,6 +1061,8 @@ export async function deliverRunCreatedOutboxEventInline(input: {
     {
       runId,
       headEventId: `run-created:${runId}`,
+      leaseOwner:
+        postgresSchedulerInlineCreatedProjectionLease(runId).leaseOwner,
       limit: 1,
       leaseSeconds: RUN_CREATED_INLINE_DELIVERY_LEASE_SECONDS,
       tokenAuthority: input.tokenAuthority,
@@ -1233,8 +1242,8 @@ export function startRunLedgerOutboxRecoveryController(input: {
     observabilityParallelism,
     // `dispatchRunLedgerOutboxToLedgerBatchOnceWithClientScope` releases each
     // short scheduler checkout before it calls the Vercel gateway. Production
-    // retains two replicas at eight lifecycle and four search slots each; one
-    // Preview replica uses 32 lifecycle and eight search slots.
+    // retains two replicas at four lifecycle and four search slots each; one
+    // Preview replica uses eight lifecycle and eight search slots.
     parallelism: runLedgerOutboxRecoveryParallelism(environment),
     notifyUnavailableSafetyWakeMs: runLedgerOutboxNotifySafetyWakeMs(
       schedulerOptions.schema,

package/dist/cli/auth-4DBOZZDX.js

@@ -0,0 +1,41 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkA7THVTRNjs = require('./chunk-A7THVTRN.js');
+require('./chunk-57F5VKHV.js');
+require('./chunk-CNQBCLQP.js');
+require('./chunk-AGIEKE3L.js');
+require('./chunk-ALJJRZNJ.js');
+require('./chunk-XNYIZMNQ.js');
+require('./chunk-DIAWYWT5.js');
+require('./chunk-NSAKJQLX.js');
+require('./chunk-OG64RBAC.js');
+require('./chunk-COGTRVWW.js');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.EXIT_WORKSPACE_MISMATCH = _chunkA7THVTRNjs.EXIT_WORKSPACE_MISMATCH; exports.authStatusLine = _chunkA7THVTRNjs.authStatusLine; exports.clearPendingClaim = _chunkA7THVTRNjs.clearPendingClaim; exports.clearSatisfiedPendingClaim = _chunkA7THVTRNjs.clearSatisfiedPendingClaim; exports.handleRegister = _chunkA7THVTRNjs.handleRegister; exports.handleStatus = _chunkA7THVTRNjs.handleStatus; exports.handleWait = _chunkA7THVTRNjs.handleWait; exports.httpJson = _chunkA7THVTRNjs.httpJson; exports.readPendingAuthClaim = _chunkA7THVTRNjs.readPendingAuthClaim; exports.readStatusBanner = _chunkA7THVTRNjs.readStatusBanner; exports.registerAuthCommands = _chunkA7THVTRNjs.registerAuthCommands; exports.reportSetupCompleted = _chunkA7THVTRNjs.reportSetupCompleted; exports.resolvePendingAuthClaimForResume = _chunkA7THVTRNjs.resolvePendingAuthClaimForResume; exports.statusBannerLine = _chunkA7THVTRNjs.statusBannerLine;

package/dist/cli/{auth-CXQRTOBC.mjs → auth-7J52UEWO.mjs}

@@ -13,14 +13,14 @@ import {
   reportSetupCompleted,
   resolvePendingAuthClaimForResume,
   statusBannerLine
-} from "./chunk-X4U763KU.mjs";
-import "./chunk-NOQRM7LV.mjs";
-import "./chunk-TVDBGEVP.mjs";
-import "./chunk-CHD7NMZD.mjs";
+} from "./chunk-BWLXHUKH.mjs";
+import "./chunk-QG7UPPOK.mjs";
+import "./chunk-VL7OL7YR.mjs";
+import "./chunk-SETIOXN4.mjs";
 import "./chunk-4QF2K7TM.mjs";
 import "./chunk-DLIRSHV6.mjs";
 import "./chunk-HBL4PM5Q.mjs";
-import "./chunk-CXYMJSRQ.mjs";
+import "./chunk-DSOTGAXS.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";
 export {