@leed-ai/cli 0.0.0-stage → 6.19.0

package/dist/chunk-1VJ9lAw7.js

@@ -0,0 +1,42 @@
+/**
+* SPDX-FileCopyrightText: © 2024-2025 Leed, Inc.
+* SPDX-License-Identifier: LicenseRef-Leed-EULA
+*/
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { get: (a, b) => (typeof require !== "undefined" ? require : a)[b] }) : x)(function(x) {
+	if (typeof require !== "undefined") return require.apply(this, arguments);
+	throw Error("Calling `require` for \"" + x + "\" in an environment that doesn't expose the `require` function. See https://rolldown.rs/in-depth/bundling-cjs#require-external-modules for more details.");
+});
+//#endregion
+export { __toESM as a, __require as i, __esmMin as n, __exportAll as r, __commonJSMin as t };

package/dist/cliAuth-38JjD6hw.js

@@ -0,0 +1,15 @@
+/**
+* SPDX-FileCopyrightText: © 2024-2025 Leed, Inc.
+* SPDX-License-Identifier: LicenseRef-Leed-EULA
+*/
+import { r as __exportAll } from "./chunk-1VJ9lAw7.js";
+import { z } from "zod";
+//#region ../../libs/data-types/src/auth/schemas/cliAuth.ts
+var cliAuth_exports = /* @__PURE__ */ __exportAll({ CliRefreshResponse: () => CliRefreshResponse });
+z.object({ accessToken: z.string().min(1).describe("The current (possibly expired) session token to refresh") });
+const CliRefreshResponse = z.object({
+	accessToken: z.string().describe("Session token to use from now on: the same token until it is renewed, then its successor"),
+	expiresIn: z.number().describe("Seconds until the returned token expires")
+});
+//#endregion
+export { cliAuth_exports as n, CliRefreshResponse as t };

package/dist/env-B0bHiXJJ.js

@@ -0,0 +1,29 @@
+/**
+* SPDX-FileCopyrightText: © 2024-2025 Leed, Inc.
+* SPDX-License-Identifier: LicenseRef-Leed-EULA
+*/
+import { r as __exportAll } from "./chunk-1VJ9lAw7.js";
+import { z } from "zod";
+//#region ../../libs/data-types/src/schema/env.ts
+var env_exports = /* @__PURE__ */ __exportAll({
+	CMS_BASE_URLS: () => CMS_BASE_URLS,
+	EnvName: () => EnvName,
+	cmsBaseUrl: () => cmsBaseUrl
+});
+const EnvName = z.enum([
+	"production",
+	"staging",
+	"dev"
+]);
+/** CMS app base URLs by environment. Use `cmsBaseUrl(env)` for resolved URL with env var override. */
+const CMS_BASE_URLS = {
+	production: "https://app.leed.ai",
+	staging: "https://staging.app.leed.ai",
+	dev: "http://localhost:8787"
+};
+/** Resolve the CMS base URL for an environment, with `LEED_CMS_URL` env var override. */
+function cmsBaseUrl(env) {
+	return process.env.LEED_CMS_URL || CMS_BASE_URLS[env] || CMS_BASE_URLS.production;
+}
+//#endregion
+export { cmsBaseUrl as n, env_exports as r, EnvName as t };

package/dist/errors-CqKamGCu.js

