@effect-motion/cli 0.1.0

package/README.md

@@ -0,0 +1,70 @@
+# @effect-motion/cli
+
+Command line for [effect-motion](https://github.com/julia-script/effect-motion): scaffold a project, preview scenes in the browser, render videos — all driven by one `motion.config.ts`.
+
+```sh
+npx @effect-motion/cli init    # scaffold a project
+motion studio                  # preview scenes with hot reload
+motion render                  # render every target to MP4
+```
+
+## init
+
+`motion init [directory]` scaffolds a single-project workspace:
+
+```
+my-project/
+├─ src/
+│  ├─ scenes/hello-world.ts   # a scene: a module exporting `scene`
+│  ├─ assets/                 # static files
+│  └─ main.ts                 # the movie — an ordinary scene composing the others
+├─ motion.config.ts           # render targets
+├─ AGENTS.md                  # authoring rules for AI coding agents
+├─ package.json               # EXACT pins of effect-motion + effect
+└─ tsconfig.json
+```
+
+Answering `.` scaffolds into the current directory and names the project after it. The package-manager prompt defaults to whichever manager invoked the CLI; `--pm <pnpm|npm|yarn|bun>` and `--no-install` skip prompts/install.
+
+Dependency versions are pinned **exactly** — the `effect` pin is a determinism invariant (upgrading effect can change seeded random sequences), so upgrade both together, deliberately.
+
+## motion.config.ts
+
+```ts
+import { defineConfig } from "@effect-motion/cli";
+
+export default defineConfig({
+	targets: [
+		{
+			name: "hello-world",                 // unique; doubles as the output basename
+			scene: "./src/scenes/hello-world.ts", // module exporting `scene`
+			settings: { width: 1920, height: 1080, frameRate: 60, dpr: 1 },
+			output: "./output",                  // a DIRECTORY — file name is derived
+			// format: "mp4"                     // default (v1: mp4 only)
+			// frames: 600                       // frame cap; required for infinite scenes
+		},
+	],
+});
+```
+
+The output path is always `<output>/<name>.<format>` — never specified by hand. `settings` is the runner's settings subset plus `dpr` (supersampling: output pixels = scene dimensions × dpr, authored coordinates unchanged).
+
+## studio
+
+`motion studio` serves the `@effect-motion/react` Player over your scenes with hot reload (edits full-reload; playback restarts from frame 0). The picker lists every config target **plus** any unregistered `src/scenes/*.ts` — preview never requires registration. Registered scenes preview with their target `settings`, so the preview aspect matches the export. `--port`/`--host` pass through to Vite; the app is generated into `.motion/studio/` (gitignored by the scaffold).
+
+Note: the studio previews through the SVG DOM renderer while `render` rasterizes through ThorVG — output is normally identical, but font fallback details can differ. The known upgrade path is a ThorVG-WASM preview sink.
+
+## render
+
+```sh
+motion render                          # all targets from the nearest motion.config.ts
+motion render hello-world              # just this target
+motion render --config ../m.config.ts  # explicit config (tsc -p style)
+motion render ./src/scenes/foo.ts      # configless: one scene file, default settings
+motion render --fps 30 --dpr 2 --out-dir ./out   # flags beat config beat defaults
+```
+
+Flags: `--width --height --fps --dpr --seed --max-frames --frames --out-dir --format --config`. Targets render sequentially; a failing target doesn't stop the rest (non-zero exit + per-target summary at the end). Errors print a single message naming the offender — add `--verbose` for the full cause chain.
+
+Encoding uses the ffmpeg build bundled via `ffmpeg-static` (H.264/yuv420p MP4, no system ffmpeg needed). That binary is GPL-licensed; it is invoked over a process boundary and this package remains MIT.

package/dist/Config.d.ts

@@ -0,0 +1,78 @@
+import type * as Runner from "effect-motion/Runner";
+/**
+ * The `motion.config.ts` contract. This module is intentionally
+ * browser-safe (the studio app imports the user's config directly), so it
+ * must stay free of Node-only imports — loading/discovery live in
+ * ConfigLoader.ts.
+ */
+/**
+ * Per-target render settings: the Runner `Settings` subset an export can
+ * honor, plus `dpr`. From the author's perspective dpr is a rendering
+ * setting like width/height; the render command maps it to the export
+ * package's supersampling option.
+ */
+export interface TargetSettings {
+    readonly width?: number;
+    readonly height?: number;
+    readonly frameRate?: number;
+    readonly seed?: Runner.Seed;
+    readonly maxFrames?: number;
+    readonly backgroundColor?: Runner.Settings["backgroundColor"];
+    readonly dpr?: number;
+}
+/** v1 ships MP4 only; the field exists so more containers slot in later. */
+export type OutputFormat = "mp4";
+export interface MotionTarget {
+    /** Unique per config — doubles as the output file basename. */
+    readonly name: string;
+    /** Path to a module exporting `scene`, relative to the config file. */
+    readonly scene: string;
+    readonly settings?: TargetSettings;
+    /** Output DIRECTORY (never a file), relative to the config file. */
+    readonly output?: string;
+    readonly format?: OutputFormat;
+    /** Frame cap — required in practice for an infinite scene. */
+    readonly frames?: number;
+}
+export interface MotionConfig {
+    readonly targets: ReadonlyArray<MotionTarget>;
+}
+/** Identity helper that types `motion.config.ts` (vite/vitest convention). */
+export declare const defineConfig: (config: MotionConfig) => MotionConfig;
+export declare const DEFAULT_OUTPUT_DIR = "./output";
+export declare const DEFAULT_FORMAT: OutputFormat;
+/**
+ * Validate the default export of a loaded config module. Plain structural
+ * checks (not Schema): the config is authored in TS against `MotionConfig`,
+ * so this only guards the untyped escape hatches (JS configs, `as any`).
+ */
+export declare const validateConfig: (value: unknown, configPath: string) => MotionConfig;
+/** Flag values a `motion render` invocation can lay over a target. */
+export interface RenderOverrides {
+    readonly width?: number;
+    readonly height?: number;
+    readonly frameRate?: number;
+    readonly dpr?: number;
+    readonly seed?: Runner.Seed;
+    readonly maxFrames?: number;
+    readonly frames?: number;
+    readonly outDir?: string;
+    readonly format?: OutputFormat;
+}
+/** A target with overrides applied and output location derived. */
+export interface ResolvedTarget {
+    readonly name: string;
+    readonly scene: string;
+    readonly settings: TargetSettings;
+    readonly frames: number | undefined;
+    /** Output directory (still config-relative — the caller resolves). */
+    readonly outDir: string;
+    /** Derived file name: `<name>.<format>` — never user-specified. */
+    readonly fileName: string;
+}
+/**
+ * Precedence, highest wins: CLI flags → target config → library defaults.
+ * Library defaults are NOT materialized here — leaving fields undefined
+ * lets the Runner's own defaults apply, so there is one source of truth.
+ */
+export declare const resolveTarget: (target: MotionTarget, overrides?: RenderOverrides) => ResolvedTarget;

package/dist/Config.js

@@ -0,0 +1,67 @@
+import { MotionCliError } from "./MotionCliError.js";
+/** Identity helper that types `motion.config.ts` (vite/vitest convention). */
+export const defineConfig = (config) => config;
+export const DEFAULT_OUTPUT_DIR = "./output";
+export const DEFAULT_FORMAT = "mp4";
+/**
+ * Validate the default export of a loaded config module. Plain structural
+ * checks (not Schema): the config is authored in TS against `MotionConfig`,
+ * so this only guards the untyped escape hatches (JS configs, `as any`).
+ */
+export const validateConfig = (value, configPath) => {
+    const fail = (problem) => {
+        throw new MotionCliError({
+            reason: "ConfigInvalid",
+            message: `${configPath}: ${problem}`,
+        });
+    };
+    if (typeof value !== "object" || value === null) {
+        return fail("default export is not a config object (did you forget `export default defineConfig({...})`?)");
+    }
+    const config = value;
+    if (!Array.isArray(config.targets)) {
+        return fail("config has no `targets` array");
+    }
+    const seen = new Set();
+    for (const [i, target] of config.targets.entries()) {
+        if (typeof target !== "object" || target === null) {
+            return fail(`targets[${i}] is not an object`);
+        }
+        if (typeof target.name !== "string" || target.name.length === 0) {
+            return fail(`targets[${i}] is missing a \`name\``);
+        }
+        if (typeof target.scene !== "string" || target.scene.length === 0) {
+            return fail(`target "${target.name}" is missing a \`scene\` path`);
+        }
+        if (seen.has(target.name)) {
+            return fail(`duplicate target name "${target.name}" (names double as output filenames, so they must be unique)`);
+        }
+        seen.add(target.name);
+        if (target.format !== undefined && target.format !== "mp4") {
+            return fail(`target "${target.name}" has unsupported format "${target.format}" (v1 supports "mp4")`);
+        }
+    }
+    return config;
+};
+const definedEntries = (obj) => Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== undefined));
+/**
+ * Precedence, highest wins: CLI flags → target config → library defaults.
+ * Library defaults are NOT materialized here — leaving fields undefined
+ * lets the Runner's own defaults apply, so there is one source of truth.
+ */
+export const resolveTarget = (target, overrides = {}) => {
+    const { frames: overrideFrames, outDir, format, ...settingsOverrides } = overrides;
+    const settings = {
+        ...definedEntries(target.settings ?? {}),
+        ...definedEntries(settingsOverrides),
+    };
+    const resolvedFormat = format ?? target.format ?? DEFAULT_FORMAT;
+    return {
+        name: target.name,
+        scene: target.scene,
+        settings,
+        frames: overrideFrames ?? target.frames,
+        outDir: outDir ?? target.output ?? DEFAULT_OUTPUT_DIR,
+        fileName: `${target.name}.${resolvedFormat}`,
+    };
+};

