deepline 0.3.349 → 0.3.351

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

@@ -200,7 +200,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.349',
+  version: '0.3.351',
   updateSummary:
     'Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.',
   packageCapabilities: {

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

@@ -8,6 +8,26 @@ import { stringifyPostgresJson } from '../postgres-json';
 
 const MAX_BUDGET_CHARGES_PER_REQUEST = 16;
 
+/** The caller sent a charge this request can never satisfy. Retrying is futile. */
+export class BudgetStateRequestError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'BudgetStateRequestError';
+  }
+}
+
+/**
+ * Only a limit or a malformed request is the budget's own answer. Anything
+ * else (a dropped connection, an aborted transaction) says nothing about the
+ * budget and must stay retryable.
+ */
+export function isBudgetStateRejection(error: unknown): boolean {
+  return (
+    error instanceof BudgetStateLimitError ||
+    error instanceof BudgetStateRequestError
+  );
+}
+
 function quoteIdent(value: string): string {
   return `"${value.replace(/"/g, '""')}"`;
 }
@@ -52,7 +72,7 @@ export async function ensurePostgresBudgetStateSchema(
 
 function normalizedCharges(input: PlayRunnerBudgetChargeInput) {
   if (input.charges.length > MAX_BUDGET_CHARGES_PER_REQUEST) {
-    throw new Error(
+    throw new BudgetStateRequestError(
       `Governor budget accepts at most ${MAX_BUDGET_CHARGES_PER_REQUEST} charges per request.`,
     );
   }
@@ -60,15 +80,17 @@ function normalizedCharges(input: PlayRunnerBudgetChargeInput) {
   for (const charge of input.charges) {
     const key = charge.key.trim();
     if (!key || key.length > 256) {
-      throw new Error('Governor budget key must be 1-256 characters.');
+      throw new BudgetStateRequestError(
+        'Governor budget key must be 1-256 characters.',
+      );
     }
     if (!Number.isSafeInteger(charge.amount) || charge.amount <= 0) {
-      throw new Error(
+      throw new BudgetStateRequestError(
         `Governor budget ${key} amount must be a positive integer.`,
       );
     }
     if (!Number.isSafeInteger(charge.limit) || charge.limit <= 0) {
-      throw new Error(
+      throw new BudgetStateRequestError(
         `Governor budget ${key} limit must be a positive integer.`,
       );
     }
@@ -108,7 +130,9 @@ export async function chargePostgresBudgetState(
   if (charges.length === 0) return { counters: {} };
   const reservationId = input.reservationId.trim();
   if (!reservationId || reservationId.length > 256) {
-    throw new Error('Governor budget reservationId must be 1-256 characters.');
+    throw new BudgetStateRequestError(
+      'Governor budget reservationId must be 1-256 characters.',
+    );
   }
   for (const charge of charges) {
     if (charge.amount > charge.limit) {
@@ -155,7 +179,7 @@ export async function chargePostgresBudgetState(
         throw new Error('Governor budget reservation disappeared.');
       }
       if (!sameCharges(reservation.charges_json, charges)) {
-        throw new Error(
+        throw new BudgetStateRequestError(
           'Governor budget reservationId was reused with different charges.',
         );
       }

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

@@ -608,7 +608,9 @@ export function isRuntimeSchedulerServerUnavailableError(
         code === '57P03' ||
         (code === '08P01' &&
           typeof message === 'string' &&
-          recoveryMessage.test(message.trim())) ||
+          (recoveryMessage.test(message.trim()) ||
+            // PgBouncer's exact report that its backend connection dropped.
+            message.trim() === 'server conn crashed?')) ||
         // Preserve legacy connection messages without accepting every 08* code.
         (legacyConnectionCode &&
           typeof message === 'string' &&

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

@@ -18182,6 +18182,33 @@ 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`;
 }
 
+/** Enumerate pending runs by index seeks, skipping each run's entire fact tail. */
+function runLedgerPendingRunsSql(
+  options?: Pick<PostgresSchedulerOptions, 'schema'>,
+  searchOnly?: boolean,
+): string {
+  const lane =
+    searchOnly === undefined
+      ? ''
+      : `AND ${searchLaneSql('pending')} = ${String(searchOnly)}`;
+  return `pending_runs AS (
+    (SELECT pending.run_id
+     FROM ${tableName('outbox', options)} AS pending
+     WHERE pending.delivered_at IS NULL ${lane}
+     ORDER BY pending.run_id LIMIT 1)
+    UNION ALL
+    SELECT next_run.run_id
+    FROM pending_runs AS previous_run
+    CROSS JOIN LATERAL (
+      SELECT pending.run_id
+      FROM ${tableName('outbox', options)} AS pending
+      WHERE pending.delivered_at IS NULL ${lane}
+        AND pending.run_id > previous_run.run_id
+      ORDER BY pending.run_id LIMIT 1
+    ) AS next_run
+  )`;
+}
+
 /** Prioritize a terminal's causal head without skipping its predecessors. */
 function runLedgerTerminalPendingSql(
   alias: string,
@@ -18712,14 +18739,8 @@ export async function readPostgresSchedulerOutboxNextDueAt(
 ): Promise<Date | null> {
   const result = await client.query<{ due_at: Date | string | null }>(
     `
-      -- Discover only run identities before seeking each lane's causal head.
-      -- Proving that every pending fact has no predecessor can be quadratic for
-      -- a large receipt backlog, even while another replica drains that run.
-      WITH pending_runs AS MATERIALIZED (
-        SELECT DISTINCT pending.run_id
-        FROM ${tableName('outbox', options)} AS pending
-        WHERE pending.delivered_at IS NULL
-      ), heads AS MATERIALIZED (
+      -- Seek distinct run identities without reading their pending fact tails.
+      WITH RECURSIVE ${runLedgerPendingRunsSql(options)}, heads AS MATERIALIZED (
         SELECT pending_run.run_id, false AS search_only, head.*
         FROM pending_runs AS pending_run
         CROSS JOIN LATERAL (
@@ -20332,7 +20353,7 @@ async function dispatchRunLedgerOutboxBatchWithScope(
       // run-scoped outbox prefix: combining it with global recovery through a
       // nullable predicate made PostgreSQL materialize every pending run head
       // for each lifecycle transition. Only the two dedicated projectors may
-      // perform the global distinct-head scan below.
+      // perform the global indexed head discovery below.
       const selected =
         (input.headEventId ? null : lockedRun) ??
         (targetRunId
@@ -20379,19 +20400,23 @@ async function dispatchRunLedgerOutboxBatchWithScope(
               run_id: string;
               dispatch_launch_json: unknown;
             }>(`
-            WITH heads AS MATERIALIZED (
-              SELECT DISTINCT ON (pending.run_id)
-                pending.run_id,
-                pending.event_id,
-                pending.event_type,
-                ${needsLaunch ? 'pending.payload_json,' : ''}
-                pending.created_at,
-                pending.next_attempt_at,
-                pending.failed_at
-              FROM ${tableName('outbox', options)} AS pending
-              WHERE pending.delivered_at IS NULL
-                AND ${searchLaneSql('pending')} = ${input.searchOnly === true ? 'true' : 'false'}
-              ORDER BY pending.run_id, ${runLedgerOrderSql('pending')}
+            WITH RECURSIVE ${runLedgerPendingRunsSql(options, input.searchOnly === true)}, heads AS MATERIALIZED (
+              SELECT pending_run.run_id, head.*
+              FROM pending_runs AS pending_run
+              CROSS JOIN LATERAL (
+                SELECT pending.event_id,
+                       pending.event_type,
+                       ${needsLaunch ? 'pending.payload_json,' : ''}
+                       pending.created_at,
+                       pending.next_attempt_at,
+                       pending.failed_at
+                FROM ${tableName('outbox', options)} AS pending
+                WHERE pending.run_id = pending_run.run_id
+                  AND pending.delivered_at IS NULL
+                  AND ${searchLaneSql('pending')} = ${input.searchOnly === true ? 'true' : 'false'}
+                ORDER BY ${runLedgerOrderSql('pending')}
+                LIMIT 1
+              ) AS head
             )
             SELECT runs.run_id, ${launchSelection} AS dispatch_launch_json
             FROM heads AS head

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

@@ -80,6 +80,9 @@ const RUN_LEDGER_OUTBOX_RECOVERY_INDEX_IN_FLIGHT = 4;
 // from starving behind continuous new admissions. An empty class never costs
 // another query: either order can select any eligible run.
 const ADMISSION_TURNS_PER_OLDEST_READY_TURN = 3;
+// Notifications are hints, not another durable queue. Overflow requests the
+// existing global drain instead of retaining an unbounded set of run ids.
+const MAX_NOTIFICATION_RUN_HINTS = RUN_LEDGER_OUTBOX_RECOVERY_MAX_IN_FLIGHT;
 
 type RecoveryTimer = ReturnType<typeof setTimeout>;
 
@@ -89,9 +92,12 @@ export type RunLedgerOutboxRecoveryDeps = {
   /** One bounded durable claim/delivery attempt. */
   dispatchOnce: (
     headPriority: RunLedgerOutboxHeadPriority,
+    runId?: string,
   ) => Promise<PostgresSchedulerOutboxProjectionResult>;
   /** Independent index deliveries share this controller and notification source. */
-  dispatchObservabilityOnce?: () => Promise<PostgresSchedulerOutboxProjectionResult>;
+  dispatchObservabilityOnce?: (
+    runId?: string,
+  ) => Promise<PostgresSchedulerOutboxProjectionResult>;
   observabilityParallelism?: number;
   /** Earliest pending retry time or active lease expiry in the durable outbox. */
   readNextDueAt: () => Promise<Date | null>;
@@ -139,6 +145,18 @@ function boundedFailureDelayMs(failures: number): number {
   );
 }
 
+function notificationRunId(payload: string): string | undefined {
+  try {
+    const message = JSON.parse(payload) as { runId?: unknown } | null;
+    if (typeof message?.runId !== 'string') return undefined;
+    const runId = message.runId.trim();
+    return runId && runId.length <= 256 ? runId : undefined;
+  } catch {
+    // Legacy, retry and repair notifications may carry no run identity.
+    return undefined;
+  }
+}
+
 /**
  * Start a bounded, work-conserving recovery controller from injected seams.
  * Subscription happens before the first database scan, so a terminal commit
@@ -189,24 +207,50 @@ export function startRunLedgerOutboxRecovery(
   let hubLease: PgNotifyHubLease | null = null;
   let unsubscribeNotify: (() => void) | undefined;
   let unsubscribeState: (() => void) | undefined;
-  let requestDrain: (reason: string) => void = () => undefined;
+  let requestDrain: (reason: string, runId?: string) => void = () => undefined;
+  const lifecycleRunHints = new Set<string>();
+  const observabilityRunHints = new Set<string>();
+  const hasRequests = () =>
+    requested ||
+    observabilityRequested ||
+    lifecycleRunHints.size > 0 ||
+    observabilityRunHints.size > 0;
+  const addRunHint = (hints: Set<string>, runId: string) => {
+    hints.add(runId);
+    if (hints.size <= MAX_NOTIFICATION_RUN_HINTS) return true;
+    hints.clear();
+    return false;
+  };
+  const takeRunHint = (hints: Set<string>): string | undefined => {
+    const runId = hints.values().next().value;
+    if (runId !== undefined) hints.delete(runId);
+    return runId;
+  };
   const inFlightStartedAt = new Map<number, number>();
   let nextDispatchId = 0;
   let lastDispatchSettledAt: number | null = null;
   let admissionTurns = 0;
   const dispatchOnce = async (
     observability = false,
+    runId?: string,
   ): Promise<PostgresSchedulerOutboxProjectionResult> => {
     const oldestReady =
       admissionTurns === ADMISSION_TURNS_PER_OLDEST_READY_TURN;
-    if (!observability) admissionTurns = oldestReady ? 0 : admissionTurns + 1;
+    // Scoped claims cannot change which run wins, so they must not consume
+    // the global drain's starvation-prevention turns.
+    if (!observability && runId === undefined)
+      admissionTurns = oldestReady ? 0 : admissionTurns + 1;
     const id = nextDispatchId++;
     inFlightStartedAt.set(id, now());
     try {
-      if (observability) return await deps.dispatchObservabilityOnce!();
-      return await deps.dispatchOnce(
-        oldestReady ? 'oldest_ready' : 'admission_first',
-      );
+      if (observability)
+        return await (runId === undefined
+          ? deps.dispatchObservabilityOnce!()
+          : deps.dispatchObservabilityOnce!(runId));
+      const headPriority = oldestReady ? 'oldest_ready' : 'admission_first';
+      return await (runId === undefined
+        ? deps.dispatchOnce(headPriority)
+        : deps.dispatchOnce(headPriority, runId));
     } finally {
       inFlightStartedAt.delete(id);
       lastDispatchSettledAt = now();
@@ -226,8 +270,8 @@ export function startRunLedgerOutboxRecovery(
     const lease = deps.acquireNotifyHub();
     if (!lease) return;
     hubLease = lease;
-    unsubscribeNotify = lease.hub.subscribe(() =>
-      requestDrain('postgres_notify'),
+    unsubscribeNotify = lease.hub.subscribe((payload) =>
+      requestDrain('postgres_notify', notificationRunId(payload)),
     );
     unsubscribeState = lease.hub.subscribeState((state) => {
       // A reconnect is a durable catch-up boundary. The controller re-reads
@@ -239,10 +283,8 @@ export function startRunLedgerOutboxRecovery(
     });
   };
 
-  requestDrain = (reason: string) => {
+  const startDrain = (reason: string) => {
     if (closed) return;
-    requested = true;
-    observabilityRequested = !!deps.dispatchObservabilityOnce;
     if (cooldownUntilMs !== null && now() < cooldownUntilMs) return;
     clearWakeTimer();
     if (drainPromise) {
@@ -260,10 +302,31 @@ export function startRunLedgerOutboxRecovery(
       })
       .finally(() => {
         drainPromise = null;
-        if (requested && !closed) requestDrain('coalesced_wake');
+        if (hasRequests() && !closed) startDrain('coalesced_wake');
       });
   };
 
+  requestDrain = (reason: string, runId?: string) => {
+    if (closed) return;
+    if (runId === undefined) {
+      requested = true;
+      observabilityRequested = !!deps.dispatchObservabilityOnce;
+      lifecycleRunHints.clear();
+      observabilityRunHints.clear();
+    } else {
+      // A pending global scan already covers these hints. Once that scan is
+      // launched its flag is consumed, so a later notification is retained.
+      if (!requested && !addRunHint(lifecycleRunHints, runId)) requested = true;
+      if (
+        deps.dispatchObservabilityOnce &&
+        !observabilityRequested &&
+        !addRunHint(observabilityRunHints, runId)
+      )
+        observabilityRequested = true;
+    }
+    startDrain(reason);
+  };
+
   const recordProjectionRetry = (retrying: number) => {
     logger.warn('[run-ledger-outbox.recovery_retry]', {
       stage: 'projection',
@@ -311,7 +374,7 @@ export function startRunLedgerOutboxRecovery(
       scheduleFailureRetry('next_due', error);
       return;
     }
-    if (closed || requested) return;
+    if (closed || hasRequests()) return;
     // When LISTEN is healthy the exact durable due time is sufficient. If the
     // optional listener is absent, down, or lost an election, an indexed
     // short safety wake discovers a fresh row that otherwise had no
@@ -337,6 +400,7 @@ export function startRunLedgerOutboxRecovery(
     type Delivery = {
       id: symbol;
       observability: boolean;
+      runId?: string;
       result:
         | PromiseSettledResult<PostgresSchedulerOutboxProjectionResult>
         | { status: 'skipped' };
@@ -371,7 +435,7 @@ export function startRunLedgerOutboxRecovery(
       completed = attempted = projected = retrying = blocked = 0;
     };
 
-    const launch = (observability = false) => {
+    const launch = (observability = false, runId?: string) => {
       const id = Symbol();
       pending.add(id);
       if (observability) pendingObservability.add(id);
@@ -380,7 +444,7 @@ export function startRunLedgerOutboxRecovery(
           dispatchFailed = true;
           scheduleFailureRetry('dispatch', result.reason);
         }
-        deliveries.push({ id, observability, result });
+        deliveries.push({ id, observability, runId, result });
         wakeActiveDrain?.();
       };
       // Subscribe once per delivery. Repeated Promise.race calls would retain
@@ -393,7 +457,7 @@ export function startRunLedgerOutboxRecovery(
         try {
           settle({
             status: 'fulfilled',
-            value: await dispatchOnce(observability),
+            value: await dispatchOnce(observability, runId),
           });
         } catch (reason) {
           settle({ status: 'rejected', reason });
@@ -404,13 +468,13 @@ export function startRunLedgerOutboxRecovery(
     const canProbeLifecycle = () =>
       !closed &&
       !dispatchFailed &&
-      requested &&
+      (requested || lifecycleRunHints.size > 0) &&
       pending.size < parallelism &&
       pending.size - pendingObservability.size < lifecycleParallelism;
     const canProbeObservability = () =>
       !closed &&
       !dispatchFailed &&
-      observabilityRequested &&
+      (observabilityRequested || observabilityRunHints.size > 0) &&
       pending.size < parallelism &&
       pendingObservability.size < observabilityParallelism;
 
@@ -420,12 +484,16 @@ export function startRunLedgerOutboxRecovery(
         // still delivering. Keep it pending when full so an empty result
         // cannot consume a notification that arrived after its query began.
         if (canProbeObservability()) {
+          const runId = observabilityRequested
+            ? undefined
+            : takeRunHint(observabilityRunHints);
           observabilityRequested = false;
-          launch(true);
+          launch(true, runId);
         }
         if (canProbeLifecycle()) {
+          const runId = requested ? undefined : takeRunHint(lifecycleRunHints);
           requested = false;
-          launch();
+          launch(false, runId);
         }
         // Productive completion permits immediate use of every free slot.
         // Empty results grant no refill, so idle work cannot spin on scans.
@@ -481,14 +549,31 @@ export function startRunLedgerOutboxRecovery(
       if (completed >= parallelism) reportDeliveries();
       // Retryable rows own durable retry clocks. The SQL claim keeps their
       // run ordered while successful slots keep unrelated runs moving.
-      if (delivery.observability) {
+      if (delivery.runId !== undefined) {
+        // Continue only the notified run. Refilling with global claims here
+        // would turn one productive scoped claim back into whole-outbox scans.
+        if (result.attempted > 0) {
+          if (delivery.observability) {
+            if (
+              !observabilityRequested &&
+              !addRunHint(observabilityRunHints, delivery.runId)
+            )
+              observabilityRequested = true;
+          } else if (
+            !requested &&
+            !addRunHint(lifecycleRunHints, delivery.runId)
+          )
+            requested = true;
+        }
+      } else if (delivery.observability) {
         observabilityRefill = result.attempted > 0;
       } else refill = result.attempted > 0;
     }
   };
 
   // Subscribe first, then scan. Notifications are lossy by design, so every
-  // wake re-reads durable state and reconnect transitions also trigger a scan.
+  // named wake re-reads that run's durable prefix. Startup, reconnect, retries
+  // and identity-less notifications retain the global recovery scan.
   attachNotifyHub();
   requestDrain('startup');
 
@@ -512,6 +597,8 @@ export function startRunLedgerOutboxRecovery(
       wakeActiveDrain?.();
       clearWakeTimer();
       cooldownUntilMs = null;
+      lifecycleRunHints.clear();
+      observabilityRunHints.clear();
       unsubscribeNotify?.();
       unsubscribeState?.();
       await drainPromise;
@@ -769,6 +856,7 @@ export function startRunLedgerOutboxRecoveryController(input: {
   const dispatch = (
     headPriority: RunLedgerOutboxHeadPriority,
     searchOnly: boolean,
+    runId?: string,
   ) =>
     dispatchRunLedgerOutboxToLedgerBatchOnceWithClientScope(
       (operation) =>
@@ -780,6 +868,7 @@ export function startRunLedgerOutboxRecoveryController(input: {
         tokenAuthority: 'gateway',
         materializeObservability: true,
         searchOnly,
+        ...(runId === undefined ? {} : { runId }),
         withObservabilityClient: (operation) =>
           withRuntimeSchedulerClient(observabilityPoolOptions, operation),
         limit: 8,
@@ -801,8 +890,8 @@ export function startRunLedgerOutboxRecoveryController(input: {
               schedulerOptions,
             }),
           ),
-    dispatchOnce: (headPriority) => dispatch(headPriority, false),
-    dispatchObservabilityOnce: () => dispatch('oldest_ready', true),
+    dispatchOnce: (headPriority, runId) => dispatch(headPriority, false, runId),
+    dispatchObservabilityOnce: (runId) => dispatch('oldest_ready', true, runId),
     observabilityParallelism: RUN_LEDGER_OUTBOX_RECOVERY_INDEX_IN_FLIGHT,
     // `dispatchRunLedgerOutboxToLedgerBatchOnceWithClientScope` releases each
     // short scheduler checkout before it calls the Vercel gateway. The two

package/dist/cli/{auth-MPHXSP64.mjs → auth-NQLQ5QBV.mjs}

@@ -9,11 +9,11 @@ import {
   registerAuthCommands,
   reportSetupCompleted,
   resolvePendingAuthClaimForResume
-} from "./chunk-GXN7DGNL.mjs";
-import "./chunk-ZQ6UF55Y.mjs";
-import "./chunk-JKJSTQ2I.mjs";
+} from "./chunk-QOYD2THS.mjs";
+import "./chunk-GT5HPOM3.mjs";
+import "./chunk-722274AA.mjs";
 import "./chunk-DLIRSHV6.mjs";
-import "./chunk-6OVLJLYH.mjs";
+import "./chunk-XFTGWGZ5.mjs";
 import "./chunk-NXGCO4JB.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";

package/dist/cli/auth-YTDZKDCB.js

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

package/dist/cli/{billing-K5WCTRBE.mjs → billing-AXSNXOTN.mjs}

@@ -2,7 +2,7 @@ import {
   DeeplineClient,
   iterateCursorPages,
   requireBillingIdempotencyKey
-} from "./chunk-VDOH4A34.mjs";
+} from "./chunk-IKC7EPDS.mjs";
 import "./chunk-CBVIJSHF.mjs";
 import {
   createTimestampedName,
@@ -10,13 +10,13 @@ import {
   openInBrowser,
   printCommandEnvelope,
   shouldEmitJson
-} from "./chunk-ZQ6UF55Y.mjs";
+} from "./chunk-GT5HPOM3.mjs";
 import {
   AuthError,
   ConfigError
-} from "./chunk-JKJSTQ2I.mjs";
+} from "./chunk-722274AA.mjs";
 import "./chunk-DLIRSHV6.mjs";
-import "./chunk-6OVLJLYH.mjs";
+import "./chunk-XFTGWGZ5.mjs";
 import "./chunk-6IKARAYD.mjs";
 import {
   DeeplineError