@anvpx/motion-cli 0.0.0-stage → 0.1.0

package/dist/integration/preview.integration.js

@@ -0,0 +1,53 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import { runCli } from "../cli.js";
+import { nodeIo } from "../node-io.js";
+const OUT = fileURLToPath(new URL("../../dist/.out/template-flow", import.meta.url));
+const SB = join(OUT, "storyboard.json");
+const PACK = join(OUT, "out", "storyboard.preview");
+const BUDGET_SEC = 90;
+const MIN_PNG_BYTES = 10_000;
+async function mk(...args) {
+    const out = [];
+    const err = [];
+    const io = { ...nodeIo(), stdout: (t) => out.push(t), stderr: (t) => err.push(t) };
+    const began = performance.now();
+    const code = await runCli(args, io);
+    const seconds = Math.round((performance.now() - began) / 100) / 10;
+    return { code, out: out.join(""), err: err.join(""), seconds };
+}
+/** The real protocol on the built-in explain/architecture example: new, preview, gate, approve. */
+describe("template flow with the real tools", () => {
+    rmSync(OUT, { recursive: true, force: true });
+    mkdirSync(OUT, { recursive: true });
+    it("mk new writes a valid storyboard with a vendored theme", async () => {
+        const made = await mk("new", "explain/architecture", "--out", SB, "--set", "title=How Smart Pricing is wired", "--set", "nodes=Market data|Pricing engine|Rules|Listing price", "--set", "edges=Market data>Pricing engine\\|signals|Rules>Pricing engine\\|guardrails|Pricing engine>Listing price");
+        expect(made.code, made.err).toBe(0);
+        expect((await mk("validate", SB)).code).toBe(0);
+        const { theme } = JSON.parse(readFileSync(SB, "utf8")).meta;
+        expect(existsSync(join(OUT, "themes", `${theme}.json`))).toBe(true);
+    });
+    it(`mk preview builds the pack within ${BUDGET_SEC} s`, async () => {
+        const preview = await mk("preview", SB);
+        expect(preview.code, preview.err).toBe(0);
+        expect(preview.seconds).toBeLessThanOrEqual(BUDGET_SEC);
+        expect(statSync(join(PACK, "contact.png")).size).toBeGreaterThan(MIN_PNG_BYTES);
+        const manifest = JSON.parse(readFileSync(join(PACK, "preview.json"), "utf8"));
+        expect(manifest.clip.status, JSON.stringify(manifest.clip)).toBe("ok");
+        expect(statSync(join(PACK, "clip.mp4")).size).toBeGreaterThan(0);
+        expect(manifest.stills.length).toBeGreaterThanOrEqual(4);
+    });
+    it("render --gated exits 4 until approved, then renders; an edit re-arms it", async () => {
+        expect((await mk("render", SB, "--gated")).code).toBe(4);
+        expect((await mk("approve", SB, "--note", "integration test")).code).toBe(0);
+        const rendered = await mk("render", SB, "--gated", "--verify");
+        expect(rendered.code, rendered.err).toBe(0);
+        expect(rendered.out).toContain("PASS");
+        const edited = readFileSync(SB, "utf8").replaceAll("Rules", "Guardrails");
+        expect(edited).not.toBe(readFileSync(SB, "utf8"));
+        writeFileSync(SB, edited);
+        expect((await mk("render", SB, "--gated")).code).toBe(4);
+    });
+});

package/dist/integration/smoke.integration.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/integration/smoke.integration.js

