@hatchet-dev/typescript-sdk 1.15.2 → 1.17.0

package/v1/examples/durable/workflow.js

@@ -8,10 +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;
-/* eslint-disable no-console */
+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;
@@ -32,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) {
@@ -45,12 +53,12 @@ function extractKeyAndEventId(waitResult) {
     // The shape is typically `{ [readableDataKey]: { [eventId]: ... } }`.
     const obj = waitResult;
     if (obj && typeof obj === 'object') {
-        const key = Object.keys(obj)[0];
+        const [key] = Object.keys(obj);
         const inner = obj[key];
-        if (inner && typeof inner === 'object') {
-            const eventId = Object.keys(inner)[0];
+        if (inner && typeof inner === 'object' && !Array.isArray(inner)) {
+            const [eventId] = Object.keys(inner);
             if (eventId) {
-                return { key: 'CREATE', eventId };
+                return { key, eventId };
             }
         }
         if (key) {
@@ -109,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/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/durable-event/run.js

@@ -15,7 +15,6 @@ function main() {
         const timeStart = Date.now();
         const res = yield workflow_1.durableEvent.run({});
         const timeEnd = Date.now();
-        // eslint-disable-next-line no-console
         console.log(`Time taken: ${timeEnd - timeStart}ms`);
     });
 }
@@ -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/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-sleep/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/durable-sleep/run.js

@@ -15,7 +15,6 @@ function main() {
         const timeStart = Date.now();
         const res = yield workflow_1.durableSleep.run({});
         const timeEnd = Date.now();
-        // eslint-disable-next-line no-console
         console.log(`Time taken: ${timeEnd - timeStart}ms`);
     });
 }
@@ -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/durable_event/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/durable_event/run.js

@@ -15,7 +15,6 @@ function main() {
         const timeStart = Date.now();
         const res = yield workflow_1.durableEvent.run({});
         const timeEnd = Date.now();
-        // eslint-disable-next-line no-console
         console.log(`Time taken: ${timeEnd - timeStart}ms`);
     });
 }
@@ -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/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;
+}, {}, {}, {}, {}>;

package/v1/examples/durable_eviction/workflow.js

@@ -0,0 +1,129 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nonEvictableSleep = exports.capacityEvictableSleep = exports.CAPACITY_SLEEP_SECONDS = exports.evictableChildBulkSpawn = exports.bulkChildTask = exports.multipleEviction = exports.evictableChildSpawn = exports.evictableWaitForEvent = exports.evictableSleepForGracefulTermination = exports.evictableSleep = exports.childTask = exports.EVENT_KEY = exports.LONG_SLEEP_SECONDS = exports.EVICTION_TTL_SECONDS = void 0;
+const sleep_1 = __importDefault(require("../../../util/sleep"));
+const hatchet_client_1 = require("../hatchet-client");
+exports.EVICTION_TTL_SECONDS = 5;
+exports.LONG_SLEEP_SECONDS = 15;
+exports.EVENT_KEY = 'durable-eviction:event';
+const EVICTION_POLICY = {
+    ttl: `${exports.EVICTION_TTL_SECONDS}s`,
+    allowCapacityEviction: true,
+    priority: 0,
+};
+exports.childTask = hatchet_client_1.hatchet.task({
+    name: 'eviction-child-task',
+    fn: () => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, sleep_1.default)(exports.LONG_SLEEP_SECONDS * 1000);
+        return { child_status: 'completed' };
+    }),
+});
+exports.evictableSleep = hatchet_client_1.hatchet.durableTask({
+    name: 'evictable-sleep',
+    executionTimeout: '5m',
+    evictionPolicy: EVICTION_POLICY,
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        yield ctx.sleepFor(`${exports.LONG_SLEEP_SECONDS}s`);
+        return { status: 'completed' };
+    }),
+});
+// NOTE: DO NOT REGISTER ON E2E TEST WORKER
+exports.evictableSleepForGracefulTermination = hatchet_client_1.hatchet.durableTask({
+    name: 'evictable-sleep-for-graceful-termination',
+    executionTimeout: '5m',
+    evictionPolicy: {
+        ttl: `30m`,
+        allowCapacityEviction: true,
+        priority: 0,
+    },
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        yield ctx.sleepFor(`5m`);
+        return { status: 'completed' };
+    }),
+});
+exports.evictableWaitForEvent = hatchet_client_1.hatchet.durableTask({
+    name: 'evictable-wait-for-event',
+    executionTimeout: '5m',
+    evictionPolicy: EVICTION_POLICY,
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        yield ctx.waitForEvent(exports.EVENT_KEY, 'true');
+        return { status: 'completed' };
+    }),
+});
+exports.evictableChildSpawn = hatchet_client_1.hatchet.durableTask({
+    name: 'evictable-child-spawn',
+    executionTimeout: '5m',
+    evictionPolicy: EVICTION_POLICY,
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const childResult = yield exports.childTask.run({});
+        return { child: childResult, status: 'completed' };
+    }),
+});
+exports.multipleEviction = hatchet_client_1.hatchet.durableTask({
+    name: 'multiple-eviction',
+    executionTimeout: '5m',
+    evictionPolicy: EVICTION_POLICY,
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        yield ctx.sleepFor(`${exports.LONG_SLEEP_SECONDS}s`);
+        yield ctx.sleepFor(`${exports.LONG_SLEEP_SECONDS}s`);
+        return { status: 'completed' };
+    }),
+});
+exports.bulkChildTask = hatchet_client_1.hatchet.task({
+    name: 'eviction-bulk-child-task',
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, sleep_1.default)(input.sleepSeconds * 1000);
+        return { sleepSeconds: input.sleepSeconds, status: 'completed' };
+    }),
+});
+exports.evictableChildBulkSpawn = hatchet_client_1.hatchet.durableTask({
+    name: 'evictable-child-bulk-spawn',
+    executionTimeout: '5m',
+    evictionPolicy: EVICTION_POLICY,
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const inputs = Array.from({ length: 3 }, (_, i) => ({
+            sleepSeconds: (exports.EVICTION_TTL_SECONDS + 5) * (i + 1),
+        }));
+        const childResults = yield exports.bulkChildTask.run(inputs);
+        return { child_results: childResults, status: 'completed' };
+    }),
+});
+exports.CAPACITY_SLEEP_SECONDS = 20;
+exports.capacityEvictableSleep = hatchet_client_1.hatchet.durableTask({
+    name: 'capacity-evictable-sleep',
+    executionTimeout: '5m',
+    evictionPolicy: {
+        ttl: undefined,
+        allowCapacityEviction: true,
+        priority: 0,
+    },
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        yield ctx.sleepFor(`${exports.CAPACITY_SLEEP_SECONDS}s`);
+        return { status: 'completed' };
+    }),
+});
+exports.nonEvictableSleep = hatchet_client_1.hatchet.durableTask({
+    name: 'non-evictable-sleep',
+    executionTimeout: '5m',
+    evictionPolicy: {
+        ttl: undefined,
+        allowCapacityEviction: false,
+        priority: 0,
+    },
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        yield ctx.sleepFor('10s');
+        return { status: 'completed' };
+    }),
+});

package/v1/examples/durable_sleep/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/durable_sleep/run.js

@@ -15,7 +15,6 @@ function main() {
         const timeStart = Date.now();
         const res = yield workflow_1.durableSleep.run({});
         const timeEnd = Date.now();
-        // eslint-disable-next-line no-console
         console.log(`Time taken: ${timeEnd - timeStart}ms`);
     });
 }
@@ -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);
     });