deepline 0.1.153 → 0.1.154

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/batching.ts

@@ -118,6 +118,38 @@ export function compileRequestsWithStrategy<TRequest>(input: {
   return compiledBatches;
 }
 
+function testRateLimitBatchItems(
+  value: unknown,
+): Array<{ itemKey?: string; result?: unknown }> {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return [];
+  }
+  const record = value as Record<string, unknown>;
+  if (Array.isArray(record.items)) {
+    return record.items as Array<{ itemKey?: string; result?: unknown }>;
+  }
+  const candidates = [
+    record.data,
+    record.result,
+    record.output,
+    record.toolResponse &&
+    typeof record.toolResponse === 'object' &&
+    !Array.isArray(record.toolResponse)
+      ? (record.toolResponse as Record<string, unknown>).raw
+      : undefined,
+    record.toolOutput &&
+    typeof record.toolOutput === 'object' &&
+    !Array.isArray(record.toolOutput)
+      ? (record.toolOutput as Record<string, unknown>).raw
+      : undefined,
+  ];
+  for (const candidate of candidates) {
+    const items = testRateLimitBatchItems(candidate);
+    if (items.length > 0) return items;
+  }
+  return [];
+}
+
 export function getDefaultPlayRuntimeBatchStrategy(
   operation: string | null | undefined,
 ): AnyBatchOperationStrategy | null {
@@ -144,7 +176,7 @@ export function getDefaultPlayRuntimeBatchStrategy(
           : undefined;
       const items = payloads.map((payload, index) => ({
         itemKey: String(
-          payload.lead_id || payload.row_number || `row_${index}`,
+          payload.lead_id || payload.row_number || payload.key || `row_${index}`,
         ),
         payload,
       }));
@@ -162,23 +194,7 @@ export function getDefaultPlayRuntimeBatchStrategy(
       };
     },
     splitResult(fullResult, compiled) {
-      const container =
-        fullResult != null &&
-        typeof fullResult === 'object' &&
-        !Array.isArray(fullResult)
-          ? (fullResult as Record<string, unknown>)
-          : {};
-      const nestedData =
-        container.data != null &&
-        typeof container.data === 'object' &&
-        !Array.isArray(container.data)
-          ? (container.data as Record<string, unknown>)
-          : {};
-      const resultItems = Array.isArray(container.items)
-        ? (container.items as Array<{ itemKey?: string; result?: unknown }>)
-        : Array.isArray(nestedData.items)
-          ? (nestedData.items as Array<{ itemKey?: string; result?: unknown }>)
-          : [];
+      const resultItems = testRateLimitBatchItems(fullResult);
       return compiled.items.map((item, index) => ({
         itemKey: item.itemKey,
         result:

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/harness-receipt-store.ts

@@ -1,7 +1,11 @@
 import {
   harnessClaimRuntimeReceipt,
+  harnessClaimRuntimeReceipts,
   harnessCompleteRuntimeReceipt,
+  harnessCompleteRuntimeReceipts,
   harnessFailRuntimeReceipt,
+  harnessFailRuntimeReceipts,
+  harnessGetRuntimeReceipt,
 } from '../../../../sdk/src/plays/harness-stub';
 import type { PreloadedRuntimeDbSessionInput } from '../../../play-harness-worker/src/rpc-types';
 import type { WorkerRuntimeReceiptStore } from './receipts';
@@ -13,6 +17,16 @@ export function createHarnessWorkerReceiptStore(input: {
   userEmail?: string | null;
 }): WorkerRuntimeReceiptStore {
   return {
+    getReceipt(command) {
+      return harnessGetRuntimeReceipt({
+        executorToken: input.executorToken,
+        orgId: input.orgId,
+        preloadedDbSessions: input.preloadedDbSessions ?? null,
+        userEmail: input.userEmail ?? null,
+        runId: '',
+        ...command,
+      });
+    },
     claimReceipt(command) {
       return harnessClaimRuntimeReceipt({
         executorToken: input.executorToken,
@@ -22,6 +36,15 @@ export function createHarnessWorkerReceiptStore(input: {
         ...command,
       });
     },
+    claimReceipts(command) {
+      return harnessClaimRuntimeReceipts({
+        executorToken: input.executorToken,
+        orgId: input.orgId,
+        preloadedDbSessions: input.preloadedDbSessions ?? null,
+        userEmail: input.userEmail ?? null,
+        ...command,
+      });
+    },
     completeReceipt(command) {
       return harnessCompleteRuntimeReceipt({
         executorToken: input.executorToken,
@@ -31,6 +54,15 @@ export function createHarnessWorkerReceiptStore(input: {
         ...command,
       });
     },
+    completeReceipts(command) {
+      return harnessCompleteRuntimeReceipts({
+        executorToken: input.executorToken,
+        orgId: input.orgId,
+        preloadedDbSessions: input.preloadedDbSessions ?? null,
+        userEmail: input.userEmail ?? null,
+        ...command,
+      });
+    },
     failReceipt(command) {
       return harnessFailRuntimeReceipt({
         executorToken: input.executorToken,
@@ -40,5 +72,14 @@ export function createHarnessWorkerReceiptStore(input: {
         ...command,
       });
     },
+    failReceipts(command) {
+      return harnessFailRuntimeReceipts({
+        executorToken: input.executorToken,
+        orgId: input.orgId,
+        preloadedDbSessions: input.preloadedDbSessions ?? null,
+        userEmail: input.userEmail ?? null,
+        ...command,
+      });
+    },
   };
 }

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/receipts.ts

@@ -3,6 +3,7 @@ import {
   type WorkReceipt,
   type WorkReceiptClaim,
   type WorkReceiptCommand,
+  type WorkReceiptGetCommand,
   type WorkReceiptStatus,
   type WorkReceiptStore,
 } from '../../../../shared_libs/play-runtime/work-receipts';
@@ -12,6 +13,7 @@ export type RuntimeReceiptStatus = WorkReceiptStatus;
 export type WorkerRuntimeReceipt = WorkReceipt;
 
 export type WorkerRuntimeReceiptCommand = WorkReceiptCommand;
+export type WorkerRuntimeReceiptGetCommand = WorkReceiptGetCommand;
 
 export type WorkerRuntimeReceiptClaim = WorkReceiptClaim;
 
@@ -25,11 +27,25 @@ type RuntimeReceiptContext = {
   receiptStore: WorkerRuntimeReceiptStore;
 };
 
+const WORKER_RECEIPT_WAIT_MAX_ATTEMPTS = 240;
+const WORKER_RECEIPT_WAIT_DELAY_MS = 250;
+
+class RuntimeReceiptWaitTimeoutError extends Error {
+  constructor(key: string) {
+    super(`Timed out waiting for runtime receipt ${key}.`);
+    this.name = 'RuntimeReceiptWaitTimeoutError';
+  }
+}
+
 function scopedReceiptKey(input: {
   orgId?: string | null;
   playName: string;
   key: string;
 }): string {
+  const orgId = input.orgId?.trim() || 'org';
+  if (input.key.startsWith(`ctx:${orgId}:`)) {
+    return input.key;
+  }
   return buildScopedWorkReceiptKey(input);
 }
 
@@ -41,6 +57,53 @@ function errorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 
+async function waitForReusableReceipt<T>(input: {
+  key: string;
+  playName: string;
+  receiptStore: WorkerRuntimeReceiptStore;
+  maxAttempts?: number;
+  delayMs?: number;
+}): Promise<T> {
+  if (!input.receiptStore.getReceipt) {
+    throw new Error(
+      `Runtime receipt ${input.key} wait requires read-only receipt lookup.`,
+    );
+  }
+  const maxAttempts = input.maxAttempts ?? WORKER_RECEIPT_WAIT_MAX_ATTEMPTS;
+  const delayMs = input.delayMs ?? WORKER_RECEIPT_WAIT_DELAY_MS;
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    if (attempt > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+    const receipt = await input.receiptStore.getReceipt({
+      playName: input.playName,
+      key: input.key,
+    });
+    if (receipt?.status === 'completed' || receipt?.status === 'skipped') {
+      return receiptOutput<T>(receipt);
+    }
+    if (receipt?.status === 'failed') {
+      throw new Error(
+        `Runtime receipt ${input.key} failed while waiting: ${receipt.error ?? 'unknown error'}`,
+      );
+    }
+  }
+  throw new RuntimeReceiptWaitTimeoutError(input.key);
+}
+
+function shouldRepairSameRunRunningReceipt(input: {
+  repairRunningReceiptForSameRun?: boolean;
+  currentRunId: string;
+  receipt: WorkerRuntimeReceipt;
+}): boolean {
+  return (
+    input.repairRunningReceiptForSameRun === true &&
+    input.receipt.status === 'running' &&
+    typeof input.receipt.runId === 'string' &&
+    input.receipt.runId.trim() === input.currentRunId
+  );
+}
+
 async function executeAndPersistReceipt<T>(input: {
   key: string;
   playName: string;
@@ -89,6 +152,9 @@ export async function runWorkerRuntimeReceiptBoundary<T>(
   input: RuntimeReceiptContext & {
     execute: () => Promise<T> | T;
     repairRunningReceiptForSameRun?: boolean;
+    repairRunningReceiptForSameRunAfterWaitTimeout?: boolean;
+    runningReceiptWaitMaxAttempts?: number;
+    runningReceiptWaitDelayMs?: number;
     reclaimRunning?: boolean;
   },
 ): Promise<T> {
@@ -104,14 +170,83 @@ export async function runWorkerRuntimeReceiptBoundary<T>(
     return receiptOutput<T>(claimed.receipt);
   }
   if (claimed.disposition === 'running') {
-    return executeAndPersistReceipt({
-      key,
-      playName: input.playName,
-      runId: input.runId,
-      execute: input.execute,
-      receiptStore,
-      ownership: 'reconciled',
-    });
+    if (
+      shouldRepairSameRunRunningReceipt({
+        repairRunningReceiptForSameRun: input.repairRunningReceiptForSameRun,
+        currentRunId: input.runId,
+        receipt: claimed.receipt,
+      })
+    ) {
+      const repaired = await receiptStore.claimReceipt({
+        playName: input.playName,
+        runId: input.runId,
+        key,
+        reclaimRunning: true,
+      });
+      if (repaired.disposition === 'reused') {
+        return receiptOutput<T>(repaired.receipt);
+      }
+      if (repaired.disposition === 'failed') {
+        throw new Error(
+          `Runtime receipt ${key} is failed and could not be repaired: ${repaired.receipt.error ?? 'unknown error'}`,
+        );
+      }
+      if (repaired.disposition === 'claimed') {
+        return executeAndPersistReceipt({
+          key,
+          playName: input.playName,
+          runId: input.runId,
+          execute: input.execute,
+          receiptStore,
+          ownership: 'claimed',
+        });
+      }
+    }
+    try {
+      return await waitForReusableReceipt<T>({
+        key,
+        playName: input.playName,
+        receiptStore,
+        maxAttempts: input.runningReceiptWaitMaxAttempts,
+        delayMs: input.runningReceiptWaitDelayMs,
+      });
+    } catch (error) {
+      if (
+        input.repairRunningReceiptForSameRunAfterWaitTimeout === true &&
+        error instanceof RuntimeReceiptWaitTimeoutError &&
+        shouldRepairSameRunRunningReceipt({
+          repairRunningReceiptForSameRun: true,
+          currentRunId: input.runId,
+          receipt: claimed.receipt,
+        })
+      ) {
+        const repaired = await receiptStore.claimReceipt({
+          playName: input.playName,
+          runId: input.runId,
+          key,
+          reclaimRunning: true,
+        });
+        if (repaired.disposition === 'reused') {
+          return receiptOutput<T>(repaired.receipt);
+        }
+        if (repaired.disposition === 'failed') {
+          throw new Error(
+            `Runtime receipt ${key} is failed and could not be repaired after wait timeout: ${repaired.receipt.error ?? 'unknown error'}`,
+          );
+        }
+        if (repaired.disposition === 'claimed') {
+          return executeAndPersistReceipt({
+            key,
+            playName: input.playName,
+            runId: input.runId,
+            execute: input.execute,
+            receiptStore,
+            ownership: 'claimed',
+          });
+        }
+      }
+      throw error;
+    }
   }
   if (claimed.disposition === 'failed') {
     throw new Error(

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/tool-receipts.ts

@@ -0,0 +1,104 @@
+import {
+  markToolExecuteResultExecutionOutcome,
+  type ToolExecutionOutcome,
+} from '../../../../shared_libs/play-runtime/tool-execution-outcome';
+
+export type WorkerToolReceiptSelection = {
+  claimableReceiptKey: string | null;
+  forceDurableRefresh: boolean;
+};
+
+export type WorkerToolReceiptGroup<TRequest> = {
+  claimableReceiptKey: string;
+  forceDurableRefresh: boolean;
+  requests: TRequest[];
+};
+
+export type WorkerToolReceiptGroupPlan<TRequest> = {
+  localRequests: TRequest[];
+  durableGroups: WorkerToolReceiptGroup<TRequest>[];
+};
+
+export function canReclaimTimedOutWorkerToolReceipt(input: {
+  ownerRunId?: string | null;
+  currentRunId: string;
+}): boolean {
+  const ownerRunId = input.ownerRunId?.trim();
+  const currentRunId = input.currentRunId.trim();
+  return Boolean(ownerRunId && currentRunId && ownerRunId === currentRunId);
+}
+
+export function selectWorkerToolReceipt(input: {
+  durableReceiptKey?: string | null;
+  localRetryCacheKey: string;
+  force: boolean;
+  allowLocalRetryReceipts: boolean;
+}): WorkerToolReceiptSelection {
+  const durableReceiptKey = input.durableReceiptKey?.trim() || null;
+  const localRetryReceiptKey =
+    durableReceiptKey || !input.allowLocalRetryReceipts
+      ? null
+      : input.localRetryCacheKey.trim() || null;
+  return {
+    claimableReceiptKey: durableReceiptKey ?? localRetryReceiptKey,
+    forceDurableRefresh: input.force === true && durableReceiptKey !== null,
+  };
+}
+
+export function planWorkerToolReceiptGroups<TRequest>(
+  requests: TRequest[],
+  input: {
+    allowLocalRetryReceipts: boolean;
+    getReceiptInput: (request: TRequest) => {
+      durableReceiptKey?: string | null;
+      localRetryCacheKey: string;
+      force: boolean;
+    };
+  },
+): WorkerToolReceiptGroupPlan<TRequest> {
+  const localRequests: TRequest[] = [];
+  const groupsByKey = new Map<string, WorkerToolReceiptGroup<TRequest>>();
+  for (const request of requests) {
+    const { claimableReceiptKey, forceDurableRefresh } =
+      selectWorkerToolReceipt({
+        ...input.getReceiptInput(request),
+        allowLocalRetryReceipts: input.allowLocalRetryReceipts,
+      });
+    if (!claimableReceiptKey) {
+      localRequests.push(request);
+      continue;
+    }
+    const group = groupsByKey.get(claimableReceiptKey) ?? {
+      claimableReceiptKey,
+      forceDurableRefresh: false,
+      requests: [],
+    };
+    group.requests.push(request);
+    group.forceDurableRefresh ||= forceDurableRefresh;
+    groupsByKey.set(claimableReceiptKey, group);
+  }
+  return {
+    localRequests,
+    durableGroups: [...groupsByKey.values()],
+  };
+}
+
+export function markWorkerToolReceiptResultCached(
+  value: unknown,
+  cacheKey: string,
+  receiptKey = cacheKey,
+): unknown {
+  return markWorkerToolReceiptResultExecution(value, {
+    kind: 'cache',
+    cacheKey,
+    receiptKey,
+    attachedToReceiptKey: receiptKey,
+  });
+}
+
+export function markWorkerToolReceiptResultExecution(
+  value: unknown,
+  outcome: ToolExecutionOutcome,
+): unknown {
+  return markToolExecuteResultExecutionOutcome(value, outcome);
+}

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

@@ -184,7 +184,6 @@ export type {
   PlayDatasetInput,
   PlayStepProgramStep,
   PrebuiltPlayRef,
-  StaleAfterSeconds,
   StepOptions,
   StepProgram,
   StepProgramResolver,

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

@@ -300,24 +300,6 @@ export type ToolExecutionRequest = {
   staleAfterSeconds?: number;
 };
 
-/**
- * Freshness policy for dataset cells and step-program columns.
- *
- * Use a positive whole number of seconds for a fixed TTL. Use a function when
- * the next expiry depends on the value that was just produced. The function
- * receives the completed cell value; return a positive whole number of seconds
- * to set the next expiry, or `null` to keep that value indefinitely.
- *
- * Result-based policies are evaluated only for dataset/step-program cells. The
- * scalar `ctx.step`, `ctx.fetch`, `ctx.runPlay`, and `ctx.tools.execute` APIs
- * accept numeric TTLs.
- *
- * @sdkReference runtime 080
- */
-export type StaleAfterSeconds<Value = unknown> =
-  | number
-  | ((value: Value) => number | null);
-
 export type StepResolver<Row, Value> = (
   row: Row,
   ctx: DeeplinePlayRuntimeContext,
@@ -349,8 +331,7 @@ export type DatasetColumnRunInput<Row, Value> = {
 /**
  * Object-column form for `.withColumn(...)`.
  *
- * Use this when a column needs `runIf`, typed `previousCell`, or a
- * result-based `staleAfterSeconds(value)` policy.
+ * Use this when a column needs `runIf` or typed `previousCell`.
  *
  * @sdkReference runtime 100
  */
@@ -359,12 +340,6 @@ export type DatasetColumnDefinition<Row, Value> = {
   run: (input: DatasetColumnRunInput<Row, Value>) => Value | Promise<Value>;
   /** Optional row-level gate. Skipped rows produce `null` for this column. */
   readonly runIf?: (row: Row, index: number) => boolean | Promise<boolean>;
-  /** Recompute this cell on each run instead of reusing its durable value. */
-  readonly recompute?: boolean;
-  /** Recompute this cell when its durable value is an error-shaped object. */
-  readonly recomputeOnError?: boolean;
-  /** Fixed or value-dependent freshness policy for this cell. */
-  readonly staleAfterSeconds?: StaleAfterSeconds<Value>;
 };
 
 export type ConditionalStepResolver<Row, Value, Else = null> = {
@@ -385,12 +360,6 @@ 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>;
-  /** Recompute this cell on each run instead of reusing its durable value. */
-  readonly recompute?: boolean;
-  /** Recompute this cell when its durable value is an error-shaped object. */
-  readonly recomputeOnError?: boolean;
-  /** Fixed or value-dependent freshness policy for this cell. */
-  readonly staleAfterSeconds?: StaleAfterSeconds<Value>;
 };
 
 export type StepProgram<Input, Output, Return = Output> = {
@@ -424,9 +393,6 @@ export type StepProgramResolver<Input, Return> = {
 
 export type PlayStepProgramStep = {
   readonly name: string;
-  readonly recompute?: boolean;
-  readonly recomputeOnError?: boolean;
-  readonly staleAfterSeconds?: StaleAfterSeconds;
   readonly resolver:
     | StepResolver<Record<string, unknown>, unknown>
     | ConditionalStepResolver<Record<string, unknown>, unknown>
@@ -491,8 +457,7 @@ export type DatasetBuilder<
   /**
    * Define one output column with object-column authoring.
    *
-   * Use this form for typed `previousCell` access or result-based
-   * `staleAfterSeconds(value)` policies.
+   * Use this form for typed `previousCell` access.
    *
    * @param name - Output column name.
    * @param definition - Object-column definition.
@@ -507,7 +472,7 @@ export type DatasetBuilder<
    *
    * @param name - Output column name.
    * @param resolver - Computes the value for one row.
-   * @param options - Row gate and freshness options.
+   * @param options - Row gate options.
    * @returns The same dataset builder with a nullable column type for skipped rows.
    */
   withColumn<Name extends string, Value>(
@@ -1218,16 +1183,6 @@ class DeeplineStepProgram<Input, Output, ReturnValue> implements StepProgram<
         {
           name,
           resolver: stepResolver as PlayStepProgramStep['resolver'],
-          ...(options?.staleAfterSeconds !== undefined
-            ? {
-                staleAfterSeconds:
-                  options.staleAfterSeconds as PlayStepProgramStep['staleAfterSeconds'],
-              }
-            : {}),
-          ...(options?.recompute === true ? { recompute: true } : {}),
-          ...(options?.recomputeOnError === true
-            ? { recomputeOnError: true }
-            : {}),
         },
       ],
       this.returnResolver as StepResolver<

package/dist/bundling-sources/sdk/src/plays/harness-stub.ts

@@ -33,10 +33,13 @@ import type {
   PlayHarnessRpc,
   PreloadedRuntimeDbSessionInput,
   CompleteRuntimeReceiptInput,
+  CompleteRuntimeReceiptsInput,
   FailRuntimeReceiptInput,
+  FailRuntimeReceiptsInput,
   RuntimeApiCallInput,
   RuntimeApiCallResult,
   RuntimeReceiptInput,
+  RuntimeReceiptsInput,
   SheetDatasetRowsInput,
   SheetDatasetRowsResult,
   StagedFileChunkInput,
@@ -46,7 +49,6 @@ import type {
   WorkReceipt,
   WorkReceiptClaim,
 } from '../../../shared_libs/play-runtime/work-receipts';
-import type { CellStalenessPolicy } from '../../../shared_libs/play-runtime/cell-staleness';
 
 /**
  * Service-binding RPC stub shape — what `env.HARNESS` looks like inside
@@ -133,18 +135,42 @@ export async function harnessClaimRuntimeReceipt(
   return requireBinding().claimRuntimeReceipt(input);
 }
 
+export async function harnessClaimRuntimeReceipts(
+  input: RuntimeReceiptsInput,
+): Promise<WorkReceiptClaim[]> {
+  return requireBinding().claimRuntimeReceipts(input);
+}
+
+export async function harnessGetRuntimeReceipt(
+  input: RuntimeReceiptInput,
+): Promise<WorkReceipt | null> {
+  return requireBinding().getRuntimeReceipt(input);
+}
+
 export async function harnessCompleteRuntimeReceipt(
   input: CompleteRuntimeReceiptInput,
 ): Promise<WorkReceipt | null> {
   return requireBinding().completeRuntimeReceipt(input);
 }
 
+export async function harnessCompleteRuntimeReceipts(
+  input: CompleteRuntimeReceiptsInput,
+): Promise<WorkReceipt[]> {
+  return requireBinding().completeRuntimeReceipts(input);
+}
+
 export async function harnessFailRuntimeReceipt(
   input: FailRuntimeReceiptInput,
 ): Promise<WorkReceipt | null> {
   return requireBinding().failRuntimeReceipt(input);
 }
 
+export async function harnessFailRuntimeReceipts(
+  input: FailRuntimeReceiptsInput,
+): Promise<WorkReceipt[]> {
+  return requireBinding().failRuntimeReceipts(input);
+}
+
 /**
  * Read a bounded staged-file byte range through typed harness RPC. This is the
  * only staged-file data path for per-play Workers; there is intentionally no
@@ -192,7 +218,6 @@ export async function harnessStartSheetDataset(input: {
   runId: string;
   inputOffset?: number;
   userEmail?: string | null;
-  cellPolicies?: Record<string, CellStalenessPolicy>;
 }): Promise<{
   inserted: number;
   skipped: number;

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

@@ -102,10 +102,10 @@ export const SDK_RELEASE = {
   // the SDK enrich generator's one-second stale policy.
   // 0.1.110 ships authored V2 prebuilts and required top-level play descriptions.
   // 0.1.111 ships dataset-native tool list getters and result row datasets.
-  version: '0.1.153',
+  version: '0.1.154',
   apiContract: '2026-06-dataset-handle-results-hard-cutover',
   supportPolicy: {
-    latest: '0.1.153',
+    latest: '0.1.154',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
     commandMinimumSupported: [

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

@@ -129,16 +129,6 @@ class WorkerStepProgram<Input, Output, ReturnValue> implements StepProgram<
         {
           name,
           resolver: stepResolver as PlayStepProgramStep['resolver'],
-          ...(options?.staleAfterSeconds !== undefined
-            ? {
-                staleAfterSeconds:
-                  options.staleAfterSeconds as PlayStepProgramStep['staleAfterSeconds'],
-              }
-            : {}),
-          ...(options?.recompute === true ? { recompute: true } : {}),
-          ...(options?.recomputeOnError === true
-            ? { recomputeOnError: true }
-            : {}),
         },
       ],
       this.returnResolver as StepResolver<

package/dist/bundling-sources/shared_libs/play-data-plane/index.ts

@@ -1,3 +1,2 @@
-export * from './cell-policy';
 export * from './column-names';
 export * from './sheet-contract';