@@ -0,0 +1,91 @@
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import { runCli } from "../cli.js";
+import { nodeIo } from "../node-io.js";
+const path = (relative) => fileURLToPath(new URL(relative, import.meta.url));
+const FIXTURE = path("../../../build/fixtures/demo.storyboard.json");
+const OUT = path("../../dist/.out/smoke");
+const MIN_PNG_BYTES = 10_000;
+async function mk(...args) {
+    const out = [];
+    const err = [];
+    const io = { ...nodeIo(), stdout: (t) => out.push(t), stderr: (t) => err.push(t) };
+    const began = performance.now();
+    const code = await runCli(args, io);
+    const seconds = Math.round((performance.now() - began) / 100) / 10;
+    return { code, out: out.join(""), err: err.join(""), seconds };
+}
+const probe = (file) => {
+    const json = execFileSync("ffprobe", [
+        "-v",
+        "error",
+        "-select_streams",
+        "v:0",
+        "-show_entries",
+        "stream=codec_name,width,height,r_frame_rate:format=duration",
+        "-of",
+        "json",
+        file,
+    ], { encoding: "utf8" });
+    return JSON.parse(json);
+};
+describe("real mk end to end on the demo fixture", () => {
+    rmSync(OUT, { recursive: true, force: true });
+    mkdirSync(OUT, { recursive: true });
+    const report = {};
+    it("validate then build", async () => {
+        expect((await mk("validate", FIXTURE)).code).toBe(0);
+        const built = await mk("build", FIXTURE, "--out", OUT);
+        expect(built.code, built.err).toBe(0);
+        expect(built.out).toMatch(/manifest sha256 [a-f0-9]{64}/);
+    });
+    it("still --at 3,10 writes two PNGs", async () => {
+        const still = await mk("still", FIXTURE, "--at", "3,10", "--out", OUT);
+        expect(still.code, still.err).toBe(0);
+        expect(still.out.match(/\.png/g)).toHaveLength(2);
+        for (const name of ["frame-00-at-3s.png", "frame-01-at-10s.png"]) {
+            expect(statSync(`${OUT}/stills/${name}`).size, name).toBeGreaterThan(MIN_PNG_BYTES);
+        }
+    });
+    it("draft is 960x540 at 15 fps", async () => {
+        const draft = await mk("draft", FIXTURE, "--out", OUT);
+        expect(draft.code, draft.err).toBe(0);
+        report.draft = { seconds: draft.seconds, ...probe(`${OUT}/draft.mp4`) };
+        expect(JSON.stringify(report.draft)).toContain('"width":960');
+    });
+    it("verify PASSes the real draft against the storyboard", async () => {
+        const verified = await mk("verify", `${OUT}/draft.mp4`, "--storyboard", FIXTURE, "--draft");
+        expect(verified.out, verified.err).toMatch(/^PASS draft[.]mp4/);
+        expect(verified.code).toBe(0);
+        report.verifyDraft = { bytes: Buffer.byteLength(verified.out), seconds: verified.seconds };
+    });
+    it("verify FAILs (exit 5) when the draft is checked as a final render", async () => {
+        const verified = await mk("verify", `${OUT}/draft.mp4`, "--storyboard", FIXTURE);
+        expect(verified.code).toBe(5);
+        expect(verified.out).toContain("resolution-mismatch");
+    });
+    it("draft writes a render manifest that matches the build manifest and the mp4", async () => {
+        const manifest = JSON.parse(readFileSync(`${OUT}/render-manifest.json`, "utf8"));
+        const sha = (file) => createHash("sha256").update(readFileSync(file)).digest("hex");
+        expect(manifest).toMatchObject({ kind: "draft", verify: "not-run" });
+        expect(manifest.output.sha256).toBe(sha(`${OUT}/draft.mp4`));
+        expect(manifest.manifestSha256).toBe(sha(`${OUT}/manifest.json`));
+        expect(manifest.tools.ffmpeg).toMatch(/^[0-9]+[.][0-9]+/);
+    });
+    it("render is 1920x1080 at 30 fps H.264", async () => {
+        const render = await mk("render", FIXTURE, "--out", OUT);
+        expect(render.code, render.err).toBe(0);
+        expect(existsSync(`${OUT}/final.mp4`)).toBe(true);
+        report.render = { seconds: render.seconds, ...probe(`${OUT}/final.mp4`) };
+        expect(JSON.stringify(report.render)).toContain('"codec_name":"h264"');
+        expect(JSON.stringify(report.render)).toContain('"width":1920');
+        const verified = await mk("verify", `${OUT}/final.mp4`, "--storyboard", FIXTURE);
+        expect(verified.out, verified.err).toMatch(/^PASS final[.]mp4/);
+        expect(verified.code).toBe(0);
+        report.verifyFinal = { bytes: Buffer.byteLength(verified.out), seconds: verified.seconds };
+        writeFileSync(`${OUT}/smoke-report.json`, `${JSON.stringify(report, null, 2)}\n`);
+    });
+});

package/dist/main.d.ts

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

