@effected/cli 0.9.0 → 0.11.0

package/Render.js

@@ -0,0 +1,254 @@
+import { underGithubActions } from "./internal/autoFormat.js";
+import { CliLinks } from "./CliLinks.js";
+import { Glyphs } from "./Glyphs.js";
+import { paintStyle } from "./internal/ansi.js";
+import { Token } from "./Token.js";
+import { CliTheme, themeForAudience } from "./CliTheme.js";
+import { renderAnsi } from "./internal/renderAnsi.js";
+import { renderPlain } from "./internal/renderPlain.js";
+import { renderGithubLog } from "./internal/renderGithubLog.js";
+import { renderMarkdown } from "./internal/renderMarkdown.js";
+import { Effect } from "effect";
+import { Audience, TerminalEnv } from "@effected/env";
+import { CommandNeutralizer } from "@effected/github-commands";
+
+//#region src/Render.ts
+/** A renderer's text, with workflow commands neutralized when the context says the runner is reading it. */
+const guarded = (text, ctx) => ctx.neutralizeWorkflowCommands === true ? CommandNeutralizer.text(text) : text;
+/**
+* Pure renderers of a document: `(doc, context) => string`.
+*
+* @remarks
+* A renderer has no environment and no effects, so the same document and context always give the same string.
+* {@link Render.plain} is for agents; the rest of the set follows.
+*
+* @example
+* ```ts
+* import { Doc, Render } from "@effected/cli"
+*
+* const doc = [Doc.heading(2, "Results"), Doc.paragraph("3 checks passed")]
+* const ctx = Render.contextOf({ audience: "agent" })
+*
+* Render.plain(doc, ctx)
+* // => "Results\n3 checks passed"
+* ```
+*
+* @public
+*/
+var Render = class {
+	constructor() {}
+	/**
+	* The {@link RenderContext} for a stream, from the services a CLI already has.
+	*
+	* @remarks
+	* Everything is read once, here, so the renderers stay pure:
+	*
+	* - `audience` is the `Audience` in force, so an audience flag is honoured;
+	* - `color`, `paint` and `glyphs` are the `CliTheme`'s for THAT stream, so redirecting stdout does not quiet
+	*   stderr; except that an agent's `color` is `none` and its `paint` the identity, so no renderer, `ansi` included,
+	*   writes an escape for an agent whatever the terminal could do;
+	* - `link` is `CliLinks.linker` over that stream's hyperlink support and the audience, so an agent never
+	*   gets an escape and a terminal without OSC 8 gets the label;
+	* - `neutralizeWorkflowCommands` is set when `CurrentRuntimeEnv` says GitHub Actions (read if present, not
+	*   required), for every audience, since the runner reads whatever is written there;
+	* - `width` is the option, else `TerminalEnv.width()` for a human, and **unbounded** (`Infinity`) for an agent
+	*   or a CI, so nothing a reader needs is truncated or wrapped for a terminal that is not there.
+	*
+	* @param stream - the stream the output is for
+	* @param options - an explicit width and a path display function
+	*/
+	static context = (stream, options) => Effect.gen(function* () {
+		const terminal = yield* TerminalEnv;
+		const { kind } = yield* Audience;
+		const theme = (yield* CliTheme).forStream(stream);
+		const seen = themeForAudience(theme, kind);
+		const links = yield* CliLinks;
+		return {
+			...(yield* underGithubActions) ? { neutralizeWorkflowCommands: true } : {},
+			width: options?.width ?? (kind === "human" ? terminal.width() : Number.POSITIVE_INFINITY),
+			audience: kind,
+			color: seen.color,
+			paint: seen.paint,
+			glyphs: theme.glyphs,
+			link: CliLinks.linker({
+				links,
+				hyperlinks: terminal[stream].hyperlinks,
+				audience: kind
+			}),
+			displayPath: options?.displayPath ?? ((absolute) => absolute)
+		};
+	});
+	/**
+	* A {@link RenderContext} from plain options, for a caller outside Effect, such as a test reporter or an Ink tree.
+	*
+	* @remarks
+	* Pure: nothing is read from the environment. The defaults are colour `none`, the identity paint, no links,
+	* Unicode glyphs, unbounded width and the identity `displayPath`, so a context built from an audience alone renders
+	* with no escape of any kind. A colour level paints with the default token styles. An `agent` is colourless and
+	* unlinked whatever `color` and `links` say, as in {@link Render.context}.
+	*
+	* @param options - the audience, and the colour, glyphs, width, path display, links, neutralizing and link base
+	*/
+	static contextOf = (options) => {
+		const agent = options.audience === "agent";
+		const color = agent ? "none" : options.color ?? "none";
+		const links = agent ? "off" : options.links ?? "off";
+		return {
+			width: options.width ?? Number.POSITIVE_INFINITY,
+			audience: options.audience,
+			color,
+			paint: color === "none" ? (_token, text) => text : (token, text) => paintStyle(Token.resolve(token), color, text),
+			glyphs: options.glyphs ?? Glyphs.unicode,
+			link: links === "off" ? (_target, label) => label : CliLinks.linker({
+				links,
+				hyperlinks: true,
+				audience: options.audience
+			}),
+			displayPath: options.displayPath ?? ((absolute) => absolute),
+			...options.neutralizeWorkflowCommands ?? options.audience === "ci" ? { neutralizeWorkflowCommands: true } : options.neutralizeWorkflowCommands === false ? { neutralizeWorkflowCommands: false } : {},
+			...options.linkBase === void 0 ? {} : { linkBase: options.linkBase }
+		};
+	};
+	/**
+	* Render a document as plain text for an agent.
+	*
+	* @remarks
+	* There are no escape sequences of any kind, whatever the context's colour or hyperlinks allow: `paint` and
+	* `link` are never called, and a control character in a document's text is removed. The audience is treated as
+	* `agent`, so a path joins with ` > `.
+	*
+	* - A heading is its text alone, code is in backticks, and a link is its label followed by the target in
+	*   parentheses, as `path:line:col` through `displayPath` for a file, unless the label already is the target.
+	* - A paragraph wraps to the width and is never truncated; a word longer than the width, such as a URL, stays
+	*   whole on its own line.
+	* - A list uses `- ` items, and past its cap the overflow row. A table is aligned text columns with a rule under
+	*   the header; a short row is padded with empty cells, a cell holding line breaks shows its first line and an
+	*   ellipsis, and cells are truncated only when the table is wider than the context, widest column first. A tree uses the glyph set's tree segments.
+	* - A collapsible is its title and the indented body, a callout its upper-case kind and the body, a code block
+	*   four-space indented, and a diff `- expected` lines then `+ received` lines, the cap limiting each side.
+	* - Counts take their total and their visible counters from {@link Doc.total} and {@link Doc.visibleCounters}.
+	*   Inline gives `3/5 passed, 1 failed (1.2s)`: the first counter is the headline and shows its share of the
+	*   total, unless `share` is `false`. Columns gives aligned label and number pairs, and row one line of cells.
+	* - A link with `suffix: false` never has its target after the label, and one with `suffix: true` always does.
+	* - Verbatim text is its lines exactly, each indented by `indent` spaces, never wrapped; an annotation is nothing.
+	* - Strong and emphasised content is its text; a file is its display path, unlinked. `Lines` are one line per entry,
+	*   a `Line` with `truncate` is cut to the width with the ellipsis, and diff text is its lines as given, the cap
+	*   followed by `… N more lines`. A counts table is a table with a column per counter key and the total row last,
+	*   and a counts `suffix` follows the duration.
+	* - A compact list has no blank lines inside an item. A `style: "pipe"` table is istanbul's shape: a rule of dashes
+	*   meeting at `|` above and below the header and at the end, and cells joined with ` | `.
+	* - Top-level blocks are consecutive lines; a section separates its title and children with blank lines.
+	*
+	* @param doc - the document
+	* @param ctx - where the output is going
+	*/
+	static plain = (doc, ctx) => guarded(renderPlain(doc, ctx), ctx);
+	/**
+	* Render a document for a person: the same layout as {@link Render.plain}, painted and linked.
+	*
+	* @remarks
+	* The context's `paint` and `link` do the styling, so a context at colour `none` with links off gives exactly
+	* what `plain` gives, apart from two things: code has no backticks (it is painted `accent` instead), and a path
+	* joins with the audience's separator (`›` for a person) rather than ` > `. Tokens:
+	*
+	* - headings, section and collapsible titles, and table headers are `emphasis`; the rule under a header, tree
+	*   lines and overflow rows are `muted`;
+	* - a status glyph takes its definition's token, and a diff's `-` lines are `failure` and `+` lines `success`;
+	* - a callout's label takes its kind's token (`note` info, `tip` success, `important` accent, `warning` warning,
+	*   `caution` error), and a counter the token of its status, with the qualifier, the duration and the suffix `muted`.
+	*   A `Counts` with `paint: "none"` paints none of it, and with `paint: "glyph"` only a status glyph.
+	* - strong content is bold and emphasised content italic, over any token it has; in diff text a `+` line is
+	*   `success` and a `-` line `failure`; a counts table's counts take their status's token.
+	*
+	* A link goes through `ctx.link`, which makes an OSC 8 hyperlink only when the policy allows it. When it does
+	* not (it returns the label unchanged), the target follows the label in parentheses, muted, as in plain text.
+	*
+	* Text is cut and wrapped before it is painted, so a colour or a hyperlink is never cut in half, and a table
+	* cut to the width keeps the colour of what remains. Tables are plain aligned columns, never box drawing:
+	* box drawing costs two columns of every row for nothing a rule and the padding do not already say, and it
+	* cannot be matched to plain text.
+	*
+	* @param doc - the document
+	* @param ctx - where the output is going
+	*/
+	static ansi = (doc, ctx) => guarded(renderAnsi(doc, ctx), ctx);
+	/**
+	* Render a document as GitHub-flavoured markdown, for a step summary or a file.
+	*
+	* @remarks
+	* There is no ANSI and no OSC 8 (`paint` and `link` are never called), and the width does not apply: a reader
+	* wraps. Everything a document carries as text is escaped so that it cannot become markdown: the characters
+	* that mean something, `|` everywhere so text can never form a table, the marker at the start of a line (a
+	* heading, bullet, setext underline or ordered item) and the start of an autolink (a URL scheme or `www.`). An
+	* email address is not escaped: a reader may make a `mailto:` link of it, which is harmless. A leading indent is
+	* dropped, since markdown would read it as code.
+	*
+	* Under GitHub Actions (`neutralizeWorkflowCommands`) the same neutralizing applies, since markdown can be printed
+	* to the log. Markdown escapes `[` in text, so `##[` cannot appear outside code and the headings are untouched
+	* (a bare `##` is not a command); code spans and blocks, which are not escaped, get the zero-width space, which can
+	* also land inside code or table text where it would otherwise have formed a command.
+	*
+	* GitHub also turns `@user`, `@org/team`, `#123` and commit SHAs in rendered markdown into mentions and references.
+	* Nothing here escapes them: in a step summary they do not notify, but markdown posted as a comment could ping
+	* whoever the text names.
+	*
+	* - A heading is `#` repeated by its level. A section's title is a heading of level 2 for a section at the top,
+	*   one deeper for each section nested inside it, to level 6.
+	* - A table is a GFM pipe table: `|` is `\|` in a cell and a line break in a cell is `<br>`. A short row is
+	*   padded and a long one widens the table. With no header, the header row is empty.
+	* - A collapsible is `<details><summary>title</summary>`, a blank line, the body as markdown, a blank line and
+	*   `</details>`. The title is HTML, so it is HTML-escaped and plain.
+	* - A callout is a quoted `[!KIND]` followed by its body. A code block is a fence longer than any backtick run it
+	*   holds, and a diff a `diff` fence of `-` and `+` lines.
+	* - A link is `[label](url)` when it has a URL a reader can follow: an `http`, `https`, `mailto`, `file` or
+	*   `vscode` URL, or a relative one. A file link has one when its path is absolute (`file://`). Otherwise, such as
+	*   for a `javascript:` URL or a relative file path, it is the label followed by the target in inline code, as
+	*   `path:line:col` for a file.
+	* - A list is bullets, a tree a nested bullet list under its root label, and overflow rows paragraphs after what
+	*   they cap. Counts inline is a paragraph, columns a list of `label: n` and row a one-row table of the counter
+	*   labels over their numbers, every header named (the duration as `duration`), with the label above the table and
+	*   the qualifier and suffix below it.
+	* - Verbatim text is a fenced code block, so its indentation survives; an annotation is nothing.
+	* - Strong content is `**…**` and emphasised `*…*`, which GFM reads inside a word too, with the spaces at a run's
+	*   edges kept outside the markers. `Lines` are one paragraph with a hard break between entries, an empty entry
+	*   between two others an empty line (one at either end is dropped); a `Line` is one
+	*   paragraph; diff text a `diff` fence; a counts table a pipe table; a file is its display path as text.
+	* - With `linkBase`, a file link goes to the base and the display path, plus `#L<line>`, in place of `file://`. A
+	*   display path that is absolute or climbs out with `..` is not under the base, so its link has no URL form.
+	* - A compact list item joins its parts with no blank line, putting a hard break where two paragraphs would merge.
+	*   A row of counts names its duration column `duration`.
+	*
+	* @param doc - the document
+	* @param ctx - where the output is going; its glyph set, audience and `displayPath` are used
+	*/
+	static markdown = (doc, ctx) => guarded(renderMarkdown(doc, ctx), ctx);
+	/**
+	* Render a document for a GitHub Actions log.
+	*
+	* @remarks
+	* Everything is what {@link Render.plain} renders, except an annotation, which is one workflow command
+	* (`::error file=…,line=…::message`), and a collapsible that starts a line, which is a group: `::group::title`, its
+	* body, `::endgroup::`. An annotation is a command at the top level, as a top-level section's child, and as a direct
+	* child of a group's body; anywhere deeper (inside a list, a callout, or a section within a group) it is nothing,
+	* as in plain. Its message and properties are escaped, so no text can end
+	* the command or start another, and the kit's own command is never neutralized. That is a top-level collapsible, or one that is a direct child of a
+	* top-level section. GitHub does not nest groups, so a collapsible inside a group, or inside a list or callout
+	* (where it would not start a line), keeps plain's rendering: its title on a line and its body indented.
+	*
+	* The runner has two command parsers, and a line is a command if either accepts it: after its leading whitespace it
+	* starts with `::`, or `##[` occurs ANYWHERE in it (a bare `##` is not one). A document's text must not be able to
+	* do that (`::add-mask::`, `::error::`, `##[error]`), so such a `::` line gets a zero-width space in front, which
+	* the runner does not treat as whitespace, and every `##[` gets one between the `##` and the `[`. The text is
+	* otherwise unchanged. A
+	* group's title is a command's data, so its `%`, CR and LF are escaped. Lines are split at CR, LF and CRLF before
+	* that check, as the runner splits them. There is no ANSI and `paint` and `link` are never called, and the audience
+	* is treated as `agent`, as `plain` does.
+	*
+	* @param doc - the document
+	* @param ctx - where the output is going; the width, glyph set and `displayPath` are used as plain uses them
+	*/
+	static githubLog = (doc, ctx) => renderGithubLog(doc, ctx);
+};
+
+//#endregion
+export { Render };

