@anvpx/motion-cli 0.0.0-stage → 0.1.1

package/dist/scene/author.js

@@ -0,0 +1,279 @@
+import { dirname, join, resolve } from "node:path";
+import { lintCustomSource, readRelativeClosure } from "@anvpx/motion-build";
+import { parseFlags, textFlag, usageError } from "../args.js";
+import { EXIT } from "../exit-codes.js";
+import { sceneContainment } from "../storyboard/containment.js";
+import { formatFindings, summaryLine } from "../storyboard/report.js";
+const USAGE = `mk scene new <id> [--dir <path>] [--force]
+mk scene lint <dir>
+
+Author a scene (type "custom"): three files beside the storyboard, rendered like a catalog scene.
+  new   scaffold scene.js, fragment.html, style.css and notes.md (refuses to overwrite without --force)
+        --dir path   where to write it (default scenes/<id>)
+  lint  determinism and safety check: clocks, timers, network, workers, window, CSS animation/transition
+  promote  copy an authored scene into the catalog package (maintainer workflow) and print the registry lines
+           --as type   catalog type name (required)
+Exit 0 when clean; 2 on lint errors or bad usage.
+`;
+const NEW_FLAGS = {
+    dir: { type: "string" },
+    force: { type: "boolean" },
+};
+const SCENE_JS = `// @ts-check
+import { ease, interpolate, progress } from "../../runtime/compose.js";
+
+/**
+ * Authored scene: seek(t) must be a pure function of t.
+ * No clocks, no timers, no unseeded random, no network, no window globals.
+ * Guide: the authoring-scene reference in the installed motion-kit skill
+ * @type {import("../../runtime/mount.js").CreateScene}
+ */
+export function createScene(root, config, ctx) {
+  const element = /** @type {HTMLElement | null} */ (root.querySelector(".authored-element"));
+  if (!element) throw new Error("authored scene: missing .authored-element");
+  // Replace the markup, layout and these values with the direction's composition.
+  // Derive every animated value on EVERY seek, including backward seeks.
+  const seek = (t) => {
+    const amount = ease("out", progress(t, 0, 0.8));
+    element.style.opacity = String(amount);
+    element.style.transform = "translateY(" + interpolate(24, 0, amount) + "px)";
+  };
+  seek(0);
+  return {
+    seek,
+    dispose() {
+      element.style.removeProperty("opacity");
+      element.style.removeProperty("transform");
+    },
+    ready: Promise.resolve(),
+  };
+}
+`;
+const FRAGMENT_HTML = `<div class="authored-composition">
+  <h1 class="authored-element" data-focus-key="subject">Your composition</h1>
+</div>
+`;
+const STYLE_CSS = `/* A blank starting surface: design its grid, layers and type from the brief. */
+#scene-root .authored-composition { display: grid; place-items: center; width: 100%; height: 100%; }
+#scene-root .authored-element {
+  margin: 0;
+  font: inherit;
+  font-size: clamp(32px, 6vw, 96px);
+  color: var(--mk-color-fg);
+}
+`;
+const notes = (id) => `# ${id}
+
+Why this scene exists: <one line>.
+
+Direction: <concept, composition, type, motion and sound decisions>.
+
+The markup and motion are yours to replace. Shared \`runtime/compose.js\` offers
+\`progress(t, start, duration)\`, \`interpolate(from, to, amount)\`,
+\`stagger(index, step, start)\` and the existing \`ease(name, amount)\` functions.
+All times are seconds. Progress clamps to 0..1; a zero duration is a cut.
+Assign every animated property from t so seeking A -> B -> A restores A.
+
+Promotion to the catalog (\`mk scene promote\`) is optional when reuse justifies it.
+`;
+const FILES = (id) => [
+    ["scene.js", SCENE_JS],
+    ["fragment.html", FRAGMENT_HTML],
+    ["style.css", STYLE_CSS],
+    ["notes.md", notes(id)],
+];
+async function runNew(args, io) {
+    const parsed = parseFlags("scene", USAGE, args, NEW_FLAGS, io);
+    if (parsed.kind === "exit")
+        return parsed.code;
+    const [id, ...extra] = parsed.positionals;
+    if (id === undefined)
+        return usageError("scene", USAGE, "missing <id>", io).code;
+    if (extra.length > 0)
+        return usageError("scene", USAGE, `unexpected "${extra[0]}"`, io).code;
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(id)) {
+        return usageError("scene", USAGE, "<id> must be a lowercase slug", io).code;
+    }
+    const requested = textFlag(parsed.flags, "dir") ?? join("scenes", id);
+    const dir = resolve(requested);
+    const force = parsed.flags.force === true;
+    const targets = FILES(id).map(([name]) => join(dir, name));
+    if (!force) {
+        const taken = await Promise.all(targets.map((path) => io.host.exists(path)));
+        if (taken.some(Boolean)) {
+            return usageError("scene", USAGE, `${dir} already has files; pass --force to overwrite`, io)
+                .code;
+        }
+    }
+    for (const [name, text] of FILES(id))
+        await io.host.writeText(join(dir, name), text);
+    io.stdout(`wrote ${requested} (${FILES(id).length} files)\n`);
+    io.stdout(`next: add { "type": "custom", "props": { "dir": "${requested.replaceAll("\\", "/")}" } } and run mk validate\n`);
+    return EXIT.OK;
+}
+async function runLint(args, io) {
+    const parsed = parseFlags("scene", USAGE, args, {}, io);
+    if (parsed.kind === "exit")
+        return parsed.code;
+    const [dir, ...extra] = parsed.positionals;
+    if (dir === undefined)
+        return usageError("scene", USAGE, "missing <dir>", io).code;
+    if (extra.length > 0)
+        return usageError("scene", USAGE, `unexpected "${extra[0]}"`, io).code;
+    const base = resolve(dir);
+    const required = ["scene.js", "fragment.html"];
+    const missing = [];
+    for (const file of required) {
+        if (!(await io.host.exists(join(base, file))))
+            missing.push(file);
+    }
+    if (missing.length > 0) {
+        io.stderr(`mk scene lint: missing ${missing.join(", ")} in ${dir}\n`);
+        return EXIT.USAGE;
+    }
+    const js = await io.host.readText(join(base, "scene.js"));
+    const html = await io.host.readText(join(base, "fragment.html"));
+    const cssPath = join(base, "style.css");
+    const css = (await io.host.exists(cssPath)) ? await io.host.readText(cssPath) : undefined;
+    const findings = lintCustomSource({ js, html, ...(css === undefined ? {} : { css }) }, dir);
+    // A linked directory or file can point outside while still looking local.
+    const containment = sceneContainment(dirname(base), base, [...required, "style.css"]);
+    if (!containment.dirInside) {
+        findings.push({
+            severity: "error",
+            path: base,
+            message: "scene directory resolves outside its parent (symlink/junction)",
+            suggestion: "replace the link with a real directory",
+        });
+    }
+    for (const file of containment.escapedFiles) {
+        findings.push({
+            severity: "error",
+            path: `${dir}/${file}`,
+            message: "scene file resolves outside the scene directory (symlink/junction)",
+            suggestion: "replace the link with a real file",
+        });
+    }
+    const closure = await readRelativeClosure(js, async (path) => {
+        const check = sceneContainment(dirname(base), base, [path]);
+        if (!check.dirInside || check.escapedFiles.length > 0)
+            return undefined;
+        const full = join(base, path);
+        return (await io.host.exists(full)) ? io.host.readText(full) : undefined;
+    });
+    for (const specifier of closure.escaping) {
+        findings.push({
+            severity: "error",
+            path: "scene.js",
+            message: `relative import "${specifier}" escapes the scene directory`,
+            suggestion: "keep helpers inside the scene directory (./lib/format.js)",
+        });
+    }
+    for (const path of closure.missing) {
+        findings.push({
+            severity: "error",
+            path: "scene.js",
+            message: `cannot import "./${path}": no such file beside the scene`,
+            suggestion: "add the file, or inline the code",
+        });
+    }
+    if (closure.overflow) {
+        findings.push({
+            severity: "error",
+            path: "scene.js",
+            message: "scene helper closure is too large",
+            suggestion: "keep the scene to a few small helpers",
+        });
+    }
+    for (const helper of closure.files) {
+        findings.push(...lintCustomSource({ js: helper.text }, dir).map((finding) => ({
+            ...finding,
+            path: finding.path.replace(/scene\.js:/, `${helper.path}:`),
+        })));
+    }
+    io.stdout(formatFindings(findings));
+    io.stdout(summaryLine(findings.length, 0));
+    return findings.length === 0 ? EXIT.OK : EXIT.USAGE;
+}
+/** camelCase export name for a promoted scene type. */
+const exportName = (type) => `${type.replace(/[^a-zA-Z0-9]+(.)/g, (_, char) => char.toUpperCase())}Scene`;
+/**
+ * Files for a promoted catalog scene. A promoted scene is static: it keeps its markup
+ * and code verbatim, so the plugin only needs an empty strict schema and a body.
+ * Adding props is a human design step, deliberately not guessed here.
+ */
+export const promoteFiles = (type, source) => {
+    const index = `import { z } from "zod";
+import { defineScene } from "../../define-scene.ts";
+import { readText } from "../../text-file.ts";
+
+const FRAGMENT = readText("./fragment.html", import.meta.url);
+
+/** Promoted from an authored scene. Give it props before it ships: configSchema is empty. */
+export const ${exportName(type)} = defineScene({
+  type: "${type}",
+  configSchema: z.strictObject({}),
+  meta: { purpose: "TODO: one line for the catalog.", example: {} },
+  style: readText("./style.css", import.meta.url),
+  script: readText("./scene.js", import.meta.url),
+  render: () => ({ body: FRAGMENT }),
+});
+`;
+    const files = [
+        ["index.ts", index],
+        ["scene.js", source.js],
+        ["fragment.html", source.html],
+    ];
+    return source.css === undefined ? files : [...files, ["style.css", source.css]];
+};
+const CATALOG_DIR = join("packages", "scenes", "src", "scenes");
+async function runPromote(args, io) {
+    const parsed = parseFlags("scene", USAGE, args, PROMOTE_FLAGS, io);
+    if (parsed.kind === "exit")
+        return parsed.code;
+    const [dir, ...extra] = parsed.positionals;
+    if (dir === undefined)
+        return usageError("scene", USAGE, "missing <dir>", io).code;
+    if (extra.length > 0)
+        return usageError("scene", USAGE, `unexpected "${extra[0]}"`, io).code;
+    const type = textFlag(parsed.flags, "as");
+    if (type === undefined)
+        return usageError("scene", USAGE, "missing --as <type>", io).code;
+    if (!/^[a-z][a-z0-9-]*$/.test(type)) {
+        return usageError("scene", USAGE, "--as must be a lowercase slug", io).code;
+    }
+    const source = resolve(dir);
+    const required = ["scene.js", "fragment.html"];
+    const missing = [];
+    for (const file of required) {
+        if (!(await io.host.exists(join(source, file))))
+            missing.push(file);
+    }
+    if (missing.length > 0) {
+        io.stderr(`mk scene promote: missing ${missing.join(", ")} in ${dir}\n`);
+        return EXIT.USAGE;
+    }
+    const target = resolve(CATALOG_DIR, type);
+    if (await io.host.exists(target)) {
+        return usageError("scene", USAGE, `${CATALOG_DIR}/${type} already exists`, io).code;
+    }
+    const js = await io.host.readText(join(source, "scene.js"));
+    const html = await io.host.readText(join(source, "fragment.html"));
+    const cssPath = join(source, "style.css");
+    const css = (await io.host.exists(cssPath)) ? await io.host.readText(cssPath) : undefined;
+    for (const [name, text] of promoteFiles(type, {
+        js,
+        html,
+        ...(css === undefined ? {} : { css }),
+    })) {
+        await io.host.writeText(join(target, name), text);
+    }
+    io.stdout(`promoted ${dir} -> ${CATALOG_DIR}/${type}\n`);
+    io.stdout(`register it in the catalog registry:\n`);
+    io.stdout(`  import { ${exportName(type)} } from "./scenes/${type}/index.ts";\n`);
+    io.stdout(`  ${exportName(type)},\n`);
+    io.stdout(`then run pnpm test (the catalog snapshot will ask for the new type).\n`);
+    return EXIT.OK;
+}
+const PROMOTE_FLAGS = { as: { type: "string" } };
+export { runLint as sceneLint, runNew as sceneNew, runPromote as scenePromote, USAGE as SCENE_AUTHOR_USAGE, };

