@hatchet-dev/typescript-sdk 1.31.1 → 1.33.0

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

@@ -0,0 +1,118 @@
+/**
+ * The seams between a task's `Context` / `DurableContext` and whatever runs the task.
+ *
+ * A worker process implements them over its `HatchetClient` and durable listener (see
+ * `worker-runtime.ts`); a serverless handler implements them over the operator's request
+ * and durable socket. Nothing in this module imports from Node, so the interfaces are
+ * usable from the edge entry point.
+ * @module Runtime
+ */
+import type { Logger, LogLevel } from '../../../util/logger';
+import type WorkflowRunRef from '../../../util/workflow-run-ref';
+import type { WorkerLabelComparator } from '../../../protoc/v1/shared/trigger';
+import type { Priority } from '../../declaration';
+import type { DurableTaskEventLogEntryResult, DurableTaskEventMemoAck, DurableTaskEventRunAck, DurableTaskEventWaitForAck, MemoEvent, RunChildrenEvent, WaitForEvent } from '../../../clients/listeners/durable-listener/durable-events';
+/** Labels a worker advertises for affinity-based assignment. */
+export type WorkerLabels = Record<string, string | number | undefined>;
+/** A worker label a spawned child run asks for. */
+export type DesiredWorkerLabel = {
+    value: string | number;
+    required?: boolean;
+    weight?: number;
+    comparator?: WorkerLabelComparator;
+};
+/**
+ * Options a context passes when it spawns a child run. Mirrors the options accepted by
+ * `AdminClient.runWorkflow`.
+ */
+export type SpawnRunOptions = {
+    parentId?: string | undefined;
+    parentTaskRunExternalId?: string | undefined;
+    /** @deprecated Use `parentTaskRunExternalId` instead. */
+    parentStepRunId?: string | undefined;
+    childIndex?: number | undefined;
+    childKey?: string | undefined;
+    /** Alias of `childKey` kept for the child run APIs on `Context`. */
+    key?: string | undefined;
+    additionalMetadata?: Record<string, string> | undefined;
+    desiredWorkerId?: string | undefined;
+    priority?: Priority;
+    sticky?: boolean;
+    returnExceptions?: boolean;
+    desiredWorkerLabels?: Record<string, DesiredWorkerLabel>;
+    _standaloneTaskName?: string | undefined;
+};
+export type SpawnRunRequest<Q = object> = {
+    workflowName: string;
+    input: Q;
+    options?: SpawnRunOptions;
+};
+/** Identifies every member of a batch task run when the whole batch is cancelled. */
+export type CancelBatchRequest = {
+    workerId: string;
+    jobId: string;
+    actionId: string;
+    batchId: string;
+    memberIds: string[];
+};
+/**
+ * Everything a `Context` needs from the process running the task: a logger factory,
+ * the namespace, the engine-facing operations, and the worker facts `ctx.worker` reports.
+ *
+ * Implementations that cannot honour an operation (for example a serverless runtime
+ * without a Hatchet client) throw from it; the context does not guard against that.
+ */
+export interface ContextRuntime {
+    /** The namespace applied to workflow names and event keys, if any. */
+    readonly namespace?: string;
+    /** Creates a logger for the given component, at the runtime's configured level. */
+    logger(name: string): Logger;
+    /** Cancels a single task run. */
+    cancelRun(taskRunExternalId: string): Promise<void>;
+    /** Cancels every member of a batch task run. */
+    cancelBatch(request: CancelBatchRequest): Promise<void>;
+    /** Writes a log line for a task run to the engine. */
+    putLog(taskRunExternalId: string, message: string, level: LogLevel | undefined, retryCount: number, extra?: Record<string, unknown>): Promise<void>;
+    /** Extends the execution timeout of a task run by `incrementBy` (Go duration string). */
+    refreshTimeout(taskRunExternalId: string, incrementBy: string): Promise<void>;
+    /** Releases the worker slot held by a task run. */
+    releaseSlot(taskRunExternalId: string): Promise<void>;
+    /** Streams a chunk of data from a task run. */
+    putStream(taskRunExternalId: string, data: string | Uint8Array, index: number): Promise<void>;
+    /** Spawns one run. */
+    runWorkflow<Q = object, P = object>(workflowName: string, input: Q, options?: SpawnRunOptions): Promise<WorkflowRunRef<P>>;
+    /** Spawns many runs in one call. */
+    runWorkflows<Q = object, P = object>(runs: SpawnRunRequest<Q>[]): Promise<WorkflowRunRef<P>[]>;
+    /** The id the engine assigned to the worker, once registered. */
+    workerId(): string | undefined;
+    /** Whether the worker serves the given workflow (used by sticky child runs). */
+    hasWorkflow(workflowName: string): boolean;
+    /** The worker's current labels. */
+    workerLabels(): WorkerLabels;
+    /** Replaces the worker's labels. */
+    upsertWorkerLabels(labels: WorkerLabels): Promise<WorkerLabels>;
+}
+/**
+ * The seam a `DurableContext` talks to for durable events: the worker implements it with
+ * `DurableListenerClient` over gRPC, a serverless handler with frames over a websocket.
+ */
+export interface DurableTransport {
+    sendEvent(durableTaskExternalId: string, invocationCount: number, event: RunChildrenEvent): Promise<DurableTaskEventRunAck>;
+    sendEvent(durableTaskExternalId: string, invocationCount: number, event: WaitForEvent): Promise<DurableTaskEventWaitForAck>;
+    sendEvent(durableTaskExternalId: string, invocationCount: number, event: MemoEvent): Promise<DurableTaskEventMemoAck>;
+    waitForCallback(durableTaskExternalId: string, invocationCount: number, branchId: number, nodeId: number, opts?: {
+        signal?: AbortSignal;
+    }): Promise<DurableTaskEventLogEntryResult>;
+    consumeCallbackWithoutBlocking(durableTaskExternalId: string, invocationCount: number, branchId: number, nodeId: number): void;
+    sendMemoCompletedNotification(durableTaskExternalId: string, nodeId: number, branchId: number, invocationCount: number, memoKey: Uint8Array, memoResultPayload?: Uint8Array): Promise<void>;
+    cleanupTaskState(durableTaskExternalId: string, invocationCount: number): void;
+    sendEvictInvocation(durableTaskExternalId: string, invocationCount: number, reason?: string): Promise<void>;
+}
+/**
+ * Options for constructing a `DurableContext` on top of a `ContextRuntime`.
+ */
+export interface DurableContextOptions {
+    /** The engine version the runtime is talking to; decides whether eviction is supported. */
+    engineVersion?: string;
+}
+export declare function isContextRuntime(value: unknown): value is ContextRuntime;