package/dist/ConfigLoader.d.ts

@@ -0,0 +1,15 @@
+import * as Effect from "effect/Effect";
+import { FileSystem } from "effect/FileSystem";
+import { Path } from "effect/Path";
+import { type MotionConfig } from "./Config.js";
+import { MotionCliError } from "./MotionCliError.js";
+import type { ViteLoader } from "./ViteLoader.js";
+export declare const CONFIG_FILE = "motion.config.ts";
+/**
+ * Resolve the config path: an explicit `--config` wins; otherwise walk up
+ * from `cwd` to the nearest motion.config.ts (tsc `-p` semantics). Fails
+ * with ConfigNotFound naming both escape hatches.
+ */
+export declare const findConfig: (cwd: string, explicit?: string) => Effect.Effect<string, MotionCliError, FileSystem | Path>;
+/** Load + validate a config module through the shared Vite loader. */
+export declare const loadConfig: (loader: ViteLoader, configPath: string) => Effect.Effect<MotionConfig, MotionCliError>;

package/dist/ConfigLoader.js

@@ -0,0 +1,58 @@
+import * as Effect from "effect/Effect";
+import { FileSystem } from "effect/FileSystem";
+import { Path } from "effect/Path";
+import { validateConfig } from "./Config.js";
+import { MotionCliError } from "./MotionCliError.js";
+export const CONFIG_FILE = "motion.config.ts";
+/**
+ * Resolve the config path: an explicit `--config` wins; otherwise walk up
+ * from `cwd` to the nearest motion.config.ts (tsc `-p` semantics). Fails
+ * with ConfigNotFound naming both escape hatches.
+ */
+export const findConfig = (cwd, explicit) => Effect.gen(function* () {
+    const fs = yield* FileSystem;
+    const path = yield* Path;
+    if (explicit !== undefined) {
+        const resolved = path.resolve(cwd, explicit);
+        const exists = yield* orFalse(fs.exists(resolved));
+        if (!exists) {
+            return yield* new MotionCliError({
+                reason: "ConfigNotFound",
+                message: `config file not found: ${resolved}`,
+            });
+        }
+        return resolved;
+    }
+    let dir = path.resolve(cwd);
+    while (true) {
+        const candidate = path.join(dir, CONFIG_FILE);
+        if (yield* orFalse(fs.exists(candidate)))
+            return candidate;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return yield* new MotionCliError({
+        reason: "ConfigNotFound",
+        message: `no ${CONFIG_FILE} found from ${cwd} upward — ` +
+            `create one (export default defineConfig({ targets: [...] })), pass --config <path>, ` +
+            `or pass a scene file directly (motion render ./src/scenes/foo.ts)`,
+    });
+});
+// fs.exists fails on permission errors etc. — treat those as "not here"
+const orFalse = (effect) => Effect.catchCause(effect, () => Effect.succeed(false));
+/** Load + validate a config module through the shared Vite loader. */
+export const loadConfig = (loader, configPath) => Effect.gen(function* () {
+    const module_ = yield* loader.load(configPath);
+    return yield* Effect.try({
+        try: () => validateConfig(module_.default, configPath),
+        catch: (error) => error instanceof MotionCliError
+            ? error
+            : new MotionCliError({
+                reason: "ConfigInvalid",
+                message: `${configPath}: config validation crashed`,
+                cause: error,
+            }),
+    });
+});

package/dist/MotionCliError.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Every failure mode of the CLI, as a `reason` union on a single tagged
+ * error. One type keeps the error channel a single name in every command
+ * signature; adding a failure mode is a union-member addition handled
+ * exhaustively at exactly one place (the top-level reporter in bin.ts).
+ */
+export type MotionCliReason = "ConfigNotFound" | "ConfigInvalid" | "SceneLoadFailed" | "UnknownTarget" | "ScaffoldTargetNotEmpty" | "ScaffoldFailed" | "InstallFailed" | "RenderFailed" | "StudioFailed";
+declare const MotionCliError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "MotionCliError";
+} & Readonly<A>;
+/**
+ * The one error type of `@effect-motion/cli`: either wraps an upstream
+ * failure (`cause` carries it) or states a custom one. `message` MUST name
+ * the offender — the file, target, or path that failed — because it is the
+ * only line shown without `--verbose`.
+ */
+export declare class MotionCliError extends MotionCliError_base<{
+    readonly reason: MotionCliReason;
+    readonly message: string;
+    readonly cause?: unknown;
+}> {
+}
+/** Render an error for the terminal: message always, cause chain on verbose. */
+export declare const renderForTerminal: (error: MotionCliError, verbose: boolean) => string;
+export {};

