semola 0.5.0 → 0.5.2

package/dist/prompts/core/keys.cjs

@@ -0,0 +1,165 @@
+//#region src/lib/prompts/core/keys.ts
+const ESC = "\x1B";
+const CSI = "\x1B[";
+const ESC_BACKSPACE = `${ESC}\u007F`;
+const CHAR_KEY_MAP = new Map(Object.values({
+	enterCr: {
+		value: "\r",
+		name: "enter"
+	},
+	enterLf: {
+		value: "\n",
+		name: "enter"
+	},
+	ctrlA: {
+		value: "
",
+		name: "ctrl_a"
+	},
+	ctrlC: {
+		value: "",
+		name: "ctrl_c"
+	},
+	ctrlBackspace: {
+		value: "",
+		name: "ctrl_backspace"
+	},
+	backspace: {
+		value: "",
+		name: "backspace"
+	},
+	tab: {
+		value: "	",
+		name: "tab"
+	},
+	space: {
+		value: " ",
+		name: "space"
+	}
+}).map((entry) => [entry.value, { name: entry.name }]));
+const KNOWN_SEQUENCES = [
+	{
+		sequence: "\x1B[1;2D",
+		key: { name: "shift_left" }
+	},
+	{
+		sequence: "\x1B[1;2C",
+		key: { name: "shift_right" }
+	},
+	{
+		sequence: "\x1B[1;5D",
+		key: { name: "ctrl_left" }
+	},
+	{
+		sequence: "\x1B[1;5C",
+		key: { name: "ctrl_right" }
+	},
+	{
+		sequence: "\x1B[1;6D",
+		key: { name: "shift_ctrl_left" }
+	},
+	{
+		sequence: "\x1B[1;6C",
+		key: { name: "shift_ctrl_right" }
+	},
+	{
+		sequence: "\x1B[3~",
+		key: { name: "delete" }
+	},
+	{
+		sequence: "\x1B[H",
+		key: { name: "home" }
+	},
+	{
+		sequence: "\x1B[F",
+		key: { name: "end" }
+	},
+	{
+		sequence: "\x1B[A",
+		key: { name: "up" }
+	},
+	{
+		sequence: "\x1B[B",
+		key: { name: "down" }
+	},
+	{
+		sequence: "\x1B[C",
+		key: { name: "right" }
+	},
+	{
+		sequence: "\x1B[D",
+		key: { name: "left" }
+	}
+];
+const isControlChar = (char) => {
+	return char <= "" || char === "";
+};
+const isCsiFinalByte = (char) => {
+	if (!char) return false;
+	if (char >= "A" && char <= "Z") return true;
+	if (char >= "a" && char <= "z") return true;
+	if (char === "~") return true;
+	return false;
+};
+const readCsiLength = (remaining) => {
+	if (!remaining.startsWith(CSI)) return null;
+	let index = 2;
+	while (index < remaining.length) {
+		if (isCsiFinalByte(remaining[index] ?? "")) return {
+			length: index + 1,
+			incomplete: false
+		};
+		index += 1;
+	}
+	return {
+		length: 0,
+		incomplete: true
+	};
+};
+const parseKeys = (chunk) => {
+	const keys = [];
+	let cursor = 0;
+	while (cursor < chunk.length) {
+		const remaining = chunk.slice(cursor);
+		if (remaining.startsWith(ESC_BACKSPACE)) {
+			keys.push({ name: "ctrl_backspace" });
+			cursor += 2;
+			continue;
+		}
+		const knownSequence = KNOWN_SEQUENCES.find((entry) => remaining.startsWith(entry.sequence));
+		if (knownSequence) {
+			keys.push(knownSequence.key);
+			cursor += knownSequence.sequence.length;
+			continue;
+		}
+		const csiLength = readCsiLength(remaining);
+		if (csiLength) {
+			if (csiLength.incomplete) return {
+				keys,
+				remaining: chunk.slice(cursor)
+			};
+			cursor += csiLength.length;
+			continue;
+		}
+		const char = chunk[cursor] ?? "";
+		switch (char) {
+			case ESC:
+				if (cursor === chunk.length - 1) keys.push({ name: "escape" });
+				break;
+			default: {
+				const key = CHAR_KEY_MAP.get(char);
+				if (key) keys.push(key);
+				else if (!isControlChar(char)) keys.push({
+					name: "character",
+					value: char
+				});
+			}
+		}
+		cursor += 1;
+	}
+	return {
+		keys,
+		remaining: ""
+	};
+};
+//#endregion
+exports.parseKeys = parseKeys;

package/dist/prompts/core/keys.mjs

