@superdurable/dex 0.5.0 → 0.7.0

package/README.md

@@ -1,10 +1,10 @@
 # Dex SDK for TypeScript
 
-## Pending Channel messages
+## Flow state I/O
 
-`Client.getChannelMessages` returns typed `ChannelMessage<T>` envelopes in FIFO
-order. `Client.deleteChannelMessage` deletes a still-pending ID and rejects with
-`ChannelMessageNotFoundError` after consumption or another deletion.
+Applications read and write Flow state through typed RPCs. The Client does not
+expose direct Attribute reads or writes, Channel publication, or pending-message
+mutation. This keeps each external state transition behind a Flow-owned method.
 
 An RPC can stage `channel.delete(context, messageId)`. Set the decorator option
 `isTransactional: true` when a missing ID must abort all other RPC writes.
@@ -221,6 +221,17 @@ and `getAllInstanceKeys` include buffered sets and deletes. The matching
 instances. Keys are decoded and sorted. Use
 `forceCompleteIfChannelsEmpty(...)` for conditional completion.
 
+Request IDs are optional for both durable waits. When omitted, the server
+derives a namespaced stable ID from the Step execution or Attribute condition,
+such as `wait-for-attribute:myInt>10`. Reuse an override only for the same
+logical wait. The Client automatically reattaches transport long polls. If an
+earlier Update with that ID exhausted its handler budget, the server appends an
+increasing `-N` suffix and starts a new Update. `maximumWaitTimeMs` is optional
+and is the total handler budget across reattachments; omit it or use zero to
+wait indefinitely. A positive budget expiry throws `WaitHandlerTimeoutError`.
+An abandoned infinite wait remains accepted and counts against Temporal's
+in-flight Update limit until it completes or the Flow closes.
+
 ### Async handlers
 
 `Step.execute`, `Step.waitFor`, and RPC methods may be `async` and return a
@@ -299,6 +310,14 @@ must be non-empty, may contain `#`, and may repeat; every write appends a new
 message. `Client.readStream` returns it as `StreamMessage.source`. Step writes
 use `#<stepExecutionID>` as source metadata.
 
+`Client.readStream` moves forward one message at a time and can long-poll.
+`Client.listStreamMessages` returns a non-blocking newest-first retained page.
+Pass the registered typed `Stream`, a positive page size, and an empty token for
+the first page. Pass `StreamMessagesPage.nextPageToken` unchanged to read older
+messages until it is empty. The server caps page size at 1000 by default. A
+trimmed anchor returns an empty page, and newer concurrent writes do not enter
+an existing older-page chain.
+
 Step durability defaults to the Flow configuration and then sync. Regular
 attempts default to two hours, heartbeat timeout defaults to one minute, and
 retry total duration defaults to four hours. The SDK accepts non-negative
@@ -347,7 +366,7 @@ Flow config, Condition ID, and reuse. Parent completion does not cancel an unfin
 ## Errors
 
 Client calls reject with concrete `DexServiceError` subclasses. Existing-Flow
-reads (`getAttribute`, `describeFlow`, `waitForFlow`, and `timeTravel`) use
+reads (`describeFlow`, `waitForFlow`, and `timeTravel`) use
 `FlowNotFoundError`; operations that require a running Flow use
 `FlowNotActiveError`. Start conflicts, worker failures, RPC lock contention,
 and long-poll timeouts use `FlowAlreadyStartedError`,
