@sigx/terminal-zero 0.5.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 Andreas Ekdahl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/contract.d.ts

@@ -0,0 +1,75 @@
+/**
+ * The shared design-system contract for SignalX terminal UIs.
+ *
+ * `@sigx/terminal-zero` is the design-system-neutral foundation that skin
+ * packages (`@sigx/terminal-ui`, …) build on. This module is the *vocabulary*
+ * they agree on — the structural/semantic color tokens every theme authors, and
+ * how each token degrades to a 16-color terminal — so switching skins or themes
+ * is a token remap, not a component rewrite.
+ *
+ * Rules of the contract:
+ * - Skins author themes against the `Theme` shape; they never redeclare the
+ *   token names. Drift fails `pnpm typecheck`.
+ * - Hex values are the single source of truth. The renderer
+ *   (`@sigx/runtime-terminal`) turns a hex into a truecolor / 256 / 16-color SGR
+ *   escape; this contract decides which *token* maps to which 16-color ANSI name
+ *   when a hex can't be shown (`FALLBACK_ALIAS`).
+ *
+ * Token groups (from the SigX-tui design spec):
+ * - structure: `bg panel chrome line fg dim faint shadow`
+ * - accent:    `accent accentSoft accentText selSoft`
+ * - status:    `success warn danger info`
+ * - ANSI core: `black red green yellow blue magenta cyan white` (themed, with a
+ *   guaranteed 16-color fallback since they ARE ANSI names)
+ */
+import type { Define } from '@sigx/runtime-core';
+export type Mode = 'dark' | 'light';
+/** Every token a component may reference. Keep this shape identical across themes. */
+export interface Theme {
+    name: string;
+    mode: Mode;
+    bg: string;
+    panel: string;
+    chrome: string;
+    line: string;
+    fg: string;
+    dim: string;
+    faint: string;
+    shadow: string;
+    accent: string;
+    accentSoft: string;
+    accentText: string;
+    selSoft: string;
+    success: string;
+    warn: string;
+    danger: string;
+    info: string;
+    black: string;
+    red: string;
+    green: string;
+    yellow: string;
+    blue: string;
+    magenta: string;
+    cyan: string;
+    white: string;
+}
+/** A token name (anything in `Theme` except its metadata). */
+export type ColorToken = keyof Omit<Theme, 'name' | 'mode'>;
+/** A color value: a semantic token (autocompleted) OR a raw `#rrggbb` hex. */
+export type ColorValue = ColorToken | (string & {});
+/** The 8 ANSI core token names — they degrade to themselves in 16-color mode. */
+export declare const ANSI_NAMES: ReadonlySet<string>;
+/**
+ * Which 16-color ANSI name each non-ANSI token degrades to when the terminal
+ * can't render truecolor/256. (Design knowledge — lives here, not in the
+ * renderer; the renderer only knows hex→SGR device math.)
+ */
+export declare const FALLBACK_ALIAS: Record<string, string>;
+/** Semantic/structural color of the component (`accent`, `danger`, `fg`, …). */
+export type WithColor = Define.Prop<'color', ColorValue, false>;
+/** Disabled: non-interactive + skin disabled styling. */
+export type WithDisabled = Define.Prop<'disabled', boolean, false>;
+/** Fieldset-style legend rendered into the top border. */
+export type WithLabel = Define.Prop<'label', string, false>;
+/** Auto-focus this control on mount. */
+export type WithAutofocus = Define.Prop<'autofocus', boolean, false>;

package/dist/contract.js

@@ -0,0 +1,32 @@
+//#region src/contract.ts
+var e = new Set([
+	"black",
+	"red",
+	"green",
+	"yellow",
+	"blue",
+	"magenta",
+	"cyan",
+	"white"
+]), t = {
+	accent: "cyan",
+	accentSoft: "black",
+	accentText: "black",
+	selSoft: "black",
+	success: "green",
+	warn: "yellow",
+	danger: "red",
+	info: "cyan",
+	fg: "white",
+	dim: "white",
+	faint: "white",
+	line: "white",
+	shadow: "black",
+	bg: "black",
+	panel: "black",
+	chrome: "black"
+};
+//#endregion
+export { e as ANSI_NAMES, t as FALLBACK_ALIAS };
+
+//# sourceMappingURL=contract.js.map

