@hatchet-dev/typescript-sdk 1.30.0 → 1.31.0

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

@@ -113,6 +113,21 @@ 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 mapConcurrencyPb(entries: Concurrency[]): {
+    expression: string;
+    maxRuns: number | undefined;
+    limitStrategy: import("../..").ConcurrencyLimitStrategy | undefined;
+    name: string | undefined;
+    isTenantScoped: boolean | undefined;
+    maxRunsExpression: string | undefined;
+}[];
+export declare function taskConcurrencyArr(task: {
+    concurrency?: Concurrency | Concurrency[];
+}, workflow: {
+    taskDefaults?: {
+        concurrency?: Concurrency | Concurrency[];
+    };
+}): Concurrency[];
 export declare function assertValidConcurrencyArr(concurrency: Concurrency[] | undefined): void;
 export declare function mapBatchConfigPb(batch: CreateWorkflowTaskOpts<any, any>['batch']): TaskBatchConfig | undefined;
 export declare function resolveExecutionTimeout(task: {

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

@@ -55,6 +55,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.InternalWorker = void 0;
 exports.mapSlotRequestsPb = mapSlotRequestsPb;
 exports.mapRateLimitPb = mapRateLimitPb;
+exports.mapConcurrencyPb = mapConcurrencyPb;
+exports.taskConcurrencyArr = taskConcurrencyArr;
 exports.assertValidConcurrencyArr = assertValidConcurrencyArr;
 exports.mapBatchConfigPb = mapBatchConfigPb;
 exports.resolveExecutionTimeout = resolveExecutionTimeout;
@@ -307,7 +309,7 @@ class InternalWorker {
                     eventTriggers,
                     cronTriggers,
                     sticky: stickyStrategy,
-                    concurrencyArr,
+                    concurrencyArr: mapConcurrencyPb(concurrencyArr),
                     onFailureTask,
                     defaultPriority: workflow.defaultPriority,
                     inputJsonSchema,
@@ -333,22 +335,13 @@ class InternalWorker {
                             slotRequests: mapSlotRequestsPb(task, durableTaskSet.has(task)),
                             batch: mapBatchConfigPb(batchOf(task)),
                             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]
-                                        : [];
+                                const taskConcurrency = taskConcurrencyArr(task, workflow);
                                 assertValidConcurrencyArr(taskConcurrency);
-                                return taskConcurrency;
+                                return mapConcurrencyPb(taskConcurrency);
                             })(),
                         });
                     }),
