@hatchet-dev/typescript-sdk 1.38.0 → 1.39.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, V1StreamPayloadRef, V1TaskEventList, V1TaskPointMetrics, V1TaskRunMetrics, V1TaskStatus, V1TaskSummary, V1TaskSummaryList, V1TaskTimingList, V1TriggerWorkflowRunRequest, V1UpdateFilterRequest, V1UpdateWebhookRequest, V1Webhook, V1WebhookList, V1WebhookResponse, V1WebhookSourceName, V1WorkflowRunCount, 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, V1CreateServerlessEndpointRequest, V1CreateWebhookRequest, V1DagChildren, V1DurableEventLogList, V1Event, V1EventList, V1Filter, V1FilterList, V1LogLineLevel, V1LogLineList, V1LogLineOrderByDirection, V1LogsPointMetrics, V1ReplayTaskRequest, V1ReplayedTasks, V1RestoreTaskResponse, V1RunningFilter, V1ServerlessEndpoint, V1ServerlessEndpointList, V1StreamPayloadRef, V1TaskEventList, V1TaskPointMetrics, V1TaskRunMetrics, V1TaskStatus, V1TaskSummary, V1TaskSummaryList, V1TaskTimingList, V1TriggerWorkflowRunRequest, V1UpdateFilterRequest, V1UpdateServerlessEndpointRequest, V1UpdateWebhookRequest, V1Webhook, V1WebhookList, V1WebhookResponse, V1WebhookSourceName, V1WorkflowRunCount, 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> {
     /**
@@ -777,6 +777,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 the serverless endpoints of a tenant.
+     *
+     * @tags Serverless
+     * @name V1ServerlessEndpointList
+     * @summary List serverless endpoints
+     * @request GET:/api/v1/stable/tenants/{tenant}/serverless/endpoints
+     * @secure
+     */
+    v1ServerlessEndpointList: (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<V1ServerlessEndpointList, any, {}>>;
+    /**
+     * @description Create a serverless endpoint
+     *
+     * @tags Serverless
+     * @name V1ServerlessEndpointCreate
+     * @summary Create a serverless endpoint
+     * @request POST:/api/v1/stable/tenants/{tenant}/serverless/endpoints
+     * @secure
+     */
+    v1ServerlessEndpointCreate: (tenant: string, data: V1CreateServerlessEndpointRequest, params?: RequestParams) => Promise<import("axios").AxiosResponse<V1ServerlessEndpoint, any, {}>>;
+    /**
+     * @description Get a serverless endpoint by its id
+     *
+     * @tags Serverless
+     * @name V1ServerlessEndpointGet
+     * @summary Get a serverless endpoint
+     * @request GET:/api/v1/stable/serverless/endpoints/{v1-serverless-endpoint}
+     * @secure
+     */
+    v1ServerlessEndpointGet: (v1ServerlessEndpoint: string, params?: RequestParams) => Promise<import("axios").AxiosResponse<V1ServerlessEndpoint, any, {}>>;
+    /**
+     * @description Update a serverless endpoint
+     *
+     * @tags Serverless
+     * @name V1ServerlessEndpointUpdate
+     * @summary Update a serverless endpoint
+     * @request PATCH:/api/v1/stable/serverless/endpoints/{v1-serverless-endpoint}
+     * @secure
+     */
+    v1ServerlessEndpointUpdate: (v1ServerlessEndpoint: string, data: V1UpdateServerlessEndpointRequest, params?: RequestParams) => Promise<import("axios").AxiosResponse<V1ServerlessEndpoint, any, {}>>;
+    /**
+     * @description Delete a serverless endpoint
+     *
+     * @tags Serverless
+     * @name V1ServerlessEndpointDelete
+     * @summary Delete a serverless endpoint
+     * @request DELETE:/api/v1/stable/serverless/endpoints/{v1-serverless-endpoint}
+     * @secure
+     */
+    v1ServerlessEndpointDelete: (v1ServerlessEndpoint: string, params?: RequestParams) => Promise<import("axios").AxiosResponse<V1ServerlessEndpoint, any, {}>>;
     /**
      * @description Evaluate a CEL expression against provided input data.
      *

package/clients/rest/generated/Api.js

@@ -405,6 +405,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 the serverless endpoints of a tenant.
+         *
+         * @tags Serverless
+         * @name V1ServerlessEndpointList
+         * @summary List serverless endpoints
+         * @request GET:/api/v1/stable/tenants/{tenant}/serverless/endpoints
+         * @secure
+         */
+        this.v1ServerlessEndpointList = (tenant, query, params = {}) => this.request(Object.assign({ path: `/api/v1/stable/tenants/${tenant}/serverless/endpoints`, method: 'GET', query: query, secure: true, format: 'json' }, params));
+        /**
+         * @description Create a serverless endpoint
+         *
+         * @tags Serverless
+         * @name V1ServerlessEndpointCreate
+         * @summary Create a serverless endpoint
+         * @request POST:/api/v1/stable/tenants/{tenant}/serverless/endpoints
+         * @secure
+         */
+        this.v1ServerlessEndpointCreate = (tenant, data, params = {}) => this.request(Object.assign({ path: `/api/v1/stable/tenants/${tenant}/serverless/endpoints`, method: 'POST', body: data, secure: true, type: http_client_1.ContentType.Json, format: 'json' }, params));
+        /**
+         * @description Get a serverless endpoint by its id
+         *
+         * @tags Serverless
+         * @name V1ServerlessEndpointGet
+         * @summary Get a serverless endpoint
+         * @request GET:/api/v1/stable/serverless/endpoints/{v1-serverless-endpoint}
+         * @secure
+         */
+        this.v1ServerlessEndpointGet = (v1ServerlessEndpoint, params = {}) => this.request(Object.assign({ path: `/api/v1/stable/serverless/endpoints/${v1ServerlessEndpoint}`, method: 'GET', secure: true, format: 'json' }, params));
+        /**
+         * @description Update a serverless endpoint
+         *
+         * @tags Serverless
+         * @name V1ServerlessEndpointUpdate
+         * @summary Update a serverless endpoint
+         * @request PATCH:/api/v1/stable/serverless/endpoints/{v1-serverless-endpoint}
+         * @secure
+         */
+        this.v1ServerlessEndpointUpdate = (v1ServerlessEndpoint, data, params = {}) => this.request(Object.assign({ path: `/api/v1/stable/serverless/endpoints/${v1ServerlessEndpoint}`, method: 'PATCH', body: data, secure: true, type: http_client_1.ContentType.Json, format: 'json' }, params));
+        /**
+         * @description Delete a serverless endpoint
+         *
+         * @tags Serverless
+         * @name V1ServerlessEndpointDelete
+         * @summary Delete a serverless endpoint
+         * @request DELETE:/api/v1/stable/serverless/endpoints/{v1-serverless-endpoint}
+         * @secure
+         */
+        this.v1ServerlessEndpointDelete = (v1ServerlessEndpoint, params = {}) => this.request(Object.assign({ path: `/api/v1/stable/serverless/endpoints/${v1ServerlessEndpoint}`, method: 'DELETE', secure: true, format: 'json' }, params));
         /**
          * @description Evaluate a CEL expression against provided input data.
          *

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

@@ -191,6 +191,11 @@ export declare enum V1CELDebugResponseStatus {
     SUCCESS = "SUCCESS",
     ERROR = "ERROR"
 }
+/** The kind of serverless endpoint. GENERIC_HTTP is any HTTPS endpoint that implements the serverless endpoint contract; CLOUDFLARE_WORKERS applies the Cloudflare Workers runtime constraints on top of it. */
+export declare enum V1ServerlessEndpointKind {
+    GENERIC_HTTP = "GENERIC_HTTP",
+    CLOUDFLARE_WORKERS = "CLOUDFLARE_WORKERS"
+}
 export declare enum V1WebhookHMACEncoding {
     HEX = "HEX",
     BASE64 = "BASE64",
@@ -1129,6 +1134,130 @@ export interface V1UpdateWebhookRequest {
     /** Whether to return the triggered event as the response payload when this webhook is triggered */
     returnEventAsResponsePayload?: boolean;
 }
+/** The health of the endpoint as last observed by the serverless operator. Written on state transitions only, so changedAt is the time the endpoint last flipped between healthy and unhealthy. */
+export interface V1ServerlessEndpointStatus {
+    /** Whether the last healthcheck succeeded. Absent until the operator has polled the endpoint at least once. */
+    healthy?: boolean;
+    /** The error from the last failed healthcheck, if the endpoint is unhealthy. */
+    error?: string;
+    /**
+     * When the healthy flag last changed.
+     * @format date-time
+     */
+    changedAt?: string;
+    /** The action ids the operator registered for this endpoint from its last healthcheck, as the endpoint declared them. Several endpoints of a tenant may register the same action; each then serves it. */
+    registeredActions: string[];
+}
+export interface V1ServerlessEndpoint {
+    metadata: APIResourceMeta;
+    /**
+     * The ID of the tenant that owns this endpoint.
+     * @format uuid
+     */
+    tenantId: string;
+    /** The name of the endpoint. Unique within the tenant. */
+    name: string;
+    /** The kind of serverless endpoint. GENERIC_HTTP is any HTTPS endpoint that implements the serverless endpoint contract; CLOUDFLARE_WORKERS applies the Cloudflare Workers runtime constraints on top of it. */
+    kind: V1ServerlessEndpointKind;
+    /** The HTTPS URL (port 443) polled periodically to discover the workflows this endpoint serves. */
+    healthcheckUrl: string;
+    /** The HTTPS URL (port 443) that assigned tasks are delivered to. */
+    triggerUrl: string;
+    /**
+     * The per-request timeout backstop for trigger requests, in seconds.
+     * @format int32
+     */
+    requestTimeoutSeconds: number;
+    /**
+     * How often the healthcheck URL is polled, in seconds.
+     * @format int32
+     */
+    pollIntervalSeconds: number;
+    /**
+     * How long a trigger request may block waiting for a durable result before the operator falls back to the websocket durable protocol, in milliseconds.
+     * @format int32
+     */
+    inlineWaitBudgetMs: number;
+    /** Worker labels applied to the connection-backed worker the operator creates for this endpoint. */
+    labels: Record<string, any>;
+    /** Whether the operator polls and dispatches to this endpoint. */
+    enabled: boolean;
+    /** The health of the endpoint as last observed by the serverless operator. Written on state transitions only, so changedAt is the time the endpoint last flipped between healthy and unhealthy. */
+    status: V1ServerlessEndpointStatus;
+}
+export interface V1ServerlessEndpointList {
+    pagination?: PaginationResponse;
+    rows?: V1ServerlessEndpoint[];
+}
+export interface V1CreateServerlessEndpointRequest {
+    /** The name of the endpoint. Unique within the tenant. */
+    name: string;
+    /** The kind of serverless endpoint. GENERIC_HTTP is any HTTPS endpoint that implements the serverless endpoint contract; CLOUDFLARE_WORKERS applies the Cloudflare Workers runtime constraints on top of it. */
+    kind?: V1ServerlessEndpointKind;
+    /** The HTTPS URL (port 443) polled periodically to discover the workflows this endpoint serves. */
+    healthcheckUrl: string;
+    /** The HTTPS URL (port 443) that assigned tasks are delivered to. */
+    triggerUrl: string;
+    /**
+     * The secret used to HMAC-sign requests delivered to the endpoint. At least 32 characters. Write-only: it is stored encrypted and never returned in responses.
+     * @minLength 32
+     */
+    signingSecret: string;
+    /**
+     * The per-request timeout backstop for trigger requests, in seconds. Defaults to 60.
+     * @format int32
+     */
+    requestTimeoutSeconds?: number;
+    /**
+     * How often the healthcheck URL is polled, in seconds. Defaults to 30.
+     * @format int32
+     */
+    pollIntervalSeconds?: number;
+    /**
+     * The inline wait budget for durable results, in milliseconds. Defaults to 5000.
+     * @format int32
+     */
+    inlineWaitBudgetMs?: number;
+    /** Worker labels applied to the worker the operator creates for this endpoint. */
+    labels?: Record<string, any>;
+    /** Whether the operator polls and dispatches to this endpoint. Defaults to true. */
+    enabled?: boolean;
+}
+/** Fields to update on a serverless endpoint. Omitted fields are left unchanged. */
+export interface V1UpdateServerlessEndpointRequest {
+    /** The name of the endpoint. Unique within the tenant. */
+    name?: string;
+    /** The kind of serverless endpoint. GENERIC_HTTP is any HTTPS endpoint that implements the serverless endpoint contract; CLOUDFLARE_WORKERS applies the Cloudflare Workers runtime constraints on top of it. */
+    kind?: V1ServerlessEndpointKind;
+    /** The HTTPS URL (port 443) polled periodically to discover the workflows this endpoint serves. */
+    healthcheckUrl?: string;
+    /** The HTTPS URL (port 443) that assigned tasks are delivered to. */
+    triggerUrl?: string;
+    /**
+     * A new secret used to HMAC-sign requests delivered to the endpoint. At least 32 characters. Provide a value to rotate the secret; it is never returned in responses.
+     * @minLength 32
+     */
+    signingSecret?: string;
+    /**
+     * The per-request timeout backstop for trigger requests, in seconds.
+     * @format int32
+     */
+    requestTimeoutSeconds?: number;
+    /**
+     * How often the healthcheck URL is polled, in seconds.
+     * @format int32
+     */
+    pollIntervalSeconds?: number;
+    /**
+     * The inline wait budget for durable results, in milliseconds.
+     * @format int32
+     */
+    inlineWaitBudgetMs?: number;
+    /** Worker labels applied to the worker the operator creates for this endpoint. Replaces the existing labels. */
+    labels?: Record<string, any>;
+    /** Whether the operator polls and dispatches to this endpoint. */
+    enabled?: boolean;
+}
 export interface V1CELDebugRequest {
     /** The CEL expression to evaluate */
     expression: string;
@@ -1661,6 +1790,8 @@ export interface Workflow {
     jobs?: Job[];
     /** The tenant id of the workflow. */
     tenantId: string;
+    /** The event and cron triggers declared on the latest workflow version. */
+    triggers?: WorkflowTriggers;
 }
 export interface WorkflowVersionMeta {
     metadata: APIResourceMeta;
@@ -1704,6 +1835,21 @@ export interface Job {
     /** The timeout of the job. */
     timeout?: string;
 }
+export interface WorkflowTriggerEventRef {
+    parent_id?: string;
+    event_key?: string;
+}
+export interface WorkflowTriggerCronRef {
+    parent_id?: string;
+    cron?: string;
+}
+export interface WorkflowTriggers {
+    metadata?: APIResourceMeta;
+    workflow_version_id?: string;
+    tenant_id?: string;
+    events?: WorkflowTriggerEventRef[];
+    crons?: WorkflowTriggerCronRef[];
+}
 export interface WorkflowList {
     metadata?: APIResourceMeta;
     rows?: Workflow[];
@@ -1904,21 +2050,6 @@ export interface WorkflowConcurrency {
     /** An action which gets the concurrency group for the WorkflowRun. */
     getConcurrencyGroup: string;
 }
-export interface WorkflowTriggerEventRef {
-    parent_id?: string;
-    event_key?: string;
-}
-export interface WorkflowTriggerCronRef {
-    parent_id?: string;
-    cron?: string;
-}
-export interface WorkflowTriggers {
-    metadata?: APIResourceMeta;
-    workflow_version_id?: string;
-    tenant_id?: string;
-    events?: WorkflowTriggerEventRef[];
-    crons?: WorkflowTriggerCronRef[];
-}
 export interface ConcurrencySetting {
     /**
      * The maximum number of concurrent workflow runs.

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

@@ -11,7 +11,8 @@
  * ---------------------------------------------------------------
  */
 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.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;
+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.V1ServerlessEndpointKind = 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;
+exports.V1TaskStatus = void 0;
 var V1TaskRunStatus;
 (function (V1TaskRunStatus) {
     V1TaskRunStatus["PENDING"] = "PENDING";
@@ -238,6 +239,12 @@ var V1CELDebugResponseStatus;
     V1CELDebugResponseStatus["SUCCESS"] = "SUCCESS";
     V1CELDebugResponseStatus["ERROR"] = "ERROR";
 })(V1CELDebugResponseStatus || (exports.V1CELDebugResponseStatus = V1CELDebugResponseStatus = {}));
+/** The kind of serverless endpoint. GENERIC_HTTP is any HTTPS endpoint that implements the serverless endpoint contract; CLOUDFLARE_WORKERS applies the Cloudflare Workers runtime constraints on top of it. */
+var V1ServerlessEndpointKind;
+(function (V1ServerlessEndpointKind) {
+    V1ServerlessEndpointKind["GENERIC_HTTP"] = "GENERIC_HTTP";
+    V1ServerlessEndpointKind["CLOUDFLARE_WORKERS"] = "CLOUDFLARE_WORKERS";
+})(V1ServerlessEndpointKind || (exports.V1ServerlessEndpointKind = V1ServerlessEndpointKind = {}));
 var V1WebhookHMACEncoding;
 (function (V1WebhookHMACEncoding) {
     V1WebhookHMACEncoding["HEX"] = "HEX";

package/clients/streams/rpc.d.ts

@@ -0,0 +1,8 @@
+import { V1StreamsClient } from '../../protoc/v1/streams';
+import type { Transport } from '../transport/transport';
+/**
+ * The v1 `V1Streams` client, every RPC of the generated `V1StreamsClient` interface, served
+ * by a Connect client on the given transport. `Subscribe` is a server stream, which the unary
+ * transport does not serve: calling it throws.
+ */
+export declare function createV1StreamsRpc(transport: Transport): V1StreamsClient;

package/clients/streams/rpc.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createV1StreamsRpc = createV1StreamsRpc;
+const streams_1 = require("../../protoc/v1/streams");
+const streams_pb_1 = require("../../protoc-es/v1/streams_pb");
+const ts_proto_client_1 = require("../transport/ts-proto-client");
+/**
+ * The v1 `V1Streams` client, every RPC of the generated `V1StreamsClient` interface, served
+ * by a Connect client on the given transport. `Subscribe` is a server stream, which the unary
+ * transport does not serve: calling it throws.
+ */
+function createV1StreamsRpc(transport) {
+    return (0, ts_proto_client_1.createTsProtoClient)(streams_1.V1StreamsDefinition, streams_pb_1.V1Streams, transport);
+}

package/clients/transport/fetch-transport.js

@@ -82,7 +82,24 @@ function createFetchTransport(options) {
         baseUrl: resolveServerUrl(options),
         useBinaryFormat: true,
         interceptors: [(0, transport_1.createAuthInterceptor)(options.token)],
-        fetch: limitMessageSizes(send, limits),
+        fetch: limitMessageSizes(withoutRedirects(send), limits),
+    });
+}
+/**
+ * Wraps a `fetch` so a redirect fails the call instead of being followed. connect-web asks
+ * for this with `redirect: 'error'`, which Cloudflare Workers reject outright ("Invalid
+ * redirect value"), so the request goes out with `redirect: 'manual'` and a redirect
+ * response (a 3xx status, or the opaque redirect a browser hands back) is turned into the
+ * error connect-web would have raised. The engine never redirects; one means `serverUrl`
+ * points at something in front of it.
+ */
+function withoutRedirects(send) {
+    return (input, init) => __awaiter(this, void 0, void 0, function* () {
+        const response = yield send(input, Object.assign(Object.assign({}, init), { redirect: 'manual' }));
+        if (response.type === 'opaqueredirect' || (response.status >= 300 && response.status < 400)) {
+            throw new connect_1.ConnectError(`the server answered with a redirect (${response.status || 'opaque'}); serverUrl must point at the engine itself`, connect_1.Code.Unavailable);
+        }
+        return response;
     });
 }
 /**

package/core/client.d.ts

@@ -55,11 +55,12 @@ export declare class HatchetCore {
     readonly rateLimits: RateLimitsClient;
     /** Writes task run log lines. */
     readonly logs: LogsClient;
-    /** Publishes task run stream chunks. */
+    /** Publishes task run stream chunks and durable stream topics. */
     readonly streams: StreamsClient;
     private readonly workflowsRpc;
     private readonly adminRpc;
     private readonly eventsRpc;
+    private readonly streamsRpc;
     constructor(config: CoreClientConfig);
     /** The same as `new HatchetCore(config)`, mirroring the Node client's `init`. */
     static init(config: CoreClientConfig): HatchetCore;

package/core/client.js

@@ -20,6 +20,7 @@ const fetch_transport_1 = require("../clients/transport/fetch-transport");
 const rpc_1 = require("../clients/admin/rpc");
 const trigger_request_1 = require("../clients/admin/trigger-request");
 const rpc_2 = require("../clients/event/rpc");
+const rpc_3 = require("../clients/streams/rpc");
 const workflows_1 = require("../protoc/workflows");
 const token_1 = require("../util/config-loader/token");
 const batch_1 = require("../util/batch");
@@ -81,13 +82,14 @@ class HatchetCore {
         this.workflowsRpc = (0, rpc_1.createWorkflowsRpc)(this.transport);
         this.adminRpc = (0, rpc_1.createV1AdminRpc)(this.transport);
         this.eventsRpc = (0, rpc_2.createEventsRpc)(this.transport);
+        this.streamsRpc = (0, rpc_3.createV1StreamsRpc)(this.transport);
         const shared = { logger: this.logger, namespace, retrier: config.retrier };
         this.events = new events_1.EventsClient(Object.assign({ rpc: this.eventsRpc }, shared));
         this.runs = new runs_1.RunsClient(this.adminRpc);
         this.workflows = new workflows_2.WorkflowsClient(Object.assign({ rpc: this.adminRpc }, shared));
         this.rateLimits = new rate_limits_1.RateLimitsClient(Object.assign({ rpc: this.workflowsRpc }, shared));
         this.logs = new logs_1.LogsClient(this.eventsRpc);
-        this.streams = new streams_1.StreamsClient(this.eventsRpc);
+        this.streams = new streams_1.StreamsClient({ events: this.eventsRpc, streams: this.streamsRpc });
     }
     /** The same as `new HatchetCore(config)`, mirroring the Node client's `init`. */
     static init(config) {

package/core/features/streams.d.ts

@@ -1,11 +1,76 @@
 import type { EventsServiceClient, PutStreamEventResponse } from '../../protoc/events/events';
-/** Publishes stream chunks from a task run, the way `ctx.putStream` does from a worker. */
+import type { V1StreamsClient } from '../../protoc/v1/streams';
+import type { StreamCallOptions, StreamTopicMetadata } from '../types';
+/**
+ * The largest payload one `publish` carries: the engine's limit for a payload sent inline
+ * (`MaxStreamMessagePayloadBytes`). The Node client uploads larger payloads over its REST
+ * client first; this client has none, so it rejects them.
+ */
+export declare const MAX_STREAM_MESSAGE_BYTES: number;
+export interface StreamsClientDeps {
+    events: EventsServiceClient;
+    streams: V1StreamsClient;
+}
+/**
+ * How many (namespace, topic) producers the client remembers. A topic past the cap starts
+ * over with a new producer id, which the engine orders after the old one, so correctness
+ * does not depend on the cap; it only bounds memory for clients that publish to many
+ * short-lived topics.
+ */
+export declare const MAX_TRACKED_TOPICS = 1024;
+/**
+ * Task run streams and durable stream topics.
+ *
+ * `put` publishes a chunk on a task run's stream, the way `ctx.putStream` does from a worker.
+ * `publish`, `reset` and `topicMetadata` are the Node client's durable topic calls
+ * (`hatchet.streams`), with the same names and options. `events()` is not here: it is a
+ * server stream, which the unary transport does not carry. Read a topic with the Node client
+ * (`hatchet.streams.events(topic)`), or from a serverless task over the operator socket once
+ * the operator relays the subscription.
+ */
 export declare class StreamsClient {
-    private readonly rpc;
-    constructor(rpc: EventsServiceClient);
+    /** Per (namespace, topic); the sequence number only advances after a publish succeeds. */
+    private readonly producers;
+    /**
+     * Serializes publishes per (namespace, topic) so two never share a sequence number. The
+     * stored promise always resolves, so one failure does not block later calls.
+     */
+    private readonly publishChains;
+    private readonly events;
+    private readonly streams;
+    /**
+     * Takes the events and durable streams services, or only the events service, which
+     * serves `put` and leaves the durable stream calls unavailable.
+     */
+    constructor(deps: StreamsClientDeps | EventsServiceClient);
+    private durable;
     /**
      * Publishes one chunk on a task run's stream. `index` orders chunks that are published
      * concurrently. Resolves once the engine has the chunk.
      */
     put(taskRunExternalId: string, data: string | Uint8Array, index?: number): Promise<PutStreamEventResponse>;
+    /**
+     * Publishes a message to a durable topic and resolves once it is stored. A client's
+     * messages to a topic are delivered in the order `publish` was called. A payload over
+     * `MAX_STREAM_MESSAGE_BYTES` rejects with a `HatchetError` before anything is sent.
+     * @param topic - the topic to publish to
+     * @param message - the message payload
+     * @param options - optional namespace override and abort signal
+     */
+    publish(topic: string, message: Uint8Array | string, options?: StreamCallOptions): Promise<void>;
+    /**
+     * Describes a topic's retained messages. Rejects with a `ConnectError` of code `NotFound`
+     * for a topic nothing was published to.
+     * @param topic - the topic to describe
+     * @param options - optional namespace override and abort signal
+     */
+    topicMetadata(topic: string, options?: Pick<StreamCallOptions, 'namespace' | 'signal'>): Promise<StreamTopicMetadata>;
+    /**
+     * Makes `events()` calls without a cursor start after the topic's latest message. Readers
+     * already iterating, and any call with a cursor, are unaffected.
+     * @param topic - the topic to reset
+     * @param options - optional namespace override and abort signal
+     */
+    reset(topic: string, options?: Pick<StreamCallOptions, 'namespace' | 'signal'>): Promise<void>;
+    private publishOrdered;
 }

package/core/features/streams.js

@@ -1,10 +1,82 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StreamsClient = void 0;
-/** Publishes stream chunks from a task run, the way `ctx.putStream` does from a worker. */
+exports.StreamsClient = exports.MAX_TRACKED_TOPICS = exports.MAX_STREAM_MESSAGE_BYTES = void 0;
+const connect_1 = require("@connectrpc/connect");
+const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
+const abort_error_1 = require("../../util/abort-error");
+/**
+ * The largest payload one `publish` carries: the engine's limit for a payload sent inline
+ * (`MaxStreamMessagePayloadBytes`). The Node client uploads larger payloads over its REST
+ * client first; this client has none, so it rejects them.
+ */
+exports.MAX_STREAM_MESSAGE_BYTES = 4 * 1024 * 1024 - 5 * 1024;
+/**
+ * How many (namespace, topic) producers the client remembers. A topic past the cap starts
+ * over with a new producer id, which the engine orders after the old one, so correctness
+ * does not depend on the cap; it only bounds memory for clients that publish to many
+ * short-lived topics.
+ */
+exports.MAX_TRACKED_TOPICS = 1024;
+function isEventsService(deps) {
+    return typeof deps.putStreamEvent === 'function';
+}
+/** The engine stored nothing, so the producer's sequence number is still unused. */
+function publishRejectedBeforeStoring(err) {
+    return (err instanceof connect_1.ConnectError &&
+        (err.code === connect_1.Code.InvalidArgument ||
+            err.code === connect_1.Code.ResourceExhausted ||
+            err.code === connect_1.Code.Unauthenticated ||
+            err.code === connect_1.Code.PermissionDenied));
+}
+/**
+ * Task run streams and durable stream topics.
+ *
+ * `put` publishes a chunk on a task run's stream, the way `ctx.putStream` does from a worker.
+ * `publish`, `reset` and `topicMetadata` are the Node client's durable topic calls
+ * (`hatchet.streams`), with the same names and options. `events()` is not here: it is a
+ * server stream, which the unary transport does not carry. Read a topic with the Node client
+ * (`hatchet.streams.events(topic)`), or from a serverless task over the operator socket once
+ * the operator relays the subscription.
+ */
 class StreamsClient {
-    constructor(rpc) {
-        this.rpc = rpc;
+    /**
+     * Takes the events and durable streams services, or only the events service, which
+     * serves `put` and leaves the durable stream calls unavailable.
+     */
+    constructor(deps) {
+        /** Per (namespace, topic); the sequence number only advances after a publish succeeds. */
+        this.producers = new Map();
+        /**
+         * Serializes publishes per (namespace, topic) so two never share a sequence number. The
+         * stored promise always resolves, so one failure does not block later calls.
+         */
+        this.publishChains = new Map();
+        if (isEventsService(deps)) {
+            this.events = deps;
+            this.streams = undefined;
+        }
+        else {
+            this.events = deps.events;
+            this.streams = deps.streams;
+        }
+    }
+    durable() {
+        if (!this.streams) {
+            throw new hatchet_error_1.default('durable streams are unavailable: this StreamsClient was built with the events service only; build it with { events, streams }');
+        }
+        return this.streams;
     }
     /**
      * Publishes one chunk on a task run's stream. `index` orders chunks that are published
@@ -12,12 +84,141 @@ class StreamsClient {
      */
     put(taskRunExternalId, data, index) {
         const message = typeof data === 'string' ? new TextEncoder().encode(data) : data;
-        return this.rpc.putStreamEvent({
+        return this.events.putStreamEvent({
             taskRunExternalId,
             createdAt: new Date(),
             message,
             eventIndex: index,
         });
     }
+    /**
+     * Publishes a message to a durable topic and resolves once it is stored. A client's
+     * messages to a topic are delivered in the order `publish` was called. A payload over
+     * `MAX_STREAM_MESSAGE_BYTES` rejects with a `HatchetError` before anything is sent.
+     * @param topic - the topic to publish to
+     * @param message - the message payload
+     * @param options - optional namespace override and abort signal
+     */
+    publish(topic, message, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const payload = typeof message === 'string' ? new TextEncoder().encode(message) : message;
+            const namespace = (_a = options === null || options === void 0 ? void 0 : options.namespace) !== null && _a !== void 0 ? _a : '';
+            const key = `${namespace}\0${topic}`;
+            if (payload.byteLength > exports.MAX_STREAM_MESSAGE_BYTES) {
+                throw new hatchet_error_1.default(`stream payload is ${payload.byteLength} bytes, over the ${exports.MAX_STREAM_MESSAGE_BYTES}-byte limit of one publish; publish it from the Node client, which uploads larger payloads`);
+            }
+            const signal = options === null || options === void 0 ? void 0 : options.signal;
+            const previous = (_b = this.publishChains.get(key)) !== null && _b !== void 0 ? _b : Promise.resolve();
+            const publishPromise = previous.then(() => {
+                // An abort while this publish waited behind earlier ones sends nothing.
+                if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                    throw new abort_error_1.AbortError();
+                }
+                return this.publishOrdered(key, namespace, topic, payload, signal);
+            });
+            const chain = publishPromise
+                .catch(() => { })
+                .then(() => {
+                // The topic's queue is idle once its last publish settled.
+                if (this.publishChains.get(key) === chain) {
+                    this.publishChains.delete(key);
+                }
+            });
+            this.publishChains.set(key, chain);
+            if (!signal) {
+                return publishPromise;
+            }
+            // The caller is released as soon as its signal aborts, while the queue keeps its order
+            // and the aborted publish is skipped when its turn comes.
+            return new Promise((resolve, reject) => {
+                const onAbort = () => reject(new abort_error_1.AbortError());
+                if (signal.aborted) {
+                    onAbort();
+                    return;
+                }
+                signal.addEventListener('abort', onAbort, { once: true });
+                publishPromise.then(resolve, reject).finally(() => {
+                    signal.removeEventListener('abort', onAbort);
+                });
+            });
+        });
+    }
+    /**
+     * Describes a topic's retained messages. Rejects with a `ConnectError` of code `NotFound`
+     * for a topic nothing was published to.
+     * @param topic - the topic to describe
+     * @param options - optional namespace override and abort signal
+     */
+    topicMetadata(topic, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const res = yield this.durable().getTopicMetadata({ namespace: (_a = options === null || options === void 0 ? void 0 : options.namespace) !== null && _a !== void 0 ? _a : '', topic }, { signal: options === null || options === void 0 ? void 0 : options.signal });
+            return {
+                namespace: res.namespace,
+                topic: res.topic,
+                tenantId: res.tenantId,
+                messageCount: res.messageCount,
+                latestCursor: res.latestCursor,
+                lastPublishedAt: res.lastPublishedAt,
+            };
+        });
+    }
+    /**
+     * Makes `events()` calls without a cursor start after the topic's latest message. Readers
+     * already iterating, and any call with a cursor, are unaffected.
+     * @param topic - the topic to reset
+     * @param options - optional namespace override and abort signal
+     */
+    reset(topic, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            yield this.durable().reset({ namespace: (_a = options === null || options === void 0 ? void 0 : options.namespace) !== null && _a !== void 0 ? _a : '', topic }, { signal: options === null || options === void 0 ? void 0 : options.signal });
+        });
+    }
+    publishOrdered(key_1, namespace_1, topic_1, payload_1, signal_1) {
+        return __awaiter(this, arguments, void 0, function* (key, namespace, topic, payload, signal, retryGap = true) {
+            const streams = this.durable();
+            let producer = this.producers.get(key);
+            if (producer) {
+                // re-inserting keeps the map in last-use order for the eviction below
+                this.producers.delete(key);
+            }
+            else {
+                producer = { producerId: crypto.randomUUID(), seq: 0 };
+            }
+            this.producers.set(key, producer);
+            while (this.producers.size > exports.MAX_TRACKED_TOPICS) {
+                const oldest = this.producers.keys().next().value;
+                if (oldest === undefined) {
+                    break;
+                }
+                this.producers.delete(oldest);
+            }
+            try {
+                yield streams.publish({
+                    namespace,
+                    topic,
+                    payload,
+                    producerId: producer.producerId,
+                    producerSeq: producer.seq,
+                }, { signal });
+            }
+            catch (err) {
+                // The message may still land, and a different payload under its sequence number
+                // would be dropped as a duplicate, so the next publish comes from a new producer.
+                if (!publishRejectedBeforeStoring(err)) {
+                    this.producers.set(key, { producerId: crypto.randomUUID(), seq: 0 });
+                }
+                // A gap stored nothing (the watermark passed cursor retention, say): resend as the
+                // new producer.
+                if (retryGap && err instanceof connect_1.ConnectError && err.code === connect_1.Code.FailedPrecondition) {
+                    return this.publishOrdered(key, namespace, topic, payload, signal, false);
+                }
+                throw err;
+            }
+            producer.seq += 1;
+        });
+    }
 }
 exports.StreamsClient = StreamsClient;

package/core/index.d.ts

@@ -1,7 +1,8 @@
 /**
  * The core entry point: the application client for runtimes without gRPC. It triggers runs,
- * pushes events, waits for results by polling and manages workflows over unary Connect calls
- * on a fetch transport, and it is configured from an explicit object only.
+ * pushes events, waits for results by polling, publishes to durable streams and manages
+ * workflows over unary Connect calls on a fetch transport, and it is configured from an
+ * explicit object only.
  *
  * Nothing exported here imports from Node. `scripts/check-edge-entry.mjs` bundles this module
  * for a browser-like target and fails the build if a Node builtin, `axios` or a gRPC package
@@ -24,14 +25,15 @@ export { WorkflowRunRef, INITIAL_POLL_INTERVAL_MS, MAX_POLL_INTERVAL_MS } from '
 export type { RunRefClient } from './run-ref';
 export { toRunDetail, parseTaskOutput, runStatusToJSON } from './run-detail';
 export { ConsoleLogger, consoleLogger } from './logger';
-export type { CallOptions, CancelRunOpts, CoreClientConfig, CreateRateLimitOpts, DesiredWorkerLabelOpt, EventWithMetadata, LogConstructor, PushEventOptions, ReplayRunOpts, ResultOptions, RunDetail, RunFilter, RunFilterBase, TaskRunDetail, TriggerRun, TriggerRunOptions, } from './types';
+export type { CallOptions, CancelRunOpts, CoreClientConfig, CreateRateLimitOpts, DesiredWorkerLabelOpt, EventWithMetadata, LogConstructor, PushEventOptions, ReplayRunOpts, ResultOptions, RunDetail, RunFilter, RunFilterBase, StreamCallOptions, StreamTopicMetadata, TaskRunDetail, TriggerRun, TriggerRunOptions, } from './types';
 export { EventsClient } from './features/events';
 export { RunsClient } from './features/runs';
 export { WorkflowsClient } from './features/workflows';
 export { RateLimitsClient } from './features/rate-limits';
 export { LogsClient, MAX_LOG_LINE_CHARS } from './features/logs';
 export type { PutLogOptions } from './features/logs';
-export { StreamsClient } from './features/streams';
+export { StreamsClient, MAX_STREAM_MESSAGE_BYTES } from './features/streams';
+export type { StreamsClientDeps } from './features/streams';
 export { createFetchTransport, limitMessageSizes, resolveServerUrl, type FetchTlsConfig, type FetchTransportOptions, type MessageSizeLimits, } from '../clients/transport/fetch-transport';
 export { createAuthInterceptor, DEFAULT_MAX_MESSAGE_BYTES, type Transport, } from '../clients/transport/transport';
 export { LogLevel } from '../clients/event/rpc';
@@ -40,7 +42,9 @@ export type { RunManyOpt, RunOpts } from '../v1/declaration';
 export { RateLimitDuration } from '../protoc/workflows/workflows';
 export { WorkerLabelComparator } from '../protoc/v1/shared/trigger';
 export { V1TaskStatus } from '../clients/rest/generated/data-contracts';
-export { default as HatchetError, getErrorMessage, toHatchetError, } from '../util/errors/hatchet-error';
+import HatchetError from '../util/errors/hatchet-error';
+export { HatchetError };
+export { getErrorMessage, toHatchetError } from '../util/errors/hatchet-error';
 export { IdempotencyCollisionError } from '../util/errors/idempotency-collision-error';
 export { BulkTriggerIdempotencyCollisionError } from '../util/errors/bulk-trigger-idempotency-collision-error';
 export { BulkTriggerPartialError } from '../util/errors/bulk-trigger-partial-error';

package/core/index.js

@@ -1,8 +1,9 @@
 "use strict";
 /**
  * The core entry point: the application client for runtimes without gRPC. It triggers runs,
- * pushes events, waits for results by polling and manages workflows over unary Connect calls
- * on a fetch transport, and it is configured from an explicit object only.
+ * pushes events, waits for results by polling, publishes to durable streams and manages
+ * workflows over unary Connect calls on a fetch transport, and it is configured from an
+ * explicit object only.
  *
  * Nothing exported here imports from Node. `scripts/check-edge-entry.mjs` bundles this module
  * for a browser-like target and fails the build if a Node builtin, `axios` or a gRPC package
@@ -21,7 +22,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAbortError = exports.AbortError = exports.BulkTriggerPartialError = exports.BulkTriggerIdempotencyCollisionError = exports.IdempotencyCollisionError = exports.toHatchetError = exports.getErrorMessage = exports.HatchetError = exports.V1TaskStatus = exports.WorkerLabelComparator = exports.RateLimitDuration = exports.Priority = exports.LogLevel = exports.DEFAULT_MAX_MESSAGE_BYTES = exports.createAuthInterceptor = exports.resolveServerUrl = exports.limitMessageSizes = exports.createFetchTransport = exports.StreamsClient = exports.MAX_LOG_LINE_CHARS = exports.LogsClient = exports.RateLimitsClient = exports.WorkflowsClient = exports.RunsClient = exports.EventsClient = exports.consoleLogger = exports.ConsoleLogger = exports.runStatusToJSON = exports.parseTaskOutput = exports.toRunDetail = exports.MAX_POLL_INTERVAL_MS = exports.INITIAL_POLL_INTERVAL_MS = exports.WorkflowRunRef = exports.Hatchet = exports.HatchetCore = exports.CORE_ENTRY_VERSION = void 0;
+exports.isAbortError = exports.AbortError = exports.BulkTriggerPartialError = exports.BulkTriggerIdempotencyCollisionError = exports.IdempotencyCollisionError = exports.toHatchetError = exports.getErrorMessage = exports.HatchetError = exports.V1TaskStatus = exports.WorkerLabelComparator = exports.RateLimitDuration = exports.Priority = exports.LogLevel = exports.DEFAULT_MAX_MESSAGE_BYTES = exports.createAuthInterceptor = exports.resolveServerUrl = exports.limitMessageSizes = exports.createFetchTransport = exports.MAX_STREAM_MESSAGE_BYTES = exports.StreamsClient = exports.MAX_LOG_LINE_CHARS = exports.LogsClient = exports.RateLimitsClient = exports.WorkflowsClient = exports.RunsClient = exports.EventsClient = exports.consoleLogger = exports.ConsoleLogger = exports.runStatusToJSON = exports.parseTaskOutput = exports.toRunDetail = exports.MAX_POLL_INTERVAL_MS = exports.INITIAL_POLL_INTERVAL_MS = exports.WorkflowRunRef = exports.Hatchet = exports.HatchetCore = exports.CORE_ENTRY_VERSION = void 0;
 /** Bumped whenever the surface exported from this entry changes incompatibly. */
 exports.CORE_ENTRY_VERSION = 1;
 var client_1 = require("./client");
@@ -52,6 +53,7 @@ Object.defineProperty(exports, "LogsClient", { enumerable: true, get: function (
 Object.defineProperty(exports, "MAX_LOG_LINE_CHARS", { enumerable: true, get: function () { return logs_1.MAX_LOG_LINE_CHARS; } });
 var streams_1 = require("./features/streams");
 Object.defineProperty(exports, "StreamsClient", { enumerable: true, get: function () { return streams_1.StreamsClient; } });
+Object.defineProperty(exports, "MAX_STREAM_MESSAGE_BYTES", { enumerable: true, get: function () { return streams_1.MAX_STREAM_MESSAGE_BYTES; } });
 // Transport
 var fetch_transport_1 = require("../clients/transport/fetch-transport");
 Object.defineProperty(exports, "createFetchTransport", { enumerable: true, get: function () { return fetch_transport_1.createFetchTransport; } });
@@ -71,10 +73,14 @@ var trigger_1 = require("../protoc/v1/shared/trigger");
 Object.defineProperty(exports, "WorkerLabelComparator", { enumerable: true, get: function () { return trigger_1.WorkerLabelComparator; } });
 var data_contracts_1 = require("../clients/rest/generated/data-contracts");
 Object.defineProperty(exports, "V1TaskStatus", { enumerable: true, get: function () { return data_contracts_1.V1TaskStatus; } });
-var hatchet_error_1 = require("../util/errors/hatchet-error");
-Object.defineProperty(exports, "HatchetError", { enumerable: true, get: function () { return __importDefault(hatchet_error_1).default; } });
-Object.defineProperty(exports, "getErrorMessage", { enumerable: true, get: function () { return hatchet_error_1.getErrorMessage; } });
-Object.defineProperty(exports, "toHatchetError", { enumerable: true, get: function () { return hatchet_error_1.toHatchetError; } });
+// HatchetError is imported and re-exported by name rather than as `default as`: tsc emits a
+// getter for the latter that Node's CommonJS export detection cannot see, which hides the name
+// from ESM importers of this entry.
+const hatchet_error_1 = __importDefault(require("../util/errors/hatchet-error"));
+exports.HatchetError = hatchet_error_1.default;
+var hatchet_error_2 = require("../util/errors/hatchet-error");
+Object.defineProperty(exports, "getErrorMessage", { enumerable: true, get: function () { return hatchet_error_2.getErrorMessage; } });
+Object.defineProperty(exports, "toHatchetError", { enumerable: true, get: function () { return hatchet_error_2.toHatchetError; } });
 var idempotency_collision_error_1 = require("../util/errors/idempotency-collision-error");
 Object.defineProperty(exports, "IdempotencyCollisionError", { enumerable: true, get: function () { return idempotency_collision_error_1.IdempotencyCollisionError; } });
 var bulk_trigger_idempotency_collision_error_1 = require("../util/errors/bulk-trigger-idempotency-collision-error");

package/core/types.d.ts

@@ -180,3 +180,23 @@ export interface ResultOptions {
     /** Rejects with an `AbortError` when the signal fires. */
     signal?: AbortSignal;
 }
+/** Per-call options of the durable stream calls; the same shape on the core and Node clients. */
+export type StreamCallOptions = {
+    /** The topic's namespace; the empty namespace when omitted. */
+    namespace?: string;
+    /** Resumes an `events()` iteration right after this message. */
+    cursor?: string;
+    /** Ends an `events()` iteration cleanly, without throwing; aborts a unary call. */
+    signal?: AbortSignal;
+};
+/** What a durable stream topic retains; counts and the latest message cover the tenant's retention. */
+export type StreamTopicMetadata = {
+    namespace: string;
+    topic: string;
+    tenantId: string;
+    messageCount: number;
+    /** Resumes `events()` after the newest retained message; undefined when none is retained. */
+    latestCursor?: string;
+    /** When the newest retained message was stored; undefined when none is retained. */
+    lastPublishedAt?: Date;
+};

package/dist/check-core-esm-exports.mjs

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+// Verifies that every export of the built core entry is visible to an ESM importer under Node:
+// the entry is CommonJS, and Node derives its named exports statically, so a re-export written
+// in a form that detection misses (a getter over a default import) vanishes for `import { X }`.
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { resolve } from 'node:path';
+
+const entry = resolve('dist/core/index.js');
+const cjs = createRequire(import.meta.url)(entry);
+const esm = await import(pathToFileURL(entry).href);
+const missing = Object.keys(cjs).filter((name) => name !== '__esModule' && !(name in esm));
+
+if (missing.length > 0) {
+  console.error(`core entry exports hidden from ESM importers: ${missing.join(', ')}`);
+  process.exit(1);
+}
+
+console.log(`core entry: ${Object.keys(cjs).length} exports visible to ESM importers`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "1.38.0",
+  "version": "1.39.0",
   "engines": {
     "node": ">=20"
   },
@@ -238,7 +238,7 @@
     "tsc:build": "pnpm run dump-version && tsc && resolve-tspaths",
     "test:unit": "jest --testMatch='**/*.test.ts'",
     "check:edge": "pnpm run tsc:build && node scripts/check-edge-entry.mjs",
-    "check:core": "pnpm run tsc:build && node scripts/check-edge-entry.mjs dist/core/index.js --forbid axios,nice-grpc,@grpc/grpc-js,@connectrpc/connect-node,long,protobufjs,yaml",
+    "check:core": "pnpm run tsc:build && node scripts/check-edge-entry.mjs dist/core/index.js --forbid axios,nice-grpc,@grpc/grpc-js,@connectrpc/connect-node,long,protobufjs,yaml && node scripts/check-core-esm-exports.mjs",
     "check:exports": "pnpm run tsc:build && node scripts/check-exports.mjs",
     "test:e2e": "jest --config jest.e2e.config.ts --silent --forceExit --runInBand",
     "test:unit:watch": "jest --testMatch='**/*.test.ts' --watch",

package/scripts/check-core-esm-exports.mjs

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+// Verifies that every export of the built core entry is visible to an ESM importer under Node:
+// the entry is CommonJS, and Node derives its named exports statically, so a re-export written
+// in a form that detection misses (a getter over a default import) vanishes for `import { X }`.
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { resolve } from 'node:path';
+
+const entry = resolve('dist/core/index.js');
+const cjs = createRequire(import.meta.url)(entry);
+const esm = await import(pathToFileURL(entry).href);
+const missing = Object.keys(cjs).filter((name) => name !== '__esModule' && !(name in esm));
+
+if (missing.length > 0) {
+  console.error(`core entry exports hidden from ESM importers: ${missing.join(', ')}`);
+  process.exit(1);
+}
+
+console.log(`core entry: ${Object.keys(cjs).length} exports visible to ESM importers`);

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

@@ -1,3 +1,4 @@
+import type { StreamCallOptions, StreamTopicMetadata } from '../../../core/types';
 import { HatchetClient } from '../client';
 export type StreamEvent = {
     /** the message payload */
@@ -7,23 +8,7 @@ export type StreamEvent = {
     /** when the message was stored */
     createdAt?: Date;
 };
-/** Covers only messages within the tenant's retention. */
-export type StreamTopicMetadata = {
-    namespace: string;
-    topic: string;
-    tenantId: string;
-    messageCount: number;
-    /** resumes events() after the newest retained message; undefined when none is retained */
-    latestCursor?: string;
-    /** when the newest retained message was stored; undefined when none is retained */
-    lastPublishedAt?: Date;
-};
-export type StreamCallOptions = {
-    namespace?: string;
-    cursor?: string;
-    /** ends an events() iteration cleanly, without throwing */
-    signal?: AbortSignal;
-};
+export type { StreamCallOptions, StreamTopicMetadata } from '../../../core/types';
 /**
  * StreamsClient publishes to and reads from durable topics. Unlike
  * `runs.subscribeToStream`, topics are stored, independent of any run, and

package/v1/examples/durable_eviction/graceful-worker.d.ts

@@ -0,0 +1 @@
+export declare const DURABLE_WAIT_MARKED = "[e2e] durable wait marked";

package/v1/examples/durable_eviction/graceful-worker.js

@@ -0,0 +1,49 @@
+"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.DURABLE_WAIT_MARKED = void 0;
+const hatchet_client_1 = require("../hatchet-client");
+const workflow_1 = require("./workflow");
+exports.DURABLE_WAIT_MARKED = '[e2e] durable wait marked';
+// Worker for the graceful termination e2e test. The test must not terminate
+// this worker before the SDK has recorded the run as waiting, and nothing
+// observable outside the process marks that moment: the engine writes the
+// WAIT_FOR entry before it acks, and the SDK only calls markWaiting once the
+// ack arrives. The eviction manager is created lazily on the worker's
+// internal state, so it is wrapped on assignment to print a line the test can
+// wait for.
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield hatchet_client_1.hatchet.worker('graceful-eviction-worker', {
+            workflows: [workflow_1.evictableSleepForGracefulTermination],
+        });
+        let manager;
+        Object.defineProperty(worker._internal, 'evictionManager', {
+            configurable: true,
+            enumerable: true,
+            get: () => manager,
+            set: (next) => {
+                manager = next;
+                if (!next)
+                    return;
+                const markWaiting = next.markWaiting.bind(next);
+                next.markWaiting = (key, waitKind, resourceId) => {
+                    markWaiting(key, waitKind, resourceId);
+                    console.log(`${exports.DURABLE_WAIT_MARKED} key=${key} kind=${waitKind} resource=${resourceId}`);
+                };
+            },
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.38.0";
+export declare const HATCHET_VERSION = "1.39.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.38.0';
+exports.HATCHET_VERSION = '1.39.0';