@hatchet-dev/typescript-sdk 1.28.2 → 1.29.0

package/clients/rest/generated/Api.d.ts

@@ -1,4 +1,4 @@
-import { APIErrors, APIMeta, AcceptInviteRequest, BulkCreateEventRequest, CancelEventRequest, CreateAPITokenRequest, CreateAPITokenResponse, CreateCronWorkflowTriggerRequest, CreateEventRequest, CreateSNSIntegrationRequest, CreateTenantAlertEmailGroupRequest, CreateTenantInviteRequest, CreateTenantRequest, CronWorkflows, CronWorkflowsList, CronWorkflowsOrderByField, Event, EventData, EventKey, EventKeyList, EventList, EventOrderByDirection, EventOrderByField, EventSearch, Events, FeatureFlagEvaluationResult, FeatureFlagId, ListAPIMetaIntegration, ListAPITokensResponse, ListSNSIntegrations, ListSlackWebhooks, OtelSpanList, RateLimitList, RateLimitOrderByDirection, RateLimitOrderByField, RejectInviteRequest, ReplayEventRequest, ReplayWorkflowRunsRequest, ReplayWorkflowRunsResponse, RerunStepRunRequest, SNSIntegration, ScheduleWorkflowRunRequest, ScheduledRunStatus, ScheduledWorkflows, ScheduledWorkflowsBulkDeleteRequest, ScheduledWorkflowsBulkDeleteResponse, ScheduledWorkflowsBulkUpdateRequest, ScheduledWorkflowsBulkUpdateResponse, ScheduledWorkflowsList, ScheduledWorkflowsOrderByField, StepRun, StepRunArchiveList, StepRunEventList, TaskStats, Tenant, TenantAlertEmailGroup, TenantAlertEmailGroupList, TenantAlertingSettings, TenantInvite, TenantInviteList, TenantMember, TenantMemberList, TenantQueueMetrics, TenantResourcePolicy, TenantStepRunQueueMetrics, TriggerRunResult, TriggerWorkflowRunRequest, UpdateCronWorkflowTriggerRequest, UpdateScheduledWorkflowRunRequest, UpdateTenantAlertEmailGroupRequest, UpdateTenantInviteRequest, UpdateTenantMemberRequest, UpdateTenantRequest, UpdateWorkerRequest, User, UserChangePasswordRequest, UserLoginRequest, UserRegisterRequest, UserTenantMembershipsList, V1AdditionalMetadataOperator, V1BranchDurableTaskRequest, V1BranchDurableTaskResponse, V1CELDebugRequest, V1CELDebugResponse, V1CancelTaskRequest, V1CancelledTasks, V1CreateFilterRequest, V1CreateWebhookRequest, V1DagChildren, V1DurableEventLogList, V1Event, V1EventList, V1Filter, V1FilterList, V1LogLineLevel, V1LogLineList, V1LogLineOrderByDirection, V1LogsPointMetrics, V1ReplayTaskRequest, V1ReplayedTasks, V1RestoreTaskResponse, V1RunningFilter, V1TaskEventList, V1TaskPointMetrics, V1TaskRunMetrics, V1TaskStatus, V1TaskSummary, V1TaskSummaryList, V1TaskTimingList, V1TriggerWorkflowRunRequest, V1UpdateFilterRequest, V1UpdateWebhookRequest, V1Webhook, V1WebhookList, V1WebhookResponse, V1WebhookSourceName, V1WorkflowRunDetails, V1WorkflowRunDisplayNameList, V1WorkflowRunExternalIdList, WebhookWorkerCreateRequest, WebhookWorkerCreated, WebhookWorkerListResponse, WebhookWorkerRequestListResponse, Worker, WorkerList, WorkerStatus, Workflow, WorkflowID, WorkflowKindList, WorkflowList, WorkflowMetrics, WorkflowRun, WorkflowRunList, WorkflowRunOrderByDirection, WorkflowRunOrderByField, WorkflowRunShape, WorkflowRunStatus, WorkflowRunStatusList, WorkflowRunsCancelRequest, WorkflowRunsMetrics, WorkflowUpdateRequest, WorkflowVersion, WorkflowWorkersCount } from './data-contracts';
+import { APIErrors, APIMeta, AcceptInviteRequest, BulkCreateEventRequest, CancelEventRequest, CreateAPITokenRequest, CreateAPITokenResponse, CreateCronWorkflowTriggerRequest, CreateEventRequest, CreateSNSIntegrationRequest, CreateTenantAlertEmailGroupRequest, CreateTenantInviteRequest, CreateTenantRequest, CronWorkflows, CronWorkflowsList, CronWorkflowsOrderByField, Event, EventData, EventKey, EventKeyList, EventList, EventOrderByDirection, EventOrderByField, EventSearch, Events, FeatureFlagEvaluationResult, FeatureFlagId, ListAPIMetaIntegration, ListAPITokensResponse, ListSNSIntegrations, ListSlackWebhooks, OtelSpanList, RateLimitList, RateLimitOrderByDirection, RateLimitOrderByField, RejectInviteRequest, ReplayEventRequest, ReplayWorkflowRunsRequest, ReplayWorkflowRunsResponse, RerunStepRunRequest, SNSIntegration, ScheduleWorkflowRunRequest, ScheduledRunStatus, ScheduledWorkflows, ScheduledWorkflowsBulkDeleteRequest, ScheduledWorkflowsBulkDeleteResponse, ScheduledWorkflowsBulkUpdateRequest, ScheduledWorkflowsBulkUpdateResponse, ScheduledWorkflowsList, ScheduledWorkflowsOrderByField, StepRun, StepRunArchiveList, StepRunEventList, TaskStats, Tenant, TenantAlertEmailGroup, TenantAlertEmailGroupList, TenantAlertingSettings, TenantInvite, TenantInviteList, TenantMember, TenantMemberList, TenantQueueMetrics, TenantResourcePolicy, TenantStepRunQueueMetrics, TriggerRunResult, TriggerWorkflowRunRequest, UpdateCronWorkflowTriggerRequest, UpdateScheduledWorkflowRunRequest, UpdateTenantAlertEmailGroupRequest, UpdateTenantInviteRequest, UpdateTenantMemberRequest, UpdateTenantRequest, UpdateWorkerRequest, User, UserChangePasswordRequest, UserLoginRequest, UserRegisterRequest, UserTenantMembershipsList, V1AdditionalMetadataOperator, V1BranchDurableTaskRequest, V1BranchDurableTaskResponse, V1CELDebugRequest, V1CELDebugResponse, V1CancelTaskRequest, V1CancelledTasks, V1CreateFilterRequest, V1CreateHTTPOperatorRequest, V1CreateWebhookRequest, V1DagChildren, V1DurableEventLogList, V1Event, V1EventList, V1Filter, V1FilterList, V1HTTPOperator, V1HTTPOperatorList, V1LogLineLevel, V1LogLineList, V1LogLineOrderByDirection, V1LogsPointMetrics, V1ReplayTaskRequest, V1ReplayedTasks, V1RestoreTaskResponse, V1RunningFilter, V1TaskEventList, V1TaskPointMetrics, V1TaskRunMetrics, V1TaskStatus, V1TaskSummary, V1TaskSummaryList, V1TaskTimingList, V1TriggerWorkflowRunRequest, V1UpdateFilterRequest, V1UpdateHTTPOperatorRequest, V1UpdateWebhookRequest, V1Webhook, V1WebhookList, V1WebhookResponse, V1WebhookSourceName, V1WorkflowRunDetails, V1WorkflowRunDisplayNameList, V1WorkflowRunExternalIdList, WebhookWorkerCreateRequest, WebhookWorkerCreated, WebhookWorkerListResponse, WebhookWorkerRequestListResponse, Worker, WorkerList, WorkerStatus, Workflow, WorkflowID, WorkflowKindList, WorkflowList, WorkflowMetrics, WorkflowRun, WorkflowRunList, WorkflowRunOrderByDirection, WorkflowRunOrderByField, WorkflowRunShape, WorkflowRunStatus, WorkflowRunStatusList, WorkflowRunsCancelRequest, WorkflowRunsMetrics, WorkflowUpdateRequest, WorkflowVersion, WorkflowWorkersCount } from './data-contracts';
 import { HttpClient, RequestParams } from './http-client';
 export declare class Api<SecurityDataType = unknown> extends HttpClient<SecurityDataType> {
     /**
@@ -601,6 +601,7 @@ export declare class Api<SecurityDataType = unknown> extends HttpClient<Security
      *
      * @tags Filter
      * @name V1FilterDelete
+     * @summary Delete a filter
      * @request DELETE:/api/v1/stable/tenants/{tenant}/filters/{v1-filter}
      * @secure
      */
@@ -610,6 +611,7 @@ export declare class Api<SecurityDataType = unknown> extends HttpClient<Security
      *
      * @tags Filter
      * @name V1FilterUpdate
+     * @summary Update a filter
      * @request PATCH:/api/v1/stable/tenants/{tenant}/filters/{v1-filter}
      * @secure
      */
@@ -664,6 +666,7 @@ export declare class Api<SecurityDataType = unknown> extends HttpClient<Security
      *
      * @tags Webhook
      * @name V1WebhookDelete
+     * @summary Delete a webhook
      * @request DELETE:/api/v1/stable/tenants/{tenant}/webhooks/{v1-webhook}
      * @secure
      */
@@ -687,6 +690,67 @@ export declare class Api<SecurityDataType = unknown> extends HttpClient<Security
      * @secure
      */
     v1WebhookUpdate: (tenant: string, v1Webhook: string, data: V1UpdateWebhookRequest, params?: RequestParams) => Promise<import("axios").AxiosResponse<V1Webhook, any, {}>>;
+    /**
+     * @description Lists all HTTP operators for a tenant.
+     *
+     * @tags Operator
+     * @name V1HttpOperatorList
+     * @summary List HTTP operators
+     * @request GET:/api/v1/stable/tenants/{tenant}/operators/http
+     * @secure
+     */
+    v1HttpOperatorList: (tenant: string, query?: {
+        /**
+         * The number to skip
+         * @format int64
+         */
+        offset?: number;
+        /**
+         * The number to limit by
+         * @format int64
+         */
+        limit?: number;
+    }, params?: RequestParams) => Promise<import("axios").AxiosResponse<V1HTTPOperatorList, any, {}>>;
+    /**
+     * @description Create a new HTTP operator
+     *
+     * @tags Operator
+     * @name V1HttpOperatorCreate
+     * @summary Create an HTTP operator
+     * @request POST:/api/v1/stable/tenants/{tenant}/operators/http
+     * @secure
+     */
+    v1HttpOperatorCreate: (tenant: string, data: V1CreateHTTPOperatorRequest, params?: RequestParams) => Promise<import("axios").AxiosResponse<V1HTTPOperator, any, {}>>;
+    /**
+     * @description Get an HTTP operator by its id
+     *
+     * @tags Operator
+     * @name V1HttpOperatorGet
+     * @summary Get an HTTP operator
+     * @request GET:/api/v1/stable/operators/http/{v1-http-operator}
+     * @secure
+     */
+    v1HttpOperatorGet: (v1HttpOperator: string, params?: RequestParams) => Promise<import("axios").AxiosResponse<V1HTTPOperator, any, {}>>;
+    /**
+     * @description Update an HTTP operator
+     *
+     * @tags Operator
+     * @name V1HttpOperatorUpdate
+     * @summary Update an HTTP operator
+     * @request PATCH:/api/v1/stable/operators/http/{v1-http-operator}
+     * @secure
+     */
+    v1HttpOperatorUpdate: (v1HttpOperator: string, data: V1UpdateHTTPOperatorRequest, params?: RequestParams) => Promise<import("axios").AxiosResponse<V1HTTPOperator, any, {}>>;
+    /**
+     * @description Delete an HTTP operator
+     *
+     * @tags Operator
+     * @name V1HttpOperatorDelete
+     * @summary Delete an HTTP operator
+     * @request DELETE:/api/v1/stable/operators/http/{v1-http-operator}
+     * @secure
+     */
+    v1HttpOperatorDelete: (v1HttpOperator: string, params?: RequestParams) => Promise<import("axios").AxiosResponse<V1HTTPOperator, any, {}>>;
     /**
      * @description Evaluate a CEL expression against provided input data.
      *

package/clients/rest/generated/Api.js

@@ -301,6 +301,7 @@ class Api extends http_client_1.HttpClient {
          *
          * @tags Filter
          * @name V1FilterDelete
+         * @summary Delete a filter
          * @request DELETE:/api/v1/stable/tenants/{tenant}/filters/{v1-filter}
          * @secure
          */
@@ -310,6 +311,7 @@ class Api extends http_client_1.HttpClient {
          *
          * @tags Filter
          * @name V1FilterUpdate
+         * @summary Update a filter
          * @request PATCH:/api/v1/stable/tenants/{tenant}/filters/{v1-filter}
          * @secure
          */
@@ -349,6 +351,7 @@ class Api extends http_client_1.HttpClient {
          *
          * @tags Webhook
          * @name V1WebhookDelete
+         * @summary Delete a webhook
          * @request DELETE:/api/v1/stable/tenants/{tenant}/webhooks/{v1-webhook}
          * @secure
          */
@@ -372,6 +375,56 @@ class Api extends http_client_1.HttpClient {
          * @secure
          */
         this.v1WebhookUpdate = (tenant, v1Webhook, data, params = {}) => this.request(Object.assign({ path: `/api/v1/stable/tenants/${tenant}/webhooks/${v1Webhook}`, method: 'PATCH', body: data, secure: true, type: http_client_1.ContentType.Json, format: 'json' }, params));
+        /**
+         * @description Lists all HTTP operators for a tenant.
+         *
+         * @tags Operator
+         * @name V1HttpOperatorList
+         * @summary List HTTP operators
+         * @request GET:/api/v1/stable/tenants/{tenant}/operators/http
+         * @secure
+         */
+        this.v1HttpOperatorList = (tenant, query, params = {}) => this.request(Object.assign({ path: `/api/v1/stable/tenants/${tenant}/operators/http`, method: 'GET', query: query, secure: true, format: 'json' }, params));
+        /**
+         * @description Create a new HTTP operator
+         *
+         * @tags Operator
+         * @name V1HttpOperatorCreate
+         * @summary Create an HTTP operator
+         * @request POST:/api/v1/stable/tenants/{tenant}/operators/http
+         * @secure
+         */
+        this.v1HttpOperatorCreate = (tenant, data, params = {}) => this.request(Object.assign({ path: `/api/v1/stable/tenants/${tenant}/operators/http`, method: 'POST', body: data, secure: true, type: http_client_1.ContentType.Json, format: 'json' }, params));
+        /**
+         * @description Get an HTTP operator by its id
+         *
+         * @tags Operator
+         * @name V1HttpOperatorGet
+         * @summary Get an HTTP operator
+         * @request GET:/api/v1/stable/operators/http/{v1-http-operator}
+         * @secure
+         */
+        this.v1HttpOperatorGet = (v1HttpOperator, params = {}) => this.request(Object.assign({ path: `/api/v1/stable/operators/http/${v1HttpOperator}`, method: 'GET', secure: true, format: 'json' }, params));
+        /**
+         * @description Update an HTTP operator
+         *
+         * @tags Operator
+         * @name V1HttpOperatorUpdate
+         * @summary Update an HTTP operator
+         * @request PATCH:/api/v1/stable/operators/http/{v1-http-operator}
+         * @secure
+         */
+        this.v1HttpOperatorUpdate = (v1HttpOperator, data, params = {}) => this.request(Object.assign({ path: `/api/v1/stable/operators/http/${v1HttpOperator}`, method: 'PATCH', body: data, secure: true, type: http_client_1.ContentType.Json, format: 'json' }, params));
+        /**
+         * @description Delete an HTTP operator
+         *
+         * @tags Operator
+         * @name V1HttpOperatorDelete
+         * @summary Delete an HTTP operator
+         * @request DELETE:/api/v1/stable/operators/http/{v1-http-operator}
+         * @secure
+         */
+        this.v1HttpOperatorDelete = (v1HttpOperator, params = {}) => this.request(Object.assign({ path: `/api/v1/stable/operators/http/${v1HttpOperator}`, method: 'DELETE', secure: true, format: 'json' }, params));
         /**
          * @description Evaluate a CEL expression against provided input data.
          *

package/clients/rest/generated/data-contracts.d.ts

@@ -141,6 +141,10 @@ export declare enum ScheduledWorkflowsMethod {
     DEFAULT = "DEFAULT",
     API = "API"
 }
+export declare enum WorkflowPauseScheduledCronRunQueueBehavior {
+    DROP = "DROP",
+    QUEUE = "QUEUE"
+}
 export declare enum RateLimitOrderByDirection {
     Asc = "asc",
     Desc = "desc"
@@ -169,7 +173,8 @@ export declare enum WorkflowRunStatus {
 export declare enum TenantMemberRole {
     OWNER = "OWNER",
     ADMIN = "ADMIN",
-    MEMBER = "MEMBER"
+    MEMBER = "MEMBER",
+    VIEWER = "VIEWER"
 }
 export declare enum TenantResource {
     WORKER = "WORKER",
@@ -415,6 +420,8 @@ export interface V1TaskSummary {
     parentTaskExternalId?: string;
     /** The idempotency key that was claimed by the task run */
     idempotencyKey?: string;
+    /** True when input, output, and event payload fields were omitted because the caller cannot view payloads. Additional metadata is still included. */
+    payloadsRestricted?: boolean;
 }
 export interface APIError {
     /**
@@ -638,6 +645,8 @@ export interface V1WorkflowRun {
      * @maxLength 36
      */
     parentTaskExternalId?: string;
+    /** True when input, output, and event payload fields were omitted because the caller cannot view payloads. Additional metadata is still included. */
+    payloadsRestricted?: boolean;
 }
 export interface WorkflowRunShapeItemForWorkflowRunDetails {
     /**
@@ -957,6 +966,8 @@ export interface V1Event {
     triggeredRuns?: V1EventTriggeredRun[];
     /** The name of the webhook that triggered this event, if applicable. */
     triggeringWebhookName?: string;
+    /** True when the event payload was omitted because the caller cannot view payloads. Additional metadata is still included. */
+    payloadsRestricted?: boolean;
 }
 export interface V1EventList {
     pagination?: PaginationResponse;
@@ -1104,6 +1115,58 @@ export interface V1UpdateWebhookRequest {
     /** Whether to return the triggered event as the response payload when this webhook is triggered */
     returnEventAsResponsePayload?: boolean;
 }
+export interface V1HTTPOperator {
+    metadata: APIResourceMeta;
+    /**
+     * The ID of the tenant associated with this operator.
+     * @format uuid
+     */
+    tenantId: string;
+    /** The name of the operator. */
+    name: string;
+    /** The HTTPS endpoint (https, port 443) that assigned tasks are delivered to. */
+    triggerEndpoint: string;
+    /** The HTTPS endpoint polled periodically to discover the actions this operator handles. */
+    healthcheckEndpoint: string;
+    /**
+     * The per-request timeout backstop, in seconds.
+     * @format int32
+     */
+    requestTimeoutSeconds: number;
+}
+export interface V1HTTPOperatorList {
+    pagination?: PaginationResponse;
+    rows?: V1HTTPOperator[];
+}
+export interface V1CreateHTTPOperatorRequest {
+    /** The name of the operator. */
+    name: string;
+    /** The HTTPS endpoint (https, port 443) that assigned tasks are delivered to. */
+    triggerEndpoint: string;
+    /** The HTTPS endpoint polled periodically to discover the actions this operator handles. */
+    healthcheckEndpoint: string;
+    /** The secret used to HMAC-sign delivered requests (sent in the X-Hatchet-Signature header). Write-only: it is never returned in responses. */
+    signingSecret: string;
+    /**
+     * The per-request timeout backstop, in seconds.
+     * @format int32
+     */
+    requestTimeoutSeconds: number;
+}
+/** Fields to update on an HTTP operator. Omitted fields are left unchanged. */
+export interface V1UpdateHTTPOperatorRequest {
+    /** The HTTPS endpoint (https, port 443) that assigned tasks are delivered to. */
+    triggerEndpoint?: string;
+    /** An optional HTTPS endpoint polled to verify the operator endpoint is reachable. */
+    healthcheckEndpoint?: string;
+    /** The secret used to HMAC-sign delivered requests. Write-only: it is never returned in responses. Provide a new value to rotate it. */
+    signingSecret?: string;
+    /**
+     * Optional override for the per-request timeout backstop, in seconds.
+     * @format int32
+     */
+    requestTimeoutSeconds?: number;
+}
 export interface V1CELDebugRequest {
     /** The CEL expression to evaluate */
     expression: string;
@@ -1189,6 +1252,11 @@ export interface APIMeta {
      * @example "eyJhbGciOiJFUzI1NiIs..."
      */
     authDisabledToken?: string;
+    /**
+     * whether this instance is running in embedded mode
+     * @example false
+     */
+    embedded?: boolean;
 }
 export interface APIMetaIntegration {
     /**
@@ -1336,6 +1404,8 @@ export interface TenantMember {
     user: UserTenantPublic;
     /** The role of the user in the tenant. */
     role: TenantMemberRole;
+    /** Whether this member can view task, event, and log payloads in the dashboard and REST API. OWNER and ADMIN always can, regardless of this flag. Defaults to true. */
+    canViewPayloads?: boolean;
     /** The tenant associated with this tenant member. */
     tenant?: Tenant;
     /** Whether this membership was explicitly granted (as opposed to synced via user-group tags). Only explicit members can have their role edited or be removed. */
@@ -1351,6 +1421,8 @@ export interface TenantInvite {
     email: string;
     /** The role of the user in the tenant. */
     role: TenantMemberRole;
+    /** Whether the invited user can view payloads. Defaults to true. */
+    canViewPayloads?: boolean;
     /** The tenant id associated with this tenant invite. */
     tenantId: string;
     /** The tenant name for the tenant. */
@@ -1434,10 +1506,14 @@ export interface CreateTenantInviteRequest {
     email: string;
     /** The role of the user in the tenant. */
     role: TenantMemberRole;
+    /** Whether the invited user can view payloads. Defaults to true. */
+    canViewPayloads?: boolean;
 }
 export interface UpdateTenantInviteRequest {
     /** The role of the user in the tenant. */
     role: TenantMemberRole;
+    /** Whether the invited user can view payloads. */
+    canViewPayloads?: boolean;
 }
 export interface APIToken {
     metadata: APIResourceMeta;
@@ -1597,6 +1673,8 @@ export interface TenantMemberList {
 export interface UpdateTenantMemberRequest {
     /** The role of the user in the tenant. */
     role: TenantMemberRole;
+    /** Whether this member can view payloads. Ignored for OWNER and ADMIN, who always can. */
+    canViewPayloads?: boolean;
 }
 export interface EventData {
     /** The data for the event (JSON bytes). */
@@ -1610,6 +1688,10 @@ export interface Workflow {
     description?: string;
     /** Whether the workflow is paused. */
     isPaused?: boolean;
+    /** The behavior of cron runs triggered while the workflow is paused. */
+    pausedWorkflowCronRunQueueBehavior?: WorkflowPauseScheduledCronRunQueueBehavior;
+    /** The behavior of scheduled runs triggered while the workflow is paused. */
+    pausedWorkflowScheduledRunQueueBehavior?: WorkflowPauseScheduledCronRunQueueBehavior;
     versions?: WorkflowVersionMeta[];
     /** The tags of the workflow. */
     tags?: WorkflowTag[];
@@ -1831,9 +1913,23 @@ export interface UpdateCronWorkflowTriggerRequest {
 export interface WorkflowRunsCancelRequest {
     workflowRunIds: string[];
 }
+export interface PauseWorkflowRequestPause {
+    /** Discriminator indicating this request pauses the workflow. */
+    action: 'pause';
+    /** The behavior of cron runs triggered while the workflow is paused. */
+    pausedWorkflowCronRunQueueBehavior: WorkflowPauseScheduledCronRunQueueBehavior;
+    /** The behavior of scheduled runs triggered while the workflow is paused. */
+    pausedWorkflowScheduledRunQueueBehavior: WorkflowPauseScheduledCronRunQueueBehavior;
+    /** The TTL for queued runs while the workflow is paused before they get dropped, expressed as a Go-style duration string (e.g. "1d7h30m"). */
+    pausedWorkflowQueueTTL: string;
+}
+export interface PauseWorkflowRequestUnpause {
+    /** Discriminator indicating this request unpauses the workflow. */
+    action: 'unpause';
+}
+export type PauseWorkflowRequest = PauseWorkflowRequestPause | PauseWorkflowRequestUnpause;
 export interface WorkflowUpdateRequest {
-    /** Whether the workflow is paused. */
-    isPaused?: boolean;
+    pause?: PauseWorkflowRequest;
 }
 export interface WorkflowConcurrency {
     /**

package/clients/rest/generated/data-contracts.js

@@ -11,7 +11,7 @@
  * ---------------------------------------------------------------
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.V1TaskStatus = exports.V1WorkflowType = exports.V1TaskEventType = exports.V1LogLineLevel = exports.V1LogLineOrderByDirection = exports.V1AdditionalMetadataOperator = exports.V1RunningFilter = exports.V1DurableEventLogKind = exports.V1DurableWaitConditionKind = exports.OtelSpanKind = exports.OtelStatusCode = exports.TenantVersion = exports.TenantEnvironment = exports.V1WebhookSourceName = exports.V1WebhookAuthType = exports.V1WebhookHMACAlgorithm = exports.V1WebhookHMACEncoding = exports.V1CELDebugResponseStatus = exports.TenantResource = exports.TenantMemberRole = exports.WorkflowRunStatus = exports.EventOrderByField = exports.EventOrderByDirection = exports.RateLimitOrderByField = exports.RateLimitOrderByDirection = exports.ScheduledWorkflowsMethod = exports.ScheduledWorkflowsOrderByField = exports.WorkflowRunOrderByDirection = exports.ScheduledRunStatus = exports.CronWorkflowsMethod = exports.CronWorkflowsOrderByField = exports.ConcurrencyLimitStrategy = exports.ConcurrencyScope = exports.StepRunStatus = exports.JobRunStatus = exports.StepRunEventReason = exports.StepRunEventSeverity = exports.WorkflowKind = exports.WorkflowRunOrderByField = exports.WorkerStatus = exports.WorkerType = exports.WorkerRuntimeSDKs = exports.WebhookWorkerRequestMethod = exports.FeatureFlagId = exports.PullRequestState = exports.LogLineLevel = exports.LogLineOrderByField = exports.LogLineOrderByDirection = exports.V1TaskRunStatus = void 0;
+exports.V1TaskStatus = exports.V1WorkflowType = exports.V1TaskEventType = exports.V1LogLineLevel = exports.V1LogLineOrderByDirection = exports.V1AdditionalMetadataOperator = exports.V1RunningFilter = exports.V1DurableEventLogKind = exports.V1DurableWaitConditionKind = exports.OtelSpanKind = exports.OtelStatusCode = exports.TenantVersion = exports.TenantEnvironment = exports.V1WebhookSourceName = exports.V1WebhookAuthType = exports.V1WebhookHMACAlgorithm = exports.V1WebhookHMACEncoding = exports.V1CELDebugResponseStatus = exports.TenantResource = exports.TenantMemberRole = exports.WorkflowRunStatus = exports.EventOrderByField = exports.EventOrderByDirection = exports.RateLimitOrderByField = exports.RateLimitOrderByDirection = exports.WorkflowPauseScheduledCronRunQueueBehavior = exports.ScheduledWorkflowsMethod = exports.ScheduledWorkflowsOrderByField = exports.WorkflowRunOrderByDirection = exports.ScheduledRunStatus = exports.CronWorkflowsMethod = exports.CronWorkflowsOrderByField = exports.ConcurrencyLimitStrategy = exports.ConcurrencyScope = exports.StepRunStatus = exports.JobRunStatus = exports.StepRunEventReason = exports.StepRunEventSeverity = exports.WorkflowKind = exports.WorkflowRunOrderByField = exports.WorkerStatus = exports.WorkerType = exports.WorkerRuntimeSDKs = exports.WebhookWorkerRequestMethod = exports.FeatureFlagId = exports.PullRequestState = exports.LogLineLevel = exports.LogLineOrderByField = exports.LogLineOrderByDirection = exports.V1TaskRunStatus = void 0;
 var V1TaskRunStatus;
 (function (V1TaskRunStatus) {
     V1TaskRunStatus["PENDING"] = "PENDING";
@@ -179,6 +179,11 @@ var ScheduledWorkflowsMethod;
     ScheduledWorkflowsMethod["DEFAULT"] = "DEFAULT";
     ScheduledWorkflowsMethod["API"] = "API";
 })(ScheduledWorkflowsMethod || (exports.ScheduledWorkflowsMethod = ScheduledWorkflowsMethod = {}));
+var WorkflowPauseScheduledCronRunQueueBehavior;
+(function (WorkflowPauseScheduledCronRunQueueBehavior) {
+    WorkflowPauseScheduledCronRunQueueBehavior["DROP"] = "DROP";
+    WorkflowPauseScheduledCronRunQueueBehavior["QUEUE"] = "QUEUE";
+})(WorkflowPauseScheduledCronRunQueueBehavior || (exports.WorkflowPauseScheduledCronRunQueueBehavior = WorkflowPauseScheduledCronRunQueueBehavior = {}));
 var RateLimitOrderByDirection;
 (function (RateLimitOrderByDirection) {
     RateLimitOrderByDirection["Asc"] = "asc";
@@ -214,6 +219,7 @@ var TenantMemberRole;
     TenantMemberRole["OWNER"] = "OWNER";
     TenantMemberRole["ADMIN"] = "ADMIN";
     TenantMemberRole["MEMBER"] = "MEMBER";
+    TenantMemberRole["VIEWER"] = "VIEWER";
 })(TenantMemberRole || (exports.TenantMemberRole = TenantMemberRole = {}));
 var TenantResource;
 (function (TenantResource) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "1.28.2",
+  "version": "1.29.0",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [

package/v1/client/client.d.ts

@@ -1,6 +1,6 @@
 /**
  * This is the TypeScript SDK reference, documenting methods available for interacting with Hatchet resources.
- * Check out the [user guide](https://docs.hatchet.run/home/) for an introduction to getting your first tasks running.
+ * Check out the [user guide](https://docs.hatchet.run/v1) for an introduction to getting your first tasks running.
  *
  * @module Hatchet TypeScript SDK Reference
  */

package/v1/client/client.js

@@ -1,7 +1,7 @@
 "use strict";
 /**
  * This is the TypeScript SDK reference, documenting methods available for interacting with Hatchet resources.
- * Check out the [user guide](https://docs.hatchet.run/home/) for an introduction to getting your first tasks running.
+ * Check out the [user guide](https://docs.hatchet.run/v1) for an introduction to getting your first tasks running.
  *
  * @module Hatchet TypeScript SDK Reference
  */

package/v1/client/features/tenant.d.ts

@@ -1,6 +1,3 @@
-/**
- * @module Tenant Client
- */
 import { Tenant } from '../../../clients/rest/generated/data-contracts';
 import { HatchetClient } from '../client';
 /**

package/v1/client/worker/context.d.ts

@@ -87,7 +87,7 @@ export declare class Context<T, K = {}> {
     worker: ContextWorker;
     overridesData: Record<string, any>;
     _logger: Logger;
-    /** @deprecated — kept for backward compat; prefer {@link nextChildIndex}. */
+    /** @deprecated Kept for backward compat; prefer {@link nextChildIndex}. */
     spawnIndex: number;
     streamIndex: number;
     protected nextChildIndex(n?: number): number;

package/v1/client/worker/context.js

@@ -89,7 +89,7 @@ class Context {
         // @deprecated use ctx.abortController instead
         this.controller = new AbortController();
         this.overridesData = {};
-        /** @deprecated — kept for backward compat; prefer {@link nextChildIndex}. */
+        /** @deprecated Kept for backward compat; prefer {@link nextChildIndex}. */
         this.spawnIndex = 0;
         this.streamIndex = 0;
         try {
@@ -139,7 +139,7 @@ class Context {
             var _a, _b;
             if (this.action.batchId) {
                 // Batch tasks share one context across every buffered member, so there is no single
-                // task-run id to cancel — cancel every member of the batch instead. `this.data` is
+                // task-run id to cancel, so cancel every member of the batch instead. `this.data` is
                 // the raw batch-items map for a START_BATCH action, keyed by each member's
                 // task-run external id.
                 const memberIds = Object.keys((_a = this.data) !== null && _a !== void 0 ? _a : {});

package/v1/declaration.js

@@ -93,7 +93,7 @@ class BaseWorkflowDeclaration {
                     : undefined,
                 warn: (message) => this.client.admin.logger.warn(message),
             });
-            // Snapshot childIndex before incrementing — shared with Context.spawnIndex
+            // Snapshot childIndex before incrementing (shared with Context.spawnIndex)
             // via parentRunContextManager so both spawning APIs produce unique indices.
             const baseChildIndex = parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.childIndex;
             const inputCount = Array.isArray(input) ? input.length : 1;

package/v1/embedded.d.ts

@@ -0,0 +1,60 @@
+import type { AxiosRequestConfig } from 'axios';
+import type { ClientConfig, HatchetClientOptions } from '../clients/hatchet-client';
+import { HatchetClient } from './client/client';
+export interface EmbeddedOptions {
+    /**
+     * hatchet-embedded release tag to download (defaults to HATCHET_CLIENT_EMBEDDED_VERSION or
+     * latest). Tags correspond to the Hatchet engine version baked into the sidecar,
+     * so pinning this pins the engine.
+     */
+    version?: string;
+    /** path to an existing sidecar binary, skips the download (or HATCHET_CLIENT_EMBEDDED_BINARY_PATH) */
+    binaryPath?: string;
+    /**
+     * expected sha256 hex digest of the sidecar binary. When set, it replaces the
+     * release's checksums.txt as the trust anchor, so a compromised release
+     * channel cannot substitute the binary. Pin it together with `version`.
+     */
+    checksum?: string;
+    /** use an existing Postgres instead of the bundled one */
+    databaseUrl?: string;
+    /** store the bundled Postgres runtime and data under this directory */
+    postgresDataDir?: string;
+    grpcPort?: number;
+    apiPort?: number;
+    /** set to false to start only the engine + gRPC, no REST API */
+    startApi?: boolean;
+    /** set to false to skip running migrations on startup */
+    runMigrations?: boolean;
+    /** use RabbitMQ instead of the Postgres message queue */
+    rabbitmqUrl?: string;
+    logLevel?: string;
+    readyTimeoutMs?: number;
+}
+export interface EmbeddedSidecar {
+    token: string;
+    tenantId: string;
+    grpcAddress: string;
+    apiUrl: string;
+    stop: () => 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 `HatchetEmbedded()` unless you need the raw
+ * connection details.
+ */
+export declare function startEmbeddedSidecar(opts?: EmbeddedOptions): Promise<EmbeddedSidecar>;
+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.
+     * @param embeddedOpts - Options for the embedded engine (version, ports, database, ...).
+     * @param config - Optional configuration overrides for the client.
+     * @param options - Optional client options.
+     * @param axiosConfig - Optional Axios configuration for HTTP requests.
+     * @returns A new Hatchet client instance connected to the embedded engine.
+     */
+    static init<T extends Record<string, any> = {}, U extends Record<string, any> = {}>(embeddedOpts?: EmbeddedOptions, config?: Omit<Partial<ClientConfig>, 'middleware'>, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig): Promise<HatchetClient<T, U>>;
+}

package/v1/embedded.js

@@ -0,0 +1,319 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HatchetEmbeddedClient = void 0;
+exports.startEmbeddedSidecar = startEmbeddedSidecar;
+const child_process_1 = require("child_process");
+const client_1 = require("./client/client");
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const fs = __importStar(require("fs/promises"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const stream_1 = require("stream");
+const net_1 = require("net");
+const promises_1 = require("stream/promises");
+const REPO_URL = 'https://github.com/hatchet-dev/hatchet-embedded';
+const DEFAULT_READY_TIMEOUT_MS = 300000;
+function sidecarAssetName() {
+    const platform = { darwin: 'darwin', linux: 'linux' }[process.platform];
+    const arch = { x64: 'amd64', arm64: 'arm64' }[process.arch];
+    if (!platform || !arch) {
+        throw new Error(`hatchet embedded is not supported on ${process.platform}/${process.arch}`);
+    }
+    return `hatchet-embedded-sidecar_${platform}_${arch}`;
+}
+function resolveVersion(version) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const requested = (_a = version !== null && version !== void 0 ? version : process.env.HATCHET_CLIENT_EMBEDDED_VERSION) !== null && _a !== void 0 ? _a : 'latest';
+        if (requested !== 'latest') {
+            return requested;
+        }
+        const res = yield fetch(`${REPO_URL}/releases/latest`, { redirect: 'manual' });
+        const location = res.headers.get('location');
+        const tag = location === null || location === void 0 ? void 0 : location.split('/').pop();
+        if (!tag || !tag.startsWith('v')) {
+            throw new Error(`could not resolve the latest hatchet-embedded release from ${REPO_URL}`);
+        }
+        return tag;
+    });
+}
+function expectedChecksum(tag, asset) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const url = `${REPO_URL}/releases/download/${tag}/checksums.txt`;
+        const res = yield fetch(url, { signal: AbortSignal.timeout(10000) });
+        if (!res.ok) {
+            throw new Error(`could not download ${url}: ${res.status}`);
+        }
+        for (const line of (yield res.text()).split('\n')) {
+            const parts = line.split(/\s+/).filter(Boolean);
+            if (parts.length === 2 && parts[1] === asset) {
+                return parts[0];
+            }
+        }
+        throw new Error(`no checksum for ${asset} in ${url}`);
+    });
+}
+function sha256File(filePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, e_1, _b, _c;
+        const digest = (0, crypto_1.createHash)('sha256');
+        try {
+            for (var _d = true, _e = __asyncValues((0, fs_1.createReadStream)(filePath)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                _c = _f.value;
+                _d = false;
+                const chunk = _c;
+                digest.update(chunk);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return digest.digest('hex');
+    });
+}
+function resolveExpectedChecksum(tag, asset, binPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const checksumPath = path.join(path.dirname(binPath), `${asset}.sha256`);
+        // fall back to the checksum cached at download time so a pinned, already
+        // verified binary still starts when GitHub is unreachable
+        let expected;
+        try {
+            expected = yield expectedChecksum(tag, asset);
+        }
+        catch (err) {
+            const cachedDigest = yield fs.readFile(checksumPath, 'utf8').then((s) => s.trim(), () => undefined);
+            const hasBinary = yield fs.access(binPath).then(() => true, () => false);
+            if (cachedDigest && hasBinary) {
+                return cachedDigest;
+            }
+            throw err;
+        }
+        yield fs.writeFile(checksumPath, `${expected}\n`);
+        return expected;
+    });
+}
+function ensureSidecarBinary(version, checksum) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const tag = yield resolveVersion(version);
+        const asset = sidecarAssetName();
+        const binPath = path.join(os.homedir(), '.hatchet', 'embedded', tag, asset);
+        yield fs.mkdir(path.dirname(binPath), { recursive: true });
+        // verified on every start, not just at download; a cached binary that no
+        // longer matches the expected checksum is re-downloaded
+        const expected = checksum !== null && checksum !== void 0 ? checksum : (yield resolveExpectedChecksum(tag, asset, binPath));
+        const cached = yield fs.access(binPath).then(() => true, () => false);
+        if (cached && (yield sha256File(binPath)) === expected) {
+            return binPath;
+        }
+        const url = `${REPO_URL}/releases/download/${tag}/${asset}`;
+        const res = yield fetch(url);
+        if (!res.ok || !res.body) {
+            throw new Error(`could not download the hatchet embedded sidecar from ${url}: ${res.status}`);
+        }
+        // unique temp name per call (not per process) so concurrent downloads of
+        // the same version never clobber each other, even within one process; the
+        // final rename is atomic and last-writer-wins
+        const tmpPath = `${binPath}.${(0, crypto_1.randomUUID)()}.download`;
+        try {
+            yield (0, promises_1.pipeline)(stream_1.Readable.fromWeb(res.body), (0, fs_1.createWriteStream)(tmpPath, { mode: 0o755 }));
+            const actual = yield sha256File(tmpPath);
+            if (actual !== expected) {
+                throw new Error(`checksum mismatch for ${url}: expected ${expected}, got ${actual}`);
+            }
+            yield fs.rename(tmpPath, binPath);
+        }
+        finally {
+            yield fs.rm(tmpPath, { force: true });
+        }
+        return binPath;
+    });
+}
+function waitForHandshake(child, handshakePath, timeoutMs) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const deadline = Date.now() + timeoutMs;
+        let exited;
+        child.once('exit', (code) => {
+            exited = new Error(`hatchet embedded sidecar exited with code ${code} before becoming ready`);
+        });
+        while (Date.now() < deadline) {
+            if (exited) {
+                throw exited;
+            }
+            try {
+                const handshake = JSON.parse(yield fs.readFile(handshakePath, 'utf8'));
+                if (handshake.token) {
+                    return handshake;
+                }
+            }
+            catch (_a) {
+                // not ready yet
+            }
+            yield new Promise((resolve) => {
+                setTimeout(resolve, 200);
+            });
+        }
+        child.kill();
+        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.
+ */
+function startEmbeddedSidecar() {
+    return __awaiter(this, arguments, void 0, function* (opts = {}) {
+        var _a, _b;
+        const suppliedPath = (_a = opts.binaryPath) !== null && _a !== void 0 ? _a : process.env.HATCHET_CLIENT_EMBEDDED_BINARY_PATH;
+        let binPath;
+        if (suppliedPath) {
+            if (opts.checksum) {
+                const actual = yield sha256File(suppliedPath);
+                if (actual !== opts.checksum) {
+                    throw new Error(`checksum mismatch for ${suppliedPath}: expected ${opts.checksum}, got ${actual}`);
+                }
+            }
+            binPath = suppliedPath;
+        }
+        else {
+            binPath = yield ensureSidecarBinary(opts.version, opts.checksum);
+        }
+        const handshakePath = path.join(yield fs.mkdtemp(path.join(os.tmpdir(), 'hatchet-embedded-')), 'handshake.json');
+        const args = ['-handshake-file', handshakePath];
+        if (opts.databaseUrl) {
+            args.push('-database-url', opts.databaseUrl);
+        }
+        if (opts.rabbitmqUrl) {
+            args.push('-rabbitmq-url', opts.rabbitmqUrl);
+        }
+        if (opts.postgresDataDir) {
+            args.push('-postgres-data-dir', opts.postgresDataDir);
+        }
+        if (opts.grpcPort) {
+            args.push('-grpc-port', String(opts.grpcPort));
+        }
+        if (opts.apiPort) {
+            args.push('-api-port', String(opts.apiPort));
+        }
+        if (opts.startApi === false) {
+            args.push('-no-api');
+        }
+        if (opts.runMigrations === false) {
+            args.push('-no-migrations');
+        }
+        if (opts.logLevel) {
+            args.push('-log-level', opts.logLevel);
+        }
+        // the sidecar shuts down when its stdin closes, so it never outlives this
+        // process, no matter how this process dies
+        const child = (0, child_process_1.spawn)(binPath, args, { stdio: ['pipe', 'ignore', 'inherit'] });
+        const killChild = () => child.kill();
+        process.once('exit', killChild);
+        let handshake;
+        try {
+            handshake = yield waitForHandshake(child, handshakePath, (_b = opts.readyTimeoutMs) !== null && _b !== void 0 ? _b : DEFAULT_READY_TIMEOUT_MS);
+        }
+        finally {
+            yield fs.rm(path.dirname(handshakePath), { recursive: true, force: true }).catch(() => { });
+        }
+        child.unref();
+        if (child.stdin instanceof net_1.Socket) {
+            child.stdin.unref();
+        }
+        return {
+            token: handshake.token,
+            tenantId: handshake.tenant_id,
+            grpcAddress: handshake.grpc_address,
+            apiUrl: handshake.api_url,
+            stop: () => new Promise((resolve) => {
+                var _a;
+                process.removeListener('exit', killChild);
+                if (child.exitCode !== null) {
+                    resolve();
+                    return;
+                }
+                const forceKill = setTimeout(() => child.kill('SIGKILL'), 30000);
+                (_a = forceKill.unref) === null || _a === void 0 ? void 0 : _a.call(forceKill);
+                child.once('exit', () => {
+                    clearTimeout(forceKill);
+                    resolve();
+                });
+                child.kill();
+            }),
+        };
+    });
+}
+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.
+     * @param embeddedOpts - Options for the embedded engine (version, ports, database, ...).
+     * @param config - Optional configuration overrides for the client.
+     * @param options - Optional client options.
+     * @param axiosConfig - Optional Axios configuration for HTTP requests.
+     * @returns A new Hatchet client instance connected to the embedded engine.
+     */
+    static init(embeddedOpts, config, options, axiosConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sidecar = yield startEmbeddedSidecar(embeddedOpts);
+            return client_1.HatchetClient.init(Object.assign(Object.assign(Object.assign({ token: sidecar.token, tenant_id: sidecar.tenantId, host_port: sidecar.grpcAddress }, (sidecar.apiUrl ? { api_url: sidecar.apiUrl } : {})), { tls_config: { tls_strategy: 'none' } }), config), options, axiosConfig);
+        });
+    }
+}
+exports.HatchetEmbeddedClient = HatchetEmbeddedClient;

package/v1/examples/migration-guides/temporal.d.ts

@@ -0,0 +1,76 @@
+import { HatchetClient } from '../..';
+export declare const hatchet: HatchetClient<{}, {}, {}, {}>;
+export type OrderInput = {
+    orderId: string;
+    correlationId: string;
+};
+export type ValidateOutput = {
+    valid: boolean;
+};
+export type FulfillOutput = {
+    fulfilled: boolean;
+    shipmentId: string;
+};
+export type SignupInput = {
+    userId: string;
+    email: string;
+};
+export type EmailOutput = {
+    sent: boolean;
+};
+export declare const validateOrder: import("../..").TaskWorkflowDeclaration<OrderInput, ValidateOutput, {}, {}, {}, {}>;
+export type ChargeOutput = {
+    charged: boolean;
+    amountCents: number;
+};
+export declare const chargeOrder: import("../..").TaskWorkflowDeclaration<OrderInput, ChargeOutput, {}, {}, {}, {}>;
+export declare const fulfillOrder: import("../..").TaskWorkflowDeclaration<OrderInput, FulfillOutput, {}, {}, {}, {}>;
+export declare const processOrder: import("../..").TaskWorkflowDeclaration<OrderInput, FulfillOutput, {}, {}, {}, {}>;
+export declare const sendWelcomeEmail: import("../..").TaskWorkflowDeclaration<SignupInput, EmailOutput, {}, {}, {}, {}>;
+export declare const sendFollowupEmail: import("../..").TaskWorkflowDeclaration<SignupInput, EmailOutput, {}, {}, {}, {}>;
+export declare const onboardingFlow: import("../..").TaskWorkflowDeclaration<SignupInput, EmailOutput, {}, {}, {}, {}>;
+export declare const chargeOrderWithRetries: import("../..").TaskWorkflowDeclaration<OrderInput, ChargeOutput, {}, {}, {}, {}>;
+export declare const orderFollowUp: import("../..").TaskWorkflowDeclaration<OrderInput, EmailOutput, {}, {}, {}, {}>;
+export declare const approvalFlow: import("../..").TaskWorkflowDeclaration<OrderInput, FulfillOutput, {}, {}, {}, {}>;
+export type ItemInput = {
+    item: string;
+};
+export type ItemOutput = {
+    packed: boolean;
+};
+export declare const processItem: import("../..").TaskWorkflowDeclaration<ItemInput, ItemOutput, {}, {}, {}, {}>;
+export declare const packOrder: import("../..").TaskWorkflowDeclaration<{
+    items: string[];
+}, {
+    packed: number;
+}, {}, {}, {}, {}>;
+export type ReportInput = {
+    kind: string;
+};
+export type ReportOutput = {
+    generate: {
+        rows: number;
+    };
+};
+export declare const weeklyReport: import("../..").WorkflowDeclaration<ReportInput, ReportOutput, {}>;
+export type SyncInput = {
+    customerId: string;
+};
+export type SyncOutput = {
+    sync: {
+        synced: number;
+    };
+};
+export type PromptInput = {
+    prompt: string;
+};
+export declare const syncCustomer: import("../..").WorkflowDeclaration<SyncInput, SyncOutput, {}>;
+export declare const callModel: import("../..").TaskWorkflowDeclaration<PromptInput, {
+    completion: string;
+}, {}, {}, {}, {}>;
+export type OrderDagOutput = {
+    validate: ValidateOutput;
+    charge: ChargeOutput;
+    fulfill: FulfillOutput;
+};
+export declare const orderWorkflow: import("../..").WorkflowDeclaration<OrderInput, OrderDagOutput, {}>;

package/v1/examples/migration-guides/temporal.js

@@ -0,0 +1,280 @@
+"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.orderWorkflow = exports.callModel = exports.syncCustomer = exports.weeklyReport = exports.packOrder = exports.processItem = exports.approvalFlow = exports.orderFollowUp = exports.chargeOrderWithRetries = exports.onboardingFlow = exports.sendFollowupEmail = exports.sendWelcomeEmail = exports.processOrder = exports.fulfillOrder = exports.chargeOrder = exports.validateOrder = exports.hatchet = void 0;
+// > Hatchet worker
+const v1_1 = require("../..");
+exports.hatchet = v1_1.HatchetClient.init();
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield exports.hatchet.worker('order-worker', {
+            workflows: [exports.validateOrder, exports.chargeOrder, exports.fulfillOrder, exports.processOrder],
+            slots: 10,
+        });
+        yield worker.start();
+    });
+}
+const payments = {
+    charge: (orderId) => __awaiter(void 0, void 0, void 0, function* () { return 2500 + orderId.length; }),
+};
+const warehouse = {
+    reserve: (orderId) => __awaiter(void 0, void 0, void 0, function* () { return orderId.length > 0; }),
+    ship: (orderId) => __awaiter(void 0, void 0, void 0, function* () { return `shp_${orderId}`; }),
+    pack: (item) => __awaiter(void 0, void 0, void 0, function* () { return item.length > 0; }),
+};
+const emails = {
+    send: (address, template) => __awaiter(void 0, void 0, void 0, function* () { return address.includes('@') && template.length > 0; }),
+};
+const models = {
+    complete: (prompt) => __awaiter(void 0, void 0, void 0, function* () { return prompt.toUpperCase(); }),
+};
+const crm = {
+    sync: (customerId) => __awaiter(void 0, void 0, void 0, function* () { return customerId.length; }),
+};
+const reports = {
+    build: (kind) => __awaiter(void 0, void 0, void 0, function* () { return kind.length; }),
+};
+exports.validateOrder = exports.hatchet.task({
+    name: 'validate-order',
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        // > Hatchet context logging
+        ctx.logger.info(`validating order ${input.orderId}`);
+        // !!
+        return { valid: yield warehouse.reserve(input.orderId) };
+    }),
+});
+exports.chargeOrder = exports.hatchet.task({
+    name: 'charge-order',
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        const amountCents = yield payments.charge(input.orderId);
+        return { charged: amountCents > 0, amountCents };
+    }),
+});
+// !!
+exports.fulfillOrder = exports.hatchet.task({
+    name: 'fulfill-order',
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        const shipmentId = yield warehouse.ship(input.orderId);
+        return { fulfilled: true, shipmentId };
+    }),
+});
+// > Hatchet workflow as durable task
+exports.processOrder = exports.hatchet.durableTask({
+    name: 'ProcessOrder',
+    executionTimeout: '10m',
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        yield exports.validateOrder.run(input);
+        yield exports.chargeOrder.run(input);
+        return exports.fulfillOrder.run(input);
+    }),
+});
+// !!
+exports.sendWelcomeEmail = exports.hatchet.task({
+    name: 'send-welcome-email',
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        return ({
+            sent: yield emails.send(input.email, 'welcome'),
+        });
+    }),
+});
+exports.sendFollowupEmail = exports.hatchet.task({
+    name: 'send-followup-email',
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        return ({
+            sent: yield emails.send(input.email, 'followup'),
+        });
+    }),
+});
+// > Hatchet durable task with sleep
+exports.onboardingFlow = exports.hatchet.durableTask({
+    name: 'OnboardingFlow',
+    // The timeout has to cover the whole wall-clock span of the run, sleeps included.
+    executionTimeout: '168h',
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        yield exports.sendWelcomeEmail.run(input);
+        yield ctx.sleepFor('72h');
+        return exports.sendFollowupEmail.run(input);
+    }),
+});
+// !!
+function invoke(input) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // > Hatchet task invocation
+        const run = yield exports.processOrder.runNoWait(input);
+        // It may be helpful to store this run id somewhere durable.
+        const runId = yield run.getWorkflowRunId();
+        const result = yield run.output;
+        // !!
+        return { runId, result };
+    });
+}
+// > Hatchet retries and timeouts
+exports.chargeOrderWithRetries = exports.hatchet.task({
+    name: 'charge-order-with-retries',
+    retries: 10,
+    backoff: {
+        // Factor to increase the wait time between retries.
+        factor: 2,
+        // Maximum number of seconds to wait between retries.
+        maxSeconds: 10,
+    },
+    executionTimeout: '30s',
+    scheduleTimeout: '10m',
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        const amountCents = yield payments.charge(input.orderId);
+        return { charged: amountCents > 0, amountCents };
+    }),
+});
+// !!
+exports.orderFollowUp = exports.hatchet.durableTask({
+    name: 'OrderFollowUp',
+    executionTimeout: '48h',
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        // > Hatchet durable sleep
+        yield ctx.sleepFor('24h');
+        // !!
+        return { sent: yield emails.send(`${input.orderId}@example.com`, 'order-followup') };
+    }),
+});
+function grantApproval(input) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // > Hatchet event push
+        yield exports.hatchet.events.push('approval:granted', {
+            correlationId: input.correlationId,
+        });
+        // !!
+    });
+}
+// > Hatchet durable event wait
+exports.approvalFlow = exports.hatchet.durableTask({
+    name: 'ApprovalFlow',
+    executionTimeout: '10m',
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        // The expression is compiled as CEL, so correlate on an id that cannot contain a quote.
+        yield ctx.waitForEvent('approval:granted', `input.correlationId == '${input.correlationId}'`);
+        return exports.fulfillOrder.run(input);
+    }),
+});
+exports.processItem = exports.hatchet.task({
+    name: 'process-item',
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        return ({
+            packed: yield warehouse.pack(input.item),
+        });
+    }),
+});
+// > Hatchet fan out children
+exports.packOrder = exports.hatchet.durableTask({
+    name: 'PackOrder',
+    executionTimeout: '30m',
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        const results = yield Promise.all(input.items.map((item) => exports.processItem.run({ item })));
+        return { packed: results.filter((result) => result.packed).length };
+    }),
+});
+// > Hatchet cron declaration
+exports.weeklyReport = exports.hatchet.workflow({
+    name: 'weekly-report',
+    on: {
+        cron: '0 9 * * 1',
+    },
+});
+exports.weeklyReport.task({
+    name: 'generate',
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        return { rows: yield reports.build(input.kind) };
+    }),
+});
+// !!
+function schedule() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // > Hatchet runtime schedules
+        // A recurring schedule, created at runtime.
+        yield exports.hatchet.crons.create('weekly-report', {
+            name: 'weekly-report-acme',
+            expression: '0 9 * * 1',
+            input: { kind: 'weekly' },
+        });
+        // A one-shot future run.
+        yield exports.hatchet.schedules.create('weekly-report', {
+            triggerAt: new Date(Date.now() + 24 * 60 * 60 * 1000),
+            input: { kind: 'weekly' },
+        });
+        // !!
+    });
+}
+// > Hatchet concurrency and rate limits
+const v1_2 = require("../..");
+// One in-flight run per customer, newest cancels the oldest.
+exports.syncCustomer = exports.hatchet.workflow({
+    name: 'SyncCustomer',
+    concurrency: {
+        expression: 'input.customerId',
+        maxRuns: 1,
+        limitStrategy: v1_2.ConcurrencyLimitStrategy.CANCEL_IN_PROGRESS,
+    },
+});
+exports.syncCustomer.task({
+    name: 'sync',
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        return { synced: yield crm.sync(input.customerId) };
+    }),
+});
+// A global budget shared by every worker, not per-process.
+exports.callModel = exports.hatchet.task({
+    name: 'call-model',
+    rateLimits: [
+        {
+            staticKey: 'openai',
+            units: 1,
+        },
+    ],
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        return { completion: yield models.complete(input.prompt) };
+    }),
+});
+// > Hatchet DAG workflow
+exports.orderWorkflow = exports.hatchet.workflow({
+    name: 'ProcessOrderDag',
+});
+const validate = exports.orderWorkflow.task({
+    name: 'validate',
+    executionTimeout: '30s',
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        return { valid: yield warehouse.reserve(input.orderId) };
+    }),
+});
+const charge = exports.orderWorkflow.task({
+    name: 'charge',
+    parents: [validate],
+    executionTimeout: '30s',
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const validated = yield ctx.parentOutput(validate);
+        if (!validated.valid) {
+            return { charged: false, amountCents: 0 };
+        }
+        const amountCents = yield payments.charge(input.orderId);
+        return { charged: true, amountCents };
+    }),
+});
+exports.orderWorkflow.task({
+    name: 'fulfill',
+    parents: [charge],
+    executionTimeout: '30s',
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const charged = yield ctx.parentOutput(charge);
+        if (!charged.charged) {
+            return { fulfilled: false, shipmentId: '' };
+        }
+        return { fulfilled: true, shipmentId: yield warehouse.ship(input.orderId) };
+    }),
+});
+// !!

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.28.2";
+export declare const HATCHET_VERSION = "1.29.0";

package/version.js

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