deepline 0.1.153 → 0.1.154

package/dist/bundling-sources/shared_libs/play-runtime/runtime-pg-driver-neon-serverless.ts

@@ -46,7 +46,6 @@
 
 import {
   registerRuntimePoolFactory,
-  registerRuntimeOneShotQueryFactory,
   type RuntimePool,
   type RuntimePoolClient,
 } from './runtime-pg-driver';
@@ -91,15 +90,6 @@ interface NeonPoolConfig {
 
 interface NeonModule {
   Pool: new (config: NeonPoolConfig) => NeonPoolInstance;
-  neon: (
-    connectionString: string,
-    options?: { fullResults?: boolean },
-  ) => {
-    query<R = Record<string, unknown>>(
-      text: string,
-      params?: unknown[],
-    ): Promise<{ rows: R[] }>;
-  };
 }
 
 function assertBindParams(params: unknown[] | undefined): void {
@@ -177,72 +167,51 @@ function wrapNeonPool(pool: NeonPoolInstance): RuntimePool {
  * until the import() resolves.
  */
 export function installNeonServerlessRuntimePoolDriver(): void {
-  registerRuntimeOneShotQueryFactory((input) => {
-    let sqlPromise: Promise<ReturnType<NeonModule['neon']>> | null = null;
-    async function getSql(): Promise<ReturnType<NeonModule['neon']>> {
-      if (!sqlPromise) {
-        sqlPromise = loadNeonModule().then((neon) =>
-          neon.neon(input.connectionString, { fullResults: true }),
-        );
-      }
-      return sqlPromise;
-    }
-    return {
-      query: async <
-        R extends Record<string, unknown> = Record<string, unknown>,
-      >(
-        text: string,
-        params?: unknown[],
-      ) => {
-        assertBindParams(params);
-        const sql = await getSql();
-        return await sql.query<R>(text, params);
-      },
-    };
-  });
+  registerRuntimePoolFactory(
+    (input) => {
+      // Captured lazily so a Pool is only constructed if the play actually
+      // connects. Most plays that don't touch Postgres directly never even
+      // reach this branch — the factory is registered but never invoked.
+      let lazyPool: NeonPoolInstance | null = null;
 
-  registerRuntimePoolFactory((input) => {
-    // Captured lazily so a Pool is only constructed if the play actually
-    // connects. Most plays that don't touch Postgres directly never even
-    // reach this branch — the factory is registered but never invoked.
-    let lazyPool: NeonPoolInstance | null = null;
-
-    /**
-     * Resolve the lazy Pool, creating it on first call.
-     *
-     * Race safety: workerd executes within a single JS event loop, so
-     * two concurrent `connect()` calls on the SAME wrapper run their
-     * "lazyPool == null" checks in turn — the first creates the Pool,
-     * the second sees it. No locking needed.
-     *
-     * If pool creation fails (e.g. DNS, bad connection string), the
-     * error propagates out of connect() to the caller. We don't cache
-     * a failed pool so retries can succeed on transient failures.
-     */
-    async function ensurePool(): Promise<NeonPoolInstance> {
-      if (lazyPool) return lazyPool;
-      const neon = await loadNeonModule();
-      const pool = new neon.Pool({
-        connectionString: input.connectionString,
-        max: input.maxConnections ?? 4,
-        idleTimeoutMillis: input.idleTimeoutMs ?? 15_000,
-        connectionTimeoutMillis: input.connectTimeoutMs ?? 10_000,
-      });
-      lazyPool = pool;
-      return pool;
-    }
+      /**
+       * Resolve the lazy Pool, creating it on first call.
+       *
+       * Race safety: workerd executes within a single JS event loop, so
+       * two concurrent `connect()` calls on the SAME wrapper run their
+       * "lazyPool == null" checks in turn — the first creates the Pool,
+       * the second sees it. No locking needed.
+       *
+       * If pool creation fails (e.g. DNS, bad connection string), the
+       * error propagates out of connect() to the caller. We don't cache
+       * a failed pool so retries can succeed on transient failures.
+       */
+      async function ensurePool(): Promise<NeonPoolInstance> {
+        if (lazyPool) return lazyPool;
+        const neon = await loadNeonModule();
+        const pool = new neon.Pool({
+          connectionString: input.connectionString,
+          max: input.maxConnections ?? 4,
+          idleTimeoutMillis: input.idleTimeoutMs ?? 15_000,
+          connectionTimeoutMillis: input.connectTimeoutMs ?? 10_000,
+        });
+        lazyPool = pool;
+        return pool;
+      }
 
-    return {
-      connect: async () => {
-        const pool = await ensurePool();
-        return wrapNeonClient(await pool.connect());
-      },
-      end: async () => {
-        if (lazyPool) {
-          await lazyPool.end();
-          lazyPool = null;
-        }
-      },
-    };
-  });
+      return {
+        connect: async () => {
+          const pool = await ensurePool();
+          return wrapNeonClient(await pool.connect());
+        },
+        end: async () => {
+          if (lazyPool) {
+            await lazyPool.end();
+            lazyPool = null;
+          }
+        },
+      };
+    },
+    { canReuseAcrossRequests: false },
+  );
 }

package/dist/bundling-sources/shared_libs/play-runtime/runtime-pg-driver.ts

@@ -58,6 +58,7 @@ const runtimePgDriverRegistryKey = Symbol.for(
 type RuntimePgDriverRegistry = {
   poolFactory: RuntimePoolFactory | null;
   oneShotQueryFactory: RuntimeOneShotQueryFactory | null;
+  canReusePoolsAcrossRequests: boolean;
 };
 
 function getRuntimePgDriverRegistry(): RuntimePgDriverRegistry {
@@ -67,6 +68,7 @@ function getRuntimePgDriverRegistry(): RuntimePgDriverRegistry {
   globalWithRegistry[runtimePgDriverRegistryKey] ??= {
     poolFactory: null,
     oneShotQueryFactory: null,
+    canReusePoolsAcrossRequests: true,
   };
   return globalWithRegistry[runtimePgDriverRegistryKey];
 }
@@ -76,7 +78,10 @@ function getRuntimePgDriverRegistry(): RuntimePgDriverRegistry {
  * with different factories will throw to prevent silent driver swaps that
  * would otherwise drop in-flight pooled connections.
  */
-export function registerRuntimePoolFactory(factory: RuntimePoolFactory): void {
+export function registerRuntimePoolFactory(
+  factory: RuntimePoolFactory,
+  options: { canReuseAcrossRequests?: boolean } = {},
+): void {
   const registry = getRuntimePgDriverRegistry();
   if (registry.poolFactory && registry.poolFactory !== factory) {
     throw new Error(
@@ -85,12 +90,17 @@ export function registerRuntimePoolFactory(factory: RuntimePoolFactory): void {
     );
   }
   registry.poolFactory = factory;
+  registry.canReusePoolsAcrossRequests = options.canReuseAcrossRequests ?? true;
 }
 
 export function isRuntimePoolFactoryRegistered(): boolean {
   return getRuntimePgDriverRegistry().poolFactory !== null;
 }
 
+export function canReuseRuntimePostgresPoolsAcrossRequests(): boolean {
+  return getRuntimePgDriverRegistry().canReusePoolsAcrossRequests;
+}
+
 export function registerRuntimeOneShotQueryFactory(
   factory: RuntimeOneShotQueryFactory,
 ): void {
@@ -146,4 +156,5 @@ export function __resetRuntimePoolFactoryForTests(): void {
   const registry = getRuntimePgDriverRegistry();
   registry.poolFactory = null;
   registry.oneShotQueryFactory = null;
+  registry.canReusePoolsAcrossRequests = true;
 }

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

@@ -1,13 +1,10 @@
-import type { AuthoredStaleAfterSeconds, PreviousCell } from './cell-staleness';
+import type { PreviousCell } from './cell-staleness';
 
 export type StepProgramDatasetOptions = {
   runIf?: (
     row: Record<string, unknown>,
     index: number,
   ) => boolean | Promise<boolean>;
-  recompute?: boolean;
-  recomputeOnError?: boolean;
-  staleAfterSeconds?: AuthoredStaleAfterSeconds;
 };
 
 export type StepProgramDatasetColumnRunInput<Value = unknown> = {
@@ -50,10 +47,7 @@ function isPreviousCell(value: unknown): value is PreviousCell {
 
 export type StepProgramDatasetStep<TResolver> = {
   name: string;
-  recompute?: boolean;
-  recomputeOnError?: boolean;
   resolver: TResolver;
-  staleAfterSeconds?: AuthoredStaleAfterSeconds;
 };
 
 export type StepProgramDatasetProgram<TStep> = {
@@ -134,13 +128,6 @@ export class StepProgramDatasetBuilder<
           normalized.resolver,
           normalized.options,
         ),
-        ...(normalized.options?.staleAfterSeconds !== undefined
-          ? { staleAfterSeconds: normalized.options.staleAfterSeconds }
-          : {}),
-        ...(normalized.options?.recompute === true ? { recompute: true } : {}),
-        ...(normalized.options?.recomputeOnError === true
-          ? { recomputeOnError: true }
-          : {}),
       } as TStep,
     ];
     return this;

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

@@ -0,0 +1,159 @@
+import {
+  cloneToolExecuteResultWithExecution,
+  isToolExecuteResult,
+  type ToolExecuteResult,
+  type ToolResultExecutionMetadata,
+} from './tool-result';
+
+type OptionalKey = string | null | undefined;
+
+type BaseToolExecutionOutcome = {
+  cacheKey?: OptionalKey;
+};
+
+export type ToolExecutionOutcome =
+  | (BaseToolExecutionOutcome & {
+      kind: 'live';
+      receiptKey?: OptionalKey;
+    })
+  | (BaseToolExecutionOutcome & {
+      kind: 'checkpoint';
+    })
+  | (BaseToolExecutionOutcome & {
+      kind: 'cache';
+      receiptKey: string;
+      attachedToReceiptKey?: OptionalKey;
+    })
+  | (BaseToolExecutionOutcome & {
+      kind: 'in_flight';
+      receiptKey: string;
+      attachedToReceiptKey?: OptionalKey;
+    });
+
+export type DurableReceiptRecoverySource = 'cache' | 'in_flight' | 'owner';
+
+function trimmed(value: OptionalKey): string | null {
+  const normalized = value?.trim();
+  return normalized ? normalized : null;
+}
+
+function optionalCacheKey(value: OptionalKey): Pick<
+  ToolResultExecutionMetadata,
+  'cacheKey'
+> {
+  const cacheKey = trimmed(value);
+  return cacheKey ? { cacheKey } : {};
+}
+
+function followerAttachment(input: {
+  receiptKey: string;
+  attachedToReceiptKey?: OptionalKey;
+}): Pick<ToolResultExecutionMetadata, 'attachedToReceiptKey'> {
+  return {
+    attachedToReceiptKey:
+      trimmed(input.attachedToReceiptKey) ?? input.receiptKey,
+  };
+}
+
+export function toolExecutionMetadataForOutcome(
+  outcome: ToolExecutionOutcome,
+): ToolResultExecutionMetadata {
+  switch (outcome.kind) {
+    case 'live': {
+      const receiptKey = trimmed(outcome.receiptKey);
+      return {
+        idempotent: true,
+        cached: false,
+        source: 'live',
+        ...optionalCacheKey(outcome.cacheKey),
+        ...(receiptKey ? { receiptRole: 'owner' as const, receiptKey } : {}),
+      };
+    }
+    case 'checkpoint':
+      return {
+        idempotent: true,
+        cached: true,
+        source: 'checkpoint',
+        ...optionalCacheKey(outcome.cacheKey),
+      };
+    case 'cache': {
+      const receiptKey = trimmed(outcome.receiptKey);
+      if (!receiptKey) {
+        throw new Error('Cached durable tool results require a receipt key.');
+      }
+      return {
+        idempotent: true,
+        cached: true,
+        source: 'cache',
+        ...optionalCacheKey(outcome.cacheKey),
+        receiptRole: 'follower',
+        receiptKey,
+        ...followerAttachment({
+          receiptKey,
+          attachedToReceiptKey: outcome.attachedToReceiptKey,
+        }),
+      };
+    }
+    case 'in_flight': {
+      const receiptKey = trimmed(outcome.receiptKey);
+      if (!receiptKey) {
+        throw new Error('In-flight durable tool results require a receipt key.');
+      }
+      return {
+        idempotent: true,
+        cached: false,
+        source: 'in_flight',
+        ...optionalCacheKey(outcome.cacheKey),
+        receiptRole: 'follower',
+        receiptKey,
+        ...followerAttachment({
+          receiptKey,
+          attachedToReceiptKey: outcome.attachedToReceiptKey,
+        }),
+      };
+    }
+    default: {
+      const exhaustive: never = outcome;
+      return exhaustive;
+    }
+  }
+}
+
+export function toolExecutionOutcomeForDurableReceipt(input: {
+  source: DurableReceiptRecoverySource;
+  receiptKey: string;
+  cacheKey?: OptionalKey;
+}): ToolExecutionOutcome {
+  return input.source === 'owner'
+    ? {
+        kind: 'live',
+        receiptKey: input.receiptKey,
+        cacheKey: input.cacheKey,
+      }
+    : {
+        kind: input.source,
+        receiptKey: input.receiptKey,
+        attachedToReceiptKey: input.receiptKey,
+        cacheKey: input.cacheKey,
+      };
+}
+
+export function cloneToolExecuteResultWithOutcome<TResult>(
+  value: ToolExecuteResult<TResult>,
+  outcome: ToolExecutionOutcome,
+): ToolExecuteResult<TResult> {
+  return cloneToolExecuteResultWithExecution(
+    value,
+    toolExecutionMetadataForOutcome(outcome),
+  );
+}
+
+export function markToolExecuteResultExecutionOutcome(
+  value: unknown,
+  outcome: ToolExecutionOutcome,
+): unknown {
+  if (!isToolExecuteResult(value)) {
+    return value;
+  }
+  return cloneToolExecuteResultWithOutcome(value, outcome);
+}

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

@@ -5,8 +5,11 @@ import type { PlayDataset, SerializedPlayDataset } from '../plays/dataset';
 export type ToolResultExecutionMetadata = {
   idempotent: true;
   cached: boolean;
-  source: 'live' | 'checkpoint' | 'cache';
+  source: 'live' | 'checkpoint' | 'cache' | 'in_flight';
   cacheKey?: string;
+  receiptRole?: 'owner' | 'follower';
+  receiptKey?: string;
+  attachedToReceiptKey?: string;
 };
 
 export type ToolResultTargetMetadata = {

package/dist/bundling-sources/shared_libs/play-runtime/work-receipts.ts

@@ -18,6 +18,30 @@ export type WorkReceiptCommand = {
   runId: string;
   key: string;
   reclaimRunning?: boolean;
+  forceRefresh?: boolean;
+};
+
+export type WorkReceiptBatchClaimCommand = {
+  playName: string;
+  runId: string;
+  keys: string[];
+  reclaimRunning?: boolean;
+  forceRefresh?: boolean;
+};
+
+export type WorkReceiptBatchCompleteCommand = {
+  playName: string;
+  receipts: Array<{ runId: string; key: string; output: unknown }>;
+};
+
+export type WorkReceiptBatchFailCommand = {
+  playName: string;
+  receipts: Array<{ runId: string; key: string; error: string }>;
+};
+
+export type WorkReceiptGetCommand = {
+  playName: string;
+  key: string;
 };
 
 export type WorkReceiptClaim =
@@ -39,13 +63,21 @@ export type WorkReceiptClaim =
     };
 
 export type WorkReceiptStore = {
+  getReceipt?(input: WorkReceiptGetCommand): Promise<WorkReceipt | null>;
   claimReceipt(input: WorkReceiptCommand): Promise<WorkReceiptClaim>;
+  claimReceipts?(
+    input: WorkReceiptBatchClaimCommand,
+  ): Promise<WorkReceiptClaim[]>;
   completeReceipt(
     input: WorkReceiptCommand & { output: unknown },
   ): Promise<WorkReceipt | null>;
+  completeReceipts?(
+    input: WorkReceiptBatchCompleteCommand,
+  ): Promise<WorkReceipt[]>;
   failReceipt(
     input: WorkReceiptCommand & { error: string },
   ): Promise<WorkReceipt | null>;
+  failReceipts?(input: WorkReceiptBatchFailCommand): Promise<WorkReceipt[]>;
 };
 
 const SCOPED_WORK_RECEIPT_KEY_VERSION = 'ctxv2';

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

@@ -198,8 +198,10 @@ export function validatePlayStructuredDefinition(definition: unknown): {
     if (typedStep.type === 'tool' && !typedStep.toolId?.trim()) {
       errors.push(`Tool step ${typedStep.alias || index} requires toolId.`);
     }
-    if (typedStep.type === 'waterfall' && !typedStep.tool?.trim()) {
-      errors.push(`Waterfall step ${typedStep.alias || index} requires tool.`);
+    if (typedStep.type === 'waterfall') {
+      errors.push(
+        `Waterfall step ${typedStep.alias || index} is no longer supported. Use explicit tool steps or a steps(...) program.`,
+      );
     }
     if (typedStep.type === 'run_javascript') {
       if (!typedStep.execute?.source?.trim()) {

package/dist/bundling-sources/shared_libs/plays/runtime-validation.ts

@@ -111,20 +111,9 @@ function validatePlayMapStructure(code: string): string[] {
         callExpression.callee.property.type === 'Identifier' &&
         callExpression.callee.property.name === 'waterfall'
       ) {
-        const firstArgument = callExpression.arguments[0];
-        if (firstArgument?.type === 'ObjectExpression') {
-          const minResultsProperty = firstArgument.properties.find(
-            (prop) =>
-              prop.type === 'Property' &&
-              prop.key.type === 'Identifier' &&
-              prop.key.name === 'minResults',
-          );
-          if (!minResultsProperty) {
-            errors.push(
-              'Inline ctx.waterfall({...}) calls must declare minResults.',
-            );
-          }
-        }
+        errors.push(
+          'ctx.waterfall(...) has been removed. Use explicit ctx.tools.execute(...) calls with steps(...) or ordinary TypeScript fallback logic.',
+        );
       }
       return;
     }

package/dist/bundling-sources/shared_libs/plays/static-pipeline.ts

@@ -131,9 +131,6 @@ export interface PlayStaticColumnProducer {
   toolId?: string;
   playId?: string;
   dependsOnFields?: string[];
-  recompute?: boolean;
-  recomputeOnError?: boolean;
-  staleAfterSeconds?: number;
   conditional?: boolean;
   sourceRange?: PlayStaticSourceRange;
   steps?: PlayStaticColumnProducer[];
@@ -144,9 +141,6 @@ export interface PlayStaticDatasetColumn {
   id: string;
   source: PlaySheetColumnSource;
   sqlName?: string;
-  recompute?: boolean;
-  recomputeOnError?: boolean;
-  staleAfterSeconds?: number;
   producers: PlayStaticColumnProducer[];
 }
 
@@ -337,9 +331,6 @@ export interface PlayStaticSourceRange {
 type PlayStaticSubstepMetadata = {
   conditional?: boolean;
   dependsOnFields?: string[];
-  recompute?: boolean;
-  recomputeOnError?: boolean;
-  staleAfterSeconds?: number;
 };
 
 export type PlayStaticSubstep = PlayStaticSubstepMetadata &
@@ -663,39 +654,11 @@ function compileDatasetColumns(
       sqlSafePlayColumnName(field),
     );
     if (!column) continue;
-    const pipelineSubstep =
-      substep.staleAfterSeconds === undefined &&
-      substep.recompute !== true &&
-      substep.recomputeOnError !== true
-        ? pipelineSubsteps.find(
-            (candidate) => fieldForColumnProducer(candidate) === field,
-          )
-        : undefined;
     const producer = columnProducerFromSubstep(
-      pipelineSubstep &&
-        (pipelineSubstep.staleAfterSeconds !== undefined ||
-          pipelineSubstep.recompute === true ||
-          pipelineSubstep.recomputeOnError === true)
-        ? pipelineSubstep
-        : substep,
+      substep,
       field,
     );
     column.producers.push(producer);
-    if (
-      column.staleAfterSeconds === undefined &&
-      producer.staleAfterSeconds !== undefined
-    ) {
-      column.staleAfterSeconds = producer.staleAfterSeconds;
-    }
-    if (column.recompute !== true && producer.recompute === true) {
-      column.recompute = true;
-    }
-    if (
-      column.recomputeOnError !== true &&
-      producer.recomputeOnError === true
-    ) {
-      column.recomputeOnError = true;
-    }
   }
 
   return [...columnsById.values()];
@@ -745,11 +708,6 @@ function columnProducerFromSubstep(
     ...(substep.dependsOnFields?.length
       ? { dependsOnFields: [...substep.dependsOnFields] }
       : {}),
-    ...(substep.recompute === true ? { recompute: true } : {}),
-    ...(substep.recomputeOnError === true ? { recomputeOnError: true } : {}),
-    ...(substep.staleAfterSeconds !== undefined
-      ? { staleAfterSeconds: substep.staleAfterSeconds }
-      : {}),
     ...(substep.conditional ? { conditional: true } : {}),
     ...(substep.sourceRange ? { sourceRange: substep.sourceRange } : {}),
     ...(steps && steps.length > 0 ? { steps } : {}),