wity-cli 0.1.0

package/dist/mcp-DnqXX8ba.mjs

@@ -0,0 +1,183 @@
+import { t as version } from "./package-7FOUqcPO.mjs";
+import { C as cost, D as pct, F as CliError, I as EXIT, N as PRICE_PER_MILLION_INPUT_USD, _ as explain, a as checkStateLength, c as MAX_STATE_CHARS, s as questionSchema, t as requireKey, v as makeClient, x as clean } from "./send-CGXuVi9Z.mjs";
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+//#region src/mcp.ts
+const UNCALIBRATED = "Probabilities rank how sure Wity is. They aren't calibrated odds.";
+const text = z.string().min(1).max(MAX_STATE_CHARS).describe("The text to judge: an email, a ticket, a diff, a document…");
+const reasoning = z.enum([
+	"off",
+	"auto",
+	"always"
+]).optional().describe("off is fastest. auto (the default) thinks only when a question needs it. always thinks first.");
+const done = (summary, data) => ({ content: [{
+	type: "text",
+	text: `${summary}\n\n${JSON.stringify(data)}`
+}] });
+const failed = (err) => {
+	return {
+		isError: true,
+		content: [{
+			type: "text",
+			text: err instanceof CliError ? [err.message, err.hint].filter(Boolean).join(" ") : "Something went wrong."
+		}]
+	};
+};
+const usage = (res) => `${res.usage.input_tokens.toLocaleString("en")} input tokens ≈ ${cost(res.usage.input_tokens)}`;
+/** One line about an answer, for the agent to read before the JSON. */
+const summarize = (res) => Object.entries(res.answers).map(([name, answer]) => {
+	if (answer.type === "noul") return `${name}: yes ${pct(answer.noul)}`;
+	if (answer.type === "score") return `${name}: score ${answer.score.toFixed(2)}`;
+	return `${name}: ${clean(answer.choice)} (${pct(answer.probabilities[answer.choice] ?? 0)})`;
+}).join(" · ");
+const createMcpServer = (ctx, found, opts) => {
+	const server = new McpServer({
+		name: "wity",
+		version
+	});
+	const client = makeClient(found.key, ctx.baseURL, ctx.io);
+	let spentTokens = 0;
+	/** Refuse once the session has spent --max-spend. Checked before each paid call. */
+	const guard = () => {
+		const spent = spentTokens * PRICE_PER_MILLION_INPUT_USD / 1e6;
+		if (opts.maxSpendUsd !== void 0 && spent >= opts.maxSpendUsd) throw new CliError(`This session reached its spending cap of $${opts.maxSpendUsd}.`, EXIT.error, "Restart the MCP server to reset it, or raise --max-spend.");
+	};
+	const systemOne = async (request) => {
+		try {
+			guard();
+			checkStateLength(request.state);
+			const res = await client.systemOne(request, { signal: ctx.io.signal });
+			spentTokens += res.usage.input_tokens;
+			return done(`${summarize(res)} · ${usage(res)}. ${UNCALIBRATED}`, res);
+		} catch (err) {
+			return failed(err instanceof CliError ? err : explain(err, found));
+		}
+	};
+	const request = (state, question, mode) => ({
+		state,
+		questions: { answer: question },
+		...mode && { reasoning: mode }
+	});
+	const readOnly = {
+		readOnlyHint: true,
+		openWorldHint: true
+	};
+	server.registerTool("wity_noul", {
+		title: "Yes or no, with a probability",
+		description: `Ask Wity a yes-or-no question about a text. Returns the probability of yes, from 0 to 1. ${UNCALIBRATED} Billed per input token (a few hundred tokens cost well under a cent).`,
+		inputSchema: {
+			text,
+			question: z.string().min(1).describe("A yes-or-no question, like 'Is this email a phishing attempt?'"),
+			yes_means: z.string().min(1).optional().describe("What yes means. Give no_means too."),
+			no_means: z.string().min(1).optional().describe("What no means. Give yes_means too."),
+			reasoning
+		},
+		annotations: readOnly
+	}, async ({ text: state, question, yes_means, no_means, reasoning: mode }) => {
+		if (yes_means === void 0 !== (no_means === void 0)) return failed(new CliError("Give both yes_means and no_means, or neither.", EXIT.usage));
+		const criteria = yes_means && no_means ? {
+			true: yes_means,
+			false: no_means
+		} : void 0;
+		return systemOne(request(state, {
+			type: "noul",
+			instructions: question,
+			...criteria && { criteria }
+		}, mode));
+	});
+	server.registerTool("wity_choice", {
+		title: "Pick one option, with probabilities",
+		description: `Ask Wity to pick one of 2 to 256 options for a text, like routing a ticket or labelling an email. Returns the winner and a probability for every option. ${UNCALIBRATED}`,
+		inputSchema: {
+			text,
+			question: z.string().min(1).describe("What to decide, like 'Which team should handle this ticket?'"),
+			options: z.record(z.string().min(1), z.string()).refine((o) => Object.keys(o).length >= 2 && Object.keys(o).length <= 256, "needs 2 to 256 options").describe("Option ids mapped to what each one means, like {\"billing\": \"Payments and refunds\"}."),
+			reasoning
+		},
+		annotations: readOnly
+	}, async ({ text: state, question, options, reasoning: mode }) => systemOne(request(state, {
+		type: "choice",
+		instructions: question,
+		criteria: options
+	}, mode)));
+	server.registerTool("wity_score", {
+		title: "Place a text on a scale",
+		description: `Ask Wity to place a text on a scale of 2 to 10 levels, lowest first. Returns the expected level (it can fall between levels) and a probability per level. ${UNCALIBRATED}`,
+		inputSchema: {
+			text,
+			question: z.string().min(1).describe("What to rate, like 'How upset is the customer?'"),
+			levels: z.array(z.string().min(1)).min(2).max(10).describe("The levels, lowest first, like ['Calm', 'Annoyed', 'Angry']."),
+			reasoning
+		},
+		annotations: readOnly
+	}, async ({ text: state, question, levels, reasoning: mode }) => systemOne(request(state, {
+		type: "score",
+		instructions: question,
+		criteria: levels
+	}, mode)));
+	server.registerTool("wity_ask", {
+		title: "Several questions in one call",
+		description: `Ask Wity several named questions about one text in one call. Each question is {type: "noul" | "choice" | "score", instructions, criteria}. criteria is {true, false} descriptions (optional) for noul, an object of option ids to descriptions for choice, and a list of levels (lowest first) for score. ${UNCALIBRATED}`,
+		inputSchema: {
+			text,
+			questions: z.record(z.string().min(1).max(64), questionSchema).describe("Questions by name. Answers come back under the same names."),
+			reasoning
+		},
+		annotations: readOnly
+	}, async ({ text: state, questions, reasoning: mode }) => {
+		if (Object.keys(questions).length === 0) return failed(new CliError("Give at least one question.", EXIT.usage));
+		return systemOne({
+			state,
+			questions,
+			...mode && { reasoning: mode }
+		});
+	});
+	server.registerTool("wity_generate", {
+		title: "Write short text or JSON",
+		description: "Ask Wity to write short text from a text (up to 512 tokens), like a one-line reply or a value read off a document. With a JSON Schema shape, the output matches it. Check generated text before acting on it: it can say things that aren't in the input. If the answer is one of a known set, use wity_choice instead.",
+		inputSchema: {
+			instructions: z.string().min(1).describe("What to write, like 'The one-line reply to send to this customer'."),
+			text: text.optional(),
+			shape: z.record(z.string(), z.unknown()).optional().describe("A JSON Schema with \"type\": \"object\" at the top."),
+			max_tokens: z.number().int().min(1).max(512).optional().describe("The most tokens to write. Default 128.")
+		},
+		annotations: readOnly
+	}, async ({ instructions, text: state, shape, max_tokens }) => {
+		try {
+			guard();
+			if (shape && shape.type !== "object") throw new CliError("The shape needs \"type\": \"object\" at the top.", EXIT.usage);
+			const req = {
+				instructions,
+				...state !== void 0 && { state },
+				...shape && { shape },
+				...max_tokens !== void 0 && { max_tokens }
+			};
+			const res = await client.generate(req, { signal: ctx.io.signal });
+			spentTokens += res.usage.input_tokens;
+			const cut = res.finish_reason === "length" ? " Cut off at max_tokens: raise it for the rest." : "";
+			return done(`Wrote ${res.usage.output_tokens} tokens · ${usage(res)}.${cut}`, res);
+		} catch (err) {
+			return failed(err instanceof CliError ? err : explain(err, found));
+		}
+	});
+	return server;
+};
+const serveMcp = async (ctx, opts) => {
+	const { io } = ctx;
+	if (opts.maxSpend !== void 0 && !(opts.maxSpend > 0)) throw new CliError("--max-spend is a dollar amount above 0.", EXIT.usage);
+	const found = await requireKey(ctx);
+	if (io.stdin.isTTY) io.stderr.write("wity mcp serve talks MCP over stdin and stdout, so an AI app should start it.\nFor example: claude mcp add wity -- wity mcp serve\nWaiting for MCP messages. Press Ctrl+C to stop.\n");
+	const server = createMcpServer(ctx, found, { maxSpendUsd: opts.maxSpend });
+	const transport = new StdioServerTransport(io.stdin, io.stdout);
+	await server.connect(transport);
+	await new Promise((resolve) => {
+		io.stdin.once("end", resolve);
+		io.stdin.once("close", resolve);
+		io.signal.addEventListener("abort", () => resolve(), { once: true });
+	});
+	await server.close();
+	return EXIT.ok;
+};
+//#endregion
+export { serveMcp };

