xgen-dex-cli 1.5.0 → 1.7.0

package/dist/chunks/{tui-KJAW7DSU.js → tui-QF5OJEFW.js}

@@ -1,11 +1,12 @@
 import {
   DexError,
+  dataDirectory,
   publicError
 } from "./chunk-ULMEXJOR.js";
 
 // src/tui/index.tsx
 import { render } from "ink";
-import { stdout } from "node:process";
+import { stdin, stdout } from "node:process";
 
 // src/tui/app.tsx
 import { useCallback, useEffect as useEffect8, useState as useState11 } from "react";
@@ -287,7 +288,7 @@ import { Box as Box2, Text as Text2 } from "ink";
 
 // src/tui/ime-text-input.tsx
 import { useEffect as useEffect2, useRef as useRef2, useState as useState2 } from "react";
-import { Box, Text, useCursor, useInput } from "ink";
+import { Box, Text, useCursor, useInput, useStdin } from "ink";
 import stringWidth2 from "string-width";
 
 // src/tui/terminal-input.ts
@@ -304,6 +305,257 @@ function classifyInput(input, pasting = false) {
   return text ? { kind: "text", text } : { kind: "ignore" };
 }
 
+// src/tui/hangul.ts
+var CHO = "\u3131\u3132\u3134\u3137\u3138\u3139\u3141\u3142\u3143\u3145\u3146\u3147\u3148\u3149\u314A\u314B\u314C\u314D\u314E";
+var JUNG = "\u314F\u3150\u3151\u3152\u3153\u3154\u3155\u3156\u3157\u3158\u3159\u315A\u315B\u315C\u315D\u315E\u315F\u3160\u3161\u3162\u3163";
+var JONG = " \u3131\u3132\u3133\u3134\u3135\u3136\u3137\u3139\u313A\u313B\u313C\u313D\u313E\u313F\u3140\u3141\u3142\u3144\u3145\u3146\u3147\u3148\u314A\u314B\u314C\u314D\u314E";
+var SYLLABLE_BASE = 44032;
+var KEYS = {
+  r: "\u3131",
+  R: "\u3132",
+  s: "\u3134",
+  e: "\u3137",
+  E: "\u3138",
+  f: "\u3139",
+  a: "\u3141",
+  q: "\u3142",
+  Q: "\u3143",
+  t: "\u3145",
+  T: "\u3146",
+  d: "\u3147",
+  w: "\u3148",
+  W: "\u3149",
+  c: "\u314A",
+  z: "\u314B",
+  x: "\u314C",
+  v: "\u314D",
+  g: "\u314E",
+  k: "\u314F",
+  o: "\u3150",
+  i: "\u3151",
+  O: "\u3152",
+  j: "\u3153",
+  p: "\u3154",
+  u: "\u3155",
+  P: "\u3156",
+  h: "\u3157",
+  y: "\u315B",
+  n: "\u315C",
+  b: "\u3160",
+  m: "\u3161",
+  l: "\u3163"
+};
+var VOWEL_PAIRS = {
+  "\u3157\u314F": "\u3158",
+  "\u3157\u3150": "\u3159",
+  "\u3157\u3163": "\u315A",
+  "\u315C\u3153": "\u315D",
+  "\u315C\u3154": "\u315E",
+  "\u315C\u3163": "\u315F",
+  "\u3161\u3163": "\u3162"
+};
+var FINAL_PAIRS = {
+  "\u3131\u3145": "\u3133",
+  "\u3134\u3148": "\u3135",
+  "\u3134\u314E": "\u3136",
+  "\u3139\u3131": "\u313A",
+  "\u3139\u3141": "\u313B",
+  "\u3139\u3142": "\u313C",
+  "\u3139\u3145": "\u313D",
+  "\u3139\u314C": "\u313E",
+  "\u3139\u314D": "\u313F",
+  "\u3139\u314E": "\u3140",
+  "\u3142\u3145": "\u3144"
+};
+var SPLIT = Object.fromEntries(
+  [...Object.entries(VOWEL_PAIRS), ...Object.entries(FINAL_PAIRS)].map(([pair, joined]) => [
+    joined,
+    [pair[0], pair[1]]
+  ])
+);
+var EMPTY = {};
+var SHIFTED_KEYS = /* @__PURE__ */ new Set(["r", "e", "q", "t", "w", "o", "p"]);
+function jamoOf(key, capsLock = false) {
+  const effective = capsLock ? swapCase(key) : key;
+  if (KEYS[effective]) return KEYS[effective];
+  const lower = effective.toLowerCase();
+  return lower === effective ? void 0 : KEYS[lower];
+}
+function swapCase(key) {
+  const lower = key.toLowerCase();
+  return key === lower ? key.toUpperCase() : lower;
+}
+function detectCapsLock(current, key) {
+  const lower = key.toLowerCase();
+  const upper = key.toUpperCase();
+  if (lower === upper) return current;
+  if (!KEYS[lower]) return current;
+  if (SHIFTED_KEYS.has(lower)) return current;
+  return key === upper;
+}
+function isVowel(jamo) {
+  return JUNG.includes(jamo) || jamo === "\u3157" || jamo === "\u315C" || jamo === "\u3161";
+}
+function canBeFinal(jamo) {
+  return JONG.indexOf(jamo) > 0;
+}
+function display(state) {
+  const { cho, jung, jong } = state;
+  if (cho && jung) {
+    const l = CHO.indexOf(cho);
+    const v = JUNG.indexOf(jung);
+    const t = jong ? JONG.indexOf(jong) : 0;
+    if (l >= 0 && v >= 0 && t >= 0) {
+      return String.fromCharCode(SYLLABLE_BASE + (l * 21 + v) * 28 + t);
+    }
+  }
+  return cho ?? jung ?? "";
+}
+function feed(state, jamo) {
+  const { cho, jung, jong } = state;
+  if (isVowel(jamo)) {
+    if (cho && jung && jong) {
+      const parts = SPLIT[jong];
+      const moved = parts ? parts[1] : jong;
+      const kept = parts ? parts[0] : void 0;
+      return {
+        commit: display({ cho, jung, jong: kept }),
+        state: { cho: moved, jung: jamo }
+      };
+    }
+    if (cho && jung) {
+      const merged = VOWEL_PAIRS[jung + jamo];
+      if (merged) return { commit: "", state: { cho, jung: merged } };
+      return { commit: display(state), state: { jung: jamo } };
+    }
+    if (cho) return { commit: "", state: { cho, jung: jamo } };
+    if (jung) {
+      const merged = VOWEL_PAIRS[jung + jamo];
+      if (merged) return { commit: "", state: { jung: merged } };
+      return { commit: jung, state: { jung: jamo } };
+    }
+    return { commit: "", state: { jung: jamo } };
+  }
+  if (cho && jung) {
+    if (!jong) {
+      if (canBeFinal(jamo)) return { commit: "", state: { cho, jung, jong: jamo } };
+      return { commit: display(state), state: { cho: jamo } };
+    }
+    const merged = FINAL_PAIRS[jong + jamo];
+    if (merged) return { commit: "", state: { cho, jung, jong: merged } };
+    return { commit: display(state), state: { cho: jamo } };
+  }
+  if (cho) {
+    return { commit: cho, state: { cho: jamo } };
+  }
+  if (jung) return { commit: jung, state: { cho: jamo } };
+  return { commit: "", state: { cho: jamo } };
+}
+function back(state) {
+  const { cho, jung, jong } = state;
+  if (jong) {
+    const parts = SPLIT[jong];
+    return { state: { cho, jung, jong: parts ? parts[0] : void 0 }, handled: true };
+  }
+  if (jung) {
+    const parts = SPLIT[jung];
+    return { state: { cho, jung: parts ? parts[0] : void 0 }, handled: true };
+  }
+  if (cho) return { state: EMPTY, handled: true };
+  return { state: EMPTY, handled: false };
+}
+var IDLE = { state: EMPTY, keys: [], capsLock: false };
+function typeKey(session, key) {
+  const caps = detectCapsLock(session.capsLock, key);
+  let { state, keys } = session;
+  let commit = "";
+  if (caps !== session.capsLock && keys.length > 0) {
+    let rebuilt = EMPTY;
+    for (const previous of keys) {
+      const jamo2 = jamoOf(previous, caps);
+      if (!jamo2) continue;
+      const step = feed(rebuilt, jamo2);
+      commit += step.commit;
+      rebuilt = step.state;
+    }
+    state = rebuilt;
+  }
+  const jamo = jamoOf(key, caps);
+  if (!jamo) {
+    commit += display(state) + key;
+    return { session: { state: EMPTY, keys: [], capsLock: caps }, commit, composing: "" };
+  }
+  const result = feed(state, jamo);
+  commit += result.commit;
+  keys = result.commit ? [key] : [...keys, key];
+  return {
+    session: { state: result.state, keys, capsLock: caps },
+    commit,
+    composing: display(result.state)
+  };
+}
+function backspace(session) {
+  const stepped = back(session.state);
+  if (!stepped.handled) return { session, composing: "", handled: false };
+  return {
+    session: { ...session, state: stepped.state, keys: session.keys.slice(0, -1) },
+    composing: display(stepped.state),
+    handled: true
+  };
+}
+
+// src/tui/kitty.ts
+var ESC = "\x1B";
+var QUERY = `${ESC}[?u`;
+var KEY_CODES = {
+  57358: "capslock",
+  57449: "rightalt"
+};
+var CAPS_LOCK_BIT = 64;
+function parseKeyEvents(chunk) {
+  const events = [];
+  const pattern = /\u001B\[(\d+)(?::\d+)*(?:;(\d+)(?::(\d+))?)?(?:;[\d:]*)?u/g;
+  for (const match of chunk.matchAll(pattern)) {
+    const code = Number(match[1]);
+    const modifiers = match[2] ? Number(match[2]) - 1 : 0;
+    events.push({
+      name: KEY_CODES[code],
+      // eslint-disable-next-line no-bitwise
+      capsLock: (modifiers & CAPS_LOCK_BIT) !== 0,
+      eventType: match[3] ? Number(match[3]) : 1
+    });
+  }
+  return events;
+}
+async function supportsKittyKeyboard(streams, timeoutMs = 200) {
+  if (process.env.DEX_NO_KITTY === "1") return false;
+  if (!streams.stdout.isTTY || !streams.isTTY) return false;
+  const wasRaw = streams.stdin.isRaw === true;
+  const wasPaused = !wasRaw;
+  streams.stdin.setRawMode?.(true);
+  streams.stdin.resume?.();
+  return new Promise((resolve) => {
+    let settled = false;
+    let seen = "";
+    const finish = (supported) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      streams.stdin.removeListener("data", onData);
+      if (!wasRaw) streams.stdin.setRawMode?.(false);
+      if (wasPaused) streams.stdin.pause?.();
+      resolve(supported);
+    };
+    const onData = (data) => {
+      seen += typeof data === "string" ? data : data.toString("utf8");
+      if (/\u001B\[\?\d*u/.test(seen)) finish(true);
+    };
+    const timer = setTimeout(() => finish(false), timeoutMs);
+    streams.stdin.on("data", onData);
+    streams.stdout.write(QUERY);
+  });
+}
+
 // src/tui/ime-text-input.tsx
 import { jsx, jsxs } from "react/jsx-runtime";
 var segmenter = new Intl.Segmenter("ko", { granularity: "grapheme" });
@@ -349,6 +601,7 @@ function ImeTextInput(props) {
   const valueRef = useRef2(props.value);
   const cursorRef = useRef2(initialSegments.length);
   const pastingRef = useRef2(false);
+  const typingRef = useRef2(IDLE);
   const moveCursor = (next, length) => {
     const resolved = clamp(next, 0, length);
     cursorRef.current = resolved;
@@ -360,6 +613,27 @@ function ImeTextInput(props) {
     moveCursor(nextCursor, segments.length);
     props.onChange(nextValue);
   };
+  const { stdin: stdin2, isRawModeSupported } = useStdin();
+  const onModeKeyRef = useRef2(void 0);
+  onModeKeyRef.current = () => props.onHangulModeChange?.(!props.hangulMode);
+  useEffect2(() => {
+    if (!props.focus || !isRawModeSupported) return void 0;
+    const onData = (data) => {
+      const chunk = typeof data === "string" ? data : data.toString("utf8");
+      for (const event of parseKeyEvents(chunk)) {
+        typingRef.current = { ...typingRef.current, capsLock: event.capsLock };
+        if (event.eventType !== 1) continue;
+        if (event.name === "rightalt" || event.name === "capslock") onModeKeyRef.current?.();
+      }
+    };
+    stdin2?.on("data", onData);
+    return () => void stdin2?.off("data", onData);
+  }, [props.focus, isRawModeSupported, stdin2]);
+  useEffect2(() => {
+    if (!props.focus || !props.hangulMode) {
+      typingRef.current = { ...IDLE, capsLock: typingRef.current.capsLock };
+    }
+  }, [props.focus, props.hangulMode]);
   useEffect2(() => {
     if (props.value === valueRef.current) return;
     const previousLength = graphemes(valueRef.current).length;
@@ -368,12 +642,23 @@ function ImeTextInput(props) {
     valueRef.current = props.value;
     moveCursor(wasAtEnd ? nextLength : cursorRef.current, nextLength);
   }, [props.value]);
+  const applyComposition = (segments, cursor2, previous, commit, next) => {
+    const removed = previous ? 1 : 0;
+    const inserted = graphemes(commit + next);
+    segments.splice(cursor2 - removed, removed, ...inserted);
+    updateValue(segments, cursor2 - removed + inserted.length);
+  };
   useInput(
     (input, key) => {
       const current = graphemes(valueRef.current);
       const currentCursor = clamp(cursorRef.current, 0, current.length);
       const event = classifyInput(input, pastingRef.current);
+      const shown = display(typingRef.current.state);
+      const settle = () => {
+        typingRef.current = { ...IDLE, capsLock: typingRef.current.capsLock };
+      };
       if (event.kind === "paste-start") {
+        settle();
         pastingRef.current = true;
         return;
       }
@@ -389,36 +674,70 @@ function ImeTextInput(props) {
         }
         return;
       }
+      if (key.ctrl && (input === "`" || input === "l") || key.meta && input === " ") {
+        settle();
+        props.onHangulModeChange?.(!props.hangulMode);
+        return;
+      }
       if (key.return) {
+        settle();
         props.onSubmit?.(valueRef.current);
         return;
       }
       if (key.leftArrow) {
+        settle();
         moveCursor(currentCursor - 1, current.length);
         return;
       }
       if (key.rightArrow) {
+        settle();
         moveCursor(currentCursor + 1, current.length);
         return;
       }
       if (key.home) {
+        settle();
         moveCursor(0, current.length);
         return;
       }
       if (key.end) {
+        settle();
         moveCursor(current.length, current.length);
         return;
       }
       if (key.backspace || key.delete) {
+        const stepped = backspace(typingRef.current);
+        if (stepped.handled) {
+          typingRef.current = stepped.session;
+          applyComposition(current, currentCursor, shown, "", stepped.composing);
+          return;
+        }
         if (currentCursor === 0) return;
         current.splice(currentCursor - 1, 1);
         updateValue(current, currentCursor - 1);
         return;
       }
       if (key.ctrl || key.meta || key.tab || key.escape || key.upArrow || key.downArrow || key.pageUp || key.pageDown) {
+        settle();
         return;
       }
       if (event.kind !== "text") return;
+      if (props.hangulMode) {
+        let session = typingRef.current;
+        let previous = shown;
+        let segments = current;
+        let cursor2 = currentCursor;
+        for (const character of event.text) {
+          const result = typeKey(session, character);
+          session = result.session;
+          applyComposition(segments, cursor2, previous, result.commit, result.composing);
+          segments = graphemes(valueRef.current);
+          cursor2 = cursorRef.current;
+          previous = result.composing;
+        }
+        typingRef.current = session;
+        return;
+      }
+      settle();
       const inserted = graphemes(event.text);
       current.splice(currentCursor, 0, ...inserted);
       updateValue(current, currentCursor + inserted.length);
@@ -451,8 +770,16 @@ function Header(props) {
     ] }) : /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "\uC124\uC815 \uD544\uC694" })
   ] });
 }
