@dexto/tui 1.14.6 → 1.15.0-beta.1

package/dist/signal/background.test.cjs

@@ -0,0 +1,186 @@
+"use strict";
+var import_node_stream = require("node:stream");
+var import_vitest = require("vitest");
+var import_caps = require("./caps.js");
+var import_background = require("./background.js");
+const caps = {
+  tty: true,
+  color: "truecolor",
+  glyphs: "unicode",
+  logo: "quadrant",
+  theme: "dark",
+  motion: "full",
+  palette: "signal"
+};
+const DA1 = "\x1B[?62;22c";
+(0, import_vitest.describe)("parseBackgroundReply", () => {
+  (0, import_vitest.it)("reads a dark and a light background, with either terminator", () => {
+    (0, import_vitest.expect)((0, import_background.parseBackgroundReply)("\x1B]11;rgb:1e1e/1e1e/1e1e\x07")).toBe("dark");
+    (0, import_vitest.expect)((0, import_background.parseBackgroundReply)("\x1B]11;rgb:ffff/ffff/ffff\x1B\\")).toBe("light");
+  });
+  (0, import_vitest.it)("accepts one to four hex digits per channel, and rgba", () => {
+    (0, import_vitest.expect)((0, import_background.parseBackgroundReply)("\x1B]11;rgb:f/f/f\x07")).toBe("light");
+    (0, import_vitest.expect)((0, import_background.parseBackgroundReply)("\x1B]11;rgb:fd/f6/e3\x07")).toBe("light");
+    (0, import_vitest.expect)((0, import_background.parseBackgroundReply)("\x1B]11;rgba:0000/2b2b/3636/ffff\x07")).toBe("dark");
+  });
+  (0, import_vitest.it)("weighs green over blue, as the eye does", () => {
+    (0, import_vitest.expect)((0, import_background.parseBackgroundReply)("\x1B]11;rgb:0000/c0c0/0000\x07")).toBe("light");
+    (0, import_vitest.expect)((0, import_background.parseBackgroundReply)("\x1B]11;rgb:0000/0000/ffff\x07")).toBe("dark");
+  });
+  (0, import_vitest.it)("finds the reply among other bytes, and returns null when there is none", () => {
+    (0, import_vitest.expect)((0, import_background.parseBackgroundReply)(`junk\x1B]11;rgb:ffff/ffff/ffff\x07${DA1}`)).toBe("light");
+    (0, import_vitest.expect)((0, import_background.parseBackgroundReply)(DA1)).toBeNull();
+    (0, import_vitest.expect)((0, import_background.parseBackgroundReply)("\x1B]11;rgb:zz/00/00\x07")).toBeNull();
+  });
+});
+(0, import_vitest.describe)("shouldQueryBackground", () => {
+  (0, import_vitest.it)("asks only when the Signal palette will use the answer on a colour TTY", () => {
+    (0, import_vitest.expect)((0, import_background.shouldQueryBackground)(caps, true)).toBe(true);
+    (0, import_vitest.expect)((0, import_background.shouldQueryBackground)({ ...caps, palette: "legacy" }, true)).toBe(false);
+    (0, import_vitest.expect)((0, import_background.shouldQueryBackground)({ ...caps, color: "none" }, true)).toBe(false);
+    (0, import_vitest.expect)((0, import_background.shouldQueryBackground)({ ...caps, tty: false }, true)).toBe(false);
+    (0, import_vitest.expect)((0, import_background.shouldQueryBackground)(caps, false)).toBe(false);
+  });
+});
+function fakeTerminal(reply) {
+  const stdin = Object.assign(new import_node_stream.PassThrough(), {
+    isTTY: true,
+    isRaw: false,
+    setRawMode: import_vitest.vi.fn(function(mode) {
+      this.isRaw = mode;
+      return this;
+    })
+  });
+  const written = [];
+  const stdout = {
+    write: (chunk) => {
+      written.push(chunk);
+      const answer = reply?.(chunk) ?? null;
+      if (answer !== null) setTimeout(() => stdin.write(answer), 0);
+      return true;
+    }
+  };
+  const io = { stdin, stdout };
+  return { io, stdin, written };
+}
+(0, import_vitest.describe)("queryBackgroundTheme", () => {
+  (0, import_vitest.it)("sends OSC 11 then DA1, and reads the theme from the reply", async () => {
+    const { io, written } = fakeTerminal(() => `\x1B]11;rgb:ffff/ffff/ffff\x07${DA1}`);
+    await (0, import_vitest.expect)((0, import_background.queryBackgroundTheme)(io, 500)).resolves.toBe("light");
+    (0, import_vitest.expect)(written).toEqual([import_background.BACKGROUND_QUERY]);
+  });
+  (0, import_vitest.it)("stops at the DA1 reply when the terminal does not answer OSC 11", async () => {
+    const { io } = fakeTerminal(() => DA1);
+    const started = Date.now();
+    await (0, import_vitest.expect)((0, import_background.queryBackgroundTheme)(io, 5e3)).resolves.toBeNull();
+    (0, import_vitest.expect)(Date.now() - started).toBeLessThan(1e3);
+  });
+  (0, import_vitest.it)("gives up after the timeout when nothing answers", async () => {
+    const { io } = fakeTerminal(null);
+    await (0, import_vitest.expect)((0, import_background.queryBackgroundTheme)(io, 20)).resolves.toBeNull();
+  });
+  (0, import_vitest.it)("handles a reply split across chunks", async () => {
+    const { io, stdin } = fakeTerminal(() => null);
+    const pending = (0, import_background.queryBackgroundTheme)(io, 500);
+    stdin.write("\x1B]11;rgb:00");
+    stdin.write(`00/0000/0000\x07${DA1}`);
+    await (0, import_vitest.expect)(pending).resolves.toBe("dark");
+  });
+  (0, import_vitest.it)("puts stdin back as it found it", async () => {
+    const { io, stdin } = fakeTerminal(() => DA1);
+    await (0, import_background.queryBackgroundTheme)(io, 500);
+    (0, import_vitest.expect)(stdin.setRawMode).toHaveBeenLastCalledWith(false);
+    (0, import_vitest.expect)(stdin.isRaw).toBe(false);
+    (0, import_vitest.expect)(stdin.listenerCount("data")).toBe(0);
+    (0, import_vitest.expect)(stdin.isPaused()).toBe(true);
+  });
+});
+(0, import_vitest.describe)("detectBackgroundTheme", () => {
+  (0, import_vitest.it)("updates the caps theme from the reply on the Signal palette", async () => {
+    const saved = (0, import_caps.getCaps)();
+    (0, import_caps.setCaps)({ ...caps, theme: "dark" });
+    try {
+      const { io } = fakeTerminal(() => `\x1B]11;rgb:ffff/ffff/ffff\x07${DA1}`);
+      await (0, import_background.detectBackgroundTheme)(io);
+      (0, import_vitest.expect)((0, import_caps.getCaps)().theme).toBe("light");
+    } finally {
+      (0, import_caps.setCaps)(saved);
+    }
+  });
+  (0, import_vitest.it)("sends nothing on the legacy palette", async () => {
+    const saved = (0, import_caps.getCaps)();
+    (0, import_caps.setCaps)({ ...caps, palette: "legacy" });
+    try {
+      const { io, written } = fakeTerminal(() => DA1);
+      await (0, import_background.detectBackgroundTheme)(io);
+      (0, import_vitest.expect)(written).toEqual([]);
+    } finally {
+      (0, import_caps.setCaps)(saved);
+    }
+  });
+});
+(0, import_vitest.describe)("queryBackgroundTheme keeps what the user typed", () => {
+  (0, import_vitest.it)("hands bytes that are not part of the reply back to stdin", async () => {
+    const { io, stdin } = fakeTerminal(
+      () => `\x1B]11;rgb:ffff/ffff/ffff\x07summarize this\r${DA1}`
+    );
+    await (0, import_vitest.expect)((0, import_background.queryBackgroundTheme)(io, 500)).resolves.toBe("light");
+    (0, import_vitest.expect)(String(stdin.read())).toBe("summarize this\r");
+  });
+  (0, import_vitest.it)("hands back nothing when only the replies arrived", async () => {
+    const { io, stdin } = fakeTerminal(() => `\x1B]11;rgb:ffff/ffff/ffff\x07${DA1}`);
+    await (0, import_background.queryBackgroundTheme)(io, 500);
+    (0, import_vitest.expect)(stdin.read()).toBeNull();
+  });
+});
+(0, import_vitest.describe)("createTerminalReplyFilter", () => {
+  const OSC = "\x1B]11;rgb:ffff/ffff/ffff";
+  (0, import_vitest.it)("drops background and DA1 replies, with either terminator", () => {
+    const filter = (0, import_background.createTerminalReplyFilter)();
+    (0, import_vitest.expect)(filter(`${OSC}\x07`)).toBe("");
+    (0, import_vitest.expect)(filter(`${OSC}\x1B\\`)).toBe("");
+    (0, import_vitest.expect)(filter(DA1)).toBe("");
+    (0, import_vitest.expect)(filter("\x1B]10;rgb:0/0/0\x07")).toBe("");
+  });
+  (0, import_vitest.it)("keeps the keys around a reply", () => {
+    const filter = (0, import_background.createTerminalReplyFilter)();
+    (0, import_vitest.expect)(filter(`ab${OSC}\x07cd${DA1}e`)).toBe("abcde");
+  });
+  (0, import_vitest.it)("drops a reply split across chunks", () => {
+    const filter = (0, import_background.createTerminalReplyFilter)();
+    (0, import_vitest.expect)(filter("x\x1B]11;rgb:ff")).toBe("x");
+    (0, import_vitest.expect)(filter("ff/ffff/ffff\x07y\x1B[?6")).toBe("y");
+    (0, import_vitest.expect)(filter("2;22cz")).toBe("z");
+  });
+  (0, import_vitest.it)("passes keyboard escapes through untouched", () => {
+    const filter = (0, import_background.createTerminalReplyFilter)();
+    (0, import_vitest.expect)(filter("\x1B")).toBe("\x1B");
+    (0, import_vitest.expect)(filter("\x1B]")).toBe("\x1B]");
+    (0, import_vitest.expect)(filter("\x1B[")).toBe("\x1B[");
+    (0, import_vitest.expect)(filter("\x1B[A\x1B[1;5C\x1B[<0;10;5M")).toBe("\x1B[A\x1B[1;5C\x1B[<0;10;5M");
+    (0, import_vitest.expect)(filter("\x1B]a")).toBe("\x1B]a");
+  });
+  (0, import_vitest.it)("releases held bytes that turn out not to be a reply", () => {
+    const filter = (0, import_background.createTerminalReplyFilter)();
+    (0, import_vitest.expect)(filter("\x1B]11;rgb")).toBe("");
+    (0, import_vitest.expect)(filter(" hello")).toBe("\x1B]11;rgb hello");
+  });
+});
+(0, import_vitest.describe)("queryBackgroundTheme hands back unfinished input as raw bytes", () => {
+  (0, import_vitest.it)("returns a reply cut off by the timeout, so the keypress filter can finish dropping it", async () => {
+    const { io, stdin } = fakeTerminal(() => "\x1B]11;rgb:ff");
+    await (0, import_vitest.expect)((0, import_background.queryBackgroundTheme)(io, 50)).resolves.toBeNull();
+    const handedBack = String(stdin.read());
+    (0, import_vitest.expect)(handedBack).toBe("\x1B]11;rgb:ff");
+    const filter = (0, import_background.createTerminalReplyFilter)();
+    (0, import_vitest.expect)(filter(handedBack) + filter("ff/ffff/ffff\x07a")).toBe("a");
+  });
+  (0, import_vitest.it)("returns a UTF-8 character cut off by the timeout unchanged", async () => {
+    const { io, stdin } = fakeTerminal(() => null);
+    const pending = (0, import_background.queryBackgroundTheme)(io, 50);
+    stdin.write(Buffer.from([104, 226]));
+    await (0, import_vitest.expect)(pending).resolves.toBeNull();
+    const handedBack = stdin.read();
+    (0, import_vitest.expect)(Buffer.concat([handedBack, Buffer.from([130, 172])]).toString("utf8")).toBe("h\u20AC");
+  });
+});