@@ -0,0 +1,167 @@
+//#region src/lib/prompts/core/keys.ts
+const ESC = "\x1B";
+const CSI = "\x1B[";
+const ESC_BACKSPACE = `${ESC}\u007F`;
+const CHAR_KEY_MAP = new Map(Object.values({
+	enterCr: {
+		value: "\r",
+		name: "enter"
+	},
+	enterLf: {
+		value: "\n",
+		name: "enter"
+	},
+	ctrlA: {
+		value: "
",
+		name: "ctrl_a"
+	},
+	ctrlC: {
+		value: "",
+		name: "ctrl_c"
+	},
+	ctrlBackspace: {
+		value: "",
+		name: "ctrl_backspace"
+	},
+	backspace: {
+		value: "",
+		name: "backspace"
+	},
+	tab: {
+		value: "	",
+		name: "tab"
+	},
+	space: {
+		value: " ",
+		name: "space"
+	}
+}).map((entry) => [entry.value, { name: entry.name }]));
+const KNOWN_SEQUENCES = [
+	{
+		sequence: "\x1B[1;2D",
+		key: { name: "shift_left" }
+	},
+	{
+		sequence: "\x1B[1;2C",
+		key: { name: "shift_right" }
+	},
+	{
+		sequence: "\x1B[1;5D",
+		key: { name: "ctrl_left" }
+	},
+	{
+		sequence: "\x1B[1;5C",
+		key: { name: "ctrl_right" }
+	},
+	{
+		sequence: "\x1B[1;6D",
+		key: { name: "shift_ctrl_left" }
+	},
+	{
+		sequence: "\x1B[1;6C",
+		key: { name: "shift_ctrl_right" }
+	},
+	{
+		sequence: "\x1B[3~",
+		key: { name: "delete" }
+	},
+	{
+		sequence: "\x1B[H",
+		key: { name: "home" }
+	},
+	{
+		sequence: "\x1B[F",
+		key: { name: "end" }
+	},
+	{
+		sequence: "\x1B[A",
+		key: { name: "up" }
+	},
+	{
+		sequence: "\x1B[B",
+		key: { name: "down" }
+	},
+	{
+		sequence: "\x1B[C",
+		key: { name: "right" }
+	},
+	{
+		sequence: "\x1B[D",
+		key: { name: "left" }
+	}
+];
+const isControlChar = (char) => {
+	return char <= "" || char === "";
+};
+const isCsiFinalByte = (char) => {
+	if (!char) return false;
+	if (char >= "A" && char <= "Z") return true;
+	if (char >= "a" && char <= "z") return true;
+	if (char === "~") return true;
+	return false;
+};
+const readCsiLength = (remaining) => {
+	if (!remaining.startsWith(CSI)) return null;
+	let index = 2;
+	while (index < remaining.length) {
+		if (isCsiFinalByte(remaining[index] ?? "")) return {
+			length: index + 1,
+			incomplete: false
+		};
+		index += 1;
+	}
+	return {
+		length: 0,
+		incomplete: true
+	};
+};
+const parseKeys = (chunk) => {
+	const keys = [];
+	let cursor = 0;
+	while (cursor < chunk.length) {
+		const remaining = chunk.slice(cursor);
+		if (remaining.startsWith(ESC_BACKSPACE)) {
+			keys.push({ name: "ctrl_backspace" });
+			cursor += 2;
+			continue;
+		}
+		const knownSequence = KNOWN_SEQUENCES.find((entry) => remaining.startsWith(entry.sequence));
+		if (knownSequence) {
+			keys.push(knownSequence.key);
+			cursor += knownSequence.sequence.length;
+			continue;
+		}
+		const csiLength = readCsiLength(remaining);
+		if (csiLength) {
+			if (csiLength.incomplete) return {
+				keys,
+				remaining: chunk.slice(cursor)
+			};
+			cursor += csiLength.length;
+			continue;
+		}
+		const char = chunk[cursor] ?? "";
+		switch (char) {
+			case ESC:
+				if (cursor === chunk.length - 1) keys.push({ name: "escape" });
+				break;
+			default: {
+				const key = CHAR_KEY_MAP.get(char);
+				if (key) keys.push(key);
+				else if (!isControlChar(char)) keys.push({
+					name: "character",
+					value: char
+				});
+			}
+		}
+		cursor += 1;
+	}
+	return {
+		keys,
+		remaining: ""
+	};
+};
+//#endregion
+export { parseKeys };
+
+//# sourceMappingURL=keys.mjs.map

