@effected/cli 0.26.0 → 0.28.0

package/bin/effected.js

@@ -1,7 +1,14 @@
 #!/usr/bin/env node
-import { main } from "../main.js";
-
 // src/bin.ts
+if (import.meta.url.endsWith(".ts")) {
+	const { register } = await import([
+		"tsx",
+		"esm",
+		"api"
+	].join("/"));
+	register();
+}
+const { main } = await import("../main.js");
 main();
 
 export {  };

package/ci.js

@@ -0,0 +1,16 @@
+import { Option } from "effect";
+import { RuntimeEnv } from "@effected/env";
+
+// src/ci.ts
+/**
+* Whether the process runs under CI, by `@effected/env`'s one rule: a known
+* provider's marker, or a truthy `CI` or `CONTINUOUS_INTEGRATION`; `CI=false`
+* is not CI. Its own module so `main` and its test call the same expression,
+* and so `main` never reaches `@effected/engine/build`, which loads the
+* bundler and its toolchain.
+*
+* @internal
+*/
+const isCI = (env) => Option.isSome(RuntimeEnv.fromRecord(env).ci);
+
+export { isCI };

package/commands/action/build.js

@@ -0,0 +1,9 @@
+import { execute } from "./execute.js";
+import { buildFlags } from "./flags.js";
+import { Command } from "effect/cli";
+
+// src/commands/action/build.ts
+/** `effected action build`: build the GitHub Action in the working directory into its `dist`. */
+const makeBuildCommand = (deps) => Command.make("build", buildFlags, (input) => execute(input, deps)).pipe(Command.withDescription("Build the GitHub Action in the working directory from the [action] table of its effected.toml into dist"));
+
+export { makeBuildCommand };

package/commands/action/errors.js

@@ -0,0 +1,54 @@
+import { Schema } from "effect";
+
+// src/commands/action/errors.ts
+/**
+* Validation stopped the build or an entry failed. Exit `1`.
+*
+* @public
+*/
+var ActionBuildFailedError = class extends Schema.TaggedError()("ActionBuildFailedError", {
+	/** How many validation errors there were. */
+	errors: Schema.Number,
+	/** How many entries failed to bundle or load. */
+	failedEntries: Schema.Number
+}) {
+	get message() {
+		const parts = [...this.errors > 0 ? [`${this.errors} validation error(s)`] : [], ...this.failedEntries > 0 ? [`${this.failedEntries} failed entry(ies)`] : []];
+		return parts.length > 0 ? `The action build failed with ${parts.join(" and ")}.` : "The action build failed: warnings are errors in strict mode.";
+	}
+};
+/**
+* The build could not start: its `effected.toml` would not load, it has no `[action]` table, or the directory is not a
+* package. Exit `2`: exit `1` means it ran and found a problem.
+*
+* @remarks
+* Carries the engine's message. This command's own type rather than the engine's, because the engine's build entry is
+* loaded only when the command runs.
+*
+* @public
+*/
+var ActionConfigError = class extends Schema.TaggedError()("ActionConfigError", { message: Schema.String }) {};
+/**
+* The build could not finish: an entry is missing with validation off, or a file could not be read, cleaned, written or
+* copied. `action init` fails with it too when a write fails after its checks, naming the files already written. Exit
+* `3`, the infrastructure tier.
+*
+* @remarks
+* Carries the engine's message, as {@link ActionConfigError} does.
+*
+* @public
+*/
+var ActionRunError = class extends Schema.TaggedError()("ActionRunError", { message: Schema.String }) {};
+/**
+* `action init` could not start: the directory is not a package, the action's name or description was found nowhere
+* or holds a control character, files it would write exist and `--force` was not given, or a path cannot be written
+* over (a symbolic link, the wrong kind of entry), which `--force` never overrides. Exit `2`, and nothing was written.
+*
+* @remarks
+* Carries the engine's message, as {@link ActionConfigError} does.
+*
+* @public
+*/
+var ActionInitError = class extends Schema.TaggedError()("ActionInitError", { message: Schema.String }) {};
+
+export { ActionBuildFailedError, ActionConfigError, ActionInitError, ActionRunError };

package/commands/action/execute-init.js

