@hatchet-dev/typescript-sdk 1.34.0-alpha.2 → 1.34.0

package/README.md

@@ -49,6 +49,7 @@ TypeScript SDK reference (overview: https://docs.hatchet.run/reference/typescrip
 - Rate Limits: https://docs.hatchet.run/reference/typescript/feature-clients/ratelimits.md (guide: https://docs.hatchet.run/v1/rate-limits.md)
 - Runs: https://docs.hatchet.run/reference/typescript/feature-clients/runs.md (guide: https://docs.hatchet.run/v1/running-your-task.md)
 - Scheduled Runs: https://docs.hatchet.run/reference/typescript/feature-clients/schedules.md (guide: https://docs.hatchet.run/v1/scheduled-runs.md)
+- Streams: https://docs.hatchet.run/reference/typescript/feature-clients/streams.md
 - Tenant: https://docs.hatchet.run/reference/typescript/feature-clients/tenant.md
 - Webhooks: https://docs.hatchet.run/reference/typescript/feature-clients/webhooks.md (guide: https://docs.hatchet.run/v1/webhooks.md)
 - Workers: https://docs.hatchet.run/reference/typescript/feature-clients/workers.md (guide: https://docs.hatchet.run/v1/workers.md)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "1.34.0-alpha.2",
+  "version": "1.34.0",
   "engines": {
     "node": ">=20"
   },

package/protoc/v1/streams.d.ts

@@ -0,0 +1,79 @@
+import { BinaryReader, BinaryWriter } from '@bufbuild/protobuf/wire';
+import type { CallContext, CallOptions } from 'nice-grpc-common';
+export declare const protobufPackage = "v1";
+export interface PublishStreamMessageRequest {
+    namespace: string;
+    topic: string;
+    payload: Uint8Array;
+    producerId: string;
+    producerSeq: number;
+}
+export interface PublishStreamMessageResponse {
+}
+export interface SubscribeStreamRequest {
+    namespace: string;
+    topic: string;
+    cursor?: string | undefined;
+}
+export interface StreamMessage {
+    entries: StreamEntry[];
+    hangup: boolean;
+    cursor: string;
+}
+export interface StreamEntry {
+    payload: Uint8Array;
+    cursor: string;
+    createdAt: Date | undefined;
+}
+export declare const PublishStreamMessageRequest: MessageFns<PublishStreamMessageRequest>;
+export declare const PublishStreamMessageResponse: MessageFns<PublishStreamMessageResponse>;
+export declare const SubscribeStreamRequest: MessageFns<SubscribeStreamRequest>;
+export declare const StreamMessage: MessageFns<StreamMessage>;
+export declare const StreamEntry: MessageFns<StreamEntry>;
+export type V1StreamsDefinition = typeof V1StreamsDefinition;
+export declare const V1StreamsDefinition: {
+    readonly name: "V1Streams";
+    readonly fullName: "v1.V1Streams";
+    readonly methods: {
+        readonly publish: {
+            readonly name: "Publish";
+            readonly requestType: typeof PublishStreamMessageRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof PublishStreamMessageResponse;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly subscribe: {
+            readonly name: "Subscribe";
+            readonly requestType: typeof SubscribeStreamRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof StreamMessage;
+            readonly responseStream: true;
+            readonly options: {};
+        };
+    };
+};
+export interface V1StreamsServiceImplementation<CallContextExt = {}> {
+    publish(request: PublishStreamMessageRequest, context: CallContext & CallContextExt): Promise<DeepPartial<PublishStreamMessageResponse>>;
+    subscribe(request: SubscribeStreamRequest, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<StreamMessage>>;
+}
+export interface V1StreamsClient<CallOptionsExt = {}> {
+    publish(request: DeepPartial<PublishStreamMessageRequest>, options?: CallOptions & CallOptionsExt): Promise<PublishStreamMessageResponse>;
+    subscribe(request: DeepPartial<SubscribeStreamRequest>, options?: CallOptions & CallOptionsExt): AsyncIterable<StreamMessage>;
+}
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export type ServerStreamingMethodResult<Response> = {
+    [Symbol.asyncIterator](): AsyncIterator<Response, void>;
+};
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create(base?: DeepPartial<T>): T;
+    fromPartial(object: DeepPartial<T>): T;
+}
+export {};

package/protoc/v1/streams.js

@@ -0,0 +1,511 @@
+"use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.12.0
+//   protoc               v3.19.1
+// source: v1/streams.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.V1StreamsDefinition = exports.StreamEntry = exports.StreamMessage = exports.SubscribeStreamRequest = exports.PublishStreamMessageResponse = exports.PublishStreamMessageRequest = exports.protobufPackage = void 0;
+/* eslint-disable */
+const wire_1 = require("@bufbuild/protobuf/wire");
+const timestamp_1 = require("../google/protobuf/timestamp");
+exports.protobufPackage = 'v1';
+function createBasePublishStreamMessageRequest() {
+    return { namespace: '', topic: '', payload: new Uint8Array(0), producerId: '', producerSeq: 0 };
+}
+exports.PublishStreamMessageRequest = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.namespace !== '') {
+            writer.uint32(10).string(message.namespace);
+        }
+        if (message.topic !== '') {
+            writer.uint32(18).string(message.topic);
+        }
+        if (message.payload.length !== 0) {
+            writer.uint32(26).bytes(message.payload);
+        }
+        if (message.producerId !== '') {
+            writer.uint32(34).string(message.producerId);
+        }
+        if (message.producerSeq !== 0) {
+            writer.uint32(40).int64(message.producerSeq);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePublishStreamMessageRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.namespace = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.topic = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.payload = reader.bytes();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.producerId = reader.string();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 40) {
+                        break;
+                    }
+                    message.producerSeq = longToNumber(reader.int64());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            namespace: isSet(object.namespace) ? globalThis.String(object.namespace) : '',
+            topic: isSet(object.topic) ? globalThis.String(object.topic) : '',
+            payload: isSet(object.payload) ? bytesFromBase64(object.payload) : new Uint8Array(0),
+            producerId: isSet(object.producerId)
+                ? globalThis.String(object.producerId)
+                : isSet(object.producer_id)
+                    ? globalThis.String(object.producer_id)
+                    : '',
+            producerSeq: isSet(object.producerSeq)
+                ? globalThis.Number(object.producerSeq)
+                : isSet(object.producer_seq)
+                    ? globalThis.Number(object.producer_seq)
+                    : 0,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.namespace !== '') {
+            obj.namespace = message.namespace;
+        }
+        if (message.topic !== '') {
+            obj.topic = message.topic;
+        }
+        if (message.payload.length !== 0) {
+            obj.payload = base64FromBytes(message.payload);
+        }
+        if (message.producerId !== '') {
+            obj.producerId = message.producerId;
+        }
+        if (message.producerSeq !== 0) {
+            obj.producerSeq = Math.round(message.producerSeq);
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.PublishStreamMessageRequest.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b, _c, _d, _e;
+        const message = createBasePublishStreamMessageRequest();
+        message.namespace = (_a = object.namespace) !== null && _a !== void 0 ? _a : '';
+        message.topic = (_b = object.topic) !== null && _b !== void 0 ? _b : '';
+        message.payload = (_c = object.payload) !== null && _c !== void 0 ? _c : new Uint8Array(0);
+        message.producerId = (_d = object.producerId) !== null && _d !== void 0 ? _d : '';
+        message.producerSeq = (_e = object.producerSeq) !== null && _e !== void 0 ? _e : 0;
+        return message;
+    },
+};
+function createBasePublishStreamMessageResponse() {
+    return {};
+}
+exports.PublishStreamMessageResponse = {
+    encode(_, writer = new wire_1.BinaryWriter()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePublishStreamMessageResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(_) {
+        return {};
+    },
+    toJSON(_) {
+        const obj = {};
+        return obj;
+    },
+    create(base) {
+        return exports.PublishStreamMessageResponse.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(_) {
+        const message = createBasePublishStreamMessageResponse();
+        return message;
+    },
+};
+function createBaseSubscribeStreamRequest() {
+    return { namespace: '', topic: '', cursor: undefined };
+}
+exports.SubscribeStreamRequest = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.namespace !== '') {
+            writer.uint32(10).string(message.namespace);
+        }
+        if (message.topic !== '') {
+            writer.uint32(18).string(message.topic);
+        }
+        if (message.cursor !== undefined) {
+            writer.uint32(26).string(message.cursor);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseSubscribeStreamRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.namespace = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.topic = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.cursor = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            namespace: isSet(object.namespace) ? globalThis.String(object.namespace) : '',
+            topic: isSet(object.topic) ? globalThis.String(object.topic) : '',
+            cursor: isSet(object.cursor) ? globalThis.String(object.cursor) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.namespace !== '') {
+            obj.namespace = message.namespace;
+        }
+        if (message.topic !== '') {
+            obj.topic = message.topic;
+        }
+        if (message.cursor !== undefined) {
+            obj.cursor = message.cursor;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.SubscribeStreamRequest.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b, _c;
+        const message = createBaseSubscribeStreamRequest();
+        message.namespace = (_a = object.namespace) !== null && _a !== void 0 ? _a : '';
+        message.topic = (_b = object.topic) !== null && _b !== void 0 ? _b : '';
+        message.cursor = (_c = object.cursor) !== null && _c !== void 0 ? _c : undefined;
+        return message;
+    },
+};
+function createBaseStreamMessage() {
+    return { entries: [], hangup: false, cursor: '' };
+}
+exports.StreamMessage = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        for (const v of message.entries) {
+            exports.StreamEntry.encode(v, writer.uint32(10).fork()).join();
+        }
+        if (message.hangup !== false) {
+            writer.uint32(16).bool(message.hangup);
+        }
+        if (message.cursor !== '') {
+            writer.uint32(26).string(message.cursor);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseStreamMessage();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.entries.push(exports.StreamEntry.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.hangup = reader.bool();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.cursor = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            entries: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.entries)
+                ? object.entries.map((e) => exports.StreamEntry.fromJSON(e))
+                : [],
+            hangup: isSet(object.hangup) ? globalThis.Boolean(object.hangup) : false,
+            cursor: isSet(object.cursor) ? globalThis.String(object.cursor) : '',
+        };
+    },
+    toJSON(message) {
+        var _a;
+        const obj = {};
+        if ((_a = message.entries) === null || _a === void 0 ? void 0 : _a.length) {
+            obj.entries = message.entries.map((e) => exports.StreamEntry.toJSON(e));
+        }
+        if (message.hangup !== false) {
+            obj.hangup = message.hangup;
+        }
+        if (message.cursor !== '') {
+            obj.cursor = message.cursor;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.StreamMessage.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b, _c;
+        const message = createBaseStreamMessage();
+        message.entries = ((_a = object.entries) === null || _a === void 0 ? void 0 : _a.map((e) => exports.StreamEntry.fromPartial(e))) || [];
+        message.hangup = (_b = object.hangup) !== null && _b !== void 0 ? _b : false;
+        message.cursor = (_c = object.cursor) !== null && _c !== void 0 ? _c : '';
+        return message;
+    },
+};
+function createBaseStreamEntry() {
+    return { payload: new Uint8Array(0), cursor: '', createdAt: undefined };
+}
+exports.StreamEntry = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.payload.length !== 0) {
+            writer.uint32(10).bytes(message.payload);
+        }
+        if (message.cursor !== '') {
+            writer.uint32(18).string(message.cursor);
+        }
+        if (message.createdAt !== undefined) {
+            timestamp_1.Timestamp.encode(toTimestamp(message.createdAt), writer.uint32(26).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseStreamEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.payload = reader.bytes();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.cursor = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.createdAt = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            payload: isSet(object.payload) ? bytesFromBase64(object.payload) : new Uint8Array(0),
+            cursor: isSet(object.cursor) ? globalThis.String(object.cursor) : '',
+            createdAt: isSet(object.createdAt)
+                ? fromJsonTimestamp(object.createdAt)
+                : isSet(object.created_at)
+                    ? fromJsonTimestamp(object.created_at)
+                    : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.payload.length !== 0) {
+            obj.payload = base64FromBytes(message.payload);
+        }
+        if (message.cursor !== '') {
+            obj.cursor = message.cursor;
+        }
+        if (message.createdAt !== undefined) {
+            obj.createdAt = message.createdAt.toISOString();
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.StreamEntry.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b, _c;
+        const message = createBaseStreamEntry();
+        message.payload = (_a = object.payload) !== null && _a !== void 0 ? _a : new Uint8Array(0);
+        message.cursor = (_b = object.cursor) !== null && _b !== void 0 ? _b : '';
+        message.createdAt = (_c = object.createdAt) !== null && _c !== void 0 ? _c : undefined;
+        return message;
+    },
+};
+exports.V1StreamsDefinition = {
+    name: 'V1Streams',
+    fullName: 'v1.V1Streams',
+    methods: {
+        publish: {
+            name: 'Publish',
+            requestType: exports.PublishStreamMessageRequest,
+            requestStream: false,
+            responseType: exports.PublishStreamMessageResponse,
+            responseStream: false,
+            options: {},
+        },
+        subscribe: {
+            name: 'Subscribe',
+            requestType: exports.SubscribeStreamRequest,
+            requestStream: false,
+            responseType: exports.StreamMessage,
+            responseStream: true,
+            options: {},
+        },
+    },
+};
+function bytesFromBase64(b64) {
+    if (globalThis.Buffer) {
+        return Uint8Array.from(globalThis.Buffer.from(b64, 'base64'));
+    }
+    else {
+        const bin = globalThis.atob(b64);
+        const arr = new Uint8Array(bin.length);
+        for (let i = 0; i < bin.length; ++i) {
+            arr[i] = bin.charCodeAt(i);
+        }
+        return arr;
+    }
+}
+function base64FromBytes(arr) {
+    if (globalThis.Buffer) {
+        return globalThis.Buffer.from(arr).toString('base64');
+    }
+    else {
+        const bin = [];
+        arr.forEach((byte) => {
+            bin.push(globalThis.String.fromCharCode(byte));
+        });
+        return globalThis.btoa(bin.join(''));
+    }
+}
+function toTimestamp(date) {
+    const seconds = Math.trunc(date.getTime() / 1000);
+    const nanos = (date.getTime() % 1000) * 1000000;
+    return { seconds, nanos };
+}
+function fromTimestamp(t) {
+    let millis = (t.seconds || 0) * 1000;
+    millis += (t.nanos || 0) / 1000000;
+    return new globalThis.Date(millis);
+}
+function fromJsonTimestamp(o) {
+    if (o instanceof globalThis.Date) {
+        return o;
+    }
+    else if (typeof o === 'string') {
+        return new globalThis.Date(o);
+    }
+    else {
+        return fromTimestamp(timestamp_1.Timestamp.fromJSON(o));
+    }
+}
+function longToNumber(int64) {
+    const num = globalThis.Number(int64.toString());
+    if (num > globalThis.Number.MAX_SAFE_INTEGER) {
+        throw new globalThis.Error('Value is larger than Number.MAX_SAFE_INTEGER');
+    }
+    if (num < globalThis.Number.MIN_SAFE_INTEGER) {
+        throw new globalThis.Error('Value is smaller than Number.MIN_SAFE_INTEGER');
+    }
+    return num;
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}

