deepline 0.3.332 → 0.3.333

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

@@ -288,6 +288,36 @@ function isMissingRateThrottleCeilingColumnError(error: unknown): boolean {
   );
 }
 
+/** Run the existing rate operation until the deploy-owned probe expansion lands. */
+function isMissingProbeBaselineColumnError(error: unknown): boolean {
+  const candidate = error as { code?: unknown; message?: unknown } | null;
+  return (
+    candidate?.code === '42703' &&
+    typeof candidate.message === 'string' &&
+    /\b(rate_probe_successes_at_ramp|rate_probe_started_at_ms)\b/.test(
+      candidate.message,
+    )
+  );
+}
+
+async function queryRateStateWithProbeBaseline<
+  Row extends Record<string, unknown>,
+>(
+  client: PostgresSchedulerQueryClient,
+  sql: (probeBaselineSupported: boolean) => string,
+  parameters: unknown[],
+) {
+  try {
+    return await client.query<Row>(sql(true), parameters);
+  } catch (error) {
+    if (!isMissingProbeBaselineColumnError(error)) throw error;
+    // PostgreSQL rejects the statement before any grant or reservation writes.
+    // Retry only that statement; previously accepted success feedback is not
+    // applied twice. No DDL, migration preflight, or global schema floor.
+    return await client.query<Row>(sql(false), parameters);
+  }
+}
+
 /**
  * v43 added `rate_requesters` and the lease `requester_id` column. Only an
  * acquire that carries a requester identity touches them, so during the
@@ -565,6 +595,8 @@ export async function ensurePostgresRateStateSchema(
       ADD COLUMN IF NOT EXISTS last_ramp_at_ms bigint NOT NULL DEFAULT 0,
       ADD COLUMN IF NOT EXISTS rate_observation_started_at_ms bigint,
       ADD COLUMN IF NOT EXISTS rate_successes bigint NOT NULL DEFAULT 0,
+      ADD COLUMN IF NOT EXISTS rate_probe_successes_at_ramp bigint NOT NULL DEFAULT 0,
+      ADD COLUMN IF NOT EXISTS rate_probe_started_at_ms bigint NOT NULL DEFAULT 0,
       ADD COLUMN IF NOT EXISTS rate_recovery_interval_ms bigint NOT NULL DEFAULT 1000,
       ADD COLUMN IF NOT EXISTS rate_throttle_ceiling_rps float8
   `);
@@ -916,6 +948,8 @@ type InternalAcquireOutcome = PlayRunnerRateStateAcquireResult & {
   observedRuleRows: number;
   /** True when a seed upsert would still change a stored row (config drift). */
   configDrift: boolean;
+  /** Local monotonic receipt time; never crosses the runtime boundary. */
+  serverClockReceivedAtMs?: number;
 };
 
 function acquireResultOf(
@@ -924,9 +958,17 @@ function acquireResultOf(
   const result: PlayRunnerRateStateAcquireResult & {
     observedRuleRows?: number;
     configDrift?: boolean;
+    serverClockReceivedAtMs?: number;
   } = { ...outcome };
   delete result.observedRuleRows;
   delete result.configDrift;
+  delete result.serverClockReceivedAtMs;
+  if (outcome.serverClockReceivedAtMs != null) {
+    result.serverClockElapsedMs = Math.max(
+      0,
+      Math.floor(performance.now() - outcome.serverClockReceivedAtMs),
+    );
+  }
   return result;
 }
 
@@ -1307,7 +1349,7 @@ async function acquirePureRate(
         concurrency: null,
       })
     : null;
