deepline 0.3.476 → 0.3.477

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.476',
+  version: '0.3.477',
   updateSummary: {
     introducedIn: '0.3.90',
     summary:

package/dist/bundling-sources/shared_libs/play-runtime/app-runtime-api.ts

@@ -2281,6 +2281,39 @@ export async function releaseRateStateViaAppRuntime(
   });
 }
 
+/** Persist the final success batch without acquiring another provider permit. */
+export async function flushRateStateFeedbackViaAppRuntime(
+  context: WorkerRuntimeApiContext,
+  input: PlayRunnerRateStateReleaseInput,
+  signal: AbortSignal,
+): Promise<void> {
+  const batch = input.concurrencyObservationBatch;
+  if (!batch)
+    throw new Error('Rate-state feedback is missing its batch identity.');
+  const result = await postAppRuntimeApi<{
+    acknowledgedObservationBatch?: typeof batch;
+  }>(
+    {
+      ...context,
+      connectionRetryBudgetMs: 0,
+      signal: context.signal
+        ? AbortSignal.any([context.signal, signal])
+        : signal,
+    },
+    { action: 'rate_state_release', ...input },
+  );
+  const acknowledged = result.acknowledgedObservationBatch;
+  if (
+    acknowledged?.observerId !== batch.observerId ||
+    acknowledged.laneId !== batch.laneId ||
+    acknowledged.sequence !== batch.sequence
+  ) {
+    throw new Error(
+      'Rate-state receiver did not acknowledge the success batch.',
+    );
+  }
+}
+
 export async function penalizeRateStateViaAppRuntime(
   context: WorkerRuntimeApiContext,
   input: PlayRunnerRateStatePenalizeInput,

package/dist/bundling-sources/shared_libs/play-runtime/governor/app-runtime-rate-state-backend.ts

@@ -2,6 +2,7 @@ import {
   acquireRateStateViaAppRuntime,
   AppRuntimeApiTransportError,
   capacityShedRetryAfterMs,
+  flushRateStateFeedbackViaAppRuntime,
   penalizeRateStateViaAppRuntime,
   releaseRateStateViaAppRuntime,
   RateStateValidationUnavailableError,
@@ -54,6 +55,7 @@ export const RATE_ACQUIRE_MAX_WAIT_MS = 300_000;
  */
 export const PROVIDER_ADMISSION_WAIT_BUDGET_MS = 120_000;
 const PROVIDER_NO_PROGRESS_WARNING_MS = 180_000;
+const SUCCESS_FEEDBACK_DRAIN_TIMEOUT_MS = 10_000;
 
 /**
  * Permits leased per app-runtime round trip for the direct Node substrate.
@@ -77,6 +79,10 @@ export interface AppRuntimeRatePort {
   penalize(
     input: Parameters<typeof penalizeRateStateViaAppRuntime>[1],
   ): ReturnType<typeof penalizeRateStateViaAppRuntime>;
+  flushFeedback?(
+    input: Parameters<typeof flushRateStateFeedbackViaAppRuntime>[1],
+    signal: AbortSignal,
+  ): Promise<void>;
   validate?(
     input: Parameters<typeof validateRateStateViaAppRuntime>[1],
   ): ReturnType<typeof validateRateStateViaAppRuntime>;
@@ -87,6 +93,8 @@ function contextRatePort(context: WorkerRuntimeApiContext): AppRuntimeRatePort {
     acquire: (input) => acquireRateStateViaAppRuntime(context, input),
     release: (input) => releaseRateStateViaAppRuntime(context, input),
     penalize: (input) => penalizeRateStateViaAppRuntime(context, input),
+    flushFeedback: (input, signal) =>
+      flushRateStateFeedbackViaAppRuntime(context, input, signal),
     validate: (input) => validateRateStateViaAppRuntime(context, input),
   };
 }
@@ -296,6 +304,16 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
   private readonly effectiveRps = new Map<string, number>();
   private readonly pendingSuccesses = new Map<string, number>();
   private readonly successFeedbackFlights = new Map<string, SuccessFeedback>();
+  private readonly successFeedbackScopes = new Map<
+    string,
+    {
+      bucketId: string;
+      rateScopeToken?: string | null;
+      rules: readonly PacingRule[];
+    }
+  >();
+  private readonly successFeedbackSupported = new Set<string>();
+  private successFeedbackDrain: Promise<void> | null = null;
   /**
    * Completion samples travel with the next lease refill. This keeps the
    * Gradient2 checkpoint current without adding one gateway request per row.
@@ -1073,6 +1091,11 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
             }
           : rawResponse;
         this.acknowledgeSuccessFeedback(successKey, feedback);
+        if (response.successFeedbackSupported === true) {
+          this.successFeedbackSupported.add(bucketId);
+        } else {
+          this.successFeedbackSupported.delete(bucketId);
+        }
         this.recordCooldown(bucketId, response);
         if (response.scopeValidationSupported === true)
           this.validationScopes.add(bucketId);
@@ -1559,11 +1582,17 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
 
   observeSuccess(input: {
     bucketId: string;
+    rateScopeToken?: string | null;
     rules: readonly PacingRule[];
     latencyMs?: number | null;
   }): void {
     this.providerStalls.delete(input.bucketId);
     const key = pendingSuccessKey(input.bucketId, input.rules);
+    this.successFeedbackScopes.set(key, {
+      bucketId: input.bucketId,
+      rateScopeToken: input.rateScopeToken,
+      rules: input.rules,
+    });
     this.pendingSuccesses.set(
       key,
       Math.min(1_000_000, (this.pendingSuccesses.get(key) ?? 0) + 1),
@@ -1593,6 +1622,43 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
     this.pendingConcurrencyObservations.set(key, pending);
   }
 
+  async flushSuccessFeedback(): Promise<void> {
+    if (!this.port.flushFeedback) return;
+    if (this.successFeedbackDrain) return await this.successFeedbackDrain;
+    const signal = AbortSignal.timeout(SUCCESS_FEEDBACK_DRAIN_TIMEOUT_MS);
+    const drain = async () => {
+      for (const [key, scope] of this.successFeedbackScopes) {
+        // Older receivers retain their existing piggyback behavior. An explicit
+        // capability and matching batch acknowledgement protect rolling deploys.
+        if (!this.successFeedbackSupported.has(scope.bucketId)) continue;
+        for (;;) {
+          if (signal.aborted) throw abortReason(signal);
+          const feedback = this.snapshotSuccessFeedback(key);
+          if (!feedback.concurrencyObservationBatch) break;
+          await this.port.flushFeedback!(
+            {
+              ...scope,
+              rules: [...scope.rules],
+              leaseIds: [],
+              ...feedback,
+              schedulerSchema: this.schedulerSchema,
+            },
+            signal,
+          );
+          // A lost response leaves this exact frozen payload available to retry.
+          this.acknowledgeSuccessFeedback(key, feedback);
+        }
+        this.successFeedbackScopes.delete(key);
+      }
+    };
+    this.successFeedbackDrain = drain();
+    try {
+      await this.successFeedbackDrain;
+    } finally {
+      this.successFeedbackDrain = null;
+    }
+  }
+
   private newPendingConcurrencyObservations(
     key: string,
     observations: Array<{ kind: 'success'; latencyMs: number }> = [],

package/dist/bundling-sources/shared_libs/play-runtime/governor/governor.ts

@@ -868,6 +868,7 @@ export function createPlayExecutionGovernor(
         if (!rules) return;
         input.rateState.observeSuccess?.({
           bucketId: rateScope[0],
+          ...(rateScope[1] ? { rateScopeToken: rateScope[1] } : {}),
           rules,
           latencyMs: success.latencyMs,
         });

package/dist/bundling-sources/shared_libs/play-runtime/governor/rate-state-backend.ts

@@ -197,6 +197,9 @@ export interface RateStateBackend {
     /** Provider residence measured at the HTTP boundary. */
     latencyMs?: number | null;
   }): void;