@@ -355,7 +374,7 @@ and long-poll timeouts use `FlowAlreadyStartedError`,
 
 ```typescript
 try {
-  await client.publish(flowId, orders.approved, orderId);
+  await client.invokeRPC(orders.updateOrder, flowId, update);
 } catch (error) {
   if (error instanceof FlowNotActiveError) {
     // The Flow is missing or already closed.

package/dist/src/client.d.ts

@@ -3,10 +3,9 @@ import { AttributeMatch } from "./attribute-match.js";
 import type { Context } from "./context.js";
 import { type Flow, type Registry } from "./flow.js";
 import { type FlowResult } from "./flow-result.js";
-import { type ClientOptions, type FlowConfig, type FlowInfo, type TimeTravelOptions, type SearchFlowsPage, type StartFlowOptions, type StepExecutionId, type StopFlowOptions, type TimerId } from "./options.js";
+import { type ClientOptions, type FlowConfig, type FlowInfo, type TimeTravelOptions, type SearchFlowsPage, type StartFlowOptions, type StepExecutionId, type StopFlowOptions, type TimerId, type WaitForAttributeOptions, type WaitForStepCompletionOptions } from "./options.js";
 import { Attribute, AttributeMap } from "./persistence.js";
 import type { RPCResult } from "./rpc.js";
-import { Channel, ChannelMap, type ChannelMessage } from "./wait.js";
 import type { Stream, StreamMessage, StreamMessagesPage } from "./stream.js";
 /**
  * Calls Dex FlowService through registered, typed Flow definitions.
@@ -87,97 +86,6 @@ export declare class Client {
      * @returns A promise resolved after successful handler completion.
      */
     invokeRPC(rpcMethod: (context: Context) => void | Promise<void>, flowId: string, runId?: string): Promise<void>;
-    /**
-     * Reads a singleton Attribute.
-     * @typeParam T - Attribute value type.
-     * @param flowId - Non-empty existing Flow ID.
-     * @param attribute - Typed singleton Attribute definition.
-     * @param runId - Optional exact run; targets the current run when omitted.
-     * @returns The decoded value, or `undefined` when unset.
-     */
-    getAttribute<T>(flowId: string, attribute: Attribute<T>, runId?: string): Promise<T | undefined>;
-    /**
-     * Reads one AttributeMap instance.
-     * @typeParam T - Attribute value type.
-     * @param flowId - Non-empty existing Flow ID.
-     * @param attribute - Typed AttributeMap definition.
-     * @param instance - The map instance. Slash is prohibited because it is a reserved character.
-     * @param runId - Optional exact run; targets the current run when omitted.
-     * @returns The decoded value, or `undefined` when unset.
-     */
-    getAttribute<T>(flowId: string, attribute: AttributeMap<T>, instance: string, runId?: string): Promise<T | undefined>;
-    /**
-     * Writes a singleton Attribute on an active Flow.
-     * @typeParam T - Attribute value type.
-     * @param flowId - Non-empty active Flow ID.
-     * @param attribute - Typed singleton Attribute definition.
-     * @param value - Value encoded by the Attribute codec.
-     * @param runId - Optional exact run; targets the active run when omitted.
-     * @returns A promise resolved after Dex applies the write.
-     */
-    setAttribute<T>(flowId: string, attribute: Attribute<T>, value: T, runId?: string): Promise<void>;
-    /**
-     * Writes one AttributeMap instance on an active Flow.
-     * @typeParam T - Attribute value type.
-     * @param flowId - Non-empty active Flow ID.
-     * @param attribute - Typed AttributeMap definition.
-     * @param instance - The map instance. Slash is prohibited because it is a reserved character.
-     * @param value - Value encoded by the Attribute codec.
-     * @param runId - Optional exact run; targets the active run when omitted.
-     * @returns A promise resolved after Dex applies the write.
-     */
-    setAttribute<T>(flowId: string, attribute: AttributeMap<T>, instance: string, value: T, runId?: string): Promise<void>;
-    /**
-     * Publishes one or more values to a singleton Channel.
-     * @typeParam T - Channel element type.
-     * @param flowId - Non-empty active Flow ID.
-     * @param channel - Typed singleton Channel definition.
-     * @param values - Values appended in argument order.
-     * @returns A promise resolved after Dex accepts the batch.
-     */
-    publish<T>(flowId: string, channel: Channel<T>, ...values: readonly T[]): Promise<void>;
-    /**
-     * Publishes one or more values to a ChannelMap instance.
-     * @typeParam T - Channel element type.
-     * @param flowId - Non-empty active Flow ID.
-     * @param channel - Typed ChannelMap definition.
-     * @param instance - The map instance. Slash is prohibited because it is a reserved character.
-     * @param values - Values appended in argument order.
-     * @returns A promise resolved after Dex accepts the batch.
-     */
-    publish<T>(flowId: string, channel: ChannelMap<T>, instance: string, ...values: readonly T[]): Promise<void>;
-    /**
-     * Returns every pending singleton Channel message in FIFO order.
-     * @typeParam T - Channel value type.
-     * @param flowId - Non-empty existing Flow ID.
-     * @param channel - Registered singleton Channel.
-     * @returns Typed pending message envelopes.
-     */
-    getChannelMessages<T>(flowId: string, channel: Channel<T>): Promise<readonly ChannelMessage<T>[]>;
-    /**
-     * Returns every pending message for one ChannelMap instance in FIFO order.
-     * @typeParam T - Channel value type.
-     * @param flowId - Non-empty existing Flow ID.
-     * @param channel - Registered ChannelMap.
-     * @param instance - The ChannelMap instance. Slash is prohibited because it is a reserved character.
-     * @returns Typed pending message envelopes.
-     */
-    getChannelMessages<T>(flowId: string, channel: ChannelMap<T>, instance: string): Promise<readonly ChannelMessage<T>[]>;
-    /**
-     * Deletes one pending singleton Channel message by its server-assigned ID.
-     * @param flowId - Non-empty active Flow ID.
-     * @param channel - Registered singleton Channel.
-     * @param messageId - Non-empty server-assigned message ID.
-     */
-    deleteChannelMessage(flowId: string, channel: Channel<unknown>, messageId: string): Promise<void>;
-    /**
-     * Deletes one pending message from a ChannelMap instance by server-assigned ID.
-     * @param flowId - Non-empty active Flow ID.
-     * @param channel - Registered ChannelMap.
-     * @param instance - The ChannelMap instance. Slash is prohibited because it is a reserved character.
-     * @param messageId - Non-empty server-assigned message ID.
-     */
-    deleteChannelMessage(flowId: string, channel: ChannelMap<unknown>, instance: string, messageId: string): Promise<void>;
     /**
      * Appends one typed best-effort Stream message with source metadata.
      * @typeParam T - Stream message type.
@@ -257,36 +165,40 @@ export declare class Client {
      */
     skipTimer(flowId: string, stepExecutionId: StepExecutionId, timerId: TimerId): Promise<void>;
     /**
-     * Long-polls until one Step execution completes.
+     * Waits until one Step execution completes or its total handler budget expires.
+     * The server derives a stable Request ID from the Step execution when none is supplied.
+     * Transport long polls automatically reattach to the same logical wait.
      * @param flowId - Non-empty active Flow ID.
      * @param stepExecutionId - Step type and positive execution number.
-     * @param timeoutMs - Non-negative server-side wait duration in milliseconds.
-     * @throws {@link LongPollTimeoutError} when completion is not observed in time.
+     * @param options - Optional Request ID override and total handler wait budget.
+     * @throws {@link WaitHandlerTimeoutError} when a positive handler budget expires first.
      */
-    waitForStepCompletion(flowId: string, stepExecutionId: StepExecutionId, timeoutMs: number): Promise<void>;
+    waitForStepCompletion(flowId: string, stepExecutionId: StepExecutionId, options: WaitForStepCompletionOptions): Promise<void>;
     /**
      * Waits until a singleton Attribute in the current run satisfies a match.
      * Returns the current value observed by the successful wait operation.
+     * The server derives a stable Request ID from the condition when none is supplied.
+     * Transport long polls automatically reattach to the same logical wait.
      * @typeParam T - Attribute value type.
      * @param flowId - Non-empty active Flow ID.
      * @param attribute - Registered singleton Attribute to observe.
      * @param match - Scalar predicate whose operand has the Attribute value type.
-     * @param timeoutMs - Non-negative server-side wait duration in milliseconds.
+     * @param options - Optional Request ID override and total handler wait budget.
      * @returns The matched current Attribute value.
      */
-    waitForAttributeMatch<T>(flowId: string, attribute: Attribute<T>, match: AttributeMatch<T>, timeoutMs: number): Promise<T>;
+    waitForAttributeMatch<T>(flowId: string, attribute: Attribute<T>, match: AttributeMatch<T>, options: WaitForAttributeOptions): Promise<T>;
     /**
      * Waits until one AttributeMap instance in the current run satisfies a match.
-     * Primitive-value restrictions and timeout errors match `waitForAttributeMatch`.
+     * Primitive-value restrictions, options, and timeout errors match `waitForAttributeMatch`.
      * @typeParam T - AttributeMap value type.
      * @param flowId - Non-empty active Flow ID.
      * @param attribute - Registered AttributeMap to observe.
      * @param instance - The map instance to observe. Slash is prohibited because it is a reserved character.
      * @param match - Scalar predicate whose operand has the AttributeMap value type.
-     * @param timeoutMs - Non-negative server-side wait duration in milliseconds.
+     * @param options - Optional Request ID override and total handler wait budget.
      * @returns The matched current AttributeMap value.
      */
-    waitForAttributeMatch<T>(flowId: string, attribute: AttributeMap<T>, instance: string, match: AttributeMatch<T>, timeoutMs: number): Promise<T>;
+    waitForAttributeMatch<T>(flowId: string, attribute: AttributeMap<T>, instance: string, match: AttributeMatch<T>, options: WaitForAttributeOptions): Promise<T>;
     private waitForAttributeValue;
     /**
      * Replaces mutable configuration for an active Flow.

package/dist/src/client.js

@@ -5,11 +5,11 @@
 // See the LICENSE file in the repository root.
 //
 // SPDX-License-Identifier: LicenseRef-Sustainable-Use-1.0
-import { credentials } from "@grpc/grpc-js";
+import { credentials, status } from "@grpc/grpc-js";
 import { AttributeMatch } from "./attribute-match.js";
 import { mapAttributeStoreNames, mapAttributeStoreSync } from "./attribute-store-sync.js";
 import { ActiveStepSearchMode as ProtoActiveStepSearchMode, FlowErrorType as ProtoFlowErrorType, FlowTimeoutPolicy as ProtoFlowTimeoutPolicy, FlowResetStepMethod as ProtoFlowResetStepMethod, FlowResetType as ProtoFlowResetType, FlowServiceClient, FlowStatus as ProtoFlowStatus, IdReusePolicy as ProtoIdReusePolicy, IndexType as ProtoIndexType, ExecuteMethodFailurePolicy, StartFlowRequest, StepDurability as ProtoStepDurability, StepOptions as ProtoStepOptions, FlowTimeoutHandlerOptions as ProtoFlowTimeoutHandlerOptions, StopType as ProtoStopType, WaitForMethodFailurePolicy, } from "./gen/dex.js";
-import { FlowErrorType, } from "./errors.js";
+import { ErrorSubStatus, FlowErrorType, LongPollTimeoutError, WaitHandlerTimeoutError, } from "./errors.js";
 import { registeredFlow, registeredRPC, registeredStream, } from "./flow.js";
 import { createFlowResultFromProto, } from "./flow-result.js";
 import { translateServiceError } from "./grpc-status.js";
@@ -149,115 +149,6 @@ export class Client {
         }
         return decodeValue(codecOrJson(rpc.options.outputCodec), await this.hydrator.hydrate(response.output));
     }
-    /**
-     * Reads and decodes a singleton or map Attribute.
-     * @param flowId - Non-empty existing Flow ID.
-     * @param attribute - Typed Attribute definition.
-     * @param instanceOrRunId - Map instance, or singleton run ID.
-     * @param runId - Exact run for a map read.
-     * @returns The decoded value, or `undefined` when unset.
-     */
-    async getAttribute(flowId, attribute, instanceOrRunId = "", runId = "") {
-        const isMap = attribute instanceof AttributeMap;
-        const response = await unary({ operation: "getAttribute", flowId, requirement: "existing" }, (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));
-    }
-    /**
-     * Encodes and writes a singleton or map Attribute.
-     * @param flowId - Non-empty active Flow ID.
-     * @param attribute - Typed Attribute definition.
-     * @param instanceOrValue - Map instance or singleton value.
-     * @param valueOrRunId - Map value or singleton run ID.
-     * @param runId - Exact run for a map write.
-     * @returns A promise resolved after Dex applies the write.
-     */
-    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({ operation: "setAttribute", flowId, requirement: "active" }, (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),
-                    syncConfig: mapAttributeStoreSync(attribute),
-                },
-            ],
-            requestId: crypto.randomUUID(),
-        }, callback));
-    }
-    /**
-     * Encodes and publishes a singleton or map Channel batch.
-     * @param flowId - Non-empty active Flow ID.
-     * @param channel - Typed Channel definition.
-     * @param instanceAndValues - Optional map instance followed by values.
-     * @returns A promise resolved after Dex accepts the batch.
-     */
-    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({ operation: "publish", flowId, requirement: "active" }, (callback) => this.service.publishToChannel({
-            flowId: requireName(flowId),
-            runId: "",
-            messages: values.map((value) => ({
-                channelName: physicalName(channel.name, instance),
-                value: encodeValue(channel.codec, value),
-                messageId: "",
-            })),
-        }, callback));
-    }
-    /**
-     * Implements singleton and ChannelMap pending-message reads.
-     * @typeParam T - Channel value type.
-     * @param flowId - Non-empty existing Flow ID.
-     * @param channel - Registered singleton or map definition.
-     * @param instance - Required ChannelMap instance; omitted for a singleton.
-     * @returns Typed pending message envelopes in FIFO order.
-     */
-    async getChannelMessages(flowId, channel, instance) {
-        const response = await unary({ operation: "getChannelMessages", flowId, requirement: "existing" }, (callback) => this.service.getChannelMessages({
-            flowId: requireName(flowId),
-            runId: "",
-            channelName: physicalName(channel.name, instance),
-        }, callback));
-        return Promise.all(response.messages.map(async (message) => ({
-            messageId: message.messageId,
-            value: decodeValue(channel.codec, await this.hydrator.hydrate(message.value)),
-        })));
-    }
-    /**
-     * Implements singleton and ChannelMap pending-message deletion.
-     * @param flowId - Non-empty active Flow ID.
-     * @param channel - Registered singleton or map definition.
-     * @param instanceOrMessageId - Map instance or singleton message ID.
-     * @param mapMessageId - Required message ID for a ChannelMap.
-     * @returns A promise resolved after Dex accepts the deletion.
-     */
-    async deleteChannelMessage(flowId, channel, instanceOrMessageId, mapMessageId) {
-        const isMap = channel instanceof ChannelMap;
-        const instance = isMap ? instanceOrMessageId : undefined;
-        const messageId = isMap ? mapMessageId : instanceOrMessageId;
-        await unary({ operation: "deleteChannelMessage", flowId, requirement: "active" }, (callback) => this.service.deleteChannelMessage({
-            flowId: requireName(flowId),
-            runId: "",
-            channelName: physicalName(channel.name, instance),
-            messageId: requireName(messageId ?? ""),
-            requestId: crypto.randomUUID(),
-        }, callback));
-    }
     /**
      * Appends one typed best-effort Stream message with source metadata.
      * @typeParam T - Stream message type.
@@ -468,62 +359,85 @@ export class Client {
         }, callback));
     }
     /**
-     * Long-polls until one Step execution completes.
+     * Waits until one Step execution completes or its total handler budget expires.
+     * The server derives a stable Request ID from the Step execution when none is supplied.
+     * Transport long polls automatically reattach to the same logical wait.
      * @param flowId - Non-empty active Flow ID.
      * @param stepExecutionId - Step type and positive execution number.
-     * @param timeoutMs - Non-negative server-side wait duration in milliseconds.
-     * @throws {@link LongPollTimeoutError} when completion is not observed in time.
+     * @param options - Optional Request ID override and total handler wait budget.
+     * @throws {@link WaitHandlerTimeoutError} when a positive handler budget expires first.
      */
-    async waitForStepCompletion(flowId, stepExecutionId, timeoutMs) {
-        await unary({ operation: "waitForStepCompletion", flowId, requirement: "active" }, (callback) => this.service.waitForStepCompletion({
-            flowId: requireName(flowId),
-            stepType: stepExecutionId.stepType,
-            stepExecutionNumber: String(stepExecutionId.number ?? 1),
-            waitTimeSeconds: seconds(timeoutMs),
-            requestId: crypto.randomUUID(),
-        }, callback));
+    async waitForStepCompletion(flowId, stepExecutionId, options) {
+        const waitBudget = new ClientWaitBudget(options.maximumWaitTimeMs);
+        while (true) {
+            try {
+                await unary({ operation: "waitForStepCompletion", flowId, requirement: "active" }, (callback) => this.service.waitForStepCompletion({
+                    flowId: requireName(flowId),
+                    stepType: stepExecutionId.stepType,
+                    stepExecutionNumber: String(stepExecutionId.number ?? 1),
+                    waitTimeSeconds: waitBudget.remainingSeconds("waitForStepCompletion", flowId),
+                    requestId: options.requestId ?? "",
+                }, callback));
+                return;
+            }
+            catch (error) {
+                if (!(error instanceof LongPollTimeoutError)) {
+                    throw error;
+                }
+            }
+        }
     }
     /**
      * Waits until a singleton Attribute or AttributeMap instance satisfies a match.
      * @param flowId - Non-empty active Flow ID.
      * @param attribute - Registered Attribute or AttributeMap to observe.
-     * @param args - Match and timeout, optionally preceded by a map instance.
+     * @param args - Match and options, optionally preceded by a map instance.
      * @returns The matched current value.
      */
     async waitForAttributeMatch(flowId, attribute, ...args) {
         if (attribute instanceof Attribute) {
-            if (args.length !== 2 || typeof args[1] !== "number") {
+            if (args.length !== 2 || !isWaitForAttributeOptions(args[1])) {
                 throw new TypeError("waitForAttributeMatch received invalid Attribute arguments");
             }
             return this.waitForAttributeValue(flowId, attribute, undefined, args[0], args[1]);
         }
         if (attribute instanceof AttributeMap) {
-            if (args.length !== 3 || typeof args[0] !== "string" || typeof args[2] !== "number") {
+            if (args.length !== 3 || typeof args[0] !== "string" || !isWaitForAttributeOptions(args[2])) {
                 throw new TypeError("waitForAttributeMatch received invalid AttributeMap arguments");
             }
             return this.waitForAttributeValue(flowId, attribute, args[0], args[1], args[2]);
         }
         throw new TypeError("waitForAttributeMatch received an invalid Attribute definition");
     }
-    async waitForAttributeValue(flowId, attribute, instance, match, timeoutMs) {
+    async waitForAttributeValue(flowId, attribute, instance, match, options) {
         if (!(match instanceof AttributeMatch)) {
             throw new TypeError("waitForAttributeMatch requires an AttributeMatch");
         }
         const encoded = match.encode(attribute.codec);
-        const response = await unary({ operation: "waitForAttributeMatch", flowId, requirement: "active" }, (callback) => this.service.waitForAttribute({
-            flowId: requireName(flowId),
-            match: {
-                key: physicalName(attribute.name, instance),
-                operator: encoded.operator,
-                operand: encoded.operand,
-            },
-            waitTimeSeconds: seconds(timeoutMs),
-            requestId: crypto.randomUUID(),
-        }, callback));
-        if (response.matchedValue === undefined) {
-            throw new Error("waitForAttributeMatch response is incomplete");
+        const waitBudget = new ClientWaitBudget(options.maximumWaitTimeMs);
+        while (true) {
+            try {
+                const response = await unary({ operation: "waitForAttributeMatch", flowId, requirement: "active" }, (callback) => this.service.waitForAttribute({
+                    flowId: requireName(flowId),
+                    match: {
+                        key: physicalName(attribute.name, instance),
+                        operator: encoded.operator,
+                        operand: encoded.operand,
+                    },
+                    waitTimeSeconds: waitBudget.remainingSeconds("waitForAttributeMatch", flowId),
+                    requestId: options.requestId ?? "",
+                }, callback));
+                if (response.matchedValue === undefined) {
+                    throw new Error("waitForAttributeMatch response is incomplete");
+                }
+                return decodeValue(attribute.codec, response.matchedValue);
+            }
+            catch (error) {
+                if (!(error instanceof LongPollTimeoutError)) {
+                    throw error;
+                }
+            }
         }
-        return decodeValue(attribute.codec, response.matchedValue);
     }
     /**
      * Replaces mutable configuration for an active Flow.
@@ -878,6 +792,29 @@ function seconds(milliseconds) {
     }
     return milliseconds / 1_000;
 }
+function isWaitForAttributeOptions(value) {
+    return typeof value === "object" && value !== null;
+}
+class ClientWaitBudget {
+    deadlineMs;
+    constructor(maximumWaitTimeMs) {
+        const maximumWaitSeconds = seconds(maximumWaitTimeMs);
+        if (maximumWaitSeconds > 2_147_483_647) {
+            throw new RangeError("duration exceeds the int32 seconds range");
+        }
+        this.deadlineMs = maximumWaitSeconds === 0 ? undefined : performance.now() + maximumWaitSeconds * 1_000;
+    }
+    remainingSeconds(operation, flowId) {
+        if (this.deadlineMs === undefined) {
+            return 0;
+        }
+        const remainingMs = this.deadlineMs - performance.now();
+        if (remainingMs <= 0) {
+            throw new WaitHandlerTimeoutError(status.DEADLINE_EXCEEDED, ErrorSubStatus.WAIT_HANDLER_TIMEOUT, "wait handler timed out", operation, flowId);
+        }
+        return Math.ceil(remainingMs / 1_000);
+    }
+}
 function heartbeatSeconds(milliseconds) {
     const value = seconds(milliseconds);
     if (value > 2_147_483_647) {