@superdurable/dex 0.2.4 → 0.2.5

package/dist/src/gen/dex.js

@@ -666,6 +666,7 @@ function createBaseContext() {
         attempt: 0,
         fromStepExecutionId: "",
         recoveryError: undefined,
+        lastHeartbeatValue: undefined,
     };
 }
 export const Context = {
@@ -700,6 +701,9 @@ export const Context = {
         if (message.recoveryError !== undefined) {
             RecoveryErrorInfo.encode(message.recoveryError, writer.uint32(66).fork()).join();
         }
+        if (message.lastHeartbeatValue !== undefined) {
+            Value.encode(message.lastHeartbeatValue, writer.uint32(74).fork()).join();
+        }
         return writer;
     },
     decode(input, length) {
@@ -765,6 +769,13 @@ export const Context = {
                     message.recoveryError = RecoveryErrorInfo.decode(reader, reader.uint32());
                     continue;
                 }
+                case 9: {
+                    if (tag !== 74) {
+                        break;
+                    }
+                    message.lastHeartbeatValue = Value.decode(reader, reader.uint32());
+                    continue;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -793,6 +804,9 @@ export const Context = {
         message.recoveryError = (object.recoveryError !== undefined && object.recoveryError !== null)
             ? RecoveryErrorInfo.fromPartial(object.recoveryError)
             : undefined;
+        message.lastHeartbeatValue = (object.lastHeartbeatValue !== undefined && object.lastHeartbeatValue !== null)
+            ? Value.fromPartial(object.lastHeartbeatValue)
+            : undefined;
         return message;
     },
 };
@@ -1872,7 +1886,7 @@ export const ChannelMessage = {
     },
 };
 function createBaseWriteStreamRequest() {
-    return { flowId: "", flowType: "", streamName: "", streamCapacityBytes: 0n, value: undefined, idempotencyKey: "" };
+    return { flowId: "", flowType: "", streamName: "", streamCapacityBytes: 0n, value: undefined, source: "" };
 }
 export const WriteStreamRequest = {
     encode(message, writer = new BinaryWriter()) {
@@ -1894,8 +1908,8 @@ export const WriteStreamRequest = {
         if (message.value !== undefined) {
             Value.encode(message.value, writer.uint32(42).fork()).join();
         }
-        if (message.idempotencyKey !== "") {
-            writer.uint32(50).string(message.idempotencyKey);
+        if (message.source !== "") {
+            writer.uint32(50).string(message.source);
         }
         return writer;
     },
@@ -1945,7 +1959,7 @@ export const WriteStreamRequest = {
                     if (tag !== 50) {
                         break;
                     }
-                    message.idempotencyKey = reader.string();
+                    message.source = reader.string();
                     continue;
                 }
             }
@@ -1968,7 +1982,7 @@ export const WriteStreamRequest = {
             ? BigInt(object.streamCapacityBytes)
             : 0n;
         message.value = (object.value !== undefined && object.value !== null) ? Value.fromPartial(object.value) : undefined;
-        message.idempotencyKey = object.idempotencyKey ?? "";
+        message.source = object.source ?? "";
         return message;
     },
 };
@@ -2101,7 +2115,7 @@ export const ReadStreamResponse = {
     },
 };
 function createBaseStreamMessage() {
-    return { value: undefined, resumeToken: "", createdTime: undefined, idempotencyKey: "" };
+    return { value: undefined, resumeToken: "", createdTime: undefined, source: "" };
 }
 export const StreamMessage = {
     encode(message, writer = new BinaryWriter()) {
@@ -2114,8 +2128,8 @@ export const StreamMessage = {
         if (message.createdTime !== undefined) {
             Timestamp.encode(toTimestamp(message.createdTime), writer.uint32(26).fork()).join();
         }
-        if (message.idempotencyKey !== "") {
-            writer.uint32(34).string(message.idempotencyKey);
+        if (message.source !== "") {
+            writer.uint32(34).string(message.source);
         }
         return writer;
     },
@@ -2151,7 +2165,7 @@ export const StreamMessage = {
                     if (tag !== 34) {
                         break;
                     }
-                    message.idempotencyKey = reader.string();
+                    message.source = reader.string();
                     continue;
                 }
             }
@@ -2170,7 +2184,7 @@ export const StreamMessage = {
         message.value = (object.value !== undefined && object.value !== null) ? Value.fromPartial(object.value) : undefined;
         message.resumeToken = object.resumeToken ?? "";
         message.createdTime = object.createdTime ?? undefined;
-        message.idempotencyKey = object.idempotencyKey ?? "";
+        message.source = object.source ?? "";
         return message;
     },
 };
@@ -7642,6 +7656,197 @@ export const InvokeWaitForMethodResponse = {
         return message;
     },
 };
+function createBaseStepMethodHeartbeat() {
+    return { value: undefined };
+}
+export const StepMethodHeartbeat = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.value !== undefined) {
+            Value.encode(message.value, writer.uint32(10).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseStepMethodHeartbeat();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.value = Value.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return StepMethodHeartbeat.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseStepMethodHeartbeat();
+        message.value = (object.value !== undefined && object.value !== null) ? Value.fromPartial(object.value) : undefined;
+        return message;
+    },
+};
+function createBaseStepStreamWrite() {
+    return { streamName: "", streamCapacityBytes: 0n, value: undefined };
+}
+export const StepStreamWrite = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.streamName !== "") {
+            writer.uint32(10).string(message.streamName);
+        }
+        if (message.streamCapacityBytes !== 0n) {
+            if (BigInt.asIntN(64, message.streamCapacityBytes) !== message.streamCapacityBytes) {
+                throw new globalThis.Error("value provided for field message.streamCapacityBytes of type int64 too large");
+            }
+            writer.uint32(16).int64(message.streamCapacityBytes);
+        }
+        if (message.value !== undefined) {
+            Value.encode(message.value, writer.uint32(26).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseStepStreamWrite();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.streamName = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.streamCapacityBytes = reader.int64();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.value = Value.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return StepStreamWrite.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseStepStreamWrite();
+        message.streamName = object.streamName ?? "";
+        message.streamCapacityBytes = (object.streamCapacityBytes !== undefined && object.streamCapacityBytes !== null)
+            ? BigInt(object.streamCapacityBytes)
+            : 0n;
+        message.value = (object.value !== undefined && object.value !== null) ? Value.fromPartial(object.value) : undefined;
+        return message;
+    },
+};
+function createBaseInvokeWaitForMethodOutput() {
+    return { output: undefined };
+}
+export const InvokeWaitForMethodOutput = {
+    encode(message, writer = new BinaryWriter()) {
+        switch (message.output?.$case) {
+            case "heartbeat":
+                StepMethodHeartbeat.encode(message.output.value, writer.uint32(10).fork()).join();
+                break;
+            case "streamWrite":
+                StepStreamWrite.encode(message.output.value, writer.uint32(18).fork()).join();
+                break;
+            case "result":
+                InvokeWaitForMethodResponse.encode(message.output.value, writer.uint32(26).fork()).join();
+                break;
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseInvokeWaitForMethodOutput();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.output = { $case: "heartbeat", value: StepMethodHeartbeat.decode(reader, reader.uint32()) };
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.output = { $case: "streamWrite", value: StepStreamWrite.decode(reader, reader.uint32()) };
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.output = { $case: "result", value: InvokeWaitForMethodResponse.decode(reader, reader.uint32()) };
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return InvokeWaitForMethodOutput.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseInvokeWaitForMethodOutput();
+        switch (object.output?.$case) {
+            case "heartbeat": {
+                if (object.output?.value !== undefined && object.output?.value !== null) {
+                    message.output = { $case: "heartbeat", value: StepMethodHeartbeat.fromPartial(object.output.value) };
+                }
+                break;
+            }
+            case "streamWrite": {
+                if (object.output?.value !== undefined && object.output?.value !== null) {
+                    message.output = { $case: "streamWrite", value: StepStreamWrite.fromPartial(object.output.value) };
+                }
+                break;
+            }
+            case "result": {
+                if (object.output?.value !== undefined && object.output?.value !== null) {
+                    message.output = { $case: "result", value: InvokeWaitForMethodResponse.fromPartial(object.output.value) };
+                }
+                break;
+            }
+        }
+        return message;
+    },
+};
 function createBaseInvokeExecuteMethodRequest() {
     return {
         context: undefined,
@@ -7871,6 +8076,88 @@ export const InvokeExecuteMethodResponse = {
         return message;
     },
 };
+function createBaseInvokeExecuteMethodOutput() {
+    return { output: undefined };
+}
+export const InvokeExecuteMethodOutput = {
+    encode(message, writer = new BinaryWriter()) {
+        switch (message.output?.$case) {
+            case "heartbeat":
+                StepMethodHeartbeat.encode(message.output.value, writer.uint32(10).fork()).join();
+                break;
+            case "streamWrite":
+                StepStreamWrite.encode(message.output.value, writer.uint32(18).fork()).join();
+                break;
+            case "result":
+                InvokeExecuteMethodResponse.encode(message.output.value, writer.uint32(26).fork()).join();
+                break;
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseInvokeExecuteMethodOutput();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.output = { $case: "heartbeat", value: StepMethodHeartbeat.decode(reader, reader.uint32()) };
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.output = { $case: "streamWrite", value: StepStreamWrite.decode(reader, reader.uint32()) };
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.output = { $case: "result", value: InvokeExecuteMethodResponse.decode(reader, reader.uint32()) };
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return InvokeExecuteMethodOutput.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseInvokeExecuteMethodOutput();
+        switch (object.output?.$case) {
+            case "heartbeat": {
+                if (object.output?.value !== undefined && object.output?.value !== null) {
+                    message.output = { $case: "heartbeat", value: StepMethodHeartbeat.fromPartial(object.output.value) };
+                }
+                break;
+            }
+            case "streamWrite": {
+                if (object.output?.value !== undefined && object.output?.value !== null) {
+                    message.output = { $case: "streamWrite", value: StepStreamWrite.fromPartial(object.output.value) };
+                }
+                break;
+            }
+            case "result": {
+                if (object.output?.value !== undefined && object.output?.value !== null) {
+                    message.output = { $case: "result", value: InvokeExecuteMethodResponse.fromPartial(object.output.value) };
+                }
+                break;
+            }
+        }
+        return message;
+    },
+};
 function createBaseInvokeWorkerRPCRequest() {
     return { context: undefined, flowType: "", rpcName: "", input: undefined, attributes: [], channelInfos: {} };
 }
@@ -12730,20 +13017,20 @@ export const WorkerServiceService = {
     invokeWaitForMethod: {
         path: "/dex.WorkerService/InvokeWaitForMethod",
         requestStream: false,
-        responseStream: false,
+        responseStream: true,
         requestSerialize: (value) => Buffer.from(InvokeWaitForMethodRequest.encode(value).finish()),
         requestDeserialize: (value) => InvokeWaitForMethodRequest.decode(value),
-        responseSerialize: (value) => Buffer.from(InvokeWaitForMethodResponse.encode(value).finish()),
-        responseDeserialize: (value) => InvokeWaitForMethodResponse.decode(value),
+        responseSerialize: (value) => Buffer.from(InvokeWaitForMethodOutput.encode(value).finish()),
+        responseDeserialize: (value) => InvokeWaitForMethodOutput.decode(value),
     },
     invokeExecuteMethod: {
         path: "/dex.WorkerService/InvokeExecuteMethod",
         requestStream: false,
-        responseStream: false,
+        responseStream: true,
         requestSerialize: (value) => Buffer.from(InvokeExecuteMethodRequest.encode(value).finish()),
         requestDeserialize: (value) => InvokeExecuteMethodRequest.decode(value),
-        responseSerialize: (value) => Buffer.from(InvokeExecuteMethodResponse.encode(value).finish()),
-        responseDeserialize: (value) => InvokeExecuteMethodResponse.decode(value),
+        responseSerialize: (value) => Buffer.from(InvokeExecuteMethodOutput.encode(value).finish()),
+        responseDeserialize: (value) => InvokeExecuteMethodOutput.decode(value),
     },
     invokeWorkerRpc: {
         path: "/dex.WorkerService/InvokeWorkerRPC",