package/dist/main.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runCli } from "./cli.js";
+import { nodeIo } from "./node-io.js";
+process.exitCode = await runCli(process.argv.slice(2), nodeIo());

package/dist/node-io.d.ts

@@ -0,0 +1,14 @@
+import type { Host, Io, Runner } from "./types.ts";
+/** Throws when an argument could be interpreted by cmd.exe instead of passed through verbatim. */
+export declare function assertCmdSafe(args: readonly string[]): void;
+export declare function launchPlan(cmd: string, args: readonly string[], platform?: string): [string, string[]];
+export declare const runCommand: Runner;
+/**
+ * Where the root manifest may live, in order: the directory being run in (a consumer
+ * install has only its own package.json), then the workspace root next to the sources.
+ */
+export declare function rootPackageJsonCandidates(cwd?: string): string[];
+/** First candidate that reads and parses; undefined when none does, never a throw. */
+export declare function readRootPackageJson(candidates?: readonly string[]): Promise<unknown>;
+export declare function nodeHost(): Host;
+export declare function nodeIo(): Io;

package/dist/node-io.js

@@ -0,0 +1,152 @@
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { access, copyFile, mkdir, readdir, readFile, rename, rm, writeFile, } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const DEFAULT_TIMEOUT_MS = 30_000;
+/** Renders print a line per frame batch; the Node default of 1 MB would kill them. */
+const MAX_OUTPUT_BYTES = 64 * 1024 * 1024;
+/**
+ * Windows invariant: `pnpm` and `npx` are .cmd shims, and Node cannot spawn those directly
+ * without a shell. They go through `cmd.exe /d /s /c` and nothing else does (never `shell: true`).
+ * cmd.exe re-parses the command line, so every argument on that path is checked by
+ * `assertCmdSafe`; anything cmd treats as syntax is refused instead of escaped.
+ */
+const WINDOWS_SHIMS = new Set(["pnpm", "npx"]);
+/** cmd.exe metacharacters (& | < > ^ " %), line breaks and NUL. */
+const CMD_UNSAFE = /[&|<>^"%\r\n\0]/;
+/** Throws when an argument could be interpreted by cmd.exe instead of passed through verbatim. */
+export function assertCmdSafe(args) {
+    const bad = args.find((arg) => CMD_UNSAFE.test(arg));
+    if (bad !== undefined) {
+        throw new Error(`argument ${JSON.stringify(bad)} contains a cmd.exe metacharacter (& | < > ^ " %) or a line break`);
+    }
+}
+/** Spawn failures (ENOENT, timeout) have no numeric exit code; report them as 127. */
+function toResult(error, stdout, stderr) {
+    if (!error)
+        return { code: 0, stdout, stderr };
+    if (typeof error.code === "number")
+        return { code: error.code, stdout, stderr };
+    return { code: 127, stdout, stderr: error.message };
+}
+export function launchPlan(cmd, args, platform = process.platform) {
+    if (platform === "win32" && WINDOWS_SHIMS.has(cmd)) {
+        assertCmdSafe([cmd, ...args]);
+        return ["cmd.exe", ["/d", "/s", "/c", cmd, ...args]];
+    }
+    return [cmd, [...args]];
+}
+export const runCommand = (cmd, args, options = {}) => new Promise((resolve) => {
+    let plan;
+    try {
+        plan = launchPlan(cmd, args);
+    }
+    catch (error) {
+        resolve({
+            code: 127,
+            stdout: "",
+            stderr: error instanceof Error ? error.message : String(error),
+        });
+        return;
+    }
+    const [file, fileArgs] = plan;
+    execFile(file, fileArgs, {
+        cwd: options.cwd,
+        env: { ...process.env, ...options.env },
+        timeout: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+        maxBuffer: MAX_OUTPUT_BYTES,
+        windowsHide: true,
+    }, (error, stdout, stderr) => resolve(toResult(error, stdout, stderr)));
+});
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function sha256File(path) {
+    try {
+        return createHash("sha256")
+            .update(await readFile(path))
+            .digest("hex");
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Where the root manifest may live, in order: the directory being run in (a consumer
+ * install has only its own package.json), then the workspace root next to the sources.
+ */
+export function rootPackageJsonCandidates(cwd = process.cwd()) {
+    return [
+        join(cwd, "package.json"),
+        fileURLToPath(new URL("../../../package.json", import.meta.url)),
+    ];
+}
+/** First candidate that reads and parses; undefined when none does, never a throw. */
+export async function readRootPackageJson(candidates = rootPackageJsonCandidates()) {
+    for (const path of candidates) {
+        try {
+            return JSON.parse(await readFile(path, "utf8"));
+        }
+        catch {
+            // Not there (or not JSON): try the next candidate.
+        }
+    }
+    return undefined;
+}
+export function nodeHost() {
+    return {
+        platform: process.platform,
+        nodeVersion: process.versions.node,
+        homeDir: homedir(),
+        env: process.env,
+        listDir: (path) => readdir(path),
+        async mkdir(path) {
+            await mkdir(path, { recursive: true });
+        },
+        readRootPackageJson,
+        readText: (path) => readFile(path, "utf8"),
+        async writeText(path, text) {
+            await mkdir(dirname(path), { recursive: true });
+            await writeFile(path, text, "utf8");
+        },
+        async writeTextAtomic(path, text) {
+            await mkdir(dirname(path), { recursive: true });
+            const temp = `${path}.${process.pid}.tmp`;
+            try {
+                await writeFile(temp, text, "utf8");
+                await rename(temp, path);
+            }
+            catch (error) {
+                await rm(temp, { force: true });
+                throw error;
+            }
+        },
+        exists,
+        async copyFile(from, to) {
+            await mkdir(dirname(to), { recursive: true });
+            await copyFile(from, to);
+        },
+        async renameFile(from, to) {
+            await mkdir(dirname(to), { recursive: true });
+            await rename(from, to);
+        },
+        sha256File,
+        remove: (path) => rm(path, { force: true }),
+    };
+}
+export function nodeIo() {
+    return {
+        stdout: (text) => process.stdout.write(text),
+        stderr: (text) => process.stderr.write(text),
+        run: runCommand,
+        host: nodeHost(),
+    };
+}

package/dist/optimize/command.d.ts

@@ -0,0 +1,12 @@
+import type { Command } from "../types.ts";
+/** Passthrough validator: GLB magic, version 2, declared length matches bytes. */
+export declare const validateGlb: (bytes: Uint8Array) => {
+    ok: true;
+    bytes: number;
+} | {
+    ok: false;
+    message: string;
+};
+/** `mk optimize-model`; `make` wrapper keeps the fit-command test pattern. */
+export declare const makeOptimizeModelCommand: () => Command;
+export declare const optimizeModelCommand: Command;

package/dist/optimize/command.js

@@ -0,0 +1,110 @@
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { parseFlags, requirePositional, textFlag, usageError } from "../args.js";
+import { EXIT } from "../exit-codes.js";
+const USAGE = `mk optimize-model <model.glb> [--out <file>]
+
+Validate a binary glTF model and write an optimized copy (offline passthrough).
+No native deps: checks the GLB magic, version and length, de-duplicates nothing
+yet, and reports in/out byte sizes deterministically. Meshopt-class compression
+is out of scope until a free, Windows-available, non-native tool is approved.
+  --out <file>   output path (default: overwrite the input in place)
+Prints one line: optimize-model ok | in N bytes -> out M bytes | <path>
+`;
+const FLAGS = {
+    out: { type: "string" },
+};
+const NAME = "optimize-model";
+/** Passthrough validator: GLB magic, version 2, declared length matches bytes. */
+export const validateGlb = (bytes) => {
+    if (bytes.length < 12 ||
+        bytes[0] !== 0x67 ||
+        bytes[1] !== 0x6c ||
+        bytes[2] !== 0x54 ||
+        bytes[3] !== 0x46) {
+        return { ok: false, message: "not a GLB model (missing glTF magic)" };
+    }
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const version = view.getUint32(4, true);
+    if (version !== 2)
+        return { ok: false, message: `unsupported glTF version ${version}; need 2` };
+    const total = view.getUint32(8, true);
+    if (total !== bytes.length) {
+        return {
+            ok: false,
+            message: `GLB length mismatch: header says ${total} bytes, file has ${bytes.length}`,
+        };
+    }
+    return { ok: true, bytes: bytes.length };
+};
+const fail = (message, io) => usageError(NAME, USAGE, message, io).code;
+/** Input path plus output path, or an exit code on bad usage. */
+const targetOf = (parsed, io) => {
+    const input = requirePositional(NAME, USAGE, parsed.positionals, "<model.glb>", io);
+    if (typeof input !== "string")
+        return input.code;
+    if (parsed.positionals.length > 1)
+        return fail(`unexpected argument "${parsed.positionals[1]}"`, io);
+    return { input, out: textFlag(parsed.flags, "out") ?? input };
+};
+/** File bytes, or an exit code when unreadable. */
+const readOf = async (io, input) => {
+    // Byte-correct path: raw bytes off disk (readText utf8-decodes binary GLB).
+    try {
+        const buf = await readFile(input);
+        return { bytes: new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength), viaFs: true };
+    }
+    catch {
+        // In-memory fakes (tests) fall through to Host.
+    }
+    try {
+        const text = await io.host.readText(input);
+        return { bytes: Uint8Array.from(Buffer.from(text, "binary")), viaFs: false };
+    }
+    catch {
+        return fail(`cannot read "${input}"`, io);
+    }
+};
+const report = (io, bytes, out) => {
+    io.stdout(`optimize-model ok | in ${bytes} bytes -> out ${bytes} bytes (saved 0%) | ${out}\n`);
+};
+/** Byte-preserving write: real FS when read came off disk, Host for fakes. */
+const writeOf = async (io, out, bytes, viaFs) => {
+    if (viaFs) {
+        await mkdir(dirname(out), { recursive: true });
+        const temp = `${out}.${process.pid}.tmp`;
+        try {
+            await writeFile(temp, bytes);
+            await rename(temp, out);
+        }
+        catch (error) {
+            await rm(temp, { force: true });
+            throw error;
+        }
+        return;
+    }
+    await io.host.writeTextAtomic(out, Buffer.from(bytes).toString("binary"));
+};
+/** `mk optimize-model`; `make` wrapper keeps the fit-command test pattern. */
+export const makeOptimizeModelCommand = () => ({
+    name: NAME,
+    summary: "validate a GLB model and write an optimized copy with a size report",
+    async run(args, io) {
+        const parsed = parseFlags(NAME, USAGE, args, FLAGS, io);
+        if (parsed.kind === "exit")
+            return parsed.code;
+        const target = targetOf(parsed, io);
+        if (typeof target === "number")
+            return target;
+        const read = await readOf(io, target.input);
+        if (typeof read === "number")
+            return read;
+        const checked = validateGlb(read.bytes);
+        if (!checked.ok)
+            return fail(checked.message, io);
+        await writeOf(io, target.out, read.bytes, read.viaFs);
+        report(io, checked.bytes, target.out);
+        return EXIT.OK;
+    },
+});
+export const optimizeModelCommand = makeOptimizeModelCommand();

package/dist/packs/command.d.ts

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

package/dist/packs/command.js

@@ -0,0 +1,109 @@
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseFlags, requirePositional, usageError } from "../args.js";
+import { EXIT } from "../exit-codes.js";
+const USAGE = `mk packs [show <id>] [--json]
+
+List qualified style packs, or show one pack's guide.
+Resolves the installed packs payload first, repo fallback.
+  --json        one compact JSON line instead of text
+`;
+const FLAGS = {
+    json: { type: "boolean" },
+};
+const ROW = /^\| ([a-z0-9-]+) \| .*? \| ([^\s|]+\.md) \|/gm;
+const parseIndex = (text) => [...text.matchAll(ROW)].map((m) => ({ id: m[1] ?? "", guide: m[2] ?? "" }));
+/** Installed payload first (`packages/core/packs`), then repo checkouts walking up from cwd. */
+async function findRoot(io) {
+    const fromModule = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "packs");
+    const roots = [fromModule, join(process.cwd(), "docs", "packs")];
+    let dir = process.cwd();
+    for (let i = 0; i < 8; i++) {
+        dir = dirname(dir);
+        roots.push(join(dir, "docs", "packs"));
+    }
+    for (const root of roots) {
+        if (await io.host.exists(join(root, "INDEX.md")))
+            return root;
+    }
+    return undefined;
+}
+async function readSummary(io, root, id) {
+    try {
+        const parsed = JSON.parse(await io.host.readText(join(root, id, "pack.json")));
+        const summary = typeof parsed === "object" && parsed !== null && "summary" in parsed
+            ? parsed.summary
+            : undefined;
+        return typeof summary === "string" ? summary : "";
+    }
+    catch {
+        return "";
+    }
+}
+async function loadRows(io) {
+    const root = await findRoot(io);
+    if (!root)
+        return {
+            code: usageError("packs", USAGE, "no packs payload found (installed packs/ or repo docs/packs)", io).code,
+        };
+    const rows = parseIndex(await io.host.readText(join(root, "INDEX.md")));
+    if (rows.length === 0)
+        return { code: usageError("packs", USAGE, "pack index lists no packs", io).code };
+    return { root, rows };
+}
+async function runList(io, root, rows, json) {
+    const items = await Promise.all(rows.map(async (row) => ({ id: row.id, summary: await readSummary(io, root, row.id) })));
+    if (json)
+        io.stdout(`${JSON.stringify(items)}\n`);
+    else
+        for (const item of items)
+            io.stdout(item.summary ? `${item.id} — ${item.summary}\n` : `${item.id}\n`);
+    return EXIT.OK;
+}
+async function runShow(io, root, rows, json, positionals) {
+    const id = requirePositional("packs", USAGE, positionals, "<id>", io);
+    if (typeof id !== "string")
+        return id.code;
+    const row = rows.find((r) => r.id === id);
+    if (!row) {
+        const known = rows.map((r) => r.id).join("|");
+        return usageError("packs", USAGE, `unknown pack "${id}"; use one of: ${known}`, io).code;
+    }
+    const guideFile = join(root, row.id, basename(row.guide));
+    let guide;
+    try {
+        guide = await io.host.readText(guideFile);
+    }
+    catch {
+        return usageError("packs", USAGE, `guide missing for pack "${id}" (${guideFile})`, io).code;
+    }
+    const summary = await readSummary(io, root, row.id);
+    if (json)
+        io.stdout(`${JSON.stringify({ id, summary, guide: row.guide, text: guide })}\n`);
+    else
+        io.stdout(guide.endsWith("\n") ? guide : `${guide}\n`);
+    return EXIT.OK;
+}
+export const packsCommand = {
+    name: "packs",
+    summary: "list style packs, or show one pack guide; installed payload first, repo fallback",
+    async run(args, io) {
+        const parsed = parseFlags("packs", USAGE, args, FLAGS, io);
+        if (parsed.kind === "exit")
+            return parsed.code;
+        const { flags, positionals } = parsed;
+        const loaded = await loadRows(io);
+        if ("code" in loaded)
+            return loaded.code;
+        const [sub, ...rest] = positionals;
+        if (sub === undefined || sub === "list") {
+            if (rest.length > 0)
+                return usageError("packs", USAGE, "list takes no id", io).code;
+            return runList(io, loaded.root, loaded.rows, flags.json === true);
+        }
+        if (sub !== "show")
+            return usageError("packs", USAGE, `unknown action "${sub}"; use: mk packs [show <id>]`, io)
+                .code;
+        return runShow(io, loaded.root, loaded.rows, flags.json === true, rest);
+    },
+};

package/dist/patch/apply.d.ts

@@ -0,0 +1,36 @@
+/** The RFC 6902 subset `mk patch` supports. */
+export type PatchOp = {
+    op: "add" | "replace" | "test";
+    path: string;
+    value: unknown;
+} | {
+    op: "remove";
+    path: string;
+} | {
+    op: "move";
+    from: string;
+    path: string;
+};
+export type ParsedOps = {
+    ok: true;
+    ops: PatchOp[];
+} | {
+    ok: false;
+    message: string;
+};
+export type PatchResult = {
+    ok: true;
+    value: unknown;
+    changed: string[];
+} | {
+    ok: false;
+    index: number;
+    message: string;
+};
+/** Checks the shape of an ops document; every message names the op index. */
+export declare function parseOps(input: unknown): ParsedOps;
+/**
+ * Applies ops in order to a copy of `doc`; the input is never mutated. Stops at the first op that
+ * cannot apply and names its index. Pure: validation of the result is the caller's job.
+ */
+export declare function applyPatch(doc: unknown, ops: readonly PatchOp[]): PatchResult;