@@ -0,0 +1,44 @@
+import { InitDoc } from "../../render/InitDoc.js";
+import { resolveFormat } from "../schema/execute.js";
+import { ActionInitError, ActionRunError } from "./errors.js";
+import { Console, Effect, Option, Schema } from "effect";
+import { CliRuntime, Doc } from "@effected/cli-kit";
+
+// src/commands/action/execute-init.ts
+/**
+* Run one `action init`.
+*
+* @remarks
+* The engine's build entry is imported here, as `action build` imports it, so `effected --version` never loads it.
+*/
+const executeInit = Effect.fn("effected.action.init")(function* (input, deps) {
+	const format = yield* resolveFormat(input.format);
+	const { ActionInit, ActionInitResult } = yield* Effect.promise(() => import("@effected/engine/build"));
+	const refused = (error) => Effect.fail(CliRuntime.reported(new ActionInitError({ message: error.message }), 2));
+	const stopped = (error) => Effect.fail(CliRuntime.reported(new ActionRunError({ message: error.message }), 3));
+	const answer = yield* ActionInit.run({
+		...Option.match(input.name, {
+			onNone: () => ({}),
+			onSome: (name) => ({ name })
+		}),
+		...Option.match(input.description, {
+			onNone: () => ({}),
+			onSome: (description) => ({ description })
+		}),
+		force: input.force
+	}, { cwd: deps.cwd }).pipe(Effect.catchTags({
+		NotAPackageError: refused,
+		ActionMetadataMissingError: refused,
+		ActionMetadataInvalidError: refused,
+		ScaffoldConflictError: refused,
+		ScaffoldExistsError: (error) => Effect.fail(CliRuntime.reported(new ActionInitError({ message: `${error.message}: pass --force to replace them` }), 2)),
+		ScaffoldWriteError: stopped,
+		PlatformError: stopped
+	}));
+	if (format === "json") {
+		yield* Console.log(JSON.stringify(Schema.encodeSync(ActionInitResult)(answer)));
+		for (const line of InitDoc.lines(answer)) yield* Effect.logInfo(line);
+	} else yield* Doc.print([InitDoc.render(answer)]);
+});
+
+export { executeInit };

package/commands/action/execute.js

@@ -0,0 +1,47 @@
+import { ActionDoc } from "../../render/ActionDoc.js";
+import { resolveFormat } from "../schema/execute.js";
+import { ActionBuildFailedError, ActionConfigError, ActionRunError } from "./errors.js";
+import { Console, Effect, Schema } from "effect";
+import { CliRuntime, Doc } from "@effected/cli-kit";
+import { StepSummary } from "@effected/engine/schema";
+
+// src/commands/action/execute.ts
+/**
+* Run one `action build`.
+*
+* @remarks
+* The engine's build entry is imported here rather than at the top of the module: it loads the bundler and its
+* toolchain, which `effected --version` and every `effected schema` run have no use for. The report is emitted first and
+* the failure follows, so a run that fails has still said why.
+*/
+const execute = Effect.fn("effected.action.execute")(function* (input, deps) {
+	const format = yield* resolveFormat(input.format);
+	const { ActionRun, ActionRunResult } = yield* Effect.promise(() => import("@effected/engine/build"));
+	const refused = (error) => Effect.fail(CliRuntime.reported(new ActionConfigError({ message: error.message }), 2));
+	const stopped = (error) => Effect.fail(CliRuntime.reported(new ActionRunError({ message: error.message }), 3));
+	const answer = yield* ActionRun.run({
+		validate: !input.noValidate,
+		persist: !input.noPersist
+	}, deps).pipe(Effect.catchTags({
+		EffectedConfigError: refused,
+		NotAPackageError: refused,
+		NotAnActionError: refused,
+		BundleFailed: stopped,
+		CleanError: stopped,
+		WriteError: stopped,
+		PersistLocalError: stopped,
+		ActionYmlPathError: stopped,
+		PlatformError: stopped
+	}));
+	if (format === "json") {
+		yield* Console.log(JSON.stringify(Schema.encodeSync(ActionRunResult)(answer)));
+		for (const line of ActionDoc.lines(answer.result)) yield* Effect.logInfo(line);
+	} else yield* Doc.print([ActionDoc.render(answer.result)]);
+	yield* StepSummary.append(ActionDoc.markdown(answer.result));
+	if (answer.verdict === "failed") return yield* Effect.fail(CliRuntime.reported(new ActionBuildFailedError({
+		errors: answer.result.validation.errors.length,
+		failedEntries: answer.result.build.entries.filter((entry) => !entry.success).length
+	}), 1));
+});
+
+export { execute };