package/SchemaIssueRenderer.js

@@ -2,20 +2,17 @@ import { formatIssue } from "./internal/format.js";
 
 //#region src/SchemaIssueRenderer.ts
 /**
-* Turn a `SchemaIssue` tree into lines a user can act on.
+* Turns a `SchemaIssue` tree into lines a user can act on.
 *
 * @remarks
 * A decode failure arrives as a structured tree; a person needs
-* `unknown key at groups.g.cleanup.rulesetz`.
+* `unknown key at groups.g.cleanup.rulesetz`. The formatters core ships for
+* this live on `SchemaIssue` rather than on `SchemaError` or `Schema`, and
+* `SchemaError.message` does not use them, so printing the error alone does not
+* give these lines.
 *
-* **Core already ships the formatters this wraps, and they are effectively
-* undiscoverable.** They live on `SchemaIssue` rather than `SchemaError` or
-* `Schema`, they are named `makeFormatter*` rather than anything containing
-* "render" or "format issue", and `SchemaError.message` does not use them — so
-* the obvious probe, printing the error, hints at nothing. Two engineers
-* searched for two rounds and concluded core had none. This export exists to
-* end that search, and the one phrasing override is a bonus rather than the
-* point.
+* The lines and `CliFailure`'s tree are two views of the same rejected values (`internal/format`), so a schema
+* failure in the default report and these lines never disagree.
 *
 * @example
 * ```ts

package/Status.js

@@ -0,0 +1,163 @@
+import { Array, Option } from "effect";
+
+//#region src/Status.ts
+/**
+* An open vocabulary of statuses.
+*
+* @remarks
+* Start from `Status.core` and add your own with `extend`. The names are a type parameter,
+* so `def` and `worst` reject a name the vocabulary does not have at compile time.
+*
+* @example
+* ```ts
+* import { Status } from "@effected/cli"
+*
+* const vocab = Status.extend({
+* 	timeout: { glyph: "⏱", ascii: "[time]", token: "warning", rank: 85 },
+* })
+* const worst = vocab.worst(["success", "timeout"])
+* // => "timeout"
+* ```
+*
+* @public
+*/
+var Status = class Status {
+	defs;
+	constructor(defs) {
+		this.defs = defs;
+	}
+	/** The core vocabulary: success, skip, pending, info, warning and failure, by rank 10, 20, 30, 40, 60, 90. */
+	static core = new Status({
+		success: {
+			glyph: "✓",
+			ascii: "[ok]",
+			token: "success",
+			rank: 10
+		},
+		skip: {
+			glyph: "↷",
+			ascii: "[skip]",
+			token: "muted",
+			rank: 20
+		},
+		pending: {
+			glyph: "◯",
+			ascii: "[ ]",
+			token: "muted",
+			rank: 30
+		},
+		info: {
+			glyph: "ℹ",
+			ascii: "[info]",
+			token: "info",
+			rank: 40
+		},
+		warning: {
+			glyph: "⚠",
+			ascii: "[warn]",
+			token: "warning",
+			rank: 60
+		},
+		failure: {
+			glyph: "✗",
+			ascii: "[FAIL]",
+			token: "failure",
+			rank: 90
+		}
+	});
+	/**
+	* The core vocabulary plus `extra`; an entry that reuses a core name replaces it.
+	*
+	* @param extra - the statuses to add, by name
+	*/
+	static extend = (extra) => Status.core.extend(extra);
+	/**
+	* This vocabulary plus `extra`; an entry that reuses a name replaces it.
+	*
+	* @remarks
+	* An entry may replace a core name. Replacing `warning` with a lower rank moves the threshold at which
+	* `CliMessage.status` defaults to stderr for this vocabulary, since that threshold is `warning`'s rank in the
+	* vocabulary it is given.
+	*
+	* @param extra - the statuses to add, by name
+	*/
+	extend(extra) {
+		return new Status({
+			...this.defs,
+			...extra
+		});
+	}
+	/**
+	* The definition of a status.
+	*
+	* @remarks
+	* A name the vocabulary does not have is a defect: it throws an `Error` naming it and the names that exist. The
+	* types already reject one, so it is reachable only through a cast.
+	*
+	* @param name - a name in this vocabulary
+	*/
+	def(name) {
+		if (!Object.hasOwn(this.defs, name)) throw new Error(`Unknown status "${name}"; this vocabulary has: ${Object.keys(this.defs).join(", ")}`);
+		return this.defs[name];
+	}
+	/**
+	* The full definition of a status as an immutable snapshot, for a caller that stores it.
+	*
+	* @remarks
+	* `def` answers the vocabulary's own entry. `resolve` answers a frozen copy, so a document node that holds
+	* the definition stays plain data and editing it cannot change the vocabulary. The copy is shallow: a
+	* `token` given as a `Style` keeps its own identity. Throws on an unknown name, as {@link Status.def} does;
+	* storing an empty definition in a document instead would fail far from the cause.
+	*
+	* @param name - a name in this vocabulary
+	*/
+	resolve(name) {
+		return Object.freeze({ ...this.def(name) });
+	}
+	/**
+	* A status's glyph from a glyph set: `def.ascii` for an ASCII set, `def.glyph` otherwise. Unpainted, for a caller
+	* that draws it itself (an Ink tree, a reporter).
+	*
+	* @remarks
+	* Throws on an unknown name, as {@link Status.def} does.
+	*
+	* @param name - a name in this vocabulary
+	* @param glyphs - the glyph set, such as `Glyphs.unicode`, `Glyphs.ascii` or a theme's
+	*/
+	glyph(name, glyphs) {
+		const def = this.def(name);
+		return glyphs.kind === "ascii" ? def.ascii : def.glyph;
+	}
+	/**
+	* The status with the highest rank; a tie goes to the one that comes first in `names`.
+	*
+	* @remarks
+	* `rank` is SEVERITY, not an aggregation policy: the higher rank wins, so in `Status.core` a `skip` outranks a
+	* `success`. A consumer whose aggregate differs (a test run where passes dominate skips, say) folds its own
+	* rule over the names instead of reading this.
+	*
+	* Takes at least one name, so the answer is always a name. For an array that may be empty, use
+	* {@link Status.worstOption}. They are two methods because a literal and an array variable are the same
+	* array at runtime, so one method could not return a name for one and an `Option` for the other.
+	*
+	* @param names - the statuses to compare
+	*/
+	worst(names) {
+		let worst = names[0];
+		for (const name of names) if (this.def(name).rank > this.def(worst).rank) worst = name;
+		return worst;
+	}
+	/**
+	* The status with the highest rank of an array that may be empty: `None` when it is, otherwise `Some` of
+	* the worst, a tie going to the one that comes first in `names`. Rank is severity, not an aggregation policy; see
+	* {@link Status.worst}.
+	*
+	* @param names - the statuses to compare
+	*/
+	worstOption(names) {
+		return Array.isReadonlyArrayNonEmpty(names) ? Option.some(this.worst(names)) : Option.none();
+	}
+};
+
+//#endregion
+export { Status };

