@restatedev/restate-sdk-cloudflare-workers 1.10.3 → 1.11.0

package/dist/endpoint/handlers/lambda.cjs

@@ -1,10 +1,7 @@
 const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
 const require_errors = require('../../types/errors.cjs');
 const require_user_agent = require('../../user_agent.cjs');
-const require_streams = require('../../utils/streams.cjs');
-const require_generic = require('./generic.cjs');
-let node_stream_web = require("node:stream/web");
-node_stream_web = require_rolldown_runtime.__toESM(node_stream_web);
+const require_utils = require('./utils.cjs');
 let node_buffer = require("node:buffer");
 node_buffer = require_rolldown_runtime.__toESM(node_buffer);
 let node_zlib = require("node:zlib");
@@ -18,70 +15,76 @@ var LambdaHandler = class {
 		this.compressionSupported = compressionSupported;
 	}
 	async handleRequest(event, context) {
-		const path = "path" in event ? event.path : event.rawPath;
-		let requestContentEncoding;
-		let requestAcceptEncoding;
-		for (const [key, value] of Object.entries(event.headers)) if (key.localeCompare("content-encoding", void 0, { sensitivity: "accent" }) === 0) requestContentEncoding = value;
-		else if (key.localeCompare("accept-encoding", void 0, { sensitivity: "accent" }) === 0) requestAcceptEncoding = value;
-		let bodyStream;
-		if (!event.body) bodyStream = null;
-		else {
-			let bodyBuffer;
-			if (event.isBase64Encoded) bodyBuffer = node_buffer.Buffer.from(event.body, "base64");
-			else bodyBuffer = node_buffer.Buffer.from(new TextEncoder().encode(event.body));
-			if (requestContentEncoding && requestContentEncoding.includes("zstd")) {
-				if (!this.compressionSupported) throw new Error("The input is compressed using zstd, but this lambda deployment doesn't support compression. Make sure to deploy the Lambda using Node > 22");
-				bodyBuffer = node_zlib.zstdDecompressSync(bodyBuffer);
-			}
-			bodyStream = require_streams.OnceStream(bodyBuffer);
-		}
 		const abortController = new AbortController();
-		const request = {
-			body: bodyStream,
-			headers: event.headers,
-			url: path,
-			extraArgs: [context],
-			abortSignal: abortController.signal
-		};
-		let response;
-		try {
-			response = await this.handler.handle(request, { AWSRequestId: context.awsRequestId });
-		} catch (e) {
-			abortController.abort();
-			throw e;
-		}
-		const chunks = [];
 		try {
-			await response.body.pipeTo(new node_stream_web.WritableStream({ write: (chunk) => {
-				chunks.push(chunk);
-			} }));
-		} catch (e) {
-			const error = require_errors.ensureError(e);
-			(require_generic.tryCreateContextualLogger(this.handler.endpoint.loggerTransport, request.url, request.headers) ?? this.handler.endpoint.rlog).error("Error while collecting invocation response: " + (error.stack ?? error.message));
-			return {
-				headers: {
-					"content-type": "application/json",
-					"x-restate-server": require_user_agent.X_RESTATE_SERVER
+			const path = "path" in event ? event.path : event.rawPath;
+			let requestContentEncoding;
+			let requestAcceptEncoding;
+			for (const [key, value] of Object.entries(event.headers)) if (key.localeCompare("content-encoding", void 0, { sensitivity: "accent" }) === 0) requestContentEncoding = value;
+			else if (key.localeCompare("accept-encoding", void 0, { sensitivity: "accent" }) === 0) requestAcceptEncoding = value;
+			let inputReader;
+			if (!event.body) inputReader = require_utils.emptyInputReader();
+			else {
+				let bodyBuffer;
+				if (event.isBase64Encoded) bodyBuffer = node_buffer.Buffer.from(event.body, "base64");
+				else bodyBuffer = node_buffer.Buffer.from(new TextEncoder().encode(event.body));
+				if (requestContentEncoding && requestContentEncoding.includes("zstd")) {
+					if (!this.compressionSupported) throw new Error("The input is compressed using zstd, but this lambda deployment doesn't support compression. Make sure to deploy the Lambda using Node > 22");
+					bodyBuffer = node_zlib.zstdDecompressSync(bodyBuffer);
+				}
+				inputReader = (async function* () {
+					yield bodyBuffer;
+				})()[Symbol.asyncIterator]();
+			}
+			const chunks = [];
+			const outputWriter = {
+				write: function(value) {
+					chunks.push(value);
+					return Promise.resolve();
 				},
-				statusCode: 500,
-				isBase64Encoded: false,
-				body: JSON.stringify({ message: error.message })
+				close: function() {
+					return Promise.resolve();
+				}
+			};
+			const response = this.handler.handle({
+				headers: event.headers,
+				url: path,
+				extraArgs: [context]
+			}, { AWSRequestId: context.awsRequestId });
+			try {
+				await response.process({
+					inputReader,
+					outputWriter,
+					abortSignal: abortController.signal
+				});
+			} catch (e) {
+				const error = require_errors.ensureError(e);
+				(require_utils.tryCreateContextualLogger(this.handler.endpoint.loggerTransport, path, event.headers) ?? this.handler.endpoint.rlog).error("Unexpected error: " + (error.stack ?? error.message));
+				return {
+					headers: {
+						"content-type": "application/json",
+						"x-restate-server": require_user_agent.X_RESTATE_SERVER
+					},
+					statusCode: 500,
+					isBase64Encoded: false,
+					body: JSON.stringify({ message: error.message })
+				};
+			}
+			const responseBodyBuffer = node_buffer.Buffer.concat(chunks);
+			let responseBody;
+			if (this.compressionSupported && responseBodyBuffer.length > RESPONSE_COMPRESSION_THRESHOLD && requestAcceptEncoding && requestAcceptEncoding.includes("zstd")) {
+				response.headers["content-encoding"] = "zstd";
+				responseBody = node_zlib.zstdCompressSync(responseBodyBuffer).toString("base64");
+			} else responseBody = responseBodyBuffer.toString("base64");
+			return {
+				headers: response.headers,
+				statusCode: response.statusCode,
+				isBase64Encoded: true,
+				body: responseBody
 			};
 		} finally {
 			abortController.abort();
 		}
-		const responseBodyBuffer = node_buffer.Buffer.concat(chunks);
-		let responseBody;
-		if (this.compressionSupported && responseBodyBuffer.length > RESPONSE_COMPRESSION_THRESHOLD && requestAcceptEncoding && requestAcceptEncoding.includes("zstd")) {
-			response.headers["content-encoding"] = "zstd";
-			responseBody = node_zlib.zstdCompressSync(responseBodyBuffer).toString("base64");
-		} else responseBody = responseBodyBuffer.toString("base64");
-		return {
-			headers: response.headers,
-			statusCode: response.statusCode,
-			isBase64Encoded: true,
-			body: responseBody
-		};
 	}
 };
 function isCompressionSupported() {

package/dist/endpoint/handlers/lambda.js

@@ -1,8 +1,6 @@
 import { ensureError } from "../../types/errors.js";
 import { X_RESTATE_SERVER } from "../../user_agent.js";
-import { OnceStream } from "../../utils/streams.js";
-import { tryCreateContextualLogger } from "./generic.js";
-import { WritableStream } from "node:stream/web";
+import { emptyInputReader, tryCreateContextualLogger } from "./utils.js";
 import { Buffer } from "node:buffer";
 import * as zlib from "node:zlib";
 
@@ -14,70 +12,76 @@ var LambdaHandler = class {
 		this.compressionSupported = compressionSupported;
 	}
 	async handleRequest(event, context) {
-		const path = "path" in event ? event.path : event.rawPath;
-		let requestContentEncoding;
-		let requestAcceptEncoding;
-		for (const [key, value] of Object.entries(event.headers)) if (key.localeCompare("content-encoding", void 0, { sensitivity: "accent" }) === 0) requestContentEncoding = value;
-		else if (key.localeCompare("accept-encoding", void 0, { sensitivity: "accent" }) === 0) requestAcceptEncoding = value;
-		let bodyStream;
-		if (!event.body) bodyStream = null;
-		else {
-			let bodyBuffer;
-			if (event.isBase64Encoded) bodyBuffer = Buffer.from(event.body, "base64");
-			else bodyBuffer = Buffer.from(new TextEncoder().encode(event.body));
-			if (requestContentEncoding && requestContentEncoding.includes("zstd")) {
-				if (!this.compressionSupported) throw new Error("The input is compressed using zstd, but this lambda deployment doesn't support compression. Make sure to deploy the Lambda using Node > 22");
-				bodyBuffer = zlib.zstdDecompressSync(bodyBuffer);
-			}
-			bodyStream = OnceStream(bodyBuffer);
-		}
 		const abortController = new AbortController();
-		const request = {
-			body: bodyStream,
-			headers: event.headers,
-			url: path,
-			extraArgs: [context],
-			abortSignal: abortController.signal
-		};
-		let response;
-		try {
-			response = await this.handler.handle(request, { AWSRequestId: context.awsRequestId });
-		} catch (e) {
-			abortController.abort();
-			throw e;
-		}
-		const chunks = [];
 		try {
-			await response.body.pipeTo(new WritableStream({ write: (chunk) => {
-				chunks.push(chunk);
-			} }));
-		} catch (e) {
-			const error = ensureError(e);
-			(tryCreateContextualLogger(this.handler.endpoint.loggerTransport, request.url, request.headers) ?? this.handler.endpoint.rlog).error("Error while collecting invocation response: " + (error.stack ?? error.message));
-			return {
-				headers: {
-					"content-type": "application/json",
-					"x-restate-server": X_RESTATE_SERVER
+			const path = "path" in event ? event.path : event.rawPath;
+			let requestContentEncoding;
+			let requestAcceptEncoding;
+			for (const [key, value] of Object.entries(event.headers)) if (key.localeCompare("content-encoding", void 0, { sensitivity: "accent" }) === 0) requestContentEncoding = value;
+			else if (key.localeCompare("accept-encoding", void 0, { sensitivity: "accent" }) === 0) requestAcceptEncoding = value;
+			let inputReader;
+			if (!event.body) inputReader = emptyInputReader();
+			else {
+				let bodyBuffer;
+				if (event.isBase64Encoded) bodyBuffer = Buffer.from(event.body, "base64");
+				else bodyBuffer = Buffer.from(new TextEncoder().encode(event.body));
+				if (requestContentEncoding && requestContentEncoding.includes("zstd")) {
+					if (!this.compressionSupported) throw new Error("The input is compressed using zstd, but this lambda deployment doesn't support compression. Make sure to deploy the Lambda using Node > 22");
+					bodyBuffer = zlib.zstdDecompressSync(bodyBuffer);
+				}
+				inputReader = (async function* () {
+					yield bodyBuffer;
+				})()[Symbol.asyncIterator]();
+			}
+			const chunks = [];
+			const outputWriter = {
+				write: function(value) {
+					chunks.push(value);
+					return Promise.resolve();
 				},
-				statusCode: 500,
-				isBase64Encoded: false,
-				body: JSON.stringify({ message: error.message })
+				close: function() {
+					return Promise.resolve();
+				}
+			};
+			const response = this.handler.handle({
+				headers: event.headers,
+				url: path,
+				extraArgs: [context]
+			}, { AWSRequestId: context.awsRequestId });
+			try {
+				await response.process({
+					inputReader,
+					outputWriter,
+					abortSignal: abortController.signal
+				});
+			} catch (e) {
+				const error = ensureError(e);
+				(tryCreateContextualLogger(this.handler.endpoint.loggerTransport, path, event.headers) ?? this.handler.endpoint.rlog).error("Unexpected error: " + (error.stack ?? error.message));
+				return {
+					headers: {
+						"content-type": "application/json",
+						"x-restate-server": X_RESTATE_SERVER
+					},
+					statusCode: 500,
+					isBase64Encoded: false,
+					body: JSON.stringify({ message: error.message })
+				};
+			}
+			const responseBodyBuffer = Buffer.concat(chunks);
+			let responseBody;
+			if (this.compressionSupported && responseBodyBuffer.length > RESPONSE_COMPRESSION_THRESHOLD && requestAcceptEncoding && requestAcceptEncoding.includes("zstd")) {
+				response.headers["content-encoding"] = "zstd";
+				responseBody = zlib.zstdCompressSync(responseBodyBuffer).toString("base64");
+			} else responseBody = responseBodyBuffer.toString("base64");
+			return {
+				headers: response.headers,
+				statusCode: response.statusCode,
+				isBase64Encoded: true,
+				body: responseBody
 			};
 		} finally {
 			abortController.abort();
 		}
-		const responseBodyBuffer = Buffer.concat(chunks);
-		let responseBody;
-		if (this.compressionSupported && responseBodyBuffer.length > RESPONSE_COMPRESSION_THRESHOLD && requestAcceptEncoding && requestAcceptEncoding.includes("zstd")) {
-			response.headers["content-encoding"] = "zstd";
-			responseBody = zlib.zstdCompressSync(responseBodyBuffer).toString("base64");
-		} else responseBody = responseBodyBuffer.toString("base64");
-		return {
-			headers: response.headers,
-			statusCode: response.statusCode,
-			isBase64Encoded: true,
-			body: responseBody
-		};
 	}
 };
 function isCompressionSupported() {

package/dist/endpoint/handlers/lambda.js.map

@@ -1 +1 @@
-{"version":3,"file":"lambda.js","names":["handler: GenericHandler","compressionSupported: boolean","bodyStream: ReadableStream<Uint8Array> | null","bodyBuffer: Buffer | undefined","request: RestateRequest","response: RestateResponse","chunks: Uint8Array[]"],"sources":["../../../src/endpoint/handlers/lambda.ts"],"sourcesContent":["/*\n * Copyright (c) 2023-2024 - Restate Software, Inc., Restate GmbH\n *\n * This file is part of the Restate SDK for Node.js/TypeScript,\n * which is released under the MIT license.\n *\n * You can find a copy of the license in file LICENSE in the root\n * directory of this repository or package, or at\n * https://github.com/restatedev/sdk-typescript/blob/main/LICENSE\n */\n\nimport type {\n  APIGatewayProxyEvent,\n  APIGatewayProxyEventV2,\n  APIGatewayProxyResult,\n  APIGatewayProxyStructuredResultV2,\n  Context,\n} from \"aws-lambda\";\nimport { Buffer } from \"node:buffer\";\nimport type {\n  GenericHandler,\n  RestateRequest,\n  RestateResponse,\n} from \"./generic.js\";\nimport { tryCreateContextualLogger } from \"./generic.js\";\nimport { WritableStream, type ReadableStream } from \"node:stream/web\";\nimport { OnceStream } from \"../../utils/streams.js\";\nimport { X_RESTATE_SERVER } from \"../../user_agent.js\";\nimport { ensureError } from \"../../types/errors.js\";\nimport * as zlib from \"node:zlib\";\n\nconst RESPONSE_COMPRESSION_THRESHOLD = 3 * 1024 * 1024;\n\nexport class LambdaHandler {\n  constructor(\n    private readonly handler: GenericHandler,\n    private readonly compressionSupported: boolean\n  ) {}\n\n  async handleRequest(\n    event: APIGatewayProxyEvent | APIGatewayProxyEventV2,\n    context: Context\n  ): Promise<APIGatewayProxyResult | APIGatewayProxyStructuredResultV2> {\n    //\n    // Request path\n    //\n    const path = \"path\" in event ? event.path : event.rawPath;\n\n    // Deal with content-encoding\n    let requestContentEncoding;\n    let requestAcceptEncoding;\n    for (const [key, value] of Object.entries(event.headers)) {\n      if (\n        key.localeCompare(\"content-encoding\", undefined, {\n          sensitivity: \"accent\",\n        }) === 0\n      ) {\n        requestContentEncoding = value;\n      } else if (\n        key.localeCompare(\"accept-encoding\", undefined, {\n          sensitivity: \"accent\",\n        }) === 0\n      ) {\n        requestAcceptEncoding = value;\n      }\n    }\n\n    //\n    // Convert the request body to a Uint8Array stream\n    // Lambda functions receive the body as base64 encoded string\n    //\n    let bodyStream: ReadableStream<Uint8Array> | null;\n    if (!event.body) {\n      bodyStream = null;\n    } else {\n      let bodyBuffer: Buffer | undefined;\n      if (event.isBase64Encoded) {\n        bodyBuffer = Buffer.from(event.body, \"base64\");\n      } else {\n        bodyBuffer = Buffer.from(new TextEncoder().encode(event.body));\n      }\n\n      // Now decode if needed\n      if (requestContentEncoding && requestContentEncoding.includes(\"zstd\")) {\n        if (!this.compressionSupported) {\n          throw new Error(\n            \"The input is compressed using zstd, but this lambda deployment doesn't support compression. Make sure to deploy the Lambda using Node > 22\"\n          );\n        }\n\n        // Input encoded with zstd, let's decode it!\n        bodyBuffer = (\n          zlib as unknown as { zstdDecompressSync: (b: Buffer) => Buffer }\n        ).zstdDecompressSync(bodyBuffer);\n      }\n\n      // Prep the stream to pass through the endpoint handler\n      bodyStream = OnceStream(bodyBuffer);\n    }\n\n    const abortController = new AbortController();\n\n    const request: RestateRequest = {\n      body: bodyStream,\n      headers: event.headers,\n      url: path,\n      extraArgs: [context],\n      abortSignal: abortController.signal,\n    };\n\n    let response: RestateResponse;\n\n    try {\n      response = await this.handler.handle(request, {\n        AWSRequestId: context.awsRequestId,\n      });\n    } catch (e) {\n      abortController.abort();\n      throw e;\n    }\n\n    const chunks: Uint8Array[] = [];\n\n    try {\n      await response.body.pipeTo(\n        new WritableStream<Uint8Array>({\n          write: (chunk) => {\n            chunks.push(chunk);\n          },\n        })\n      );\n    } catch (e) {\n      // unlike in the streaming case, we can actually catch errors in the response body and form a nicer error\n      const error = ensureError(e);\n      (\n        tryCreateContextualLogger(\n          this.handler.endpoint.loggerTransport,\n          request.url,\n          request.headers\n        ) ?? this.handler.endpoint.rlog\n      ).error(\n        \"Error while collecting invocation response: \" +\n          (error.stack ?? error.message)\n      );\n      return {\n        headers: {\n          \"content-type\": \"application/json\",\n          \"x-restate-server\": X_RESTATE_SERVER,\n        },\n        statusCode: 500,\n        isBase64Encoded: false,\n        body: JSON.stringify({ message: error.message }),\n      };\n    } finally {\n      abortController.abort();\n    }\n\n    const responseBodyBuffer = Buffer.concat(chunks);\n    let responseBody;\n\n    // Now let's encode if we need to.\n    if (\n      this.compressionSupported &&\n      responseBodyBuffer.length > RESPONSE_COMPRESSION_THRESHOLD &&\n      requestAcceptEncoding &&\n      requestAcceptEncoding.includes(\"zstd\")\n    ) {\n      response.headers[\"content-encoding\"] = \"zstd\";\n\n      responseBody = (\n        zlib as unknown as { zstdCompressSync: (b: Buffer) => Buffer }\n      )\n        .zstdCompressSync(responseBodyBuffer)\n        .toString(\"base64\");\n    } else {\n      responseBody = responseBodyBuffer.toString(\"base64\");\n    }\n    return {\n      headers: response.headers,\n      statusCode: response.statusCode,\n      isBase64Encoded: true,\n      body: responseBody,\n    };\n  }\n}\n\nexport function isCompressionSupported() {\n  return \"zstdDecompressSync\" in zlib && \"zstdCompressSync\" in zlib;\n}\n"],"mappings":";;;;;;;;;AA+BA,MAAM,iCAAiC,IAAI,OAAO;AAElD,IAAa,gBAAb,MAA2B;CACzB,YACE,AAAiBA,SACjB,AAAiBC,sBACjB;EAFiB;EACA;;CAGnB,MAAM,cACJ,OACA,SACoE;EAIpE,MAAM,OAAO,UAAU,QAAQ,MAAM,OAAO,MAAM;EAGlD,IAAI;EACJ,IAAI;AACJ,OAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,MAAM,QAAQ,CACtD,KACE,IAAI,cAAc,oBAAoB,QAAW,EAC/C,aAAa,UACd,CAAC,KAAK,EAEP,0BAAyB;WAEzB,IAAI,cAAc,mBAAmB,QAAW,EAC9C,aAAa,UACd,CAAC,KAAK,EAEP,yBAAwB;EAQ5B,IAAIC;AACJ,MAAI,CAAC,MAAM,KACT,cAAa;OACR;GACL,IAAIC;AACJ,OAAI,MAAM,gBACR,cAAa,OAAO,KAAK,MAAM,MAAM,SAAS;OAE9C,cAAa,OAAO,KAAK,IAAI,aAAa,CAAC,OAAO,MAAM,KAAK,CAAC;AAIhE,OAAI,0BAA0B,uBAAuB,SAAS,OAAO,EAAE;AACrE,QAAI,CAAC,KAAK,qBACR,OAAM,IAAI,MACR,6IACD;AAIH,iBACE,KACA,mBAAmB,WAAW;;AAIlC,gBAAa,WAAW,WAAW;;EAGrC,MAAM,kBAAkB,IAAI,iBAAiB;EAE7C,MAAMC,UAA0B;GAC9B,MAAM;GACN,SAAS,MAAM;GACf,KAAK;GACL,WAAW,CAAC,QAAQ;GACpB,aAAa,gBAAgB;GAC9B;EAED,IAAIC;AAEJ,MAAI;AACF,cAAW,MAAM,KAAK,QAAQ,OAAO,SAAS,EAC5C,cAAc,QAAQ,cACvB,CAAC;WACK,GAAG;AACV,mBAAgB,OAAO;AACvB,SAAM;;EAGR,MAAMC,SAAuB,EAAE;AAE/B,MAAI;AACF,SAAM,SAAS,KAAK,OAClB,IAAI,eAA2B,EAC7B,QAAQ,UAAU;AAChB,WAAO,KAAK,MAAM;MAErB,CAAC,CACH;WACM,GAAG;GAEV,MAAM,QAAQ,YAAY,EAAE;AAC5B,IACE,0BACE,KAAK,QAAQ,SAAS,iBACtB,QAAQ,KACR,QAAQ,QACT,IAAI,KAAK,QAAQ,SAAS,MAC3B,MACA,kDACG,MAAM,SAAS,MAAM,SACzB;AACD,UAAO;IACL,SAAS;KACP,gBAAgB;KAChB,oBAAoB;KACrB;IACD,YAAY;IACZ,iBAAiB;IACjB,MAAM,KAAK,UAAU,EAAE,SAAS,MAAM,SAAS,CAAC;IACjD;YACO;AACR,mBAAgB,OAAO;;EAGzB,MAAM,qBAAqB,OAAO,OAAO,OAAO;EAChD,IAAI;AAGJ,MACE,KAAK,wBACL,mBAAmB,SAAS,kCAC5B,yBACA,sBAAsB,SAAS,OAAO,EACtC;AACA,YAAS,QAAQ,sBAAsB;AAEvC,kBACE,KAEC,iBAAiB,mBAAmB,CACpC,SAAS,SAAS;QAErB,gBAAe,mBAAmB,SAAS,SAAS;AAEtD,SAAO;GACL,SAAS,SAAS;GAClB,YAAY,SAAS;GACrB,iBAAiB;GACjB,MAAM;GACP;;;AAIL,SAAgB,yBAAyB;AACvC,QAAO,wBAAwB,QAAQ,sBAAsB"}
+{"version":3,"file":"lambda.js","names":["handler: RestateHandler","compressionSupported: boolean","inputReader: InputReader","bodyBuffer: Buffer | undefined","chunks: Uint8Array[]","outputWriter: OutputWriter"],"sources":["../../../src/endpoint/handlers/lambda.ts"],"sourcesContent":["/*\n * Copyright (c) 2023-2024 - Restate Software, Inc., Restate GmbH\n *\n * This file is part of the Restate SDK for Node.js/TypeScript,\n * which is released under the MIT license.\n *\n * You can find a copy of the license in file LICENSE in the root\n * directory of this repository or package, or at\n * https://github.com/restatedev/sdk-typescript/blob/main/LICENSE\n */\n\nimport type {\n  APIGatewayProxyEvent,\n  APIGatewayProxyEventV2,\n  APIGatewayProxyResult,\n  APIGatewayProxyStructuredResultV2,\n  Context,\n} from \"aws-lambda\";\nimport { Buffer } from \"node:buffer\";\nimport { X_RESTATE_SERVER } from \"../../user_agent.js\";\nimport { ensureError } from \"../../types/errors.js\";\nimport * as zlib from \"node:zlib\";\nimport { InputReader, OutputWriter, RestateHandler } from \"./types.js\";\nimport { emptyInputReader, tryCreateContextualLogger } from \"./utils.js\";\n\nconst RESPONSE_COMPRESSION_THRESHOLD = 3 * 1024 * 1024;\n\nexport class LambdaHandler {\n  constructor(\n    private readonly handler: RestateHandler,\n    private readonly compressionSupported: boolean\n  ) {}\n\n  async handleRequest(\n    event: APIGatewayProxyEvent | APIGatewayProxyEventV2,\n    context: Context\n  ): Promise<APIGatewayProxyResult | APIGatewayProxyStructuredResultV2> {\n    const abortController = new AbortController();\n    try {\n      //\n      // Request path\n      //\n      const path = \"path\" in event ? event.path : event.rawPath;\n\n      // Deal with content-encoding\n      let requestContentEncoding;\n      let requestAcceptEncoding;\n      for (const [key, value] of Object.entries(event.headers)) {\n        if (\n          key.localeCompare(\"content-encoding\", undefined, {\n            sensitivity: \"accent\",\n          }) === 0\n        ) {\n          requestContentEncoding = value;\n        } else if (\n          key.localeCompare(\"accept-encoding\", undefined, {\n            sensitivity: \"accent\",\n          }) === 0\n        ) {\n          requestAcceptEncoding = value;\n        }\n      }\n\n      //\n      // Convert the request body to a Uint8Array stream\n      // Lambda functions receive the body as base64 encoded string\n      //\n      let inputReader: InputReader;\n      if (!event.body) {\n        inputReader = emptyInputReader();\n      } else {\n        let bodyBuffer: Buffer | undefined;\n        if (event.isBase64Encoded) {\n          bodyBuffer = Buffer.from(event.body, \"base64\");\n        } else {\n          bodyBuffer = Buffer.from(new TextEncoder().encode(event.body));\n        }\n\n        // Now decode if needed\n        if (requestContentEncoding && requestContentEncoding.includes(\"zstd\")) {\n          if (!this.compressionSupported) {\n            throw new Error(\n              \"The input is compressed using zstd, but this lambda deployment doesn't support compression. Make sure to deploy the Lambda using Node > 22\"\n            );\n          }\n\n          // Input encoded with zstd, let's decode it!\n          bodyBuffer = (\n            zlib as unknown as { zstdDecompressSync: (b: Buffer) => Buffer }\n          ).zstdDecompressSync(bodyBuffer);\n        }\n\n        // Prep the stream to pass through the endpoint handler\n        // eslint-disable-next-line @typescript-eslint/require-await\n        inputReader = (async function* () {\n          yield bodyBuffer as Uint8Array;\n        })()[Symbol.asyncIterator]();\n      }\n\n      const chunks: Uint8Array[] = [];\n      const outputWriter: OutputWriter = {\n        write: function (value: Uint8Array): Promise<void> {\n          chunks.push(value);\n          return Promise.resolve();\n        },\n        close: function (): Promise<void> {\n          return Promise.resolve();\n        },\n      };\n\n      const response = this.handler.handle(\n        {\n          headers: event.headers,\n          url: path,\n          extraArgs: [context],\n        },\n        {\n          AWSRequestId: context.awsRequestId,\n        }\n      );\n\n      try {\n        await response.process({\n          inputReader,\n          outputWriter,\n          abortSignal: abortController.signal,\n        });\n      } catch (e) {\n        // handle should never throw\n        const error = ensureError(e);\n        const logger =\n          tryCreateContextualLogger(\n            this.handler.endpoint.loggerTransport,\n            path,\n            event.headers\n          ) ?? this.handler.endpoint.rlog;\n        logger.error(\"Unexpected error: \" + (error.stack ?? error.message));\n        return {\n          headers: {\n            \"content-type\": \"application/json\",\n            \"x-restate-server\": X_RESTATE_SERVER,\n          },\n          statusCode: 500,\n          isBase64Encoded: false,\n          body: JSON.stringify({ message: error.message }),\n        };\n      }\n\n      const responseBodyBuffer = Buffer.concat(chunks);\n      let responseBody;\n\n      // Now let's encode if we need to.\n      if (\n        this.compressionSupported &&\n        responseBodyBuffer.length > RESPONSE_COMPRESSION_THRESHOLD &&\n        requestAcceptEncoding &&\n        requestAcceptEncoding.includes(\"zstd\")\n      ) {\n        response.headers[\"content-encoding\"] = \"zstd\";\n\n        responseBody = (\n          zlib as unknown as { zstdCompressSync: (b: Buffer) => Buffer }\n        )\n          .zstdCompressSync(responseBodyBuffer)\n          .toString(\"base64\");\n      } else {\n        responseBody = responseBodyBuffer.toString(\"base64\");\n      }\n      return {\n        headers: response.headers,\n        statusCode: response.statusCode,\n        isBase64Encoded: true,\n        body: responseBody,\n      };\n    } finally {\n      abortController.abort();\n    }\n  }\n}\n\nexport function isCompressionSupported() {\n  return \"zstdDecompressSync\" in zlib && \"zstdCompressSync\" in zlib;\n}\n"],"mappings":";;;;;;;AAyBA,MAAM,iCAAiC,IAAI,OAAO;AAElD,IAAa,gBAAb,MAA2B;CACzB,YACE,AAAiBA,SACjB,AAAiBC,sBACjB;EAFiB;EACA;;CAGnB,MAAM,cACJ,OACA,SACoE;EACpE,MAAM,kBAAkB,IAAI,iBAAiB;AAC7C,MAAI;GAIF,MAAM,OAAO,UAAU,QAAQ,MAAM,OAAO,MAAM;GAGlD,IAAI;GACJ,IAAI;AACJ,QAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,MAAM,QAAQ,CACtD,KACE,IAAI,cAAc,oBAAoB,QAAW,EAC/C,aAAa,UACd,CAAC,KAAK,EAEP,0BAAyB;YAEzB,IAAI,cAAc,mBAAmB,QAAW,EAC9C,aAAa,UACd,CAAC,KAAK,EAEP,yBAAwB;GAQ5B,IAAIC;AACJ,OAAI,CAAC,MAAM,KACT,eAAc,kBAAkB;QAC3B;IACL,IAAIC;AACJ,QAAI,MAAM,gBACR,cAAa,OAAO,KAAK,MAAM,MAAM,SAAS;QAE9C,cAAa,OAAO,KAAK,IAAI,aAAa,CAAC,OAAO,MAAM,KAAK,CAAC;AAIhE,QAAI,0BAA0B,uBAAuB,SAAS,OAAO,EAAE;AACrE,SAAI,CAAC,KAAK,qBACR,OAAM,IAAI,MACR,6IACD;AAIH,kBACE,KACA,mBAAmB,WAAW;;AAKlC,mBAAe,mBAAmB;AAChC,WAAM;QACJ,CAAC,OAAO,gBAAgB;;GAG9B,MAAMC,SAAuB,EAAE;GAC/B,MAAMC,eAA6B;IACjC,OAAO,SAAU,OAAkC;AACjD,YAAO,KAAK,MAAM;AAClB,YAAO,QAAQ,SAAS;;IAE1B,OAAO,WAA2B;AAChC,YAAO,QAAQ,SAAS;;IAE3B;GAED,MAAM,WAAW,KAAK,QAAQ,OAC5B;IACE,SAAS,MAAM;IACf,KAAK;IACL,WAAW,CAAC,QAAQ;IACrB,EACD,EACE,cAAc,QAAQ,cACvB,CACF;AAED,OAAI;AACF,UAAM,SAAS,QAAQ;KACrB;KACA;KACA,aAAa,gBAAgB;KAC9B,CAAC;YACK,GAAG;IAEV,MAAM,QAAQ,YAAY,EAAE;AAO5B,KALE,0BACE,KAAK,QAAQ,SAAS,iBACtB,MACA,MAAM,QACP,IAAI,KAAK,QAAQ,SAAS,MACtB,MAAM,wBAAwB,MAAM,SAAS,MAAM,SAAS;AACnE,WAAO;KACL,SAAS;MACP,gBAAgB;MAChB,oBAAoB;MACrB;KACD,YAAY;KACZ,iBAAiB;KACjB,MAAM,KAAK,UAAU,EAAE,SAAS,MAAM,SAAS,CAAC;KACjD;;GAGH,MAAM,qBAAqB,OAAO,OAAO,OAAO;GAChD,IAAI;AAGJ,OACE,KAAK,wBACL,mBAAmB,SAAS,kCAC5B,yBACA,sBAAsB,SAAS,OAAO,EACtC;AACA,aAAS,QAAQ,sBAAsB;AAEvC,mBACE,KAEC,iBAAiB,mBAAmB,CACpC,SAAS,SAAS;SAErB,gBAAe,mBAAmB,SAAS,SAAS;AAEtD,UAAO;IACL,SAAS,SAAS;IAClB,YAAY,SAAS;IACrB,iBAAiB;IACjB,MAAM;IACP;YACO;AACR,mBAAgB,OAAO;;;;AAK7B,SAAgB,yBAAyB;AACvC,QAAO,wBAAwB,QAAQ,sBAAsB"}

package/dist/endpoint/handlers/utils.cjs

@@ -0,0 +1,51 @@
+const require_logger_transport = require('../../logging/logger_transport.cjs');
+const require_components = require('../components.cjs');
+const require_logger = require('../../logging/logger.cjs');
+const require_user_agent = require('../../user_agent.cjs');
+
+//#region src/endpoint/handlers/utils.ts
+function tryCreateContextualLogger(loggerTransport, url, headers, additionalContext) {
+	try {
+		const path = new URL(url, "https://example.com").pathname;
+		const parsed = require_components.parseUrlComponents(path);
+		if (parsed.type !== "invoke") return;
+		const invocationId = invocationIdFromHeaders(headers);
+		return require_logger.createLogger(loggerTransport, require_logger_transport.LogSource.SYSTEM, new require_logger_transport.LoggerContext(invocationId, parsed.componentName, parsed.handlerName, void 0, void 0, additionalContext));
+	} catch {
+		return;
+	}
+}
+function invocationIdFromHeaders(headers) {
+	const invocationIdHeader = headers["x-restate-invocation-id"];
+	return typeof invocationIdHeader === "string" ? invocationIdHeader : Array.isArray(invocationIdHeader) ? invocationIdHeader[0] ?? "unknown id" : "unknown id";
+}
+function errorResponse(code, message) {
+	return simpleResponse(code, {
+		"content-type": "application/json",
+		"x-restate-server": require_user_agent.X_RESTATE_SERVER
+	}, new TextEncoder().encode(JSON.stringify({ message })));
+}
+function simpleResponse(statusCode, headers, body) {
+	return {
+		headers,
+		statusCode,
+		async process({ inputReader, outputWriter }) {
+			if (inputReader !== void 0) while (true) {
+				const { done } = await inputReader.next();
+				if (done) break;
+			}
+			await outputWriter.write(body);
+			await outputWriter.close();
+		}
+	};
+}
+function emptyInputReader() {
+	return (async function* () {})()[Symbol.asyncIterator]();
+}
+
+//#endregion
+exports.emptyInputReader = emptyInputReader;
+exports.errorResponse = errorResponse;
+exports.invocationIdFromHeaders = invocationIdFromHeaders;
+exports.simpleResponse = simpleResponse;
+exports.tryCreateContextualLogger = tryCreateContextualLogger;

package/dist/endpoint/handlers/utils.js

@@ -0,0 +1,48 @@
+import { LogSource, LoggerContext } from "../../logging/logger_transport.js";
+import { parseUrlComponents } from "../components.js";
+import { createLogger } from "../../logging/logger.js";
+import { X_RESTATE_SERVER } from "../../user_agent.js";
+
+//#region src/endpoint/handlers/utils.ts
+function tryCreateContextualLogger(loggerTransport, url, headers, additionalContext) {
+	try {
+		const path = new URL(url, "https://example.com").pathname;
+		const parsed = parseUrlComponents(path);
+		if (parsed.type !== "invoke") return;
+		const invocationId = invocationIdFromHeaders(headers);
+		return createLogger(loggerTransport, LogSource.SYSTEM, new LoggerContext(invocationId, parsed.componentName, parsed.handlerName, void 0, void 0, additionalContext));
+	} catch {
+		return;
+	}
+}
+function invocationIdFromHeaders(headers) {
+	const invocationIdHeader = headers["x-restate-invocation-id"];
+	return typeof invocationIdHeader === "string" ? invocationIdHeader : Array.isArray(invocationIdHeader) ? invocationIdHeader[0] ?? "unknown id" : "unknown id";
+}
+function errorResponse(code, message) {
+	return simpleResponse(code, {
+		"content-type": "application/json",
+		"x-restate-server": X_RESTATE_SERVER
+	}, new TextEncoder().encode(JSON.stringify({ message })));
+}
+function simpleResponse(statusCode, headers, body) {
+	return {
+		headers,
+		statusCode,
+		async process({ inputReader, outputWriter }) {
+			if (inputReader !== void 0) while (true) {
+				const { done } = await inputReader.next();
+				if (done) break;
+			}
+			await outputWriter.write(body);
+			await outputWriter.close();
+		}
+	};
+}
+function emptyInputReader() {
+	return (async function* () {})()[Symbol.asyncIterator]();
+}
+
+//#endregion
+export { emptyInputReader, errorResponse, invocationIdFromHeaders, simpleResponse, tryCreateContextualLogger };
+//# sourceMappingURL=utils.js.map

package/dist/endpoint/handlers/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":[],"sources":["../../../src/endpoint/handlers/utils.ts"],"sourcesContent":["import {\n  LoggerContext,\n  LogSource,\n  LoggerTransport,\n} from \"../../logging/logger_transport.js\";\nimport type {\n  Headers,\n  InputReader,\n  ResponseHeaders,\n  RestateResponse,\n} from \"./types.js\";\nimport { createLogger, Logger } from \"../../logging/logger.js\";\nimport { parseUrlComponents } from \"../components.js\";\nimport { X_RESTATE_SERVER } from \"../../user_agent.js\";\n\nexport function tryCreateContextualLogger(\n  loggerTransport: LoggerTransport,\n  url: string,\n  headers: Headers,\n  additionalContext?: { [name: string]: string }\n): Logger | undefined {\n  try {\n    const path = new URL(url, \"https://example.com\").pathname;\n    const parsed = parseUrlComponents(path);\n    if (parsed.type !== \"invoke\") {\n      return undefined;\n    }\n    const invocationId = invocationIdFromHeaders(headers);\n    return createLogger(\n      loggerTransport,\n      LogSource.SYSTEM,\n      new LoggerContext(\n        invocationId,\n        parsed.componentName,\n        parsed.handlerName,\n        undefined,\n        undefined,\n        additionalContext\n      )\n    );\n  } catch {\n    return undefined;\n  }\n}\n\nexport function invocationIdFromHeaders(headers: Headers) {\n  const invocationIdHeader = headers[\"x-restate-invocation-id\"];\n  const invocationId =\n    typeof invocationIdHeader === \"string\"\n      ? invocationIdHeader\n      : Array.isArray(invocationIdHeader)\n        ? (invocationIdHeader[0] ?? \"unknown id\")\n        : \"unknown id\";\n  return invocationId;\n}\n\nexport function errorResponse(code: number, message: string): RestateResponse {\n  return simpleResponse(\n    code,\n    {\n      \"content-type\": \"application/json\",\n      \"x-restate-server\": X_RESTATE_SERVER,\n    },\n    new TextEncoder().encode(JSON.stringify({ message }))\n  );\n}\n\nexport function simpleResponse(\n  statusCode: number,\n  headers: ResponseHeaders,\n  body: Uint8Array\n): RestateResponse {\n  return {\n    headers,\n    statusCode,\n    async process({ inputReader, outputWriter }): Promise<void> {\n      if (inputReader !== undefined) {\n        // Drain the input stream\n        while (true) {\n          const { done } = await inputReader.next();\n          if (done) break;\n        }\n      }\n\n      await outputWriter.write(body);\n      // This closes both the writer and the stream!!!\n      await outputWriter.close();\n    },\n  };\n}\n\nexport function emptyInputReader(): InputReader {\n  return (async function* () {})()[Symbol.asyncIterator]();\n}\n"],"mappings":";;;;;;AAeA,SAAgB,0BACd,iBACA,KACA,SACA,mBACoB;AACpB,KAAI;EACF,MAAM,OAAO,IAAI,IAAI,KAAK,sBAAsB,CAAC;EACjD,MAAM,SAAS,mBAAmB,KAAK;AACvC,MAAI,OAAO,SAAS,SAClB;EAEF,MAAM,eAAe,wBAAwB,QAAQ;AACrD,SAAO,aACL,iBACA,UAAU,QACV,IAAI,cACF,cACA,OAAO,eACP,OAAO,aACP,QACA,QACA,kBACD,CACF;SACK;AACN;;;AAIJ,SAAgB,wBAAwB,SAAkB;CACxD,MAAM,qBAAqB,QAAQ;AAOnC,QALE,OAAO,uBAAuB,WAC1B,qBACA,MAAM,QAAQ,mBAAmB,GAC9B,mBAAmB,MAAM,eAC1B;;AAIV,SAAgB,cAAc,MAAc,SAAkC;AAC5E,QAAO,eACL,MACA;EACE,gBAAgB;EAChB,oBAAoB;EACrB,EACD,IAAI,aAAa,CAAC,OAAO,KAAK,UAAU,EAAE,SAAS,CAAC,CAAC,CACtD;;AAGH,SAAgB,eACd,YACA,SACA,MACiB;AACjB,QAAO;EACL;EACA;EACA,MAAM,QAAQ,EAAE,aAAa,gBAA+B;AAC1D,OAAI,gBAAgB,OAElB,QAAO,MAAM;IACX,MAAM,EAAE,SAAS,MAAM,YAAY,MAAM;AACzC,QAAI,KAAM;;AAId,SAAM,aAAa,MAAM,KAAK;AAE9B,SAAM,aAAa,OAAO;;EAE7B;;AAGH,SAAgB,mBAAgC;AAC9C,SAAQ,mBAAmB,KAAK,CAAC,OAAO,gBAAgB"}

package/dist/endpoint/handlers/vm/sdk_shared_core_wasm_bindings.d.ts

@@ -1,14 +1,14 @@
 /* tslint:disable */
 /* eslint-disable */
-/**
- * Setups the WASM module
- */
-export function start(): void;
+export function cancel_handle(): number;
 /**
  * This will set the log level of the overall log subscriber.
  */
 export function set_log_level(level: LogLevel): void;
-export function cancel_handle(): number;
+/**
+ * Setups the WASM module
+ */
+export function start(): void;
 export enum LogLevel {
   TRACE = 0,
   DEBUG = 1,
@@ -37,9 +37,12 @@ export enum WasmCommandType {
   CompleteAwakeable = 17,
   CancelInvocation = 18,
 }
-export interface WasmFailureMetadata {
-    key: string;
-    value: string;
+export interface WasmExponentialRetryConfig {
+    initial_interval: number | undefined;
+    factor: number;
+    max_interval: number | undefined;
+    max_attempts: number | undefined;
+    max_duration: number | undefined;
 }
 
 export interface WasmFailure {
@@ -48,26 +51,23 @@ export interface WasmFailure {
     metadata: WasmFailureMetadata[];
 }
 
-export interface WasmExponentialRetryConfig {
-    initial_interval: number | undefined;
-    factor: number;
-    max_interval: number | undefined;
-    max_attempts: number | undefined;
-    max_duration: number | undefined;
+export interface WasmCallHandle {
+    invocation_id_completion_id: number;
+    call_completion_id: number;
 }
 
+export type WasmAsyncResultValue = "NotReady" | "Empty" | { Success: Uint8Array } | { Failure: WasmFailure } | { StateKeys: string[] } | { InvocationId: string };
+
 export interface WasmAwakeable {
     id: string;
     handle: number;
 }
 
-export type WasmAsyncResultValue = "NotReady" | "Empty" | { Success: Uint8Array } | { Failure: WasmFailure } | { StateKeys: string[] } | { InvocationId: string };
-
 export type WasmDoProgressResult = "AnyCompleted" | "ReadFromInput" | "WaitingPendingRun" | { ExecuteRun: number } | "CancelSignalReceived";
 
-export interface WasmCallHandle {
-    invocation_id_completion_id: number;
-    call_completion_id: number;
+export interface WasmFailureMetadata {
+    key: string;
+    value: string;
 }
 
 export interface WasmSendHandle {
@@ -82,8 +82,8 @@ export class WasmHeader {
 }
 export class WasmIdentityVerifier {
   free(): void;
-  constructor(keys: string[]);
   verify_identity(path: string, headers: WasmHeader[]): void;
+  constructor(keys: string[]);
 }
 export class WasmInput {
   private constructor();
@@ -102,46 +102,46 @@ export class WasmResponseHead {
 }
 export class WasmVM {
   free(): void;
-  constructor(headers: WasmHeader[], log_level: LogLevel, logger_id: number, disable_payload_checks: boolean);
-  get_response_head(): WasmResponseHead;
-  notify_input(buffer: Uint8Array): void;
-  notify_input_closed(): void;
-  notify_error(error_message: string, stacktrace?: string | null): void;
-  notify_error_with_delay_override(error_message: string, stacktrace?: string | null, delay_override?: bigint | null): void;
-  notify_error_for_next_command(error_message: string, stacktrace: string | null | undefined, wasm_command_type: WasmCommandType): void;
-  notify_error_for_specific_command(error_message: string, stacktrace: string | null | undefined, wasm_command_type: WasmCommandType, command_index: number, command_name?: string | null): void;
+  do_progress(handles: Uint32Array): WasmDoProgressResult;
   take_output(): any;
-  is_ready_to_execute(): boolean;
   is_completed(handle: number): boolean;
-  do_progress(handles: Uint32Array): WasmDoProgressResult;
-  take_notification(handle: number): WasmAsyncResultValue;
-  sys_input(): WasmInput;
+  notify_error(error_message: string, stacktrace?: string | null): void;
+  notify_input(buffer: Uint8Array): void;
+  is_processing(): boolean;
+  sys_awakeable(): WasmAwakeable;
   sys_get_state(key: string): number;
-  sys_get_state_keys(): number;
   sys_set_state(key: string, buffer: Uint8Array): void;
   sys_clear_state(key: string): void;
+  sys_get_promise(key: string): number;
+  sys_peek_promise(key: string): number;
+  get_response_head(): WasmResponseHead;
+  take_notification(handle: number): WasmAsyncResultValue;
+  last_command_index(): number;
+  sys_get_state_keys(): number;
+  is_ready_to_execute(): boolean;
+  notify_input_closed(): void;
   sys_clear_all_state(): void;
-  sys_sleep(millis: bigint, name?: string | null): number;
   sys_attach_invocation(invocation_id: string): number;
+  sys_cancel_invocation(target_invocation_id: string): void;
+  sys_write_output_failure(value: WasmFailure): void;
+  sys_write_output_success(buffer: Uint8Array): void;
   sys_get_invocation_output(invocation_id: string): number;
-  sys_call(service: string, handler: string, buffer: Uint8Array, key: string | null | undefined, headers: WasmHeader[], idempotency_key?: string | null, name?: string | null): WasmCallHandle;
-  sys_send(service: string, handler: string, buffer: Uint8Array, key: string | null | undefined, headers: WasmHeader[], delay?: bigint | null, idempotency_key?: string | null, name?: string | null): WasmSendHandle;
-  sys_awakeable(): WasmAwakeable;
-  sys_complete_awakeable_success(id: string, buffer: Uint8Array): void;
-  sys_complete_awakeable_failure(id: string, value: WasmFailure): void;
-  sys_get_promise(key: string): number;
-  sys_peek_promise(key: string): number;
-  sys_complete_promise_success(key: string, buffer: Uint8Array): number;
   sys_complete_promise_failure(key: string, value: WasmFailure): number;
-  sys_run(name: string): number;
-  propose_run_completion_success(handle: number, buffer: Uint8Array): void;
+  sys_complete_promise_success(key: string, buffer: Uint8Array): number;
+  notify_error_for_next_command(error_message: string, stacktrace: string | null | undefined, wasm_command_type: WasmCommandType): void;
   propose_run_completion_failure(handle: number, value: WasmFailure): void;
+  propose_run_completion_success(handle: number, buffer: Uint8Array): void;
+  sys_complete_awakeable_failure(id: string, value: WasmFailure): void;
+  sys_complete_awakeable_success(id: string, buffer: Uint8Array): void;
+  notify_error_with_delay_override(error_message: string, stacktrace?: string | null, delay_override?: bigint | null): void;
+  notify_error_for_specific_command(error_message: string, stacktrace: string | null | undefined, wasm_command_type: WasmCommandType, command_index: number, command_name?: string | null): void;
+  constructor(headers: WasmHeader[], log_level: LogLevel, logger_id: number, disable_payload_checks: boolean);
   propose_run_completion_failure_transient(handle: number, error_message: string, error_stacktrace: string | null | undefined, attempt_duration: bigint, config?: WasmExponentialRetryConfig | null): void;
   propose_run_completion_failure_transient_with_delay_override(handle: number, error_message: string, error_stacktrace: string | null | undefined, attempt_duration: bigint, delay_override?: bigint | null, max_retry_attempts_override?: number | null, max_retry_duration_override?: bigint | null): void;
-  sys_cancel_invocation(target_invocation_id: string): void;
-  sys_write_output_success(buffer: Uint8Array): void;
-  sys_write_output_failure(value: WasmFailure): void;
   sys_end(): void;
-  is_processing(): boolean;
-  last_command_index(): number;
+  sys_run(name: string): number;
+  sys_call(service: string, handler: string, buffer: Uint8Array, key: string | null | undefined, headers: WasmHeader[], idempotency_key?: string | null, name?: string | null): WasmCallHandle;
+  sys_send(service: string, handler: string, buffer: Uint8Array, key: string | null | undefined, headers: WasmHeader[], delay?: bigint | null, idempotency_key?: string | null, name?: string | null): WasmSendHandle;
+  sys_input(): WasmInput;
+  sys_sleep(millis: bigint, name?: string | null): number;
 }