package/dist/MotionCliError.js

@@ -0,0 +1,21 @@
+import * as Data from "effect/Data";
+/**
+ * The one error type of `@effect-motion/cli`: either wraps an upstream
+ * failure (`cause` carries it) or states a custom one. `message` MUST name
+ * the offender — the file, target, or path that failed — because it is the
+ * only line shown without `--verbose`.
+ */
+export class MotionCliError extends Data.TaggedError("MotionCliError") {
+}
+/** Render an error for the terminal: message always, cause chain on verbose. */
+export const renderForTerminal = (error, verbose) => {
+    const lines = [`error(${error.reason}): ${error.message}`];
+    if (verbose) {
+        let cause = error.cause;
+        while (cause !== undefined && cause !== null) {
+            lines.push(`caused by: ${cause instanceof Error ? (cause.stack ?? cause.message) : String(cause)}`);
+            cause = cause instanceof Error ? cause.cause : undefined;
+        }
+    }
+    return lines.join("\n");
+};

package/dist/ViteLoader.d.ts

@@ -0,0 +1,15 @@
+import * as Effect from "effect/Effect";
+import type * as Scope from "effect/Scope";
+import type { ViteDevServer } from "vite";
+import { MotionCliError } from "./MotionCliError.js";
+/**
+ * The one TypeScript loader of the CLI: a Vite server in middleware mode
+ * whose `ssrLoadModule` executes user TS (config and scenes) in Node.
+ * Studio uses a Vite server too, so preview and render resolve the same
+ * module graph — the design's single-resolver invariant.
+ */
+export interface ViteLoader {
+    readonly load: (file: string) => Effect.Effect<Record<string, unknown>, MotionCliError>;
+    readonly server: ViteDevServer;
+}
+export declare const makeViteLoader: (root: string) => Effect.Effect<ViteLoader, MotionCliError, Scope.Scope>;

