deepline 0.1.157 → 0.1.159

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/map-chunk-plan.ts

@@ -1,11 +1,14 @@
 import {
   chooseMapChunkSize,
+  EXECUTION_PLAN_DEFAULTS,
   type ExecutionPlan,
 } from '../../../../shared_libs/play-runtime/execution-plan';
 import { TOOL_CALLING_MAP_CHUNK_SIZE } from '../../../../shared_libs/play-runtime/map-chunk-limits';
 
 export const CACHE_ENABLED_SIMPLE_MAP_CHUNK_SIZE = 10_000;
 export { TOOL_CALLING_MAP_CHUNK_SIZE };
+export const WORKER_SUBREQUEST_SAFE_TOOL_CALLS_PER_CHUNK =
+  TOOL_CALLING_MAP_CHUNK_SIZE;
 
 export type WorkerMapChunkPlanInput = {
   mapName: string;
@@ -29,11 +32,52 @@ export function chooseWorkerMapRowsPerChunk(
     preferredChunkSize: planMap?.defaultChunkSize,
     softWorkflowStepBudget: plan?.chunkPlan.softWorkflowStepBudget,
   });
+  const estimatedSubrequestProducingSteps =
+    estimateSubrequestProducingStepsForMap(plan, planMap);
+  if (estimatedSubrequestProducingSteps > 0) {
+    const subrequestSafeRows = Math.max(
+      1,
+      Math.floor(
+        WORKER_SUBREQUEST_SAFE_TOOL_CALLS_PER_CHUNK /
+          estimatedSubrequestProducingSteps,
+      ),
+    );
+    if (subrequestSafeRows < rowsPerChunk) {
+      if (input.rowCountHint === null || !Number.isFinite(input.rowCountHint)) {
+        return subrequestSafeRows;
+      }
+      const totalRows = Math.max(0, Math.floor(input.rowCountHint));
+      const mapCount = Math.max(1, plan?.maps.length ?? 1);
+      const softBudget =
+        plan?.chunkPlan.softWorkflowStepBudget ??
+        EXECUTION_PLAN_DEFAULTS.workflowSoftStepBudget;
+      const maxChunksPerMap = Math.max(
+        1,
+        Math.floor(
+          Math.max(
+            mapCount,
+            Math.floor(
+              (softBudget -
+                EXECUTION_PLAN_DEFAULTS.ingestStepCount -
+                EXECUTION_PLAN_DEFAULTS.finalizationStepCount) /
+                estimatedSubrequestProducingSteps,
+            ),
+          ) / mapCount,
+        ),
+      );
+      const requiredChunks = Math.ceil(totalRows / subrequestSafeRows);
+      if (requiredChunks <= maxChunksPerMap) return subrequestSafeRows;
+      throw new Error(
+        `Worker budget exceeded for map "${input.mapName}": ${requiredChunks}/${maxChunksPerMap} chunks.`,
+      );
+    }
+    return rowsPerChunk;
+  }
 
   const toolFreeSimpleMap =
     !!planMap &&
     planMap.stepsPerChunk === 1 &&
