@hatchet-dev/typescript-sdk 1.30.0 → 1.30.1

package/v1/client/worker/eviction/eviction-manager.js

@@ -53,8 +53,15 @@ class DurableEvictionManager {
     markActive(key) {
         this._cache.markActive(key);
     }
-    _evictRun(key) {
-        this._cancelLocal(key);
+    // The invocation count pins the teardown to the invocation that was
+    // actually evicted: between requesting eviction and the server's ack, the
+    // server may restore and re-dispatch the next invocation, which registers
+    // under the same action key and must not be torn down.
+    _evictRun(key, invocationCount) {
+        const current = this._cache.get(key);
+        if (current && current.invocationCount !== invocationCount)
+            return;
+        this._cancelLocal(key, invocationCount);
         this.unregisterRun(key);
     }
     _tickSafe() {
@@ -89,7 +96,7 @@ class DurableEvictionManager {
                 this._logger.debug(`DurableEvictionManager: evicting task_run_external_id=${rec.taskRunExternalId} ` +
                     `wait_kind=${rec.waitKind} resource_id=${rec.waitResourceId}`);
                 yield this._requestEvictionWithAck(key, rec);
-                this._evictRun(key);
+                this._evictRun(key, rec.invocationCount);
             }
         });
     }
@@ -101,7 +108,7 @@ class DurableEvictionManager {
         if (rec && rec.invocationCount !== invocationCount)
             return;
         this._logger.info(`DurableEvictionManager: server-initiated eviction for task_run_external_id=${taskRunExternalId} invocation_count=${invocationCount}`);
-        this._evictRun(key);
+        this._evictRun(key, invocationCount);
     }
     evictAllWaiting() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -122,7 +129,7 @@ class DurableEvictionManager {
                 // Always cancel locally even if the server ACK failed, so the
                 // future settles and exitGracefully doesn't hang.
                 // This will get resolved by the reassignment of the task.
-                this._evictRun(rec.key);
+                this._evictRun(rec.key, rec.invocationCount);
                 evicted++;
             }
             return evicted;

package/v1/client/worker/worker-internal.js

