remobi 0.1.0

package/dist/src/index.mjs

@@ -0,0 +1,1637 @@
+import { defaultConfig, defineConfig } from "./config.mjs";
+
+//#region src/actions/registry.ts
+function createActionRegistry() {
+	const handlers = /* @__PURE__ */ new Map();
+	let sendQueue = Promise.resolve();
+	function register(type, handler) {
+		handlers.set(type, handler);
+	}
+	async function execute(action, context) {
+		const handler = handlers.get(action.type);
+		if (!handler) return false;
+		if (action.type === "send") {
+			const current = sendQueue.then(async () => {
+				await handler(action, context);
+			});
+			sendQueue = current.catch(() => {});
+			await current;
+			return true;
+		}
+		if (action.type === "paste") {
+			await sendQueue;
+			await handler(action, context);
+			return true;
+		}
+		await handler(action, context);
+		return true;
+	}
+	return {
+		register,
+		execute
+	};
+}
+function createDefaultActionRegistry() {
+	const registry = createActionRegistry();
+	let pasteQueue = Promise.resolve();
+	registry.register("send", (action, context) => {
+		if (action.type !== "send") return;
+		return context.sendText(action.data).then(() => context.focusIfNeeded());
+	});
+	registry.register("paste", (_action, context) => {
+		if (!navigator.clipboard || typeof navigator.clipboard.readText !== "function") {
+			context.focusIfNeeded();
+			return;
+		}
+		const runPaste = async () => {
+			try {
+				const text = await navigator.clipboard.readText();
+				if (!text) return;
+				if (context.sendRawText) {
+					await context.sendRawText(text);
+					return;
+				}
+				await context.sendText(text);
+			} catch {} finally {
+				context.focusIfNeeded();
+			}
+		};
+		const current = pasteQueue.then(runPaste);
+		pasteQueue = current.catch(() => {});
+		return current;
+	});
+	registry.register("ctrl-modifier", (_action, context) => {
+		if (context.toggleCtrlModifier) context.toggleCtrlModifier();
+		else context.focusIfNeeded();
+	});
+	registry.register("drawer-toggle", (_action, context) => {
+		if (context.openDrawer) context.openDrawer();
+		else context.focusIfNeeded();
+	});
+	registry.register("combo-picker", (_action, context) => {
+		if (context.openComboPicker) context.openComboPicker({
+			sendText: async (data) => {
+				await registry.execute({
+					type: "send",
+					data
+				}, {
+					...context,
+					sendText: context.sendRawText ?? context.sendText
+				});
+			},
+			focusIfNeeded: context.focusIfNeeded
+		});
+		else context.focusIfNeeded();
+	});
+	return registry;
+}
+
+//#endregion
+//#region src/util/dom.ts
+/** Create an element with optional attributes and children */
+function el(tag, attrs, ...children) {
+	const element = document.createElement(tag);
+	if (attrs) for (const [key, value] of Object.entries(attrs)) element.setAttribute(key, value);
+	for (const child of children) if (typeof child === "string") element.appendChild(document.createTextNode(child));
+	else element.appendChild(child);
+	return element;
+}
+/** Create a button with label and aria-label */
+function btn(label, ariaLabel) {
+	const button = el("button");
+	button.textContent = label;
+	if (ariaLabel) button.setAttribute("aria-label", ariaLabel);
+	return button;
+}
+
+//#endregion
+//#region src/util/haptic.ts
+/** Short haptic vibration — no-op on devices without vibration API */
+function haptic() {
+	if (navigator.vibrate) navigator.vibrate(10);
+}
+
+//#endregion
+//#region src/controls/combo-picker.ts
+const NAMED_KEYS = [
+	"pagedown",
+	"pageup",
+	"return",
+	"escape",
+	"backspace",
+	"delete",
+	"enter",
+	"space",
+	"tab",
+	"home",
+	"end",
+	"left",
+	"right",
+	"down",
+	"up",
+	"pgdn",
+	"pgup",
+	"del",
+	"esc",
+	"bs"
+];
+function parseComboTokens(value) {
+	const trimmed = value.trim();
+	if (trimmed.length === 0) return null;
+	let keyToken = null;
+	let prefix = "";
+	for (const key of NAMED_KEYS) {
+		const pattern = new RegExp(`(?:^|[+\\-\\s])(${key})$`, "i");
+		const match = trimmed.match(pattern);
+		if (!match || match.index === void 0) continue;
+		const matchedKey = match[1];
+		if (!matchedKey) continue;
+		const keyStart = match.index + match[0].length - matchedKey.length;
+		keyToken = matchedKey;
+		prefix = trimmed.slice(0, keyStart);
+		break;
+	}
+	if (!keyToken) {
+		keyToken = trimmed[trimmed.length - 1] ?? "";
+		prefix = trimmed.slice(0, -1);
+	}
+	return {
+		modifiers: prefix.split(/[+\-\s]+/).map((token) => token.trim()).filter((token) => token.length > 0),
+		key: keyToken
+	};
+}
+function resolveBaseKey(key, keyLower) {
+	if (key.length === 1) return {
+		ok: true,
+		data: key
+	};
+	if (keyLower === "enter" || keyLower === "return") return {
+		ok: true,
+		data: "\r"
+	};
+	if (keyLower === "tab") return {
+		ok: true,
+		data: "	"
+	};
+	if (keyLower === "space") return {
+		ok: true,
+		data: " "
+	};
+	if (keyLower === "esc" || keyLower === "escape") return {
+		ok: true,
+		data: "\x1B"
+	};
+	if (keyLower === "backspace" || keyLower === "bs") return {
+		ok: true,
+		data: ""
+	};
+	if (keyLower === "delete" || keyLower === "del") return {
+		ok: true,
+		data: "\x1B[3~"
+	};
+	if (keyLower === "up") return {
+		ok: true,
+		data: "\x1B[A"
+	};
+	if (keyLower === "down") return {
+		ok: true,
+		data: "\x1B[B"
+	};
+	if (keyLower === "right") return {
+		ok: true,
+		data: "\x1B[C"
+	};
+	if (keyLower === "left") return {
+		ok: true,
+		data: "\x1B[D"
+	};
+	if (keyLower === "home") return {
+		ok: true,
+		data: "\x1B[H"
+	};
+	if (keyLower === "end") return {
+		ok: true,
+		data: "\x1B[F"
+	};
+	if (keyLower === "pageup" || keyLower === "pgup") return {
+		ok: true,
+		data: "\x1B[5~"
+	};
+	if (keyLower === "pagedown" || keyLower === "pgdn") return {
+		ok: true,
+		data: "\x1B[6~"
+	};
+	return {
+		ok: false,
+		error: "Unknown key. Try one character, Enter, Tab, Space, Esc, arrows, Home/End, PgUp/PgDn."
+	};
+}
+function applyCtrl(base, key, keyLower) {
+	if (base.length !== 1) return {
+		ok: false,
+		error: "Ctrl supports single characters (for Enter use M-Enter)."
+	};
+	if (keyLower === "space") return {
+		ok: true,
+		data: "\0"
+	};
+	if (key.length !== 1) return {
+		ok: false,
+		error: "Unsupported Ctrl combo for this key."
+	};
+	if (key === "[") return {
+		ok: true,
+		data: "\x1B"
+	};
+	if (key === "\\") return {
+		ok: true,
+		data: ""
+	};
+	if (key === "]") return {
+		ok: true,
+		data: ""
+	};
+	if (key === "6") return {
+		ok: true,
+		data: ""
+	};
+	if (key === "-" || key === "/") return {
+		ok: true,
+		data: ""
+	};
+	if (key === "8") return {
+		ok: true,
+		data: ""
+	};
+	const code = key.charCodeAt(0);
+	if (code >= 65 && code <= 90 || code >= 97 && code <= 122) return {
+		ok: true,
+		data: String.fromCharCode(code & 31)
+	};
+	return {
+		ok: false,
+		error: "Unsupported Ctrl combo for this key."
+	};
+}
+function parseComboInput(value) {
+	const tokens = parseComboTokens(value);
+	if (!tokens) return {
+		ok: false,
+		error: "Type a combo like C-s, M-Enter, or C-[."
+	};
+	let ctrl = false;
+	let alt = false;
+	for (const modifier of tokens.modifiers) {
+		const token = modifier.toLowerCase();
+		if (token === "c" || token === "ctrl" || token === "control") {
+			ctrl = true;
+			continue;
+		}
+		if (token === "m" || token === "meta" || token === "alt" || token === "a") {
+			alt = true;
+			continue;
+		}
+		if (token === "s" || token === "shift") continue;
+		return {
+			ok: false,
+			error: `Unknown modifier: ${modifier}`
+		};
+	}
+	const keyToken = tokens.key;
+	if (!keyToken) return {
+		ok: false,
+		error: "Missing key in combo."
+	};
+	const keyLower = keyToken.toLowerCase();
+	const base = resolveBaseKey(keyToken, keyLower);
+	if (!base.ok) return base;
+	let data = base.data;
+	if (ctrl) {
+		const next = applyCtrl(data, keyToken, keyLower);
+		if (!next.ok) return next;
+		data = next.data;
+	}
+	if (alt) data = `\x1b${data}`;
+	return {
+		ok: true,
+		data
+	};
+}
+function createComboPicker() {
+	const backdrop = el("div", { id: "wt-combo-backdrop" });
+	const panel = el("div", { id: "wt-combo-panel" });
+	const title = el("h3");
+	title.textContent = "Send combo";
+	const description = el("p");
+	description.textContent = "Examples: C-s, C-[, M-Enter, Alt-x";
+	const input = el("input", {
+		type: "text",
+		placeholder: "Combo",
+		"aria-label": "Combo input",
+		autocomplete: "off",
+		autocorrect: "off",
+		autocapitalize: "off",
+		spellcheck: "false"
+	});
+	const error = el("p", { class: "wt-combo-error" });
+	const actions = el("div", { class: "wt-combo-actions" });
+	const cancelButton = el("button", { type: "button" }, "Cancel");
+	const sendButton = el("button", { type: "button" }, "Send");
+	actions.appendChild(cancelButton);
+	actions.appendChild(sendButton);
+	panel.appendChild(title);
+	panel.appendChild(description);
+	panel.appendChild(input);
+	panel.appendChild(error);
+	panel.appendChild(actions);
+	backdrop.appendChild(panel);
+	let currentDispatch = null;
+	function clearError() {
+		error.textContent = "";
+	}
+	function setError(message) {
+		error.textContent = message;
+	}
+	function closeAndFocus() {
+		const dispatch = currentDispatch;
+		backdrop.style.display = "none";
+		currentDispatch = null;
+		clearError();
+		input.value = "";
+		if (dispatch) dispatch.focusIfNeeded();
+	}
+	async function submit() {
+		const dispatch = currentDispatch;
+		if (!dispatch) return;
+		const parsed = parseComboInput(input.value);
+		if (!parsed.ok) {
+			setError(parsed.error);
+			return;
+		}
+		backdrop.style.display = "none";
+		currentDispatch = null;
+		clearError();
+		input.value = "";
+		try {
+			await dispatch.sendText(parsed.data);
+		} catch (errorValue) {
+			console.error("remobi: combo send failed", errorValue);
+		} finally {
+			dispatch.focusIfNeeded();
+		}
+	}
+	function open(dispatch) {
+		currentDispatch = dispatch;
+		clearError();
+		input.value = "";
+		backdrop.style.display = "flex";
+		setTimeout(() => input.focus(), 0);
+	}
+	function close() {
+		closeAndFocus();
+	}
+	backdrop.addEventListener("click", (event) => {
+		if (event.target !== backdrop) return;
+		haptic();
+		closeAndFocus();
+	});
+	cancelButton.addEventListener("click", (event) => {
+		event.preventDefault();
+		haptic();
+		closeAndFocus();
+	});
+	sendButton.addEventListener("click", (event) => {
+		event.preventDefault();
+		haptic();
+		submit();
+	});
+	input.addEventListener("keydown", (event) => {
+		if (event.key === "Enter") {
+			event.preventDefault();
+			haptic();
+			submit();
+			return;
+		}
+		if (event.key === "Escape") {
+			event.preventDefault();
+			haptic();
+			closeAndFocus();
+		}
+	});
+	return {
+		element: backdrop,
+		open,
+		close
+	};
+}
+
+//#endregion
+//#region src/util/keyboard.ts
+/** Threshold in pixels — if the gap between innerHeight and viewport height exceeds this, the keyboard is open */
+const KB_THRESHOLD = 150;
+/** Check whether the virtual keyboard appears to be open */
+function isKeyboardOpen() {
+	const vp = window.visualViewport;
+	if (!vp) return false;
+	return window.innerHeight - vp.height > KB_THRESHOLD;
+}
+/** Focus terminal only if the keyboard was already visible */
+function conditionalFocus(term, kbWasOpen) {
+	if (kbWasOpen) term.focus();
+}
+
+//#endregion
+//#region src/util/terminal.ts
+/** Send data to the terminal as if the user typed it */
+function sendData(term, data) {
+	term.input(data, true);
+}
+/** Trigger xterm resize via window resize event */
+function resizeTerm() {
+	window.dispatchEvent(new Event("resize"));
+}
+/**
+* Wait for `window.term` to become available (ttyd sets it).
+* Resolves with the terminal instance, rejects after maxRetries (default 100 = 10s).
+*/
+function waitForTerm(maxRetries = 100) {
+	return new Promise((resolve, reject) => {
+		let attempts = 0;
+		function check() {
+			if (window.term) resolve(window.term);
+			else if (attempts >= maxRetries) reject(/* @__PURE__ */ new Error(`waitForTerm: window.term not available after ${maxRetries * 100}ms`));
+			else {
+				attempts += 1;
+				setTimeout(check, 100);
+			}
+		}
+		check();
+	});
+}
+
+//#endregion
+//#region src/controls/floating-buttons.ts
+function createGroupButton(term, def, config, hooks, actions, openDrawer, openComboPicker) {
+	const button = el("button");
+	button.textContent = def.label;
+	button.setAttribute("aria-label", def.description);
+	button.addEventListener("click", (e) => {
+		e.preventDefault();
+		const kbWasOpen = isKeyboardOpen();
+		haptic();
+		async function sendWithHooks(data) {
+			const before = await hooks.runBeforeSendData({
+				term,
+				config,
+				source: "floating-buttons",
+				actionType: def.action.type,
+				kbWasOpen,
+				data
+			});
+			if (before.blocked) return;
+			sendData(term, before.data);
+			await hooks.runAfterSendData({
+				term,
+				config,
+				source: "floating-buttons",
+				actionType: def.action.type,
+				kbWasOpen,
+				data: before.data
+			});
+		}
+		actions.execute(def.action, {
+			term,
+			kbWasOpen,
+			focusIfNeeded: () => conditionalFocus(term, kbWasOpen),
+			sendText: sendWithHooks,
+			sendRawText: sendWithHooks,
+			openDrawer,
+			openComboPicker
+		}).catch((error) => {
+			console.error("remobi: floating button action failed", error);
+			conditionalFocus(term, kbWasOpen);
+		});
+	});
+	return button;
+}
+/**
+* Create one container element per floating button group.
+* Each group is positioned via CSS classes (`wt-floating-group`, `wt-floating-${position}`)
+* and rendered as a row or column depending on `direction` (default: row).
+*/
+function createFloatingButtons(term, groups, config, hooks, actions, openDrawer, openComboPicker) {
+	const elements = [];
+	for (const group of groups) {
+		const container = el("div", { class: `wt-floating-group wt-floating-${group.position}${group.direction === "column" ? " wt-floating-column" : ""}` });
+		for (const def of group.buttons) container.appendChild(createGroupButton(term, def, config, hooks, actions, openDrawer, openComboPicker));
+		elements.push(container);
+	}
+	return { elements };
+}
+
+//#endregion
+//#region src/controls/font-size.ts
+/** Change terminal font size by delta, clamped to config range */
+function changeFontSize(term, delta, font) {
+	const current = term.options.fontSize;
+	const next = Math.max(font.sizeRange[0], Math.min(font.sizeRange[1], current + delta));
+	if (next !== current) {
+		term.options.fontSize = next;
+		resizeTerm();
+	}
+}
+/** Create the font size controls (-, +) and help button */
+function createFontControls(term, font) {
+	const container = el("div", { id: "wt-font-controls" });
+	const btnMinus = btn("−", "Decrease font size");
+	const btnPlus = btn("+", "Increase font size");
+	const btnHelp = btn("?", "Help");
+	container.appendChild(btnMinus);
+	container.appendChild(btnPlus);
+	container.appendChild(btnHelp);
+	btnMinus.addEventListener("click", (e) => {
+		e.preventDefault();
+		haptic();
+		changeFontSize(term, -2, font);
+	});
+	btnPlus.addEventListener("click", (e) => {
+		e.preventDefault();
+		haptic();
+		changeFontSize(term, 2, font);
+	});
+	return {
+		element: container,
+		helpButton: btnHelp
+	};
+}
+
+//#endregion
+//#region src/controls/help.ts
+/** Create a table row with two cells — textContent auto-escapes */
+function row(left, right) {
+	return el("tr", {}, el("td", {}, left), el("td", {}, right));
+}
+function renderButtonTable(title, buttons) {
+	const frag = document.createDocumentFragment();
+	frag.appendChild(el("h2", {}, title));
+	const table = el("table");
+	for (const button of buttons) table.appendChild(row(button.label || button.id || "Unnamed", button.description || "No description"));
+	frag.appendChild(table);
+	return frag;
+}
+function renderGestures(config) {
+	const frag = document.createDocumentFragment();
+	frag.appendChild(el("h2", {}, "Gestures"));
+	const table = el("table");
+	if (config.gestures.swipe.enabled) {
+		table.appendChild(row("Swipe right", config.gestures.swipe.rightLabel));
+		table.appendChild(row("Swipe left", config.gestures.swipe.leftLabel));
+	}
+	if (config.gestures.pinch.enabled) table.appendChild(row("Pinch in/out", "Decrease/increase font size"));
+	if (config.gestures.scroll.enabled) if (config.gestures.scroll.strategy === "wheel") {
+		table.appendChild(row("Finger drag", "Send wheel scroll events to terminal apps"));
+		table.appendChild(row("Side ▲ ▼", "Send wheel-up / wheel-down at terminal centre"));
+	} else {
+		table.appendChild(row("Finger drag", "Send PageUp / PageDown keys"));
+		table.appendChild(row("Side ▲ ▼", "Send PageUp / PageDown keys"));
+	}
+	if (table.rows.length === 0) table.appendChild(row("None", "All gestures are disabled in config"));
+	frag.appendChild(table);
+	return frag;
+}
+/** Build the help overlay content as a DocumentFragment — no innerHTML */
+function buildHelpContent(config) {
+	const topRightButtons = [{
+		id: "font-size",
+		label: "− / +",
+		description: "Decrease / increase font size",
+		action: {
+			type: "send",
+			data: ""
+		}
+	}, {
+		id: "help",
+		label: "?",
+		description: "Open this help screen",
+		action: {
+			type: "send",
+			data: ""
+		}
+	}];
+	const frag = document.createDocumentFragment();
+	const closeBtn = el("button", { class: "wt-help-close" }, "×");
+	frag.appendChild(closeBtn);
+	frag.appendChild(renderButtonTable("Toolbar — Row 1", config.toolbar.row1));
+	frag.appendChild(renderButtonTable("Toolbar — Row 2", config.toolbar.row2));
+	frag.appendChild(renderButtonTable("Drawer Buttons", config.drawer.buttons));
+	frag.appendChild(renderGestures(config));
+	frag.appendChild(renderButtonTable("Top-Right Controls", topRightButtons));
+	if (config.floatingButtons.length > 0) {
+		const groups = config.floatingButtons;
+		if (groups.length === 1 && groups[0] !== void 0) frag.appendChild(renderButtonTable("Floating Buttons", groups[0].buttons));
+		else for (const group of groups) frag.appendChild(renderButtonTable(`Floating Buttons (${group.position})`, group.buttons));
+	}
+	return frag;
+}
+/** Create the help overlay and wire the help button */
+function createHelpOverlay(term, helpButton, config) {
+	const overlay = el("div", { id: "wt-help" });
+	overlay.appendChild(buildHelpContent(config));
+	function open() {
+		overlay.style.display = "block";
+	}
+	function close() {
+		overlay.style.display = "none";
+	}
+	overlay.addEventListener("click", (e) => {
+		const target = e.target;
+		if (!(target instanceof HTMLElement)) return;
+		if (target === overlay || target.classList.contains("wt-help-close")) {
+			const kbWasOpen = isKeyboardOpen();
+			haptic();
+			close();
+			conditionalFocus(term, kbWasOpen);
+		}
+	});
+	helpButton.addEventListener("click", (e) => {
+		e.preventDefault();
+		haptic();
+		open();
+	});
+	return {
+		element: overlay,
+		open,
+		close
+	};
+}
+
+//#endregion
+//#region src/gestures/lock.ts
+/** Create a gesture lock in the unclaimed state */
+function createGestureLock() {
+	return { current: "none" };
+}
+/** Try to claim the lock. Succeeds only if no gesture owns it yet. */
+function tryLock(lock, type) {
+	if (lock.current !== "none") return false;
+	lock.current = type;
+	return true;
+}
+/** Release the lock back to unclaimed */
+function resetLock(lock) {
+	lock.current = "none";
+}
+
+//#endregion
+//#region src/gestures/scroll.ts
+/** SGR mouse wheel escape sequence for a given direction */
+function scrollSeq(direction, x, y) {
+	return `\x1b[\x3c${direction === "up" ? 64 : 65};${x};${y}M`;
+}
+/** Page navigation key sequence for a given direction */
+function pageSeq(direction) {
+	return direction === "up" ? "\x1B[5~" : "\x1B[6~";
+}
+function clamp(value, min, max) {
+	return Math.min(max, Math.max(min, value));
+}
+function terminalGrid(screenRect, term) {
+	const colsFromTerm = term.cols;
+	const rowsFromTerm = term.rows;
+	if (typeof colsFromTerm === "number" && typeof rowsFromTerm === "number") {
+		if (colsFromTerm > 0 && rowsFromTerm > 0) return {
+			cols: Math.round(colsFromTerm),
+			rows: Math.round(rowsFromTerm)
+		};
+	}
+	const measure = document.querySelector(".xterm-char-measure-element");
+	if (measure instanceof HTMLElement) {
+		const measureRect = measure.getBoundingClientRect();
+		if (measureRect.width > 0 && measureRect.height > 0) return {
+			cols: Math.max(1, Math.round(screenRect.width / measureRect.width)),
+			rows: Math.max(1, Math.round(screenRect.height / measureRect.height))
+		};
+	}
+	return {
+		cols: 80,
+		rows: 24
+	};
+}
+function touchToCell(touch, screen, term) {
+	const rect = screen.getBoundingClientRect();
+	const { cols, rows } = terminalGrid(rect, term);
+	const width = Math.max(1, rect.width);
+	const height = Math.max(1, rect.height);
+	const relX = clamp(touch.clientX - rect.left, 0, width);
+	const relY = clamp(touch.clientY - rect.top, 0, height);
+	return {
+		x: clamp(Math.floor(relX / width * cols) + 1, 1, cols),
+		y: clamp(Math.floor(relY / height * rows) + 1, 1, rows)
+	};
+}
+/** Attach single-finger vertical scroll to the xterm screen */
+function attachScrollGesture(term, config, lock, isDrawerOpen) {
+	let startY = 0;
+	let lastY = 0;
+	let accDelta = 0;
+	let lastWheelAt = 0;
+	let screenEl = null;
+	function onTouchStart(e) {
+		if (!(e instanceof TouchEvent)) return;
+		if (e.touches.length === 1) {
+			const t = e.touches[0];
+			if (!t) return;
+			startY = t.clientY;
+			lastY = t.clientY;
+			accDelta = 0;
+		}
+	}
+	function onTouchMove(e) {
+		if (!(e instanceof TouchEvent)) return;
+		if (e.touches.length !== 1 || isDrawerOpen()) return;
+		const t = e.touches[0];
+		if (!t) return;
+		const y = t.clientY;
+		const totalDy = y - startY;
+		if (lock.current === "none" && Math.abs(totalDy) > config.sensitivity) {
+			if (!tryLock(lock, "scroll")) return;
+		}
+		if (lock.current !== "scroll") return;
+		e.preventDefault();
+		const moveDy = y - lastY;
+		lastY = y;
+		accDelta += moveDy;
+		while (Math.abs(accDelta) >= config.sensitivity) {
+			const dir = accDelta < 0 ? "down" : "up";
+			if (config.strategy === "keys") sendData(term, pageSeq(dir));
+			else {
+				const now = Date.now();
+				if (now - lastWheelAt < config.wheelIntervalMs) break;
+				lastWheelAt = now;
+				const screen = screenEl;
+				if (!screen) break;
+				const { x, y: row } = touchToCell(t, screen, term);
+				sendData(term, scrollSeq(dir, x, row));
+			}
+			accDelta -= (accDelta < 0 ? -1 : 1) * config.sensitivity;
+		}
+	}
+	function onTouchEnd(e) {
+		if (!(e instanceof TouchEvent)) return;
+		if (lock.current === "scroll") resetLock(lock);
+	}
+	function attach() {
+		const screen = document.querySelector(".xterm-screen");
+		if (!(screen instanceof HTMLElement)) {
+			setTimeout(attach, 200);
+			return;
+		}
+		screenEl = screen;
+		screen.addEventListener("touchstart", onTouchStart, { passive: true });
+		screen.addEventListener("touchmove", onTouchMove, { passive: false });
+		screen.addEventListener("touchend", onTouchEnd, { passive: true });
+		screen.addEventListener("touchcancel", onTouchEnd, { passive: true });
+	}
+	attach();
+}
+
+//#endregion
+//#region src/controls/scroll-buttons.ts
+const LONG_PRESS_DELAY = 300;
+const REPEAT_INTERVAL = 100;
+const FADE_TIMEOUT = 2e3;
+/** Create floating scroll buttons (PgUp ▲ / PgDn ▼) */
+function createScrollButtons(term, config) {
+	const container = el("div", { id: "wt-scroll-buttons" });
+	const upBtn = el("button", { "aria-label": "Page Up" }, "▲");
+	const downBtn = el("button", { "aria-label": "Page Down" }, "▼");
+	container.appendChild(upBtn);
+	container.appendChild(downBtn);
+	function targetCell() {
+		const active = term.buffer?.active;
+		if (active && typeof active.cursorX === "number" && typeof active.cursorY === "number") return {
+			x: Math.max(1, active.cursorX + 1),
+			y: Math.max(1, active.cursorY + 1)
+		};
+		const cols = typeof term.cols === "number" && term.cols > 0 ? Math.round(term.cols) : 80;
+		const rows = typeof term.rows === "number" && term.rows > 0 ? Math.round(term.rows) : 24;
+		return {
+			x: Math.max(1, Math.floor((cols + 1) / 2)),
+			y: Math.max(1, Math.floor((rows + 1) / 2))
+		};
+	}
+	function sequence(direction) {
+		if (config.strategy === "keys") return pageSeq(direction);
+		const { x, y } = targetCell();
+		return scrollSeq(direction, x, y);
+	}
+	function wireButton(button, direction) {
+		let repeatTimer;
+		let delayTimer;
+		function send() {
+			const kbWasOpen = isKeyboardOpen();
+			sendData(term, sequence(direction));
+			conditionalFocus(term, kbWasOpen);
+		}
+		function startRepeat() {
+			delayTimer = setTimeout(() => {
+				repeatTimer = setInterval(send, REPEAT_INTERVAL);
+			}, LONG_PRESS_DELAY);
+		}
+		function stopRepeat() {
+			if (delayTimer !== void 0) {
+				clearTimeout(delayTimer);
+				delayTimer = void 0;
+			}
+			if (repeatTimer !== void 0) {
+				clearInterval(repeatTimer);
+				repeatTimer = void 0;
+			}
+		}
+		button.addEventListener("touchstart", (e) => {
+			e.preventDefault();
+			send();
+			startRepeat();
+			resetFade();
+		});
+		button.addEventListener("touchend", () => stopRepeat());
+		button.addEventListener("touchcancel", () => stopRepeat());
+		button.addEventListener("click", () => {
+			send();
+			resetFade();
+		});
+	}
+	wireButton(upBtn, "up");
+	wireButton(downBtn, "down");
+	let fadeTimer;
+	function resetFade() {
+		container.classList.add("wt-active");
+		if (fadeTimer !== void 0) clearTimeout(fadeTimer);
+		fadeTimer = setTimeout(() => {
+			container.classList.remove("wt-active");
+		}, FADE_TIMEOUT);
+	}
+	return { element: container };
+}
+
+//#endregion
+//#region src/drawer/drawer.ts
+/** Create the command drawer with backdrop */
+function createDrawer(term, buttons, config) {
+	const actionRegistry = config.actions ?? createDefaultActionRegistry();
+	const hooks = config.hooks;
+	const appConfig = config.appConfig;
+	const backdrop = el("div", { id: "wt-backdrop" });
+	const drawer = el("div", { id: "wt-drawer" });
+	const handle = el("div", { id: "wt-drawer-handle" });
+	const grid = el("div", { id: "wt-drawer-grid" });
+	drawer.appendChild(handle);
+	drawer.appendChild(grid);
+	let drawerOpen = false;
+	for (const buttonDef of buttons) {
+		const button = el("button");
+		button.textContent = buttonDef.label;
+		button.addEventListener("click", (e) => {
+			e.preventDefault();
+			const kbWasOpen = isKeyboardOpen();
+			haptic();
+			close();
+			async function sendWithHooks(data) {
+				const before = await hooks.runBeforeSendData({
+					term,
+					config: appConfig,
+					source: "drawer",
+					actionType: buttonDef.action.type,
+					kbWasOpen,
+					data
+				});
+				if (before.blocked) return;
+				sendData(term, before.data);
+				await hooks.runAfterSendData({
+					term,
+					config: appConfig,
+					source: "drawer",
+					actionType: buttonDef.action.type,
+					kbWasOpen,
+					data: before.data
+				});
+			}
+			actionRegistry.execute(buttonDef.action, {
+				term,
+				kbWasOpen,
+				focusIfNeeded: () => conditionalFocus(term, kbWasOpen),
+				sendText: sendWithHooks,
+				sendRawText: sendWithHooks,
+				openComboPicker: config.openComboPicker
+			}).catch((error) => {
+				console.error("remobi: drawer action execution failed", error);
+				conditionalFocus(term, kbWasOpen);
+			});
+		});
+		grid.appendChild(button);
+	}
+	function open() {
+		backdrop.style.display = "block";
+		drawer.classList.add("open");
+		drawerOpen = true;
+	}
+	function close() {
+		drawer.classList.remove("open");
+		backdrop.style.display = "none";
+		drawerOpen = false;
+	}
+	function isOpen() {
+		return drawerOpen;
+	}
+	backdrop.addEventListener("click", () => {
+		const kbWasOpen = isKeyboardOpen();
+		haptic();
+		close();
+		conditionalFocus(term, kbWasOpen);
+	});
+	let handleStartY = 0;
+	handle.addEventListener("touchstart", (e) => {
+		const touch = e.touches[0];
+		if (touch) handleStartY = touch.clientY;
+	}, { passive: true });
+	handle.addEventListener("touchmove", (e) => {
+		const touch = e.touches[0];
+		if (!touch) return;
+		const dy = touch.clientY - handleStartY;
+		if (dy > 0) drawer.style.transform = `translateY(${dy}px)`;
+	}, { passive: true });
+	handle.addEventListener("touchend", (e) => {
+		const touch = e.changedTouches[0];
+		if (!touch) return;
+		const kbWasOpen = isKeyboardOpen();
+		const dy = touch.clientY - handleStartY;
+		drawer.style.transform = "";
+		if (dy > 60) {
+			close();
+			conditionalFocus(term, kbWasOpen);
+		}
+	}, { passive: true });
+	return {
+		backdrop,
+		drawer,
+		open,
+		close,
+		isOpen
+	};
+}
+
+//#endregion
+//#region src/gestures/pinch.ts
+/** Calculate distance between two touch points */
+function touchDistance(t1, t2) {
+	const dx = t1.clientX - t2.clientX;
+	const dy = t1.clientY - t2.clientY;
+	return Math.sqrt(dx * dx + dy * dy);
+}
+/** Clamp font size to configured range */
+function clampFontSize(size, range) {
+	return Math.max(range[0], Math.min(range[1], size));
+}
+/** Attach pinch-to-zoom gesture to the xterm screen */
+function attachPinchGestures(term, font, lock) {
+	let pinchStartDist = 0;
+	let pinchBaseFontSize = 0;
+	function onPinchStart(e) {
+		if (e.touches.length === 2) {
+			const t0 = e.touches[0];
+			const t1 = e.touches[1];
+			if (!t0 || !t1) return;
+			pinchStartDist = touchDistance(t0, t1);
+			pinchBaseFontSize = term.options.fontSize;
+		}
+	}
+	function onPinchMove(e) {
+		if (e.touches.length !== 2) return;
+		if (lock.current === "scroll") return;
+		if (pinchStartDist === 0) return;
+		const t0 = e.touches[0];
+		const t1 = e.touches[1];
+		if (!t0 || !t1) return;
+		const ratio = touchDistance(t0, t1) / pinchStartDist;
+		if (lock.current === "none" && Math.abs(ratio - 1) > .05) {
+			if (!tryLock(lock, "pinch")) return;
+		}
+		if (lock.current !== "pinch") return;
+		e.preventDefault();
+		const newSize = clampFontSize(Math.round(pinchBaseFontSize * ratio), font.sizeRange);
+		if (newSize !== term.options.fontSize) {
+			term.options.fontSize = newSize;
+			resizeTerm();
+		}
+	}
+	function onTouchEnd() {
+		if (lock.current === "pinch") resetLock(lock);
+	}
+	function attach() {
+		const screen = document.querySelector(".xterm-screen");
+		if (!screen) {
+			setTimeout(attach, 200);
+			return;
+		}
+		screen.addEventListener("touchstart", (e) => onPinchStart(e), { passive: true });
+		screen.addEventListener("touchmove", (e) => onPinchMove(e), { passive: false });
+		screen.addEventListener("touchend", () => onTouchEnd(), { passive: true });
+	}
+	attach();
+}
+
+//#endregion
+//#region src/gestures/swipe.ts
+/** Result of swipe validity check — pure logic, no side effects */
+function isValidSwipe(dx, dy, dt, config) {
+	const absDx = Math.abs(dx);
+	const absDy = Math.abs(dy);
+	if (absDx > config.threshold && dt < config.maxDuration && absDx > absDy * 2) return dx > 0 ? "right" : "left";
+	return null;
+}
+/** Create the swipe indicator element */
+function createSwipeIndicator() {
+	const indicator = el("div", { id: "wt-swipe-indicator" });
+	let timer = 0;
+	function show(arrow) {
+		indicator.textContent = arrow;
+		indicator.style.opacity = "1";
+		clearTimeout(timer);
+		timer = window.setTimeout(() => {
+			indicator.style.opacity = "0";
+		}, 300);
+	}
+	return {
+		element: indicator,
+		show
+	};
+}
+/** Attach swipe gesture detection to the xterm screen */
+function attachSwipeGestures(term, config, isDrawerOpen) {
+	const { element: indicator, show } = createSwipeIndicator();
+	let startX = 0;
+	let startY = 0;
+	let startTime = 0;
+	function onTouchStart(e) {
+		if (isDrawerOpen() || e.touches.length !== 1) return;
+		const touch = e.touches[0];
+		if (!touch) return;
+		startX = touch.clientX;
+		startY = touch.clientY;
+		startTime = Date.now();
+	}
+	function onTouchEnd(e) {
+		if (isDrawerOpen() || e.changedTouches.length !== 1) return;
+		const touch = e.changedTouches[0];
+		if (!touch) return;
+		const direction = isValidSwipe(touch.clientX - startX, touch.clientY - startY, Date.now() - startTime, config);
+		if (direction === "right") {
+			sendData(term, config.right);
+			show("◀");
+			haptic();
+		} else if (direction === "left") {
+			sendData(term, config.left);
+			show("▶");
+			haptic();
+		}
+	}
+	function attach() {
+		const screen = document.querySelector(".xterm-screen");
+		if (!screen) {
+			setTimeout(attach, 200);
+			return;
+		}
+		screen.addEventListener("touchstart", (e) => onTouchStart(e), { passive: true });
+		screen.addEventListener("touchend", (e) => onTouchEnd(e), { passive: true });
+	}
+	attach();
+	return indicator;
+}
+
+//#endregion
+//#region src/hooks/registry.ts
+function logHookError(name, error) {
+	console.error(`remobi: hook '${name}' failed`, error);
+}
+function createHookRegistry() {
+	const hooks = {
+		beforeSendData: [],
+		afterSendData: [],
+		overlayInitStart: [],
+		overlayReady: [],
+		toolbarCreated: [],
+		drawerCreated: []
+	};
+	function on(name, hook) {
+		hooks[name].push(hook);
+		return { dispose() {
+			const index = hooks[name].indexOf(hook);
+			if (index >= 0) hooks[name].splice(index, 1);
+		} };
+	}
+	async function runBeforeSendData(context) {
+		let nextData = context.data;
+		for (const hook of hooks.beforeSendData) try {
+			const result = await hook({
+				...context,
+				data: nextData
+			});
+			if (result?.block) return {
+				blocked: true,
+				data: nextData
+			};
+			if (typeof result?.data === "string") nextData = result.data;
+		} catch (error) {
+			logHookError("beforeSendData", error);
+		}
+		return {
+			blocked: false,
+			data: nextData
+		};
+	}
+	async function runAfterSendData(context) {
+		for (const hook of hooks.afterSendData) try {
+			await hook(context);
+		} catch (error) {
+			logHookError("afterSendData", error);
+		}
+	}
+	async function runOverlayInitStart(context) {
+		for (const hook of hooks.overlayInitStart) try {
+			await hook(context);
+		} catch (error) {
+			logHookError("overlayInitStart", error);
+		}
+	}
+	async function runOverlayReady(context) {
+		for (const hook of hooks.overlayReady) try {
+			await hook(context);
+		} catch (error) {
+			logHookError("overlayReady", error);
+		}
+	}
+	async function runToolbarCreated(context) {
+		for (const hook of hooks.toolbarCreated) try {
+			await hook(context);
+		} catch (error) {
+			logHookError("toolbarCreated", error);
+		}
+	}
+	async function runDrawerCreated(context) {
+		for (const hook of hooks.drawerCreated) try {
+			await hook(context);
+		} catch (error) {
+			logHookError("drawerCreated", error);
+		}
+	}
+	return {
+		on,
+		runBeforeSendData,
+		runAfterSendData,
+		runOverlayInitStart,
+		runOverlayReady,
+		runToolbarCreated,
+		runDrawerCreated
+	};
+}
+
+//#endregion
+//#region src/reconnect.ts
+/** Find the ttyd WebSocket from the interceptor array */
+function findTtydSocket() {
+	const sockets = window.__remobiSockets;
+	if (!sockets) return void 0;
+	return sockets.find((ws) => ws.url.endsWith("/ws"));
+}
+/** Create the reconnect overlay DOM (hidden by default) */
+function createOverlay(onReconnect) {
+	const overlay = el("div", {
+		id: "remobi-reconnect-overlay",
+		style: [
+			"display:none",
+			"position:fixed",
+			"inset:0",
+			"z-index:10000",
+			"background:rgba(30,30,46,0.92)",
+			"color:#cdd6f4",
+			"font-family:sans-serif",
+			"justify-content:center",
+			"align-items:center",
+			"flex-direction:column",
+			"gap:16px"
+		].join(";")
+	});
+	const message = el("div", { style: "font-size:1.4rem;font-weight:600" });
+	message.textContent = "Connection lost";
+	const button = el("button", { style: [
+		"padding:10px 28px",
+		"font-size:1rem",
+		"border:none",
+		"border-radius:8px",
+		"background:#cba6f7",
+		"color:#1e1e2e",
+		"cursor:pointer",
+		"font-weight:600"
+	].join(";") });
+	button.type = "button";
+	button.textContent = "Reconnect";
+	button.addEventListener("click", (event) => {
+		event.stopPropagation();
+		onReconnect();
+	});
+	overlay.addEventListener("click", () => {
+		onReconnect();
+	});
+	overlay.appendChild(message);
+	overlay.appendChild(button);
+	return {
+		element: overlay,
+		button
+	};
+}
+/**
+* Set up reconnect detection and overlay.
+*
+* Watches the ttyd WebSocket for close/error events. Falls back to
+* navigator.onLine + visibilitychange if no WebSocket found.
+* Returns a dispose function that removes listeners and DOM.
+*/
+function setupReconnect(_term, config) {
+	if (!config.enabled) return () => {};
+	let disconnected = false;
+	let reconnectTriggered = false;
+	function triggerReconnect() {
+		if (!disconnected || reconnectTriggered) return;
+		reconnectTriggered = true;
+		location.reload();
+	}
+	const { element: overlay, button } = createOverlay(triggerReconnect);
+	document.body.appendChild(overlay);
+	function onDisconnect() {
+		if (disconnected) return;
+		disconnected = true;
+		overlay.style.display = "flex";
+		button.focus();
+	}
+	function onOnline() {
+		if (disconnected) triggerReconnect();
+	}
+	function onVisibilityChange() {
+		if (document.visibilityState === "visible" && disconnected) triggerReconnect();
+	}
+	const ws = findTtydSocket();
+	if (ws) {
+		ws.addEventListener("close", onDisconnect);
+		ws.addEventListener("error", onDisconnect);
+	} else {
+		window.addEventListener("offline", onDisconnect);
+		document.addEventListener("visibilitychange", onVisibilityChange);
+	}
+	window.addEventListener("online", onOnline);
+	return () => {
+		if (ws) {
+			ws.removeEventListener("close", onDisconnect);
+			ws.removeEventListener("error", onDisconnect);
+		} else {
+			window.removeEventListener("offline", onDisconnect);
+			document.removeEventListener("visibilitychange", onVisibilityChange);
+		}
+		window.removeEventListener("online", onOnline);
+		overlay.remove();
+	};
+}
+
+//#endregion
+//#region src/theme/apply.ts
+/** Apply a theme to the xterm.js terminal instance */
+function applyTheme(term, theme) {
+	term.options.theme = { ...theme };
+}
+
+//#endregion
+//#region src/toolbar/toolbar.ts
+/** Create the ctrl modifier state manager */
+function createCtrlState() {
+	return {
+		active: false,
+		disposer: null,
+		buttonEl: null
+	};
+}
+/** Activate ctrl sticky modifier */
+function activateCtrl(state, term, theme) {
+	if (!state.buttonEl) return;
+	state.active = true;
+	state.buttonEl.style.background = theme.blue;
+	state.buttonEl.style.color = theme.background;
+	if (!state.disposer) state.disposer = term.onData((data) => {
+		if (state.active && data.length === 1) {
+			const code = data.charCodeAt(0);
+			deactivateCtrl(state, theme);
+			if (code >= 65 && code <= 90 || code >= 97 && code <= 122) sendData(term, String.fromCharCode(code & 31));
+		}
+	});
+}
+/** Deactivate ctrl sticky modifier */
+function deactivateCtrl(state, theme) {
+	if (!state.buttonEl) return;
+	state.active = false;
+	state.buttonEl.style.background = theme.black;
+	state.buttonEl.style.color = theme.foreground;
+	if (state.disposer) {
+		state.disposer.dispose();
+		state.disposer = null;
+	}
+}
+/** Wire up a single button's click handler based on its action type */
+function wireButton(button, def, term, ctrlState, config, registry, hooks, openDrawer, openComboPicker) {
+	button.addEventListener("click", (e) => {
+		e.preventDefault();
+		const kbWasOpen = isKeyboardOpen();
+		haptic();
+		async function sendWithCtrlAware(data) {
+			const before = await hooks.runBeforeSendData({
+				term,
+				config,
+				source: "toolbar",
+				actionType: def.action.type,
+				kbWasOpen,
+				data
+			});
+			if (before.blocked) return;
+			let nextData = before.data;
+			if (ctrlState.active && ctrlState.buttonEl) {
+				deactivateCtrl(ctrlState, config.theme);
+				if (nextData.length === 1) {
+					const code = nextData.charCodeAt(0);
+					if (code >= 65 && code <= 90 || code >= 97 && code <= 122) nextData = String.fromCharCode(code & 31);
+				}
+			}
+			sendData(term, nextData);
+			await hooks.runAfterSendData({
+				term,
+				config,
+				source: "toolbar",
+				actionType: def.action.type,
+				kbWasOpen,
+				data: nextData
+			});
+		}
+		async function sendRaw(data) {
+			const before = await hooks.runBeforeSendData({
+				term,
+				config,
+				source: "toolbar",
+				actionType: def.action.type,
+				kbWasOpen,
+				data
+			});
+			if (before.blocked) return;
+			sendData(term, before.data);
+			await hooks.runAfterSendData({
+				term,
+				config,
+				source: "toolbar",
+				actionType: def.action.type,
+				kbWasOpen,
+				data: before.data
+			});
+		}
+		registry.execute(def.action, {
+			term,
+			kbWasOpen,
+			focusIfNeeded: () => conditionalFocus(term, kbWasOpen),
+			sendText: sendWithCtrlAware,
+			sendRawText: sendRaw,
+			openDrawer,
+			openComboPicker,
+			toggleCtrlModifier: () => {
+				if (ctrlState.active) deactivateCtrl(ctrlState, config.theme);
+				else activateCtrl(ctrlState, term, config.theme);
+				conditionalFocus(term, kbWasOpen);
+			}
+		}).catch((error) => {
+			console.error("remobi: toolbar action execution failed", error);
+			conditionalFocus(term, kbWasOpen);
+		});
+	});
+}
+/** Build a row of buttons */
+function buildRow(buttons, term, ctrlState, config, registry, hooks, openDrawer, openComboPicker) {
+	const row = el("div", { class: "wt-row" });
+	for (const def of buttons) {
+		const button = el("button");
+		button.textContent = def.label;
+		if (def.action.type === "ctrl-modifier") ctrlState.buttonEl = button;
+		wireButton(button, def, term, ctrlState, config, registry, hooks, openDrawer, openComboPicker);
+		row.appendChild(button);
+	}
+	return row;
+}
+/** Create the two-row toolbar */
+function createToolbar(term, config, openDrawer, hooks, actions = createDefaultActionRegistry(), openComboPicker) {
+	const toolbar = el("div", { id: "wt-toolbar" });
+	const ctrlState = createCtrlState();
+	const row1 = buildRow(config.toolbar.row1, term, ctrlState, config, actions, hooks, openDrawer, openComboPicker);
+	const row2 = buildRow(config.toolbar.row2, term, ctrlState, config, actions, hooks, openDrawer, openComboPicker);
+	toolbar.appendChild(row1);
+	toolbar.appendChild(row2);
+	return {
+		element: toolbar,
+		ctrlState
+	};
+}
+
+//#endregion
+//#region src/viewport/landscape.ts
+/**
+* Detect landscape orientation + keyboard open state.
+* In landscape with keyboard, hides row 2 and shrinks buttons via CSS class.
+*/
+function checkLandscapeKeyboard(toolbar) {
+	const vp = window.visualViewport;
+	if (!vp) return;
+	const kbOpen = window.innerHeight - vp.height > KB_THRESHOLD;
+	const landscape = window.innerWidth > window.innerHeight;
+	if (kbOpen && landscape) toolbar.classList.add("wt-kb-open");
+	else toolbar.classList.remove("wt-kb-open");
+}
+
+//#endregion
+//#region src/viewport/height.ts
+function viewportHeight(vp, fallbackHeight, includeOffsetTop) {
+	if (!vp) return fallbackHeight;
+	return includeOffsetTop ? vp.height + vp.offsetTop : vp.height;
+}
+function lockDocumentHeight(height) {
+	document.documentElement.style.setProperty("height", height, "important");
+	document.documentElement.style.setProperty("max-height", height, "important");
+	document.documentElement.style.setProperty("overflow", "hidden", "important");
+	document.documentElement.style.setProperty("overscroll-behavior", "none", "important");
+	document.body.style.setProperty("min-height", "0", "important");
+	document.body.style.setProperty("height", height, "important");
+	document.body.style.setProperty("max-height", height, "important");
+	document.body.style.setProperty("overflow", "hidden", "important");
+	document.body.style.setProperty("overscroll-behavior", "none", "important");
+}
+/**
+* Manage terminal height to account for the toolbar and virtual keyboard.
+* Uses visualViewport API when available for accurate keyboard detection.
+*/
+function initHeightManager(toolbar) {
+	let pendingResize = 0;
+	function updateHeight() {
+		pendingResize = 0;
+		checkLandscapeKeyboard(toolbar);
+		const vp = window.visualViewport;
+		const kbOpen = isKeyboardOpen();
+		lockDocumentHeight(`${viewportHeight(vp, window.innerHeight, kbOpen) - (kbOpen ? 0 : toolbar.offsetHeight || 90)}px`);
+		resizeTerm();
+	}
+	function scheduleResize() {
+		if (!pendingResize) pendingResize = requestAnimationFrame(updateHeight);
+	}
+	if (window.visualViewport) {
+		window.visualViewport.addEventListener("resize", scheduleResize);
+		window.visualViewport.addEventListener("scroll", scheduleResize);
+	}
+	window.addEventListener("resize", scheduleResize);
+	window.addEventListener("orientationchange", () => {
+		setTimeout(scheduleResize, 200);
+	});
+	scheduleResize();
+}
+
+//#endregion
+//#region src/index.ts
+/** Detect touch device */
+function isMobile() {
+	return "ontouchstart" in window || navigator.maxTouchPoints > 0;
+}
+/**
+* Initialise the remobi overlay.
+* Called automatically when loaded in a browser (via the IIFE in build output).
+* Config is embedded at build time.
+*/
+function init(config = defaultConfig, hooks = createHookRegistry()) {
+	waitForTerm().then(async (term) => {
+		const disposeReconnect = setupReconnect(term, config.reconnect);
+		const mobile = isMobile();
+		const actions = createDefaultActionRegistry();
+		let disposed = false;
+		function dispose() {
+			if (disposed) return;
+			disposed = true;
+			disposeReconnect();
+			window.removeEventListener("pagehide", onPageHide);
+		}
+		function onPageHide(event) {
+			if (event.persisted) return;
+			dispose();
+		}
+		window.addEventListener("beforeunload", dispose, { once: true });
+		window.addEventListener("pagehide", onPageHide);
+		try {
+			await hooks.runOverlayInitStart({
+				term,
+				config,
+				mobile
+			});
+			document.fonts.ready.then(() => resizeTerm()).catch(() => {});
+			document.title = `${config.name} · ${location.hostname.replace(/\..*/, "")}`;
+			if (!mobile) {
+				await hooks.runOverlayReady({
+					term,
+					config,
+					mobile
+				});
+				return;
+			}
+			applyTheme(term, config.theme);
+			term.options.fontSize = config.font.mobileSizeDefault;
+			term.options.fontFamily = config.font.family;
+			resizeTerm();
+			const comboPicker = createComboPicker();
+			document.body.appendChild(comboPicker.element);
+			const drawer = createDrawer(term, config.drawer.buttons, {
+				hooks,
+				appConfig: config,
+				actions,
+				openComboPicker: comboPicker.open
+			});
+			document.body.appendChild(drawer.backdrop);
+			document.body.appendChild(drawer.drawer);
+			await hooks.runDrawerCreated({
+				term,
+				config,
+				drawer: drawer.drawer,
+				backdrop: drawer.backdrop
+			});
+			const { element: toolbar } = createToolbar(term, config, drawer.open, hooks, actions, comboPicker.open);
+			document.body.appendChild(toolbar);
+			await hooks.runToolbarCreated({
+				term,
+				config,
+				toolbar
+			});
+			const { element: fontControls, helpButton } = createFontControls(term, config.font);
+			document.body.appendChild(fontControls);
+			if (config.floatingButtons.length > 0) {
+				const { elements: floatingEls } = createFloatingButtons(term, config.floatingButtons, config, hooks, actions, drawer.open, comboPicker.open);
+				for (const floatingEl of floatingEls) document.body.appendChild(floatingEl);
+			}
+			const { element: scrollButtons } = createScrollButtons(term, config.gestures.scroll);
+			document.body.appendChild(scrollButtons);
+			const gestureLock = createGestureLock();
+			if (config.gestures.swipe.enabled) {
+				const indicator = attachSwipeGestures(term, config.gestures.swipe, drawer.isOpen);
+				document.body.appendChild(indicator);
+			}
+			if (config.gestures.pinch.enabled) attachPinchGestures(term, config.font, gestureLock);
+			if (config.gestures.scroll.enabled) attachScrollGesture(term, config.gestures.scroll, gestureLock, drawer.isOpen);
+			initHeightManager(toolbar);
+			if (config.mobile.initData !== null && window.innerWidth < config.mobile.widthThreshold) {
+				const data = config.mobile.initData;
+				const before = await hooks.runBeforeSendData({
+					term,
+					config,
+					source: "mobile-init",
+					actionType: "send",
+					kbWasOpen: false,
+					data
+				});
+				if (!before.blocked) {
+					sendData(term, before.data);
+					await hooks.runAfterSendData({
+						term,
+						config,
+						source: "mobile-init",
+						actionType: "send",
+						kbWasOpen: false,
+						data: before.data
+					});
+				}
+			}
+			try {
+				const { element: helpOverlay } = createHelpOverlay(term, helpButton, config);
+				document.body.appendChild(helpOverlay);
+			} catch (error) {
+				console.error("remobi: failed to initialise help overlay", error);
+			}
+			await hooks.runOverlayReady({
+				term,
+				config,
+				mobile
+			});
+		} catch (error) {
+			dispose();
+			throw error;
+		}
+	}).catch((error) => {
+		console.error("remobi: failed to initialise overlay", error);
+	});
+}
+
+//#endregion
+export { createHookRegistry, defineConfig, init };
+//# sourceMappingURL=index.mjs.map