package/dist/signal/background.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=background.test.d.ts.map

package/dist/signal/background.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"background.test.d.ts","sourceRoot":"","sources":["../../src/signal/background.test.ts"],"names":[],"mappings":""}

package/dist/signal/background.test.js

@@ -0,0 +1,192 @@
+import { PassThrough } from "node:stream";
+import { describe, expect, it, vi } from "vitest";
+import { getCaps, setCaps } from "./caps.js";
+import {
+  BACKGROUND_QUERY,
+  createTerminalReplyFilter,
+  detectBackgroundTheme,
+  parseBackgroundReply,
+  queryBackgroundTheme,
+  shouldQueryBackground
+} from "./background.js";
+const caps = {
+  tty: true,
+  color: "truecolor",
+  glyphs: "unicode",
+  logo: "quadrant",
+  theme: "dark",
+  motion: "full",
+  palette: "signal"
+};
+const DA1 = "\x1B[?62;22c";
+describe("parseBackgroundReply", () => {
+  it("reads a dark and a light background, with either terminator", () => {
+    expect(parseBackgroundReply("\x1B]11;rgb:1e1e/1e1e/1e1e\x07")).toBe("dark");
+    expect(parseBackgroundReply("\x1B]11;rgb:ffff/ffff/ffff\x1B\\")).toBe("light");
+  });
+  it("accepts one to four hex digits per channel, and rgba", () => {
+    expect(parseBackgroundReply("\x1B]11;rgb:f/f/f\x07")).toBe("light");
+    expect(parseBackgroundReply("\x1B]11;rgb:fd/f6/e3\x07")).toBe("light");
+    expect(parseBackgroundReply("\x1B]11;rgba:0000/2b2b/3636/ffff\x07")).toBe("dark");
+  });
+  it("weighs green over blue, as the eye does", () => {
+    expect(parseBackgroundReply("\x1B]11;rgb:0000/c0c0/0000\x07")).toBe("light");
+    expect(parseBackgroundReply("\x1B]11;rgb:0000/0000/ffff\x07")).toBe("dark");
+  });
+  it("finds the reply among other bytes, and returns null when there is none", () => {
+    expect(parseBackgroundReply(`junk\x1B]11;rgb:ffff/ffff/ffff\x07${DA1}`)).toBe("light");
+    expect(parseBackgroundReply(DA1)).toBeNull();
+    expect(parseBackgroundReply("\x1B]11;rgb:zz/00/00\x07")).toBeNull();
+  });
+});
+describe("shouldQueryBackground", () => {
+  it("asks only when the Signal palette will use the answer on a colour TTY", () => {
+    expect(shouldQueryBackground(caps, true)).toBe(true);
+    expect(shouldQueryBackground({ ...caps, palette: "legacy" }, true)).toBe(false);
+    expect(shouldQueryBackground({ ...caps, color: "none" }, true)).toBe(false);
+    expect(shouldQueryBackground({ ...caps, tty: false }, true)).toBe(false);
+    expect(shouldQueryBackground(caps, false)).toBe(false);
+  });
+});
+function fakeTerminal(reply) {
+  const stdin = Object.assign(new PassThrough(), {
+    isTTY: true,
+    isRaw: false,
+    setRawMode: vi.fn(function(mode) {
+      this.isRaw = mode;
+      return this;
+    })
+  });
+  const written = [];
+  const stdout = {
+    write: (chunk) => {
+      written.push(chunk);
+      const answer = reply?.(chunk) ?? null;
+      if (answer !== null) setTimeout(() => stdin.write(answer), 0);
+      return true;
+    }
+  };
+  const io = { stdin, stdout };
+  return { io, stdin, written };
+}
+describe("queryBackgroundTheme", () => {
+  it("sends OSC 11 then DA1, and reads the theme from the reply", async () => {
+    const { io, written } = fakeTerminal(() => `\x1B]11;rgb:ffff/ffff/ffff\x07${DA1}`);
+    await expect(queryBackgroundTheme(io, 500)).resolves.toBe("light");
+    expect(written).toEqual([BACKGROUND_QUERY]);
+  });
+  it("stops at the DA1 reply when the terminal does not answer OSC 11", async () => {
+    const { io } = fakeTerminal(() => DA1);
+    const started = Date.now();
+    await expect(queryBackgroundTheme(io, 5e3)).resolves.toBeNull();
+    expect(Date.now() - started).toBeLessThan(1e3);
+  });
+  it("gives up after the timeout when nothing answers", async () => {
+    const { io } = fakeTerminal(null);
+    await expect(queryBackgroundTheme(io, 20)).resolves.toBeNull();
+  });
+  it("handles a reply split across chunks", async () => {
+    const { io, stdin } = fakeTerminal(() => null);
+    const pending = queryBackgroundTheme(io, 500);
+    stdin.write("\x1B]11;rgb:00");
+    stdin.write(`00/0000/0000\x07${DA1}`);
+    await expect(pending).resolves.toBe("dark");
+  });
+  it("puts stdin back as it found it", async () => {
+    const { io, stdin } = fakeTerminal(() => DA1);
+    await queryBackgroundTheme(io, 500);
+    expect(stdin.setRawMode).toHaveBeenLastCalledWith(false);
+    expect(stdin.isRaw).toBe(false);
+    expect(stdin.listenerCount("data")).toBe(0);
+    expect(stdin.isPaused()).toBe(true);
+  });
+});
+describe("detectBackgroundTheme", () => {
+  it("updates the caps theme from the reply on the Signal palette", async () => {
+    const saved = getCaps();
+    setCaps({ ...caps, theme: "dark" });
+    try {
+      const { io } = fakeTerminal(() => `\x1B]11;rgb:ffff/ffff/ffff\x07${DA1}`);
+      await detectBackgroundTheme(io);
+      expect(getCaps().theme).toBe("light");
+    } finally {
+      setCaps(saved);
+    }
+  });
+  it("sends nothing on the legacy palette", async () => {
+    const saved = getCaps();
+    setCaps({ ...caps, palette: "legacy" });
+    try {
+      const { io, written } = fakeTerminal(() => DA1);
+      await detectBackgroundTheme(io);
+      expect(written).toEqual([]);
+    } finally {
+      setCaps(saved);
+    }
+  });
+});
+describe("queryBackgroundTheme keeps what the user typed", () => {
+  it("hands bytes that are not part of the reply back to stdin", async () => {
+    const { io, stdin } = fakeTerminal(
+      () => `\x1B]11;rgb:ffff/ffff/ffff\x07summarize this\r${DA1}`
+    );
+    await expect(queryBackgroundTheme(io, 500)).resolves.toBe("light");
+    expect(String(stdin.read())).toBe("summarize this\r");
+  });
+  it("hands back nothing when only the replies arrived", async () => {
+    const { io, stdin } = fakeTerminal(() => `\x1B]11;rgb:ffff/ffff/ffff\x07${DA1}`);
+    await queryBackgroundTheme(io, 500);
+    expect(stdin.read()).toBeNull();
+  });
+});
+describe("createTerminalReplyFilter", () => {
+  const OSC = "\x1B]11;rgb:ffff/ffff/ffff";
+  it("drops background and DA1 replies, with either terminator", () => {
+    const filter = createTerminalReplyFilter();
+    expect(filter(`${OSC}\x07`)).toBe("");
+    expect(filter(`${OSC}\x1B\\`)).toBe("");
+    expect(filter(DA1)).toBe("");
+    expect(filter("\x1B]10;rgb:0/0/0\x07")).toBe("");
+  });
+  it("keeps the keys around a reply", () => {
+    const filter = createTerminalReplyFilter();
+    expect(filter(`ab${OSC}\x07cd${DA1}e`)).toBe("abcde");
+  });
+  it("drops a reply split across chunks", () => {
+    const filter = createTerminalReplyFilter();
+    expect(filter("x\x1B]11;rgb:ff")).toBe("x");
+    expect(filter("ff/ffff/ffff\x07y\x1B[?6")).toBe("y");
+    expect(filter("2;22cz")).toBe("z");
+  });
+  it("passes keyboard escapes through untouched", () => {
+    const filter = createTerminalReplyFilter();
+    expect(filter("\x1B")).toBe("\x1B");
+    expect(filter("\x1B]")).toBe("\x1B]");
+    expect(filter("\x1B[")).toBe("\x1B[");
+    expect(filter("\x1B[A\x1B[1;5C\x1B[<0;10;5M")).toBe("\x1B[A\x1B[1;5C\x1B[<0;10;5M");
+    expect(filter("\x1B]a")).toBe("\x1B]a");
+  });
+  it("releases held bytes that turn out not to be a reply", () => {
+    const filter = createTerminalReplyFilter();
+    expect(filter("\x1B]11;rgb")).toBe("");
+    expect(filter(" hello")).toBe("\x1B]11;rgb hello");
+  });
+});
+describe("queryBackgroundTheme hands back unfinished input as raw bytes", () => {
+  it("returns a reply cut off by the timeout, so the keypress filter can finish dropping it", async () => {
+    const { io, stdin } = fakeTerminal(() => "\x1B]11;rgb:ff");
+    await expect(queryBackgroundTheme(io, 50)).resolves.toBeNull();
+    const handedBack = String(stdin.read());
+    expect(handedBack).toBe("\x1B]11;rgb:ff");
+    const filter = createTerminalReplyFilter();
+    expect(filter(handedBack) + filter("ff/ffff/ffff\x07a")).toBe("a");
+  });
+  it("returns a UTF-8 character cut off by the timeout unchanged", async () => {
+    const { io, stdin } = fakeTerminal(() => null);
+    const pending = queryBackgroundTheme(io, 50);
+    stdin.write(Buffer.from([104, 226]));
+    await expect(pending).resolves.toBeNull();
+    const handedBack = stdin.read();
+    expect(Buffer.concat([handedBack, Buffer.from([130, 172])]).toString("utf8")).toBe("h\u20AC");
+  });
+});