+
+  /** Bounded final feedback write after the invocation's provider work settles. */
+  flushSuccessFeedback?(): Promise<void>;
 }
 
 const NOOP_PERMIT: PacingPermit = {

package/dist/bundling-sources/shared_libs/play-runtime/protocol.ts

@@ -90,6 +90,8 @@ export type PlayRunnerRateStateAcquireResult = {
   scopeValidationSupported?: boolean;
   /** This gateway rechecks signed provider permits on integration execute. */
   dispatchValidationSupported?: boolean;
+  /** This receiver acknowledges replay-safe success batches on release. */
+  successFeedbackSupported?: boolean;
   /**
    * Gateway clock used to produce `scheduledAtMs`. Runners translate the
    * schedule into relative delays so cross-machine clock skew cannot compress
@@ -138,6 +140,10 @@ export type PlayRunnerRateStateReleaseInput = {
   leaseIds: string[];
   /** Idempotently refund rate reservations that never reached provider fetch. */
   refundReservationIds?: string[];
+  /** Flush confirmed outcomes without reserving another provider permit. */
+  observedSuccesses?: number;
+  concurrencyObservations?: PlayRunnerRateStateConcurrencyObservation[];
+  concurrencyObservationBatch?: PlayRunnerRateStateConcurrencyObservationBatch;
   schedulerSchema?: string | null;
 };
 

package/dist/bundling-sources/shared_libs/play-runtime/runner-app/index.ts

@@ -3788,6 +3788,19 @@ async function run(
   } finally {
     clearInterval(workCounterTimer);
     emitWorkCounters();
+    try {
+      await rateStateBackend.rateState?.flushSuccessFeedback?.();
+    } catch (feedbackError) {
+      // Feedback is advisory: preserve the Play's result or original failure.
+      emitWorkerLog(
+        `[warn] runtime.provider_success_feedback_flush_failed: ${
+          feedbackError instanceof Error
+            ? feedbackError.message
+            : String(feedbackError)
+        }`,
+        options,
+      );
+    }
   }
 }
 