package/dist/prompts/core/keys.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"keys.mjs","names":[],"sources":["../../../src/lib/prompts/core/keys.ts"],"sourcesContent":["import type { Key, KeyName } from \"./types.js\";\n\nconst ESC = \"\\u001B\";\nconst CSI = \"\\u001B[\";\nconst ESC_BACKSPACE = `${ESC}\\u007F`;\n\nconst CHAR_KEYS = {\n  enterCr: { value: \"\\r\", name: \"enter\" },\n  enterLf: { value: \"\\n\", name: \"enter\" },\n  ctrlA: { value: \"\\u0001\", name: \"ctrl_a\" },\n  ctrlC: { value: \"\\u0003\", name: \"ctrl_c\" },\n  ctrlBackspace: { value: \"\\u0017\", name: \"ctrl_backspace\" },\n  backspace: { value: \"\\u007F\", name: \"backspace\" },\n  tab: { value: \"\\t\", name: \"tab\" },\n  space: { value: \" \", name: \"space\" },\n} satisfies Record<string, { value: string; name: KeyName }>;\n\nconst CHAR_KEY_MAP = new Map<string, Key>(\n  Object.values(CHAR_KEYS).map((entry) => [entry.value, { name: entry.name }]),\n);\n\nconst KNOWN_SEQUENCES = [\n  { sequence: \"\\u001B[1;2D\", key: { name: \"shift_left\" } },\n  { sequence: \"\\u001B[1;2C\", key: { name: \"shift_right\" } },\n  { sequence: \"\\u001B[1;5D\", key: { name: \"ctrl_left\" } },\n  { sequence: \"\\u001B[1;5C\", key: { name: \"ctrl_right\" } },\n  { sequence: \"\\u001B[1;6D\", key: { name: \"shift_ctrl_left\" } },\n  { sequence: \"\\u001B[1;6C\", key: { name: \"shift_ctrl_right\" } },\n  { sequence: \"\\u001B[3~\", key: { name: \"delete\" } },\n  { sequence: \"\\u001B[H\", key: { name: \"home\" } },\n  { sequence: \"\\u001B[F\", key: { name: \"end\" } },\n  { sequence: \"\\u001B[A\", key: { name: \"up\" } },\n  { sequence: \"\\u001B[B\", key: { name: \"down\" } },\n  { sequence: \"\\u001B[C\", key: { name: \"right\" } },\n  { sequence: \"\\u001B[D\", key: { name: \"left\" } },\n] as const;\n\nconst isControlChar = (char: string) => {\n  return char <= \"\\u001F\" || char === \"\\u007F\";\n};\n\nconst isCsiFinalByte = (char: string) => {\n  if (!char) {\n    return false;\n  }\n\n  if (char >= \"A\" && char <= \"Z\") {\n    return true;\n  }\n\n  if (char >= \"a\" && char <= \"z\") {\n    return true;\n  }\n\n  if (char === \"~\") {\n    return true;\n  }\n\n  return false;\n};\n\nconst readCsiLength = (remaining: string) => {\n  if (!remaining.startsWith(CSI)) {\n    return null;\n  }\n\n  let index = CSI.length;\n\n  while (index < remaining.length) {\n    const char = remaining[index] ?? \"\";\n\n    if (isCsiFinalByte(char)) {\n      return { length: index + 1, incomplete: false };\n    }\n\n    index += 1;\n  }\n\n  return { length: 0, incomplete: true };\n};\n\nexport const parseKeys = (chunk: string) => {\n  const keys: Key[] = [];\n\n  let cursor = 0;\n\n  while (cursor < chunk.length) {\n    const remaining = chunk.slice(cursor);\n\n    if (remaining.startsWith(ESC_BACKSPACE)) {\n      keys.push({ name: \"ctrl_backspace\" });\n      cursor += 2;\n      continue;\n    }\n\n    const knownSequence = KNOWN_SEQUENCES.find((entry) =>\n      remaining.startsWith(entry.sequence),\n    );\n\n    if (knownSequence) {\n      keys.push(knownSequence.key);\n      cursor += knownSequence.sequence.length;\n      continue;\n    }\n\n    const csiLength = readCsiLength(remaining);\n\n    if (csiLength) {\n      if (csiLength.incomplete) {\n        return { keys, remaining: chunk.slice(cursor) };\n      }\n\n      cursor += csiLength.length;\n      continue;\n    }\n\n    const char = chunk[cursor] ?? \"\";\n\n    switch (char) {\n      case ESC: {\n        if (cursor === chunk.length - 1) {\n          keys.push({ name: \"escape\" });\n        }\n        break;\n      }\n      default: {\n        const key = CHAR_KEY_MAP.get(char);\n\n        if (key) {\n          keys.push(key);\n        } else if (!isControlChar(char)) {\n          keys.push({ name: \"character\", value: char });\n        }\n      }\n    }\n\n    cursor += 1;\n  }\n\n  return { keys, remaining: \"\" };\n};\n"],"mappings":";AAEA,MAAM,MAAM;AACZ,MAAM,MAAM;AACZ,MAAM,gBAAgB,GAAG,IAAI;AAa7B,MAAM,eAAe,IAAI,IACvB,OAAO,OAZS;CAChB,SAAS;EAAE,OAAO;EAAM,MAAM;EAAS;CACvC,SAAS;EAAE,OAAO;EAAM,MAAM;EAAS;CACvC,OAAO;EAAE,OAAO;EAAU,MAAM;EAAU;CAC1C,OAAO;EAAE,OAAO;EAAU,MAAM;EAAU;CAC1C,eAAe;EAAE,OAAO;EAAU,MAAM;EAAkB;CAC1D,WAAW;EAAE,OAAO;EAAU,MAAM;EAAa;CACjD,KAAK;EAAE,OAAO;EAAM,MAAM;EAAO;CACjC,OAAO;EAAE,OAAO;EAAK,MAAM;EAAS;CACrC,CAGyB,CAAC,KAAK,UAAU,CAAC,MAAM,OAAO,EAAE,MAAM,MAAM,MAAM,CAAC,CAAC,CAC7E;AAED,MAAM,kBAAkB;CACtB;EAAE,UAAU;EAAe,KAAK,EAAE,MAAM,cAAc;EAAE;CACxD;EAAE,UAAU;EAAe,KAAK,EAAE,MAAM,eAAe;EAAE;CACzD;EAAE,UAAU;EAAe,KAAK,EAAE,MAAM,aAAa;EAAE;CACvD;EAAE,UAAU;EAAe,KAAK,EAAE,MAAM,cAAc;EAAE;CACxD;EAAE,UAAU;EAAe,KAAK,EAAE,MAAM,mBAAmB;EAAE;CAC7D;EAAE,UAAU;EAAe,KAAK,EAAE,MAAM,oBAAoB;EAAE;CAC9D;EAAE,UAAU;EAAa,KAAK,EAAE,MAAM,UAAU;EAAE;CAClD;EAAE,UAAU;EAAY,KAAK,EAAE,MAAM,QAAQ;EAAE;CAC/C;EAAE,UAAU;EAAY,KAAK,EAAE,MAAM,OAAO;EAAE;CAC9C;EAAE,UAAU;EAAY,KAAK,EAAE,MAAM,MAAM;EAAE;CAC7C;EAAE,UAAU;EAAY,KAAK,EAAE,MAAM,QAAQ;EAAE;CAC/C;EAAE,UAAU;EAAY,KAAK,EAAE,MAAM,SAAS;EAAE;CAChD;EAAE,UAAU;EAAY,KAAK,EAAE,MAAM,QAAQ;EAAE;CAChD;AAED,MAAM,iBAAiB,SAAiB;AACtC,QAAO,QAAQ,OAAY,SAAS;;AAGtC,MAAM,kBAAkB,SAAiB;AACvC,KAAI,CAAC,KACH,QAAO;AAGT,KAAI,QAAQ,OAAO,QAAQ,IACzB,QAAO;AAGT,KAAI,QAAQ,OAAO,QAAQ,IACzB,QAAO;AAGT,KAAI,SAAS,IACX,QAAO;AAGT,QAAO;;AAGT,MAAM,iBAAiB,cAAsB;AAC3C,KAAI,CAAC,UAAU,WAAW,IAAI,CAC5B,QAAO;CAGT,IAAI,QAAQ;AAEZ,QAAO,QAAQ,UAAU,QAAQ;AAG/B,MAAI,eAFS,UAAU,UAAU,GAET,CACtB,QAAO;GAAE,QAAQ,QAAQ;GAAG,YAAY;GAAO;AAGjD,WAAS;;AAGX,QAAO;EAAE,QAAQ;EAAG,YAAY;EAAM;;AAGxC,MAAa,aAAa,UAAkB;CAC1C,MAAM,OAAc,EAAE;CAEtB,IAAI,SAAS;AAEb,QAAO,SAAS,MAAM,QAAQ;EAC5B,MAAM,YAAY,MAAM,MAAM,OAAO;AAErC,MAAI,UAAU,WAAW,cAAc,EAAE;AACvC,QAAK,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACrC,aAAU;AACV;;EAGF,MAAM,gBAAgB,gBAAgB,MAAM,UAC1C,UAAU,WAAW,MAAM,SAAS,CACrC;AAED,MAAI,eAAe;AACjB,QAAK,KAAK,cAAc,IAAI;AAC5B,aAAU,cAAc,SAAS;AACjC;;EAGF,MAAM,YAAY,cAAc,UAAU;AAE1C,MAAI,WAAW;AACb,OAAI,UAAU,WACZ,QAAO;IAAE;IAAM,WAAW,MAAM,MAAM,OAAO;IAAE;AAGjD,aAAU,UAAU;AACpB;;EAGF,MAAM,OAAO,MAAM,WAAW;AAE9B,UAAQ,MAAR;GACE,KAAK;AACH,QAAI,WAAW,MAAM,SAAS,EAC5B,MAAK,KAAK,EAAE,MAAM,UAAU,CAAC;AAE/B;GAEF,SAAS;IACP,MAAM,MAAM,aAAa,IAAI,KAAK;AAElC,QAAI,IACF,MAAK,KAAK,IAAI;aACL,CAAC,cAAc,KAAK,CAC7B,MAAK,KAAK;KAAE,MAAM;KAAa,OAAO;KAAM,CAAC;;;AAKnD,YAAU;;AAGZ,QAAO;EAAE;EAAM,WAAW;EAAI"}

