deepline 0.3.475 → 0.3.476

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

@@ -185,8 +185,8 @@ export type PlayFetchResponse = PlayAuthoringFetchResponse;
  *   The changed row is delivered as the listener event's `after` in the play function's input.
  *
  * The default Play runtime is 30 minutes with the `standard` 1 GiB / 1 CPU
- * profile. Preview deployments also support `large` (4 GiB / 2 CPU) and
- * `xlarge` (8 GiB / 4 CPU) through `runtime.size`. Production uses `standard`.
+ * profile. Select `large` (4 GiB / 2 CPU) or `xlarge` (8 GiB / 4 CPU)
+ * through `runtime.size` when a step needs more memory.
  * Compute pricing follows the workspace plan; use `deepline billing quote`
  * for the session ceiling.
  * Set `runtime.timeout` for longer bounded runs; duration values are whole

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.475',
+  version: '0.3.476',
   updateSummary: {
     introducedIn: '0.3.90',
     summary:
@@ -252,9 +252,9 @@ export const SDK_RELEASE = {
       },
       {
         command: 'search',
-        introducedIn: '0.3.91',
+        introducedIn: '0.3.287',
         reason:
-          'deepline search was added in SDK CLI 0.3.91 as the one search across tools, monitors, and plays. On an older version run deepline tools search or deepline plays search, or update.',
+          'deepline search was added in SDK CLI 0.3.287 as the one search across tools, monitors, and plays. On an older version run deepline tools search or deepline plays search, or update.',
       },
       {
         command: 'notifications',

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

@@ -46,8 +46,9 @@ type ProviderMonitorUpstreamIdentityDefinition = {
    * Payload fields that never change which findings the provider resource
    * delivers. `updates_since` only sets how far back the first delivery
    * replays, so two monitors that differ only there watch the same feed.
-   * Claim keys written before this list existed still carry these fields;
-   * readers resolve them through `canonicalProviderMonitorIdentityClaimKey`.
+   * New claim keys omit them. Keys stored before that still carry them until
+   * the `normalizeProviderMonitorIdentityClaimKeys` migration rewrites them;
+   * readers resolve both through `canonicalProviderMonitorIdentityClaimKey`.
    */
   nonConfigurationFields?: readonly string[];
 };
@@ -171,9 +172,11 @@ export function providerMonitorUpstreamIdentitySignature(
 /**
  * Exact claim identity used by the Convex conflict index. The provider's
  * declared scope remains visible in `scopeKey`; providers that allow
- * configuration variants add every non-scope payload field to the claim key.
- * Keeping the old scope JSON as the prefix lets readers recognize claims
- * created before this distinction was introduced.
+ * configuration variants add every non-scope payload field to the claim key,
+ * except `nonConfigurationFields`. Keeping the old scope JSON as the prefix
+ * lets readers recognize claims created before this distinction was
+ * introduced. The result is always canonical
+ * (`canonicalProviderMonitorIdentityClaimKey` returns it unchanged).
  */
 export function providerMonitorUpstreamIdentityClaimKey(
   tool: string,
@@ -206,9 +209,10 @@ export function providerMonitorUpstreamIdentityClaimKey(
         : []),
     ]),
   );
+  const ignored = new Set(definition.nonConfigurationFields ?? []);
   const configuration = Object.fromEntries(
     Object.entries(payload ?? {}).filter(
-      ([field]) => !scopeAndAliases.has(field),
+      ([field]) => !scopeAndAliases.has(field) && !ignored.has(field),
     ),
   );
   if (Object.keys(configuration).length === 0) return scopeKey;
@@ -275,6 +279,15 @@ export function canonicalProviderMonitorIdentityClaimKey(
   return `${parts.scopeKey}${CONFIGURATION_SEPARATOR}${stableJson(configuration)}`;
 }
 
+/**
+ * The scope part of a stored claim key: the whole key when it is scope-only.
+ * Every key for one provider scope starts with this exact JSON object, so it
+ * bounds an index range over that scope's claims.
+ */
+export function providerMonitorIdentityClaimScopeKey(identityKey: string) {
+  return splitClaimKey(identityKey)?.scopeKey ?? identityKey;
+}
+
 /** Whether a claim key carries configuration beyond its scope. */
 export function providerMonitorIdentityClaimKeyHasConfiguration(
   identityKey: string,

package/dist/bundling-sources/shared_libs/observability/scheduled-jobs.json

@@ -241,7 +241,7 @@
     "id": "github.eval-agent-cli-matrix",
     "name": "Eval Agent CLI Matrix",
     "scheduler": "github_actions",
-    "cadence": "0 7 * * *",
+    "cadence": "0 7 * * *; 0 22 * * 4; 0 3 * * 1,3,5",
     "timezone": "America/New_York",
     "source": ".github/workflows/eval-agent-cli-matrix.yml",
     "locator": "schedule:",
@@ -265,9 +265,9 @@
     "locator": "schedule:",
     "owner": "platform",
     "criticality": "maintenance",
-    "purpose": "Reconcile completed PR Preview Machines and release capacity only after the per-app lease fence allows it. Its named-estate lane plans every named Preview estate (eval reuse keys, runtime up preview branch lanes, one-off namespaces) with `bun scripts/fly-preview-estate-lifecycle.ts --report --named-reclaim-plan` and, only on a workflow_dispatch with reclaim_named_estates=true, scales at most 8 planned estates per pass (interrupted reclaims first, then reclaimable estates idle 24 h by lease, release or reclaim evidence) to zero through the claimed runtime-preview-namespace.yml scale-to-zero, recording the start and lane app before the seam, retiring the release lane and recording reclaimed history; scheduled passes only report it.",
-    "successDefinition": "Fly inventory is reconciled and eligible terminal/closed PR capacity is released; every named estate is classified without a read failure, and a dispatched named reclaim leaves each target at zero Machines with its release lane retired and reclaimed history written. No eligible app or estate is a valid no-op.",
-    "failureDefinition": "Inventory, lease resolution, scale-down, or empty-app cleanup fails or is ambiguous; a named-estate Fly or authority read fails; a named reclaim is refused inside its claim (active owner, used since discovery, ownership or lane-app refusal) or any role keeps a Machine; or any named reclaim is incomplete (started but its release lane was never retired), which fails every pass until a dispatch finishes it.",
+    "purpose": "Reconcile completed PR Preview Machines and release capacity only after the per-app lease fence allows it. Its named-estate lane plans every named Preview estate (eval reuse keys, runtime up preview branch lanes, one-off namespaces) with `bun scripts/fly-preview-estate-lifecycle.ts --report --named-reclaim-plan` and, only on a workflow_dispatch with reclaim_named_estates=true, scales at most 8 planned estates per pass (interrupted reclaims first, then reclaimable estates idle 24 h by lease, release or reclaim evidence) to zero through the claimed runtime-preview-namespace.yml scale-to-zero, recording the start and lane app before the seam, retiring the release lane and recording reclaimed history; scheduled passes only report it. Each pass also returns the deeplinev1/load PlanetScale branch to its parked size when no Customer Workload Suite run is active on load-tests/framework, in case a load test's own teardown never ran.",
+    "successDefinition": "Fly inventory is reconciled and eligible terminal/closed PR capacity is released; every named estate is classified without a read failure, and a dispatched named reclaim leaves each target at zero Machines with its release lane retired and reclaimed history written. No eligible app or estate is a valid no-op. The load database is parked, a change toward that size is in flight, or an active Customer Workload Suite run on load-tests/framework may be holding it.",
+    "failureDefinition": "Inventory, lease resolution, scale-down, or empty-app cleanup fails or is ambiguous; a named-estate Fly or authority read fails; a named reclaim is refused inside its claim (active owner, used since discovery, ownership or lane-app refusal) or any role keeps a Machine; or any named reclaim is incomplete (started but its release lane was never retired), which fails every pass until a dispatch finishes it; or reading or parking the load database fails.",
     "startGraceMs": 600000,
     "runTimeoutMs": 3600000,
     "failureAlert": "github_workflow_run",

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

@@ -790,6 +790,13 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
   ): void {
     if (retryAtMs <= (this.localProviderRetryAtMs.get(bucketId) ?? 0)) return;
     this.localProviderRetryAtMs.set(bucketId, retryAtMs);
+    const cadence = this.validatedDispatchCadences.get(bucketId);
+    const serverOffsetMs = this.serverClockOffsetsMs.get(bucketId) ?? 0;
+    // A new hold fences old tickets and their dispatch debt. Keep debt from
+    // sends after an expired hold; their physical spacing is still current.
+    if (cadence && cadence.lastAtMs + serverOffsetMs <= retryAtMs) {
+      this.validatedDispatchCadences.delete(bucketId);
+    }
     for (const waiting of this.scheduledPermitWaits.get(bucketId) ?? []) {
       if (waiting.retryAtMsAtGrant < retryAtMs) waiting.invalidate();
     }
@@ -1626,6 +1633,14 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
       scopeRetryAtMsAtGrant,
       dispatchValidationSupported,
     ] = scheduled;
+    // Legacy grants have no shared hold snapshot. Capture their local fence
+    // when assigned, while keeping the signed gateway proof unchanged.
+    const localRetryAtMsAtGrant = this.validationScopes.has(bucketId)
+      ? scopeRetryAtMsAtGrant
+      : Math.max(
+          scopeRetryAtMsAtGrant,
+          this.localProviderRetryAtMs.get(bucketId) ?? 0,
+        );
     let settled = false;
     const refund = async (): Promise<void> => {
       if (!reservationId) {
@@ -1732,7 +1747,15 @@ export class AppRuntimeRateStateBackend implements RateStateBackend {
                 });
               }
               if (waitMs > 0) {
-                await this.sleep(waitMs, signal);
+                if (
+                  !(await this.waitForScheduledPermit(
+                    bucketId,
+                    localRetryAtMsAtGrant,
+                    waitMs,
+                    signal,
+                  ))
+                )
+                  return false;
                 continue;
               }
               this.validatedDispatchCadences.set(bucketId, {

package/dist/bundling-sources/shared_libs/play-runtime/play-run-recovery-policy.ts

@@ -72,11 +72,14 @@ export type PlayRunRecoveryDecision = Readonly<{
 export class PlayRunRecoveryError extends Error {
   readonly decision: PlayRunRecoveryDecision;
   readonly cause?: unknown;
+  /** Log-only provider facts; see `playRunRecoveryLogDetail`. */
+  readonly recoveryLogDetail?: unknown;
 
   constructor(input: {
     decision: PlayRunRecoveryDecision;
     message: string;
     cause?: unknown;
+    recoveryLogDetail?: unknown;
   }) {
     super(input.message);
     this.name = PLAY_RUN_RECOVERY_ERROR_NAME;
@@ -84,6 +87,9 @@ export class PlayRunRecoveryError extends Error {
     if (input.cause !== undefined) {
       this.cause = input.cause;
     }
+    if (input.recoveryLogDetail !== undefined) {
+      this.recoveryLogDetail = input.recoveryLogDetail;
+    }
   }
 }
 
@@ -106,7 +112,7 @@ export type PlayRunRecoveryLogDetail = Readonly<
 >;
 
 /**
- * Provider facts an adapter attached to the cause of a recovery error, for the
+ * Provider facts an adapter attached to a recovery error or its cause, for the
  * scheduler's defer log only. The decision's `reason` stays the single durable
  * recovery fact: this detail is never persisted, never returned to a caller,
  * and never read to choose a recovery action. It is bounded here, at the edge
@@ -119,9 +125,11 @@ export function playRunRecoveryLogDetail(
   try {
     if (!isPlayRunRecoveryError(error)) return null;
     const cause: unknown = error.cause;
-    if (!cause || typeof cause !== 'object') return null;
-    const supplied = (cause as { recoveryLogDetail?: unknown })
-      .recoveryLogDetail;
+    const supplied =
+      error.recoveryLogDetail ??
+      (cause && typeof cause === 'object'
+        ? (cause as { recoveryLogDetail?: unknown }).recoveryLogDetail
+        : undefined);
     if (!supplied || typeof supplied !== 'object' || Array.isArray(supplied)) {
       return null;
     }
@@ -203,6 +211,14 @@ export function recoveryForModalSandboxCreateFailure(
   const code = errorCode(error);
   const status = errorStatus(error);
   const message = messageOf(error);
+  // Only this rejection carries Modal's own words. Once it opens the circuit,
+  // later runs defer without calling Modal, and every reason here groups
+  // several provider conditions.
+  const recoveryLogDetail = {
+    providerCode: code,
+    providerStatus: status,
+    providerMessage: message,
+  };
   const resourceExhausted =
     code === 8 ||
     (typeof code === 'string' && /RESOURCE_EXHAUSTED/i.test(code)) ||
@@ -218,6 +234,7 @@ export function recoveryForModalSandboxCreateFailure(
       message:
         'Modal sandbox capacity is unavailable before customer execution began.',
       cause: error,
+      recoveryLogDetail,
     });
   }
 

package/dist/bundling-sources/shared_libs/play-runtime/runtime-capacity-policy.ts

@@ -56,8 +56,20 @@ export const RUNTIME_CAPACITY_POLICY = {
     maxScaleDownMachinesPerReconcile: 2,
     /** Empty relay capacity must be quiet before it is reclaimed. */
     scaleDownQuietMs: 120_000,
+    /**
+     * Pooled Postgres clients per relay Machine when
+     * DEEPLINE_RUNTIME_GATEWAY_POOL_MAX_CLIENTS sets none, as in production.
+     * packages/runtime-gateway/server.ts explains the budget.
+     */
+    poolMaxClients: 6,
   },
   receiptGateway: {
+    /**
+     * Pooled Postgres clients per receipt-gateway Machine when
+     * DEEPLINE_RUNTIME_GATEWAY_POOL_MAX_CLIENTS sets none, as in production.
+     * packages/runtime-gateway/server.ts explains the budget.
+     */
+    poolMaxClients: 8,
     admissionTimeoutMs: 10_000,
     /** End identical receipt-row work before the caller can overlap a retry. */
     claimOperationTimeoutMs: 20_000,

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

@@ -72,7 +72,7 @@ export function acquireRateScopeSql(
         THEN CASE WHEN ${productiveRecovery} THEN ${AIMD_RECOVERY_STEP_MS}
           ELSE ${sparseRecoveryInterval} END
         ELSE LEAST(${floorRecoveryInterval}, CEIL(1000.0 / ${refillRate})) END`
-    : `LEAST(h.rate_recovery_interval_ms, ${AIMD_RECOVERY_STEP_MS})`;
+    : `${AIMD_RECOVERY_STEP_MS}`;
   // A local no-progress pause remains active after the provider's shorter
   // Retry-After. Only time beyond every outstanding dispatch/hold is idle.
   const observationWasIdle = `${successesParameter}::int = 0
@@ -202,13 +202,15 @@ export function updateRateScopeSql(
         ELSE ph.rate_probe_started_at_ms END,`
           : ''
       }
-      -- At the floor, a new successful epoch must not inherit failed-probe
-      -- backoff. Above the floor, retain its useful measurement duration for
-      -- sparse upward probes; that rate already proves successful recovery.
+      -- A productive known-provider epoch uses the one-second recovery window,
+      -- so its old measurement must not become a failed-probe streak when the
+      -- success counter resets. Unknown providers above the floor retain that
+      -- measurement for their separate sparse upward-probe policy.
       rate_recovery_interval_ms = CASE
-        WHEN ${unknownProvider} AND (SELECT granted FROM grant_calc) > 0
+        WHEN (SELECT granted FROM grant_calc) > 0
           AND ph.rate_successes > 0
-          AND ph.next_refill_per_sec <= ${DEFAULT_UNKNOWN_PROVIDER_MIN_RPS}
+          AND (${!unknownProvider}
+            OR ph.next_refill_per_sec <= ${DEFAULT_UNKNOWN_PROVIDER_MIN_RPS})
           AND (ph.observation_was_idle
             OR ph.rate_observation_started_at_ms IS NULL)
           -- Zero is an unmeasured new episode, not a failed-probe interval.

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;
@@ -19774,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'>,
@@ -21106,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.
@@ -23132,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-CFDYJ7FZ.mjs → auth-A22724UX.mjs}

@@ -13,14 +13,14 @@ import {
   reportSetupCompleted,
   resolvePendingAuthClaimForResume,
   statusBannerLine
-} from "./chunk-42F6LTBJ.mjs";
-import "./chunk-BVAYLXMH.mjs";
-import "./chunk-NGOKBSBH.mjs";
-import "./chunk-3QSFSHCJ.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-YAAQNDP6.mjs";
+import "./chunk-UHTJWDYB.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";
 export {

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

@@ -1,10 +1,10 @@
 import {
   DeeplineClient
-} from "./chunk-DIMKSDF6.mjs";
+} from "./chunk-NPNQCPFP.mjs";
 import {
   iterateCursorPages,
   requireBillingIdempotencyKey
-} from "./chunk-VFP3MFLD.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-BVAYLXMH.mjs";
-import "./chunk-NGOKBSBH.mjs";
-import "./chunk-3QSFSHCJ.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-YAAQNDP6.mjs";
+import "./chunk-UHTJWDYB.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";