overmux 0.0.10 → 0.0.12

package/dist/internal/server/worker-entry.js

@@ -0,0 +1,728 @@
+import { P as loadOvermuxConfig, _ as isServerLogEnabled, a as serializeWorkerError, c as defaultInstanceId, d as createRuntimeOperations, f as createHandlerLogger, i as postWorkerMessage, o as workerLimits, r as encodeWorkerMessage, s as createRuntimeInstance, t as decodeWorkerMessage, v as serializeServerLogEntry } from "../../worker-protocol-hXs4FXCH.js";
+import { randomUUID } from "node:crypto";
+import "zod";
+import { isDeepStrictEqual } from "node:util";
+import { parentPort } from "node:worker_threads";
+//#region src/internal/server/runtime/runtime-lifecycle.ts
+const asError = (cause) => cause instanceof Error ? cause : new Error(String(cause));
+const disposeAll = async (disposers) => {
+	const errors = (await Promise.allSettled([...disposers].map(async (dispose) => dispose()))).flatMap((result) => result.status === "rejected" ? [asError(result.reason)] : []);
+	if (errors.length) throw new AggregateError(errors, "Runtime disposal failed");
+};
+const createRuntimeLifecycle = (preparationSignal) => {
+	const controller = new AbortController();
+	const activeDisposers = /* @__PURE__ */ new Set();
+	let disposal;
+	const abortPreparation = () => controller.abort(preparationSignal?.reason);
+	preparationSignal?.addEventListener("abort", abortPreparation, { once: true });
+	if (preparationSignal?.aborted) abortPreparation();
+	const completePreparation = () => {
+		preparationSignal?.removeEventListener("abort", abortPreparation);
+	};
+	const requestSignal = (signal) => signal ? AbortSignal.any([controller.signal, signal]) : controller.signal;
+	const track = (dispose, signal) => {
+		let pending;
+		const disposeOnce = () => {
+			if (pending) return pending;
+			controller.signal.removeEventListener("abort", onAbort);
+			signal?.removeEventListener("abort", onAbort);
+			activeDisposers.delete(disposeOnce);
+			pending = Promise.resolve().then(dispose);
+			return pending;
+		};
+		const onAbort = () => {
+			disposeOnce().catch(() => void 0);
+		};
+		activeDisposers.add(disposeOnce);
+		controller.signal.addEventListener("abort", onAbort, { once: true });
+		signal?.addEventListener("abort", onAbort, { once: true });
+		if (controller.signal.aborted || signal?.aborted) onAbort();
+		return disposeOnce;
+	};
+	const dispose = (reason = /* @__PURE__ */ new Error("Runtime disposed")) => {
+		if (disposal) return disposal;
+		completePreparation();
+		const pending = [...activeDisposers];
+		activeDisposers.clear();
+		controller.abort(reason);
+		disposal = disposeAll(pending);
+		return disposal;
+	};
+	return {
+		completePreparation,
+		dispose,
+		disposeAll,
+		requestSignal,
+		signal: controller.signal,
+		track
+	};
+};
+//#endregion
+//#region src/internal/server/runtime/resource-dependency-graph.ts
+const emptyGraphFor = (resourceIds) => new Map(resourceIds.map((resourceId) => [resourceId, /* @__PURE__ */ new Set()]));
+const visitDependencies = ({ dependencies, path, resourceId, visited, visiting }) => {
+	if (visiting.has(resourceId)) throw new Error(`Resource dependency cycle: ${[...path, resourceId].join(" -> ")}`);
+	if (visited.has(resourceId)) return;
+	visiting.add(resourceId);
+	dependencies.get(resourceId)?.forEach((dependencyId) => {
+		visitDependencies({
+			dependencies,
+			path: [...path, resourceId],
+			resourceId: dependencyId,
+			visited,
+			visiting
+		});
+	});
+	visiting.delete(resourceId);
+	visited.add(resourceId);
+};
+const assertAcyclic = (dependencies) => {
+	const visited = /* @__PURE__ */ new Set();
+	const visiting = /* @__PURE__ */ new Set();
+	dependencies.forEach((_, resourceId) => {
+		visitDependencies({
+			dependencies,
+			path: [],
+			resourceId,
+			visited,
+			visiting
+		});
+	});
+};
+const createResourceDependencyGraph = (resources) => {
+	const resourceIds = Object.keys(resources);
+	if (resourceIds.some((resourceId) => !resourceId)) throw new Error("Resource IDs must not be empty");
+	const dependencies = emptyGraphFor(resourceIds);
+	const dependants = emptyGraphFor(resourceIds);
+	Object.entries(resources).forEach(([resourceId, resource]) => {
+		if (resource.kind !== "derived") return;
+		Object.entries(resource.dependencies).forEach(([dependencyName, dependencyId]) => {
+			if (!dependencyName) throw new Error(`Resource ${resourceId} has an empty dependency name`);
+			if (!dependencyId) throw new Error(`Resource ${resourceId} has an empty dependency ID`);
+			if (!dependencies.has(dependencyId)) throw new Error(`Unknown resource dependency: ${dependencyId}`);
+			dependencies.get(resourceId)?.add(dependencyId);
+			dependants.get(dependencyId)?.add(resourceId);
+		});
+	});
+	assertAcyclic(dependencies);
+	return Object.freeze({
+		dependencies,
+		dependants
+	});
+};
+const collectInvalidatedResourceIds = (graph, resourceId, invalidated) => {
+	if (invalidated.has(resourceId)) return;
+	invalidated.add(resourceId);
+	graph.dependants.get(resourceId)?.forEach((dependantId) => {
+		collectInvalidatedResourceIds(graph, dependantId, invalidated);
+	});
+};
+const getInvalidatedResourceIds = (graph, resourceId) => {
+	const invalidated = /* @__PURE__ */ new Set();
+	collectInvalidatedResourceIds(graph, resourceId, invalidated);
+	return invalidated;
+};
+//#endregion
+//#region src/internal/server/runtime/runtime-resources.ts
+const parseDependencyInputs = (definitions, graph, id, rawInput, inputs = /* @__PURE__ */ new Map()) => {
+	if (inputs.has(id)) return inputs;
+	inputs.set(id, definitions[id].contract.input.parse(rawInput));
+	graph.dependencies.get(id)?.forEach((dependencyId) => {
+		parseDependencyInputs(definitions, graph, dependencyId, rawInput, inputs);
+	});
+	return inputs;
+};
+const createSubscriptionLifetime = ({ entry, invalidationListeners, lifecycle, signal }) => {
+	const controller = new AbortController();
+	const subscriptionSignal = AbortSignal.any([lifecycle.requestSignal(signal), controller.signal]);
+	subscriptionSignal.throwIfAborted();
+	const registeredEntry = {
+		...entry,
+		listener: () => {
+			if (!subscriptionSignal.aborted) entry.listener();
+		}
+	};
+	const disposers = [];
+	const subscription = {
+		disposers,
+		dispose: () => {
+			controller.abort(/* @__PURE__ */ new Error("Resource subscription closed"));
+			return release();
+		},
+		refresh: registeredEntry.listener,
+		signal: subscriptionSignal
+	};
+	const release = lifecycle.track(async () => {
+		invalidationListeners.delete(registeredEntry);
+		await lifecycle.disposeAll(disposers);
+	}, subscriptionSignal);
+	invalidationListeners.add(registeredEntry);
+	return subscription;
+};
+const createRuntimeResources = ({ definitions, instance, lifecycle, serverLogger }) => {
+	const graph = createResourceDependencyGraph(definitions);
+	const invalidationListeners = /* @__PURE__ */ new Set();
+	const resources = /* @__PURE__ */ new Map();
+	const invalidateResource = (id, input, allInputs = false) => {
+		if (lifecycle.signal.aborted) return;
+		const ids = getInvalidatedResourceIds(graph, id);
+		invalidationListeners.forEach((entry) => {
+			if (ids.has(entry.resourceId) && (allInputs || isDeepStrictEqual(entry.inputs.get(id), input))) entry.listener();
+		});
+	};
+	const invalidate = (resourceId, input) => {
+		if (!Object.hasOwn(definitions, resourceId)) throw new Error(`Unknown resource ID: ${resourceId}`);
+		const definition = definitions[resourceId];
+		const parsedInput = input === void 0 ? void 0 : definition.contract.input.parse(input);
+		invalidateResource(resourceId, parsedInput, input === void 0);
+	};
+	const context = (signal) => ({
+		instance,
+		invalidate,
+		signal: lifecycle.requestSignal(signal)
+	});
+	const read = (id, rawInput, signal, correlation = { correlationId: randomUUID() }, reads = /* @__PURE__ */ new Map()) => {
+		const existing = reads.get(id);
+		if (existing) return existing;
+		const pending = readDefinition(id, rawInput, signal, correlation, reads);
+		reads.set(id, pending);
+		return pending;
+	};
+	const readDefinition = async (id, rawInput, signal, correlation, reads) => {
+		const definition = definitions[id];
+		const handlerContext = {
+			...context(signal),
+			logger: createHandlerLogger({
+				serverLogger,
+				correlation,
+				capabilityKind: "resource",
+				registeredName: id,
+				handler: "read"
+			})
+		};
+		handlerContext.signal.throwIfAborted();
+		const input = definition.contract.input.parse(rawInput);
+		const dependencies = definition.kind === "derived" ? Object.fromEntries(await Promise.all(Object.entries(definition.dependencies).map(async ([name, dependencyId]) => [name, await read(dependencyId, rawInput, handlerContext.signal, correlation, reads)]))) : void 0;
+		handlerContext.signal.throwIfAborted();
+		const output = definition.kind === "derived" ? definition.combine(dependencies) : await definition.read(input, handlerContext);
+		handlerContext.signal.throwIfAborted();
+		return definition.contract.output.parse(output);
+	};
+	const activateSubscriptions = async (inputs, subscription, correlation) => {
+		for (const [id, input] of inputs) {
+			subscription.signal.throwIfAborted();
+			const definition = definitions[id];
+			if (definition.kind === "subscription") {
+				const dispose = await definition.subscribe(input, () => {
+					if (!subscription.signal.aborted) invalidateResource(id, input);
+				}, {
+					...context(subscription.signal),
+					logger: createHandlerLogger({
+						serverLogger,
+						correlation,
+						capabilityKind: "resource",
+						registeredName: id,
+						handler: "subscribe"
+					})
+				});
+				if (typeof dispose !== "function") throw new Error(`Resource ${id} subscribe must return a disposer`);
+				if (subscription.signal.aborted) {
+					await dispose();
+					subscription.signal.throwIfAborted();
+				}
+				subscription.disposers.push(dispose);
+			}
+		}
+	};
+	Object.keys(definitions).forEach((name) => {
+		resources.set(name, {
+			read: (rawInput, signal, correlation) => read(name, rawInput, signal, correlation),
+			subscribe: async (rawInput, listener, signal, _onError, correlation = { correlationId: randomUUID() }) => {
+				lifecycle.requestSignal(signal).throwIfAborted();
+				const inputs = parseDependencyInputs(definitions, graph, name, rawInput);
+				const subscription = createSubscriptionLifetime({
+					entry: {
+						inputs,
+						listener,
+						resourceId: name
+					},
+					invalidationListeners,
+					lifecycle,
+					signal
+				});
+				try {
+					await activateSubscriptions(inputs, subscription, correlation);
+					subscription.signal.throwIfAborted();
+					subscription.refresh();
+					subscription.signal.throwIfAborted();
+					return subscription.dispose;
+				} catch (cause) {
+					try {
+						await subscription.dispose();
+					} catch (cleanupError) {
+						throw new AggregateError([cause, cleanupError], "Resource subscription setup and cleanup failed");
+					}
+					throw cause;
+				}
+			}
+		});
+	});
+	return {
+		context,
+		get: (name) => resources.get(name),
+		invalidate,
+		names: [...resources.keys()]
+	};
+};
+//#endregion
+//#region src/internal/server/runtime/runtime-streams.ts
+const createRuntimeStreams = ({ instance, definitions, lifecycle, serverLogger }) => {
+	const streams = /* @__PURE__ */ new Map();
+	Object.entries(definitions).forEach(([name, definition]) => {
+		if (!name) throw new Error("Stream names must not be empty");
+		streams.set(name, { open: async (rawInput, emit, requestSignal, onError, correlation) => {
+			const sessionController = new AbortController();
+			const sessionSignal = requestSignal ? AbortSignal.any([requestSignal, sessionController.signal]) : sessionController.signal;
+			const operationSignal = lifecycle.requestSignal(sessionSignal);
+			operationSignal.throwIfAborted();
+			const input = definition.contract.input.parse(rawInput);
+			let acceptingMessages = true;
+			let failed = false;
+			let failure;
+			let opened = false;
+			const fail = (cause) => {
+				if (failed || operationSignal.aborted) return;
+				failed = true;
+				failure = cause;
+				acceptingMessages = false;
+				sessionController.abort(cause);
+				if (opened) onError?.(cause);
+			};
+			const session = await definition.open(input, {
+				instance,
+				logger: createHandlerLogger({
+					serverLogger,
+					correlation,
+					capabilityKind: "stream",
+					registeredName: name,
+					handler: "open"
+				}),
+				emit: (message) => {
+					if (operationSignal.aborted) return;
+					try {
+						emit(definition.contract.serverMessage.parse(message));
+					} catch (cause) {
+						fail(cause);
+					}
+				},
+				fail,
+				signal: operationSignal
+			});
+			opened = true;
+			if (failed || operationSignal.aborted) {
+				await session.dispose?.();
+				operationSignal.throwIfAborted();
+				throw failure;
+			}
+			let messages = Promise.resolve();
+			const dispose = lifecycle.track(async () => {
+				acceptingMessages = false;
+				sessionController.abort(/* @__PURE__ */ new Error("Stream session disposed"));
+				await messages.catch(() => void 0);
+				await session.dispose?.();
+			}, requestSignal);
+			return {
+				dispose: async () => dispose(),
+				send: async (rawMessage) => {
+					if (!acceptingMessages) throw new Error("Stream session is closed");
+					const message = definition.contract.clientMessage.parse(rawMessage);
+					messages = messages.then(async () => {
+						operationSignal.throwIfAborted();
+						await session.onMessage?.(message);
+						operationSignal.throwIfAborted();
+					});
+					return messages;
+				}
+			};
+		} });
+	});
+	return {
+		get: (name) => streams.get(name),
+		names: [...streams.keys()]
+	};
+};
+//#endregion
+//#region src/internal/server/runtime/create-runtime.ts
+const createRuntime = async ({ config, notifications = { send: async () => void 0 }, signal, serverLogger }) => {
+	const lifecycle = createRuntimeLifecycle(signal);
+	const instance = createRuntimeInstance(config.instanceId ?? defaultInstanceId);
+	try {
+		const resources = createRuntimeResources({
+			definitions: config.server.resources ?? {},
+			instance: instance.context,
+			lifecycle,
+			serverLogger
+		});
+		const context = resources.context;
+		const operations = createRuntimeOperations({
+			context,
+			definitions: config.server.operations ?? {},
+			notifications,
+			serverLogger
+		});
+		const streams = createRuntimeStreams({
+			instance: instance.context,
+			definitions: config.server.streams ?? {},
+			lifecycle,
+			serverLogger
+		});
+		lifecycle.signal.throwIfAborted();
+		lifecycle.completePreparation();
+		const manifest = {
+			logLevel: serverLogger?.logLevel ?? config.logLevel ?? "info",
+			operations: [...operations.names],
+			protocolVersion: 11,
+			resources: [...resources.names],
+			streams: [...streams.names]
+		};
+		return {
+			instance: instance.context,
+			establishInstance: instance.establish,
+			manifest,
+			dispose: lifecycle.dispose,
+			getOperation: operations.get,
+			getResource: resources.get,
+			getStream: streams.get
+		};
+	} catch (cause) {
+		await lifecycle.dispose(cause).catch(() => void 0);
+		throw cause;
+	}
+};
+//#endregion
+//#region src/internal/server/worker-entry.ts
+if (!parentPort) throw new Error("Overmux worker requires a parent port");
+const port = parentPort;
+const requests = /* @__PURE__ */ new Map();
+const lifetimes = /* @__PURE__ */ new Map();
+const invalidations = /* @__PURE__ */ new Map();
+const deliveries = /* @__PURE__ */ new Map();
+const notifications = /* @__PURE__ */ new Map();
+let runtime;
+let instanceId;
+let stopping = false;
+let deliveryId = 0;
+let notificationId = 0;
+let deliveryBytes = 0;
+let logCount = 0;
+let logBytes = 0;
+let logsSaturated = false;
+const send = (message) => {
+	const packet = encodeWorkerMessage({
+		...message,
+		deliveryId: ++deliveryId
+	});
+	const bytes = packet.byteLength;
+	const data = message.type === "stream-output" || message.type === "invalidate" || message.type === "notification" || message.type === "log";
+	const countLimit = data ? workerLimits.eventCount - workerLimits.pendingRequests - 2 * workerLimits.lifetimes : workerLimits.eventCount;
+	const byteLimit = data ? workerLimits.eventBytes - 256 * 1024 : workerLimits.eventBytes;
+	if (bytes > workerLimits.messageBytes || deliveries.size >= countLimit || deliveryBytes + bytes > byteLimit || message.type === "log" && (logCount >= workerLimits.logCount || logBytes + bytes > workerLimits.logBytes)) {
+		if (message.type === "log") logsSaturated = logCount > 0;
+		throw new Error("Worker output queue is full or message exceeds 1 MiB");
+	}
+	deliveries.set(deliveryId, {
+		bytes,
+		log: message.type === "log",
+		...message.type === "invalidate" ? { sessionId: message.sessionId } : {}
+	});
+	deliveryBytes += bytes;
+	if (message.type === "log") {
+		logCount += 1;
+		logBytes += bytes;
+	}
+	postWorkerMessage(port, packet);
+	return deliveryId;
+};
+const closeLifetime = (id) => {
+	const lifetime = lifetimes.get(id);
+	if (!lifetime) return Promise.resolve();
+	if (lifetime.closing) return lifetime.closing;
+	invalidations.delete(id);
+	lifetime.controller.abort(/* @__PURE__ */ new Error("Worker lifetime closed"));
+	lifetime.closing = lifetime.setup.then(async () => {
+		try {
+			await lifetime.dispose?.();
+		} finally {
+			if (lifetimes.get(id) === lifetime) lifetimes.delete(id);
+		}
+	});
+	return lifetime.closing;
+};
+const failStream = (id, cause) => {
+	const lifetime = lifetimes.get(id);
+	if (!lifetime || lifetime.closing) return;
+	closeLifetime(id).catch(fatal);
+	send({
+		type: "stream-error",
+		sessionId: id,
+		error: serializeWorkerError(cause)
+	});
+};
+const invalidate = (id) => {
+	if (!lifetimes.has(id) || lifetimes.get(id)?.controller.signal.aborted || stopping) return;
+	const pending = invalidations.get(id);
+	if (pending) {
+		pending.dirty = true;
+		return;
+	}
+	invalidations.set(id, {
+		deliveryId: send({
+			type: "invalidate",
+			sessionId: id
+		}),
+		dirty: false
+	});
+};
+const acknowledge = (id) => {
+	const delivery = deliveries.get(id);
+	if (!delivery) return;
+	deliveries.delete(id);
+	deliveryBytes -= delivery.bytes;
+	if (delivery.log) {
+		logsSaturated = false;
+		logCount -= 1;
+		logBytes -= delivery.bytes;
+	}
+	if (delivery.sessionId !== void 0) {
+		const pending = invalidations.get(delivery.sessionId);
+		invalidations.delete(delivery.sessionId);
+		if (pending?.dirty) invalidate(delivery.sessionId);
+	}
+};
+const fatal = (cause) => {
+	if (stopping) return;
+	stopping = true;
+	postWorkerMessage(port, encodeWorkerMessage({
+		type: "fatal",
+		error: serializeWorkerError(cause)
+	}));
+	process.exit(1);
+};
+const load = async ({ configPath, aliases, logLevel, role, stream }) => {
+	const { config } = await loadOvermuxConfig({
+		configPath,
+		aliases
+	});
+	const { server, instanceId: configuredIdentity, ...settings } = config;
+	const manifest = {
+		logLevel: logLevel ?? config.logLevel ?? "info",
+		protocolVersion: 11,
+		resources: Object.keys(server.resources),
+		operations: Object.keys(server.operations ?? {}),
+		streams: Object.keys(server.streams ?? {})
+	};
+	if (manifest.streams.length > workerLimits.streams) throw new Error("Application stream worker limit exceeded");
+	if (role === "stream" && (!stream || !server.streams?.[stream])) throw new Error("Stream definition not found");
+	if (role !== "metadata") runtime = await createRuntime({
+		config: {
+			...config,
+			instanceId: role === "application" ? configuredIdentity : () => {
+				if (!instanceId) throw new Error("Worker identity is not established");
+				return instanceId;
+			},
+			server: role === "application" ? {
+				resources: server.resources,
+				operations: server.operations
+			} : {
+				resources: {},
+				streams: { [stream]: server.streams[stream] }
+			}
+		},
+		serverLogger: {
+			logLevel: manifest.logLevel,
+			id: randomUUID,
+			log: (entry) => {
+				if (!isServerLogEnabled(manifest.logLevel, entry) || logsSaturated || logCount >= workerLimits.logCount || logBytes >= workerLimits.logBytes) return;
+				try {
+					send({
+						type: "log",
+						entry: serializeServerLogEntry(entry)
+					});
+				} catch {}
+			}
+		},
+		notifications: { send: async (notification) => {
+			if (stopping || notifications.size >= workerLimits.notifications) throw new Error("Worker notification queue is full or disposed");
+			const id = ++notificationId;
+			await new Promise((resolve, reject) => {
+				notifications.set(id, {
+					resolve,
+					reject
+				});
+				try {
+					send({
+						type: "notification",
+						id,
+						notification
+					});
+				} catch (cause) {
+					notifications.delete(id);
+					reject(cause);
+				}
+			});
+		} }
+	});
+	postWorkerMessage(port, encodeWorkerMessage({
+		type: "ready",
+		manifest,
+		settings,
+		voidOperations: manifest.operations.filter((name) => runtime?.getOperation(name)?.returnsVoid)
+	}));
+};
+const createLifetime = (id, controller) => {
+	if (lifetimes.size >= workerLimits.lifetimes) throw new Error("Worker lifetime limit reached");
+	if (lifetimes.has(id)) throw new Error("Duplicate worker lifetime ID");
+	let prepared;
+	const lifetime = {
+		controller,
+		setup: new Promise((resolveSetup) => {
+			prepared = resolveSetup;
+		}),
+		prepared
+	};
+	lifetimes.set(id, lifetime);
+	return lifetime;
+};
+const execute = async (message, controller) => {
+	if (!runtime || stopping) throw new Error("Worker is unavailable");
+	if (message.action === "initialize-instance-identity") {
+		instanceId = message.instanceId;
+		return runtime.establishInstance(message.port);
+	}
+	if (message.action === "resource-read") {
+		const resource = runtime.getResource(message.name);
+		if (!resource) throw new Error("Resource not found");
+		return resource.read(message.input, controller.signal, message.correlation);
+	}
+	if (message.action === "operation") {
+		const operation = runtime.getOperation(message.name);
+		if (!operation) throw new Error("Operation not found");
+		return operation.execute(message.input, controller.signal, message.correlation);
+	}
+	if (message.action === "stream-message") {
+		const lifetime = lifetimes.get(message.sessionId);
+		if (!lifetime?.send) throw new Error("Stream not found");
+		return lifetime.send(message.message);
+	}
+	const id = message.sessionId;
+	const lifetime = createLifetime(id, controller);
+	try {
+		if (message.action === "stream-open") {
+			const stream = runtime.getStream(message.name);
+			if (!stream) throw new Error("Stream not found");
+			const session = await stream.open(message.input, (output) => {
+				if (lifetimes.get(id) === lifetime && !controller.signal.aborted && !stopping) send({
+					type: "stream-output",
+					sessionId: id,
+					message: output
+				});
+			}, controller.signal, (cause) => failStream(id, cause), message.correlation);
+			lifetime.dispose = session.dispose;
+			lifetime.send = session.send;
+		} else {
+			const resource = runtime.getResource(message.name);
+			if (!resource) throw new Error("Resource not found");
+			const dispose = await resource.subscribe(message.input, () => invalidate(id), controller.signal, void 0, message.correlation);
+			lifetime.dispose = async () => dispose();
+		}
+		if (controller.signal.aborted || lifetimes.get(id) !== lifetime) {
+			await lifetime.dispose?.();
+			controller.signal.throwIfAborted();
+			throw new Error("Worker lifetime closed during setup");
+		}
+	} catch (cause) {
+		if (lifetimes.get(id) === lifetime && !lifetime.closing) lifetimes.delete(id);
+		invalidations.delete(id);
+		throw cause;
+	} finally {
+		lifetime.prepared();
+	}
+};
+const handleRequest = async (message) => {
+	const controller = new AbortController();
+	requests.set(message.id, controller);
+	try {
+		const value = await execute(message, controller);
+		send({
+			type: "reply",
+			id: message.id,
+			ok: true,
+			value
+		});
+	} catch (cause) {
+		try {
+			send({
+				type: "reply",
+				id: message.id,
+				ok: false,
+				error: serializeWorkerError(cause)
+			});
+		} catch (sendCause) {
+			fatal(sendCause);
+		}
+	} finally {
+		requests.delete(message.id);
+	}
+};
+const shutdown = async () => {
+	if (stopping) return;
+	stopping = true;
+	requests.forEach((controller) => controller.abort(/* @__PURE__ */ new Error("Worker disposed")));
+	notifications.forEach(({ reject }) => reject(/* @__PURE__ */ new Error("Worker disposed")));
+	notifications.clear();
+	await Promise.all([...[...lifetimes.keys()].map(closeLifetime), runtime?.dispose()]);
+	postWorkerMessage(port, encodeWorkerMessage({ type: "disposed" }));
+};
+const handleControl = (message) => {
+	if (message.type === "ack") acknowledge(message.deliveryId);
+	if (message.type === "cancel") requests.get(message.requestId)?.abort(/* @__PURE__ */ new Error("Request cancelled"));
+	if (message.type === "close") closeLifetime(message.sessionId).then(() => send({
+		type: "closed",
+		sessionId: message.sessionId
+	}), (cause) => send({
+		type: "closed",
+		sessionId: message.sessionId,
+		error: serializeWorkerError(cause)
+	})).catch(fatal);
+	if (message.type === "shutdown") shutdown().catch((cause) => postWorkerMessage(port, encodeWorkerMessage({
+		type: "fatal",
+		error: serializeWorkerError(cause)
+	})));
+	if (message.type === "notification-result") {
+		const pending = notifications.get(message.id);
+		notifications.delete(message.id);
+		message.ok ? pending?.resolve() : pending?.reject(new Error(message.error));
+	}
+};
+port.on("message", (packet) => {
+	try {
+		const message = decodeWorkerMessage(packet);
+		if ("action" in message) {
+			handleRequest(message);
+			return;
+		}
+		if (message.type === "init") {
+			load(message).catch(fatal);
+			return;
+		}
+		handleControl(message);
+	} catch (cause) {
+		fatal(cause);
+	}
+});
+process.once("uncaughtException", fatal);
+process.once("unhandledRejection", fatal);
+//#endregion
+export {};
+
+//# sourceMappingURL=worker-entry.js.map