@effected/cli 0.10.0 → 0.12.0

package/internal/renderMarkdown.js

@@ -0,0 +1,368 @@
+import { Fmt, sanitize } from "../Fmt.js";
+import { counterLabel, countsTableOf, totalOf, visibleCountersOf } from "./counts.js";
+import { isAllowedLinkUrl } from "./linkScheme.js";
+import { DRIVE, encodePath, fileUrlPath } from "./linkTarget.js";
+import { flatten } from "./layout.js";
+import { capOf, isAnnotation, showsSuffix, targetText, textLines } from "./renderDoc.js";
+
+//#region src/internal/renderMarkdown.ts
+/** Marks a line break inside flowing text until the paragraph is split into lines. Sanitized text never holds NUL. */
+const BREAK = "\0";
+/**
+* Escape what markdown would read as syntax: backslash, backtick, `*`, `_`, brackets, angle brackets, `&`, `~` and
+* `|` (so text can never form a table), and the start of an autolink literal (any scheme before `://`, or `www.`), which a GFM
+* reader would otherwise turn into a link. An email address is left alone: the `mailto:` link a reader makes of it
+* is harmless, and escaping its `@` does not stop every reader.
+*/
+const escapeText = (text) => text.replace(/[\\`*_[\]<>&~|]/g, "\\$&").replace(/(?<=[a-z0-9+.-]):(?=\/\/)/gi, "\\:").replace(/\b(www)\./gi, "$1\\.");
+/**
+* Escape a block marker at the start of a line: a heading or an ordered item, and always a leading `-`, `+` or `=`,
+* which would make a bullet, a setext underline or (with spaces between dashes) a thematic break.
+*/
+const escapeLineStart = (line) => {
+	if (/^[-+=]/.test(line)) return `\\${line}`;
+	if (/^#{1,6}(?:\s|$)/.test(line)) return `\\${line}`;
+	const ordered = /^(\d{1,9})([.)])(?:\s|$)/.exec(line);
+	if (ordered !== null) return `${ordered[1]}\\${line.slice(ordered[1].length)}`;
+	return line;
+};
+const htmlEscape = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+/** Whether some `|` in the text has an odd run of backslashes straight before it. */
+const pipeAfterOddBackslashes = (text) => {
+	let run = 0;
+	for (const ch of text) {
+		if (ch === "|" && run % 2 === 1) return true;
+		run = ch === "\\" ? run + 1 : 0;
+	}
+	return false;
+};
+/**
+* Inline code: a backtick fence longer than any run inside, padded where a reader would strip or merge a space.
+*
+* @remarks
+* In a table cell a `|` is written `\|`, which GFM unescapes before it reads the code span. GFM's row scanner reads a
+* backslash and the character after it as a pair, so a `|` survives the scanner only after an odd run of backslashes,
+* and the unescape then leaves an even run: a code span in a cell cannot hold a `|` after an odd run of backslashes at
+* all. That text is written as `<code>` around escaped text instead, which reads the same; every other `|` follows an
+* even run, which `\|` keeps.
+*/
+const codeSpan = (text, mode) => {
+	const flat = text.replace(/\r\n|\r|\n/g, " ");
+	if (mode === "cell" && pipeAfterOddBackslashes(flat)) return `<code>${escapeText(flat)}</code>`;
+	const longest = Math.max(0, ...[...flat.matchAll(/`+/g)].map((run) => run[0].length));
+	const fence = "`".repeat(longest + 1);
+	const padded = /^`|`$/.test(flat) || /^ .* $/.test(flat) && flat.trim() !== "" || flat === "";
+	const body = mode === "cell" ? flat.replace(/\|/g, "\\|") : flat;
+	const pad = padded ? " " : "";
+	return `${fence}${pad}${body === "" ? " " : body}${pad}${fence}`;
+};
+const textPiece = (text, mode) => text.split(/\r\n|\r|\n/).map(escapeText).join(mode === "cell" ? "<br>" : mode === "line" ? " " : BREAK);
+/**
+* A link's URL when it has a form a reader can follow: an allowed scheme, a relative URL, or an absolute file path.
+*
+* The scheme is read from a normalised copy, with whitespace and control characters removed and the case folded,
+* because a browser ignores them inside a scheme (`java<tab>script:`). An entity cannot hide one either: the
+* destination escapes `&`, so what a reader decodes is the text that was checked here.
+*/
+const linkUrl = (target, ctx) => {
+	if ("url" in target) {
+		const url = target.url.trim();
+		return isAllowedLinkUrl(url) ? url : void 0;
+	}
+	if (ctx.linkBase !== void 0) {
+		const display = sanitize(ctx.displayPath(target.file)).replace(/\\/g, "/");
+		if (display.startsWith("/") || DRIVE.test(display) || display.split("/").includes("..")) return void 0;
+		const url = `${ctx.linkBase}${encodePath(display)}${target.line === void 0 ? "" : `#L${target.line}`}`;
+		return isAllowedLinkUrl(url) ? url : void 0;
+	}
+	if (!target.file.startsWith("/") && !DRIVE.test(target.file)) return void 0;
+	const path = fileUrlPath(target.file);
+	return path === void 0 ? void 0 : `file://${path}`;
+};
+/**
+* A link destination. `&` is escaped so a reader does not decode an entity into something other than what was written.
+* `|` and the backtick are percent-encoded, which is the same URL: GFM splits a table row into cells before it reads
+* inlines, so a raw `|` would split the row however the destination is written, and a backtick can open a code span.
+*/
+const destination = (raw) => {
+	const url = raw.replace(/&/g, "&amp;").replace(/\|/g, "%7C").replace(/`/g, "%60");
+	return /^[^\s()<>\\]*$/.test(url) ? url : `<${url.replace(/[\r\n]/g, "").replace(/\\/g, "\\\\").replace(/</g, "%3C").replace(/>/g, "%3E")}>`;
+};
+/**
+* Spans as markdown: each piece escaped, or fenced as code, and `**` or `_` around each stretch of strong or emphasised
+* spans. The spaces at a stretch's edges stay outside its markers, where a reader would otherwise not see emphasis.
+*/
+const emphasized = (spans, mode) => {
+	let out = "";
+	let i = 0;
+	while (i < spans.length) {
+		const strong = spans[i].strong === true;
+		const em = spans[i].em === true;
+		let body = "";
+		do {
+			const span = spans[i];
+			body += span.code === true ? codeSpan(span.text, mode) : textPiece(span.text, mode);
+			i++;
+		} while (i < spans.length && spans[i].strong === true === strong && spans[i].em === true === em);
+		const lead = /^\s*/.exec(body)?.[0] ?? "";
+		const core = body.slice(lead.length).trimEnd();
+		const trail = body.slice(lead.length + core.length);
+		if (!strong && !em || core === "") {
+			out += body;
+			continue;
+		}
+		out += `${lead}${strong ? "**" : ""}${em ? "*" : ""}${core}${em ? "*" : ""}${strong ? "**" : ""}${trail}`;
+	}
+	return out;
+};
+/** Inline nodes as markdown: text escaped, code fenced, a link as `[label](url)` or, with no URL form, label and path. */
+const inlineMd = (inlines, ctx, mode) => {
+	const flat = flatten(inlines, ctx);
+	let out = "";
+	let i = 0;
+	while (i < flat.length) {
+		const link = flat[i].link;
+		const start = i;
+		do
+			i++;
+		while (i < flat.length && flat[i].link === link);
+		const run = flat.slice(start, i);
+		const label = emphasized(run, mode);
+		if (link === void 0) {
+			out += label;
+			continue;
+		}
+		const raw = run.map((span) => span.text).join("");
+		const url = linkUrl(link, ctx);
+		const target = targetText(link, ctx);
+		if (url !== void 0) out += `[${label}](${destination(url)})`;
+		else out += showsSuffix(flat[i - 1].suffix, raw, target) ? `${label} (${codeSpan(target, mode)})` : label;
+	}
+	return out;
+};
+/** Flowing text as lines: blank lines dropped, each line cleared of indentation and of block markers, hard breaks between. */
+const flowLines = (markdown) => {
+	const lines = markdown.split(BREAK).map((line) => line.trimStart()).filter((line) => line.trim() !== "").map(escapeLineStart);
+	return lines.map((line, index) => index < lines.length - 1 ? `${line}\\` : line.trimEnd());
+};
+const joinBlocks = (blocks) => blocks.filter((block) => block.length > 0).flatMap((block, index) => index === 0 ? block : ["", ...block]);
+/** A line a paragraph ends on: text, rather than a heading, fence, table, quote, list item or HTML. */
+const endsText = (line) => line !== "" && !/^(?:#{1,6}(?:\s|$)|`{3,}|~{3,}|\||>|[-+*] |\d+[.)] |<)/.test(line);
+/**
+* Blocks joined with no blank line between them, for a compact list item. Where one block's text runs straight into
+* the next block's text they would merge into one paragraph, so a hard break keeps them apart.
+*/
+const joinTight = (blocks) => {
+	const joined = [];
+	for (const block of blocks) {
+		if (block.length === 0) continue;
+		const last = joined[joined.length - 1];
+		if (last !== void 0 && endsText(last) && endsText(block[0] ?? "")) joined[joined.length - 1] = `${last}\\`;
+		joined.push(...block);
+	}
+	return joined;
+};
+const hang = (lines, first, rest) => lines.length === 0 ? [first.trimEnd()] : lines.map((line, index) => `${index === 0 ? first : rest}${line}`.trimEnd());
+const overflowMd = (overflow, hidden, ctx) => flowLines(overflow === void 0 ? escapeText(`${ctx.glyphs.ellipsis} ${hidden} more`) : inlineMd(overflow(hidden), ctx, "flow"));
+const fenced = (lines, info) => {
+	const longest = Math.max(0, ...lines.flatMap((line) => [...line.matchAll(/`+/g)].map((run) => run[0].length)));
+	const fence = "`".repeat(Math.max(3, longest + 1));
+	return [
+		`${fence}${info}`,
+		...lines,
+		fence
+	];
+};
+const align = {
+	left: ":--",
+	right: "--:",
+	center: ":-:"
+};
+const tableMd = (header, aligns, rows) => {
+	const row = (cells) => `| ${cells.join(" | ")} |`.replace(/ {2}\|/g, " |");
+	return [
+		row(header),
+		row(aligns.map((a) => a === void 0 ? "---" : align[a])),
+		...rows.map(row)
+	];
+};
+const countsMd = (walk, block) => {
+	const { ctx } = walk;
+	const visible = visibleCountersOf(block);
+	const total = totalOf(block);
+	const label = block.label === void 0 ? "" : inlineMd(block.label, ctx, "line").trim();
+	const qualifier = block.qualifier === void 0 ? "" : inlineMd(block.qualifier, ctx, "line").trim();
+	const duration = block.durationMs === void 0 ? "" : Fmt.duration(block.durationMs);
+	const suffix = block.suffix === void 0 ? "" : inlineMd(block.suffix, ctx, "line").trim();
+	const name = (counter, count) => escapeText(sanitize(counterLabel(counter, count)).replace(/\r\n|\r|\n/g, " "));
+	const headlineName = (counter, index) => index === 0 && block.share !== false ? name(counter, total) : name(counter);
+	if (block.layout === "row") {
+		const header = [...visible.map(headlineName), ...duration === "" ? [] : ["duration"]];
+		const cells = [...visible.map((counter, index) => index === 0 && block.share !== false ? `${counter.n}/${total}` : String(counter.n)), ...duration === "" ? [] : [duration]];
+		const after = [qualifier, suffix].filter((part) => part !== "").join(" ");
+		return [
+			...label === "" ? [] : [flowLines(label)],
+			...header.length === 0 ? [] : [tableMd(header, header.map(() => void 0), [cells])],
+			...after === "" ? [] : [flowLines(after)]
+		];
+	}
+	if (block.layout === "columns") return [
+		...label === "" ? [] : [flowLines(label)],
+		...visible.length === 0 ? [] : [visible.flatMap((counter) => hang([`${escapeLineStart(name(counter).trimStart())}: ${counter.n}`], "- ", "  "))],
+		...qualifier === "" ? [] : [flowLines(qualifier)],
+		...duration === "" ? [] : [[duration]],
+		...suffix === "" ? [] : [flowLines(suffix)]
+	];
+	const tally = visible.map((counter, index) => index === 0 && block.share !== false ? `${counter.n}/${total} ${headlineName(counter, index)}` : `${counter.n} ${name(counter)}`).join(", ");
+	const line = [
+		[label === "" ? "" : `${label}:`, tally].filter((part) => part !== "").join(" "),
+		qualifier,
+		duration === "" ? "" : `(${duration})`,
+		suffix
+	].filter((part) => part !== "").join(" ");
+	return line === "" ? [] : [flowLines(line)];
+};
+/**
+* A heading's text with any closing run of `#` escaped, so a reader does not take it for the optional closing sequence.
+*
+* @remarks
+* The text is already markdown: every backslash that came from the document was escaped as text, so a backslash can
+* never sit unescaped in front of the run.
+*/
+const headingText = (markdown) => {
+	const text = markdown.trim();
+	let start = text.length;
+	while (start > 0 && text[start - 1] === "#") start--;
+	return `${text.slice(0, start)}${"\\#".repeat(text.length - start)}`;
+};
+const WHITESPACE = /\s/;
+/**
+* A cell's text without the whitespace and `<br>` breaks at either edge, scanned from each end. A regex alternation
+* anchored only at the end retries from every position of an interior run, which is quadratic on a long one.
+*/
+const trimCellEdges = (text) => {
+	let start = 0;
+	let end = text.length;
+	for (;;) if (start < end && WHITESPACE.test(text.charAt(start))) start += 1;
+	else if (start + 4 <= end && text.startsWith("<br>", start)) start += 4;
+	else break;
+	for (;;) if (end > start && WHITESPACE.test(text.charAt(end - 1))) end -= 1;
+	else if (end - 4 >= start && text.startsWith("<br>", end - 4)) end -= 4;
+	else break;
+	return text.slice(start, end);
+};
+/** A block as markdown. `compact` is set on a compact list's item: a section there joins its parts with no blank lines. */
+const blockMd = (walk, block, depth, compact = false) => {
+	const { ctx } = walk;
+	switch (block._tag) {
+		case "Heading": return [`${"#".repeat(block.level)} ${headingText(inlineMd(block.content, ctx, "line"))}`.trimEnd()];
+		case "Paragraph": return flowLines(inlineMd(block.content, ctx, "flow"));
+		case "List": {
+			const cap = capOf(block.cap);
+			const listed = block.items.filter((item) => !isAnnotation(item));
+			const shown = cap === void 0 ? listed : listed.slice(0, cap);
+			const items = shown.flatMap((item) => hang(blockMd(walk, item, depth, block.compact === true), "- ", "  "));
+			const hidden = listed.length - shown.length;
+			return joinBlocks([items, hidden > 0 ? overflowMd(block.overflow, hidden, ctx) : []]);
+		}
+		case "Table": {
+			const columns = Math.max(block.columns.length, ...block.rows.map((row) => row.length));
+			if (columns === 0) return [];
+			const cap = capOf(block.cap);
+			const shown = cap === void 0 ? block.rows : block.rows.slice(0, cap);
+			const cell = (inlines) => inlines === void 0 ? "" : trimCellEdges(inlineMd(inlines, ctx, "cell"));
+			const header = Array.from({ length: columns }, (_, index) => cell(block.columns[index]?.header));
+			const aligns = Array.from({ length: columns }, (_, index) => block.columns[index]?.align);
+			const rows = shown.map((row) => Array.from({ length: columns }, (_, index) => cell(row[index])));
+			const hidden = block.rows.length - shown.length;
+			const overflow = hidden > 0 ? overflowMd(block.overflow, hidden, ctx) : [];
+			if (rows.length === 0 && header.every((text) => text === "")) return overflow;
+			return joinBlocks([tableMd(header, aligns, rows), overflow]);
+		}
+		case "Tree": {
+			const lines = [];
+			const visit = (children, indent) => {
+				for (const child of children) {
+					const label = flowLines(inlineMd(child.label, ctx, "line"))[0] ?? "";
+					lines.push(`${" ".repeat(indent)}- ${label}`.trimEnd());
+					visit(child.children, indent + 2);
+				}
+			};
+			visit(block.root.children, 0);
+			return joinBlocks([flowLines(inlineMd(block.root.label, ctx, "line")), lines]);
+		}
+		case "Collapsible": {
+			const title = htmlEscape(flatten(block.title, ctx).map((span) => span.text).join("").replace(/\r\n|\r|\n/g, " "));
+			const open = block.open === true ? " open" : "";
+			const body = joinBlocks(block.body.map((child) => blockMd(walk, child, depth)));
+			return [
+				`<details${open}><summary>${title}</summary>`,
+				"",
+				...body.length === 0 ? [] : [...body, ""],
+				"</details>"
+			];
+		}
+		case "Callout": {
+			const body = joinBlocks(block.body.map((child) => blockMd(walk, child, depth)));
+			const first = block.body[0];
+			const separate = first !== void 0 && first._tag !== "Paragraph";
+			return [
+				`[!${block.kind.toUpperCase()}]`,
+				...separate ? [""] : [],
+				...body
+			].map((line) => line === "" ? ">" : `> ${line}`);
+		}
+		case "CodeBlock": {
+			const info = sanitize(block.lang ?? "").trim().split(/\s+/)[0]?.replace(/`/g, "") ?? "";
+			return fenced(block.text === "" ? [] : textLines(block.text), info);
+		}
+		case "Diff": {
+			const cap = capOf(block.cap);
+			const side = (marker, text) => {
+				const lines = textLines(text);
+				const shown = cap === void 0 ? lines : lines.slice(0, cap);
+				const hidden = lines.length - shown.length;
+				return [...shown.map((line) => `${marker} ${line}`.trimEnd()), ...hidden > 0 ? [`  ${ctx.glyphs.ellipsis} ${hidden} more lines`] : []];
+			};
+			return fenced([...side("-", block.expected), ...side("+", block.received)], "diff");
+		}
+		case "Section": {
+			const level = Math.min(2 + depth, 6);
+			const parts = [block.title === void 0 ? [] : [`${"#".repeat(level)} ${headingText(inlineMd(block.title, ctx, "line"))}`.trimEnd()], ...block.children.map((child) => blockMd(walk, child, depth + 1))];
+			return compact ? joinTight(parts) : joinBlocks(parts);
+		}
+		case "Counts": return joinBlocks(countsMd(walk, block));
+		case "Verbatim": {
+			const indent = " ".repeat(Math.max(0, Math.floor(block.indent ?? 0)));
+			return fenced(block.text === "" ? [] : textLines(block.text).map((line) => `${indent}${line}`), "");
+		}
+		case "Annotation": return [];
+		case "CountsTable": return blockMd(walk, countsTableOf(block), depth);
+		case "Lines": {
+			const entries = block.lines.map((entry) => escapeLineStart(inlineMd(entry, ctx, "line").trim()));
+			let first = 0;
+			let last = entries.length;
+			while (first < last && entries[first] === "") first++;
+			while (last > first && entries[last - 1] === "") last--;
+			const kept = entries.slice(first, last);
+			return kept.map((line, index) => index < kept.length - 1 ? `${line}\\` : line);
+		}
+		case "Line": return flowLines(inlineMd(block.content, ctx, "line"));
+		case "DiffText": {
+			const cap = capOf(block.cap);
+			const lines = block.text === "" ? [] : textLines(block.text);
+			const shown = cap === void 0 ? lines : lines.slice(0, cap);
+			const hidden = lines.length - shown.length;
+			return fenced([...shown, ...hidden > 0 ? [`${ctx.glyphs.ellipsis} ${hidden} more lines`] : []], "diff");
+		}
+	}
+};
+/**
+* Render a document as GitHub-flavoured markdown.
+*
+* @internal
+*/
+const renderMarkdown = (doc, ctx) => joinBlocks(doc.map((block) => blockMd({ ctx }, block, 0))).join("\n");
+
+//#endregion
+export { renderMarkdown };

package/internal/renderPlain.js

@@ -0,0 +1,50 @@
+import { flatten } from "./layout.js";
+import { renderDocLines, showsSuffix, targetText } from "./renderDoc.js";
+
+//#region src/internal/renderPlain.ts
+/**
+* Inline content as spans of plain text: code in backticks, and a link as its label followed by its target in
+* parentheses unless the label already is the target. Tokens and links are dropped, as plain text has neither.
+*/
+const plainInline = (inlines, ctx) => {
+	const flat = flatten(inlines, ctx);
+	const out = [];
+	let i = 0;
+	while (i < flat.length) {
+		const link = flat[i].link;
+		let label = "";
+		do {
+			const span = flat[i];
+			label += span.text;
+			out.push({ text: span.code === true ? `\`${span.text}\`` : span.text });
+			i++;
+		} while (link !== void 0 && i < flat.length && flat[i].link === link);
+		if (link !== void 0) {
+			const target = targetText(link, ctx);
+			if (showsSuffix(flat[i - 1].suffix, label, target)) out.push({ text: ` (${target})` });
+		}
+	}
+	return out;
+};
+const plain = {
+	inline: plainInline,
+	finish: (line) => line.map((span) => span.text).join("")
+};
+/**
+* {@link renderPlain}'s finished lines, one entry per line: a block that draws nothing contributes none.
+*
+* @internal
+*/
+const renderPlainLines = (doc, ctx) => renderDocLines(doc, {
+	...ctx,
+	audience: "agent"
+}, plain);
+/**
+* Render a document as plain text for an agent: no escape sequences, no decoration.
+*
+* @internal
+*/
+const renderPlain = (doc, ctx) => renderPlainLines(doc, ctx).join("\n");
+
+//#endregion
+export { plainInline, renderPlain, renderPlainLines };

package/internal/scanAudience.js

@@ -0,0 +1,106 @@
+//#region src/internal/scanAudience.ts
+/**
+* The one counting rule, shared by the resolver that runs on parsed flags and by {@link scanAudience}, so the two
+* cannot drift: every `--audience` value counts, and a boolean counts only when it is true (`--agent=false` and
+* `--no-agent` mean "not given").
+*
+* @internal
+*/
+const tallyAudience = (input) => {
+	const given = [
+		...input.audience,
+		...input.human.filter(Boolean).map(() => "human"),
+		...input.agent.filter(Boolean).map(() => "agent"),
+		...input.ci.filter(Boolean).map(() => "ci")
+	];
+	return {
+		given,
+		conflict: given.length > 1
+	};
+};
+const KINDS = [
+	"human",
+	"agent",
+	"ci"
+];
+const TRUE_WORDS = [
+	"true",
+	"yes",
+	"on",
+	"1",
+	"y"
+];
+const FALSE_WORDS = [
+	"false",
+	"no",
+	"off",
+	"0",
+	"n"
+];
+const isKind = (value) => KINDS.includes(value);
+/**
+* Read the audience flags straight out of `argv`, the way core will parse them later.
+*
+* @remarks
+* Pure, and needed because the audience must be known BEFORE core parses: a fallback prompt fires during the
+* parse, which happens before any parsed flag is visible to it. Mirrors the syntax core accepts for the four
+* flags: `--audience v`, `--audience=v`, `--human`, `--agent` and `--ci`, each boolean with an optional `=true`
+* or `=false` (and the other spellings core accepts), or a following `true` or `false` token, `--no-<name>`,
+* repeats, and anywhere before a `--`, which ends flag parsing. A value core would reject (a bad `--audience`
+* kind, an unknown boolean spelling, a missing value) is left uncounted: core reports that as its own usage error.
+*
+* @internal
+*/
+const scanAudience = (argv) => {
+	const audience = [];
+	const booleans = {
+		human: [],
+		agent: [],
+		ci: []
+	};
+	const isBoolean = (name) => name === "human" || name === "agent" || name === "ci";
+	for (let index = 0; index < argv.length; index++) {
+		const token = argv[index] ?? "";
+		if (token === "--") break;
+		if (!token.startsWith("--")) continue;
+		const equals = token.indexOf("=");
+		const name = equals === -1 ? token.slice(2) : token.slice(2, equals);
+		const inline = equals === -1 ? void 0 : token.slice(equals + 1);
+		if (name === "audience") {
+			let value = inline;
+			if (value === void 0) {
+				const next = argv[index + 1];
+				if (next !== void 0 && !next.startsWith("-")) {
+					value = next;
+					index++;
+				}
+			}
+			if (value !== void 0 && isKind(value)) audience.push(value);
+			continue;
+		}
+		if (isBoolean(name)) {
+			if (inline !== void 0) {
+				if (TRUE_WORDS.includes(inline)) booleans[name].push(true);
+				else if (FALSE_WORDS.includes(inline)) booleans[name].push(false);
+				continue;
+			}
+			const next = argv[index + 1];
+			if (next !== void 0 && TRUE_WORDS.includes(next)) {
+				booleans[name].push(true);
+				index++;
+			} else if (next !== void 0 && FALSE_WORDS.includes(next)) {
+				booleans[name].push(false);
+				index++;
+			} else booleans[name].push(true);
+			continue;
+		}
+		if (name.startsWith("no-") && isBoolean(name.slice(3))) booleans[name.slice(3)].push(false);
+	}
+	return tallyAudience({
+		audience,
+		...booleans
+	});
+};
+
+//#endregion
+export { scanAudience, tallyAudience };

package/internal/splitFrame.js

@@ -0,0 +1,56 @@
+//#region src/internal/splitFrame.ts
+/** What JavaScript's `.` does not match outside dotAll mode: the four line terminators. */
+const isTerminator = (ch) => ch === "\n" || ch === "\r" || ch === "\u2028" || ch === "\u2029";
+/** One UTF-16 unit of JavaScript's `\s`; every character `\s` matches is in the BMP. */
+const isSpace = (ch) => ch !== void 0 && /\s/.test(ch);
+/**
+* A frame text split as `fn (location)`: at the FIRST whitespace run followed by `(`, when the text ends with `)`.
+*
+* @remarks
+* A linear scan with exactly the result of `/^(.*?)\s+\((.*)\)$/`, which backtracks polynomially on a long whitespace
+* run with no closing parenthesis. The split is the first one, not the last, because a location can hold parentheses
+* (an `eval` frame's `eval at <anonymous> (file:1:2), <anonymous>:1:1`). As with the regular expression, neither the
+* function nor the location may hold a line terminator, though the whitespace between them may.
+*/
+const wrappedFrame = (text) => {
+	if (!text.endsWith(")")) return void 0;
+	let firstTerminator = -1;
+	let lastTerminator = -1;
+	for (let i = 0; i < text.length; i++) {
+		if (!isTerminator(text[i])) continue;
+		if (firstTerminator === -1) firstTerminator = i;
+		lastTerminator = i;
+	}
+	let i = 0;
+	while (i < text.length) {
+		if (!isSpace(text[i])) {
+			i++;
+			continue;
+		}
+		if (firstTerminator !== -1 && firstTerminator < i) return void 0;
+		let j = i;
+		while (isSpace(text[j])) j++;
+		if (text[j] === "(" && j <= text.length - 2 && lastTerminator < j) return {
+			fn: text.slice(0, i),
+			location: text.slice(j + 1, -1)
+		};
+		i = j;
+	}
+};
+/**
+* A frame's text without `at `, and its location: the part in parentheses, or the whole text when there are none.
+*
+* @internal
+*/
+const splitFrame = (raw) => {
+	const text = raw.trim().replace(/^at\s+/, "");
+	const wrapped = wrappedFrame(text);
+	return {
+		text,
+		...wrapped === void 0 || wrapped.fn === "" ? {} : { fn: wrapped.fn },
+		location: wrapped === void 0 ? text : wrapped.location
+	};
+};
+
+//#endregion
+export { splitFrame };

package/internal/wizardGate.js

@@ -0,0 +1,18 @@
+import { Context } from "effect";
+
+//#region src/internal/wizardGate.ts
+/**
+* The exact `CliConfig` object `CliPrompt.gateWizard` produced when it removed `--wizard`, or `undefined` when it
+* removed nothing.
+*
+* @remarks
+* It is how a later decision can put the flag back without inventing it: the restore happens only when the CURRENT
+* config is this very object. A consumer who left `Wizard` out of their own `builtIns` never has it set, and one who
+* provides their own `CliConfig` inside the gate has a different object, so neither gets a wizard they did not ask for.
+*
+* @internal
+*/
+var WizardDropped = class extends Context.Reference("@effected/cli/WizardDropped", { defaultValue: () => void 0 }) {};
+
+//#endregion
+export { WizardDropped };

package/package.json

@@ -1,13 +1,15 @@
 {
 	"name": "@effected/cli",
-	"version": "0.10.0",
+	"version": "0.12.0",
 	"private": false,
-	"description": "The boundary layer of an effect/cli program: plain CLI output, failure reporting, and schema-issue rendering",
+	"description": "The presentation boundary of an effect/cli program: audience-aware output, a document IR and renderers, editor links, failure reports and logging, plus opt-in Ink screens, widgets and a live view",
 	"keywords": [
 		"effect",
 		"cli",
 		"logger",
-		"terminal"
+		"terminal",
+		"ink",
+		"tui"
 	],
 	"homepage": "https://github.com/spencerbeggs/effected/tree/main/packages/cli#readme",
 	"bugs": {
@@ -37,15 +39,48 @@
 			"import": "./testing.js",
 			"default": "./testing.js"
 		},
+		"./ui": {
+			"types": "./ui.d.ts",
+			"import": "./ui.js",
+			"default": "./ui.js"
+		},
+		"./ui/testing": {
+			"types": "./ui-testing.d.ts",
+			"import": "./ui-testing.js",
+			"default": "./ui-testing.js"
+		},
+		"./ui/testing/serializer": {
+			"types": "./ui-testing-serializer.d.ts",
+			"import": "./ui-testing-serializer.js",
+			"default": "./ui-testing-serializer.js"
+		},
 		"./package.json": "./package.json"
 	},
+	"dependencies": {
+		"@effected/github-commands": "^0.1.0"
+	},
 	"peerDependencies": {
-		"@effected/config-file": "^0.13.0",
-		"effect": "4.0.0-rc.118"
+		"@effected/config-file": "^0.14.1",
+		"@effected/env": "^0.1.0",
+		"@effected/glob": "^0.10.0",
+		"@effected/walker": "^0.15.0",
+		"@types/react": "^19.2.0",
+		"effect": "^4.0.0",
+		"ink": "^7.1.1",
+		"react": "^19.2.0"
 	},
 	"peerDependenciesMeta": {
 		"@effected/config-file": {
 			"optional": true
+		},
+		"@types/react": {
+			"optional": true
+		},
+		"ink": {
+			"optional": true
+		},
+		"react": {
+			"optional": true
 		}
 	},
 	"engines": {