editprompt 1.7.0 → 2.0.0

package/dist/index.js

@@ -1,96 +1,411 @@
 #!/usr/bin/env node
 import { configureSync, getAnsiColorFormatter, getLogger, getTextFormatter, parseLogLevel, withFilter } from "@logtape/logtape";
 import { cli, define } from "gunshi";
-import { appendFileSync } from "node:fs";
+import { appendFileSync, existsSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import { exec, spawn } from "node:child_process";
+import Conf from "conf";
 import { createHash, randomBytes } from "node:crypto";
 import { createConnection } from "node:net";
-import Conf from "conf";
-import { exec, spawn } from "node:child_process";
 import { promisify } from "node:util";
 import clipboardy from "clipboardy";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
 
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) {
-		__defProp(target, name, {
-			get: all[name],
-			enumerable: true
-		});
-	}
-	if (!no_symbols) {
-		__defProp(target, Symbol.toStringTag, { value: "Module" });
-	}
-	return target;
-};
+//#region src/modules/conf.ts
+const projectName = process.env.NODE_ENV === "test" ? "editprompt-test" : "editprompt";
+const conf = new Conf({ projectName });
 
 //#endregion
-//#region src/modules/logger.ts
-function resolveLogFilePath(options) {
-	if (options.logFile) return options.logFile;
-	const envPath = process.env.EDITPROMPT_LOG_FILE;
-	if (envPath) return envPath;
-}
-function resolveFileLogLevel(options) {
-	if (options.verbose) return "debug";
-	const envLevel = process.env.EDITPROMPT_LOG_LEVEL;
-	if (envLevel) return parseLogLevel(envLevel);
-	return "info";
+//#region src/backends/stores.ts
+const VAR_EDITOR_PANE = "editor_pane";
+const VAR_IS_EDITOR = "is_editor";
+const VAR_TARGET_PANES = "target_panes";
+const VAR_QUOTE = "quote";
+/**
+* State kept in variables on the panes themselves (tmux pane options, niwaterm
+* tab variables). Variable names are `<prefix>editor_pane`, `<prefix>is_editor`,
+* `<prefix>target_panes` and `<prefix>quote`.
+*
+* The variables disappear with their pane, so forgetting an editor pane is a
+* no-op here: only the link on the target pane is cleared.
+*/
+function paneVariableStore(io, prefix) {
+	const name = (key) => `${prefix}${key}`;
+	const read = async (paneId, key) => (await io.get(paneId, name(key))).trim();
+	return {
+		getEditorPaneId: (targetPaneId) => read(targetPaneId, VAR_EDITOR_PANE),
+		setEditorPaneId: (targetPaneId, editorPaneId) => io.set(targetPaneId, name(VAR_EDITOR_PANE), editorPaneId),
+		removeEditorPaneId: (targetPaneId) => io.set(targetPaneId, name(VAR_EDITOR_PANE), ""),
+		isEditorPane: async (paneId) => await read(paneId, VAR_IS_EDITOR) === "1",
+		getTargetPaneIds: async (editorPaneId) => {
+			const value = await read(editorPaneId, VAR_TARGET_PANES);
+			if (value === "") return [];
+			return value.split(",").map((id) => id.trim());
+		},
+		setTargetPaneIds: async (editorPaneId, targetPaneIds) => {
+			await io.set(editorPaneId, name(VAR_IS_EDITOR), "1");
+			await io.set(editorPaneId, name(VAR_TARGET_PANES), targetPaneIds.join(","));
+		},
+		removeEditorPane: async () => {},
+		keepsEditorPaneMarks: true,
+		getQuote: (targetPaneId) => io.get(targetPaneId, name(VAR_QUOTE)),
+		setQuote: (targetPaneId, text) => io.set(targetPaneId, name(VAR_QUOTE), text),
+		removeQuote: (targetPaneId) => io.set(targetPaneId, name(VAR_QUOTE), "")
+	};
 }
-function resolveLogLevel(options) {
-	if (options.quiet) return null;
-	if (options.verbose) return "debug";
-	const envLevel = process.env.EDITPROMPT_LOG_LEVEL;
-	if (envLevel) return parseLogLevel(envLevel);
-	return "info";
+function readRecord(key) {
+	const data = conf.get(key);
+	return typeof data === "object" && data !== null && !Array.isArray(data) ? data : void 0;
 }
-function setupLogger(options = {}) {
-	const stderrLevel = resolveLogLevel(options);
-	const stderrFormatter = getAnsiColorFormatter({
-		timestamp: "time-timezone",
-		level: "ABBR"
+function setField(key, field, value) {
+	conf.set(key, {
+		...readRecord(key),
+		[field]: value
 	});
-	const rawStderrSink = (record) => {
-		process.stderr.write(stderrFormatter(record));
+}
+function removeField(key, field) {
+	const data = readRecord(key);
+	if (!data || !(field in data)) return;
+	const { [field]: _, ...remaining } = data;
+	if (Object.keys(remaining).length === 0) conf.delete(key);
+	else conf.set(key, remaining);
+}
+/**
+* State kept in editprompt's Conf storage, for backends whose panes cannot hold
+* variables. The layout is:
+*
+* - `<namespace>.targetPane.pane_<id>`: `{ editorPaneId?, quote_text? }`
+* - `<namespace>.editorPane.pane_<id>`: `{ targetPaneIds }`
+*
+* The namespace is resolved on every access so that it can depend on the
+* environment (Herdr scopes it to the session socket).
+*/
+function confStore(namespace, options = {}) {
+	const targetKey = (paneId) => `${namespace()}.targetPane.pane_${paneId}`;
+	const editorKey = (paneId) => `${namespace()}.editorPane.pane_${paneId}`;
+	const store = {
+		getEditorPaneId: async (targetPaneId) => {
+			const data = readRecord(targetKey(targetPaneId));
+			return data && "editorPaneId" in data ? String(data.editorPaneId) : "";
+		},
+		setEditorPaneId: async (targetPaneId, editorPaneId) => {
+			setField(targetKey(targetPaneId), "editorPaneId", editorPaneId);
+		},
+		removeEditorPaneId: async (targetPaneId) => {
+			removeField(targetKey(targetPaneId), "editorPaneId");
+		},
+		isEditorPane: async (paneId) => conf.has(editorKey(paneId)),
+		getTargetPaneIds: async (editorPaneId) => {
+			const targetPaneIds = readRecord(editorKey(editorPaneId))?.targetPaneIds;
+			return Array.isArray(targetPaneIds) ? targetPaneIds.map((id) => String(id)) : [];
+		},
+		setTargetPaneIds: async (editorPaneId, targetPaneIds) => {
+			conf.set(editorKey(editorPaneId), { targetPaneIds });
+		},
+		removeEditorPane: async (editorPaneId) => {
+			conf.delete(editorKey(editorPaneId));
+		},
+		getQuote: async (targetPaneId) => {
+			const data = readRecord(targetKey(targetPaneId));
+			return data && "quote_text" in data ? String(data.quote_text) : "";
+		},
+		setQuote: async (targetPaneId, text) => {
+			setField(targetKey(targetPaneId), "quote_text", text);
+		},
+		removeQuote: async (targetPaneId) => {
+			removeField(targetKey(targetPaneId), "quote_text");
+		}
 	};
-	const sinks = { stderr: stderrLevel === null ? () => {} : withFilter(rawStderrSink, stderrLevel) };
-	const loggerSinks = ["stderr"];
-	const logFilePath = resolveLogFilePath(options);
-	const fileLogLevel = resolveFileLogLevel(options);
-	if (logFilePath) try {
-		appendFileSync(logFilePath, "");
-		const fileFormatter = getTextFormatter({
-			timestamp: "date-time-timezone",
-			level: "ABBR"
-		});
-		const rawFileSink = (record) => {
-			appendFileSync(logFilePath, fileFormatter(record));
+	if (!options.wholeTargetRecord) return store;
+	const logger = getLogger([...options.logCategory ?? ["editprompt", "state"]]);
+	return swallowErrors(logger, {
+		...store,
+		setEditorPaneId: async (targetPaneId, editorPaneId) => {
+			logger.debug(`Saving editor pane ID to conf key: ${namespace()}.targetPane.pane_{targetPaneId}`, { targetPaneId });
+			conf.set(targetKey(targetPaneId), { editorPaneId });
+		},
+		removeEditorPaneId: async (targetPaneId) => {
+			conf.delete(targetKey(targetPaneId));
+		},
+		removeQuote: async (targetPaneId) => {
+			const key = `${targetKey(targetPaneId)}.quote_text`;
+			if (conf.has(key)) conf.delete(key);
+		}
+	});
+}
+const FAILURE_RESULTS = {
+	getEditorPaneId: "",
+	setEditorPaneId: void 0,
+	removeEditorPaneId: void 0,
+	isEditorPane: false,
+	getTargetPaneIds: [],
+	setTargetPaneIds: void 0,
+	removeEditorPane: void 0,
+	getQuote: "",
+	setQuote: void 0,
+	removeQuote: void 0
+};
+const LEGACY_METHOD_NAMES = {
+	getEditorPaneId: "getEditorPaneId",
+	setEditorPaneId: "saveEditorPaneId",
+	removeEditorPaneId: "clearEditorPaneId",
+	isEditorPane: "isEditorPaneFromConf",
+	getTargetPaneIds: "getTargetPaneIds",
+	setTargetPaneIds: "markAsEditorPane",
+	removeEditorPane: "clearEditorPaneId",
+	getQuote: "getQuoteText",
+	setQuote: "appendToQuoteText",
+	removeQuote: "clearQuoteText"
+};
+function swallowErrors(logger, store) {
+	const wrapped = {};
+	for (const method of Object.keys(FAILURE_RESULTS)) {
+		const call = store[method];
+		wrapped[method] = async (...args) => {
+			try {
+				return await call(...args);
+			} catch (error) {
+				logger.debug(`${LEGACY_METHOD_NAMES[method]} failed: {error}`, { error });
+				return FAILURE_RESULTS[method];
+			}
 		};
-		sinks.file = withFilter(rawFileSink, fileLogLevel);
-		loggerSinks.push("file");
-	} catch {
-		process.stderr.write(`Warning: Cannot write to log file '${logFilePath}', continuing without file logging.\n`);
 	}
-	configureSync({
-		sinks,
-		loggers: [{
-			category: ["editprompt"],
-			sinks: loggerSinks,
-			lowestLevel: "trace"
-		}, {
-			category: ["logtape", "meta"],
-			lowestLevel: null
-		}]
-	});
+	return wrapped;
 }
 
 //#endregion
-//#region package.json
-var version = "1.7.0";
+//#region src/backends/types.ts
+function canSplitPane(backend) {
+	return typeof backend.splitPane === "function" && typeof backend.runInPane === "function" && typeof backend.closePane === "function";
+}
+/** Identity helper that gives backend definitions full type checking. */
+function defineBackend(backend) {
+	return backend;
+}
+
+//#endregion
+//#region src/backends/command.ts
+const logger$16 = getLogger(["editprompt", "command-backend"]);
+const COMMAND_VARIABLES = {
+	currentPane: [],
+	paneExists: ["EDITPROMPT_PANE"],
+	focus: ["EDITPROMPT_PANE"],
+	sendText: ["EDITPROMPT_PANE"],
+	sendKey: ["EDITPROMPT_PANE", "EDITPROMPT_KEY"],
+	splitPane: [
+		"EDITPROMPT_PANE",
+		"EDITPROMPT_ROWS",
+		"EDITPROMPT_CWD"
+	],
+	runInPane: ["EDITPROMPT_PANE", "EDITPROMPT_COMMAND"],
+	closePane: ["EDITPROMPT_PANE"]
+};
+const COMMAND_VARIABLE_NAMES = new Set(Object.values(COMMAND_VARIABLES).flat());
+const REQUIRED_COMMANDS = [
+	"paneExists",
+	"focus",
+	"sendText",
+	"sendKey"
+];
+const OPTIONAL_COMMANDS = [
+	"splitPane",
+	"runInPane",
+	"closePane"
+];
+const KNOWN_FIELDS = new Set([
+	"detect",
+	"currentPane",
+	...REQUIRED_COMMANDS,
+	...OPTIONAL_COMMANDS,
+	"maxChunkBytes",
+	"submitKey",
+	"quoteSeparator",
+	"collectInput"
+]);
+const DEFAULT_MAX_CHUNK_BYTES = 8192;
+const SHELL = "/bin/sh";
+const VARIABLE_PATTERN = /\$\{?(EDITPROMPT_[A-Z_]+)/g;
+var CommandBackendConfigError = class extends Error {
+	name = "CommandBackendConfigError";
+};
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseScript(value, path, field, errors) {
+	if (typeof value !== "string" || value.trim() === "") {
+		errors.push(`${path} must be a non-empty string`);
+		return;
+	}
+	const allowed = COMMAND_VARIABLES[field];
+	const reported = /* @__PURE__ */ new Set();
+	for (const [, name] of value.matchAll(VARIABLE_PATTERN)) {
+		const variable = name;
+		if (COMMAND_VARIABLE_NAMES.has(variable) && !allowed.includes(variable)) {
+			if (!reported.has(variable)) {
+				reported.add(variable);
+				const hint = allowed.length > 0 ? ` (available: ${allowed.map((n) => `$${n}`).join(", ")})` : "";
+				errors.push(`${path} uses $${variable}, which is not set for this command${hint}`);
+			}
+		}
+	}
+	return {
+		path,
+		source: value
+	};
+}
+function readEnvRef(value) {
+	if (isRecord(value) && Object.keys(value).length === 1 && typeof value.env === "string") return value.env;
+}
+function shellQuote(value) {
+	return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function runScript(script, values, input) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(SHELL, ["-c", script.source], {
+			env: {
+				...process.env,
+				...values
+			},
+			stdio: [
+				input === void 0 ? "ignore" : "pipe",
+				"pipe",
+				"pipe"
+			]
+		});
+		let stdout = "";
+		let stderr = "";
+		child.stdout?.setEncoding("utf8");
+		child.stdout?.on("data", (chunk) => {
+			stdout += chunk;
+		});
+		child.stderr?.setEncoding("utf8");
+		child.stderr?.on("data", (chunk) => {
+			stderr += chunk;
+		});
+		child.on("error", (error) => {
+			reject(/* @__PURE__ */ new Error(`Failed to run ${script.path}: ${error.message}`));
+		});
+		child.on("close", (code) => {
+			resolve({
+				code,
+				stdout,
+				stderr
+			});
+		});
+		if (input !== void 0) {
+			child.stdin?.on("error", (error) => {
+				reject(/* @__PURE__ */ new Error(`Failed to write to ${script.path}: ${error.message}`));
+			});
+			child.stdin?.end(input);
+		}
+	});
+}
+async function runChecked(script, values, input) {
+	const result = await runScript(script, values, input);
+	if (result.code !== 0) throw new Error(`${script.path} exited with ${result.code}: ${result.stderr.trim()}`);
+	return result.stdout;
+}
+/**
+* Validates a backend declared in the configuration file and builds it.
+* Throws CommandBackendConfigError listing every problem found.
+*/
+function createCommandBackend(name, spec) {
+	const path = `backends.${name}`;
+	const errors = [];
+	if (!/^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(name)) errors.push(`${path}: the name may only contain letters, digits, "-" and "_"`);
+	if (!isRecord(spec)) throw new CommandBackendConfigError(`${path} must be an object`);
+	for (const key of Object.keys(spec)) if (!KNOWN_FIELDS.has(key)) errors.push(`${path}.${key} is not a known option`);
+	let detectEnv;
+	if (spec.detect !== void 0) {
+		detectEnv = readEnvRef(spec.detect);
+		if (detectEnv === void 0) errors.push(`${path}.detect must be { env = "VARIABLE_NAME" }`);
+	}
+	const currentPaneEnv = readEnvRef(spec.currentPane);
+	let currentPaneScript;
+	if (spec.currentPane === void 0) errors.push(`${path}.currentPane is required`);
+	else if (currentPaneEnv === void 0) currentPaneScript = parseScript(spec.currentPane, `${path}.currentPane`, "currentPane", errors);
+	const commands = {};
+	for (const field of REQUIRED_COMMANDS) if (spec[field] === void 0) errors.push(`${path}.${field} is required`);
+	else commands[field] = parseScript(spec[field], `${path}.${field}`, field, errors);
+	const optionalCount = OPTIONAL_COMMANDS.filter((field) => spec[field] !== void 0).length;
+	if (optionalCount > 0 && optionalCount < OPTIONAL_COMMANDS.length) errors.push(`${path}: splitPane, runInPane and closePane must be set together`);
+	for (const field of OPTIONAL_COMMANDS) if (spec[field] !== void 0) commands[field] = parseScript(spec[field], `${path}.${field}`, field, errors);
+	const maxChunkBytes = spec.maxChunkBytes ?? DEFAULT_MAX_CHUNK_BYTES;
+	if (typeof maxChunkBytes !== "number" || !Number.isInteger(maxChunkBytes) || maxChunkBytes < 4) errors.push(`${path}.maxChunkBytes must be an integer of at least 4`);
+	const submitKey = spec.submitKey ?? "Enter";
+	if (typeof submitKey !== "string" || submitKey === "") errors.push(`${path}.submitKey must be a non-empty string`);
+	const quoteSeparator = spec.quoteSeparator ?? "\n\n";
+	if (typeof quoteSeparator !== "string") errors.push(`${path}.quoteSeparator must be a string`);
+	const collectInput = spec.collectInput ?? "argument";
+	if (collectInput !== "stdin" && collectInput !== "argument") errors.push(`${path}.collectInput must be "stdin" or "argument"`);
+	if (errors.length > 0) throw new CommandBackendConfigError(errors.join("\n"));
+	const command = (field) => commands[field];
+	const namespace = () => `state.${name}`;
+	const backend = defineBackend({
+		name,
+		detect: detectEnv ? (env) => (env[detectEnv]?.trim() ?? "") !== "" : void 0,
+		getCurrentPaneId: async () => {
+			if (currentPaneEnv !== void 0) {
+				const paneId = process.env[currentPaneEnv]?.trim();
+				if (!paneId) throw new Error(`${currentPaneEnv} is not set`);
+				return paneId;
+			}
+			return (await runChecked(currentPaneScript, {})).trim();
+		},
+		paneExists: async (paneId) => {
+			try {
+				return (await runScript(command("paneExists"), { EDITPROMPT_PANE: paneId })).code === 0;
+			} catch (error) {
+				logger$16.debug("paneExists failed: {error}", { error });
+				return false;
+			}
+		},
+		focusPane: async (paneId) => {
+			await runChecked(command("focus"), { EDITPROMPT_PANE: paneId });
+		},
+		sendText: async (paneId, chunk) => {
+			await runChecked(command("sendText"), { EDITPROMPT_PANE: paneId }, chunk);
+		},
+		sendKey: async (paneId, key) => {
+			await runChecked(command("sendKey"), {
+				EDITPROMPT_PANE: paneId,
+				EDITPROMPT_KEY: key
+			});
+		},
+		maxChunkBytes,
+		defaultSubmitKey: submitKey,
+		quoteSeparator,
+		collectInput,
+		storageNamespace: namespace,
+		resumeAcceptsEditorPane: true,
+		keepNewerEditorLink: true,
+		quietResumeErrors: "all",
+		state: confStore(namespace)
+	});
+	if (commands.splitPane && commands.runInPane && commands.closePane) {
+		const { splitPane, runInPane, closePane } = commands;
+		backend.splitPane = async (targetPaneId, options) => {
+			const paneId = (await runChecked(splitPane, {
+				EDITPROMPT_PANE: targetPaneId,
+				EDITPROMPT_ROWS: String(options.rows),
+				EDITPROMPT_CWD: options.cwd ?? process.cwd()
+			})).trim();
+			if (paneId === "") throw new Error(`${path}.splitPane did not print the new pane ID`);
+			return paneId;
+		};
+		backend.runInPane = async (paneId, argv) => {
+			await runChecked(runInPane, {
+				EDITPROMPT_PANE: paneId,
+				EDITPROMPT_COMMAND: argv.map(shellQuote).join(" ")
+			});
+		};
+		backend.closePane = async (paneId) => {
+			await runChecked(closePane, { EDITPROMPT_PANE: paneId });
+		};
+	}
+	return backend;
+}
 
 //#endregion
 //#region src/config/constants.ts
@@ -103,65 +418,12 @@ const WEZTERM_SEND_CHUNK_BYTES = TMUX_SEND_CHUNK_BYTES;
 const HERDR_REQUEST_LIMIT_BYTES = 1024 * 1024;
 const HERDR_SEND_CHUNK_BYTES = HERDR_REQUEST_LIMIT_BYTES / 8;
 const NIWATERM_SEND_CHUNK_BYTES = WEZTERM_SEND_CHUNK_BYTES;
-
-//#endregion
-//#region src/utils/contentChunker.ts
-/**
-* Split content into chunks not exceeding maxBytes (UTF-8 byte count),
-* never breaking a Unicode code point across chunks.
-*
-* Content shorter than maxBytes is returned as a single chunk, so short
-* input keeps the previous behavior of being sent in one shot.
-*/
-function splitByByteSize(content, maxBytes) {
-	if (content === "") return [];
-	const chunks = [];
-	let current = "";
-	let currentBytes = 0;
-	for (const char of content) {
-		const charBytes = Buffer.byteLength(char, "utf8");
-		if (current !== "" && currentBytes + charBytes > maxBytes) {
-			chunks.push(current);
-			current = "";
-			currentBytes = 0;
-		}
-		current += char;
-		currentBytes += charBytes;
-	}
-	if (current !== "") chunks.push(current);
-	return chunks;
-}
-
-//#endregion
-//#region src/modules/conf.ts
-const projectName = process.env.NODE_ENV === "test" ? "editprompt-test" : "editprompt";
-const conf = new Conf({ projectName });
+const REX_CONTROL_LIMIT_BYTES = 64 * 1024;
+const REX_SEND_CHUNK_BYTES = REX_CONTROL_LIMIT_BYTES / 8;
 
 //#endregion
 //#region src/modules/herdr.ts
-var herdr_exports = /* @__PURE__ */ __exportAll({
-	appendToQuoteText: () => appendToQuoteText$1,
-	calculateEditorSplitRatio: () => calculateEditorSplitRatio,
-	checkPaneExists: () => checkPaneExists$3,
-	clearEditorPaneId: () => clearEditorPaneId$3,
-	clearQuoteText: () => clearQuoteText$1,
-	closePane: () => closePane,
-	focusPane: () => focusPane$3,
-	getCurrentPaneId: () => getCurrentPaneId$3,
-	getEditorPaneId: () => getEditorPaneId$3,
-	getQuoteText: () => getQuoteText$1,
-	getStorageNamespace: () => getStorageNamespace,
-	getTargetPaneIds: () => getTargetPaneIds$3,
-	inputToHerdrPane: () => inputToHerdrPane,
-	isEditorPaneFromConf: () => isEditorPaneFromConf$1,
-	markAsEditorPane: () => markAsEditorPane$3,
-	resumeEditorPane: () => resumeEditorPane,
-	runCommandInPane: () => runCommandInPane,
-	saveEditorPaneId: () => saveEditorPaneId$3,
-	sendKeyToHerdrPane: () => sendKeyToHerdrPane,
-	splitEditorPane: () => splitEditorPane
-});
-const logger$14 = getLogger(["editprompt", "herdr"]);
+const logger$15 = getLogger(["editprompt", "herdr"]);
 const HERDR_REQUEST_TIMEOUT_MS = 6e3;
 let requestSequence = 0;
 function getSocketPath() {
@@ -242,27 +504,21 @@ async function sendRequest(method, params) {
 function getStorageNamespace() {
 	return `herdr.session_${createHash("sha256").update(getSocketPath()).digest("hex").slice(0, 16)}`;
 }
-function targetPaneKey(paneId) {
-	return `${getStorageNamespace()}.targetPane.pane_${paneId}`;
-}
-function editorPaneKey(paneId) {
-	return `${getStorageNamespace()}.editorPane.pane_${paneId}`;
-}
-async function getCurrentPaneId$3() {
+async function getCurrentPaneId$4() {
 	const paneId = process.env.HERDR_PANE_ID?.trim() || process.env.HERDR_ACTIVE_PANE_ID?.trim();
 	if (!paneId) throw new Error("HERDR_PANE_ID or HERDR_ACTIVE_PANE_ID is not set");
 	return paneId;
 }
-async function checkPaneExists$3(paneId) {
+async function checkPaneExists$4(paneId) {
 	try {
 		await sendRequest("pane.get", { pane_id: paneId });
 		return true;
 	} catch (error) {
-		logger$14.debug("checkPaneExists failed: {error}", { error });
+		logger$15.debug("checkPaneExists failed: {error}", { error });
 		return false;
 	}
 }
-async function focusPane$3(paneId) {
+async function focusPane$4(paneId) {
 	await sendRequest("pane.focus", { pane_id: paneId });
 }
 function calculateEditorSplitRatio(paneHeight, editorPaneRows) {
@@ -299,123 +555,73 @@ async function runCommandInPane(paneId, argv) {
 async function closePane(paneId) {
 	await sendRequest("pane.close", { pane_id: paneId });
 }
-async function inputToHerdrPane(paneId, content) {
-	const chunks = splitByByteSize(content, HERDR_SEND_CHUNK_BYTES);
-	for (const chunk of chunks) await sendRequest("pane.send_text", {
+async function sendTextChunk$4(paneId, chunk) {
+	await sendRequest("pane.send_text", {
 		pane_id: paneId,
 		text: chunk
 	});
-	logger$14.debug("Content sent to Herdr pane: {paneId} ({chunkCount} chunks)", {
-		paneId,
-		chunkCount: chunks.length
-	});
 }
-async function sendKeyToHerdrPane(paneId, key, delay = 1e3) {
-	await new Promise((resolve) => setTimeout(resolve, delay));
+async function sendKey$4(paneId, key) {
 	await sendRequest("pane.send_keys", {
 		pane_id: paneId,
 		keys: [key]
 	});
 }
-async function saveEditorPaneId$3(targetPaneId, editorPaneId) {
-	const data = conf.get(targetPaneKey(targetPaneId));
-	const existing = typeof data === "object" && data !== null ? data : {};
-	conf.set(targetPaneKey(targetPaneId), {
-		...existing,
-		editorPaneId
+function logContentSent$4(paneId, chunkCount) {
+	logger$15.debug("Content sent to Herdr pane: {paneId} ({chunkCount} chunks)", {
+		paneId,
+		chunkCount
 	});
 }
-async function getEditorPaneId$3(targetPaneId) {
-	const data = conf.get(targetPaneKey(targetPaneId));
-	if (typeof data === "object" && data !== null && "editorPaneId" in data) return String(data.editorPaneId);
-	return "";
-}
-async function clearEditorPaneId$3(targetPaneId, expectedEditorPaneId) {
-	const editorPaneId = await getEditorPaneId$3(targetPaneId);
-	if (expectedEditorPaneId && editorPaneId !== expectedEditorPaneId) {
-		conf.delete(editorPaneKey(expectedEditorPaneId));
-		return;
-	}
-	const data = conf.get(targetPaneKey(targetPaneId));
-	if (typeof data === "object" && data !== null && "editorPaneId" in data) {
-		const { editorPaneId: _, ...remaining } = data;
-		if (Object.keys(remaining).length === 0) conf.delete(targetPaneKey(targetPaneId));
-		else conf.set(targetPaneKey(targetPaneId), remaining);
-	}
-	if (editorPaneId) conf.delete(editorPaneKey(editorPaneId));
-}
-async function markAsEditorPane$3(editorPaneId, targetPaneIds) {
-	const uniqueTargetPaneIds = [...new Set(targetPaneIds)];
-	conf.set(editorPaneKey(editorPaneId), { targetPaneIds: uniqueTargetPaneIds });
-	for (const targetPaneId of uniqueTargetPaneIds) await saveEditorPaneId$3(targetPaneId, editorPaneId);
-}
-async function getTargetPaneIds$3(editorPaneId) {
-	const data = conf.get(editorPaneKey(editorPaneId));
-	if (typeof data === "object" && data !== null && "targetPaneIds" in data) {
-		const targetPaneIds = data.targetPaneIds;
-		if (Array.isArray(targetPaneIds)) return targetPaneIds.map((id) => String(id));
-	}
-	return [];
-}
-function isEditorPaneFromConf$1(paneId) {
-	return conf.has(editorPaneKey(paneId));
-}
-async function resumeEditorPane(targetPaneId) {
-	const currentPaneId = await getCurrentPaneId$3();
-	const editorPaneId = isEditorPaneFromConf$1(currentPaneId) ? currentPaneId : isEditorPaneFromConf$1(targetPaneId) ? targetPaneId : "";
-	if (editorPaneId) {
-		const targetPaneIds = await getTargetPaneIds$3(editorPaneId);
-		for (const paneId of targetPaneIds) if (await checkPaneExists$3(paneId)) {
-			await focusPane$3(paneId);
-			return true;
-		}
-		return false;
-	}
-	const registeredEditorPaneId = await getEditorPaneId$3(targetPaneId);
-	if (registeredEditorPaneId === "") return false;
-	if (!await checkPaneExists$3(registeredEditorPaneId)) {
-		await clearEditorPaneId$3(targetPaneId);
-		return false;
-	}
-	await focusPane$3(registeredEditorPaneId);
-	return true;
+
+//#endregion
+//#region src/backends/env.ts
+function hasValue(value) {
+	return typeof value === "string" && value.trim() !== "";
 }
-async function appendToQuoteText$1(paneId, content) {
-	const data = conf.get(targetPaneKey(paneId));
-	const existing = typeof data === "object" && data !== null ? data : {};
-	const existingQuoteText = "quote_text" in existing ? String(existing.quote_text) : "";
-	const quoteText = existingQuoteText.trim() !== "" ? `${existingQuoteText}\n\n${content}` : content;
-	conf.set(targetPaneKey(paneId), {
-		...existing,
-		quote_text: quoteText
-	});
+function isHerdrEnvironment(env = process.env) {
+	return hasValue(env.HERDR_SOCKET_PATH) && (hasValue(env.HERDR_PANE_ID) || hasValue(env.HERDR_ACTIVE_PANE_ID));
 }
-async function getQuoteText$1(paneId) {
-	const data = conf.get(targetPaneKey(paneId));
-	if (typeof data === "object" && data !== null && "quote_text" in data) return String(data.quote_text);
-	return "";
+function isNiwatermEnvironment(env = process.env) {
+	return hasValue(env.NIWATERM_TAB_ID);
 }
-async function clearQuoteText$1(paneId) {
-	const data = conf.get(targetPaneKey(paneId));
-	if (typeof data === "object" && data !== null && "quote_text" in data) {
-		const { quote_text: _, ...remaining } = data;
-		if (Object.keys(remaining).length === 0) conf.delete(targetPaneKey(paneId));
-		else conf.set(targetPaneKey(paneId), remaining);
-	}
+function isRexEnvironment(env = process.env) {
+	return hasValue(env.REX_BLOCK);
 }
 
+//#endregion
+//#region src/backends/herdr.ts
+const herdrBackend = defineBackend({
+	name: "herdr",
+	detect: (env) => isHerdrEnvironment(env),
+	getCurrentPaneId: () => getCurrentPaneId$4(),
+	paneExists: (paneId) => checkPaneExists$4(paneId),
+	focusPane: (paneId) => focusPane$4(paneId),
+	sendText: (paneId, chunk) => sendTextChunk$4(paneId, chunk),
+	sendKey: (paneId, key) => sendKey$4(paneId, key),
+	logContentSent: (paneId, chunkCount) => logContentSent$4(paneId, chunkCount),
+	maxChunkBytes: HERDR_SEND_CHUNK_BYTES,
+	defaultSubmitKey: "enter",
+	quoteSeparator: "\n\n",
+	collectInput: "argument",
+	quietResumeErrors: "all",
+	resumeAcceptsEditorPane: true,
+	keepNewerEditorLink: true,
+	storageNamespace: () => getStorageNamespace(),
+	state: confStore(() => getStorageNamespace()),
+	splitPane: (targetPaneId, { rows, cwd, env }) => splitEditorPane(targetPaneId, rows, cwd ?? process.env.HERDR_ACTIVE_PANE_CWD, env),
+	runInPane: (paneId, argv) => runCommandInPane(paneId, argv),
+	closePane: (paneId) => closePane(paneId)
+});
+
 //#endregion
 //#region src/modules/niwaterm.ts
 const execAsync$2 = promisify(exec);
-const logger$13 = getLogger(["editprompt", "niwaterm"]);
-const VAR_EDITOR_PANE = "editprompt_editor_pane";
-const VAR_IS_EDITOR = "editprompt_is_editor";
-const VAR_TARGET_PANES = "editprompt_target_panes";
-const VAR_QUOTE = "editprompt_quote";
+const logger$14 = getLogger(["editprompt", "niwaterm"]);
 function quoteShellWord(value) {
 	return `'${value.replace(/'/g, "'\\''")}'`;
 }
-async function getCurrentPaneId$2() {
+async function getCurrentPaneId$3() {
 	const tabId = process.env.NIWATERM_TAB_ID?.trim();
 	if (!tabId) throw new Error("NIWATERM_TAB_ID is not set");
 	return tabId;
@@ -425,71 +631,184 @@ async function getTabVar(tabId, key) {
 		const { stdout } = await execAsync$2(`niwa tab var get -t ${quoteShellWord(tabId)} ${quoteShellWord(key)}`);
 		return stdout.trim();
 	} catch (error) {
-		logger$13.debug("getTabVar failed: {error}", { error });
+		logger$14.debug("getTabVar failed: {error}", { error });
 		return "";
 	}
 }
 async function setTabVar(tabId, key, value) {
 	await execAsync$2(`niwa tab var set -t ${quoteShellWord(tabId)} ${quoteShellWord(key)} ${quoteShellWord(value)}`);
 }
-async function checkPaneExists$2(paneId) {
+async function checkPaneExists$3(paneId) {
 	try {
 		await execAsync$2(`niwa tab var list -t ${quoteShellWord(paneId)}`);
 		return true;
 	} catch (error) {
-		logger$13.debug("checkPaneExists failed: {error}", { error });
+		logger$14.debug("checkPaneExists failed: {error}", { error });
 		return false;
 	}
 }
-async function focusPane$2(paneId) {
+async function focusPane$3(paneId) {
 	await execAsync$2(`niwa tab focus -t ${quoteShellWord(paneId)}`);
 }
-async function saveEditorPaneId$2(targetPaneId, editorPaneId) {
-	await setTabVar(targetPaneId, VAR_EDITOR_PANE, editorPaneId);
-}
-async function clearEditorPaneId$2(targetPaneId) {
-	await setTabVar(targetPaneId, VAR_EDITOR_PANE, "");
-}
-async function getEditorPaneId$2(targetPaneId) {
-	return getTabVar(targetPaneId, VAR_EDITOR_PANE);
-}
-async function markAsEditorPane$2(editorPaneId, targetPaneIds) {
-	const uniqueTargetPaneIds = [...new Set(targetPaneIds)];
-	await setTabVar(editorPaneId, VAR_IS_EDITOR, "1");
-	await setTabVar(editorPaneId, VAR_TARGET_PANES, uniqueTargetPaneIds.join(","));
-	for (const targetPaneId of uniqueTargetPaneIds) await saveEditorPaneId$2(targetPaneId, editorPaneId);
+async function sendKey$3(paneId, key) {
+	await execAsync$2(`niwa tab send-keys -t ${quoteShellWord(paneId)} ${quoteShellWord(key)}`);
 }
-async function getTargetPaneIds$2(editorPaneId) {
-	const value = await getTabVar(editorPaneId, VAR_TARGET_PANES);
-	if (value === "") return [];
-	return value.split(",").map((id) => id.trim());
+async function sendTextChunk$3(paneId, chunk) {
+	await execAsync$2(`niwa tab send-keys -t ${quoteShellWord(paneId)} -- ${quoteShellWord(chunk)}`);
 }
-async function isEditorPane$1(paneId) {
-	return await getTabVar(paneId, VAR_IS_EDITOR) === "1";
+function logContentSent$3(paneId, chunkCount) {
+	logger$14.debug("Content sent to niwaterm pane: {paneId} ({chunks} chunk(s))", {
+		paneId,
+		chunks: chunkCount
+	});
 }
-async function getQuoteVariableContent$1(paneId) {
-	return getTabVar(paneId, VAR_QUOTE);
+
+//#endregion
+//#region src/backends/niwaterm.ts
+const niwatermBackend = defineBackend({
+	name: "niwaterm",
+	detect: (env) => isNiwatermEnvironment(env),
+	getCurrentPaneId: () => getCurrentPaneId$3(),
+	paneExists: (paneId) => checkPaneExists$3(paneId),
+	focusPane: (paneId) => focusPane$3(paneId),
+	sendText: (paneId, chunk) => sendTextChunk$3(paneId, chunk),
+	sendKey: (paneId, key) => sendKey$3(paneId, key),
+	logContentSent: (paneId, chunkCount) => logContentSent$3(paneId, chunkCount),
+	maxChunkBytes: NIWATERM_SEND_CHUNK_BYTES,
+	defaultSubmitKey: "C-m",
+	quoteSeparator: "\n",
+	collectInput: "argument",
+	quietResumeErrors: "editorFocus",
+	traceResume: true,
+	storageNamespace: () => "niwaterm",
+	state: paneVariableStore({
+		get: (paneId, name) => getTabVar(paneId, name),
+		set: (paneId, name, value) => setTabVar(paneId, name, value)
+	}, "editprompt_")
+});
+
+//#endregion
+//#region src/modules/rex.ts
+const logger$13 = getLogger(["editprompt", "rex"]);
+const REX_COMMAND = "rex";
+const REX_GLOBAL_ARGS = ["--autostart=false"];
+function rexCommand() {
+	const binDir = process.env.REX_BIN_DIR?.trim();
+	return binDir ? join(binDir, REX_COMMAND) : REX_COMMAND;
+}
+function rexArgs(args) {
+	return [...REX_GLOBAL_ARGS, ...args];
+}
+function runRex(args, input) {
+	const command = rexCommand();
+	const argv = rexArgs(args);
+	return new Promise((resolve, reject) => {
+		const child = spawn(command, argv, { stdio: [
+			input === void 0 ? "ignore" : "pipe",
+			"pipe",
+			"pipe"
+		] });
+		let stdout = "";
+		let stderr = "";
+		child.stdout?.setEncoding("utf8");
+		child.stdout?.on("data", (chunk) => {
+			stdout += chunk;
+		});
+		child.stderr?.setEncoding("utf8");
+		child.stderr?.on("data", (chunk) => {
+			stderr += chunk;
+		});
+		child.on("error", (error) => {
+			reject(/* @__PURE__ */ new Error(`Failed to run rex: ${error.message}`));
+		});
+		child.on("close", (code) => {
+			if (code === 0) {
+				resolve(stdout);
+				return;
+			}
+			reject(/* @__PURE__ */ new Error(`rex ${argv.join(" ")} exited with ${code}: ${stderr.trim()}`));
+		});
+		if (input !== void 0) {
+			if (!child.stdin) {
+				reject(/* @__PURE__ */ new Error("rex was started without a standard input to write to"));
+				return;
+			}
+			child.stdin.on("error", (error) => {
+				reject(/* @__PURE__ */ new Error(`Failed to write to rex: ${error.message}`));
+			});
+			child.stdin.end(input);
+		}
+	});
 }
-async function appendToQuoteVariable$1(paneId, content) {
-	const existingContent = await getQuoteVariableContent$1(paneId);
-	await setTabVar(paneId, VAR_QUOTE, existingContent.trim() !== "" ? `${existingContent}\n${content}` : content);
+async function getCurrentPaneId$2() {
+	const paneId = process.env.REX_BLOCK?.trim();
+	if (!paneId) throw new Error("REX_BLOCK is not set");
+	return paneId;
 }
-async function clearQuoteVariable$1(paneId) {
-	await setTabVar(paneId, VAR_QUOTE, "");
+async function checkPaneExists$2(paneId) {
+	try {
+		await runRex([
+			"block",
+			"inspect",
+			paneId,
+			"--json"
+		]);
+		return true;
+	} catch (error) {
+		logger$13.debug("checkPaneExists failed: {error}", { error });
+		return false;
+	}
 }
-async function sendKeyToNiwatermPane(paneId, key, delay = 1e3) {
-	await new Promise((resolve) => setTimeout(resolve, delay));
-	await execAsync$2(`niwa tab send-keys -t ${quoteShellWord(paneId)} ${quoteShellWord(key)}`);
+async function focusPane$2(paneId) {
+	await runRex([
+		"block",
+		"focus",
+		paneId
+	]);
+}
+async function sendTextChunk$2(paneId, chunk) {
+	await runRex([
+		"send",
+		"-b",
+		paneId
+	], chunk);
+}
+async function sendKey$2(paneId, key) {
+	await runRex([
+		"send-key",
+		"-b",
+		paneId,
+		key
+	]);
 }
-async function inputToNiwatermPane(paneId, content) {
-	const chunks = splitByByteSize(content, NIWATERM_SEND_CHUNK_BYTES);
-	for (const chunk of chunks) await execAsync$2(`niwa tab send-keys -t ${quoteShellWord(paneId)} ${quoteShellWord(chunk)}`);
-	logger$13.debug("Content sent to niwaterm pane: {paneId} ({chunks} chunk(s))", {
+function logContentSent$2(paneId, chunkCount) {
+	logger$13.debug("Content sent to Rex pane: {paneId} ({chunks} chunk(s))", {
 		paneId,
-		chunks: chunks.length
+		chunks: chunkCount
 	});
 }
 
+//#endregion
+//#region src/backends/rex.ts
+const rexBackend = defineBackend({
+	name: "rex",
+	detect: (env) => isRexEnvironment(env),
+	getCurrentPaneId: () => getCurrentPaneId$2(),
+	paneExists: (paneId) => checkPaneExists$2(paneId),
+	focusPane: (paneId) => focusPane$2(paneId),
+	sendText: (paneId, chunk) => sendTextChunk$2(paneId, chunk),
+	sendKey: (paneId, key) => sendKey$2(paneId, key),
+	logContentSent: (paneId, chunkCount) => logContentSent$2(paneId, chunkCount),
+	maxChunkBytes: REX_SEND_CHUNK_BYTES,
+	defaultSubmitKey: "enter",
+	quoteSeparator: "\n\n",
+	collectInput: "argument",
+	quietResumeErrors: "all",
+	resumeAcceptsEditorPane: true,
+	storageNamespace: () => "rex",
+	state: confStore(() => "rex")
+});
+
 //#endregion
 //#region src/modules/tmux.ts
 const execAsync$1 = promisify(exec);
@@ -500,20 +819,6 @@ async function getCurrentPaneId$1() {
 	const { stdout } = await execAsync$1("tmux display-message -p \"#{pane_id}\"");
 	return stdout.trim();
 }
-async function saveEditorPaneId$1(targetPaneId, editorPaneId) {
-	await execAsync$1(`tmux set-option -pt '${targetPaneId}' @editprompt_editor_pane '${editorPaneId}'`);
-}
-async function clearEditorPaneId$1(targetPaneId) {
-	await execAsync$1(`tmux set-option -pt '${targetPaneId}' @editprompt_editor_pane ""`);
-}
-async function getEditorPaneId$1(targetPaneId) {
-	try {
-		const { stdout } = await execAsync$1(`tmux show -pt '${targetPaneId}' -v @editprompt_editor_pane`);
-		return stdout.trim();
-	} catch {
-		return "";
-	}
-}
 async function checkPaneExists$1(paneId) {
 	try {
 		const { stdout } = await execAsync$1("tmux list-panes -a -F \"#{pane_id}\"");
@@ -525,62 +830,55 @@ async function checkPaneExists$1(paneId) {
 async function focusPane$1(paneId) {
 	await execAsync$1(`tmux select-pane -t '${paneId}'`);
 }
-async function markAsEditorPane$1(editorPaneId, targetPaneIds) {
-	await execAsync$1(`tmux set-option -pt '${editorPaneId}' @editprompt_is_editor 1`);
-	const uniqueTargetPaneIds = [...new Set(targetPaneIds)];
-	await execAsync$1(`tmux set-option -pt '${editorPaneId}' @editprompt_target_panes '${uniqueTargetPaneIds.join(",")}'`);
-	for (const targetPaneId of uniqueTargetPaneIds) await saveEditorPaneId$1(targetPaneId, editorPaneId);
-}
-async function getTargetPaneIds$1(editorPaneId) {
+async function getPaneOption(paneId, name) {
 	try {
-		const { stdout } = await execAsync$1(`tmux show -pt '${editorPaneId}' -v @editprompt_target_panes`);
-		const value = stdout.trim();
-		if (value === "") return [];
-		return value.split(",").map((id) => id.trim());
-	} catch {
-		return [];
-	}
-}
-async function isEditorPane(paneId) {
-	try {
-		const { stdout } = await execAsync$1(`tmux show -pt '${paneId}' -v @editprompt_is_editor`);
-		return stdout.trim() === "1";
-	} catch {
-		return false;
-	}
-}
-async function getQuoteVariableContent(paneId) {
-	try {
-		const { stdout } = await execAsync$1(`tmux show -pt '${paneId}' -v @editprompt_quote`);
+		const { stdout } = await execAsync$1(`tmux show -pt '${paneId}' -v ${name}`);
 		return stdout;
 	} catch {
 		return "";
 	}
 }
-async function appendToQuoteVariable(paneId, content) {
-	let newContent = "";
-	const existingContent = await getQuoteVariableContent(paneId);
-	if (existingContent.trim() !== "") newContent = `${existingContent}\n${content}`;
-	else newContent = content;
-	await execAsync$1(`tmux set-option -pt '${paneId}' @editprompt_quote '${newContent.replace(/'/g, "'\\''")}' `);
-}
-async function clearQuoteVariable(targetPaneId) {
-	await execAsync$1(`tmux set-option -pt '${targetPaneId}' @editprompt_quote ""`);
+async function setPaneOption(paneId, name, value) {
+	await execAsync$1(`tmux set-option -pt '${paneId}' ${name} '${value.replace(/'/g, "'\\''")}'`);
 }
-async function sendKeyToTmuxPane(paneId, key, delay = 1e3) {
-	await new Promise((resolve) => setTimeout(resolve, delay));
+async function sendKey$1(paneId, key) {
 	await execAsync$1(`tmux send-keys -t '${paneId}' '${key}'`);
 }
-async function inputToTmuxPane(paneId, content) {
+async function exitCopyMode(paneId) {
 	await execAsync$1(`tmux if-shell -t '${paneId}' '[ "#{pane_in_mode}" = "1" ]' "copy-mode -q -t '${paneId}'"`);
-	const chunks = splitByByteSize(content, TMUX_SEND_CHUNK_BYTES);
-	for (const chunk of chunks) await execAsync$1(`tmux send-keys -t '${paneId}' -- '${chunk.replace(/'/g, "'\\''")}'`);
+}
+async function sendTextChunk$1(paneId, chunk) {
+	await execAsync$1(`tmux send-keys -t '${paneId}' -- '${chunk.replace(/'/g, "'\\''")}'`);
+}
+function logContentSent$1(paneId, chunkCount) {
 	logger$12.debug("Content sent to tmux pane: {paneId} ({chunks} chunk(s))", {
 		paneId,
-		chunks: chunks.length
+		chunks: chunkCount
 	});
 }
 
+//#endregion
+//#region src/backends/tmux.ts
+const tmuxBackend = defineBackend({
+	name: "tmux",
+	getCurrentPaneId: () => getCurrentPaneId$1(),
+	paneExists: (paneId) => checkPaneExists$1(paneId),
+	focusPane: (paneId) => focusPane$1(paneId),
+	beforeSendText: (paneId) => exitCopyMode(paneId),
+	sendText: (paneId, chunk) => sendTextChunk$1(paneId, chunk),
+	sendKey: (paneId, key) => sendKey$1(paneId, key),
+	logContentSent: (paneId, chunkCount) => logContentSent$1(paneId, chunkCount),
+	maxChunkBytes: TMUX_SEND_CHUNK_BYTES,
+	defaultSubmitKey: "C-m",
+	quoteSeparator: "\n",
+	collectInput: "stdin",
+	storageNamespace: () => "tmux",
+	state: paneVariableStore({
+		get: (paneId, name) => getPaneOption(paneId, name),
+		set: (paneId, name, value) => setPaneOption(paneId, name, value)
+	}, "@editprompt_")
+});
+
 //#endregion
 //#region src/modules/wezterm.ts
 const logger$11 = getLogger(["editprompt", "wezterm"]);
@@ -605,114 +903,270 @@ async function checkPaneExists(paneId) {
 		return false;
 	}
 }
-async function saveEditorPaneId(targetPaneId, editorPaneId) {
-	logger$11.debug("Saving editor pane ID to conf key: wezterm.targetPane.pane_{targetPaneId}", { targetPaneId });
-	try {
-		conf.set(`wezterm.targetPane.pane_${targetPaneId}`, { editorPaneId });
-	} catch (error) {
-		logger$11.debug("saveEditorPaneId failed: {error}", { error });
-	}
+async function focusPane(paneId) {
+	await execAsync(`wezterm cli activate-pane --pane-id '${paneId}'`);
 }
-async function getEditorPaneId(targetPaneId) {
-	try {
-		const data = conf.get(`wezterm.targetPane.pane_${targetPaneId}`);
-		if (typeof data === "object" && data !== null && "editorPaneId" in data) return String(data.editorPaneId);
-		return "";
-	} catch (error) {
-		logger$11.debug("getEditorPaneId failed: {error}", { error });
-		return "";
-	}
+async function sendKey(paneId, key) {
+	await execAsync(`wezterm cli send-text --no-paste --pane-id '${paneId}' $'${key}'`);
 }
-async function clearEditorPaneId(targetPaneId) {
-	try {
-		const editorPaneId = await getEditorPaneId(targetPaneId);
-		conf.delete(`wezterm.targetPane.pane_${targetPaneId}`);
-		if (editorPaneId) conf.delete(`wezterm.editorPane.pane_${editorPaneId}`);
-	} catch (error) {
-		logger$11.debug("clearEditorPaneId failed: {error}", { error });
-	}
+async function sendTextChunk(paneId, chunk) {
+	await execAsync(`wezterm cli send-text --no-paste --pane-id '${paneId}' -- '${chunk.replace(/'/g, "'\\''")}'`);
 }
-async function focusPane(paneId) {
-	await execAsync(`wezterm cli activate-pane --pane-id '${paneId}'`);
+function logContentSent(paneId, chunkCount) {
+	logger$11.debug("Content sent to wezterm pane: {paneId} ({chunks} chunk(s))", {
+		paneId,
+		chunks: chunkCount
+	});
 }
-async function markAsEditorPane(editorPaneId, targetPaneIds) {
-	try {
-		const uniqueTargetPaneIds = [...new Set(targetPaneIds)];
-		conf.set(`wezterm.editorPane.pane_${editorPaneId}`, { targetPaneIds: uniqueTargetPaneIds });
-		for (const targetPaneId of uniqueTargetPaneIds) await saveEditorPaneId(targetPaneId, editorPaneId);
-	} catch (error) {
-		logger$11.debug("markAsEditorPane failed: {error}", { error });
+
+//#endregion
+//#region src/backends/wezterm.ts
+const weztermBackend = defineBackend({
+	name: "wezterm",
+	getCurrentPaneId: () => getCurrentPaneId(),
+	paneExists: (paneId) => checkPaneExists(paneId),
+	focusPane: (paneId) => focusPane(paneId),
+	sendText: (paneId, chunk) => sendTextChunk(paneId, chunk),
+	sendKey: (paneId, key) => sendKey(paneId, key),
+	logContentSent: (paneId, chunkCount) => logContentSent(paneId, chunkCount),
+	maxChunkBytes: WEZTERM_SEND_CHUNK_BYTES,
+	defaultSubmitKey: "\\r",
+	quoteSeparator: "\n\n",
+	collectInput: "argument",
+	quietResumeErrors: "editorFocus",
+	traceResume: true,
+	storageNamespace: () => "wezterm",
+	state: confStore(() => "wezterm", {
+		wholeTargetRecord: true,
+		logCategory: ["editprompt", "wezterm"]
+	})
+});
+
+//#endregion
+//#region src/backends/registry.ts
+/** Used when nothing is configured and no backend detects its environment. */
+const FALLBACK_BACKEND_NAME = "tmux";
+const BUILTIN_BACKENDS = [
+	tmuxBackend,
+	weztermBackend,
+	herdrBackend,
+	niwatermBackend,
+	rexBackend
+];
+const backends = new Map(BUILTIN_BACKENDS.map((b) => [b.name, b]));
+function isBuiltinBackendName(name) {
+	return BUILTIN_BACKENDS.some((backend) => backend.name === name);
+}
+function registerBackend(backend) {
+	if (backends.has(backend.name)) throw new Error(`A backend named '${backend.name}' is already registered`);
+	backends.set(backend.name, backend);
+}
+function hasBackend(name) {
+	return typeof name === "string" && backends.has(name);
+}
+function listBackendNames() {
+	return [...backends.keys()];
+}
+function getBackend(name) {
+	const backend = backends.get(name);
+	if (!backend) throw new Error(`Invalid multiplexer type '${name}'. Supported values: ${listBackendNames().join(", ")}`);
+	return backend;
+}
+function detectBackendName(env = process.env) {
+	for (const backend of backends.values()) if (backend.detect?.(env)) return backend.name;
+	return FALLBACK_BACKEND_NAME;
+}
+/**
+* Resolves the backend name from, in order: the explicit `--mux` value,
+* `EDITPROMPT_MUX`, and auto-detection. Throws for an unknown name.
+*/
+function resolveBackendName(explicit, env = process.env) {
+	const value = explicit || env.EDITPROMPT_MUX || detectBackendName(env);
+	if (!hasBackend(value)) {
+		const displayValue = typeof value === "string" ? value : `<${typeof value}>`;
+		throw new Error(`Invalid multiplexer type '${displayValue}'. Supported values: ${listBackendNames().join(", ")}`);
 	}
+	return value;
 }
-async function getTargetPaneIds(editorPaneId) {
-	try {
-		const data = conf.get(`wezterm.editorPane.pane_${editorPaneId}`);
-		if (typeof data === "object" && data !== null && "targetPaneIds" in data) {
-			const targetPaneIds = data.targetPaneIds;
-			if (Array.isArray(targetPaneIds)) return targetPaneIds.map((id) => String(id));
+
+//#endregion
+//#region src/config/userConfig.ts
+const RC_FILE = ".editpromptrc";
+/**
+* The directory holding the configuration file: `EDITPROMPT_CONFIG_DIR`, or
+* `editprompt` under `XDG_CONFIG_HOME` (default `~/.config`).
+*/
+function getConfigDir(env = process.env) {
+	const explicit = env.EDITPROMPT_CONFIG_DIR?.trim();
+	if (explicit) return explicit;
+	return join(env.XDG_CONFIG_HOME?.trim() || join(homedir(), ".config"), "editprompt");
+}
+/**
+* Loads the configuration with c12, so every format c12 supports works:
+* `config.{json,jsonc,json5,yaml,yml,toml,js,ts,mjs,cjs,mts,cts}` in the
+* config directory, and the `.editpromptrc` RC file there, in
+* `$XDG_CONFIG_HOME` or in the home directory.
+*
+* Configuration is read from the user's config directory only, never from the
+* current working directory: a repository must not be able to change how
+* editprompt talks to the terminal, or run code through a config file.
+*/
+async function loadUserConfig(configDir = getConfigDir()) {
+	const { loadConfig } = await import("c12");
+	const { config } = await loadConfig({
+		name: "editprompt",
+		cwd: configDir,
+		configFile: "config",
+		rcFile: RC_FILE,
+		globalRc: true,
+		dotenv: false,
+		packageJson: false
+	});
+	return config ?? {};
+}
+/**
+* Registers the backends declared in the configuration. Returns one message
+* per backend that could not be registered, so that a broken entry does not
+* take the built-in backends down with it.
+*/
+function registerConfiguredBackends(config) {
+	const errors = [];
+	const { backends } = config;
+	if (backends === void 0) return errors;
+	if (typeof backends !== "object" || backends === null || Array.isArray(backends)) return ["backends must be an object keyed by backend name"];
+	for (const [name, spec] of Object.entries(backends)) {
+		if (isBuiltinBackendName(name)) {
+			errors.push(`backends.${name}: '${name}' is a built-in backend and cannot be redefined`);
+			continue;
+		}
+		try {
+			registerBackend(createCommandBackend(name, spec));
+		} catch (error) {
+			errors.push(error instanceof Error ? error.message : String(error));
 		}
-		return [];
-	} catch (error) {
-		logger$11.debug("getTargetPaneIds failed: {error}", { error });
-		return [];
 	}
+	return errors;
 }
-function isEditorPaneFromConf(paneId) {
-	try {
-		return conf.has(`wezterm.editorPane.pane_${paneId}`);
-	} catch (error) {
-		logger$11.debug("isEditorPaneFromConf failed: {error}", { error });
-		return false;
+/**
+* Returns the `--mux` value given on the command line, ignoring anything after
+* `--` (content passed to input, collect or stash).
+*/
+function findMuxArgument(argv) {
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg === "--") return;
+		if (arg === "--mux" || arg === "-m") return argv[i + 1];
+		if (arg.startsWith("--mux=")) return arg.slice(6);
 	}
 }
-async function appendToQuoteText(paneId, content) {
+/**
+* Decides whether this invocation can use a configured backend at all, so that
+* the common case skips loading c12. Configured backends cannot replace
+* built-in ones and are detected after them, so they only matter when an
+* explicit `--mux`/EDITPROMPT_MUX names a non-built-in backend, or when
+* auto-detection would otherwise fall back to tmux.
+*/
+function mayUseConfiguredBackend(argv, env = process.env) {
+	const explicit = findMuxArgument(argv) || env.EDITPROMPT_MUX;
+	if (explicit) return !isBuiltinBackendName(explicit);
+	return detectBackendName(env) === FALLBACK_BACKEND_NAME;
+}
+/** Returns true when one of the files c12 would read exists. */
+function hasConfigFiles(configDir = getConfigDir(), env = process.env) {
+	return existsSync(configDir) || existsSync(join(env.XDG_CONFIG_HOME?.trim() || homedir(), RC_FILE));
+}
+/** Loads the configuration and registers its backends, reporting problems on stderr. */
+async function setupUserConfig(configDir = getConfigDir()) {
+	if (!hasConfigFiles(configDir)) return;
+	let config;
 	try {
-		const data = conf.get(`wezterm.targetPane.pane_${paneId}`);
-		let newData;
-		if (typeof data === "object" && data !== null) {
-			const existingQuoteText = "quote_text" in data ? String(data.quote_text) : "";
-			const newQuoteText = existingQuoteText.trim() !== "" ? `${existingQuoteText}\n\n${content}` : content;
-			newData = {
-				...data,
-				quote_text: newQuoteText
-			};
-		} else newData = { quote_text: content };
-		conf.set(`wezterm.targetPane.pane_${paneId}`, newData);
+		config = await loadUserConfig(configDir);
 	} catch (error) {
-		logger$11.debug("appendToQuoteText failed: {error}", { error });
+		console.error(`editprompt: failed to load the configuration: ${error instanceof Error ? error.message : String(error)}`);
+		return;
 	}
+	for (const message of registerConfiguredBackends(config)) console.error(`editprompt: invalid configuration: ${message}`);
 }
-async function getQuoteText(paneId) {
-	try {
-		const data = conf.get(`wezterm.targetPane.pane_${paneId}`);
-		if (typeof data === "object" && data !== null && "quote_text" in data) return String(data.quote_text);
-		return "";
-	} catch (error) {
-		logger$11.debug("getQuoteText failed: {error}", { error });
-		return "";
-	}
+
+//#endregion
+//#region src/modules/logger.ts
+function resolveLogFilePath(options) {
+	if (options.logFile) return options.logFile;
+	const envPath = process.env.EDITPROMPT_LOG_FILE;
+	if (envPath) return envPath;
 }
-async function clearQuoteText(paneId) {
-	try {
-		const key = `wezterm.targetPane.pane_${paneId}.quote_text`;
-		if (conf.has(key)) conf.delete(key);
-	} catch (error) {
-		logger$11.debug("clearQuoteText failed: {error}", { error });
-	}
+function resolveFileLogLevel(options) {
+	if (options.verbose) return "debug";
+	const envLevel = process.env.EDITPROMPT_LOG_LEVEL;
+	if (envLevel) return parseLogLevel(envLevel);
+	return "info";
 }
-async function sendKeyToWeztermPane(paneId, key, delay = 1e3) {
-	await new Promise((resolve) => setTimeout(resolve, delay));
-	await execAsync(`wezterm cli send-text --no-paste --pane-id '${paneId}' $'${key}'`);
+function resolveLogLevel(options) {
+	if (options.quiet) return null;
+	if (options.verbose) return "debug";
+	const envLevel = process.env.EDITPROMPT_LOG_LEVEL;
+	if (envLevel) return parseLogLevel(envLevel);
+	return "info";
 }
-async function inputToWeztermPane(paneId, content) {
-	const chunks = splitByByteSize(content, WEZTERM_SEND_CHUNK_BYTES);
-	for (const chunk of chunks) await execAsync(`wezterm cli send-text --no-paste --pane-id '${paneId}' -- '${chunk.replace(/'/g, "'\\''")}'`);
-	logger$11.debug("Content sent to wezterm pane: {paneId} ({chunks} chunk(s))", {
-		paneId,
-		chunks: chunks.length
+function setupLogger(options = {}) {
+	const stderrLevel = resolveLogLevel(options);
+	const stderrFormatter = getAnsiColorFormatter({
+		timestamp: "time-timezone",
+		level: "ABBR"
+	});
+	const rawStderrSink = (record) => {
+		process.stderr.write(stderrFormatter(record));
+	};
+	const sinks = { stderr: stderrLevel === null ? () => {} : withFilter(rawStderrSink, stderrLevel) };
+	const loggerSinks = ["stderr"];
+	const logFilePath = resolveLogFilePath(options);
+	const fileLogLevel = resolveFileLogLevel(options);
+	if (logFilePath) try {
+		appendFileSync(logFilePath, "");
+		const fileFormatter = getTextFormatter({
+			timestamp: "date-time-timezone",
+			level: "ABBR"
+		});
+		const rawFileSink = (record) => {
+			appendFileSync(logFilePath, fileFormatter(record));
+		};
+		sinks.file = withFilter(rawFileSink, fileLogLevel);
+		loggerSinks.push("file");
+	} catch {
+		process.stderr.write(`Warning: Cannot write to log file '${logFilePath}', continuing without file logging.\n`);
+	}
+	configureSync({
+		sinks,
+		loggers: [{
+			category: ["editprompt"],
+			sinks: loggerSinks,
+			lowestLevel: "trace"
+		}, {
+			category: ["logtape", "meta"],
+			lowestLevel: null
+		}]
 	});
 }
 
+//#endregion
+//#region package.json
+var version = "2.0.0";
+
+//#endregion
+//#region src/core/quote.ts
+/** Appends a quote to the target pane's quote buffer. */
+async function appendQuote(backend, targetPaneId, content) {
+	const existing = await backend.state.getQuote(targetPaneId);
+	const quote = existing.trim() !== "" ? `${existing}${backend.quoteSeparator}${content}` : content;
+	await backend.state.setQuote(targetPaneId, quote);
+}
+/** Returns the target pane's quote buffer and clears it. */
+async function takeQuote(backend, targetPaneId) {
+	const quote = await backend.state.getQuote(targetPaneId);
+	await backend.state.removeQuote(targetPaneId);
+	return quote;
+}
+
 //#endregion
 //#region src/utils/argumentParser.ts
 /**
@@ -852,31 +1306,8 @@ function processQuoteText(text, options) {
 
 //#endregion
 //#region src/utils/mux.ts
-const SUPPORTED_MUXES = [
-	"tmux",
-	"wezterm",
-	"herdr",
-	"niwaterm"
-];
-function isMuxType(value) {
-	return value === "tmux" || value === "wezterm" || value === "herdr" || value === "niwaterm";
-}
-function hasValue(value) {
-	return typeof value === "string" && value.trim() !== "";
-}
-function isHerdrEnvironment(env = process.env) {
-	return hasValue(env.HERDR_SOCKET_PATH) && (hasValue(env.HERDR_PANE_ID) || hasValue(env.HERDR_ACTIVE_PANE_ID));
-}
-function isNiwatermEnvironment(env = process.env) {
-	return hasValue(env.NIWATERM_TAB_ID);
-}
 function resolveMux(explicitMux, env = process.env) {
-	const muxValue = explicitMux || env.EDITPROMPT_MUX || (isHerdrEnvironment(env) ? "herdr" : isNiwatermEnvironment(env) ? "niwaterm" : "tmux");
-	if (!isMuxType(muxValue)) {
-		const displayValue = typeof muxValue === "string" ? muxValue : `<${typeof muxValue}>`;
-		throw new Error(`Invalid multiplexer type '${displayValue}'. Supported values: ${SUPPORTED_MUXES.join(", ")}`);
-	}
-	return muxValue;
+	return resolveBackendName(explicitMux, env);
 }
 
 //#endregion
@@ -884,7 +1315,7 @@ function resolveMux(explicitMux, env = process.env) {
 const logger$10 = getLogger(["editprompt"]);
 const ARG_MUX = {
 	short: "m",
-	description: "Multiplexer type (tmux, wezterm, herdr, or niwaterm; auto-detects Herdr and niwaterm, otherwise tmux)",
+	description: "Multiplexer type (tmux, wezterm, herdr, niwaterm, or rex; auto-detects Herdr, niwaterm and Rex, otherwise tmux)",
 	type: "string"
 };
 const ARG_TARGET_PANE_SINGLE = {
@@ -994,10 +1425,7 @@ async function runCollectMode(mux, targetPaneId, rawContent, outputs = ["buffer"
 		if (rawContent !== void 0) selection = rawContent;
 		else selection = await readStdin();
 		const processedText = processQuoteText(selection, { withQuote });
-		for (const output of outputs) if (output === "buffer") if (mux === "tmux") await appendToQuoteVariable(targetPaneId, processedText);
-		else if (mux === "wezterm") await appendToQuoteText(targetPaneId, processedText);
-		else if (mux === "niwaterm") await appendToQuoteVariable$1(targetPaneId, processedText);
-		else await appendToQuoteText$1(targetPaneId, processedText);
+		for (const output of outputs) if (output === "buffer") await appendQuote(getBackend(mux), targetPaneId, processedText);
 		else if (output === "stdout") process.stdout.write(processedText);
 	} catch (error) {
 		logger$9.error(`${error instanceof Error ? error.message : "Unknown error"}`);
@@ -1027,7 +1455,7 @@ const collectCommand = define({
 		const outputs = normalizeCollectOutputs(ctx.values.output);
 		const withQuote = !ctx.values["no-quote"];
 		let rawContent;
-		if (mux === "wezterm" || mux === "herdr" || mux === "niwaterm") {
+		if (getBackend(mux).collectInput === "argument") {
 			rawContent = extractRawContent(ctx.rest, ctx.positionals);
 			if (rawContent === void 0) {
 				logger$9.error(`Text content is required for collect mode with ${mux}. Use: editprompt collect --mux ${mux} --target-pane <id> -- "<text>"`);
@@ -1053,111 +1481,124 @@ function readSendConfig() {
 }
 
 //#endregion
-//#region src/modes/dump.ts
-const logger$8 = getLogger(["editprompt", "dump"]);
-async function runDumpMode() {
-	try {
-		const config = readSendConfig();
-		let currentPaneId;
-		let isEditor;
-		if (config.mux === "tmux") {
-			currentPaneId = await getCurrentPaneId$1();
-			isEditor = await isEditorPane(currentPaneId);
-		} else if (config.mux === "wezterm") {
-			currentPaneId = await getCurrentPaneId();
-			isEditor = isEditorPaneFromConf(currentPaneId);
-		} else if (config.mux === "niwaterm") {
-			currentPaneId = await getCurrentPaneId$2();
-			isEditor = await isEditorPane$1(currentPaneId);
-		} else {
-			currentPaneId = await getCurrentPaneId$3();
-			isEditor = isEditorPaneFromConf$1(currentPaneId);
-		}
-		if (!isEditor) {
-			logger$8.error("Current pane is not an editor pane");
-			process.exit(1);
-		}
-		let targetPanes;
-		if (config.mux === "tmux") targetPanes = await getTargetPaneIds$1(currentPaneId);
-		else if (config.mux === "wezterm") targetPanes = await getTargetPaneIds(currentPaneId);
-		else if (config.mux === "niwaterm") targetPanes = await getTargetPaneIds$2(currentPaneId);
-		else targetPanes = await getTargetPaneIds$3(currentPaneId);
-		if (targetPanes.length === 0) {
-			logger$8.error("No target panes registered for this editor pane");
-			process.exit(1);
-		}
-		const quoteContents = [];
-		for (const targetPane of targetPanes) {
-			let content;
-			if (config.mux === "tmux") {
-				content = await getQuoteVariableContent(targetPane);
-				await clearQuoteVariable(targetPane);
-			} else if (config.mux === "wezterm") {
-				content = await getQuoteText(targetPane);
-				await clearQuoteText(targetPane);
-			} else if (config.mux === "niwaterm") {
-				content = await getQuoteVariableContent$1(targetPane);
-				await clearQuoteVariable$1(targetPane);
-			} else {
-				content = await getQuoteText$1(targetPane);
-				await clearQuoteText$1(targetPane);
-			}
-			if (content.trim() !== "") quoteContents.push(content);
-		}
-		const combinedContent = quoteContents.join("\n");
-		process.stdout.write(combinedContent.replace(/\n{3,}$/, "\n\n"));
-		process.exit(0);
-	} catch (error) {
-		logger$8.error(`${error instanceof Error ? error.message : "Unknown error"}`);
-		process.exit(1);
-	}
+//#region src/core/link.ts
+/**
+* Marks a pane as an editor pane serving the target panes, and records the
+* editor pane on each target pane so that resume can find it.
+*/
+async function markAsEditorPane(backend, editorPaneId, targetPaneIds) {
+	const uniqueTargetPaneIds = [...new Set(targetPaneIds)];
+	await backend.state.setTargetPaneIds(editorPaneId, uniqueTargetPaneIds);
+	for (const targetPaneId of uniqueTargetPaneIds) await backend.state.setEditorPaneId(targetPaneId, editorPaneId);
 }
-const dumpCommand = define({
-	name: "dump",
-	description: "Output and clear collected quoted text from environment variables",
-	args: {
-		"log-file": ARG_LOG_FILE,
-		quiet: ARG_QUIET,
-		verbose: ARG_VERBOSE
-	},
-	async run(ctx) {
-		setupLogger({
-			quiet: Boolean(ctx.values.quiet),
-			verbose: Boolean(ctx.values.verbose),
-			logFile: ctx.values["log-file"]
-		});
-		await runDumpMode();
+function isEditorPane(backend, paneId) {
+	return backend.state.isEditorPane(paneId);
+}
+function getTargetPaneIds(backend, editorPaneId) {
+	return backend.state.getTargetPaneIds(editorPaneId);
+}
+/**
+* Clears the editor pane registered on a target pane.
+*
+* When `expectedEditorPaneId` is given and the target pane has meanwhile been
+* linked to a newer editor pane, the newer link is kept and only the expected
+* editor pane is forgotten. This lets an editor that exits late leave a newer
+* editor's registration alone.
+*/
+async function clearEditorLink(backend, targetPaneId, expectedEditorPaneId) {
+	if (!expectedEditorPaneId && backend.state.keepsEditorPaneMarks) {
+		await backend.state.removeEditorPaneId(targetPaneId);
+		return;
 	}
-});
+	const editorPaneId = await backend.state.getEditorPaneId(targetPaneId);
+	if (expectedEditorPaneId && editorPaneId !== expectedEditorPaneId) {
+		await backend.state.removeEditorPane(expectedEditorPaneId);
+		return;
+	}
+	await backend.state.removeEditorPaneId(targetPaneId);
+	if (editorPaneId) await backend.state.removeEditorPane(editorPaneId);
+}
+var EditorContextError = class extends Error {
+	name = "EditorContextError";
+};
+/**
+* Resolves the editor pane editprompt runs in and the target panes registered
+* on it. Throws EditorContextError when the current pane is not an editor pane
+* or has no target panes.
+*/
+async function resolveEditorContext(backend) {
+	const editorPaneId = await backend.getCurrentPaneId();
+	if (!await backend.state.isEditorPane(editorPaneId)) throw new EditorContextError("Current pane is not an editor pane");
+	const targetPaneIds = await backend.state.getTargetPaneIds(editorPaneId);
+	if (targetPaneIds.length === 0) throw new EditorContextError("No target panes registered for this editor pane");
+	return {
+		editorPaneId,
+		targetPaneIds
+	};
+}
 
 //#endregion
-//#region src/utils/contentProcessor.ts
-function processContent(content) {
-	let processed = content.replace(/\n$/, "");
-	if (/@[^\n]*$/.test(processed)) processed += " ";
-	return processed;
+//#region src/utils/contentChunker.ts
+/**
+* Split content into chunks not exceeding maxBytes (UTF-8 byte count),
+* never breaking a Unicode code point across chunks.
+*
+* Content shorter than maxBytes is returned as a single chunk, so short
+* input keeps the previous behavior of being sent in one shot.
+*/
+function splitByByteSize(content, maxBytes) {
+	if (content === "") return [];
+	const chunks = [];
+	let current = "";
+	let currentBytes = 0;
+	for (const char of content) {
+		const charBytes = Buffer.byteLength(char, "utf8");
+		if (current !== "" && currentBytes + charBytes > maxBytes) {
+			chunks.push(current);
+			current = "";
+			currentBytes = 0;
+		}
+		current += char;
+		currentBytes += charBytes;
+	}
+	if (current !== "") chunks.push(current);
+	return chunks;
 }
 
 //#endregion
-//#region src/modes/common.ts
-const logger$7 = getLogger(["editprompt", "delivery"]);
+//#region src/core/delivery.ts
+const logger$8 = getLogger(["editprompt", "delivery"]);
 async function copyToClipboard(content) {
 	await clipboardy.write(content);
 }
-async function inputContentToPane(content, mux, targetPaneId) {
-	if (mux === "wezterm") await inputToWeztermPane(targetPaneId, content);
-	else if (mux === "herdr") await inputToHerdrPane(targetPaneId, content);
-	else if (mux === "niwaterm") await inputToNiwatermPane(targetPaneId, content);
-	else await inputToTmuxPane(targetPaneId, content);
+/**
+* Types content into a pane without changing focus. Long content is split
+* into chunks the backend accepts and sent in order.
+*/
+async function sendContentToPane(backend, paneId, content) {
+	await backend.beforeSendText?.(paneId);
+	const chunks = splitByByteSize(content, backend.maxChunkBytes);
+	for (const chunk of chunks) await backend.sendText(paneId, chunk);
+	if (backend.logContentSent) backend.logContentSent(paneId, chunks.length);
+	else logger$8.debug("Content sent to {backend} pane: {paneId} ({chunks} chunk(s))", {
+		backend: backend.name,
+		paneId,
+		chunks: chunks.length
+	});
+}
+/**
+* Sends a key after a delay. The delay keeps some CLIs (e.g., codex) from
+* treating the key as part of a paste.
+*/
+async function sendKeyToPane(backend, paneId, key, delay = 1e3) {
+	await new Promise((resolve) => setTimeout(resolve, delay));
+	await backend.sendKey(paneId, key);
 }
-async function focusFirstSuccessPane(mux, targetPanes, failedPanes) {
+async function focusFirstSuccessPane(backend, targetPanes, failedPanes) {
 	const firstSuccessPane = targetPanes.find((p) => !failedPanes.includes(p));
-	if (firstSuccessPane) if (mux === "tmux") await focusPane$1(firstSuccessPane);
-	else if (mux === "wezterm") await focusPane(firstSuccessPane);
-	else if (mux === "niwaterm") await focusPane$2(firstSuccessPane);
-	else await focusPane$3(firstSuccessPane);
+	if (firstSuccessPane) await backend.focusPane(firstSuccessPane);
 }
-async function handleContentDelivery(content, mux, targetPanes) {
+async function handleContentDelivery(content, backend, targetPanes) {
 	if (!content) return {
 		successCount: 0,
 		totalCount: 0,
@@ -1168,9 +1609,9 @@ async function handleContentDelivery(content, mux, targetPanes) {
 	if (targetPanes.length === 0) {
 		try {
 			await copyToClipboard(content);
-			logger$7.info("Content copied to clipboard.");
+			logger$8.info("Content copied to clipboard.");
 		} catch (error) {
-			logger$7.warn(`Failed to copy to clipboard: ${error instanceof Error ? error.message : "Unknown error"}`);
+			logger$8.warn(`Failed to copy to clipboard: ${error instanceof Error ? error.message : "Unknown error"}`);
 		}
 		return {
 			successCount: 0,
@@ -1182,13 +1623,13 @@ async function handleContentDelivery(content, mux, targetPanes) {
 	}
 	const results = [];
 	for (const targetPane of targetPanes) try {
-		await inputContentToPane(content, mux, targetPane);
+		await sendContentToPane(backend, targetPane, content);
 		results.push({
 			pane: targetPane,
 			success: true
 		});
 	} catch (error) {
-		logger$7.warn(`Failed to send to pane ${targetPane}: ${error instanceof Error ? error.message : "Unknown error"}`);
+		logger$8.warn(`Failed to send to pane ${targetPane}: ${error instanceof Error ? error.message : "Unknown error"}`);
 		results.push({
 			pane: targetPane,
 			success: false
@@ -1198,13 +1639,13 @@ async function handleContentDelivery(content, mux, targetPanes) {
 	const failedPanes = results.filter((r) => !r.success).map((r) => r.pane);
 	const allSuccess = successCount === targetPanes.length;
 	const allFailed = successCount === 0;
-	if (allSuccess) logger$7.info("Content sent successfully to all panes!");
+	if (allSuccess) logger$8.info("Content sent successfully to all panes!");
 	else if (allFailed) {
-		logger$7.error("All target panes failed to receive content.");
-		logger$7.info("Falling back to clipboard...");
+		logger$8.error("All target panes failed to receive content.");
+		logger$8.info("Falling back to clipboard...");
 		await copyToClipboard(content);
-		logger$7.info("Content copied to clipboard.");
-	} else logger$7.warn(`Content sent to ${successCount}/${targetPanes.length} panes. Failed panes: ${failedPanes.join(", ")}`);
+		logger$8.info("Content copied to clipboard.");
+	} else logger$8.warn(`Content sent to ${successCount}/${targetPanes.length} panes. Failed panes: ${failedPanes.join(", ")}`);
 	return {
 		successCount,
 		totalCount: targetPanes.length,
@@ -1214,6 +1655,71 @@ async function handleContentDelivery(content, mux, targetPanes) {
 	};
 }
 
+//#endregion
+//#region src/modes/common.ts
+/**
+* Resolves the editor pane and its target panes for commands that run inside
+* an editor pane, exiting with an error (logged to the command's logger) when
+* there are none.
+*/
+async function requireEditorContext(backend, logger) {
+	try {
+		return await resolveEditorContext(backend);
+	} catch (error) {
+		if (error instanceof EditorContextError) {
+			logger.error(error.message);
+			process.exit(1);
+		}
+		throw error;
+	}
+}
+
+//#endregion
+//#region src/modes/dump.ts
+const logger$7 = getLogger(["editprompt", "dump"]);
+async function runDumpMode() {
+	try {
+		const backend = getBackend(readSendConfig().mux);
+		const { targetPaneIds } = await requireEditorContext(backend, logger$7);
+		const quoteContents = [];
+		for (const targetPane of targetPaneIds) {
+			const content = await takeQuote(backend, targetPane);
+			if (content.trim() !== "") quoteContents.push(content);
+		}
+		const combinedContent = quoteContents.join("\n");
+		process.stdout.write(combinedContent.replace(/\n{3,}$/, "\n\n"));
+		process.exit(0);
+	} catch (error) {
+		logger$7.error(`${error instanceof Error ? error.message : "Unknown error"}`);
+		process.exit(1);
+	}
+}
+const dumpCommand = define({
+	name: "dump",
+	description: "Output and clear collected quoted text from environment variables",
+	args: {
+		"log-file": ARG_LOG_FILE,
+		quiet: ARG_QUIET,
+		verbose: ARG_VERBOSE
+	},
+	async run(ctx) {
+		setupLogger({
+			quiet: Boolean(ctx.values.quiet),
+			verbose: Boolean(ctx.values.verbose),
+			logFile: ctx.values["log-file"]
+		});
+		await runDumpMode();
+	}
+});
+
+//#endregion
+//#region src/utils/contentProcessor.ts
+function processContent(content) {
+	let processed = content.replace(/\n$/, "");
+	if (/@[^\n]*$/.test(processed)) processed += " ";
+	return processed;
+}
+
 //#endregion
 //#region src/modes/input.ts
 const logger$6 = getLogger(["editprompt", "input"]);
@@ -1224,52 +1730,15 @@ async function runInputMode(rawContent, autoSend, sendKey, sendKeyDelay) {
 		return;
 	}
 	const config = readSendConfig();
-	let currentPaneId;
-	let isEditor;
-	if (config.mux === "tmux") {
-		currentPaneId = await getCurrentPaneId$1();
-		isEditor = await isEditorPane(currentPaneId);
-	} else if (config.mux === "wezterm") {
-		currentPaneId = await getCurrentPaneId();
-		isEditor = isEditorPaneFromConf(currentPaneId);
-	} else if (config.mux === "niwaterm") {
-		currentPaneId = await getCurrentPaneId$2();
-		isEditor = await isEditorPane$1(currentPaneId);
-	} else {
-		currentPaneId = await getCurrentPaneId$3();
-		isEditor = isEditorPaneFromConf$1(currentPaneId);
-	}
-	if (!isEditor) {
-		logger$6.error("Current pane is not an editor pane");
-		process.exit(1);
-	}
-	let targetPanes;
-	if (config.mux === "tmux") targetPanes = await getTargetPaneIds$1(currentPaneId);
-	else if (config.mux === "wezterm") targetPanes = await getTargetPaneIds(currentPaneId);
-	else if (config.mux === "niwaterm") targetPanes = await getTargetPaneIds$2(currentPaneId);
-	else targetPanes = await getTargetPaneIds$3(currentPaneId);
-	if (targetPanes.length === 0) {
-		logger$6.error("No target panes registered for this editor pane");
-		process.exit(1);
-	}
+	const backend = getBackend(config.mux);
+	const { targetPaneIds: targetPanes } = await requireEditorContext(backend, logger$6);
 	if (autoSend) {
-		const key = sendKey || (config.mux === "wezterm" ? "\\r" : config.mux === "herdr" ? "enter" : "C-m");
+		const key = sendKey || backend.defaultSubmitKey;
 		const delay = /\.(png|webp|avif|jpe?g|gif)\b/i.test(content) ? sendKeyDelay ?? 1e3 : 200;
 		let successCount = 0;
 		for (const targetPane of targetPanes) try {
-			if (config.mux === "wezterm") {
-				await inputToWeztermPane(targetPane, content);
-				await sendKeyToWeztermPane(targetPane, key, delay);
-			} else if (config.mux === "herdr") {
-				await inputToHerdrPane(targetPane, content);
-				await sendKeyToHerdrPane(targetPane, key, delay);
-			} else if (config.mux === "niwaterm") {
-				await inputToNiwatermPane(targetPane, content);
-				await sendKeyToNiwatermPane(targetPane, key, delay);
-			} else {
-				await inputToTmuxPane(targetPane, content);
-				await sendKeyToTmuxPane(targetPane, key, delay);
-			}
+			await sendContentToPane(backend, targetPane, content);
+			await sendKeyToPane(backend, targetPane, key, delay);
 			successCount++;
 		} catch (error) {
 			logger$6.error(`Failed to send to pane ${targetPane}: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -1286,12 +1755,12 @@ async function runInputMode(rawContent, autoSend, sendKey, sendKeyDelay) {
 		return;
 	}
 	try {
-		const result = await handleContentDelivery(content, config.mux, targetPanes);
+		const result = await handleContentDelivery(content, backend, targetPanes);
 		if (config.alwaysCopy && !result.allFailed) {
 			await copyToClipboard(content);
 			logger$6.info("Also copied to clipboard.");
 		}
-		if (result.successCount > 0) await focusFirstSuccessPane(config.mux, targetPanes, result.failedPanes);
+		if (result.successCount > 0) await focusFirstSuccessPane(backend, targetPanes, result.failedPanes);
 		if (result.allFailed) process.exit(1);
 	} catch (error) {
 		logger$6.error(`${error instanceof Error ? error.message : "Unknown error"}`);
@@ -1424,22 +1893,11 @@ async function openEditorAndGetContent(editorOption, envVars, sendConfig) {
 //#region src/modes/openEditor.ts
 const logger$5 = getLogger(["editprompt", "open"]);
 async function runOpenEditorMode(options) {
-	let herdrEditorPaneId;
-	if (options.targetPanes.length > 0 && options.mux === "tmux") try {
-		await markAsEditorPane$1(await getCurrentPaneId$1(), options.targetPanes);
-	} catch {}
-	else if (options.targetPanes.length > 0 && options.mux === "wezterm") try {
-		const currentPaneId = await getCurrentPaneId();
-		await markAsEditorPane(currentPaneId, options.targetPanes);
-	} catch {}
-	else if (options.targetPanes.length > 0 && options.mux === "herdr") try {
-		const currentPaneId = await getCurrentPaneId$3();
-		herdrEditorPaneId = currentPaneId;
-		await markAsEditorPane$3(currentPaneId, options.targetPanes);
-	} catch {}
-	else if (options.targetPanes.length > 0 && options.mux === "niwaterm") try {
-		const currentPaneId = await getCurrentPaneId$2();
-		await markAsEditorPane$2(currentPaneId, options.targetPanes);
+	const backend = getBackend(options.mux);
+	let editorPaneId;
+	if (options.targetPanes.length > 0) try {
+		editorPaneId = await backend.getCurrentPaneId();
+		await markAsEditorPane(backend, editorPaneId, options.targetPanes);
 	} catch {}
 	try {
 		const sendConfig = {
@@ -1454,31 +1912,23 @@ async function runOpenEditorMode(options) {
 			return;
 		}
 		try {
-			const result = await handleContentDelivery(content, options.mux, options.targetPanes);
+			const result = await handleContentDelivery(content, backend, options.targetPanes);
 			console.log("---");
 			console.log(content);
 			if (options.alwaysCopy && !result.allFailed) {
 				await copyToClipboard(content);
 				logger$5.info("Also copied to clipboard.");
 			}
-			if (options.targetPanes.length > 0 && result.successCount > 0) await focusFirstSuccessPane(options.mux, options.targetPanes, result.failedPanes);
+			if (options.targetPanes.length > 0 && result.successCount > 0) await focusFirstSuccessPane(backend, options.targetPanes, result.failedPanes);
 			if (!result.allSuccess) process.exit(1);
 		} catch (error) {
 			logger$5.error(`${error instanceof Error ? error.message : "Unknown error"}`);
 			process.exit(1);
 		}
 	} finally {
-		if (options.targetPanes.length > 0 && options.mux === "tmux") try {
-			for (const targetPane of options.targetPanes) await clearEditorPaneId$1(targetPane);
-		} catch {}
-		else if (options.targetPanes.length > 0 && options.mux === "wezterm") try {
-			for (const targetPane of options.targetPanes) await clearEditorPaneId(targetPane);
-		} catch {}
-		else if (options.targetPanes.length > 0 && options.mux === "herdr") try {
-			for (const targetPane of options.targetPanes) await clearEditorPaneId$3(targetPane, herdrEditorPaneId);
-		} catch {}
-		else if (options.targetPanes.length > 0 && options.mux === "niwaterm") try {
-			for (const targetPane of options.targetPanes) await clearEditorPaneId$2(targetPane);
+		if (options.targetPanes.length > 0) try {
+			const expectedEditorPaneId = backend.keepNewerEditorLink ? editorPaneId : void 0;
+			for (const targetPane of options.targetPanes) await clearEditorLink(backend, targetPane, expectedEditorPaneId);
 		} catch {}
 	}
 }
@@ -1519,47 +1969,20 @@ async function runRegisterMode(options) {
 		logger$4.error("--target-pane is required for register command");
 		process.exit(1);
 	}
+	const backend = getBackend(options.mux);
 	let editorPaneId;
 	if (options.editorPane) editorPaneId = options.editorPane;
-	else if (options.mux === "tmux") {
-		editorPaneId = await getCurrentPaneId$1();
-		if (!await isEditorPane(editorPaneId)) {
-			logger$4.error("Current pane is not an editor pane. Please run this command from an editor pane or specify --editor-pane.");
-			process.exit(1);
-		}
-	} else if (options.mux === "wezterm") {
-		editorPaneId = await getCurrentPaneId();
-		if (!isEditorPaneFromConf(editorPaneId)) {
-			logger$4.error("Current pane is not an editor pane. Please run this command from an editor pane or specify --editor-pane.");
-			process.exit(1);
-		}
-	} else if (options.mux === "herdr") {
-		editorPaneId = await getCurrentPaneId$3();
-		if (!isEditorPaneFromConf$1(editorPaneId)) {
-			logger$4.error("Current pane is not an editor pane. Please run this command from an editor pane or specify --editor-pane.");
-			process.exit(1);
-		}
-	} else if (options.mux === "niwaterm") {
-		editorPaneId = await getCurrentPaneId$2();
-		if (!await isEditorPane$1(editorPaneId)) {
+	else {
+		editorPaneId = await backend.getCurrentPaneId();
+		if (!await isEditorPane(backend, editorPaneId)) {
 			logger$4.error("Current pane is not an editor pane. Please run this command from an editor pane or specify --editor-pane.");
 			process.exit(1);
 		}
-	} else {
-		logger$4.error("Unsupported multiplexer");
-		process.exit(1);
 	}
 	try {
-		let existingPanes = [];
-		if (options.mux === "tmux") existingPanes = await getTargetPaneIds$1(editorPaneId);
-		else if (options.mux === "wezterm") existingPanes = await getTargetPaneIds(editorPaneId);
-		else if (options.mux === "herdr") existingPanes = await getTargetPaneIds$3(editorPaneId);
-		else if (options.mux === "niwaterm") existingPanes = await getTargetPaneIds$2(editorPaneId);
+		const existingPanes = await getTargetPaneIds(backend, editorPaneId);
 		const mergedTargetPanes = [...new Set([...existingPanes, ...options.targetPanes])];
-		if (options.mux === "tmux") await markAsEditorPane$1(editorPaneId, mergedTargetPanes);
-		else if (options.mux === "wezterm") await markAsEditorPane(editorPaneId, mergedTargetPanes);
-		else if (options.mux === "herdr") await markAsEditorPane$3(editorPaneId, mergedTargetPanes);
-		else if (options.mux === "niwaterm") await markAsEditorPane$2(editorPaneId, mergedTargetPanes);
+		await markAsEditorPane(backend, editorPaneId, mergedTargetPanes);
 		logger$4.info(`Editor pane ${editorPaneId} registered with target panes: ${mergedTargetPanes.join(", ")}`);
 	} catch (error) {
 		logger$4.error(`${error instanceof Error ? error.message : "Unknown error"}`);
@@ -1596,124 +2019,74 @@ const registerCommand = define({
 });
 
 //#endregion
-//#region src/modes/resume.ts
-const logger$3 = getLogger(["editprompt", "resume"]);
-async function runResumeMode(targetPane, mux) {
-	if (mux === "herdr") try {
-		process.exit(await resumeEditorPane(targetPane) ? 0 : 1);
-	} catch (error) {
-		logger$3.debug("Herdr resume failed: {error}", { error });
-		process.exit(1);
+//#region src/core/resume.ts
+/** Raised when focusing the editor pane from its target pane fails. */
+var EditorFocusError = class extends Error {
+	name = "EditorFocusError";
+	constructor(editorPaneId, cause) {
+		super(`Can't focus editor pane ${editorPaneId}: ${cause instanceof Error ? cause.message : String(cause)}`);
+		this.editorPaneId = editorPaneId;
+		this.cause = cause;
 	}
-	if (mux === "niwaterm") {
-		const currentPaneId = await getCurrentPaneId$2();
-		if (await isEditorPane$1(currentPaneId)) {
-			logger$3.debug("Current pane is an editor pane");
-			const originalTargetPaneIds = await getTargetPaneIds$2(currentPaneId);
-			if (originalTargetPaneIds.length === 0) {
-				logger$3.debug("No target pane IDs found for editor pane");
-				process.exit(1);
-			}
-			let focused = false;
-			for (const paneId of originalTargetPaneIds) if (await checkPaneExists$2(paneId)) {
-				await focusPane$2(paneId);
-				focused = true;
-				break;
-			}
-			if (!focused) {
-				logger$3.debug("All target panes do not exist");
-				process.exit(1);
-			}
-			process.exit(0);
-		}
-		logger$3.debug("Current pane is not an editor pane");
-		const editorPaneId = await getEditorPaneId$2(targetPane);
-		logger$3.debug("niwaterm editorPaneId: {editorPaneId}", { editorPaneId });
-		if (editorPaneId === "") {
-			logger$3.debug("Editor pane ID not found");
-			process.exit(1);
-		}
-		if (!await checkPaneExists$2(editorPaneId)) {
-			logger$3.debug("Editor pane does not exist");
-			await clearEditorPaneId$2(targetPane);
-			process.exit(1);
+};
+async function switchEditorFocus(backend, targetPaneId, trace = () => {}) {
+	const currentPaneId = await backend.getCurrentPaneId();
+	const editorPaneId = await backend.state.isEditorPane(currentPaneId) ? currentPaneId : backend.resumeAcceptsEditorPane && await backend.state.isEditorPane(targetPaneId) ? targetPaneId : "";
+	if (editorPaneId) {
+		trace("Current pane is an editor pane");
+		const targetPaneIds = await backend.state.getTargetPaneIds(editorPaneId);
+		if (targetPaneIds.length === 0) {
+			trace("No target pane IDs found for editor pane");
+			return false;
 		}
-		try {
-			await focusPane$2(editorPaneId);
-			process.exit(0);
-		} catch (error) {
-			logger$3.debug("Can't focus editorPaneId: {editorPaneId}, error: {error}", {
-				editorPaneId,
-				error
-			});
-			process.exit(1);
+		for (const paneId of targetPaneIds) if (await backend.paneExists(paneId)) {
+			await backend.focusPane(paneId);
+			return true;
 		}
+		trace("All target panes do not exist");
+		return false;
 	}
-	if (mux === "wezterm") {
-		const currentPaneId = await getCurrentPaneId();
-		if (isEditorPaneFromConf(currentPaneId)) {
-			logger$3.debug("Current pane is an editor pane");
-			const originalTargetPaneIds = await getTargetPaneIds(currentPaneId);
-			if (originalTargetPaneIds.length === 0) {
-				logger$3.debug("No target pane IDs found for editor pane");
-				process.exit(1);
-			}
-			let focused = false;
-			for (const paneId of originalTargetPaneIds) if (await checkPaneExists(paneId)) {
-				await focusPane(paneId);
-				focused = true;
-				break;
-			}
-			if (!focused) {
-				logger$3.debug("All target panes do not exist");
-				process.exit(1);
-			}
-			process.exit(0);
-		}
-		logger$3.debug("Current pane is not an editor pane");
-		const editorPaneId = await getEditorPaneId(targetPane);
-		logger$3.debug("wezterm editorPaneId: {editorPaneId}", { editorPaneId });
-		if (editorPaneId === "") {
-			logger$3.debug("Editor pane ID not found");
-			process.exit(1);
-		}
-		if (!await checkPaneExists(editorPaneId)) {
-			logger$3.debug("Editor pane does not exist");
-			await clearEditorPaneId(targetPane);
-			process.exit(1);
-		}
-		try {
-			await focusPane(editorPaneId);
-			process.exit(0);
-		} catch (error) {
-			logger$3.debug("Can't focus editorPaneId: {editorPaneId}, error: {error}", {
-				editorPaneId,
-				error
-			});
-			process.exit(1);
-		}
+	trace("Current pane is not an editor pane");
+	const registeredEditorPaneId = await backend.state.getEditorPaneId(targetPaneId);
+	trace(`${backend.name} editorPaneId: {editorPaneId}`, { editorPaneId: registeredEditorPaneId });
+	if (registeredEditorPaneId === "") {
+		trace("Editor pane ID not found");
+		return false;
 	}
-	const currentPaneId = await getCurrentPaneId$1();
-	if (await isEditorPane(currentPaneId)) {
-		const originalTargetPaneIds = await getTargetPaneIds$1(currentPaneId);
-		if (originalTargetPaneIds.length === 0) process.exit(1);
-		let focused = false;
-		for (const paneId of originalTargetPaneIds) if (await checkPaneExists$1(paneId)) {
-			await focusPane$1(paneId);
-			focused = true;
-			break;
-		}
-		if (!focused) process.exit(1);
-		process.exit(0);
+	if (!await backend.paneExists(registeredEditorPaneId)) {
+		trace("Editor pane does not exist");
+		await clearEditorLink(backend, targetPaneId);
+		return false;
 	}
-	const editorPaneId = await getEditorPaneId$1(targetPane);
-	if (editorPaneId === "") process.exit(1);
-	if (!await checkPaneExists$1(editorPaneId)) {
-		await clearEditorPaneId$1(targetPane);
+	try {
+		await backend.focusPane(registeredEditorPaneId);
+	} catch (error) {
+		throw new EditorFocusError(registeredEditorPaneId, error);
+	}
+	return true;
+}
+
+//#endregion
+//#region src/modes/resume.ts
+const logger$3 = getLogger(["editprompt", "resume"]);
+async function runResumeMode(targetPane, mux) {
+	const backend = getBackend(mux);
+	let switched;
+	try {
+		switched = await switchEditorFocus(backend, targetPane, backend.traceResume ? (message, properties) => logger$3.debug(message, properties) : void 0);
+	} catch (error) {
+		if (!(backend.quietResumeErrors === "all" || backend.quietResumeErrors === "editorFocus" && error instanceof EditorFocusError)) throw error instanceof EditorFocusError ? error.cause : error;
+		if (error instanceof EditorFocusError) logger$3.debug("Can't focus editorPaneId: {editorPaneId}, error: {error}", {
+			editorPaneId: error.editorPaneId,
+			error: error.cause
+		});
+		else {
+			const label = backend.name.charAt(0).toUpperCase() + backend.name.slice(1);
+			logger$3.debug(`${label} resume failed: {error}`, { error });
+		}
 		process.exit(1);
 	}
-	await focusPane$1(editorPaneId);
-	process.exit(0);
+	process.exit(switched ? 0 : 1);
 }
 const resumeCommand = define({
 	name: "resume",
@@ -1743,41 +2116,11 @@ async function runPressMode(key, delay = 0) {
 		logger$2.error("Key is required");
 		process.exit(1);
 	}
-	const config = readSendConfig();
-	let currentPaneId;
-	let isEditor;
-	if (config.mux === "tmux") {
-		currentPaneId = await getCurrentPaneId$1();
-		isEditor = await isEditorPane(currentPaneId);
-	} else if (config.mux === "wezterm") {
-		currentPaneId = await getCurrentPaneId();
-		isEditor = isEditorPaneFromConf(currentPaneId);
-	} else if (config.mux === "niwaterm") {
-		currentPaneId = await getCurrentPaneId$2();
-		isEditor = await isEditorPane$1(currentPaneId);
-	} else {
-		currentPaneId = await getCurrentPaneId$3();
-		isEditor = isEditorPaneFromConf$1(currentPaneId);
-	}
-	if (!isEditor) {
-		logger$2.error("Current pane is not an editor pane");
-		process.exit(1);
-	}
-	let targetPanes;
-	if (config.mux === "tmux") targetPanes = await getTargetPaneIds$1(currentPaneId);
-	else if (config.mux === "wezterm") targetPanes = await getTargetPaneIds(currentPaneId);
-	else if (config.mux === "niwaterm") targetPanes = await getTargetPaneIds$2(currentPaneId);
-	else targetPanes = await getTargetPaneIds$3(currentPaneId);
-	if (targetPanes.length === 0) {
-		logger$2.error("No target panes registered for this editor pane");
-		process.exit(1);
-	}
+	const backend = getBackend(readSendConfig().mux);
+	const { targetPaneIds } = await requireEditorContext(backend, logger$2);
 	let successCount = 0;
-	for (const targetPane of targetPanes) try {
-		if (config.mux === "wezterm") await sendKeyToWeztermPane(targetPane, key, delay);
-		else if (config.mux === "herdr") await sendKeyToHerdrPane(targetPane, key, delay);
-		else if (config.mux === "niwaterm") await sendKeyToNiwatermPane(targetPane, key, delay);
-		else await sendKeyToTmuxPane(targetPane, key, delay);
+	for (const targetPane of targetPaneIds) try {
+		await sendKeyToPane(backend, targetPane, key, delay);
 		successCount++;
 	} catch (error) {
 		logger$2.warn(`Failed to send key to pane ${targetPane}: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -1820,7 +2163,7 @@ const pressCommand = define({
 //#region src/modes/stash.ts
 const logger$1 = getLogger(["editprompt", "stash"]);
 function getStashKey(mux, targetPaneId) {
-	return `${mux === "herdr" ? getStorageNamespace() : mux}.targetPane.pane_${targetPaneId}.stash`;
+	return `${getBackend(mux).storageNamespace()}.targetPane.pane_${targetPaneId}.stash`;
 }
 async function pushStash(mux, targetPaneId, content) {
 	const key = (/* @__PURE__ */ new Date()).toISOString();
@@ -1862,37 +2205,10 @@ function dropStash(mux, targetPaneId, key) {
 }
 async function getTargetPaneForStash() {
 	const config = readSendConfig();
-	let currentPaneId;
-	let isEditor;
-	if (config.mux === "tmux") {
-		currentPaneId = await getCurrentPaneId$1();
-		isEditor = await isEditorPane(currentPaneId);
-	} else if (config.mux === "wezterm") {
-		currentPaneId = await getCurrentPaneId();
-		isEditor = isEditorPaneFromConf(currentPaneId);
-	} else if (config.mux === "niwaterm") {
-		currentPaneId = await getCurrentPaneId$2();
-		isEditor = await isEditorPane$1(currentPaneId);
-	} else {
-		currentPaneId = await getCurrentPaneId$3();
-		isEditor = isEditorPaneFromConf$1(currentPaneId);
-	}
-	if (!isEditor) {
-		logger$1.error("Current pane is not an editor pane");
-		process.exit(1);
-	}
-	let targetPanes;
-	if (config.mux === "tmux") targetPanes = await getTargetPaneIds$1(currentPaneId);
-	else if (config.mux === "wezterm") targetPanes = await getTargetPaneIds(currentPaneId);
-	else if (config.mux === "niwaterm") targetPanes = await getTargetPaneIds$2(currentPaneId);
-	else targetPanes = await getTargetPaneIds$3(currentPaneId);
-	if (targetPanes.length === 0) {
-		logger$1.error("No target panes registered for this editor pane");
-		process.exit(1);
-	}
+	const { targetPaneIds } = await requireEditorContext(getBackend(config.mux), logger$1);
 	return {
 		mux: config.mux,
-		targetPaneId: targetPanes[0]
+		targetPaneId: targetPaneIds[0]
 	};
 }
 async function runPush(rest, positionals) {
@@ -2034,18 +2350,21 @@ function buildOpenEditorArgv(options) {
 	if (options.verbose) argv.push("--verbose");
 	return argv;
 }
-async function runToggleMode(options, herdrApi = herdr_exports) {
-	if (options.mux !== "herdr") throw new Error("toggle currently supports only the Herdr multiplexer");
+async function runToggleMode(options, backend = getBackend(options.mux)) {
+	if (!canSplitPane(backend)) throw new Error(isBuiltinBackendName(backend.name) ? "toggle currently supports only the Herdr multiplexer" : `toggle is not supported by the '${backend.name}' multiplexer because it cannot split panes`);
 	if (!Number.isInteger(options.paneRows) || options.paneRows <= 0) throw new Error("--pane-rows must be a positive integer");
-	if (await herdrApi.resumeEditorPane(options.targetPane)) return;
+	if (await switchEditorFocus(backend, options.targetPane)) return;
 	const launchEnv = {};
 	if (process.env.NODE_NO_WARNINGS !== void 0) launchEnv.NODE_NO_WARNINGS = process.env.NODE_NO_WARNINGS;
-	const editorPaneId = await herdrApi.splitEditorPane(options.targetPane, options.paneRows, process.env.HERDR_ACTIVE_PANE_CWD, launchEnv);
+	const editorPaneId = await backend.splitPane(options.targetPane, {
+		rows: options.paneRows,
+		env: launchEnv
+	});
 	try {
-		await herdrApi.runCommandInPane(editorPaneId, buildOpenEditorArgv(options));
+		await backend.runInPane(editorPaneId, buildOpenEditorArgv(options));
 	} catch (error) {
 		try {
-			await herdrApi.closePane(editorPaneId);
+			await backend.closePane(editorPaneId);
 		} catch (closeError) {
 			logger.warn("Failed to close editor pane after launch failure: {error}", { error: closeError });
 		}
@@ -2102,7 +2421,9 @@ const toggleCommand = define({
 
 //#endregion
 //#region src/index.ts
-await cli(process.argv.slice(2), {
+const argv = process.argv.slice(2);
+if (mayUseConfiguredBackend(argv)) await setupUserConfig();
+await cli(argv, {
 	name: "editprompt",
 	description: "A CLI tool that lets you write prompts for CLI tools using your favorite text editor",
 	args: {},