package/dist/signal/caps.cjs

@@ -0,0 +1,100 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var caps_exports = {};
+__export(caps_exports, {
+  detectCaps: () => detectCaps,
+  getCaps: () => getCaps,
+  setCaps: () => setCaps,
+  useCaps: () => useCaps
+});
+module.exports = __toCommonJS(caps_exports);
+var import_react = require("react");
+const SEXTANT_TERMS = /* @__PURE__ */ new Set([
+  "ghostty",
+  "WezTerm",
+  "vscode",
+  "kitty",
+  "foot",
+  "WindowsTerminal",
+  "rio"
+]);
+function detectColor(env, tty) {
+  if (env.NO_COLOR !== void 0 && env.NO_COLOR !== "") return "none";
+  if (!tty) return "none";
+  if (/^(truecolor|24bit)$/i.test(env.COLORTERM ?? "")) return "truecolor";
+  if (/256color/.test(env.TERM ?? "")) return "256";
+  if (env.TERM === "dumb") return "none";
+  return "16";
+}
+function terminalProgram(env) {
+  if (env.TERM_PROGRAM) return env.TERM_PROGRAM;
+  if (env.TERM === "xterm-kitty") return "kitty";
+  if (env.WT_SESSION) return "WindowsTerminal";
+  return "";
+}
+function isLightIndex(index) {
+  if (index < 16) return index === 7 || index >= 9;
+  if (index >= 232) return 8 + (index - 232) * 10 >= 128;
+  const level = (n) => n === 0 ? 0 : 55 + n * 40;
+  const i = index - 16;
+  const [r, g, b] = [level(Math.floor(i / 36)), level(Math.floor(i / 6) % 6), level(i % 6)];
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b >= 128;
+}
+function themeFromColorFgBg(value) {
+  const bg = Number(value?.split(";").pop());
+  return Number.isInteger(bg) && bg >= 0 && bg <= 255 && isLightIndex(bg) ? "light" : "dark";
+}
+function detectCaps(env, isTTY) {
+  const locale = env.LC_ALL || env.LC_CTYPE || env.LANG || "en_US.UTF-8";
+  return {
+    tty: isTTY,
+    color: detectColor(env, isTTY),
+    glyphs: /utf-?8/i.test(locale) ? "unicode" : "ascii",
+    logo: env.DEXTO_LOGO === "sextant" && SEXTANT_TERMS.has(terminalProgram(env)) ? "sextant" : "quadrant",
+    theme: themeFromColorFgBg(env.COLORFGBG),
+    motion: env.DEXTO_MOTION === "reduced" ? "reduced" : "full",
+    palette: env.DEXTO_PALETTE === "signal" ? "signal" : "legacy"
+  };
+}
+let current = null;
+const listeners = /* @__PURE__ */ new Set();
+function getCaps() {
+  if (current === null) current = detectCaps(process.env, process.stdout.isTTY === true);
+  return current;
+}
+function setCaps(next) {
+  current = next;
+  for (const listener of listeners) listener();
+}
+function subscribe(listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+function useCaps() {
+  return (0, import_react.useSyncExternalStore)(subscribe, getCaps, getCaps);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  detectCaps,
+  getCaps,
+  setCaps,
+  useCaps
+});