package/protoc-es/v1/streams_pb.d.ts

@@ -0,0 +1,133 @@
+import type { GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv2";
+import type { Timestamp } from "@bufbuild/protobuf/wkt";
+import type { Message } from "@bufbuild/protobuf";
+/**
+ * Describes the file v1/streams.proto.
+ */
+export declare const file_v1_streams: GenFile;
+/**
+ * @generated from message v1.PublishStreamMessageRequest
+ */
+export type PublishStreamMessageRequest = Message<"v1.PublishStreamMessageRequest"> & {
+    /**
+     * @generated from field: string namespace = 1;
+     */
+    namespace: string;
+    /**
+     * @generated from field: string topic = 2;
+     */
+    topic: string;
+    /**
+     * @generated from field: bytes payload = 3;
+     */
+    payload: Uint8Array;
+    /**
+     * @generated from field: string producer_id = 4;
+     */
+    producerId: string;
+    /**
+     * @generated from field: int64 producer_seq = 5;
+     */
+    producerSeq: bigint;
+};
+/**
+ * Describes the message v1.PublishStreamMessageRequest.
+ * Use `create(PublishStreamMessageRequestSchema)` to create a new message.
+ */
+export declare const PublishStreamMessageRequestSchema: GenMessage<PublishStreamMessageRequest>;
+/**
+ * @generated from message v1.PublishStreamMessageResponse
+ */
+export type PublishStreamMessageResponse = Message<"v1.PublishStreamMessageResponse"> & {};
+/**
+ * Describes the message v1.PublishStreamMessageResponse.
+ * Use `create(PublishStreamMessageResponseSchema)` to create a new message.
+ */
+export declare const PublishStreamMessageResponseSchema: GenMessage<PublishStreamMessageResponse>;
+/**
+ * @generated from message v1.SubscribeStreamRequest
+ */
+export type SubscribeStreamRequest = Message<"v1.SubscribeStreamRequest"> & {
+    /**
+     * @generated from field: string namespace = 1;
+     */
+    namespace: string;
+    /**
+     * @generated from field: string topic = 2;
+     */
+    topic: string;
+    /**
+     * @generated from field: optional string cursor = 3;
+     */
+    cursor?: string | undefined;
+};
+/**
+ * Describes the message v1.SubscribeStreamRequest.
+ * Use `create(SubscribeStreamRequestSchema)` to create a new message.
+ */
+export declare const SubscribeStreamRequestSchema: GenMessage<SubscribeStreamRequest>;
+/**
+ * @generated from message v1.StreamMessage
+ */
+export type StreamMessage = Message<"v1.StreamMessage"> & {
+    /**
+     * @generated from field: repeated v1.StreamEntry entries = 1;
+     */
+    entries: StreamEntry[];
+    /**
+     * @generated from field: bool hangup = 2;
+     */
+    hangup: boolean;
+    /**
+     * @generated from field: string cursor = 3;
+     */
+    cursor: string;
+};
+/**
+ * Describes the message v1.StreamMessage.
+ * Use `create(StreamMessageSchema)` to create a new message.
+ */
+export declare const StreamMessageSchema: GenMessage<StreamMessage>;
+/**
+ * @generated from message v1.StreamEntry
+ */
+export type StreamEntry = Message<"v1.StreamEntry"> & {
+    /**
+     * @generated from field: bytes payload = 1;
+     */
+    payload: Uint8Array;
+    /**
+     * @generated from field: string cursor = 2;
+     */
+    cursor: string;
+    /**
+     * @generated from field: google.protobuf.Timestamp created_at = 3;
+     */
+    createdAt?: Timestamp | undefined;
+};
+/**
+ * Describes the message v1.StreamEntry.
+ * Use `create(StreamEntrySchema)` to create a new message.
+ */
+export declare const StreamEntrySchema: GenMessage<StreamEntry>;
+/**
+ * @generated from service v1.V1Streams
+ */
+export declare const V1Streams: GenService<{
+    /**
+     * @generated from rpc v1.V1Streams.Publish
+     */
+    publish: {
+        methodKind: "unary";
+        input: typeof PublishStreamMessageRequestSchema;
+        output: typeof PublishStreamMessageResponseSchema;
+    };
+    /**
+     * @generated from rpc v1.V1Streams.Subscribe
+     */
+    subscribe: {
+        methodKind: "server_streaming";
+        input: typeof SubscribeStreamRequestSchema;
+        output: typeof StreamMessageSchema;
+    };
+}>;

package/protoc-es/v1/streams_pb.js

@@ -0,0 +1,41 @@
+"use strict";
+// @generated by protoc-gen-es v2.15.0 with parameter "target=ts"
+// @generated from file v1/streams.proto (package v1, syntax proto3)
+/* eslint-disable */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.V1Streams = exports.StreamEntrySchema = exports.StreamMessageSchema = exports.SubscribeStreamRequestSchema = exports.PublishStreamMessageResponseSchema = exports.PublishStreamMessageRequestSchema = exports.file_v1_streams = void 0;
+const codegenv2_1 = require("@bufbuild/protobuf/codegenv2");
+const wkt_1 = require("@bufbuild/protobuf/wkt");
+/**
+ * Describes the file v1/streams.proto.
+ */
+exports.file_v1_streams = (0, codegenv2_1.fileDesc)("ChB2MS9zdHJlYW1zLnByb3RvEgJ2MSJ7ChtQdWJsaXNoU3RyZWFtTWVzc2FnZVJlcXVlc3QSEQoJbmFtZXNwYWNlGAEgASgJEg0KBXRvcGljGAIgASgJEg8KB3BheWxvYWQYAyABKAwSEwoLcHJvZHVjZXJfaWQYBCABKAkSFAoMcHJvZHVjZXJfc2VxGAUgASgDIh4KHFB1Ymxpc2hTdHJlYW1NZXNzYWdlUmVzcG9uc2UiWgoWU3Vic2NyaWJlU3RyZWFtUmVxdWVzdBIRCgluYW1lc3BhY2UYASABKAkSDQoFdG9waWMYAiABKAkSEwoGY3Vyc29yGAMgASgJSACIAQFCCQoHX2N1cnNvciJRCg1TdHJlYW1NZXNzYWdlEiAKB2VudHJpZXMYASADKAsyDy52MS5TdHJlYW1FbnRyeRIOCgZoYW5ndXAYAiABKAgSDgoGY3Vyc29yGAMgASgJIl4KC1N0cmVhbUVudHJ5Eg8KB3BheWxvYWQYASABKAwSDgoGY3Vyc29yGAIgASgJEi4KCmNyZWF0ZWRfYXQYAyABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wMpsBCglWMVN0cmVhbXMSTgoHUHVibGlzaBIfLnYxLlB1Ymxpc2hTdHJlYW1NZXNzYWdlUmVxdWVzdBogLnYxLlB1Ymxpc2hTdHJlYW1NZXNzYWdlUmVzcG9uc2UiABI+CglTdWJzY3JpYmUSGi52MS5TdWJzY3JpYmVTdHJlYW1SZXF1ZXN0GhEudjEuU3RyZWFtTWVzc2FnZSIAMAFCQlpAZ2l0aHViLmNvbS9oYXRjaGV0LWRldi9oYXRjaGV0L2ludGVybmFsL3NlcnZpY2VzL3NoYXJlZC9wcm90by92MWIGcHJvdG8z", [wkt_1.file_google_protobuf_timestamp]);
+/**
+ * Describes the message v1.PublishStreamMessageRequest.
+ * Use `create(PublishStreamMessageRequestSchema)` to create a new message.
+ */
+exports.PublishStreamMessageRequestSchema = (0, codegenv2_1.messageDesc)(exports.file_v1_streams, 0);
+/**
+ * Describes the message v1.PublishStreamMessageResponse.
+ * Use `create(PublishStreamMessageResponseSchema)` to create a new message.
+ */
+exports.PublishStreamMessageResponseSchema = (0, codegenv2_1.messageDesc)(exports.file_v1_streams, 1);
+/**
+ * Describes the message v1.SubscribeStreamRequest.
+ * Use `create(SubscribeStreamRequestSchema)` to create a new message.
+ */
+exports.SubscribeStreamRequestSchema = (0, codegenv2_1.messageDesc)(exports.file_v1_streams, 2);
+/**
+ * Describes the message v1.StreamMessage.
+ * Use `create(StreamMessageSchema)` to create a new message.
+ */
+exports.StreamMessageSchema = (0, codegenv2_1.messageDesc)(exports.file_v1_streams, 3);
+/**
+ * Describes the message v1.StreamEntry.
+ * Use `create(StreamEntrySchema)` to create a new message.
+ */
+exports.StreamEntrySchema = (0, codegenv2_1.messageDesc)(exports.file_v1_streams, 4);
+/**
+ * @generated from service v1.V1Streams
+ */
+exports.V1Streams = (0, codegenv2_1.serviceDesc)(exports.file_v1_streams, 0);

package/v1/client/client.d.ts

@@ -19,7 +19,7 @@ import { BatchTaskFn } from '../task';
 import type { LegacyWorkflow } from '../../legacy/legacy-transformer';
 import { IHatchetClient } from './client.interface';
 import { CreateWorkerOpts, Worker } from './worker/worker';
-import { CELClient, CronClient, FiltersClient, LogsClient, MetricsClient, RatelimitsClient, RunsClient, ScheduleClient, TenantClient, WebhooksClient, WorkersClient, WorkflowsClient } from './features';
+import { CELClient, CronClient, FiltersClient, LogsClient, MetricsClient, RatelimitsClient, RunsClient, ScheduleClient, StreamsClient, TenantClient, WebhooksClient, WorkersClient, WorkflowsClient } from './features';
 import { InputType, OutputType, UnknownInputType, StrictWorkflowOutputType, Resolved } from '../types';
 import { AdminClient } from './admin';
 import { DurableContext } from './worker/context';
@@ -294,6 +294,13 @@ export declare class HatchetClient<GlobalInput extends Record<string, any> = {},
      * @returns A runs client instance
      */
     get runs(): RunsClient;
+    private _streams;
+    /**
+     * Get the streams client for publishing to and reading from durable,
+     * topic-based streams
+     * @returns A streams client instance
+     */
+    get streams(): StreamsClient;
     private _workflows;
     /**
      * Get the workflows client for creating and managing workflows

package/v1/client/client.js

@@ -405,6 +405,17 @@ class HatchetClient {
         }
         return this._runs;
     }
+    /**
+     * Get the streams client for publishing to and reading from durable,
+     * topic-based streams
+     * @returns A streams client instance
+     */
+    get streams() {
+        if (!this._streams) {
+            this._streams = new features_1.StreamsClient(this);
+        }
+        return this._streams;
+    }
     /**
      * Get the workflows client for creating and managing workflows
      * @returns A workflows client instance

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

@@ -10,3 +10,4 @@ export * from './filters';
 export * from './tenant';
 export * from './webhooks';
 export * from './cel';
+export * from './streams';

package/v1/client/features/index.js

@@ -26,3 +26,4 @@ __exportStar(require("./filters"), exports);
 __exportStar(require("./tenant"), exports);
 __exportStar(require("./webhooks"), exports);
 __exportStar(require("./cel"), exports);
+__exportStar(require("./streams"), exports);

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

@@ -0,0 +1,47 @@
+import { HatchetClient } from '../client';
+export type StreamEvent = {
+    /** the message payload */
+    payload: Uint8Array;
+    /** resumes events() right after this event */
+    cursor: string;
+    /** when the message was stored */
+    createdAt?: Date;
+};
+export type StreamCallOptions = {
+    namespace?: string;
+    cursor?: string;
+    /** ends an events() iteration cleanly, without throwing */
+    signal?: AbortSignal;
+};
+/**
+ * StreamsClient publishes to and reads from durable topics. Unlike
+ * `runs.subscribeToStream`, topics are stored, independent of any run, and
+ * readers can resume from a cursor.
+ */
+export declare class StreamsClient {
+    private _config;
+    private _grpc;
+    private producers;
+    private publishChains;
+    constructor(client: HatchetClient);
+    private get grpc();
+    private publishOrdered;
+    /**
+     * Resolves once the message is stored. A client's messages to a topic are
+     * delivered in the order publish() was called.
+     * @param topic - the topic to publish to
+     * @param message - the message payload
+     * @param options - optional namespace override
+     */
+    publish(topic: string, message: Uint8Array | string, options?: StreamCallOptions): Promise<void>;
+    /**
+     * Yields topic's messages after options.cursor, or from the oldest retained.
+     * If the connection drops, it resubscribes from the last message yielded, so
+     * nothing is skipped or repeated. Ends when the server hangs up an idle
+     * subscription, options.signal aborts, or the caller stops iterating; throws
+     * on errors a retry can't fix, such as an expired cursor.
+     * @param topic - the topic to read from
+     * @param options - optional namespace override, resume cursor, and abort signal
+     */
+    events(topic: string, options?: StreamCallOptions): AsyncIterable<StreamEvent>;
+}

