deepline 0.3.312 → 0.3.314

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/backends/daytona.ts

@@ -1,4 +1,7 @@
-import { createDaytonaLaunchClient } from './daytona-launch-transport';
+import {
+  createDaytonaLaunchClient,
+  redactDaytonaErrorDetail,
+} from './daytona-launch-transport';
 import type { DaytonaClientOptions } from '../../daytona-runtime-config';
 import {
   createDaytonaControlClient,
@@ -328,23 +331,6 @@ function numberProperty(value: unknown, key: string): number | null {
     : null;
 }
 
-function redactDaytonaErrorDetail(value: string): string {
-  return value
-    .replace(
-      /authorization\s*[=:]\s*bearer\s+[^\s,;]+/gi,
-      'Authorization=Bearer [redacted]',
-    )
-    .replace(
-      /(authorization\s*[=:]\s*)(?!bearer\s+\[redacted\])[^\s,;]+/gi,
-      '$1[redacted]',
-    )
-    .replace(/(bearer\s+)[^\s,;]+/gi, '$1[redacted]')
-    .replace(/((?:api[_-]?key|token)\s*[=:]\s*)[^\s,;]+/gi, '$1[redacted]')
-    .replace(/\s+/g, ' ')
-    .trim()
-    .slice(0, 1_000);
-}
-
 /**
  * Preserve the actionable shape of a Daytona control-plane failure without
  * copying credentials or an arbitrarily large upstream response into logs.

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

@@ -48,6 +48,7 @@ import { RUNTIME_RELIABILITY_POLICY } from '../runtime-reliability-policy';
 import type { RuntimeTrafficPolicy } from '../runtime-traffic-policy';
 import { runtimeLimitExceededCause } from '../run-failure';
 import {
+  playRunRecoveryLogDetail,
   recoveryForDaytonaSandboxAcquisitionUnavailable,
   recoveryForRuntimeInitializationTransportFailure,
   recoveryForRuntimeSchedulerAdmissionFailure,
@@ -4359,6 +4360,9 @@ async function executeAssignedAbsurdAttempt(input: {
         }),
       );
       if (recovery.kind === 'deferred') {
+        // Log-only. The persisted reason groups several provider conditions
+        // into one decision; the detail names the one that was observed.
+        const detail = playRunRecoveryLogDetail(recoveryError);
         console.warn('[absurd-runtime.worker] pre_code_recovery_deferred', {
           runId,
           generation,
@@ -4367,6 +4371,7 @@ async function executeAssignedAbsurdAttempt(input: {
           deferCount: recovery.deferCount,
           deadlineAtMs: recovery.deadlineAtMs,
           delaySeconds: recovery.delaySeconds,
+          ...(detail ? { detail } : {}),
         });
         throw new DeferTask(
           `Platform recovery deferred for ${recovery.dependency}: ${recovery.reason}`,

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

@@ -354,8 +354,10 @@ const POSTGRES_SCHEDULER_SCHEMA_INIT_STATEMENT_TIMEOUT_MS = 60_000;
 // v60 indexes all sandbox leases by Run, including released custody history.
 // v61 adds an operator-owned new-run projection cutover and admission pin.
 // Existing namespace mode values and unpinned runs keep their behavior.
+// v62 adds a deploy-owned index for per-run active outbox lease exclusion.
+// Failed facts remain indexed: their live leases still fence the run.
 // This marker records deployment work, never a runtime schema floor.
-export const POSTGRES_SCHEDULER_SCHEMA_VERSION = 61;
+export const POSTGRES_SCHEDULER_SCHEMA_VERSION = 62;
 const POSTGRES_SCHEDULER_SCHEMA_MIGRATIONS_TABLE =
   'scheduler_schema_migrations';
 export const POSTGRES_SCHEDULER_OPEN_RECOVERY_INDEX =
@@ -1986,6 +1988,15 @@ export async function hasCurrentPostgresSchedulerSchemaShape(
             AND index_row.indrelid = to_regclass($3)
             AND index_row.indisready AND index_row.indisvalid
         )
+        AND EXISTS (
+          SELECT 1 FROM pg_index AS index_row
+          JOIN pg_class AS index_class ON index_class.oid = index_row.indexrelid
+          JOIN pg_namespace AS index_namespace ON index_namespace.oid = index_class.relnamespace
+          WHERE index_namespace.nspname = $1
+            AND index_class.relname = 'runtime_scheduler_outbox_run_lease_idx'
+            AND index_row.indrelid = to_regclass($3)
+            AND index_row.indisready AND index_row.indisvalid
+        )
         AND EXISTS (
           SELECT 1 FROM pg_index AS index_row
           JOIN pg_class AS index_class ON index_class.oid = index_row.indexrelid
@@ -4018,6 +4029,11 @@ export async function ensurePostgresSchedulerSchema(
           )
           WHERE delivered_at IS NULL AND ${searchLaneSql('outbox')} = true
       `);
+      await client.query(`
+        CREATE INDEX IF NOT EXISTS runtime_scheduler_outbox_run_lease_idx
+          ON ${tableName('outbox', options)} (run_id, lease_expires_at)
+          WHERE delivered_at IS NULL AND lease_owner IS NOT NULL
+      `);
       await client.query(`
         CREATE INDEX IF NOT EXISTS runtime_scheduler_outbox_lease_health_idx
           ON ${tableName('outbox', options)}
@@ -4194,6 +4210,12 @@ const POSTGRES_SCHEDULER_RUNTIME_ADMIN_INDEXES = [
       created_at, event_id)
       WHERE delivered_at IS NULL AND ${searchLaneSql('outbox')} = true`,
   },
+  {
+    name: 'runtime_scheduler_outbox_run_lease_idx',
+    table: 'outbox',
+    definition: `(run_id, lease_expires_at)
+      WHERE delivered_at IS NULL AND lease_owner IS NOT NULL`,
+  },
   {
     name: 'runtime_scheduler_outbox_lease_health_idx',
     table: 'outbox',
@@ -17982,8 +18004,11 @@ function runLedgerPrecedesSql(
   predecessor: string,
   successor: string,
   inclusive = false,
+  searchOnly?: boolean,
 ): string {
-  return `(${searchLaneSql(predecessor)} = ${searchLaneSql(successor)} AND ${runLedgerPositionSql(predecessor)} ${inclusive ? '<=' : '<'} ${runLedgerPositionSql(successor)})`;
+  const lane =
+    searchOnly === undefined ? searchLaneSql(successor) : String(searchOnly);
+  return `(${searchLaneSql(predecessor)} = ${lane} AND ${runLedgerPositionSql(predecessor)} ${inclusive ? '<=' : '<'} ${runLedgerPositionSql(successor)})`;
 }
 
 function searchLaneSql(alias: string): string {
@@ -18014,30 +18039,28 @@ function runLedgerTerminalPendingSql(
   )`;
 }
 
-function runLedgerWaitingRunsSql(
+function runLedgerWaitingPendingSql(
+  alias: string,
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
-  runIdParameter?: string,
+  runIdSql = `${alias}.run_id`,
 ): string {
-  return `SELECT DISTINCT waiting_event.run_id
+  return `EXISTS (SELECT 1
     FROM ${tableName('outbox', options)} AS waiting_event
-    WHERE waiting_event.event_type = ${RUN_EVENT_KIND_SQL_LITERAL.runWaiting}
+    WHERE waiting_event.run_id = ${runIdSql}
+      AND waiting_event.event_type = ${RUN_EVENT_KIND_SQL_LITERAL.runWaiting}
       -- Detached runner parks are transport-only and project no public wait.
       AND waiting_event.payload_json->>'kind' IS DISTINCT FROM 'detached_runner'
       AND waiting_event.delivered_at IS NULL
       AND waiting_event.failed_at IS NULL
-      AND coalesce(waiting_event.next_attempt_at, waiting_event.created_at) <= now()
-      ${runIdParameter ? `AND (${runIdParameter}::text IS NULL OR waiting_event.run_id = ${runIdParameter}::text)` : ''}`;
-}
-
-function runLedgerWaitingPendingSql(alias: string): string {
-  return `(${alias}.run_id IN (SELECT run_id FROM waiting_runs))`;
+      AND coalesce(waiting_event.next_attempt_at, waiting_event.created_at) <= now())`;
 }
 
 function runLedgerUrgentLifecyclePendingSql(
   alias: string,
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
+  runIdSql?: string,
 ): string {
-  return `(${runLedgerTerminalPendingSql(alias, options)} OR ${runLedgerWaitingPendingSql(alias)})`;
+  return `(${runLedgerTerminalPendingSql(alias, options)} OR ${runLedgerWaitingPendingSql(alias, options, runIdSql)})`;
 }
 
 /**
@@ -18111,7 +18134,14 @@ async function claimPostgresSchedulerOutboxPrefix(
     const urgentLifecyclePendingSql = (alias: string) =>
       input.searchOnly === true
         ? runLedgerTerminalPendingSql(alias, options)
-        : runLedgerUrgentLifecyclePendingSql(alias, options);
+        : runLedgerUrgentLifecyclePendingSql(
+            alias,
+            options,
+            // Every claimed row belongs to the selected run. An independent
+            // wait probe evaluates once, instead of scanning its backlog for
+            // each row whose delivery batch is being frozen.
+            runId !== null ? '$2::text' : undefined,
+          );
     // Search is locally indexed and acknowledged; it has no remote ingress
     // receipt to freeze. Preserve causal ordering/due/lease checks, but admit
     // its full prefix instead of inheriting lifecycle's singleton transport.
@@ -18121,6 +18151,20 @@ async function claimPostgresSchedulerOutboxPrefix(
         : supportsTerminalBatchMarker && input.allowIngressPrefix === true
           ? `(head.event_type = ${RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL.runEvents})`
           : 'false';
+    const findSearchBlockersOnce = seekRunHead && input.searchOnly === true;
+    const blockingPredecessorSql = (alias: string) => `(
+      (${alias}.event_type = ${RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL.runEvents}
+       AND NOT (${ingressPrefixSql}))
+      OR (${supportsTerminalBatchMarker && input.allowIngressPrefix === true ? `head.delivery_batch_started_at IS NOT NULL AND ${alias}.delivery_batch_started_at IS NULL` : 'false'})
+      OR ${alias}.failed_at IS NOT NULL
+      OR coalesce(${alias}.next_attempt_at, ${alias}.created_at) > now()
+      OR (
+        $3::text IS NOT NULL
+        AND ${alias}.lease_expires_at IS NOT NULL
+        AND ${alias}.lease_expires_at > now()
+        AND ${alias}.lease_owner IS DISTINCT FROM $3::text
+      )
+    )`;
     return await client.query<{
       row_kind: 'claimed' | 'delivered';
       event_id: string;
@@ -18139,12 +18183,6 @@ async function claimPostgresSchedulerOutboxPrefix(
       ),`
           : ''
       } ${
-        input.searchOnly === true
-          ? ''
-          : `waiting_runs AS MATERIALIZED (
-        ${runLedgerWaitingRunsSql(options, '$2')}
-      ), `
-      }${
         seekRunHead
           ? `pending_head AS MATERIALIZED (
         SELECT pending.event_id
@@ -18169,6 +18207,7 @@ async function claimPostgresSchedulerOutboxPrefix(
           : ''
       } head AS MATERIALIZED (
         SELECT candidate.event_id, candidate.run_id, candidate.event_type,
+               ${findSearchBlockersOnce ? 'candidate.created_at,' : ''}
                ${supportsTerminalBatchMarker ? 'candidate.delivery_batch_started_at' : 'NULL::timestamptz'} AS delivery_batch_started_at
         FROM ${tableName('outbox', options)} AS candidate
         ${seekRunHead ? 'JOIN pending_head ON pending_head.event_id = candidate.event_id' : ''}
@@ -18207,7 +18246,7 @@ async function claimPostgresSchedulerOutboxPrefix(
             SELECT 1 FROM ${tableName('outbox', options)} AS active
             WHERE active.run_id = candidate.run_id
               AND ${pending('active')}
-              AND ${searchLaneSql('active')} = ${searchLaneSql('candidate')}
+              AND ${searchLaneSql('active')} = ${input.searchOnly === true ? 'true' : 'false'}
               AND active.lease_owner IS NOT NULL
               AND active.lease_expires_at > now()
               AND active.lease_owner IS DISTINCT FROM $3::text
@@ -18223,7 +18262,7 @@ async function claimPostgresSchedulerOutboxPrefix(
             FROM ${tableName('outbox', options)} AS predecessor
             WHERE predecessor.run_id = candidate.run_id
               AND ${pending('predecessor')}
-              AND ${runLedgerPrecedesSql('predecessor', 'candidate')}
+              AND ${runLedgerPrecedesSql('predecessor', 'candidate', false, input.searchOnly === true)}
           )`
           }
         -- A new durable admission has no causal dependency on unrelated
@@ -18234,23 +18273,62 @@ async function claimPostgresSchedulerOutboxPrefix(
         -- predecessors. Giving priority only to a terminal head leaves a
         -- finished run's earlier progress behind unrelated progress. The
         -- predecessor checks still forbid skipping any fact within the run.
-        ORDER BY
+        ${
+          runId !== null
+            ? ''
+            : `ORDER BY
           CASE
             WHEN candidate.event_type = ${RUN_EVENT_KIND_SQL_LITERAL.runCreated} THEN 0
             WHEN ${runLedgerTerminalPendingSql('candidate', options)} THEN 1
-            ${input.searchOnly === true ? '' : `WHEN ${runLedgerWaitingPendingSql('candidate')} THEN 2`}
+            ${input.searchOnly === true ? '' : `WHEN ${runLedgerWaitingPendingSql('candidate', options)} THEN 2`}
             ELSE 3
           END,
           coalesce(candidate.next_attempt_at, candidate.created_at),
           candidate.created_at,
-          candidate.event_id
+          candidate.event_id`
+        }
         FOR UPDATE SKIP LOCKED
         LIMIT 1
-      ), candidates AS MATERIALIZED (
+      ), ${
+        findSearchBlockersOnce
+          ? `first_blocker AS MATERIALIZED (
+        SELECT predecessor.event_type, predecessor.created_at, predecessor.event_id
+        FROM ${tableName('outbox', options)} AS predecessor
+        JOIN head ON head.run_id = predecessor.run_id
+        WHERE predecessor.run_id = $2::text
+          AND ${pending('predecessor')}
+          AND ${searchLaneSql('predecessor')} = true
+          -- The oldest pending head passed eligibility above. Only later
+          -- facts can introduce an ordinary blocker for this prefix.
+          AND ${runLedgerPositionSql('predecessor')} > (
+            (SELECT CASE head.event_type WHEN ${RUN_EVENT_KIND_SQL_LITERAL.runCreated} THEN 0 WHEN ${RUN_EVENT_KIND_SQL_LITERAL.runStarted} THEN 1 ELSE 2 END FROM head),
+            (SELECT head.created_at FROM head),
+            (SELECT head.event_id FROM head)
+          )
+          AND ${blockingPredecessorSql('predecessor')}
+        ORDER BY ${runLedgerOrderSql('predecessor')}
+        LIMIT 1
+      ), first_started_terminal AS MATERIALIZED (
+        SELECT terminal_predecessor.event_type, terminal_predecessor.created_at, terminal_predecessor.event_id
+        FROM ${tableName('outbox', options)} AS terminal_predecessor
+        JOIN head ON head.run_id = terminal_predecessor.run_id
+        WHERE terminal_predecessor.run_id = $2::text
+          AND ${pending('terminal_predecessor')}
+          AND ${searchLaneSql('terminal_predecessor')} = true
+          AND ${supportsTerminalBatchMarker ? 'terminal_predecessor.delivery_batch_started_at IS NOT NULL' : 'false'}
+          AND terminal_predecessor.event_type IN (
+            ${RUN_EVENT_KIND_SQL_LITERAL.runCompleted}, ${RUN_EVENT_KIND_SQL_LITERAL.runFailed}, ${RUN_EVENT_KIND_SQL_LITERAL.runCancelled}
+          )
+        ORDER BY ${runLedgerOrderSql('terminal_predecessor')}
+        LIMIT 1
+      ),`
+          : ''
+      }candidates AS MATERIALIZED (
         SELECT outbox.event_id
         FROM ${tableName('outbox', options)} AS outbox
         JOIN head ON head.run_id = outbox.run_id
         WHERE ${pending('outbox')}
+          ${runId !== null ? 'AND outbox.run_id = $2::text' : ''}
           AND ${searchLaneSql('outbox')} = ${input.searchOnly === true ? 'true' : 'false'}
           AND outbox.failed_at IS NULL
           -- Admission is causally first and must be projected alone. A later
@@ -18284,7 +18362,20 @@ async function claimPostgresSchedulerOutboxPrefix(
           -- that the replay included a new event.  A terminal which has not
           -- started a batch yet remains an ordinary causal event and can be
           -- claimed with its existing contiguous prefix.
+          ${
+            findSearchBlockersOnce
+              ? `-- Each cutoff reads this run's blockers once, even when stale
+          -- statistics make a broad pending scan look cheaper than a seek.
+          AND NOT EXISTS (
+            SELECT 1 FROM first_started_terminal AS blocker
+            WHERE ${supportsTerminalBatchMarker ? 'outbox.delivery_batch_started_at IS NULL' : 'true'}
+              AND ${runLedgerPositionSql('blocker')} < ${runLedgerPositionSql('outbox')}
+          )
           AND NOT EXISTS (
+            SELECT 1 FROM first_blocker AS blocker
+            WHERE ${runLedgerPositionSql('blocker')} < ${runLedgerPositionSql('outbox')}
+          )`
+              : `          AND NOT EXISTS (
             SELECT 1
             FROM ${tableName('outbox', options)} AS terminal_predecessor
             WHERE terminal_predecessor.run_id = outbox.run_id
@@ -18302,7 +18393,7 @@ async function claimPostgresSchedulerOutboxPrefix(
               AND terminal_predecessor.event_type IN (
                 ${RUN_EVENT_KIND_SQL_LITERAL.runCompleted}, ${RUN_EVENT_KIND_SQL_LITERAL.runFailed}, ${RUN_EVENT_KIND_SQL_LITERAL.runCancelled}
               )
-              AND ${runLedgerPrecedesSql('terminal_predecessor', 'outbox')}
+              AND ${runLedgerPrecedesSql('terminal_predecessor', 'outbox', false, input.searchOnly === true)}
           )
           -- Claim only the contiguous due prefix. A delayed, leased, or failed
           -- predecessor retains ownership of everything that follows it.
@@ -18311,21 +18402,11 @@ async function claimPostgresSchedulerOutboxPrefix(
             FROM ${tableName('outbox', options)} AS predecessor
             WHERE predecessor.run_id = outbox.run_id
               AND ${pending('predecessor')}
-              AND ${runLedgerPrecedesSql('predecessor', 'outbox')}
-              AND (
-                (predecessor.event_type = ${RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL.runEvents}
-                 AND NOT (${ingressPrefixSql}))
-                OR (${supportsTerminalBatchMarker && input.allowIngressPrefix === true ? 'head.delivery_batch_started_at IS NOT NULL AND predecessor.delivery_batch_started_at IS NULL' : 'false'})
-                OR predecessor.failed_at IS NOT NULL
-                OR coalesce(predecessor.next_attempt_at, predecessor.created_at) > now()
-                OR (
-                  $3::text IS NOT NULL
-                  AND predecessor.lease_expires_at IS NOT NULL
-                  AND predecessor.lease_expires_at > now()
-                  AND predecessor.lease_owner IS DISTINCT FROM $3::text
-                )
-              )
+              AND ${runLedgerPrecedesSql('predecessor', 'outbox', false, input.searchOnly === true)}
+              AND ${blockingPredecessorSql('predecessor')}
           )
+`
+          }
         ORDER BY ${runLedgerOrderSql('outbox')}
         FOR UPDATE OF outbox
         LIMIT $1
@@ -20021,7 +20102,7 @@ async function dispatchRunLedgerOutboxBatchWithScope(
               SELECT pending.run_id,
                      pending.event_id,
                      pending.event_type,
-                     pending.payload_json,
+                     ${needsLaunch ? 'pending.payload_json,' : ''}
                      pending.created_at,
                      pending.next_attempt_at,
                      pending.failed_at
@@ -20055,18 +20136,12 @@ async function dispatchRunLedgerOutboxBatchWithScope(
               run_id: string;
               dispatch_launch_json: unknown;
             }>(`
-            WITH ${
-              input.searchOnly === true
-                ? ''
-                : `waiting_runs AS MATERIALIZED (
-              ${runLedgerWaitingRunsSql(options)}
-            ), `
-            }heads AS MATERIALIZED (
+            WITH heads AS MATERIALIZED (
               SELECT DISTINCT ON (pending.run_id)
                 pending.run_id,
                 pending.event_id,
                 pending.event_type,
-                pending.payload_json,
+                ${needsLaunch ? 'pending.payload_json,' : ''}
                 pending.created_at,
                 pending.next_attempt_at,
                 pending.failed_at
@@ -20098,7 +20173,7 @@ async function dispatchRunLedgerOutboxBatchWithScope(
                 : `CASE
                        WHEN head.event_type = ${RUN_EVENT_KIND_SQL_LITERAL.runCreated} THEN 0
                        WHEN ${runLedgerTerminalPendingSql('head', options)} THEN 1
-                       ${input.searchOnly === true ? '' : `WHEN ${runLedgerWaitingPendingSql('head')} THEN 2`}
+                       ${input.searchOnly === true ? '' : `WHEN ${runLedgerWaitingPendingSql('head', options)} THEN 2`}
                        ELSE 3
                      END,`
             }

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

@@ -345,6 +345,7 @@ export function startRunLedgerOutboxRecovery(
     const pendingObservability = new Set<symbol>();
     const deliveries: Delivery[] = [];
     let refill = false;
+    let observabilityRefill = false;
     let dispatchFailed = false;
     let completed = 0;
     let attempted = 0;
@@ -420,11 +421,7 @@ export function startRunLedgerOutboxRecovery(
         // cannot consume a notification that arrived after its query began.
         if (canProbeObservability()) {
           observabilityRequested = false;
-          while (
-            pendingObservability.size < observabilityParallelism &&
-            pending.size < parallelism
-          )
-            launch(true);
+          launch(true);
         }
         if (canProbeLifecycle()) {
           requested = false;
@@ -432,6 +429,14 @@ export function startRunLedgerOutboxRecovery(
         }
         // Productive completion permits immediate use of every free slot.
         // Empty results grant no refill, so idle work cannot spin on scans.
+        if (observabilityRefill) {
+          while (
+            pendingObservability.size < observabilityParallelism &&
+            pending.size < parallelism
+          )
+            launch(true);
+          observabilityRefill = false;
+        }
         if (refill) {
           while (
             pending.size < parallelism &&
@@ -477,7 +482,7 @@ export function startRunLedgerOutboxRecovery(
       // Retryable rows own durable retry clocks. The SQL claim keeps their
       // run ordered while successful slots keep unrelated runs moving.
       if (delivery.observability) {
-        if (result.attempted > 0) observabilityRequested = true;
+        observabilityRefill = result.attempted > 0;
       } else refill = result.attempted > 0;
     }
   };

package/dist/cli/{auth-ACDTPM3M.mjs → auth-GWF55S3N.mjs}

@@ -9,11 +9,11 @@ import {
   registerAuthCommands,
   reportSetupCompleted,
   resolvePendingAuthClaimForResume
-} from "./chunk-6OGNRAS7.mjs";
-import "./chunk-ZH7KTVAB.mjs";
-import "./chunk-WPTUKXIF.mjs";
+} from "./chunk-HTXZLCSP.mjs";
+import "./chunk-QB5MAFCU.mjs";
+import "./chunk-25SPKKF2.mjs";
 import "./chunk-DLIRSHV6.mjs";
-import "./chunk-AA66YTS7.mjs";
+import "./chunk-3K6QD7Z3.mjs";
 import "./chunk-NXGCO4JB.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";

package/dist/cli/auth-QX2L4LPM.js

@@ -0,0 +1,31 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+var _chunkWDPRE6DUjs = require('./chunk-WDPRE6DU.js');
+require('./chunk-ODEWOXWW.js');
+require('./chunk-B5LUKLKH.js');
+require('./chunk-XNYIZMNQ.js');
+require('./chunk-VFRZG4OW.js');
+require('./chunk-7P5AA3SN.js');
+require('./chunk-OG64RBAC.js');
+require('./chunk-COGTRVWW.js');
+
+
+
+
+
+
+
+
+
+
+
+exports.EXIT_WORKSPACE_MISMATCH = _chunkWDPRE6DUjs.EXIT_WORKSPACE_MISMATCH; exports.clearPendingClaim = _chunkWDPRE6DUjs.clearPendingClaim; exports.clearSatisfiedPendingClaim = _chunkWDPRE6DUjs.clearSatisfiedPendingClaim; exports.handleRegister = _chunkWDPRE6DUjs.handleRegister; exports.handleStatus = _chunkWDPRE6DUjs.handleStatus; exports.handleWait = _chunkWDPRE6DUjs.handleWait; exports.readPendingAuthClaim = _chunkWDPRE6DUjs.readPendingAuthClaim; exports.registerAuthCommands = _chunkWDPRE6DUjs.registerAuthCommands; exports.reportSetupCompleted = _chunkWDPRE6DUjs.reportSetupCompleted; exports.resolvePendingAuthClaimForResume = _chunkWDPRE6DUjs.resolvePendingAuthClaimForResume;