package/dist/prompts/core/runtime.cjs

@@ -0,0 +1,104 @@
+const require_lib_errors_index = require("../../lib/errors/index.cjs");
+const require_keys = require("./keys.cjs");
+//#region src/lib/prompts/core/runtime.ts
+const HIDE_CURSOR = "\x1B[?25l";
+const SHOW_CURSOR = "\x1B[?25h";
+const countLines = (text) => {
+	let count = 1;
+	for (let i = 0; i < text.length; i++) if (text[i] === "\n") count += 1;
+	return count;
+};
+var NodePromptRuntime = class {
+	stdin;
+	stdout;
+	queue = [];
+	waiters = [];
+	initialized = false;
+	previousLines = 0;
+	buffer = "";
+	constructor(stdin = process.stdin, stdout = process.stdout) {
+		this.stdin = stdin;
+		this.stdout = stdout;
+	}
+	isInteractive() {
+		return Boolean(this.stdin.isTTY && this.stdout.isTTY && typeof this.stdin.setRawMode === "function");
+	}
+	init() {
+		if (!this.isInteractive()) return require_lib_errors_index.err("PromptEnvironmentError", "Interactive prompts require a TTY with raw mode support");
+		if (this.initialized) return require_lib_errors_index.ok(void 0);
+		const [initError] = require_lib_errors_index.mightThrowSync(() => {
+			this.stdin.setRawMode(true);
+			this.stdin.setEncoding("utf8");
+			this.stdin.resume();
+			this.stdin.on("data", this.onData);
+			this.stdout.write(HIDE_CURSOR);
+		});
+		if (initError) return require_lib_errors_index.err("PromptIOError", "Unable to initialize prompt runtime");
+		this.initialized = true;
+		return require_lib_errors_index.ok(void 0);
+	}
+	readKey() {
+		const queued = this.queue.shift();
+		if (queued) return Promise.resolve(require_lib_errors_index.ok(queued));
+		return new Promise((resolve) => {
+			this.waiters.push(resolve);
+		});
+	}
+	render(frame) {
+		const [renderError] = require_lib_errors_index.mightThrowSync(() => {
+			if (this.previousLines > 1) this.stdout.write(`\u001B[${this.previousLines - 1}A`);
+			this.stdout.write("\r\x1B[J");
+			this.stdout.write(frame);
+			this.previousLines = countLines(frame);
+		});
+		if (renderError) return require_lib_errors_index.err("PromptIOError", "Unable to render prompt frame");
+		return require_lib_errors_index.ok(void 0);
+	}
+	done(frame) {
+		const [doneError] = require_lib_errors_index.mightThrowSync(() => {
+			if (this.previousLines > 1) this.stdout.write(`\u001B[${this.previousLines - 1}A`);
+			this.stdout.write("\r\x1B[J");
+			this.stdout.write(`${frame}\n`);
+			this.previousLines = 0;
+		});
+		if (doneError) return require_lib_errors_index.err("PromptIOError", "Unable to finalize prompt frame");
+		return require_lib_errors_index.ok(void 0);
+	}
+	close() {
+		if (!this.initialized) return require_lib_errors_index.ok(void 0);
+		this.initialized = false;
+		const [closeError] = require_lib_errors_index.mightThrowSync(() => {
+			this.stdin.off("data", this.onData);
+			this.stdin.setRawMode(false);
+			this.stdin.pause?.();
+			this.stdout.write(SHOW_CURSOR);
+		});
+		if (closeError) return require_lib_errors_index.err("PromptIOError", "Unable to close prompt runtime");
+		return require_lib_errors_index.ok(void 0);
+	}
+	interrupt() {
+		this.close();
+		process.exit(0);
+	}
+	onData = (chunk) => {
+		const value = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+		const combined = `${this.buffer}${value}`;
+		this.buffer = "";
+		const [parseError, result] = require_lib_errors_index.mightThrowSync(() => require_keys.parseKeys(combined));
+		if (parseError || !result) {
+			for (const waiter of this.waiters.splice(0)) waiter(require_lib_errors_index.err("PromptIOError", "Failed to parse input"));
+			return;
+		}
+		this.buffer = result.remaining;
+		for (const key of result.keys) {
+			const waiter = this.waiters.shift();
+			if (waiter) waiter(require_lib_errors_index.ok(key));
+			else this.queue.push(key);
+		}
+	};
+};
+const createNodePromptRuntime = () => {
+	return new NodePromptRuntime();
+};
+//#endregion
+exports.createNodePromptRuntime = createNodePromptRuntime;