@@ -383,28 +383,31 @@ class InternalWorker {
         const totalDurableSlots = (_c = (_b = (_a = this.slotConfig) === null || _a === void 0 ? void 0 : _a.durable) !== null && _b !== void 0 ? _b : this.durableSlots) !== null && _c !== void 0 ? _c : 0;
         this.evictionManager = new eviction_manager_1.DurableEvictionManager({
             durableSlots: totalDurableSlots,
-            cancelLocal: (key) => {
+            cancelLocal: (key, invocationCount) => {
                 var _a;
                 const err = new task_run_terminated_error_1.TaskRunTerminatedError('evicted');
                 const ctx = this.contexts[key];
+                // A newer invocation may already be registered under this key (the
+                // server restored the run before the eviction ack arrived); it must
+                // not be aborted for the old invocation's eviction.
+                const ctxMatchesEvictedInvocation = ctx && ((_a = ctx.invocationCount) !== null && _a !== void 0 ? _a : 1) === invocationCount;
                 if (ctx) {
-                    const invocationCount = (_a = ctx.invocationCount) !== null && _a !== void 0 ? _a : 1;
-                    this.client.durableListener.cleanupTaskState(ctx.action.taskRunExternalId, invocationCount);
-                    if (ctx.abortController) {
+                    // Abort before cleanup: waiters must settle as aborted (eviction),
+                    // not with cleanup's generic rejection, which would surface as a
+                    // task failure.
+                    if (ctxMatchesEvictedInvocation && ctx.abortController) {
                         ctx.abortController.abort(err);
                     }
+                    this.client.durableListener.cleanupTaskState(ctx.action.taskRunExternalId, invocationCount);
                 }
                 const future = this.futures[key];
-                if (future) {
+                if (future && ctxMatchesEvictedInvocation) {
                     future.promise.catch(() => undefined);
                     future.cancel(hatchet_promise_1.CancellationReason.EVICTED_BY_WORKER);
                 }
             },
             requestEvictionWithAck: (key, rec) => __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                const ctx = this.contexts[key];
-                const invocationCount = (_a = ctx === null || ctx === void 0 ? void 0 : ctx.invocationCount) !== null && _a !== void 0 ? _a : 1;
-                yield this.client.durableListener.sendEvictInvocation(rec.taskRunExternalId, invocationCount, rec.evictionReason);
+                yield this.client.durableListener.sendEvictInvocation(rec.taskRunExternalId, rec.invocationCount, rec.evictionReason);
             }),
             logger: this.logger,
         });
@@ -415,12 +418,16 @@ class InternalWorker {
         this.evictionManager.start();
         return this.evictionManager;
     }
-    cleanupRun(key) {
+    cleanupRun(key, attemptContext) {
         var _a;
-        const ctx = this.contexts[key];
+        const ctx = attemptContext !== null && attemptContext !== void 0 ? attemptContext : this.contexts[key];
         if (ctx instanceof context_1.DurableContext) {
             this.client.durableListener.cleanupTaskState(ctx.action.taskRunExternalId, ctx.invocationCount);
         }
+        // A restored invocation may have re-registered under this key while this
+        // attempt was shutting down; the key-owned state now belongs to it.
+        if (attemptContext && this.contexts[key] !== attemptContext)
+            return;
         (_a = this.evictionManager) === null || _a === void 0 ? void 0 : _a.unregisterRun(key);
         delete this.futures[key];
         delete this.contexts[key];
@@ -456,7 +463,7 @@ class InternalWorker {
                 if (!step) {
                     this.logger.error(`Registered actions: '${Object.keys(this.action_registry).join(', ')}'`);
                     this.logger.error(`Could not find step '${actionId}'`);
-                    this.cleanupRun(actionKey);
+                    this.cleanupRun(actionKey, context);
                     return;
                 }
                 const run = () => __awaiter(this, void 0, void 0, function* () {
@@ -517,7 +524,7 @@ class InternalWorker {
                         this.logger.error(`Could not send action event: ${actionEventError.message || actionEventError}`);
                     }
                     finally {
-                        this.cleanupRun(actionKey);
+                        this.cleanupRun(actionKey, context);
                     }
                 });
                 const failure = (error) => __awaiter(this, void 0, void 0, function* () {
@@ -526,6 +533,11 @@ class InternalWorker {
                         if (context.cancelled) {
                             return;
                         }
+                        // The run was evicted or cancelled by the worker, not failed by
+                        // user code; the server already accounts for it.
+                        if ((0, task_run_terminated_error_1.isTaskRunTerminatedError)(error)) {
+                            return;
+                        }
                         this.logger.error((0, logger_1.taskRunLog)(taskName, taskRunExternalId, `failed: ${error.message}`));
                         if (error.stack) {
                             this.logger.error(error.stack);
@@ -540,7 +552,7 @@ class InternalWorker {
                         this.logger.error(`Could not send action event: ${e.message}`);
                     }
                     finally {
-                        this.cleanupRun(actionKey);
+                        this.cleanupRun(actionKey, context);
                     }
                 });
                 const future = new hatchet_promise_1.default((() => __awaiter(this, void 0, void 0, function* () {
@@ -581,7 +593,7 @@ class InternalWorker {
                     }
                 }
                 finally {
-                    this.cleanupRun(actionKey);
+                    this.cleanupRun(actionKey, context);
                 }
             }
             catch (e) {

package/v1/embedded.d.ts

@@ -1,6 +1,10 @@
 import type { AxiosRequestConfig } from 'axios';
 import type { ClientConfig, HatchetClientOptions } from '../clients/hatchet-client';
 import { HatchetClient } from './client/client';
+/**
+ * Options for the embedded engine sidecar. All fields are optional; by default the
+ * latest hatchet-embedded release is downloaded and started with a bundled Postgres.
+ */
 export interface EmbeddedOptions {
     /**
      * hatchet-embedded release tag to download (defaults to HATCHET_CLIENT_EMBEDDED_VERSION or
@@ -20,7 +24,9 @@ export interface EmbeddedOptions {
     databaseUrl?: string;
     /** store the bundled Postgres runtime and data under this directory */
     postgresDataDir?: string;
+    /** bind the engine's gRPC server to this port */
     grpcPort?: number;
+    /** bind the REST API server to this port */
     apiPort?: number;
     /** set to false to start only the engine + gRPC, no REST API */
     startApi?: boolean;
@@ -28,14 +34,25 @@ export interface EmbeddedOptions {
     runMigrations?: boolean;
     /** use RabbitMQ instead of the Postgres message queue */
     rabbitmqUrl?: string;
+    /** log level for the engine's output */
     logLevel?: string;
+    /** how long to wait for the engine to become ready, in milliseconds (default 300000) */
     readyTimeoutMs?: number;
 }
+/**
+ * A running embedded engine sidecar and its connection details, as returned by
+ * `startEmbeddedSidecar`.
+ */
 export interface EmbeddedSidecar {
+    /** API token for the sidecar's default tenant */
     token: string;
+    /** ID of the sidecar's default tenant */
     tenantId: string;
+    /** host:port of the engine's gRPC server */
     grpcAddress: string;
+    /** base URL of the REST API (empty when `startApi` is false) */
     apiUrl: string;
+    /** gracefully stops the sidecar and resolves once it has fully exited */
     stop: () => Promise<void>;
 }
 /**
@@ -46,12 +63,25 @@ export interface EmbeddedSidecar {
  * your program has returned.
  */
 export declare function stopEmbeddedSidecar(): Promise<void>;
+/**
+ * Downloads (and caches) the hatchet-embedded sidecar binary, spawns it, and waits
+ * until the embedded engine is ready. The sidecar shuts down when this process exits.
+ * Use {@link HatchetEmbeddedClient.init} unless you need the raw connection details.
+ */
 export declare function startEmbeddedSidecar(opts?: EmbeddedOptions): Promise<EmbeddedSidecar>;
+/**
+ * Entry point for embedded mode. `init()` starts a full local Hatchet engine and
+ * returns a regular Hatchet client connected to it. No API token or Docker is needed.
+ * See the [embedded mode guide](https://docs.hatchet.run/v1/embedded).
+ */
 export declare class HatchetEmbeddedClient {
     /**
      * Runs a full Hatchet engine locally via the hatchet-embedded sidecar (downloaded
-     * on first use) and returns a client wired to it. By default the sidecar starts a
-     * bundled Postgres; pass `databaseUrl` to point it at your own instead.
+     * on first use) and returns a client wired to it. No API token or Docker is needed,
+     * which makes this a good fit for local development and CI. By default the sidecar
+     * starts a bundled Postgres; pass `databaseUrl` to point it at your own instead.
+     *
+     * See the [embedded mode guide](https://docs.hatchet.run/v1/embedded).
      * @param embeddedOpts - Options for the embedded engine (version, ports, database, ...).
      * @param config - Optional configuration overrides for the client.
      * @param options - Optional client options.
@@ -60,6 +90,10 @@ export declare class HatchetEmbeddedClient {
      */
     static init<T extends Record<string, any> = {}, U extends Record<string, any> = {}>(embeddedOpts?: EmbeddedOptions, config?: Omit<Partial<ClientConfig>, 'middleware'>, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig): Promise<EmbeddedClient<T, U>>;
 }
+/**
+ * A `HatchetClient` connected to an embedded engine, extended with `stopEmbedded`.
+ * Returned by {@link HatchetEmbeddedClient.init}.
+ */
 export type EmbeddedClient<T extends Record<string, any> = {}, U extends Record<string, any> = {}> = HatchetClient<T, U> & {
     /**
      * Gracefully stops the embedded engine sidecar and resolves once it has

package/v1/embedded.js

@@ -52,6 +52,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HatchetEmbeddedClient = void 0;
 exports.stopEmbeddedSidecar = stopEmbeddedSidecar;
 exports.startEmbeddedSidecar = startEmbeddedSidecar;
+/**
+ * Embedded mode runs a full local Hatchet engine as a sidecar process managed by your
+ * application. It needs no API token, no Docker, and no external services (by default
+ * the sidecar starts a bundled Postgres), which makes it a good fit for local
+ * development and CI.
+ *
+ * ```typescript
+ * import { HatchetEmbeddedClient } from './embedded.js';
+ *
+ * const hatchet = await HatchetEmbeddedClient.init();
+ * // ... register workers and run tasks as usual ...
+ * await hatchet.stopEmbedded();
+ * ```
+ *
+ * See the [embedded mode guide](https://docs.hatchet.run/v1/embedded) for setup and
+ * configuration details.
+ *
+ * @module Embedded
+ */
 const child_process_1 = require("child_process");
 const client_1 = require("./client/client");
 const crypto_1 = require("crypto");
@@ -211,12 +230,7 @@ function waitForHandshake(child, handshakePath, timeoutMs) {
         throw new Error(`hatchet embedded sidecar did not become ready within ${timeoutMs}ms`);
     });
 }
-/**
- * Downloads (and caches) the hatchet-embedded sidecar binary, spawns it, and
- * waits until the embedded engine is ready. The sidecar shuts down when this
- * process exits. Use `HatchetEmbedded()` unless you need the raw
- * connection details.
- */
+// sidecars started in this process that have not been stopped yet
 const activeSidecars = new Set();
 /**
  * Gracefully stops every sidecar started in this process by
@@ -232,6 +246,11 @@ function stopEmbeddedSidecar() {
         }
     });
 }
+/**
+ * Downloads (and caches) the hatchet-embedded sidecar binary, spawns it, and waits
+ * until the embedded engine is ready. The sidecar shuts down when this process exits.
+ * Use {@link HatchetEmbeddedClient.init} unless you need the raw connection details.
+ */
 function startEmbeddedSidecar() {
     return __awaiter(this, arguments, void 0, function* (opts = {}) {
         var _a, _b;
@@ -321,11 +340,19 @@ function startEmbeddedSidecar() {
         return sidecar;
     });
 }
+/**
+ * Entry point for embedded mode. `init()` starts a full local Hatchet engine and
+ * returns a regular Hatchet client connected to it. No API token or Docker is needed.
+ * See the [embedded mode guide](https://docs.hatchet.run/v1/embedded).
+ */
 class HatchetEmbeddedClient {
     /**
      * Runs a full Hatchet engine locally via the hatchet-embedded sidecar (downloaded
-     * on first use) and returns a client wired to it. By default the sidecar starts a
-     * bundled Postgres; pass `databaseUrl` to point it at your own instead.
+     * on first use) and returns a client wired to it. No API token or Docker is needed,
+     * which makes this a good fit for local development and CI. By default the sidecar
+     * starts a bundled Postgres; pass `databaseUrl` to point it at your own instead.
+     *
+     * See the [embedded mode guide](https://docs.hatchet.run/v1/embedded).
      * @param embeddedOpts - Options for the embedded engine (version, ports, database, ...).
      * @param config - Optional configuration overrides for the client.
      * @param options - Optional client options.

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

@@ -0,0 +1,42 @@
+export type LeafInput = {
+    mid: number;
+    branch: number;
+    delayMs: number;
+    generation: number;
+};
+export type LeafOutput = {
+    mid: number;
+    branch: number;
+    generation: number;
+};
+export type MidInput = {
+    mid: number;
+    branches: number;
+    childDelayMs: number;
+    delayStepMs: number;
+};
+export type MidOutput = {
+    mid: number;
+    completedBranches: number[];
+    invocationCount: number;
+};
+export type RootInput = {
+    durables?: number;
+    branches?: number;
+    childDelayMs?: number;
+    delayStepMs?: number;
+};
+export type RootOutput = {
+    rootInvocationCount: number;
+    midInvocationCounts: number[];
+    completedMids: number[];
+};
+export declare const ROOT_DEFAULTS: {
+    durables: number;
+    branches: number;
+    childDelayMs: number;
+    delayStepMs: number;
+};
+export declare const callbackOrderingLeaf: import("../..").TaskWorkflowDeclaration<LeafInput, LeafOutput, {}, {}, {}, {}>;
+export declare const callbackOrderingMid: import("../..").TaskWorkflowDeclaration<MidInput, MidOutput, {}, {}, {}, {}>;
+export declare const callbackOrderingRoot: import("../..").TaskWorkflowDeclaration<RootInput, RootOutput, {}, {}, {}, {}>;

package/v1/examples/durable_callback_ordering/workflow.js

@@ -0,0 +1,95 @@
+"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.callbackOrderingRoot = exports.callbackOrderingMid = exports.callbackOrderingLeaf = exports.ROOT_DEFAULTS = void 0;
+const sleep_1 = __importDefault(require("../../../util/sleep"));
+const hatchet_client_1 = require("../hatchet-client");
+const WORKFLOW_PREFIX = 'durable-callback-ordering';
+const EVICTION_POLICY = {
+    ttl: 250,
+    allowCapacityEviction: true,
+    priority: 0,
+};
+exports.ROOT_DEFAULTS = {
+    durables: 4,
+    branches: 8,
+    childDelayMs: 1500,
+    delayStepMs: 3,
+};
+exports.callbackOrderingLeaf = hatchet_client_1.hatchet.task({
+    name: `${WORKFLOW_PREFIX}-leaf`,
+    executionTimeout: '1m',
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, sleep_1.default)(input.delayMs);
+        return { mid: input.mid, branch: input.branch, generation: input.generation };
+    }),
+});
+exports.callbackOrderingMid = hatchet_client_1.hatchet.durableTask({
+    name: `${WORKFLOW_PREFIX}-mid`,
+    executionTimeout: '5m',
+    retries: 0,
+    evictionPolicy: EVICTION_POLICY,
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        // Staggered first-generation children complete out of spawn order, so each
+        // branch's second-generation spawn is emitted in completion order. Replays
+        // after eviction must re-deliver those completions in the recorded order or
+        // the re-emitted spawn sequence diverges from the event log.
+        const branch = (branchIndex) => __awaiter(void 0, void 0, void 0, function* () {
+            const firstDelayMs = input.childDelayMs + (input.branches - branchIndex - 1) * input.delayStepMs;
+            const first = yield exports.callbackOrderingLeaf.run({
+                mid: input.mid,
+                branch: branchIndex,
+                delayMs: firstDelayMs,
+                generation: 1,
+            });
+            const second = yield exports.callbackOrderingLeaf.run({
+                mid: input.mid,
+                branch: first.branch,
+                delayMs: input.childDelayMs,
+                generation: 2,
+            });
+            return second.branch;
+        });
+        const completed = yield Promise.all(Array.from({ length: input.branches }, (_, branchIndex) => branch(branchIndex)));
+        return {
+            mid: input.mid,
+            completedBranches: completed,
+            invocationCount: ctx.invocationCount,
+        };
+    }),
+});
+exports.callbackOrderingRoot = hatchet_client_1.hatchet.durableTask({
+    name: `${WORKFLOW_PREFIX}-root`,
+    executionTimeout: '10m',
+    retries: 0,
+    evictionPolicy: EVICTION_POLICY,
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const durables = (_a = input.durables) !== null && _a !== void 0 ? _a : exports.ROOT_DEFAULTS.durables;
+        const results = yield Promise.all(Array.from({ length: durables }, (_, midIndex) => {
+            var _a, _b, _c;
+            return exports.callbackOrderingMid.run({
+                mid: midIndex,
+                branches: (_a = input.branches) !== null && _a !== void 0 ? _a : exports.ROOT_DEFAULTS.branches,
+                childDelayMs: (_b = input.childDelayMs) !== null && _b !== void 0 ? _b : exports.ROOT_DEFAULTS.childDelayMs,
+                delayStepMs: (_c = input.delayStepMs) !== null && _c !== void 0 ? _c : exports.ROOT_DEFAULTS.delayStepMs,
+            });
+        }));
+        return {
+            rootInvocationCount: ctx.invocationCount,
+            midInvocationCounts: results.map((item) => item.invocationCount),
+            completedMids: results.map((item) => item.mid),
+        };
+    }),
+});

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

@@ -13,6 +13,11 @@ export declare const evictableSleepForGracefulTermination: import("../..").TaskW
 export declare const evictableWaitForEvent: import("../..").TaskWorkflowDeclaration<import("../..").JsonObject, {
     status: string;
 }, {}, {}, {}, {}>;
+export declare const MEMO_EVENT_KEY = "durable-eviction:memo-event";
+export declare const evictableMemoThenWaitForEvent: import("../..").TaskWorkflowDeclaration<import("../..").JsonObject, {
+    status: string;
+    memoizedNow: string;
+}, {}, {}, {}, {}>;
 export declare const evictableChildSpawn: import("../..").TaskWorkflowDeclaration<import("../..").JsonObject, {
     child: {
         child_status: string;

package/v1/examples/durable_eviction/workflow.js

@@ -12,7 +12,7 @@ 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;
+exports.nonEvictableSleep = exports.capacityEvictableSleep = exports.CAPACITY_SLEEP_SECONDS = exports.evictableChildBulkSpawn = exports.bulkChildTask = exports.multipleEviction = exports.evictableChildSpawn = exports.evictableMemoThenWaitForEvent = exports.MEMO_EVENT_KEY = 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;
@@ -66,6 +66,20 @@ exports.evictableWaitForEvent = hatchet_client_1.hatchet.durableTask({
         return { status: 'completed' };
     }),
 });
+exports.MEMO_EVENT_KEY = 'durable-eviction:memo-event';
+exports.evictableMemoThenWaitForEvent = hatchet_client_1.hatchet.durableTask({
+    name: 'evictable-memo-then-wait-for-event',
+    executionTimeout: '5m',
+    evictionPolicy: EVICTION_POLICY,
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        // now() records a memo node. On replay after eviction, the server
+        // re-delivers that node's completion, which never has a callback waiter
+        // and must not block the event completion queued behind it.
+        const memoizedNow = yield ctx.now();
+        yield ctx.waitForEvent(exports.MEMO_EVENT_KEY, 'true');
+        return { status: 'completed', memoizedNow: memoizedNow.toISOString() };
+    }),
+});
 exports.evictableChildSpawn = hatchet_client_1.hatchet.durableTask({
     name: 'evictable-child-spawn',
     executionTimeout: '5m',

package/v1/examples/e2e-worker.js

@@ -30,24 +30,25 @@ const workflow_9 = require("./dag/workflow");
 const workflow_10 = require("./durable/workflow");
 const workflow_11 = require("./durable_event/workflow");
 const workflow_12 = require("./durable_eviction/workflow");
-const workflow_13 = require("./durable_sleep/workflow");
-const workflow_14 = require("./logger/workflow");
-const workflow_15 = require("./non_retryable/workflow");
-const workflow_16 = require("./on_failure/workflow");
-const workflow_17 = require("./idempotency/workflow");
-const workflow_18 = require("./on_event/workflow");
-const workflow_19 = require("./return_exceptions/workflow");
-const workflow_20 = require("./run_details/workflow");
+const workflow_13 = require("./durable_callback_ordering/workflow");
+const workflow_14 = require("./durable_sleep/workflow");
+const workflow_15 = require("./logger/workflow");
+const workflow_16 = require("./non_retryable/workflow");
+const workflow_17 = require("./on_failure/workflow");
+const workflow_18 = require("./idempotency/workflow");
+const workflow_19 = require("./on_event/workflow");
+const workflow_20 = require("./return_exceptions/workflow");
+const workflow_21 = require("./run_details/workflow");
 const e2e_workflows_1 = require("./simple/e2e-workflows");
-const workflow_21 = require("./batch_assign/workflow");
-const workflow_22 = require("./streaming/workflow");
-const workflow_23 = require("./subscribe_to_stream/workflow");
-const workflow_24 = require("./timeout/workflow");
-const workflow_25 = require("./webhooks/workflow");
-const workflow_26 = require("./child_index/workflow");
-const workflow_27 = require("./support_agent/workflow");
-const workflow_28 = require("./welcome_email/workflow");
-const workflow_29 = require("./pdf_pipeline/workflow");
+const workflow_22 = require("./batch_assign/workflow");
+const workflow_23 = require("./streaming/workflow");
+const workflow_24 = require("./subscribe_to_stream/workflow");
+const workflow_25 = require("./timeout/workflow");
+const workflow_26 = require("./webhooks/workflow");
+const workflow_27 = require("./child_index/workflow");
+const workflow_28 = require("./support_agent/workflow");
+const workflow_29 = require("./welcome_email/workflow");
+const workflow_30 = require("./pdf_pipeline/workflow");
 const workflows = [
     workflow_1.bulkChild,
     workflow_1.bulkParentWorkflow,
@@ -81,54 +82,58 @@ const workflows = [
     workflow_10.errorRaisingDurableParent,
     workflow_11.durableEvent,
     workflow_11.durableEventWithFilter,
-    workflow_13.durableSleep,
+    workflow_13.callbackOrderingLeaf,
+    workflow_13.callbackOrderingMid,
+    workflow_13.callbackOrderingRoot,
+    workflow_14.durableSleep,
     workflow_12.evictableSleep,
     workflow_12.evictableWaitForEvent,
+    workflow_12.evictableMemoThenWaitForEvent,
     workflow_12.evictableChildSpawn,
     workflow_12.multipleEviction,
     workflow_12.nonEvictableSleep,
     workflow_12.childTask,
     workflow_12.bulkChildTask,
     workflow_12.evictableChildBulkSpawn,
-    (0, workflow_14.createLoggingWorkflow)(hatchet_client_1.hatchet),
-    workflow_15.nonRetryableWorkflow,
-    workflow_16.failureWorkflow,
-    workflow_17.idempotentTask,
-    workflow_17.idempotentTaskShortWindow,
-    workflow_18.lower,
-    workflow_19.returnExceptionsTask,
-    workflow_20.runDetailTestWorkflow,
+    (0, workflow_15.createLoggingWorkflow)(hatchet_client_1.hatchet),
+    workflow_16.nonRetryableWorkflow,
+    workflow_17.failureWorkflow,
+    workflow_18.idempotentTask,
+    workflow_18.idempotentTaskShortWindow,
+    workflow_19.lower,
+    workflow_20.returnExceptionsTask,
+    workflow_21.runDetailTestWorkflow,
     e2e_workflows_1.helloWorld,
     e2e_workflows_1.helloWorldDurable,
-    workflow_22.streamingTask,
-    workflow_23.dagStream,
-    workflow_23.longStream,
-    workflow_24.timeoutTask,
-    workflow_24.refreshTimeoutTask,
-    workflow_25.webhookWorkflow,
-    workflow_26.childIndexChild,
-    workflow_26.childIndexParent,
-    workflow_26.scenarioTask,
-    workflow_26.orchestratorTask,
-    workflow_27.supportAgent,
-    workflow_27.triageTicket,
-    workflow_27.generateReply,
-    workflow_27.escalateTicket,
-    workflow_28.welcomeEmail,
-    workflow_29.pdfPipeline,
-    workflow_21.batchSimple,
-    workflow_21.batchKeyed,
-    workflow_21.batchKeyedFailable,
-    workflow_21.batchKeyedInterval,
-    workflow_21.batchLarge,
-    workflow_21.batchSingle,
-    workflow_21.batchOrdered,
-    workflow_21.batchBroadcast,
-    workflow_21.batchCancel,
-    workflow_21.child,
-    workflow_21.childBatch,
-    workflow_21.batchChildSpawn,
-    workflow_21.batchChildBatchSpawn,
+    workflow_23.streamingTask,
+    workflow_24.dagStream,
+    workflow_24.longStream,
+    workflow_25.timeoutTask,
+    workflow_25.refreshTimeoutTask,
+    workflow_26.webhookWorkflow,
+    workflow_27.childIndexChild,
+    workflow_27.childIndexParent,
+    workflow_27.scenarioTask,
+    workflow_27.orchestratorTask,
+    workflow_28.supportAgent,
+    workflow_28.triageTicket,
+    workflow_28.generateReply,
+    workflow_28.escalateTicket,
+    workflow_29.welcomeEmail,
+    workflow_30.pdfPipeline,
+    workflow_22.batchSimple,
+    workflow_22.batchKeyed,
+    workflow_22.batchKeyedFailable,
+    workflow_22.batchKeyedInterval,
+    workflow_22.batchLarge,
+    workflow_22.batchSingle,
+    workflow_22.batchOrdered,
+    workflow_22.batchBroadcast,
+    workflow_22.batchCancel,
+    workflow_22.child,
+    workflow_22.childBatch,
+    workflow_22.batchChildSpawn,
+    workflow_22.batchChildBatchSpawn,
 ];
 function main() {
     return __awaiter(this, void 0, void 0, function* () {

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.30.0";
+export declare const HATCHET_VERSION = "1.30.1";

package/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HATCHET_VERSION = void 0;
-exports.HATCHET_VERSION = '1.30.0';
+exports.HATCHET_VERSION = '1.30.1';