@hatchet-dev/typescript-sdk 1.29.3 → 1.30.1

package/v1/client/worker/context.js

@@ -692,9 +692,27 @@ exports.Context = Context;
  * It extends the Context class and includes additional methods for durable execution like sleepFor and waitFor.
  */
 class DurableContext extends Context {
+    _serializeSendEvent(send) {
+        // Re-check cancellation when the queued send actually executes: once this
+        // invocation is aborted (evicted), a queued send must not reach the
+        // server, where it could race the eviction and append to the event log
+        // out of recorded order. Python gets this for free from task
+        // cancellation killing coroutines queued on the send lock.
+        const runSend = () => {
+            this.throwIfCancelled();
+            return send();
+        };
+        const result = this._sendEventLock.then(runSend, runSend);
+        this._sendEventLock = result.then(() => undefined, () => undefined);
+        return result;
+    }
     constructor(action, v1, worker, durableListener, evictionManager, engineVersion) {
         super(action, v1, worker);
         this._waitKey = 0;
+        // Serializes sendEvent calls from concurrent coroutines in this invocation.
+        // The listener keys pending acks by (task, invocation), so overlapping sends
+        // would overwrite each other's ack and cross-wire branch/node assignments.
+        this._sendEventLock = Promise.resolve();
         this._durableListener = durableListener;
         this._evictionManager = evictionManager;
         this._engineVersion = engineVersion;
@@ -767,14 +785,14 @@ class DurableContext extends Context {
             }
             const rendered = (0, conditions_1.Render)(condition_1.Action.CREATE, conditions);
             const pbConditions = (0, transformer_1.conditionsToPb)(rendered, this.v1.config.namespace);
-            const ack = yield this._durableListener.sendEvent(this.action.taskRunExternalId, this.invocationCount, {
+            const ack = yield this._serializeSendEvent(() => this._durableListener.sendEvent(this.action.taskRunExternalId, this.invocationCount, {
                 kind: 'waitFor',
                 waitForConditions: {
                     sleepConditions: pbConditions.sleepConditions,
                     userEventConditions: pbConditions.userEventConditions,
                 },
                 label,
-            });
+            }));
             const resourceId = rendered
                 .map((c) => c.base.readableDataKey)
                 .filter(Boolean)
@@ -787,9 +805,8 @@ class DurableContext extends Context {
     }
     waitForEvent(key, expression, payloadSchema, scope, lookbackWindow, label) {
         return __awaiter(this, void 0, void 0, function* () {
-            const now = yield this.now();
             const considerEventsSince = lookbackWindow
-                ? new Date(now.getTime() - (0, duration_1.durationToMs)(lookbackWindow)).toISOString()
+                ? new Date((yield this.now()).getTime() - (0, duration_1.durationToMs)(lookbackWindow)).toISOString()
                 : undefined;
             const res = yield this.waitFor({
                 eventKey: key,
@@ -918,10 +935,10 @@ class DurableContext extends Context {
                 const { triggerOpts } = this._buildTriggerOpts(child.workflow, child.input, child.options);
                 return triggerOpts;
             });
-            const ack = yield this._durableListener.sendEvent(this.action.taskRunExternalId, this.invocationCount, {
+            const ack = yield this._serializeSendEvent(() => this._durableListener.sendEvent(this.action.taskRunExternalId, this.invocationCount, {
                 kind: 'runChildren',
                 triggerOpts: triggerOptsList,
-            });
+            }));
             const results = yield Promise.all(ack.runEntries.map((entry) => this.withEvictionWait('runChild', `workflow:bulk-child`, () => __awaiter(this, void 0, void 0, function* () {
                 const result = yield this._durableListener.waitForCallback(this.action.taskRunExternalId, this.invocationCount, entry.branchId, entry.nodeId, { signal: this.abortController.signal });
                 if (result.isFailure) {
@@ -946,10 +963,11 @@ class DurableContext extends Context {
                 return fn();
             }
             const memoKey = computeMemoKey(this.action.taskRunExternalId, deps);
-            const ack = yield this._durableListener.sendEvent(this.action.taskRunExternalId, this.invocationCount, {
+            const ack = yield this._serializeSendEvent(() => this._durableListener.sendEvent(this.action.taskRunExternalId, this.invocationCount, {
                 kind: 'memo',
                 memoKey,
-            });
+            }));
+            this._durableListener.consumeCallbackWithoutBlocking(this.action.taskRunExternalId, this.invocationCount, ack.branchId, ack.nodeId);
             if (ack.memoAlreadyExisted && ack.memoResultPayload && ack.memoResultPayload.length > 0) {
                 const serialized = new TextDecoder().decode(ack.memoResultPayload);
                 return JSON.parse(serialized);

package/v1/client/worker/eviction/eviction-manager.d.ts

@@ -21,7 +21,7 @@ export declare class DurableEvictionManager {
     private _ticking;
     constructor(opts: {
         durableSlots: number;
-        cancelLocal: (key: ActionKey) => void;
+        cancelLocal: (key: ActionKey, invocationCount: number) => void;
         requestEvictionWithAck: (key: ActionKey, rec: DurableRunRecord) => Promise<void>;
         config?: DurableEvictionConfig;
         cache?: DurableEvictionCache;

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.d.ts

@@ -5,7 +5,7 @@ import { CreateStepRateLimit } from '../../../protoc/workflows';
 import { Logger } from '../../../util/logger';
 import { BaseWorkflowDeclaration, WorkflowDefinition, HatchetClient } from '../..';
 import { TaskBatchConfig } from '../../../protoc/v1/workflows';
-import { CreateWorkflowTaskOpts } from '../../task';
+import { Concurrency, CreateWorkflowTaskOpts } from '../../task';
 import { WorkerLabels } from '../../../clients/dispatcher/dispatcher-client';
 import { Duration } from '../duration';
 import { Context } from './context';
@@ -113,6 +113,7 @@ export declare function mapSlotRequestsPb(task: {
     slotCost?: number;
 }, isDurable: boolean): Record<string, number>;
 export declare function mapRateLimitPb(limits: CreateWorkflowTaskOpts<any, any>['rateLimits']): CreateStepRateLimit[];
+export declare function assertValidConcurrencyArr(concurrency: Concurrency[] | undefined): void;
 export declare function mapBatchConfigPb(batch: CreateWorkflowTaskOpts<any, any>['batch']): TaskBatchConfig | undefined;
 export declare function resolveExecutionTimeout(task: {
     executionTimeout?: Duration;

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

@@ -55,6 +55,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.InternalWorker = void 0;
 exports.mapSlotRequestsPb = mapSlotRequestsPb;
 exports.mapRateLimitPb = mapRateLimitPb;
+exports.assertValidConcurrencyArr = assertValidConcurrencyArr;
 exports.mapBatchConfigPb = mapBatchConfigPb;
 exports.resolveExecutionTimeout = resolveExecutionTimeout;
 exports.resolveScheduleTimeout = resolveScheduleTimeout;
@@ -269,6 +270,8 @@ class InternalWorker {
                 ];
                 const concurrencyArr = Array.isArray(concurrency) ? concurrency : [];
                 const concurrencySolo = !Array.isArray(concurrency) ? concurrency : undefined;
+                assertValidConcurrencyArr(concurrencyArr);
+                assertValidConcurrencyArr(concurrencySolo ? [concurrencySolo] : undefined);
                 // Convert Zod schema to JSON Schema if provided
                 let inputJsonSchema;
                 if (workflow.inputValidator) {
@@ -309,7 +312,7 @@ class InternalWorker {
                     defaultPriority: workflow.defaultPriority,
                     inputJsonSchema,
                     tasks: [...workflow._tasks, ...workflow._durableTasks].map((task) => {
-                        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+                        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
                         return ({
                             readableId: task.name,
                             action: `${workflow.name}:${task.name}`,
@@ -329,15 +332,20 @@ class InternalWorker {
                             isDurable: durableTaskSet.has(task),
                             slotRequests: mapSlotRequestsPb(task, durableTaskSet.has(task)),
                             batch: mapBatchConfigPb(batchOf(task)),
-                            concurrency: task.concurrency
-                                ? Array.isArray(task.concurrency)
-                                    ? task.concurrency
-                                    : [task.concurrency]
-                                : ((_m = workflow.taskDefaults) === null || _m === void 0 ? void 0 : _m.concurrency)
-                                    ? Array.isArray(workflow.taskDefaults.concurrency)
-                                        ? workflow.taskDefaults.concurrency
-                                        : [workflow.taskDefaults.concurrency]
-                                    : [],
+                            concurrency: (() => {
+                                var _a;
+                                const taskConcurrency = task.concurrency
+                                    ? Array.isArray(task.concurrency)
+                                        ? task.concurrency
+                                        : [task.concurrency]
+                                    : ((_a = workflow.taskDefaults) === null || _a === void 0 ? void 0 : _a.concurrency)
+                                        ? Array.isArray(workflow.taskDefaults.concurrency)
+                                            ? workflow.taskDefaults.concurrency
+                                            : [workflow.taskDefaults.concurrency]
+                                        : [];
+                                assertValidConcurrencyArr(taskConcurrency);
+                                return taskConcurrency;
+                            })(),
                         });
                     }),
                     concurrency: concurrencySolo,
@@ -375,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,
         });
@@ -407,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];
@@ -448,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* () {
@@ -509,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* () {
@@ -518,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);
@@ -532,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* () {
@@ -573,7 +593,7 @@ class InternalWorker {
                     }
                 }
                 finally {
-                    this.cleanupRun(actionKey);
+                    this.cleanupRun(actionKey, context);
                 }
             }
             catch (e) {
@@ -1096,6 +1116,13 @@ function parseBatchPayload(actionPayload) {
 function batchOf(task) {
     return 'batch' in task ? task.batch : undefined;
 }
+function assertValidConcurrencyArr(concurrency) {
+    concurrency === null || concurrency === void 0 ? void 0 : concurrency.forEach((c) => {
+        if (c.maxRuns !== undefined && (!Number.isInteger(c.maxRuns) || c.maxRuns <= 0)) {
+            throw new Error(`concurrency.maxRuns must be a positive integer when provided, got: ${c.maxRuns}`);
+        }
+    });
+}
 function mapBatchConfigPb(batch) {
     if (!batch) {
         return undefined;

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/concurrency_cancel_queued_except_newest/workflow.d.ts

@@ -0,0 +1,9 @@
+import type { EmptyTaskOutput } from '../concurrency-types';
+export type WorkflowInput = {
+    group: string;
+};
+export type WorkflowOutput = {
+    step1: EmptyTaskOutput;
+    step2: EmptyTaskOutput;
+};
+export declare const concurrencyCancelQueuedExceptNewestWorkflow: import("../..").WorkflowDeclaration<WorkflowInput, WorkflowOutput, {}>;

package/v1/examples/concurrency_cancel_queued_except_newest/workflow.js

@@ -0,0 +1,47 @@
+"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.concurrencyCancelQueuedExceptNewestWorkflow = void 0;
+const sleep_1 = __importDefault(require("../../../util/sleep"));
+const v1_1 = require("../..");
+const hatchet_client_1 = require("../hatchet-client");
+// > Cancel Queued Except Newest
+exports.concurrencyCancelQueuedExceptNewestWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'concurrencycancelqueuedexceptnewest',
+    concurrency: {
+        expression: 'input.group',
+        maxRuns: 1,
+        limitStrategy: v1_1.ConcurrencyLimitStrategy.CANCEL_QUEUED_EXCEPT_NEWEST,
+    },
+});
+// !!
+const step1 = exports.concurrencyCancelQueuedExceptNewestWorkflow.task({
+    name: 'step1',
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        for (let i = 0; i < 50; i += 1) {
+            yield (0, sleep_1.default)(20, ctx.abortController.signal);
+        }
+        return {};
+    }),
+});
+exports.concurrencyCancelQueuedExceptNewestWorkflow.task({
+    name: 'step2',
+    parents: [step1],
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        for (let i = 0; i < 50; i += 1) {
+            yield (0, sleep_1.default)(20, ctx.abortController.signal);
+        }
+        return {};
+    }),
+});

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

@@ -0,0 +1,9 @@
+import type { EmptyTaskOutput } from '../concurrency-types';
+export type WorkflowInput = {
+    group: string;
+};
+export type WorkflowOutput = {
+    step1: EmptyTaskOutput;
+    step2: EmptyTaskOutput;
+};
+export declare const concurrencyCancelQueuedExceptOldestWorkflow: import("../..").WorkflowDeclaration<WorkflowInput, WorkflowOutput, {}>;

package/v1/examples/concurrency_cancel_queued_except_oldest/workflow.js

@@ -0,0 +1,47 @@
+"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.concurrencyCancelQueuedExceptOldestWorkflow = void 0;
+const sleep_1 = __importDefault(require("../../../util/sleep"));
+const v1_1 = require("../..");
+const hatchet_client_1 = require("../hatchet-client");
+// > Cancel Queued Except Oldest
+exports.concurrencyCancelQueuedExceptOldestWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'concurrencycancelqueuedexceptoldest',
+    concurrency: {
+        expression: 'input.group',
+        maxRuns: 1,
+        limitStrategy: v1_1.ConcurrencyLimitStrategy.CANCEL_QUEUED_EXCEPT_OLDEST,
+    },
+});
+// !!
+const step1 = exports.concurrencyCancelQueuedExceptOldestWorkflow.task({
+    name: 'step1',
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        for (let i = 0; i < 50; i += 1) {
+            yield (0, sleep_1.default)(20, ctx.abortController.signal);
+        }
+        return {};
+    }),
+});
+exports.concurrencyCancelQueuedExceptOldestWorkflow.task({
+    name: 'step2',
+    parents: [step1],
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        for (let i = 0; i < 50; i += 1) {
+            yield (0, sleep_1.default)(20, ctx.abortController.signal);
+        }
+        return {};
+    }),
+});

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