package/commands/action/flags.js

@@ -0,0 +1,19 @@
+import { formatFlag } from "../schema/flags.js";
+import { Flag } from "effect/cli";
+
+// src/commands/action/flags.ts
+/** What `action build` takes. */
+const buildFlags = {
+	format: formatFlag,
+	noValidate: Flag.Boolean("no-validate").pipe(Flag.withDefault(false), Flag.withDescription("Skip validating the config and action.yml, and the bundle size check")),
+	noPersist: Flag.Boolean("no-persist").pipe(Flag.withDefault(false), Flag.withDescription("Skip copying the build to the local action directory"))
+};
+/** What `action init` takes. A name or description left out is read from `package.json`. */
+const initFlags = {
+	format: formatFlag,
+	name: Flag.String("name").pipe(Flag.optional, Flag.withDescription("The action's display name in action.yml; omitted, package.json's name without its scope")),
+	description: Flag.String("description").pipe(Flag.optional, Flag.withDescription("What the action does, for action.yml; omitted, package.json's description")),
+	force: Flag.Boolean("force").pipe(Flag.withDefault(false), Flag.withDescription("Replace files that already exist; without it, any existing file stops the run before a write"))
+};
+
+export { buildFlags, initFlags };

package/commands/action/index.js

@@ -0,0 +1,9 @@
+import { makeBuildCommand } from "./build.js";
+import { makeInitCommand } from "./init.js";
+import { Command } from "effect/cli";
+
+// src/commands/action/index.ts
+/** `effected action`: the group, closed over the process boundary it runs against. */
+const makeActionCommand = (deps) => Command.make("action", {}).pipe(Command.withDescription("Scaffold or build the GitHub Action in the working directory, from its effected.toml"), Command.withSubcommands([makeBuildCommand(deps), makeInitCommand(deps)]));
+
+export { makeActionCommand };

package/commands/action/init.js

@@ -0,0 +1,9 @@
+import { executeInit } from "./execute-init.js";
+import { initFlags } from "./flags.js";
+import { Command } from "effect/cli";
+
+// src/commands/action/init.ts
+/** `effected action init`: scaffold a new GitHub Action in the working directory. */
+const makeInitCommand = (deps) => Command.make("init", initFlags, (input) => executeInit(input, deps)).pipe(Command.withDescription("Scaffold a new GitHub Action in the working directory: the [action] table of effected.toml, action.yml, src/main.ts, src/program.ts and tsconfig.json"));
+
+export { makeInitCommand };

package/commands/package/build.js

@@ -0,0 +1,9 @@
+import { execute } from "./execute.js";
+import { buildFlags } from "./flags.js";
+import { Command } from "effect/cli";
+
+// src/commands/package/build.ts
+/** `effected package build`: build the package in the working directory into its `dist/prod`. */
+const makeBuildCommand = (deps) => Command.make("build", buildFlags, (input) => execute(input, deps)).pipe(Command.withDescription("Build the package in the working directory into dist/prod: JS, declarations, the manifest, the API model and any binary"));
+
+export { makeBuildCommand };

package/commands/package/errors.js