package/v1/client/features/streams.js

@@ -0,0 +1,210 @@
+"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 __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); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamsClient = void 0;
+const crypto_1 = require("crypto");
+const nice_grpc_1 = require("nice-grpc");
+const grpc_helpers_1 = require("../../../util/grpc-helpers");
+const grpc_error_1 = require("../../../util/grpc-error");
+const sleep_1 = __importDefault(require("../../../util/sleep"));
+const streams_1 = require("../../../protoc/v1/streams");
+// the server stored nothing, so the seq is unused
+function publishRejectedBeforeStoring(err) {
+    const code = (0, grpc_error_1.getGrpcErrorCode)(err);
+    return (code === nice_grpc_1.Status.INVALID_ARGUMENT ||
+        code === nice_grpc_1.Status.RESOURCE_EXHAUSTED ||
+        code === nice_grpc_1.Status.UNAUTHENTICATED ||
+        code === nice_grpc_1.Status.PERMISSION_DENIED);
+}
+// retrying a subscribe that failed with these can't succeed
+const permanentSubscribeErrors = new Set([
+    nice_grpc_1.Status.INVALID_ARGUMENT,
+    nice_grpc_1.Status.PERMISSION_DENIED,
+    nice_grpc_1.Status.UNAUTHENTICATED,
+    nice_grpc_1.Status.OUT_OF_RANGE,
+    nice_grpc_1.Status.FAILED_PRECONDITION,
+    nice_grpc_1.Status.NOT_FOUND,
+]);
+const resubscribeMinDelayMs = 250;
+const resubscribeMaxDelayMs = 10000;
+function shouldResubscribe(err, attempt) {
+    const code = (0, grpc_error_1.getGrpcErrorCode)(err);
+    if (code === undefined || permanentSubscribeErrors.has(code)) {
+        return false;
+    }
+    // proxies answer 404 while an engine restarts, but on a first attempt it means no streams support
+    if (code === nice_grpc_1.Status.UNIMPLEMENTED) {
+        return attempt > 0;
+    }
+    return true;
+}
+/**
+ * StreamsClient publishes to and reads from durable topics. Unlike
+ * `runs.subscribeToStream`, topics are stored, independent of any run, and
+ * readers can resume from a cursor.
+ */
+class StreamsClient {
+    constructor(client) {
+        // per (namespace, topic); seq only advances after a publish succeeds
+        this.producers = new Map();
+        // serializes publishes per (namespace, topic) so two never share a seq; the
+        // stored promise always resolves, so one failure doesn't block later calls
+        this.publishChains = new Map();
+        this._config = client.config;
+    }
+    get grpc() {
+        if (!this._grpc) {
+            const { client } = (0, grpc_helpers_1.createGrpcClient)(this._config, streams_1.V1StreamsDefinition);
+            this._grpc = client;
+        }
+        return this._grpc;
+    }
+    publishOrdered(key_1, namespace_1, topic_1, payload_1) {
+        return __awaiter(this, arguments, void 0, function* (key, namespace, topic, payload, retryGap = true) {
+            let producer = this.producers.get(key);
+            if (!producer) {
+                producer = { producerId: (0, crypto_1.randomUUID)(), seq: 0 };
+                this.producers.set(key, producer);
+            }
+            try {
+                yield this.grpc.publish({
+                    namespace,
+                    topic,
+                    payload,
+                    producerId: producer.producerId,
+                    producerSeq: producer.seq,
+                });
+            }
+            catch (err) {
+                // it may still land, and a different payload under its seq would be dropped as a duplicate
+                if (!publishRejectedBeforeStoring(err)) {
+                    this.producers.set(key, { producerId: (0, crypto_1.randomUUID)(), seq: 0 });
+                }
+                // a gap stored nothing (e.g. the watermark passed cursor retention), so resend as the new producer
+                if (retryGap && (0, grpc_error_1.getGrpcErrorCode)(err) === nice_grpc_1.Status.FAILED_PRECONDITION) {
+                    return this.publishOrdered(key, namespace, topic, payload, false);
+                }
+                throw err;
+            }
+            producer.seq += 1;
+        });
+    }
+    /**
+     * Resolves once the message is stored. A client's messages to a topic are
+     * delivered in the order publish() was called.
+     * @param topic - the topic to publish to
+     * @param message - the message payload
+     * @param options - optional namespace override
+     */
+    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}\u0000${topic}`;
+            const previous = (_b = this.publishChains.get(key)) !== null && _b !== void 0 ? _b : Promise.resolve();
+            const publishPromise = previous.then(() => this.publishOrdered(key, namespace, topic, payload));
+            this.publishChains.set(key, publishPromise.catch(() => { }));
+            return publishPromise;
+        });
+    }
+    /**
+     * Yields topic's messages after options.cursor, or from the oldest retained.
+     * If the connection drops, it resubscribes from the last message yielded, so
+     * nothing is skipped or repeated. Ends when the server hangs up an idle
+     * subscription, options.signal aborts, or the caller stops iterating; throws
+     * on errors a retry can't fix, such as an expired cursor.
+     * @param topic - the topic to read from
+     * @param options - optional namespace override, resume cursor, and abort signal
+     */
+    events(topic, options) {
+        return __asyncGenerator(this, arguments, function* events_1() {
+            var _a, e_1, _b, _c;
+            var _d;
+            const namespace = (_d = options === null || options === void 0 ? void 0 : options.namespace) !== null && _d !== void 0 ? _d : '';
+            const signal = options === null || options === void 0 ? void 0 : options.signal;
+            let { cursor } = options !== null && options !== void 0 ? options : {};
+            let failures = 0;
+            for (let attempt = 0;; attempt += 1) {
+                try {
+                    const stream = this.grpc.subscribe({ namespace, topic, cursor }, { signal });
+                    try {
+                        for (var _e = true, stream_1 = (e_1 = void 0, __asyncValues(stream)), stream_1_1; stream_1_1 = yield __await(stream_1.next()), _a = stream_1_1.done, !_a; _e = true) {
+                            _c = stream_1_1.value;
+                            _e = false;
+                            const msg = _c;
+                            if (msg.hangup) {
+                                return yield __await(void 0);
+                            }
+                            failures = 0;
+                            for (const entry of msg.entries) {
+                                ({ cursor } = entry);
+                                yield yield __await({
+                                    payload: entry.payload,
+                                    cursor: entry.cursor,
+                                    createdAt: entry.createdAt,
+                                });
+                            }
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (!_e && !_a && (_b = stream_1.return)) yield __await(_b.call(stream_1));
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                    // ending without a hangup means the engine went away, e.g. it is shutting down
+                }
+                catch (err) {
+                    if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                        return yield __await(void 0);
+                    }
+                    if (!shouldResubscribe(err, attempt)) {
+                        throw err;
+                    }
+                }
+                const delayMs = Math.min(resubscribeMinDelayMs * 2 ** failures, resubscribeMaxDelayMs);
+                failures += 1;
+                try {
+                    yield __await((0, sleep_1.default)(delayMs * (0.5 + Math.random() / 2), signal));
+                }
+                catch (_f) {
+                    return yield __await(void 0);
+                }
+            }
+        });
+    }
+}
+exports.StreamsClient = StreamsClient;

package/v1/examples/durable-streams/publish-latency.d.ts

@@ -0,0 +1,15 @@
+import { HatchetClient } from '../..';
+export type PublishLatencyStats = {
+    count: number;
+    avgMs: number;
+    p50Ms: number;
+    p99Ms: number;
+    maxMs: number;
+    throughputPerSec: number;
+};
+/**
+ * Times `count` sequential publishes, after `warmupCount` unmeasured ones
+ * absorb connection setup and topic creation.
+ */
+export declare function measurePublishLatency(hatchet: HatchetClient, topic: string, payload: Uint8Array | string, count: number, warmupCount?: number): Promise<PublishLatencyStats>;
+export declare function formatPublishLatency(stats: PublishLatencyStats): string;

package/v1/examples/durable-streams/publish-latency.js

@@ -0,0 +1,50 @@
+"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.measurePublishLatency = measurePublishLatency;
+exports.formatPublishLatency = formatPublishLatency;
+const perf_hooks_1 = require("perf_hooks");
+function percentile(sorted, p) {
+    return sorted[Math.min(sorted.length - 1, Math.floor(sorted.length * p))];
+}
+/**
+ * Times `count` sequential publishes, after `warmupCount` unmeasured ones
+ * absorb connection setup and topic creation.
+ */
+function measurePublishLatency(hatchet_1, topic_1, payload_1, count_1) {
+    return __awaiter(this, arguments, void 0, function* (hatchet, topic, payload, count, warmupCount = 5) {
+        for (let i = 0; i < warmupCount; i += 1) {
+            yield hatchet.streams.publish(topic, payload);
+        }
+        const durationsMs = [];
+        const start = perf_hooks_1.performance.now();
+        for (let i = 0; i < count; i += 1) {
+            const before = perf_hooks_1.performance.now();
+            yield hatchet.streams.publish(topic, payload);
+            durationsMs.push(perf_hooks_1.performance.now() - before);
+        }
+        const totalMs = perf_hooks_1.performance.now() - start;
+        const sorted = [...durationsMs].sort((a, b) => a - b);
+        return {
+            count,
+            avgMs: durationsMs.reduce((sum, d) => sum + d, 0) / count,
+            p50Ms: percentile(sorted, 0.5),
+            p99Ms: percentile(sorted, 0.99),
+            maxMs: sorted[sorted.length - 1],
+            throughputPerSec: (count / totalMs) * 1000,
+        };
+    });
+}
+function formatPublishLatency(stats) {
+    const fmt = (ms) => ms.toFixed(2);
+    return (`avg=${fmt(stats.avgMs)}ms p50=${fmt(stats.p50Ms)}ms p99=${fmt(stats.p99Ms)}ms ` +
+        `max=${fmt(stats.maxMs)}ms throughput=${fmt(stats.throughputPerSec)}/s`);
+}

package/v1/examples/durable_callback_ordering/workflow.js

@@ -69,11 +69,15 @@ exports.callbackOrderingMid = hatchet_client_1.hatchet.durableTask({
         };
     }),
 });
+// The root is never evicted. The ordering property under test lives in the
+// mids, and the worker evicts one waiting run per server round trip, oldest
+// wait first: evictable roots register before every mid and would consume the
+// sweep for as long as it takes to ack all of them before any mid is reached.
 exports.callbackOrderingRoot = hatchet_client_1.hatchet.durableTask({
     name: `${WORKFLOW_PREFIX}-root`,
     executionTimeout: '10m',
     retries: 0,
-    evictionPolicy: EVICTION_POLICY,
+    evictionPolicy: { ttl: undefined, allowCapacityEviction: false, priority: 0 },
     fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
         var _a;
         const durables = (_a = input.durables) !== null && _a !== void 0 ? _a : exports.ROOT_DEFAULTS.durables;

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.34.0-alpha.2";
+export declare const HATCHET_VERSION = "1.34.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.34.0-alpha.2';
+exports.HATCHET_VERSION = '1.34.0';