overmux 0.0.1 → 0.0.3

package/dist/exports/client.js

@@ -0,0 +1,1665 @@
+import "./style.css";
+import { i as overmuxLogoutPath, r as notificationSchema, s as resolveOvermuxReturnTo } from "./notifications-kDp16bU_.js";
+import { z } from "zod";
+import { QueryClient, QueryClientProvider, useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { Component, createContext, createElement, useCallback, useContext, useEffect, useMemo, useReducer, useRef, useState } from "react";
+import { formatKeyBinding, formatKeyBinding as formatKeyBinding$1, keyBindingSchema, keyBindingSchema as keyBindingSchema$1, matchesKeyBinding, matchesKeyBinding as matchesKeyBinding$1, platformBinding } from "@overmux/keybindings";
+import { createPortal } from "react-dom";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+//#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();
+const backgroundNotificationPublicKeyResponseSchema = z.object({ publicKey: deliveryKeySchema }).strict();
+z.object({ endpoint: backgroundNotificationSubscriptionSchema.shape.endpoint }).strict();
+const webSocketCloseCode = {
+	authenticationRevoked: 4001,
+	authenticationUnavailable: 4002
+};
+const runtimeManifestSchema = z.object({
+	debug: z.boolean(),
+	operations: z.array(z.string().min(1)),
+	protocolVersion: z.literal(9),
+	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()
+});
+const clientProtocolMessageSchema = 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 serverProtocolMessageSchema = z.discriminatedUnion("type", [
+	resourceResultMessageSchema,
+	resourceInvalidatedMessageSchema,
+	streamOpenedMessageSchema,
+	streamOutputMessageSchema,
+	streamClosedMessageSchema,
+	protocolErrorMessageSchema,
+	updateAvailableEventSchema,
+	restartingEventSchema,
+	notificationEventSchema
+]);
+const byteMarker = "$overmuxBytes";
+const encodeValue = (value) => {
+	if (value instanceof Uint8Array) return { [byteMarker]: Array.from(value) };
+	if (Array.isArray(value)) return value.map(encodeValue);
+	if (typeof value === "object" && value !== null) return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, encodeValue(item)]));
+	return value;
+};
+const decodeValue = (value) => {
+	if (Array.isArray(value)) return value.map(decodeValue);
+	if (typeof value !== "object" || value === null) return value;
+	const record = value;
+	if (Object.keys(record).length === 1 && Array.isArray(record[byteMarker]) && record[byteMarker].every((item) => Number.isInteger(item) && item >= 0 && item <= 255)) return Uint8Array.from(record[byteMarker]);
+	return Object.fromEntries(Object.entries(record).map(([key, item]) => [key, decodeValue(item)]));
+};
+const binaryMarker = "$overmuxBinary";
+const binaryMagic = 1330468865;
+const decodeBinaryValue = (value, payload) => {
+	if (Array.isArray(value)) return value.map((item) => decodeBinaryValue(item, payload));
+	if (typeof value !== "object" || value === null) return value;
+	const record = value;
+	const marker = record[binaryMarker];
+	if (Object.keys(record).length === 1 && Array.isArray(marker) && marker.length === 2 && marker.every((item) => Number.isInteger(item) && item >= 0)) {
+		const [offset, length] = marker;
+		if (offset + length > payload.byteLength) throw new Error("Invalid Overmux binary payload range");
+		return payload.slice(offset, offset + length);
+	}
+	return Object.fromEntries(Object.entries(record).map(([key, item]) => [key, decodeBinaryValue(item, payload)]));
+};
+const encodeProtocolMessage = (message) => JSON.stringify(encodeValue(message));
+const decodeProtocolMessage = (message) => decodeValue(JSON.parse(message));
+const decodeProtocolFrame = (frame) => {
+	if (typeof frame === "string") return decodeProtocolMessage(frame);
+	const bytes = frame instanceof Uint8Array ? frame : new Uint8Array(frame, 0, frame.byteLength);
+	if (bytes.byteLength < 8) throw new Error("Invalid Overmux binary frame");
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	if (view.getUint32(0) !== binaryMagic) throw new Error("Invalid Overmux binary frame magic");
+	const headerLength = view.getUint32(4);
+	if (8 + headerLength > bytes.byteLength) throw new Error("Invalid Overmux binary frame header");
+	const header = JSON.parse(new TextDecoder().decode(bytes.subarray(8, 8 + headerLength)));
+	return decodeBinaryValue(header, bytes.subarray(8 + headerLength));
+};
+//#endregion
+//#region src/internal/client/background-notifications.ts
+const enabledStorageKey = "overmux.backgroundNotificationsEnabled";
+const isIos = () => /iPad|iPhone|iPod/u.test(navigator.userAgent) || navigator.platform === "MacIntel" && navigator.maxTouchPoints > 1;
+const isStandalone = () => window.matchMedia("(display-mode: standalone)").matches || Boolean(navigator.standalone);
+const supportStatus = () => {
+	if (window.overmuxHost?.notifications) return "unsupported";
+	if (isIos() && !isStandalone()) return "ios-home-screen";
+	if (!window.isSecureContext || !("Notification" in window) || !("serviceWorker" in navigator) || !("PushManager" in window)) return "unsupported";
+};
+const decodeApplicationServerKey = (value) => {
+	const padded = `${value}${"=".repeat((4 - value.length % 4) % 4)}`;
+	return Uint8Array.from(atob(padded.replaceAll("-", "+").replaceAll("_", "/")), (character) => character.charCodeAt(0));
+};
+const encodeApplicationServerKey = (value) => {
+	if (!value) return;
+	const binary = String.fromCharCode(...new Uint8Array(value));
+	return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/u, "");
+};
+const request = async (path, init) => {
+	const response = await fetch(path, {
+		cache: "no-store",
+		...init
+	});
+	if (!response.ok) throw new Error(`Background notification request failed: ${response.status}`);
+	return response;
+};
+const getPublicKey = async () => {
+	const response = await request("/api/background-notifications/public-key");
+	return backgroundNotificationPublicKeyResponseSchema.parse(await response.json()).publicKey;
+};
+const serializeSubscription = (subscription) => {
+	const json = subscription.toJSON();
+	return backgroundNotificationSubscriptionSchema.parse({
+		endpoint: subscription.endpoint,
+		expirationTime: subscription.expirationTime ?? null,
+		keys: json.keys
+	});
+};
+const enableSubscription = async (subscription) => {
+	await request("/api/background-notifications/subscription", {
+		body: JSON.stringify(serializeSubscription(subscription)),
+		headers: { "Content-Type": "application/json" },
+		method: "PUT"
+	});
+};
+const disableSubscription = async (subscription) => {
+	await request("/api/background-notifications/subscription", {
+		body: JSON.stringify({ endpoint: subscription.endpoint }),
+		headers: { "Content-Type": "application/json" },
+		method: "DELETE"
+	});
+};
+const subscribe = async (registration, publicKey) => registration.pushManager.subscribe({
+	applicationServerKey: decodeApplicationServerKey(publicKey),
+	userVisibleOnly: true
+});
+const canManageSubscription = () => window.isSecureContext && "serviceWorker" in navigator && "PushManager" in window;
+const removeCurrentSubscription = async () => {
+	if (!canManageSubscription()) return;
+	const subscription = await (await navigator.serviceWorker.getRegistration())?.pushManager.getSubscription();
+	if (!subscription) return;
+	await disableSubscription(subscription);
+	if (!await subscription.unsubscribe()) throw new Error("The background subscription could not be removed");
+};
+const reconcileBackgroundNotifications = async () => {
+	const registration = await navigator.serviceWorker.ready;
+	const publicKey = await getPublicKey();
+	let subscription = await registration.pushManager.getSubscription();
+	const subscriptionKey = subscription ? encodeApplicationServerKey(subscription.options.applicationServerKey) : void 0;
+	if (subscription && subscriptionKey !== publicKey) {
+		await disableSubscription(subscription);
+		if (!await subscription.unsubscribe()) throw new Error("The previous background subscription is still active");
+		subscription = null;
+	}
+	if (!subscription) subscription = await subscribe(registration, publicKey);
+	await enableSubscription(subscription);
+};
+const enableBackgroundNotifications = async () => {
+	if (supportStatus()) {
+		localStorage.removeItem(enabledStorageKey);
+		return false;
+	}
+	if ((Notification.permission === "default" ? await Notification.requestPermission() : Notification.permission) !== "granted") {
+		localStorage.removeItem(enabledStorageKey);
+		return false;
+	}
+	await reconcileBackgroundNotifications();
+	localStorage.setItem(enabledStorageKey, "true");
+	return true;
+};
+const disableBackgroundNotifications = async () => {
+	localStorage.removeItem(enabledStorageKey);
+	await removeCurrentSubscription();
+};
+const reconciledStatus = async () => {
+	const unavailable = supportStatus();
+	if (unavailable) {
+		await disableBackgroundNotifications().catch(() => void 0);
+		return unavailable;
+	}
+	if (Notification.permission !== "granted") {
+		await disableBackgroundNotifications().catch(() => void 0);
+		return Notification.permission === "denied" ? "denied" : "disabled";
+	}
+	if (localStorage.getItem(enabledStorageKey) !== "true") {
+		await disableBackgroundNotifications();
+		return "disabled";
+	}
+	await reconcileBackgroundNotifications();
+	return "enabled";
+};
+//#endregion
+//#region src/internal/client/clipboard.ts
+const readClipboardText = async () => {
+	if (!globalThis.navigator?.clipboard?.readText) throw new Error("Clipboard reading is unavailable in this browser context");
+	return navigator.clipboard.readText();
+};
+const writeClipboardText = async (text) => {
+	const desktopClipboard = globalThis.window?.overmuxHost?.clipboard;
+	if (desktopClipboard?.version === 1) {
+		desktopClipboard.writeText(text);
+		return;
+	}
+	if (!globalThis.navigator?.clipboard?.writeText) throw new Error("Clipboard writing is unavailable in this browser context");
+	await navigator.clipboard.writeText(text);
+};
+//#endregion
+//#region src/internal/client/client-definition.ts
+const shortcutBindingSchema = z.union([keyBindingSchema$1, z.array(keyBindingSchema$1).min(2)]);
+const commandBindingSchema = z.union([shortcutBindingSchema, z.object({
+	binding: shortcutBindingSchema,
+	when: z.object({ media: z.string().trim().min(1) })
+})]);
+const chordPrefixSchema = z.object({
+	binding: keyBindingSchema$1,
+	unmatched: z.literal("replay-to-focused-input")
+});
+const formatShortcutBinding = (binding) => typeof binding === "string" ? formatKeyBinding$1(binding) : binding.map(formatKeyBinding$1).join(" ");
+const validateBindings = (bindings) => bindings?.forEach((binding) => commandBindingSchema.parse(binding));
+const defineCommandRegistry = () => (commands) => Object.fromEntries(Object.entries(commands).map(([id, command]) => {
+	validateBindings(command.defaultBindings);
+	return [id, {
+		...command,
+		id
+	}];
+}));
+const defineOvermuxClient = (definition) => {
+	definition.chordPrefixes?.forEach((prefix) => chordPrefixSchema.parse(prefix));
+	Object.values(definition.shortcutOverrides ?? {}).forEach(validateBindings);
+	return definition;
+};
+const isConditionalShortcutBinding = (binding) => typeof binding !== "string" && !Array.isArray(binding);
+const resolveShortcutBinding = (binding) => isConditionalShortcutBinding(binding) ? binding.binding : binding;
+const configuredCommandBindings = (definition, command) => definition.shortcutOverrides?.[command.id] ?? command.defaultBindings ?? [];
+const activeCommandBindings = (bindings, matchesMedia) => bindings.flatMap((binding) => !isConditionalShortcutBinding(binding) || matchesMedia(binding.when.media) ? [resolveShortcutBinding(binding)] : []);
+const shortcutMediaQueries = (definition) => [...new Set(Object.values(definition.commands).flatMap((command) => configuredCommandBindings(definition, command).flatMap((binding) => isConditionalShortcutBinding(binding) ? [binding.when.media] : [])))];
+//#endregion
+//#region src/internal/client/commands.tsx
+const skipToken = Symbol("overmux command registration");
+const RuntimeContext = createContext(void 0);
+const useRuntime = () => {
+	const runtime = useContext(RuntimeContext);
+	if (!runtime) throw new Error("Overmux hooks must be used inside an active Overmux client runtime");
+	return runtime;
+};
+const executeRegistration = async (command, registration, overmuxServerApi) => {
+	const params = command.params ? command.params.parse(registration.params) : void 0;
+	if (registration.run) {
+		await registration.run();
+		return;
+	}
+	if (typeof command.run !== "function") throw new Error(`Command has no implementation: ${command.id}`);
+	await command.run({
+		overmuxServerApi,
+		params
+	});
+};
+const createRegisteredCommand = ({ command, getRegistration, overmuxServerApi }) => ({
+	command,
+	element: () => {
+		const registration = getRegistration();
+		return registration === skipToken ? void 0 : registration.element?.current;
+	},
+	enabled: () => {
+		const registration = getRegistration();
+		return registration === skipToken ? false : registration.enabled ?? true;
+	},
+	execute: () => {
+		const registration = getRegistration();
+		return registration === skipToken ? Promise.resolve() : executeRegistration(command, registration, overmuxServerApi);
+	}
+});
+const useCommand = (command, registration) => {
+	const { overmuxServerApi, refreshCommands, registerCommand } = useRuntime();
+	const registrationRef = useRef(registration);
+	registrationRef.current = registration;
+	const skipped = registration === skipToken;
+	useEffect(() => {
+		if (skipped) return;
+		return registerCommand(createRegisteredCommand({
+			command,
+			getRegistration: () => registrationRef.current,
+			overmuxServerApi
+		}));
+	}, [
+		command,
+		overmuxServerApi,
+		registerCommand,
+		skipped
+	]);
+	const enabled = skipped ? false : registration.enabled ?? true;
+	useEffect(refreshCommands, [
+		skipped ? void 0 : registration.element,
+		enabled,
+		refreshCommands,
+		skipped
+	]);
+};
+const elementDepth$1 = (element) => {
+	let depth = 0;
+	for (let current = element; current; current = current.parentElement) depth += 1;
+	return depth;
+};
+const selectCommandRegistration = (command, registrations, activeElement) => {
+	const candidates = [...registrations].filter((registration) => registration.command === command);
+	return candidates.filter((registration) => {
+		const element = registration.element();
+		return Boolean(element && activeElement && element.contains(activeElement));
+	}).reduce((selected, candidate) => {
+		const selectedElement = selected?.element();
+		const candidateElement = candidate.element();
+		if (!selectedElement || !candidateElement) return candidate;
+		return elementDepth$1(candidateElement) >= elementDepth$1(selectedElement) ? candidate : selected;
+	}, void 0) ?? candidates.at(-1);
+};
+const currentActiveElement = () => document.activeElement;
+const selectedRegistration = (command, registrations, getActiveElement = currentActiveElement) => selectCommandRegistration(command, registrations, getActiveElement());
+const executeCommand = async (command, registrations, getActiveElement = currentActiveElement) => {
+	const selected = selectedRegistration(command, registrations, getActiveElement);
+	if (selected?.enabled()) await selected.execute();
+};
+const createCommandEntries = (definition, registrations, getActiveElement = currentActiveElement, matchesMedia = (media) => typeof window !== "undefined" && window.matchMedia(media).matches) => Object.values(definition.commands).flatMap((command) => {
+	const selected = selectedRegistration(command, registrations, getActiveElement);
+	return selected ? [{
+		bindings: activeCommandBindings(configuredCommandBindings(definition, command), matchesMedia),
+		enabled: selected.enabled(),
+		execute: () => executeCommand(command, registrations, getActiveElement),
+		id: command.id,
+		title: command.title
+	}] : [];
+});
+const CommandsContext = createContext([]);
+const useCommands = () => useContext(CommandsContext);
+//#endregion
+//#region src/internal/client/overmux-react.ts
+const inputKey = (input) => JSON.stringify(input) ?? "";
+const useCanonicalInput = (input) => {
+	const key = inputKey(input);
+	return useMemo(() => key ? JSON.parse(key) : void 0, [key]);
+};
+const useResourceById = (id, input, skipped) => {
+	const { manifest, overmuxServerApi } = useRuntime();
+	const queryClient = useQueryClient();
+	const canonicalInput = useCanonicalInput(input);
+	const queryKey = useMemo(() => [id, canonicalInput], [canonicalInput, id]);
+	const query = useQuery({
+		enabled: !skipped,
+		queryFn: () => overmuxServerApi.readResource({
+			id,
+			input: canonicalInput
+		}),
+		queryKey
+	});
+	useEffect(() => !skipped && manifest.resources.includes(id) ? overmuxServerApi.subscribeResource({
+		id,
+		input: canonicalInput,
+		onError: () => void queryClient.invalidateQueries({
+			exact: true,
+			queryKey
+		}),
+		onInvalidate: () => void queryClient.invalidateQueries({
+			exact: true,
+			queryKey
+		})
+	}) : void 0, [
+		manifest.resources,
+		canonicalInput,
+		id,
+		overmuxServerApi,
+		queryClient,
+		queryKey,
+		skipped
+	]);
+	const refetch = useCallback(() => {
+		queryClient.invalidateQueries({
+			exact: true,
+			queryKey
+		});
+	}, [queryClient, queryKey]);
+	if (skipped) return;
+	if (query.status === "pending") return {
+		refetch,
+		status: "pending"
+	};
+	if (query.status === "error") return query.data === void 0 ? {
+		error: query.error,
+		refetch,
+		status: "error"
+	} : {
+		data: query.data,
+		error: query.error,
+		refetch,
+		status: "error"
+	};
+	return {
+		data: query.data,
+		refetch,
+		status: "success"
+	};
+};
+const useOperationById = (id, signal) => {
+	const { overmuxServerApi } = useRuntime();
+	return useMutation({ mutationFn: (input) => overmuxServerApi.executeOperation(id, input, signal) });
+};
+const useStreamById = (id, input) => {
+	const { manifest, overmuxServerApi } = useRuntime();
+	const streamAvailable = manifest.streams.includes(id);
+	const [state, setState] = useState({ status: "opening" });
+	const listeners = useMemo(() => /* @__PURE__ */ new Set(), []);
+	const canonicalInput = useCanonicalInput(input);
+	const streamRef = useRef(void 0);
+	useEffect(() => {
+		streamRef.current?.close();
+		streamRef.current = void 0;
+		if (!streamAvailable) {
+			setState({ status: "closed" });
+			return;
+		}
+		setState({ status: "opening" });
+		const stream = overmuxServerApi.openStream({
+			id,
+			input: canonicalInput,
+			onClose: () => setState({ status: "closed" }),
+			onError: (error) => setState({
+				error,
+				status: "closed"
+			}),
+			onOpen: () => setState({ status: "open" }),
+			onMessage: (message) => listeners.forEach((listener) => listener(message))
+		});
+		streamRef.current = stream;
+		return () => {
+			stream.close();
+			if (streamRef.current === stream) streamRef.current = void 0;
+		};
+	}, [
+		canonicalInput,
+		id,
+		listeners,
+		overmuxServerApi,
+		streamAvailable
+	]);
+	const close = useCallback(() => {
+		streamRef.current?.close();
+		streamRef.current = void 0;
+		setState({ status: "closed" });
+	}, []);
+	const send = useCallback((message) => streamRef.current?.send(message) ?? false, []);
+	const subscribe = useCallback((listener) => {
+		listeners.add(listener);
+		return () => listeners.delete(listener);
+	}, [listeners]);
+	return {
+		close,
+		error: streamAvailable ? state.error : /* @__PURE__ */ new Error(`Stream is not available: ${id}`),
+		send,
+		status: streamAvailable ? state.status : "closed",
+		subscribe
+	};
+};
+const createOvermuxHooks = () => ({
+	useOperation: ({ id, signal }) => {
+		return useOperationById(id, signal);
+	},
+	useResource: (({ id, input }) => useResourceById(id, input, input === skipToken)),
+	useStream: ({ id, input }) => useStreamById(id, input)
+});
+//#endregion
+//#region src/internal/client/theme-scope.tsx
+const PortalRootContext = createContext(void 0);
+const useOvermuxPortalContainer = (external) => {
+	const scopeRoot = useContext(PortalRootContext);
+	if (external) return external.container;
+	if (scopeRoot !== void 0) return scopeRoot;
+	return typeof document === "undefined" ? null : document.body;
+};
+const OvermuxPortal = ({ children, external }) => {
+	const container = useOvermuxPortalContainer(external);
+	return container ? createPortal(children, container) : null;
+};
+const OvermuxThemeScope = ({ children, className, contrast = "auto", scheme = "system", style }) => {
+	const [portalRoot, setPortalRoot] = useState(null);
+	const capturePortalRoot = useCallback((element) => {
+		setPortalRoot(element);
+	}, []);
+	return /* @__PURE__ */ jsxs("div", {
+		className,
+		"data-om-contrast": contrast,
+		"data-om-scheme": scheme,
+		"data-om-scope": "",
+		style,
+		children: [/* @__PURE__ */ jsx(PortalRootContext.Provider, {
+			value: portalRoot,
+			children
+		}), /* @__PURE__ */ jsx("div", {
+			"data-om-overlay-root": "",
+			ref: capturePortalRoot
+		})]
+	});
+};
+//#endregion
+//#region src/internal/client/browser-api.ts
+const availableName = (names, kind, name) => {
+	if (!names.includes(name)) throw new Error(`${kind} is not available: ${name}`);
+	return name;
+};
+const createOvermuxServerApi = ({ manifest, transport }) => ({
+	executeOperation: (id, input, signal) => {
+		if (!manifest.operations.includes(id)) throw new Error(`Operation is not available: ${id}`);
+		return transport.invokeOperation({
+			input,
+			name: id,
+			signal
+		});
+	},
+	openStream: ({ id, ...input }) => transport.openStream({
+		...input,
+		streamName: availableName(manifest.streams, "Stream", id)
+	}),
+	readResource: ({ id, input }) => transport.readResource({
+		input,
+		resourceName: availableName(manifest.resources, "Resource", id)
+	}),
+	subscribeResource: ({ id, ...input }) => transport.subscribeResource({
+		...input,
+		resourceName: availableName(manifest.resources, "Resource", id)
+	})
+});
+//#endregion
+//#region src/internal/client/host/browser-log-forwarding.ts
+const maxStringLength = 2e3;
+const truncate = (value, length = maxStringLength) => value.length <= length ? value : `${value.slice(0, length)}…[truncated]`;
+const serializeValue = (value, seen, depth = 0) => {
+	if (typeof value === "string") return truncate(value);
+	if (value === null || typeof value === "boolean" || typeof value === "number") return value;
+	if (typeof value === "bigint") return `${value}n`;
+	if (typeof value === "undefined" || typeof value === "symbol") return String(value);
+	if (typeof value === "function") return `[Function ${value.name || "anonymous"}]`;
+	if (depth >= 4) return "[Max depth]";
+	if (typeof value !== "object") return truncate(String(value));
+	if (seen.has(value)) return "[Circular]";
+	seen.add(value);
+	if (value instanceof Error) return {
+		message: truncate(value.message),
+		name: value.name,
+		...value.stack ? { stack: truncate(value.stack, 8e3) } : {}
+	};
+	if (Array.isArray(value)) return value.slice(0, 25).map((item) => serializeValue(item, seen, depth + 1));
+	try {
+		return Object.fromEntries(Object.entries(value).slice(0, 25).map(([key, item]) => [key, serializeValue(item, seen, depth + 1)]));
+	} catch {
+		return `[Unserializable ${Object.prototype.toString.call(value)}]`;
+	}
+};
+const serializeBrowserLogArguments = (values) => {
+	const seen = /* @__PURE__ */ new WeakSet();
+	const serialized = values.map((value) => serializeValue(value, seen));
+	const json = JSON.stringify(serialized);
+	return truncate(json, 16e3);
+};
+const diagnosticUrl = () => {
+	try {
+		return `${location.origin}${location.pathname}`;
+	} catch {
+		return;
+	}
+};
+const stackOf = (values) => {
+	const error = values.find((value) => value instanceof Error);
+	return error instanceof Error && error.stack ? truncate(error.stack, 8e3) : void 0;
+};
+const installBrowserLogForwarding = (report) => {
+	const methods = [
+		"log",
+		"info",
+		"warn",
+		"error",
+		"debug"
+	];
+	const originals = Object.fromEntries(methods.map((level) => [level, console[level].bind(console)]));
+	let reporting = false;
+	const emit = (level, values, stack) => {
+		if (reporting) return;
+		reporting = true;
+		try {
+			const serializedArguments = serializeBrowserLogArguments(values);
+			report({
+				arguments: serializedArguments,
+				level,
+				message: truncate(values.map((value) => typeof value === "string" ? value : serializedArguments).join(" "), 4e3),
+				...stack ? { stack: truncate(stack, 8e3) } : {},
+				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+				type: "client-diagnostic",
+				...diagnosticUrl() ? { url: diagnosticUrl() } : {}
+			});
+		} finally {
+			reporting = false;
+		}
+	};
+	methods.forEach((level) => {
+		console[level] = (...values) => {
+			originals[level](...values);
+			emit(level, values, stackOf(values));
+		};
+	});
+	const onError = (event) => emit("error", [event.message], event.error?.stack);
+	const onRejection = (event) => emit("error", ["Unhandled rejection", event.reason], stackOf([event.reason]));
+	window.addEventListener("error", onError);
+	window.addEventListener("unhandledrejection", onRejection);
+	return () => {
+		methods.forEach((level) => {
+			console[level] = originals[level];
+		});
+		window.removeEventListener("error", onError);
+		window.removeEventListener("unhandledrejection", onRejection);
+	};
+};
+//#endregion
+//#region src/internal/client/host/notification-forwarding.ts
+const installNotificationForwarding = (transport) => transport.subscribeNotification((event) => {
+	const notification = notificationEventSchema.safeParse(event);
+	if (notification.success) window.overmuxHost?.notifications?.show(notification.data);
+});
+//#endregion
+//#region src/internal/client/shortcuts.tsx
+const bindingSequence = (binding) => typeof binding === "string" ? [binding] : [...binding];
+const normalizedBinding = (binding) => bindingSequence(binding).map((key) => platformBinding(key));
+const sequenceMatches = (binding, pending, event) => {
+	const sequence = normalizedBinding(binding);
+	return sequence.length > pending.length && pending.every((key, index) => sequence[index] === key) && matchesKeyBinding$1(sequence[pending.length], event);
+};
+const isTextInput = (element) => element instanceof HTMLInputElement || element instanceof HTMLSelectElement || element instanceof HTMLTextAreaElement || element instanceof HTMLElement && (element.isContentEditable || element.getAttribute("role") === "textbox");
+const acceptsTextInput = (bindings) => {
+	if (!(document.activeElement instanceof Element)) return false;
+	const terminal = document.activeElement.closest(".xterm");
+	if (!terminal) return false;
+	if (terminal.closest("[data-copy-mode]")) return true;
+	return bindings.some((binding) => {
+		const sequence = bindingSequence(binding);
+		return sequence.length > 1 || sequence[0]?.startsWith("F") || sequence[0]?.includes("+");
+	});
+};
+const flattenShortcuts = (definition, matchesMedia) => Object.values(definition.commands).flatMap((command) => {
+	const bindings = activeCommandBindings(configuredCommandBindings(definition, command), matchesMedia);
+	return bindings.length ? [{
+		bindings,
+		command
+	}] : [];
+});
+const canRunShortcut = (shortcut, event, registrations) => {
+	const selected = selectCommandRegistration(shortcut.command, registrations, document.activeElement);
+	return Boolean(selected?.enabled() && !event.repeat && !(isTextInput(document.activeElement) && !acceptsTextInput(shortcut.bindings)));
+};
+const runShortcut = (shortcut, event, registrations) => {
+	if (!canRunShortcut(shortcut, event, registrations)) return false;
+	executeCommand(shortcut.command, registrations);
+	event.preventDefault();
+	return true;
+};
+const ShortcutInputTargetsContext = createContext(void 0);
+const useShortcutInputTarget = (target) => {
+	const register = useContext(ShortcutInputTargetsContext);
+	const { container, input } = target;
+	useEffect(() => register?.({
+		container,
+		input
+	}), [
+		container,
+		input,
+		register
+	]);
+};
+const elementDepth = (element) => {
+	let depth = 0;
+	for (let current = element; current; current = current.parentElement) depth += 1;
+	return depth;
+};
+const selectShortcutInputTarget = (targets, activeElement) => [...targets].filter((target) => {
+	const container = target.container.current;
+	return Boolean(container && activeElement && container.contains(activeElement));
+}).reduce((selected, candidate) => {
+	const selectedElement = selected?.container.current;
+	const candidateElement = candidate.container.current;
+	if (!selectedElement || !candidateElement) return candidate;
+	return elementDepth(candidateElement) >= elementDepth(selectedElement) ? candidate : selected;
+}, void 0);
+const replayedKeyboardEvents = /* @__PURE__ */ new WeakSet();
+const keyboardEventProperties = [
+	"charCode",
+	"keyCode",
+	"which"
+];
+const replayKeyboardEvent = (target, source) => {
+	const replay = new KeyboardEvent(source.type, {
+		altKey: source.altKey,
+		bubbles: true,
+		cancelable: true,
+		code: source.code,
+		composed: true,
+		ctrlKey: source.ctrlKey,
+		key: source.key,
+		location: source.location,
+		metaKey: source.metaKey,
+		repeat: source.repeat,
+		shiftKey: source.shiftKey
+	});
+	keyboardEventProperties.forEach((property) => Object.defineProperty(replay, property, { value: source[property] }));
+	replayedKeyboardEvents.add(replay);
+	target.dispatchEvent(replay);
+};
+const replayChord = (target, events) => {
+	const input = target?.input.current;
+	if (!input) return;
+	events.forEach((event) => replayKeyboardEvent(input, event));
+};
+const ShortcutHost = ({ children, definition, registrations, registrationRevision }) => {
+	const [, setFocusRevision] = useState(0);
+	const [inputTargets] = useState(() => /* @__PURE__ */ new Set());
+	const [mediaRevision, setMediaRevision] = useState(0);
+	const registerInputTarget = useCallback((target) => {
+		inputTargets.add(target);
+		return () => {
+			inputTargets.delete(target);
+		};
+	}, [inputTargets]);
+	useEffect(() => {
+		const refreshMedia = () => setMediaRevision((revision) => revision + 1);
+		const queries = shortcutMediaQueries(definition).map((media) => window.matchMedia(media));
+		queries.forEach((query) => query.addEventListener("change", refreshMedia));
+		return () => queries.forEach((query) => query.removeEventListener("change", refreshMedia));
+	}, [definition]);
+	useEffect(() => {
+		const refreshFocus = () => setFocusRevision((revision) => revision + 1);
+		window.addEventListener("focusin", refreshFocus);
+		return () => window.removeEventListener("focusin", refreshFocus);
+	}, []);
+	useEffect(() => {
+		const shortcuts = flattenShortcuts(definition, (media) => window.matchMedia(media).matches);
+		let pending = [];
+		let pendingEvents = [];
+		let pendingTarget;
+		let timeout;
+		const clearPending = () => {
+			pending = [];
+			pendingEvents = [];
+			pendingTarget = void 0;
+			if (timeout !== void 0) {
+				window.clearTimeout(timeout);
+				timeout = void 0;
+			}
+		};
+		const replayPending = (events = pendingEvents) => {
+			replayChord(pendingTarget, events);
+			clearPending();
+		};
+		const scheduleTimeout = () => {
+			if (timeout !== void 0) window.clearTimeout(timeout);
+			timeout = window.setTimeout(() => replayPending(), 1e3);
+		};
+		const onKeyDown = (event) => {
+			if (replayedKeyboardEvents.has(event)) return;
+			if (pending.length && event.key === "Escape") {
+				event.preventDefault();
+				event.stopPropagation();
+				clearPending();
+				return;
+			}
+			const matches = shortcuts.flatMap((shortcut) => shortcut.bindings.filter((binding) => sequenceMatches(binding, pending, event) && canRunShortcut(shortcut, event, registrations)).map((binding) => ({
+				binding,
+				shortcut
+			})));
+			if (!matches.length) {
+				if (pending.length) {
+					event.preventDefault();
+					event.stopPropagation();
+					replayPending([...pendingEvents, event]);
+				}
+				return;
+			}
+			const complete = matches.find(({ binding }) => normalizedBinding(binding).length === pending.length + 1);
+			if (complete) {
+				clearPending();
+				if (runShortcut(complete.shortcut, event, registrations)) event.stopPropagation();
+				return;
+			}
+			if (!pending.length) pendingTarget = definition.chordPrefixes?.some((prefix) => matchesKeyBinding$1(prefix.binding, event)) ? selectShortcutInputTarget(inputTargets, document.activeElement) : void 0;
+			pending = [...pending, normalizedBinding(matches[0].binding)[pending.length]];
+			pendingEvents = [...pendingEvents, event];
+			event.preventDefault();
+			event.stopPropagation();
+			scheduleTimeout();
+		};
+		window.addEventListener("keydown", onKeyDown, { capture: true });
+		return () => {
+			window.removeEventListener("keydown", onKeyDown, { capture: true });
+			if (timeout !== void 0) window.clearTimeout(timeout);
+		};
+	}, [
+		definition,
+		inputTargets,
+		mediaRevision,
+		registrationRevision,
+		registrations
+	]);
+	const commands = createCommandEntries(definition, registrations, () => document.activeElement, (media) => window.matchMedia(media).matches);
+	return /* @__PURE__ */ jsx(ShortcutInputTargetsContext.Provider, {
+		value: registerInputTarget,
+		children: /* @__PURE__ */ jsx(CommandsContext.Provider, {
+			value: commands,
+			children
+		})
+	});
+};
+//#endregion
+//#region src/internal/client/websocket.ts
+const maxWebSocketBufferedBytes = 1048576;
+const socketUrl = () => `${location.protocol === "https:" ? "wss:" : "ws:"}//${location.host}/api/socket`;
+const operationId = () => {
+	const randomUUID = crypto.randomUUID?.();
+	if (randomUUID) return randomUUID;
+	const bytes = crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(16));
+	bytes[6] = bytes[6] & 15 | 64;
+	bytes[8] = bytes[8] & 63 | 128;
+	const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+};
+const disconnected = () => /* @__PURE__ */ new Error("Overmux transport disconnected.");
+const createWebSocketTransport = ({ createSocket = () => new WebSocket(socketUrl()) } = {}) => {
+	let active = false;
+	let disposed = false;
+	let reconnectDelay = 250;
+	let reconnectTimer;
+	let socket;
+	let status = "disconnected";
+	const diagnosticQueue = [];
+	const requests = /* @__PURE__ */ new Map();
+	const subscriptions = /* @__PURE__ */ new Map();
+	const streams = /* @__PURE__ */ new Map();
+	const lifecycleListeners = /* @__PURE__ */ new Set();
+	const notificationListeners = /* @__PURE__ */ new Set();
+	const statusListeners = /* @__PURE__ */ new Set();
+	const setStatus = (next) => {
+		if (status === next) return;
+		status = next;
+		statusListeners.forEach((listener) => listener(status));
+	};
+	const send = (message) => {
+		if (socket?.readyState !== WebSocket.OPEN) return false;
+		if (socket.bufferedAmount > maxWebSocketBufferedBytes) {
+			socket.close(1013, "client could not keep up");
+			return false;
+		}
+		socket.send(encodeProtocolMessage(clientProtocolMessageSchema.parse(message)));
+		return true;
+	};
+	const flushDiagnostics = () => {
+		const unsent = diagnosticQueue.filter((event) => !send(event));
+		diagnosticQueue.splice(0, diagnosticQueue.length, ...unsent);
+	};
+	const request = ({ input, resourceName }) => new Promise((resolve, reject) => {
+		const id = operationId();
+		requests.set(id, {
+			reject,
+			resolve
+		});
+		if (!send({
+			input,
+			operationId: id,
+			resourceName,
+			type: "resource-read"
+		})) {
+			requests.delete(id);
+			reject(disconnected());
+		}
+	});
+	const restore = () => {
+		subscriptions.forEach(({ input, onInvalidate, resourceName }, subscriptionId) => {
+			if (send({
+				input,
+				operationId: subscriptionId,
+				resourceName,
+				subscriptionId,
+				type: "resource-subscribe"
+			})) onInvalidate();
+		});
+		streams.forEach((stream, streamId) => {
+			if (stream.status === "failed") return;
+			stream.status = send({
+				input: stream.input,
+				operationId: streamId,
+				streamId,
+				streamName: stream.streamName,
+				type: "stream-open"
+			}) ? "opening" : "disconnected";
+		});
+	};
+	const rejectRequests = (error) => {
+		requests.forEach(({ reject }) => reject(error));
+		requests.clear();
+	};
+	const reportDisconnect = () => {
+		const error = disconnected();
+		rejectRequests(error);
+		subscriptions.forEach(({ onError }) => onError(error));
+		streams.forEach((stream) => {
+			stream.pendingMessages.length = 0;
+			if (stream.status !== "failed") stream.status = "disconnected";
+			stream.onError(error);
+		});
+	};
+	const connect = () => {
+		if (!active || disposed || socket) return;
+		setStatus("connecting");
+		const next = createSocket();
+		next.binaryType = "arraybuffer";
+		socket = next;
+		next.addEventListener("open", () => {
+			if (socket !== next) return;
+			reconnectDelay = 250;
+			setStatus("connected");
+			flushDiagnostics();
+			restore();
+		});
+		next.addEventListener("message", (event) => {
+			if (socket !== next) return;
+			let decoded;
+			try {
+				decoded = decodeProtocolFrame(event.data);
+			} catch (cause) {
+				reportDisconnect();
+				console.error("Invalid Overmux transport message", cause);
+				next.close(1002, "invalid protocol message");
+				return;
+			}
+			const parsed = serverProtocolMessageSchema.safeParse(decoded);
+			if (!parsed.success) {
+				reportDisconnect();
+				console.error("Invalid Overmux transport message", parsed.error);
+				next.close(1002, "invalid protocol message");
+				return;
+			}
+			const message = parsed.data;
+			if (message.type === "update-available" || message.type === "restarting") lifecycleListeners.forEach((listener) => listener(message));
+			if (message.type === "notification") notificationListeners.forEach((listener) => listener(message));
+			if (message.type === "resource-invalidated") subscriptions.get(message.subscriptionId)?.onInvalidate();
+			if (message.type === "stream-opened") {
+				const stream = streams.get(message.streamId);
+				if (stream?.status === "opening") {
+					stream.status = "open";
+					if (stream.pendingMessages.splice(0).every(send)) stream.onOpen();
+				}
+			}
+			if (message.type === "stream-output") streams.get(message.streamId)?.onMessage(message.message);
+			if (message.type === "stream-closed") {
+				const stream = streams.get(message.streamId);
+				if (stream) {
+					stream.pendingMessages.length = 0;
+					stream.onClose();
+					streams.delete(message.streamId);
+				}
+			}
+			if (message.type === "error") {
+				if (message.operationId) requests.get(message.operationId)?.reject(new Error(message.message));
+				const stream = streams.get(message.operationId ?? "");
+				if (stream) {
+					stream.pendingMessages.length = 0;
+					stream.status = "failed";
+					stream.onError(new Error(message.message));
+				}
+				subscriptions.get(message.operationId ?? "")?.onError(new Error(message.message));
+				requests.delete(message.operationId ?? "");
+			}
+			if (message.type === "resource-result") {
+				requests.get(message.operationId)?.resolve(message.output);
+				requests.delete(message.operationId);
+			}
+		});
+		next.addEventListener("close", (event) => {
+			if (socket !== next || disposed) return;
+			socket = void 0;
+			reportDisconnect();
+			if (event.code === webSocketCloseCode.authenticationRevoked) {
+				active = false;
+				setStatus("authentication-required");
+				return;
+			}
+			setStatus("disconnected");
+			reconnectTimer = setTimeout(() => {
+				reconnectTimer = void 0;
+				connect();
+			}, reconnectDelay);
+			reconnectDelay = Math.min(reconnectDelay * 2, 5e3);
+		});
+	};
+	return {
+		activate: () => {
+			active = true;
+			connect();
+		},
+		dispose: () => {
+			disposed = true;
+			if (reconnectTimer !== void 0) clearTimeout(reconnectTimer);
+			reportDisconnect();
+			streams.forEach(({ onClose }) => onClose());
+			streams.clear();
+			subscriptions.clear();
+			socket?.close();
+		},
+		openStream: ({ input, onClose, onError, onMessage, onOpen, streamName }) => {
+			if (!active || disposed) {
+				onError(disconnected());
+				return {
+					close: () => {},
+					send: () => false
+				};
+			}
+			const streamId = operationId();
+			const stream = {
+				input,
+				onClose,
+				onError,
+				onMessage,
+				onOpen,
+				pendingMessages: [],
+				status: "disconnected",
+				streamName
+			};
+			streams.set(streamId, stream);
+			stream.status = socket?.readyState === WebSocket.CONNECTING || send({
+				input,
+				operationId: streamId,
+				streamId,
+				streamName,
+				type: "stream-open"
+			}) ? "opening" : "disconnected";
+			if (stream.status === "disconnected") onError(disconnected());
+			return {
+				close: () => {
+					const activeStream = streams.get(streamId);
+					if (activeStream) {
+						activeStream.pendingMessages.length = 0;
+						activeStream.onClose();
+						streams.delete(streamId);
+					}
+					send({
+						streamId,
+						type: "stream-close"
+					});
+				},
+				send: (message) => {
+					const activeStream = streams.get(streamId);
+					if (activeStream?.status !== "open" && activeStream?.status !== "opening") return false;
+					const protocolMessage = streamMessageSchema.parse({
+						message,
+						streamId,
+						type: "stream-message"
+					});
+					if (activeStream.status === "opening") {
+						activeStream.pendingMessages.push(protocolMessage);
+						return true;
+					}
+					return send(protocolMessage);
+				}
+			};
+		},
+		readResource: (input) => request(input),
+		reportDiagnostic: (event) => {
+			if (send(event)) return;
+			diagnosticQueue.push(event);
+			if (diagnosticQueue.length > 100) diagnosticQueue.shift();
+		},
+		subscribeResource: ({ input, onError, onInvalidate, resourceName }) => {
+			const subscriptionId = operationId();
+			subscriptions.set(subscriptionId, {
+				input,
+				onError,
+				onInvalidate,
+				resourceName
+			});
+			if (!send({
+				input,
+				operationId: subscriptionId,
+				resourceName,
+				subscriptionId,
+				type: "resource-subscribe"
+			})) onError(disconnected());
+			return () => {
+				subscriptions.delete(subscriptionId);
+				send({
+					subscriptionId,
+					type: "resource-unsubscribe"
+				});
+			};
+		},
+		subscribeStatus: (listener) => {
+			statusListeners.add(listener);
+			listener(status);
+			return () => statusListeners.delete(listener);
+		},
+		subscribeLifecycle: (listener) => {
+			lifecycleListeners.add(listener);
+			return () => lifecycleListeners.delete(listener);
+		},
+		subscribeNotification: (listener) => {
+			notificationListeners.add(listener);
+			return () => notificationListeners.delete(listener);
+		}
+	};
+};
+//#endregion
+//#region src/internal/client/transport.ts
+const TransportContext = createContext(void 0);
+const operationError = async (response) => {
+	const body = await response.text();
+	try {
+		const error = JSON.parse(body).error;
+		if (typeof error === "string") return new Error(error);
+	} catch {}
+	return /* @__PURE__ */ new Error(`Operation request failed: ${response.status} ${response.statusText}`);
+};
+const createClientTransport = ({ createSocket, fetch: fetchRequest = globalThis.fetch } = {}) => ({
+	...createWebSocketTransport({ createSocket }),
+	invokeOperation: async ({ input, name, signal }) => {
+		const response = await fetchRequest(`/api/operations/${encodeURIComponent(name)}`, {
+			body: input === void 0 ? void 0 : JSON.stringify(input),
+			headers: { "content-type": "application/json" },
+			method: "POST",
+			signal
+		});
+		if (!response.ok) throw await operationError(response);
+		return response.status === 204 ? void 0 : response.json();
+	}
+});
+//#endregion
+//#region src/internal/client/host/hosted-pages/hosted-page.tsx
+const HostedPage = ({ children }) => /* @__PURE__ */ jsx("main", {
+	"data-om-hosted-page": "",
+	children: /* @__PURE__ */ jsx("article", {
+		"data-om-hosted-panel": "",
+		children
+	})
+});
+//#endregion
+//#region src/internal/client/host/hosted-pages/logout-page.tsx
+const logoutRequests = /* @__PURE__ */ new WeakMap();
+const minimumLogoutDuration = 3e3;
+const requestLogout = () => {
+	const existing = logoutRequests.get(document);
+	if (existing) return existing;
+	const request = fetch("/api/auth/logout", { method: "POST" }).then((response) => {
+		if (!response.ok) throw new Error(`Logout failed: ${response.status}`);
+	});
+	logoutRequests.set(document, request);
+	return request;
+};
+const minimumDelay = () => new Promise((resolve) => setTimeout(resolve, minimumLogoutDuration));
+const HostedLogoutPage = () => {
+	const [attempt, setAttempt] = useState(0);
+	const [error, setError] = useState(false);
+	useEffect(() => {
+		let active = true;
+		setError(false);
+		Promise.allSettled([requestLogout(), minimumDelay()]).then(([logout]) => {
+			if (!active) return;
+			if (logout?.status === "fulfilled") {
+				location.replace("/login");
+				return;
+			}
+			setError(true);
+		});
+		return () => {
+			active = false;
+		};
+	}, [attempt]);
+	return /* @__PURE__ */ jsxs(HostedPage, { children: [/* @__PURE__ */ jsx("h1", { children: error ? "Log out failed" : "Logging out…" }), error ? /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("p", {
+		role: "alert",
+		children: "Overmux could not log you out. Check your connection and try again."
+	}), /* @__PURE__ */ jsx("button", {
+		"data-om-hosted-retry": "",
+		onClick: () => {
+			logoutRequests.delete(document);
+			setAttempt((current) => current + 1);
+		},
+		type: "button",
+		children: "Retry"
+	})] }) : /* @__PURE__ */ jsx("p", { children: "Please wait while Overmux ends your session." })] });
+};
+//#endregion
+//#region src/internal/client/host/hosted-pages/browser-notification-settings.tsx
+const statusMessage = (status) => {
+	return {
+		checking: "Checking background notification status…",
+		denied: "Background notifications are blocked in this browser's site settings.",
+		disabled: "Background notifications are disabled for this browser.",
+		enabled: "Background notifications are enabled for this browser.",
+		error: "Background notification settings could not be updated. Try again.",
+		"ios-home-screen": "On iPhone or iPad, add Overmux to the Home Screen before enabling background notifications.",
+		unsupported: "Background notifications are not supported in this browser."
+	}[status];
+};
+const BrowserNotificationSettings = () => {
+	const [status, setStatus] = useState("checking");
+	useEffect(() => {
+		let active = true;
+		const reconcile = () => {
+			reconciledStatus().then((next) => {
+				if (active) setStatus(next);
+			}).catch(() => {
+				if (active) setStatus("error");
+			});
+		};
+		const onVisibilityChange = () => {
+			if (document.visibilityState === "visible") reconcile();
+		};
+		reconcile();
+		document.addEventListener("visibilitychange", onVisibilityChange);
+		navigator.serviceWorker?.addEventListener("controllerchange", reconcile);
+		return () => {
+			active = false;
+			document.removeEventListener("visibilitychange", onVisibilityChange);
+			navigator.serviceWorker?.removeEventListener("controllerchange", reconcile);
+		};
+	}, []);
+	const enable = useCallback(async () => {
+		try {
+			setStatus("checking");
+			const enabled = await enableBackgroundNotifications();
+			setStatus(enabled ? "enabled" : Notification.permission === "denied" ? "denied" : "disabled");
+		} catch {
+			setStatus("error");
+		}
+	}, []);
+	const disable = useCallback(async () => {
+		try {
+			setStatus("checking");
+			await disableBackgroundNotifications();
+			setStatus("disabled");
+		} catch {
+			setStatus("error");
+		}
+	}, []);
+	const canEnable = status === "disabled" || status === "error";
+	const canDisable = status === "enabled" || status === "error";
+	return /* @__PURE__ */ jsxs("div", {
+		"data-om-browser-notifications": "",
+		children: [
+			/* @__PURE__ */ jsx("h3", { children: "Browser notifications" }),
+			/* @__PURE__ */ jsx("p", {
+				"aria-live": "polite",
+				"data-om-background-notifications-status": "",
+				children: statusMessage(status)
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				"data-om-hosted-actions": "",
+				children: [canEnable ? /* @__PURE__ */ jsx("button", {
+					"data-om-background-notifications-enable": "",
+					onClick: enable,
+					type: "button",
+					children: "Enable"
+				}) : null, canDisable ? /* @__PURE__ */ jsx("button", {
+					"data-om-background-notifications-disable": "",
+					onClick: disable,
+					type: "button",
+					children: "Disable"
+				}) : null]
+			})
+		]
+	});
+};
+//#endregion
+//#region src/internal/client/host/hosted-pages/settings-page.tsx
+const DesktopNotificationSettings = () => /* @__PURE__ */ jsxs("div", {
+	"data-om-desktop-notifications": "",
+	children: [/* @__PURE__ */ jsx("h3", { children: "Desktop notifications" }), /* @__PURE__ */ jsx("p", { children: "Notifications are delivered through the Overmux desktop app and managed by the OS. Change notification permissions and preferences in your operating system's settings." })]
+});
+const HostedSettingsPage = () => {
+	const returnTo = resolveOvermuxReturnTo(new URLSearchParams(location.search).get("returnTo"));
+	const desktopNotifications = Boolean(window.overmuxHost?.notifications);
+	return /* @__PURE__ */ jsxs(HostedPage, { children: [
+		/* @__PURE__ */ jsxs("header", {
+			"data-om-hosted-header": "",
+			children: [/* @__PURE__ */ jsx("h1", { children: "Overmux settings" }), /* @__PURE__ */ jsx("a", {
+				href: returnTo,
+				children: "Back to Overmux"
+			})]
+		}),
+		/* @__PURE__ */ jsxs("section", {
+			"data-om-hosted-section": "",
+			children: [/* @__PURE__ */ jsx("h2", { children: "Notifications" }), desktopNotifications ? /* @__PURE__ */ jsx(DesktopNotificationSettings, {}) : /* @__PURE__ */ jsx(BrowserNotificationSettings, {})]
+		}),
+		/* @__PURE__ */ jsxs("section", {
+			"data-om-hosted-section": "",
+			children: [
+				/* @__PURE__ */ jsx("h2", { children: "Session" }),
+				/* @__PURE__ */ jsx("p", { children: "End this Overmux session on this device." }),
+				/* @__PURE__ */ jsx("a", {
+					"data-om-hosted-button": "",
+					href: overmuxLogoutPath,
+					children: "Log out"
+				})
+			]
+		})
+	] });
+};
+//#endregion
+//#region src/internal/client/host/recovery-screen.tsx
+const RecoveryScreen = ({ error }) => /* @__PURE__ */ jsx("main", {
+	"data-om-recovery": "",
+	children: /* @__PURE__ */ jsxs("section", {
+		"data-om-recovery-panel": "",
+		children: [
+			/* @__PURE__ */ jsx("h1", {
+				"data-om-recovery-title": "",
+				children: "Overmux recovery"
+			}),
+			error ? /* @__PURE__ */ jsx("pre", {
+				"data-om-recovery-error": "",
+				children: error
+			}) : null,
+			/* @__PURE__ */ jsx("button", {
+				"data-om-recovery-reload": "",
+				onClick: () => location.reload(),
+				type: "button",
+				children: "Reload"
+			})
+		]
+	})
+});
+//#endregion
+//#region ../lib/dist/index.js
+const delay = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
+//#endregion
+//#region src/internal/client/host/update-popover.tsx
+const reduceUpdateState = (_state, action) => {
+	if (action.type === "update-available") return { type: "available" };
+	if (action.type === "restart-requested") return { type: "requesting" };
+	if (action.type === "restart-failed") return {
+		type: "available",
+		error: action.error
+	};
+	return { type: "restarting" };
+};
+const pollUntilHealthy = async (signal) => {
+	if (signal.aborted) return;
+	try {
+		if ((await fetch("/api/health", {
+			cache: "no-store",
+			signal
+		})).ok) {
+			location.reload();
+			return;
+		}
+	} catch {}
+	await delay(250);
+	return pollUntilHealthy(signal);
+};
+const ReconnectingScreen = () => /* @__PURE__ */ jsx("main", {
+	"aria-live": "polite",
+	"data-om-reconnecting": "",
+	role: "status",
+	children: /* @__PURE__ */ jsxs("section", {
+		"data-om-reconnecting-panel": "",
+		children: [/* @__PURE__ */ jsx("h1", {
+			"data-om-reconnecting-title": "",
+			children: "Reconnecting"
+		}), /* @__PURE__ */ jsx("p", {
+			"data-om-reconnecting-message": "",
+			children: "Reconnecting to Overmux. Your workspace will resume shortly."
+		})]
+	})
+});
+const useUpdateState = (transport) => {
+	const [state, dispatch] = useReducer(reduceUpdateState, { type: "current" });
+	useEffect(() => transport.subscribeLifecycle((event) => dispatch(event)), [transport]);
+	useEffect(() => {
+		if (state.type !== "restarting") return;
+		const controller = new AbortController();
+		pollUntilHealthy(controller.signal);
+		return () => controller.abort();
+	}, [state.type]);
+	return {
+		requestRestart: useCallback(async () => {
+			dispatch({ type: "restart-requested" });
+			try {
+				const response = await fetch("/api/restart", { method: "POST" });
+				if (!response.ok) throw new Error(`Restart request failed: ${response.status}`);
+				dispatch({ type: "restarting" });
+			} catch (cause) {
+				const error = cause instanceof Error ? cause.message : String(cause);
+				dispatch({
+					type: "restart-failed",
+					error
+				});
+			}
+		}, []),
+		state
+	};
+};
+const useConnectionState = (transport) => {
+	const connected = useRef(false);
+	const [connection, setConnection] = useState("initial");
+	useEffect(() => transport.subscribeStatus((status) => {
+		if (status === "connected") {
+			connected.current = true;
+			setConnection("connected");
+			return;
+		}
+		if (!connected.current) return;
+		connected.current = false;
+		setConnection("reconnecting");
+	}), [transport]);
+	return connection;
+};
+const UpdatePopover = ({ transport }) => {
+	const connection = useConnectionState(transport);
+	const { requestRestart, state } = useUpdateState(transport);
+	if (state.type === "restarting") return /* @__PURE__ */ jsx("main", {
+		"aria-live": "polite",
+		"data-om-restarting": "",
+		role: "status",
+		children: /* @__PURE__ */ jsxs("section", {
+			"data-om-restarting-panel": "",
+			children: [/* @__PURE__ */ jsx("h1", {
+				"data-om-restarting-title": "",
+				children: "Restarting Overmux"
+			}), /* @__PURE__ */ jsx("p", {
+				"data-om-restarting-message": "",
+				children: "Waiting for the new version."
+			})]
+		})
+	});
+	if (connection === "reconnecting") return /* @__PURE__ */ jsx(ReconnectingScreen, {});
+	if (state.type === "current") return null;
+	const error = state.type === "available" ? state.error : void 0;
+	return /* @__PURE__ */ jsxs("aside", {
+		"data-om-update": "",
+		role: "status",
+		children: [
+			/* @__PURE__ */ jsx("p", { children: "A new version is available. Reload to update." }),
+			/* @__PURE__ */ jsx("button", {
+				"data-om-update-reload": "",
+				disabled: state.type === "requesting",
+				onClick: () => void requestRestart(),
+				type: "button",
+				children: "Reload"
+			}),
+			error ? /* @__PURE__ */ jsx("p", {
+				"data-om-update-error": "",
+				children: error
+			}) : null
+		]
+	});
+};
+//#endregion
+//#region src/internal/client/host/overmux-host.tsx
+var RootErrorBoundary = class extends Component {
+	state = {};
+	static getDerivedStateFromError(error) {
+		return { error };
+	}
+	render() {
+		return this.state.error ? this.props.fallback(this.state.error) : this.props.children;
+	}
+};
+var AuthenticationRequiredError = class extends Error {};
+const redirectToLogin = () => location.replace("/login?reason=session-expired");
+const loadRuntimeManifest = async () => {
+	const response = await fetch("/api/runtime-manifest", { cache: "no-store" });
+	if (response.status === 401) throw new AuthenticationRequiredError("Authentication required");
+	if (!response.ok) throw new Error(`Runtime manifest request failed: ${response.status}`);
+	return runtimeManifestSchema.parse(await response.json());
+};
+const OvermuxRuntime = ({ definition }) => {
+	const safeMode = new URLSearchParams(location.search).get("safe") === "1";
+	const transport = useMemo(createClientTransport, []);
+	const queryClient = useMemo(() => new QueryClient(), []);
+	const logForwardingDisposer = useRef(void 0);
+	const [manifest, setManifest] = useState();
+	const [error, setError] = useState();
+	useEffect(() => {
+		let active = true;
+		loadRuntimeManifest().then((next) => {
+			if (!active) return;
+			setManifest(next);
+			transport.activate();
+		}).catch((cause) => {
+			if (cause instanceof AuthenticationRequiredError) {
+				redirectToLogin();
+				return;
+			}
+			if (active) setError(cause instanceof Error ? cause.message : String(cause));
+		});
+		return () => {
+			active = false;
+		};
+	}, [transport]);
+	const registrations = useMemo(() => /* @__PURE__ */ new Set(), []);
+	const [registrationRevision, setRegistrationRevision] = useState(0);
+	useEffect(() => {
+		if (manifest?.debug && !logForwardingDisposer.current) logForwardingDisposer.current = installBrowserLogForwarding(transport.reportDiagnostic);
+	}, [manifest?.debug, transport]);
+	useEffect(() => transport.subscribeStatus((status) => {
+		if (status === "authentication-required") redirectToLogin();
+	}), [transport]);
+	useEffect(() => () => {
+		logForwardingDisposer.current?.();
+		transport.dispose();
+	}, [transport]);
+	useEffect(() => installNotificationForwarding(transport), [transport]);
+	const refreshCommands = useCallback(() => setRegistrationRevision((revision) => revision + 1), []);
+	const registerCommand = useCallback((registration) => {
+		registrations.add(registration);
+		refreshCommands();
+		return () => {
+			registrations.delete(registration);
+			refreshCommands();
+		};
+	}, [refreshCommands, registrations]);
+	const overmuxServerApi = useMemo(() => manifest ? createOvermuxServerApi({
+		manifest,
+		transport
+	}) : void 0, [manifest, transport]);
+	if (safeMode || !manifest || !overmuxServerApi) return /* @__PURE__ */ jsx(RecoveryScreen, { error });
+	const App = definition.component;
+	return /* @__PURE__ */ jsx(QueryClientProvider, {
+		client: queryClient,
+		children: /* @__PURE__ */ jsx(RuntimeContext.Provider, {
+			value: {
+				manifest,
+				overmuxServerApi,
+				refreshCommands,
+				registerCommand
+			},
+			children: /* @__PURE__ */ jsx(TransportContext.Provider, {
+				value: transport,
+				children: /* @__PURE__ */ jsxs(ShortcutHost, {
+					definition,
+					registrations,
+					registrationRevision,
+					children: [/* @__PURE__ */ jsx(RootErrorBoundary, {
+						fallback: (cause) => /* @__PURE__ */ jsx(RecoveryScreen, { error: cause.message }),
+						children: createElement(App)
+					}), /* @__PURE__ */ jsx(UpdatePopover, { transport })]
+				})
+			})
+		})
+	});
+};
+const OvermuxHost = ({ definition }) => /* @__PURE__ */ jsx(OvermuxThemeScope, {
+	...definition.appearance,
+	children: location.pathname === "/_overmux/settings" ? /* @__PURE__ */ jsx(HostedSettingsPage, {}) : location.pathname === "/_overmux/logout" ? /* @__PURE__ */ jsx(HostedLogoutPage, {}) : /* @__PURE__ */ jsx(OvermuxRuntime, { definition })
+});
+//#endregion
+export { OvermuxHost, OvermuxPortal, OvermuxThemeScope, chordPrefixSchema, commandBindingSchema, createOvermuxHooks, defineCommandRegistry, defineOvermuxClient, disableBackgroundNotifications, enableBackgroundNotifications, formatKeyBinding, formatShortcutBinding, keyBindingSchema, matchesKeyBinding, readClipboardText, shortcutBindingSchema, skipToken, useCommand, useCommands, useShortcutInputTarget, writeClipboardText };
+
+//# sourceMappingURL=client.js.map