package/dist/bundling-sources/shared_libs/play-runtime/sandbox-compute-usage.ts

@@ -88,6 +88,9 @@ export function resolveRuntimeSandboxComputeItems(input: {
         sandboxId,
         startedAt: resource.startedAt,
         endedAt,
+        maxBillingDurationSeconds: resource.maxBillingDurationSeconds,
+        observedWallTimeSeconds:
+          Math.max(0, observedEndedAt - resource.startedAt) / 1_000,
       }),
     );
   }
@@ -201,6 +204,9 @@ export function resolveDaytonaRuntimeComputeItems(input: {
         sandboxId,
         startedAt: resource.startedAt,
         endedAt,
+        maxBillingDurationSeconds: resource.maxBillingDurationSeconds,
+        observedWallTimeSeconds:
+          Math.max(0, observedEndedAt - resource.startedAt) / 1_000,
       }),
     );
   }

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

@@ -38,6 +38,26 @@ const RATE_SCOPE_HOLD_TABLE = 'rate_scope_holds';
 const PHYSICAL_DISPATCH_RULE_ID = 'runtime:physical-dispatch';
 
 const MIN_CONCURRENCY_WAIT_MS = 10;
+/**
+ * Longest re-ask when every concurrency slot is taken. A full scope re-asks
+ * about when its next slot should free: the average age of its live leases
+ * divided by their count. A fast provider stays at the 10 ms floor; one whose
+ * calls hold a slot for minutes no longer re-locks its scope row every 10 ms.
+ * On 2026-11-06 five such runs re-asked about 160 times a second for hours.
+ */
+const MAX_CONCURRENCY_WAIT_MS = 1_000;
+/**
+ * A healthy scope lock is held for milliseconds. An acquire that cannot get it
+ * within this budget stops waiting on the server instead of leaving a backend
+ * queued behind a stuck holder after its caller gave up. On 2026-11-06 one
+ * stuck holder queued such abandoned waits for 16 minutes until they exhausted
+ * the shared scheduler pool.
+ */
+const RATE_STATE_LOCK_TIMEOUT_MS = 3_000;
+/** Ends a bounded acquire statement before the gateway's 30 s caller budget. */
+const RATE_STATE_STATEMENT_TIMEOUT_MS = 15_000;
+/** Re-ask after a lock timeout, as for any other busy scope. */
+const RATE_STATE_LOCK_BUSY_WAIT_MS = 1_000;
 /**
  * Longest a requester held back by the fair-share cap sleeps before it re-asks.
  * The natural wait is the rest of the current fair-share window (a sibling's
@@ -771,6 +791,32 @@ async function seedBucketRows(
   },
   seeds: RateBucketSeed[],
   nowMs: number | null,
+): Promise<void> {
+  // Cold path only, so its own bounded transaction costs two round trips once
+  // per bucket per process. Its insert waits on the same scope row as a grant.
+  await client.query('BEGIN');
+  try {
+    await boundRateStateTransaction(client);
+    await seedBucketRowsStatement(client, input, seeds, nowMs);
+    await client.query('COMMIT');
+  } catch (error) {
+    try {
+      await client.query('ROLLBACK');
+    } catch {
+      // Preserve the original seed/storage error.
+    }
+    throw rateStateLockBusyOr(error);
+  }
+}
+
+async function seedBucketRowsStatement(
+  client: PostgresSchedulerQueryClient,
+  input: { bucketId: string } & {
+    schema?: string | null;
+    schedulerSchema?: string | null;
+  },
+  seeds: RateBucketSeed[],
+  nowMs: number | null,
 ): Promise<void> {
   await client.query(
     `
@@ -1797,6 +1843,7 @@ async function acquireWithConcurrency(
   while (true) {
     await client.query('BEGIN ISOLATION LEVEL READ COMMITTED');
     try {
+      await boundRateStateTransaction(client);
       await client.query(
         `SELECT bucket_id FROM ${scopeHoldTableName(input)}
        WHERE bucket_id = $1 FOR UPDATE`,
@@ -1824,11 +1871,53 @@ async function acquireWithConcurrency(
         probeBaselineSupported = false;
         continue;
       }
-      throw error;
+      throw rateStateLockBusyOr(error);
     }
   }
 }
 
+/**
+ * Bound the current rate-state transaction. `SET LOCAL` keeps the limits inside
+ * this transaction: the scheduler pool runs behind PgBouncer transaction
+ * pooling, where a session setting would leak to another caller.
+ */
+async function boundRateStateTransaction(
+  client: PostgresSchedulerQueryClient,
+): Promise<void> {
+  await client.query(
+    `SELECT set_config('lock_timeout', $1, true),
+            set_config('statement_timeout', $2, true)`,
+    [`${RATE_STATE_LOCK_TIMEOUT_MS}ms`, `${RATE_STATE_STATEMENT_TIMEOUT_MS}ms`],
+  );
+}
+
+/** A scope row another transaction still holds after the lock budget. */
+class RateStateLockBusyError extends Error {
+  constructor(cause: unknown) {
+    super('Rate-state scope lock was not available within its budget.', {
+      cause,
+    });
+    this.name = 'RateStateLockBusyError';
+  }
+}
+
+/**
+ * A bounded rate-state transaction that ran out of its lock or statement
+ * budget (57014 is statement_timeout).
+ */
+function isRateStateBusy(error: unknown): boolean {
+  return (
+    error instanceof RateStateLockBusyError ||
+    (error as { code?: unknown } | null)?.code === '57014'
+  );
+}
+
+function rateStateLockBusyOr(error: unknown): unknown {
+  return (error as { code?: unknown } | null)?.code === '55P03'
+    ? new RateStateLockBusyError(error)
+    : error;
+}
+
 async function grantWithConcurrency(
   client: PostgresSchedulerQueryClient,
   input: RateStateAcquireInput,
@@ -2315,7 +2404,29 @@ async function grantWithConcurrency(
               (SELECT cool_until_ms FROM cooling),
               (SELECT retry_at_ms FROM cooling)
             ) - (SELECT now_ms FROM refreshed LIMIT 1)${fair?.waitBranch ?? ''}
-          WHEN (SELECT free FROM free_slots) <= 0 THEN $7::bigint
+          WHEN (SELECT free FROM free_slots) <= 0 THEN (
+            -- Re-ask about when the next slot should free. Leases are never
+            -- renewed, so a lease's age is its TTL minus its remaining life.
+            SELECT LEAST(
+              ${MAX_CONCURRENCY_WAIT_MS}::bigint,
+              GREATEST(
+                $7::bigint,
+                CEIL(
+                  COALESCE(
+                    AVG(
+                      (SELECT now_ms FROM now_value)
+                        - (cl.expires_at_ms - $8::bigint)
+                    ),
+                    0
+                  ) / GREATEST((SELECT active_count FROM concurrency_context), 1)
+                )::bigint
+              )
+            )
+            FROM ${concurrencyLeaseTableName(input)} cl
+            WHERE cl.bucket_id = $1
+              AND cl.rule_id = ANY($5::text[])
+              AND cl.expires_at_ms > (SELECT now_ms FROM now_value)
+          )
           ELSE LEAST((SELECT pending_recovery_wait_ms FROM provider_hold), (
             SELECT CEIL(
               MAX(
@@ -2417,9 +2528,24 @@ export async function acquirePostgresRateState(
   client: PostgresSchedulerQueryClient,
   input: RateStateAcquireInput,
 ): Promise<PlayRunnerRateStateAcquireResult> {
-  return await withRateStateAvailabilityGuard(input, () =>
-    acquireRateStateStatements(client, input),
-  );
+  return await withRateStateAvailabilityGuard(input, async () => {
+    try {
+      return await acquireRateStateStatements(client, input);
+    } catch (error) {
+      // A store error spends the runner's fail-closed retry ladder, so a stuck
+      // holder elsewhere would fail this run. A busy scope is not a broken
+      // store: answer as for any other wait. Feedback rolled back with a busy
+      // feedback step is not re-sent, because the runner acknowledges any
+      // answer. A lost success sample only slows the next ramp, and its batch
+      // identity still prevents a double apply.
+      if (!(error instanceof RateStateLockBusyError)) throw error;
+      return {
+        granted: 0,
+        waitMs: RATE_STATE_LOCK_BUSY_WAIT_MS,
+        leaseIds: [],
+      };
+    }
+  });
 }
 
 /**
@@ -2838,6 +2964,8 @@ async function applyConcurrencyObservations(
   rules: readonly AcquirePacingRule[],
   observations: readonly ConcurrencyObservation[],
   batch: ConcurrencyObservationBatch | null,
+  /** Acquire bounds its lock waits; release and penalty keep their behaviour. */
+  options: { bounded?: boolean } = {},
 ): Promise<{
   disposition: 'unbatched' | 'applied' | 'already_applied';
   ruleCount: number;
@@ -2895,6 +3023,7 @@ async function applyConcurrencyObservations(
 
   await client.query('BEGIN');
   try {
+    if (options.bounded) await boundRateStateTransaction(client);
     const accepted = await client.query<{ last_sequence: number }>(
       `
         WITH now_value AS (
@@ -3103,7 +3232,7 @@ async function applyConcurrencyObservations(
     } catch {
       // Preserve the original controller/storage error.
     }
-    throw error;
+    throw options.bounded ? rateStateLockBusyOr(error) : error;
   }
 }
 
@@ -3143,6 +3272,7 @@ async function acquireRateStateStatements(
     rules,
     concurrencyObservationsFrom(input.concurrencyObservations),
     concurrencyObservationBatchFrom(input.concurrencyObservationBatch),
+    { bounded: true },
   );
   // The buffered success count and RTT observations share one identity. If a
   // runner lost the prior acquire response, its retry still needs a fresh
@@ -3179,7 +3309,16 @@ async function acquireRateStateStatements(
     // so a row widened out of band is repaired here instead of waiting for a
     // process restart. Repairing after the grant keeps the acquire itself to a
     // single granting statement, so no permit is ever issued twice.
-    await seedBucketRows(client, input, seeds, nowMs);
+    try {
+      await seedBucketRows(client, input, seeds, nowMs);
+    } catch (error) {
+      // The grant above already committed. A busy scope must not turn its
+      // leases into a zero answer the runner never releases. Leave the bucket
+      // cold so the next acquire repairs before it grants.
+      if (!isRateStateBusy(error)) throw error;
+      warmRateBuckets.delete(warmKey);
+      return acquireResultOf(outcome);
+    }
   }
   markRateBucketWarm(warmKey);
   return acquireResultOf(outcome);
@@ -3199,6 +3338,27 @@ async function releaseRateStateStatements(
   input: PlayRunnerRateStateReleaseInput & { nowMs?: number },
 ): Promise<void> {
   const allRules = normalizeRules(input.rules as AcquirePacingRule[]);
+  if (
+    input.observedSuccesses !== undefined ||
+    input.concurrencyObservations !== undefined ||
+    input.concurrencyObservationBatch !== undefined
+  ) {
+    const batch = concurrencyObservationBatchFrom(
+      input.concurrencyObservationBatch,
+    );
+    if (!batch) {
+      throw new Error(
+        'Rate-state success feedback requires a replay-safe observation batch.',
+      );
+    }
+    await applyConcurrencyObservations(
+      client,
+      input,
+      allRules,
+      concurrencyObservationsFrom(input.concurrencyObservations),
+      batch,
+    );
+  }
   if (allRules.length === 0) return;
   const refundReservationIds = [
     ...new Set(

package/dist/bundling-sources/shared_libs/play-runtime/worker-api-types.ts

@@ -98,6 +98,32 @@ function sandboxSizeMetadata(cpu: number, memoryGiB: number) {
   return entry ? { sandboxSize: entry[0] } : {};
 }
 
+/**
+ * Lets settlement tell a run that used its declared runtime from a duration no
+ * runtime limit explains. Billed time stops at the ceiling, so the unclamped
+ * duration travels beside it: without it an overrun looks like a run that
+ * stayed inside its limit. Items without a ceiling keep their historical shape.
+ */
+function runtimeLimitMetadata(
+  maxBillingDurationSeconds: number | null | undefined,
+  observedWallTimeSeconds: number | undefined,
+) {
+  if (
+    typeof maxBillingDurationSeconds !== 'number' ||
+    !Number.isFinite(maxBillingDurationSeconds) ||
+    maxBillingDurationSeconds <= 0
+  ) {
+    return {};
+  }
+  return {
+    maxBillingDurationSeconds,
+    ...(typeof observedWallTimeSeconds === 'number' &&
+    Number.isFinite(observedWallTimeSeconds)
+      ? { observedWallTimeSeconds: Math.max(0, observedWallTimeSeconds) }
+      : {}),
+  };
+}
+
 export function resolveDaytonaSandboxComputeItem(input: {
   itemId: string;
   source?: string;
@@ -108,6 +134,10 @@ export function resolveDaytonaSandboxComputeItem(input: {
   sandboxId?: string | null;
   startedAt?: number;
   endedAt?: number;
+  /** The resource's own billing ceiling: its timeout plus terminal grace. */
+  maxBillingDurationSeconds?: number | null;
+  /** Wall time before the ceiling clamped it; recorded only with a ceiling. */
+  observedWallTimeSeconds?: number;
 }): ComputeBillingItem {
   const billableSeconds = Math.max(1, Math.ceil(input.wallTimeSeconds));
   const cpu = Math.max(0, input.cpu);
@@ -138,6 +168,10 @@ export function resolveDaytonaSandboxComputeItem(input: {
       billableDiskGiB,
       startedAt: input.startedAt,
       endedAt: input.endedAt,
+      ...runtimeLimitMetadata(
+        input.maxBillingDurationSeconds,
+        input.observedWallTimeSeconds,
+      ),
     },
   };
 }
@@ -152,6 +186,10 @@ export function resolveModalSandboxComputeItem(input: {
   sandboxId?: string | null;
   startedAt?: number;
   endedAt?: number;
+  /** The resource's own billing ceiling: its timeout plus terminal grace. */
+  maxBillingDurationSeconds?: number | null;
+  /** Wall time before the ceiling clamped it; recorded only with a ceiling. */
+  observedWallTimeSeconds?: number;
 }): ComputeBillingItem {
   const billableSeconds = Math.max(1, Math.ceil(input.wallTimeSeconds));
   const physicalCpuCores = Math.max(0, input.physicalCpuCores);
@@ -186,6 +224,10 @@ export function resolveModalSandboxComputeItem(input: {
           }),
       startedAt: input.startedAt,
       endedAt: input.endedAt,
+      ...runtimeLimitMetadata(
+        input.maxBillingDurationSeconds,
+        input.observedWallTimeSeconds,
+      ),
     },
   };
 }

package/dist/cli/auth-QITP34OX.js

@@ -0,0 +1,41 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkCH4VMDB5js = require('./chunk-CH4VMDB5.js');
+require('./chunk-M2UL4ZS5.js');
+require('./chunk-NC52JG66.js');
+require('./chunk-ACDXGOXE.js');
+require('./chunk-ALJJRZNJ.js');
+require('./chunk-XNYIZMNQ.js');
+require('./chunk-DIAWYWT5.js');
+require('./chunk-6KKDIISC.js');
+require('./chunk-OG64RBAC.js');
+require('./chunk-COGTRVWW.js');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.EXIT_WORKSPACE_MISMATCH = _chunkCH4VMDB5js.EXIT_WORKSPACE_MISMATCH; exports.authStatusLine = _chunkCH4VMDB5js.authStatusLine; exports.clearPendingClaim = _chunkCH4VMDB5js.clearPendingClaim; exports.clearSatisfiedPendingClaim = _chunkCH4VMDB5js.clearSatisfiedPendingClaim; exports.handleRegister = _chunkCH4VMDB5js.handleRegister; exports.handleStatus = _chunkCH4VMDB5js.handleStatus; exports.handleWait = _chunkCH4VMDB5js.handleWait; exports.httpJson = _chunkCH4VMDB5js.httpJson; exports.readPendingAuthClaim = _chunkCH4VMDB5js.readPendingAuthClaim; exports.readStatusBanner = _chunkCH4VMDB5js.readStatusBanner; exports.registerAuthCommands = _chunkCH4VMDB5js.registerAuthCommands; exports.reportSetupCompleted = _chunkCH4VMDB5js.reportSetupCompleted; exports.resolvePendingAuthClaimForResume = _chunkCH4VMDB5js.resolvePendingAuthClaimForResume; exports.statusBannerLine = _chunkCH4VMDB5js.statusBannerLine;

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

@@ -13,14 +13,14 @@ import {
   reportSetupCompleted,
   resolvePendingAuthClaimForResume,
   statusBannerLine
-} from "./chunk-CFSCHLNQ.mjs";
-import "./chunk-NTJDZURV.mjs";
-import "./chunk-ZOXV6WFI.mjs";
-import "./chunk-FVPT44IJ.mjs";
+} from "./chunk-6IJJCRE5.mjs";
+import "./chunk-QODW5ILA.mjs";
+import "./chunk-YZA5UJXM.mjs";
+import "./chunk-LJYTYNQZ.mjs";
 import "./chunk-4QF2K7TM.mjs";
 import "./chunk-DLIRSHV6.mjs";
 import "./chunk-HBL4PM5Q.mjs";
-import "./chunk-UHTJWDYB.mjs";
+import "./chunk-PQQNMMWM.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";
 export {