@@ -0,0 +1,38 @@
+import { Schema } from "effect";
+
+// src/commands/package/errors.ts
+/**
+* The build crashed or recorded an error. Exit `1`.
+*
+* @public
+*/
+var BuildFailedError = class extends Schema.TaggedError()("BuildFailedError", {
+	/** How many errors the build recorded. */
+	errors: Schema.Number,
+	/** What ended the build, when it did not reach its end. */
+	failure: Schema.optionalKey(Schema.String)
+}) {
+	get message() {
+		const count = `${this.errors} error(s)`;
+		return this.failure !== void 0 ? `The build failed with ${count}: ${this.failure}` : `The build recorded ${count}.`;
+	}
+};
+/**
+* The build could not run: its `effected.toml` or a plugin would not load, the directory is not a package, or the
+* bundler refused the config before any work. Exit `2`: exit `1` means it ran and found a problem.
+*
+* @remarks
+* Carries the engine's message, which names the file at fault and the key within it. This command's own type rather
+* than the bundler's, because the CLI reaches the bundler only through the engine.
+*
+* @public
+*/
+var PackageConfigError = class extends Schema.TaggedError()("PackageConfigError", { message: Schema.String }) {};
+/**
+* A file the build needs could not be read or written. Exit `3`, the infrastructure tier.
+*
+* @public
+*/
+var PackageRunError = class extends Schema.TaggedError()("PackageRunError", { message: Schema.String }) {};
+
+export { BuildFailedError, PackageConfigError, PackageRunError };

package/commands/package/execute.js

@@ -0,0 +1,52 @@
+import { IssuesDoc } from "../../render/IssuesDoc.js";
+import { resolveFormat } from "../schema/execute.js";
+import { BuildFailedError, PackageConfigError, PackageRunError } from "./errors.js";
+import { Console, Effect, Schema } from "effect";
+import { CliRuntime, Doc } from "@effected/cli-kit";
+import { StepSummary } from "@effected/engine/schema";
+import { Audience } from "@effected/env";
+
+// src/commands/package/execute.ts
+/**
+* Run one `package build`.
+*
+* @remarks
+* The engine's build entry is imported here rather than at the top of the module: it loads the bundler and its
+* toolchain, which `effected --version` and every `effected schema` run have no use for. The report is emitted first and
+* the failure follows, so a run that fails has still said why.
+*
+* With `--format json`, stdout holds one document, so CI's annotations go to stderr instead, where the runner reads
+* workflow commands too.
+*/
+const execute = Effect.fn("effected.package.execute")(function* (input, deps) {
+	const format = yield* resolveFormat(input.format);
+	const audience = yield* Audience;
+	const { BuildRun, BuildRunResult, renderCiAnnotations } = yield* Effect.promise(() => import("@effected/engine/build"));
+	const refused = (error) => Effect.fail(CliRuntime.reported(new PackageConfigError({ message: error.message }), 2));
+	const result = yield* BuildRun.run({
+		noExe: input.noExe,
+		verbose: input.verbose
+	}, deps).pipe(Effect.catchTags({
+		EffectedConfigError: refused,
+		PluginLoadError: refused,
+		NotAPackageError: refused,
+		ConfigValidationError: refused,
+		PlatformError: (error) => Effect.fail(CliRuntime.reported(new PackageRunError({ message: error.message }), 3))
+	}));
+	const { issues } = result;
+	if (format === "json") {
+		yield* Console.log(JSON.stringify(Schema.encodeSync(BuildRunResult)(result)));
+		for (const line of IssuesDoc.lines(issues)) yield* Effect.logInfo(line);
+	} else yield* Doc.print([IssuesDoc.render(issues)]);
+	if (audience.kind === "ci") {
+		const write = format === "json" ? Console.error : Console.log;
+		for (const line of renderCiAnnotations(result.report)) yield* write(line);
+	}
+	yield* StepSummary.append(IssuesDoc.markdown(issues));
+	if (result.verdict === "failed") return yield* Effect.fail(CliRuntime.reported(new BuildFailedError({
+		errors: issues.errors.length,
+		...issues.failure !== void 0 ? { failure: issues.failure.message } : {}
+	}), 1));
+});
+
+export { execute };

package/commands/package/flags.js

@@ -0,0 +1,12 @@
+import { formatFlag } from "../schema/flags.js";
+import { Flag } from "effect/cli";
+
+// src/commands/package/flags.ts
+/** What `package build` takes. */
+const buildFlags = {
+	format: formatFlag,
+	noExe: Flag.Boolean("no-exe").pipe(Flag.withDefault(false), Flag.withDescription("Skip the single-executable compile; the manifest still points at the binary")),
+	verbose: Flag.Boolean("verbose").pipe(Flag.withDefault(false), Flag.withDescription("Measure gzip sizes for the report"))
+};
+
+export { buildFlags };