@@ -0,0 +1,481 @@
+/**
+* SPDX-FileCopyrightText: © 2024-2025 Leed, Inc.
+* SPDX-License-Identifier: LicenseRef-Leed-EULA
+*/
+//#region src/cli/output/documentStrings.ts
+/**
+* One walk over every string a document will actually serialize (#334).
+*
+* `emit()` applies two whole-document string transforms before it writes:
+* credential redaction (`./redact.ts`) and ANSI stripping (`./ansi.ts`). Both
+* are "rewrite every string anywhere in the value", and both have to agree
+* exactly about which strings those are — a boxed `String`, a class instance's
+* own enumerable properties, a `toJSON` bearer, a cycle. Getting that set wrong
+* is how the original credential leak happened, so it is written once here and
+* the two transforms are parameters.
+*
+* Extracted from `redactDocument`, whose behavior it is verbatim;
+* `redactionSweep.test.ts` and `redact.test.ts` are its coverage.
+*/
+/**
+* The primitive behind a boxed `String`, or null for anything else.
+*
+* `JSON.stringify` writes `new String(url)` as the URL, not as the `{"0":"h",
+* "1":"t",…}` its own enumerable properties would produce — so walking those
+* properties would rewrite nothing that gets serialized. It needs the same
+* treatment a bare string gets, on its primitive.
+*/
+function boxedStringValue(value) {
+	return Object.prototype.toString.call(value) === "[object String]" ? String(value) : null;
+}
+/**
+* Whether `JSON.stringify` will serialize `value` through its own `toJSON`
+* rather than from its properties — a `Date`, or anything that declares one.
+*
+* Such a value is returned as it came. Its own enumerable properties are NOT
+* what the serializer writes, so rewriting them would change the object without
+* changing the document, and there is no way to rewrite what `toJSON` returns
+* that leaves the value still usable by a renderer — replacing a `Date` with a
+* string breaks the first `.toISOString()` that touches it. See the residual
+* edge noted below.
+*/
+function hasToJson(value) {
+	return typeof value.toJSON === "function";
+}
+/**
+* `value` with every string in it, at any depth, run through `transform`.
+*
+* **It walks what `JSON.stringify` will actually serialize**, which is the
+* whole point of a backstop: the own enumerable properties of any object the
+* serializer will write as an object, arrays by their elements, boxed strings
+* by their primitive. Restricting the walk to *plain* objects was a hole in
+* exactly the shape `./redact.ts` was written for — a simple-git `GitError` is
+* a class instance, and the token lives on its own enumerable `task.commands`,
+* which the serializer writes out and the walk skipped straight past.
+*
+* The one thing it does not walk is a `toJSON`-bearing value, because that is
+* the one case where own enumerable properties are not what gets serialized.
+* **Residual edge:** a `toJSON` that itself returns a string the caller wanted
+* rewritten is therefore left alone. Nothing in the CLI has one — `Date` is the
+* only such value it produces — and closing it would mean replacing the value
+* with its JSON projection, which breaks every renderer that calls a method on
+* it.
+*
+* A non-plain object is rebuilt as a plain one, so what comes out serializes
+* byte-for-byte as the input would have, minus whatever `transform` removed.
+* That rebuild loses the prototype and any non-enumerable property (an
+* `Error`'s `message` and `stack`) — but it happens ONLY when something below
+* actually changed. On every other value the original object is returned
+* unchanged, so the common case allocates nothing and the value `emit()` hands
+* a renderer is identical.
+*
+* `open` is the set of objects on the current path, and it is not an
+* optimization: a payload can be circular, and `emit()` runs this BEFORE
+* `JSON.stringify` — so an unguarded walk turns "the caller handed us a cyclic
+* result" into a `RangeError` thrown out of `emit()` itself, which is the one
+* thing `emit()` promises never to do. A node already on the path is returned
+* as it came; the serializer that follows refuses the cycle anyway and
+* `emit()` answers with its substituted failure envelope, so no document
+* carrying the unwalked subtree is ever written.
+*/
+function mapDocumentStrings(value, transform, open = /* @__PURE__ */ new WeakSet()) {
+	if (typeof value === "string") return transform(value);
+	if (typeof value !== "object" || value === null) return value;
+	if (open.has(value)) return value;
+	const isArray = Array.isArray(value);
+	if (!isArray) {
+		const boxed = boxedStringValue(value);
+		if (boxed !== null) {
+			const mapped = transform(boxed);
+			return mapped === boxed ? value : new String(mapped);
+		}
+		if (hasToJson(value)) return value;
+	}
+	open.add(value);
+	try {
+		let changed = false;
+		const walk = (item) => {
+			const mapped = mapDocumentStrings(item, transform, open);
+			if (mapped !== item) changed = true;
+			return mapped;
+		};
+		if (isArray) {
+			const next = value.map(walk);
+			return changed ? next : value;
+		}
+		const next = {};
+		for (const [key, item] of Object.entries(value)) next[key] = walk(item);
+		return changed ? next : value;
+	} finally {
+		open.delete(value);
+	}
+}
+//#endregion
+//#region src/cli/output/redact.ts
+/**
+* Credential redaction at the one place documents leave the CLI (#333).
+*
+* `leed site init` used to build the raw-content clone URL with the freshly
+* issued GitLab token embedded in it — `https://access-token:<token>@gitlab.com/…`
+* — because that URL was also what got persisted as the checkout's `origin`, and
+* every later `leed site push` / `leed site commit` authenticated with it. The
+* token therefore appeared in the argv of the git commands the CLI ran, and
+* simple-git parks that argv on the error it throws as an OWN ENUMERABLE
+* `task.commands` property. Anything that renders such an error as a value —
+* `util.format`, `util.inspect`, `console.error(err)` — prints own enumerable
+* properties, so the token came out with it.
+*
+* #413 removed that URL: the token lives in `~/.config/leed/auth.json` and
+* reaches git through config environment variables, so argv is clean by
+* construction. **That moved the leak surface rather than closing this
+* module.** Three shapes have to be matched now, not one:
+*
+*  - `URL_USERINFO`, kept as the backstop for a checkout that has not been
+*    migrated yet — its `origin` still carries userinfo, and git prints the
+*    remote URL in plenty of its own messages;
+*  - `GITLAB_TOKEN`, the bare `glpat-…` shape, which is what a token looks like
+*    once it is not in a URL — in a `git credential` transcript, in an
+*    `auth.json` path a user pasted, or in a CMS response a command echoed;
+*  - `AUTHORIZATION_VALUE`, the header the config environment carries, which
+*    `simple-git` itself logs with `logger("%O", spawnOptions)` under
+*    `DEBUG=simple-git`.
+*
+* Without the last two this module would silently stop covering anything the
+* moment the URL form went away.
+*
+* On its own that was a line on a terminal. Under `--json` it became a field of
+* a document written to stdout for a machine to capture, parse, persist and
+* forward — `data.repositoryError` and `warnings[0]` on the `site.init`
+* envelope. Log-read access is a far wider circle than repo-write access, and
+* the token stays valid: every failure that produces one of those strings (a
+* half-created directory, an aborted earlier init, a removed remote, a clone
+* that failed on the network) is unrelated to whether the token still works.
+*
+* Two rules, and this module is the second:
+*
+*  1. Never render a git error OBJECT into a reported string. Take its
+*     `message`. `initRepository.ts` is where that is done.
+*  2. Redact anyway, at the boundary — because rule 1 is a convention and one
+*     unwrapped `simpleGit(...).remote(["set-url", …])` reintroduces the
+*     vulnerability. `emit()` is that boundary: every document the CLI emits,
+*     from a command leaf, from a Commander `_exit`, or from `emit()`'s own
+*     substituted failure envelope, is written by it and nothing else.
+*
+* The redaction runs on the PARSED value, before either projection, so the
+* human render and the JSON payload are redacted by the same pass and cannot
+* disagree about it.
+*
+* ## What the guarantee covers, and where it stops
+*
+* It covers **the document** — every field of every envelope the CLI writes,
+* under `--json` and in the human render alike, because both are projections of
+* the value this module has already walked.
+*
+* It does **not** cover **stderr passthrough**. The output of a program the CLI
+* drives — wrangler, Eleventy, git — is streamed to stderr as it arrives
+* (`./subprocess.ts`, `./streams.ts`), never buffered into a field, and never
+* routed through `emit()`. Nothing redacts it. That is deliberate: it is
+* diagnostic narration for the person watching, it is what the program itself
+* chose to print, and interposing on a live stream would mean holding output
+* back to look for a `//user:password@` that could straddle two chunks. The
+* machine-readable document on stdout is the surface with the guarantee; the
+* narration on stderr is not, and no future reader should assume otherwise.
+*
+* The one place an invocation IS reconstructed into a field —
+* `externalCommandDetails` in `./errors.ts`, which prints the argv git was run
+* with — redacts at the point it builds the string, as well as here.
+*
+* URL userinfo: the `user:password@` (or bare `token@`) between `//` and the
+* host.
+*
+* Neither half may contain `/`, whitespace or a second `@`, which is what stops
+* it matching an `@` that merely appears somewhere in a path — `//host/a@b` has
+* a `/` before the `@` and is left alone. An `scp`-form remote
+* (`git@gitlab.com:leed-ai/x.git`) has no `//` and carries no secret, so it is
+* likewise untouched.
+*
+* The user half also excludes `:`, which the password half does not. Without
+* that it is greedy enough to swallow the separator — `//access-token:<token>@`
+* matched as a username of `access-token:<token>` and no password at all, which
+* still redacted the secret but reported the wrong shape.
+*/
+const URL_USERINFO = /\/\/([^/\s@:]*)(:[^/\s@]*)?@/g;
+/** What a redacted `user:password@` reads as. */
+const REDACTED_USERINFO = "//***:***@";
+/** What a redacted bare `token@` reads as. */
+const REDACTED_USER = "//***@";
+/**
+* A GitLab access token outside any URL: the `glpat-` prefix and its payload.
+*
+* The prefix is the whole anchor, and it is enough — GitLab stamps it on every
+* personal and project access token, and nothing else in this CLI's output is
+* shaped like it. The prefix is KEPT in the replacement, because a reader needs
+* to know that what was removed was a repository token rather than a session
+* cookie or a password.
+*/
+const GITLAB_TOKEN = /glpat-[A-Za-z0-9_-]+/g;
+/** What a redacted bare `glpat-…` token reads as. */
+const REDACTED_TOKEN = "glpat-***";
+/**
+* An `Authorization` header carrying an actual credential.
+*
+* **Anchored on the credential, not on the header name.** `redactDocument`
+* walks every string of every emitted document, and `leed import openapi`
+* legitimately handles specs that *describe* an `Authorization` header — a
+* matcher that ate from the word `Authorization:` to the end of the line would
+* redact the user's own API documentation. Requiring `Basic` or `Bearer`
+* followed by at least one credential character means a prose mention, or a
+* placeholder like `Authorization: Bearer <token>`, is left exactly as it is.
+*
+* The scheme is kept in the replacement for the same reason the `glpat-` prefix
+* is: it says what was removed.
+*
+* **Horizontal whitespace only.** `\s` matches newlines, so an
+* `Authorization: Basic` ending a line — a truncated log, a header printed with
+* no value — reached across the break and ate the first token-shaped word on
+* the NEXT line, which is someone else's output. Failing safe is still
+* corrupting, so the classes are `[ \t]`.
+*/
+const AUTHORIZATION_VALUE = /(Authorization:[ \t]*(?:Basic|Bearer)[ \t]+)[A-Za-z0-9+/=._~-]+/gi;
+/**
+* `text` with every credential shape it contains replaced by `***`.
+*
+* A URL keeps its shape — scheme, host, path — because that is the part a
+* reader needs to understand what failed. Only the secret goes, and the same
+* goes for a token's prefix and a header's scheme.
+*/
+function redactCredentials(text) {
+	return text.replace(URL_USERINFO, (_match, _user, password) => password === void 0 ? REDACTED_USER : REDACTED_USERINFO).replace(GITLAB_TOKEN, REDACTED_TOKEN).replace(AUTHORIZATION_VALUE, (_match, scheme) => `${scheme}***`);
+}
+/**
+* `value` with every string in it, at any depth, run through
+* `redactCredentials`.
+*
+* The walk itself lives in `./documentStrings.ts`, shared with the ANSI sweep
+* in `./ansi.ts`: both transforms must agree exactly about which strings a
+* document contains — a boxed `String`, a class instance's own enumerable
+* properties, a `toJSON` bearer, a cycle — and that set is where the original
+* leak hid. See that module for what is and is not walked, and for the
+* residual `toJSON` edge.
+*/
+function redactDocument(value) {
+	return mapDocumentStrings(value, redactCredentials);
+}
+//#endregion
+//#region src/cli/output/errors.ts
+/**
+* The bridge between thrown errors and the `--json` envelope (#333 Phase 2).
+*
+* `CliUserError` is the CLI's one deliberate, user-facing throw. Folding it
+* into the shared error catalog means a single thrown error renders correctly
+* in BOTH modes: `src/cli/index.ts` prints its message and hint as text, and
+* `cliErrorFrom` turns the same instance into the envelope's `error` object
+* with a machine-readable `code`.
+*
+* Nothing here changes the wording of any message — only its shape.
+*/
+/**
+* The code a `CliUserError` carries when its throw site does not name one.
+*
+* It is the code for exactly one situation: the options or arguments supplied
+* cannot be used — a bad flag value, a file named by a flag that is missing or
+* of the wrong kind. It is NOT a catch-all. Every throw site whose remedy is
+* something other than "fix your arguments" — cd into a site checkout, log in
+* again, stage a set first — names its own code, because that code
+* is the branch an agent takes and a wrong one sends it down the wrong path.
+*/
+const DEFAULT_USER_ERROR_CODE = "invalid_arguments";
+/** The code used for any error that is not a deliberate, user-facing one. */
+const UNEXPECTED_ERROR_CODE = "internal_error";
+/** The code for a fault in the environment the CLI is running in, not in the CLI. */
+const EXTERNAL_COMMAND_ERROR_CODE = "external_command_failed";
+/**
+* simple-git's own error classes, by constructor name.
+*
+* Every command that touches a repository reaches git through simple-git, and
+* everything it throws — git absent from PATH, the directory not a repository,
+* a command that exited non-zero — arrives here as one of these. `name` is no
+* use: they all inherit `"Error"` from `Error.prototype`, so the constructor is
+* what identifies them. `TaskConfigurationError` is deliberately absent: that
+* one means the CLI called simple-git wrongly, which IS an internal fault.
+*/
+const GIT_ERROR_CONSTRUCTORS = new Set([
+	"GitError",
+	"GitConstructError",
+	"GitPluginError",
+	"GitResponseError"
+]);
+/**
+* Markers of an external fault in a message, for anything that reaches us
+* without its class intact — a bundler that renamed a constructor, an error
+* re-thrown as a plain `Error` carrying a subprocess's own words.
+*
+* `fatal:` and `error:` are git's, at the start of a line; `spawn … ENOENT` is
+* Node's for a program that could not be started at all.
+*/
+const EXTERNAL_FAULT_RE = /^fatal: |^error: |\bspawn\b[^\n]*\bENOENT\b/m;
+/**
+* Node's own prefix on an `execSync`/`exec` failure: `Command failed: <cmd>`,
+* followed by whatever the child wrote to stderr.
+*
+* `leed self-update` is why this is here. It drives `bun pm view` and `bun
+* install -g` through `execSync`, and a registry that cannot be reached throws
+* a plain `Error` whose message begins with this prefix — no git error class,
+* no `fatal:`, no `spawn ENOENT`. It was therefore reported as
+* `internal_error`, "an unexpected fault in the CLI itself", for a failure
+* entirely in the caller's network or registry configuration: an agent that
+* branched on that code would file a bug against the CLI instead of checking
+* its own connectivity.
+*/
+const SUBPROCESS_PREFIX_RE = /^Command failed: (.*)$/m;
+/**
+* Whether `thrown` came back from a child process the CLI started.
+*
+* `status` is the child's exit code, set by `execSync` and `spawnSync` on the
+* error they throw; a genuine internal fault does not carry one. The message
+* prefix is the fallback for anything that lost its extra properties on the way
+* here — a re-throw, a bundler, a `structuredClone`.
+*/
+function isSubprocessFailure(thrown) {
+	const status = thrown.status;
+	if (typeof status === "number" || typeof status === "string") return true;
+	return SUBPROCESS_PREFIX_RE.test(thrown.message);
+}
+/**
+* Whether `thrown` is a program the CLI drives failing, rather than the CLI
+* failing.
+*
+* The distinction is the whole reason `external_command_failed` exists. "git
+* is not installed" and "this is not a git repository" reached `site validate`,
+* `site commit` and `site upload` as `internal_error`, which tells an agent the
+* CLI is broken and there is nothing it can do — when in fact the remedy is
+* entirely in the caller's environment, and git has usually printed it.
+*/
+function isExternalCommandFailure(thrown) {
+	if (!(thrown instanceof Error)) return false;
+	if (GIT_ERROR_CONSTRUCTORS.has(thrown.constructor?.name ?? "")) return true;
+	if (isSubprocessFailure(thrown)) return true;
+	return EXTERNAL_FAULT_RE.test(thrown.message);
+}
+/** The invocation behind `thrown`, when the thrower recorded one. */
+function failingInvocation(thrown) {
+	const commands = thrown.task?.commands;
+	if (Array.isArray(commands) && commands.length > 0) return `git ${commands.join(" ")}`;
+	return SUBPROCESS_PREFIX_RE.exec(thrown.message)?.[1]?.trim();
+}
+/** Whatever the child wrote, when it is carried separately from the message. */
+function subprocessOutput(thrown) {
+	const stderr = thrown.stderr;
+	const text = typeof stderr === "string" ? stderr : stderr instanceof Uint8Array ? Buffer.from(stderr).toString() : "";
+	return text.trim().length > 0 ? text.trim() : void 0;
+}
+/**
+* The message with Node's own `Command failed: <cmd>` line taken off.
+*
+* The invocation on that line is reported as `details`' first line already;
+* leaving it in the body prints it twice, once as the CLI's framing and once as
+* Node's, with the child's actual words below both.
+*/
+function withoutSubprocessPrefix(message) {
+	const lines = message.split("\n");
+	if (!SUBPROCESS_PREFIX_RE.test(lines[0] ?? "")) return message.trim();
+	return lines.slice(1).join("\n").trim();
+}
+/**
+* `error.details` for a failure of a program the CLI drives.
+*
+* The enum entry for `external_command_failed` tells a consumer to read
+* `error.details` — so it has to BE there. It was not: the codes assigned by
+* hand (`site push`'s fetch and push failures) carried an extract, while every
+* failure that arrived by being thrown carried git's output in `message` and no
+* `details` at all, leaving an agent that followed the documented advice
+* holding `undefined`.
+*
+* What it carries is the fullest form of the program's own words the CLI has:
+* the exact invocation, when the thrower recorded one, then that program's
+* output. The invocation is the part `message` never has, and it is what turns
+* "fatal: ambiguous argument 'origin/staging..HEAD'" into something a caller
+* can act on without guessing which command produced it.
+*
+* **It is also the one place that deliberately reconstructs an argv**, and the
+* CLI's git argv carries the raw-content access token inside the remote URL —
+* `git remote set-url origin https://access-token:<token>@gitlab.com/…`. So the
+* reconstruction is redacted here, at the point it is built, as well as at
+* `emit()`'s boundary. Two layers because this one is the specific hazard and
+* that one is the general guarantee.
+*
+* Both layers are about the DOCUMENT. The same program's output streamed live
+* to stderr — `./subprocess.ts` — passes through neither and is not redacted;
+* that boundary is written up in `./redact.ts`.
+*/
+function externalCommandDetails(thrown) {
+	if (!(thrown instanceof Error)) return void 0;
+	const invocation = failingInvocation(thrown);
+	const output = subprocessOutput(thrown) ?? withoutSubprocessPrefix(thrown.message);
+	if (output.length === 0) return invocation ? redactCredentials(`$ ${invocation}`) : void 0;
+	return redactCredentials(invocation ? `$ ${invocation}\n\n${output}` : output);
+}
+/**
+* Whether `value` is a user-facing CLI error.
+*
+* Tested by `name` rather than `instanceof`: the CLI is bundled, and tests
+* re-import modules through `vi.resetModules()`, either of which can produce
+* two distinct `CliUserError` constructors for the same conceptual class.
+* `name` survives both. This is the same check `index.ts` has always made.
+*/
+function isCliUserError(value) {
+	return value instanceof Error && value.name === "CliUserError";
+}
+/**
+* Convert anything thrown into the envelope's `error` object.
+*
+* A `CliUserError` keeps its code, message, hint and `next` steps. A failure of a program the
+* CLI drives is `external_command_failed` — the message is that program's, and
+* the remedy is in the caller's environment. Anything else is an internal
+* fault: its message is preserved for the reader, but the code is
+* `internal_error` because the CLI has no idea what actually went wrong.
+*/
+function cliErrorFrom(thrown, details) {
+	if (isCliUserError(thrown)) {
+		const error = {
+			code: thrown.code,
+			message: thrown.message,
+			...thrown.hint ? { hint: thrown.hint } : {},
+			...thrown.next && thrown.next.length > 0 ? { next: [...thrown.next] } : {},
+			...blockedRequestOfError(thrown)
+		};
+		return details === void 0 ? error : {
+			...error,
+			details
+		};
+	}
+	const code = codeForFault(thrown);
+	const resolved = details ?? (code === "external_command_failed" ? externalCommandDetails(thrown) : void 0);
+	const error = {
+		code,
+		message: messageOf(thrown)
+	};
+	return resolved === void 0 ? error : {
+		...error,
+		details: resolved
+	};
+}
+/**
+* A thrown `request_blocked` error's details (#463), when it carries them (`notifyBuildResult.ts`'s
+* `BuildResultRefusal`): the envelope promises `error.request` with that code.
+*/
+function blockedRequestOfError(thrown) {
+	const { request } = thrown;
+	return thrown.code === "request_blocked" && request ? { request } : {};
+}
+/** `external_command_failed` for a driven program's fault, else `internal_error`. */
+function codeForFault(thrown) {
+	return isExternalCommandFailure(thrown) ? EXTERNAL_COMMAND_ERROR_CODE : UNEXPECTED_ERROR_CODE;
+}
+function messageOf(thrown) {
+	if (thrown instanceof Error) return thrown.message;
+	if (typeof thrown === "string") return thrown;
+	return String(thrown);
+}
+//#endregion
+export { isCliUserError as a, redactDocument as c, externalCommandDetails as i, mapDocumentStrings as l, EXTERNAL_COMMAND_ERROR_CODE as n, isExternalCommandFailure as o, cliErrorFrom as r, redactCredentials as s, DEFAULT_USER_ERROR_CODE as t };