package/dist/contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.js","names":[],"sources":["../src/contract.ts"],"sourcesContent":["/**\r\n * The shared design-system contract for SignalX terminal UIs.\r\n *\r\n * `@sigx/terminal-zero` is the design-system-neutral foundation that skin\r\n * packages (`@sigx/terminal-ui`, …) build on. This module is the *vocabulary*\r\n * they agree on — the structural/semantic color tokens every theme authors, and\r\n * how each token degrades to a 16-color terminal — so switching skins or themes\r\n * is a token remap, not a component rewrite.\r\n *\r\n * Rules of the contract:\r\n * - Skins author themes against the `Theme` shape; they never redeclare the\r\n *   token names. Drift fails `pnpm typecheck`.\r\n * - Hex values are the single source of truth. The renderer\r\n *   (`@sigx/runtime-terminal`) turns a hex into a truecolor / 256 / 16-color SGR\r\n *   escape; this contract decides which *token* maps to which 16-color ANSI name\r\n *   when a hex can't be shown (`FALLBACK_ALIAS`).\r\n *\r\n * Token groups (from the SigX-tui design spec):\r\n * - structure: `bg panel chrome line fg dim faint shadow`\r\n * - accent:    `accent accentSoft accentText selSoft`\r\n * - status:    `success warn danger info`\r\n * - ANSI core: `black red green yellow blue magenta cyan white` (themed, with a\r\n *   guaranteed 16-color fallback since they ARE ANSI names)\r\n */\r\nimport type { Define } from '@sigx/runtime-core';\r\n\r\nexport type Mode = 'dark' | 'light';\r\n\r\n/** Every token a component may reference. Keep this shape identical across themes. */\r\nexport interface Theme {\r\n    name: string;\r\n    mode: Mode;\r\n\r\n    // structure\r\n    bg: string;       // canvas / terminal background\r\n    panel: string;    // raised surface\r\n    chrome: string;   // title bars / footers\r\n    line: string;     // idle borders, rules\r\n    fg: string;       // default text\r\n    dim: string;      // muted text\r\n    faint: string;    // faintest text / progress track\r\n    shadow: string;   // drop-shadow tone (▒)\r\n\r\n    // accent (focus + selection)\r\n    accent: string;\r\n    accentSoft: string;   // subtle focus tint behind content\r\n    accentText: string;   // text on a solid accent fill\r\n    selSoft: string;      // selected-row tint (Select / Radio)\r\n\r\n    // status\r\n    success: string;\r\n    warn: string;\r\n    danger: string;\r\n    info: string;\r\n\r\n    // ANSI core (themed); each also has a guaranteed 16-color SGR fallback\r\n    black: string;\r\n    red: string;\r\n    green: string;\r\n    yellow: string;\r\n    blue: string;\r\n    magenta: string;\r\n    cyan: string;\r\n    white: string;\r\n}\r\n\r\n/** A token name (anything in `Theme` except its metadata). */\r\nexport type ColorToken = keyof Omit<Theme, 'name' | 'mode'>;\r\n\r\n/** A color value: a semantic token (autocompleted) OR a raw `#rrggbb` hex. */\r\n// eslint-disable-next-line @typescript-eslint/no-empty-object-type, @typescript-eslint/ban-types\r\nexport type ColorValue = ColorToken | (string & {});\r\n\r\n/** The 8 ANSI core token names — they degrade to themselves in 16-color mode. */\r\nexport const ANSI_NAMES: ReadonlySet<string> = new Set([\r\n    'black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white',\r\n]);\r\n\r\n/**\r\n * Which 16-color ANSI name each non-ANSI token degrades to when the terminal\r\n * can't render truecolor/256. (Design knowledge — lives here, not in the\r\n * renderer; the renderer only knows hex→SGR device math.)\r\n */\r\nexport const FALLBACK_ALIAS: Record<string, string> = {\r\n    accent: 'cyan', accentSoft: 'black', accentText: 'black', selSoft: 'black',\r\n    success: 'green', warn: 'yellow', danger: 'red', info: 'cyan',\r\n    fg: 'white', dim: 'white', faint: 'white', line: 'white',\r\n    shadow: 'black', bg: 'black', panel: 'black', chrome: 'black',\r\n};\r\n\r\n// ---------------------------------------------------------------------------\r\n// Common prop fragments — skin component props intersect these instead of\r\n// redeclaring the conventions. (`variant` is intentionally NOT here — fill style\r\n// is skin chrome and differs per design system.)\r\n// ---------------------------------------------------------------------------\r\n\r\n/** Semantic/structural color of the component (`accent`, `danger`, `fg`, …). */\r\nexport type WithColor = Define.Prop<'color', ColorValue, false>;\r\n\r\n/** Disabled: non-interactive + skin disabled styling. */\r\nexport type WithDisabled = Define.Prop<'disabled', boolean, false>;\r\n\r\n/** Fieldset-style legend rendered into the top border. */\r\nexport type WithLabel = Define.Prop<'label', string, false>;\r\n\r\n/** Auto-focus this control on mount. */\r\nexport type WithAutofocus = Define.Prop<'autofocus', boolean, false>;\r\n"],"mappings":";AA0EA,IAAa,IAAkC,IAAI,IAAI;CACnD;CAAS;CAAO;CAAS;CAAU;CAAQ;CAAW;CAAQ;CACjE,CAAC,EAOW,IAAyC;CAClD,QAAQ;CAAQ,YAAY;CAAS,YAAY;CAAS,SAAS;CACnE,SAAS;CAAS,MAAM;CAAU,QAAQ;CAAO,MAAM;CACvD,IAAI;CAAS,KAAK;CAAS,OAAO;CAAS,MAAM;CACjD,QAAQ;CAAS,IAAI;CAAS,OAAO;CAAS,QAAQ;CACzD"}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @sigx/terminal-zero — headless, design-system-neutral foundation for SignalX
+ * terminal UIs. Provides the token contract, the theme engine, shared glyphs +
+ * focus/input re-exports, and layout primitives. Design-system skins
+ * (`@sigx/terminal-ui`) build styled components on top.
+ */
+export * from './contract';
+export * from './theme';
+export * from './shared';
+export * from './layout';
+export * from './prompts';

package/dist/index.js

@@ -0,0 +1,6 @@
+import { ANSI_NAMES as e, FALLBACK_ALIAS as t } from "./contract.js";
+import { applyThemeCanvas as n, disableThemeCanvas as r, getActiveTheme as i, getTheme as a, hasTheme as o, listThemes as s, registerTheme as c, resolveColor as l, setTheme as u } from "./theme/index.js";
+import { A as d, B as f, C as p, D as m, E as h, F as g, G as _, H as v, I as y, J as b, K as x, L as S, M as C, N as w, O as T, P as E, R as D, S as O, T as k, U as A, V as j, W as M, _ as N, a as P, b as F, c as I, d as L, f as R, g as z, h as B, i as V, j as H, k as U, l as W, m as G, n as K, o as q, p as J, q as Y, r as X, s as Z, t as Q, u as $, v as ee, w as te, x as ne, y as re, z as ie } from "./shared-h5p-EcZV.js";
+import { a as ae, i as oe, n as se, o as ce, r as le, s as ue, t as de } from "./layout-BRHtLdVH.js";
+import { CANCEL as fe, __setInteractiveOverride as pe, enqueue as me, isBackspace as he, isCancel as ge, isCtrlC as _e, isDown as ve, isEnter as ye, isEsc as be, isInteractive as xe, isLeft as Se, isPrintable as Ce, isRight as we, isSpace as Te, isUp as Ee, paintToken as De, runPrompt as Oe, summaryLine as ke, tokenSgr as Ae } from "./prompts/index.js";
+export { e as ANSI_NAMES, ue as Box, fe as CANCEL, ce as Col, oe as Divider, t as FALLBACK_ALIAS, Q as GLYPHS, de as Heading, K as PRESS_MS, X as READY_DELAY_MS, le as Row, V as SPINNERS, ae as Spacer, j as TICK_MS, se as Text, pe as __setInteractiveOverride, n as applyThemeCanvas, P as charWidth, U as createViewStack, d as cursorToRowCol, H as deleteAt, C as deleteBefore, r as disableThemeCanvas, q as dispatchKey, Z as displayWidth, me as enqueue, I as focus, W as focusNext, $ as focusPrev, L as focusState, T as generateQR, i as getActiveTheme, R as getColorDepth, J as getOutputTarget, G as getTerminalSize, a as getTheme, v as getTick, M as gradient, o as hasTheme, B as hexToSGR, _ as hueShift, w as insertAt, he as isBackspace, ge as isCancel, _e as isCtrlC, ve as isDown, ye as isEnter, be as isEsc, xe as isInteractive, Se as isLeft, Ce as isPrintable, we as isRight, Te as isSpace, Ee as isUp, E as layoutText, s as listThemes, x as mixHex, g as moveLeft, y as moveLineEnd, S as moveLineStart, D as moveRight, ie as moveVertical, z as onKey, De as paintToken, Y as parseHex, N as printStatic, ee as registerFocusable, c as registerTheme, re as renderTerminal, F as resolveBg, l as resolveColor, ne as resolveFg, b as rgbToHex, f as rowColToCursor, Oe as runPrompt, O as setScreenBackground, p as setScreenForeground, u as setTheme, A as subscribeTicker, ke as summaryLine, te as syncTerminalSize, Ae as tokenSgr, k as truncateToWidth, h as unregisterFocusable, m as writeStatic };

package/dist/layout/Box.d.ts

@@ -0,0 +1,25 @@
+/** @jsxImportSource @sigx/runtime-core */
+import { type Define } from '@sigx/runtime-core';
+/**
+ * Themed container. A thin wrapper over the renderer's `<box>` that resolves
+ * token-named colors and defaults to a rounded `line` border with a themed
+ * drop shadow. Skins compose this; raw `<box>` stays available for the renderer.
+ */
+export declare const Box: import("@sigx/runtime-core").ComponentFactory<{
+    border?: "double" | "none" | "rounded" | "single" | "thick" | undefined;
+} & {
+    borderColor?: string | undefined;
+} & {
+    backgroundColor?: string | undefined;
+} & {
+    label?: string | undefined;
+} & {
+    labelColor?: string | undefined;
+} & {
+    padX?: number | undefined;
+} & {
+    dropShadow?: boolean | undefined;
+} & Define.Slot<"default", void>, void, {
+    default: () => import("@sigx/runtime-core").JSXElement | import("@sigx/runtime-core").JSXElement[] | null;
+}>;
+export default Box;

package/dist/layout/Col.d.ts

@@ -0,0 +1,15 @@
+/** @jsxImportSource @sigx/runtime-core */
+import { type Define } from '@sigx/runtime-core';
+/**
+ * Vertical stack. The renderer already lays block children out top-to-bottom,
+ * so `Col` is a borderless grouping box with optional spacing: `gap` inserts
+ * that many blank rows BETWEEN children (not before or after) — the
+ * component-layer replacement for `<box></box>` spacer hacks. For
+ * side-by-side columns, see `Row`.
+ */
+export declare const Col: import("@sigx/runtime-core").ComponentFactory<{
+    gap?: number | undefined;
+} & Define.Slot<"default", void>, void, {
+    default: () => import("@sigx/runtime-core").JSXElement | import("@sigx/runtime-core").JSXElement[] | null;
+}>;
+export default Col;

package/dist/layout/Divider.d.ts

@@ -0,0 +1,9 @@
+/** Horizontal rule of `width` cells, with an optional centered accent label. */
+export declare const Divider: import("@sigx/runtime-core").ComponentFactory<{
+    width?: number | undefined;
+} & {
+    label?: string | undefined;
+} & {
+    color?: string | undefined;
+}, void, {}>;
+export default Divider;

package/dist/layout/Row.d.ts

@@ -0,0 +1,18 @@
+/** @jsxImportSource @sigx/runtime-core */
+import { type Define } from '@sigx/runtime-core';
+/**
+ * Horizontal layout: each slot child renders as a column, merged side by side
+ * (the renderer pads every column to its own display width and zips the lines).
+ * `gap` is the spacing between columns (default 2); `align` places shorter
+ * columns at the start (default), center, or end — 'top'/'bottom' are
+ * accepted aliases. A row wider than the terminal clips at the right edge —
+ * put the column that must stay intact leftmost.
+ */
+export declare const Row: import("@sigx/runtime-core").ComponentFactory<Define.Slot<"default", void> & {
+    gap?: number | undefined;
+} & {
+    align?: "bottom" | "center" | "end" | "start" | "top" | undefined;
+}, void, {
+    default: () => import("@sigx/runtime-core").JSXElement | import("@sigx/runtime-core").JSXElement[] | null;
+}>;
+export default Row;

package/dist/layout/Spacer.d.ts

@@ -0,0 +1,5 @@
+/** Vertical gap of `size` blank lines (default 1). */
+export declare const Spacer: import("@sigx/runtime-core").ComponentFactory<{
+    size?: number | undefined;
+}, void, {}>;
+export default Spacer;

package/dist/layout/Text.d.ts

@@ -0,0 +1,50 @@
+/** @jsxImportSource @sigx/runtime-core */
+import { type Define } from '@sigx/runtime-core';
+/**
+ * Typography span — the token-aware way to write styled text without
+ * touching `resolveColor` or raw `<text>`:
+ *
+ *     <Text color="dim">Scan with sigx-lynx-go:</Text>
+ *     <Text color="danger" bold>failed</Text>
+ *
+ * `color`/`bg` accept theme tokens or `#hex`. Style flags map to terminal
+ * SGR attributes (rendering depends on the emulator; all are gated off for
+ * piped/CI output).
+ *
+ * NOTE — deliberately INLINE, unlike every other component: Text is a span
+ * that composes inside a line (`<Text color="accent">{n}</Text> items`).
+ * Standalone lines use `Heading` or wrap in a layout component.
+ *
+ * There is no `size`/`weight` enum: terminal cells have exactly one size;
+ * weight is the `bold`/`faint` pair. This mirrors the daisy/lynx `Text`
+ * shape (discrete props, no variant) minus what a terminal cannot do.
+ */
+export declare const Text: import("@sigx/runtime-core").ComponentFactory<{
+    color?: string | undefined;
+} & {
+    bg?: string | undefined;
+} & {
+    bold?: boolean | undefined;
+} & {
+    faint?: boolean | undefined;
+} & {
+    italic?: boolean | undefined;
+} & {
+    underline?: boolean | undefined;
+} & {
+    lineThrough?: boolean | undefined;
+} & {
+    inverse?: boolean | undefined;
+} & Define.Slot<"default", void>, void, {
+    default: () => import("@sigx/runtime-core").JSXElement | import("@sigx/runtime-core").JSXElement[] | null;
+}>;
+/**
+ * A standalone bold line — the terminal analog of a heading. Block element
+ * (its own line), default color `fg`.
+ */
+export declare const Heading: import("@sigx/runtime-core").ComponentFactory<{
+    color?: string | undefined;
+} & Define.Slot<"default", void>, void, {
+    default: () => import("@sigx/runtime-core").JSXElement | import("@sigx/runtime-core").JSXElement[] | null;
+}>;
+export default Text;

package/dist/layout/index.d.ts

@@ -0,0 +1,6 @@
+export { Box } from './Box';
+export { Col } from './Col';
+export { Spacer } from './Spacer';
+export { Divider } from './Divider';
+export { Row } from './Row';
+export { Text, Heading } from './Text';

package/dist/layout/index.js

@@ -0,0 +1,2 @@
+import { a as e, i as t, n, o as r, r as i, s as a, t as o } from "../layout-BRHtLdVH.js";
+export { a as Box, r as Col, t as Divider, o as Heading, i as Row, e as Spacer, n as Text };

package/dist/layout-BRHtLdVH.js

@@ -0,0 +1,71 @@
+import { resolveColor as e } from "./theme/index.js";
+import { displayWidth as t } from "@sigx/runtime-terminal";
+import { component as n } from "@sigx/runtime-core";
+import { jsx as r, jsxs as i } from "@sigx/runtime-core/jsx-runtime";
+//#region src/layout/Box.tsx
+var a = n(({ props: t, slots: n }) => () => /* @__PURE__ */ r("box", {
+	border: t.border ?? "rounded",
+	borderColor: e(t.borderColor ?? "line"),
+	backgroundColor: t.backgroundColor ? e(t.backgroundColor) : void 0,
+	label: t.label,
+	labelColor: e(t.labelColor ?? "accent"),
+	padX: t.padX,
+	dropShadow: t.dropShadow,
+	shadowColor: e("shadow"),
+	children: n.default?.()
+}), { name: "Box" }), o = n(({ props: e, slots: t }) => () => {
+	let n = t.default?.(), i = Math.max(0, e.gap ?? 0);
+	if (!i || !Array.isArray(n) || n.length < 2) return /* @__PURE__ */ r("box", { children: n });
+	let a = [];
+	return n.forEach((e, t) => {
+		if (t > 0) for (let e = 0; e < i; e++) a.push(/* @__PURE__ */ r("box", { children: /* @__PURE__ */ r("text", { children: " " }) }));
+		a.push(e);
+	}), /* @__PURE__ */ r("box", { children: a });
+}, { name: "Col" }), s = n(({ props: e }) => () => {
+	let t = Math.max(1, e.size ?? 1), n = [];
+	for (let e = 0; e < t - 1; e++) n.push(/* @__PURE__ */ r("br", {}));
+	return /* @__PURE__ */ r("box", { children: n });
+}, { name: "Spacer" }), c = n(({ props: n }) => () => {
+	let a = Math.max(1, n.width ?? 24), o = e(n.color ?? "line"), s = n.label;
+	if (!s) return /* @__PURE__ */ r("box", { children: /* @__PURE__ */ r("text", {
+		color: o,
+		children: "─".repeat(a)
+	}) });
+	let c = ` ${s} `, l = Math.max(0, a - t(c)), u = Math.floor(l / 2), d = l - u;
+	return /* @__PURE__ */ i("box", { children: [
+		/* @__PURE__ */ r("text", {
+			color: o,
+			children: "─".repeat(u)
+		}),
+		/* @__PURE__ */ r("text", {
+			color: e("accent"),
+			children: c
+		}),
+		/* @__PURE__ */ r("text", {
+			color: o,
+			children: "─".repeat(d)
+		})
+	] });
+}, { name: "Divider" }), l = n(({ props: e, slots: t }) => () => /* @__PURE__ */ r("row", {
+	gap: e.gap ?? 2,
+	align: e.align ?? "start",
+	children: t.default?.()
+}), { name: "Row" }), u = n(({ props: t, slots: n }) => () => /* @__PURE__ */ r("text", {
+	color: t.color ? e(t.color) : void 0,
+	backgroundColor: t.bg ? e(t.bg) : void 0,
+	bold: t.bold,
+	faint: t.faint,
+	italic: t.italic,
+	underline: t.underline,
+	lineThrough: t.lineThrough,
+	inverse: t.inverse,
+	children: n.default?.()
+}), { name: "Text" }), d = n(({ props: t, slots: n }) => () => /* @__PURE__ */ r("box", { children: /* @__PURE__ */ r("text", {
+	bold: !0,
+	color: e(t.color ?? "fg"),
+	children: n.default?.()
+}) }), { name: "Heading" });
+//#endregion
+export { s as a, c as i, u as n, o, l as r, a as s, d as t };
+
+//# sourceMappingURL=layout-BRHtLdVH.js.map

package/dist/layout-BRHtLdVH.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout-BRHtLdVH.js","names":[],"sources":["../src/layout/Box.tsx","../src/layout/Col.tsx","../src/layout/Spacer.tsx","../src/layout/Divider.tsx","../src/layout/Row.tsx","../src/layout/Text.tsx"],"sourcesContent":["/** @jsxImportSource @sigx/runtime-core */\r\nimport { component, type Define } from '@sigx/runtime-core';\r\nimport { resolveColor } from '../theme';\r\n\r\n/**\r\n * Themed container. A thin wrapper over the renderer's `<box>` that resolves\r\n * token-named colors and defaults to a rounded `line` border with a themed\r\n * drop shadow. Skins compose this; raw `<box>` stays available for the renderer.\r\n */\r\nexport const Box = component<\r\n    Define.Prop<'border', 'single' | 'double' | 'rounded' | 'thick' | 'none', false> &\r\n    Define.Prop<'borderColor', string, false> &\r\n    Define.Prop<'backgroundColor', string, false> &\r\n    Define.Prop<'label', string, false> &\r\n    Define.Prop<'labelColor', string, false> &\r\n    Define.Prop<'padX', number, false> &\r\n    Define.Prop<'dropShadow', boolean, false> &\r\n    Define.Slot<'default'>\r\n>(({ props, slots }) => {\r\n    return () => (\r\n        <box\r\n            border={props.border ?? 'rounded'}\r\n            borderColor={resolveColor(props.borderColor ?? 'line')}\r\n            backgroundColor={props.backgroundColor ? resolveColor(props.backgroundColor) : undefined}\r\n            label={props.label}\r\n            labelColor={resolveColor(props.labelColor ?? 'accent')}\r\n            padX={props.padX}\r\n            dropShadow={props.dropShadow}\r\n            shadowColor={resolveColor('shadow')}\r\n        >\r\n            {slots.default?.()}\r\n        </box>\r\n    );\r\n}, { name: 'Box' });\r\n\r\nexport default Box;\r\n","/** @jsxImportSource @sigx/runtime-core */\r\nimport { component, type Define } from '@sigx/runtime-core';\r\n\r\n/**\r\n * Vertical stack. The renderer already lays block children out top-to-bottom,\r\n * so `Col` is a borderless grouping box with optional spacing: `gap` inserts\r\n * that many blank rows BETWEEN children (not before or after) — the\r\n * component-layer replacement for `<box></box>` spacer hacks. For\r\n * side-by-side columns, see `Row`.\r\n */\r\nexport const Col = component<\r\n    Define.Prop<'gap', number, false> &\r\n    Define.Slot<'default'>\r\n>(({ props, slots }) => {\r\n    return () => {\r\n        const children = slots.default?.();\r\n        const gap = Math.max(0, props.gap ?? 0);\r\n        if (!gap || !Array.isArray(children) || children.length < 2) {\r\n            return <box>{children}</box>;\r\n        }\r\n        const spaced: unknown[] = [];\r\n        children.forEach((child, i) => {\r\n            if (i > 0) {\r\n                for (let g = 0; g < gap; g++) {\r\n                    spaced.push(<box><text> </text></box>);\r\n                }\r\n            }\r\n            spaced.push(child);\r\n        });\r\n        return <box>{spaced}</box>;\r\n    };\r\n}, { name: 'Col' });\r\n\r\nexport default Col;\r\n","/** @jsxImportSource @sigx/runtime-core */\r\nimport { component, type Define } from '@sigx/runtime-core';\r\n\r\n/** Vertical gap of `size` blank lines (default 1). */\r\nexport const Spacer = component<\r\n    Define.Prop<'size', number, false>\r\n>(({ props }) => {\r\n    return () => {\r\n        const size = Math.max(1, props.size ?? 1);\r\n        // A <box> already renders one line; each <br/> adds another — so\r\n        // exactly `size` blank lines means size-1 breaks.\r\n        const breaks = [];\r\n        for (let i = 0; i < size - 1; i++) breaks.push(<br />);\r\n        return <box>{breaks}</box>;\r\n    };\r\n}, { name: 'Spacer' });\r\n\r\nexport default Spacer;\r\n","/** @jsxImportSource @sigx/runtime-core */\r\nimport { component, type Define } from '@sigx/runtime-core';\r\nimport { displayWidth } from '@sigx/runtime-terminal';\r\nimport { resolveColor } from '../theme';\r\n\r\n/** Horizontal rule of `width` cells, with an optional centered accent label. */\r\nexport const Divider = component<\r\n    Define.Prop<'width', number, false> &\r\n    Define.Prop<'label', string, false> &\r\n    Define.Prop<'color', string, false>\r\n>(({ props }) => {\r\n    return () => {\r\n        const width = Math.max(1, props.width ?? 24);\r\n        const ruleColor = resolveColor(props.color ?? 'line');\r\n        const label = props.label;\r\n\r\n        if (!label) {\r\n            return <box><text color={ruleColor}>{'─'.repeat(width)}</text></box>;\r\n        }\r\n\r\n        const inner = ` ${label} `;\r\n        // Measure in terminal cells, not UTF-16 units — wide glyphs (CJK,\r\n        // emoji) and combining marks would otherwise mis-center the label.\r\n        const remain = Math.max(0, width - displayWidth(inner));\r\n        const left = Math.floor(remain / 2);\r\n        const right = remain - left;\r\n        return (\r\n            <box>\r\n                <text color={ruleColor}>{'─'.repeat(left)}</text>\r\n                <text color={resolveColor('accent')}>{inner}</text>\r\n                <text color={ruleColor}>{'─'.repeat(right)}</text>\r\n            </box>\r\n        );\r\n    };\r\n}, { name: 'Divider' });\r\n\r\nexport default Divider;\r\n","/** @jsxImportSource @sigx/runtime-core */\r\nimport { component, type Define } from '@sigx/runtime-core';\r\n\r\n/**\r\n * Horizontal layout: each slot child renders as a column, merged side by side\r\n * (the renderer pads every column to its own display width and zips the lines).\r\n * `gap` is the spacing between columns (default 2); `align` places shorter\r\n * columns at the start (default), center, or end — 'top'/'bottom' are\r\n * accepted aliases. A row wider than the terminal clips at the right edge —\r\n * put the column that must stay intact leftmost.\r\n */\r\nexport const Row = component<\r\n    Define.Slot<'default'> &\r\n    Define.Prop<'gap', number, false> &\r\n    Define.Prop<'align', 'start' | 'center' | 'end' | 'top' | 'bottom', false>\r\n>(({ props, slots }) => {\r\n    return () => (\r\n        <row gap={props.gap ?? 2} align={props.align ?? 'start'}>\r\n            {slots.default?.()}\r\n        </row>\r\n    );\r\n}, { name: 'Row' });\r\n\r\nexport default Row;\r\n","/** @jsxImportSource @sigx/runtime-core */\r\nimport { component, type Define } from '@sigx/runtime-core';\r\nimport { resolveColor } from '../theme';\r\n\r\n/**\r\n * Typography span — the token-aware way to write styled text without\r\n * touching `resolveColor` or raw `<text>`:\r\n *\r\n *     <Text color=\"dim\">Scan with sigx-lynx-go:</Text>\r\n *     <Text color=\"danger\" bold>failed</Text>\r\n *\r\n * `color`/`bg` accept theme tokens or `#hex`. Style flags map to terminal\r\n * SGR attributes (rendering depends on the emulator; all are gated off for\r\n * piped/CI output).\r\n *\r\n * NOTE — deliberately INLINE, unlike every other component: Text is a span\r\n * that composes inside a line (`<Text color=\"accent\">{n}</Text> items`).\r\n * Standalone lines use `Heading` or wrap in a layout component.\r\n *\r\n * There is no `size`/`weight` enum: terminal cells have exactly one size;\r\n * weight is the `bold`/`faint` pair. This mirrors the daisy/lynx `Text`\r\n * shape (discrete props, no variant) minus what a terminal cannot do.\r\n */\r\nexport const Text = component<\r\n    Define.Prop<'color', string, false> &\r\n    Define.Prop<'bg', string, false> &\r\n    Define.Prop<'bold', boolean, false> &\r\n    Define.Prop<'faint', boolean, false> &\r\n    Define.Prop<'italic', boolean, false> &\r\n    Define.Prop<'underline', boolean, false> &\r\n    Define.Prop<'lineThrough', boolean, false> &\r\n    Define.Prop<'inverse', boolean, false> &\r\n    Define.Slot<'default'>\r\n>(({ props, slots }) => {\r\n    return () => (\r\n        <text\r\n            color={props.color ? resolveColor(props.color) : undefined}\r\n            backgroundColor={props.bg ? resolveColor(props.bg) : undefined}\r\n            bold={props.bold}\r\n            faint={props.faint}\r\n            italic={props.italic}\r\n            underline={props.underline}\r\n            lineThrough={props.lineThrough}\r\n            inverse={props.inverse}\r\n        >\r\n            {slots.default?.()}\r\n        </text>\r\n    );\r\n}, { name: 'Text' });\r\n\r\n/**\r\n * A standalone bold line — the terminal analog of a heading. Block element\r\n * (its own line), default color `fg`.\r\n */\r\nexport const Heading = component<\r\n    Define.Prop<'color', string, false> &\r\n    Define.Slot<'default'>\r\n>(({ props, slots }) => {\r\n    return () => (\r\n        <box>\r\n            <text bold color={resolveColor(props.color ?? 'fg')}>\r\n                {slots.default?.()}\r\n            </text>\r\n        </box>\r\n    );\r\n}, { name: 'Heading' });\r\n\r\nexport default Text;\r\n"],"mappings":"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"}

package/dist/prompts/cancel.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Cancellation marker for the imperative prompts. `Symbol.for` so duplicated
+ * module instances (mixed dist/src resolution in a workspace) still agree.
+ */
+export declare const CANCEL: unique symbol;
+/** True when a prompt result means the user cancelled (Esc / Ctrl+C). */
+export declare function isCancel(value: unknown): value is typeof CANCEL;

package/dist/prompts/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Headless prompt engine: the cancellation symbol, key predicates, and the
+ * one-shot mount/serialization/summary machinery that imperative prompts run
+ * on. UI-agnostic — the styled prompt functions (text/select/multiselect/
+ * confirm and their styled chrome) live in `@sigx/terminal-ui/prompts`;
+ * any skin built on this foundation reuses the engine and brings its own
+ * views.
+ */
+export * from './cancel';
+export * from './keys';
+export * from './runPrompt';

package/dist/prompts/index.js

@@ -0,0 +1,53 @@
+import { resolveColor as e } from "../theme/index.js";
+import { getOutputTarget as t, printStatic as n, renderTerminal as r, resolveFg as i, writeStatic as a } from "@sigx/runtime-terminal";
+//#region src/prompts/cancel.ts
+var o = Symbol.for("sigx.prompt.cancel");
+function s(e) {
+	return e === o;
+}
+//#endregion
+//#region src/prompts/keys.ts
+var c = "\x1B", l = "", u = "", d = "\b", f = (e) => e === "\r" || e === "\n", p = (e) => e === " ", m = (e) => e === c, h = (e) => e === l, g = (e) => e === u || e === d, _ = (e) => e === c + "[A", v = (e) => e === c + "[B", y = (e) => e === c + "[C", b = (e) => e === c + "[D", x = (e) => e.length === 1 && e >= " " && e !== u, S = Promise.resolve(), C;
+function w(e) {
+	C = e;
+}
+function T() {
+	return C === void 0 ? t().isTTY && !!process.stdin.isTTY : C;
+}
+function E(t) {
+	return i(e(t));
+}
+function D(e, t) {
+	let n = E(t);
+	return n ? `${n}${e}\x1b[39m` : e;
+}
+function O(e, t, n) {
+	if (e === "cancel") return `${D("■", "danger")} ${t} ${D("· cancelled", "dim")}`;
+	let r = n !== void 0 && n !== "" ? ` ${D(`· ${n}`, "dim")}` : "";
+	return `${D("◇", "success")} ${t}${r}`;
+}
+function k(e) {
+	let t = S.then(e);
+	return S = t.then(() => void 0, () => void 0), t;
+}
+function A(e) {
+	return k(() => {
+		if (!T()) {
+			let t = e.fallback?.();
+			return t && t.ok ? (n(O("done", e.message, e.display(t.value))), Promise.resolve(t.value)) : Promise.reject(/* @__PURE__ */ Error(`Prompt "${e.message}" requires an interactive terminal — pass the value via a CLI flag or provide initialValue.`));
+		}
+		return new Promise((t) => {
+			let n = !1, i = r(e.build((r) => {
+				n || (n = !0, i.unmount(), a(r === o ? O("cancel", e.message) : O("done", e.message, e.display(r))), t(r));
+			}), {
+				mode: "inline",
+				persistOnExit: !1,
+				exitOnCtrlC: !1
+			});
+		});
+	});
+}
+//#endregion
+export { o as CANCEL, w as __setInteractiveOverride, k as enqueue, g as isBackspace, s as isCancel, h as isCtrlC, v as isDown, f as isEnter, m as isEsc, T as isInteractive, b as isLeft, x as isPrintable, y as isRight, p as isSpace, _ as isUp, D as paintToken, A as runPrompt, O as summaryLine, E as tokenSgr };
+
+//# sourceMappingURL=index.js.map

package/dist/prompts/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/prompts/cancel.ts","../../src/prompts/keys.ts","../../src/prompts/runPrompt.ts"],"sourcesContent":["/**\r\n * Cancellation marker for the imperative prompts. `Symbol.for` so duplicated\r\n * module instances (mixed dist/src resolution in a workspace) still agree.\r\n */\r\nexport const CANCEL: unique symbol = Symbol.for('sigx.prompt.cancel') as never;\r\n\r\n/** True when a prompt result means the user cancelled (Esc / Ctrl+C). */\r\nexport function isCancel(value: unknown): value is typeof CANCEL {\r\n    return value === CANCEL;\r\n}\r\n","/**\r\n * Shared key predicates for prompt input. Constants are built with\r\n * fromCharCode so no raw control bytes live in source. Esc is detected by\r\n * exact match: Node delivers complete escape sequences per data event, so a\r\n * lone ESC byte is the Esc key, while arrows arrive as multi-byte chunks.\r\n */\r\nconst ESC = String.fromCharCode(27);\r\nconst CTRL_C = String.fromCharCode(3);\r\nconst DEL = String.fromCharCode(127);\r\nconst BS = String.fromCharCode(8);\r\n\r\nexport const isEnter = (key: string): boolean => key === '\\r' || key === '\\n';\r\nexport const isSpace = (key: string): boolean => key === ' ';\r\nexport const isEsc = (key: string): boolean => key === ESC;\r\nexport const isCtrlC = (key: string): boolean => key === CTRL_C;\r\n/** DEL on most terminals, BS on some Windows shells. */\r\nexport const isBackspace = (key: string): boolean => key === DEL || key === BS;\r\nexport const isUp = (key: string): boolean => key === ESC + '[A';\r\nexport const isDown = (key: string): boolean => key === ESC + '[B';\r\nexport const isRight = (key: string): boolean => key === ESC + '[C';\r\nexport const isLeft = (key: string): boolean => key === ESC + '[D';\r\n/** A single printable character (what a text field appends). */\r\nexport const isPrintable = (key: string): boolean => key.length === 1 && key >= ' ' && key !== DEL;\r\n","/**\r\n * One-shot mount plumbing for the imperative prompts: each prompt mounts an\r\n * inline app with `persistOnExit: false` (the UI vanishes on settle) and\r\n * `exitOnCtrlC: false` (Ctrl+C becomes a cancel). On settle the live region\r\n * is erased by the unmount and a permanent summary line takes its place —\r\n * a finished wizard reads as a tidy `◇`-transcript in scrollback.\r\n *\r\n * Concurrent calls SERIALIZE through a module-level promise chain — the\r\n * renderer is a singleton, so two live prompts can never race it.\r\n */\r\nimport {\r\n    renderTerminal, getOutputTarget, writeStatic, printStatic, resolveFg,\r\n} from '@sigx/runtime-terminal';\r\nimport { resolveColor } from '../theme';\r\nimport { CANCEL } from './cancel';\r\n\r\nlet chain: Promise<unknown> = Promise.resolve();\r\nlet interactiveOverride: boolean | undefined;\r\n\r\n/** Test seam: force the interactive/non-interactive decision. */\r\nexport function __setInteractiveOverride(value?: boolean): void {\r\n    interactiveOverride = value;\r\n}\r\n\r\n/** Both ends must be a TTY: output for the live region, stdin for the keys. */\r\nexport function isInteractive(): boolean {\r\n    if (interactiveOverride !== undefined) return interactiveOverride;\r\n    return getOutputTarget().isTTY && !!process.stdin.isTTY;\r\n}\r\n\r\n/** Foreground SGR for a theme token; '' at depth none (plain output). */\r\nexport function tokenSgr(token: string): string {\r\n    return resolveFg(resolveColor(token));\r\n}\r\n\r\n/** Wrap text in a token color, with default-fg restore (never a full reset). */\r\nexport function paintToken(text: string, token: string): string {\r\n    const code = tokenSgr(token);\r\n    return code ? `${code}${text}\\x1b[39m` : text;\r\n}\r\n\r\nexport function summaryLine(kind: 'done' | 'cancel', message: string, display?: string): string {\r\n    if (kind === 'cancel') {\r\n        return `${paintToken('■', 'danger')} ${message} ${paintToken('· cancelled', 'dim')}`;\r\n    }\r\n    const tail = display !== undefined && display !== '' ? ` ${paintToken(`· ${display}`, 'dim')}` : '';\r\n    return `${paintToken('◇', 'success')} ${message}${tail}`;\r\n}\r\n\r\n/**\r\n * Serialize a task behind any prompts already in flight. Exposed to the\r\n * prompt spinner so it occupies the live region exclusively too.\r\n */\r\nexport function enqueue<T>(task: () => Promise<T>): Promise<T> {\r\n    const p = chain.then(task);\r\n    chain = p.then(() => undefined, () => undefined);\r\n    return p;\r\n}\r\n\r\nexport interface RunPromptSpec<R> {\r\n    message: string;\r\n    /** Build the prompt vnode; call `done` exactly once to settle. */\r\n    build: (done: (result: R | typeof CANCEL) => void) => unknown;\r\n    /** Human display of the result for the `◇ message · display` summary. */\r\n    display: (result: R) => string;\r\n    /** Non-interactive fallback (the prompt's initialValue, when provided). */\r\n    fallback?: () => { ok: true; value: R } | { ok: false };\r\n}\r\n\r\n/**\r\n * Note on the event loop: a prompt resolves inside the stdin data handler, so\r\n * back-to-back awaited prompts never let the loop go empty. Pure-promise work\r\n * between prompts with no other pending handles could end the process —\r\n * real async work (fs, network, timers) keeps it alive on its own.\r\n */\r\nexport function runPrompt<R>(spec: RunPromptSpec<R>): Promise<R | typeof CANCEL> {\r\n    const run = (): Promise<R | typeof CANCEL> => {\r\n        if (!isInteractive()) {\r\n            const fb = spec.fallback?.();\r\n            if (fb && fb.ok) {\r\n                printStatic(summaryLine('done', spec.message, spec.display(fb.value)));\r\n                return Promise.resolve(fb.value);\r\n            }\r\n            return Promise.reject(new Error(\r\n                `Prompt \"${spec.message}\" requires an interactive terminal — ` +\r\n                'pass the value via a CLI flag or provide initialValue.',\r\n            ));\r\n        }\r\n        return new Promise<R | typeof CANCEL>((resolve) => {\r\n            let settled = false;\r\n            const done = (result: R | typeof CANCEL) => {\r\n                if (settled) return;\r\n                settled = true;\r\n                // Order matters: unmount erases the live region and pauses\r\n                // stdin; the unmounted writeStatic then prints the summary\r\n                // exactly where the prompt stood.\r\n                handle.unmount();\r\n                writeStatic(result === CANCEL\r\n                    ? summaryLine('cancel', spec.message)\r\n                    : summaryLine('done', spec.message, spec.display(result as R)));\r\n                resolve(result);\r\n            };\r\n            const handle = renderTerminal(spec.build(done), {\r\n                mode: 'inline',\r\n                persistOnExit: false,\r\n                exitOnCtrlC: false,\r\n            });\r\n        });\r\n    };\r\n    return enqueue(run);\r\n}\r\n"],"mappings":";;;AAIA,IAAa,IAAwB,OAAO,IAAI,qBAAqB;AAGrE,SAAgB,EAAS,GAAwC;CAC7D,OAAO,MAAU;;;;ACFrB,IAAM,IAAM,QACN,IAAS,KACT,IAAM,KACN,IAAK,MAEE,KAAW,MAAyB,MAAQ,QAAQ,MAAQ,MAC5D,KAAW,MAAyB,MAAQ,KAC5C,KAAS,MAAyB,MAAQ,GAC1C,KAAW,MAAyB,MAAQ,GAE5C,KAAe,MAAyB,MAAQ,KAAO,MAAQ,GAC/D,KAAQ,MAAyB,MAAQ,IAAM,MAC/C,KAAU,MAAyB,MAAQ,IAAM,MACjD,KAAW,MAAyB,MAAQ,IAAM,MAClD,KAAU,MAAyB,MAAQ,IAAM,MAEjD,KAAe,MAAyB,EAAI,WAAW,KAAK,KAAO,OAAO,MAAQ,GCN3F,IAA0B,QAAQ,SAAS,EAC3C;AAGJ,SAAgB,EAAyB,GAAuB;CAC5D,IAAsB;;AAI1B,SAAgB,IAAyB;CAErC,OADI,MAAwB,KAAA,IACrB,GAAiB,CAAC,SAAS,CAAC,CAAC,QAAQ,MAAM,QADJ;;AAKlD,SAAgB,EAAS,GAAuB;CAC5C,OAAO,EAAU,EAAa,EAAM,CAAC;;AAIzC,SAAgB,EAAW,GAAc,GAAuB;CAC5D,IAAM,IAAO,EAAS,EAAM;CAC5B,OAAO,IAAO,GAAG,IAAO,EAAK,YAAY;;AAG7C,SAAgB,EAAY,GAAyB,GAAiB,GAA0B;CAC5F,IAAI,MAAS,UACT,OAAO,GAAG,EAAW,KAAK,SAAS,CAAC,GAAG,EAAQ,GAAG,EAAW,eAAe,MAAM;CAEtF,IAAM,IAAO,MAAY,KAAA,KAAa,MAAY,KAAK,IAAI,EAAW,KAAK,KAAW,MAAM,KAAK;CACjG,OAAO,GAAG,EAAW,KAAK,UAAU,CAAC,GAAG,IAAU;;AAOtD,SAAgB,EAAW,GAAoC;CAC3D,IAAM,IAAI,EAAM,KAAK,EAAK;CAE1B,OADA,IAAQ,EAAE,WAAW,KAAA,SAAiB,KAAA,EAAU,EACzC;;AAmBX,SAAgB,EAAa,GAAoD;CAkC7E,OAAO,QAjCuC;EAC1C,IAAI,CAAC,GAAe,EAAE;GAClB,IAAM,IAAK,EAAK,YAAY;GAK5B,OAJI,KAAM,EAAG,MACT,EAAY,EAAY,QAAQ,EAAK,SAAS,EAAK,QAAQ,EAAG,MAAM,CAAC,CAAC,EAC/D,QAAQ,QAAQ,EAAG,MAAM,IAE7B,QAAQ,OAAO,gBAAI,MACtB,WAAW,EAAK,QAAQ,6FAE3B,CAAC;;EAEN,OAAO,IAAI,SAA4B,MAAY;GAC/C,IAAI,IAAU,IAaR,IAAS,EAAe,EAAK,OAZrB,MAA8B;IACpC,MACJ,IAAU,IAIV,EAAO,SAAS,EAChB,EAAY,MAAW,IACjB,EAAY,UAAU,EAAK,QAAQ,GACnC,EAAY,QAAQ,EAAK,SAAS,EAAK,QAAQ,EAAY,CAAC,CAAC,EACnE,EAAQ,EAAO;KAE2B,EAAE;IAC5C,MAAM;IACN,eAAe;IACf,aAAa;IAChB,CAAC;IACJ;GAEa"}

package/dist/prompts/keys.d.ts

@@ -0,0 +1,12 @@
+export declare const isEnter: (key: string) => boolean;
+export declare const isSpace: (key: string) => boolean;
+export declare const isEsc: (key: string) => boolean;
+export declare const isCtrlC: (key: string) => boolean;
+/** DEL on most terminals, BS on some Windows shells. */
+export declare const isBackspace: (key: string) => boolean;
+export declare const isUp: (key: string) => boolean;
+export declare const isDown: (key: string) => boolean;
+export declare const isRight: (key: string) => boolean;
+export declare const isLeft: (key: string) => boolean;
+/** A single printable character (what a text field appends). */
+export declare const isPrintable: (key: string) => boolean;

package/dist/prompts/runPrompt.d.ts

@@ -0,0 +1,36 @@
+import { CANCEL } from './cancel';
+/** Test seam: force the interactive/non-interactive decision. */
+export declare function __setInteractiveOverride(value?: boolean): void;
+/** Both ends must be a TTY: output for the live region, stdin for the keys. */
+export declare function isInteractive(): boolean;
+/** Foreground SGR for a theme token; '' at depth none (plain output). */
+export declare function tokenSgr(token: string): string;
+/** Wrap text in a token color, with default-fg restore (never a full reset). */
+export declare function paintToken(text: string, token: string): string;
+export declare function summaryLine(kind: 'done' | 'cancel', message: string, display?: string): string;
+/**
+ * Serialize a task behind any prompts already in flight. Exposed to the
+ * prompt spinner so it occupies the live region exclusively too.
+ */
+export declare function enqueue<T>(task: () => Promise<T>): Promise<T>;
+export interface RunPromptSpec<R> {
+    message: string;
+    /** Build the prompt vnode; call `done` exactly once to settle. */
+    build: (done: (result: R | typeof CANCEL) => void) => unknown;
+    /** Human display of the result for the `◇ message · display` summary. */
+    display: (result: R) => string;
+    /** Non-interactive fallback (the prompt's initialValue, when provided). */
+    fallback?: () => {
+        ok: true;
+        value: R;
+    } | {
+        ok: false;
+    };
+}
+/**
+ * Note on the event loop: a prompt resolves inside the stdin data handler, so
+ * back-to-back awaited prompts never let the loop go empty. Pure-promise work
+ * between prompts with no other pending handles could end the process —
+ * real async work (fs, network, timers) keeps it alive on its own.
+ */
+export declare function runPrompt<R>(spec: RunPromptSpec<R>): Promise<R | typeof CANCEL>;

package/dist/shared/colorMath.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Pure color→color math for gradients and animated effects. Deliberately
+ * dependency-free: token→color stays in the theme layer, color→SGR in the
+ * renderer — this module only mixes concrete colors in between. Invalid input
+ * degrades to white instead of throwing; these run inside render functions.
+ */
+export declare function parseHex(hex: string): [number, number, number] | null;
+export declare function rgbToHex(r: number, g: number, b: number): string;
+/** Per-channel linear mix of two hex colors; `t` clamped to 0..1. */
+export declare function mixHex(a: string, b: string, t: number): string;
+/** Sample `n` colors evenly across a multi-stop gradient. */
+export declare function gradient(stops: string[], n: number): string[];
+/** Rotate a hex color's hue by `degrees` (HSL space). */
+export declare function hueShift(hex: string, degrees: number): string;

package/dist/shared/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Shared, design-system-neutral utilities for terminal components: the glyph
+ * set the SigX-tui spec standardizes on, interaction timings, and re-exports of
+ * the renderer's focus + key APIs so skins depend only on `@sigx/terminal-zero`.
+ */
+export { focusState, registerFocusable, unregisterFocusable, focus, focusNext, focusPrev, onKey, setScreenBackground, setScreenForeground, } from '@sigx/runtime-terminal';
+export { hexToSGR, resolveFg, getColorDepth, getOutputTarget, writeStatic, printStatic, displayWidth, truncateToWidth, } from '@sigx/runtime-terminal';
+export { renderTerminal, dispatchKey, type RenderTerminalOptions, type KeyLayer, type KeyHandler, } from '@sigx/runtime-terminal';
+export { charWidth, resolveBg, } from '@sigx/runtime-terminal';
+export { getTerminalSize, syncTerminalSize, } from '@sigx/runtime-terminal';
+export * from './colorMath';
+export * from './ticker';
+export * from './textBuffer';
+export * from './viewStack';
+export { generateQR } from './qr';
+/**
+ * Standard glyphs. All are width-1 in monospace fonts (Braille, geometric,
+ * box-drawing) — except the status icons, which some terminals render as 2
+ * cells; prefer them only where a trailing column is acceptable.
+ */
+export declare const GLYPHS: {
+    readonly checkboxOn: '\u25C9';
+    readonly checkboxOff: '\u25EF';
+    readonly radioOn: '\u25CF';
+    readonly radioOff: '\u25CB';
+    readonly cursor: '\u276F';
+    readonly focusBar: '\u258C';
+    readonly shadowCell: '\u2592';
+    readonly barFull: '\u2588';
+    readonly barEmpty: '\u2591';
+    readonly barEighths: readonly string[];
+    readonly check: '\u2714';
+    readonly cross: '\u2716';
+    readonly warn: '\u26A0';
+    readonly info: '\u2139';
+    readonly spinner: readonly string[];
+};
+/**
+ * Spinner frame sets, selectable via the Spinner `variant` prop. All width-1
+ * except `moon` (emoji — 2 cells; use where a wider glyph column is fine).
+ */
+export declare const SPINNERS: {
+    readonly dots: readonly string[];
+    readonly line: readonly ["—", "\\", "|", "/"];
+    readonly arc: readonly ["◜", "◠", "◝", "◞", "◡", "◟"];
+    readonly circle: readonly ["◐", "◓", "◑", "◒"];
+    readonly bounce: readonly ["▁", "▃", "▄", "▅", "▆", "▇", "▆", "▅", "▄", "▃"];
+    readonly moon: readonly ["🌑", "🌒", "🌓", "🌔", "🌕", "🌖", "🌗", "🌘"];
+};
+export type SpinnerVariant = keyof typeof SPINNERS;
+/** Milliseconds a button stays in its visual "pressed" state after activation. */
+export declare const PRESS_MS = 120;
+/** Milliseconds to ignore input after mount (debounces the activating Enter). */
+export declare const READY_DELAY_MS = 50;