package/dist/ViteLoader.js

@@ -0,0 +1,35 @@
+import * as Effect from "effect/Effect";
+import { MotionCliError } from "./MotionCliError.js";
+export const makeViteLoader = (root) => Effect.acquireRelease(Effect.tryPromise({
+    try: async () => {
+        const { createServer } = await import("vite");
+        return createServer({
+            root,
+            configFile: false,
+            logLevel: "error",
+            appType: "custom",
+            server: {
+                middlewareMode: true,
+                // a load-only server: no HMR socket, no file watching
+                hmr: false,
+                watch: null,
+            },
+            optimizeDeps: { noDiscovery: true },
+        });
+    },
+    catch: (cause) => new MotionCliError({
+        reason: "SceneLoadFailed",
+        message: `could not start the module loader (vite) in ${root}`,
+        cause,
+    }),
+}), (server) => Effect.promise(() => server.close())).pipe(Effect.map((server) => ({
+    server,
+    load: (file) => Effect.tryPromise({
+        try: () => server.ssrLoadModule(file),
+        catch: (cause) => new MotionCliError({
+            reason: "SceneLoadFailed",
+            message: `failed to load ${file}`,
+            cause,
+        }),
+    }),
+})));

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import { NodeRuntime, NodeServices } from "@effect/platform-node";
+import * as Effect from "effect/Effect";
+import { Command } from "effect/unstable/cli";
+import { CLI_VERSION, reportErrors, rootCommand } from "./cli.js";
+// read pre-parse so the reporter works even when parsing itself fails
+const verbose = process.argv.includes("--verbose");
+const program = reportErrors(Command.run(rootCommand, { version: CLI_VERSION }), verbose);
+// every typed failure is handled by reportErrors, so the default reporter
+// only ever fires for defects — bugs in the CLI itself, where a trace is right
+NodeRuntime.runMain(Effect.provide(program, NodeServices.layer));