package/commands/package/index.js

@@ -0,0 +1,8 @@
+import { makeBuildCommand } from "./build.js";
+import { Command } from "effect/cli";
+
+// src/commands/package/index.ts
+/** `effected package`: the group, closed over the process boundary it runs against. */
+const makePackageCommand = (deps) => Command.make("package", {}).pipe(Command.withDescription("Build the package in the working directory from its effected.toml"), Command.withSubcommands([makeBuildCommand(deps)]));
+
+export { makePackageCommand };

package/commands/root.js

@@ -1,14 +1,20 @@
+import { makeActionCommand } from "./action/index.js";
+import { makePackageCommand } from "./package/index.js";
+import { makeSchemaCommand } from "./schema/index.js";
 import { CliAudience } from "@effected/cli-kit";
 import { Command } from "effect/cli";
 
 // src/commands/root.ts
 /**
-* The `effected` command tree. This release carries no subcommand: `--version`
-* and `--help` come from the framework, and the audience flags are shared on
-* the root so every future subcommand accepts them.
+* The `effected` command tree, closed over the process boundary it runs against: `main` hands in the process values, a
+* test its own. The audience flags are shared on the root so every subcommand accepts them.
 *
 * @public
 */
-const rootCommand = Command.make("effected", {}).pipe(Command.withDescription("The effected tool: a toolchain for Effect v4 applications."), Command.withSharedFlags(CliAudience.flags()));
+const makeRootCommand = (deps) => Command.make("effected", {}).pipe(Command.withDescription("The effected tool: a toolchain for Effect v4 applications."), Command.withSharedFlags(CliAudience.flags()), Command.withSubcommands([
+	makeSchemaCommand(deps),
+	makePackageCommand(deps),
+	makeActionCommand(deps)
+]));
 
-export { rootCommand };
+export { makeRootCommand };

package/commands/schema/LiveProgress.js

@@ -0,0 +1,114 @@
+import { Console, Effect, PubSub } from "effect";
+import { CliUi, useGlyphs, useStyle } from "@effected/cli-kit/ui";
+import { Box, Text } from "ink";
+import { createElement } from "react";
+
+// src/commands/schema/LiveProgress.ts
+const SETTLED = {
+	written: {
+		label: "written",
+		token: "success"
+	},
+	unchanged: {
+		label: "unchanged",
+		token: "muted"
+	},
+	"would-write": {
+		label: "would write",
+		token: "warning"
+	},
+	drift: {
+		label: "drift",
+		token: "error"
+	},
+	held: {
+		label: "held",
+		token: "muted"
+	},
+	"gate-failed": {
+		label: "gate failed",
+		token: "error"
+	}
+};
+const reduce = (state, event) => {
+	const update = (name, row) => ({ rows: state.rows.map((current) => current.name === name ? {
+		name,
+		...row
+	} : current) });
+	switch (event._tag) {
+		case "Started": return { rows: event.names.map((name) => ({
+			name,
+			pending: true,
+			label: "checking",
+			token: "muted"
+		})) };
+		case "SchemaChecked": return update(event.name, event.blocked ? {
+			pending: true,
+			label: "gate failed",
+			token: "error"
+		} : event.verdict === "drift" ? {
+			pending: true,
+			label: "drift",
+			token: "error"
+		} : event.change === "none" ? {
+			pending: true,
+			label: "clean",
+			token: "muted"
+		} : {
+			pending: true,
+			label: event.change,
+			token: "warning"
+		});
+		case "SchemaDone": return update(event.report.name, {
+			pending: false,
+			...SETTLED[event.report.outcome]
+		});
+		case "Ended": return state;
+	}
+};
+const RowView = ({ row, frame }) => {
+	const glyphs = useGlyphs();
+	const name = useStyle("emphasis");
+	const label = useStyle(row.token);
+	const mark = row.pending ? glyphs.spinner[frame % glyphs.spinner.length] ?? "" : glyphs.bullet;
+	return createElement(Text, null, createElement(Text, label, `${mark} `), createElement(Text, name, row.name), createElement(Text, label, ` ${row.label}`));
+};
+/**
+* The view's options, less the events: one value, so the test drives what the command runs.
+*
+* @internal
+*/
+const liveProgress = {
+	initial: { rows: [] },
+	reduce,
+	render: (state, frame) => createElement(Box, { flexDirection: "column" }, ...state.rows.map((row) => createElement(RowView, {
+		key: row.name,
+		row,
+		frame
+	}))),
+	isStart: (event) => event._tag === "Started",
+	isTerminal: (event) => event._tag === "Ended"
+};
+/**
+* Run the walk under the view: its progress feeds the rows, and its log lines write above the frame.
+*
+* @remarks
+* The frame is committed before the walk's answer is handed back, whichever way it ended, so what follows prints
+* below it and a walk that failed keeps the rows it reached.
+*
+* @internal
+*/
+const withLiveProgress = (walk) => Effect.gen(function* () {
+	const pubsub = yield* PubSub.unbounded();
+	const events = yield* PubSub.subscribe(pubsub);
+	const view = yield* CliUi.live({
+		...liveProgress,
+		events
+	});
+	const exit = yield* Effect.exit(walk((event) => Effect.asVoid(PubSub.publish(pubsub, event))).pipe(Effect.provideService(Console.Console, view.logConsole)));
+	yield* PubSub.publish(pubsub, { _tag: "Ended" });
+	yield* view.close;
+	return yield* exit;
+}).pipe(Effect.scoped);
+
+export { liveProgress, withLiveProgress };