package/dist/signal/caps.d.ts

@@ -0,0 +1,23 @@
+export type ColorTier = 'truecolor' | '256' | '16' | 'none';
+export type GlyphTier = 'unicode' | 'ascii';
+export type LogoTier = 'sextant' | 'quadrant';
+export type ThemeName = 'dark' | 'light';
+export type Motion = 'full' | 'reduced';
+export type Palette = 'legacy' | 'signal';
+export interface Caps {
+    tty: boolean;
+    color: ColorTier;
+    glyphs: GlyphTier;
+    logo: LogoTier;
+    theme: ThemeName;
+    motion: Motion;
+    palette: Palette;
+}
+type Env = Readonly<Record<string, string | undefined>>;
+export declare function detectCaps(env: Env, isTTY: boolean): Caps;
+export declare function getCaps(): Caps;
+/** Replace the process-wide caps (OSC 11 result, user override, tests). */
+export declare function setCaps(next: Caps): void;
+export declare function useCaps(): Caps;
+export {};
+//# sourceMappingURL=caps.d.ts.map

package/dist/signal/caps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"caps.d.ts","sourceRoot":"","sources":["../../src/signal/caps.ts"],"names":[],"mappings":"AAkBA,MAAM,MAAM,SAAS,GAAG,WAAW,GAAG,KAAK,GAAG,IAAI,GAAG,MAAM,CAAC;AAC5D,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,OAAO,CAAC;AAC5C,MAAM,MAAM,QAAQ,GAAG,SAAS,GAAG,UAAU,CAAC;AAC9C,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,OAAO,CAAC;AACzC,MAAM,MAAM,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;AACxC,MAAM,MAAM,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAE1C,MAAM,WAAW,IAAI;IACjB,GAAG,EAAE,OAAO,CAAC;IACb,KAAK,EAAE,SAAS,CAAC;IACjB,MAAM,EAAE,SAAS,CAAC;IAClB,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,SAAS,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;CACpB;AAED,KAAK,GAAG,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC;AA+CxD,wBAAgB,UAAU,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAczD;AAKD,wBAAgB,OAAO,IAAI,IAAI,CAG9B;AAED,2EAA2E;AAC3E,wBAAgB,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAGxC;AASD,wBAAgB,OAAO,IAAI,IAAI,CAE9B"}