package/v1/client/worker/runtime.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isContextRuntime = isContextRuntime;
+function isContextRuntime(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const candidate = value;
+    return typeof candidate.logger === 'function' && typeof candidate.workerId === 'function';
+}

package/v1/client/worker/worker-internal.d.ts

@@ -1,17 +1,15 @@
-import { Action, ActionKey, ActionListener } from '../../../clients/dispatcher/action-listener';
+import { ActionListener } from '../../../clients/dispatcher/action-listener';
+import { Action, ActionKey } from '../../../clients/dispatcher/action';
 import { StepActionEvent, StepActionEventType, GroupKeyActionEvent, GroupKeyActionEventType, BatchActionEvent } from '../../../protoc/dispatcher';
 import HatchetPromise from '../../../util/hatchet-promise/hatchet-promise';
-import { CreateStepRateLimit } from '../../../protoc/workflows';
 import { Logger } from '../../../util/logger';
 import { BaseWorkflowDeclaration, WorkflowDefinition, HatchetClient } from '../..';
-import { TaskBatchConfig } from '../../../protoc/v1/workflows';
-import { Concurrency, CreateWorkflowTaskOpts } from '../../task';
 import { WorkerLabels } from '../../../clients/dispatcher/dispatcher-client';
-import { Duration } from '../duration';
 import { Context } from './context';
 import { SlotConfig } from '../../slot-types';
 import { DurableEvictionManager } from './eviction/eviction-manager';
 import { EvictionPolicy } from './eviction/eviction-policy';