package/dist/scene/command.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "../types.ts";
+export declare const sceneCommand: Command;

package/dist/scene/command.js

@@ -0,0 +1,110 @@
+import { listFlag, parseFlags, textFlag, usageError } from "../args.js";
+import { editStoryboard } from "../storyboard/edit.js";
+import { sceneLint, sceneNew, scenePromote } from "./author.js";
+import { addScene, moveScene, removeScene } from "./ops.js";
+const USAGE = `mk scene new <id> [--dir <path>] [--force]
+mk scene lint <dir>
+mk scene promote <dir> --as <type>
+mk scene add <storyboard.json> <type> [--id x] [--after id] [--set k=v ...] [--duration s] [--over id] [--offset s]
+mk scene remove <storyboard.json> <id>
+mk scene move <storyboard.json> <id> (--after <id> | --first)
+
+Edit the scene list of a storyboard; the result is validated and written atomically (never written invalid).
+  add     insert a scene of <type> built from its minimal catalog example (see \`mk catalog <type>\`)
+          --id x       scene id (default <type>-<n>)         --after id   insert after that scene (default: at the end)
+          --set k=v    top-level prop; v is JSON when it parses (3, true, ["a","b"]), else text; repeatable
+          --duration s seconds (default: auto from the text)
+          --over id    overlay types only: the base scene it covers (required), --offset s seconds into it (default 0)
+  remove  delete a scene (an overlay still pointing at it makes the result invalid)
+  move    reorder: land after another scene, or first
+Nested prop edits: \`mk patch\`. Prints one line.
+`;
+const FLAGS = {
+    id: { type: "string" },
+    after: { type: "string" },
+    first: { type: "boolean" },
+    set: { type: "string", multiple: true },
+    duration: { type: "string" },
+    over: { type: "string" },
+    offset: { type: "string" },
+};
+const SUBCOMMANDS = ["add", "remove", "move"];
+const isSub = (value) => SUBCOMMANDS.some((sub) => sub === value);
+/** Flags each subcommand accepts; anything else is a usage error rather than silently ignored. */
+const ALLOWED = {
+    add: ["id", "after", "set", "duration", "over", "offset"],
+    remove: [],
+    move: ["after", "first"],
+};
+const seconds = (flags, name) => {
+    const text = textFlag(flags, name);
+    if (text === undefined)
+        return undefined;
+    const value = Number(text);
+    return Number.isFinite(value) && value >= 0 ? value : "bad";
+};
+/** Subcommand, storyboard path, target and flags checked together; an exit code on bad usage. */
+function parseTarget(args, io) {
+    const parsed = parseFlags("scene", USAGE, args, FLAGS, io);
+    if (parsed.kind === "exit")
+        return parsed.code;
+    const [sub, path, target, ...extra] = parsed.positionals;
+    const usage = (message) => usageError("scene", USAGE, message, io).code;
+    if (!isSub(sub))
+        return usage(`use one of: ${SUBCOMMANDS.join("|")}`);
+    const stray = Object.keys(parsed.flags).find((flag) => !ALLOWED[sub].includes(flag));
+    if (stray !== undefined)
+        return usage(`--${stray} does not apply to ${sub}`);
+    if (path === undefined)
+        return usage("missing <storyboard.json>");
+    if (target === undefined)
+        return usage(sub === "add" ? "missing <type>" : "missing <id>");
+    if (extra.length > 0)
+        return usage(`unexpected argument "${extra[0]}"`);
+    return { sub, path, target, flags: parsed.flags };
+}
+function runMove(request, io) {
+    const after = textFlag(request.flags, "after");
+    if ((after === undefined) === (request.flags.first !== true)) {
+        return usageError("scene", USAGE, "move needs exactly one of --after <id> or --first", io).code;
+    }
+    return editStoryboard("scene", request.path, io, (doc) => moveScene(doc, { id: request.target, after }));
+}
+function runAdd(request, io) {
+    const { flags } = request;
+    const duration = seconds(flags, "duration");
+    const offset = seconds(flags, "offset");
+    if (duration === "bad" || offset === "bad" || duration === 0) {
+        return usageError("scene", USAGE, "--duration and --offset need positive seconds", io).code;
+    }
+    return editStoryboard("scene", request.path, io, (doc) => addScene(doc, {
+        type: request.target,
+        id: textFlag(flags, "id"),
+        after: textFlag(flags, "after"),
+        sets: listFlag(flags, "set"),
+        duration,
+        over: textFlag(flags, "over"),
+        offset,
+    }));
+}
+export const sceneCommand = {
+    name: "scene",
+    summary: "add, remove, move, scaffold or lint scenes",
+    async run(args, io) {
+        const head = args[0];
+        if (head === "new")
+            return sceneNew(args.slice(1), io);
+        if (head === "lint")
+            return sceneLint(args.slice(1), io);
+        if (head === "promote")
+            return scenePromote(args.slice(1), io);
+        const request = parseTarget(args, io);
+        if (typeof request === "number")
+            return request;
+        if (request.sub === "move")
+            return runMove(request, io);
+        if (request.sub === "add")
+            return runAdd(request, io);
+        return editStoryboard("scene", request.path, io, (doc) => removeScene(doc, request.target));
+    },
+};