package/commands/schema/build.js

@@ -0,0 +1,9 @@
+import { execute } from "./execute.js";
+import { commandFlags } from "./flags.js";
+import { Command } from "effect/cli";
+
+// src/commands/schema/build.ts
+/** `effected schema build`: generate, gate and write every schema and catalog entry the config declares. */
+const makeBuildCommand = (deps) => Command.make("build", commandFlags, (input) => execute("build", input, deps)).pipe(Command.withDescription("Generate, gate and write every schema the config declares, its catalog slice, and the merged catalog"));
+
+export { makeBuildCommand };

package/commands/schema/check.js

@@ -0,0 +1,12 @@
+import { execute } from "./execute.js";
+import { commandFlags } from "./flags.js";
+import { Command } from "effect/cli";
+
+// src/commands/schema/check.ts
+/**
+* `effected schema check`: the same walk as `build`, reported and never written. The CI drift gate: it also fails when
+* the committed documents are stale, and on outputs nothing claims, which `build` never deletes.
+*/
+const makeCheckCommand = (deps) => Command.make("check", commandFlags, (input) => execute("check", input, deps)).pipe(Command.withDescription("Report what build would do, fail when it would write anything or refuse to, or when a catalog file or document is orphaned or the merged catalog is blocked, and write nothing"));
+
+export { makeCheckCommand };

package/commands/schema/errors.js

