@rigerc/ink-ui 0.0.0-stage → 0.41.1

package/dist/index.js

@@ -0,0 +1,1920 @@
+import { Box, Text, useWindowSize, useInput, measureElement, useApp, useStdout } from 'ink';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { glyph } from '@kud/glyphs';
+import React8, { createContext, useContext, useState, useEffect, useRef, useLayoutEffect, Children, isValidElement, Fragment as Fragment$1 } from 'react';
+import stringWidth3 from 'string-width';
+import { spawn } from 'child_process';
+
+// src/components/banner.tsx
+
+// src/tokens.ts
+var palette = {
+  orange: "#FF8C00",
+  amber: "#FFB400",
+  yellow: "#FFCB6B",
+  red: "#FF5364",
+  mint: "#5FD7A7",
+  green: "#4ADE80",
+  coral: "#FF6B6B",
+  blue: "#82AAFF",
+  cyan: "#89DDFF",
+  purple: "#C792EA",
+  ink: "#E4E4EC",
+  grey: "#999999",
+  slate: "#75767E",
+  dusk: "#5C5E73",
+  selection: "#30364A",
+  track: "#2B323D",
+  trackHigh: "#6B7480",
+  ground: "#1A1B27"
+};
+var colors = {
+  accent: palette.orange,
+  secondary: palette.grey,
+  muted: palette.slate,
+  success: palette.mint,
+  error: palette.red,
+  warning: palette.amber,
+  info: palette.cyan,
+  group: palette.purple,
+  track: palette.track,
+  trackHighlight: palette.trackHigh,
+  ticket: palette.yellow,
+  pr: palette.orange,
+  link: palette.blue,
+  added: palette.green,
+  removed: palette.coral,
+  pending: palette.slate,
+  dim: palette.dusk,
+  selection: palette.selection
+};
+var softColors = {
+  accent: "#8f4611",
+  muted: "#474a54",
+  success: "#2e6d4c",
+  error: "#7e2a2c",
+  warning: "#8a6a1e",
+  info: "#3c74a2",
+  group: "#524389"
+};
+var tonalColors = {
+  success: { fill: "#25393B", ink: "#5FD7A7" },
+  error: { fill: "#3F2431", ink: "#FF5364" },
+  warning: { fill: "#3F3321", ink: "#FFB400" },
+  info: { fill: "#2C3A4A", ink: "#89DDFF" },
+  accent: { fill: "#3D2A1C", ink: "#C47718" },
+  muted: { fill: "#262735", ink: "#7A7B85" },
+  group: { fill: "#362E46", ink: "#C792EA" }
+};
+var tonalStrongColors = {
+  success: { fill: "#2D504B", ink: "#5FD7A7" },
+  error: { fill: "#5A2B38", ink: "#FF5364" },
+  warning: { fill: "#5A461C", ink: "#FFB400" },
+  info: { fill: "#395163", ink: "#89DDFF" },
+  accent: { fill: "#5A3816", ink: "#E0913A" },
+  muted: { fill: "#33343F", ink: "#7F808A" },
+  group: { fill: "#4A3C5E", ink: "#C792EA" }
+};
+var priorityColors = {
+  highest: palette.ink,
+  high: palette.ink,
+  medium: palette.grey,
+  low: palette.slate,
+  lowest: palette.slate
+};
+var spacing = {
+  xs: 1,
+  sm: 2,
+  md: 3,
+  lg: 4
+};
+var symbols = {
+  active: "\u25CF",
+  nestedBullet: "\u25AA",
+  nestedBulletEmpty: "\u25AB",
+  rule: "\u254C",
+  caret: "\u258F",
+  verticalLine: "\u2502",
+  success: "\u2713",
+  error: "\u2717",
+  warn: "\u26A0",
+  info: "\u2139",
+  pointer: "\u276F",
+  checkboxChecked: "\u25FC",
+  checkboxUnchecked: "\u25FB",
+  bullet: "\u2022",
+  pending: "\u25CB",
+  ellipsis: "\u2026",
+  line: "\u2500",
+  barFull: "\u2588",
+  barEmpty: "\u2591"
+};
+var asciiSymbols = {
+  active: "*",
+  nestedBullet: "+",
+  nestedBulletEmpty: "-",
+  rule: "-",
+  caret: "|",
+  verticalLine: "|",
+  success: "+",
+  error: "x",
+  warn: "!",
+  info: "i",
+  pointer: ">",
+  checkboxChecked: "[x]",
+  checkboxUnchecked: "[ ]",
+  bullet: "*",
+  pending: "o",
+  ellipsis: "...",
+  line: "-",
+  barFull: "#",
+  barEmpty: "-"
+};
+var borders = {
+  base: "round",
+  focus: "bold",
+  ascii: "classic"
+};
+var motion = {
+  spinner: ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"],
+  asciiSpinner: ["-", "\\", "|", "/"],
+  intervalMs: 80,
+  /** Skeleton shimmer has a faster independent rhythm. */
+  skeletonIntervalMs: 70
+};
+var Banner = ({ title, subtitle, icon = "\u25C6" }) => /* @__PURE__ */ jsxs(Box, { gap: 1, marginBottom: 1, children: [
+  /* @__PURE__ */ jsx(Text, { color: colors.accent, children: icon }),
+  /* @__PURE__ */ jsx(Text, { bold: true, children: title }),
+  subtitle && /* @__PURE__ */ jsx(Text, { dimColor: true, children: subtitle })
+] });
+var variantColor = {
+  success: colors.success,
+  error: colors.error,
+  warning: colors.warning,
+  info: colors.info
+};
+var Badge = ({ children, variant = "info" }) => /* @__PURE__ */ jsxs(Text, { color: variantColor[variant], children: [
+  "[",
+  children,
+  "]"
+] });
+var FILL = {
+  success: colors.success,
+  error: colors.error,
+  warning: colors.warning,
+  info: colors.info,
+  accent: colors.accent,
+  muted: colors.muted,
+  group: colors.group
+};
+var INK = {
+  success: "black",
+  error: "white",
+  warning: "black",
+  info: "black",
+  accent: "black",
+  muted: "white",
+  group: "white"
+};
+var inkFor = (fill) => {
+  const hex = /^#([0-9a-f]{6})$/i.exec(fill)?.[1];
+  if (!hex) return "white";
+  const channel = (i) => {
+    const c = parseInt(hex.slice(i, i + 2), 16) / 255;
+    return c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+  };
+  const luminance = 0.2126 * channel(0) + 0.7152 * channel(2) + 0.0722 * channel(4);
+  return (luminance + 0.05) / 0.05 >= 1.05 / (luminance + 0.05) ? "black" : "white";
+};
+var pillStyle = (variant, tone, strong = false) => {
+  if (tone === "tonal") {
+    const pair = strong ? tonalStrongColors[variant] : tonalColors[variant];
+    return { fill: pair.fill, ink: pair.ink, bold: strong };
+  }
+  if (tone === "soft")
+    return {
+      fill: softColors[variant],
+      ink: inkFor(softColors[variant]),
+      bold: false
+    };
+  if (tone === "outline")
+    return { fill: FILL[variant], ink: FILL[variant], bold: false };
+  return { fill: FILL[variant], ink: INK[variant], bold: false };
+};
+var Pill = ({
+  children,
+  variant = "muted",
+  tone = "solid",
+  strong = false,
+  color
+}) => {
+  if (tone === "outline") {
+    const fill2 = color ?? FILL[variant];
+    return /* @__PURE__ */ jsxs(Text, { color: fill2, children: [
+      glyph("plCapLeftThin"),
+      children,
+      glyph("plCapRightThin")
+    ] });
+  }
+  if (tone === "tonal") {
+    const style = pillStyle(variant, tone, strong);
+    const fill2 = color ?? style.fill;
+    if (process.env["NO_COLOR"]) return /* @__PURE__ */ jsxs(Text, { color: fill2, children: [
+      "[",
+      children,
+      "]"
+    ] });
+    return /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsx(Text, { color: fill2, children: glyph("plCapLeft") }),
+      /* @__PURE__ */ jsx(Text, { backgroundColor: fill2, color: style.ink, bold: style.bold, children }),
+      /* @__PURE__ */ jsx(Text, { color: fill2, children: glyph("plCapRight") })
+    ] });
+  }
+  const fill = color ?? (tone === "soft" ? softColors[variant] : FILL[variant]);
+  const ink = tone === "soft" || color ? inkFor(fill) : INK[variant];
+  if (process.env["NO_COLOR"]) return /* @__PURE__ */ jsxs(Text, { color: fill, children: [
+    "[",
+    children,
+    "]"
+  ] });
+  return /* @__PURE__ */ jsxs(Text, { children: [
+    /* @__PURE__ */ jsx(Text, { color: fill, children: glyph("plCapLeft") }),
+    /* @__PURE__ */ jsx(Text, { backgroundColor: fill, color: ink, children }),
+    /* @__PURE__ */ jsx(Text, { color: fill, children: glyph("plCapRight") })
+  ] });
+};
+var pillWidth = (text) => text.length + 2;
+var Header = ({ children, subtitle }) => /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+  /* @__PURE__ */ jsx(Text, { bold: true, underline: true, children }),
+  subtitle && /* @__PURE__ */ jsx(Text, { dimColor: true, children: subtitle })
+] });
+var Spinner = ({ label, ascii = false }) => {
+  const [frame, setFrame] = useState(0);
+  const frames = ascii ? motion.asciiSpinner : motion.spinner;
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setFrame((prev) => (prev + 1) % frames.length);
+    }, motion.intervalMs);
+    return () => clearInterval(timer);
+  }, [ascii]);
+  return /* @__PURE__ */ jsxs(Box, { gap: spacing.xs, children: [
+    /* @__PURE__ */ jsx(Text, { color: colors.accent, children: frames[frame % frames.length] }),
+    label && /* @__PURE__ */ jsx(Text, { dimColor: true, children: label })
+  ] });
+};
+var knownTerminalColumns = (stdout, windowColumns) => {
+  if (typeof stdout !== "object" || stdout === null || !("columns" in stdout))
+    return void 0;
+  const columns = stdout.columns;
+  return typeof columns === "number" && Number.isFinite(columns) && columns > 0 ? windowColumns : void 0;
+};
+var useTerminalColumns = () => {
+  const { stdout } = useStdout();
+  const { columns } = useWindowSize();
+  return knownTerminalColumns(stdout, columns);
+};
+var DEFAULT_MIN_WIDTH = 3;
+var widestLine = (value) => value.split("\n").reduce((widest, line) => Math.max(widest, stringWidth3(line)), 0);
+var naturalWidth = (column, cells) => cells.reduce(
+  (widest, cell) => Math.max(widest, widestLine(cell)),
+  widestLine(column.header)
+);
+var floorFor = (column, width) => column.width !== void 0 ? width : Math.min(width, column.minWidth ?? DEFAULT_MIN_WIDTH);
+var widestShrinkable = (widths, floors) => widths.reduce(
+  (best, width, index) => width > floors[index] && (best === -1 || width > widths[best]) ? index : best,
+  -1
+);
+var shrinkToFit = (widths, floors, excess) => {
+  const shrunk = [...widths];
+  let remaining = excess;
+  while (remaining > 0) {
+    const target = widestShrinkable(shrunk, floors);
+    if (target === -1) break;
+    shrunk[target] = shrunk[target] - 1;
+    remaining -= 1;
+  }
+  return shrunk;
+};
+var resolveColumnWidths = ({
+  columns,
+  rows,
+  gap,
+  maxWidth
+}) => {
+  const widths = columns.map(
+    (column, index) => column.width ?? naturalWidth(
+      column,
+      rows.map((row) => row[index] ?? "")
+    )
+  );
+  const gaps = gap * Math.max(columns.length - 1, 0);
+  const excess = widths.reduce((total, width) => total + width, gaps) - maxWidth;
+  return excess > 0 ? shrinkToFit(
+    widths,
+    columns.map((column, index) => floorFor(column, widths[index])),
+    excess
+  ) : widths;
+};
+var FALLBACK_TERMINAL_WIDTH = 80;
+var justification = {
+  left: "flex-start",
+  center: "center",
+  right: "flex-end"
+};
+var cellText = (value) => String(value ?? "");
+var Table = ({
+  data,
+  columns,
+  gap = 2,
+  maxWidth,
+  headerColor = colors.muted
+}) => {
+  const terminalColumns = useTerminalColumns();
+  const rows = data.map(
+    (row) => columns.map((column) => cellText(row[column.key]))
+  );
+  const widths = resolveColumnWidths({
+    columns,
+    rows,
+    gap,
+    maxWidth: maxWidth ?? terminalColumns ?? FALLBACK_TERMINAL_WIDTH
+  });
+  const cell = (column, index, content) => /* @__PURE__ */ jsx(
+    Box,
+    {
+      width: widths[index],
+      flexShrink: 0,
+      flexGrow: 0,
+      justifyContent: justification[column.align ?? "left"],
+      children: content
+    },
+    column.key
+  );
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(Box, { gap, children: columns.map(
+      (column, index) => cell(
+        column,
+        index,
+        /* @__PURE__ */ jsx(Text, { bold: true, color: headerColor, wrap: "truncate-end", children: column.header })
+      )
+    ) }),
+    rows.map((cells, rowIndex) => /* @__PURE__ */ jsx(Box, { gap, children: columns.map(
+      (column, index) => cell(
+        column,
+        index,
+        /* @__PURE__ */ jsx(Text, { wrap: column.overflow === "wrap" ? "wrap" : "truncate-end", children: cells[index] })
+      )
+    ) }, rowIndex))
+  ] });
+};
+var tailHints = (page, help = true) => [
+  ...page === "nested" ? [["\u232B", "back"]] : [],
+  ...help ? [["?", "help"]] : [],
+  ["q", "quit"]
+];
+var FooterHints = ({ hints, page, help = true }) => {
+  const all = page ? [...hints, ...tailHints(page, help)] : hints;
+  return /* @__PURE__ */ jsx(Box, { columnGap: spacing.sm, rowGap: 0, flexWrap: "wrap", children: all.map(([key, label]) => /* @__PURE__ */ jsxs(Box, { children: [
+    /* @__PURE__ */ jsx(Text, { color: "white", children: key }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: " " + label })
+  ] }, key)) });
+};
+var STATUS_COLOR = {
+  news: colors.accent,
+  busy: colors.info,
+  quiet: void 0
+};
+var Page = ({
+  title,
+  icon,
+  count,
+  noun = "item",
+  user,
+  scope,
+  alert,
+  critical = false,
+  status,
+  facts,
+  tabs,
+  counter,
+  hints,
+  page = "root",
+  help = true,
+  gap = true,
+  filter,
+  fill = false,
+  width,
+  height,
+  children
+}) => {
+  const terminal = useWindowSize();
+  const frameWidth = width ?? (fill ? terminal.columns : void 0);
+  const frameHeight = height ?? (fill ? terminal.rows : void 0);
+  const brand = icon ? `${icon} ${title}` : title;
+  const countSeg = count === void 0 ? facts ? `   ${facts}  ` : "  " : `  ${String(count).padStart(3)} ${noun}${count !== 1 ? "s" : ""}  \xB7  `;
+  const userSeg = user ? `@${user}  ` : "";
+  const scopeSeg = scope ? `${scope}  ` : "";
+  const alertSeg = alert ? `${alert}  ` : "";
+  const statusSeg = status ? `${status.text}  ` : "";
+  const inner = (frameWidth ?? 80) - 4;
+  const used = stringWidth3(
+    brand + countSeg + userSeg + scopeSeg + alertSeg + statusSeg
+  );
+  const ruleWidth = Math.max(4, inner - used);
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      flexDirection: "column",
+      width: frameWidth,
+      height: frameHeight,
+      borderStyle: borders.base,
+      borderColor: colors.muted,
+      overflow: "hidden",
+      children: [
+        /* @__PURE__ */ jsxs(Box, { paddingLeft: 1, children: [
+          /* @__PURE__ */ jsx(Text, { color: colors.accent, bold: true, children: brand }),
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: countSeg }),
+          userSeg ? /* @__PURE__ */ jsx(Text, { children: userSeg }) : null,
+          scopeSeg ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: scopeSeg }) : null,
+          alertSeg ? /* @__PURE__ */ jsx(Text, { bold: true, color: critical ? colors.error : colors.accent, children: alertSeg }) : null,
+          statusSeg && status ? /* @__PURE__ */ jsx(
+            Text,
+            {
+              color: STATUS_COLOR[status.tone],
+              dimColor: status.tone === "quiet",
+              bold: status.tone === "news",
+              children: statusSeg
+            }
+          ) : null,
+          /* @__PURE__ */ jsx(Text, { color: colors.info, dimColor: true, children: symbols.rule.repeat(ruleWidth) })
+        ] }),
+        filter ? /* @__PURE__ */ jsx(Box, { paddingLeft: 2, children: filter }) : null,
+        tabs ? /* @__PURE__ */ jsx(Box, { paddingLeft: 2, marginTop: filter ? 0 : 1, children: tabs }) : null,
+        /* @__PURE__ */ jsx(
+          Box,
+          {
+            flexDirection: "column",
+            flexGrow: 1,
+            marginTop: gap && !(filter && !tabs) ? 1 : 0,
+            children
+          }
+        ),
+        counter ? /* @__PURE__ */ jsx(Box, { justifyContent: "flex-end", paddingRight: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: counter }) }) : null,
+        hints ? /* @__PURE__ */ jsx(Box, { paddingLeft: 2, children: /* @__PURE__ */ jsx(FooterHints, { hints, page, help }) }) : null
+      ]
+    }
+  );
+};
+var PAGE_CHROME = 4;
+var isTextValue = (value) => typeof value === "string" || typeof value === "number";
+var KeyValue = ({ label, value, labelWidth = 12 }) => /* @__PURE__ */ jsxs(Box, { children: [
+  /* @__PURE__ */ jsx(Box, { width: labelWidth, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: label }) }),
+  isTextValue(value) ? /* @__PURE__ */ jsx(Text, { children: value }) : value
+] });
+var LoadingScreen = ({ label }) => /* @__PURE__ */ jsx(Box, { padding: 1, children: /* @__PURE__ */ jsx(Spinner, { label }) });
+var Panel = ({
+  title,
+  color = colors.info,
+  focused = false,
+  width,
+  height,
+  flexGrow,
+  children
+}) => /* @__PURE__ */ jsxs(
+  Box,
+  {
+    flexDirection: "column",
+    width,
+    height,
+    flexGrow,
+    borderStyle: focused ? borders.focus : borders.base,
+    borderColor: focused ? color : colors.muted,
+    overflow: "hidden",
+    children: [
+      title && /* @__PURE__ */ jsx(Text, { color: focused ? color : colors.muted, bold: true, children: focused ? `${title} ${symbols.active}` : title }),
+      children
+    ]
+  }
+);
+var Columns = ({ gap = 1, children }) => /* @__PURE__ */ jsx(Box, { flexDirection: "row", gap, flexGrow: 1, children });
+var isTextValue2 = (value) => typeof value === "string" || typeof value === "number";
+var SelectableRow = ({
+  active = false,
+  marker = symbols.pointer,
+  children
+}) => /* @__PURE__ */ jsxs(Box, { children: [
+  /* @__PURE__ */ jsx(Box, { flexShrink: 0, children: /* @__PURE__ */ jsx(Text, { color: colors.info, children: active ? `  ${marker} ` : "    " }) }),
+  isTextValue2(children) ? /* @__PURE__ */ jsx(Text, { bold: active, children }) : children
+] });
+var windowStart = (cursor, total, count) => {
+  if (total <= count) return 0;
+  return Math.max(0, Math.min(cursor - Math.floor(count / 2), total - count));
+};
+var Select = ({
+  options,
+  onChange,
+  onSubmit,
+  defaultValue,
+  isDisabled = false,
+  visibleOptionCount
+}) => {
+  const initial = options.findIndex((o) => o.value === defaultValue);
+  const [cursor, setCursor] = useState(initial === -1 ? 0 : initial);
+  const move = (delta) => {
+    const next = (cursor + delta + options.length) % options.length;
+    setCursor(next);
+    onChange?.(options[next].value);
+  };
+  useInput(
+    (_input, key) => {
+      if (key.upArrow) move(-1);
+      if (key.downArrow) move(1);
+      if (key.return) onSubmit?.(options[cursor].value);
+    },
+    { isActive: !isDisabled && options.length > 0 }
+  );
+  const count = visibleOptionCount ?? options.length;
+  const start = windowStart(cursor, options.length, count);
+  const visible = options.slice(start, start + count);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    visible.map((option, i) => {
+      const active = start + i === cursor;
+      return /* @__PURE__ */ jsxs(SelectableRow, { active, children: [
+        /* @__PURE__ */ jsx(Text, { bold: active, color: active ? colors.info : void 0, children: option.label }),
+        active ? /* @__PURE__ */ jsx(Text, { color: colors.success, children: " " + symbols.success }) : null
+      ] }, option.value);
+    }),
+    options.length > count && /* @__PURE__ */ jsx(Text, { dimColor: true, children: `  ${symbols.ellipsis} ${options.length} total` })
+  ] });
+};
+var windowStart2 = (cursor, total, count) => {
+  if (total <= count) return 0;
+  return Math.max(0, Math.min(cursor - Math.floor(count / 2), total - count));
+};
+var MultiSelect = ({
+  options,
+  onChange,
+  onSubmit,
+  defaultValue = [],
+  isDisabled = false,
+  visibleOptionCount
+}) => {
+  const [cursor, setCursor] = useState(0);
+  const [selected, setSelected] = useState(new Set(defaultValue));
+  useInput(
+    (input, key) => {
+      if (key.upArrow)
+        setCursor((i) => (i - 1 + options.length) % options.length);
+      if (key.downArrow) setCursor((i) => (i + 1) % options.length);
+      if (input === " ") {
+        const value = options[cursor].value;
+        const next = new Set(selected);
+        if (next.has(value)) next.delete(value);
+        else next.add(value);
+        setSelected(next);
+        onChange?.([...next]);
+      }
+      if (key.return) onSubmit?.([...selected]);
+    },
+    { isActive: !isDisabled && options.length > 0 }
+  );
+  const count = visibleOptionCount ?? options.length;
+  const start = windowStart2(cursor, options.length, count);
+  const visible = options.slice(start, start + count);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    visible.map((option, i) => {
+      const active = start + i === cursor;
+      const on = selected.has(option.value);
+      return /* @__PURE__ */ jsxs(SelectableRow, { active, children: [
+        /* @__PURE__ */ jsx(Text, { bold: active, color: active ? colors.info : void 0, children: option.label }),
+        on ? /* @__PURE__ */ jsx(Text, { color: colors.success, children: " " + symbols.success }) : null
+      ] }, option.value);
+    }),
+    options.length > count && /* @__PURE__ */ jsx(Text, { dimColor: true, children: `  ${symbols.ellipsis} ${options.length} total` })
+  ] });
+};
+var TextInput = ({
+  placeholder = "",
+  defaultValue = "",
+  onChange,
+  onSubmit,
+  onCancel,
+  isDisabled = false
+}) => {
+  const [value, setValue] = useState(defaultValue);
+  const [cursor, setCursor] = useState(defaultValue.length);
+  const update = (nextValue, nextCursor) => {
+    setValue(nextValue);
+    setCursor(nextCursor);
+    onChange?.(nextValue);
+  };
+  useInput(
+    (input, key) => {
+      if (key.return) {
+        onSubmit?.(value);
+        return;
+      }
+      if (key.escape) {
+        onCancel?.();
+        return;
+      }
+      if (key.leftArrow) {
+        setCursor((c) => Math.max(0, c - 1));
+        return;
+      }
+      if (key.rightArrow) {
+        setCursor((c) => Math.min(value.length, c + 1));
+        return;
+      }
+      if (key.backspace || key.delete) {
+        if (cursor === 0) return;
+        update(value.slice(0, cursor - 1) + value.slice(cursor), cursor - 1);
+        return;
+      }
+      if (input && !key.ctrl && !key.meta && !key.tab) {
+        update(
+          value.slice(0, cursor) + input + value.slice(cursor),
+          cursor + input.length
+        );
+      }
+    },
+    { isActive: !isDisabled }
+  );
+  if (value.length === 0) {
+    return /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsx(Text, { inverse: true, children: " " }),
+      placeholder ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: placeholder }) : null
+    ] });
+  }
+  const before = value.slice(0, cursor);
+  const at = value.slice(cursor, cursor + 1) || " ";
+  const after = value.slice(cursor + 1);
+  return /* @__PURE__ */ jsxs(Text, { children: [
+    before,
+    /* @__PURE__ */ jsx(Text, { inverse: true, children: at }),
+    after
+  ] });
+};
+var defaultDomains = [
+  "gmail.com",
+  "outlook.com",
+  "hotmail.com",
+  "yahoo.com",
+  "icloud.com",
+  "proton.me"
+];
+var EmailInput = ({
+  placeholder = "",
+  defaultValue = "",
+  domains = defaultDomains,
+  onChange,
+  onSubmit,
+  isDisabled = false
+}) => {
+  const [value, setValue] = useState(defaultValue);
+  const [cursor, setCursor] = useState(defaultValue.length);
+  const at = value.indexOf("@");
+  const domainFragment = at === -1 ? "" : value.slice(at + 1);
+  const match = at !== -1 && domainFragment.length > 0 ? domains.find(
+    (d) => d.startsWith(domainFragment) && d !== domainFragment
+  ) : void 0;
+  const suggestion = match ? match.slice(domainFragment.length) : "";
+  const showSuggestion = suggestion.length > 0 && cursor === value.length;
+  const update = (nextValue, nextCursor) => {
+    setValue(nextValue);
+    setCursor(nextCursor);
+    onChange?.(nextValue);
+  };
+  useInput(
+    (input, key) => {
+      if (key.return) {
+        onSubmit?.(value);
+        return;
+      }
+      if (key.tab && showSuggestion) {
+        update(value + suggestion, value.length + suggestion.length);
+        return;
+      }
+      if (key.leftArrow) {
+        setCursor((c) => Math.max(0, c - 1));
+        return;
+      }
+      if (key.rightArrow) {
+        setCursor((c) => Math.min(value.length, c + 1));
+        return;
+      }
+      if (key.backspace || key.delete) {
+        if (cursor === 0) return;
+        update(value.slice(0, cursor - 1) + value.slice(cursor), cursor - 1);
+        return;
+      }
+      if (input && !key.ctrl && !key.meta && !key.tab) {
+        update(
+          value.slice(0, cursor) + input + value.slice(cursor),
+          cursor + input.length
+        );
+      }
+    },
+    { isActive: !isDisabled }
+  );
+  if (value.length === 0) {
+    return /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsx(Text, { inverse: true, children: " " }),
+      placeholder ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: placeholder }) : null
+    ] });
+  }
+  if (showSuggestion) {
+    return /* @__PURE__ */ jsxs(Text, { children: [
+      value,
+      /* @__PURE__ */ jsx(Text, { inverse: true, children: suggestion.slice(0, 1) }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: suggestion.slice(1) })
+    ] });
+  }
+  const before = value.slice(0, cursor);
+  const atChar = value.slice(cursor, cursor + 1) || " ";
+  const after = value.slice(cursor + 1);
+  return /* @__PURE__ */ jsxs(Text, { children: [
+    before,
+    /* @__PURE__ */ jsx(Text, { inverse: true, children: atChar }),
+    after
+  ] });
+};
+var PasswordInput = ({
+  placeholder = "",
+  mask = "*",
+  onChange,
+  onSubmit,
+  isDisabled = false
+}) => {
+  const [value, setValue] = useState("");
+  const [cursor, setCursor] = useState(0);
+  const update = (nextValue, nextCursor) => {
+    setValue(nextValue);
+    setCursor(nextCursor);
+    onChange?.(nextValue);
+  };
+  useInput(
+    (input, key) => {
+      if (key.return) {
+        onSubmit?.(value);
+        return;
+      }
+      if (key.leftArrow) {
+        setCursor((c) => Math.max(0, c - 1));
+        return;
+      }
+      if (key.rightArrow) {
+        setCursor((c) => Math.min(value.length, c + 1));
+        return;
+      }
+      if (key.backspace || key.delete) {
+        if (cursor === 0) return;
+        update(value.slice(0, cursor - 1) + value.slice(cursor), cursor - 1);
+        return;
+      }
+      if (input && !key.ctrl && !key.meta && !key.tab) {
+        update(
+          value.slice(0, cursor) + input + value.slice(cursor),
+          cursor + input.length
+        );
+      }
+    },
+    { isActive: !isDisabled }
+  );
+  if (value.length === 0) {
+    return /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsx(Text, { inverse: true, children: " " }),
+      placeholder ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: placeholder }) : null
+    ] });
+  }
+  const masked = mask.repeat(value.length);
+  const before = masked.slice(0, cursor);
+  const at = masked.slice(cursor, cursor + 1) || " ";
+  const after = masked.slice(cursor + 1);
+  return /* @__PURE__ */ jsxs(Text, { children: [
+    before,
+    /* @__PURE__ */ jsx(Text, { inverse: true, children: at }),
+    after
+  ] });
+};
+var ConfirmInput = ({
+  defaultChoice = "confirm",
+  onConfirm,
+  onCancel,
+  isDisabled = false
+}) => {
+  useInput(
+    (input, key) => {
+      if (input.toLowerCase() === "y") {
+        onConfirm?.();
+        return;
+      }
+      if (input.toLowerCase() === "n") {
+        onCancel?.();
+        return;
+      }
+      if (key.return) {
+        if (defaultChoice === "confirm") onConfirm?.();
+        else onCancel?.();
+      }
+    },
+    { isActive: !isDisabled }
+  );
+  const hint = defaultChoice === "confirm" ? "(Y/n)" : "(y/N)";
+  return /* @__PURE__ */ jsx(Text, { dimColor: true, children: hint });
+};
+var markers = [symbols.active, symbols.pending, symbols.nestedBullet, symbols.nestedBulletEmpty];
+var DepthContext = createContext(0);
+var UnorderedListItem = ({ children }) => {
+  const depth = useContext(DepthContext);
+  const marker = markers[Math.max(0, depth - 1) % markers.length];
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
+    /* @__PURE__ */ jsxs(Text, { children: [
+      marker,
+      " "
+    ] }),
+    /* @__PURE__ */ jsx(Box, { flexDirection: "column", children })
+  ] });
+};
+var UnorderedListRoot = ({ children }) => {
+  const depth = useContext(DepthContext);
+  return /* @__PURE__ */ jsx(DepthContext.Provider, { value: depth + 1, children: /* @__PURE__ */ jsx(Box, { flexDirection: "column", children }) });
+};
+var UnorderedList = Object.assign(UnorderedListRoot, {
+  Item: UnorderedListItem
+});
+var OrderedListItem = ({ children, _index = 1 }) => /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
+  /* @__PURE__ */ jsxs(Text, { children: [
+    _index,
+    ". "
+  ] }),
+  /* @__PURE__ */ jsx(Box, { flexDirection: "column", children })
+] });
+var OrderedListRoot = ({ children }) => {
+  let n = 0;
+  const numbered = React8.Children.map(children, (child) => {
+    if (React8.isValidElement(child) && child.type === OrderedListItem) {
+      n += 1;
+      return React8.cloneElement(child, {
+        _index: n
+      });
+    }
+    return child;
+  });
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: numbered });
+};
+var OrderedList = Object.assign(OrderedListRoot, {
+  Item: OrderedListItem
+});
+var ScrollView = ({
+  lines,
+  showIndicator = true,
+  initialStart = 0,
+  isActive = true
+}) => {
+  const ref = useRef(null);
+  const [height, setHeight] = useState(1);
+  const [start, setStart] = useState(initialStart);
+  useEffect(() => setStart(initialStart), [initialStart]);
+  useLayoutEffect(() => {
+    if (!ref.current) return;
+    const { height: h } = measureElement(ref.current);
+    if (h > 0 && h !== height) setHeight(h);
+  });
+  const maxStart = Math.max(0, lines.length - height);
+  const clamped = Math.min(start, maxStart);
+  useInput(
+    (input, key) => {
+      if (key.downArrow || input === "j")
+        setStart((s) => Math.min(maxStart, s + 1));
+      if (key.upArrow || input === "k") setStart((s) => Math.max(0, s - 1));
+      if (input === " " || key.pageDown || input === "f")
+        setStart((s) => Math.min(maxStart, s + height));
+      if (key.pageUp || input === "b") setStart((s) => Math.max(0, s - height));
+      if (input === "g") setStart(0);
+      if (input === "G") setStart(maxStart);
+    },
+    { isActive }
+  );
+  const visible = lines.slice(clamped, clamped + height);
+  const hasMore = lines.length > height;
+  const atEnd = clamped >= maxStart;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [
+    /* @__PURE__ */ jsx(Box, { ref, flexDirection: "column", flexGrow: 1, overflow: "hidden", children: visible.map(
+      (l, i) => l.spans ? /* @__PURE__ */ jsxs(Text, { wrap: "truncate-end", children: [
+        l.spans.map((s, j) => /* @__PURE__ */ jsx(
+          Text,
+          {
+            color: s.color,
+            bold: s.bold,
+            dimColor: s.dim,
+            italic: s.italic,
+            children: s.text
+          },
+          j
+        )),
+        l.spans.length === 0 ? " " : ""
+      ] }, i) : /* @__PURE__ */ jsx(
+        Text,
+        {
+          color: l.color,
+          bold: l.bold,
+          dimColor: l.dim,
+          wrap: "truncate-end",
+          children: l.text || " "
+        },
+        i
+      )
+    ) }),
+    showIndicator && hasMore && /* @__PURE__ */ jsx(Text, { dimColor: true, children: `  ${clamped + 1}\u2013${clamped + visible.length} / ${lines.length}` + (atEnd ? "  (end)" : "  \u2193 j/space") })
+  ] });
+};
+var GAP = spacing.sm;
+var FOLDED_PENDING_COUNT = "\u2013";
+var DIVIDER = symbols.verticalLine;
+var DIVIDER_WIDTH = 1;
+var tabCountStyle = (isActive) => {
+  const style = pillStyle(isActive ? "accent" : "muted", "tonal", isActive);
+  return {
+    bold: style.bold,
+    color: style.ink,
+    backgroundColor: style.fill
+  };
+};
+var countContentOf = (item) => {
+  if (item.count === void 0) return void 0;
+  if (item.count === null)
+    return process.env["NO_COLOR"] ? FOLDED_PENDING_COUNT : " \u2013";
+  if (item.total === void 0) return String(item.count);
+  return `${item.count}/${item.total}`;
+};
+var chipTailOf = (content) => ` ${glyph("plCapLeft")}${content}${glyph("plCapRight")}`;
+var fullPartsOf = (item) => {
+  const head = item.icon === void 0 ? item.label : `${item.icon} ${item.label}`;
+  const content = countContentOf(item);
+  if (content === void 0) return [head, ""];
+  if (process.env["NO_COLOR"]) return [head, ` (${content})`];
+  return [head, chipTailOf(content)];
+};
+var shouldFoldTabs = (fullWidth, availableWidth) => availableWidth !== void 0 && fullWidth > availableWidth;
+var tabLabelStyle = (isActive) => ({
+  bold: isActive,
+  color: isActive ? colors.accent : void 0,
+  dimColor: !isActive
+});
+var fullTextOf = (item) => fullPartsOf(item).join("");
+var foldedPartsOf = (item) => {
+  const icon = item.icon ?? "";
+  const content = countContentOf(item);
+  if (content === void 0) return [icon, ""];
+  if (process.env["NO_COLOR"])
+    return [
+      icon,
+      item.count === null ? ` ${FOLDED_PENDING_COUNT}` : ` ${content}`
+    ];
+  return [icon, chipTailOf(content)];
+};
+var foldedTextOf = (item) => foldedPartsOf(item).join("");
+var Tabs = ({
+  active,
+  items,
+  width
+}) => {
+  const terminalColumns = useTerminalColumns();
+  const availableWidth = width ?? terminalColumns;
+  const cells = items.map((item) => {
+    const [fullLabel, fullTail] = fullPartsOf(item);
+    const [foldedLabel, foldedTail] = foldedPartsOf(item);
+    return {
+      key: item.value,
+      marker: item.marker ?? "",
+      markerColor: item.markerColor,
+      fullText: fullTextOf(item),
+      foldedText: foldedTextOf(item),
+      fullLabel,
+      fullTail,
+      foldedLabel,
+      foldedTail,
+      countContent: countContentOf(item),
+      hasIcon: item.icon !== void 0,
+      isActive: item.value === active,
+      group: item.group
+    };
+  });
+  const renderItems = [];
+  for (let i = 0; i < cells.length; i++) {
+    const prevGroup = i > 0 ? cells[i - 1].group : void 0;
+    const currGroup = cells[i].group;
+    if (i > 0 && currGroup !== prevGroup) {
+      renderItems.push({ type: "divider" });
+    }
+    renderItems.push({ type: "tab", cell: cells[i] });
+  }
+  const cellWidth = (marker, text) => stringWidth3(marker) + stringWidth3(text);
+  const fullWidth = renderItems.reduce(
+    (sum, item) => sum + (item.type === "divider" ? DIVIDER_WIDTH : cellWidth(item.cell.marker, item.cell.fullText)),
+    0
+  ) + GAP * Math.max(0, renderItems.length - 1);
+  const folded = shouldFoldTabs(fullWidth, availableWidth);
+  const textOf = (cell) => folded && !cell.isActive && cell.hasIcon ? cell.foldedText : cell.fullText;
+  const gutterOf = (cell) => stringWidth3(cell.marker);
+  const labelOf = (cell) => stringWidth3(
+    folded && !cell.isActive && cell.hasIcon ? cell.foldedLabel : cell.fullLabel
+  );
+  let x = 0;
+  let rule = { start: 0, width: 0 };
+  for (const item of renderItems) {
+    if (item.type === "tab") {
+      if (item.cell.isActive)
+        rule = { start: x + gutterOf(item.cell), width: labelOf(item.cell) };
+      x += gutterOf(item.cell) + stringWidth3(textOf(item.cell)) + GAP;
+    } else {
+      x += DIVIDER_WIDTH + GAP;
+    }
+  }
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(Box, { gap: GAP, children: renderItems.map((item, idx) => {
+      if (item.type === "divider") {
+        return /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { color: colors.muted, dimColor: true, children: DIVIDER }) }, `divider-${idx}`);
+      }
+      const cell = item.cell;
+      const isFolded = folded && !cell.isActive && cell.hasIcon;
+      const labelText = isFolded ? cell.foldedLabel : cell.fullLabel;
+      const tailText = isFolded ? cell.foldedTail : cell.fullTail;
+      return /* @__PURE__ */ jsxs(Box, { children: [
+        cell.marker ? /* @__PURE__ */ jsx(Text, { color: cell.markerColor, children: cell.marker }) : null,
+        /* @__PURE__ */ jsx(Text, { ...tabLabelStyle(cell.isActive), children: labelText }),
+        tailText ? process.env["NO_COLOR"] ? /* @__PURE__ */ jsx(Text, { ...tabCountStyle(cell.isActive), children: tailText }) : (
+          // The separating space lives inside this run, not beside
+          // it: a bare string child of the row's `Box` blanks the
+          // whole strip, while a string inside a `Text` is just text.
+          /* @__PURE__ */ jsxs(Text, { children: [
+            " ",
+            /* @__PURE__ */ jsx(
+              Pill,
+              {
+                tone: "tonal",
+                variant: cell.isActive ? "accent" : "muted",
+                strong: cell.isActive,
+                children: cell.countContent ?? ""
+              }
+            )
+          ] })
+        ) : null
+      ] }, cell.key);
+    }) }),
+    /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { color: colors.accent, children: " ".repeat(rule.start) + symbols.line.repeat(rule.width) }) })
+  ] });
+};
+
+// src/icon-mode.ts
+var current = "text";
+var setIconMode = (mode) => {
+  current = mode;
+};
+var getIconMode = () => current;
+
+// src/components/status-variants.ts
+var UNICODE = {
+  success: symbols.success,
+  error: symbols.error,
+  warning: symbols.warn,
+  info: symbols.info
+};
+var NERD = {
+  success: glyph("check"),
+  error: glyph("cross"),
+  warning: glyph("warning"),
+  info: glyph("info")
+};
+var COLOR = {
+  success: colors.success,
+  error: colors.error,
+  warning: colors.warning,
+  info: colors.info
+};
+var statusVariant = (variant) => ({
+  icon: (getIconMode() === "nerd" ? NERD : UNICODE)[variant],
+  color: COLOR[variant]
+});
+var StatusMessage = ({
+  variant = "info",
+  children
+}) => {
+  const { icon, color } = statusVariant(variant);
+  return /* @__PURE__ */ jsxs(Box, { gap: 1, children: [
+    /* @__PURE__ */ jsx(Text, { color, children: icon }),
+    /* @__PURE__ */ jsx(Text, { children })
+  ] });
+};
+var Step = (_props) => null;
+var StepperProgress = ({
+  steps,
+  currentStep,
+  orientation = "horizontal",
+  ascii = false
+}) => {
+  const markers2 = ascii ? asciiSymbols : symbols;
+  return /* @__PURE__ */ jsx(
+    Box,
+    {
+      flexDirection: orientation === "vertical" ? "column" : "row",
+      flexWrap: "wrap",
+      columnGap: spacing.sm,
+      children: steps.map(({ id, name }, index) => {
+        const complete = index < currentStep;
+        const current2 = index === currentStep;
+        const marker = complete ? markers2.success : current2 ? markers2.pointer : markers2.pending;
+        return /* @__PURE__ */ jsxs(
+          Text,
+          {
+            bold: current2,
+            color: colors[complete ? "success" : current2 ? "accent" : "muted"],
+            dimColor: !current2 && !complete,
+            children: [
+              marker,
+              " ",
+              index + 1,
+              ". ",
+              name
+            ]
+          },
+          id
+        );
+      })
+    }
+  );
+};
+var StepperContext = createContext(null);
+var useStepper = () => {
+  const context = useContext(StepperContext);
+  if (!context) throw new Error("useStepper must be used inside Stepper");
+  return context;
+};
+var StepperNavigation = () => {
+  const { isFirst, isLast, isValidating, keyboardNav } = useStepper();
+  if (isValidating) return /* @__PURE__ */ jsxs(Text, { color: colors.muted, children: [
+    "Validating",
+    symbols.ellipsis
+  ] });
+  const hints = [
+    ...keyboardNav ? [["\u21B5", isLast ? "finish" : "next"]] : [],
+    ["\u232B", isFirst ? "cancel" : "back"]
+  ];
+  return /* @__PURE__ */ jsx(FooterHints, { hints });
+};
+var collectSteps = (children, prefix = "") => Children.toArray(children).flatMap((child, index) => {
+  if (!isValidElement(child)) {
+    throw new Error("Stepper children must be Step elements or fragments");
+  }
+  const id = prefix + "/" + (child.key ?? index);
+  if (child.type === Fragment$1) {
+    return collectSteps(child.props.children, id);
+  }
+  if (child.type !== Step) {
+    throw new Error("Stepper children must be Step elements or fragments");
+  }
+  return [{ id, element: child }];
+});
+var clamp = (index, length) => Math.max(0, Math.min(Number.isFinite(index) ? Math.trunc(index) : 0, length - 1));
+var Stepper = ({
+  children,
+  onComplete,
+  onCancel,
+  onStepChange,
+  onExitStep,
+  onEnterStep,
+  onError,
+  step,
+  initialStep = 0,
+  keyboardNav = false,
+  ascii = false,
+  showProgress = true,
+  renderProgress
+}) => {
+  const steps = collectSteps(children);
+  const [position, setPosition] = useState({
+    index: initialStep,
+    id: null
+  });
+  const trackedIndex = position.id === null ? -1 : steps.findIndex((item) => item.id === position.id);
+  const currentStep = clamp(
+    step ?? (trackedIndex < 0 ? position.index : trackedIndex),
+    steps.length
+  );
+  const active = steps[currentStep];
+  const [isValidating, setIsValidating] = useState(false);
+  const [error, setError] = useState();
+  const [finished, setFinished] = useState(false);
+  const busy = useRef(false);
+  const ended = useRef(false);
+  const mounted = useRef(true);
+  const source = useRef({ id: active?.id, index: currentStep, signature: "" });
+  source.current = {
+    id: active?.id,
+    index: currentStep,
+    signature: JSON.stringify(steps.map((item) => item.id))
+  };
+  useEffect(() => {
+    mounted.current = true;
+    return () => {
+      mounted.current = false;
+    };
+  }, []);
+  useEffect(() => {
+    if (step === void 0 && active) {
+      setPosition(
+        (previous) => previous.id === active.id && previous.index === currentStep ? previous : { id: active.id, index: currentStep }
+      );
+    }
+  }, [active?.id, currentStep, step]);
+  const cancel = () => {
+    if (busy.current || ended.current || !active) return;
+    ended.current = true;
+    setFinished(true);
+    onCancel?.();
+  };
+  const navigate = async (direction) => {
+    if (busy.current || ended.current || !active) return;
+    const target = typeof direction === "number" ? clamp(direction, steps.length) : direction === "next" ? currentStep + 1 : currentStep - 1;
+    if (target === currentStep) return;
+    busy.current = true;
+    setIsValidating(true);
+    setError(void 0);
+    const origin = source.current;
+    const stillCurrent = () => mounted.current && source.current.id === origin.id && source.current.index === origin.index && source.current.signature === origin.signature;
+    try {
+      await Promise.resolve();
+      if (!stillCurrent()) return;
+      if (direction === "next") {
+        const guard = active.element.props.canProceed ?? true;
+        const permitted = typeof guard === "function" ? await guard() : guard;
+        if (!permitted || !stillCurrent()) return;
+      }
+      if (onExitStep && await onExitStep(currentStep) === false) return;
+      if (!stillCurrent()) return;
+      if (target < 0 || target >= steps.length) {
+        ended.current = true;
+        setFinished(true);
+        if (target < 0) onCancel?.();
+        else onComplete();
+      } else {
+        if (step === void 0) {
+          setPosition({ index: target, id: steps[target].id });
+        }
+        onStepChange?.(target);
+        onEnterStep?.(target);
+      }
+    } catch (cause) {
+      if (stillCurrent()) {
+        setError(cause instanceof Error ? cause.message : String(cause));
+        onError?.(cause);
+      }
+    } finally {
+      if (mounted.current) setIsValidating(false);
+      busy.current = false;
+    }
+  };
+  const context = {
+    currentStep,
+    totalSteps: steps.length,
+    isFirst: currentStep === 0,
+    isLast: currentStep === steps.length - 1,
+    isValidating,
+    keyboardNav,
+    goNext: () => navigate("next"),
+    goBack: () => navigate("back"),
+    goTo: (index) => navigate(index),
+    cancel
+  };
+  useInput(
+    (_input, key) => {
+      if (key.return) void context.goNext();
+    },
+    // Keep the subscription mounted while a transition is validating.
+    // navigate() uses busy.current to reject overlapping Enter presses.
+    { isActive: keyboardNav && !finished && !!active }
+  );
+  if (!active || finished) return null;
+  const progress = {
+    steps: steps.map((item) => ({ id: item.id, name: item.element.props.name })),
+    currentStep,
+    ascii
+  };
+  const content = active.element.props.children;
+  return /* @__PURE__ */ jsx(StepperContext.Provider, { value: context, children: /* @__PURE__ */ jsxs(Box, { flexDirection: "column", gap: spacing.xs, children: [
+    showProgress && (renderProgress ? renderProgress(progress) : /* @__PURE__ */ jsx(StepperProgress, { ...progress })),
+    /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: typeof content === "function" ? content(context) : content }, active.id),
+    error && /* @__PURE__ */ jsx(StatusMessage, { variant: "error", children: error })
+  ] }) });
+};
+var useTabs = (items, { initial, isActive = true, arrows = true } = {}) => {
+  const [active, setActive] = useState(
+    initial ?? items[0]?.value
+  );
+  useInput(
+    (_input, key) => {
+      if (items.length === 0) return;
+      const backward = key.tab ? key.shift : arrows && key.leftArrow;
+      const forward = key.tab ? !key.shift : arrows && key.rightArrow;
+      if (!backward && !forward) return;
+      const current2 = items.findIndex((item) => item.value === active);
+      const next = (current2 + (backward ? -1 : 1) + items.length) % items.length;
+      setActive(items[next].value);
+    },
+    { isActive }
+  );
+  return { active, setActive };
+};
+var useListCursor = (length, {
+  initial = 0,
+  wrap = false,
+  vimKeys = true,
+  isActive = true
+} = {}) => {
+  const [cursor, setCursor] = useState(initial);
+  const moveCursor = (delta) => {
+    if (length === 0) return;
+    setCursor((current2) => {
+      const next = current2 + delta;
+      if (wrap) return (next + length) % length;
+      return Math.min(length - 1, Math.max(0, next));
+    });
+  };
+  useInput(
+    (input, key) => {
+      if (key.upArrow || vimKeys && input === "k") moveCursor(-1);
+      if (key.downArrow || vimKeys && input === "j") moveCursor(1);
+    },
+    { isActive }
+  );
+  return { cursor, setCursor, moveCursor };
+};
+var isItemRow = (row) => "item" in row;
+var rowsOf = (items, query) => {
+  const grouped = query.trim() === "" && items.some((item) => item.group);
+  if (!grouped) return items.map((item, index) => ({ item, index }));
+  const rows = [];
+  const seen = [];
+  for (const group of items.map((item) => item.group ?? "")) {
+    if (!seen.includes(group)) seen.push(group);
+  }
+  for (const group of seen) {
+    if (group) rows.push({ header: group });
+    items.forEach((item, index) => {
+      if ((item.group ?? "") === group) rows.push({ item, index });
+    });
+  }
+  return rows;
+};
+var DEFAULT_HINTS = [
+  ["\u2191\u2193", "move"],
+  ["\u23CE", "select"],
+  ["esc", "close"]
+];
+var spaces = (count) => " ".repeat(Math.max(0, count));
+var padEndWidth = (value, width) => value + spaces(width - stringWidth3(value));
+var CommandPalette = ({
+  items,
+  query,
+  onQueryChange,
+  onSelect,
+  onClose,
+  message,
+  emptyHint,
+  placeholder = "type to search",
+  width = 60,
+  maxRows = 10,
+  hints = DEFAULT_HINTS,
+  isActive = true
+}) => {
+  const { cursor, setCursor } = useListCursor(items.length, {
+    vimKeys: false,
+    isActive
+  });
+  useEffect(() => setCursor(0), [query, setCursor]);
+  const at = Math.min(cursor, Math.max(0, items.length - 1));
+  const rows = rowsOf(items, query);
+  const cursorRow = rows.findIndex((row) => isItemRow(row) && row.index === at);
+  const budget = Math.max(1, maxRows);
+  const start = Math.max(
+    0,
+    Math.min(cursorRow - Math.floor(budget / 2), rows.length - budget)
+  );
+  const visible = rows.slice(start, start + budget);
+  const scrolls = rows.length > budget;
+  const hasMarkers = items.some((item) => item.marker);
+  const inner = width - 2;
+  const headerTrail = (title) => Math.max(2, inner - 5 - stringWidth3(title));
+  const note = typeof message === "string" ? { text: message } : message;
+  const emptyLine = note ?? (query.trim() === "" && emptyHint ? { text: emptyHint } : void 0);
+  const errorMark = emptyLine?.tone === "error" ? statusVariant("error") : void 0;
+  const counter = `${at + 1} of ${items.length}`;
+  const hintsWidth = hints.reduce(
+    (total, [key, label]) => total + stringWidth3(key) + 1 + stringWidth3(label),
+    0
+  ) + Math.max(0, hints.length - 1) * 2;
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      flexDirection: "column",
+      borderStyle: borders.base,
+      borderColor: colors.info,
+      backgroundColor: colors.track,
+      width,
+      children: [
+        /* @__PURE__ */ jsxs(Box, { width: inner, children: [
+          /* @__PURE__ */ jsx(Text, { color: colors.info, children: " \u203A " }),
+          /* @__PURE__ */ jsx(
+            TextInput,
+            {
+              defaultValue: query,
+              placeholder,
+              onChange: onQueryChange,
+              onSubmit: () => {
+                const item = items[at];
+                if (item) onSelect(item.id);
+                else note?.onSubmit?.();
+              },
+              onCancel: onClose,
+              isDisabled: !isActive
+            }
+          ),
+          /* @__PURE__ */ jsx(Box, { flexGrow: 1, flexDirection: "column", children: /* @__PURE__ */ jsx(Text, { children: " " }) })
+        ] }),
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: " " + symbols.line.repeat(inner - 2) + " " }),
+        items.length === 0 && emptyLine?.text ? errorMark ? /* @__PURE__ */ jsx(Text, { color: errorMark.color, children: " " + padEndWidth(`${errorMark.icon} ${emptyLine.text}`, inner - 2) + " " }) : /* @__PURE__ */ jsx(Text, { dimColor: true, children: " " + padEndWidth(emptyLine.text, inner - 2) + " " }) : null,
+        visible.map((row) => {
+          if (!isItemRow(row)) {
+            const title = row.header.toUpperCase();
+            return /* @__PURE__ */ jsxs(Text, { children: [
+              " ",
+              /* @__PURE__ */ jsx(Text, { dimColor: true, children: symbols.line.repeat(2) + " " }),
+              /* @__PURE__ */ jsx(Text, { bold: true, color: colors.group, children: title }),
+              /* @__PURE__ */ jsx(Text, { dimColor: true, children: " " + symbols.line.repeat(headerTrail(title)) })
+            ] }, `header:${row.header}`);
+          }
+          const { item } = row;
+          const active = row.index === at;
+          return /* @__PURE__ */ jsxs(Box, { width: inner, children: [
+            /* @__PURE__ */ jsx(Box, { flexShrink: 0, children: /* @__PURE__ */ jsx(Text, { color: colors.info, children: active ? ` ${symbols.pointer} ` : "   " }) }),
+            hasMarkers ? /* @__PURE__ */ jsx(Box, { flexShrink: 0, children: /* @__PURE__ */ jsx(Text, { color: item.markerColor, children: (item.marker ?? " ") + " " }) }) : null,
+            /* @__PURE__ */ jsx(Box, { flexGrow: 1, flexDirection: "column", children: /* @__PURE__ */ jsxs(Text, { bold: active, children: [
+              item.label ?? item.title,
+              item.hint ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: "  " + item.hint }) : null
+            ] }) })
+          ] }, item.id);
+        }),
+        scrolls ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: " " + spaces(inner - 2 - stringWidth3(counter)) + counter + " " }) : null,
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: " " + symbols.line.repeat(inner - 2) + " " }),
+        /* @__PURE__ */ jsxs(Text, { children: [
+          " ",
+          hints.map(([key, label], index) => /* @__PURE__ */ jsxs(React8.Fragment, { children: [
+            index > 0 ? "  " : null,
+            /* @__PURE__ */ jsx(Text, { color: "white", children: key }),
+            /* @__PURE__ */ jsx(Text, { dimColor: true, children: " " + label })
+          ] }, key)),
+          spaces(inner - 1 - hintsWidth)
+        ] })
+      ]
+    }
+  );
+};
+
+// src/components/fuzzy-filter.ts
+var isSubsequence = (needle, haystack) => {
+  let at = 0;
+  for (const ch of haystack) {
+    if (ch === needle[at]) at++;
+    if (at === needle.length) return true;
+  }
+  return needle.length === 0;
+};
+var haystackOf = (item) => [item.title, item.group ?? "", item.hint ?? "", ...item.keywords ?? []].join(" ").toLowerCase();
+var fuzzyFilter = (items, query) => {
+  const q = query.trim().toLowerCase();
+  if (!q) return items;
+  const substring = [];
+  const subsequence = [];
+  for (const item of items) {
+    const hay = haystackOf(item);
+    if (hay.includes(q)) substring.push(item);
+    else if (isSubsequence(q, hay)) subsequence.push(item);
+  }
+  return [...substring, ...subsequence];
+};
+var useAppKeys = ({
+  onBack,
+  onQuit,
+  atRoot = "ignore",
+  isActive = true
+} = {}) => {
+  const { exit } = useApp();
+  const quit = onQuit ?? exit;
+  useInput(
+    (input, key) => {
+      if (input === "q") return quit();
+      if (key.escape || key.backspace || key.delete) {
+        const handled = onBack ? onBack() !== false : false;
+        if (!handled && atRoot === "quit") quit();
+      }
+    },
+    { isActive }
+  );
+};
+var useFilterMode = ({
+  isActive = true,
+  onChange
+} = {}) => {
+  const [state, setState] = useState({
+    term: null,
+    caret: 0
+  });
+  const [typing, setTyping] = useState(false);
+  const { term, caret } = state;
+  const previous = useRef(term);
+  useEffect(() => {
+    if (previous.current === term) return;
+    previous.current = term;
+    onChange?.(term);
+  }, [term, onChange]);
+  const clear = () => {
+    setState({ term: null, caret: 0 });
+    setTyping(false);
+  };
+  useInput(
+    (input, key) => {
+      if (!typing) {
+        if (input === "/") {
+          setState((s) => {
+            const next = s.term ?? "";
+            return { term: next, caret: next.length };
+          });
+          setTyping(true);
+        }
+        return;
+      }
+      if (key.upArrow || key.downArrow) return;
+      if (key.return || key.escape) {
+        setState((s) => !s.term ? { term: null, caret: 0 } : s);
+        return setTyping(false);
+      }
+      if (key.ctrl && (input === "u" || input === "U"))
+        return setState({ term: "", caret: 0 });
+      if (key.leftArrow)
+        return setState((s) => ({ ...s, caret: Math.max(0, s.caret - 1) }));
+      if (key.rightArrow)
+        return setState((s) => ({
+          ...s,
+          caret: Math.min((s.term ?? "").length, s.caret + 1)
+        }));
+      if (key.ctrl && (input === "a" || input === "A"))
+        return setState((s) => ({ ...s, caret: 0 }));
+      if (key.ctrl && (input === "e" || input === "E"))
+        return setState((s) => ({ ...s, caret: (s.term ?? "").length }));
+      if (key.backspace || key.delete)
+        return setState((s) => {
+          const current2 = s.term ?? "";
+          if (s.caret === 0) return { term: current2, caret: 0 };
+          return {
+            term: current2.slice(0, s.caret - 1) + current2.slice(s.caret),
+            caret: s.caret - 1
+          };
+        });
+      if (input && !key.ctrl && !key.meta && !key.tab)
+        return setState((s) => {
+          const current2 = s.term ?? "";
+          const at = Math.min(s.caret, current2.length);
+          return {
+            term: current2.slice(0, at) + input + current2.slice(at),
+            caret: at + input.length
+          };
+        });
+    },
+    { isActive }
+  );
+  const hints = typing ? [
+    ["\u2191\u2193", "move"],
+    ["\u21B5/esc", "done"],
+    ["\u2303u", "clear"]
+  ] : term !== null ? [
+    ["/", "edit"],
+    ["esc", "clear"]
+  ] : [["/", "filter"]];
+  return { term, typing, caret, active: term !== null, clear, hints };
+};
+var FilterBar = ({ term, typing, caret, matches }) => {
+  if (term === null) return null;
+  const at = Math.max(0, Math.min(caret ?? term.length, term.length));
+  return /* @__PURE__ */ jsxs(Box, { children: [
+    /* @__PURE__ */ jsx(Text, { color: colors.info, children: "/ " }),
+    /* @__PURE__ */ jsx(Text, { children: term.slice(0, at) }),
+    typing && at < term.length ? /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Text, { inverse: true, children: term[at] }),
+      /* @__PURE__ */ jsx(Text, { children: term.slice(at + 1) })
+    ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+      typing ? /* @__PURE__ */ jsx(Text, { color: colors.info, children: symbols.caret }) : null,
+      /* @__PURE__ */ jsx(Text, { children: term.slice(at) })
+    ] }),
+    matches === void 0 ? null : /* @__PURE__ */ jsx(
+      Text,
+      {
+        dimColor: true,
+        children: `   ${matches} match${matches !== 1 ? "es" : ""}`
+      }
+    )
+  ] });
+};
+var Switch = ({
+  left,
+  right,
+  value,
+  color = colors.accent
+}) => {
+  const leftActive = value === "left";
+  return /* @__PURE__ */ jsxs(Text, { children: [
+    /* @__PURE__ */ jsx(
+      Text,
+      {
+        color: leftActive ? color : void 0,
+        bold: leftActive,
+        dimColor: !leftActive,
+        children: left
+      }
+    ),
+    /* @__PURE__ */ jsx(Text, { children: " " }),
+    /* @__PURE__ */ jsx(Text, { color: leftActive ? color : colors.muted, children: leftActive ? symbols.active : symbols.pending }),
+    /* @__PURE__ */ jsx(Text, { color: colors.muted, children: symbols.line }),
+    /* @__PURE__ */ jsx(Text, { color: !leftActive ? color : colors.muted, children: !leftActive ? symbols.active : symbols.pending }),
+    /* @__PURE__ */ jsx(Text, { children: " " }),
+    /* @__PURE__ */ jsx(
+      Text,
+      {
+        color: !leftActive ? color : void 0,
+        bold: !leftActive,
+        dimColor: leftActive,
+        children: right
+      }
+    )
+  ] });
+};
+var Toggle = ({ label, on, color = colors.accent }) => /* @__PURE__ */ jsxs(Text, { color: on ? color : void 0, dimColor: !on, children: [
+  label,
+  " ",
+  on ? symbols.active : symbols.pending
+] });
+var CAP_LEFT = "\uE0B6";
+var CAP_RIGHT = "\uE0B4";
+var ToggleSwitch = ({
+  on,
+  label,
+  onColor = colors.success,
+  offColor = colors.muted
+}) => {
+  const track = on ? onColor : offColor;
+  return /* @__PURE__ */ jsxs(Box, { columnGap: 1, children: [
+    /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsx(Text, { color: track, children: CAP_LEFT }),
+      /* @__PURE__ */ jsx(Text, { backgroundColor: track, color: "black", children: on ? ` ${symbols.active}` : `${symbols.active} ` }),
+      /* @__PURE__ */ jsx(Text, { color: track, children: CAP_RIGHT })
+    ] }),
+    label !== void 0 && /* @__PURE__ */ jsx(Text, { color: on ? onColor : void 0, dimColor: !on, children: label })
+  ] });
+};
+var UpdateBanner = ({
+  name,
+  current: current2,
+  latest,
+  command,
+  onConfirm,
+  onDecline,
+  focused = true
+}) => {
+  useInput(
+    (input, key) => {
+      if (key.return || /^y$/i.test(input)) onConfirm();
+      else if (key.escape || /^n$/i.test(input)) onDecline();
+    },
+    { isActive: focused }
+  );
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      flexDirection: "column",
+      borderStyle: borders.base,
+      borderColor: colors.accent,
+      paddingX: spacing.sm,
+      paddingY: spacing.xs,
+      rowGap: spacing.xs,
+      children: [
+        /* @__PURE__ */ jsxs(Box, { columnGap: 1, children: [
+          /* @__PURE__ */ jsx(Text, { bold: true, color: colors.accent, children: name }),
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\xB7" }),
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: "update available" })
+        ] }),
+        /* @__PURE__ */ jsxs(Box, { columnGap: 1, children: [
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: current2 }),
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2192" }),
+          /* @__PURE__ */ jsx(Text, { bold: true, color: colors.success, children: latest })
+        ] }),
+        /* @__PURE__ */ jsxs(Box, { columnGap: 1, children: [
+          /* @__PURE__ */ jsx(Text, { backgroundColor: colors.accent, color: "black", bold: true, children: " Y " }),
+          /* @__PURE__ */ jsx(Text, { children: "upgrade now" }),
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\xB7" }),
+          /* @__PURE__ */ jsx(Text, { backgroundColor: colors.track, color: "#8fa3ad", children: " N " }),
+          /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+            "later \u2014 run ",
+            command,
+            " yourself"
+          ] })
+        ] })
+      ]
+    }
+  );
+};
+var ProgressBar = ({
+  value,
+  width = 20,
+  color = colors.accent,
+  trackColor = colors.track
+}) => {
+  const clamped = Math.max(0, Math.min(100, value));
+  const filled = Math.round(clamped / 100 * width);
+  return /* @__PURE__ */ jsxs(Text, { children: [
+    /* @__PURE__ */ jsx(Text, { color, children: symbols.barFull.repeat(filled) }),
+    /* @__PURE__ */ jsx(Text, { color: trackColor, children: symbols.barFull.repeat(width - filled) })
+  ] });
+};
+var SHIMMER_FRAME_MS = motion.skeletonIntervalMs;
+var CREST_HALF = 3;
+var FALLOFF = 2;
+var LEAD = CREST_HALF + FALLOFF + 1;
+var PAUSE_FRAMES = 10;
+var ROW_LAG = 2;
+var toRgb = (hex) => [
+  parseInt(hex.slice(1, 3), 16),
+  parseInt(hex.slice(3, 5), 16),
+  parseInt(hex.slice(5, 7), 16)
+];
+var blendHex = (from, to, t) => {
+  const [r1, g1, b1] = toRgb(from);
+  const [r2, g2, b2] = toRgb(to);
+  const mix = (a, b) => Math.round(a + (b - a) * t);
+  const hex = (n) => n.toString(16).padStart(2, "0");
+  return `#${hex(mix(r1, r2))}${hex(mix(g1, g2))}${hex(mix(b1, b2))}`;
+};
+var skeletonCellColor = (cell, frame, width, rowOffset = 0) => {
+  const cells = Math.max(0, Math.floor(width));
+  const travel = cells + LEAD * 2;
+  const cycle = travel + PAUSE_FRAMES;
+  const phase = ((frame - rowOffset) % cycle + cycle) % cycle;
+  if (phase >= travel) return colors.track;
+  const distance = Math.abs(cell - (phase - LEAD));
+  if (distance <= CREST_HALF) return colors.trackHighlight;
+  if (distance <= CREST_HALF + FALLOFF)
+    return blendHex(
+      colors.track,
+      colors.trackHighlight,
+      (CREST_HALF + FALLOFF + 1 - distance) / (FALLOFF + 1)
+    );
+  return colors.track;
+};
+var skeletonMotionEnabled = (animate) => {
+  if (!animate) return false;
+  if (process.env["NO_MOTION"] || process.env["REDUCE_MOTION"]) return false;
+  return process.stdout?.isTTY === true;
+};
+var SkeletonBar = ({
+  width,
+  animate = true,
+  frame,
+  rowOffset = 0
+}) => {
+  const cells = Math.max(0, Math.floor(width));
+  const controlled = frame !== void 0;
+  const active = !controlled && skeletonMotionEnabled(animate);
+  const [ownFrame, setOwnFrame] = useState(0);
+  useEffect(() => {
+    if (!active) return;
+    const timer = setInterval(
+      () => setOwnFrame((f) => f + 1),
+      SHIMMER_FRAME_MS
+    );
+    return () => clearInterval(timer);
+  }, [active]);
+  if (!controlled && !active)
+    return /* @__PURE__ */ jsx(Text, { color: colors.track, children: symbols.barFull.repeat(cells) });
+  const at = controlled ? frame : ownFrame;
+  return /* @__PURE__ */ jsx(Text, { children: Array.from({ length: cells }, (_, i) => /* @__PURE__ */ jsx(Text, { color: skeletonCellColor(i, at, cells, rowOffset), children: symbols.barFull }, i)) });
+};
+var SkeletonRows = ({
+  rows,
+  widths,
+  gapEvery,
+  indent = 0,
+  width,
+  animate = true
+}) => {
+  const ref = useRef(null);
+  const [measured, setMeasured] = useState(0);
+  useWindowSize();
+  useLayoutEffect(() => {
+    if (width !== void 0 || !ref.current) return;
+    const { width: w } = measureElement(ref.current);
+    if (w !== measured) setMeasured(w);
+  });
+  const active = skeletonMotionEnabled(animate);
+  const [frame, setFrame] = useState(0);
+  useEffect(() => {
+    if (!active) return;
+    const timer = setInterval(() => setFrame((f) => f + 1), SHIMMER_FRAME_MS);
+    return () => clearInterval(timer);
+  }, [active]);
+  const available = Math.max(0, (width ?? measured) - indent);
+  const lines = [];
+  for (let i = 0; i < rows; i++) {
+    const fraction = widths.length ? widths[i % widths.length] : 1;
+    lines.push(Math.round(Math.max(0, Math.min(1, fraction)) * available));
+    const closesGroup = gapEvery !== void 0 && gapEvery > 0 && (i + 1) % gapEvery === 0;
+    if (closesGroup && i < rows - 1) lines.push(null);
+  }
+  let bar = 0;
+  return /* @__PURE__ */ jsx(Box, { ref, flexDirection: "column", children: lines.map((cells, i) => {
+    if (cells === null)
+      return /* @__PURE__ */ jsx(Text, { children: " " }, i);
+    const rowOffset = bar++ * ROW_LAG;
+    return /* @__PURE__ */ jsxs(Text, { children: [
+      " ".repeat(indent),
+      /* @__PURE__ */ jsx(
+        SkeletonBar,
+        {
+          width: cells,
+          animate,
+          frame: active ? frame : void 0,
+          rowOffset
+        }
+      )
+    ] }, i);
+  }) });
+};
+var Alert = ({ variant = "info", title, children }) => {
+  const { icon, color } = statusVariant(variant);
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      borderStyle: borders.base,
+      borderColor: color,
+      paddingX: spacing.xs,
+      flexDirection: "column",
+      children: [
+        /* @__PURE__ */ jsxs(Box, { gap: spacing.xs, children: [
+          /* @__PURE__ */ jsx(Text, { color, children: icon }),
+          title ? /* @__PURE__ */ jsx(Text, { bold: true, color, children: title }) : null
+        ] }),
+        /* @__PURE__ */ jsx(Text, { children })
+      ]
+    }
+  );
+};
+var Toast = ({
+  message,
+  variant = "info",
+  duration = 2e3,
+  onDone
+}) => {
+  const [visible, setVisible] = useState(true);
+  useEffect(() => {
+    const timer = setTimeout(() => {
+      setVisible(false);
+      onDone?.();
+    }, duration);
+    return () => clearTimeout(timer);
+  }, [duration]);
+  if (!visible) return null;
+  const { icon, color } = statusVariant(variant);
+  return /* @__PURE__ */ jsxs(Box, { gap: 1, children: [
+    /* @__PURE__ */ jsx(Text, { color, children: icon }),
+    /* @__PURE__ */ jsx(Text, { children: message })
+  ] });
+};
+var escape = (value) => value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+var buildAppleScript = (message, options = {}) => {
+  const clauses = [
+    options.title && `title "${escape(options.title)}"`,
+    options.subtitle && `subtitle "${escape(options.subtitle)}"`,
+    options.sound && `sound name "${escape(typeof options.sound === "string" ? options.sound : "default")}"`
+  ].filter(Boolean);
+  const suffix = clauses.length > 0 ? ` with ${clauses.join(" ")}` : "";
+  return `display notification "${escape(message)}"${suffix}`;
+};
+var notify = (message, options = {}) => {
+  if (process.platform !== "darwin") return;
+  const child = spawn("osascript", ["-e", buildAppleScript(message, options)], {
+    stdio: "ignore"
+  });
+  child.on("error", () => {
+  });
+  child.unref();
+};
+
+export { Alert, Badge, Banner, Columns, CommandPalette, ConfirmInput, EmailInput, FilterBar, FooterHints, Header, KeyValue, LoadingScreen, MultiSelect, OrderedList, PAGE_CHROME, Page, Panel, PasswordInput, Pill, ProgressBar, ScrollView, Select, SelectableRow, SkeletonBar, SkeletonRows, Spinner, StatusMessage, Step, Stepper, StepperNavigation, StepperProgress, Switch, Table, Tabs, TextInput, Toast, Toggle, ToggleSwitch, UnorderedList, UpdateBanner, asciiSymbols, borders, colors, fuzzyFilter, getIconMode, motion, notify, palette, pillWidth, priorityColors, setIconMode, softColors, spacing, symbols, tailHints, tonalColors, tonalStrongColors, useAppKeys, useFilterMode, useListCursor, useStepper, useTabs };