package/dist/signal/caps.js

@@ -0,0 +1,73 @@
+import { useSyncExternalStore } from "react";
+const SEXTANT_TERMS = /* @__PURE__ */ new Set([
+  "ghostty",
+  "WezTerm",
+  "vscode",
+  "kitty",
+  "foot",
+  "WindowsTerminal",
+  "rio"
+]);
+function detectColor(env, tty) {
+  if (env.NO_COLOR !== void 0 && env.NO_COLOR !== "") return "none";
+  if (!tty) return "none";
+  if (/^(truecolor|24bit)$/i.test(env.COLORTERM ?? "")) return "truecolor";
+  if (/256color/.test(env.TERM ?? "")) return "256";
+  if (env.TERM === "dumb") return "none";
+  return "16";
+}
+function terminalProgram(env) {
+  if (env.TERM_PROGRAM) return env.TERM_PROGRAM;
+  if (env.TERM === "xterm-kitty") return "kitty";
+  if (env.WT_SESSION) return "WindowsTerminal";
+  return "";
+}
+function isLightIndex(index) {
+  if (index < 16) return index === 7 || index >= 9;
+  if (index >= 232) return 8 + (index - 232) * 10 >= 128;
+  const level = (n) => n === 0 ? 0 : 55 + n * 40;
+  const i = index - 16;
+  const [r, g, b] = [level(Math.floor(i / 36)), level(Math.floor(i / 6) % 6), level(i % 6)];
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b >= 128;
+}
+function themeFromColorFgBg(value) {
+  const bg = Number(value?.split(";").pop());
+  return Number.isInteger(bg) && bg >= 0 && bg <= 255 && isLightIndex(bg) ? "light" : "dark";
+}
+function detectCaps(env, isTTY) {
+  const locale = env.LC_ALL || env.LC_CTYPE || env.LANG || "en_US.UTF-8";
+  return {
+    tty: isTTY,
+    color: detectColor(env, isTTY),
+    glyphs: /utf-?8/i.test(locale) ? "unicode" : "ascii",
+    logo: env.DEXTO_LOGO === "sextant" && SEXTANT_TERMS.has(terminalProgram(env)) ? "sextant" : "quadrant",
+    theme: themeFromColorFgBg(env.COLORFGBG),
+    motion: env.DEXTO_MOTION === "reduced" ? "reduced" : "full",
+    palette: env.DEXTO_PALETTE === "signal" ? "signal" : "legacy"
+  };
+}
+let current = null;
+const listeners = /* @__PURE__ */ new Set();
+function getCaps() {
+  if (current === null) current = detectCaps(process.env, process.stdout.isTTY === true);
+  return current;
+}
+function setCaps(next) {
+  current = next;
+  for (const listener of listeners) listener();
+}
+function subscribe(listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+function useCaps() {
+  return useSyncExternalStore(subscribe, getCaps, getCaps);
+}
+export {
+  detectCaps,
+  getCaps,
+  setCaps,
+  useCaps
+};

package/dist/signal/caps.test.cjs

@@ -0,0 +1,56 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_caps = require("./caps.js");
+(0, import_vitest.describe)("detectCaps", () => {
+  const tty = { TERM: "xterm-256color", LANG: "en_US.UTF-8" };
+  (0, import_vitest.it)("honours NO_COLOR before anything else", () => {
+    (0, import_vitest.expect)((0, import_caps.detectCaps)({ ...tty, NO_COLOR: "1", COLORTERM: "truecolor" }, true).color).toBe(
+      "none"
+    );
+  });
+  (0, import_vitest.it)("treats an empty NO_COLOR as unset", () => {
+    (0, import_vitest.expect)((0, import_caps.detectCaps)({ ...tty, NO_COLOR: "" }, true).color).toBe("256");
+  });
+  (0, import_vitest.it)("draws no colour when stdout is not a TTY", () => {
+    (0, import_vitest.expect)((0, import_caps.detectCaps)({ ...tty, COLORTERM: "truecolor" }, false).color).toBe("none");
+  });
+  import_vitest.it.each([
+    [{ COLORTERM: "truecolor", TERM: "xterm" }, "truecolor"],
+    [{ COLORTERM: "24bit", TERM: "xterm" }, "truecolor"],
+    [{ TERM: "screen-256color" }, "256"],
+    [{ TERM: "dumb" }, "none"],
+    [{ TERM: "xterm" }, "16"]
+  ])("picks the colour tier from %o", (env, tier) => {
+    (0, import_vitest.expect)((0, import_caps.detectCaps)(env, true).color).toBe(tier);
+  });
+  (0, import_vitest.it)("falls back to ASCII glyphs outside a UTF-8 locale", () => {
+    (0, import_vitest.expect)((0, import_caps.detectCaps)({ LANG: "C" }, true).glyphs).toBe("ascii");
+    (0, import_vitest.expect)((0, import_caps.detectCaps)({ LC_ALL: "en_GB.utf8" }, true).glyphs).toBe("unicode");
+  });
+  (0, import_vitest.it)("reads a light background from COLORFGBG", () => {
+    (0, import_vitest.expect)((0, import_caps.detectCaps)({ COLORFGBG: "0;15" }, true).theme).toBe("light");
+    (0, import_vitest.expect)((0, import_caps.detectCaps)({ COLORFGBG: "15;default;0" }, true).theme).toBe("dark");
+    (0, import_vitest.expect)((0, import_caps.detectCaps)({ COLORFGBG: "0;8" }, true).theme).toBe("dark");
+    (0, import_vitest.expect)((0, import_caps.detectCaps)({}, true).theme).toBe("dark");
+  });
+  (0, import_vitest.it)("reads 256-colour COLORFGBG backgrounds by their brightness", () => {
+    (0, import_vitest.expect)((0, import_caps.detectCaps)({ COLORFGBG: "15;234" }, true).theme).toBe("dark");
+    (0, import_vitest.expect)((0, import_caps.detectCaps)({ COLORFGBG: "0;254" }, true).theme).toBe("light");
+    (0, import_vitest.expect)((0, import_caps.detectCaps)({ COLORFGBG: "15;17" }, true).theme).toBe("dark");
+    (0, import_vitest.expect)((0, import_caps.detectCaps)({ COLORFGBG: "0;231" }, true).theme).toBe("light");
+    (0, import_vitest.expect)((0, import_caps.detectCaps)({ COLORFGBG: "0;300" }, true).theme).toBe("dark");
+  });
+  (0, import_vitest.it)("keeps the legacy palette unless DEXTO_PALETTE=signal", () => {
+    (0, import_vitest.expect)((0, import_caps.detectCaps)({}, true).palette).toBe("legacy");
+    (0, import_vitest.expect)((0, import_caps.detectCaps)({ DEXTO_PALETTE: "signal" }, true).palette).toBe("signal");
+  });
+  (0, import_vitest.it)("uses sextants only when asked for on a terminal that draws them", () => {
+    (0, import_vitest.expect)((0, import_caps.detectCaps)({ DEXTO_LOGO: "sextant", TERM_PROGRAM: "ghostty" }, true).logo).toBe(
+      "sextant"
+    );
+    (0, import_vitest.expect)(
+      (0, import_caps.detectCaps)({ DEXTO_LOGO: "sextant", TERM_PROGRAM: "Apple_Terminal" }, true).logo
+    ).toBe("quadrant");
+    (0, import_vitest.expect)((0, import_caps.detectCaps)({ TERM_PROGRAM: "ghostty" }, true).logo).toBe("quadrant");
+  });
+});

package/dist/signal/caps.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=caps.test.d.ts.map

package/dist/signal/caps.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"caps.test.d.ts","sourceRoot":"","sources":["../../src/signal/caps.test.ts"],"names":[],"mappings":""}