@hatchet-dev/typescript-sdk 1.16.0 → 1.17.1

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

package/v1/declaration.js

@@ -131,9 +131,17 @@ 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) {

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) {
@@ -54,6 +57,16 @@ function stopWorker(worker) {
         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();

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/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: {};
+}, {}, {}, {}, {}>;

package/v1/examples/durable/workflow.js

@@ -8,9 +8,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.waitForSleepTwice = exports.durableWorkflow = exports.SLEEP_TIME = exports.SLEEP_TIME_SECONDS = exports.EVENT_KEY = void 0;
+exports.durableSpawnDag = exports.dagChildWorkflow = exports.memoNowCaching = exports.durableReplayReset = exports.REPLAY_RESET_MEMOIZED_MAX_SECONDS = exports.REPLAY_RESET_SLEEP_SECONDS = exports.durableNonDeterminism = exports.durableWithExplicitSpawn = exports.durableSleepEventSpawn = exports.durableWithBulkSpawn = exports.durableWithSpawn = exports.spawnChildTask = exports.waitForSleepTwice = exports.durableWorkflow = exports.SLEEP_TIME = exports.SLEEP_TIME_SECONDS = exports.EVENT_KEY = void 0;
 const conditions_1 = require("../../conditions");
+const non_determinism_error_1 = require("../../../util/errors/non-determinism-error");
+const sleep_1 = __importDefault(require("../../../util/sleep"));
 const hatchet_client_1 = require("../hatchet-client");
 exports.EVENT_KEY = 'durable-example:event';
 exports.SLEEP_TIME_SECONDS = 2;
@@ -31,12 +36,16 @@ exports.durableWorkflow.durableTask({
     executionTimeout: '10m',
     fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
         console.log('Waiting for sleep');
-        yield ctx.sleepFor(exports.SLEEP_TIME);
+        const sleepResult = yield ctx.sleepFor(exports.SLEEP_TIME);
         console.log('Sleep finished');
         console.log('Waiting for event');
-        yield ctx.waitFor({ eventKey: exports.EVENT_KEY });
+        const event = yield ctx.waitForEvent(exports.EVENT_KEY, 'true');
         console.log('Event received');
-        return { status: 'success' };
+        return {
+            status: 'success',
+            event: event,
+            sleep_duration_ms: sleepResult.durationMs,
+        };
     }),
 });
 function extractKeyAndEventId(waitResult) {
@@ -46,10 +55,10 @@ function extractKeyAndEventId(waitResult) {
     if (obj && typeof obj === 'object') {
         const [key] = Object.keys(obj);
         const inner = obj[key];
-        if (inner && typeof inner === 'object') {
+        if (inner && typeof inner === 'object' && !Array.isArray(inner)) {
             const [eventId] = Object.keys(inner);
             if (eventId) {
-                return { key: 'CREATE', eventId };
+                return { key, eventId };
             }
         }
         if (key) {
@@ -108,8 +117,154 @@ exports.waitForSleepTwice = hatchet_client_1.hatchet.durableTask({
             return { runtime: Math.round((Date.now() - start) / 1000) };
         }
         catch (e) {
-            // treat cancellation as a successful completion for parity with Python sample
             return { runtime: -1 };
         }
     }),
 });
+// --- Spawn child from durable task ---
+exports.spawnChildTask = hatchet_client_1.hatchet.task({
+    name: 'spawn-child-task',
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        return { message: `hello from child ${(_a = input.n) !== null && _a !== void 0 ? _a : 1}` };
+    }),
+});
+exports.durableWithSpawn = hatchet_client_1.hatchet.durableTask({
+    name: 'durable-with-spawn',
+    executionTimeout: '10s',
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const childResult = yield exports.spawnChildTask.run({});
+        return { child_output: childResult };
+    }),
+});
+exports.durableWithBulkSpawn = hatchet_client_1.hatchet.durableTask({
+    name: 'durable-with-bulk-spawn',
+    executionTimeout: '10m',
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const n = (_a = input.n) !== null && _a !== void 0 ? _a : 10;
+        const inputs = Array.from({ length: n }, (_, i) => ({ n: i }));
+        const childResults = yield exports.spawnChildTask.run(inputs);
+        return { child_outputs: childResults };
+    }),
+});
+exports.durableSleepEventSpawn = hatchet_client_1.hatchet.durableTask({
+    name: 'durable-sleep-event-spawn',
+    executionTimeout: '10m',
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const start = Date.now();
+        yield ctx.sleepFor(exports.SLEEP_TIME);
+        yield ctx.waitForEvent(exports.EVENT_KEY, 'true');
+        const childResult = yield exports.spawnChildTask.run({});
+        return {
+            runtime: (Date.now() - start) / 1000,
+            child_output: childResult,
+        };
+    }),
+});
+// --- Spawn child using explicit ctx.spawnChild ---
+exports.durableWithExplicitSpawn = hatchet_client_1.hatchet.durableTask({
+    name: 'durable-with-explicit-spawn',
+    executionTimeout: '10m',
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const childResult = yield ctx.spawnChild(exports.spawnChildTask, {});
+        return { child_output: childResult };
+    }),
+});
+// --- Non-determinism detection ---
+exports.durableNonDeterminism = hatchet_client_1.hatchet.durableTask({
+    name: 'durable-non-determinism',
+    executionTimeout: '10s',
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const sleepTime = ctx.invocationCount * 2;
+        try {
+            yield ctx.sleepFor(`${sleepTime}s`);
+        }
+        catch (e) {
+            if (e instanceof non_determinism_error_1.NonDeterminismError) {
+                return {
+                    attempt_number: ctx.invocationCount,
+                    sleep_time: sleepTime,
+                    non_determinism_detected: true,
+                    node_id: e.nodeId,
+                };
+            }
+            throw e;
+        }
+        return {
+            attempt_number: ctx.invocationCount,
+            sleep_time: sleepTime,
+            non_determinism_detected: false,
+        };
+    }),
+});
+// --- Replay reset ---
+exports.REPLAY_RESET_SLEEP_SECONDS = 3;
+/** Max duration (seconds) for a replayed/memoized step; above this we treat it as a real sleep. */
+exports.REPLAY_RESET_MEMOIZED_MAX_SECONDS = 5;
+const REPLAY_RESET_SLEEP = `${exports.REPLAY_RESET_SLEEP_SECONDS}s`;
+exports.durableReplayReset = hatchet_client_1.hatchet.durableTask({
+    name: 'durable-replay-reset',
+    executionTimeout: '20s',
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        let start = Date.now();
+        yield ctx.sleepFor(REPLAY_RESET_SLEEP);
+        const sleep1Duration = (Date.now() - start) / 1000;
+        start = Date.now();
+        yield ctx.sleepFor(REPLAY_RESET_SLEEP);
+        const sleep2Duration = (Date.now() - start) / 1000;
+        start = Date.now();
+        yield ctx.sleepFor(REPLAY_RESET_SLEEP);
+        const sleep3Duration = (Date.now() - start) / 1000;
+        return {
+            sleep_1_duration: sleep1Duration,
+            sleep_2_duration: sleep2Duration,
+            sleep_3_duration: sleep3Duration,
+        };
+    }),
+});
+exports.memoNowCaching = hatchet_client_1.hatchet.durableTask({
+    name: 'memo-now-caching',
+    executionTimeout: '10m',
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const now = yield ctx.now();
+        return { start_time: now.toISOString() };
+    }),
+});
+// --- Spawn DAG from durable task ---
+exports.dagChildWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'dag-child-workflow-ts',
+});
+const dagChild1 = exports.dagChildWorkflow.task({
+    name: 'dag-child-1',
+    fn: () => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, sleep_1.default)(1000);
+        return { result: 'child1' };
+    }),
+});
+exports.dagChildWorkflow.task({
+    name: 'dag-child-2',
+    parents: [dagChild1],
+    fn: () => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, sleep_1.default)(2000);
+        return { result: 'child2' };
+    }),
+});
+exports.durableSpawnDag = hatchet_client_1.hatchet.durableTask({
+    name: 'durable-spawn-dag',
+    executionTimeout: '10s',
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const sleepStart = Date.now();
+        const sleepResult = yield ctx.sleepFor(exports.SLEEP_TIME);
+        const sleepDuration = (Date.now() - sleepStart) / 1000;
+        const spawnStart = Date.now();
+        const spawnResult = yield exports.dagChildWorkflow.run({});
+        const spawnDuration = (Date.now() - spawnStart) / 1000;
+        return {
+            sleep_duration: sleepDuration,
+            sleep_duration_ms: sleepResult.durationMs,
+            spawn_duration: spawnDuration,
+            spawn_result: spawnResult,
+        };
+    }),
+});