package/dist/prompts/core/runtime.mjs

@@ -0,0 +1,106 @@
+import { err, mightThrowSync, ok } from "../../lib/errors/index.mjs";
+import { parseKeys } from "./keys.mjs";
+//#region src/lib/prompts/core/runtime.ts
+const HIDE_CURSOR = "\x1B[?25l";
+const SHOW_CURSOR = "\x1B[?25h";
+const countLines = (text) => {
+	let count = 1;
+	for (let i = 0; i < text.length; i++) if (text[i] === "\n") count += 1;
+	return count;
+};
+var NodePromptRuntime = class {
+	stdin;
+	stdout;
+	queue = [];
+	waiters = [];
+	initialized = false;
+	previousLines = 0;
+	buffer = "";
+	constructor(stdin = process.stdin, stdout = process.stdout) {
+		this.stdin = stdin;
+		this.stdout = stdout;
+	}
+	isInteractive() {
+		return Boolean(this.stdin.isTTY && this.stdout.isTTY && typeof this.stdin.setRawMode === "function");
+	}
+	init() {
+		if (!this.isInteractive()) return err("PromptEnvironmentError", "Interactive prompts require a TTY with raw mode support");
+		if (this.initialized) return ok(void 0);
+		const [initError] = mightThrowSync(() => {
+			this.stdin.setRawMode(true);
+			this.stdin.setEncoding("utf8");
+			this.stdin.resume();
+			this.stdin.on("data", this.onData);
+			this.stdout.write(HIDE_CURSOR);
+		});
+		if (initError) return err("PromptIOError", "Unable to initialize prompt runtime");
+		this.initialized = true;
+		return ok(void 0);
+	}
+	readKey() {
+		const queued = this.queue.shift();
+		if (queued) return Promise.resolve(ok(queued));
+		return new Promise((resolve) => {
+			this.waiters.push(resolve);
+		});
+	}
+	render(frame) {
+		const [renderError] = mightThrowSync(() => {
+			if (this.previousLines > 1) this.stdout.write(`\u001B[${this.previousLines - 1}A`);
+			this.stdout.write("\r\x1B[J");
+			this.stdout.write(frame);
+			this.previousLines = countLines(frame);
+		});
+		if (renderError) return err("PromptIOError", "Unable to render prompt frame");
+		return ok(void 0);
+	}
+	done(frame) {
+		const [doneError] = mightThrowSync(() => {
+			if (this.previousLines > 1) this.stdout.write(`\u001B[${this.previousLines - 1}A`);
+			this.stdout.write("\r\x1B[J");
+			this.stdout.write(`${frame}\n`);
+			this.previousLines = 0;
+		});
+		if (doneError) return err("PromptIOError", "Unable to finalize prompt frame");
+		return ok(void 0);
+	}
+	close() {
+		if (!this.initialized) return ok(void 0);
+		this.initialized = false;
+		const [closeError] = mightThrowSync(() => {
+			this.stdin.off("data", this.onData);
+			this.stdin.setRawMode(false);
+			this.stdin.pause?.();
+			this.stdout.write(SHOW_CURSOR);
+		});
+		if (closeError) return err("PromptIOError", "Unable to close prompt runtime");
+		return ok(void 0);
+	}
+	interrupt() {
+		this.close();
+		process.exit(0);
+	}
+	onData = (chunk) => {
+		const value = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+		const combined = `${this.buffer}${value}`;
+		this.buffer = "";
+		const [parseError, result] = mightThrowSync(() => parseKeys(combined));
+		if (parseError || !result) {
+			for (const waiter of this.waiters.splice(0)) waiter(err("PromptIOError", "Failed to parse input"));
+			return;
+		}
+		this.buffer = result.remaining;
+		for (const key of result.keys) {
+			const waiter = this.waiters.shift();
+			if (waiter) waiter(ok(key));
+			else this.queue.push(key);
+		}
+	};
+};
+const createNodePromptRuntime = () => {
+	return new NodePromptRuntime();
+};
+//#endregion
+export { createNodePromptRuntime };
+
+//# sourceMappingURL=runtime.mjs.map