package/dist/package-7FOUqcPO.mjs

@@ -0,0 +1,4 @@
+//#region package.json
+var version = "0.1.0";
+//#endregion
+export { version as t };

package/dist/playground-Cn7EIrd7.mjs

@@ -0,0 +1,389 @@
+import { C as cost, E as painter, F as CliError, I as EXIT, O as shouldColor, S as cleanBlock, _ as explain, a as checkStateLength, p as keyPrefix, t as requireKey, v as makeClient, x as clean } from "./send-CGXuVi9Z.mjs";
+import { a as scoreQuestion, f as systemOneTs, n as choiceQuestion, o as renderAnswer, r as noulQuestion, s as renderFooter } from "./questions-eZ01WB1q.mjs";
+import { Box, Text, render, useAnimation, useApp, useInput, usePaste, useWindowSize } from "ink";
+import { useEffect, useRef, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/playground.tsx
+const TYPES = [
+	"noul",
+	"choice",
+	"score"
+];
+const REASONINGS = [
+	"off",
+	"auto",
+	"always"
+];
+const LABEL_WIDTH = 13;
+const FRAMES = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏";
+const fieldsFor = (type) => type === "noul" ? [
+	"text",
+	"type",
+	"question",
+	"reasoning"
+] : [
+	"text",
+	"type",
+	"question",
+	"options",
+	"reasoning"
+];
+const cycle = (values, value, step) => values[(values.indexOf(value) + step + values.length) % values.length];
+/** "billing=Payments; technical=Bugs" → ["billing=Payments", "technical=Bugs"] */
+const splitOptions = (value) => value.split(";").map((part) => part.trim()).filter(Boolean);
+/**
+* A one-line text box. Ctrl combinations, Tab and arrows up and down are left to the playground.
+* Pasted text arrives whole (bracketed paste), so a pasted line break never sends the question.
+*/
+function Input(props) {
+	const { value, onChange, focus, placeholder, multiline } = props;
+	const [cursor, setCursor] = useState(value.length);
+	useEffect(() => setCursor((at) => Math.min(at, value.length)), [value]);
+	const insert = (text) => {
+		onChange(value.slice(0, cursor) + text + value.slice(cursor));
+		setCursor(cursor + text.length);
+	};
+	useInput((input, key) => {
+		if (key.ctrl || key.meta || key.tab || key.upArrow || key.downArrow || key.return || key.escape) return;
+		if (key.leftArrow) setCursor(Math.max(0, cursor - 1));
+		else if (key.rightArrow) setCursor(Math.min(value.length, cursor + 1));
+		else if (key.backspace || key.delete) {
+			if (cursor > 0) {
+				onChange(value.slice(0, cursor - 1) + value.slice(cursor));
+				setCursor(cursor - 1);
+			}
+		} else if (input) insert(cleanBlock(input).replaceAll("\n", ""));
+	}, { isActive: focus });
+	usePaste((pasted) => insert(multiline ? cleanBlock(pasted) : cleanBlock(pasted).replace(/\s*\n\s*/g, " ")), { isActive: focus });
+	const shown = value.replaceAll("\n", "⏎");
+	if (!focus) return shown ? /* @__PURE__ */ jsx(Text, { children: shown }) : /* @__PURE__ */ jsx(Text, {
+		dimColor: true,
+		children: placeholder
+	});
+	if (!shown) return /* @__PURE__ */ jsxs(Text, { children: [/* @__PURE__ */ jsx(Text, {
+		inverse: true,
+		children: " "
+	}), /* @__PURE__ */ jsx(Text, {
+		dimColor: true,
+		children: placeholder
+	})] });
+	return /* @__PURE__ */ jsxs(Text, { children: [
+		shown.slice(0, cursor),
+		/* @__PURE__ */ jsx(Text, {
+			inverse: true,
+			children: shown[cursor] ?? " "
+		}),
+		shown.slice(cursor + 1)
+	] });
+}
+function Row(props) {
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [/* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsx(Box, {
+			width: LABEL_WIDTH,
+			flexShrink: 0,
+			children: /* @__PURE__ */ jsxs(Text, {
+				color: props.focus ? "cyan" : void 0,
+				dimColor: !props.focus,
+				children: [props.focus ? "› " : "  ", props.label]
+			})
+		}), /* @__PURE__ */ jsx(Box, {
+			flexGrow: 1,
+			children: props.children
+		})] }), props.focus && props.hint ? /* @__PURE__ */ jsx(Box, {
+			marginLeft: LABEL_WIDTH,
+			children: /* @__PURE__ */ jsx(Text, {
+				dimColor: true,
+				children: props.hint
+			})
+		}) : null]
+	});
+}
+function Choices(props) {
+	return /* @__PURE__ */ jsx(Text, { children: props.values.map((value) => value === props.value ? /* @__PURE__ */ jsx(Text, {
+		color: "cyan",
+		bold: true,
+		inverse: props.focus,
+		children: ` ${value} `
+	}, value) : /* @__PURE__ */ jsx(Text, {
+		dimColor: true,
+		children: ` ${value} `
+	}, value)) });
+}
+function Working({ started }) {
+	const { frame } = useAnimation({ interval: 80 });
+	const slow = Date.now() - started > 1500;
+	return /* @__PURE__ */ jsxs(Text, { children: [/* @__PURE__ */ jsx(Text, {
+		color: "cyan",
+		children: FRAMES[frame % 10]
+	}), /* @__PURE__ */ jsx(Text, {
+		dimColor: true,
+		children: slow ? " Still working. Wity may be thinking this one through…" : " Asking Wity…"
+	})] });
+}
+function Playground(props) {
+	const { ctx, found, paint } = props;
+	const { exit } = useApp();
+	const { columns } = useWindowSize();
+	const [text, setText] = useState(props.initialText);
+	const [type, setType] = useState("noul");
+	const [question, setQuestion] = useState("");
+	const [options, setOptions] = useState("");
+	const [reasoning, setReasoning] = useState("auto");
+	const [focus, setFocus] = useState(props.initialText ? "question" : "text");
+	const [showCode, setShowCode] = useState(false);
+	const [status, setStatus] = useState({ kind: "idle" });
+	const [spent, setSpent] = useState({
+		calls: 0,
+		tokens: 0
+	});
+	const inFlight = useRef(null);
+	const fields = fieldsFor(type);
+	const move = (step) => setFocus((at) => cycle(fields, fields.includes(at) ? at : "type", step));
+	/** The request as it stands. Throws a CliError that says what's missing. */
+	const build = () => {
+		if (text.trim() === "") throw new CliError("Type or paste the text to judge first.", EXIT.usage);
+		checkStateLength(text);
+		const built = type === "noul" ? noulQuestion(question, void 0, void 0) : type === "choice" ? choiceQuestion(question, splitOptions(options)) : scoreQuestion(question, splitOptions(options));
+		return {
+			state: text,
+			questions: { answer: built },
+			reasoning
+		};
+	};
+	const ask = async () => {
+		if (inFlight.current) return;
+		let request;
+		try {
+			request = build();
+		} catch (err) {
+			const e = err;
+			setStatus({
+				kind: "error",
+				message: e.message,
+				hint: e.hint
+			});
+			return;
+		}
+		setShowCode(false);
+		const controller = new AbortController();
+		inFlight.current = controller;
+		setStatus({
+			kind: "running",
+			started: Date.now()
+		});
+		const quietIo = {
+			...ctx.io,
+			stderr: { write: () => true }
+		};
+		const client = makeClient(found.key, ctx.baseURL, quietIo);
+		const started = performance.now();
+		try {
+			const res = await client.systemOne(request, { signal: AbortSignal.any([controller.signal, ctx.io.signal]) });
+			setSpent((s) => ({
+				calls: s.calls + 1,
+				tokens: s.tokens + res.usage.input_tokens
+			}));
+			setStatus({
+				kind: "done",
+				res,
+				totalMs: performance.now() - started,
+				instructions: question
+			});
+		} catch (err) {
+			const e = explain(err, found);
+			setStatus(e instanceof CliError ? {
+				kind: "error",
+				message: e.message,
+				hint: e.hint
+			} : {
+				kind: "error",
+				message: String(e)
+			});
+		} finally {
+			inFlight.current = null;
+		}
+	};
+	useInput((input, key) => {
+		if (key.ctrl && input === "c") {
+			if (inFlight.current) inFlight.current.abort();
+			else exit();
+		} else if (key.escape) {
+			if (showCode) setShowCode(false);
+			else exit();
+		} else if (key.ctrl && input === "t") setShowCode((shown) => !shown);
+		else if (key.tab) move(key.shift ? -1 : 1);
+		else if (key.downArrow) move(1);
+		else if (key.upArrow) move(-1);
+		else if (key.return) ask();
+		else if ((key.leftArrow || key.rightArrow) && (focus === "type" || focus === "reasoning")) {
+			const step = key.leftArrow ? -1 : 1;
+			if (focus === "type") setType((at) => cycle(TYPES, at, step));
+			else setReasoning((at) => cycle(REASONINGS, at, step));
+		}
+	});
+	let code;
+	if (showCode) try {
+		code = systemOneTs(build(), ctx.baseURL);
+	} catch (err) {
+		code = `// ${err.message}`;
+	}
+	const width = Math.min(columns, 100);
+	const optionsHint = type === "choice" ? "id=description; id=description (2 to 256 options, separated by ;)" : "lowest; …; highest (2 to 10 levels, separated by ;)";
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		width,
+		paddingX: 1,
+		children: [
+			/* @__PURE__ */ jsxs(Box, {
+				borderStyle: "round",
+				borderColor: "cyan",
+				paddingX: 1,
+				justifyContent: "space-between",
+				children: [/* @__PURE__ */ jsxs(Text, { children: [/* @__PURE__ */ jsx(Text, {
+					color: "cyan",
+					children: "◆ "
+				}), /* @__PURE__ */ jsx(Text, {
+					bold: true,
+					children: "wity playground"
+				})] }), /* @__PURE__ */ jsxs(Text, {
+					dimColor: true,
+					children: [
+						keyPrefix(found.key),
+						" · ",
+						found.source === "env" ? "WITY_API_KEY" : found.source,
+						spent.calls > 0 ? ` · ${spent.calls} call${spent.calls > 1 ? "s" : ""} ≈ ${cost(spent.tokens)}` : ""
+					]
+				})]
+			}),
+			/* @__PURE__ */ jsxs(Box, {
+				flexDirection: "column",
+				marginTop: 1,
+				children: [
+					/* @__PURE__ */ jsx(Row, {
+						label: "Text",
+						focus: focus === "text",
+						hint: "what Wity reads · paste works, line breaks show as ⏎",
+						children: /* @__PURE__ */ jsx(Input, {
+							value: text,
+							onChange: setText,
+							focus: focus === "text",
+							placeholder: "My card was charged twice…",
+							multiline: true
+						})
+					}),
+					/* @__PURE__ */ jsx(Row, {
+						label: "Type",
+						focus: focus === "type",
+						hint: "← → to change",
+						children: /* @__PURE__ */ jsx(Choices, {
+							values: TYPES,
+							value: type,
+							focus: focus === "type"
+						})
+					}),
+					/* @__PURE__ */ jsx(Row, {
+						label: "Question",
+						focus: focus === "question",
+						children: /* @__PURE__ */ jsx(Input, {
+							value: question,
+							onChange: setQuestion,
+							focus: focus === "question",
+							placeholder: type === "noul" ? "Does the customer need this soon?" : "Which team should handle this?"
+						})
+					}),
+					type !== "noul" ? /* @__PURE__ */ jsx(Row, {
+						label: type === "choice" ? "Options" : "Levels",
+						focus: focus === "options",
+						hint: optionsHint,
+						children: /* @__PURE__ */ jsx(Input, {
+							value: options,
+							onChange: setOptions,
+							focus: focus === "options",
+							placeholder: type === "choice" ? "billing=Payments; technical=Bugs; other" : "Calm; Annoyed; Angry"
+						})
+					}) : null,
+					/* @__PURE__ */ jsx(Row, {
+						label: "Reasoning",
+						focus: focus === "reasoning",
+						hint: "← → to change · auto thinks only when needed",
+						children: /* @__PURE__ */ jsx(Choices, {
+							values: REASONINGS,
+							value: reasoning,
+							focus: focus === "reasoning"
+						})
+					})
+				]
+			}),
+			/* @__PURE__ */ jsx(Box, {
+				marginTop: 1,
+				children: /* @__PURE__ */ jsxs(Text, {
+					dimColor: true,
+					children: [
+						"⏎ ask · tab next · ctrl+t ",
+						showCode ? "hide" : "show",
+						" code · esc quit"
+					]
+				})
+			}),
+			/* @__PURE__ */ jsx(Box, {
+				flexDirection: "column",
+				marginTop: 1,
+				children: code !== void 0 ? /* @__PURE__ */ jsxs(Box, {
+					borderStyle: "round",
+					borderDimColor: true,
+					paddingX: 1,
+					flexDirection: "column",
+					children: [/* @__PURE__ */ jsx(Text, {
+						dimColor: true,
+						children: "TypeScript · npm install wity-sdk"
+					}), /* @__PURE__ */ jsx(Text, { children: code })]
+				}) : status.kind === "running" ? /* @__PURE__ */ jsx(Working, { started: status.started }) : status.kind === "error" ? /* @__PURE__ */ jsxs(Box, {
+					flexDirection: "column",
+					children: [/* @__PURE__ */ jsxs(Text, { children: [/* @__PURE__ */ jsx(Text, {
+						color: "red",
+						children: "✗ "
+					}), status.message] }), status.hint ? /* @__PURE__ */ jsx(Text, {
+						dimColor: true,
+						children: `  ${status.hint}`
+					}) : null]
+				}) : status.kind === "done" ? /* @__PURE__ */ jsxs(Box, {
+					flexDirection: "column",
+					children: [
+						/* @__PURE__ */ jsx(Text, {
+							bold: true,
+							children: clean(status.instructions)
+						}),
+						status.res.answers.answer ? /* @__PURE__ */ jsx(Text, { children: [
+							"",
+							...renderAnswer(status.res.answers.answer, paint, width),
+							""
+						].join("\n") }) : null,
+						/* @__PURE__ */ jsx(Text, { children: renderFooter(status.res, status.totalMs, paint) })
+					]
+				}) : null
+			})
+		]
+	});
+}
+const playground = async (ctx, initialText) => {
+	const { io } = ctx;
+	if (!io.stdin.isTTY || !io.stdout.isTTY) throw new CliError("The playground needs a terminal.", EXIT.usage, "In scripts, use noul, choice, score or ask.");
+	const found = await requireKey(ctx);
+	const paint = painter(shouldColor(io.env, io.stdout));
+	await render(/* @__PURE__ */ jsx(Playground, {
+		ctx,
+		found,
+		initialText,
+		paint
+	}), {
+		stdin: io.stdin,
+		stdout: io.stdout,
+		stderr: io.stderr,
+		exitOnCtrlC: false,
+		patchConsole: false
+	}).waitUntilExit();
+	return EXIT.ok;
+};
+//#endregion
+export { playground };