+export { assertValidConcurrencyArr, mapBatchConfigPb, mapConcurrencyPb, mapRateLimitPb, mapSlotRequestsPb, resolveExecutionTimeout, resolveScheduleTimeout, taskConcurrencyArr, } from './workflow-proto';
 export type ActionRegistry = Record<Action['actionId'], Function>;
 export interface WorkerOpts {
     name: string;
@@ -107,37 +105,3 @@ export declare class InternalWorker {
     handleAction(action: Action): Promise<void | Error>;
     upsertLabels(labels: WorkerLabels): Promise<WorkerLabels>;
 }
-/** Durable tasks stay on the durable pool; slotCost applies only to the default pool. */
-export declare function mapSlotRequestsPb(task: {
-    slotRequests?: Record<string, number>;
-    slotCost?: number;
-}, isDurable: boolean): Record<string, number>;
-export declare function mapRateLimitPb(limits: CreateWorkflowTaskOpts<any, any>['rateLimits']): CreateStepRateLimit[];
-export declare function mapConcurrencyPb(entries: Concurrency[]): {
-    expression: string;
-    maxRuns: number | undefined;
-    limitStrategy: import("../..").ConcurrencyLimitStrategy | undefined;
-    name: string | undefined;
-    isTenantScoped: boolean | undefined;
-    maxRunsExpression: string | undefined;
-}[];
-export declare function taskConcurrencyArr(task: {
-    concurrency?: Concurrency | Concurrency[];
-}, workflow: {
-    taskDefaults?: {
-        concurrency?: Concurrency | Concurrency[];
-    };
-}): Concurrency[];
-export declare function assertValidConcurrencyArr(concurrency: Concurrency[] | undefined): void;
-export declare function mapBatchConfigPb(batch: CreateWorkflowTaskOpts<any, any>['batch']): TaskBatchConfig | undefined;
-export declare function resolveExecutionTimeout(task: {
-    executionTimeout?: Duration;
-    timeout?: Duration;
-}, workflowDefaults?: {
-    executionTimeout?: Duration;
-}): string;
-export declare function resolveScheduleTimeout(task: {
-    scheduleTimeout?: Duration;
-}, workflowDefaults?: {
-    scheduleTimeout?: Duration;
-}): string | undefined;

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

@@ -52,35 +52,37 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InternalWorker = void 0;
-exports.mapSlotRequestsPb = mapSlotRequestsPb;
-exports.mapRateLimitPb = mapRateLimitPb;
-exports.mapConcurrencyPb = mapConcurrencyPb;
-exports.taskConcurrencyArr = taskConcurrencyArr;
-exports.assertValidConcurrencyArr = assertValidConcurrencyArr;
-exports.mapBatchConfigPb = mapBatchConfigPb;
-exports.resolveExecutionTimeout = resolveExecutionTimeout;
-exports.resolveScheduleTimeout = resolveScheduleTimeout;
+exports.InternalWorker = exports.taskConcurrencyArr = exports.resolveScheduleTimeout = exports.resolveExecutionTimeout = exports.mapSlotRequestsPb = exports.mapRateLimitPb = exports.mapConcurrencyPb = exports.mapBatchConfigPb = exports.assertValidConcurrencyArr = void 0;
 const hatchet_error_1 = __importDefault(require("../../../util/errors/hatchet-error"));
 const task_run_terminated_error_1 = require("../../../util/errors/task-run-terminated-error");
+const action_1 = require("../../../clients/dispatcher/action");
 const dispatcher_1 = require("../../../protoc/dispatcher");
 const hatchet_promise_1 = __importStar(require("../../../util/hatchet-promise/hatchet-promise"));
-const workflows_1 = require("../../../protoc/workflows");
 const logger_1 = require("../../../util/logger");
-const workflows_2 = require("../../../protoc/v1/workflows");
 const task_1 = require("../../task");
-const transformer_1 = require("../../conditions/transformer");
-const z = __importStar(require("zod/v4"));
 const apply_namespace_1 = require("../../../util/apply-namespace");
 const sleep_1 = __importDefault(require("../../../util/sleep"));
 const abort_error_1 = require("../../../util/abort-error");
-const duration_1 = require("../duration");
 const context_1 = require("./context");
 const parent_run_context_vars_1 = require("../../parent-run-context-vars");
+const parent_run_context_storage_1 = require("../../parent-run-context-storage");
+const workflow_proto_1 = require("./workflow-proto");
 const health_server_1 = require("./health-server");
 const eviction_manager_1 = require("./eviction/eviction-manager");
 const eviction_policy_1 = require("./eviction/eviction-policy");
 const engine_version_1 = require("./engine-version");
+var workflow_proto_2 = require("./workflow-proto");
+Object.defineProperty(exports, "assertValidConcurrencyArr", { enumerable: true, get: function () { return workflow_proto_2.assertValidConcurrencyArr; } });
+Object.defineProperty(exports, "mapBatchConfigPb", { enumerable: true, get: function () { return workflow_proto_2.mapBatchConfigPb; } });
+Object.defineProperty(exports, "mapConcurrencyPb", { enumerable: true, get: function () { return workflow_proto_2.mapConcurrencyPb; } });
+Object.defineProperty(exports, "mapRateLimitPb", { enumerable: true, get: function () { return workflow_proto_2.mapRateLimitPb; } });
+Object.defineProperty(exports, "mapSlotRequestsPb", { enumerable: true, get: function () { return workflow_proto_2.mapSlotRequestsPb; } });
+Object.defineProperty(exports, "resolveExecutionTimeout", { enumerable: true, get: function () { return workflow_proto_2.resolveExecutionTimeout; } });
+Object.defineProperty(exports, "resolveScheduleTimeout", { enumerable: true, get: function () { return workflow_proto_2.resolveScheduleTimeout; } });
+Object.defineProperty(exports, "taskConcurrencyArr", { enumerable: true, get: function () { return workflow_proto_2.taskConcurrencyArr; } });
+// Tasks read the parent run context across awaits; the worker is the only place that
+// enters it, so it installs the AsyncLocalStorage store before any task can run.
+(0, parent_run_context_storage_1.installAsyncLocalParentRunContext)();
 class InternalWorker {
     constructor(client, options) {
         var _a, _b, _c, _d;
@@ -143,7 +145,7 @@ class InternalWorker {
         const newActions = workflow._durableTasks
             .filter((task) => !!task.fn)
             .reduce((acc, task) => {
-            const actionId = `${(0, apply_namespace_1.applyNamespace)(workflow.name, this.client.config.namespace).toLowerCase()}:${task.name.toLowerCase()}`;
+            const actionId = (0, action_1.createActionId)((0, apply_namespace_1.applyNamespace)(workflow.name, this.client.config.namespace), task.name);
             acc[actionId] = (ctx) => task.fn(ctx.input, ctx);
             this.durable_action_set.add(actionId);
             this.eviction_policies.set(actionId, task.evictionPolicy !== undefined
@@ -157,7 +159,7 @@ class InternalWorker {
         const newActions = workflow._tasks
             .filter((task) => !!task.fn)
             .reduce((acc, task) => {
-            const actionId = `${workflow.name}:${task.name.toLowerCase()}`;
+            const actionId = (0, action_1.createActionId)(workflow.name, task.name);
             if (task.batch) {
                 acc[actionId] = (ctx) => task.fn(decodeBatchItems(ctx.action.actionPayload), ctx);
             }
@@ -173,192 +175,17 @@ class InternalWorker {
             : undefined;
         const onFailureAction = onFailureFn
             ? {
-                [onFailureTaskName(workflow)]: (ctx) => onFailureFn(ctx.input, ctx),
+                [(0, workflow_proto_1.onFailureTaskName)(workflow)]: (ctx) => onFailureFn(ctx.input, ctx),
             }
             : {};
         this.action_registry = Object.assign(Object.assign(Object.assign({}, this.action_registry), newActions), onFailureAction);
     }
     registerWorkflow(initWorkflow_1) {
         return __awaiter(this, arguments, void 0, function* (initWorkflow, durable = false) {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w;
-            // patch the namespace
-            const workflow = Object.assign(Object.assign({}, initWorkflow.definition), { name: (0, apply_namespace_1.applyNamespace)(initWorkflow.definition.name, this.client.config.namespace).toLowerCase() });
+            const { namespace } = this.client.config;
+            const workflow = (0, workflow_proto_1.normalizeWorkflowDefinition)(initWorkflow, { namespace, durable });
             try {
-                const { concurrency } = workflow;
-                let onFailureTask;
-                if (workflow.onFailure && typeof workflow.onFailure === 'function') {
-                    onFailureTask = {
-                        readableId: 'on-failure-task',
-                        action: onFailureTaskName(workflow),
-                        timeout: '60s',
-                        inputs: '{}',
-                        parents: [],
-                        retries: 0,
-                        rateLimits: [],
-                        workerLabels: {},
-                        concurrency: [],
-                        isDurable: false,
-                        slotRequests: { default: 1 },
-                    };
-                }
-                if (workflow.onFailure && typeof workflow.onFailure === 'object') {
-                    const onFailure = workflow.onFailure;
-                    const scheduleTimeout = (_a = onFailure.scheduleTimeout) !== null && _a !== void 0 ? _a : (_b = workflow.taskDefaults) === null || _b === void 0 ? void 0 : _b.scheduleTimeout;
-                    onFailureTask = {
-                        readableId: 'on-failure-task',
-                        action: onFailureTaskName(workflow),
-                        timeout: (0, duration_1.durationToString)(onFailure.executionTimeout || ((_c = workflow.taskDefaults) === null || _c === void 0 ? void 0 : _c.executionTimeout) || '60s'),
-                        scheduleTimeout: scheduleTimeout ? (0, duration_1.durationToString)(scheduleTimeout) : undefined,
-                        inputs: '{}',
-                        parents: [],
-                        retries: onFailure.retries || ((_d = workflow.taskDefaults) === null || _d === void 0 ? void 0 : _d.retries) || 0,
-                        rateLimits: mapRateLimitPb(onFailure.rateLimits || ((_e = workflow.taskDefaults) === null || _e === void 0 ? void 0 : _e.rateLimits)),
-                        workerLabels: mapWorkerLabelPb(onFailure.desiredWorkerLabels || ((_f = workflow.taskDefaults) === null || _f === void 0 ? void 0 : _f.workerLabels)),
-                        concurrency: [],
-                        backoffFactor: ((_g = onFailure.backoff) === null || _g === void 0 ? void 0 : _g.factor) || ((_j = (_h = workflow.taskDefaults) === null || _h === void 0 ? void 0 : _h.backoff) === null || _j === void 0 ? void 0 : _j.factor),
-                        backoffMaxSeconds: ((_k = onFailure.backoff) === null || _k === void 0 ? void 0 : _k.maxSeconds) || ((_m = (_l = workflow.taskDefaults) === null || _l === void 0 ? void 0 : _l.backoff) === null || _m === void 0 ? void 0 : _m.maxSeconds),
-                        isDurable: false,
-                        slotRequests: mapSlotRequestsPb(onFailure, false),
-                    };
-                }
-                let onSuccessTask;
-                if (!durable && workflow.onSuccess && typeof workflow.onSuccess === 'function') {
-                    const parents = getLeaves([...workflow._tasks, ...workflow._durableTasks]);
-                    onSuccessTask = {
-                        name: 'on-success-task',
-                        fn: workflow.onSuccess,
-                        executionTimeout: '60s',
-                        parents,
-                        retries: 0,
-                        rateLimits: [],
-                        desiredWorkerLabels: undefined,
-                        concurrency: [],
-                    };
-                }
-                if (!durable && workflow.onSuccess && typeof workflow.onSuccess === 'object') {
-                    const onSuccess = workflow.onSuccess;
-                    const parents = getLeaves([...workflow._tasks, ...workflow._durableTasks]);
-                    onSuccessTask = {
-                        name: 'on-success-task',
-                        fn: onSuccess.fn,
-                        executionTimeout: onSuccess.executionTimeout || ((_o = workflow.taskDefaults) === null || _o === void 0 ? void 0 : _o.executionTimeout) || '60s',
-                        scheduleTimeout: onSuccess.scheduleTimeout || ((_p = workflow.taskDefaults) === null || _p === void 0 ? void 0 : _p.scheduleTimeout),
-                        parents,
-                        retries: onSuccess.retries || ((_q = workflow.taskDefaults) === null || _q === void 0 ? void 0 : _q.retries) || 0,
-                        rateLimits: onSuccess.rateLimits || ((_r = workflow.taskDefaults) === null || _r === void 0 ? void 0 : _r.rateLimits),
-                        desiredWorkerLabels: onSuccess.desiredWorkerLabels || ((_s = workflow.taskDefaults) === null || _s === void 0 ? void 0 : _s.workerLabels),
-                        concurrency: onSuccess.concurrency || ((_t = workflow.taskDefaults) === null || _t === void 0 ? void 0 : _t.concurrency),
-                        backoff: onSuccess.backoff || ((_u = workflow.taskDefaults) === null || _u === void 0 ? void 0 : _u.backoff),
-                    };
-                }
-                if (onSuccessTask) {
-                    workflow._tasks.push(onSuccessTask);
-                }
-                const eventTriggers = [
-                    ...(workflow.onEvents || []).map((event) => (0, apply_namespace_1.applyNamespace)(event, this.client.config.namespace)),
-                    ...(workflow.on && 'event' in workflow.on && workflow.on.event
-                        ? Array.isArray(workflow.on.event)
-                            ? workflow.on.event.map((event) => (0, apply_namespace_1.applyNamespace)(event, this.client.config.namespace))
-                            : [(0, apply_namespace_1.applyNamespace)(workflow.on.event, this.client.config.namespace)]
-                        : []),
-                ];
-                const cronTriggers = [
-                    ...(workflow.onCrons || []),
-                    ...(workflow.on && 'cron' in workflow.on && workflow.on.cron
-                        ? Array.isArray(workflow.on.cron)
-                            ? workflow.on.cron
-                            : [workflow.on.cron]
-                        : []),
-                ];
-                const concurrencyArr = Array.isArray(concurrency) ? concurrency : [];
-                const concurrencySolo = !Array.isArray(concurrency) ? concurrency : undefined;
-                assertValidConcurrencyArr(concurrencyArr);
-                assertValidConcurrencyArr(concurrencySolo ? [concurrencySolo] : undefined);
-                // Convert Zod schema to JSON Schema if provided
-                let inputJsonSchema;
-                if (workflow.inputValidator) {
-                    const jsonSchema = z.toJSONSchema(workflow.inputValidator);
-                    inputJsonSchema = new TextEncoder().encode(JSON.stringify(jsonSchema));
-                }
-                const durableTaskSet = new Set(workflow._durableTasks);
-                let stickyStrategy;
-                // `workflow.sticky` is optional. When omitted, we don't set any sticky strategy.
-                //
-                // When provided, `workflow.sticky` is a v1 (non-protobuf) config which may also include
-                // legacy protobuf enum values for backwards compatibility.
-                if (workflow.sticky != null) {
-                    switch (workflow.sticky) {
-                        case 'soft':
-                        case 'SOFT':
-                        case 0:
-                            stickyStrategy = workflows_1.StickyStrategy.SOFT;
-                            break;
-                        case 'hard':
-                        case 'HARD':
-                        case 1:
-                            stickyStrategy = workflows_1.StickyStrategy.HARD;
-                            break;
-                        default:
-                            throw new hatchet_error_1.default(`Invalid sticky strategy: ${workflow.sticky}`);
-                    }
-                }
-                const registeredWorkflow = this.client.admin.putWorkflow({
-                    name: workflow.name,
-                    description: workflow.description || '',
-                    version: workflow.version || '',
-                    eventTriggers,
-                    cronTriggers,
-                    sticky: stickyStrategy,
-                    concurrencyArr: mapConcurrencyPb(concurrencyArr),
-                    onFailureTask,
-                    defaultPriority: workflow.defaultPriority,
-                    inputJsonSchema,
-                    tasks: [...workflow._tasks, ...workflow._durableTasks].map((task) => {
-                        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
-                        return ({
-                            readableId: task.name,
-                            action: `${workflow.name}:${task.name}`,
-                            timeout: resolveExecutionTimeout(task, workflow.taskDefaults),
-                            scheduleTimeout: resolveScheduleTimeout(task, workflow.taskDefaults),
-                            inputs: '{}',
-                            parents: (_b = (_a = task.parents) === null || _a === void 0 ? void 0 : _a.map((p) => p.name)) !== null && _b !== void 0 ? _b : [],
-                            userData: '{}',
-                            // Batch tasks buffer many concurrent runs into a single execution; per-item retry
-                            // semantics don't apply, so retries is always forced to 0.
-                            retries: batchOf(task) ? 0 : task.retries || ((_c = workflow.taskDefaults) === null || _c === void 0 ? void 0 : _c.retries) || 0,
-                            rateLimits: mapRateLimitPb(task.rateLimits || ((_d = workflow.taskDefaults) === null || _d === void 0 ? void 0 : _d.rateLimits)),
-                            workerLabels: mapWorkerLabelPb(task.desiredWorkerLabels || ((_e = workflow.taskDefaults) === null || _e === void 0 ? void 0 : _e.workerLabels)),
-                            backoffFactor: ((_f = task.backoff) === null || _f === void 0 ? void 0 : _f.factor) || ((_h = (_g = workflow.taskDefaults) === null || _g === void 0 ? void 0 : _g.backoff) === null || _h === void 0 ? void 0 : _h.factor),
-                            backoffMaxSeconds: ((_j = task.backoff) === null || _j === void 0 ? void 0 : _j.maxSeconds) || ((_l = (_k = workflow.taskDefaults) === null || _k === void 0 ? void 0 : _k.backoff) === null || _l === void 0 ? void 0 : _l.maxSeconds),
-                            conditions: (0, transformer_1.taskConditionsToPb)(task, this.client.config.namespace),
-                            isDurable: durableTaskSet.has(task),
-                            slotRequests: mapSlotRequestsPb(task, durableTaskSet.has(task)),
-                            batch: mapBatchConfigPb(batchOf(task)),
-                            concurrency: (() => {
-                                const taskConcurrency = taskConcurrencyArr(task, workflow);
-                                assertValidConcurrencyArr(taskConcurrency);
-                                return mapConcurrencyPb(taskConcurrency);
-                            })(),
-                        });
-                    }),
-                    concurrency: concurrencySolo ? mapConcurrencyPb([concurrencySolo])[0] : undefined,
-                    defaultFilters: (_w = (_v = workflow.defaultFilters) === null || _v === void 0 ? void 0 : _v.map((f) => ({
-                        scope: f.scope,
-                        expression: f.expression,
-                        payload: f.payload ? new TextEncoder().encode(JSON.stringify(f.payload)) : undefined,
-                    }))) !== null && _w !== void 0 ? _w : [],
-                    idempotency: workflow.idempotency
-                        ? {
-                            expression: workflow.idempotency.expression,
-                            ttlMs: workflow.idempotency.strategy === 'status'
-                                ? workflow.idempotency.fallbackTtlMs
-                                : workflow.idempotency.ttlMs,
-                            method: workflow.idempotency.strategy === 'status'
-                                ? workflows_2.IdempotencyMethod.STATUS
-                                : workflows_2.IdempotencyMethod.TTL,
-                        }
-                        : undefined,
-                });
+                const registeredWorkflow = this.client.admin.putWorkflow((0, workflow_proto_1.workflowToProto)(workflow, { namespace, durable }));
                 this.registeredWorkflowPromises.push(registeredWorkflow);
                 yield registeredWorkflow;
                 this.workflow_registry.push(workflow);
@@ -960,125 +787,6 @@ class InternalWorker {
     }
 }
 exports.InternalWorker = InternalWorker;
-function mapWorkerLabelPb(in_) {
-    if (!in_) {
-        return {};
-    }
-    return Object.entries(in_).reduce((acc, [key, label]) => {
-        if (!label) {
-            return Object.assign(Object.assign({}, acc), { [key]: {
-                    strValue: undefined,
-                    intValue: undefined,
-                } });
-        }
-        if (typeof label === 'string') {
-            return Object.assign(Object.assign({}, acc), { [key]: {
-                    strValue: label,
-                    intValue: undefined,
-                } });
-        }
-        if (typeof label === 'number') {
-            return Object.assign(Object.assign({}, acc), { [key]: {
-                    strValue: undefined,
-                    intValue: label,
-                } });
-        }
-        return Object.assign(Object.assign({}, acc), { [key]: {
-                strValue: typeof label.value === 'string' ? label.value : undefined,
-                intValue: typeof label.value === 'number' ? label.value : undefined,
-                required: label.required,
-                weight: label.weight,
-                comparator: label.comparator,
-            } });
-    }, {});
-}
-function onFailureTaskName(workflow) {
-    return `${workflow.name}:on-failure-task`;
-}
-function getLeaves(tasks) {
-    return tasks.filter((task) => isLeafTask(task, tasks));
-}
-function isLeafTask(task, allTasks) {
-    return !allTasks.some((t) => { var _a; return (_a = t.parents) === null || _a === void 0 ? void 0 : _a.some((p) => p.name === task.name); });
-}
-/** Durable tasks stay on the durable pool; slotCost applies only to the default pool. */
-function mapSlotRequestsPb(task, isDurable) {
-    if (task.slotRequests) {
-        return task.slotRequests;
-    }
-    if (isDurable) {
-        return { durable: 1 };
-    }
-    if (task.slotCost !== undefined) {
-        if (!Number.isInteger(task.slotCost) || task.slotCost <= 0) {
-            throw new Error(`slotCost must be a positive integer, got: ${task.slotCost}`);
-        }
-        return { default: task.slotCost };
-    }
-    return { default: 1 };
-}
-function mapRateLimitPb(limits) {
-    if (!limits) {
-        return [];
-    }
-    return limits.map((l) => {
-        let key = l.staticKey;
-        const keyExpression = l.dynamicKey;
-        if (l.key !== undefined) {
-            console.warn('key is deprecated and will be removed in a future release, please use staticKey instead');
-            ({ key } = l);
-        }
-        if (keyExpression !== undefined) {
-            if (key !== undefined) {
-                throw new Error('Cannot have both static key and dynamic key set');
-            }
-            key = keyExpression;
-            if (!validateCelExpression(keyExpression)) {
-                throw new Error(`Invalid CEL expression: ${keyExpression}`);
-            }
-        }
-        if (key === undefined) {
-            throw new Error(`Invalid key`);
-        }
-        let units;
-        let unitsExpression;
-        if (typeof l.units === 'number') {
-            ({ units } = l);
-        }
-        else {
-            if (!validateCelExpression(l.units)) {
-                throw new Error(`Invalid CEL expression: ${l.units}`);
-            }
-            unitsExpression = l.units;
-        }
-        let limitExpression;
-        if (l.limit !== undefined) {
-            if (typeof l.limit === 'number') {
-                limitExpression = `${l.limit}`;
-            }
-            else {
-                if (!validateCelExpression(l.limit)) {
-                    throw new Error(`Invalid CEL expression: ${l.limit}`);
-                }
-                limitExpression = l.limit;
-            }
-        }
-        if (keyExpression !== undefined && limitExpression === undefined) {
-            throw new Error('CEL based keys requires limit to be set');
-        }
-        if (limitExpression === undefined) {
-            limitExpression = `-1`;
-        }
-        return {
-            key,
-            keyExpr: keyExpression,
-            units,
-            unitsExpr: unitsExpression,
-            limitValuesExpr: limitExpression,
-            duration: l.duration,
-        };
-    });
-}
 /**
  * Decodes the buffered items of a batch task's START_BATCH action into a Record keyed by
  * each buffered item's task-run external id, mapping to that item's input. The wire shape
@@ -1105,82 +813,3 @@ function parseBatchPayload(actionPayload) {
         return {};
     }
 }
-/** Batch tasks are only available on non-durable tasks; durable tasks never carry `batch`. */
-function batchOf(task) {
-    return 'batch' in task ? task.batch : undefined;
-}
-// mapConcurrencyPb maps SDK concurrency entries onto the proto shape; entries keep their
-// declared order, which is the chain order.
-function mapConcurrencyPb(entries) {
-    return entries.map((c) => ({
-        expression: c.expression,
-        // a string maxRuns is a CEL expression; the static field then carries the default
-        // of 1, which only governs slots created before the expression existed
-        maxRuns: typeof c.maxRuns === 'string' ? 1 : c.maxRuns,
-        limitStrategy: c.limitStrategy,
-        name: c.name,
-        isTenantScoped: c.isTenantScoped,
-        maxRunsExpression: typeof c.maxRuns === 'string' ? c.maxRuns : undefined,
-    }));
-}
-function taskConcurrencyArr(task, workflow) {
-    var _a;
-    if (task.concurrency) {
-        return Array.isArray(task.concurrency) ? task.concurrency : [task.concurrency];
-    }
-    if ((_a = workflow.taskDefaults) === null || _a === void 0 ? void 0 : _a.concurrency) {
-        return Array.isArray(workflow.taskDefaults.concurrency)
-            ? workflow.taskDefaults.concurrency
-            : [workflow.taskDefaults.concurrency];
-    }
-    return [];
-}
-function assertValidConcurrencyArr(concurrency) {
-    concurrency === null || concurrency === void 0 ? void 0 : concurrency.forEach((c) => {
-        if (typeof c.maxRuns === 'string') {
-            if (!c.maxRuns.trim()) {
-                throw new Error('concurrency.maxRuns expression must be non-empty');
-            }
-            return;
-        }
-        if (c.maxRuns !== undefined && (!Number.isInteger(c.maxRuns) || c.maxRuns <= 0)) {
-            throw new Error(`concurrency.maxRuns must be a positive integer or a CEL expression, got: ${c.maxRuns}`);
-        }
-    });
-}
-function mapBatchConfigPb(batch) {
-    if (!batch) {
-        return undefined;
-    }
-    if (!Number.isInteger(batch.maxSize) || batch.maxSize <= 0) {
-        throw new Error(`batch.maxSize must be a positive integer, got: ${batch.maxSize}`);
-    }
-    const batchMaxIntervalMs = batch.maxInterval !== undefined ? (0, duration_1.durationToMs)(batch.maxInterval) : undefined;
-    if (batchMaxIntervalMs !== undefined && batchMaxIntervalMs <= 0) {
-        throw new Error('batch.maxInterval must be positive when provided');
-    }
-    if (batch.groupMaxRuns !== undefined &&
-        (!Number.isInteger(batch.groupMaxRuns) || batch.groupMaxRuns <= 0)) {
-        throw new Error(`batch.groupMaxRuns must be a positive integer when provided, got: ${batch.groupMaxRuns}`);
-    }
-    return {
-        batchMaxSize: batch.maxSize,
-        batchMaxIntervalMs,
-        batchGroupKey: batch.groupKey,
-        batchGroupMaxRuns: batch.groupMaxRuns,
-        broadcastOutput: batch.broadcastOutput,
-    };
-}
-// Helper function to validate CEL expressions
-function validateCelExpression(_expr) {
-    // FIXME: this is a placeholder. In a real implementation, you'd need to use a CEL parser or validator.
-    // For now, we'll just return true to mimic the behavior.
-    return true;
-}
-function resolveExecutionTimeout(task, workflowDefaults) {
-    return (0, duration_1.durationToString)(task.executionTimeout || task.timeout || (workflowDefaults === null || workflowDefaults === void 0 ? void 0 : workflowDefaults.executionTimeout) || '60s');
-}
-function resolveScheduleTimeout(task, workflowDefaults) {
-    const value = task.scheduleTimeout || (workflowDefaults === null || workflowDefaults === void 0 ? void 0 : workflowDefaults.scheduleTimeout);
-    return value ? (0, duration_1.durationToString)(value) : undefined;
-}