package/dist/cli.d.ts

@@ -0,0 +1,12 @@
+import * as Effect from "effect/Effect";
+import { CliError, Command } from "effect/unstable/cli";
+import { type MotionCliError } from "./MotionCliError.js";
+export declare const rootCommand: Command.Command<"motion", {}, {}, MotionCliError, never>;
+export declare const CLI_VERSION: "0.1.0";
+/**
+ * The single exhaustive failure boundary (design D3a): MotionCliError
+ * prints its message (cause chain under --verbose) and sets a non-zero
+ * exit; Command API errors print their diagnostic (help output was already
+ * rendered for ShowHelp). Anything past this boundary is a defect.
+ */
+export declare const reportErrors: <A, R>(program: Effect.Effect<A, MotionCliError | CliError.CliError, R>, verbose: boolean) => Effect.Effect<A | undefined, never, R>;

package/dist/cli.js

@@ -0,0 +1,32 @@
+import * as Console from "effect/Console";
+import * as Effect from "effect/Effect";
+import { CliError, Command, Flag, GlobalFlag } from "effect/unstable/cli";
+import { initCommand } from "./commands/init.js";
+import { renderCommand } from "./commands/render.js";
+import { studioCommand } from "./commands/studio.js";
+import { renderForTerminal } from "./MotionCliError.js";
+import { PINS } from "./pins.js";
+// registered globally so `--verbose` parses anywhere on the command line;
+// the reporter reads argv directly because it sits outside handler context
+const verboseFlag = GlobalFlag.setting("verbose")({
+    flag: Flag.boolean("verbose").pipe(Flag.withDescription("Print full error cause chains")),
+});
+export const rootCommand = Command.make("motion").pipe(Command.withDescription("effect-motion: scaffold projects, preview scenes, render videos"), Command.withSubcommands([initCommand, studioCommand, renderCommand]), Command.withGlobalFlags([verboseFlag]));
+export const CLI_VERSION = PINS["@effect-motion/cli"];
+/**
+ * The single exhaustive failure boundary (design D3a): MotionCliError
+ * prints its message (cause chain under --verbose) and sets a non-zero
+ * exit; Command API errors print their diagnostic (help output was already
+ * rendered for ShowHelp). Anything past this boundary is a defect.
+ */
+export const reportErrors = (program, verbose) => program.pipe(Effect.catchTag("MotionCliError", (error) => Effect.gen(function* () {
+    yield* Console.error(renderForTerminal(error, verbose));
+    process.exitCode = 1;
+    return undefined;
+})), Effect.catchIf(CliError.isCliError, (error) => error._tag === "ShowHelp"
+    ? Effect.succeed(undefined)
+    : Effect.gen(function* () {
+        yield* Console.error(error.message);
+        process.exitCode = 1;
+        return undefined;
+    })));

