@effected/cli 0.27.0 → 0.29.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,3 +1,5 @@
+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";
@@ -9,6 +11,10 @@ import { Command } from "effect/cli";
 *
 * @public
 */
-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)]));
+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 { makeRootCommand };

package/commands/schema/execute.js

@@ -1,9 +1,9 @@
 import { DiffDoc } from "../../render/DiffDoc.js";
 import { CatalogMergeError, DriftError, GateError, NoConfigError, StaleError } from "./errors.js";
+import { Console, Effect, Option } from "effect";
 import { CliInteractive, CliRuntime, Doc } from "@effected/cli-kit";
 import { ConfigLoadError, ConfigLoader, Report, SchemaRun, StepSummary } from "@effected/engine/schema";
 import { Audience } from "@effected/env";
-import { Console, Effect, Option } from "effect";
 
 // src/commands/schema/execute.ts
 /** `--format` as given, else what the audience reads: JSON for an agent, human text for a person and for CI. */

package/commands/schema/validate.js

@@ -1,10 +1,10 @@
 import { ValidationFailedError } from "./errors.js";
 import { configFailures, resolveFormat, warnVersionMismatch } from "./execute.js";
 import { configArgument, formatFlag, ignoreVersionMismatchFlag } from "./flags.js";
+import { Console, Effect, Option, Schema } from "effect";
 import { CliRuntime, Doc } from "@effected/cli-kit";
 import { Argument, Command, Flag } from "effect/cli";
 import { SchemaValidate, ValidateReport } from "@effected/engine/schema";
