@restatedev/restate-sdk-cloudflare-workers 1.10.4 → 1.11.1

package/dist/endpoint/handlers/generic.cjs

@@ -1,49 +1,28 @@
 const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
-const require_errors = require('../../types/errors.cjs');
-const require_rpc = require('../../types/rpc.cjs');
-const require_components = require('../components.cjs');
-const require_user_agent = require('../../user_agent.cjs');
-const require_streams = require('../../utils/streams.cjs');
-const require_completable_promise = require('../../utils/completable_promise.cjs');
 const require_logger_transport = require('../../logging/logger_transport.cjs');
-const require_logger = require('../../logging/logger.cjs');
 const require_console_logger_transport = require('../../logging/console_logger_transport.cjs');
+const require_core_logging = require('./core_logging.cjs');
 const require_sdk_shared_core_wasm_bindings = require('./vm/sdk_shared_core_wasm_bindings.cjs');
+const require_errors = require('../../types/errors.cjs');
+const require_rpc = require('../../types/rpc.cjs');
+const require_completable_promise = require('../../utils/completable_promise.cjs');
 const require_context_impl = require('../../context_impl.cjs');
+const require_components = require('../components.cjs');
+const require_logger = require('../../logging/logger.cjs');
+const require_user_agent = require('../../user_agent.cjs');
+const require_utils = require('./utils.cjs');
+const require_discovery = require('./discovery.cjs');
 let __restatedev_restate_sdk_core = require("@restatedev/restate-sdk-core");
 __restatedev_restate_sdk_core = require_rolldown_runtime.__toESM(__restatedev_restate_sdk_core);
-let node_stream_web = require("node:stream/web");
-node_stream_web = require_rolldown_runtime.__toESM(node_stream_web);
 
 //#region src/endpoint/handlers/generic.ts
-const ENDPOINT_MANIFEST_V2 = "application/vnd.restate.endpointmanifest.v2+json";
-const ENDPOINT_MANIFEST_V3 = "application/vnd.restate.endpointmanifest.v3+json";
-const ENDPOINT_MANIFEST_V4 = "application/vnd.restate.endpointmanifest.v4+json";
-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 createRestateHandler(endpoint, protocolMode, additionalDiscoveryFields) {
+	return new RestateHandlerImpl(endpoint, protocolMode, additionalDiscoveryFields);
 }
 /**
-* This is an internal API to support 'fetch' like handlers.
-* It supports both request-reply mode and bidirectional streaming mode.
-*
-* An individual handler will have to convert the shape of the incoming request
-* to a RestateRequest, and then pass it to this handler, and eventually convert back
-* the response.
-* Different runtimes have slightly different shapes of the incoming request, and responses.
+* This is the RestateHandler implementation
 */