-    !mapDoesExternalWork(planMap, plan);
+    estimateSubrequestProducingStepsForMap(plan, planMap) === 0;
   if (
     toolFreeSimpleMap &&
     (input.rowCountHint === null ||
@@ -42,55 +86,75 @@ export function chooseWorkerMapRowsPerChunk(
     return Math.max(rowsPerChunk, CACHE_ENABLED_SIMPLE_MAP_CHUNK_SIZE);
   }
 
-  if (
-    mapDoesExternalWork(planMap, plan) &&
-    input.rowCountHint !== null &&
-    input.rowCountHint <= rowsPerChunk
-  ) {
-    return Math.min(rowsPerChunk, TOOL_CALLING_MAP_CHUNK_SIZE);
-  }
-
   return rowsPerChunk;
 }
 
-function mapDoesExternalWork(
-  planMap: ExecutionPlan['maps'][number] | undefined,
+function estimateSubrequestProducingStepsForMap(
   plan: ExecutionPlan | null,
-): boolean {
-  if (Array.isArray(planMap?.externalStepFields)) {
-    return planMap.externalStepFields.length > 0;
-  }
-  if (!plan?.toolDeclarations.length) {
-    return false;
-  }
+  planMap: ExecutionPlan['maps'][number] | undefined,
+): number {
+  const toolDeclarations = plan?.toolDeclarations ?? [];
   if (!planMap) {
-    return true;
+    return toolDeclarations.length;
+  }
+  const explicitExternalSteps = Array.isArray(planMap.externalStepFields)
+    ? planMap.externalStepFields.length
+    : 0;
+  const mapStepsPerChunk =
+    explicitExternalSteps > 0
+      ? 0
+      : (planMap.stepsPerChunk ?? 1) > 1
+        ? (planMap.stepsPerChunk ?? 1)
+        : 0;
+  if (toolDeclarations.length === 0) {
+    return Math.max(mapStepsPerChunk, explicitExternalSteps);
   }
-  const outputFields = new Set(planMap.outputFields);
+  const outputFields = new Set(
+    planMap.outputFields.map((field) => field.trim()).filter(Boolean),
+  );
+  const explicitExternalStepFields = new Set(
+    (planMap.externalStepFields ?? [])
+      .map((field) => field.trim())
+      .filter(Boolean),
+  );
+  const hasModernStepMetadata =
+    Array.isArray(planMap.stepFields) ||
+    Array.isArray(planMap.externalStepFields);
   const mapFields = new Set([
     planMap.mapName,
     planMap.tableNamespace,
     ...planMap.outputFields,
-    ...(planMap.stepFields ?? []),
     ...(planMap.externalStepFields ?? []),
+    ...(hasModernStepMetadata ? [] : (planMap.stepFields ?? [])),
     ...planMap.waterfallStages.flatMap((stage) => [
       stage.waterfallId,
       ...stage.stageIds,
     ]),
   ]);
-  return plan.toolDeclarations.some((tool) => {
-    const field = tool.field?.trim();
-    if (!field) {
-      return false;
-    }
+  let scopedToolDeclarations = 0;
+  for (const declaration of toolDeclarations) {
+    const field = declaration.field?.trim();
+    if (!field) continue;
     if (mapFields.has(field)) {
-      return true;
+      scopedToolDeclarations += 1;
+      continue;
     }
     if (!field.includes('.')) {
-      return false;
+      continue;
     }
     const firstSegment = field.slice(0, field.indexOf('.'));
     const lastSegment = field.slice(field.lastIndexOf('.') + 1);
-    return outputFields.has(firstSegment) || outputFields.has(lastSegment);
-  });
+    if (
+      outputFields.has(firstSegment) ||
+      explicitExternalStepFields.has(lastSegment) ||
+      (!hasModernStepMetadata && outputFields.has(lastSegment))
+    ) {
+      scopedToolDeclarations += 1;
+    }
+  }
+  return Math.max(
+    mapStepsPerChunk,
+    explicitExternalSteps,
+    scopedToolDeclarations,
+  );
 }

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

@@ -362,6 +362,17 @@ export type ConditionalStepResolver<Row, Value, Else = null> = {
 export type StepOptions<Row, Value = unknown> = {
   /** Optional row-level gate. Skipped rows produce `null` for this column. */
   readonly runIf?: (row: Row, index: number) => boolean | Promise<boolean>;
+  /**
+   * Legacy dataset-column recompute flag accepted for older authored plays.
+   *
+   * Prefer putting freshness on the actual reusable call
+   * (`ctx.tools.execute`, `ctx.step`, `ctx.fetch`, or `ctx.runPlay`).
+   */
+  readonly recompute?: boolean;
+  /** Legacy error-recompute flag accepted for older authored plays. */
+  readonly recomputeOnError?: boolean;
+  /** Legacy cell staleness metadata accepted for older authored plays. */
+  readonly staleAfterSeconds?: number;
 };
 
 export type StepProgram<Input, Output, Return = Output> = {
@@ -395,6 +406,9 @@ export type StepProgramResolver<Input, Return> = {
 
 export type PlayStepProgramStep = {
   readonly name: string;
+  readonly recompute?: boolean;
+  readonly recomputeOnError?: boolean;
+  readonly staleAfterSeconds?: number;
   readonly resolver:
     | StepResolver<Record<string, unknown>, unknown>
     | ConditionalStepResolver<Record<string, unknown>, unknown>
@@ -1184,6 +1198,13 @@ class DeeplineStepProgram<Input, Output, ReturnValue> implements StepProgram<
         ...this.steps,
         {
           name,
+          ...(options?.recompute === true ? { recompute: true } : {}),
+          ...(options?.recomputeOnError === true
+            ? { recomputeOnError: true }
+            : {}),
+          ...(typeof options?.staleAfterSeconds === 'number'
+            ? { staleAfterSeconds: options.staleAfterSeconds }
+            : {}),
           resolver: stepResolver as PlayStepProgramStep['resolver'],
         },
       ],

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

@@ -104,10 +104,10 @@ export const SDK_RELEASE = {
   // 0.1.111 ships dataset-native tool list getters and result row datasets.
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
-  version: '0.1.157',
+  version: '0.1.159',
   apiContract: '2026-06-dataset-handle-results-hard-cutover',
   supportPolicy: {
-    latest: '0.1.157',
+    latest: '0.1.159',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
     commandMinimumSupported: [

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

@@ -128,6 +128,13 @@ class WorkerStepProgram<Input, Output, ReturnValue> implements StepProgram<
         ...this.steps,
         {
           name,
+          ...(options?.recompute === true ? { recompute: true } : {}),
+          ...(options?.recomputeOnError === true
+            ? { recomputeOnError: true }
+            : {}),
+          ...(typeof options?.staleAfterSeconds === 'number'
+            ? { staleAfterSeconds: options.staleAfterSeconds }
+            : {}),
           resolver: stepResolver as PlayStepProgramStep['resolver'],
         },
       ],

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

@@ -654,6 +654,9 @@ export type RuntimeConditionalStepResolver<
 
 export type RuntimeStepProgramStep = {
   name: string;
+  recompute?: boolean;
+  recomputeOnError?: boolean;
+  staleAfterSeconds?: number;
   resolver:
     | RuntimeStepResolver
     | RuntimeConditionalStepResolver

package/dist/bundling-sources/shared_libs/play-runtime/map-chunk-limits.ts

@@ -1 +1 @@
-export const TOOL_CALLING_MAP_CHUNK_SIZE = 25;
+export const TOOL_CALLING_MAP_CHUNK_SIZE = 20;

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

@@ -612,6 +612,24 @@ function conflictingTerminalSnapshot(
   );
 }
 
+function retryablePlatformDeployFailureSnapshot(
+  base: PlayRunLedgerSnapshot,
+  eventError?: string | null,
+): PlayRunLedgerSnapshot | null {
+  if (
+    isTerminalPlayRunLedgerStatus(base.status) ||
+    !eventError ||
+    normalizePlayRunFailure(eventError).code !== 'PLATFORM_DEPLOY_INTERRUPTED'
+  ) {
+    return null;
+  }
+  return withTiming(
+    appendLogLines(base, [
+      `[ledger] retryable platform deploy run.failed ignored; status remains ${base.status}`,
+    ]),
+  );
+}
+
 function settleRunningStepsOnTerminal(
   snapshot: PlayRunLedgerSnapshot,
   status: Extract<PlayRunLedgerStepStatus, 'completed' | 'failed'>,
@@ -714,6 +732,7 @@ export function reducePlayRunLedgerEvent(
       );
     case 'run.failed':
       return (
+        retryablePlatformDeployFailureSnapshot(base, event.error) ??
         conflictingTerminalSnapshot(
           base,
           event.type,

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

@@ -610,6 +610,23 @@ async function ensureRuntimeSheetForPreloadedSession(
       phase: 'ensure_sheet_for_preloaded_session',
       ms: Date.now() - ensureStartedAt,
     });
+    const recheckStartedAt = Date.now();
+    const readyAfterEnsure = await isRuntimeSheetSchemaReady(input.session, {
+      sheetContract: input.sheetContract,
+    });
+    input.timings?.push({
+      phase: 'schema_check_after_preloaded_session_ensure',
+      ms: Date.now() - recheckStartedAt,
+      ready: readyAfterEnsure,
+    });
+    if (!readyAfterEnsure) {
+      if (runtimeSheetEnsureCache.get(cacheKey)?.promise === promise) {
+        runtimeSheetEnsureCache.delete(cacheKey);
+      }
+      throw new Error(
+        `Runtime sheet schema for ctx.dataset("${input.tableNamespace}") is still not ready after ensure_sheet.`,
+      );
+    }
   } catch (error) {
     if (runtimeSheetEnsureCache.get(cacheKey)?.promise === promise) {
       runtimeSheetEnsureCache.delete(cacheKey);

package/dist/bundling-sources/shared_libs/play-runtime/step-program-dataset-builder.ts

@@ -5,6 +5,9 @@ export type StepProgramDatasetOptions = {
     row: Record<string, unknown>,
     index: number,
   ) => boolean | Promise<boolean>;
+  recompute?: boolean;
+  recomputeOnError?: boolean;
+  staleAfterSeconds?: number;
 };
 
 export type StepProgramDatasetColumnRunInput<Value = unknown> = {
@@ -124,6 +127,13 @@ export class StepProgramDatasetBuilder<
       ...this.program.steps,
       {
         name,
+        ...(normalized.options?.recompute === true ? { recompute: true } : {}),
+        ...(normalized.options?.recomputeOnError === true
+          ? { recomputeOnError: true }
+          : {}),
+        ...(typeof normalized.options?.staleAfterSeconds === 'number'
+          ? { staleAfterSeconds: normalized.options.staleAfterSeconds }
+          : {}),
         resolver: this.applyDerivationOptions(
           normalized.resolver,
           normalized.options,

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

@@ -727,13 +727,15 @@ function staticStringFromExpression(
   node: AstNode | null | undefined,
   context: PlayMetadataExtractionContext,
   seen = new Set<string>(),
+  trimResult = true,
 ): string | null {
   const expression = unwrapStaticExpression(node);
   if (!expression) return null;
 
   if (expression.type === 'Literal') {
     const value = expression.value;
-    return typeof value === 'string' && value.trim() ? value.trim() : null;
+    if (typeof value !== 'string' || !value.trim()) return null;
+    return trimResult ? value.trim() : value;
   }
 
   if (
@@ -745,9 +747,26 @@ function staticStringFromExpression(
       firstQuasi && typeof firstQuasi.value === 'object'
         ? (firstQuasi.value as { cooked?: unknown }).cooked
         : null;
-    return typeof cooked === 'string' && cooked.trim()
-      ? cooked.trim()
-      : null;
+    if (typeof cooked !== 'string' || !cooked.trim()) return null;
+    return trimResult ? cooked.trim() : cooked;
+  }
+
+  if (expression.type === 'BinaryExpression' && expression.operator === '+') {
+    const left = staticStringFromExpression(
+      isAstNode(expression.left) ? expression.left : null,
+      context,
+      new Set(seen),
+      false,
+    );
+    const right = staticStringFromExpression(
+      isAstNode(expression.right) ? expression.right : null,
+      context,
+      new Set(seen),
+      false,
+    );
+    const value = left !== null && right !== null ? `${left}${right}` : null;
+    if (!value?.trim()) return null;
+    return trimResult ? value.trim() : value;
   }
 
   const identifier = getIdentifierName(expression);
@@ -757,6 +776,7 @@ function staticStringFromExpression(
     context.declarations.get(identifier),
     context,
     seen,
+    trimResult,
   );
 }
 

package/dist/cli/index.js

@@ -657,10 +657,10 @@ var SDK_RELEASE = {
   // 0.1.111 ships dataset-native tool list getters and result row datasets.
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
-  version: "0.1.157",
+  version: "0.1.159",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.157",
+    latest: "0.1.159",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [

package/dist/cli/index.mjs

@@ -642,10 +642,10 @@ var SDK_RELEASE = {
   // 0.1.111 ships dataset-native tool list getters and result row datasets.
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
-  version: "0.1.157",
+  version: "0.1.159",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.157",
+    latest: "0.1.159",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [

package/dist/index.d.mts

@@ -2983,6 +2983,17 @@ type ConditionalStepResolver<Row, Value, Else = null> = {
 type StepOptions<Row, Value = unknown> = {
     /** Optional row-level gate. Skipped rows produce `null` for this column. */
     readonly runIf?: (row: Row, index: number) => boolean | Promise<boolean>;
+    /**
+     * Legacy dataset-column recompute flag accepted for older authored plays.
+     *
+     * Prefer putting freshness on the actual reusable call
+     * (`ctx.tools.execute`, `ctx.step`, `ctx.fetch`, or `ctx.runPlay`).
+     */
+    readonly recompute?: boolean;
+    /** Legacy error-recompute flag accepted for older authored plays. */
+    readonly recomputeOnError?: boolean;
+    /** Legacy cell staleness metadata accepted for older authored plays. */
+    readonly staleAfterSeconds?: number;
 };
 type StepProgram<Input, Output, Return = Output> = {
     readonly kind: 'steps';
@@ -3001,6 +3012,9 @@ type StepProgramResolver<Input, Return> = {
 };
 type PlayStepProgramStep = {
     readonly name: string;
+    readonly recompute?: boolean;
+    readonly recomputeOnError?: boolean;
+    readonly staleAfterSeconds?: number;
     readonly resolver: StepResolver<Record<string, unknown>, unknown> | ConditionalStepResolver<Record<string, unknown>, unknown> | StepProgramResolver<Record<string, unknown>, unknown>;
 };
 type ColumnResolver<Row, Value> = StepResolver<Row, Value> | ConditionalStepResolver<Row, Value> | StepProgramResolver<Row, Value>;

package/dist/index.d.ts

@@ -2983,6 +2983,17 @@ type ConditionalStepResolver<Row, Value, Else = null> = {
 type StepOptions<Row, Value = unknown> = {
     /** Optional row-level gate. Skipped rows produce `null` for this column. */
     readonly runIf?: (row: Row, index: number) => boolean | Promise<boolean>;
+    /**
+     * Legacy dataset-column recompute flag accepted for older authored plays.
+     *
+     * Prefer putting freshness on the actual reusable call
+     * (`ctx.tools.execute`, `ctx.step`, `ctx.fetch`, or `ctx.runPlay`).
+     */
+    readonly recompute?: boolean;
+    /** Legacy error-recompute flag accepted for older authored plays. */
+    readonly recomputeOnError?: boolean;
+    /** Legacy cell staleness metadata accepted for older authored plays. */
+    readonly staleAfterSeconds?: number;
 };
 type StepProgram<Input, Output, Return = Output> = {
     readonly kind: 'steps';
@@ -3001,6 +3012,9 @@ type StepProgramResolver<Input, Return> = {
 };
 type PlayStepProgramStep = {
     readonly name: string;
+    readonly recompute?: boolean;
+    readonly recomputeOnError?: boolean;
+    readonly staleAfterSeconds?: number;
     readonly resolver: StepResolver<Record<string, unknown>, unknown> | ConditionalStepResolver<Record<string, unknown>, unknown> | StepProgramResolver<Record<string, unknown>, unknown>;
 };
 type ColumnResolver<Row, Value> = StepResolver<Row, Value> | ConditionalStepResolver<Row, Value> | StepProgramResolver<Row, Value>;

package/dist/index.js

@@ -421,10 +421,10 @@ var SDK_RELEASE = {
   // 0.1.111 ships dataset-native tool list getters and result row datasets.
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
-  version: "0.1.157",
+  version: "0.1.159",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.157",
+    latest: "0.1.159",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -5114,6 +5114,9 @@ var DeeplineStepProgram = class _DeeplineStepProgram {
         ...this.steps,
         {
           name,
+          ...options?.recompute === true ? { recompute: true } : {},
+          ...options?.recomputeOnError === true ? { recomputeOnError: true } : {},
+          ...typeof options?.staleAfterSeconds === "number" ? { staleAfterSeconds: options.staleAfterSeconds } : {},
           resolver: stepResolver
         }
       ],

package/dist/index.mjs

@@ -351,10 +351,10 @@ var SDK_RELEASE = {
   // 0.1.111 ships dataset-native tool list getters and result row datasets.
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
-  version: "0.1.157",
+  version: "0.1.159",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.157",
+    latest: "0.1.159",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -5044,6 +5044,9 @@ var DeeplineStepProgram = class _DeeplineStepProgram {
         ...this.steps,
         {
           name,
+          ...options?.recompute === true ? { recompute: true } : {},
+          ...options?.recomputeOnError === true ? { recomputeOnError: true } : {},
+          ...typeof options?.staleAfterSeconds === "number" ? { staleAfterSeconds: options.staleAfterSeconds } : {},
           resolver: stepResolver
         }
       ],

package/dist/plays/bundle-play-file.mjs

@@ -554,17 +554,36 @@ function unwrapStaticExpression(node) {
   }
   return current;
 }
-function staticStringFromExpression(node, context, seen = /* @__PURE__ */ new Set()) {
+function staticStringFromExpression(node, context, seen = /* @__PURE__ */ new Set(), trimResult = true) {
   const expression = unwrapStaticExpression(node);
   if (!expression) return null;
   if (expression.type === "Literal") {
     const value = expression.value;
-    return typeof value === "string" && value.trim() ? value.trim() : null;
+    if (typeof value !== "string" || !value.trim()) return null;
+    return trimResult ? value.trim() : value;
   }
   if (expression.type === "TemplateLiteral" && astArray(expression.expressions).length === 0) {
     const firstQuasi = astArray(expression.quasis)[0];
     const cooked = firstQuasi && typeof firstQuasi.value === "object" ? firstQuasi.value.cooked : null;
-    return typeof cooked === "string" && cooked.trim() ? cooked.trim() : null;
+    if (typeof cooked !== "string" || !cooked.trim()) return null;
+    return trimResult ? cooked.trim() : cooked;
+  }
+  if (expression.type === "BinaryExpression" && expression.operator === "+") {
+    const left = staticStringFromExpression(
+      isAstNode(expression.left) ? expression.left : null,
+      context,
+      new Set(seen),
+      false
+    );
+    const right = staticStringFromExpression(
+      isAstNode(expression.right) ? expression.right : null,
+      context,
+      new Set(seen),
+      false
+    );
+    const value = left !== null && right !== null ? `${left}${right}` : null;
+    if (!value?.trim()) return null;
+    return trimResult ? value.trim() : value;
   }
   const identifier = getIdentifierName(expression);
   if (!identifier || seen.has(identifier)) return null;
@@ -572,7 +591,8 @@ function staticStringFromExpression(node, context, seen = /* @__PURE__ */ new Se
   return staticStringFromExpression(
     context.declarations.get(identifier),
     context,
-    seen
+    seen,
+    trimResult
   );
 }
 function propertyNameFromKey(property) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepline",
-  "version": "0.1.157",
+  "version": "0.1.159",
   "description": "Deepline SDK + CLI — B2B data enrichment powered by durable cloud execution",
   "license": "MIT",
   "repository": {