-import { Console, Effect, Option, Schema } from "effect";
 
 // src/commands/schema/validate.ts
 const findingLine = (finding) => {

package/index.d.ts

@@ -1,7 +1,115 @@
+import { Schema } from "effect";
+import { ActionRunDeps, BuildRunDeps } from "@effected/engine/build";
+import "@effected/env";
 import "effect/cli";
 import { SchemaRunDeps } from "@effected/engine/schema";
-import "@effected/env";
-import { Schema } from "effect";
+declare const ActionBuildFailedError_base: Schema.Class<ActionBuildFailedError, Schema.TaggedStruct<"ActionBuildFailedError", {
+  /** How many validation errors there were. */
+  readonly errors: Schema.Number;
+  /** How many entries failed to bundle or load. */
+  readonly failedEntries: Schema.Number;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Validation stopped the build or an entry failed. Exit `1`.
+ *
+ * @public
+ */
+export declare class ActionBuildFailedError extends ActionBuildFailedError_base {
+  get message(): string;
+}
+declare const ActionConfigError_base: Schema.Class<ActionConfigError, Schema.TaggedStruct<"ActionConfigError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * 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
+ */
+export declare class ActionConfigError extends ActionConfigError_base {}
+declare const ActionRunError_base: Schema.Class<ActionRunError, Schema.TaggedStruct<"ActionRunError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * 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
+ */
+export declare class ActionRunError extends ActionRunError_base {}
+declare const ActionInitError_base: Schema.Class<ActionInitError, Schema.TaggedStruct<"ActionInitError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * `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
+ */
+export declare class ActionInitError extends ActionInitError_base {}
+/**
+ * What `effected action` is given by the process boundary. `main` reads `cwd` and `ci`, and nothing else reads the
+ * process.
+ *
+ * @public
+ */
+type ActionCommandDeps = ActionRunDeps;
+declare const BuildFailedError_base: Schema.Class<BuildFailedError, Schema.TaggedStruct<"BuildFailedError", {
+  /** How many errors the build recorded. */
+  readonly errors: Schema.Number;
+  /** What ended the build, when it did not reach its end. */
+  readonly failure: Schema.optionalKey<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The build crashed or recorded an error. Exit `1`.
+ *
+ * @public
+ */
+export declare class BuildFailedError extends BuildFailedError_base {
+  get message(): string;
+}
+declare const PackageConfigError_base: Schema.Class<PackageConfigError, Schema.TaggedStruct<"PackageConfigError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * 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
+ */
+export declare class PackageConfigError extends PackageConfigError_base {}
+declare const PackageRunError_base: Schema.Class<PackageRunError, Schema.TaggedStruct<"PackageRunError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A file the build needs could not be read or written. Exit `3`, the infrastructure tier.
+ *
+ * @public
+ */
+export declare class PackageRunError extends PackageRunError_base {}
+/**
+ * What `effected package` is given by the process boundary, and the test seams: the engine's dependencies, less the
+ * progress callback. `main` reads `cwd` and `ci`, and nothing else reads the process.
+ *
+ * @public
+ */
+type PackageCommandDeps = Omit<BuildRunDeps, "onProgress">;
 declare const DriftError_base: Schema.Class<DriftError, Schema.TaggedStruct<"DriftError", {
   readonly drifted: Schema.$Array<Schema.Struct<{
     readonly $id: Schema.String;
@@ -111,6 +219,12 @@ export declare class NoConfigError extends NoConfigError_base {
  * @public
  */
 type SchemaCommandDeps = Omit<SchemaRunDeps, "onProgress">;
+/**
+ * What every command is given by the process boundary, and the test seams.
+ *
+ * @public
+ */
+type CommandDeps = SchemaCommandDeps & PackageCommandDeps & ActionCommandDeps;
 /**
  * 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.
@@ -126,5 +240,5 @@ export declare const makeRootCommand: any;
  * @public
  */
 export declare const CLI_VERSION: string;
-export type { SchemaCommandDeps };
+export type { ActionCommandDeps, CommandDeps, PackageCommandDeps, SchemaCommandDeps };
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -1,5 +1,7 @@
+import { ActionBuildFailedError, ActionConfigError, ActionInitError, ActionRunError } from "./commands/action/errors.js";
+import { BuildFailedError, PackageConfigError, PackageRunError } from "./commands/package/errors.js";
 import { makeRootCommand } from "./commands/root.js";
 import { CatalogMergeError, DriftError, GateError, NoConfigError, StaleError, ValidationFailedError } from "./commands/schema/errors.js";
 import { CLI_VERSION } from "./version.js";
 
-export { CLI_VERSION, CatalogMergeError, DriftError, GateError, NoConfigError, StaleError, ValidationFailedError, makeRootCommand };
+export { ActionBuildFailedError, ActionConfigError, ActionInitError, ActionRunError, BuildFailedError, CLI_VERSION, CatalogMergeError, DriftError, GateError, NoConfigError, PackageConfigError, PackageRunError, StaleError, ValidationFailedError, makeRootCommand };

package/main.d.ts

@@ -1,7 +1,23 @@
 import { Distribution } from "@effected/kit";
 import { Layer } from "effect";
-import { SchemaRunDeps } from "@effected/engine/schema";
+import "effect/cli";
+import { ActionRunDeps, BuildRunDeps } from "@effected/engine/build";
 import "@effected/env";
+import { SchemaRunDeps } from "@effected/engine/schema";
+/**
+ * What `effected action` is given by the process boundary. `main` reads `cwd` and `ci`, and nothing else reads the
+ * process.
+ *
+ * @public
+ */
+type ActionCommandDeps = ActionRunDeps;
+/**
+ * What `effected package` is given by the process boundary, and the test seams: the engine's dependencies, less the
+ * progress callback. `main` reads `cwd` and `ci`, and nothing else reads the process.
+ *
+ * @public
+ */
+type PackageCommandDeps = Omit<BuildRunDeps, "onProgress">;
 /**
  * What `effected schema` is given by the process boundary, and the test seams: the engine's dependencies, less the
  * progress callback the command supplies itself. `main` reads `cwd`, and nothing else reads the process.
@@ -9,6 +25,12 @@ import "@effected/env";
  * @public
  */
 type SchemaCommandDeps = Omit<SchemaRunDeps, "onProgress">;
+/**
+ * What every command is given by the process boundary, and the test seams.
+ *
+ * @public
+ */
+type CommandDeps = SchemaCommandDeps & PackageCommandDeps & ActionCommandDeps;
 /**
  * Options a carrier's bin shim passes to {@link main}. `distribution` names
  * the package the `effected` bin was installed through; omitted for a direct
@@ -39,7 +61,7 @@ export declare const mainOptions: {
  *
  * @public
  */
-export declare const run: <RP, EP>(options: MainOptions, deps: SchemaCommandDeps, platform: Layer.Layer<RP, EP>) => import("effect/Effect").Effect<void, Error, Exclude<import("effect/process/ChildProcessSpawner").ChildProcessSpawner, RP> | Exclude<import("effect/FileSystem").FileSystem, RP> | Exclude<import("effect/Path").Path, RP> | Exclude<import("effect/Stdio").Stdio, RP> | Exclude<import("effect/Stdio").Stdio, RP> | Exclude<import("effect/Terminal").Terminal, RP>>;
+export declare const run: <RP, EP>(options: MainOptions, deps: CommandDeps, platform: Layer.Layer<RP, EP>) => import("effect/Effect").Effect<void, Error, Exclude<import("effect/process/ChildProcessSpawner").ChildProcessSpawner, RP> | Exclude<import("effect/FileSystem").FileSystem, RP> | Exclude<import("effect/Path").Path, RP> | Exclude<import("effect/Stdio").Stdio, RP> | Exclude<import("effect/Stdio").Stdio, RP> | Exclude<import("effect/Terminal").Terminal, RP>>;
 /**
  * Run the `effected` command. Owns the process: installs the runtime teardown
  * and sets the exit code.
@@ -47,5 +69,5 @@ export declare const run: <RP, EP>(options: MainOptions, deps: SchemaCommandDeps
  * @public
  */
 export declare const main: (options?: MainOptions) => void;
-export type { SchemaCommandDeps };
+export type { ActionCommandDeps, CommandDeps, PackageCommandDeps, SchemaCommandDeps };
 //# sourceMappingURL=main.d.ts.map

package/main.js

@@ -1,3 +1,4 @@
+import { isCI } from "./ci.js";
 import { makeRootCommand } from "./commands/root.js";
 import { CLI_VERSION } from "./version.js";
 import { CliAudience, CliLogger, CliRuntime } from "@effected/cli-kit";
@@ -55,7 +56,10 @@ const run = (options, deps, platform) => CliRuntime.main(CliAudience.run(makeRoo
 * @public
 */
 const main = (options = {}) => {
-	NodeRuntime.runMain(run(options, { cwd: process.cwd() }, NodeServices.layer));
+	NodeRuntime.runMain(run(options, {
+		cwd: process.cwd(),
+		ci: isCI(process.env)
+	}, NodeServices.layer));
 };
 
 export { main, mainOptions, run };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/cli",
-	"version": "0.27.0",
+	"version": "0.29.0",
 	"private": false,
 	"description": "The effected command: the tool's command tree on the kit's front-end runtime",
 	"keywords": [
@@ -43,16 +43,20 @@
 	},
 	"dependencies": {
 		"@effect/platform-node": "~4.1.2",
-		"@effected/cli-kit": "^0.27.0",
-		"@effected/engine": "0.13.0",
+		"@effected/cli-kit": "^0.27.1",
+		"@effected/engine": "0.15.0",
 		"@effected/env": "^0.11.0",
-		"@effected/glob": "^0.19.0",
+		"@effected/glob": "^0.20.0",
 		"@effected/kit": "^0.13.0",
-		"@effected/walker": "^0.25.1",
+		"@effected/walker": "^0.26.0",
 		"effect": "~4.1.2",
 		"ink": "^8.0.0",
 		"react": "^19.3.0"
 	},
+	"peerDependencies": {
+		"@types/node": "^26.6.0",
+		"typescript": "7.1.0-beta || 7.1.1-rc || >=7.1.0 <8"
+	},
 	"engines": {
 		"node": ">=24.11.0"
 	}

package/render/ActionDoc.js

@@ -0,0 +1,66 @@
+import { Doc } from "@effected/cli-kit";
+
+// src/render/ActionDoc.ts
+const formatBytes = (bytes) => {
+	if (bytes < 1024) return `${bytes} B`;
+	return bytes < 1048576 ? `${(bytes / 1024).toFixed(1)} KB` : `${(bytes / 1048576).toFixed(1)} MB`;
+};
+const issueLine = (issue) => `${issue.code}: ${issue.message}`;
+/** One line for an entry, with only the first line of its error: a failed load's message can carry a require stack. */
+const entryLine = (entry) => {
+	if (entry.stats === void 0) return `✗ ${(entry.error ?? "failed").split("\n")[0]}`;
+	const { entry: name, size, duration, outputPath } = entry.stats;
+	return `✓ ${name}: ${formatBytes(size)} (${duration}ms) → ${outputPath}`;
+};
+const summaryOf = ({ build }) => `built ${build.entries.filter((entry) => entry.success).length} entries in ${build.duration}ms`;
+/** A warning as its first line, indented under the entry it belongs to. */
+const warningLines = (entry) => (entry.warnings ?? []).map((warning) => `  ${warning.trim().split("\n")[0]}`);
+/**
+* An action build for a reader: validation's errors, its warnings, a line per entry, then the total.
+*
+* @public
+*/
+var ActionDoc = class ActionDoc {
+	constructor() {}
+	/** The report as plain lines, the total last, for a log. */
+	static lines(result) {
+		return [
+			...result.validation.errors.map(issueLine),
+			...result.validation.warnings.map(issueLine),
+			...result.build.entries.flatMap((entry) => [entryLine(entry), ...warningLines(entry)]),
+			summaryOf(result)
+		];
+	}
+	/**
+	* The report as a `Doc`.
+	*
+	* @remarks
+	* Every line goes in as a `Doc.text` run, which is data: the renderers remove escape and control characters from it,
+	* so an error quoting untrusted text cannot repaint the terminal.
+	*/
+	static render(result) {
+		const rows = [
+			...result.validation.errors.map((issue) => Doc.text(issueLine(issue), "error")),
+			...result.validation.warnings.map((issue) => Doc.text(issueLine(issue), "warning")),
+			...result.build.entries.flatMap((entry) => [Doc.text(entryLine(entry), entry.success ? "success" : "error"), ...warningLines(entry).map((line) => Doc.text(line, "warning"))]),
+			Doc.text(summaryOf(result), result.build.success ? "success" : "error")
+		];
+		return Doc.lines(rows, { wrap: false });
+	}
+	/** The report for a GitHub step summary, in a code block. */
+	static markdown(result) {
+		const body = ActionDoc.lines(result).join("\n");
+		const longest = (body.match(/`+/g) ?? []).reduce((length, run) => Math.max(length, run.length), 2);
+		const fence = "`".repeat(longest + 1);
+		return [
+			"### effected action build",
+			"",
+			fence,
+			body,
+			fence,
+			""
+		].join("\n");
+	}
+};
+
+export { ActionDoc };

package/render/InitDoc.js

@@ -0,0 +1,35 @@
+import { Doc } from "@effected/cli-kit";
+
+// src/render/InitDoc.ts
+/** What is left to do, as lines: the packages to add, the module type, and the build. */
+const nextSteps = (result) => [
+	...result.missingDependencies.length > 0 ? [`add dependencies: ${result.missingDependencies.join(" ")}`] : [],
+	...result.missingDevDependencies.length > 0 ? [`add devDependencies: ${result.missingDevDependencies.join(" ")}`] : [],
+	...result.typeModule ? [] : ["set \"type\": \"module\" in package.json"],
+	"then run: effected action build"
+];
+const fileLine = (result, file) => `${result.overwritten.includes(file) ? "replaced" : "wrote"} ${file}`;
+/**
+* An `action init` for a reader: a line per file written, then what is left to do.
+*
+* @public
+*/
+var InitDoc = class {
+	constructor() {}
+	/** The report as plain lines, for a log. */
+	static lines(result) {
+		return [...result.written.map((file) => fileLine(result, file)), ...nextSteps(result)];
+	}
+	/**
+	* The report as a `Doc`.
+	*
+	* @remarks
+	* Every line goes in as a `Doc.text` run, which is data, so a name echoed back cannot repaint the terminal.
+	*/
+	static render(result) {
+		const rows = [...result.written.map((file) => Doc.text(fileLine(result, file), result.overwritten.includes(file) ? "warning" : "success")), ...nextSteps(result).map((line) => Doc.text(line, "muted"))];
+		return Doc.lines(rows, { wrap: false });
+	}
+};
+
+export { InitDoc };

package/render/IssuesDoc.js

@@ -0,0 +1,73 @@
+import { Doc } from "@effected/cli-kit";
+
+// src/render/IssuesDoc.ts
+/** `file:line:col code text`, leaving out whichever parts the diagnostic does not have. */
+const lineOf = (diagnostic) => {
+	return [
+		...diagnostic.file === void 0 ? [] : [[
+			diagnostic.file,
+			diagnostic.line,
+			diagnostic.column
+		].filter((part) => part !== void 0).join(":")],
+		...diagnostic.code !== void 0 ? [diagnostic.code] : [],
+		diagnostic.text
+	].join(" ");
+};
+const summaryOf = (issues) => `built ${issues.package}: ${issues.errors.length} errors, ${issues.warnings.length} warnings, ${issues.suppressed.length} suppressed`;
+const summaryToken = (issues) => !issues.buildOk || issues.errors.length > 0 ? "error" : issues.warnings.length > 0 ? "warning" : "success";
+const fenceFor = (text) => {
+	const longest = (text.match(/`+/g) ?? []).reduce((length, run) => Math.max(length, run.length), 2);
+	return "`".repeat(longest + 1);
+};
+/**
+* A build's `issues.json` for a reader: errors, then warnings, then one summary line. Suppressed diagnostics are only
+* counted.
+*
+* @public
+*/
+var IssuesDoc = class {
+	constructor() {}
+	/** The report as plain lines, the summary last, for a log. */
+	static lines(issues) {
+		return [
+			...issues.errors.map(lineOf),
+			...issues.warnings.map(lineOf),
+			summaryOf(issues)
+		];
+	}
+	/**
+	* The report as a `Doc`.
+	*
+	* @remarks
+	* Every line goes in as a `Doc.text` run, which is data: the renderers remove escape and control characters from it,
+	* so a diagnostic quoting untrusted text cannot repaint the terminal.
+	*/
+	static render(issues) {
+		const rows = [
+			...issues.errors.map((diagnostic) => Doc.text(lineOf(diagnostic), "error")),
+			...issues.warnings.map((diagnostic) => Doc.text(lineOf(diagnostic), "warning")),
+			Doc.text(summaryOf(issues), summaryToken(issues))
+		];
+		return Doc.lines(rows, { wrap: false });
+	}
+	/** The report for a GitHub step summary: the failure, when there is one, and the diagnostics in a code block. */
+	static markdown(issues) {
+		const diagnostics = [...issues.errors, ...issues.warnings].map(lineOf).join("\n");
+		const fence = fenceFor(diagnostics);
+		return [
+			"### effected package build",
+			"",
+			summaryOf(issues),
+			...issues.failure !== void 0 ? ["", `Failed: ${issues.failure.message}`] : [],
+			...diagnostics !== "" ? [
+				"",
+				fence,
+				diagnostics,
+				fence
+			] : [],
+			""
+		].join("\n");
+	}
+};
+
+export { IssuesDoc };

package/version.js

@@ -6,6 +6,6 @@
 *
 * @public
 */
-const CLI_VERSION = "0.27.0";
+const CLI_VERSION = "0.29.0";
 
 export { CLI_VERSION };