package/dist/scene/ops.d.ts

@@ -0,0 +1,23 @@
+import { type Edit } from "../storyboard/edit.ts";
+export interface AddRequest {
+    type: string;
+    id?: string | undefined;
+    after?: string | undefined;
+    /** `k=v` pairs; v is JSON when it parses (numbers, true, [..]), else a string. */
+    sets: readonly string[];
+    duration?: number | undefined;
+    /** Overlay scenes only. */
+    over?: string | undefined;
+    offset?: number | undefined;
+}
+/** Inserts a scene built from the catalog's minimal example for `type`. */
+export declare function addScene(doc: unknown, request: AddRequest): Edit;
+/** Removes a scene by id; an overlay still pointing at it makes the validator refuse the result. */
+export declare function removeScene(doc: unknown, id: string): Edit;
+export interface MoveRequest {
+    id: string;
+    /** Scene id to land after; `undefined` moves to the start. */
+    after: string | undefined;
+}
+/** Moves a scene to follow another one (or to the start). */
+export declare function moveScene(doc: unknown, request: MoveRequest): Edit;

package/dist/scene/ops.js

@@ -0,0 +1,151 @@
+import { sceneDocs } from "@anvpx/motion-build";
+import { forbiddenKeys } from "@anvpx/motion-schema";
+import { round1 } from "../storyboard/edit.js";
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const sceneList = (doc) => {
+    const scenes = isRecord(doc) ? doc.scenes : undefined;
+    return Array.isArray(scenes) ? scenes : undefined;
+};
+const indexOfId = (scenes, id) => scenes.findIndex((scene) => scene.id === id);
+const knownIds = (scenes) => scenes.map((s) => String(s.id)).join(", ");
+const NO_SCENES = { ok: false, message: "the storyboard has no scenes array" };
+const OVERLAY_SECONDS = 3;
+const jsonOrText = (text) => {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+};
+/** `k=v` pairs onto the props; keys are top-level prop names (use `mk patch` for nested edits). */
+function applySets(props, sets) {
+    for (const pair of sets) {
+        const cut = pair.indexOf("=");
+        const key = cut > 0 ? pair.slice(0, cut) : "";
+        if (key === "")
+            return `--set "${pair}" needs k=v`;
+        const [problem] = forbiddenKeys({ [key]: 0 }, []);
+        if (problem !== undefined)
+            return `--set ${key}: ${problem.message}`;
+        props[key] = jsonOrText(pair.slice(cut + 1));
+    }
+    return undefined;
+}
+const freeId = (type, scenes) => {
+    const taken = new Set(scenes.map((scene) => scene.id));
+    for (let n = 1;; n++)
+        if (!taken.has(`${type}-${n}`))
+            return `${type}-${n}`;
+};
+/** The entry's timing fields: `duration`, and `layer`/`over`/`offset` for overlays. */
+function timingOf(overlay, request) {
+    const duration = request.duration ?? (overlay ? OVERLAY_SECONDS : undefined);
+    return {
+        ...(duration === undefined ? {} : { duration }),
+        ...(overlay ? { layer: "overlay", over: request.over, offset: request.offset ?? 0 } : {}),
+    };
+}
+/** The scene entry for `type`, or the reason it cannot be built. */
+function buildEntry(scenes, request) {
+    const docs = sceneDocs();
+    const found = docs.find((entry) => entry.type === request.type);
+    if (found === undefined) {
+        const known = docs.map((d) => d.type).join("|");
+        return { ok: false, message: `unknown scene type "${request.type}"; use one of: ${known}` };
+    }
+    const id = request.id ?? freeId(request.type, scenes);
+    if (indexOfId(scenes, id) !== -1)
+        return { ok: false, message: `scene id "${id}" already exists` };
+    const props = structuredClone(found.example);
+    const problem = applySets(props, request.sets);
+    if (problem !== undefined)
+        return { ok: false, message: problem };
+    const overlay = found.layer === "overlay";
+    if (overlay && (request.over === undefined || indexOfId(scenes, request.over) === -1)) {
+        const known = knownIds(scenes);
+        return {
+            ok: false,
+            message: `${request.type} is an overlay: give --over <base scene id> (one of: ${known})`,
+        };
+    }
+    return { ok: true, entry: { id, type: request.type, props, ...timingOf(overlay, request) } };
+}
+/** Index to insert at: after `--after`, else the end; undefined when that scene does not exist. */
+function insertionIndex(scenes, after) {
+    if (after === undefined)
+        return scenes.length;
+    const at = indexOfId(scenes, after);
+    return at === -1 ? undefined : at + 1;
+}
+/** Inserts a scene built from the catalog's minimal example for `type`. */
+export function addScene(doc, request) {
+    const scenes = sceneList(doc);
+    if (scenes === undefined)
+        return NO_SCENES;
+    const built = buildEntry(scenes, request);
+    if (!built.ok)
+        return built;
+    const at = insertionIndex(scenes, request.after);
+    if (at === undefined) {
+        return {
+            ok: false,
+            message: `--after "${request.after}": no such scene (have: ${knownIds(scenes)})`,
+        };
+    }
+    const next = structuredClone(doc);
+    next.scenes.splice(at, 0, built.entry);
+    return {
+        ok: true,
+        value: next,
+        lines: (report) => [
+            `scene add ok | ${built.entry.id} (${request.type}) at ${at + 1}/${next.scenes.length} | total ${round1(report.total ?? 0)}s | ${report.errors.length} errors, ${report.warnings.length} warnings`,
+        ],
+    };
+}
+/** Removes a scene by id; an overlay still pointing at it makes the validator refuse the result. */
+export function removeScene(doc, id) {
+    const scenes = sceneList(doc);
+    if (scenes === undefined)
+        return NO_SCENES;
+    const at = indexOfId(scenes, id);
+    if (at === -1)
+        return { ok: false, message: `no scene "${id}" (have: ${knownIds(scenes)})` };
+    const next = structuredClone(doc);
+    next.scenes.splice(at, 1);
+    return {
+        ok: true,
+        value: next,
+        lines: (report) => [
+            `scene remove ok | ${id} | scenes ${next.scenes.length} | total ${round1(report.total ?? 0)}s | ${report.errors.length} errors, ${report.warnings.length} warnings`,
+        ],
+    };
+}
+/** Moves a scene to follow another one (or to the start). */
+export function moveScene(doc, request) {
+    const scenes = sceneList(doc);
+    if (scenes === undefined)
+        return NO_SCENES;
+    const from = indexOfId(scenes, request.id);
+    if (from === -1)
+        return { ok: false, message: `no scene "${request.id}" (have: ${knownIds(scenes)})` };
+    if (request.after === request.id)
+        return { ok: false, message: "cannot move a scene after itself" };
+    const next = structuredClone(doc);
+    const [moved] = next.scenes.splice(from, 1);
+    const anchor = request.after === undefined ? -1 : indexOfId(next.scenes, request.after);
+    if (request.after !== undefined && anchor === -1) {
+        return {
+            ok: false,
+            message: `--after "${request.after}": no such scene (have: ${knownIds(scenes)})`,
+        };
+    }
+    next.scenes.splice(anchor + 1, 0, moved);
+    return {
+        ok: true,
+        value: next,
+        lines: (report) => [
+            `scene move ok | ${request.id} now at ${anchor + 2}/${next.scenes.length} | total ${round1(report.total ?? 0)}s | ${report.errors.length} errors, ${report.warnings.length} warnings`,
+        ],
+    };
+}

package/dist/state/command.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "../types.ts";
+export declare const stateCommand: Command;