deepline 0.3.328 → 0.3.329

package/dist/bundling-sources/shared_libs/play-runtime/tool-result.ts

@@ -32,6 +32,8 @@ import {
   type JobChangeStatus,
 } from '../plays/extractor-targets';
 import type {
+  BasicToolExecuteResult,
+  BasicToolResultListAccessor,
   SerializedToolExecuteResult,
   ToolExecuteResult,
   ToolResultBilling,
@@ -47,6 +49,7 @@ import type {
 import {
   createDeferredPlayDataset,
   createPlayDataset,
+  isPlayDataset,
   isSerializedPlayDataset,
   residentPlayDatasetRows,
   trimSerializedPlayDatasetPreview,
@@ -75,6 +78,116 @@ const SERIALIZED_TOOL_RESULT_LIST_PREVIEW_LIMIT = 5;
 const LIVE_TOOL_RESULT_LIST_DATASET_REGISTRY_LIMIT = 256;
 const SERIALIZED_TOOL_LIST_ROWS = Symbol('deepline.serialized_tool_list_rows');
 
+// Artifact-specific array getters must not change the receipt's dataset
+// descriptor or call a getter while serializing. Keep their backing private.
+// The runner and customer SDK can be independently bundled copies. A module-
+// local WeakMap cannot cross that boundary; a non-enumerable shared symbol can.
+const ARRAY_GETTER_DATASET = Symbol.for('deepline.list_dataset');
+
+function listAccessorDataset(
+  accessor: ToolResultListAccessor | BasicToolResultListAccessor,
+): PlayDataset<Record<string, unknown>> {
+  const dataset =
+    (
+      accessor as typeof accessor & {
+        [ARRAY_GETTER_DATASET]?: PlayDataset<Record<string, unknown>>;
+      }
+    )[ARRAY_GETTER_DATASET] ?? accessor.get();
+  if (!isPlayDataset(dataset)) {
+    throw new Error(
+      'List accessor has no backing dataset for an explicit read.',
+    );
+  }
+  return dataset;
+}
+
+/**
+ * Reader-first policy selected at the Play boundary, not by the provider.
+ * The canonical receipt and editions 1–9 retain their dataset projection.
+ * Edition 10 exposes complete resident response lists as ordinary arrays.
+ */
+export function projectToolResultListGetters(
+  result: ToolExecuteResult,
+  policy: 'array',
+): BasicToolExecuteResult;
+export function projectToolResultListGetters(
+  result: ToolExecuteResult,
+  policy: 'dataset' | 'array',
+): ToolExecuteResult;
+export function projectToolResultListGetters(
+  result: ToolExecuteResult,
+  policy: 'dataset' | 'array',
+): ToolExecuteResult | BasicToolExecuteResult {
+  if (policy === 'dataset') return result;
+  const extractedLists = Object.fromEntries(
+    Object.entries(result.extractedLists).map(([name, original]) => {
+      const dataset = listAccessorDataset(original);
+      const accessor = {
+        path: original.path,
+        count: original.count,
+        keys: original.keys,
+      };
+      Object.defineProperty(accessor, 'get', {
+        enumerable: false,
+        value() {
+          const rows = residentPlayDatasetRows(dataset);
+          if (
+            !rows ||
+            (original.count !== null && rows.length < original.count)
+          ) {
+            throw new Error(
+              `List getter ${name} cannot return a complete array: its rows are lazy or the retained response is incomplete. Use readList(result, ${JSON.stringify(original.path)}) to read the explicit dataset; never treat its preview as complete.`,
+            );
+          }
+          // Legacy dataset rows wrap scalar list items as {value}. A basic
+          // getter preserves the provider's array items, including primitives.
+          const canonicalRaw = Object.hasOwn(result.toolResponse, 'rawV2')
+            ? legacyRawFromToolResponseRawV2(
+                result.toolResponse.rawV2,
+                result.toolResponse.view ?? 'rawV2',
+              )
+            : result.toolResponse.raw;
+          for (const raw of [canonicalRaw, result.toolResponse.raw]) {
+            const originalRows = getAtPath(
+              { toolResponse: { raw } },
+              original.path,
+            );
+            if (
+              Array.isArray(originalRows) &&
+              originalRows.length === rows.length
+            ) {
+              return [...originalRows];
+            }
+          }
+          return [...rows];
+        },
+      });
+      Object.defineProperty(accessor, ARRAY_GETTER_DATASET, {
+        value: dataset,
+        enumerable: false,
+      });
+      return [name, accessor];
+    }),
+  );
+  // This descriptor map builds a different public view; it is not the
+  // canonical dataset-valued ToolExecuteResult descriptor type.
+  const descriptors: PropertyDescriptorMap =
+    Object.getOwnPropertyDescriptors(result);
+  descriptors.extractedLists = {
+    ...descriptors.extractedLists,
+    value: extractedLists,
+  };
+  // Canonical receipt construction stays dataset-valued. Public source types and
+  // cloud declarations describe the edition-selected view, not this storage form.
+  const projected = Object.create(Object.getPrototypeOf(result), descriptors);
+  const evidence = savedToolCallEvidence.get(result);
+  if (evidence !== undefined) savedToolCallEvidence.set(projected, evidence);
+  const relayReference = relayPublishedResultReferences.get(result);
+  if (relayReference)
+    relayPublishedResultReferences.set(projected, relayReference);
+  return projected;
+}
+
 /**
  * A live tool result may have been durably published by the execution relay
  * before the runner sees its provider body. Keep that transport-only fact out
@@ -1260,7 +1373,7 @@ function buildExtractedAccessors(
 }
 
 function serializedTargetValuesFromResult(
-  value: ToolExecuteResult,
+  value: ToolExecuteResult | BasicToolExecuteResult,
 ): Record<string, ToolResultTargetMetadata> | undefined {
   const targets = value._metadata.targets;
   return Object.keys(targets).length > 0 ? targets : undefined;
@@ -1452,7 +1565,9 @@ export function isToolExecuteResult(
   );
 }
 
-function resultRootOf(result: ToolExecuteResult): unknown {
+function resultRootOf(
+  result: ToolExecuteResult | BasicToolExecuteResult,
+): unknown {
   return { toolResponse: result.toolOutput };
 }
 
@@ -1461,7 +1576,7 @@ function resultRootOf(result: ToolExecuteResult): unknown {
  * selector paths, then by key. Used by SDK play helpers (`extractValue`).
  */
 export function readValue(
-  result: ToolExecuteResult,
+  result: ToolExecuteResult | BasicToolExecuteResult,
   selector: readonly string[] | string,
 ): unknown {
   if (typeof selector === 'string') {
@@ -1484,14 +1599,14 @@ export function readValue(
  * declared list accessor. Companion to {@link readValue} for `extractList`.
  */
 export function readList(
-  result: ToolExecuteResult,
+  result: ToolExecuteResult | BasicToolExecuteResult,
   selector?: readonly string[] | string,
 ): PlayDataset<Record<string, unknown>> | Record<string, unknown>[] {
   if (selector) {
     const paths = Array.isArray(selector) ? selector : [selector];
     const declaredList = findDeclaredListAccessor(result, paths);
     if (declaredList && preservedSerializedListRows(result)) {
-      return declaredList.get();
+      return listAccessorDataset(declaredList);
     }
     const found = findFirstTargetByPath(resultRootOf(result), paths)?.value;
     const rows = normalizeRows(found);
@@ -1501,13 +1616,14 @@ export function readList(
         typeof declaredList.count === 'number' &&
         declaredList.count > rows.length
       ) {
-        return declaredList.get();
+        return listAccessorDataset(declaredList);
       }
       return rows;
     }
-    if (declaredList) return declaredList.get();
+    if (declaredList) return listAccessorDataset(declaredList);
   }
-  return Object.values(result.extractedLists)[0]?.get() ?? [];
+  const first = Object.values(result.extractedLists)[0];
+  return first ? listAccessorDataset(first) : [];
 }
 
 export function attachToolResultListDataset<T extends Record<string, unknown>>(
@@ -1579,9 +1695,9 @@ function normalizeListPathForMatch(path: string): string {
 }
 
 function findDeclaredListAccessor(
-  result: ToolExecuteResult,
+  result: ToolExecuteResult | BasicToolExecuteResult,
   paths: readonly string[],
-): ToolResultListAccessor | undefined {
+): ToolResultListAccessor | BasicToolResultListAccessor | undefined {
   const candidates = new Set(
     paths.flatMap((path) =>
       candidateResultPaths(path).flatMap((candidate) => [
@@ -1591,7 +1707,9 @@ function findDeclaredListAccessor(
     ),
   );
   return Object.values(result.extractedLists).find((list) =>
-    candidates.has(normalizeListPathForMatch(list.path)),
+    candidateResultPaths(list.path).some((path) =>
+      candidates.has(normalizeListPathForMatch(path)),
+    ),
   );
 }
 
@@ -1621,11 +1739,11 @@ function replaceAtPath(
 }
 
 function serializedListDatasetsFromResult(
-  value: ToolExecuteResult,
+  value: ToolExecuteResult | BasicToolExecuteResult,
 ): Record<string, SerializedPlayDataset<Record<string, unknown>>> | undefined {
   const entries = Object.entries(value.extractedLists).flatMap(
     ([name, accessor]) => {
-      const dataset = accessor.get();
+      const dataset = listAccessorDataset(accessor);
       const serialized = dataset.toJSON();
       if (!isSerializedPlayDataset<Record<string, unknown>>(serialized)) {
         return [];
@@ -1710,7 +1828,7 @@ function serializedListRowsFromRawV2(input: {
 }
 
 function preservedSerializedListRows(
-  value: ToolExecuteResult,
+  value: ToolExecuteResult | BasicToolExecuteResult,
 ): Record<string, Array<Record<string, unknown>>> | undefined {
   const rows = (
     value as ToolExecuteResult & {
@@ -1723,7 +1841,7 @@ function preservedSerializedListRows(
 }
 
 function serializedListRowsFromResult(input: {
-  value: ToolExecuteResult;
+  value: ToolExecuteResult | BasicToolExecuteResult;
   metadata: ToolResultMetadataInput;
   listDatasets:
     | Record<string, SerializedPlayDataset<Record<string, unknown>>>
@@ -1741,7 +1859,8 @@ function serializedListRowsFromResult(input: {
   ]);
   const entries = [...names].flatMap((name) => {
     const dataset = input.listDatasets?.[name];
-    const liveDataset = input.value.extractedLists[name]?.get();
+    const accessor = input.value.extractedLists[name];
+    const liveDataset = accessor ? listAccessorDataset(accessor) : undefined;
     const residentRows = liveDataset
       ? residentPlayDatasetRows(liveDataset)
       : null;
@@ -1806,6 +1925,7 @@ function rawWithSerializedListRows(input: {
     | Record<string, SerializedPlayDataset<Record<string, unknown>>>
     | undefined;
   listRows: Record<string, Array<Record<string, unknown>>> | undefined;
+  preserveComplete?: boolean;
 }): unknown {
   if (!input.listRows || Object.keys(input.listRows).length === 0) {
     return input.raw;
@@ -1821,7 +1941,11 @@ function rawWithSerializedListRows(input: {
       (candidate, index, all) => all.indexOf(candidate) === index,
     );
     for (const candidate of candidates) {
-      if (!Array.isArray(getAtPath(root, candidate))) continue;
+      const existing = getAtPath(root, candidate);
+      if (!Array.isArray(existing)) continue;
+      // Compatibility dataset rows wrap primitives; never substitute those
+      // wrappers for an already-complete canonical provider response.
+      if (input.preserveComplete && existing.length >= rows.length) break;
       root = replaceAtPath(root, candidate, rows);
       break;
     }
@@ -1948,7 +2072,7 @@ function applySerializedListDatasets(
 }
 
 function metadataInputFromToolExecuteResult(
-  value: ToolExecuteResult,
+  value: ToolExecuteResult | BasicToolExecuteResult,
 ): ToolResultMetadataInput {
   return {
     toolId: value._metadata.toolId,
@@ -2062,6 +2186,7 @@ function rawV2WithSerializedListRows(input: {
       ...input.rawV2,
       data: rawWithSerializedListRows({
         raw: input.rawV2.data,
+        preserveComplete: true,
         lists: input.lists,
         listDatasets: input.listDatasets,
         listRows: input.listRows,
@@ -2070,6 +2195,7 @@ function rawV2WithSerializedListRows(input: {
   }
   return rawWithSerializedListRows({
     raw: input.rawV2,
+    preserveComplete: true,
     lists: input.lists,
     listDatasets: input.listDatasets,
     listRows: input.listRows,
@@ -2111,7 +2237,7 @@ function fitSavedCallEvidence(
 }
 
 export function serializeToolExecuteResult(
-  value: ToolExecuteResult,
+  value: ToolExecuteResult | BasicToolExecuteResult,
   options?: { includeCallEvidence?: boolean },
 ): SerializedToolExecuteResult {
   const callEvidence =

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

@@ -2,17 +2,20 @@ import { Type, type Static, type TSchema } from '@sinclair/typebox';
 import { Value } from '@sinclair/typebox/value';
 import type { PreviousCell } from './cell-staleness';
 import type { PlaySandboxRuntimeLimits } from './sandbox-runtime-limits';
-import type { ToolExecuteResult } from './tool-result-types';
+import type {
+  BasicToolExecuteResult,
+  ToolExecuteResult,
+} from './tool-result-types';
 import type { ToolExecutionErrorSchemaVersion } from './tool-execution-error';
 import type { PlayDataset, PlayDatasetInput, PlayDatasetRow } from './dataset';
 
 export const LEGACY_PLAY_AUTHORING_CONTRACT_EDITION = 1 as const;
-// Reader-first rollout: accept edition 9, but keep new bundles on edition 8
-// until the edition-9 runtime reader has completed deployment.
-export const PLAY_AUTHORING_CONTRACT_EDITION = 8 as const;
+// New source uses ordinary list values. Historical artifacts keep their pinned
+// edition; deploy the edition-10 reader before promoting this writer.
+export const PLAY_AUTHORING_CONTRACT_EDITION = 10 as const;
 export const PLAY_AUTHORING_INPUT_SCHEMA_SNAPSHOT_EDITION = 3 as const;
 export const SUPPORTED_PLAY_AUTHORING_CONTRACT_EDITIONS = [
-  1, 2, 3, 4, 5, 6, 7, 8, 9,
+  1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
 ] as const;
 
 export type PlayAuthoringContractEdition =
@@ -84,8 +87,22 @@ const PLAY_AUTHORING_CONTRACT_CHANGELOG_DETAILS = [
     newWritesEnd: null,
     readerRemoval: null,
   },
+  {
+    changed:
+      'List getters return ordinary arrays from the complete resident tool response. Lazy database datasets require an explicit dataset read; incomplete historical previews fail rather than masquerade as complete arrays. Editions 1–9 retain dataset-valued getters; stored tool receipts are unchanged.',
+    compatibilityOwner: 'Plays Runtime',
+    newWritesEnd: null,
+    readerRemoval: null,
+  },
 ] as const;
 
+/** Authoring types and runtime projection must select the same getter contract. */
+export function playToolListGetterMode(
+  edition: PlayAuthoringContractEdition = PLAY_AUTHORING_CONTRACT_EDITION,
+): 'dataset' | 'array' {
+  return edition >= 10 ? 'array' : 'dataset';
+}
+
 export const PLAY_AUTHORING_CONTRACT_CHANGELOG =
   SUPPORTED_PLAY_AUTHORING_CONTRACT_EDITIONS.map((edition, index) => ({
     edition,
@@ -1461,7 +1478,9 @@ export const PLAY_AUTHORING_STATIC_FETCH_KEY_HINT =
   `${PLAY_AUTHORING_DOCUMENTATION.staticCallKeys.workaround} Do not compute the key.` as const;
 
 /** The complete customer-authored `ctx` Interface shared by every Adapter. */
-export interface PlayAuthoringRuntimeContext {
+export interface PlayAuthoringRuntimeContext<
+  TListGetter extends 'dataset' | 'array' = 'dataset',
+> {
   /**
    * Load a staged CSV file as a durable dataset handle.
    * @sdkReference runtime 040 ctx.csv(path, options)
@@ -1481,7 +1500,7 @@ export interface PlayAuthoringRuntimeContext {
   ): PlayAuthoringDatasetBuilder<
     PlayDatasetRow<TSource> & object,
     PlayDatasetRow<TSource> & object,
-    PlayAuthoringRuntimeContext
+    PlayAuthoringRuntimeContext<TListGetter>
   >;
 
   /** @deprecated `ctx.map(...)` was replaced by `ctx.dataset(...)`. */
@@ -1506,7 +1525,11 @@ export interface PlayAuthoringRuntimeContext {
      */
     execute<TOutput = PlayLooseObject>(
       request: PlayToolExecutionRequest,
-    ): Promise<ToolExecuteResult<TOutput>>;
+    ): Promise<
+      TListGetter extends 'array'
+        ? BasicToolExecuteResult<TOutput>
+        : ToolExecuteResult<TOutput>
+    >;
   };
 
   customerDb: {
@@ -1522,7 +1545,11 @@ export interface PlayAuthoringRuntimeContext {
     toolId: string,
     input: Record<string, unknown>,
     options?: { description?: string },
-  ): Promise<ToolExecuteResult<TOutput>>;
+  ): Promise<
+    TListGetter extends 'array'
+      ? BasicToolExecuteResult<TOutput>
+      : ToolExecuteResult<TOutput>
+  >;
 
   /**
    * Execute one reusable step program against a scalar input.
@@ -1531,7 +1558,7 @@ export interface PlayAuthoringRuntimeContext {
   runSteps<TInput extends Record<string, unknown>, TOutput>(
     program: PlayAuthoringRunnableStepProgram<
       TOutput,
-      PlayAuthoringRuntimeContext
+      PlayAuthoringRuntimeContext<TListGetter>
     > & { readonly __inputType?: (input: TInput) => void },
     input: TInput,
     options?: PlayAuthoringRunStepsOptions,

package/dist/bundling-sources/shared_libs/plays/dataset.ts

@@ -153,6 +153,9 @@ export interface PlayDataset<T> extends AsyncIterable<T> {
    * Explicit escape hatch for bounded result sets.
    * Large datasets should flow by handle through Neon-backed storage, not
    * through worker memory as giant arrays.
+   * No argument loads the complete current handle within the memory cap or
+   * throws. A numeric limit loads only a prefix, not proof of completeness.
+   * Materializing a tool-result list does not fetch more provider pages.
    */
   materialize(options?: number | PlayDatasetMaterializeOptions): Promise<T[]>;
   toJSON(): {

package/dist/bundling-sources/shared_libs/plays/tool-result-types.ts

@@ -86,9 +86,59 @@ export type ToolResultListAccessor<
   TKey extends string = string,
 > = Omit<ToolResultListMetadata, 'keys'> & {
   keys: Partial<Record<TKey, string>> & Record<string, string>;
+  /**
+   * Editions 1–9: dataset handle, not a JavaScript array. Edition 10 uses
+   * BasicToolResultListAccessor instead; its .get() returns an ordinary array.
+   * Pass it to ctx.dataset, use first() or async iteration, or await
+   * get().materialize() for the complete current list within the memory cap.
+   * materialize(n) and peek(n) return a prefix; none fetch provider pages.
+   */
   get(): PlayDataset<T>;
 };
 
+/** Edition-10 getter: ordinary data, not a dataset or a promise. */
+export type BasicToolResultListAccessor<
+  T = Record<string, unknown>,
+  TKey extends string = string,
+> = Omit<ToolResultListAccessor<T, TKey>, 'get'> & {
+  /** Complete resident response list. Throws for a lazy or incomplete list. */
+  get(): T[];
+};
+
+export type BasicToolExecuteResultBase<
+  TResult = unknown,
+  TMeta = Record<string, unknown>,
+> = Omit<ToolExecuteResultBase<TResult, TMeta>, 'extractedLists'> & {
+  extractedLists: Record<string, BasicToolResultListAccessor>;
+};
+
+export type BasicToolExecuteResultAccessors<
+  TExtracted extends Record<string, unknown> = Partial<DeeplineGetterValueMap>,
+  TLists extends Record<string, Record<string, unknown>> = Record<
+    string,
+    Record<string, unknown>
+  >,
+> = {
+  extractedValues: {
+    [K in keyof TExtracted]: ToolResultTargetAccessor<TExtracted[K]>;
+  };
+  extractedLists: {
+    [K in keyof TLists]: BasicToolResultListAccessor<TLists[K]>;
+  };
+};
+
+/** Public source-SDK result for new Plays; receipts retain the canonical form. */
+export type BasicToolExecuteResult<
+  TResult = unknown,
+  TMeta = Record<string, unknown>,
+  TExtracted extends Record<string, unknown> = Partial<DeeplineGetterValueMap>,
+  TLists extends Record<string, Record<string, unknown>> = Record<
+    string,
+    Record<string, unknown>
+  >,
+> = BasicToolExecuteResultBase<TResult, TMeta> &
+  BasicToolExecuteResultAccessors<TExtracted, TLists>;
+
 export type ToolResultMetadataInput = {
   toolId: string;
   extractors?: Record<string, ToolResultExtractorDescriptor>;
@@ -220,17 +270,16 @@ export type ToolExecuteResultAccessors<
 /**
  * Canonical result returned by Deepline tool execution.
  *
- * The top-level object is Deepline-owned execution metadata and semantic
- * extraction state. The canonical provider response lives under
- * `toolResponse.rawV2`. Response metadata lives under `toolResponse.meta`. Semantic single-value
- * getters live under `extractedValues.<name>.get()`, and list getters live
- * under `extractedLists.<name>.get()`.
+ * Provider data: `toolResponse.rawV2`; metadata: `toolResponse.meta`.
+ * Single-value getters: `extractedValues.<name>.get()`; lists: `extractedLists.<name>.get()`.
  *
- * Use extractors first when a tool contract exposes them. Use list getters for
- * row-shaped data. Use `toolResponse.rawV2` for provider-specific fields or
- * debugging. Inspect the observed response before selecting a nested field;
- * provider envelopes are preserved, including pagination and sibling resources.
- * This is parsed, scrubbed data, not the original HTTP bytes or headers.
+ * Prefer declared getters. New Plays (edition 10) receive ordinary arrays from
+ * list `.get()` synchronously; persist explicitly with ctx.dataset. Lazy or
+ * incomplete lists throw: use readList(result, path) for explicit dataset access.
+ * Provider pagination requires a separate request; getters never fetch it.
+ * Historical editions 1–9 retain PlayDataset getters and async materialize/peek;
+ * missing getters never mean empty results. Inspect rawV2 for debugging: parsed,
+ * scrubbed envelopes, pagination and siblings, not HTTP bytes or headers.
  *
  * @sdkReference runtime 200
  */

package/dist/cli/{auth-ANHHABWT.mjs → auth-MFFVOITR.mjs}

@@ -9,11 +9,11 @@ import {
   registerAuthCommands,
   reportSetupCompleted,
   resolvePendingAuthClaimForResume
-} from "./chunk-SMGNDW7O.mjs";
-import "./chunk-B2R66UTW.mjs";
-import "./chunk-WWVE4HFN.mjs";
+} from "./chunk-MFQQINUY.mjs";
+import "./chunk-EROOAI5G.mjs";
+import "./chunk-FK7PW6BP.mjs";
 import "./chunk-DLIRSHV6.mjs";
-import "./chunk-YFCHBN3C.mjs";
+import "./chunk-GCNER3HV.mjs";
 import "./chunk-NXGCO4JB.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";

package/dist/cli/auth-W2MQM6GQ.js

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

package/dist/cli/{billing-R6NYYO6G.mjs → billing-LRBHWLIQ.mjs}

@@ -1,7 +1,7 @@
 import {
   DeeplineClient,
   iterateCursorPages
-} from "./chunk-7R6KQSFA.mjs";
+} from "./chunk-OZGU7P2S.mjs";
 import "./chunk-CBVIJSHF.mjs";
 import {
   createTimestampedName,
@@ -9,13 +9,13 @@ import {
   openInBrowser,
   printCommandEnvelope,
   shouldEmitJson
-} from "./chunk-B2R66UTW.mjs";
+} from "./chunk-EROOAI5G.mjs";
 import {
   AuthError,
   ConfigError
-} from "./chunk-WWVE4HFN.mjs";
+} from "./chunk-FK7PW6BP.mjs";
 import "./chunk-DLIRSHV6.mjs";
-import "./chunk-YFCHBN3C.mjs";
+import "./chunk-GCNER3HV.mjs";
 import "./chunk-6IKARAYD.mjs";
 import {
   DeeplineError