package/v1/examples/durable-event/workflow.js

@@ -17,9 +17,7 @@ exports.durableEvent = hatchet_client_1.hatchet.durableTask({
     name: 'durable-event',
     executionTimeout: '10m',
     fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-        const res = ctx.waitFor({
-            eventKey: 'user:update',
-        });
+        const res = yield ctx.waitForEvent('user:update');
         console.log('res', res);
         return {
             Value: 'done',
@@ -32,10 +30,7 @@ exports.durableEventWithFilter = hatchet_client_1.hatchet.durableTask({
     executionTimeout: '10m',
     fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
         // > Durable Event With Filter
-        const res = ctx.waitFor({
-            eventKey: 'user:update',
-            expression: "input.userId == '1234'",
-        });
+        const res = yield ctx.waitForEvent('user:update', "input.userId == '1234'");
         // !!
         console.log('res', res);
         return {

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

@@ -1,3 +1,4 @@
+export declare const EVENT_KEY = "user:update";
 export declare const durableEvent: import("../..").TaskWorkflowDeclaration<import("../..").JsonObject, {
     Value: string;
 }, {}, {}, {}, {}>;

package/v1/examples/durable_event/workflow.js

@@ -9,17 +9,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.durableEventWithFilter = exports.durableEvent = void 0;
-// import sleep from '../../../util/sleep.js';
+exports.durableEventWithFilter = exports.durableEvent = exports.EVENT_KEY = void 0;
 const hatchet_client_1 = require("../hatchet-client");
+exports.EVENT_KEY = 'user:update';
 // > Durable Event
 exports.durableEvent = hatchet_client_1.hatchet.durableTask({
     name: 'durable-event',
     executionTimeout: '10m',
     fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-        const res = ctx.waitFor({
-            eventKey: 'user:update',
-        });
+        const res = yield ctx.waitForEvent(exports.EVENT_KEY);
         console.log('res', res);
         return {
             Value: 'done',
@@ -32,10 +30,7 @@ exports.durableEventWithFilter = hatchet_client_1.hatchet.durableTask({
     executionTimeout: '10m',
     fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
         // > Durable Event With Filter
-        const res = ctx.waitFor({
-            eventKey: 'user:update',
-            expression: "input.userId == '1234'",
-        });
+        const res = yield ctx.waitForEvent(exports.EVENT_KEY, "input.userId == '1234'");
         // !!
         console.log('res', res);
         return {

package/v1/examples/durable_eviction/capacity-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/v1/examples/durable_eviction/capacity-worker.js

@@ -0,0 +1,31 @@
+"use strict";
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Dedicated worker for capacity-eviction e2e tests.
+ *
+ * Runs with durableSlots=1 so that a single waiting durable task triggers
+ * capacity pressure and gets evicted (even with ttl=undefined).
+ */
+const hatchet_client_1 = require("../hatchet-client");
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield hatchet_client_1.hatchet.worker('capacity-eviction-worker', {
+            durableSlots: 1,
+            workflows: [workflow_1.capacityEvictableSleep],
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}

package/v1/examples/durable_eviction/worker.d.ts

@@ -0,0 +1 @@
+export {};

package/v1/examples/durable_eviction/worker.js

@@ -0,0 +1,34 @@
+"use strict";
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const hatchet_client_1 = require("../hatchet-client");
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield hatchet_client_1.hatchet.worker('eviction-worker', {
+            workflows: [
+                workflow_1.evictableSleep,
+                workflow_1.evictableWaitForEvent,
+                workflow_1.evictableChildSpawn,
+                workflow_1.evictableChildBulkSpawn,
+                workflow_1.multipleEviction,
+                workflow_1.nonEvictableSleep,
+                workflow_1.childTask,
+                workflow_1.bulkChildTask,
+                workflow_1.evictableSleepForGracefulTermination,
+            ],
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}

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

@@ -0,0 +1,44 @@
+export declare const EVICTION_TTL_SECONDS = 5;
+export declare const LONG_SLEEP_SECONDS = 15;
+export declare const EVENT_KEY = "durable-eviction:event";
+export declare const childTask: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, {
+    child_status: string;
+}, {}, {}, {}, {}>;
+export declare const evictableSleep: import("../..").TaskWorkflowDeclaration<import("../..").JsonObject, {
+    status: string;
+}, {}, {}, {}, {}>;
+export declare const evictableSleepForGracefulTermination: import("../..").TaskWorkflowDeclaration<import("../..").JsonObject, {
+    status: string;
+}, {}, {}, {}, {}>;
+export declare const evictableWaitForEvent: import("../..").TaskWorkflowDeclaration<import("../..").JsonObject, {
+    status: string;
+}, {}, {}, {}, {}>;
+export declare const evictableChildSpawn: import("../..").TaskWorkflowDeclaration<import("../..").JsonObject, {
+    child: {
+        child_status: string;
+    };
+    status: string;
+}, {}, {}, {}, {}>;
+export declare const multipleEviction: import("../..").TaskWorkflowDeclaration<import("../..").JsonObject, {
+    status: string;
+}, {}, {}, {}, {}>;
+export declare const bulkChildTask: import("../..").TaskWorkflowDeclaration<{
+    sleepSeconds: number;
+}, {
+    sleepSeconds: number;
+    status: string;
+}, {}, {}, {}, {}>;
+export declare const evictableChildBulkSpawn: import("../..").TaskWorkflowDeclaration<import("../..").JsonObject, {
+    child_results: {
+        sleepSeconds: number;
+        status: string;
+    }[];
+    status: string;
+}, {}, {}, {}, {}>;
+export declare const CAPACITY_SLEEP_SECONDS = 20;
+export declare const capacityEvictableSleep: import("../..").TaskWorkflowDeclaration<import("../..").JsonObject, {
+    status: string;
+}, {}, {}, {}, {}>;
+export declare const nonEvictableSleep: import("../..").TaskWorkflowDeclaration<import("../..").JsonObject, {
+    status: string;
+}, {}, {}, {}, {}>;