pomotty 1.0.1 → 1.2.0

package/dist/cli.js

@@ -0,0 +1,1621 @@
+#!/usr/bin/env node
+import process$1 from "node:process";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { accessSync, constants, realpathSync, statSync, writeSync } from "node:fs";
+import path from "node:path";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import { on } from "node:events";
+import { emitKeypressEvents } from "node:readline";
+//#region src/diagnostics/writer.ts
+/**
+* 診断の出力先が閉じていても失敗しない書き込み処理を生成します。
+*
+* 最初の書き込みより前に`error`リスナーを登録し、閉じたパイプなどで
+* 発生する非同期エラーを未処理の例外にしません。同期例外も握りつぶし、
+* 一度でも書き込みに失敗したら以後の診断を出力しません。
+* これにより出力先の状態が終了コードへ影響しなくなります。
+*
+* @param stream 診断の出力先。
+* @returns 出力先の状態にかかわらず例外を投げない書き込み処理。
+*/
+const createDiagnosticWriter = (stream = process$1.stderr) => {
+	let unavailable = false;
+	stream.on("error", () => {
+		unavailable = true;
+	});
+	return (output) => {
+		if (unavailable) return;
+		try {
+			stream.write(output);
+		} catch {
+			unavailable = true;
+		}
+	};
+};
+//#endregion
+//#region src/notification/operation.ts
+const SUCCESS_EXIT_CODE$1 = 0;
+const EMPTY_SIZE = 0;
+const PLAYER_TIMEOUT_MS = 1e4;
+const FORCE_KILL_DELAY_MS = 1e3;
+const COMPLETION_GRACE_MS = 3e3;
+const DETACH_DELAY_MS = 1500;
+const bestEffort = (action) => {
+	try {
+		action();
+	} catch {}
+};
+const setUnrefTimeout = (callback, delayMs) => {
+	const timer = setTimeout(callback, delayMs);
+	timer.unref();
+	return timer;
+};
+const clearTimers = (timers) => {
+	for (const timer of timers) clearTimeout(timer);
+	timers.clear();
+};
+const spawnNodeChild = (commandPath, commandArguments, { env }) => {
+	const child = spawn(commandPath, [...commandArguments], {
+		env,
+		shell: false,
+		stdio: "ignore",
+		windowsHide: true
+	});
+	return {
+		detach: () => {
+			child.stdin?.destroy();
+			child.stdout?.destroy();
+			child.stderr?.destroy();
+			child.unref();
+		},
+		kill: (signal) => {
+			child.kill(signal);
+		},
+		onClose: (listener) => {
+			child.once("close", listener);
+		},
+		onError: (listener) => {
+			child.on("error", listener);
+		}
+	};
+};
+const createOperation = (completionNotice) => {
+	const callbacks = /* @__PURE__ */ new Set();
+	let cancelled = false;
+	return {
+		cancel: () => {
+			if (cancelled) return;
+			cancelled = true;
+			for (const callback of callbacks) bestEffort(callback);
+			callbacks.clear();
+		},
+		completionNotice,
+		isCancelled: () => cancelled,
+		onCancel: (callback) => {
+			if (cancelled) {
+				callback();
+				return () => {};
+			}
+			callbacks.add(callback);
+			return () => {
+				callbacks.delete(callback);
+			};
+		}
+	};
+};
+const createOperationTracker = (spawnChild = spawnNodeChild) => {
+	const activeChildren = /* @__PURE__ */ new Set(), activeOperations = /* @__PURE__ */ new Map(), forceKillTimers = /* @__PURE__ */ new Set(), terminationTimers = /* @__PURE__ */ new Set();
+	let shuttingDown = false, shutdownPromise;
+	const isOperationCancelled = (operation) => operation.isCancelled() || shuttingDown && !operation.completionNotice, scheduleForceKill = (child) => {
+		const timer = setUnrefTimeout(() => {
+			forceKillTimers.delete(timer);
+			if (activeChildren.has(child)) bestEffort(() => {
+				child.kill("SIGKILL");
+			});
+		}, FORCE_KILL_DELAY_MS);
+		forceKillTimers.add(timer);
+	}, spawnTracked = (operation, commandPath, commandArguments, options = {}) => {
+		if (isOperationCancelled(operation)) return { result: "cancelled" };
+		let child;
+		try {
+			child = spawnChild(commandPath, commandArguments, { env: options.env });
+		} catch {
+			return { result: "failure" };
+		}
+		activeChildren.add(child);
+		child.onError(() => {});
+		child.onClose(() => {
+			activeChildren.delete(child);
+			if (activeChildren.size === EMPTY_SIZE) clearTimers(terminationTimers);
+		});
+		if (isOperationCancelled(operation)) {
+			bestEffort(() => {
+				child.kill();
+			});
+			return { result: "cancelled" };
+		}
+		return {
+			child,
+			result: "success"
+		};
+	}, runChild = (operation, commandPath, commandArguments, { env, timeoutMs = PLAYER_TIMEOUT_MS } = {}) => new Promise((resolve) => {
+		if (isOperationCancelled(operation)) {
+			resolve("cancelled");
+			return;
+		}
+		const cleanups = [];
+		let settled = false;
+		const finish = (result) => {
+			if (settled) return;
+			settled = true;
+			for (const cleanup of cleanups) cleanup();
+			if (isOperationCancelled(operation)) resolve("cancelled");
+			else resolve(result);
+		};
+		cleanups.push(operation.onCancel(() => {
+			finish("cancelled");
+		}));
+		const spawned = spawnTracked(operation, commandPath, commandArguments, { env });
+		if (spawned.result !== "success") {
+			finish(spawned.result);
+			return;
+		}
+		const { child } = spawned;
+		child.onError(() => {
+			finish("failure");
+		});
+		child.onClose((code, signal) => {
+			if (code === SUCCESS_EXIT_CODE$1 && signal === null) finish("success");
+			else finish("failure");
+		});
+		const timeout = setTimeout(() => {
+			bestEffort(() => {
+				child.kill();
+			});
+			scheduleForceKill(child);
+			finish("failure");
+		}, timeoutMs);
+		cleanups.push(() => {
+			clearTimeout(timeout);
+		});
+	}), terminateChildren = () => {
+		clearTimers(forceKillTimers);
+		if (activeChildren.size === EMPTY_SIZE) return;
+		for (const child of activeChildren) bestEffort(() => {
+			child.kill();
+		});
+		terminationTimers.add(setUnrefTimeout(() => {
+			for (const child of activeChildren) bestEffort(() => {
+				child.kill("SIGKILL");
+			});
+		}, 500));
+		terminationTimers.add(setUnrefTimeout(() => {
+			for (const child of activeChildren) bestEffort(() => {
+				child.detach();
+			});
+		}, DETACH_DELAY_MS));
+	}, waitForCompletionNotices = () => {
+		const pending = [...activeOperations].filter(([operation]) => operation.completionNotice).map(([, promise]) => promise);
+		if (pending.length === EMPTY_SIZE) return Promise.resolve();
+		return new Promise((resolve) => {
+			const timer = setUnrefTimeout(resolve, COMPLETION_GRACE_MS);
+			Promise.all(pending).then(() => {
+				clearTimeout(timer);
+				resolve();
+			});
+		});
+	}, cancelOperations = (filter) => {
+		for (const operation of activeOperations.keys()) if (filter(operation)) operation.cancel();
+	};
+	return {
+		activeChildCount: () => activeChildren.size,
+		isOperationCancelled,
+		runChild,
+		shutdown: ({ complete }) => {
+			if (shutdownPromise) return shutdownPromise;
+			shuttingDown = true;
+			cancelOperations((operation) => !complete || !operation.completionNotice);
+			let grace = Promise.resolve();
+			if (complete) grace = waitForCompletionNotices();
+			shutdownPromise = grace.then(() => {
+				cancelOperations(() => true);
+				terminateChildren();
+			});
+			return shutdownPromise;
+		},
+		spawnTracked,
+		startOperation: (completionNotice, run) => {
+			if (shuttingDown) return;
+			const operation = createOperation(completionNotice), promise = run(operation).then(() => {}).catch(() => {}).finally(() => {
+				activeOperations.delete(operation);
+			});
+			activeOperations.set(operation, promise);
+			return operation;
+		}
+	};
+};
+//#endregion
+//#region src/notification/sound.ts
+const FALLBACK_SOUNDS = {
+	break: "\x07\x07",
+	work: "\x07"
+};
+const WINDOWS_SOUND_SCRIPT = [
+	"$player = New-Object System.Media.SoundPlayer",
+	"$player.SoundLocation = $env:POMOTTY_SOUND_FILE",
+	"$player.PlaySync()"
+].join("; ");
+const soundFileFor = (soundDirectory, phase) => fileURLToPath(new URL(`${phase}-end.wav`, soundDirectory));
+const commandsFor = (commands, soundFile, environment) => {
+	const candidates = [];
+	for (const commandPath of [
+		commands.afplay,
+		commands.paplay,
+		commands.aplay
+	]) if (commandPath !== void 0) candidates.push({
+		commandArguments: [soundFile],
+		commandPath
+	});
+	if (commands.powershell !== void 0) candidates.push({
+		commandArguments: [
+			"-NoProfile",
+			"-NonInteractive",
+			"-Command",
+			WINDOWS_SOUND_SCRIPT
+		],
+		commandPath: commands.powershell,
+		env: {
+			...environment,
+			POMOTTY_SOUND_FILE: soundFile
+		}
+	});
+	return candidates;
+};
+const runSoundCommands = async (operation, tracker, candidates, fallback) => {
+	for (const candidate of candidates) if (await tracker.runChild(operation, candidate.commandPath, candidate.commandArguments, { env: candidate.env }) !== "failure" || tracker.isOperationCancelled(operation)) return;
+	if (!tracker.isOperationCancelled(operation)) fallback();
+};
+const createSoundPlayer = ({ commands, environment = process$1.env, soundDirectory, spawnChild, tracker = createOperationTracker(spawnChild), writeFallback = createDiagnosticWriter() }) => ({
+	play: (phase, { completionNotice = false } = {}) => {
+		const candidates = commandsFor(commands, soundFileFor(soundDirectory, phase), environment), fallback = () => {
+			writeFallback(FALLBACK_SOUNDS[phase]);
+		};
+		tracker.startOperation(completionNotice, (operation) => runSoundCommands(operation, tracker, candidates, fallback));
+	},
+	shutdown: (options) => tracker.shutdown(options)
+});
+//#endregion
+//#region src/diagnostics/escape.ts
+const BACKSLASH = "\\";
+const BIDIRECTIONAL_PATTERN = /[\u061C\u200B\u200E\u200F\u2028-\u202E\u2066-\u206F\uFEFF]/u;
+const CONTROL_HEX_LENGTH = 2;
+const CONTROL_PATTERN = /[\u0000-\u001F\u007F-\u009F]/u;
+const EMPTY_CODE_POINT = 0;
+const FIRST_INDEX = 0;
+const HEXADECIMAL_RADIX = 16;
+const HEX_PAD_CHARACTER = "0";
+const MAXIMUM_CODE_POINTS = 160;
+const QUOTATION_MARK = "\"";
+const SURROGATE_HEX_LENGTH = 4;
+const SURROGATE_PATTERN = /[\uD800-\uDFFF]/u;
+const TRUNCATION_MARK = "…";
+const UNPADDED_HEX_LENGTH = 0;
+const characterToHexadecimal = (character, length) => (character.codePointAt(FIRST_INDEX) ?? EMPTY_CODE_POINT).toString(HEXADECIMAL_RADIX).toUpperCase().padStart(length, HEX_PAD_CHARACTER);
+const escapeUnsafeCharacter = (character) => {
+	if (CONTROL_PATTERN.test(character)) return String.raw`\x${characterToHexadecimal(character, CONTROL_HEX_LENGTH)}`;
+	if (BIDIRECTIONAL_PATTERN.test(character)) return String.raw`\u{${characterToHexadecimal(character, UNPADDED_HEX_LENGTH)}}`;
+	if (SURROGATE_PATTERN.test(character)) return String.raw`\u${characterToHexadecimal(character, SURROGATE_HEX_LENGTH)}`;
+	return character;
+};
+const escapeCharacter = (character) => {
+	if (character === BACKSLASH) return String.raw`\\`;
+	if (character === QUOTATION_MARK) return String.raw`\"`;
+	return escapeUnsafeCharacter(character);
+};
+const escapeDiagnostic = (value) => {
+	const codePoints = [...value], escaped = codePoints.slice(FIRST_INDEX, MAXIMUM_CODE_POINTS).map((character) => escapeCharacter(character)).join("");
+	if (codePoints.length > MAXIMUM_CODE_POINTS) return `${QUOTATION_MARK}${escaped}${TRUNCATION_MARK}${QUOTATION_MARK}`;
+	return `${QUOTATION_MARK}${escaped}${QUOTATION_MARK}`;
+};
+//#endregion
+//#region src/platform/commands.ts
+const AFPLAY_PATH = "/usr/bin/afplay";
+const DEFAULT_LINUX_PATH = [
+	"/usr/local/bin",
+	"/usr/bin",
+	"/bin"
+];
+const NODE_MODULES_SEGMENT = "node_modules";
+const BIN_SEGMENT = ".bin";
+const NEXT_SEGMENT_OFFSET = 1;
+const POWERSHELL_SEGMENTS = [
+	"System32",
+	"WindowsPowerShell",
+	"v1.0",
+	"powershell.exe"
+];
+const isExecutableFile = (target) => {
+	try {
+		if (!statSync(target).isFile()) return false;
+		accessSync(target, constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
+};
+const nodeFileSystem = {
+	isExecutableFile,
+	realpath: (target) => realpathSync(target)
+};
+const comparablePath = (value, context) => {
+	const normalized = context.pathApi.normalize(value);
+	if (context.caseInsensitive) return normalized.toLowerCase();
+	return normalized;
+};
+const isWithin = (parent, child, context) => {
+	const relative = context.pathApi.relative(comparablePath(parent, context), comparablePath(child, context));
+	return relative === "" || !relative.startsWith(`..${context.pathApi.sep}`) && relative !== ".." && !context.pathApi.isAbsolute(relative);
+};
+const containsNodeModulesBin = (value, context) => {
+	const segments = comparablePath(value, context).split(context.pathApi.sep).filter((segment) => segment !== "");
+	return segments.some((segment, index) => segment === NODE_MODULES_SEGMENT && segments[index + NEXT_SEGMENT_OFFSET] === BIN_SEGMENT);
+};
+const isExcluded = (value, context) => containsNodeModulesBin(value, context) || context.excludedDirectories.some((directory) => isWithin(directory, value, context));
+const tryRealpath = (target, context) => {
+	try {
+		return context.fileSystem.realpath(target);
+	} catch {
+		return;
+	}
+};
+const excludedDirectoriesFor = (cwd, fileSystem) => {
+	try {
+		return [cwd, fileSystem.realpath(cwd)];
+	} catch {
+		return [cwd];
+	}
+};
+const commandInDirectory = (directory, name, context) => {
+	if (!context.pathApi.isAbsolute(directory) || isExcluded(directory, context)) return;
+	const realDirectory = tryRealpath(directory, context);
+	if (realDirectory === void 0 || isExcluded(realDirectory, context)) return;
+	const candidate = tryRealpath(context.pathApi.join(realDirectory, name), context);
+	if (candidate === void 0 || isExcluded(candidate, context) || !context.fileSystem.isExecutableFile(candidate)) return;
+	return candidate;
+};
+const findInPath = (name, environment, context) => {
+	const directories = environment.PATH?.split(path.posix.delimiter) ?? DEFAULT_LINUX_PATH;
+	for (const directory of directories) {
+		const resolved = commandInDirectory(directory, name, context);
+		if (resolved !== void 0) return resolved;
+	}
+};
+const findWindowsPowerShell = (environment, context) => {
+	const systemRoot = environment.SystemRoot;
+	if (systemRoot === void 0 || !path.win32.isAbsolute(systemRoot)) return;
+	const realSystemRoot = tryRealpath(systemRoot, context);
+	if (realSystemRoot === void 0) return;
+	const candidate = tryRealpath(path.win32.join(realSystemRoot, ...POWERSHELL_SEGMENTS), context);
+	if (candidate === void 0 || isExcluded(candidate, context) || !context.fileSystem.isExecutableFile(candidate)) return;
+	return candidate;
+};
+const resolvePlayerCommands = ({ cwd = process$1.cwd(), environment = process$1.env, fileSystem = nodeFileSystem, platform = process$1.platform } = {}) => {
+	switch (platform) {
+		case "darwin":
+			if (fileSystem.isExecutableFile(AFPLAY_PATH)) return { afplay: AFPLAY_PATH };
+			return {};
+		case "linux": {
+			const context = {
+				caseInsensitive: false,
+				excludedDirectories: excludedDirectoriesFor(cwd, fileSystem),
+				fileSystem,
+				pathApi: path.posix
+			};
+			return {
+				aplay: findInPath("aplay", environment, context),
+				paplay: findInPath("paplay", environment, context)
+			};
+		}
+		case "win32": {
+			const context = {
+				caseInsensitive: true,
+				excludedDirectories: excludedDirectoriesFor(cwd, fileSystem),
+				fileSystem,
+				pathApi: path.win32
+			};
+			return { powershell: findWindowsPowerShell(environment, context) };
+		}
+		default: return {};
+	}
+};
+//#endregion
+//#region src/timer/state.ts
+const FIRST_CYCLE$1 = 1;
+const COUNT_INCREMENT = 1;
+const NO_TIME$1 = 0;
+const durationFor$1 = (phase, settings) => {
+	if (phase === "work") return settings.workDurationMs;
+	return settings.breakDurationMs;
+};
+const startPhase = ({ completedPomodoros, cycle, phase }, now, settings) => ({
+	completedPomodoros,
+	cycle,
+	endsAt: now + durationFor$1(phase, settings),
+	paused: false,
+	phase,
+	remainingMs: NO_TIME$1
+});
+const createInitialState = (settings, startedAt) => startPhase({
+	completedPomodoros: 0,
+	cycle: FIRST_CYCLE$1,
+	phase: "work"
+}, startedAt, settings);
+const nextPhase = ({ completedPomodoros, cycle, phase }, now, settings) => {
+	if (phase === "work") return startPhase({
+		completedPomodoros,
+		cycle,
+		phase: "break"
+	}, now, settings);
+	if (cycle < settings.loopCount) return startPhase({
+		completedPomodoros,
+		cycle: cycle + COUNT_INCREMENT,
+		phase: "work"
+	}, now, settings);
+};
+const completedPomodorosAfterTimeout = (state) => {
+	if (state.phase === "work") return state.completedPomodoros + COUNT_INCREMENT;
+	return state.completedPomodoros;
+};
+const transitionFromTimeout = (state, now, settings) => {
+	const next = nextPhase({
+		completedPomodoros: completedPomodorosAfterTimeout(state),
+		cycle: state.cycle,
+		phase: state.phase
+	}, now, settings);
+	if (next === void 0) return {
+		completedPhase: state.phase,
+		final: true,
+		state
+	};
+	return {
+		completedPhase: state.phase,
+		final: false,
+		state: next
+	};
+};
+const transitionFromSkip = (state, now, settings) => {
+	const next = nextPhase(state, now, settings);
+	if (next === void 0) return {
+		final: true,
+		skippedPhase: state.phase,
+		state
+	};
+	return {
+		final: false,
+		skippedPhase: state.phase,
+		state: next
+	};
+};
+const remainingMsAt = (state, now) => {
+	if (state.paused) return state.remainingMs;
+	return Math.max(NO_TIME$1, state.endsAt - now);
+};
+const togglePause = (state, now) => {
+	if (state.paused) return {
+		completedPomodoros: state.completedPomodoros,
+		cycle: state.cycle,
+		endsAt: now + state.remainingMs,
+		paused: false,
+		phase: state.phase,
+		remainingMs: NO_TIME$1
+	};
+	return {
+		completedPomodoros: state.completedPomodoros,
+		cycle: state.cycle,
+		endsAt: state.endsAt,
+		paused: true,
+		phase: state.phase,
+		remainingMs: remainingMsAt(state, now)
+	};
+};
+const MILLISECONDS_PER_MINUTE = 6e4;
+const DEFAULT_BREAK_DURATION_MS = 5 * MILLISECONDS_PER_MINUTE;
+const DEFAULT_WORK_DURATION_MS = 15 * MILLISECONDS_PER_MINUTE;
+const sleepWithTimer = (durationMs, signal) => setTimeout$1(durationMs, void 0, { signal });
+const combineSignals = (signal, internal) => {
+	if (signal === void 0) return internal;
+	return AbortSignal.any([signal, internal]);
+};
+const waitForTick = async (sleep, signal) => {
+	if (signal?.aborted) return false;
+	try {
+		await sleep(250, signal);
+	} catch (error) {
+		if (signal?.aborted) return false;
+		throw error;
+	}
+	return signal?.aborted !== true;
+};
+const runPomodoroTimer = async ({ workDurationMs = DEFAULT_WORK_DURATION_MS, breakDurationMs = DEFAULT_BREAK_DURATION_MS, loopCount, now = Date.now, sleep = sleepWithTimer, signal, onPhaseStarted, onPhaseCompleted, onPhaseSkipped, onTick, bindControls }) => {
+	const settings = {
+		breakDurationMs,
+		loopCount,
+		workDurationMs
+	}, startedAt = now(), finishController = new AbortController(), tickSignal = combineSignals(signal, finishController.signal);
+	let state = createInitialState(settings, startedAt), finished = false;
+	/** 最後の休憩の終了でタイマーを完了し、待機中のtickを打ち切ります。 */
+	const finish = () => {
+		finished = true;
+		finishController.abort();
+	}, notifyStarted = () => {
+		onPhaseStarted?.(state.phase, durationFor$1(state.phase, settings));
+	}, settleExpiredPhase = (currentTime) => {
+		if (finished || state.paused || currentTime < state.endsAt) return finished;
+		const transition = transitionFromTimeout(state, currentTime, settings);
+		({state} = transition);
+		onPhaseCompleted?.(transition.completedPhase, { final: transition.final });
+		if (transition.final) {
+			finish();
+			return true;
+		}
+		notifyStarted();
+		return false;
+	}, applyManualAction = (action) => {
+		if (finished || tickSignal.aborted) return finished;
+		const currentTime = now();
+		if (settleExpiredPhase(currentTime)) return true;
+		action(currentTime);
+		if (!finished) onTick?.(state, currentTime);
+		return finished;
+	};
+	bindControls?.({
+		settle: () => applyManualAction(() => {}),
+		skip: () => {
+			applyManualAction((currentTime) => {
+				const transition = transitionFromSkip(state, currentTime, settings);
+				({state} = transition);
+				onPhaseSkipped?.(transition.skippedPhase);
+				if (transition.final) {
+					finish();
+					return;
+				}
+				notifyStarted();
+			});
+		},
+		togglePause: () => {
+			applyManualAction((currentTime) => {
+				state = togglePause(state, currentTime);
+			});
+		}
+	});
+	notifyStarted();
+	onTick?.(state, startedAt);
+	for (;;) {
+		if (!await waitForTick(sleep, tickSignal)) return {
+			completed: finished,
+			completedPomodoros: state.completedPomodoros
+		};
+		const currentTime = now();
+		if (settleExpiredPhase(currentTime)) return {
+			completed: true,
+			completedPomodoros: state.completedPomodoros
+		};
+		onTick?.(state, currentTime);
+	}
+};
+//#endregion
+//#region src/terminal/output.ts
+/** 出力先が閉じたパイプであることを示すエラーコードです。 */
+const BROKEN_PIPE_CODE = "EPIPE";
+const isBrokenPipe = (error) => typeof error === "object" && error !== null && Reflect.get(error, "code") === BROKEN_PIPE_CODE;
+const createStandardOutput = (onFailure, stream = process$1.stdout) => {
+	let unavailable = false;
+	const fail = (error) => {
+		if (unavailable) return;
+		unavailable = true;
+		onFailure(error);
+	};
+	stream.on("error", fail);
+	return (output) => {
+		if (unavailable) return;
+		try {
+			stream.write(output);
+		} catch (error) {
+			fail(error);
+		}
+	};
+};
+const OPTIONS = [
+	{
+		description: `Work duration in minutes (1-1440, default: 15)`,
+		name: "--work",
+		valueName: "<minutes>"
+	},
+	{
+		description: `Break duration in minutes (1-1440, default: 5)`,
+		name: "--break",
+		valueName: "<minutes>"
+	},
+	{
+		description: `Work-break repetitions (positive integer, default: 3)`,
+		name: "--loop",
+		valueName: "<count>"
+	},
+	{
+		alias: "-h",
+		description: "Print help",
+		name: "--help"
+	}
+];
+//#endregion
+//#region src/terminal/input.ts
+const CHOICES = ["OK", "NG"];
+const ENTER_KEY_NAMES = /* @__PURE__ */ new Set(["enter", "return"]);
+const FIRST_CHOICE_INDEX = 0;
+const KEYPRESS_EVENT_KEY_INDEX = 1;
+const MOVE_KEY_NAMES = /* @__PURE__ */ new Set(["down", "up"]);
+const NEXT_INDEX_OFFSET = 1;
+const REDRAW_SEQUENCE = `\r\u001B[${CHOICES.length}A\u001B[J`;
+const STDIN_CLOSE_EVENTS = ["end", "close"];
+const SELECTION_QUESTION = "Start working? (Use ↑/↓ to select, Enter to confirm)";
+const keyFrom = (value) => {
+	let key = {}, normalizedName = "";
+	if (typeof value === "object" && value !== null) key = value;
+	const ctrl = Reflect.get(key, "ctrl"), name = Reflect.get(key, "name");
+	if (typeof name === "string") normalizedName = name;
+	return {
+		ctrl: ctrl === true,
+		name: normalizedName
+	};
+};
+const createSelectionTerminal = ({ input = process$1.stdin, signal, write = (output) => {
+	process$1.stdout.write(output);
+} } = {}) => {
+	emitKeypressEvents(input);
+	const inputWasFlowing = input.readableFlowing === true, keypressEvents = on(input, "keypress", { close: STDIN_CLOSE_EVENTS }), rawModeWasEnabled = input.isRaw === true, supportsRawMode = input.isTTY === true && typeof input.setRawMode === "function", stopListening = () => {
+		keypressEvents.return?.();
+	};
+	let restored = false;
+	signal?.addEventListener("abort", stopListening, { once: true });
+	if (signal?.aborted) stopListening();
+	if (supportsRawMode && !rawModeWasEnabled) input.setRawMode?.(true);
+	if (!inputWasFlowing) input.resume();
+	return {
+		nextKey: async () => {
+			const event = await keypressEvents.next();
+			if (event.done) return {
+				ctrl: true,
+				name: "c"
+			};
+			return keyFrom(event.value.at(KEYPRESS_EVENT_KEY_INDEX));
+		},
+		restore: async () => {
+			if (restored) return;
+			restored = true;
+			signal?.removeEventListener("abort", stopListening);
+			await keypressEvents.return?.();
+			if (supportsRawMode && !rawModeWasEnabled) input.setRawMode?.(false);
+			if (!inputWasFlowing) input.pause();
+		},
+		write
+	};
+};
+const markerFor = (selected) => {
+	if (selected) return "❯";
+	return " ";
+};
+const renderSelection = (selectedIndex) => [SELECTION_QUESTION, ...CHOICES.map((choice, index) => `${markerFor(index === selectedIndex)} ${choice}`)].join("\n");
+const nextChoiceIndex = (selectedIndex) => {
+	if (selectedIndex === FIRST_CHOICE_INDEX) return CHOICES.length - NEXT_INDEX_OFFSET;
+	return FIRST_CHOICE_INDEX;
+};
+const handleKey = (key, selectedIndex, terminal) => {
+	if (key.ctrl && key.name === "c") {
+		terminal.write("\n");
+		return false;
+	}
+	if (MOVE_KEY_NAMES.has(key.name)) {
+		const newSelectedIndex = nextChoiceIndex(selectedIndex);
+		terminal.write(`${REDRAW_SEQUENCE}${renderSelection(newSelectedIndex)}`);
+		return newSelectedIndex;
+	}
+	if (ENTER_KEY_NAMES.has(key.name)) {
+		terminal.write("\n");
+		return CHOICES[selectedIndex] === "OK";
+	}
+	return selectedIndex;
+};
+const confirmWorkStart = async ({ createTerminal = createSelectionTerminal, ...terminalParameters } = {}) => {
+	const terminal = createTerminal(terminalParameters);
+	let selectedIndex = FIRST_CHOICE_INDEX;
+	try {
+		terminal.write(renderSelection(selectedIndex));
+		for (;;) {
+			const key = await terminal.nextKey(), selection = handleKey(key, selectedIndex, terminal);
+			if (typeof selection === "boolean") return selection;
+			selectedIndex = selection;
+		}
+	} finally {
+		await terminal.restore();
+	}
+};
+//#endregion
+//#region src/terminal/constants.ts
+/**
+* ロゴが収まらない狭い端末で、ロゴの代わりに表示する見出しです。
+*/
+const COMPACT_LOGO = `
+  🍅 pomotty
+`;
+const LOGO = `
+  ██████╗  ██████╗ ███╗   ███╗ ██████╗ ████████╗████████╗██╗   ██╗
+  ██╔══██╗██╔═══██╗████╗ ████║██╔═══██╗╚══██╔══╝╚══██╔══╝╚██╗ ██╔╝
+  ██████╔╝██║   ██║██╔████╔██║██║   ██║   ██║      ██║    ╚████╔╝ 
+  ██╔═══╝ ██║   ██║██║╚██╔╝██║██║   ██║   ██║      ██║     ╚██╔╝  
+  ██║     ╚██████╔╝██║ ╚═╝ ██║╚██████╔╝   ██║      ██║      ██║   
+  ╚═╝      ╚═════╝ ╚═╝     ╚═╝ ╚═════╝    ╚═╝      ╚═╝      ╚═╝
+`;
+//#endregion
+//#region src/terminal/frame-line.ts
+const ELLIPSIS = "…";
+const NO_WIDTH = 0;
+const SINGLE_WIDTH = 1;
+const DOUBLE_WIDTH = 2;
+const WIDE_CHARACTER = /[\u1100-\u115F\u2615\u2E80-\uA4CF\uAC00-\uD7A3\uF900-\uFAFF\uFE30-\uFE4F\uFF00-\uFF60\uFFE0-\uFFE6\u{1F300}-\u{1FAFF}]/u;
+const ZERO_WIDTH_CHARACTERS = /* @__PURE__ */ new Set([
+	"‍",
+	"︎",
+	"️"
+]);
+const SGR_DEFAULT_FOREGROUND = "\x1B[39m";
+const SGR_TONES = {
+	break: "\x1B[32m",
+	work: "\x1B[31m"
+};
+const characterWidth = (character) => {
+	if (ZERO_WIDTH_CHARACTERS.has(character)) return NO_WIDTH;
+	if (WIDE_CHARACTER.test(character)) return DOUBLE_WIDTH;
+	return SINGLE_WIDTH;
+};
+const cellWidth = (text) => [...text].reduce((width, character) => width + characterWidth(character), NO_WIDTH);
+const lineWidth = (line) => line.reduce((width, segment) => width + cellWidth(segment.text), NO_WIDTH);
+const takeWithin = (text, maxWidth) => {
+	let taken = "", used = NO_WIDTH;
+	for (const character of text) {
+		used += characterWidth(character);
+		if (used > maxWidth) break;
+		taken += character;
+	}
+	return taken;
+};
+const takeSegmentsWithin = (line, maxWidth) => {
+	const kept = [];
+	let remaining = maxWidth;
+	for (const { text, tone } of line) {
+		const taken = takeWithin(text, remaining);
+		if (taken !== "") kept.push({
+			text: taken,
+			tone
+		});
+		if (taken !== text) break;
+		remaining -= cellWidth(taken);
+	}
+	return kept;
+};
+const truncateLine = (line, maxWidth) => {
+	if (lineWidth(line) <= maxWidth) return line;
+	return [...takeSegmentsWithin(line, maxWidth - cellWidth(ELLIPSIS)), { text: ELLIPSIS }];
+};
+const stringifySegment = ({ text, tone }, color) => {
+	if (!color || !tone || text === "") return text;
+	return `${SGR_TONES[tone]}${text}${SGR_DEFAULT_FOREGROUND}`;
+};
+const stringifyFrameLine = (line, color) => line.map((segment) => stringifySegment(segment, color)).join("").trimEnd();
+const isColorEnabled = (env) => (env.NO_COLOR ?? "") === "";
+//#endregion
+//#region src/terminal/render.ts
+const CLI_OPTION_INDEX = 2;
+const LOGO_WIDTH = Math.max(...LOGO.split("\n").map((line) => cellWidth(line)));
+const RIGHT_MARGIN$1 = 1;
+const canShowLogo = (columns) => !columns || LOGO_WIDTH <= columns - RIGHT_MARGIN$1;
+const createCliOutput = ({ columns, options, optionName = process.argv.at(CLI_OPTION_INDEX) }) => {
+	const option = options.find(({ alias, name }) => alias === optionName || name === optionName);
+	if (!option && canShowLogo(columns)) return `${LOGO}\n`;
+	if (!option) return `${COMPACT_LOGO}\n`;
+	return [
+		"Pomotty CLI",
+		"",
+		"Usage: pomotty [OPTIONS]",
+		"",
+		"Options:",
+		...options.flatMap(({ alias, description, name, valueName }) => {
+			return [`  ${[alias, [name, valueName].filter(Boolean).join(" ")].filter(Boolean).join(", ")}`, `          ${description}`];
+		}),
+		""
+	].join("\n");
+};
+//#endregion
+//#region src/terminal/inline-renderer.ts
+const CSI = "\x1B[";
+const NO_ROWS = 0;
+const CLEAR_LINE = `${CSI}2K`;
+const cursorUp = (rows) => {
+	if (rows <= NO_ROWS) return "";
+	return `${CSI}${rows}A`;
+};
+const createInlineRenderer = (write) => {
+	let previous, renderedRows = NO_ROWS;
+	const eraseSequence = () => `${cursorUp(renderedRows)}${`${CLEAR_LINE}\n`.repeat(renderedRows)}${cursorUp(renderedRows)}`;
+	return {
+		log: (output) => {
+			write(`${eraseSequence()}${output}`);
+			previous = void 0;
+			renderedRows = NO_ROWS;
+		},
+		release: () => {
+			previous = void 0;
+			renderedRows = NO_ROWS;
+		},
+		render: (lines) => {
+			const frame = lines.join("\n");
+			if (frame === previous) return;
+			const leftoverRows = Math.max(NO_ROWS, renderedRows - lines.length);
+			write([
+				cursorUp(renderedRows),
+				...lines.map((line) => `${CLEAR_LINE}${line}\n`),
+				`${CLEAR_LINE}\n`.repeat(leftoverRows),
+				cursorUp(leftoverRows)
+			].join(""));
+			previous = frame;
+			renderedRows = lines.length;
+		}
+	};
+};
+//#endregion
+//#region src/terminal/terminal-guard.ts
+const HIDE_CURSOR = "\x1B[?25l";
+const SHOW_CURSOR = "\x1B[?25h";
+const TERMINATION_SIGNALS = [
+	"SIGHUP",
+	"SIGINT",
+	"SIGTERM"
+];
+const createSyncCursorRestorer = (terminal) => () => {
+	if (terminal.fd === void 0) return;
+	try {
+		writeSync(terminal.fd, SHOW_CURSOR);
+	} catch {}
+};
+const createTerminalGuard = ({ onSignal, processEvents, terminal, write }) => {
+	const restoreCursorSync = createSyncCursorRestorer(terminal), signalHandlers = TERMINATION_SIGNALS.map((signal) => {
+		const handler = () => {
+			onSignal(signal);
+		};
+		processEvents.on(signal, handler);
+		return [signal, handler];
+	});
+	let cursorHidden = false, released = false;
+	return {
+		hideCursor: () => {
+			if (cursorHidden || released) return;
+			cursorHidden = true;
+			processEvents.on("exit", restoreCursorSync);
+			write(HIDE_CURSOR);
+		},
+		release: () => {
+			if (released) return;
+			released = true;
+			for (const [signal, handler] of signalHandlers) processEvents.off(signal, handler);
+			if (cursorHidden) {
+				write(SHOW_CURSOR);
+				processEvents.off("exit", restoreCursorSync);
+			}
+		}
+	};
+};
+//#endregion
+//#region src/terminal/clock.ts
+const MILLISECONDS_PER_SECOND = 1e3;
+const SECONDS_PER_MINUTE = 60;
+const SECONDS_PER_HOUR = 3600;
+const PERCENT$1 = 100;
+const TIME_PART_WIDTH = 2;
+const NO_TIME = 0;
+const MIN_RATIO = 0;
+const MAX_RATIO = 1;
+const twoDigits = (value) => String(value).padStart(TIME_PART_WIDTH, "0");
+const formatClock = (seconds) => {
+	const hours = Math.floor(seconds / SECONDS_PER_HOUR), minutes = Math.floor(seconds % SECONDS_PER_HOUR / SECONDS_PER_MINUTE), restSeconds = seconds % SECONDS_PER_MINUTE;
+	if (hours === NO_TIME) return `${minutes}:${twoDigits(restSeconds)}`;
+	return `${hours}:${twoDigits(minutes)}:${twoDigits(restSeconds)}`;
+};
+const toDisplaySeconds = (milliseconds) => Math.ceil(milliseconds / MILLISECONDS_PER_SECOND);
+const formatDuration = (milliseconds) => formatClock(toDisplaySeconds(milliseconds));
+const durationFor = (phase, settings) => {
+	if (phase === "work") return settings.workDurationMs;
+	return settings.breakDurationMs;
+};
+const progressFor = (state, now, settings) => {
+	const durationMs = durationFor(state.phase, settings), remainingMs = remainingMsAt(state, now), ratio = Math.min(MAX_RATIO, Math.max(MIN_RATIO, (durationMs - remainingMs) / durationMs)), remainingSeconds = toDisplaySeconds(remainingMs), totalSeconds = toDisplaySeconds(durationMs);
+	return {
+		elapsedSeconds: Math.max(NO_TIME, totalSeconds - remainingSeconds),
+		percent: Math.floor(ratio * PERCENT$1),
+		ratio,
+		remainingSeconds,
+		totalSeconds
+	};
+};
+//#endregion
+//#region src/terminal/timeline.ts
+const BLOCK = "█";
+const EMPTY_CELL = "·";
+const EIGHTH_BLOCKS = [
+	"",
+	"▏",
+	"▎",
+	"▍",
+	"▌",
+	"▋",
+	"▊",
+	"▉"
+];
+const EIGHTHS_PER_CELL = 8;
+const INDENT$1 = "  ";
+const LABEL_GAP = "  ";
+const BAR_GAP = " ";
+const CURRENT_LABEL = "◀ now";
+const DONE_LABEL = "✓";
+const FIRST_CYCLE = 1;
+const NOT_STARTED = 0;
+const NO_CYCLES = 0;
+const COMPLETED = 1;
+const ONE_CELL = 1;
+const TIMELINE_CONTEXT = 2;
+const TIMELINE_CELLS = 20;
+const TIMELINE_MIN_CELLS = 2;
+const TIMELINE_MAX_ROWS = 5;
+const createSmoothBar = (ratio, cells, tone) => {
+	const eighths = Math.floor(ratio * cells * EIGHTHS_PER_CELL), fullCells = Math.floor(eighths / EIGHTHS_PER_CELL), partial = EIGHTH_BLOCKS[eighths % EIGHTHS_PER_CELL] ?? "", filled = `${BLOCK.repeat(fullCells)}${partial}`;
+	return [{
+		text: filled,
+		tone
+	}, { text: EMPTY_CELL.repeat(cells - cellWidth(filled)) }];
+};
+const timelineCellsFor = (settings) => {
+	const totalMs = settings.workDurationMs + settings.breakDurationMs, work = Math.min(18, Math.max(TIMELINE_MIN_CELLS, Math.round(TIMELINE_CELLS * settings.workDurationMs / totalMs)));
+	return {
+		break: TIMELINE_CELLS - work,
+		work
+	};
+};
+const timelineRangeFor = (cycle, loopCount) => {
+	const lastStart = Math.max(FIRST_CYCLE, loopCount - TIMELINE_MAX_ROWS + FIRST_CYCLE), first = Math.min(lastStart, Math.max(FIRST_CYCLE, cycle - TIMELINE_CONTEXT));
+	return [first, Math.min(loopCount, first + TIMELINE_MAX_ROWS - FIRST_CYCLE)];
+};
+const cycleStatusFor = (row, state, ratio) => {
+	if (row < state.cycle) return {
+		breakRatio: COMPLETED,
+		label: DONE_LABEL,
+		workRatio: COMPLETED
+	};
+	if (row > state.cycle) return {
+		breakRatio: NOT_STARTED,
+		label: "",
+		workRatio: NOT_STARTED
+	};
+	if (state.phase === "work") return {
+		breakRatio: NOT_STARTED,
+		label: CURRENT_LABEL,
+		workRatio: ratio
+	};
+	return {
+		breakRatio: ratio,
+		label: CURRENT_LABEL,
+		workRatio: COMPLETED
+	};
+};
+const createCycleRow = (label, status, cells) => {
+	const row = [
+		{ text: `${INDENT$1}${label}${LABEL_GAP}` },
+		...createSmoothBar(status.workRatio, cells.work, "work"),
+		{ text: BAR_GAP },
+		...createSmoothBar(status.breakRatio, cells.break, "break")
+	];
+	if (status.label !== "") row.push({ text: `${LABEL_GAP}${status.label}` });
+	return row;
+};
+const createLegend = (settings, cells) => {
+	const workLegend = `work ${formatDuration(settings.workDurationMs)}`, breakLegend = `break ${formatDuration(settings.breakDurationMs)}`, breakColumn = cells.work + ONE_CELL;
+	if (cellWidth(workLegend) < breakColumn) return `${workLegend.padEnd(breakColumn)}${breakLegend}`;
+	return `${workLegend} · ${breakLegend}`;
+};
+const hiddenCyclesLines = (text, count) => {
+	if (count <= NO_CYCLES) return [];
+	return [[{ text }]];
+};
+const createTimeline = (state, settings, ratio) => {
+	const cells = timelineCellsFor(settings), [first, last] = timelineRangeFor(state.cycle, settings.loopCount), labelWidth = cellWidth(`#${last}`), prefix = " ".repeat(cellWidth(`${INDENT$1}${LABEL_GAP}`) + labelWidth), hiddenBefore = first - FIRST_CYCLE, hiddenAfter = settings.loopCount - last, rows = Array.from({ length: last - first + FIRST_CYCLE }, (_value, index) => {
+		const cycle = first + index;
+		return createCycleRow(`#${cycle}`.padEnd(labelWidth), cycleStatusFor(cycle, state, ratio), cells);
+	});
+	return [
+		...hiddenCyclesLines(`${prefix}⋮ ${hiddenBefore} done`, hiddenBefore),
+		...rows,
+		...hiddenCyclesLines(`${prefix}⋮ ${hiddenAfter} more`, hiddenAfter),
+		[{ text: `${prefix}${createLegend(settings, cells)}` }]
+	];
+};
+//#endregion
+//#region src/terminal/timer-view.ts
+const BAR_WIDTH = 40;
+const INDENT = "  ";
+const MIN_GAP = 2;
+const HALF = 2;
+const NO_CELLS = 0;
+const MIN_WIDTH = 1;
+const PERCENT = 100;
+const FALLBACK_COLUMNS = 80;
+const RIGHT_MARGIN = 1;
+const COMPACT_MIN_WIDTH = 20;
+const BIG_DIGIT_ROWS = 5;
+const BIG_DIGITS = {
+	"0": [
+		"###",
+		"# #",
+		"# #",
+		"# #",
+		"###"
+	],
+	"1": [
+		"## ",
+		" # ",
+		" # ",
+		" # ",
+		"###"
+	],
+	"2": [
+		"###",
+		"  #",
+		"###",
+		"#  ",
+		"###"
+	],
+	"3": [
+		"###",
+		"  #",
+		"###",
+		"  #",
+		"###"
+	],
+	"4": [
+		"# #",
+		"# #",
+		"###",
+		"  #",
+		"  #"
+	],
+	"5": [
+		"###",
+		"#  ",
+		"###",
+		"  #",
+		"###"
+	],
+	"6": [
+		"###",
+		"#  ",
+		"###",
+		"# #",
+		"###"
+	],
+	"7": [
+		"###",
+		"  #",
+		"  #",
+		"  #",
+		"  #"
+	],
+	"8": [
+		"###",
+		"# #",
+		"###",
+		"# #",
+		"###"
+	],
+	"9": [
+		"###",
+		"# #",
+		"###",
+		"  #",
+		"###"
+	],
+	":": [
+		" ",
+		"#",
+		" ",
+		"#",
+		" "
+	]
+};
+const BIG_PIXEL_ON = "██";
+const BIG_PIXEL_OFF = "  ";
+const BIG_DIGIT_GAP = " ";
+const LINE_FILLED = "━";
+const LINE_EMPTY = "─";
+const PHASE_ICONS$1 = {
+	break: "☕",
+	work: "🍅"
+};
+const PHASE_LABELS = {
+	break: "BREAK",
+	work: "WORK"
+};
+const PAUSED_LABEL = "PAUSED";
+const KEY_GUIDES = {
+	paused: "[space] resume   [s] skip   [q] quit",
+	running: "[space] pause   [s] skip   [q] quit"
+};
+const COMPACT_KEY_GUIDES = {
+	paused: "[sp]resume [s]skip [q]quit",
+	running: "[sp]pause [s]skip [q]quit"
+};
+const keyGuideKind = (state) => {
+	if (state.paused) return "paused";
+	return "running";
+};
+const spaces = (cells) => " ".repeat(Math.max(NO_CELLS, cells));
+const bigPixel = (pixel) => {
+	if (pixel === "#") return BIG_PIXEL_ON;
+	return BIG_PIXEL_OFF;
+};
+const renderBigClock = (clock) => Array.from({ length: BIG_DIGIT_ROWS }, (_value, row) => [...clock].map((character) => [...(BIG_DIGITS[character] ?? []).at(row) ?? ""].map((pixel) => bigPixel(pixel)).join("")).join(BIG_DIGIT_GAP));
+const createBigClockLines = (clock, phase) => {
+	const rows = renderBigClock(clock), offset = Math.floor((BAR_WIDTH - cellWidth(rows.at(NO_CELLS) ?? "")) / HALF);
+	return rows.map((row) => [{ text: `${INDENT}${spaces(offset)}` }, {
+		text: row.trimEnd(),
+		tone: phase
+	}]);
+};
+const createLineBar = (percent, cells, tone) => {
+	const filled = Math.floor(percent * cells / PERCENT);
+	return [{
+		text: LINE_FILLED.repeat(filled),
+		tone
+	}, { text: LINE_EMPTY.repeat(cells - filled) }];
+};
+const spreadLabels = ([left, center, right]) => {
+	const centerStart = Math.floor((BAR_WIDTH - cellWidth(center)) / HALF), leftGap = centerStart - cellWidth(left), rightGap = BAR_WIDTH - centerStart - cellWidth(center) - cellWidth(right);
+	if (leftGap < MIN_GAP || rightGap < MIN_GAP) return [
+		left,
+		center,
+		right
+	].join(spaces(MIN_GAP));
+	return `${left}${spaces(leftGap)}${center}${spaces(rightGap)}${right}`;
+};
+const phaseSegment = ({ paused, phase }) => {
+	const label = `${PHASE_ICONS$1[phase]} ${PHASE_LABELS[phase]}`;
+	if (paused) return {
+		text: `${label} ${PAUSED_LABEL}`,
+		tone: phase
+	};
+	return {
+		text: label,
+		tone: phase
+	};
+};
+const minimalPhaseLabel = ({ paused, phase }) => {
+	if (paused) return PAUSED_LABEL;
+	return PHASE_LABELS[phase];
+};
+const createHeader = (state, settings) => {
+	const phase = phaseSegment(state), cycle = `Cycle ${state.cycle} / ${settings.loopCount}`, gap = Math.max(MIN_GAP, BAR_WIDTH - cellWidth(phase.text) - cellWidth(cycle));
+	return [
+		{ text: INDENT },
+		phase,
+		{ text: `${spaces(gap)}${cycle}` }
+	];
+};
+const createFullFrame = ({ progress, settings, state }) => [
+	createHeader(state, settings),
+	[],
+	...createBigClockLines(formatClock(progress.remainingSeconds), state.phase),
+	[],
+	[{ text: INDENT }, ...createLineBar(progress.percent, BAR_WIDTH, state.phase)],
+	[{ text: `${INDENT}${spreadLabels([
+		`${formatClock(progress.elapsedSeconds)} elapsed`,
+		`${progress.percent}%`,
+		`${formatClock(progress.totalSeconds)} total`
+	])}` }],
+	[],
+	...createTimeline(state, settings, progress.ratio),
+	[],
+	[{ text: `${INDENT}${KEY_GUIDES[keyGuideKind(state)]}` }]
+];
+const createCompactFrame = ({ progress, settings, state, width }) => [
+	[phaseSegment(state), { text: `${spaces(MIN_GAP)}${state.cycle}/${settings.loopCount}` }],
+	[{ text: `${formatClock(progress.remainingSeconds)} left · ${progress.percent}%` }],
+	createLineBar(progress.percent, Math.min(BAR_WIDTH, width), state.phase),
+	[{ text: COMPACT_KEY_GUIDES[keyGuideKind(state)] }]
+];
+const createMinimalFrame = ({ progress, settings, state }) => [[{
+	text: minimalPhaseLabel(state),
+	tone: state.phase
+}, { text: ` ${formatClock(progress.remainingSeconds)} ${state.cycle}/${settings.loopCount}` }]];
+const createTimerFrame = ({ state, now, settings, columns }) => {
+	const width = Math.max(MIN_WIDTH, (columns || FALLBACK_COLUMNS) - RIGHT_MARGIN), layout = {
+		progress: progressFor(state, now, settings),
+		settings,
+		state,
+		width
+	}, full = createFullFrame(layout);
+	if (full.every((line) => lineWidth(line) <= width)) return [...full];
+	if (width >= COMPACT_MIN_WIDTH) return createCompactFrame(layout).map((line) => truncateLine(line, width));
+	return createMinimalFrame(layout).map((line) => truncateLine(line, width));
+};
+//#endregion
+//#region src/terminal/timer-keys.ts
+/** Ctrlなしで受け付けるキー名と操作の対応です。Shift（大文字）は区別しません。 */
+const PLAIN_KEYS = /* @__PURE__ */ new Map([
+	["q", "quit"],
+	["s", "skip"],
+	["space", "toggle-pause"]
+]);
+const timerKeyFrom = (value) => {
+	const key = keyFrom(value);
+	if (typeof value === "object" && value !== null && Reflect.get(value, "meta") === true) return;
+	if (key.ctrl) {
+		if (key.name === "c") return "interrupt";
+		return;
+	}
+	return PLAIN_KEYS.get(key.name);
+};
+const watchTimerKeys = ({ input = process$1.stdin, onKey }) => {
+	emitKeypressEvents(input);
+	const inputWasFlowing = input.readableFlowing === true, rawModeWasEnabled = input.isRaw === true, supportsRawMode = input.isTTY === true && typeof input.setRawMode === "function", handleKeypress = (_sequence, value) => {
+		const key = timerKeyFrom(value);
+		if (key !== void 0) onKey(key);
+	};
+	let stopped = false;
+	input.on("keypress", handleKeypress);
+	if (supportsRawMode && !rawModeWasEnabled) input.setRawMode?.(true);
+	if (!inputWasFlowing) input.resume();
+	return () => {
+		if (stopped) return;
+		stopped = true;
+		input.removeListener("keypress", handleKeypress);
+		if (supportsRawMode && !rawModeWasEnabled) input.setRawMode?.(false);
+		if (!inputWasFlowing) input.pause();
+	};
+};
+//#endregion
+//#region src/cli/progress-view.ts
+const PHASE_ICONS = {
+	break: "☕",
+	work: "🍅"
+};
+const PHASE_NAMES = {
+	break: "Break",
+	work: "Work"
+};
+const createPhaseStartedOutput = (phase, durationMs) => {
+	const durationMinutes = durationMs / MILLISECONDS_PER_MINUTE;
+	return `${PHASE_ICONS[phase]} ${PHASE_NAMES[phase]} started (${durationMinutes} min)\n`;
+};
+const createPhaseCompletedOutput = (phase) => `✅ ${PHASE_NAMES[phase]} complete.\n`;
+const createPhaseSkippedOutput = (phase) => `⏩ ${PHASE_NAMES[phase]} skipped.\n`;
+const applyTimerKey = (key, controls, onStop) => {
+	if (key === "toggle-pause") {
+		controls.togglePause();
+		return;
+	}
+	if (key === "skip") {
+		controls.skip();
+		return;
+	}
+	if (!controls.settle()) onStop(key);
+};
+const isInteractiveTerminal = (stdin, stdout) => stdin.isTTY === true && stdout.isTTY === true && process$1.env.TERM !== "dumb";
+const createLineView = (write) => ({
+	finish: () => {},
+	onPhaseCompleted: (phase) => {
+		write(createPhaseCompletedOutput(phase));
+	},
+	onPhaseStarted: (phase, durationMs) => {
+		write(createPhaseStartedOutput(phase, durationMs));
+	}
+});
+const createInteractiveView = ({ color, onStop, processEvents, settings, stdin, terminal, write }) => {
+	const renderer = createInlineRenderer(write), guard = createTerminalGuard({
+		onSignal: onStop,
+		processEvents,
+		terminal,
+		write
+	});
+	let controls, latest;
+	const draw = () => {
+		if (latest === void 0) return;
+		guard.hideCursor();
+		renderer.render(createTimerFrame({
+			columns: terminal.columns,
+			now: latest.now,
+			settings,
+			state: latest.state
+		}).map((line) => stringifyFrameLine(line, color)));
+	}, handleResize = () => {
+		renderer.release();
+		draw();
+	}, stopWatchingKeys = watchTimerKeys({
+		input: stdin,
+		onKey: (key) => {
+			if (controls !== void 0) applyTimerKey(key, controls, onStop);
+		}
+	});
+	terminal.on("resize", handleResize);
+	return {
+		bindControls: (bound) => {
+			controls = bound;
+		},
+		finish: () => {
+			stopWatchingKeys();
+			terminal.off?.("resize", handleResize);
+			guard.release();
+		},
+		onPhaseCompleted: (phase) => {
+			renderer.log(createPhaseCompletedOutput(phase));
+		},
+		onPhaseSkipped: (phase) => {
+			renderer.log(createPhaseSkippedOutput(phase));
+		},
+		onPhaseStarted: () => {},
+		onTick: (state, now) => {
+			latest = {
+				now,
+				state
+			};
+			draw();
+		}
+	};
+};
+const createProgressView = ({ color = isColorEnabled(process$1.env), interactive, onStop, processEvents = process$1, settings, stdin = process$1.stdin, stdout = process$1.stdout, write }) => {
+	if (!(interactive ?? isInteractiveTerminal(stdin, stdout))) return createLineView(write);
+	return createInteractiveView({
+		color,
+		onStop,
+		processEvents,
+		settings,
+		stdin,
+		terminal: stdout,
+		write
+	});
+};
+//#endregion
+//#region src/cli/parse-arguments.ts
+const ARGUMENT_INDEX_INCREMENT = 1;
+const ARGUMENTS_START_INDEX = 0;
+const DURATION_PATTERN = /^[1-9][0-9]{0,3}$/u;
+const EQUALS_SIGN = "=";
+const EQUALS_SIGN_NOT_FOUND = -1;
+const HELP_OPTIONS = ["--help", "-h"];
+const MAXIMUM_DURATION_MINUTES = 1440;
+const NEXT_ARGUMENT_OFFSET = 1;
+const LOOP_PATTERN = /^[1-9][0-9]*$/u;
+const isNumericOption = (value) => value === "--break" || value === "--work" || value === "--loop";
+const isHelpOption = (value) => HELP_OPTIONS.some((option) => option === value);
+const createValueError = (option) => {
+	let maximum = MAXIMUM_DURATION_MINUTES;
+	if (option === "--loop") maximum = Number.MAX_SAFE_INTEGER;
+	return {
+		kind: "error",
+		message: `Error: ${option} requires an integer from 1 to ${maximum}.\n`
+	};
+};
+const createDuplicateError = (option) => ({
+	kind: "error",
+	message: `Error: ${option} may only be specified once.\n`
+});
+const parseNumericValue = (option, value) => {
+	let pattern = DURATION_PATTERN, maximum = MAXIMUM_DURATION_MINUTES;
+	if (option === "--loop") {
+		pattern = LOOP_PATTERN;
+		maximum = Number.MAX_SAFE_INTEGER;
+	}
+	if (typeof value !== "string" || !pattern.test(value)) return;
+	const numericValue = Number(value);
+	if (!Number.isSafeInteger(numericValue) || numericValue > maximum) return;
+	return numericValue;
+};
+const parseNumericArgument = (argument, nextArgument) => {
+	const equalsSignIndex = argument.indexOf(EQUALS_SIGN);
+	if (equalsSignIndex === EQUALS_SIGN_NOT_FOUND) return {
+		consumesNextArgument: true,
+		optionName: argument,
+		value: nextArgument
+	};
+	return {
+		consumesNextArgument: false,
+		optionName: argument.slice(ARGUMENTS_START_INDEX, equalsSignIndex),
+		value: argument.slice(equalsSignIndex + NEXT_ARGUMENT_OFFSET)
+	};
+};
+const parseCliArguments = (arguments_) => {
+	if (arguments_.some((argument) => isHelpOption(argument))) return { kind: "help" };
+	const specifiedOptions = /* @__PURE__ */ new Set();
+	let breakDurationMinutes = 5, loopCount = 3, workDurationMinutes = 15;
+	for (let argumentIndex = ARGUMENTS_START_INDEX; argumentIndex < arguments_.length; argumentIndex += ARGUMENT_INDEX_INCREMENT) {
+		const argument = arguments_[argumentIndex] ?? "", { consumesNextArgument, optionName, value } = parseNumericArgument(argument, arguments_[argumentIndex + NEXT_ARGUMENT_OFFSET]);
+		if (!isNumericOption(optionName)) return {
+			kind: "error",
+			message: `Error: Unknown option: ${escapeDiagnostic(argument)}\n`
+		};
+		if (specifiedOptions.has(optionName)) return createDuplicateError(optionName);
+		const numericValue = parseNumericValue(optionName, value);
+		if (typeof numericValue !== "number") return createValueError(optionName);
+		specifiedOptions.add(optionName);
+		if (consumesNextArgument) argumentIndex += NEXT_ARGUMENT_OFFSET;
+		if (optionName === "--work") workDurationMinutes = numericValue;
+		else if (optionName === "--loop") loopCount = numericValue;
+		else breakDurationMinutes = numericValue;
+	}
+	return {
+		breakDurationMinutes,
+		kind: "run",
+		loopCount,
+		workDurationMinutes
+	};
+};
+//#endregion
+//#region src/cli/run.ts
+const CLI_ARGUMENTS_START_INDEX = 2;
+const FAILURE_EXIT_CODE$1 = 1;
+const SUCCESS_EXIT_CODE = 0;
+const STOP_EXIT_CODES = {
+	SIGHUP: 129,
+	SIGINT: 130,
+	SIGTERM: 143,
+	interrupt: 130,
+	quit: SUCCESS_EXIT_CODE
+};
+const USAGE_ERROR_EXIT_CODE = 2;
+const SHUTDOWN_DEADLINE_MS = 2e3;
+const COMPLETION_SHUTDOWN_DEADLINE_MS = 5e3;
+const exitCodeForOutputFailure = (error) => {
+	if (isBrokenPipe(error)) return SUCCESS_EXIT_CODE;
+	return FAILURE_EXIT_CODE$1;
+};
+const emitDiagnostic = (writeError, message) => {
+	try {
+		writeError(message);
+	} catch {}
+};
+const scheduleProcessExit = (exitCode, delayMs) => {
+	setTimeout(() => {
+		process$1.exit(exitCode);
+	}, delayMs).unref();
+};
+const setProcessExitCode = (exitCode) => {
+	process$1.exitCode = exitCode;
+};
+const runHelp = (stdout, setExitCode) => {
+	let exitCode = SUCCESS_EXIT_CODE;
+	createStandardOutput((error) => {
+		exitCode = exitCodeForOutputFailure(error);
+		setExitCode(exitCode);
+	}, stdout)(createCliOutput({
+		optionName: "--help",
+		options: OPTIONS
+	}));
+	return exitCode;
+};
+const runCli = async ({ arguments_ = process$1.argv.slice(CLI_ARGUMENTS_START_INDEX), confirmStart = confirmWorkStart, createSoundPlayer, now, scheduleExit = scheduleProcessExit, setExitCode = setProcessExitCode, sleep, stdin, stdout, interactive, processEvents, color, writeError = createDiagnosticWriter() }) => {
+	const parsedArguments = parseCliArguments(arguments_);
+	if (parsedArguments.kind === "error") {
+		emitDiagnostic(writeError, parsedArguments.message);
+		return USAGE_ERROR_EXIT_CODE;
+	}
+	if (parsedArguments.kind === "help") return runHelp(stdout, setExitCode);
+	const controller = new AbortController();
+	let shutdownExitCode, soundPlayer, view;
+	/**
+	* 終了処理を1回だけ開始します。
+	*
+	* 最初の呼び出しで終了コードを固定し、確認待ちとタイマーを中断して、
+	* 再生中の子プロセスへ終了要求を送ります。親プロセスは期限に達すると
+	* 強制終了するため、終了しない子プロセスがあっても残り続けません。
+	*/
+	const requestShutdown = (exitCode, complete) => {
+		if (shutdownExitCode !== void 0) return shutdownExitCode;
+		shutdownExitCode = exitCode;
+		setExitCode(exitCode);
+		controller.abort();
+		soundPlayer?.shutdown({ complete });
+		if (complete) scheduleExit(exitCode, COMPLETION_SHUTDOWN_DEADLINE_MS);
+		else scheduleExit(exitCode, SHUTDOWN_DEADLINE_MS);
+		return exitCode;
+	}, writeOutput = createStandardOutput((error) => {
+		requestShutdown(exitCodeForOutputFailure(error), false);
+	}, stdout);
+	try {
+		soundPlayer = createSoundPlayer();
+		writeOutput(createCliOutput({
+			columns: (stdout ?? process$1.stdout).columns,
+			optionName: "",
+			options: OPTIONS
+		}));
+		if (shutdownExitCode !== void 0) return shutdownExitCode;
+		const confirmed = await confirmStart({
+			signal: controller.signal,
+			write: writeOutput
+		});
+		if (shutdownExitCode !== void 0) return shutdownExitCode;
+		if (!confirmed) {
+			writeOutput("⏹️ Work was not started.\n");
+			return requestShutdown(SUCCESS_EXIT_CODE, false);
+		}
+		const player = soundPlayer, settings = {
+			breakDurationMs: parsedArguments.breakDurationMinutes * MILLISECONDS_PER_MINUTE,
+			loopCount: parsedArguments.loopCount,
+			workDurationMs: parsedArguments.workDurationMinutes * MILLISECONDS_PER_MINUTE
+		};
+		view = createProgressView({
+			color,
+			interactive,
+			onStop: (reason) => {
+				requestShutdown(STOP_EXIT_CODES[reason], false);
+			},
+			processEvents,
+			settings,
+			stdin,
+			stdout,
+			write: writeOutput
+		});
+		const timerView = view, result = await runPomodoroTimer({
+			...settings,
+			bindControls: timerView.bindControls,
+			now,
+			onPhaseCompleted: (phase, { final }) => {
+				timerView.onPhaseCompleted(phase);
+				player.play(phase, { completionNotice: final });
+			},
+			onPhaseSkipped: timerView.onPhaseSkipped,
+			onPhaseStarted: timerView.onPhaseStarted,
+			onTick: timerView.onTick,
+			signal: controller.signal,
+			sleep
+		});
+		view.finish();
+		if (!result.completed) return shutdownExitCode ?? FAILURE_EXIT_CODE$1;
+		writeOutput("🎉 Pomodoro complete.\n");
+		return requestShutdown(SUCCESS_EXIT_CODE, true);
+	} catch (error) {
+		view?.finish();
+		requestShutdown(FAILURE_EXIT_CODE$1, false);
+		throw error;
+	}
+};
+//#endregion
+//#region src/cli.ts
+const FAILURE_EXIT_CODE = 1;
+const SOUND_DIRECTORY = new URL("../assets/", import.meta.url);
+const UNCONVERTIBLE_VALUE_MESSAGE = "Unable to convert the thrown value to a string";
+const stringifyError = (error) => {
+	try {
+		return String(error);
+	} catch {
+		return UNCONVERTIBLE_VALUE_MESSAGE;
+	}
+};
+const handleFailure = (error) => {
+	process$1.exitCode = FAILURE_EXIT_CODE;
+	createDiagnosticWriter()(`Error: ${escapeDiagnostic(stringifyError(error))}\n`);
+};
+try {
+	process$1.exitCode = await runCli({ createSoundPlayer: () => createSoundPlayer({
+		commands: resolvePlayerCommands(),
+		soundDirectory: SOUND_DIRECTORY
+	}) });
+} catch (error) {
+	handleFailure(error);
+}
+//#endregion
+export {};