-  const result = await client.query<{
+  const result = await queryRateStateWithProbeBaseline<{
     granted: string | number;
     wait_ms: string | number;
     observed_rule_rows: string | number;
@@ -1319,7 +1361,8 @@ async function acquirePureRate(
     reservation_ids: string[] | null;
     effective_rps: string | number;
   }>(
-    `
+    client,
+    (probeBaselineSupported) => `
       WITH now_value AS (
         SELECT COALESCE(
           $3::bigint,
@@ -1346,6 +1389,7 @@ async function acquirePureRate(
         '$5',
         minimumRateSqlForRules(rules),
         unknownProvider,
+        probeBaselineSupported,
       )},
       reclaim_reservations AS (
         DELETE FROM ${reservationTableName(input)}
@@ -1500,7 +1544,7 @@ async function acquirePureRate(
           GREATEST(1, FLOOR(MIN(next_refill_per_sec) / 100.0))::bigint AS burst_size
         FROM refreshed
       ),
-      ${updateRateScopeSql(scopeHoldTableName(input), unknownProvider)},
+      ${updateRateScopeSql(scopeHoldTableName(input), unknownProvider, probeBaselineSupported)},
       updated AS (
         UPDATE ${bucketTableName(input)} b
         SET
@@ -1669,6 +1713,8 @@ async function acquirePureRate(
       ...(requesterId ? [requesterId] : []),
     ],
   );
+  const serverClockReceivedAtMs =
+    input.nowMs == null ? performance.now() : undefined;
   const row = result.rows[0];
   if (!row) {
     // Seeding raced away or rows vanished; the caller re-seeds and retries.
@@ -1709,6 +1755,7 @@ async function acquirePureRate(
     granted,
     waitMs,
     serverNowMs,
+    serverClockReceivedAtMs,
     observedRuleRows,
     configDrift,
     leaseIds: [],
@@ -1741,29 +1788,39 @@ async function acquireWithConcurrency(
   seeds: RateBucketSeed[],
   requested: number,
 ): Promise<InternalAcquireOutcome> {
-  await client.query('BEGIN ISOLATION LEVEL READ COMMITTED');
-  try {
-    await client.query(
-      `SELECT bucket_id FROM ${scopeHoldTableName(input)}
-       WHERE bucket_id = $1 FOR UPDATE`,
-      [input.bucketId],
-    );
-    const outcome = await grantWithConcurrency(
-      client,
-      input,
-      rules,
-      seeds,
-      requested,
-    );
-    await client.query('COMMIT');
-    return outcome;
-  } catch (error) {
+  let probeBaselineSupported = true;
+  while (true) {
+    await client.query('BEGIN ISOLATION LEVEL READ COMMITTED');
     try {
-      await client.query('ROLLBACK');
-    } catch {
-      // Preserve the original admission/storage error.
+      await client.query(
+        `SELECT bucket_id FROM ${scopeHoldTableName(input)}
+       WHERE bucket_id = $1 FOR UPDATE`,
+        [input.bucketId],
+      );
+      const outcome = await grantWithConcurrency(
+        client,
+        input,
+        rules,
+        seeds,
+        requested,
+        probeBaselineSupported,
+      );
+      await client.query('COMMIT');
+      return outcome;
+    } catch (error) {
+      try {
+        await client.query('ROLLBACK');
+      } catch {
+        // Preserve the original admission/storage error.
+      }
+      if (probeBaselineSupported && isMissingProbeBaselineColumnError(error)) {
+        // The failed grant aborts its transaction. Reacquire the same scope lock
+        // with a fresh snapshot; only the grant is repeated, never its feedback.
+        probeBaselineSupported = false;
+        continue;
+      }
+      throw error;
     }
-    throw error;
   }
 }
 
@@ -1773,6 +1830,7 @@ async function grantWithConcurrency(
   rules: AcquirePacingRule[],
   seeds: RateBucketSeed[],
   requested: number,
+  probeBaselineSupported: boolean,
 ): Promise<InternalAcquireOutcome> {
   const ruleIds = rules.map((rule) => rule.ruleId);
   const unknownProvider = rules.some(
@@ -1830,6 +1888,7 @@ async function grantWithConcurrency(
         '$10',
         minimumRateSqlForRules(rules),
         unknownProvider,
+        probeBaselineSupported,
       )},
       reclaim_reservations AS (
         DELETE FROM ${reservationTableName(input)}
@@ -2068,7 +2127,7 @@ async function grantWithConcurrency(
           GREATEST(1, FLOOR(MIN(next_refill_per_sec) / 100.0))::bigint AS burst_size
         FROM refreshed
       ),
-      ${updateRateScopeSql(scopeHoldTableName(input), unknownProvider)},
+      ${updateRateScopeSql(scopeHoldTableName(input), unknownProvider, probeBaselineSupported)},
       updated AS (
         UPDATE ${bucketTableName(input)} b
         SET
@@ -2283,6 +2342,8 @@ async function grantWithConcurrency(
       ...(requesterId ? [requesterId] : []),
     ],
   );
+  const serverClockReceivedAtMs =
+    input.nowMs == null ? performance.now() : undefined;
   const row = result.rows[0];
   if (!row) {
     return {
@@ -2327,6 +2388,7 @@ async function grantWithConcurrency(
     granted,
     waitMs,
     serverNowMs,
+    serverClockReceivedAtMs,
     observedRuleRows,
     configDrift,
     leaseIds: granted > 0 ? leaseIds : [],
@@ -2410,9 +2472,15 @@ export async function validatePostgresRateStatePermit(
  */
 export async function claimPostgresProviderDispatch(
   client: PostgresSchedulerQueryClient,
-  input: PlayRunnerRateStateValidateInput & { nowMs?: number },
+  input: PlayRunnerRateStateValidateInput & {
+    nowMs?: number;
+    retryAtMsAtGrant?: number;
+  },
 ): Promise<
-  PlayRunnerRateStateValidateResult & { physicalCadenceWait: boolean }
+  PlayRunnerRateStateValidateResult & {
+    physicalCadenceWait: boolean;
+    stalePermit?: boolean;
+  }
 > {
   return withRateStateAvailabilityGuard(input, async () => {
     const result = await client.query<{
@@ -2420,6 +2488,7 @@ export async function claimPostgresProviderDispatch(
       retry_at_ms: string | number;
       allowed: boolean;
       cadence_wait: boolean;
+      stale_permit: boolean;
     }>(
       `
         WITH now_value AS (
@@ -2438,6 +2507,7 @@ export async function claimPostgresProviderDispatch(
             GREATEST(COALESCE(s.retry_at_ms, 0), COALESCE(s.cool_until_ms, 0)) AS hold_until_ms,
             s.physical_rps,
             COALESCE(s.seen_backpressure, false) AS preserve_cadence_phase,
+            COALESCE(s.retry_at_ms > $3::bigint, false) AS stale_permit,
             GREATEST(1, FLOOR(s.physical_rps / 100))::int AS burst_size,
             GREATEST(1, CEIL(1000.0 / s.physical_rps))::bigint AS spacing_ms
           FROM now_value nv LEFT JOIN scope_rows s ON true
@@ -2453,6 +2523,7 @@ export async function claimPostgresProviderDispatch(
             c.now_ms + c.spacing_ms * c.burst_size, 0
           FROM cadence c
           WHERE c.hold_until_ms <= c.now_ms AND c.physical_rps > 0
+            AND NOT c.stale_permit
           ON CONFLICT (bucket_id, rule_id) DO UPDATE SET
             -- Always return the locked current cursor, including a denial.
             -- A snapshot read after a blocked upsert could miss a concurrent
@@ -2466,9 +2537,16 @@ export async function claimPostgresProviderDispatch(
             cool_until_ms = CASE
               WHEN existing.next_dispatch_at_ms <= EXCLUDED.refilled_at_ms
                 OR LEAST(existing.tokens, EXCLUDED.capacity) >= 1 THEN 0
-              ELSE LEAST(existing.next_dispatch_at_ms, EXCLUDED.next_dispatch_at_ms) END,
-            -- Persist debt decay at the new pace so repeated probes converge
-            -- to this deadline instead of moving it forward on every denial.
+              ELSE CASE WHEN EXCLUDED.refill_per_sec > existing.refill_per_sec
+                THEN LEAST(existing.next_dispatch_at_ms,
+                  GREATEST(existing.refilled_at_ms, EXCLUDED.refilled_at_ms)
+                    + (EXCLUDED.next_dispatch_at_ms - EXCLUDED.refilled_at_ms))
+                ELSE existing.next_dispatch_at_ms END END,
+            -- Only a faster rate shortens existing debt. A contender can
+            -- sample the clock before waiting behind a newer cursor grant;
+            -- its denial must not rewind that grant at the same pace. Anchor
+            -- recovery at the latest cursor clock, then persist its deadline
+            -- so repeated probes converge without consuming another slot.
             next_dispatch_at_ms = CASE
               WHEN existing.next_dispatch_at_ms <= EXCLUDED.refilled_at_ms
                 -- Keep the cadence phase when a request reaches its slot
@@ -2487,23 +2565,30 @@ export async function claimPostgresProviderDispatch(
                   -- Cold discovery retains strict spacing until provider
                   -- backpressure establishes an adaptive cadence.
                   ELSE EXCLUDED.next_dispatch_at_ms END
-              ELSE LEAST(existing.next_dispatch_at_ms, EXCLUDED.next_dispatch_at_ms) END,
+              ELSE CASE WHEN EXCLUDED.refill_per_sec > existing.refill_per_sec
+                THEN LEAST(existing.next_dispatch_at_ms,
+                  GREATEST(existing.refilled_at_ms, EXCLUDED.refilled_at_ms)
+                    + (EXCLUDED.next_dispatch_at_ms - EXCLUDED.refilled_at_ms))
+                ELSE existing.next_dispatch_at_ms END END,
             capacity = EXCLUDED.capacity,
             refill_per_sec = EXCLUDED.refill_per_sec,
             base_refill_per_sec = EXCLUDED.base_refill_per_sec,
             max_rps = EXCLUDED.max_rps,
-            refilled_at_ms = EXCLUDED.refilled_at_ms
+            refilled_at_ms = GREATEST(existing.refilled_at_ms, EXCLUDED.refilled_at_ms)
           RETURNING cool_until_ms
         )
         SELECT c.now_ms AS server_now_ms,
-          GREATEST(c.hold_until_ms, COALESCE(cursor.cool_until_ms, 0)) AS retry_at_ms,
-          c.hold_until_ms <= c.now_ms AND (
+          GREATEST(c.hold_until_ms, COALESCE(cursor.cool_until_ms, 0),
+            CASE WHEN c.stale_permit THEN c.now_ms ELSE 0 END) AS retry_at_ms,
+          NOT c.stale_permit AND c.hold_until_ms <= c.now_ms AND (
             c.physical_rps IS NULL OR cursor.cool_until_ms = 0
           ) AS allowed,
-          c.hold_until_ms <= c.now_ms AND COALESCE(cursor.cool_until_ms > c.now_ms, false) AS cadence_wait
+          NOT c.stale_permit AND c.hold_until_ms <= c.now_ms
+            AND COALESCE(cursor.cool_until_ms > c.now_ms, false) AS cadence_wait,
+          c.stale_permit
         FROM cadence c LEFT JOIN cursor ON true
       `,
-      [input.bucketId, input.nowMs ?? null],
+      [input.bucketId, input.nowMs ?? null, input.retryAtMsAtGrant ?? null],
     );
     const row = result.rows[0];
     if (!row || typeof row.allowed !== 'boolean') {
@@ -2516,6 +2601,9 @@ export async function claimPostgresProviderDispatch(
       physicalCadenceWait: row.cadence_wait,
       serverNowMs: Number(row.server_now_ms),
       retryAtMs: Number(row.retry_at_ms),
+      ...(input.retryAtMsAtGrant !== undefined
+        ? { stalePermit: row.stale_permit }
+        : {}),
     };
   });
 }
@@ -3362,7 +3450,13 @@ async function penalizeRateStateStatements(
             -- no successes justifies the shared exponential pause.
             WHEN h.rate_successes <= 0
               AND ($5::bigint IS NOT NULL OR h.seen_backpressure)
-              AND (NOT h.unknown_provider OR h.seen_backpressure) THEN
+              -- An unknown scope can only recover above its floor after
+              -- successful work. A cleared counter at that new epoch does
+              -- not turn its measurement duration into consecutive failures.
+              AND (NOT h.unknown_provider
+                OR h.refill_per_sec <= ${DEFAULT_UNKNOWN_PROVIDER_MIN_RPS})
+              AND (NOT h.unknown_provider OR (h.seen_backpressure
+                AND h.rate_recovery_interval_ms > 0)) THEN
               CASE WHEN h.seen_backpressure THEN
                 LEAST(60000, GREATEST(1000, h.rate_recovery_interval_ms * 2))
               ELSE 1000 END
@@ -3392,6 +3486,7 @@ async function penalizeRateStateStatements(
         SELECT e.*,
           CASE WHEN e.new_episode THEN GREATEST(
             CASE WHEN e.seen_backpressure AND e.rate_successes = 0
+              AND e.no_progress_probe_interval_ms IS NOT NULL
               THEN ${noProgressProbeRateRps}
               ELSE CASE WHEN e.unknown_provider
                 THEN ${DEFAULT_UNKNOWN_PROVIDER_MIN_RPS} ELSE ${minimumRateRps} END END,

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

@@ -363,8 +363,10 @@ const POSTGRES_SCHEDULER_SCHEMA_INIT_STATEMENT_TIMEOUT_MS = 60_000;
 // 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.
+// v63 adds optional rate-probe count and clock baselines. Older writers ignore them;
+// unexpanded acquires retain their existing operation-local measurement.
 // This marker records deployment work, never a runtime schema floor.
-export const POSTGRES_SCHEDULER_SCHEMA_VERSION = 62;
+export const POSTGRES_SCHEDULER_SCHEMA_VERSION = 63;
 const POSTGRES_SCHEDULER_SCHEMA_MIGRATIONS_TABLE =
   'scheduler_schema_migrations';
 export const POSTGRES_SCHEDULER_OPEN_RECOVERY_INDEX =
@@ -1564,9 +1566,10 @@ export async function hasCurrentPostgresSchedulerSchemaShape(
                   'tokens', 'refilled_at_ms', 'next_dispatch_at_ms', 'seen_backpressure',
                   'cool_until_ms', 'last_ramp_at_ms', 'rate_observation_started_at_ms',
                   'rate_successes', 'rate_recovery_interval_ms',
-                  'rate_throttle_ceiling_rps'
+                  'rate_throttle_ceiling_rps', 'rate_probe_successes_at_ramp',
+                  'rate_probe_started_at_ms'
                 )
-            ) = 15
+            ) = 17
             AND (
               SELECT count(DISTINCT column_name)
               FROM information_schema.columns

package/dist/bundling-sources/shared_libs/play-runtime/tool-execute-retry-policy.ts

@@ -107,10 +107,20 @@ export const TOOL_EXECUTE_RUNNER_ACCEPTS_HEADER = 'x-deepline-runner-accepts';
  */
 export const TOOL_EXECUTE_RUNNER_ACCEPTS_CONCURRENCY_BACKPRESSURE =
   'concurrency-backpressure';
+export const TOOL_EXECUTE_RUNNER_ACCEPTS_PROVIDER_RETRY_DEADLINE =
+  'provider-retry-deadline-ms';
+
+/** Set by a supporting gateway only when its runner also reads exact deadlines. */
+export const TOOL_EXECUTE_PROVIDER_RETRY_DEADLINE_CAPABILITY_HEADER =
+  'x-deepline-provider-retry-deadline';
+export const TOOL_EXECUTE_PROVIDER_RETRY_DEADLINE_CAPABILITY_VALUE =
+  'milliseconds';
+/** Immutable provider deadline; Retry-After remains an HTTP-date for old readers. */
+export const TOOL_EXECUTE_PROVIDER_RETRY_AT_HEADER =
+  'x-deepline-provider-retry-at-ms';
 
 /** The capability tokens this runner build advertises on provider execute. */
-export const TOOL_EXECUTE_RUNNER_ACCEPTS_VALUE =
-  TOOL_EXECUTE_RUNNER_ACCEPTS_CONCURRENCY_BACKPRESSURE;
+export const TOOL_EXECUTE_RUNNER_ACCEPTS_VALUE = `${TOOL_EXECUTE_RUNNER_ACCEPTS_CONCURRENCY_BACKPRESSURE},${TOOL_EXECUTE_RUNNER_ACCEPTS_PROVIDER_RETRY_DEADLINE}`;
 /** Runner proof headers consumed by the gateway and authenticated app boundary. */
 export const TOOL_EXECUTE_PROVIDER_RATE_SCOPE_HEADER =
   'x-deepline-provider-rate-scope';
@@ -161,6 +171,73 @@ export function runnerAcceptsConcurrencyBackpressure(
     );
 }
 
+export function providerRetryDeadlineCapabilityForRunner(
+  headers: Pick<Headers, 'get'>,
+): string | null {
+  return headers
+    .get(TOOL_EXECUTE_RUNNER_ACCEPTS_HEADER)
+    ?.split(',')
+    .some(
+      (token) =>
+        token.trim().toLowerCase() ===
+        TOOL_EXECUTE_RUNNER_ACCEPTS_PROVIDER_RETRY_DEADLINE,
+    )
+    ? TOOL_EXECUTE_PROVIDER_RETRY_DEADLINE_CAPABILITY_VALUE
+    : null;
+}
+
+export function providerRetryDeadlinePrecisionEnabled(
+  headers: Pick<Headers, 'get'> | undefined,
+): boolean {
+  return (
+    headers?.get(TOOL_EXECUTE_PROVIDER_RETRY_DEADLINE_CAPABILITY_HEADER) ===
+    TOOL_EXECUTE_PROVIDER_RETRY_DEADLINE_CAPABILITY_VALUE
+  );
+}
+
+/** An exact deadline is usable only beside its matching legacy HTTP-date. */
+export function parseToolExecuteExactProviderRetryAtMs(response: {
+  status: number;
+  headers: Pick<Headers, 'get'>;
+}): number | undefined {
+  if (response.status !== 429) return undefined;
+  const retryAfter = response.headers.get('retry-after');
+  if (!retryAfter?.trim()) return undefined;
+  // Exact writers emit IMF-fixdate. Date.parse also accepts delta-seconds
+  // such as "1" as a calendar date, and ISO/obsolete date presentations.
+  if (
+    !/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), \d{2} (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \d{4} \d{2}:\d{2}:\d{2} GMT$/.test(
+      retryAfter,
+    )
+  )
+    return undefined;
+  const exact = response.headers.get(TOOL_EXECUTE_PROVIDER_RETRY_AT_HEADER);
+  const retryAtMs = exact && /^\d+$/.test(exact) ? Number(exact) : NaN;
+  if (
+    isAttestedProvider429Response(response) &&
+    Number.isSafeInteger(retryAtMs) &&
+    retryAtMs >= 0 &&
+    retryAtMs <= 8.64e15 &&
+    new Date(Math.ceil(retryAtMs / 1_000) * 1_000).toUTCString() === retryAfter
+  ) {
+    return retryAtMs;
+  }
+  return undefined;
+}
+
+export function parseToolExecuteProviderRetryAtMs(
+  response: { status: number; headers: Pick<Headers, 'get'> },
+  nowMs = Date.now(),
+): number | undefined {
+  if (response.status !== 429) return undefined;
+  const retryAfter = response.headers.get('retry-after');
+  if (!retryAfter?.trim()) return undefined;
+  return (
+    parseToolExecuteExactProviderRetryAtMs(response) ??
+    parseToolExecuteRetryAtMs(retryAfter, nowMs)
+  );
+}
+
 export class ToolExecuteAuthScopeChangedError extends Error {
   readonly code = TOOL_EXECUTE_AUTH_SCOPE_CHANGED_CODE;
   readonly status = 409;
@@ -612,6 +689,8 @@ export function classifyToolExecuteHttpFailure(input: {
   bodyText: string;
   schemaVersion?: ToolExecutionErrorSchemaVersion;
   retryAfterHeader?: string | null;
+  /** Captured at response-header arrival; absent keeps the legacy header path. */
+  retryAtMs?: number;
   transientHttpRetrySafe?: boolean;
   /** The call runs under the gateway's durable execution fence. */
   executionFenced?: boolean;
@@ -670,7 +749,12 @@ export function classifyToolExecuteHttpFailure(input: {
   const retryAfterMs =
     providerPacingWait && exactProviderPacingWaitMs !== null
       ? exactProviderPacingWaitMs
-      : parseToolExecuteRetryAfterMs(input.retryAfterHeader, input.nowMs);
+      : input.status === 429 &&
+          Number.isSafeInteger(input.retryAtMs) &&
+          input.retryAtMs! >= 0 &&
+          input.retryAtMs! <= 8.64e15
+        ? Math.max(0, input.retryAtMs! - (input.nowMs ?? Date.now()))
+        : parseToolExecuteRetryAfterMs(input.retryAfterHeader, input.nowMs);
   const error = normalizeToolHttpErrorMessage({
     toolId: input.toolId,
     status: input.status,

package/dist/cli/auth-26GA3RM6.js

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

package/dist/cli/{auth-V4IWMXTG.mjs → auth-OQ356CEE.mjs}

@@ -9,11 +9,11 @@ import {
   registerAuthCommands,
   reportSetupCompleted,
   resolvePendingAuthClaimForResume
-} from "./chunk-MSQK2FLJ.mjs";
-import "./chunk-WQI642QX.mjs";
-import "./chunk-LAJ56FLL.mjs";
+} from "./chunk-H5SORD7Q.mjs";
+import "./chunk-HNX3RC6V.mjs";
+import "./chunk-5UN6KLD2.mjs";
 import "./chunk-DLIRSHV6.mjs";
-import "./chunk-3E7P62NA.mjs";
+import "./chunk-2CLENWOQ.mjs";
 import "./chunk-NXGCO4JB.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";