-function Footer({ text }) {
-  return /* @__PURE__ */ jsx2(Box2, { paddingX: 1, children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: text }) });
+function Footer({ text, mode }) {
+  return /* @__PURE__ */ jsxs2(Box2, { paddingX: 1, children: [
+    mode ? /* @__PURE__ */ jsxs2(Text2, { bold: true, color: mode === "\uD55C" ? "yellow" : "gray", children: [
+      "[",
+      mode,
+      "]",
+      " "
+    ] }) : null,
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, wrap: "truncate-end", children: text })
+  ] });
 }
 function Loading({ label = "\uBD88\uB7EC\uC624\uB294 \uC911..." }) {
   return /* @__PURE__ */ jsx2(Box2, { padding: 1, children: /* @__PURE__ */ jsxs2(Text2, { color: "cyan", children: [
@@ -736,7 +1063,8 @@ function ChatPane(props) {
 }
 function Composer(props) {
   return /* @__PURE__ */ jsxs6(Box6, { borderStyle: "round", borderColor: props.focused ? "cyan" : "gray", paddingX: 1, children: [
-    /* @__PURE__ */ jsx6(Text6, { color: "cyan", children: "\u203A " }),
+    /* @__PURE__ */ jsx6(Text6, { color: props.hangulMode ? "yellow" : void 0, dimColor: !props.hangulMode, children: props.hangulMode ? "\uD55C" : "EN" }),
+    /* @__PURE__ */ jsx6(Text6, { color: "cyan", children: " \u203A " }),
     props.disabled ? /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "\uC751\uB2F5\uC744 \uAE30\uB2E4\uB9AC\uB294 \uC911..." }) : /* @__PURE__ */ jsx6(
       ImeTextInput,
       {
@@ -744,7 +1072,9 @@ function Composer(props) {
         onChange: props.onChange,
         onSubmit: props.onSubmit,
         focus: props.focused,
-        placeholder: "\uBA54\uC2DC\uC9C0\uB97C \uC785\uB825\uD558\uC138\uC694"
+        placeholder: "\uBA54\uC2DC\uC9C0\uB97C \uC785\uB825\uD558\uC138\uC694",
+        hangulMode: props.hangulMode,
+        onHangulModeChange: props.onHangulModeChange
       }
     )
   ] });
@@ -765,6 +1095,11 @@ function Dashboard(props) {
   const [history, setHistory] = useState7(false);
   const [start, setStart] = useState7();
   const [scrollUp, setScrollUp] = useState7(0);
+  const [hangulMode, setHangulMode] = useState7(props.preferences?.hangulMode ?? false);
+  const changeHangulMode = (enabled) => {
+    setHangulMode(enabled);
+    props.preferences?.onHangulModeChange?.(enabled);
+  };
   const viewport = useRef3({ lineCount: 0, height: 0 });
   const [starting, setStarting] = useState7(false);
   const controller = useRef3(null);
@@ -966,7 +1301,9 @@ function Dashboard(props) {
           onChange: setInput,
           onSubmit: (value) => void send(value),
           focused: focus === "composer",
-          disabled: chat.running || !selected
+          disabled: chat.running || !selected,
+          hangulMode,
+          onHangulModeChange: changeHangulMode
         }
       )
     ] });
@@ -985,7 +1322,13 @@ function Dashboard(props) {
       }
     ),
     body,
-    /* @__PURE__ */ jsx6(Footer, { text: "Tab \uD328\uB110 \xB7 PgUp/PgDn \uC2A4\uD06C\uB864 \xB7 Ctrl+K \uBA85\uB839 \xB7 Ctrl+H \uAE30\uB85D \xB7 Ctrl+P \uD504\uB85C\uD544 \xB7 Esc \uCDE8\uC18C \xB7 Ctrl+Q \uC885\uB8CC" })
+    /* @__PURE__ */ jsx6(
+      Footer,
+      {
+        mode: hangulMode ? "\uD55C" : "EN",
+        text: "Ctrl+Space \uD55C/\uC601 \xB7 Tab \uD328\uB110 \xB7 PgUp/PgDn \uC2A4\uD06C\uB864 \xB7 Ctrl+K \uBA85\uB839 \xB7 Ctrl+H \uAE30\uB85D \xB7 Ctrl+P \uD504\uB85C\uD544 \xB7 Esc \uCDE8\uC18C \xB7 Ctrl+Q \uC885\uB8CC"
+      }
+    )
   ] });
 }
 