-var GenericHandler = class {
+var RestateHandlerImpl = class {
 	identityVerifier;
 	constructor(endpoint, protocolMode, additionalDiscoveryFields) {
 		this.endpoint = endpoint;
@@ -56,57 +35,31 @@ var GenericHandler = class {
 		}
 		require_sdk_shared_core_wasm_bindings.set_log_level(restateLogLevelToWasmLogLevel(require_console_logger_transport.DEFAULT_CONSOLE_LOGGER_LOG_LEVEL));
 	}
-	async handle(request, context) {
+	handle(request, context) {
 		try {
-			return await this._handle(request, context);
+			return this._handle(request, context);
 		} catch (e) {
 			const error = require_errors.ensureError(e);
-			(tryCreateContextualLogger(this.endpoint.loggerTransport, request.url, request.headers) ?? this.endpoint.rlog).error("Error while handling request: " + (error.stack ?? error.message));
-			return this.toErrorResponse(error instanceof require_errors.RestateError ? error.code : 500, error.message);
+			(require_utils.tryCreateContextualLogger(this.endpoint.loggerTransport, request.url, request.headers) ?? this.endpoint.rlog).error("Error while handling request: " + (error.stack ?? error.message));
+			return require_utils.errorResponse(error instanceof require_errors.RestateError ? error.code : 500, error.message);
 		}
 	}
-	async _handle(request, context) {
+	_handle(request, context) {
 		const path = new URL(request.url, "https://example.com").pathname;
 		const parsed = require_components.parseUrlComponents(path);
 		if (parsed.type === "unknown") {
 			const msg = `Invalid path. Allowed are /health, or /discover, or /invoke/SvcName/handlerName, but was: ${path}`;
 			this.endpoint.rlog.trace(msg);
-			return this.toErrorResponse(404, msg);
+			return require_utils.errorResponse(404, msg);
 		}
-		if (parsed.type === "health") return {
-			body: require_streams.OnceStream(new TextEncoder().encode("OK")),
-			headers: {
-				"content-type": "application/text",
-				"x-restate-server": require_user_agent.X_RESTATE_SERVER
-			},
-			statusCode: 200
-		};
+		if (parsed.type === "health") return require_utils.simpleResponse(200, {
+			"content-type": "application/text",
+			"x-restate-server": require_user_agent.X_RESTATE_SERVER
+		}, new TextEncoder().encode("OK"));
 		const error = this.validateConnectionSignature(path, request.headers);
 		if (error !== null) return error;
-		if (parsed.type === "discover") return this.handleDiscovery(request.headers["accept"]);
-		if (typeof request.headers["content-type"] !== "string") {
-			const errorMessage = "Missing content-type header";
-			this.endpoint.rlog.warn(errorMessage);
-			return this.toErrorResponse(415, errorMessage);
-		}
-		const service = this.endpoint.components.get(parsed.componentName);
-		if (!service) {
-			const msg = `No service found for URL: ${JSON.stringify(parsed)}`;
-			this.endpoint.rlog.error(msg);
-			return this.toErrorResponse(404, msg);
-		}
-		const handler = service?.handlerMatching(parsed);
-		if (!handler) {
-			const msg = `No service found for URL: ${JSON.stringify(parsed)}`;
-			this.endpoint.rlog.error(msg);
-			return this.toErrorResponse(404, msg);
-		}
-		if (!request.body) {
-			const msg = "The incoming message body was null";
-			this.endpoint.rlog.error(msg);
-			return this.toErrorResponse(400, msg);
-		}
-		return this.handleInvoke(service, handler, request.body, request.headers, request.extraArgs, request.abortSignal, context ?? {});
+		if (parsed.type === "discover") return require_discovery.handleDiscovery(this.endpoint, this.protocolMode, this.additionalDiscoveryFields, request.headers["accept"]);
+		return this.handleInvoke(parsed, request.headers, request.extraArgs, context ?? {});
 	}
 	validateConnectionSignature(path, headers) {
 		if (!this.identityVerifier) return null;
@@ -116,207 +69,170 @@ var GenericHandler = class {
 			return null;
 		} catch (e) {
 			this.endpoint.rlog.error(`Rejecting request as its JWT did not validate: ${e}`);
-			return this.toErrorResponse(401, "Unauthorized");
+			return require_utils.errorResponse(401, "Unauthorized");
 		}
 	}
-	async handleInvoke(service, handler, body, headers, extraArgs, abortSignal, additionalContext) {
-		const journalValueCodec = this.endpoint.journalValueCodec ? await this.endpoint.journalValueCodec : {
+	handleInvoke(invokePathComponent, headers, extraArgs, additionalContext) {
+		if (typeof headers["content-type"] !== "string") {
+			const errorMessage = "Missing content-type header";
+			this.endpoint.rlog.warn(errorMessage);
+			return require_utils.errorResponse(415, errorMessage);
+		}
+		const service = this.endpoint.components.get(invokePathComponent.componentName);
+		if (!service) {
+			const msg = `No service found for URL: ${JSON.stringify(invokePathComponent)}`;
+			this.endpoint.rlog.error(msg);
+			return require_utils.errorResponse(404, msg);
+		}
+		const handler = service?.handlerMatching(invokePathComponent);
+		if (!handler) {
+			const msg = `No service found for URL: ${JSON.stringify(invokePathComponent)}`;
+			this.endpoint.rlog.error(msg);
+			return require_utils.errorResponse(404, msg);
+		}
+		return new RestateInvokeResponse(service, handler, headers, extraArgs, additionalContext, this.endpoint.journalValueCodec, this.endpoint.loggerTransport);
+	}
+};
+var RestateInvokeResponse = class {
+	headers;
+	statusCode;
+	loggerId;
+	vmLogger;
+	coreVm;
+	constructor(service, handler, attemptHeaders, extraArgs, additionalContext, journalValueCodecInit, loggerTransport) {
+		this.service = service;
+		this.handler = handler;
+		this.attemptHeaders = attemptHeaders;
+		this.extraArgs = extraArgs;
+		this.additionalContext = additionalContext;
+		this.journalValueCodecInit = journalValueCodecInit;
+		this.loggerTransport = loggerTransport;
+		this.loggerId = Math.floor(Math.random() * 4294967295);
+		const isJournalCodecDefined = this.journalValueCodecInit !== void 0;
+		const vmHeaders = Object.entries(this.attemptHeaders).filter(([, v]) => v !== void 0).map(([k, v]) => new require_sdk_shared_core_wasm_bindings.WasmHeader(k, v instanceof Array ? v[0] : v));
+		this.coreVm = new require_sdk_shared_core_wasm_bindings.WasmVM(vmHeaders, restateLogLevelToWasmLogLevel(require_console_logger_transport.DEFAULT_CONSOLE_LOGGER_LOG_LEVEL), this.loggerId, isJournalCodecDefined);
+		const responseHead = this.coreVm.get_response_head();
+		this.statusCode = responseHead.status_code;
+		this.headers = responseHead.headers.reduce((headers, { key, value }) => ({
+			[key]: value,
+			...headers
+		}), { "x-restate-server": require_user_agent.X_RESTATE_SERVER });
+		this.vmLogger = require_logger.createLogger(this.loggerTransport, require_logger_transport.LogSource.JOURNAL, new require_logger_transport.LoggerContext(require_utils.invocationIdFromHeaders(this.attemptHeaders), this.service.name(), this.handler.name(), void 0, void 0, this.additionalContext));
+	}
+	async process({ inputReader, outputWriter, abortSignal }) {
+		abortSignal.addEventListener("abort", () => {
+			require_core_logging.destroyLogger(this.loggerId);
+		}, { once: true });
+		require_core_logging.registerLogger(this.loggerId, this.vmLogger);
+		const journalValueCodec = this.journalValueCodecInit ? await this.journalValueCodecInit : {
 			encode: (entry) => entry,
 			decode: (entry) => Promise.resolve(entry)
 		};
-		const loggerId = Math.floor(Math.random() * 4294967295);
+		const invocationEndPromise = new require_completable_promise.CompletablePromise();
+		let ctx;
 		try {
-			const vmHeaders = Object.entries(headers).filter(([, v]) => v !== void 0).map(([k, v]) => new require_sdk_shared_core_wasm_bindings.WasmHeader(k, v instanceof Array ? v[0] : v));
-			const coreVm = new require_sdk_shared_core_wasm_bindings.WasmVM(vmHeaders, restateLogLevelToWasmLogLevel(require_console_logger_transport.DEFAULT_CONSOLE_LOGGER_LOG_LEVEL), loggerId, this.endpoint.journalValueCodec !== void 0);
-			const responseHead = coreVm.get_response_head();
-			const responseHeaders = responseHead.headers.reduce((headers$1, { key, value }) => ({
-				[key]: value,
-				...headers$1
-			}), { "x-restate-server": require_user_agent.X_RESTATE_SERVER });
-			invocationLoggers.set(loggerId, require_logger.createLogger(this.endpoint.loggerTransport, require_logger_transport.LogSource.JOURNAL, new require_logger_transport.LoggerContext(invocationIdFromHeaders(headers), service.name(), handler.name(), void 0, void 0, additionalContext)));
-			const inputReader = body.getReader();
-			abortSignal.addEventListener("abort", () => {
-				invocationLoggers.delete(loggerId);
-				inputReader.cancel();
-			}, { once: true });
-			while (!coreVm.is_ready_to_execute()) {
-				const nextValue = await inputReader.read();
-				if (nextValue.value !== void 0) coreVm.notify_input(nextValue.value);
-				if (nextValue.done) {
-					coreVm.notify_input_closed();
-					break;
-				}
-			}
-			const input = coreVm.sys_input();
+			await bufferJournalReplayInCoreVm(this.coreVm, inputReader);
+			const input = this.coreVm.sys_input();
 			const invocationRequest = {
 				id: input.invocation_id,
-				headers: input.headers.reduce((headers$1, { key, value }) => {
-					headers$1.set(key, value);
-					return headers$1;
+				headers: input.headers.reduce((headers, { key, value }) => {
+					headers.set(key, value);
+					return headers;
 				}, /* @__PURE__ */ new Map()),
-				attemptHeaders: Object.entries(headers).reduce((headers$1, [key, value]) => {
-					if (value !== void 0) headers$1.set(key, value instanceof Array ? value[0] : value);
-					return headers$1;
+				attemptHeaders: Object.entries(this.attemptHeaders).reduce((headers, [key, value]) => {
+					if (value !== void 0) headers.set(key, value instanceof Array ? value[0] : value);
+					return headers;
 				}, /* @__PURE__ */ new Map()),
 				body: input.input,
-				extraArgs,
+				extraArgs: this.extraArgs,
 				attemptCompletedSignal: abortSignal
 			};
-			const loggerContext = new require_logger_transport.LoggerContext(input.invocation_id, handler.component().name(), handler.name(), handler.kind() === require_rpc.HandlerKind.SERVICE ? void 0 : input.key, invocationRequest, additionalContext);
-			const ctxLogger = require_logger.createLogger(this.endpoint.loggerTransport, require_logger_transport.LogSource.USER, loggerContext, () => !coreVm.is_processing());
-			const vmLogger = require_logger.createLogger(this.endpoint.loggerTransport, require_logger_transport.LogSource.JOURNAL, loggerContext);
-			invocationLoggers.set(loggerId, vmLogger);
-			if (!coreVm.is_processing()) vmLogger.info("Replaying invocation.");
-			else vmLogger.info("Starting invocation.");
-			const invocationEndPromise = new require_completable_promise.CompletablePromise();
-			const responseTransformStream = new node_stream_web.TransformStream();
-			const outputWriter = responseTransformStream.writable.getWriter();
-			const ctx = new require_context_impl.ContextImpl(coreVm, input, ctxLogger, handler.kind(), vmLogger, invocationRequest, invocationEndPromise, inputReader, outputWriter, journalValueCodec, service.options?.serde, service.options?.asTerminalError);
-			journalValueCodec.decode(input.input).catch((e) => Promise.reject(new require_errors.TerminalError(`Failed to decode input using journal value codec: ${require_errors.ensureError(e).message}`, { errorCode: 400 }))).then((decodedInput) => handler.invoke(ctx, decodedInput)).then((output) => {
-				coreVm.sys_write_output_success(journalValueCodec.encode(output));
-				coreVm.sys_end();
-				vmLogger.info("Invocation completed successfully.");
-			}).catch((e) => {
-				const error = require_errors.ensureError(e, service.options?.asTerminalError);
-				require_errors.logError(vmLogger, error);
-				if (error instanceof require_errors.TerminalError) {
-					coreVm.sys_write_output_failure({
-						code: error.code,
-						message: error.message,
-						metadata: []
-					});
-					coreVm.sys_end();
-					return;
-				}
-				throw error;
-			}).catch((e) => {
-				const error = require_errors.ensureError(e);
-				if (error instanceof require_errors.RetryableError) coreVm.notify_error_with_delay_override(error.message, error.stack, error.retryAfter !== void 0 ? BigInt((0, __restatedev_restate_sdk_core.millisOrDurationToMillis)(error.retryAfter)) : void 0);
-				else coreVm.notify_error(error.message, error.stack);
-			}).finally(() => {
-				invocationEndPromise.resolve();
-			});
-			invocationEndPromise.promise.then(async () => {
-				let nextOutput = coreVm.take_output();
-				while (nextOutput !== null && nextOutput !== void 0) {
-					await outputWriter.write(nextOutput);
-					nextOutput = coreVm.take_output();
-				}
-				let inputClosed = false;
-				while (!inputClosed) try {
-					inputClosed = (await inputReader.read()).done;
-				} catch (e) {
-					inputClosed = true;
-				}
-				await outputWriter.close();
-			}).finally(() => {
-				invocationLoggers.delete(loggerId);
-			}).catch(() => {});
-			return {
-				headers: responseHeaders,
-				statusCode: responseHead.status_code,
-				body: responseTransformStream.readable
-			};
-		} catch (error) {
-			invocationLoggers.delete(loggerId);
-			throw error;
+			const loggerContext = new require_logger_transport.LoggerContext(input.invocation_id, this.handler.component().name(), this.handler.name(), this.handler.kind() === require_rpc.HandlerKind.SERVICE ? void 0 : input.key, invocationRequest, this.additionalContext);
+			const ctxLogger = require_logger.createLogger(this.loggerTransport, require_logger_transport.LogSource.USER, loggerContext, () => !this.coreVm.is_processing());
+			this.vmLogger = require_logger.createLogger(this.loggerTransport, require_logger_transport.LogSource.JOURNAL, loggerContext);
+			require_core_logging.registerLogger(this.loggerId, this.vmLogger);
+			if (!this.coreVm.is_processing()) this.vmLogger.info("Replaying invocation.");
+			else this.vmLogger.info("Starting invocation.");
+			ctx = new require_context_impl.ContextImpl(this.coreVm, input, ctxLogger, this.handler.kind(), this.vmLogger, invocationRequest, invocationEndPromise, inputReader, outputWriter, journalValueCodec, this.service.options?.serde, this.service.options?.asTerminalError);
+		} catch (e) {
+			const error = require_errors.ensureError(e);
+			this.coreVm.notify_error(error.message, error.message);
+			await flushAndClose(this.coreVm, this.vmLogger, inputReader, outputWriter);
+			return;
 		}
+		startUserHandler(ctx, this.service, this.handler, journalValueCodec).finally(() => {
+			invocationEndPromise.resolve();
+		});
+		await invocationEndPromise.promise;
+		await flushAndClose(this.coreVm, this.vmLogger, inputReader, outputWriter);
 	}
-	handleDiscovery(acceptVersionsString) {
-		if (typeof acceptVersionsString !== "string") {
-			const errorMessage = "Missing accept header";
-			this.endpoint.rlog.warn(errorMessage);
-			return this.toErrorResponse(415, errorMessage);
-		}
-		let manifestVersion;
-		if (acceptVersionsString.includes(ENDPOINT_MANIFEST_V4)) manifestVersion = 4;
-		else if (acceptVersionsString.includes(ENDPOINT_MANIFEST_V3)) manifestVersion = 3;
-		else if (acceptVersionsString.includes(ENDPOINT_MANIFEST_V2)) manifestVersion = 2;
-		else {
-			const errorMessage = `Unsupported service discovery protocol version '${acceptVersionsString}'`;
-			this.endpoint.rlog.warn(errorMessage);
-			return this.toErrorResponse(415, errorMessage);
-		}
-		const discovery = {
-			...this.endpoint.discoveryMetadata,
-			...this.additionalDiscoveryFields,
-			protocolMode: this.protocolMode
-		};
-		const checkUnsupportedFeature = (obj, ...fields) => {
-			for (const field of fields) if (field in obj && obj[field] !== void 0) return this.toErrorResponse(500, `The code uses the new discovery feature '${String(field)}' but the runtime doesn't support it yet (discovery protocol negotiated version ${manifestVersion}). Either remove the usage of this feature, or upgrade the runtime.`);
-		};
-		if (manifestVersion < 3) for (const service of discovery.services) {
-			const error = checkUnsupportedFeature(service, "journalRetention", "idempotencyRetention", "inactivityTimeout", "abortTimeout", "enableLazyState", "ingressPrivate");
-			if (error !== void 0) return error;
-			for (const handler of service.handlers) {
-				const error$1 = checkUnsupportedFeature(handler, "journalRetention", "idempotencyRetention", "workflowCompletionRetention", "inactivityTimeout", "abortTimeout", "enableLazyState", "ingressPrivate");
-				if (error$1 !== void 0) return error$1;
-			}
+};
+async function bufferJournalReplayInCoreVm(coreVm, inputReader) {
+	while (!coreVm.is_ready_to_execute()) {
+		const nextValue = await inputReader.next();
+		if (nextValue.done) {
+			coreVm.notify_input_closed();
+			break;
 		}
-		if (manifestVersion < 4) {
-			discovery.lambdaCompression = void 0;
-			for (const service of discovery.services) {
-				const error = checkUnsupportedFeature(service, "retryPolicyExponentiationFactor", "retryPolicyInitialInterval", "retryPolicyMaxAttempts", "retryPolicyMaxInterval", "retryPolicyOnMaxAttempts");
-				if (error !== void 0) return error;
-				for (const handler of service.handlers) {
-					const error$1 = checkUnsupportedFeature(handler, "retryPolicyExponentiationFactor", "retryPolicyInitialInterval", "retryPolicyMaxAttempts", "retryPolicyMaxInterval", "retryPolicyOnMaxAttempts");
-					if (error$1 !== void 0) return error$1;
-				}
+		if (nextValue.value !== void 0) coreVm.notify_input(nextValue.value);
+	}
+}
+async function startUserHandler(ctx, service, handler, journalValueCodec) {
+	try {
+		try {
+			const decodedInput = await journalValueCodec.decode(ctx.request().body).catch((e) => Promise.reject(new require_errors.TerminalError(`Failed to decode input using journal value codec: ${require_errors.ensureError(e).message}`, { errorCode: 400 })));
+			const output = await handler.invoke(ctx, decodedInput);
+			const encodedOutput = journalValueCodec.encode(output);
+			ctx.coreVm.sys_write_output_success(encodedOutput);
+			ctx.coreVm.sys_end();
+			ctx.vmLogger.info("Invocation completed successfully.");
+		} catch (e) {
+			const error = require_errors.ensureError(e, service.options?.asTerminalError);
+			require_errors.logError(ctx.vmLogger, error);
+			if (error instanceof require_errors.TerminalError) {
+				ctx.coreVm.sys_write_output_failure({
+					code: error.code,
+					message: error.message,
+					metadata: Object.entries(error.metadata ?? {}).map(([key, value]) => ({
+						key,
+						value
+					}))
+				});
+				ctx.coreVm.sys_end();
+				return;
 			}
+			throw error;
 		}
-		const body = JSON.stringify(discovery);
-		return {
-			headers: {
-				"content-type": manifestVersion === 2 ? ENDPOINT_MANIFEST_V2 : manifestVersion === 3 ? ENDPOINT_MANIFEST_V3 : ENDPOINT_MANIFEST_V4,
-				"x-restate-server": require_user_agent.X_RESTATE_SERVER
-			},
-			statusCode: 200,
-			body: require_streams.OnceStream(new TextEncoder().encode(body))
-		};
-	}
-	toErrorResponse(code, message) {
-		return {
-			headers: {
-				"content-type": "application/json",
-				"x-restate-server": require_user_agent.X_RESTATE_SERVER
-			},
-			statusCode: code,
-			body: require_streams.OnceStream(new TextEncoder().encode(JSON.stringify({ message })))
-		};
+	} catch (e) {
+		const error = require_errors.ensureError(e);
+		if (error instanceof require_errors.RetryableError) ctx.coreVm.notify_error_with_delay_override(error.message, error.stack, error.retryAfter !== void 0 ? BigInt((0, __restatedev_restate_sdk_core.millisOrDurationToMillis)(error.retryAfter)) : void 0);
+		else ctx.coreVm.notify_error(error.message, error.stack);
 	}
-};
-const invocationLoggers = /* @__PURE__ */ new Map();
-const logsTextDecoder = new TextDecoder("utf-8", { fatal: false });
-/**
-* The shared core propagates logs to the SDK invoking this method.
-* When possible it provides an invocationId, which is used to access the registered invocationLoggers, that should contain the logger per invocation id.
-*/
-function vm_log(level, strBytes, loggerId) {
+}
+async function flushAndClose(coreVm, vmLogger, inputReader, outputWriter) {
+	let inputClosed = false;
 	try {
-		const logger = loggerId && invocationLoggers.get(loggerId) || void 0;
-		const str = logsTextDecoder.decode(strBytes);
-		if (logger !== void 0) logger.logForLevel(wasmLogLevelToRestateLogLevel(level), str);
-		else require_console_logger_transport.defaultLoggerTransport({
-			level: wasmLogLevelToRestateLogLevel(level),
-			replaying: false,
-			source: require_logger_transport.LogSource.JOURNAL
-		}, str);
+		let nextOutput = coreVm.take_output();
+		while (nextOutput !== null && nextOutput !== void 0) {
+			await outputWriter.write(nextOutput);
+			nextOutput = coreVm.take_output();
+		}
+		while (!inputClosed) try {
+			inputClosed = (await inputReader.next()).done ?? false;
+		} catch (e) {
+			inputClosed = true;
+		}
+		await outputWriter.close();
 	} catch (e) {
-		require_console_logger_transport.defaultLoggerTransport({
-			level: require_logger_transport.RestateLogLevel.ERROR,
-			replaying: false,
-			source: require_logger_transport.LogSource.SYSTEM
-		}, "Unexpected error thrown while trying to log: " + e?.toString());
+		const error = require_errors.ensureError(e);
+		const abortErrorOnWrite = isAbortErrorOnWrite(error);
+		if (inputClosed && abortErrorOnWrite) return;
+		if (abortErrorOnWrite) vmLogger.error("Got abort error from connection: " + error.message + "\nThis might indicate that:\n* The restate-server aborted the connection after hitting the 'abort-timeout'\n* The connection with the restate-server was lost\n\nPlease check the invocation in the Restate UI for more details.");
+		else vmLogger.error("Error while handling request: " + (error.stack ?? error.message));
 	}
 }
-function wasmLogLevelToRestateLogLevel(level) {
-	switch (level) {
-		case require_sdk_shared_core_wasm_bindings.LogLevel.TRACE: return require_logger_transport.RestateLogLevel.TRACE;
-		case require_sdk_shared_core_wasm_bindings.LogLevel.DEBUG: return require_logger_transport.RestateLogLevel.DEBUG;
-		case require_sdk_shared_core_wasm_bindings.LogLevel.INFO: return require_logger_transport.RestateLogLevel.INFO;
-		case require_sdk_shared_core_wasm_bindings.LogLevel.WARN: return require_logger_transport.RestateLogLevel.WARN;
-		case require_sdk_shared_core_wasm_bindings.LogLevel.ERROR: return require_logger_transport.RestateLogLevel.ERROR;
-	}
+function isAbortErrorOnWrite(error) {
+	return error.name === "AbortError" || error.message === "Invalid state: WritableStream is closed" || error.code === "ERR_HTTP2_INVALID_STREAM";
 }
 function restateLogLevelToWasmLogLevel(level) {
 	switch (level) {
@@ -329,6 +245,4 @@ function restateLogLevelToWasmLogLevel(level) {
 }
 
 //#endregion
-exports.GenericHandler = GenericHandler;
-exports.tryCreateContextualLogger = tryCreateContextualLogger;
-exports.vm_log = vm_log;
+exports.createRestateHandler = createRestateHandler;