package/dist/prompts/core/runtime.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.mjs","names":[],"sources":["../../../src/lib/prompts/core/runtime.ts"],"sourcesContent":["import { err, mightThrowSync, ok } from \"../../errors/index.js\";\nimport { parseKeys } from \"./keys.js\";\nimport type { Key, PromptResultLike, PromptRuntime } from \"./types.js\";\n\nconst HIDE_CURSOR = \"\\u001B[?25l\";\nconst SHOW_CURSOR = \"\\u001B[?25h\";\n\nconst countLines = (text: string) => {\n  let count = 1;\n\n  for (let i = 0; i < text.length; i++) {\n    if (text[i] === \"\\n\") {\n      count += 1;\n    }\n  }\n\n  return count;\n};\n\ntype StdinLike = {\n  isTTY?: boolean;\n  setRawMode: (mode: boolean) => void;\n  setEncoding: (encoding: BufferEncoding) => void;\n  resume: () => void;\n  pause?: () => void;\n  on: (event: string, listener: (chunk: Buffer | string) => void) => unknown;\n  off: (event: string, listener: (chunk: Buffer | string) => void) => unknown;\n};\n\ntype StdoutLike = {\n  isTTY?: boolean;\n  write: (chunk: string) => boolean;\n};\n\nexport class NodePromptRuntime implements PromptRuntime {\n  private readonly stdin: StdinLike;\n  private readonly stdout: StdoutLike;\n  private readonly queue: Key[] = [];\n  private readonly waiters: Array<(result: PromptResultLike<Key>) => void> = [];\n  private initialized = false;\n  private previousLines = 0;\n  private buffer = \"\";\n\n  public constructor(\n    stdin: StdinLike = process.stdin,\n    stdout: StdoutLike = process.stdout,\n  ) {\n    this.stdin = stdin;\n    this.stdout = stdout;\n  }\n\n  public isInteractive() {\n    return Boolean(\n      this.stdin.isTTY &&\n        this.stdout.isTTY &&\n        typeof this.stdin.setRawMode === \"function\",\n    );\n  }\n\n  public init() {\n    if (!this.isInteractive()) {\n      return err(\n        \"PromptEnvironmentError\",\n        \"Interactive prompts require a TTY with raw mode support\",\n      );\n    }\n\n    if (this.initialized) {\n      return ok(undefined);\n    }\n\n    const [initError] = mightThrowSync(() => {\n      this.stdin.setRawMode(true);\n      this.stdin.setEncoding(\"utf8\");\n      this.stdin.resume();\n      this.stdin.on(\"data\", this.onData);\n      this.stdout.write(HIDE_CURSOR);\n    });\n\n    if (initError) {\n      return err(\"PromptIOError\", \"Unable to initialize prompt runtime\");\n    }\n\n    this.initialized = true;\n    return ok(undefined);\n  }\n\n  public readKey(): Promise<PromptResultLike<Key>> {\n    const queued = this.queue.shift();\n\n    if (queued) {\n      return Promise.resolve(ok(queued));\n    }\n\n    return new Promise<PromptResultLike<Key>>((resolve) => {\n      this.waiters.push(resolve);\n    });\n  }\n\n  public render(frame: string) {\n    const [renderError] = mightThrowSync(() => {\n      if (this.previousLines > 1) {\n        this.stdout.write(`\\u001B[${this.previousLines - 1}A`);\n      }\n\n      this.stdout.write(\"\\r\\u001B[J\");\n      this.stdout.write(frame);\n\n      this.previousLines = countLines(frame);\n    });\n\n    if (renderError) {\n      return err(\"PromptIOError\", \"Unable to render prompt frame\");\n    }\n\n    return ok(undefined);\n  }\n\n  public done(frame: string) {\n    const [doneError] = mightThrowSync(() => {\n      if (this.previousLines > 1) {\n        this.stdout.write(`\\u001B[${this.previousLines - 1}A`);\n      }\n\n      this.stdout.write(\"\\r\\u001B[J\");\n      this.stdout.write(`${frame}\\n`);\n      this.previousLines = 0;\n    });\n\n    if (doneError) {\n      return err(\"PromptIOError\", \"Unable to finalize prompt frame\");\n    }\n\n    return ok(undefined);\n  }\n\n  public close() {\n    if (!this.initialized) {\n      return ok(undefined);\n    }\n\n    this.initialized = false;\n\n    const [closeError] = mightThrowSync(() => {\n      this.stdin.off(\"data\", this.onData);\n      this.stdin.setRawMode(false);\n      this.stdin.pause?.();\n      this.stdout.write(SHOW_CURSOR);\n    });\n\n    if (closeError) {\n      return err(\"PromptIOError\", \"Unable to close prompt runtime\");\n    }\n\n    return ok(undefined);\n  }\n\n  public interrupt(): never {\n    this.close();\n    process.exit(0);\n  }\n\n  private onData = (chunk: Buffer | string) => {\n    const value = typeof chunk === \"string\" ? chunk : chunk.toString(\"utf8\");\n    const combined = `${this.buffer}${value}`;\n    this.buffer = \"\";\n\n    const [parseError, result] = mightThrowSync(() => parseKeys(combined));\n\n    if (parseError || !result) {\n      for (const waiter of this.waiters.splice(0)) {\n        waiter(err(\"PromptIOError\", \"Failed to parse input\"));\n      }\n\n      return;\n    }\n\n    this.buffer = result.remaining;\n\n    for (const key of result.keys) {\n      const waiter = this.waiters.shift();\n\n      if (waiter) {\n        waiter(ok(key));\n      } else {\n        this.queue.push(key);\n      }\n    }\n  };\n}\n\nexport const createNodePromptRuntime = () => {\n  return new NodePromptRuntime();\n};\n"],"mappings":"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"}