@@ -1193,7 +1536,10 @@ function ServerScreen(props) {
 
 // src/tui/app.tsx
 import { jsx as jsx10, jsxs as jsxs10 } from "react/jsx-runtime";
-function App({ engine }) {
+function App({
+  engine,
+  preferences
+}) {
   const { exit } = useApp2();
   const [route, setRoute] = useState11("boot");
   const [session, setSession] = useState11();
@@ -1385,6 +1731,7 @@ function App({ engine }) {
     return /* @__PURE__ */ jsx10(
       Dashboard,
       {
+        preferences,
         engine,
         session,
         onProfiles: () => void openProfiles(),
@@ -1408,25 +1755,26 @@ function RetryInput({ onRetry }) {
 }
 
 // src/tui/screen.ts
-var ESC = "\x1B";
-var ENTER_ALT_SCREEN = `${ESC}[?1049h`;
-var LEAVE_ALT_SCREEN = `${ESC}[?1049l`;
-var SHOW_CURSOR = `${ESC}[?25h`;
+var ESC2 = "\x1B";
+var ENTER_ALT_SCREEN = `${ESC2}[?1049h`;
+var LEAVE_ALT_SCREEN = `${ESC2}[?1049l`;
+var SHOW_CURSOR = `${ESC2}[?25h`;
 var DISABLE_REPORTS = [
-  `${ESC}[?1004l`,
+  `${ESC2}[?1004l`,
   // 포커스 들어옴/나감
-  `${ESC}[?1000l`,
+  `${ESC2}[?1000l`,
   // 마우스 클릭
-  `${ESC}[?1002l`,
+  `${ESC2}[?1002l`,
   // 마우스 드래그
-  `${ESC}[?1003l`,
+  `${ESC2}[?1003l`,
   // 마우스 이동 전부
-  `${ESC}[?1006l`
+  `${ESC2}[?1006l`
   // SGR 확장 좌표
 ].join("");
-var ENABLE_BRACKETED_PASTE = `${ESC}[?2004h`;
-var DISABLE_BRACKETED_PASTE = `${ESC}[?2004l`;
-function createScreenGuard(stream) {
+var ENABLE_BRACKETED_PASTE = `${ESC2}[?2004h`;
+var DISABLE_BRACKETED_PASTE = `${ESC2}[?2004l`;
+var POP_KITTY_KEYBOARD = `${ESC2}[<u`;
+function createScreenGuard(stream, options = {}) {
   const alt = Boolean(stream.isTTY);
   let entered = false;
   let restored = false;
@@ -1439,16 +1787,49 @@ function createScreenGuard(stream) {
     restore() {
       if (restored) return;
       restored = true;
-      if (entered) stream.write(DISABLE_BRACKETED_PASTE + LEAVE_ALT_SCREEN);
+      if (entered) {
+        stream.write(
+          (options.kittyKeyboard ? POP_KITTY_KEYBOARD : "") + DISABLE_BRACKETED_PASTE + LEAVE_ALT_SCREEN
+        );
+      }
       stream.write(SHOW_CURSOR);
     }
   };
 }
 
+// src/tui/preferences.ts
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { dirname, join } from "node:path";
+function preferencesPath(env = process.env) {
+  return join(dataDirectory(env), "tui.json");
+}
+function localeDefaultHangul(env = process.env) {
+  const locale = env.LC_ALL || env.LC_CTYPE || env.LANG || "";
+  return /^ko(_|-|\.|$)/i.test(locale.trim());
+}
+async function readPreferences(env = process.env) {
+  const fallback = { hangulMode: localeDefaultHangul(env) };
+  try {
+    const raw = JSON.parse(await readFile(preferencesPath(env), "utf8"));
+    return typeof raw.hangulMode === "boolean" ? { hangulMode: raw.hangulMode } : fallback;
+  } catch {
+    return fallback;
+  }
+}
+async function writePreferences(preferences, env = process.env) {
+  try {
+    const path = preferencesPath(env);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify(preferences, null, 2)}
+`, "utf8");
+  } catch {
+  }
+}
+
 // src/tui/index.tsx
 import { jsx as jsx11 } from "react/jsx-runtime";
 async function runTui(engine) {
-  const screen = createScreenGuard(stdout);
+  let screen = createScreenGuard(stdout);
   const restore = () => screen.restore();
   const onSignal = () => {
     restore();
@@ -1457,12 +1838,34 @@ async function runTui(engine) {
   process.once("exit", restore);
   process.once("SIGINT", onSignal);
   process.once("SIGTERM", onSignal);
+  const preferences = await readPreferences();
+  const kitty = await supportsKittyKeyboard({ stdin, stdout, isTTY: stdin.isTTY });
+  screen = createScreenGuard(stdout, { kittyKeyboard: kitty });
   screen.enter();
   try {
-    const instance = render(/* @__PURE__ */ jsx11(App, { engine }), {
-      exitOnCtrlC: true,
-      patchConsole: true
-    });
+    const instance = render(
+      /* @__PURE__ */ jsx11(
+        App,
+        {
+          engine,
+          preferences: {
+            hangulMode: preferences.hangulMode,
+            onHangulModeChange: (enabled) => void writePreferences({ hangulMode: enabled })
+          }
+        }
+      ),
+      {
+        exitOnCtrlC: true,
+        patchConsole: true,
+        // 모든 키를 이스케이프로 받아야 수식 키 자체가 사건으로 온다.
+        ...kitty ? {
+          kittyKeyboard: {
+            mode: "enabled",
+            flags: ["disambiguateEscapeCodes", "reportAllKeysAsEscapeCodes"]
+          }
+        } : {}
+      }
+    );
     await instance.waitUntilExit();
   } finally {
     restore();
@@ -1474,4 +1877,4 @@ async function runTui(engine) {
 export {
   runTui
 };
-//# sourceMappingURL=tui-KJAW7DSU.js.map
+//# sourceMappingURL=tui-QF5OJEFW.js.map