overmux 0.0.4 → 0.0.5

package/dist/exports/server.js

@@ -1,14 +1,8 @@
-import { realpath } from "node:fs/promises";
 import { isIP } from "node:net";
-import { dirname, isAbsolute, join, resolve } from "node:path";
-import { createJiti } from "jiti";
-import { ZodError, z } from "zod";
-import { homedir, hostname } from "node:os";
-import ts from "typescript";
-import { isDeepStrictEqual } from "node:util";
-import { fork } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import { watch } from "node:fs";
+import { isAbsolute, join } from "node:path";
+import "jiti";
+import { z } from "zod";
+import { homedir } from "node:os";
 //#region ../shared/dist/node/index.js
 const durationPattern = /^([1-9]\d*)(ms|s|m|h|d)$/;
 const millisecondsByUnit = {
@@ -26,7 +20,7 @@ const durationToMilliseconds = (duration) => {
 	return Number.isSafeInteger(milliseconds) ? milliseconds : void 0;
 };
 const aiContextSnippets = ["package-source", "tech-stack-recommendations"];
-const instanceIdSchema$1 = z.string().max(253).regex(/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?(?![\s\S])/, "Expected a lowercase instance ID with only ASCII letters, digits, internal dots and hyphens");
+const instanceIdSchema = z.string().max(253).regex(/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?(?![\s\S])/, "Expected a lowercase instance ID with only ASCII letters, digits, internal dots and hyphens");
 const zodTypeSchema = z.custom((value) => value instanceof z.ZodType, "Expected a Zod schema");
 const functionSchema = z.custom((value) => typeof value === "function", "Expected a function");
 const contractRuntimeSchema = z.object({
@@ -75,12 +69,11 @@ const loopbackPeerSchema = z.string().refine((value) => isIP(value) !== 0 && (va
 const authConfigRuntimeSchema = z.object({
 	mode: z.literal("cli-login"),
 	origins: z.array(exactOriginSchema).min(1).refine((origins) => new Set(origins).size === origins.length, "Expected unique origins").optional(),
-	sessionLifetime: z.union([z.literal("never"), authDurationSchema]).default("never"),
+	sessionLifetime: z.union([z.literal("forever"), authDurationSchema]).default("forever"),
 	trustedProxyPeer: loopbackPeerSchema.optional()
 }).strict();
 const serverConfigRuntimeSchema = z.object({
 	host: z.string().min(1).optional(),
-	logFile: z.string().min(1).optional(),
 	port: z.number().int().min(1).max(65535).optional(),
 	productionWebAssetsDir: z.string().min(1).optional(),
 	watch: z.boolean().optional()
@@ -90,52 +83,14 @@ const serverDefinitionRuntimeSchema = z.object({
 	resources: z.record(z.string(), resourceDefinitionRuntimeSchema),
 	streams: z.record(z.string(), streamHandlerRuntimeSchema).optional()
 });
-const configDefinitionRuntimeSchema = serverConfigRuntimeSchema.extend({
+serverConfigRuntimeSchema.extend({
 	aiContextSnippets: z.array(z.enum(aiContextSnippets)).optional(),
 	auth: authConfigRuntimeSchema,
 	debug: z.boolean().optional(),
-	instanceId: z.union([instanceIdSchema$1, z.custom((value) => typeof value === "function", "Expected an instance ID or a function of the bound port")]).optional(),
+	instanceId: z.union([instanceIdSchema, z.custom((value) => typeof value === "function", "Expected an instance ID or a function of the bound port")]).optional(),
 	server: serverDefinitionRuntimeSchema,
 	vite: z.string().min(1).optional()
 });
-const resolveLogicalPath = async (path) => {
-	const logicalPath = resolve(path);
-	return {
-		logicalPath,
-		realPath: await realpath(logicalPath)
-	};
-};
-const resolveOvermuxConfigPaths = async (configPath) => {
-	const { logicalPath, realPath } = await resolveLogicalPath(configPath);
-	return {
-		logicalApplicationRoot: dirname(logicalPath),
-		logicalConfigPath: logicalPath,
-		realApplicationRoot: dirname(realPath),
-		realConfigPath: realPath
-	};
-};
-const unwrapDefaultExport = (module) => {
-	if (typeof module === "object" && module !== null && "default" in module) return module.default;
-	return module;
-};
-const loadOvermuxConfig = async ({ aliases = {}, configPath }) => {
-	const paths = await resolveOvermuxConfigPaths(configPath);
-	const module = await createJiti(paths.logicalConfigPath, {
-		alias: aliases,
-		fsCache: true,
-		jsx: {
-			importSource: "react",
-			runtime: "automatic"
-		},
-		moduleCache: false,
-		sourceMaps: true,
-		tsconfigPaths: true
-	}).import(paths.logicalConfigPath);
-	return {
-		config: configDefinitionRuntimeSchema.parse(unwrapDefaultExport(module)),
-		paths
-	};
-};
 const xdgDirectory = (configured, fallback) => configured && isAbsolute(configured) ? configured : fallback;
 const overmuxDirectory = (root) => join(root, "overmux");
 const getOvermuxPaths = ({ environment = process.env, homeDir = homedir(), xdgCacheHome = environment.XDG_CACHE_HOME, xdgConfigHome = environment.XDG_CONFIG_HOME, xdgDataHome = environment.XDG_DATA_HOME, xdgRuntimeDir = environment.XDG_RUNTIME_DIR, xdgStateHome = environment.XDG_STATE_HOME } = {}) => {
@@ -150,1013 +105,6 @@ const getOvermuxPaths = ({ environment = process.env, homeDir = homedir(), xdgCa
 	};
 };
 //#endregion
-//#region src/internal/shared/background-notifications.ts
-const deliveryKeySchema = z.string().min(1).max(1024).regex(/^[\w-]+$/u);
-const backgroundNotificationSubscriptionSchema = z.object({
-	endpoint: z.url().max(4096).refine((endpoint) => {
-		const url = new URL(endpoint);
-		return url.protocol === "https:" && !url.username && !url.password;
-	}),
-	expirationTime: z.number().int().nonnegative().nullable(),
-	keys: z.object({
-		auth: deliveryKeySchema,
-		p256dh: deliveryKeySchema
-	}).strict()
-}).strict();
-z.object({ publicKey: deliveryKeySchema }).strict();
-z.object({ endpoint: backgroundNotificationSubscriptionSchema.shape.endpoint }).strict();
-const safeRelativeNotificationLink = (link) => {
-	let decoded;
-	try {
-		decoded = decodeURIComponent(link);
-	} catch {
-		return false;
-	}
-	return !decoded.startsWith("//") && !decoded.includes("\\") && ![...decoded].some((character) => {
-		const codePoint = character.codePointAt(0) ?? 0;
-		return codePoint < 32 || codePoint === 127;
-	});
-};
-const notificationLinkSchema = z.union([z.string().max(4096).startsWith("/").refine(safeRelativeNotificationLink), z.string().max(4096).url().refine((link) => {
-	if (!URL.canParse(link)) return false;
-	const url = new URL(link);
-	return ["http:", "https:"].includes(url.protocol) && !url.username && !url.password;
-})]);
-const notificationSchema = z.object({
-	body: z.string().max(4096).optional(),
-	open: z.object({ link: notificationLinkSchema }).strict().optional(),
-	title: z.string().min(1).max(4096)
-}).strict();
-const instanceIdSchema = z.string().max(253).regex(/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?(?![\s\S])/, "Expected a lowercase instance ID with only ASCII letters, digits, internal dots and hyphens");
-const createInstanceIdentity = (instanceId) => ({
-	instanceId: instanceIdSchema.parse(instanceId),
-	deepLinkPrefix: `overmux://${instanceId}`
-});
-z.object({
-	debug: z.boolean(),
-	operations: z.array(z.string().min(1)),
-	protocolVersion: z.literal(10),
-	resources: z.array(z.string().min(1)),
-	streams: z.array(z.string().min(1))
-});
-const updateAvailableEventSchema = z.object({ type: z.literal("update-available") });
-const restartingEventSchema = z.object({ type: z.literal("restarting") });
-z.discriminatedUnion("type", [updateAvailableEventSchema, restartingEventSchema]);
-const notificationEventSchema = z.object({
-	notification: notificationSchema,
-	type: z.literal("notification")
-}).strict();
-const operationIdSchema = z.string().min(1).max(256);
-const registrationNameSchema = z.string().min(1).max(256);
-const resourceReadMessageSchema = z.object({
-	input: z.unknown().optional(),
-	operationId: operationIdSchema,
-	resourceName: registrationNameSchema,
-	type: z.literal("resource-read")
-});
-const resourceSubscribeMessageSchema = z.object({
-	input: z.unknown().optional(),
-	operationId: operationIdSchema,
-	resourceName: registrationNameSchema,
-	subscriptionId: operationIdSchema,
-	type: z.literal("resource-subscribe")
-});
-const resourceUnsubscribeMessageSchema = z.object({
-	subscriptionId: operationIdSchema,
-	type: z.literal("resource-unsubscribe")
-});
-const streamOpenMessageSchema = z.object({
-	input: z.unknown().optional(),
-	operationId: operationIdSchema,
-	streamId: operationIdSchema,
-	streamName: registrationNameSchema,
-	type: z.literal("stream-open")
-});
-const streamMessageSchema = z.object({
-	message: z.unknown(),
-	streamId: operationIdSchema,
-	type: z.literal("stream-message")
-});
-const streamCloseMessageSchema = z.object({
-	streamId: operationIdSchema,
-	type: z.literal("stream-close")
-});
-const clientDiagnosticEventSchema = z.object({
-	arguments: z.string().max(16100),
-	level: z.enum([
-		"log",
-		"info",
-		"warn",
-		"error",
-		"debug"
-	]),
-	message: z.string().max(4100),
-	stack: z.string().max(8100).optional(),
-	timestamp: z.iso.datetime(),
-	type: z.literal("client-diagnostic"),
-	url: z.string().max(2100).optional()
-});
-z.discriminatedUnion("type", [
-	resourceReadMessageSchema,
-	resourceSubscribeMessageSchema,
-	resourceUnsubscribeMessageSchema,
-	streamOpenMessageSchema,
-	streamMessageSchema,
-	streamCloseMessageSchema,
-	clientDiagnosticEventSchema
-]);
-const resourceResultMessageSchema = z.object({
-	operationId: operationIdSchema,
-	output: z.unknown(),
-	type: z.literal("resource-result")
-});
-const resourceInvalidatedMessageSchema = z.object({
-	subscriptionId: operationIdSchema,
-	type: z.literal("resource-invalidated")
-});
-const streamOpenedMessageSchema = z.object({
-	operationId: operationIdSchema,
-	streamId: operationIdSchema,
-	type: z.literal("stream-opened")
-});
-const streamOutputMessageSchema = z.object({
-	message: z.unknown(),
-	streamId: operationIdSchema,
-	type: z.literal("stream-output")
-});
-const streamClosedMessageSchema = z.object({
-	streamId: operationIdSchema,
-	type: z.literal("stream-closed")
-});
-const protocolErrorMessageSchema = z.object({
-	code: z.enum([
-		"bad-request",
-		"conflict",
-		"internal",
-		"not-found"
-	]),
-	message: z.string(),
-	operationId: operationIdSchema.optional(),
-	streamId: operationIdSchema.optional(),
-	subscriptionId: operationIdSchema.optional(),
-	type: z.literal("error")
-});
-const serverInfoMessageSchema = z.object({
-	type: z.literal("server-info"),
-	instanceId: instanceIdSchema
-}).strict();
-z.discriminatedUnion("type", [
-	serverInfoMessageSchema,
-	resourceResultMessageSchema,
-	resourceInvalidatedMessageSchema,
-	streamOpenedMessageSchema,
-	streamOutputMessageSchema,
-	streamClosedMessageSchema,
-	protocolErrorMessageSchema,
-	updateAvailableEventSchema,
-	restartingEventSchema,
-	notificationEventSchema
-]);
-//#endregion
-//#region src/internal/server/runtime/runtime-instance.ts
-const createRuntimeInstance = (configured) => {
-	let identity;
-	const get = () => {
-		if (!identity) throw new Error("Overmux instance identity is not ready");
-		return identity;
-	};
-	return {
-		context: {
-			getInstanceId: () => get().instanceId,
-			getDeepLinkPrefix: () => get().deepLinkPrefix
-		},
-		establish: (port) => {
-			if (identity) throw new Error("Overmux instance identity is already established");
-			try {
-				identity = createInstanceIdentity(typeof configured === "function" ? configured({ port }) : configured ?? `${hostname()}-${port}`);
-			} catch (cause) {
-				throw new Error("Invalid Overmux instance ID; configure instanceId with a canonical lowercase ID", { cause });
-			}
-			return identity;
-		}
-	};
-};
-//#endregion
-//#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/runtime-operations.ts
-var OperationValidationError = class extends Error {
-	phase;
-	constructor(phase, cause) {
-		super(cause.message, { cause });
-		this.phase = phase;
-	}
-};
-const createRuntimeOperations = ({ context, definitions, notifications }) => {
-	const operations = /* @__PURE__ */ new Map();
-	Object.entries(definitions).forEach(([name, definition]) => {
-		if (!name) throw new Error("Operation names must not be empty");
-		operations.set(name, {
-			execute: async (rawInput, signal) => {
-				const operationContext = context(signal);
-				operationContext.signal.throwIfAborted();
-				const input = definition.input.safeParse(rawInput);
-				if (!input.success) throw new OperationValidationError("input", input.error);
-				const rawOutput = await definition.handle(input.data, {
-					...operationContext,
-					notifications
-				});
-				operationContext.signal.throwIfAborted();
-				const output = definition.output.safeParse(rawOutput);
-				if (!output.success) throw new OperationValidationError("output", output.error);
-				return output.data;
-			},
-			returnsVoid: definition.output instanceof z.ZodVoid
-		});
-	});
-	return {
-		get: (name) => operations.get(name),
-		names: [...operations.keys()]
-	};
-};
-z.void();
-const jsonValueSchema = z.lazy(() => z.union([
-	z.string(),
-	z.number().finite(),
-	z.boolean(),
-	z.null(),
-	z.array(jsonValueSchema),
-	z.record(z.string(), jsonValueSchema)
-]));
-//#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 createRuntimeResources = ({ definitions, instance, lifecycle }) => {
-	const graph = createResourceDependencyGraph(definitions);
-	const invalidationListeners = /* @__PURE__ */ new Set();
-	const contracts = /* @__PURE__ */ new Map();
-	const resources = /* @__PURE__ */ new Map();
-	Object.entries(definitions).forEach(([id, definition]) => {
-		contracts.set(definition.contract, [...contracts.get(definition.contract) ?? [], id]);
-	});
-	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.input, input))) entry.listener();
-		});
-	};
-	const invalidate = (contract, input) => {
-		const ids = contracts.get(contract) ?? Object.entries(definitions).filter(([, definition]) => definition.contract.input === contract.input && definition.contract.output === contract.output).map(([id]) => id);
-		if (!ids.length) throw new Error("Cannot invalidate a resource outside this runtime");
-		ids.forEach((id) => {
-			const definition = definitions[id];
-			const parsedInput = input === void 0 ? void 0 : definition.contract.input.parse(input);
-			invalidateResource(id, parsedInput, input === void 0);
-		});
-	};
-	const context = (signal) => ({
-		instance,
-		invalidate,
-		signal: lifecycle.requestSignal(signal)
-	});
-	const read = async (id, rawInput, signal) => {
-		const definition = definitions[id];
-		const operationSignal = lifecycle.requestSignal(signal);
-		operationSignal.throwIfAborted();
-		const input = definition.contract.input.parse(rawInput);
-		const rawOutput = definition.kind === "derived" ? definition.combine(Object.fromEntries(await Promise.all(Object.entries(definition.dependencies).map(async ([name, dependencyId]) => [name, await read(dependencyId, rawInput, signal)])))) : await definition.read(input, context(signal));
-		operationSignal.throwIfAborted();
-		return definition.contract.output.parse(rawOutput);
-	};
-	const activateWatchers = (id, rawInput, signal, activated, disposers) => {
-		if (activated.has(id)) return;
-		activated.add(id);
-		const definition = definitions[id];
-		const input = definition.contract.input.parse(rawInput);
-		if (definition.kind === "subscription") {
-			const dispose = definition.subscribe(input, () => invalidateResource(id, input), context(signal));
-			if (typeof dispose !== "function") throw new Error(`Resource ${id} subscribe must return a disposer`);
-			disposers.push(dispose);
-			return;
-		}
-		if (definition.kind === "derived") graph.dependencies.get(id)?.forEach((dependencyId) => {
-			activateWatchers(dependencyId, rawInput, signal, activated, disposers);
-		});
-	};
-	Object.keys(definitions).forEach((name) => {
-		resources.set(name, {
-			read: (input, signal) => read(name, input, signal),
-			subscribe: (rawInput, listener, signal) => {
-				lifecycle.requestSignal(signal).throwIfAborted();
-				const entry = {
-					input: definitions[name].contract.input.parse(rawInput),
-					listener,
-					resourceId: name
-				};
-				const watcherDisposers = [];
-				invalidationListeners.add(entry);
-				try {
-					activateWatchers(name, rawInput, signal, /* @__PURE__ */ new Set(), watcherDisposers);
-				} catch (cause) {
-					invalidationListeners.delete(entry);
-					lifecycle.disposeAll(watcherDisposers).catch(() => void 0);
-					throw cause;
-				}
-				return lifecycle.track(async () => {
-					invalidationListeners.delete(entry);
-					await lifecycle.disposeAll(watcherDisposers);
-				}, signal);
-			}
-		});
-	});
-	return {
-		context,
-		get: (name) => resources.get(name),
-		invalidate,
-		names: [...resources.keys()]
-	};
-};
-//#endregion
-//#region src/internal/server/runtime/runtime-streams.ts
-const createRuntimeStreams = ({ context, definitions, lifecycle }) => {
-	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) => {
-			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, {
-				...context(sessionSignal),
-				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, debug = false, notifications = { send: async () => void 0 }, signal }) => {
-	const lifecycle = createRuntimeLifecycle(signal);
-	const instance = createRuntimeInstance(config.instanceId);
-	try {
-		const resources = createRuntimeResources({
-			definitions: config.server.resources ?? {},
-			instance: instance.context,
-			lifecycle
-		});
-		const context = resources.context;
-		const operations = createRuntimeOperations({
-			context,
-			definitions: config.server.operations ?? {},
-			notifications
-		});
-		const streams = createRuntimeStreams({
-			context,
-			definitions: config.server.streams ?? {},
-			lifecycle
-		});
-		lifecycle.signal.throwIfAborted();
-		lifecycle.completePreparation();
-		const manifest = {
-			debug,
-			operations: [...operations.names],
-			protocolVersion: 10,
-			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/check-overmux.ts
-const loadCompilerOptions = (configPath) => {
-	const tsconfig = ts.findConfigFile(dirname(configPath), ts.sys.fileExists);
-	if (!tsconfig) return {
-		allowImportingTsExtensions: true,
-		allowJs: false,
-		esModuleInterop: true,
-		jsx: ts.JsxEmit.ReactJSX,
-		module: ts.ModuleKind.ESNext,
-		moduleResolution: ts.ModuleResolutionKind.Bundler,
-		noEmit: true,
-		skipLibCheck: true,
-		strict: true,
-		target: ts.ScriptTarget.ES2022
-	};
-	const loaded = ts.readConfigFile(tsconfig, ts.sys.readFile);
-	if (loaded.error) throw new Error(ts.flattenDiagnosticMessageText(loaded.error.messageText, "\n"));
-	return {
-		...ts.parseJsonConfigFileContent(loaded.config, ts.sys, dirname(tsconfig)).options,
-		allowImportingTsExtensions: true,
-		noEmit: true
-	};
-};
-const diagnosticOf = (diagnostic) => {
-	const position = diagnostic.file && diagnostic.start !== void 0 ? diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start) : void 0;
-	return {
-		code: diagnostic.code,
-		column: position ? position.character + 1 : void 0,
-		file: diagnostic.file?.fileName,
-		line: position ? position.line + 1 : void 0,
-		message: ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"),
-		phase: "types"
-	};
-};
-const kindOf = (fileName, configPath) => {
-	if (resolve(fileName) === resolve(configPath) || fileName.match(/\.server\.[cm]?[jt]sx?$/)) return "server";
-	if (fileName.match(/\.ui\.[cm]?[jt]sx?$/)) return "client";
-	if (fileName.match(/\.shared\.[cm]?[jt]sx?$/)) return "shared";
-};
-const kindOfSpecifier = (specifier) => {
-	if (specifier === "overmux/client" || specifier.endsWith("/react")) return "client";
-	if (specifier === "overmux/server" || specifier.endsWith("/server") || specifier.startsWith("node:")) return "server";
-	if (specifier === "overmux" || specifier.endsWith("/shared")) return "shared";
-};
-const isTypeOnlyReference = (node) => {
-	if (ts.isExportDeclaration(node)) return Boolean(node.isTypeOnly || node.exportClause && ts.isNamedExports(node.exportClause) && node.exportClause.elements.every((element) => element.isTypeOnly));
-	const clause = node.importClause;
-	if (!clause || clause.name) return Boolean(clause?.isTypeOnly);
-	return Boolean(clause.isTypeOnly || clause.namedBindings && ts.isNamedImports(clause.namedBindings) && clause.namedBindings.elements.every((element) => element.isTypeOnly));
-};
-const resolvedImports = (program, source) => {
-	const imports = [];
-	source.forEachChild((node) => {
-		if (!ts.isImportDeclaration(node) && !ts.isExportDeclaration(node) || !node.moduleSpecifier || !ts.isStringLiteral(node.moduleSpecifier) || isTypeOnlyReference(node)) return;
-		const specifier = node.moduleSpecifier.text;
-		const resolved = ts.resolveModuleName(specifier, source.fileName, program.getCompilerOptions(), ts.sys).resolvedModule?.resolvedFileName;
-		const target = resolved ? program.getSourceFile(resolved) : void 0;
-		const kind = kindOfSpecifier(specifier);
-		if (kind || target && !target.isDeclarationFile) imports.push({
-			kind,
-			node,
-			source: target?.isDeclarationFile ? void 0 : target
-		});
-	});
-	return imports;
-};
-const invalidImport = (source, target) => source === "server" && target === "client" || source === "client" && target === "server" || source === "shared" && target !== void 0 && target !== "shared";
-const visitImportGraph = ({ configPath, diagnostics, kind, program, seen, source }) => {
-	const visitKey = `${kind}:${source.fileName}`;
-	if (seen.has(visitKey)) return;
-	seen.add(visitKey);
-	resolvedImports(program, source).forEach(({ kind: importKind, node, source: target }) => {
-		const declaredKind = importKind ?? (target ? kindOf(target.fileName, configPath) : void 0);
-		if (invalidImport(kind, declaredKind)) {
-			const position = source.getLineAndCharacterOfPosition(node.getStart());
-			diagnostics.push({
-				code: "OVERMUX_IMPORT_BOUNDARY",
-				column: position.character + 1,
-				file: source.fileName,
-				line: position.line + 1,
-				message: `${kind} modules may not import ${declaredKind} modules`,
-				phase: "imports"
-			});
-			return;
-		}
-		if (target) visitImportGraph({
-			configPath,
-			diagnostics,
-			kind: declaredKind === "shared" ? "shared" : kind,
-			program,
-			seen,
-			source: target
-		});
-	});
-};
-const importBoundaryDiagnostics = (program, configPath) => {
-	const diagnostics = [];
-	const seen = /* @__PURE__ */ new Set();
-	program.getSourceFiles().forEach((source) => {
-		const kind = kindOf(source.fileName, configPath);
-		if (kind && !source.isDeclarationFile) visitImportGraph({
-			configPath,
-			diagnostics,
-			kind,
-			program,
-			seen,
-			source
-		});
-	});
-	return diagnostics;
-};
-const runtimeDiagnostics = (cause) => {
-	if (cause instanceof ZodError) return cause.issues.map((issue) => ({
-		message: issue.message,
-		path: issue.path.length ? issue.path.join(".") : void 0,
-		phase: "runtime"
-	}));
-	return [{
-		message: cause instanceof Error ? cause.message : String(cause),
-		phase: "runtime"
-	}];
-};
-const typecheck = async ({ aliases = {}, configPath, typeAliases }) => {
-	const options = loadCompilerOptions(configPath);
-	const aliasesForTypes = typeAliases ?? Object.fromEntries(Object.entries(aliases).filter(([key]) => key === "overmux" || key.startsWith("overmux/")));
-	const absoluteAliases = Object.fromEntries(Object.entries(aliasesForTypes).map(([key, value]) => [key, [isAbsolute(value) ? value : resolve(value)]]));
-	const program = ts.createProgram({
-		options: {
-			...options,
-			baseUrl: options.baseUrl ?? "/",
-			paths: {
-				...options.paths,
-				...absoluteAliases
-			}
-		},
-		rootNames: [configPath]
-	});
-	return {
-		diagnostics: [...ts.getPreEmitDiagnostics(program).map(diagnosticOf), ...importBoundaryDiagnostics(program, configPath)],
-		files: program.getSourceFiles().filter((file) => !file.isDeclarationFile && !file.fileName.includes("node_modules")).length
-	};
-};
-const checkOvermux = async (options) => {
-	const configPath = resolve(options.configPath);
-	let checked;
-	try {
-		checked = await typecheck({
-			...options,
-			configPath
-		});
-	} catch (cause) {
-		return {
-			config: configPath,
-			diagnostics: [{
-				message: cause instanceof Error ? cause.message : String(cause),
-				phase: "config"
-			}],
-			files: 0,
-			ok: false
-		};
-	}
-	if (checked.diagnostics.length || options.typesOnly) return {
-		config: configPath,
-		diagnostics: checked.diagnostics,
-		files: checked.files,
-		ok: checked.diagnostics.length === 0
-	};
-	let runtime;
-	try {
-		const { config } = await loadOvermuxConfig({
-			aliases: options.aliases,
-			configPath
-		});
-		runtime = await createRuntime({ config });
-		return {
-			operations: runtime.manifest.operations.length,
-			config: configPath,
-			diagnostics: [],
-			files: checked.files,
-			ok: true
-		};
-	} catch (cause) {
-		return {
-			config: configPath,
-			diagnostics: runtimeDiagnostics(cause),
-			files: checked.files,
-			ok: false
-		};
-	} finally {
-		await runtime?.dispose();
-	}
-};
-//#endregion
-//#region src/internal/server/server-logger.ts
-const errorMessage = (cause) => cause instanceof Error ? cause.message : String(cause);
-//#endregion
-//#region src/internal/server/coordinator/ipc-protocol.ts
-const childOptionsSchema = z.object({
-	configAliases: z.record(z.string(), z.string()).optional(),
-	configPath: z.string(),
-	debug: z.boolean().optional(),
-	developmentWebTarget: z.url().optional(),
-	host: z.string().optional(),
-	logFile: z.string().optional(),
-	port: z.number().int().min(0).max(65535).optional(),
-	productionWebAssetsDir: z.string().optional(),
-	watch: z.boolean().optional()
-});
-z.discriminatedUnion("type", [
-	z.object({
-		options: childOptionsSchema,
-		type: z.literal("start")
-	}),
-	z.object({ type: z.literal("update-available") }),
-	z.object({ type: z.literal("stop") })
-]);
-const childMessageSchema = z.discriminatedUnion("type", [
-	z.object({
-		host: z.string(),
-		port: z.number().int().min(1).max(65535),
-		type: z.literal("ready"),
-		url: z.string(),
-		watch: z.boolean()
-	}),
-	z.object({ type: z.literal("restart-requested") }),
-	z.object({
-		message: z.string(),
-		type: z.literal("startup-failed")
-	})
-]);
-const parseChildMessage = (value) => childMessageSchema.parse(value);
-//#endregion
-//#region src/internal/server/coordinator/update-watcher.ts
-const isRelevantUpdatePath = (path) => {
-	if (path.split(/[\\/]/).some((segment) => segment.toLowerCase() === "node_modules")) return false;
-	return /\.(?:js|jsx|mjs|cjs|ts|tsx|mts|cts|json|css)$/i.test(path);
-};
-const startUpdateWatcher = ({ configPath, onUpdate }) => {
-	let closed = false;
-	let timeout;
-	const watcher = watch(dirname(configPath), { recursive: true }, (_event, fileName) => {
-		if (closed || !fileName || !isRelevantUpdatePath(fileName.toString())) return;
-		if (timeout) clearTimeout(timeout);
-		timeout = setTimeout(onUpdate, 100);
-	});
-	return { close: () => {
-		if (closed) return;
-		closed = true;
-		if (timeout) clearTimeout(timeout);
-		watcher.close();
-	} };
-};
-//#endregion
-//#region src/internal/server/coordinator/server-coordinator.ts
-const send = (child, message, onError) => {
-	if (!child.connected) {
-		onError?.(/* @__PURE__ */ new Error("Server child IPC channel is closed"));
-		return;
-	}
-	try {
-		child.send(message, (cause) => {
-			if (cause) onError?.(cause);
-		});
-	} catch (cause) {
-		onError?.(cause instanceof Error ? cause : new Error(String(cause)));
-	}
-};
-const stopChild = (child) => new Promise((resolve) => {
-	let timeout;
-	const finish = () => {
-		child.off("exit", finish);
-		clearTimeout(timeout);
-		resolve();
-	};
-	child.once("exit", finish);
-	if (child.exitCode !== null || child.signalCode !== null) {
-		finish();
-		return;
-	}
-	timeout = setTimeout(() => {
-		if (!child.kill("SIGKILL")) finish();
-	}, 5e3);
-	send(child, { type: "stop" });
-});
-const serverChildPath = () => fileURLToPath(import.meta.resolve("#server-child"));
-const startChild = (options, onRestartRequested) => new Promise((resolve, reject) => {
-	const child = fork(serverChildPath(), [], {
-		serialization: "json",
-		stdio: [
-			"inherit",
-			"inherit",
-			"inherit",
-			"ipc"
-		]
-	});
-	let settled = false;
-	const fail = (cause) => {
-		if (settled) return;
-		settled = true;
-		if (child.exitCode === null && child.signalCode === null) child.kill();
-		reject(cause instanceof Error ? cause : new Error(String(cause)));
-	};
-	child.on("error", fail);
-	child.on("exit", (code, signal) => {
-		fail(/* @__PURE__ */ new Error(`Server child exited before readiness (${signal ?? code ?? "unknown"})`));
-	});
-	child.on("message", (raw) => {
-		let message;
-		try {
-			message = parseChildMessage(raw);
-		} catch (cause) {
-			fail(cause);
-			return;
-		}
-		if (message.type === "restart-requested") {
-			if (settled) onRestartRequested();
-			return;
-		}
-		if (message.type === "startup-failed") {
-			fail(new Error(message.message));
-			return;
-		}
-		if (!settled) {
-			settled = true;
-			resolve({
-				host: message.host,
-				port: message.port,
-				process: child,
-				url: message.url,
-				watch: message.watch
-			});
-		}
-	});
-	send(child, {
-		options,
-		type: "start"
-	}, fail);
-});
-const startServerCoordinator = async (initialOptions) => {
-	let child;
-	let closed = false;
-	let closePromise;
-	let restartPromise;
-	let updateDuringRestart = false;
-	let startupAddress;
-	let watcher;
-	const adoptChild = (next) => {
-		child = next;
-		next.process.once("exit", () => {
-			if (child?.process === next.process) child = void 0;
-		});
-	};
-	const restart = () => {
-		if (closed || restartPromise) return restartPromise ?? Promise.resolve();
-		restartPromise = (async () => {
-			const previous = child;
-			child = void 0;
-			if (previous) await stopChild(previous.process);
-			if (closed || !startupAddress) return;
-			try {
-				const replacement = await startChild({
-					...initialOptions,
-					host: startupAddress.host,
-					port: startupAddress.port
-				}, () => void restart());
-				if (closed) {
-					await stopChild(replacement.process);
-					return;
-				}
-				adoptChild(replacement);
-				if (updateDuringRestart) {
-					updateDuringRestart = false;
-					send(replacement.process, { type: "update-available" });
-				}
-			} catch (cause) {
-				process.stderr.write(`[overmux] replacement child failed: ${errorMessage(cause)}\n`);
-			}
-		})().finally(() => {
-			const shouldRetry = updateDuringRestart && !child && !closed;
-			updateDuringRestart = false;
-			restartPromise = void 0;
-			if (shouldRetry) restart();
-		});
-		return restartPromise;
-	};
-	const onUpdate = () => {
-		if (closed) return;
-		if (restartPromise) {
-			updateDuringRestart = true;
-			return;
-		}
-		if (child) {
-			send(child.process, { type: "update-available" });
-			return;
-		}
-		restart();
-	};
-	const initial = await startChild(initialOptions, () => void restart());
-	startupAddress = {
-		host: initial.host,
-		port: initial.port
-	};
-	adoptChild(initial);
-	try {
-		if (initial.watch) watcher = startUpdateWatcher({
-			configPath: initialOptions.configPath,
-			onUpdate
-		});
-	} catch (cause) {
-		await stopChild(initial.process);
-		throw cause;
-	}
-	const close = () => {
-		if (closePromise) return closePromise;
-		closed = true;
-		closePromise = (async () => {
-			process.off("SIGINT", onSignal);
-			process.off("SIGTERM", onSignal);
-			watcher?.close();
-			const active = child;
-			child = void 0;
-			if (active) await stopChild(active.process);
-			await restartPromise;
-		})();
-		return closePromise;
-	};
-	const onSignal = () => {
-		close().catch((cause) => {
-			process.stderr.write(`[overmux] coordinator shutdown failed: ${errorMessage(cause)}\n`);
-		});
-	};
-	process.once("SIGINT", onSignal);
-	process.once("SIGTERM", onSignal);
-	return {
-		announceUpdateAvailable: onUpdate,
-		close,
-		port: initial.port,
-		url: initial.url
-	};
-};
-//#endregion
-//#region src/internal/server/start-overmux-server.ts
-const startOvermuxServer = async (options) => startServerCoordinator({
-	...options,
-	configPath: resolve(options.configPath)
-});
-//#endregion
-export { checkOvermux, getOvermuxPaths, startOvermuxServer };
+export { getOvermuxPaths };
 
 //# sourceMappingURL=server.js.map