package/TestTerminal.js

@@ -0,0 +1,80 @@
+import { Effect, Layer, Option, Queue, Terminal } from "effect";
+
+//#region src/TestTerminal.ts
+/**
+* A scripted `Terminal` for testing prompts and anything that reads the terminal.
+*
+* @remarks
+* Queue keys with `input` or `type`, run the program under `layer`, then read `output`. To assert that a code path
+* did NOT touch the terminal, queue some keys first and check `reads` is all zero (no subscription, no key, no
+* line) and `pending` is unchanged afterwards. Only
+* available from `@effected/cli/testing`.
+*
+* @public
+*/
+var TestTerminal = class {
+	constructor() {}
+	/**
+	* Build a test terminal.
+	*
+	* @param options - the reported size; 80 by 24 by default
+	*/
+	static make = (options) => Effect.gen(function* () {
+		const queue = yield* Queue.unbounded();
+		const written = [];
+		let offered = 0;
+		let lines = 0;
+		let subscriptions = 0;
+		const offer = (inputs) => Effect.suspend(() => {
+			offered += inputs.length;
+			return Queue.offerAll(queue, inputs);
+		}).pipe(Effect.asVoid);
+		const terminal = Terminal.make({
+			columns: Effect.succeed(options?.columns ?? 80),
+			rows: Effect.succeed(options?.rows ?? 24),
+			readInput: Effect.sync(() => {
+				subscriptions++;
+				return queue;
+			}),
+			readLine: Effect.suspend(() => {
+				lines++;
+				return Effect.fail(new Terminal.QuitError({}));
+			}),
+			display: (text) => Effect.sync(() => {
+				written.push(text);
+			})
+		});
+		return {
+			layer: Layer.succeed(Terminal.Terminal, terminal),
+			input: (keys) => offer(keys.map((key) => ({
+				input: Option.none(),
+				key: {
+					name: key.name,
+					ctrl: key.ctrl ?? false,
+					meta: key.meta ?? false,
+					shift: key.shift ?? false
+				}
+			}))),
+			type: (text) => offer(Array.from(text, (char) => ({
+				input: Option.some(char),
+				key: {
+					name: char,
+					ctrl: false,
+					meta: false,
+					shift: false
+				}
+			}))),
+			end: Queue.end(queue).pipe(Effect.asVoid),
+			output: Effect.sync(() => written.join("")),
+			pending: Queue.size(queue),
+			reads: Effect.map(Queue.size(queue), (size) => ({
+				keys: offered - size,
+				lines,
+				subscriptions
+			}))
+		};
+	});
+};
+
+//#endregion
+export { TestTerminal };

