deepline 0.3.333 → 0.3.334

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

@@ -477,7 +477,7 @@ export type CsvOptions = PlayAuthoringCsvOptions;
  *   // Emit a log line (visible in `play tail`)
  *   ctx.log(`Loaded ${await leads.count()} leads`);
  *
- *   // Pause execution
+ *   // Wait at least one second before continuing.
  *   await ctx.sleep(1000);
  *
  *   // Access submitted input through the handler's second argument.

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.333',
+  version: '0.3.334',
   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/context.ts

@@ -654,6 +654,7 @@ const TOOL_RETRY_AFTER_FALLBACK_MS = 1_000;
 export const TOOL_EXECUTE_RESPONSE_BODY_TIMEOUT_MS = 30_000;
 const TOOL_RETRY_HEARTBEAT_INTERVAL_MS = 30_000;
 const TOOL_PROVIDER_RESIDENT_WAIT_BUDGET_MS = 5_000;
+const AUTHORED_SLEEP_RESIDENT_LIMIT_MS = 10_000;
 const DEEPLINEAGENT_TOOL_RUNTIME_TIMEOUT_MS = 15 * 60 * 1000;
 // Every runtime-API tool fetch needs a client-side deadline. Without one, a
 // stalled execute request (e.g. a credential-less call whose gateway connection
@@ -2929,6 +2930,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
    */
   private readonly persistenceLatch: RuntimePersistenceLatch =
     createRuntimePersistenceLatch();