package/dist/prompts/core/session.cjs

@@ -0,0 +1,98 @@
+const require_lib_errors_index = require("../../lib/errors/index.cjs");
+//#region src/lib/prompts/core/session.ts
+const CANCEL_MESSAGE = "Interrupted, bye!";
+const resolveOutput = async (options, value) => {
+	if (!options.transform) return require_lib_errors_index.ok(value);
+	const [transformError, transformed] = await require_lib_errors_index.mightThrow(Promise.resolve().then(() => options.transform?.(value)));
+	if (transformError || transformed === null || transformed === void 0) return require_lib_errors_index.err("PromptIOError", "Prompt transform callback failed unexpectedly");
+	return require_lib_errors_index.ok(transformed);
+};
+const runValidation = async (options, value) => {
+	if (!options.validate) return require_lib_errors_index.ok(null);
+	const [validationError, validationMessage] = await require_lib_errors_index.mightThrow(Promise.resolve().then(() => options.validate?.(value)));
+	if (validationError) return require_lib_errors_index.err("PromptIOError", "Prompt validate callback failed unexpectedly");
+	if (typeof validationMessage === "string" && validationMessage.length > 0) return require_lib_errors_index.ok(validationMessage);
+	return require_lib_errors_index.ok(null);
+};
+const isCancelKey = (key) => {
+	if (key.name === "ctrl_c") return true;
+	if (key.name === "escape") return true;
+	return false;
+};
+const runPromptSession = async (params) => {
+	const [initError] = params.runtime.init();
+	if (initError) return require_lib_errors_index.err(initError.type, initError.message);
+	let state = params.initialState;
+	let errorMessage = null;
+	const closeAndDone = (message) => {
+		const [closeErr] = params.runtime.close();
+		if (closeErr) return require_lib_errors_index.err(closeErr.type, closeErr.message);
+		const [doneErr] = params.runtime.done(message);
+		if (doneErr) return require_lib_errors_index.err(doneErr.type, doneErr.message);
+		return null;
+	};
+	while (true) {
+		const [renderError] = params.runtime.render(params.render({
+			options: params.options,
+			state,
+			errorMessage
+		}));
+		if (renderError) {
+			params.runtime.close();
+			return require_lib_errors_index.err(renderError.type, renderError.message);
+		}
+		const [readError, key] = await params.runtime.readKey();
+		if (readError || !key) {
+			params.runtime.close();
+			return require_lib_errors_index.err(readError?.type ?? "PromptIOError", readError?.message ?? "Unable to read prompt input");
+		}
+		if (isCancelKey(key)) {
+			const [closeError] = params.runtime.close();
+			if (closeError) return require_lib_errors_index.err(closeError.type, closeError.message);
+			const [doneError] = params.runtime.done(`✖ ${CANCEL_MESSAGE}`);
+			if (doneError) return require_lib_errors_index.err(doneError.type, doneError.message);
+			if (params.runtime.interrupt) {
+				const [interruptError] = params.runtime.interrupt(CANCEL_MESSAGE);
+				if (interruptError) return require_lib_errors_index.err(interruptError.type, interruptError.message);
+			}
+			return require_lib_errors_index.err("PromptCancelledError", CANCEL_MESSAGE);
+		}
+		if (key.name !== "enter") {
+			state = params.onKey(state, key);
+			errorMessage = null;
+			continue;
+		}
+		const submitResult = params.onSubmit(state);
+		if ("errorMessage" in submitResult) {
+			errorMessage = submitResult.errorMessage;
+			continue;
+		}
+		const rawValue = submitResult.value;
+		const [validationRunError, validationErrorMessage] = await runValidation(params.options, rawValue);
+		if (validationRunError) {
+			const closeDoneErr = closeAndDone(`✖ ${params.options.message}`);
+			if (closeDoneErr) return closeDoneErr;
+			return require_lib_errors_index.err(validationRunError.type, validationRunError.message);
+		}
+		if (validationErrorMessage) {
+			errorMessage = validationErrorMessage;
+			continue;
+		}
+		const [transformError, finalValue] = await resolveOutput(params.options, rawValue);
+		if (transformError) {
+			const closeDoneErr = closeAndDone(`✖ ${params.options.message}`);
+			if (closeDoneErr) return closeDoneErr;
+			return require_lib_errors_index.err(transformError.type, transformError.message);
+		}
+		if (finalValue === null) return require_lib_errors_index.err("PromptIOError", "Unable to transform prompt value");
+		const closeDoneErr = closeAndDone(params.complete({
+			options: params.options,
+			state,
+			value: finalValue
+		}));
+		if (closeDoneErr) return closeDoneErr;
+		return require_lib_errors_index.ok(finalValue);
+	}
+};
+//#endregion
+exports.runPromptSession = runPromptSession;