-                    concurrency: concurrencySolo,
+                    concurrency: concurrencySolo ? mapConcurrencyPb([concurrencySolo])[0] : undefined,
                     defaultFilters: (_w = (_v = workflow.defaultFilters) === null || _v === void 0 ? void 0 : _v.map((f) => ({
                         scope: f.scope,
                         expression: f.expression,
@@ -383,28 +376,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 +411,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 +456,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 +517,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 +526,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 +545,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 +586,7 @@ class InternalWorker {
                     }
                 }
                 finally {
-                    this.cleanupRun(actionKey);
+                    this.cleanupRun(actionKey, context);
                 }
             }
             catch (e) {
@@ -1104,10 +1109,42 @@ function parseBatchPayload(actionPayload) {
 function batchOf(task) {
     return 'batch' in task ? task.batch : undefined;
 }
+// mapConcurrencyPb maps SDK concurrency entries onto the proto shape; entries keep their
+// declared order, which is the chain order.
+function mapConcurrencyPb(entries) {
+    return entries.map((c) => ({
+        expression: c.expression,
+        // a string maxRuns is a CEL expression; the static field then carries the default
+        // of 1, which only governs slots created before the expression existed
+        maxRuns: typeof c.maxRuns === 'string' ? 1 : c.maxRuns,
+        limitStrategy: c.limitStrategy,
+        name: c.name,
+        isTenantScoped: c.isTenantScoped,
+        maxRunsExpression: typeof c.maxRuns === 'string' ? c.maxRuns : undefined,
+    }));
+}
+function taskConcurrencyArr(task, workflow) {
+    var _a;
+    if (task.concurrency) {
+        return Array.isArray(task.concurrency) ? task.concurrency : [task.concurrency];
+    }
+    if ((_a = workflow.taskDefaults) === null || _a === void 0 ? void 0 : _a.concurrency) {
+        return Array.isArray(workflow.taskDefaults.concurrency)
+            ? workflow.taskDefaults.concurrency
+            : [workflow.taskDefaults.concurrency];
+    }
+    return [];
+}
 function assertValidConcurrencyArr(concurrency) {
     concurrency === null || concurrency === void 0 ? void 0 : concurrency.forEach((c) => {
+        if (typeof c.maxRuns === 'string') {
+            if (!c.maxRuns.trim()) {
+                throw new Error('concurrency.maxRuns expression must be non-empty');
+            }
+            return;
+        }
         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}`);
+            throw new Error(`concurrency.maxRuns must be a positive integer or a CEL expression, got: ${c.maxRuns}`);
         }
     });
 }

package/v1/declaration.d.ts

@@ -228,7 +228,9 @@ export type TaskDefaults = {
      */
     workerLabels?: CreateWorkflowTaskOpts<any, any>['desiredWorkerLabels'];
     /**
-     * (optional) the concurrency options for the task.
+     * (optional) the concurrency options for the task, processed in array order. Entries
+     * may be workflow-scoped strategies or tenant-scoped entries (`isTenantScoped`)
+     * strategies, whose definitions are upserted as part of workflow registration.
      */
     concurrency?: Concurrency | Concurrency[];
 };

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

@@ -0,0 +1,10 @@
+export type WorkflowInput = {
+    account: string;
+    tier: string;
+};
+export type WorkflowOutput = {
+    'dynamic-task': {
+        account: string;
+    };
+};
+export declare const concurrencyDynamicWorkflow: import("../..").WorkflowDeclaration<WorkflowInput, WorkflowOutput, {}>;

package/v1/examples/concurrency_dynamic/workflow.js

@@ -0,0 +1,32 @@
+"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 });
+exports.concurrencyDynamicWorkflow = void 0;
+const v1_1 = require("../..");
+const hatchet_client_1 = require("../hatchet-client");
+// > Dynamic Max Runs
+// maxRuns accepts a number or a CEL expression string. With an expression, each
+// concurrency group's limit is computed from the task's input.
+exports.concurrencyDynamicWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'concurrency-dynamic',
+});
+exports.concurrencyDynamicWorkflow.task({
+    name: 'dynamic-task',
+    concurrency: [
+        {
+            expression: 'input.account',
+            maxRuns: "input.tier == 'premium' ? 10 : 1",
+            limitStrategy: v1_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
+        },
+    ],
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () { return ({ account: input.account }); }),
+});
+// !!

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

@@ -0,0 +1,17 @@
+import { Concurrency } from '../..';
+export declare const SLEEP_TIME_MS = 1500;
+export type WorkflowInput = {
+    group: string;
+    inline?: string;
+};
+export type RunWindow = {
+    startMs: number;
+    endMs: number;
+};
+export type WorkflowOutput = {
+    'shared-task': RunWindow;
+};
+export declare const sharedLimit: Concurrency;
+export declare const concurrencySharedWorkflowA: import("../..").WorkflowDeclaration<WorkflowInput, WorkflowOutput, {}>;
+export declare const concurrencySharedWorkflowB: import("../..").WorkflowDeclaration<WorkflowInput, WorkflowOutput, {}>;
+export declare const concurrencySharedMixedWorkflow: import("../..").WorkflowDeclaration<WorkflowInput, WorkflowOutput, {}>;

package/v1/examples/concurrency_shared/workflow.js

@@ -0,0 +1,70 @@
+"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 });
+exports.concurrencySharedMixedWorkflow = exports.concurrencySharedWorkflowB = exports.concurrencySharedWorkflowA = exports.sharedLimit = exports.SLEEP_TIME_MS = void 0;
+const v1_1 = require("../..");
+const hatchet_client_1 = require("../hatchet-client");
+const sleep = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+exports.SLEEP_TIME_MS = 1500;
+// > Shared Concurrency Strategy
+// A tenant-scoped strategy is shared across workflows: every task declaring the same name
+// consumes the same concurrency limit. The definition rides on workflow registration and
+// re-registering the name updates it in place.
+exports.sharedLimit = {
+    name: 'ts-example-shared-limit',
+    isTenantScoped: true,
+    expression: 'input.group',
+    maxRuns: 1,
+    limitStrategy: v1_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
+};
+const runWindowTask = () => __awaiter(void 0, void 0, void 0, function* () {
+    const startMs = Date.now();
+    yield sleep(exports.SLEEP_TIME_MS);
+    return { startMs, endMs: Date.now() };
+});
+exports.concurrencySharedWorkflowA = hatchet_client_1.hatchet.workflow({
+    name: 'concurrency-shared-a',
+});
+exports.concurrencySharedWorkflowA.task({
+    name: 'shared-task',
+    concurrency: [exports.sharedLimit],
+    fn: runWindowTask,
+});
+exports.concurrencySharedWorkflowB = hatchet_client_1.hatchet.workflow({
+    name: 'concurrency-shared-b',
+});
+exports.concurrencySharedWorkflowB.task({
+    name: 'shared-task',
+    concurrency: [exports.sharedLimit],
+    fn: runWindowTask,
+});
+// !!
+// > Mixed Inline And Shared Concurrency
+// A single task can combine a workflow-scoped inline strategy with a shared strategy;
+// both limits apply at once.
+exports.concurrencySharedMixedWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'concurrency-shared-mixed',
+});
+exports.concurrencySharedMixedWorkflow.task({
+    name: 'shared-task',
+    concurrency: [
+        {
+            expression: 'input.inline',
+            maxRuns: 1,
+            limitStrategy: v1_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
+        },
+        exports.sharedLimit,
+    ],
+    fn: runWindowTask,
+});
+// !!

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