deepline 0.3.343 → 0.3.345

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.343',
+  version: '0.3.345',
   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/runner-app/index.ts

@@ -10,6 +10,7 @@ import { compileFunction } from 'node:vm';
 import { gunzipSync } from 'node:zlib';
 import { Readable } from 'node:stream';
 import { parse } from 'csv-parse';
+import { csvInputTextOptions } from '../../plays/csv-text-repair';
 import { install as installSourceMapSupport } from 'source-map-support';
 import {
   createDeferredPlayDataset,
@@ -1559,7 +1560,14 @@ async function emitAndExit(
 function parseCsvStream(
   source: NodeJS.ReadableStream,
 ): AsyncIterable<Record<string, unknown>> {
-  const parser = parse({ columns: true, skip_empty_lines: true, trim: true });
+  // Every Play's CSV input passes through here, so this is where a customer
+  // file's BOM and mis-decoded UTF-8 ("j̩r̫me", "o’malley") get fixed before
+  // any row reaches a provider. See ../../plays/csv-text-repair.
+  const parser = parse({
+    ...csvInputTextOptions(),
+    skip_empty_lines: true,
+    trim: true,
+  });
   // `Readable.pipe()` does not forward source errors to the destination. A
   // missing staged file therefore used to emit an unhandled `error` from
   // createReadStream and kill the Daytona process outside main().catch().

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

@@ -520,6 +520,68 @@ export type RuntimeSheetTiming = {
   error?: string;
 };
 
+type RuntimeMapCompletionPhase =
+  | 'dbSessionAcquire'
+  | 'poolAcquire'
+  | 'transactionBegin'
+  | 'mapRowsUpdate'
+  | 'missingRowsInsert'
+  | 'failedRowsUpdate'
+  | 'transactionCommit'
+  | 'queryClient';
+
+type RuntimeMapCompletionDiagnostics = Record<
+  `${RuntimeMapCompletionPhase}Ms` | `${RuntimeMapCompletionPhase}Failures`,
+  number
+> & {
+  operationAttempts: number;
+  provisioningRetryAttempts: number;
+};
+
+function createRuntimeMapCompletionDiagnostics(): RuntimeMapCompletionDiagnostics {
+  return {
+    dbSessionAcquireMs: 0,
+    dbSessionAcquireFailures: 0,
+    poolAcquireMs: 0,
+    poolAcquireFailures: 0,
+    transactionBeginMs: 0,
+    transactionBeginFailures: 0,
+    mapRowsUpdateMs: 0,
+    mapRowsUpdateFailures: 0,
+    missingRowsInsertMs: 0,
+    missingRowsInsertFailures: 0,
+    failedRowsUpdateMs: 0,
+    failedRowsUpdateFailures: 0,
+    transactionCommitMs: 0,
+    transactionCommitFailures: 0,
+    queryClientMs: 0,
+    queryClientFailures: 0,
+    operationAttempts: 0,
+    provisioningRetryAttempts: 0,
+  };
+}
+
+async function measureRuntimeSheetPhase<T>(
+  diagnostics: RuntimeMapCompletionDiagnostics | undefined,
+  phase: RuntimeMapCompletionPhase,
+  operation: () => Promise<T>,
+): Promise<T> {
+  if (!diagnostics) return await operation();
+  const startedAt = Date.now();
+  let failed = false;
+  try {
+    return await operation();
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    const msKey = `${phase}Ms` as const;
+    const failuresKey = `${phase}Failures` as const;
+    diagnostics[msKey] += Date.now() - startedAt;
+    diagnostics[failuresKey] += Number(failed);
+  }
+}
+
 export type RuntimeSheetAttemptHeartbeatResult = {
   renewed: number;
   renewedKeys: string[];
@@ -2314,6 +2376,7 @@ async function withRuntimePostgres<T>(
     maxConnectAttempts?: number;
     operationTimeoutMs?: number;
     signal?: AbortSignal | null;
+    completionDiagnostics?: RuntimeMapCompletionDiagnostics;
   } = {},
 ): Promise<T> {
   let client: RuntimePoolClient | null = null;
@@ -2336,24 +2399,35 @@ async function withRuntimePostgres<T>(
       if (!cachePool) {
         requestLocalPool = pool;
       }
-      client = await connectRuntimePostgresPool(
-        pool,
-        admission,
-        lane,
-        session.postgresUrl,
-        options.signal,
+      client = await measureRuntimeSheetPhase(
+        options.completionDiagnostics,
+        'poolAcquire',
+        () =>
+          connectRuntimePostgresPool(
+            pool,
+            admission,
+            lane,
+            session.postgresUrl,
+            options.signal,
+          ),
       );
       operationDeadlineAt =
         options.operationTimeoutMs === undefined
           ? null
           : Date.now() + Math.max(1, Math.floor(options.operationTimeoutMs));
       if (session.executionRole) {
-        await awaitRuntimePostgresOperation({
-          client,
-          deadlineAt: operationDeadlineAt,
-          operation: client.query('BEGIN'),
-          signal: options.signal,
-        });
+        const roleClient = client;
+        await measureRuntimeSheetPhase(
+          options.completionDiagnostics,
+          'transactionBegin',
+          () =>
+            awaitRuntimePostgresOperation({
+              client: roleClient,
+              deadlineAt: operationDeadlineAt,
+              operation: roleClient.query('BEGIN'),
+              signal: options.signal,
+            }),
+        );
         roleTransactionStarted = true;
         await awaitRuntimePostgresOperation({
           client,
@@ -2419,12 +2493,18 @@ async function withRuntimePostgres<T>(
       signal: options.signal,
     });
     if (roleTransactionStarted) {
-      await awaitRuntimePostgresOperation({
-        client,
-        deadlineAt: operationDeadlineAt,
-        operation: client.query('COMMIT'),
-        signal: options.signal,
-      });
+      const roleClient = client;
+      await measureRuntimeSheetPhase(
+        options.completionDiagnostics,
+        'transactionCommit',
+        () =>
+          awaitRuntimePostgresOperation({
+            client: roleClient,
+            deadlineAt: operationDeadlineAt,
+            operation: roleClient.query('COMMIT'),
+            signal: options.signal,
+          }),
+      );
       roleTransactionStarted = false;
     }
     return result;
@@ -2549,10 +2629,14 @@ async function withRuntimeSheetProvisioningRetry<T>(
     sheetContract: PlaySheetContract;
     session: RuntimePostgresSession;
     timings?: RuntimeSheetTiming[];
+    completionDiagnostics?: RuntimeMapCompletionDiagnostics;
   },
   operation: () => Promise<T>,
 ): Promise<T> {
   const firstAttemptStartedAt = Date.now();
+  if (input.completionDiagnostics) {
+    input.completionDiagnostics.operationAttempts += 1;
+  }
   try {
     const result = await operation();
     input.timings?.push({
@@ -2610,6 +2694,10 @@ async function withRuntimeSheetProvisioningRetry<T>(
     } else {
       throw error;
     }
+    if (input.completionDiagnostics) {
+      input.completionDiagnostics.provisioningRetryAttempts += 1;
+      input.completionDiagnostics.operationAttempts += 1;
+    }
     const retryStartedAt = Date.now();
     const result = await operation();
     input.timings?.push({
@@ -2631,11 +2719,12 @@ async function withRuntimeSheetQueryClient<T>(
     transactional: boolean;
     statementTimeoutMs?: number;
     timings?: RuntimeSheetTiming[];
+    completionDiagnostics?: RuntimeMapCompletionDiagnostics;
   },
   operation: (client: RuntimeQueryClient) => Promise<T>,
 ): Promise<T> {
-  const totalStartedAt = Date.now();
-  const result = await withRuntimeSheetProvisioningRetry(
+  const resultStartedAt = Date.now();
+  const resultPromise = withRuntimeSheetProvisioningRetry(
     context,
     { ...input, session },
     async () => {
@@ -2661,7 +2750,13 @@ async function withRuntimeSheetQueryClient<T>(
           const managesTransaction =
             (input.transactional || input.statementTimeoutMs !== undefined) &&
             !transaction.active;
-          if (managesTransaction) await client.query('BEGIN');
+          if (managesTransaction) {
+            await measureRuntimeSheetPhase(
+              input.completionDiagnostics,
+              'transactionBegin',
+              () => client.query('BEGIN'),
+            );
+          }
           try {
             if (input.statementTimeoutMs !== undefined) {
               await client.query(
@@ -2669,7 +2764,13 @@ async function withRuntimeSheetQueryClient<T>(
               );
             }
             const result = await operation(client);
-            if (managesTransaction) await client.query('COMMIT');
+            if (managesTransaction) {
+              await measureRuntimeSheetPhase(
+                input.completionDiagnostics,
+                'transactionCommit',
+                () => client.query('COMMIT'),
+              );
+            }
             return result;
           } catch (error) {
             if (managesTransaction) {
@@ -2687,13 +2788,22 @@ async function withRuntimeSheetQueryClient<T>(
               ? undefined
               : RUNTIME_SHEET_COMPLETION_SERVER_OPERATION_TIMEOUT_MS,
           signal: context.abortSignal,
+          completionDiagnostics: input.completionDiagnostics,
         },
       );
     },
   );
+  if (input.completionDiagnostics) {
+    return await measureRuntimeSheetPhase(
+      input.completionDiagnostics,
+      'queryClient',
+      () => resultPromise,
+    );
+  }
+  const result = await resultPromise;
   input.timings?.push({
     phase: 'query_client_total',
-    ms: Date.now() - totalStartedAt,
+    ms: Date.now() - resultStartedAt,
   });
   return result;
 }
@@ -8686,24 +8796,62 @@ export async function completeRuntimeMapRows(
     rows: input.rows.map((row) => row.data),
     outputFields: input.outputFields,
   });
-  const session = requireRuntimePostgresSession(
-    await getRuntimeDbSession(
-      {
-        ...context,
-        playName: context.playName,
-        runId: context.runId ?? input.runId,
-      },
-      {
-        tableNamespace: input.tableNamespace,
-        logicalTable: 'sheet_rows',
-        operations: ['rows.read', 'rows.upsert'],
-        limits: {
-          maxRows: runtimeDbSessionRowLimit(input.rows.length),
-        },
-        sheetContract,
-      },
-    ),
-  );
+  const completionDiagnostics = createRuntimeMapCompletionDiagnostics();
+  const completionStartedAt = Date.now();
+  let completionOutcome: 'succeeded' | 'failed' = 'failed';
+  let uniqueRowCount = 0;
+  let completedRowCount = 0;
+  let failedRowCount = 0;
+  let chunkCount = 0;
+  let updatedRowCount = 0;
+  let fencedRowCount = 0;
+  const logCompletion = () => {
+    console.info(
+      '[runtime-sheet-map-completion]',
+      JSON.stringify({
+        event: 'finished',
+        outcome: completionOutcome,
+        inputRows: input.rows.length,
+        uniqueRows: uniqueRowCount,
+        completedRows: completedRowCount,
+        failedRows: failedRowCount,
+        chunks: chunkCount,
+        updatedRows: updatedRowCount,
+        fencedRows: fencedRowCount,
+        ...completionDiagnostics,
+        totalMs: Date.now() - completionStartedAt,
+      }),
+    );
+  };
+  let session: RuntimePostgresSession;
+  try {
+    session = await measureRuntimeSheetPhase(
+      completionDiagnostics,
+      'dbSessionAcquire',
+      async () =>
+        requireRuntimePostgresSession(
+          await getRuntimeDbSession(
+            {
+              ...context,
+              playName: context.playName,
+              runId: context.runId ?? input.runId,
+            },
+            {
+              tableNamespace: input.tableNamespace,
+              logicalTable: 'sheet_rows',
+              operations: ['rows.read', 'rows.upsert'],
+              limits: {
+                maxRows: runtimeDbSessionRowLimit(input.rows.length),
+              },
+              sheetContract,
+            },
+          ),
+        ),
+    );
+  } catch (error) {
+    logCompletion();
+    throw error;
+  }
 
   // Dedupe by key. Last write wins on payload, status, and error.
   const uniqueRows = new Map<string, RuntimeApiRowRecord>();
@@ -8718,7 +8866,10 @@ export async function completeRuntimeMapRows(
     if (!resolvedKey) continue;
     uniqueRows.set(resolvedKey, { ...row, key: resolvedKey });
   }
+  uniqueRowCount = uniqueRows.size;
   if (uniqueRows.size === 0) {
+    completionOutcome = 'succeeded';
+    logCompletion();
     return classifyRuntimeMapRowsWrite({
       submittedKeys: [],
       updated: 0,
@@ -8735,6 +8886,9 @@ export async function completeRuntimeMapRows(
   });
   const chunks = chunkValues(completedRows, DIRECT_POSTGRES_BATCH_SIZE);
   const failedChunks = chunkValues(failedRows, DIRECT_POSTGRES_BATCH_SIZE);
+  completedRowCount = completedRows.length;
+  failedRowCount = failedRows.length;
+  chunkCount = chunks.length + failedChunks.length;
   const needsTransaction = true;
   const outputFields = [...new Set(input.outputFields ?? [])];
   const attemptId = input.attemptId?.trim() || null;
@@ -8752,7 +8906,7 @@ export async function completeRuntimeMapRows(
     );
   }
 
-  return await withRuntimeSheetQueryClient(
+  return withRuntimeSheetQueryClient(
     context,
     session,
     {
@@ -8761,6 +8915,7 @@ export async function completeRuntimeMapRows(
       sheetContract,
       transactional: needsTransaction,
       statementTimeoutMs: RUNTIME_SHEET_COMPLETION_STATEMENT_TIMEOUT_MS,
+      completionDiagnostics,
     },
     async (client) => {
       const completed =
@@ -8781,15 +8936,20 @@ export async function completeRuntimeMapRows(
                 ),
                 outputFields,
               };
-              const updated = await completeRuntimeMapRowChunks(
-                client,
-                session,
-                chunkInput,
+              const updated = await measureRuntimeSheetPhase(
+                completionDiagnostics,
+                'mapRowsUpdate',
+                () => completeRuntimeMapRowChunks(client, session, chunkInput),
               );
-              const inserted = await insertMissingCompletedMapRowChunks(
-                client,
-                session,
-                chunkInput,
+              const inserted = await measureRuntimeSheetPhase(
+                completionDiagnostics,
+                'missingRowsInsert',
+                () =>
+                  insertMissingCompletedMapRowChunks(
+                    client,
+                    session,
+                    chunkInput,
+                  ),
               );
               return {
                 updated: updated.updated + inserted.inserted,
@@ -8799,21 +8959,28 @@ export async function completeRuntimeMapRows(
           : { updated: 0, fencedRows: [] };
       const failed =
         failedRows.length > 0
-          ? await failRuntimeMapRowChunks(client, session, {
-              chunks: failedChunks,
-              physicalColumnProjections: projections,
-              forceTerminal: input.forceFailedRows === true,
-              runId: input.runId,
-              attemptId,
-              attemptOwnerRunId,
-              attemptExpiresAt,
-              attemptSeq,
-              writeVersion,
-              normalizedPlayName: normalizePlayNameForSheet(session.playName),
-              normalizedTableNamespace: normalizeTableNamespace(
-                input.tableNamespace,
-              ),
-            })
+          ? await measureRuntimeSheetPhase(
+              completionDiagnostics,
+              'failedRowsUpdate',
+              () =>
+                failRuntimeMapRowChunks(client, session, {
+                  chunks: failedChunks,
+                  physicalColumnProjections: projections,
+                  forceTerminal: input.forceFailedRows === true,
+                  runId: input.runId,
+                  attemptId,
+                  attemptOwnerRunId,
+                  attemptExpiresAt,
+                  attemptSeq,
+                  writeVersion,
+                  normalizedPlayName: normalizePlayNameForSheet(
+                    session.playName,
+                  ),
+                  normalizedTableNamespace: normalizeTableNamespace(
+                    input.tableNamespace,
+                  ),
+                }),
+            )
           : { updated: 0, fencedRows: [] };
       return classifyRuntimeMapRowsWrite({
         submittedKeys: uniqueRows.keys(),
@@ -8821,7 +8988,14 @@ export async function completeRuntimeMapRows(
         fencedRows: [...completed.fencedRows, ...failed.fencedRows],
       });
     },
-  );
+  )
+    .then((result) => {
+      updatedRowCount = result.updated;
+      fencedRowCount = result.fencedKeys.length;
+      completionOutcome = 'succeeded';
+      return result;
+    })
+    .finally(logCompletion);
 }
 
 /**

package/dist/bundling-sources/shared_libs/plays/csv-text-repair.ts

@@ -0,0 +1,145 @@
+/**
+ * Repair UTF-8 text that was decoded with the wrong single-byte code page and
+ * re-encoded ("mojibake"), the way Excel exports and copy-pasted sheets often
+ * arrive: "jérôme" as "jérôme" (read as Windows-1252) or "o’malley" as
+ * "o’malley" (read as Mac Roman).
+ *
+ * Why this exists: a 2026-08 ContactOut batch of 50 LinkedIn profiles was
+ * rejected outright because one slug carried "o’malley", and the same corrupt
+ * URLs had already been sent to LimaData and LeadMagic as paid misses. The
+ * corruption is in the customer's file, so the fix belongs where every CSV
+ * enters a Play: the runtime's CSV parser and the CLI's local CSV reader.
+ *
+ * Only runs of non-ASCII characters are touched, and a run is rewritten only
+ * when mapping it back through one of the two code pages yields strictly
+ * valid UTF-8. Correctly encoded text ("José", "Zoltán Erdős", CJK, emoji)
+ * never satisfies that test and passes through unchanged.
+ */
+
+/** Windows-1252 bytes 0x80-0x9F that are not Latin-1 identity. */
+const CP1252_HIGH_TO_BYTE = new Map<number, number>([
+  [0x20ac, 0x80],
+  [0x201a, 0x82],
+  [0x0192, 0x83],
+  [0x201e, 0x84],
+  [0x2026, 0x85],
+  [0x2020, 0x86],
+  [0x2021, 0x87],
+  [0x02c6, 0x88],
+  [0x2030, 0x89],
+  [0x0160, 0x8a],
+  [0x2039, 0x8b],
+  [0x0152, 0x8c],
+  [0x017d, 0x8e],
+  [0x2018, 0x91],
+  [0x2019, 0x92],
+  [0x201c, 0x93],
+  [0x201d, 0x94],
+  [0x2022, 0x95],
+  [0x2013, 0x96],
+  [0x2014, 0x97],
+  [0x02dc, 0x98],
+  [0x2122, 0x99],
+  [0x0161, 0x9a],
+  [0x203a, 0x9b],
+  [0x0153, 0x9c],
+  [0x017e, 0x9e],
+  [0x0178, 0x9f],
+]);
+
+/** Mac OS Roman bytes 0x80-0xFF, in order (Python `bytes(range(128,256)).decode('mac_roman')`). */
+const MAC_ROMAN_HIGH =
+  'ÄÅÇÉÑÖÜáàâäãåçéè' +
+  'êëíìîïñóòôöõúùûü' +
+  '†°¢£§•¶ß®©™´¨≠ÆØ' +
+  '∞±≤≥¥µ∂∑∏π∫ªºΩæø' +
+  '¿¡¬√ƒ≈∆«»… ÀÃÕŒœ' +
+  '–—“”‘’÷◊ÿŸ⁄€‹›fifl' +
+  '‡·‚„‰ÂÊÁËÈÍÎÏÌÓÔ' +
+  'ÒÚÛÙıˆ˜¯˘˙˚¸˝˛ˇ';
+const MAC_ROMAN_TO_BYTE = new Map<number, number>(
+  [...MAC_ROMAN_HIGH].map((ch, i) => [ch.codePointAt(0)!, 0x80 + i] as const),
+);
+
+const STRICT_UTF8 = new TextDecoder('utf-8', { fatal: true });
+
+function cp1252Byte(code: number): number | null {
+  if (code < 0x100) return code;
+  return CP1252_HIGH_TO_BYTE.get(code) ?? null;
+}
+
+function macRomanByte(code: number): number | null {
+  if (code < 0x80) return code;
+  return MAC_ROMAN_TO_BYTE.get(code) ?? null;
+}
+
+function decodeAs(
+  run: string,
+  toByte: (code: number) => number | null,
+): string | null {
+  const bytes = new Uint8Array(run.length);
+  let i = 0;
+  for (const ch of run) {
+    const byte = toByte(ch.codePointAt(0)!);
+    if (byte === null) return null;
+    bytes[i++] = byte;
+  }
+  // A real mojibake run always encodes at least one multi-byte sequence, so it
+  // must contain a UTF-8 lead byte; a lone Latin-1 letter never does.
+  if (!bytes.subarray(0, i).some((b) => b >= 0xc2 && b <= 0xf4)) return null;
+  try {
+    return STRICT_UTF8.decode(bytes.subarray(0, i));
+  } catch {
+    return null;
+  }
+}
+
+/** Maximal runs of non-ASCII characters are the only places mojibake can live. */
+const NON_ASCII_RUN = /[^\u0000-\u007f]+/g;
+
+/**
+ * Return `value` with mis-decoded UTF-8 runs repaired. Text that is already
+ * valid UTF-8 comes back identical (same string instance when nothing changed).
+ */
+export function repairMisdecodedText(value: string): string {
+  // Fast path: pure ASCII cannot be mojibake.
+  if (!/[^\u0000-\u007f]/.test(value)) return value;
+  let changed = false;
+  const repaired = value.replace(NON_ASCII_RUN, (run) => {
+    const fixed = decodeAs(run, cp1252Byte) ?? decodeAs(run, macRomanByte);
+    if (fixed === null || fixed === run) return run;
+    changed = true;
+    return fixed;
+  });
+  return changed ? repaired : value;
+}
+
+/** Repair every string value of a parsed CSV record in place and return it. */
+export function repairRecordText<T extends Record<string, unknown>>(
+  record: T,
+): T {
+  for (const key of Object.keys(record)) {
+    const value = record[key];
+    if (typeof value === 'string') {
+      (record as Record<string, unknown>)[key] = repairMisdecodedText(value);
+    }
+  }
+  return record;
+}
+
+/**
+ * `csv-parse` options every CSV entry point shares: strip a UTF-8 BOM, repair
+ * mojibake in header names (a corrupt header never matches a column mapping)
+ * and in every string cell.
+ */
+export function csvInputTextOptions(): {
+  bom: true;
+  columns: (header: string[]) => string[];
+  on_record: <T extends Record<string, unknown>>(record: T) => T;
+} {
+  return {
+    bom: true,
+    columns: (header) => header.map(repairMisdecodedText),
+    on_record: repairRecordText,
+  };
+}

package/dist/cli/auth-4HCZZPZH.js

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

package/dist/cli/{auth-IPOSX2NV.mjs → auth-YQSQYS2V.mjs}

@@ -9,11 +9,11 @@ import {
   registerAuthCommands,
   reportSetupCompleted,
   resolvePendingAuthClaimForResume
-} from "./chunk-QV2WIEUP.mjs";
-import "./chunk-2Y2QZJBT.mjs";
-import "./chunk-W6LB26RC.mjs";
+} from "./chunk-MLO7ZGSH.mjs";
+import "./chunk-NTIWTBEH.mjs";
+import "./chunk-JDSRPSES.mjs";
 import "./chunk-DLIRSHV6.mjs";
-import "./chunk-U5L6FIIL.mjs";
+import "./chunk-EWYAS4WD.mjs";
 import "./chunk-NXGCO4JB.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";