@superdurable/dex 0.1.0

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2026 Super Durable, Inc.
+
+Licensed under the Super Durable Source License 1.0.
+You may not use this file except in compliance with the License.
+See the LICENSE file in the repository root.
+
+SPDX-License-Identifier: LicenseRef-Super-Durable-1.0

package/README.md

@@ -0,0 +1,145 @@
+# Dex SDK for TypeScript
+
+This package targets Node.js 22 and 24. It provides strongly typed workflow
+contracts and a Promise-based gRPC Client. The Client and Worker runtime use
+`@grpc/grpc-js`. The native BlobCache binding remains a separate runtime phase.
+
+Application values use `Codec<T>`. Flow, Step, RPC, Attribute, and Channel
+definitions retain their input and output types. Client methods return Promise
+because Node network I/O is asynchronous.
+
+The Client uses `@grpc/grpc-js` directly. Rust is only the implementation
+boundary for the shared BlobCache; TypeScript callbacks and network transport
+stay in Node.
+
+Step input codecs and RPC input/output codecs remain explicit because
+TypeScript erases generic types at runtime. They are serialization metadata,
+not builder arguments.
+
+```typescript
+class ApproveOrder implements Step<string> {
+  readonly inputCodec = stringCodec;
+
+  getStepType(): string {
+    return "ApproveOrder";
+  }
+
+  waitFor(_context: Context, _orderId: string): Wait {
+    return Wait.allOf(Timer.byDuration(1_000));
+  }
+
+  execute(_context: Context, orderId: string): StepDecision {
+    return gracefulComplete(orderId);
+  }
+}
+
+class Orders implements Flow<string> {
+  readonly approve = new ApproveOrder();
+
+  getFlowType(): string {
+    return "Orders";
+  }
+
+  getSteps() {
+    return StepList.startStep(this.approve);
+  }
+}
+
+const orders = new Orders();
+const registry = new Registry([orders]);
+```
+
+Flows return all Steps once. Start with `StepList.startStep(step)` and append
+heterogeneous Steps with `.otherSteps(...)`. Use
+`StepList.withoutStartStep<void>(...)` for RPC-triggered Steps, or
+`StepList.empty()` when the Flow has no Steps.
+`Flow<StartInput>` only types the starting Step and `Client.startFlow()` input;
+`StepList<StartInput>` enforces that relationship during type checking.
+Non-starting Steps may use unrelated input types. `Flow` defaults to `void` for
+Flows without a start input.
+
+`StepOptions.waitForMethodTimeoutMs` and `executeMethodTimeoutMs` bound the two
+handler calls. Timer and channel conditions determine how long a Step waits.
+
+Every TypeScript Flow and Step must return an explicit durable name from
+`getFlowType()` or `getStepType()`. Class names are never used as fallbacks
+because bundlers and minifiers may rename them.
+
+## Source layout
+
+Public contracts are grouped by domain under `src/`. The root `src/index.ts`
+is a barrel that re-exports the supported package API; applications should
+continue importing only from `@superdurable/dex`.
+
+- `codec.ts`: wire values and codecs
+- `persistence.ts`: attributes, indexes, locks, and schemas
+- `wait.ts`: channels, timers, conditions, and waits
+- `step.ts`: Steps, movements, options, and decisions
+- `rpc.ts`: typed RPC contracts and decorators
+- `flow.ts`: Flows, registration, and validation
+- `client.ts`: Promise-based FlowService Client
+- `worker.ts`: Worker gRPC service and lifecycle
+- `worker-dispatcher.ts`: typed callback dispatch and response mapping
+- `invocation-context.ts`: invocation-scoped persistence and condition state
+- `blob-cache.ts`: injectable cache contract and future N-API binding
+- `gen/`: checked-in protobuf and grpc-js bindings
+
+Run `npm test` for runtime contracts and `npm run typecheck` for strict static
+contracts. Run `./run-integration-tests.sh` for all 58 IWF compatibility
+scenarios against an isolated `dexcli dev` environment. Run
+`npm run generate:proto` after changing `protos/dex.proto`; `protoc` and its
+standard protobuf includes must be installed.
+
+## Integration coverage
+
+Run the complete integration suite with TypeScript source coverage:
+
+```shell
+npm run coverage:integration
+```
+
+The terminal report lists coverage per SDK source file and every uncovered
+line. Open `coverage/index.html` for annotated source, or inspect
+`coverage/coverage-summary.json` programmatically. `coverage/lcov.info` is the
+report uploaded by CI. Generated protobuf code under `src/gen/` is excluded.
+
+CI uploads the LCOV report to Codecov with GitHub OIDC, so no upload secret is
+stored in this repository. The report uses the `sdk-typescript-integration`
+flag and contributes to the TypeScript SDK component defined in the root
+`codecov.yml`. After the first successful `main` upload, Codecov displays
+project and patch coverage in its dashboard, GitHub checks, and PR comments.
+The Actions run also publishes the complete HTML report as
+`sdk-typescript-integration-coverage`.
+
+The complete legacy IWF integration inventory lives under
+[`test/integ`](test/integ/README.md). Its Flow fixtures retain the Java
+suite's workflow behavior and its 58 assertions run against a real Dex server.
+
+## Releases
+
+The npm package is published as [`@superdurable/dex`](https://www.npmjs.com/package/@superdurable/dex).
+Update `package.json` and `package-lock.json` to the same version, merge the
+change, then publish a GitHub Release tagged `sdk-typescript/vX.Y.Z`. The
+release workflow verifies that the tag matches `package.json`, runs type checks
+and tests, inspects the tarball, and publishes through npm Trusted Publishing.
+Prerelease versions use the `next` npm dist-tag; stable versions use `latest`.
+
+Trusted Publishing can only be configured after the package exists. Bootstrap
+the first version from a maintainer workstation with 2FA:
+
+```shell
+cd sdk-typescript
+npm ci
+npm run typecheck
+npm test
+npm pack --dry-run
+npm login
+npm publish --access public
+```
+
+Then open the package settings on npmjs.com and add a GitHub Actions trusted
+publisher with organization `superdurable`, repository `dex`, workflow
+`sdk-typescript-publish.yml`, no environment, and `npm publish` permission.
+Future releases use short-lived OIDC credentials and require no `NPM_TOKEN`.
+After verifying the first OIDC release, configure npm publishing access to
+require 2FA and disallow token-based publication.

package/dist/src/blob-cache.d.ts

@@ -0,0 +1,14 @@
+export interface BlobCacheConfig {
+    readonly directory: string;
+    readonly maxBytes: number;
+    readonly frequencyCounters?: number;
+}
+export interface BlobCache {
+    readonly config: BlobCacheConfig;
+    get(blobId: string): Uint8Array | undefined;
+    put(blobId: string, payload: Uint8Array): boolean;
+    delete(blobId: string): void;
+    deleteAll(): void;
+    close(): void;
+}
+export declare function openBlobCache(config: BlobCacheConfig): BlobCache;

package/dist/src/blob-cache.js

@@ -0,0 +1,22 @@
+// Copyright (c) 2026 Super Durable, Inc.
+//
+// Licensed under the Super Durable Source License 1.0.
+// You may not use this file except in compliance with the License.
+// See the LICENSE file in the repository root.
+//
+// SPDX-License-Identifier: LicenseRef-Super-Durable-1.0
+import { laterPhase } from "./errors.js";
+export function openBlobCache(config) {
+    if (config.directory.length === 0) {
+        throw new TypeError("blob cache directory is required");
+    }
+    if (!Number.isSafeInteger(config.maxBytes) || config.maxBytes <= 0) {
+        throw new RangeError("blob cache maxBytes must be a positive safe integer");
+    }
+    if (config.frequencyCounters !== undefined &&
+        (!Number.isSafeInteger(config.frequencyCounters) || config.frequencyCounters < 0)) {
+        throw new RangeError("blob cache frequencyCounters must be a non-negative safe integer");
+    }
+    throw laterPhase("BlobCache bridge");
+}
+//# sourceMappingURL=blob-cache.js.map

package/dist/src/blob-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blob-cache.js","sourceRoot":"","sources":["../../src/blob-cache.ts"],"names":[],"mappings":"AAAA,yCAAyC;AACzC,EAAE;AACF,uDAAuD;AACvD,mEAAmE;AACnE,+CAA+C;AAC/C,EAAE;AACF,wDAAwD;AAExD,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAiBzC,MAAM,UAAU,aAAa,CAAC,MAAuB;IACnD,IAAI,MAAM,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAClC,MAAM,IAAI,SAAS,CAAC,kCAAkC,CAAC,CAAC;IAC1D,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,MAAM,CAAC,QAAQ,IAAI,CAAC,EAAE,CAAC;QACnE,MAAM,IAAI,UAAU,CAAC,qDAAqD,CAAC,CAAC;IAC9E,CAAC;IACD,IACE,MAAM,CAAC,iBAAiB,KAAK,SAAS;QACtC,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,IAAI,MAAM,CAAC,iBAAiB,GAAG,CAAC,CAAC,EACjF,CAAC;QACD,MAAM,IAAI,UAAU,CAAC,kEAAkE,CAAC,CAAC;IAC3F,CAAC;IACD,MAAM,UAAU,CAAC,kBAAkB,CAAC,CAAC;AACvC,CAAC"}

package/dist/src/client.d.ts

@@ -0,0 +1,36 @@
+import type { BlobCache } from "./blob-cache.js";
+import type { Codec } from "./codec.js";
+import type { Context } from "./context.js";
+import { type Flow, type Registry } from "./flow.js";
+import { type ClientOptions, type FlowConfig, type FlowInfo, type ResetFlowOptions, type StartFlowOptions, type StepExecutionId, type StopFlowOptions, type TimerId } from "./options.js";
+import { AttributeMap, type Attribute } from "./persistence.js";
+import type { RPCResult } from "./rpc.js";
+import { ChannelMap, type Channel } from "./wait.js";
+export declare class Client {
+    readonly registry: Registry;
+    readonly blobCache: BlobCache;
+    readonly options: ClientOptions;
+    private readonly service;
+    private readonly hydrator;
+    constructor(registry: Registry, blobCache: BlobCache, options?: ClientOptions);
+    startFlow<StartInput>(flow: Flow<StartInput>, flowId: string, input: StartInput, options?: StartFlowOptions): Promise<string>;
+    invokeRPC<Input, Output>(rpcMethod: (context: Context, input: Input) => RPCResult<Output>, flowId: string, input: Input, runId?: string): Promise<Output>;
+    invokeRPC<Output>(rpcMethod: (context: Context) => RPCResult<Output>, flowId: string, runId?: string): Promise<Output>;
+    invokeRPC<Input>(rpcMethod: (context: Context, input: Input) => void, flowId: string, input: Input, runId?: string): Promise<void>;
+    invokeRPC(rpcMethod: (context: Context) => void, flowId: string, runId?: string): Promise<void>;
+    getAttribute<T>(flowId: string, attribute: Attribute<T>, runId?: string): Promise<T | undefined>;
+    getAttribute<T>(flowId: string, attribute: AttributeMap<T>, instance: string, runId?: string): Promise<T | undefined>;
+    setAttribute<T>(flowId: string, attribute: Attribute<T>, value: T, runId?: string): Promise<void>;
+    setAttribute<T>(flowId: string, attribute: AttributeMap<T>, instance: string, value: T, runId?: string): Promise<void>;
+    publish<T>(flowId: string, channel: Channel<T>, ...values: readonly T[]): Promise<void>;
+    publish<T>(flowId: string, channel: ChannelMap<T>, instance: string, ...values: readonly T[]): Promise<void>;
+    waitForFlow(flowId: string): Promise<void>;
+    waitForFlow<Output>(flowId: string, outputCodec: Codec<Output>, timeoutMs?: number): Promise<Output>;
+    stopFlow(flowId: string, options?: StopFlowOptions): Promise<void>;
+    describeFlow(flowId: string): Promise<FlowInfo>;
+    resetFlow(flowId: string, options: ResetFlowOptions): Promise<string>;
+    skipTimer(flowId: string, stepExecutionId: StepExecutionId, timerId: TimerId): Promise<void>;
+    waitForStepCompletion(flowId: string, stepExecutionId: StepExecutionId, timeoutMs: number): Promise<void>;
+    updateFlowConfig(flowId: string, config: FlowConfig): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/src/client.js

@@ -0,0 +1,441 @@
+// Copyright (c) 2026 Super Durable, Inc.
+//
+// Licensed under the Super Durable Source License 1.0.
+// You may not use this file except in compliance with the License.
+// See the LICENSE file in the repository root.
+//
+// SPDX-License-Identifier: LicenseRef-Super-Durable-1.0
+import { credentials, status as GrpcStatus } from "@grpc/grpc-js";
+import { ActiveStepSearchMode as ProtoActiveStepSearchMode, FlowErrorType as ProtoFlowErrorType, FlowResetType as ProtoFlowResetType, FlowServiceClient, FlowStatus as ProtoFlowStatus, IdReusePolicy as ProtoIdReusePolicy, IndexType as ProtoIndexType, ExecuteMethodFailurePolicy, StartFlowRequest, StepDurability as ProtoStepDurability, StepOptions as ProtoStepOptions, StopType as ProtoStopType, WaitForMethodFailurePolicy, } from "./gen/dex.js";
+import { DexError, ErrorSubStatus, FlowErrorType, FlowUncompletedError, LongPollTimeoutError, } from "./errors.js";
+import { registeredFlow, registeredRPC, } from "./flow.js";
+import { translateServiceError } from "./grpc-status.js";
+import { ActiveStepSearchMode, IdReusePolicy, ResetType, StopType, } from "./options.js";
+import { AttributeMap, IndexType } from "./persistence.js";
+import { requireName } from "./validation.js";
+import { decodeValue, encodeValue, ValueHydrator } from "./value-mapper.js";
+import { ChannelMap } from "./wait.js";
+const defaultServerAddress = "localhost:8801";
+export class Client {
+    registry;
+    blobCache;
+    options;
+    service;
+    hydrator;
+    constructor(registry, blobCache, options = {}) {
+        this.registry = registry;
+        this.blobCache = blobCache;
+        this.options = options;
+        this.service = new FlowServiceClient(options.serverAddress ?? defaultServerAddress, credentials.createInsecure());
+        this.hydrator = new ValueHydrator(this.service, blobCache);
+    }
+    async startFlow(flow, flowId, input, options = {}) {
+        const registered = registeredFlow(this.registry, flow);
+        const request = StartFlowRequest.create({
+            flowId: requireName(flowId),
+            flowType: registered.name,
+            flowTimeoutSeconds: seconds(options.timeoutMs),
+            requestId: options.requestId ?? crypto.randomUUID(),
+            flowStartOptions: {
+                idReusePolicy: mapIdReusePolicy(options.idReusePolicy),
+                cronSchedule: options.cronSchedule ?? "",
+                flowStartDelaySeconds: seconds(options.startDelayMs),
+                retryPolicy: mapFlowRetryPolicy(options.retryPolicy),
+                attributes: (options.attributes ?? []).map((initial) => ({
+                    key: physicalName(initial.attribute.name, initial.instance),
+                    value: encodeValue(initial.attribute.codec, initial.value),
+                    indexConfig: mapIndex(initial.attribute.index),
+                })),
+                flowConfigOverride: mapFlowConfig(options.configOverride, this.options),
+                flowAlreadyStartedOptions: {
+                    ignoreAlreadyStartedError: options.ignoreAlreadyStarted ?? false,
+                },
+            },
+        });
+        if (registered.startStep === undefined) {
+            if (input !== undefined) {
+                throw new TypeError("Flow without a start Step requires undefined input");
+            }
+        }
+        else {
+            request.startStepType = registered.startStep.name;
+            request.stepInput = encodeValue(registered.startStep.step.inputCodec, input);
+            request.stepOptions = mapStepOptions(registered.startStep.step.getStepOptions?.(), registered.startStep.step.waitFor === undefined, registered);
+        }
+        return (await unary((callback) => this.service.startFlow(request, callback)))
+            .runId;
+    }
+    async invokeRPC(rpcMethod, flowId, inputOrRunId, runId = "") {
+        const rpc = registeredRPC(this.registry, rpcMethod);
+        const hasInput = rpc.options.inputCodec !== undefined;
+        const response = await unary((callback) => this.service.invokeRpc({
+            flowId: requireName(flowId),
+            runId: hasInput ? runId : inputOrRunId ?? "",
+            rpcName: rpc.name,
+            input: hasInput
+                ? encodeValue(rpc.options.inputCodec, inputOrRunId)
+                : undefined,
+            timeoutSeconds: seconds(rpc.options.timeoutMs),
+            lockAttributeKeys: (rpc.options.lockAttributes ?? []).map((lock) => physicalName(lock.attribute.name, lock.instance)),
+            requestId: crypto.randomUUID(),
+        }, callback));
+        if (rpc.options.outputCodec === undefined) {
+            return undefined;
+        }
+        return decodeValue(rpc.options.outputCodec, await this.hydrator.hydrate(response.output));
+    }
+    async getAttribute(flowId, attribute, instanceOrRunId = "", runId = "") {
+        const isMap = attribute instanceof AttributeMap;
+        const response = await unary((callback) => this.service.getAttributes({
+            flowId: requireName(flowId),
+            runId: isMap ? runId : instanceOrRunId,
+            keys: [physicalName(attribute.name, isMap ? instanceOrRunId : undefined)],
+            allKeys: false,
+        }, callback));
+        const value = response.attributes[0]?.value;
+        if (value === undefined) {
+            return undefined;
+        }
+        return decodeValue(attribute.codec, await this.hydrator.hydrate(value));
+    }
+    async setAttribute(flowId, attribute, instanceOrValue, valueOrRunId, runId = "") {
+        const isMap = attribute instanceof AttributeMap;
+        const instance = isMap ? String(instanceOrValue) : undefined;
+        const value = isMap ? valueOrRunId : instanceOrValue;
+        await unary((callback) => this.service.setAttributes({
+            flowId: requireName(flowId),
+            runId: isMap ? runId : typeof valueOrRunId === "string" ? valueOrRunId : "",
+            attributes: [
+                {
+                    key: physicalName(attribute.name, instance),
+                    value: encodeValue(attribute.codec, value),
+                    indexConfig: mapIndex(attribute.index),
+                },
+            ],
+            requestId: crypto.randomUUID(),
+        }, callback));
+    }
+    async publish(flowId, channel, ...instanceAndValues) {
+        const isMap = channel instanceof ChannelMap;
+        const instance = isMap ? String(instanceAndValues[0]) : undefined;
+        const values = isMap ? instanceAndValues.slice(1) : instanceAndValues;
+        await unary((callback) => this.service.publishToChannel({
+            flowId: requireName(flowId),
+            runId: "",
+            messages: values.map((value) => ({
+                channelName: physicalName(channel.name, instance),
+                value: encodeValue(channel.codec, value),
+            })),
+        }, callback));
+    }
+    async waitForFlow(flowId, outputCodec, timeoutMs) {
+        let response;
+        try {
+            response = await unary((callback) => this.service.waitForFlow({
+                flowId: requireName(flowId),
+                runId: "",
+                needsResults: outputCodec !== undefined,
+                waitTimeSeconds: seconds(timeoutMs),
+            }, callback));
+        }
+        catch (failure) {
+            if (failure instanceof DexError &&
+                (failure.code === GrpcStatus.DEADLINE_EXCEEDED ||
+                    failure.subStatus === ErrorSubStatus.LONG_POLL_TIMEOUT)) {
+                throw new LongPollTimeoutError(flowId, { cause: failure });
+            }
+            throw failure;
+        }
+        if (response.flowStatus !== ProtoFlowStatus.FLOW_STATUS_COMPLETED) {
+            const summary = await this.describeFlow(flowId);
+            const results = await this.hydrator.hydrateAll(response.results.map((result) => result.completedStepOutput));
+            throw new FlowUncompletedError(summary.runId, mapFlowStatus(response.flowStatus), mapFlowErrorType(response.errorType), response.errorMessage || undefined, results);
+        }
+        if (outputCodec === undefined) {
+            return undefined;
+        }
+        for (let index = response.results.length - 1; index >= 0; index -= 1) {
+            const value = response.results[index]?.completedStepOutput;
+            if (value !== undefined) {
+                return decodeValue(outputCodec, await this.hydrator.hydrate(value));
+            }
+        }
+        throw new TypeError(`Flow ${flowId} completed without an output`);
+    }
+    async stopFlow(flowId, options = {}) {
+        await unary((callback) => this.service.stopFlow({
+            flowId: requireName(flowId),
+            runId: "",
+            reason: options.reason ?? "",
+            stopType: mapStopType(options.type),
+        }, callback));
+    }
+    async describeFlow(flowId) {
+        const response = await unary((callback) => this.service.getFlowSummary({ flowId: requireName(flowId), runId: "" }, callback));
+        if (response.flowExecutionId === undefined || response.startTime === undefined) {
+            throw new TypeError(`Dex returned an incomplete summary for Flow ${flowId}`);
+        }
+        return {
+            flowId: response.flowExecutionId.flowId,
+            runId: response.flowExecutionId.runId,
+            flowType: response.flowType,
+            status: mapFlowStatus(response.flowStatus),
+            startedAt: response.startTime,
+        };
+    }
+    async resetFlow(flowId, options) {
+        const response = await unary((callback) => this.service.resetFlow({
+            flowId: requireName(flowId),
+            runId: "",
+            resetType: mapResetType(options.type),
+            historyEventId: number64(options.historyEventId),
+            reason: options.reason ?? "",
+            historyEventTime: options.historyEventTime?.toISOString() ?? "",
+            stepType: options.stepType ?? "",
+            stepExecutionId: options.stepExecutionId ?? "",
+            skipChannelMessagesReapply: options.skipChannelMessagesReapply ?? false,
+            skipLockingRpcReapply: options.skipLockingRpcReapply ?? false,
+        }, callback));
+        return response.runId;
+    }
+    async skipTimer(flowId, stepExecutionId, timerId) {
+        await unary((callback) => this.service.skipTimer({
+            flowId: requireName(flowId),
+            runId: "",
+            stepExecutionId: `${stepExecutionId.stepType}-${stepExecutionId.number ?? 1}`,
+            timerConditionId: timerId.conditionId ?? "",
+            timerConditionIndex: timerId.conditionIndex,
+        }, callback));
+    }
+    async waitForStepCompletion(flowId, stepExecutionId, timeoutMs) {
+        await unary((callback) => this.service.waitForStepCompletion({
+            flowId: requireName(flowId),
+            stepType: stepExecutionId.stepType,
+            stepExecutionNumber: String(stepExecutionId.number ?? 1),
+            waitTimeSeconds: seconds(timeoutMs),
+            requestId: crypto.randomUUID(),
+        }, callback));
+    }
+    async updateFlowConfig(flowId, config) {
+        await unary((callback) => this.service.updateFlowConfig({
+            flowId: requireName(flowId),
+            runId: "",
+            flowConfig: mapFlowConfig(config, this.options),
+        }, callback));
+    }
+    async close() {
+        this.service.close();
+    }
+}
+function mapStepOptions(options, skipWaitFor, flow) {
+    const executeFailureStep = options?.executeFailure?.step;
+    const executeFailureDefinition = executeFailureStep === undefined
+        ? undefined
+        : flow.steps.find((definition) => definition.step === executeFailureStep);
+    if (executeFailureStep !== undefined && executeFailureDefinition === undefined) {
+        throw new TypeError("execute failure Step must belong to the Flow");
+    }
+    const executeFailureOptions = options?.executeFailure?.options ?? executeFailureDefinition?.step.getStepOptions?.();
+    return ProtoStepOptions.create({
+        waitForTimeoutSeconds: seconds(options?.waitForMethodTimeoutMs),
+        executeTimeoutSeconds: seconds(options?.executeMethodTimeoutMs),
+        waitForRetryPolicy: mapRetryPolicy(options?.waitForRetry),
+        executeRetryPolicy: mapRetryPolicy(options?.executeRetry),
+        waitForFailurePolicy: options?.waitForFailure === "proceed"
+            ? WaitForMethodFailurePolicy.WAIT_FOR_METHOD_FAILURE_POLICY_PROCEED_ON_FAILURE
+            : options?.waitForFailure === "failFlow"
+                ? WaitForMethodFailurePolicy.WAIT_FOR_METHOD_FAILURE_POLICY_FAIL_FLOW_ON_FAILURE
+                : WaitForMethodFailurePolicy.WAIT_FOR_METHOD_FAILURE_POLICY_UNSPECIFIED,
+        executeFailurePolicy: executeFailureDefinition === undefined
+            ? ExecuteMethodFailurePolicy.EXECUTE_METHOD_FAILURE_POLICY_UNSPECIFIED
+            : ExecuteMethodFailurePolicy.EXECUTE_METHOD_FAILURE_POLICY_PROCEED_TO_CONFIGURED_STEP,
+        executeFailureProceedStepType: executeFailureDefinition?.name ?? "",
+        executeFailureProceedStepOptions: executeFailureDefinition === undefined
+            ? undefined
+            : mapStepOptions(executeFailureOptions, executeFailureDefinition.step.waitFor === undefined, flow),
+        skipWaitFor,
+        waitForDurabilityOverride: mapDurability(options?.waitForDurability),
+        executeDurabilityOverride: mapDurability(options?.executeDurability),
+        waitForLockAttributeKeys: (options?.waitForLockAttributes ?? []).map((lock) => physicalName(lock.attribute.name, lock.instance)),
+        executeLockAttributeKeys: (options?.executeLockAttributes ?? []).map((lock) => physicalName(lock.attribute.name, lock.instance)),
+    });
+}
+function mapRetryPolicy(retry) {
+    if (retry === undefined) {
+        return undefined;
+    }
+    return {
+        initialIntervalSeconds: seconds(retry.initialIntervalMs),
+        backoffCoefficient: retry.backoffCoefficient ?? 0,
+        maximumIntervalSeconds: seconds(retry.maximumIntervalMs),
+        maximumAttempts: retry.maximumAttempts ?? 0,
+        totalDurationSeconds: seconds(retry.totalDurationMs),
+    };
+}
+function mapFlowRetryPolicy(retry) {
+    if (retry === undefined) {
+        return undefined;
+    }
+    return {
+        initialIntervalSeconds: seconds(retry.initialIntervalMs),
+        backoffCoefficient: retry.backoffCoefficient ?? 0,
+        maximumIntervalSeconds: seconds(retry.maximumIntervalMs),
+        maximumAttempts: retry.maximumAttempts ?? 0,
+    };
+}
+function mapFlowConfig(config, clientOptions) {
+    const workerTarget = config?.workerTarget ?? clientOptions.workerTarget;
+    if (config === undefined && workerTarget === undefined) {
+        return undefined;
+    }
+    return {
+        activeStepSearchMode: config?.activeStepSearchMode === undefined
+            ? undefined
+            : config.activeStepSearchMode === ActiveStepSearchMode.ALL
+                ? ProtoActiveStepSearchMode.ACTIVE_STEP_SEARCH_MODE_ENABLED_FOR_ALL
+                : ProtoActiveStepSearchMode.ACTIVE_STEP_SEARCH_MODE_UNSPECIFIED,
+        continueAsNewThreshold: config?.continueAsNewThreshold,
+        continueAsNewPageSizeInBytes: config?.continueAsNewPageSizeBytes,
+        stepDurability: config?.stepDurability === undefined ? undefined : mapDurability(config.stepDurability),
+        workerTarget: workerTarget === undefined
+            ? undefined
+            : { address: workerTarget.address, isHeadlessAddress: workerTarget.headless ?? false },
+    };
+}
+function mapIndex(index) {
+    if (index === undefined) {
+        return undefined;
+    }
+    const types = {
+        [IndexType.KEYWORD]: ProtoIndexType.INDEX_TYPE_KEYWORD,
+        [IndexType.FULL_TEXT]: ProtoIndexType.INDEX_TYPE_TEXT,
+        [IndexType.KEYWORD_ARRAY]: ProtoIndexType.INDEX_TYPE_KEYWORD_ARRAY,
+        [IndexType.INT]: ProtoIndexType.INDEX_TYPE_INT,
+        [IndexType.DOUBLE]: ProtoIndexType.INDEX_TYPE_DOUBLE,
+        [IndexType.BOOL]: ProtoIndexType.INDEX_TYPE_BOOL,
+        [IndexType.DATETIME]: ProtoIndexType.INDEX_TYPE_DATETIME,
+    };
+    return {
+        enable: true,
+        type: types[index.type],
+        indexKey: index.indexKey ?? "",
+    };
+}
+function mapIdReusePolicy(policy) {
+    switch (policy) {
+        case IdReusePolicy.ALLOW_IF_PREVIOUS_FAILED:
+            return ProtoIdReusePolicy.ID_REUSE_POLICY_ALLOW_IF_PREVIOUS_EXISTS_ABNORMALLY;
+        case IdReusePolicy.ALLOW_IF_NOT_RUNNING:
+            return ProtoIdReusePolicy.ID_REUSE_POLICY_ALLOW_IF_NO_RUNNING;
+        case IdReusePolicy.ALLOW_TERMINATE_IF_RUNNING:
+            return ProtoIdReusePolicy.ID_REUSE_POLICY_ALLOW_TERMINATE_IF_RUNNING;
+        case IdReusePolicy.DISALLOW:
+            return ProtoIdReusePolicy.ID_REUSE_POLICY_DISALLOW_REUSE;
+        default:
+            return ProtoIdReusePolicy.ID_REUSE_POLICY_UNSPECIFIED;
+    }
+}
+function mapStopType(type) {
+    switch (type) {
+        case StopType.TERMINATE:
+            return ProtoStopType.STOP_TYPE_TERMINATE;
+        case StopType.FAIL:
+            return ProtoStopType.STOP_TYPE_FAIL;
+        default:
+            return ProtoStopType.STOP_TYPE_CANCEL;
+    }
+}
+function mapResetType(type) {
+    const types = {
+        [ResetType.BEGINNING]: ProtoFlowResetType.FLOW_RESET_TYPE_BEGINNING,
+        [ResetType.HISTORY_EVENT_ID]: ProtoFlowResetType.FLOW_RESET_TYPE_HISTORY_EVENT_ID,
+        [ResetType.HISTORY_EVENT_TIME]: ProtoFlowResetType.FLOW_RESET_TYPE_HISTORY_EVENT_TIME,
+        [ResetType.STEP_TYPE]: ProtoFlowResetType.FLOW_RESET_TYPE_STEP_TYPE,
+        [ResetType.STEP_EXECUTION_ID]: ProtoFlowResetType.FLOW_RESET_TYPE_STEP_EXECUTION_ID,
+    };
+    return types[type];
+}
+function mapDurability(value) {
+    if (value === "sync") {
+        return ProtoStepDurability.STEP_DURABILITY_SYNC;
+    }
+    if (value === "async") {
+        return ProtoStepDurability.STEP_DURABILITY_ASYNC;
+    }
+    return ProtoStepDurability.STEP_DURABILITY_UNSPECIFIED;
+}
+function mapFlowStatus(status) {
+    switch (status) {
+        case ProtoFlowStatus.FLOW_STATUS_RUNNING:
+            return "running";
+        case ProtoFlowStatus.FLOW_STATUS_COMPLETED:
+            return "completed";
+        case ProtoFlowStatus.FLOW_STATUS_FAILED:
+            return "failed";
+        case ProtoFlowStatus.FLOW_STATUS_TIMEOUT:
+            return "timedOut";
+        case ProtoFlowStatus.FLOW_STATUS_TERMINATED:
+            return "terminated";
+        case ProtoFlowStatus.FLOW_STATUS_CANCELED:
+            return "cancelled";
+        case ProtoFlowStatus.FLOW_STATUS_CONTINUED_AS_NEW:
+            return "continuedAsNew";
+        default:
+            throw new TypeError(`unsupported Flow status ${status}`);
+    }
+}
+function mapFlowErrorType(type) {
+    switch (type) {
+        case ProtoFlowErrorType.FLOW_ERROR_TYPE_STEP_DECISION_FAILING_FLOW:
+            return FlowErrorType.STEP_DECISION_FAILED;
+        case ProtoFlowErrorType.FLOW_ERROR_TYPE_CLIENT_API_FAILING_FLOW:
+            return FlowErrorType.CLIENT_API_FAILED;
+        case ProtoFlowErrorType.FLOW_ERROR_TYPE_WORKER_API_FAIL:
+            return FlowErrorType.WORKER_API_FAILED;
+        case ProtoFlowErrorType.FLOW_ERROR_TYPE_INVALID_USER_FLOW_CODE:
+            return FlowErrorType.INVALID_USER_FLOW_CODE;
+        case ProtoFlowErrorType.FLOW_ERROR_TYPE_INTERNAL:
+            return FlowErrorType.INTERNAL;
+        default:
+            return undefined;
+    }
+}
+function physicalName(name, instance) {
+    if (instance === undefined) {
+        return name;
+    }
+    requireName(instance);
+    const encoded = encodeURIComponent(instance).replace(/[!'()*]/g, (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`);
+    return `${name}/${encoded}`;
+}
+function seconds(milliseconds) {
+    if (milliseconds === undefined) {
+        return 0;
+    }
+    if (!Number.isSafeInteger(milliseconds) || milliseconds < 0 || milliseconds % 1_000 !== 0) {
+        throw new RangeError("duration must be a non-negative whole number of seconds");
+    }
+    return milliseconds / 1_000;
+}
+function number64(value) {
+    if (value === undefined) {
+        return 0;
+    }
+    const number = Number(value);
+    if (!Number.isSafeInteger(number)) {
+        throw new RangeError("history event ID exceeds JavaScript's safe integer range");
+    }
+    return number;
+}
+function unary(invoke) {
+    return new Promise((resolve, reject) => {
+        invoke((error, response) => {
+            if (error !== null) {
+                reject(translateServiceError(error));
+                return;
+            }
+            resolve(response);
+        });
+    });
+}
+//# sourceMappingURL=client.js.map