@@ -0,0 +1,121 @@
+import { Schema } from "effect";
+
+// src/commands/schema/errors.ts
+const DriftedSchema = Schema.Struct({
+	$id: Schema.String,
+	change: Schema.Literals([
+		"none",
+		"created",
+		"annotations",
+		"contract"
+	]),
+	version: Schema.optionalKey(Schema.String),
+	nextVersion: Schema.optionalKey(Schema.String)
+});
+/**
+* A published schema drifted under `onDrift: "error"`, so nothing was written. Exit `1`.
+*
+* @public
+*/
+var DriftError = class extends Schema.TaggedError()("DriftError", { drifted: Schema.Array(DriftedSchema) }) {
+	get count() {
+		return this.drifted.length;
+	}
+	get message() {
+		const lines = this.drifted.map((s) => `  ${s.$id}: ${s.change}${s.version !== void 0 ? ` at published ${s.version}` : ""}${s.nextVersion !== void 0 ? ` → suggest ${s.nextVersion}` : ""}`);
+		return `${this.count} published schema(s) drifted; nothing was written.\n${lines.join("\n")}\nBump the drifting versions in the config, or re-run with --force to write anyway.`;
+	}
+};
+/**
+* A schema failed the lint/validation gate, so nothing was written. Exit `1`.
+*
+* @public
+*/
+var GateError = class extends Schema.TaggedError()("GateError", { count: Schema.Number }) {
+	get message() {
+		return `${this.count} schema(s) failed the lint/validation gate; nothing was written.`;
+	}
+};
+/**
+* The merged catalog could not be assembled: a catalog URL or entry name is advertised more than once across the
+* slices, or a slice is not a catalog entry array. Nothing is merged silently, so the merged catalog was left as it
+* is. Exit `1` under both `build` and `check`: only an edit to the slices or the configs clears it.
+*
+* @public
+*/
+var CatalogMergeError = class extends Schema.TaggedError()("CatalogMergeError", {
+	path: Schema.String,
+	conflicts: Schema.Array(Schema.Union([Schema.Struct({
+		kind: Schema.Literal("url"),
+		url: Schema.String,
+		slices: Schema.Array(Schema.String)
+	}), Schema.Struct({
+		kind: Schema.Literal("name"),
+		name: Schema.String,
+		slices: Schema.Array(Schema.String)
+	})])),
+	invalid: Schema.Array(Schema.Struct({
+		path: Schema.String,
+		reason: Schema.String
+	}))
+}) {
+	get message() {
+		const lines = [...this.conflicts.map((conflict) => `  ${conflict.kind === "url" ? `url ${conflict.url}` : `name ${conflict.name}`} is advertised by ${conflict.slices.join(", ")}`), ...this.invalid.map(({ path, reason }) => `  ${path} is invalid: ${reason}`)];
+		return `The merged catalog ${this.path} was not written.\n${lines.join("\n")}\nGive each catalog URL and name to exactly one config, and fix or delete every invalid slice.`;
+	}
+};
+/**
+* `check` found committed documents that differ from what the config generates, or outputs nothing claims, which
+* `build` never deletes. `check` is the CI drift gate, so a stale tree fails it. Exit `1`. `count` is every finding;
+* `orphaned` the part of it a build cannot clear, so the message names both remedies.
+*
+* @public
+*/
+var StaleError = class extends Schema.TaggedError()("StaleError", {
+	count: Schema.Number,
+	orphaned: Schema.optionalKey(Schema.Number)
+}) {
+	get message() {
+		const orphaned = this.orphaned ?? 0;
+		const stale = this.count - orphaned;
+		return [...stale > 0 ? [`${stale} document(s) are stale; run \`effected schema build\` and commit the result.`] : [], ...orphaned > 0 ? [`${orphaned} orphaned output(s) must be deleted by hand; build never will.`] : []].join(" ");
+	}
+};
+/**
+* The payload does not conform to the resolved document: the engine answered findings, each already reported. Exit
+* `1`: a validation verdict, the reason CI runs the command.
+*
+* @public
+*/
+var ValidationFailedError = class extends Schema.TaggedError()("ValidationFailedError", {
+	count: Schema.Number,
+	payload: Schema.String,
+	schema: Schema.String
+}) {
+	get message() {
+		return `${this.count} finding(s): ${this.payload} does not conform to ${this.schema}`;
+	}
+};
+/**
+* No schemastore config was found. Exit `2`: the command could not run, where exit `1` means it ran and found a
+* problem. The engine's error says what was searched; this adds the way out, which is the front end's to state because
+* it shows the command that was run.
+*
+* @public
+*/
+var NoConfigError = class extends Schema.TaggedError()("NoConfigError", {
+	/** The file names looked for. */
+	names: Schema.Array(Schema.String),
+	/** The directories walked, or the one explicit path checked. */
+	searched: Schema.Array(Schema.String),
+	/** Whether `searched` is the one path the user named. */
+	explicit: Schema.Boolean,
+	/** What follows `effected schema` in the example: the subcommand and its positionals, with a config path. */
+	usage: Schema.String
+}) {
+	get message() {
+		return `${this.explicit ? `The schemastore config ${this.searched.join(", ")} does not exist.` : `No schemastore config found. Looked for ${this.names.join(", ")} in: ${this.searched.join(", ")}.`}\nRun next to a config, or pass its path, for example: effected schema ${this.usage}`;
+	}
+};
+
+export { CatalogMergeError, DriftError, GateError, NoConfigError, StaleError, ValidationFailedError };