@restatedev/restate-sdk-cloudflare-workers 1.4.0 → 1.5.0

package/dist/esm/src/context_impl.js

@@ -8,19 +8,22 @@
  * directory of this repository or package, or at
  * https://github.com/restatedev/sdk-typescript/blob/main/LICENSE
  */
-import { ensureError, INTERNAL_ERROR_CODE, RestateError, SUSPENDED_ERROR_CODE, TerminalError, TimeoutError, UNKNOWN_ERROR_CODE, } from "./types/errors.js";
+import { WasmHeader } from "./endpoint/handlers/vm/sdk_shared_core_wasm_bindings.js";
+import { ensureError, INTERNAL_ERROR_CODE, RestateError, SUSPENDED_ERROR_CODE, TerminalError, UNKNOWN_ERROR_CODE, } from "./types/errors.js";
 import { defaultSerde, HandlerKind, makeRpcCallProxy, makeRpcSendProxy, } from "./types/rpc.js";
 import { serde } from "@restatedev/restate-sdk-core";
 import { RandImpl } from "./utils/rand.js";
+import { CompletablePromise } from "./utils/completable_promise.js";
+import { extractContext, pendingPromise, PromisesExecutor, RestateInvocationPromise, RestateCombinatorPromise, RestatePendingPromise, InvocationPendingPromise, RestateSinglePromise, } from "./promises.js";
+import { InputPump, OutputPump } from "./io.js";
 export class ContextImpl {
     coreVm;
     input;
     console;
     handlerKind;
-    invocationEndPromise;
-    inputReader;
-    outputWriter;
+    vmLogger;
     invocationRequest;
+    invocationEndPromise;
     rand;
     date = {
         now: () => {
@@ -30,35 +33,34 @@ export class ContextImpl {
             return this.run(() => new Date().toJSON());
         },
     };
-    currentRead;
-    constructor(coreVm, input, console, handlerKind, attemptHeaders, extraArgs, invocationEndPromise, inputReader, outputWriter) {
+    outputPump;
+    runClosuresTracker;
+    promisesExecutor;
+    constructor(coreVm, input, console, handlerKind, vmLogger, invocationRequest, invocationEndPromise, inputReader, outputWriter) {
         this.coreVm = coreVm;
         this.input = input;
         this.console = console;
         this.handlerKind = handlerKind;
+        this.vmLogger = vmLogger;
+        this.invocationRequest = invocationRequest;
         this.invocationEndPromise = invocationEndPromise;
-        this.inputReader = inputReader;
-        this.outputWriter = outputWriter;
-        this.invocationRequest = {
-            id: input.invocation_id,
-            headers: input.headers.reduce((headers, { key, value }) => {
-                headers.set(key, value);
-                return headers;
-            }, new Map()),
-            attemptHeaders: Object.entries(attemptHeaders).reduce((headers, [key, value]) => {
-                if (value !== undefined) {
-                    headers.set(key, value instanceof Array ? value[0] : value);
-                }
-                return headers;
-            }, new Map()),
-            body: input.input,
-            extraArgs,
-        };
         this.rand = new RandImpl(input.invocation_id, () => {
-            if (coreVm.is_inside_run()) {
-                throw new Error("Cannot generate random numbers within a run closure. Use the random object outside the run closure.");
-            }
+            // TODO reimplement this check with async context
+            // if (coreVm.is_inside_run()) {
+            //   throw new Error(
+            //     "Cannot generate random numbers within a run closure. Use the random object outside the run closure."
+            //   );
+            // }
         });
+        this.outputPump = new OutputPump(coreVm, outputWriter);
+        this.runClosuresTracker = new RunClosuresTracker();
+        this.promisesExecutor = new PromisesExecutor(coreVm, new InputPump(coreVm, inputReader, this.handleInvocationEndError.bind(this)), this.outputPump, this.runClosuresTracker, this.handleInvocationEndError.bind(this));
+    }
+    cancel(invocationId) {
+        this.processNonCompletableEntry((vm) => vm.sys_cancel_invocation(invocationId));
+    }
+    attach(invocationId, serde) {
+        return this.processCompletableEntry((vm) => vm.sys_attach_invocation(invocationId), completeUsing(SuccessWithSerde(serde ?? defaultSerde()), Failure));
     }
     get key() {
         switch (this.handlerKind) {
@@ -75,36 +77,10 @@ export class ContextImpl {
         return this.invocationRequest;
     }
     get(name, serde) {
-        return this.processCompletableEntry((vm) => vm.sys_get_state(name), (asyncResultValue) => {
-            if (asyncResultValue === "Empty") {
-                // Empty
-                return null;
-            }
-            else if ("Success" in asyncResultValue) {
-                return (serde ?? defaultSerde()).deserialize(asyncResultValue.Success);
-            }
-            else if ("Failure" in asyncResultValue) {
-                throw new TerminalError(asyncResultValue.Failure.message, {
-                    errorCode: asyncResultValue.Failure.code,
-                });
-            }
-            throw new Error(`Unexpected variant in async result: ${JSON.stringify(asyncResultValue)}`);
-        });
+        return this.processCompletableEntry((vm) => vm.sys_get_state(name), completeUsing(VoidAsNull, SuccessWithSerde(serde ?? defaultSerde())));
     }
     stateKeys() {
-        return this.processCompletableEntry((vm) => vm.sys_get_state_keys(), (asyncResultValue) => {
-            if (typeof asyncResultValue === "object" &&
-                "StateKeys" in asyncResultValue) {
-                return asyncResultValue.StateKeys;
-            }
-            else if (typeof asyncResultValue === "object" &&
-                "Failure" in asyncResultValue) {
-                throw new TerminalError(asyncResultValue.Failure.message, {
-                    errorCode: asyncResultValue.Failure.code,
-                });
-            }
-            throw new Error(`Unexpected variant in async result: ${JSON.stringify(asyncResultValue)}`);
-        });
+        return this.processCompletableEntry((vm) => vm.sys_get_state_keys(), completeUsing(StateKeys));
     }
     set(name, value, serde) {
         this.processNonCompletableEntry((vm) => vm.sys_set_state(name, (serde ?? defaultSerde()).serialize(value)));
@@ -120,33 +96,50 @@ export class ContextImpl {
     genericCall(call) {
         const requestSerde = call.inputSerde ?? serde.binary;
         const responseSerde = call.outputSerde ?? serde.binary;
-        return this.processCompletableEntry((vm) => {
+        try {
+            const vm = this.coreVm;
             const parameter = requestSerde.serialize(call.parameter);
-            return vm.sys_call(call.service, call.method, parameter, call.key);
-        }, (asyncResultValue) => {
-            if (typeof asyncResultValue === "object" &&
-                "Success" in asyncResultValue) {
-                return responseSerde.deserialize(asyncResultValue.Success);
-            }
-            else if (typeof asyncResultValue === "object" &&
-                "Failure" in asyncResultValue) {
-                throw new TerminalError(asyncResultValue.Failure.message, {
-                    errorCode: asyncResultValue.Failure.code,
-                });
-            }
-            throw new Error(`Unexpected variant in async result: ${JSON.stringify(asyncResultValue)}`);
-        });
+            const call_handles = vm.sys_call(call.service, call.method, parameter, call.key, call.headers
+                ? Object.entries(call.headers).map(([key, value]) => new WasmHeader(key, value))
+                : [], call.idempotencyKey);
+            const invocationIdHandle = call_handles.invocation_id_completion_id;
+            const invocationIdPromise = this.createInvocationIdPromise(invocationIdHandle);
+            const callHandle = call_handles.call_completion_id;
+            return new RestateInvocationPromise(this, callHandle, completeUsing(SuccessWithSerde(responseSerde), Failure), invocationIdPromise);
+        }
+        catch (e) {
+            this.handleInvocationEndError(e);
+            // We return a pending promise to avoid the caller to see the error.
+            return new InvocationPendingPromise(this);
+        }
     }
     genericSend(send) {
-        this.processNonCompletableEntry((vm) => {
+        try {
+            const vm = this.coreVm;
             const requestSerde = send.inputSerde ?? serde.binary;
             const parameter = requestSerde.serialize(send.parameter);
             let delay;
             if (send.delay !== undefined) {
                 delay = BigInt(send.delay);
             }
-            vm.sys_send(send.service, send.method, parameter, send.key, delay);
-        });
+            const handles = vm.sys_send(send.service, send.method, parameter, send.key, send.headers
+                ? Object.entries(send.headers).map(([key, value]) => new WasmHeader(key, value))
+                : [], delay, send.idempotencyKey);
+            const handle = handles.invocation_id_completion_id;
+            const invocationId = this.createInvocationIdPromise(handle);
+            return {
+                invocationId,
+            };
+        }
+        catch (e) {
+            this.handleInvocationEndError(e);
+            return {
+                invocationId: pendingPromise(),
+            };
+        }
+    }
+    createInvocationIdPromise(handle) {
+        return new RestateSinglePromise(this, handle, completeUsing(InvocationIdCompleter));
     }
     serviceClient({ name }) {
         return makeRpcCallProxy((call) => this.genericCall(call), name);
@@ -171,28 +164,20 @@ export class ContextImpl {
     // and not in the promise context. To understand the semantic difference, make this function async and run the
     // UnawaitedSideEffectShouldFailSubsequentContextCall test.
     run(nameOrAction, actionSecondParameter, options) {
-        const { name, action } = unpack(nameOrAction, actionSecondParameter);
+        const { name, action } = unpackRunParameters(nameOrAction, actionSecondParameter);
         const serde = options?.serde ?? defaultSerde();
+        // Prepare the handle
+        let handle;
         try {
-            const runEnterResult = this.coreVm.sys_run_enter(name || "");
-            // Check if the run was already executed
-            if (typeof runEnterResult === "object" &&
-                "ExecutedWithSuccess" in runEnterResult) {
-                return Promise.resolve(serde.deserialize(runEnterResult.ExecutedWithSuccess));
-            }
-            else if (typeof runEnterResult === "object" &&
-                "ExecutedWithFailure" in runEnterResult) {
-                return Promise.reject(new TerminalError(runEnterResult.ExecutedWithFailure.message, {
-                    errorCode: runEnterResult.ExecutedWithFailure.code,
-                }));
-            }
+            handle = this.coreVm.sys_run(name || "");
         }
         catch (e) {
             this.handleInvocationEndError(e);
-            return pendingPromise();
+            return new RestatePendingPromise(this);
         }
-        // We wrap the rest of the execution in this closure to create a future
+        // Now prepare the run task
         const doRun = async () => {
+            // Execute the user code
             const startTime = Date.now();
             let res;
             let err;
@@ -203,28 +188,30 @@ export class ContextImpl {
                 err = ensureError(e);
             }
             const attemptDuration = Date.now() - startTime;
-            // Record the result/failure, get back the handle for the ack.
-            let handle;
+            // Propose the completion to the VM
             try {
                 if (err !== undefined) {
                     if (err instanceof TerminalError) {
                         // Record failure, go ahead
-                        handle = this.coreVm.sys_run_exit_failure({
+                        this.coreVm.propose_run_completion_failure(handle, {
                             code: err.code,
                             message: err.message,
                         });
                     }
                     else {
+                        this.vmLogger.warn(`Error when processing ctx.run '${name}'.\n`, err);
                         if (options?.retryIntervalFactor === undefined &&
                             options?.initialRetryIntervalMillis === undefined &&
                             options?.maxRetryAttempts === undefined &&
                             options?.maxRetryDurationMillis === undefined &&
                             options?.maxRetryIntervalMillis === undefined) {
-                            // If no retry option was set, simply throw the error.
-                            // This will lead to the invoker applying its retry, without the SDK overriding it.
-                            throw err;
+                            // If no retry option was set, simply notify the error.
+                            this.coreVm.notify_error(err.message, err.stack);
+                            // From now on, no progress will be made.
+                            this.invocationEndPromise.resolve();
+                            return pendingPromise();
                         }
-                        handle = this.coreVm.sys_run_exit_failure_transient(err.message, err.cause?.toString(), BigInt(attemptDuration), {
+                        this.coreVm.propose_run_completion_failure_transient(handle, err.message, err.cause?.toString(), BigInt(attemptDuration), {
                             factor: options?.retryIntervalFactor || 2.0,
                             initial_interval: options?.initialRetryIntervalMillis || 50,
                             max_attempts: options?.maxRetryAttempts,
@@ -234,45 +221,25 @@ export class ContextImpl {
                     }
                 }
                 else {
+                    this.coreVm.propose_run_completion_success(handle, 
                     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                     // @ts-expect-error
-                    handle = this.coreVm.sys_run_exit_success(serde.serialize(res));
+                    serde.serialize(res));
                 }
             }
             catch (e) {
                 this.handleInvocationEndError(e);
                 return pendingPromise();
             }
-            // Got the handle, wait for the result now (which we get once we get the ack)
-            return await this.pollAsyncResult(handle, (asyncResultValue) => {
-                if (typeof asyncResultValue === "object" &&
-                    "Success" in asyncResultValue) {
-                    return serde.deserialize(asyncResultValue.Success);
-                }
-                else if (typeof asyncResultValue === "object" &&
-                    "Failure" in asyncResultValue) {
-                    throw new TerminalError(asyncResultValue.Failure.message, {
-                        errorCode: asyncResultValue.Failure.code,
-                    });
-                }
-                throw new Error(`Unexpected variant in async result: ${JSON.stringify(asyncResultValue)}`);
-            });
+            await this.outputPump.awaitNextProgress();
         };
-        return doRun();
+        // Register the run to execute
+        this.runClosuresTracker.registerRunClosure(handle, doRun);
+        // Return the promise
+        return new RestateSinglePromise(this, handle, completeUsing(SuccessWithSerde(serde), Failure));
     }
     sleep(millis) {
-        return this.processCompletableEntry((vm) => vm.sys_sleep(BigInt(millis)), (asyncResultValue) => {
-            if (asyncResultValue === "Empty") {
-                // Empty
-                return undefined;
-            }
-            else if ("Failure" in asyncResultValue) {
-                throw new TerminalError(asyncResultValue.Failure.message, {
-                    errorCode: asyncResultValue.Failure.code,
-                });
-            }
-            throw new Error(`Unexpected variant in async result: ${JSON.stringify(asyncResultValue)}`);
-        });
+        return this.processCompletableEntry((vm) => vm.sys_sleep(BigInt(millis)), completeUsing(VoidAsUndefined));
     }
     // -- Awakeables
     awakeable(serde) {
@@ -284,30 +251,12 @@ export class ContextImpl {
             this.handleInvocationEndError(e);
             return {
                 id: "invalid",
-                promise: new LazyContextPromise(0, this, () => pendingPromise()),
+                promise: new RestatePendingPromise(this),
             };
         }
         return {
             id: awakeable.id,
-            promise: new LazyContextPromise(awakeable.handle, this, () => this.pollAsyncResult(awakeable.handle, (asyncResultValue) => {
-                if (typeof asyncResultValue === "object" &&
-                    "Success" in asyncResultValue) {
-                    if (!serde) {
-                        return defaultSerde().deserialize(asyncResultValue.Success);
-                    }
-                    if (asyncResultValue.Success.length === 0) {
-                        return undefined;
-                    }
-                    return serde.deserialize(asyncResultValue.Success);
-                }
-                else if (typeof asyncResultValue === "object" &&
-                    "Failure" in asyncResultValue) {
-                    throw new TerminalError(asyncResultValue.Failure.message, {
-                        errorCode: asyncResultValue.Failure.code,
-                    });
-                }
-                throw new Error(`Unexpected variant in async result: ${JSON.stringify(asyncResultValue)}`);
-            })),
+            promise: new RestateSinglePromise(this, awakeable.handle, completeUsing(VoidAsUndefined, SuccessWithSerde(serde), Failure)),
         };
     }
     resolveAwakeable(id, payload, serde) {
@@ -339,7 +288,7 @@ export class ContextImpl {
         return new DurablePromiseImpl(this, name, serde);
     }
     // Used by static methods of CombineablePromise
-    static createCombinator(combinatorType, promises) {
+    static createCombinator(combinatorConstructor, promises) {
         // Extract context from first promise
         const self = extractContext(promises[0]);
         if (!self) {
@@ -350,133 +299,11 @@ export class ContextImpl {
         for (const promise of promises) {
             if (extractContext(promise) !== self) {
                 self.handleInvocationEndError(new Error("You're mixing up CombineablePromises from different RestateContext. This is not supported."));
-                return pendingPromise();
+                return new RestatePendingPromise(self);
             }
             castedPromises.push(promise);
         }
-        const handles = new Uint32Array(castedPromises.map((p) => p.asyncResultHandle));
-        // From now on, lazily executes on await
-        return new LazyPromise(async () => {
-            let combinatorResultHandle;
-            try {
-                // Take output
-                const nextOutput1 = self.coreVm.take_output();
-                if (nextOutput1 instanceof Uint8Array) {
-                    await self.outputWriter.write(nextOutput1);
-                }
-                for (;;) {
-                    switch (combinatorType) {
-                        case "All":
-                            combinatorResultHandle =
-                                self.coreVm.sys_try_complete_all_combinator(handles);
-                            break;
-                        case "Any":
-                            combinatorResultHandle =
-                                self.coreVm.sys_try_complete_any_combinator(handles);
-                            break;
-                        case "AllSettled":
-                            combinatorResultHandle =
-                                self.coreVm.sys_try_complete_all_settled_combinator(handles);
-                            break;
-                        case "Race":
-                        case "OrTimeout":
-                            combinatorResultHandle =
-                                self.coreVm.sys_try_complete_race_combinator(handles);
-                            break;
-                    }
-                    // We got a result, we're done in this loop
-                    if (combinatorResultHandle !== undefined) {
-                        break;
-                    }
-                    // No result yet, await the next read
-                    await self.awaitNextRead();
-                }
-                // We got a result, we need to take_output to write the combinator entry, then we need to poll the result
-                const nextOutput = self.coreVm.take_output();
-                if (nextOutput instanceof Uint8Array) {
-                    await self.outputWriter.write(nextOutput);
-                }
-            }
-            catch (e) {
-                if (e instanceof TerminalError) {
-                    // All good, this is a recorded failure
-                    throw e;
-                }
-                // Not good, this is a retryable error.
-                self.handleInvocationEndError(e);
-                return await pendingPromise();
-            }
-            const handlesResult = await self.pollAsyncResult(combinatorResultHandle, (asyncResultValue) => {
-                if (typeof asyncResultValue === "object" &&
-                    "CombinatorResult" in asyncResultValue) {
-                    return asyncResultValue.CombinatorResult;
-                }
-                throw new Error(`Unexpected variant in async result: ${JSON.stringify(asyncResultValue)}`);
-            });
-            const promisesMap = new Map(castedPromises.map((p) => [p.asyncResultHandle, p]));
-            // Now all we need to do is to construct the final output based on the handles,
-            // this depends on combinators themselves.
-            switch (combinatorType) {
-                case "All":
-                    return this.extractAllCombinatorResult(handlesResult, promisesMap);
-                case "Any":
-                    return this.extractAnyCombinatorResult(handlesResult, promisesMap);
-                case "AllSettled":
-                    return this.extractAllSettledCombinatorResult(handlesResult, promisesMap);
-                case "Race":
-                    // Just one promise succeeded
-                    return promisesMap.get(handlesResult[0]);
-                case "OrTimeout":
-                    // The sleep promise is always the second one in the list.
-                    if (handlesResult[0] === castedPromises[1].asyncResultHandle) {
-                        return Promise.reject(new TimeoutError());
-                    }
-                    else {
-                        return promisesMap.get(handlesResult[0]);
-                    }
-            }
-        });
-    }
-    static async extractAllCombinatorResult(handlesResult, promisesMap) {
-        // The result can either all values, or one error
-        const resultValues = [];
-        for (const handle of handlesResult) {
-            try {
-                resultValues.push(await promisesMap.get(handle));
-            }
-            catch (e) {
-                return Promise.reject(e);
-            }
-        }
-        return Promise.resolve(resultValues);
-    }
-    static async extractAnyCombinatorResult(handlesResult, promisesMap) {
-        // The result can either be one value, or a list of errors
-        const resultFailures = [];
-        for (const handle of handlesResult) {
-            try {
-                return Promise.resolve(await promisesMap.get(handle));
-            }
-            catch (e) {
-                resultFailures.push(e);
-            }
-        }
-        // Giving back the cause here is completely fine, because all these errors in Aggregate error are Terminal errors!
-        return Promise.reject(new TerminalError("All input promises failed", {
-            cause: new AggregateError(resultFailures),
-        }));
-    }
-    static async extractAllSettledCombinatorResult(handlesResult, promisesMap) {
-        const resultValues = [];
-        for (const handle of handlesResult) {
-            try {
-                resultValues.push(await promisesMap.get(handle));
-            }
-            catch (e) {
-                resultValues.push(e);
-            }
-        }
-        return Promise.resolve(resultValues);
+        return new RestateCombinatorPromise(self, combinatorConstructor, castedPromises);
     }
     // -- Various private methods
     processNonCompletableEntry(vmCall) {
@@ -487,88 +314,29 @@ export class ContextImpl {
             this.handleInvocationEndError(e);
         }
     }
-    processCompletableEntry(vmCall, transformer) {
+    processCompletableEntry(vmCall, completer) {
         let handle;
         try {
             handle = vmCall(this.coreVm);
         }
         catch (e) {
             this.handleInvocationEndError(e);
-            return new LazyContextPromise(0, this, () => pendingPromise());
-        }
-        return new LazyContextPromise(handle, this, () => this.pollAsyncResult(handle, transformer));
-    }
-    async pollAsyncResult(handle, transformer) {
-        try {
-            // Take output
-            const nextOutput = this.coreVm.take_output();
-            if (nextOutput instanceof Uint8Array) {
-                await this.outputWriter.write(nextOutput);
-            }
-            // Now loop waiting for the async result
-            let asyncResult = this.coreVm.take_async_result(handle);
-            while (asyncResult === "NotReady") {
-                await this.awaitNextRead();
-                // Using notify_await_point immediately before take_async_result
-                // makes sure the state machine will try to suspend only now,
-                // in case there aren't other concurrent tasks trying to poll this async result.
-                this.coreVm.notify_await_point(handle);
-                asyncResult = this.coreVm.take_async_result(handle);
-            }
-            return transformer(asyncResult);
-        }
-        catch (e) {
-            if (e instanceof TerminalError) {
-                // All good, this is a recorded failure
-                throw e;
-            }
-            // Not good, this is a retryable error.
-            this.handleInvocationEndError(e);
-            return await pendingPromise();
-        }
-    }
-    // This function triggers a read on the input reader,
-    // and will notify the caller that a read was executed
-    // and the result was piped in the state machine.
-    awaitNextRead() {
-        if (this.currentRead === undefined) {
-            // Register a new read
-            this.currentRead = this.readNext().finally(() => {
-                this.currentRead = undefined;
-            });
-        }
-        // eslint-disable-next-line @typescript-eslint/no-misused-promises
-        return new Promise((resolve) => this.currentRead?.finally(resolve));
-    }
-    async readNext() {
-        // Take input, and notify it to the vm
-        let nextValue;
-        try {
-            nextValue = await this.inputReader.read();
-        }
-        catch (e) {
-            this.handleInvocationEndError(e);
-            return pendingPromise();
-        }
-        if (nextValue.value !== undefined) {
-            this.coreVm.notify_input(nextValue.value);
-        }
-        if (nextValue.done) {
-            this.coreVm.notify_input_closed();
+            return new RestatePendingPromise(this);
         }
+        return new RestateSinglePromise(this, handle, completer);
     }
     handleInvocationEndError(e) {
         const error = ensureError(e);
         if (!(error instanceof RestateError) ||
             error.code !== SUSPENDED_ERROR_CODE) {
-            this.console.warn("Function completed with an error.\n", error);
+            this.vmLogger.warn("Error when processing a Restate context operation.\n", error);
         }
         this.coreVm.notify_error(error.message, error.stack);
         // From now on, no progress will be made.
         this.invocationEndPromise.resolve();
     }
 }
-function unpack(a, b) {
+function unpackRunParameters(a, b) {
     if (typeof a === "string") {
         if (typeof b !== "function") {
             throw new TypeError("");
@@ -583,12 +351,6 @@ function unpack(a, b) {
     }
     return { action: a };
 }
-const RESTATE_CTX_SYMBOL = Symbol("restateContext");
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function extractContext(n) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    return n[RESTATE_CTX_SYMBOL];
-}
 class DurablePromiseImpl {
     ctx;
     name;
@@ -609,108 +371,117 @@ class DurablePromiseImpl {
     }
     [Symbol.toStringTag] = "DurablePromise";
     get() {
-        return this.ctx.processCompletableEntry((vm) => vm.sys_get_promise(this.name), (asyncResultValue) => {
-            if (typeof asyncResultValue === "object" &&
-                "Success" in asyncResultValue) {
-                return this.serde.deserialize(asyncResultValue.Success);
-            }
-            else if (typeof asyncResultValue === "object" &&
-                "Failure" in asyncResultValue) {
-                throw new TerminalError(asyncResultValue.Failure.message, {
-                    errorCode: asyncResultValue.Failure.code,
-                });
-            }
-            throw new Error(`Unexpected variant in async result: ${JSON.stringify(asyncResultValue)}`);
-        });
+        return this.ctx.processCompletableEntry((vm) => vm.sys_get_promise(this.name), completeUsing(SuccessWithSerde(this.serde), Failure));
     }
     peek() {
-        return this.ctx.processCompletableEntry((vm) => vm.sys_peek_promise(this.name), (asyncResultValue) => {
-            if (asyncResultValue === "Empty") {
-                return undefined;
-            }
-            else if (typeof asyncResultValue === "object" &&
-                "Success" in asyncResultValue) {
-                return this.serde.deserialize(asyncResultValue.Success);
-            }
-            else if (typeof asyncResultValue === "object" &&
-                "Failure" in asyncResultValue) {
-                throw new TerminalError(asyncResultValue.Failure.message, {
-                    errorCode: asyncResultValue.Failure.code,
-                });
-            }
-            throw new Error(`Unexpected variant in async result: ${JSON.stringify(asyncResultValue)}`);
-        });
+        return this.ctx.processCompletableEntry((vm) => vm.sys_peek_promise(this.name), completeUsing(VoidAsUndefined, SuccessWithSerde(this.serde), Failure));
     }
     resolve(value) {
-        return this.ctx.processCompletableEntry((vm) => vm.sys_complete_promise_success(this.name, this.serde.serialize(value)), (asyncResultValue) => {
-            if (asyncResultValue === "Empty") {
-                return undefined;
-            }
-            else if (typeof asyncResultValue === "object" &&
-                "Failure" in asyncResultValue) {
-                throw new TerminalError(asyncResultValue.Failure.message, {
-                    errorCode: asyncResultValue.Failure.code,
-                });
-            }
-            throw new Error(`Unexpected variant in async result: ${JSON.stringify(asyncResultValue)}`);
-        });
+        return this.ctx.processCompletableEntry((vm) => vm.sys_complete_promise_success(this.name, this.serde.serialize(value)), completeUsing(VoidAsUndefined, Failure));
     }
     reject(errorMsg) {
         return this.ctx.processCompletableEntry((vm) => vm.sys_complete_promise_failure(this.name, {
             code: INTERNAL_ERROR_CODE,
             message: errorMsg,
-        }), (asyncResultValue) => {
-            if (asyncResultValue === "Empty") {
-                return undefined;
-            }
-            else if (typeof asyncResultValue === "object" &&
-                "Failure" in asyncResultValue) {
-                throw new TerminalError(asyncResultValue.Failure.message, {
-                    errorCode: asyncResultValue.Failure.code,
-                });
-            }
-            throw new Error(`Unexpected variant in async result: ${JSON.stringify(asyncResultValue)}`);
-        });
+        }), completeUsing(VoidAsUndefined, Failure));
     }
 }
-class LazyPromise {
-    executor;
-    _promise;
-    constructor(executor) {
-        this.executor = executor;
-    }
-    then(onfulfilled, onrejected) {
-        this._promise = this._promise || this.executor();
-        return this._promise.then(onfulfilled, onrejected);
-    }
-    catch(onrejected) {
-        this._promise = this._promise || this.executor();
-        return this._promise.catch(onrejected);
+/// Tracker of run closures to run
+export class RunClosuresTracker {
+    currentRunWaitPoint;
+    runsToExecute = new Map();
+    executeRun(handle) {
+        const runClosure = this.runsToExecute.get(handle);
+        if (runClosure === undefined) {
+            throw new Error(`Handle ${handle} doesn't exist`);
+        }
+        runClosure()
+            .finally(() => {
+            this.unblockCurrentRunWaitPoint();
+        })
+            .catch(() => { });
+    }
+    registerRunClosure(handle, runClosure) {
+        this.runsToExecute.set(handle, runClosure);
+    }
+    awaitNextCompletedRun() {
+        if (this.currentRunWaitPoint === undefined) {
+            this.currentRunWaitPoint = new CompletablePromise();
+        }
+        return this.currentRunWaitPoint.promise;
     }
-    finally(onfinally) {
-        this._promise = this._promise || this.executor();
-        return this._promise.finally(onfinally);
+    unblockCurrentRunWaitPoint() {
+        if (this.currentRunWaitPoint !== undefined) {
+            const p = this.currentRunWaitPoint;
+            this.currentRunWaitPoint = undefined;
+            p.resolve();
+        }
     }
-    [Symbol.toStringTag] = "LazyPromise";
 }
-class LazyContextPromise extends LazyPromise {
-    asyncResultHandle;
-    [RESTATE_CTX_SYMBOL];
-    constructor(asyncResultHandle, ctx, executor) {
-        super(executor);
-        this.asyncResultHandle = asyncResultHandle;
-        this[RESTATE_CTX_SYMBOL] = ctx;
-    }
-    orTimeout(millis) {
-        return ContextImpl.createCombinator("OrTimeout", [
-            this,
-            this[RESTATE_CTX_SYMBOL].sleep(millis),
-        ]);
-    }
+function completeUsing(...completers) {
+    return (value, prom) => {
+        for (const completer of completers) {
+            if (completer(value, prom)) {
+                return;
+            }
+        }
+        throw new Error(`Unexpected variant in async result: ${JSON.stringify(value)}`);
+    };
 }
-// A promise that is never completed
-function pendingPromise() {
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    return new Promise(() => { });
+const VoidAsNull = (value, prom) => {
+    if (value === "Empty") {
+        prom.resolve(null);
+        return true;
+    }
+    return false;
+};
+const VoidAsUndefined = (value, prom) => {
+    if (value === "Empty") {
+        prom.resolve(undefined);
+        return true;
+    }
+    return false;
+};
+function SuccessWithSerde(serde, transform) {
+    return (value, prom) => {
+        if (typeof value !== "object" || !("Success" in value)) {
+            return false;
+        }
+        let val;
+        if (serde) {
+            val = serde.deserialize(value.Success);
+        }
+        else {
+            val = defaultSerde().deserialize(value.Success);
+        }
+        if (transform) {
+            val = transform(val);
+        }
+        prom.resolve(val);
+        return true;
+    };
 }
+const Failure = (value, prom) => {
+    if (typeof value === "object" && "Failure" in value) {
+        prom.reject(new TerminalError(value.Failure.message, {
+            errorCode: value.Failure.code,
+        }));
+        return true;
+    }
+    return false;
+};
+const StateKeys = (value, prom) => {
+    if (typeof value === "object" && "StateKeys" in value) {
+        prom.resolve(value.StateKeys);
+        return true;
+    }
+    return false;
+};
+const InvocationIdCompleter = (value, prom) => {
+    if (typeof value === "object" && "InvocationId" in value) {
+        prom.resolve(value.InvocationId);
+        return true;
+    }
+    return false;
+};
 //# sourceMappingURL=context_impl.js.map