@hatchet-dev/typescript-sdk 1.15.2 → 1.17.0

package/v1/client/worker/worker.js

@@ -14,10 +14,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.__testing = exports.Worker = void 0;
 const sleep_1 = __importDefault(require("../../../util/sleep"));
+const declaration_1 = require("../../declaration");
 const legacy_transformer_1 = require("../../../legacy/legacy-transformer");
 const worker_internal_1 = require("./worker-internal");
 const slot_utils_1 = require("./slot-utils");
 const deprecated_1 = require("./deprecated");
+const engine_version_1 = require("./engine-version");
 /**
  * HatchetWorker class for workflow execution runtime
  */
@@ -97,9 +99,35 @@ class Worker {
                 this._legacyWorker = yield deprecated_1.LegacyDualWorker.create(this._v1, this.name, legacyConfig);
                 return this._legacyWorker.start();
             }
+            const engineVersion = yield (0, deprecated_1.fetchEngineVersion)(this._v1).catch(() => undefined);
+            this._checkEvictionSupport(engineVersion);
+            this._internal.engineVersion = engineVersion;
             return this._internal.start();
         });
     }
+    _checkEvictionSupport(engineVersion) {
+        if ((0, engine_version_1.supportsEviction)(engineVersion))
+            return;
+        const workflows = (this.config.workflows || []);
+        const tasksWithEviction = [];
+        for (const wf of workflows) {
+            if (!(wf instanceof declaration_1.BaseWorkflowDeclaration))
+                continue;
+            for (const task of wf.definition._durableTasks) {
+                if (task.evictionPolicy) {
+                    tasksWithEviction.push(`${wf.definition.name}:${task.name}`);
+                }
+            }
+        }
+        if (tasksWithEviction.length === 0)
+            return;
+        const names = tasksWithEviction.join(', ');
+        const logger = this._v1.config.logger('Worker', this._v1.config.log_level);
+        (0, deprecated_1.emitDeprecationNotice)('pre-eviction-engine', `Engine ${engineVersion || 'unknown'} does not support durable eviction ` +
+            `(requires >= ${engine_version_1.MinEngineVersion.DURABLE_EVICTION}). ` +
+            `Eviction policies will be ignored for tasks: ${names}. ` +
+            `Please upgrade your Hatchet engine.`, new Date('2026-03-01T00:00:00Z'), logger);
+    }
     /**
      * Stops the worker
      * @returns Promise that resolves when the worker stops
@@ -163,6 +191,12 @@ class Worker {
             const pollInterval = 200;
             const start = Date.now();
             while (Date.now() - start < timeoutMs) {
+                // start() may asynchronously detect a legacy engine and set _legacyWorker
+                // after waitUntilReady has already entered this loop
+                if (this._legacyWorker) {
+                    yield (0, sleep_1.default)(2000);
+                    return;
+                }
                 if ((_a = this._internal) === null || _a === void 0 ? void 0 : _a.workerId)
                     return;
                 yield (0, sleep_1.default)(pollInterval);

package/v1/conditions/base.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Condition = exports.Action = void 0;
-/* eslint-disable no-shadow */
 var Action;
 (function (Action) {
     Action[Action["CREATE"] = 0] = "CREATE";

package/v1/conditions/index.js

@@ -1,7 +1,4 @@
 "use strict";
-/* eslint-disable no-param-reassign */
-/* eslint-disable no-shadow */
-/* eslint-disable max-classes-per-file */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OrCondition = exports.UserEventCondition = exports.SleepCondition = void 0;
 exports.Render = Render;
@@ -33,8 +30,9 @@ exports.OrCondition = OrCondition;
  * );
  */
 function Render(action, conditions) {
-    if (!conditions)
+    if (!conditions) {
         return [];
+    }
     if (!Array.isArray(conditions)) {
         return Render(action, [conditions]);
     }

package/v1/conditions/sleep-condition.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SleepCondition = void 0;
+const duration_1 = require("../client/duration");
 const base_1 = require("./base");
 /**
  * Represents a condition that waits for a specified duration before proceeding.
@@ -27,7 +28,7 @@ class SleepCondition extends base_1.Condition {
      */
     constructor(sleepFor, readableDataKey, action) {
         super({
-            readableDataKey: readableDataKey || `sleep-${sleepFor}`,
+            readableDataKey: readableDataKey || `sleep-${(0, duration_1.durationToString)(sleepFor)}`,
             action,
             orGroupId: '',
             expression: '',

package/v1/conditions/transformer.js

@@ -6,6 +6,7 @@ const apply_namespace_1 = require("../../util/apply-namespace");
 const _1 = require(".");
 const base_1 = require("./base");
 const parent_condition_1 = require("./parent-condition");
+const duration_1 = require("../client/duration");
 function taskConditionsToPb(task, namespace) {
     const waitForConditions = (0, _1.Render)(base_1.Action.QUEUE, task.waitFor);
     const cancelIfConditions = (0, _1.Render)(base_1.Action.CANCEL, task.cancelIf);
@@ -21,7 +22,7 @@ function conditionsToPb(conditions, namespace) {
         if (condition instanceof _1.SleepCondition) {
             sleepConditions.push({
                 base: baseToPb(condition.base),
-                sleepFor: condition.sleepFor,
+                sleepFor: (0, duration_1.durationToString)(condition.sleepFor),
             });
         }
         else if (condition instanceof _1.UserEventCondition) {

package/v1/declaration.d.ts

@@ -8,13 +8,13 @@
 import WorkflowRunRef from '../util/workflow-run-ref';
 import { CronWorkflows, ScheduledWorkflows, V1CreateFilterRequest } from '../clients/rest/generated/data-contracts';
 import { z } from 'zod';
-import { WorkerLabelComparator } from '../protoc/v1/workflows';
 import { IHatchetClient } from './client/client.interface';
-import { CreateWorkflowTaskOpts, CreateOnFailureTaskOpts, TaskFn, CreateWorkflowDurableTaskOpts, CreateBaseTaskOpts, CreateOnSuccessTaskOpts, Concurrency, DurableTaskFn } from './task';
+import { CreateWorkflowTaskOpts, CreateOnFailureTaskOpts, TaskFn, CreateWorkflowDurableTaskOpts, CreateBaseTaskOpts, CreateOnSuccessTaskOpts, Concurrency, DurableTaskFn, WorkerLabelComparator } from './task';
 import { Duration } from './client/duration';
 import { MetricsClient } from './client/features/metrics';
 import { InputType, OutputType, UnknownInputType, JsonObject, Resolved } from './types';
 import { Context, DurableContext } from './client/worker/context';
+import { EvictionPolicy } from './client/worker/eviction/eviction-policy';
 export declare enum Priority {
     LOW = 1,
     MEDIUM = 2,
@@ -141,7 +141,9 @@ export type CreateBaseWorkflowOpts = {
     inputValidator?: z.ZodType<any>;
 };
 export type CreateTaskWorkflowOpts<I extends InputType = UnknownInputType, O extends OutputType = void> = CreateBaseWorkflowOpts & CreateBaseTaskOpts<I, O, TaskFn<I, O>>;
-export type CreateDurableTaskWorkflowOpts<I extends InputType = UnknownInputType, O extends OutputType = void> = CreateBaseWorkflowOpts & CreateBaseTaskOpts<I, O, DurableTaskFn<I, O>>;
+export type CreateDurableTaskWorkflowOpts<I extends InputType = UnknownInputType, O extends OutputType = void> = CreateBaseWorkflowOpts & CreateBaseTaskOpts<I, O, DurableTaskFn<I, O>> & {
+    evictionPolicy?: EvictionPolicy;
+};
 /**
  * Options for creating a new workflow.
  * @hidden
@@ -453,7 +455,7 @@ export declare class WorkflowDeclaration<I extends InputType = UnknownInputType,
  * @template MiddlewareBefore - Extra fields added to the task fn input by pre-middleware hooks.
  * @template MiddlewareAfter - Extra fields merged into the task output by post-middleware hooks.
  */
-export declare class TaskWorkflowDeclaration<I extends InputType = UnknownInputType, O extends OutputType = void, GlobalInput extends Record<string, any> = {}, GlobalOutput extends Record<string, any> = {}, MiddlewareBefore extends Record<string, any> = {}, MiddlewareAfter extends Record<string, any> = {}> extends BaseWorkflowDeclaration<I, O> {
+export declare class TaskWorkflowDeclaration<I extends InputType = UnknownInputType, O extends OutputType = void, GlobalInput extends Record<string, any> = {}, GlobalOutput extends Record<string, any> = {}, _MiddlewareBefore extends Record<string, any> = {}, MiddlewareAfter extends Record<string, any> = {}> extends BaseWorkflowDeclaration<I, O> {
     _standalone_task_name: string;
     constructor(options: CreateTaskWorkflowOpts<any, any>, client?: IHatchetClient);
     /**

package/v1/declaration.js

@@ -1,4 +1,11 @@
 "use strict";
+/**
+ * `Runnables` in the Hatchet TypeScript SDK are things that can be run, namely tasks and workflows. The two main types of runnables you'll encounter are:
+ *
+ * - `WorkflowDeclaration`, returned by `hatchet.workflow(...)`, which lets you define tasks and call `run()`, `schedule()`, `cron()`, etc.
+ * - `TaskWorkflowDeclaration`, returned by `hatchet.task(...)`, which is a single standalone task that exposes the same execution helpers as a workflow.
+ * @module Runnables
+ */
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -16,7 +23,6 @@ exports.CreateDurableTaskWorkflow = CreateDurableTaskWorkflow;
 const abort_error_1 = require("../util/abort-error");
 const parent_run_context_vars_1 = require("./parent-run-context-vars");
 const UNBOUND_ERR = new Error('workflow unbound to hatchet client, hint: use client.run instead');
-// eslint-disable-next-line no-shadow
 var Priority;
 (function (Priority) {
     Priority[Priority["LOW"] = 1] = "LOW";
@@ -93,15 +99,12 @@ class BaseWorkflowDeclaration {
                 resp.forEach((ref, index) => {
                     const wf = input[index].workflow;
                     if (wf instanceof TaskWorkflowDeclaration) {
-                        // eslint-disable-next-line no-param-reassign
                         ref._standaloneTaskName = wf._standalone_task_name;
                     }
                     if (_standaloneTaskName) {
-                        // eslint-disable-next-line no-param-reassign
                         ref._standaloneTaskName = _standaloneTaskName;
                     }
                     // Ensure result subscriptions inherit cancellation if no signal is provided explicitly.
-                    // eslint-disable-next-line no-param-reassign
                     ref.defaultSignal = inheritedSignal;
                     res.push(ref);
                 });
@@ -128,19 +131,29 @@ class BaseWorkflowDeclaration {
     }
     run(input, options, _standaloneTaskName) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             if (!this.client) {
                 throw UNBOUND_ERR;
             }
+            const durableCtx = (_a = parent_run_context_vars_1.parentRunContextManager.getContext()) === null || _a === void 0 ? void 0 : _a.durableContext;
+            if (durableCtx) {
+                if (Array.isArray(input)) {
+                    return durableCtx.spawnChildren(input.map((inp) => ({ workflow: this, input: inp, options })));
+                }
+                return durableCtx.spawnChild(this, input, options);
+            }
             if (Array.isArray(input)) {
                 const refs = yield this.runNoWait(input, options, _standaloneTaskName);
                 if (options === null || options === void 0 ? void 0 : options.returnExceptions) {
                     const settled = yield Promise.allSettled(refs.map((ref) => ref.result()));
                     return settled.map((s) => {
-                        if (s.status === 'fulfilled')
+                        if (s.status === 'fulfilled') {
                             return s.value;
+                        }
                         const { reason } = s;
-                        if (reason instanceof Error)
+                        if (reason instanceof Error) {
                             return reason;
+                        }
                         return new Error(Array.isArray(reason) ? reason.join('; ') : String(reason));
                     });
                 }
@@ -567,7 +580,7 @@ function CreateDurableTaskWorkflow(options, client) {
     const taskWorkflow = new TaskWorkflowDeclaration(options, client);
     // Move the task from tasks to durableTasks
     if (taskWorkflow.definition._tasks.length > 0) {
-        const task = taskWorkflow.definition._tasks[0];
+        const [task] = taskWorkflow.definition._tasks;
         taskWorkflow.definition._tasks = [];
         taskWorkflow.definition._durableTasks.push(task);
     }

package/v1/examples/__e2e__/harness.d.ts

@@ -11,6 +11,11 @@ export declare function startWorker({ client, name, workflows, slots, }: {
     slots?: number;
 }): Promise<Worker>;
 export declare function stopWorker(worker: Worker | undefined): Promise<void>;
+/**
+ * Checks whether the connected engine supports durable eviction.
+ * Call from beforeAll / beforeEach and skip tests when false.
+ */
+export declare function checkDurableEvictionSupport(client: HatchetClient): Promise<boolean>;
 export declare function poll<T>(fn: () => Promise<T>, { timeoutMs, intervalMs, shouldStop, label, }: {
     timeoutMs?: number;
     intervalMs?: number;

package/v1/examples/__e2e__/harness.js

@@ -17,10 +17,13 @@ exports.makeE2EClient = makeE2EClient;
 exports.makeTestScope = makeTestScope;
 exports.startWorker = startWorker;
 exports.stopWorker = stopWorker;
+exports.checkDurableEvictionSupport = checkDurableEvictionSupport;
 exports.poll = poll;
 const sleep_1 = __importDefault(require("../../../util/sleep"));
 const crypto_1 = require("crypto");
 const v1_1 = require("../..");
+const engine_version_1 = require("../../client/worker/engine-version");
+const legacy_worker_1 = require("../../client/worker/deprecated/legacy-worker");
 function requireEnv(name) {
     const value = process.env[name];
     if (!value) {
@@ -47,20 +50,31 @@ function startWorker(_a) {
 }
 function stopWorker(worker) {
     return __awaiter(this, void 0, void 0, function* () {
-        if (!worker)
+        if (!worker) {
             return;
+        }
         yield worker.stop();
         yield (0, sleep_1.default)(300);
     });
 }
+/**
+ * Checks whether the connected engine supports durable eviction.
+ * Call from beforeAll / beforeEach and skip tests when false.
+ */
+function checkDurableEvictionSupport(client) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const version = yield (0, legacy_worker_1.fetchEngineVersion)(client).catch(() => undefined);
+        return (0, engine_version_1.supportsEviction)(version);
+    });
+}
 function poll(fn_1, _a) {
     return __awaiter(this, arguments, void 0, function* (fn, { timeoutMs = 30000, intervalMs = 100, shouldStop, label = 'poll', }) {
         const start = Date.now();
-        // eslint-disable-next-line no-constant-condition
         while (true) {
             const value = yield fn();
-            if (shouldStop(value))
+            if (shouldStop(value)) {
                 return value;
+            }
             if (Date.now() - start > timeoutMs) {
                 throw new Error(`Timed out waiting for ${label} after ${timeoutMs}ms`);
             }

package/v1/examples/affinity/affinity-workers.js

@@ -20,7 +20,6 @@ workflow.task({
     name: 'step1',
     fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
         const results = [];
-        // eslint-disable-next-line no-plusplus
         for (let i = 0; i < 50; i++) {
             const result = yield childWorkflow.run({});
             results.push(result);

package/v1/examples/bulk_operations/workflow.js

@@ -10,7 +10,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.bulkReplayTest3 = exports.bulkReplayTest2 = exports.bulkReplayTest1 = void 0;
-/* eslint-disable no-console */
 const hatchet_client_1 = require("../hatchet-client");
 exports.bulkReplayTest1 = hatchet_client_1.hatchet.task({
     name: 'bulk-replay-test-1',

package/v1/examples/cancellation/run.js

@@ -12,7 +12,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable no-console */
 // > Running a Task with Results
 const sleep_1 = __importDefault(require("../../../util/sleep"));
 const cancellation_workflow_1 = require("./cancellation-workflow");

package/v1/examples/cancellations/run.js

@@ -12,7 +12,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable no-console */
 // > Running a Task with Results
 const sleep_1 = __importDefault(require("../../../util/sleep"));
 const workflow_1 = require("./workflow");

package/v1/examples/child_workflows/run.js

@@ -15,7 +15,6 @@ function main() {
         const res = yield workflow_1.parent.run({
             N: 10,
         });
-        // eslint-disable-next-line no-console
         console.log(res.Result);
     });
 }
@@ -23,7 +22,6 @@ if (require.main === module) {
     main()
         .then(() => process.exit(0))
         .catch((error) => {
-        // eslint-disable-next-line no-console
         console.error('Error:', error);
         process.exit(1);
     });

package/v1/examples/child_workflows/workflow.js

@@ -10,7 +10,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.withErrorHandling = exports.parentSingleChild = exports.parent = exports.child = void 0;
-/* eslint-disable no-plusplus */
 // > Declaring a Child
 const hatchet_client_1 = require("../hatchet-client");
 exports.child = hatchet_client_1.hatchet.task({

package/v1/examples/concurrency-rr/load.js

@@ -9,7 +9,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable no-plusplus */
 const hatchet_client_1 = require("../hatchet-client");
 const workflow_1 = require("./workflow");
 function generateRandomString(length) {

package/v1/examples/concurrency-rr/run.js

@@ -26,11 +26,8 @@ function main() {
                 GroupKey: 'B',
             },
         ]);
-        // eslint-disable-next-line no-console
         console.log(res[0]['to-lower'].TransformedMessage);
-        // eslint-disable-next-line no-console
         console.log(res[1]['to-lower'].TransformedMessage);
-        // eslint-disable-next-line no-console
         console.log(res[2]['to-lower'].TransformedMessage);
     });
 }

package/v1/examples/concurrency_limit_rr/load.js

@@ -9,7 +9,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable no-plusplus */
 const hatchet_client_1 = require("../hatchet-client");
 const workflow_1 = require("./workflow");
 function generateRandomString(length) {

package/v1/examples/concurrency_limit_rr/run.js

@@ -26,11 +26,8 @@ function main() {
                 GroupKey: 'B',
             },
         ]);
-        // eslint-disable-next-line no-console
         console.log(res[0]['to-lower'].TransformedMessage);
-        // eslint-disable-next-line no-console
         console.log(res[1]['to-lower'].TransformedMessage);
-        // eslint-disable-next-line no-console
         console.log(res[2]['to-lower'].TransformedMessage);
     });
 }

package/v1/examples/concurrency_workflow_level/workflow.d.ts

@@ -1,5 +1,5 @@
 import type { EmptyTaskOutput } from '../concurrency-types';
-export declare const SLEEP_TIME_MS = 500;
+export declare const SLEEP_TIME_MS = 2000;
 export declare const DIGIT_MAX_RUNS = 8;
 export declare const NAME_MAX_RUNS = 3;
 export type WorkflowInput = {

package/v1/examples/concurrency_workflow_level/workflow.js

@@ -15,7 +15,7 @@ const hatchet_client_1 = require("../hatchet-client");
 const sleep = (ms) => new Promise((resolve) => {
     setTimeout(resolve, ms);
 });
-exports.SLEEP_TIME_MS = 500;
+exports.SLEEP_TIME_MS = 2000;
 exports.DIGIT_MAX_RUNS = 8;
 exports.NAME_MAX_RUNS = 3;
 exports.concurrencyWorkflowLevelWorkflow = hatchet_client_1.hatchet.workflow({

package/v1/examples/conditions/event.js

@@ -21,7 +21,6 @@ if (require.main === module) {
     main()
         .then(() => process.exit(0))
         .catch((error) => {
-        // eslint-disable-next-line no-console
         console.error('Error:', error);
         process.exit(1);
     });

package/v1/examples/conditions/run.js

@@ -9,7 +9,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable no-console */
 const workflow_1 = require("./workflow");
 function main() {
     return __awaiter(this, void 0, void 0, function* () {

package/v1/examples/dag/run.js

@@ -17,7 +17,6 @@ function main() {
             Message: 'hello world',
         });
         // !!
-        // eslint-disable-next-line no-console
         console.log(res.reverse.Transformed);
     });
 }

package/v1/examples/dag_match_condition/event.js

@@ -21,7 +21,6 @@ if (require.main === module) {
     main()
         .then(() => process.exit(0))
         .catch((error) => {
-        // eslint-disable-next-line no-console
         console.error('Error:', error);
         process.exit(1);
     });

package/v1/examples/dag_match_condition/run.js

@@ -9,7 +9,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable no-console */
 const workflow_1 = require("./workflow");
 function main() {
     return __awaiter(this, void 0, void 0, function* () {

package/v1/examples/deep/run.js

@@ -16,13 +16,11 @@ function main() {
             Message: 'hello',
             N: 5,
         });
-        // eslint-disable-next-line no-console
         console.log(res.parent.Sum);
     });
 }
 if (require.main === module) {
     main()
-        // eslint-disable-next-line no-console
         .catch(console.error)
         .finally(() => process.exit(0));
 }

package/v1/examples/durable/workflow.d.ts

@@ -5,3 +5,60 @@ export declare const durableWorkflow: import("../..").WorkflowDeclaration<import
 export declare const waitForSleepTwice: import("../..").TaskWorkflowDeclaration<import("../..").JsonObject, {
     runtime: number;
 }, {}, {}, {}, {}>;
+export declare const spawnChildTask: import("../..").TaskWorkflowDeclaration<{
+    n?: number;
+}, {
+    message: string;
+}, {}, {}, {}, {}>;
+export declare const durableWithSpawn: import("../..").TaskWorkflowDeclaration<import("../..").JsonObject, {
+    child_output: {
+        message: string;
+    };
+}, {}, {}, {}, {}>;
+export declare const durableWithBulkSpawn: import("../..").TaskWorkflowDeclaration<{
+    n?: number;
+}, {
+    child_outputs: {
+        message: string;
+    }[];
+}, {}, {}, {}, {}>;
+export declare const durableSleepEventSpawn: import("../..").TaskWorkflowDeclaration<import("../..").JsonObject, {
+    runtime: number;
+    child_output: {
+        message: string;
+    };
+}, {}, {}, {}, {}>;
+export declare const durableWithExplicitSpawn: import("../..").TaskWorkflowDeclaration<import("../..").JsonObject, {
+    child_output: {
+        message: string;
+    };
+}, {}, {}, {}, {}>;
+export declare const durableNonDeterminism: import("../..").TaskWorkflowDeclaration<import("../..").JsonObject, {
+    attempt_number: number;
+    sleep_time: number;
+    non_determinism_detected: true;
+    node_id: number;
+} | {
+    attempt_number: number;
+    sleep_time: number;
+    non_determinism_detected: false;
+    node_id?: undefined;
+}, {}, {}, {}, {}>;
+export declare const REPLAY_RESET_SLEEP_SECONDS = 3;
+/** Max duration (seconds) for a replayed/memoized step; above this we treat it as a real sleep. */
+export declare const REPLAY_RESET_MEMOIZED_MAX_SECONDS = 5;
+export declare const durableReplayReset: import("../..").TaskWorkflowDeclaration<import("../..").JsonObject, {
+    sleep_1_duration: number;
+    sleep_2_duration: number;
+    sleep_3_duration: number;
+}, {}, {}, {}, {}>;
+export declare const memoNowCaching: import("../..").TaskWorkflowDeclaration<import("../..").JsonObject, {
+    start_time: string;
+}, {}, {}, {}, {}>;
+export declare const dagChildWorkflow: import("../..").WorkflowDeclaration<import("../..").UnknownInputType, {}, {}>;
+export declare const durableSpawnDag: import("../..").TaskWorkflowDeclaration<import("../..").JsonObject, {
+    sleep_duration: number;
+    sleep_duration_ms: number;
+    spawn_duration: number;
+    spawn_result: {};
+}, {}, {}, {}, {}>;