@restatedev/restate-sdk 1.3.3 → 1.5.0

package/dist/cjs/src/context_impl.js

@@ -10,25 +10,23 @@
  * https://github.com/restatedev/sdk-typescript/blob/main/LICENSE
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContextImpl = void 0;
-const protocol_pb_js_1 = require("./generated/proto/protocol_pb.js");
-const protocol_js_1 = require("./types/protocol.js");
+exports.RunClosuresTracker = exports.ContextImpl = void 0;
+const sdk_shared_core_wasm_bindings_js_1 = require("./endpoint/handlers/vm/sdk_shared_core_wasm_bindings.js");
 const errors_js_1 = require("./types/errors.js");
-const protobuf_1 = require("@bufbuild/protobuf");
 const rpc_js_1 = require("./types/rpc.js");
 const restate_sdk_core_1 = require("@restatedev/restate-sdk-core");
 const rand_js_1 = require("./utils/rand.js");
-const promise_combinator_tracker_js_1 = require("./promise_combinator_tracker.js");
-const node_buffer_1 = require("node:buffer");
+const completable_promise_js_1 = require("./utils/completable_promise.js");
+const promises_js_1 = require("./promises.js");
+const io_js_1 = require("./io.js");
 class ContextImpl {
+    coreVm;
+    input;
     console;
     handlerKind;
-    keyedContextKey;
-    stateMachine;
-    // This is used to guard users against calling ctx.sideEffect without awaiting it.
-    // See https://github.com/restatedev/sdk-typescript/issues/197 for more details.
-    executingRun = false;
+    vmLogger;
     invocationRequest;
+    invocationEndPromise;
     rand;
     date = {
         now: () => {
@@ -38,138 +36,113 @@ class ContextImpl {
             return this.run(() => new Date().toJSON());
         },
     };
-    constructor(id, console, handlerKind, keyedContextKey, invocationValue, invocationHeaders, attemptHeaders, extraArgs, 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    stateMachine) {
+    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.keyedContextKey = keyedContextKey;
-        this.stateMachine = stateMachine;
-        this.invocationRequest = {
-            id,
-            headers: invocationHeaders,
-            attemptHeaders,
-            body: invocationValue,
-            extraArgs,
-        };
-        this.rand = new rand_js_1.RandImpl(id, this.checkState.bind(this));
+        this.vmLogger = vmLogger;
+        this.invocationRequest = invocationRequest;
+        this.invocationEndPromise = invocationEndPromise;
+        this.rand = new rand_js_1.RandImpl(input.invocation_id, () => {
+            // 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 io_js_1.OutputPump(coreVm, outputWriter);
+        this.runClosuresTracker = new RunClosuresTracker();
+        this.promisesExecutor = new promises_js_1.PromisesExecutor(coreVm, new io_js_1.InputPump(coreVm, inputReader, this.handleInvocationEndError.bind(this)), this.outputPump, this.runClosuresTracker, this.handleInvocationEndError.bind(this));
     }
-    promise(name, serde) {
-        return new DurablePromiseImpl(this, name, serde);
+    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 ?? (0, rpc_js_1.defaultSerde)()), Failure));
     }
     get key() {
         switch (this.handlerKind) {
             case rpc_js_1.HandlerKind.EXCLUSIVE:
             case rpc_js_1.HandlerKind.SHARED:
             case rpc_js_1.HandlerKind.WORKFLOW: {
-                if (this.keyedContextKey === undefined) {
-                    throw new errors_js_1.TerminalError("unexpected missing key");
-                }
-                return this.keyedContextKey;
+                return this.input.key;
             }
-            case rpc_js_1.HandlerKind.SERVICE:
-                throw new errors_js_1.TerminalError("unexpected missing key");
             default:
-                throw new errors_js_1.TerminalError("unknown handler type");
+                throw new errors_js_1.TerminalError("this handler type doesn't support key()");
         }
     }
     request() {
         return this.invocationRequest;
     }
-    // DON'T make this function async!!! see sideEffect comment for details.
     get(name, serde) {
-        // Check if this is a valid action
-        this.checkState("get state");
-        // Create the message and let the state machine process it
-        const msg = new protocol_pb_js_1.GetStateEntryMessage({
-            key: new TextEncoder().encode(name),
-        });
-        const completed = this.stateMachine.localStateStore.tryCompleteGet(name, msg);
-        const getState = async () => {
-            const result = await this.stateMachine.handleUserCodeMessage(protocol_js_1.GET_STATE_ENTRY_MESSAGE_TYPE, msg, completed);
-            // If the GetState message did not have a value or empty,
-            // then we went to the runtime to get the value.
-            // When we get the response, we set it in the localStateStore,
-            // to answer subsequent requests
-            if (!completed) {
-                this.stateMachine.localStateStore.add(name, result);
-            }
-            if (!(result instanceof Uint8Array)) {
-                return null;
-            }
-            return (serde ?? (0, rpc_js_1.defaultSerde)()).deserialize(result);
-        };
-        return getState();
+        return this.processCompletableEntry((vm) => vm.sys_get_state(name), completeUsing(VoidAsNull, SuccessWithSerde(serde ?? (0, rpc_js_1.defaultSerde)())));
     }
-    // DON'T make this function async!!! see sideEffect comment for details.
     stateKeys() {
-        // Check if this is a valid action
-        this.checkState("state keys");
-        // Create the message and let the state machine process it
-        const msg = new protocol_pb_js_1.GetStateKeysEntryMessage({});
-        const completed = this.stateMachine.localStateStore.tryCompletedGetStateKeys(msg);
-        const getStateKeys = async () => {
-            const result = await this.stateMachine.handleUserCodeMessage(protocol_js_1.GET_STATE_KEYS_ENTRY_MESSAGE_TYPE, msg, completed);
-            return result.keys.map((b) => new TextDecoder().decode(b));
-        };
-        return getStateKeys();
+        return this.processCompletableEntry((vm) => vm.sys_get_state_keys(), completeUsing(StateKeys));
     }
     set(name, value, serde) {
-        this.checkState("set state");
-        const bytes = (serde ?? (0, rpc_js_1.defaultSerde)()).serialize(value);
-        const msg = this.stateMachine.localStateStore.set(name, bytes);
-        this.stateMachine
-            .handleUserCodeMessage(protocol_js_1.SET_STATE_ENTRY_MESSAGE_TYPE, msg)
-            .catch((e) => this.stateMachine.handleDanglingPromiseError(e));
+        this.processNonCompletableEntry((vm) => vm.sys_set_state(name, (serde ?? (0, rpc_js_1.defaultSerde)()).serialize(value)));
     }
     clear(name) {
-        this.checkState("clear state");
-        const msg = this.stateMachine.localStateStore.clear(name);
-        this.stateMachine
-            .handleUserCodeMessage(protocol_js_1.CLEAR_STATE_ENTRY_MESSAGE_TYPE, msg)
-            .catch((e) => this.stateMachine.handleDanglingPromiseError(e));
+        this.processNonCompletableEntry((vm) => vm.sys_clear_state(name));
     }
     clearAll() {
-        this.checkState("clear all state");
-        const msg = this.stateMachine.localStateStore.clearAll();
-        this.stateMachine
-            .handleUserCodeMessage(protocol_js_1.CLEAR_ALL_STATE_ENTRY_MESSAGE_TYPE, msg)
-            .catch((e) => this.stateMachine.handleDanglingPromiseError(e));
+        this.processNonCompletableEntry((vm) => vm.sys_clear_all_state());
     }
     // --- Calls, background calls, etc
     //
     genericCall(call) {
         const requestSerde = call.inputSerde ?? restate_sdk_core_1.serde.binary;
         const responseSerde = call.outputSerde ?? restate_sdk_core_1.serde.binary;
-        const parameter = requestSerde.serialize(call.parameter);
-        const msg = new protocol_pb_js_1.CallEntryMessage({
-            serviceName: call.service,
-            handlerName: call.method,
-            parameter,
-            key: call.key,
-        });
-        const rawRequest = this.stateMachine.handleUserCodeMessage(protocol_js_1.INVOKE_ENTRY_MESSAGE_TYPE, msg);
-        const decoded = rawRequest.transform((res) => responseSerde.deserialize(res));
-        return this.markCombineablePromise(decoded);
+        try {
+            const vm = this.coreVm;
+            const parameter = requestSerde.serialize(call.parameter);
+            const call_handles = vm.sys_call(call.service, call.method, parameter, call.key, call.headers
+                ? Object.entries(call.headers).map(([key, value]) => new sdk_shared_core_wasm_bindings_js_1.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 promises_js_1.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 promises_js_1.InvocationPendingPromise(this);
+        }
     }
     genericSend(send) {
-        const requestSerde = send.inputSerde ?? restate_sdk_core_1.serde.binary;
-        const parameter = requestSerde.serialize(send.parameter);
-        const actualDelay = send.delay || 0;
-        const jsInvokeTime = actualDelay > 0 ? Date.now() + actualDelay : protobuf_1.protoInt64.zero;
-        const invokeTime = protobuf_1.protoInt64.parse(jsInvokeTime);
-        const msg = new protocol_pb_js_1.OneWayCallEntryMessage({
-            serviceName: send.service,
-            handlerName: send.method,
-            parameter,
-            invokeTime,
-            key: send.key,
-        });
-        this.stateMachine
-            .handleUserCodeMessage(protocol_js_1.BACKGROUND_INVOKE_ENTRY_MESSAGE_TYPE, msg)
-            .catch((e) => {
-            this.stateMachine.handleDanglingPromiseError(e);
-        });
+        try {
+            const vm = this.coreVm;
+            const requestSerde = send.inputSerde ?? restate_sdk_core_1.serde.binary;
+            const parameter = requestSerde.serialize(send.parameter);
+            let delay;
+            if (send.delay !== undefined) {
+                delay = BigInt(send.delay);
+            }
+            const handles = vm.sys_send(send.service, send.method, parameter, send.key, send.headers
+                ? Object.entries(send.headers).map(([key, value]) => new sdk_shared_core_wasm_bindings_js_1.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: (0, promises_js_1.pendingPromise)(),
+            };
+        }
+    }
+    createInvocationIdPromise(handle) {
+        return new promises_js_1.RestateSinglePromise(this, handle, completeUsing(InvocationIdCompleter));
     }
     serviceClient({ name }) {
         return (0, rpc_js_1.makeRpcCallProxy)((call) => this.genericCall(call), name);
@@ -194,225 +167,181 @@ 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) {
-        this.checkState("run");
-        const { name, action } = unpack(nameOrAction, actionSecondParameter);
-        this.executingRun = true;
+        const { name, action } = unpackRunParameters(nameOrAction, actionSecondParameter);
         const serde = options?.serde ?? (0, rpc_js_1.defaultSerde)();
-        const executeRun = async () => {
-            // in replay mode, we directly return the value from the log
-            if (this.stateMachine.nextEntryWillBeReplayed()) {
-                const emptyMsg = new protocol_pb_js_1.RunEntryMessage({});
-                return this.stateMachine
-                    .handleUserCodeMessage(protocol_js_1.SIDE_EFFECT_ENTRY_MESSAGE_TYPE, emptyMsg)
-                    .transform((result) => {
-                    if (!result || result instanceof protocol_pb_js_1.Empty) {
-                        return undefined;
-                    }
-                    return serde.deserialize(result);
-                });
-            }
-            let sideEffectResult;
+        // Prepare the handle
+        let handle;
+        try {
+            handle = this.coreVm.sys_run(name || "");
+        }
+        catch (e) {
+            this.handleInvocationEndError(e);
+            return new promises_js_1.RestatePendingPromise(this);
+        }
+        // Now prepare the run task
+        const doRun = async () => {
+            // Execute the user code
+            const startTime = Date.now();
+            let res;
+            let err;
             try {
-                sideEffectResult = await action();
+                res = await action();
             }
             catch (e) {
-                if (!(e instanceof errors_js_1.TerminalError)) {
-                    ///non terminal errors are retirable.
-                    // we do not commit the error itself into the journal, but rather let restate know about this
-                    // so that restate can retry this invocation later.
-                    // Before we can propagate this error to the user, we must let the state machine know that this attempt
-                    // is finished with an error, and it should not append anything else to the journal from now on.
-                    const error = (0, errors_js_1.ensureError)(e);
-                    const additionalContext = {
-                        relatedEntryName: name,
-                        relatedEntryType: protocol_js_1.SIDE_EFFECT_ENTRY_MESSAGE_TYPE,
-                    };
-                    await this.stateMachine.sendErrorAndFinish(error, additionalContext);
-                    throw e;
+                err = (0, errors_js_1.ensureError)(e);
+            }
+            const attemptDuration = Date.now() - startTime;
+            // Propose the completion to the VM
+            try {
+                if (err !== undefined) {
+                    if (err instanceof errors_js_1.TerminalError) {
+                        // Record failure, go ahead
+                        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 notify the error.
+                            this.coreVm.notify_error(err.message, err.stack);
+                            // From now on, no progress will be made.
+                            this.invocationEndPromise.resolve();
+                            return (0, promises_js_1.pendingPromise)();
+                        }
+                        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,
+                            max_duration: options?.maxRetryDurationMillis,
+                            max_interval: options?.maxRetryIntervalMillis || 10 * 1000,
+                        });
+                    }
                 }
-                // we commit a terminal error from the side effect to the journal, and re-throw it into
-                // the function. that way, any catching by the user and reacting to it will be
-                // deterministic on replay
-                const error = (0, errors_js_1.ensureError)(e);
-                const failure = (0, errors_js_1.errorToFailure)(error);
-                const sideEffectMsg = new protocol_pb_js_1.RunEntryMessage({
-                    name,
-                    result: { case: "failure", value: failure },
-                });
-                // this may throw an error from the SDK/runtime/connection side, in case the
-                // failure message cannot be committed to the journal. That error would then
-                // be returned from this function (replace the original error)
-                // that is acceptable, because in such a situation (failure to append to journal),
-                // the state machine closes anyways and no further operations will succeed and the
-                // the execution aborts
-                await this.stateMachine.handleUserCodeMessage(protocol_js_1.SIDE_EFFECT_ENTRY_MESSAGE_TYPE, sideEffectMsg, false, true);
-                throw e;
+                else {
+                    this.coreVm.propose_run_completion_success(handle, 
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    // @ts-expect-error
+                    serde.serialize(res));
+                }
+            }
+            catch (e) {
+                this.handleInvocationEndError(e);
+                return (0, promises_js_1.pendingPromise)();
             }
-            // we have this code outside the above try/catch block, to ensure that any error arising
-            // from here is not incorrectly attributed to the side-effect
-            const sideEffectMsg = sideEffectResult !== undefined
-                ? new protocol_pb_js_1.RunEntryMessage({
-                    name,
-                    result: {
-                        case: "value",
-                        value: serde.serialize(sideEffectResult),
-                    },
-                })
-                : new protocol_pb_js_1.RunEntryMessage({
-                    name,
-                });
-            // if an error arises from committing the side effect result, then this error will
-            // be thrown here (reject the returned promise) and the function will see that error,
-            // even if the side-effect function completed correctly
-            // that is acceptable, because in such a situation (failure to append to journal),
-            // the state machine closes anyways and reports an execution failure, meaning no further
-            // operations will succeed and the the execution will be retried.
-            // If the side-effect result did in fact not make it to the journal, then the side-effect
-            // re-executes, and if it made it to the journal after all (error happend inly during
-            // ack-back), then retries will use the journaled result.
-            // So all good in any case, due to the beauty of "the runtime log is the ground thruth" approach.
-            await this.stateMachine.handleUserCodeMessage(protocol_js_1.SIDE_EFFECT_ENTRY_MESSAGE_TYPE, sideEffectMsg, false, true);
-            return sideEffectResult;
+            await this.outputPump.awaitNextProgress();
         };
-        return executeRun().finally(() => {
-            this.executingRun = false;
-        });
+        // Register the run to execute
+        this.runClosuresTracker.registerRunClosure(handle, doRun);
+        // Return the promise
+        return new promises_js_1.RestateSinglePromise(this, handle, completeUsing(SuccessWithSerde(serde), Failure));
     }
     sleep(millis) {
-        this.checkState("sleep");
-        return this.markCombineablePromise(this.sleepInternal(millis));
-    }
-    sleepInternal(millis) {
-        return this.stateMachine.handleUserCodeMessage(protocol_js_1.SLEEP_ENTRY_MESSAGE_TYPE, new protocol_pb_js_1.SleepEntryMessage({
-            wakeUpTime: protobuf_1.protoInt64.parse(Date.now() + millis),
-        }));
+        return this.processCompletableEntry((vm) => vm.sys_sleep(BigInt(millis)), completeUsing(VoidAsUndefined));
     }
     // -- Awakeables
     awakeable(serde) {
-        this.checkState("awakeable");
-        const msg = new protocol_pb_js_1.AwakeableEntryMessage();
-        const promise = this.stateMachine
-            .handleUserCodeMessage(protocol_js_1.AWAKEABLE_ENTRY_MESSAGE_TYPE, msg)
-            .transform((result) => {
-            if (!(result instanceof Uint8Array)) {
-                // This should either be a filled buffer or an empty buffer but never anything else.
-                throw errors_js_1.RetryableError.internal("Awakeable was not resolved with a buffer payload");
-            }
-            if (!serde) {
-                return (0, rpc_js_1.defaultSerde)().deserialize(result);
-            }
-            if (result.length == 0) {
-                return undefined;
-            }
-            return serde.deserialize(result);
-        });
-        // This needs to be done after handling the message in the state machine
-        // otherwise the index is not yet incremented.
-        const encodedEntryIndex = node_buffer_1.Buffer.alloc(4 /* Size of u32 */);
-        encodedEntryIndex.writeUInt32BE(this.stateMachine.getUserCodeJournalIndex());
+        let awakeable;
+        try {
+            awakeable = this.coreVm.sys_awakeable();
+        }
+        catch (e) {
+            this.handleInvocationEndError(e);
+            return {
+                id: "invalid",
+                promise: new promises_js_1.RestatePendingPromise(this),
+            };
+        }
         return {
-            id: protocol_js_1.AWAKEABLE_IDENTIFIER_PREFIX +
-                node_buffer_1.Buffer.concat([this.request().id, encodedEntryIndex]).toString("base64url"),
-            promise: this.markCombineablePromise(promise),
+            id: awakeable.id,
+            promise: new promises_js_1.RestateSinglePromise(this, awakeable.handle, completeUsing(VoidAsUndefined, SuccessWithSerde(serde), Failure)),
         };
     }
     resolveAwakeable(id, payload, serde) {
-        // We coerce undefined to null as null can be stringified by JSON.stringify
-        let value;
-        if (serde) {
-            value =
-                payload == undefined ? new Uint8Array() : serde.serialize(payload);
-        }
-        else {
-            value =
-                payload != undefined
-                    ? (0, rpc_js_1.defaultSerde)().serialize(payload)
-                    : (0, rpc_js_1.defaultSerde)().serialize(null);
-        }
-        this.checkState("resolveAwakeable");
-        this.completeAwakeable(id, {
-            result: {
-                case: "value",
-                value,
-            },
+        this.processNonCompletableEntry((vm) => {
+            // We coerce undefined to null as null can be stringified by JSON.stringify
+            let value;
+            if (serde) {
+                value =
+                    payload === undefined ? new Uint8Array() : serde.serialize(payload);
+            }
+            else {
+                value =
+                    payload !== undefined
+                        ? (0, rpc_js_1.defaultSerde)().serialize(payload)
+                        : (0, rpc_js_1.defaultSerde)().serialize(null);
+            }
+            vm.sys_complete_awakeable_success(id, value);
         });
     }
     rejectAwakeable(id, reason) {
-        this.checkState("rejectAwakeable");
-        this.completeAwakeable(id, {
-            result: {
-                case: "failure",
-                value: { code: errors_js_1.UNKNOWN_ERROR_CODE, message: reason },
-            },
+        this.processNonCompletableEntry((vm) => {
+            vm.sys_complete_awakeable_failure(id, {
+                code: errors_js_1.UNKNOWN_ERROR_CODE,
+                message: reason,
+            });
         });
     }
-    completeAwakeable(id, base) {
-        base.id = id;
-        this.stateMachine
-            .handleUserCodeMessage(protocol_js_1.COMPLETE_AWAKEABLE_ENTRY_MESSAGE_TYPE, new protocol_pb_js_1.CompleteAwakeableEntryMessage(base))
-            .catch((e) => this.stateMachine.handleDanglingPromiseError(e));
+    promise(name, serde) {
+        return new DurablePromiseImpl(this, name, serde);
     }
     // Used by static methods of CombineablePromise
     static createCombinator(combinatorConstructor, promises) {
-        const self = extractContext(promises[0]);
+        // Extract context from first promise
+        const self = (0, promises_js_1.extractContext)(promises[0]);
         if (!self) {
-            throw errors_js_1.RetryableError.internal("Not a combinable promise");
+            throw new Error("Not a combinable promise");
         }
-        const outPromises = [];
+        // Collect first the promises downcasted to the internal promise type
+        const castedPromises = [];
         for (const promise of promises) {
-            if (extractContext(promise) !== self) {
-                throw errors_js_1.RetryableError.internal("You're mixing up CombineablePromises from different RestateContext. This is not supported.");
+            if ((0, promises_js_1.extractContext)(promise) !== self) {
+                self.handleInvocationEndError(new Error("You're mixing up CombineablePromises from different RestateContext. This is not supported."));
+                return new promises_js_1.RestatePendingPromise(self);
             }
-            const index = promise
-                .journalIndex;
-            outPromises.push({
-                id: (0, promise_combinator_tracker_js_1.newJournalEntryPromiseId)(index),
-                promise: promise,
-            });
+            castedPromises.push(promise);
         }
-        return self.stateMachine.createCombinator(combinatorConstructor, outPromises);
+        return new promises_js_1.RestateCombinatorPromise(self, combinatorConstructor, castedPromises);
     }
     // -- Various private methods
-    checkNotExecutingRun(callType) {
-        if (this.executingRun) {
-            throw new errors_js_1.TerminalError(`Invoked a RestateContext method (${callType}) while a run() is still executing.
-          Make sure you await the ctx.run() call before using any other RestateContext method.`, { errorCode: errors_js_1.INTERNAL_ERROR_CODE });
+    processNonCompletableEntry(vmCall) {
+        try {
+            vmCall(this.coreVm);
+        }
+        catch (e) {
+            this.handleInvocationEndError(e);
         }
     }
-    checkState(callType) {
-        this.checkNotExecutingRun(callType);
+    processCompletableEntry(vmCall, completer) {
+        let handle;
+        try {
+            handle = vmCall(this.coreVm);
+        }
+        catch (e) {
+            this.handleInvocationEndError(e);
+            return new promises_js_1.RestatePendingPromise(this);
+        }
+        return new promises_js_1.RestateSinglePromise(this, handle, completer);
     }
-    markCombineablePromise(p) {
-        const journalIndex = this.stateMachine.getUserCodeJournalIndex();
-        const orTimeout = (millis) => {
-            const sleepPromise = this.sleepInternal(millis).transform(() => {
-                throw new errors_js_1.TimeoutError();
-            });
-            const sleepPromiseIndex = this.stateMachine.getUserCodeJournalIndex();
-            return this.stateMachine.createCombinator(Promise.race.bind(Promise), [
-                {
-                    id: (0, promise_combinator_tracker_js_1.newJournalEntryPromiseId)(journalIndex),
-                    promise: p,
-                },
-                {
-                    id: (0, promise_combinator_tracker_js_1.newJournalEntryPromiseId)(sleepPromiseIndex),
-                    promise: sleepPromise,
-                },
-            ]);
-        };
-        defineProperty(p, RESTATE_CTX_SYMBOL, this);
-        defineProperty(p, "journalIndex", journalIndex);
-        defineProperty(p, "orTimeout", orTimeout.bind(this));
-        return p;
+    handleInvocationEndError(e) {
+        const error = (0, errors_js_1.ensureError)(e);
+        if (!(error instanceof errors_js_1.RestateError) ||
+            error.code !== errors_js_1.SUSPENDED_ERROR_CODE) {
+            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();
     }
 }
 exports.ContextImpl = ContextImpl;
-// wraps defineProperty such that it informs tsc of the correct type of its output
-function defineProperty(obj, prop, value) {
-    Object.defineProperty(obj, prop, { value });
-}
-function unpack(a, b) {
-    if (typeof a == "string") {
+function unpackRunParameters(a, b) {
+    if (typeof a === "string") {
         if (typeof b !== "function") {
             throw new TypeError("");
         }
@@ -426,12 +355,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;
@@ -452,56 +375,118 @@ class DurablePromiseImpl {
     }
     [Symbol.toStringTag] = "DurablePromise";
     get() {
-        const msg = new protocol_pb_js_1.GetPromiseEntryMessage({
-            key: this.name,
-        });
-        return this.ctx.markCombineablePromise(this.ctx.stateMachine
-            .handleUserCodeMessage(protocol_js_1.GET_PROMISE_MESSAGE_TYPE, msg)
-            .transform((v) => {
-            if (!v) {
-                return undefined;
-            }
-            if (v instanceof protocol_pb_js_1.Empty) {
-                return undefined;
-            }
-            return this.serde.deserialize(v);
-        }));
+        return this.ctx.processCompletableEntry((vm) => vm.sys_get_promise(this.name), completeUsing(SuccessWithSerde(this.serde), Failure));
     }
     peek() {
-        const msg = new protocol_pb_js_1.PeekPromiseEntryMessage({
-            key: this.name,
-        });
-        return this.ctx.stateMachine
-            .handleUserCodeMessage(protocol_js_1.PEEK_PROMISE_MESSAGE_TYPE, msg)
-            .transform((v) => {
-            if (!v || v instanceof protocol_pb_js_1.Empty) {
-                return undefined;
-            }
-            return this.serde.deserialize(v);
-        });
+        return this.ctx.processCompletableEntry((vm) => vm.sys_peek_promise(this.name), completeUsing(VoidAsUndefined, SuccessWithSerde(this.serde), Failure));
     }
     resolve(value) {
-        const buffer = value != undefined ? this.serde.serialize(value) : new Uint8Array();
-        const msg = new protocol_pb_js_1.CompletePromiseEntryMessage({
-            key: this.name,
-            completion: {
-                case: "completionValue",
-                value: buffer,
-            },
-        });
-        return this.ctx.stateMachine.handleUserCodeMessage(protocol_js_1.COMPLETE_PROMISE_MESSAGE_TYPE, msg);
+        return this.ctx.processCompletableEntry((vm) => vm.sys_complete_promise_success(this.name, this.serde.serialize(value)), completeUsing(VoidAsUndefined, Failure));
     }
     reject(errorMsg) {
-        const msg = new protocol_pb_js_1.CompletePromiseEntryMessage({
-            key: this.name,
-            completion: {
-                case: "completionFailure",
-                value: {
-                    message: errorMsg,
-                },
-            },
-        });
-        return this.ctx.stateMachine.handleUserCodeMessage(protocol_js_1.COMPLETE_PROMISE_MESSAGE_TYPE, msg);
+        return this.ctx.processCompletableEntry((vm) => vm.sys_complete_promise_failure(this.name, {
+            code: errors_js_1.INTERNAL_ERROR_CODE,
+            message: errorMsg,
+        }), completeUsing(VoidAsUndefined, Failure));
     }
 }
+/// Tracker of run closures to run
+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 completable_promise_js_1.CompletablePromise();
+        }
+        return this.currentRunWaitPoint.promise;
+    }
+    unblockCurrentRunWaitPoint() {
+        if (this.currentRunWaitPoint !== undefined) {
+            const p = this.currentRunWaitPoint;
+            this.currentRunWaitPoint = undefined;
+            p.resolve();
+        }
+    }
+}
+exports.RunClosuresTracker = RunClosuresTracker;
+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)}`);
+    };
+}
+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 = (0, rpc_js_1.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 errors_js_1.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