+  private sleepMetadataPersistenceFailed = false;
   /**
    * The single source of every concurrency, budget, and pacing decision for this
    * run-attempt. Tool/play/row slots are blocking semaphores; budgets are charged
@@ -3154,6 +3156,9 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
    */
   assertNoPendingDurableSuspension(): void {
     this.#options.executionSignal?.throwIfAborted();
+    if (this.sleepMetadataPersistenceFailed) {
+      throw new RuntimePersistenceCircuitOpenError(this.persistenceLatch);
+    }
     this.assertNoSlackHitlTimeoutFailure();
     this.assertNoRowProviderBackpressure();
     if (this.pendingDurableSuspension) {
@@ -6235,7 +6240,10 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
       runningReceiptWaitMaxAttempts?: number;
       runningReceiptWaitDelayMs?: number;
       reclaimRunning?: boolean;
-      markSkipped?: (output: T) => Promise<void> | void;
+      markSkipped?: (
+        output: T,
+        receipt: RuntimeStepReceipt,
+      ) => Promise<void> | void;
       onRecovered?: (
         output: T,
         receipt: RuntimeStepReceipt,
@@ -14581,6 +14589,111 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     this.suspendDurably({ kind: 'sleep', boundaryId, delayMs });
   }
 
+  private sleepMetadataReceiptKey(
+    boundaryId: string,
+    intent: 'wake' | 'count',
+  ): string {
+    return durableCtxKey({
+      orgId: this.#options.orgId,
+      playId: this.currentExecutionScope.receipt.namespace,
+      operation: 'step',
+      id: `__deepline_sleep_${intent}__`,
+      semanticKey: stableStringify({
+        runId: this.currentReceiptOwnerRunId,
+        boundaryId,
+      }),
+    });
+  }
+
+  private async readStepSleepCount(boundaryId: string): Promise<number | null> {
+    try {
+      const receipt = await this.getRuntimeStepReceipt(
+        this.sleepMetadataReceiptKey(boundaryId, 'count'),
+      );
+      if (receipt?.status !== 'completed') return null;
+      const output = receipt.output;
+      const sleepCount =
+        output && typeof output === 'object' && 'sleepCount' in output
+          ? output.sleepCount
+          : undefined;
+      if (
+        typeof sleepCount !== 'number' ||
+        !Number.isSafeInteger(sleepCount) ||
+        sleepCount < 0
+      ) {
+        throw new Error(`Durable step ${boundaryId} has no valid sleep count.`);
+      }
+      return sleepCount;
+    } catch (error) {
+      this.sleepMetadataPersistenceFailed = true;
+      tripRuntimePersistenceLatch(this.persistenceLatch, error);
+      throw error;
+    }
+  }
+
+  private async persistStepSleepCount(
+    boundaryId: string,
+    sleepCount: number,
+  ): Promise<void> {
+    try {
+      await this.completeRuntimeStepReceipt(
+        this.sleepMetadataReceiptKey(boundaryId, 'count'),
+        this.currentReceiptOwnerRunId,
+        { sleepCount },
+        COMPLETED_RECEIPT_CACHE_INSERT_LEASE_ID,
+      );
+      if ((await this.readStepSleepCount(boundaryId)) === null) {
+        throw new Error(
+          `Durable step ${boundaryId} did not persist its sleep count.`,
+        );
+      }
+    } catch (error) {
+      this.sleepMetadataPersistenceFailed = true;
+      tripRuntimePersistenceLatch(this.persistenceLatch, error);
+      throw error;
+    }
+  }
+
+  private async resolveCanonicalSleepWakeAtMs(
+    boundaryId: string,
+    delayMs: number,
+  ): Promise<number> {
+    const key = this.sleepMetadataReceiptKey(boundaryId, 'wake');
+    const proposedWakeAtMs = Date.now() + delayMs;
+    try {
+      let receipt = await this.getRuntimeStepReceipt(key);
+      if (receipt?.status !== 'completed') {
+        await this.completeRuntimeStepReceipt(
+          key,
+          this.currentReceiptOwnerRunId,
+          { wakeAtMs: proposedWakeAtMs },
+          COMPLETED_RECEIPT_CACHE_INSERT_LEASE_ID,
+        );
+        receipt = await this.getRuntimeStepReceipt(key);
+      }
+      const output = receipt?.output;
+      const wakeAtMs =
+        output && typeof output === 'object' && 'wakeAtMs' in output
+          ? output.wakeAtMs
+          : undefined;
+      if (
+        receipt?.status !== 'completed' ||
+        typeof wakeAtMs !== 'number' ||
+        !Number.isSafeInteger(wakeAtMs) ||
+        wakeAtMs < 0
+      ) {
+        throw new Error(
+          `Durable sleep intent ${boundaryId} has no valid wake timestamp.`,
+        );
+      }
+      return wakeAtMs;
+    } catch (error) {
+      this.sleepMetadataPersistenceFailed = true;
+      tripRuntimePersistenceLatch(this.persistenceLatch, error);
+      throw error;
+    }
+  }
+
   async sleep(ms: number): Promise<void> {
     if (!rowContext.getStore()) this.assertRowAdmissionOpen();
     this.assertNoPendingDurableSuspension();
@@ -14654,17 +14767,49 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
       if (existing?.kind === 'sleep' && existing.completedAt !== undefined) {
         return;
       }
+      const wakeAtMs =
+        existing?.kind === 'sleep' && existing.wakeAtMs !== undefined
+          ? existing.wakeAtMs
+          : this.durableDirectToolResultsBackedByReceipts
+            ? await this.resolveCanonicalSleepWakeAtMs(boundaryId, delayMs)
+            : undefined;
+      this.assertNoPendingDurableSuspension();
       this.checkpoint.resolvedBoundaries = {
         ...(this.checkpoint.resolvedBoundaries ?? {}),
         [boundaryId]: {
+          ...existing,
           kind: 'sleep',
           delayMs,
+          ...(wakeAtMs !== undefined ? { wakeAtMs } : {}),
         },
       };
+      if (
+        wakeAtMs !== undefined &&
+        !rowStore &&
+        this.durableDirectToolResultsBackedByReceipts &&
+        (wakeAtMs <= Date.now() ||
+          (delayMs <= AUTHORED_SLEEP_RESIDENT_LIMIT_MS &&
+            wakeAtMs < (this.#options.executionDrainAtMs ?? Infinity)))
+      ) {
+        const remainingMs = Math.max(0, wakeAtMs - Date.now());
+        if (remainingMs > 0)
+          await this.sleepWithCheckpointHeartbeat(remainingMs);
+        this.assertNoPendingDurableSuspension();
+        this.checkpoint.resolvedBoundaries[boundaryId] = {
+          ...this.checkpoint.resolvedBoundaries[boundaryId],
+          kind: 'sleep',
+          delayMs,
+          wakeAtMs,
+          completedAt: Date.now(),
+        };
+        this.#options.onBatchComplete?.(this.checkpoint);
+        return;
+      }
       this.suspendDurably({
         kind: 'sleep',
         boundaryId,
         delayMs,
+        ...(wakeAtMs !== undefined ? { wakeAtMs } : {}),
       });
     }
     return new Promise((resolve) => setTimeout(resolve, delayMs));
@@ -15001,30 +15146,33 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     const boundaryId = this.durableBoundaryId(
       `step-${scope}:${normalizedKey}${boundarySuffix}`,
     );
+    const advanceRecoveredSleepCursor = async (
+      receipt?: RuntimeStepReceipt,
+    ) => {
+      if (rowStore?.replayCallIndexes?.recoverStep(boundaryId)) return;
+      const existing = assertKnownResolvedBoundary(
+        boundaryId,
+        this.checkpoint.resolvedBoundaries?.[boundaryId],
+      );
+      const sleepCount =
+        existing?.kind === 'step' && existing.sleepCount !== undefined
+          ? existing.sleepCount
+          : receipt?.runId === this.currentReceiptOwnerRunId
+            ? ((await this.readStepSleepCount(boundaryId)) ?? 0)
+            : 0;
+      if (Number.isSafeInteger(sleepCount) && sleepCount > 0)
+        this.sleepBoundaryIndex += sleepCount;
+    };
     const executeStep = async (): Promise<T> => {
       const existing = assertKnownResolvedBoundary(
         boundaryId,
         this.checkpoint.resolvedBoundaries?.[boundaryId],
       );
       if (existing?.kind === 'step' && 'output' in existing) {
-        const replayedCalls =
-          rowStore?.replayCallIndexes?.recoverStep(boundaryId) ?? false;
         this.runtimeLog(
           `ctx.step(${normalizedKey}): recovered result from checkpoint`,
         );
-        // The step callback is not evaluated on replay, so any sleeps that it
-        // contained would otherwise disappear from the positional sleep
-        // cursor. Preserve the authored boundary sequence before evaluating
-        // the next sibling operation. This is deliberately run-local state;
-        // it is not a cross-run sleep cache or an input-derived identity.
-        if (
-          !replayedCalls &&
-          Number.isSafeInteger(existing.sleepCount) &&
-          existing.sleepCount !== undefined &&
-          existing.sleepCount > 0
-        ) {
-          this.sleepBoundaryIndex += existing.sleepCount;
-        }
+        await advanceRecoveredSleepCursor();
         return existing.output as T;
       }
 
@@ -15047,15 +15195,20 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
       // publish an enclosing step fallback that would make a later resume skip
       // the suspended work.
       this.assertNoPendingDurableSuspension();
+      const sleepCount = rowStore?.replayCallIndexes
+        ? (callAdvances.get('sleep:legacy') ?? 0)
+        : this.sleepBoundaryIndex - sleepBoundaryIndexBefore;
+      if (sleepCount > 0 && this.durableDirectToolResultsBackedByReceipts) {
+        await this.persistStepSleepCount(boundaryId, sleepCount);
+      }
+      this.assertNoPendingDurableSuspension();
       this.checkpoint.resolvedBoundaries = {
         ...(this.checkpoint.resolvedBoundaries ?? {}),
         [boundaryId]: {
           kind: 'step',
           stepId: normalizedKey,
           output,
-          sleepCount: rowStore?.replayCallIndexes
-            ? (callAdvances.get('sleep:legacy') ?? 0)
-            : this.sleepBoundaryIndex - sleepBoundaryIndexBefore,
+          sleepCount,
           completedAt: Date.now(),
         },
       };
@@ -15100,8 +15253,9 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                 : options?.semanticKey,
               staleAfterSeconds: options?.staleAfterSeconds,
               force: this.#options.cachePolicy?.forceStepRefresh === true,
-              markSkipped: (output) => {
+              markSkipped: async (output, receipt) => {
                 assertJsonSerializableStepOutput(normalizedKey, output);
+                await advanceRecoveredSleepCursor(receipt);
               },
               execute: executeStep,
             },

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

@@ -815,6 +815,8 @@ export interface ContextOptions {
   rowAdmissionSignal?: AbortSignal;
   /** Local runner cancellation; never serialized into a Play artifact. */
   executionSignal?: AbortSignal;
+  /** Runner-local deadline for stopping new work, captured when its timer arms. */
+  executionDrainAtMs?: number;
   /**
    * Runtime-sheet transport selected by the runner. Daytona sandboxes use the
    * execution gateway and must never fall back to minting direct DB sessions.
@@ -1244,6 +1246,8 @@ export interface PlayCheckpoint {
     | {
         kind: 'sleep';
         delayMs: number;
+        /** Original wake deadline. Historical boundaries retain relative waits. */
+        wakeAtMs?: number;
         completedAt?: number;
         scope?: {
           type: 'workflow' | 'map_row';

package/dist/bundling-sources/shared_libs/play-runtime/durable-receipt-execution.ts

@@ -777,7 +777,10 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
   runningReceiptWaitMaxAttempts?: number;
   runningReceiptWaitDelayMs?: number;
   reclaimRunning?: boolean;
-  markSkipped?: (output: T) => Promise<void> | void;
+  markSkipped?: (
+    output: T,
+    receipt: RuntimeStepReceipt,
+  ) => Promise<void> | void;
   onRecovered?: (
     output: T,
     receipt: RuntimeStepReceipt,
@@ -812,6 +815,9 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
   ): Promise<T> => {
     input.log(`ctx.${input.operation}(${input.id}): reused completed work`);
     if (receipt.output === undefined) {
+      if (input.operation === 'step' && input.markSkipped) {
+        await input.markSkipped(receipt.output as T, receipt);
+      }
       return receipt.output as T;
     }
     const output = runtimeReceiptOutput<T>(receipt);
@@ -819,7 +825,7 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
       ? input.onRecovered(output, receipt, 'cache')
       : output;
     if (input.markSkipped) {
-      await input.markSkipped(recovered);
+      await input.markSkipped(recovered, receipt);
     }
     return recovered;
   };

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

@@ -1159,6 +1159,7 @@ export interface ExecutePlayRunnerOptions {
   signal?: AbortSignal;
   /** Stops future row admission while already admitted rows can persist. */
   rowAdmissionSignal?: AbortSignal;
+  executionDrainAtMs?: number;
   /** Runner-local terminal state made available to the deadline drain. */
   onRuntimeReady?: (runtime: {
     log: (line: string) => void;
@@ -2036,14 +2037,15 @@ async function run(
     runnerRunAttempt,
   );
   const workCounterSegmentId = randomUUID();
+  const runtimeLimitMs =
+    validatePlaySandboxRuntimeLimits(
+      config.context.sandboxRuntimeLimits ??
+        STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS,
+    ).timeoutSeconds * 1_000;
   const persistenceSignal =
-    options?.signal ??
-    AbortSignal.timeout(
-      validatePlaySandboxRuntimeLimits(
-        config.context.sandboxRuntimeLimits ??
-          STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS,
-      ).timeoutSeconds * 1_000,
-    );
+    options?.signal ?? AbortSignal.timeout(runtimeLimitMs);
+  const executionDrainAtMs =
+    options?.executionDrainAtMs ?? runStartedAt + runtimeLimitMs;
   const contextSetupStartedAt = Date.now();
   const getRuntimeToolMetadata = createRuntimeToolMetadataResolver(config);
   const getRuntimeToolAuthScopeDigest =
@@ -2225,6 +2227,7 @@ async function run(
     artifactRuntimeContract,
     rowAdmissionSignal: options?.rowAdmissionSignal,
     executionSignal: persistenceSignal,
+    executionDrainAtMs,
     executorToken: config.context.executorToken,
     baseUrl: config.context.baseUrl,
     // Runtime control stays on baseUrl (the receipt gateway); provider calls
@@ -3894,6 +3897,7 @@ async function main() {
       result = await executePlayRunner(config, {
         signal: executionController.signal,
         rowAdmissionSignal: rowAdmissionController.signal,
+        executionDrainAtMs: runtimeDeadline.drainAtMs,
         onRuntimeReady: (runtime) => {
           runtimeState = runtime;
         },

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

@@ -16,6 +16,7 @@ export interface PlayRunnerRuntimeDeadlineOptions {
 }
 
 export interface PlayRunnerRuntimeDeadlineHandle {
+  drainAtMs: number;
   /** Claim normal settlement. False means the deadline already won. */
   claimCompletion: () => boolean;
   /** Settles only if the deadline callback unexpectedly returns or rejects. */
@@ -60,6 +61,10 @@ export function startPlayRunnerRuntimeDeadline(
   options: PlayRunnerRuntimeDeadlineOptions,
 ): PlayRunnerRuntimeDeadlineHandle {
   const limitMs = Math.max(1, Math.floor(options.limitMs));
+  const drainDelayMs = options.onDrain
+    ? Math.max(1, limitMs - Math.min(options.drainLeadMs ?? 4_000, limitMs / 2))
+    : limitMs;
+  const drainAtMs = Date.now() + drainDelayMs;
   const setTimeoutImpl =
     options.setTimeoutImpl ??
     ((callback, delayMs) => setTimeout(callback, delayMs));
@@ -73,20 +78,14 @@ export function startPlayRunnerRuntimeDeadline(
     settleDeadline = resolve;
   });
   const drainHandle = options.onDrain
-    ? setTimeoutImpl(
-        () => {
-          if (fired || completionClaimed) return;
-          try {
-            options.onDrain?.();
-          } catch (error) {
-            options.onError?.(error);
-          }
-        },
-        Math.max(
-          1,
-          limitMs - Math.min(options.drainLeadMs ?? 4_000, limitMs / 2),
-        ),
-      )
+    ? setTimeoutImpl(() => {
+        if (fired || completionClaimed) return;
+        try {
+          options.onDrain?.();
+        } catch (error) {
+          options.onError?.(error);
+        }
+      }, drainDelayMs)
     : null;
   const handle = setTimeoutImpl(() => {
     if (fired || completionClaimed) return;
@@ -99,6 +98,7 @@ export function startPlayRunnerRuntimeDeadline(
   }, limitMs);
 
   return {
+    drainAtMs,
     claimCompletion: () => {
       if (fired || completionClaimed) return false;
       completionClaimed = true;

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

@@ -736,7 +736,7 @@ export class AbsurdExecutionOperationTimeoutError extends Error {
  * park/resume seam without a real engine. */
 export type AbsurdSuspensionContext = Pick<
   TaskContext,
-  'sleepFor' | 'awaitEvent' | 'heartbeat'
+  'sleepFor' | 'sleepUntil' | 'awaitEvent' | 'heartbeat'
 >;
 
 /** Injected DB + app-runtime seams so the handler is testable against real SQL
@@ -1393,10 +1393,17 @@ export async function parkAndResolveSuspension(input: {
 
   if (suspension.kind === 'sleep') {
     // Throws SuspendTask on the first leg; returns once the deadline elapsed.
-    await ctx.sleepFor(
-      suspension.boundaryId,
-      Math.max(0, suspension.delayMs) / 1000,
-    );
+    if (suspension.wakeAtMs !== undefined) {
+      await ctx.sleepUntil(
+        suspension.boundaryId,
+        new Date(suspension.wakeAtMs),
+      );
+    } else {
+      await ctx.sleepFor(
+        suspension.boundaryId,
+        Math.max(0, suspension.delayMs) / 1000,
+      );
+    }
     return absurdCheckpointWithSleep(
       checkpoint,
       suspension.boundaryId,

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

@@ -818,7 +818,12 @@ export function absurdCheckpointWithSleep(
     ...base,
     resolvedBoundaries: {
       ...resolvedBoundaries(base),
-      [boundaryId]: { kind: 'sleep', delayMs, completedAt: Date.now() },
+      [boundaryId]: {
+        ...resolvedBoundaries(base)[boundaryId],
+        kind: 'sleep',
+        delayMs,
+        completedAt: Date.now(),
+      },
     },
   };
 }

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

@@ -17448,7 +17448,10 @@ async function loadPostgresSchedulerStagedFile(
 export async function readPostgresSchedulerResult(
   client: PostgresSchedulerQueryClient,
   runId: string,
-  options?: Pick<PostgresSchedulerOptions, 'schema'>,
+  options?: Pick<PostgresSchedulerOptions, 'schema'> & {
+    /** Read-only customer-result hydration; ordinary scheduler reads retain their behavior. */
+    includeCancelledOutput?: boolean;
+  },
 ): Promise<PlaySchedulerResultEnvelope | null> {
   const result = await client.query<RunRow>(
     `
@@ -17477,7 +17480,9 @@ export async function readPostgresSchedulerResult(
     runId: row.run_id,
     status: row.status,
     ...(row.status === 'completed' ||
-    (row.status === 'failed' && row.terminal_result_json !== null)
+    ((row.status === 'failed' ||
+      (row.status === 'cancelled' && options?.includeCancelledOutput)) &&
+      row.terminal_result_json !== null)
       ? { output: row.terminal_result_json }
       : {}),
     ...(row.status === 'failed' || row.status === 'cancelled'

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

@@ -8,6 +8,7 @@ export type PlayExecutionSuspension =
       kind: 'sleep';
       boundaryId: string;
       delayMs: number;
+      wakeAtMs?: number;
     }
   | {
       kind: 'integration_event';

package/dist/bundling-sources/shared_libs/plays/authoring-contract.ts

@@ -1659,6 +1659,13 @@ export interface PlayAuthoringRuntimeContext<
       context?: Readonly<Record<string, string | number | boolean>>;
     },
   ): void;
+  /**
+   * Wait at least the requested duration before continuing the Play.
+   * Waits of at most 10 seconds stay in the current execution when its remaining time permits.
+   * Longer waits park the Run. On wake, replay reuses completed steps and sleeps.
+   * Scheduling and replay can delay continuation beyond the requested duration.
+   * Use sequential waits for backoff or coordination outside Dataset resolvers.
+   */
   sleep(ms: number): Promise<void>;
 }
 

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

@@ -9,11 +9,11 @@ import {
   registerAuthCommands,
   reportSetupCompleted,
   resolvePendingAuthClaimForResume
-} from "./chunk-H5SORD7Q.mjs";
-import "./chunk-HNX3RC6V.mjs";
-import "./chunk-5UN6KLD2.mjs";
+} from "./chunk-U724V33M.mjs";
+import "./chunk-A7S4PRK2.mjs";
+import "./chunk-VB7TNIUB.mjs";
 import "./chunk-DLIRSHV6.mjs";
-import "./chunk-2CLENWOQ.mjs";
+import "./chunk-P3ZX3NSE.mjs";
 import "./chunk-NXGCO4JB.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";

package/dist/cli/auth-WR3XFOHN.js

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

package/dist/cli/{billing-7YVHLDMO.mjs → billing-QGQJUM5G.mjs}

@@ -2,7 +2,7 @@ import {
   DeeplineClient,
   iterateCursorPages,
   requireBillingIdempotencyKey
-} from "./chunk-SXX4ST3D.mjs";
+} from "./chunk-TT2CLWMK.mjs";
 import "./chunk-CBVIJSHF.mjs";
 import {
   createTimestampedName,
@@ -10,13 +10,13 @@ import {
   openInBrowser,
   printCommandEnvelope,
   shouldEmitJson
-} from "./chunk-HNX3RC6V.mjs";
+} from "./chunk-A7S4PRK2.mjs";
 import {
   AuthError,
   ConfigError
-} from "./chunk-5UN6KLD2.mjs";
+} from "./chunk-VB7TNIUB.mjs";
 import "./chunk-DLIRSHV6.mjs";
-import "./chunk-2CLENWOQ.mjs";
+import "./chunk-P3ZX3NSE.mjs";
 import "./chunk-6IKARAYD.mjs";
 import {
   DeeplineError