deepline 0.3.474 → 0.3.476

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

@@ -12736,9 +12736,17 @@ export async function claimPostgresSchedulerSandboxCleanupJobs(
   if (providers?.length === 0) return [];
   // The v12 table retains deleted history. Avoid planning the lineage repair
   // when neither a legacy row nor a v2 NULL-domain duplicate needs adoption.
-  // A row arriving after this read is picked up by the next claim poll; the
-  // provider-qualified v2 claim below still runs on every call.
-  const adoptionWork = await client.query<{ pending: boolean }>(`
+  // The same read proves whether any v2 row could be claimed: the claim below
+  // is ~15 KB of SQL whose planning costs milliseconds while every idle
+  // worker polls it each second, so it is skipped when nothing is claimable.
+  // `claimable` repeats the claim's own row predicates without the detached
+  // sandbox fence, so it is a superset of what the claim could select. A row
+  // arriving after this read is picked up by the next claim poll.
+  const adoptionWork = await client.query<{
+    pending: boolean;
+    claimable: boolean;
+  }>(
+    `
     SELECT EXISTS (
       SELECT 1 FROM ${tableName('sandbox_cleanup_jobs_v2', options)}
       WHERE provider = 'daytona' AND routing_domain IS NULL
@@ -12746,9 +12754,29 @@ export async function claimPostgresSchedulerSandboxCleanupJobs(
     ) OR EXISTS (
       SELECT 1 FROM ${tableName('sandbox_cleanup_jobs', options)}
       WHERE status <> 'deleted'
-    ) AS pending
-  `);
-  if (typeof adoptionWork.rows[0]?.pending !== 'boolean') {
+    ) AS pending,
+    EXISTS (
+      SELECT 1 FROM ${tableName('sandbox_cleanup_jobs_v2', options)} AS cleanup
+      WHERE cleanup.status <> 'deleted' AND cleanup.blocked_at IS NULL
+        AND (cleanup.available_at <= now() OR cleanup.diagnostic_json IS NOT NULL)
+        AND (cleanup.lease_expires_at IS NULL OR cleanup.lease_expires_at <= now())
+        AND ($1::text IS NULL OR cleanup.environment = $1)
+        AND ($2::text[] IS NULL OR cleanup.provider = ANY($2::text[]))
+        AND ($3::text IS NULL OR cleanup.run_id = $3)
+        AND ($4::integer IS NULL OR cleanup.attempt <= $4)
+    ) AS claimable
+  `,
+    [
+      input.environment?.trim() || null,
+      providers,
+      input.runId ?? null,
+      input.throughAttempt ?? null,
+    ],
+  );
+  if (
+    typeof adoptionWork.rows[0]?.pending !== 'boolean' ||
+    typeof adoptionWork.rows[0]?.claimable !== 'boolean'
+  ) {
     throw new Error(
       'Sandbox cleanup adoption preflight returned no pending proof.',
     );
@@ -12944,6 +12972,10 @@ export async function claimPostgresSchedulerSandboxCleanupJobs(
       ON CONFLICT (provider, sandbox_id, routing_domain_key) DO NOTHING
     `,
     );
+  // Adoption may have just created claimable v2 rows, so only an idle read
+  // that proved neither kind of work skips the claim.
+  if (!adoptionWork.rows[0].pending && !adoptionWork.rows[0].claimable)
+    return [];
   const claimed = await client.query<{
     provider: 'daytona' | 'modal';
     sandbox_id: string;
@@ -16389,7 +16421,6 @@ export async function executePostgresSchedulerClaim(
   execute: PostgresSchedulerAttemptExecutor,
   options: PostgresSchedulerClaimExecutionOptions = {},
 ): Promise<PostgresSchedulerWorkerOnceResult> {
-  let runtimeResources: unknown[] = [];
   let runnerFailureResult: Extract<
     PlayRunnerResult,
     { status: 'failed' }
@@ -16445,11 +16476,6 @@ export async function executePostgresSchedulerClaim(
       },
       options,
     );
-    runtimeResources = await readPostgresSchedulerRuntimeResourcesForRun(
-      client,
-      { runId: claim.runId },
-      options,
-    );
     // A PlayRunnerResult envelope ({status, output, logs, steps, ...}) is the
     // executor's transport shape; the run's terminal result — what the ledger
     // run.completed event and `runs get` expose — is the play's own output.
@@ -16587,31 +16613,9 @@ export async function executePostgresSchedulerClaim(
         `Postgres scheduler worker failed after losing lease for ${claim.runId}/${claim.attempt}: ${message}`,
       );
     }
-    if (runtimeResources.length === 0) {
-      await settlePostgresSchedulerRuntimeResources(
-        client,
-        {
-          runId: claim.runId,
-          billingEndedAt: runnerTerminalReceivedAtMs ?? Date.now(),
-          terminalReason,
-        },
-        options,
-      ).catch((settlementError) => {
-        console.warn('[postgres-scheduler.resource_settlement_failed]', {
-          runId: claim.runId,
-          terminalReason,
-          error:
-            settlementError instanceof Error
-              ? settlementError.message
-              : String(settlementError),
-        });
-      });
-      runtimeResources = await readPostgresSchedulerRuntimeResourcesForRun(
-        client,
-        { runId: claim.runId },
-        options,
-      ).catch(() => []);
-    }
+    // The failure statement already stamps every sandbox and persists its
+    // cleanup/billing obligations. Return to terminal projection without
+    // reacquiring custody locks or reading resources that this caller never uses.
     return {
       status: 'failed',
       runId: claim.runId,
@@ -19477,6 +19481,27 @@ export async function readPostgresSchedulerTerminalArrayInputIntent(
   return readTerminalArrayInputIntentForScope(client, input, options);
 }
 
+/**
+ * Prove delivery before exposing the same run's terminal cleanup intent.
+ * Fold the optional-column probe into that proof, preserving old schemas
+ * without another round trip or copying the wide run tuple to JSON.
+ */
+export async function assertPostgresRunLedgerDeliveryAndReadTerminalArrayInputIntent(
+  client: PostgresSchedulerQueryClient,
+  input: Parameters<typeof assertPostgresRunLedgerDelivery>[1],
+  options?: Pick<PostgresSchedulerOptions, 'schema'>,
+): Promise<{ playName: string | null; started: boolean }> {
+  const markerPresent = await provePostgresRunLedgerDelivery(
+    client,
+    input,
+    options,
+    true,
+  );
+  return markerPresent
+    ? readTerminalArrayInputIntentRow(client, input, options)
+    : { playName: null, started: false };
+}
+
 /** Internal dispatch already owns the run's outbox lease; receiver reads also bind its org. */
 async function readTerminalArrayInputIntentForScope(
   client: PostgresSchedulerQueryClient,
@@ -19499,6 +19524,14 @@ async function readTerminalArrayInputIntentForScope(
   if (column.rows[0]?.present !== true) {
     return { playName: null, started: false };
   }
+  return readTerminalArrayInputIntentRow(client, input, options);
+}
+
+async function readTerminalArrayInputIntentRow(
+  client: PostgresSchedulerQueryClient,
+  input: { orgId?: string; runId: string },
+  options?: Pick<PostgresSchedulerOptions, 'schema'>,
+): Promise<{ playName: string | null; started: boolean }> {
   const run = await client.query<{
     array_input_started: boolean;
     play_name: string;
@@ -19529,6 +19562,15 @@ export async function assertPostgresRunLedgerDelivery(
   },
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
 ): Promise<void> {
+  await provePostgresRunLedgerDelivery(client, input, options);
+}
+
+async function provePostgresRunLedgerDelivery(
+  client: PostgresSchedulerQueryClient,
+  input: Parameters<typeof assertPostgresRunLedgerDelivery>[1],
+  options?: Pick<PostgresSchedulerOptions, 'schema'>,
+  readArrayInputMarker = false,
+): Promise<boolean> {
   const result = await client.query<{
     delivery_key: string;
     event_type: string;
@@ -19539,6 +19581,7 @@ export async function assertPostgresRunLedgerDelivery(
     blocked: boolean;
     payload_json: unknown;
     created_at: Date;
+    array_input_marker_present?: boolean;
   }>(
     `
     SELECT outbox.delivery_key,
@@ -19551,6 +19594,16 @@ export async function assertPostgresRunLedgerDelivery(
            outbox.failed_at IS NOT NULL AS blocked,
            outbox.payload_json,
            outbox.created_at
+           ${
+             readArrayInputMarker
+               ? `, EXISTS (
+                   SELECT 1 FROM pg_attribute
+                   WHERE attrelid = to_regclass($3)
+                     AND attname = 'array_input_started'
+                     AND NOT attisdropped
+                 ) AS array_input_marker_present`
+               : ''
+           }
     FROM ${tableName('outbox', options)} AS outbox
     JOIN ${tableName('runs', options)} AS runs ON runs.run_id = outbox.run_id
     WHERE outbox.run_id = $1 AND runs.org_id = $2
@@ -19562,7 +19615,9 @@ export async function assertPostgresRunLedgerDelivery(
     -- their own delivery without changing the drain's convergence behavior.
     LIMIT ${RUN_LEDGER_PROJECTION_PREFIX_MAX_FACTS}
   `,
-    [input.runId, input.orgId],
+    readArrayInputMarker
+      ? [input.runId, input.orgId, tableName('runs', options)]
+      : [input.runId, input.orgId],
   );
   const rows = result.rows;
   const leaseOwner = input.leaseOwner?.trim() || rows[0]?.lease_owner;
@@ -19656,7 +19711,8 @@ export async function assertPostgresRunLedgerDelivery(
         input.idempotencyKey === batchKey ||
         legacySingletonKey)
     ) {
-      if (input.projectedEvents === undefined) return;
+      if (input.projectedEvents === undefined)
+        return rows[0]?.array_input_marker_present === true;
       const prefixEvents: PlayRunLedgerIngressEvent[] = [];
       for (const prefixRow of prefix) {
         prefixEvents.push(
@@ -19696,7 +19752,8 @@ export async function assertPostgresRunLedgerDelivery(
         expectedEventCandidates: expectedProjectionCandidates,
         ...(input.projectionChunk ? { chunk: input.projectionChunk } : {}),
       });
-      if (projectionMismatch === null) return;
+      if (projectionMismatch === null)
+        return rows[0]?.array_input_marker_present === true;
       throw new RunLedgerProjectionLeaseLostError(
         'projected_events_mismatch',
         projectionMismatch,
@@ -19749,6 +19806,40 @@ function runLedgerOrderSql(alias: string): string {
   return `CASE ${alias}.event_type WHEN ${RUN_EVENT_KIND_SQL_LITERAL.runCreated} THEN 0 WHEN ${RUN_EVENT_KIND_SQL_LITERAL.runStarted} THEN 1 ELSE 2 END, ${alias}.created_at, ${alias}.event_id`;
 }
 
+/**
+ * Whether a lane (or, without `searchOnly`, either lane) holds any
+ * undelivered fact. Global discovery and due-clock statements are kilobytes
+ * of SQL planned on every call, and an idle Preview projector issues them
+ * twice a second. Every such statement starts from these same undelivered
+ * rows, so an empty probe proves it would return nothing. The probe is the
+ * first seek of `runLedgerPendingRunsSql`: an ordered LIMIT keeps the lane's
+ * pending partial index even when statistics expect the other lane's backlog
+ * to match, where EXISTS (which discards ORDER BY and LIMIT) would scan the
+ * retained outbox instead.
+ */
+async function runLedgerOutboxLaneHasPending(
+  client: PostgresSchedulerQueryClient,
+  options: Pick<PostgresSchedulerOptions, 'schema'> | undefined,
+  searchOnly?: boolean,
+): Promise<boolean> {
+  const lane =
+    searchOnly === undefined
+      ? ''
+      : `AND ${searchLaneSql('pending')} = ${String(searchOnly)}`;
+  const result = await client.query<{ pending: boolean }>(
+    `SELECT (
+      SELECT pending.run_id FROM ${tableName('outbox', options)} AS pending
+      WHERE pending.delivered_at IS NULL ${lane}
+      ORDER BY pending.run_id LIMIT 1
+    ) IS NOT NULL AS pending`,
+  );
+  const pending = result.rows[0]?.pending;
+  if (typeof pending !== 'boolean') {
+    throw new Error('Run Ledger outbox pending probe returned no proof.');
+  }
+  return pending;
+}
+
 /** Enumerate pending runs by index seeks, skipping each run's entire fact tail. */
 function runLedgerPendingRunsSql(
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
@@ -21081,6 +21172,16 @@ export async function readPostgresSchedulerOutboxNextDueAt(
         ? [true]
         : [false, true];
   const runId = options?.runId?.trim() || null;
+  // Every due time below belongs to an undelivered fact.
+  if (
+    !runId &&
+    !(await runLedgerOutboxLaneHasPending(
+      client,
+      options,
+      options?.lane === undefined ? undefined : lanes[0],
+    ))
+  )
+    return null;
   const result = await client.query<{ due_at: Date | string | null }>(
     `
       -- Seek distinct run identities without reading their pending fact tails.
@@ -23107,6 +23208,28 @@ async function dispatchRunLedgerOutboxBatchWithScope(
         arrayInputStarted: scope?.nextArrayInputStarted,
       }
     : await withClient(async (client) => {
+        // Global discovery of an empty lane would plan its multi-kilobyte
+        // claim statements only to select nothing.
+        if (
+          !scope &&
+          !input.runId?.trim() &&
+          !input.headEventId?.trim() &&
+          !(await runLedgerOutboxLaneHasPending(
+            client,
+            options,
+            input.searchOnly === true,
+          ))
+        ) {
+          return {
+            events: [] as PostgresSchedulerOutboxEvent[],
+            launchJson: null,
+            ingressPrefixClaimed: false,
+            freshClaimLease: undefined,
+            transportDelivered: undefined,
+            transportOwnershipUnconfirmed: undefined,
+            arrayInputStarted: undefined,
+          };
+        }
         const fast = await claimFastEvents(client);
         let result: Awaited<ReturnType<typeof claimEvents>>;
         if (fast !== null) {

package/dist/bundling-sources/shared_libs/plays/authoring-contract.ts

@@ -2988,7 +2988,7 @@ export const PLAY_AUTHORING_FIELD_REGISTRY = {
     resolution: 'static-required',
     issueCode: 'play_authoring_binding_invalid',
     description:
-      'Deepline-managed sandbox size. Standard is 1 GiB memory. Large (4 GiB) and xlarge (8 GiB) are available only on branch Preview deployments. Production supports standard.',
+      'Deepline-managed sandbox size: standard (1 GiB memory, 1 CPU), large (4 GiB, 2 CPU), or xlarge (8 GiB, 4 CPU). Standard is the default. Compute pricing follows the workspace plan and selected size.',
     errorMessage:
       'runtime.size must be the static literal "standard", "large", or "xlarge".',
   },

package/dist/cli/auth-2ZY57Q7W.js

@@ -0,0 +1,41 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunk6YZYCKWDjs = require('./chunk-6YZYCKWD.js');
+require('./chunk-AS3VECCY.js');
+require('./chunk-7HAUVMRF.js');
+require('./chunk-5AEEINTU.js');
+require('./chunk-ALJJRZNJ.js');
+require('./chunk-XNYIZMNQ.js');
+require('./chunk-DIAWYWT5.js');
+require('./chunk-A6BETJ2A.js');
+require('./chunk-OG64RBAC.js');
+require('./chunk-COGTRVWW.js');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.EXIT_WORKSPACE_MISMATCH = _chunk6YZYCKWDjs.EXIT_WORKSPACE_MISMATCH; exports.authStatusLine = _chunk6YZYCKWDjs.authStatusLine; exports.clearPendingClaim = _chunk6YZYCKWDjs.clearPendingClaim; exports.clearSatisfiedPendingClaim = _chunk6YZYCKWDjs.clearSatisfiedPendingClaim; exports.handleRegister = _chunk6YZYCKWDjs.handleRegister; exports.handleStatus = _chunk6YZYCKWDjs.handleStatus; exports.handleWait = _chunk6YZYCKWDjs.handleWait; exports.httpJson = _chunk6YZYCKWDjs.httpJson; exports.readPendingAuthClaim = _chunk6YZYCKWDjs.readPendingAuthClaim; exports.readStatusBanner = _chunk6YZYCKWDjs.readStatusBanner; exports.registerAuthCommands = _chunk6YZYCKWDjs.registerAuthCommands; exports.reportSetupCompleted = _chunk6YZYCKWDjs.reportSetupCompleted; exports.resolvePendingAuthClaimForResume = _chunk6YZYCKWDjs.resolvePendingAuthClaimForResume; exports.statusBannerLine = _chunk6YZYCKWDjs.statusBannerLine;

package/dist/cli/{auth-QMANU5PV.mjs → auth-A22724UX.mjs}

@@ -13,14 +13,14 @@ import {
   reportSetupCompleted,
   resolvePendingAuthClaimForResume,
   statusBannerLine
-} from "./chunk-JEYX3345.mjs";
-import "./chunk-KKWQ24VM.mjs";
-import "./chunk-YK64UZXN.mjs";
-import "./chunk-Z27NSLPC.mjs";
+} from "./chunk-CFSCHLNQ.mjs";
+import "./chunk-NTJDZURV.mjs";
+import "./chunk-ZOXV6WFI.mjs";
+import "./chunk-FVPT44IJ.mjs";
 import "./chunk-4QF2K7TM.mjs";
 import "./chunk-DLIRSHV6.mjs";
 import "./chunk-HBL4PM5Q.mjs";
-import "./chunk-UGYLGT7B.mjs";
+import "./chunk-UHTJWDYB.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";
 export {

package/dist/cli/{billing-YJAP4VZN.mjs → billing-IIBEZ6J7.mjs}

@@ -1,10 +1,10 @@
 import {
   DeeplineClient
-} from "./chunk-26CZVDQN.mjs";
+} from "./chunk-NPNQCPFP.mjs";
 import {
   iterateCursorPages,
   requireBillingIdempotencyKey
-} from "./chunk-DQZBERDL.mjs";
+} from "./chunk-F5PYBZ2H.mjs";
 import "./chunk-L2VKAASU.mjs";
 import "./chunk-NELMCOWK.mjs";
 import "./chunk-S3A4IXBQ.mjs";
@@ -15,9 +15,9 @@ import {
   openInBrowser,
   printCommandEnvelope,
   shouldEmitJson
-} from "./chunk-KKWQ24VM.mjs";
-import "./chunk-YK64UZXN.mjs";
-import "./chunk-Z27NSLPC.mjs";
+} from "./chunk-NTJDZURV.mjs";
+import "./chunk-ZOXV6WFI.mjs";
+import "./chunk-FVPT44IJ.mjs";
 import {
   AuthError,
   ConfigError
@@ -26,7 +26,7 @@ import "./chunk-DLIRSHV6.mjs";
 import {
   DeeplineError
 } from "./chunk-HBL4PM5Q.mjs";
-import "./chunk-UGYLGT7B.mjs";
+import "./chunk-UHTJWDYB.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";