package/dist/commands/init.d.ts

@@ -0,0 +1,9 @@
+import * as Option from "effect/Option";
+import { Command, Prompt } from "effect/unstable/cli";
+import { ChildProcessSpawner } from "effect/unstable/process";
+import { MotionCliError } from "../MotionCliError.js";
+export declare const initCommand: Command.Command<"init", {
+    readonly directory: Option.Option<string>;
+    readonly pm: Option.Option<"bun" | "npm" | "pnpm" | "yarn">;
+    readonly noInstall: boolean;
+}, {}, MotionCliError, ChildProcessSpawner.ChildProcessSpawner | Prompt.Environment>;

package/dist/commands/init.js

@@ -0,0 +1,94 @@
+import * as Console from "effect/Console";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Path } from "effect/Path";
+import { Argument, Command, Flag, Prompt } from "effect/unstable/cli";
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+import { MotionCliError } from "../MotionCliError.js";
+import { ensureEmptyDir, resolveProjectDir, scaffoldProject, } from "../scaffold.js";
+const PACKAGE_MANAGERS = ["pnpm", "npm", "yarn", "bun"];
+/** The manager that invoked us (`pnpm create …` etc.), if detectable. */
+const detectPackageManager = () => {
+    const agent = process.env.npm_config_user_agent ?? "";
+    return PACKAGE_MANAGERS.find((pm) => agent.startsWith(pm));
+};
+const initFlags = {
+    directory: Argument.string("directory").pipe(Argument.withDescription('Target directory ("." scaffolds into the current directory)'), Argument.optional),
+    pm: Flag.optional(Flag.choice("pm", PACKAGE_MANAGERS).pipe(Flag.withDescription("Package manager (skips the prompt)"))),
+    noInstall: Flag.boolean("no-install").pipe(Flag.withDescription("Skip dependency installation")),
+};
+const promptDirectory = Prompt.text({
+    message: 'Where should the project be created? ("." for the current directory)',
+    default: "my-motion-project",
+});
+const promptPackageManager = Effect.suspend(() => {
+    const detected = detectPackageManager();
+    // detected manager listed first so plain Enter picks it
+    const ordered = [
+        ...(detected ? [detected] : []),
+        ...PACKAGE_MANAGERS.filter((pm) => pm !== detected),
+    ];
+    return Prompt.select({
+        message: "Which package manager?",
+        choices: ordered.map((pm) => ({ title: pm, value: pm })),
+    });
+});
+const runInstall = (pm, dir) => Effect.gen(function* () {
+    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+    const command = ChildProcess.make(pm, ["install"], {
+        cwd: dir,
+        stdin: "inherit",
+        stdout: "inherit",
+        stderr: "inherit",
+    });
+    yield* Effect.scoped(Effect.gen(function* () {
+        const handle = yield* spawner.spawn(command);
+        const code = yield* handle.exitCode;
+        if (code !== 0) {
+            return yield* new MotionCliError({
+                reason: "InstallFailed",
+                message: `${pm} install exited with code ${code} in ${dir} — run it manually`,
+                cause: code,
+            });
+        }
+    })).pipe(Effect.catchTag("PlatformError", (cause) => Effect.fail(new MotionCliError({
+        reason: "InstallFailed",
+        message: `could not run "${pm} install" in ${dir} — is ${pm} installed?`,
+        cause,
+    }))));
+});
+const handler = (input) => Effect.gen(function* () {
+    const path = yield* Path;
+    const cwd = process.cwd();
+    const dirInput = Option.getOrUndefined(input.directory) ?? (yield* promptDirectory);
+    const { dir, name } = resolveProjectDir(path, cwd, dirInput);
+    yield* ensureEmptyDir(dir);
+    const pm = Option.getOrUndefined(input.pm) ?? (yield* promptPackageManager);
+    yield* scaffoldProject(dir, name);
+    yield* Console.log(`Scaffolded ${name} in ${dir}`);
+    if (input.noInstall) {
+        yield* Console.log([
+            "",
+            "Next steps:",
+            dir === cwd ? "" : `  cd ${path.relative(cwd, dir)}`,
+            `  ${pm} install`,
+            `  ${pm === "npm" ? "npm run" : pm} studio`,
+        ]
+            .filter((line) => line !== "")
+            .join("\n"));
+        return;
+    }
+    yield* runInstall(pm, dir);
+    yield* Console.log([
+        "",
+        `${name} is ready.`,
+        dir === cwd ? "" : `  cd ${path.relative(cwd, dir)}`,
+        `  ${pm === "npm" ? "npm run" : pm} studio    # preview scenes with hot reload`,
+        `  ${pm === "npm" ? "npm run" : pm} render    # render targets from motion.config.ts`,
+    ]
+        .filter((line) => line !== "")
+        .join("\n"));
+}).pipe(
+// ctrl-c in a prompt is an interruption, not a failure
+Effect.catchTag("QuitError", () => Effect.interrupt));
+export const initCommand = Command.make("init", initFlags, handler).pipe(Command.withDescription("Scaffold a new effect-motion project"));

package/dist/commands/render.d.ts

@@ -0,0 +1,18 @@
+import { FileSystem } from "effect/FileSystem";
+import * as Option from "effect/Option";
+import { Path } from "effect/Path";
+import { Command } from "effect/unstable/cli";
+import { MotionCliError } from "../MotionCliError.js";
+export declare const renderCommand: Command.Command<"render", {
+    readonly config: Option.Option<string>;
+    readonly width: Option.Option<number>;
+    readonly height: Option.Option<number>;
+    readonly fps: Option.Option<number>;
+    readonly dpr: Option.Option<number>;
+    readonly seed: Option.Option<string>;
+    readonly maxFrames: Option.Option<number>;
+    readonly frames: Option.Option<number>;
+    readonly outDir: Option.Option<string>;
+    readonly format: Option.Option<"mp4">;
+    readonly targets: readonly string[];
+}, {}, MotionCliError, import("effect/unstable/process/ChildProcessSpawner").ChildProcessSpawner | FileSystem | Path>;