package/Token.js

@@ -0,0 +1,69 @@
+//#region src/Token.ts
+/** The default style of every token. Deeply frozen: the record is shared. */
+const DEFAULTS = Object.freeze({
+	success: Object.freeze({ fg: "green" }),
+	failure: Object.freeze({ fg: "red" }),
+	error: Object.freeze({
+		fg: "red",
+		bold: true
+	}),
+	warning: Object.freeze({ fg: "yellow" }),
+	info: Object.freeze({ fg: "cyan" }),
+	muted: Object.freeze({ dim: true }),
+	accent: Object.freeze({ fg: "cyan" }),
+	emphasis: Object.freeze({ bold: true })
+});
+/**
+* Constructors for {@link Style} values, and the pure resolution of a token to one.
+*
+* @public
+*/
+var Token = class {
+	constructor() {}
+	/**
+	* The default {@link Style} of every token, frozen.
+	*
+	* @remarks
+	* Data, not a service: it is what `CliTheme` starts from, and a renderer with no Effect context (an Ink
+	* component) reads it directly.
+	*/
+	static defaults = DEFAULTS;
+	/**
+	* The style a token or style resolves to, as a pure function: no service, no terminal.
+	*
+	* @remarks
+	* An explicit style resolves to itself. A token name resolves to its override when `overrides` has one, else
+	* its default; a name that is not a token (including an `Object.prototype` member) resolves to the empty
+	* style. This is the same resolution `CliTheme.paint` applies, which is what `StreamTheme.style` reports.
+	*
+	* @param token - a token name or an explicit style
+	* @param overrides - styles that replace the default of a token, as `CliThemeOptions.tokens` does
+	*/
+	static resolve = (token, overrides) => {
+		if (typeof token !== "string") return token;
+		const own = overrides !== void 0 && Object.hasOwn(overrides, token) ? overrides[token] : void 0;
+		if (own !== void 0) return own;
+		return Object.hasOwn(DEFAULTS, token) ? DEFAULTS[token] : {};
+	};
+	/**
+	* A foreground from a hex colour.
+	*
+	* @param hex - `#rrggbb` (or `#rgb`)
+	*/
+	static hex = (hex) => ({ fg: hex });
+	/**
+	* A foreground from a named colour.
+	*
+	* @param color - the colour
+	*/
+	static named = (color) => ({ fg: color });
+	/**
+	* A style, as written. Exists so a style reads as a token at a call site.
+	*
+	* @param style - the style
+	*/
+	static style = (style) => style;
+};
+
+//#endregion
+export { Token };