makeables 0.6.0 → 0.7.0

package/dist/cli.js

@@ -8,6 +8,7 @@ import {
   cardStyles,
   checkSubmittedSvg,
   connectAccount,
+  createStickerSheet,
   defaultStickerMaterial,
   designCatalog,
   designProfile,
@@ -22,16 +23,27 @@ import {
   newBadge,
   newCard,
   openBrowser,
+  packSheet,
   packageJson,
+  placeNear,
+  prepareSheetPrint,
   readBadge,
   readPackageJson,
   removeBadgeLayer,
   renderBadge,
   setBadgeLayer,
+  sheetPrintPdf,
+  sheetSizes,
+  sheetSpec,
+  sheetTypeIds,
+  sheetTypes,
   side,
   skills,
   startStudio,
+  stickerCut,
+  stickerCutSvg,
   stickerMaterialSchema,
+  stickerSheetSchema,
   stickerStyles,
   studioRequest,
   submitDesign,
@@ -40,15 +52,15 @@ import {
   svgNodeXml,
   version,
   writeAtomic
-} from "./chunk-4AJQBAFB.js";
+} from "./chunk-QJHEOZGN.js";
 
 // src/cli.ts
 import { spawnSync as spawnSync2 } from "child_process";
 import { constants as constants2 } from "fs";
-import { access, lstat as lstat2, open as open2, readFile as readFile6 } from "fs/promises";
-import { dirname as dirname3, extname as extname4, resolve as resolve5 } from "path";
+import { access, lstat as lstat2, open as open2, readFile as readFile7 } from "fs/promises";
+import { dirname as dirname3, extname as extname4, resolve as resolve6 } from "path";
 import { parseArgs } from "util";
-import sharp6 from "sharp";
+import sharp8 from "sharp";
 import { zodToJsonSchema } from "zod-to-json-schema";
 
 // src/card-import.ts
@@ -908,10 +920,195 @@ async function referenceImage(command, file, options, out, reference) {
   }
 }
 
+// src/sheet.ts
+import { readFile as readFile4 } from "fs/promises";
+import { resolve as resolve4 } from "path";
+import { deflateSync } from "zlib";
+import { createCanvas } from "@napi-rs/canvas";
+import sharp4 from "sharp";
+async function readSheet(file) {
+  const value = JSON.parse(await readFile4(resolve4(file), "utf8"));
+  const parsed = stickerSheetSchema.safeParse(value);
+  if (!parsed.success)
+    throw new InputError(
+      `Invalid sheet: ${parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}`
+    );
+  return parsed.data;
+}
+function newSheet(type, size, name) {
+  if (typeof type !== "string" || !sheetTypeIds.includes(type))
+    throw new InputError(`--type must be one of ${sheetTypeIds.join(", ")}.`);
+  const sheet = createStickerSheet(
+    type,
+    typeof name === "string" ? name : void 0
+  );
+  if (size !== void 0) {
+    if (typeof size !== "string" || !(size in sheetSizes))
+      throw new InputError(`--size must be one of ${Object.keys(sheetSizes).join(", ")}.`);
+    sheet.size = size;
+  }
+  return parse(sheet);
+}
+function parse(sheet) {
+  const parsed = stickerSheetSchema.safeParse(sheet);
+  if (!parsed.success)
+    throw new InputError(parsed.error.issues.map((issue) => issue.message).join("; "));
+  return parsed.data;
+}
+async function readSticker(source) {
+  const style2 = stickerStyles.find((entry) => entry.source === source);
+  if (style2) return badgeDesignSchema.parse(structuredClone(style2));
+  const design = badgeDesignSchema.parse(JSON.parse(await readFile4(resolve4(source), "utf8")));
+  if (design.product !== "sticker") throw new InputError(`${source} is not a sticker design.`);
+  return design;
+}
+var artCache = /* @__PURE__ */ new Map();
+function flatArt(design) {
+  const key = JSON.stringify(design);
+  let art = artCache.get(key);
+  if (!art) {
+    art = renderBadge(design, { face: "front", person: {} }).then(async ({ png }) => {
+      const { data, info } = await sharp4(png).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+      return {
+        width: info.width,
+        height: info.height,
+        rgba: new Uint8ClampedArray(data.buffer, data.byteOffset, data.length)
+      };
+    });
+    artCache.set(key, art);
+  }
+  return art;
+}
+async function sheetArt(sheet) {
+  return new Map(
+    await Promise.all(
+      sheet.items.map(async (item) => [item.id, await flatArt(item.design)])
+    )
+  );
+}
+function bounds(sheet) {
+  const spec = sheetSpec(sheet);
+  return { widthMm: spec.widthMm ?? 0, heightMm: spec.heightMm ?? 0 };
+}
+async function addToSheet(sheet, source, widthMm) {
+  const type = sheetTypes[sheet.type];
+  if (type.cut === "die-cut" && sheet.items.length)
+    throw new InputError("A single sticker file holds one sticker. Start another sheet.");
+  const width = widthMm === void 0 ? type.stickerWidthMm : Number(widthMm);
+  if (!Number.isFinite(width) || width < 5 || width > 300)
+    throw new InputError("--width-mm must be a number from 5 to 300.");
+  const design = await readSticker(source);
+  const base = (design.source ?? "sticker").replace(/[^a-z0-9-]/g, "").slice(0, 40) || "sticker";
+  let id = base;
+  for (let n = 2; sheet.items.some((item2) => item2.id === id); n++) id = `${base}-${n}`;
+  const spec = sheetSpec(sheet);
+  const item = {
+    id,
+    design,
+    x: (spec.widthMm ?? width) / 2,
+    y: (spec.heightMm ?? width) / 2,
+    rotation: 0,
+    widthMm: width
+  };
+  const next = parse({ ...sheet, items: [...sheet.items, item] });
+  if (type.cut === "die-cut") return { sheet: next, item, placed: true };
+  const print = prepareSheetPrint(next, await sheetArt(next));
+  const moved = placeNear(
+    spec,
+    bounds(next),
+    next.items.map((entry) => ({ item: entry, shape: print.shapes.get(entry.id) })),
+    id,
+    [item.x, item.y]
+  );
+  if (moved) next.items[next.items.length - 1] = moved;
+  return { sheet: next, item: moved ?? item, placed: Boolean(moved) };
+}
+async function packStickerSheet(sheet) {
+  if (sheetTypes[sheet.type].cut === "die-cut") return { sheet, missing: [] };
+  const print = prepareSheetPrint(sheet, await sheetArt(sheet));
+  const packed = packSheet(
+    sheetSpec(sheet),
+    bounds(sheet),
+    sheet.items.map((item) => ({ item, shape: print.shapes.get(item.id) })),
+    sheet.hero
+  );
+  return { sheet: parse({ ...sheet, items: packed.items }), missing: packed.missing };
+}
+async function checkSheet(sheet) {
+  return prepareSheetPrint(sheet, await sheetArt(sheet));
+}
+function sheetReport(print) {
+  return {
+    printable: print.printable,
+    widthMm: Number(print.widthMm.toFixed(2)),
+    heightMm: Number(print.heightMm.toFixed(2)),
+    stickers: print.items.length,
+    violations: print.violations,
+    issues: print.issues.map(({ id, issue }) => ({ id, ...issue }))
+  };
+}
+async function exportSheetPdf(sheet, print) {
+  return sheetPrintPdf(sheet, print, async (bytes) => new Uint8Array(deflateSync(bytes)));
+}
+function sheetPreviewPng(print, dpi = 150) {
+  const scale = dpi / 25.4;
+  const canvas = createCanvas(
+    Math.round(print.widthMm * scale),
+    Math.round(print.heightMm * scale)
+  );
+  const context = canvas.getContext("2d");
+  context.fillStyle = "#f4f3ef";
+  context.fillRect(0, 0, canvas.width, canvas.height);
+  for (const item of print.pdfItems) {
+    const art = createCanvas(item.art.width, item.art.height);
+    const data = art.getContext("2d").createImageData(item.art.width, item.art.height);
+    data.data.set(item.art.rgba);
+    art.getContext("2d").putImageData(data, 0, 0);
+    context.save();
+    context.translate(item.x * scale, item.y * scale);
+    context.rotate(item.rotation * Math.PI / 180);
+    context.drawImage(
+      art,
+      -item.widthMm / 2 * scale,
+      -item.heightMm / 2 * scale,
+      item.widthMm * scale,
+      item.heightMm * scale
+    );
+    context.restore();
+    context.strokeStyle = "#ff00ff";
+    context.lineWidth = Math.max(1, 0.2 * scale);
+    context.beginPath();
+    for (const loop of item.cut) {
+      for (const [i, [x, y]] of loop.entries())
+        if (i) context.lineTo(x * scale, y * scale);
+        else context.moveTo(x * scale, y * scale);
+      context.closePath();
+    }
+    context.stroke();
+  }
+  return canvas.toBuffer("image/png");
+}
+
+// src/sticker-cut.ts
+import sharp5 from "sharp";
+async function stickerPrintCut(design) {
+  const { png } = await renderBadge(design, { face: "front", person: {} });
+  const { data, info } = await sharp5(png).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+  const material = design.sticker ?? defaultStickerMaterial;
+  const cut = stickerCut(
+    new Uint8ClampedArray(data.buffer, data.byteOffset, data.length),
+    info.width,
+    info.height,
+    material.border,
+    material.widthMm
+  );
+  return { cut, svg: stickerCutSvg(cut) };
+}
+
 // src/sticker-material.ts
-import { readFile as readFile4, stat as stat3 } from "fs/promises";
+import { readFile as readFile5, stat as stat3 } from "fs/promises";
 import { basename as basename2 } from "path";
-import sharp4 from "sharp";
+import sharp6 from "sharp";
 async function bindStickerMap(design, layerId, path) {
   if (design.product !== "sticker") throw new InputError("Optical maps require a sticker.");
   const layer = design.front.layers.find((layer2) => layer2.id === layerId);
@@ -919,8 +1116,8 @@ async function bindStickerMap(design, layerId, path) {
   const info = await stat3(path);
   if (!info.isFile() || info.size > 4e6)
     throw new InputError("Use an optical image below 4 MB.");
-  const bytes = await readFile4(path);
-  const meta = await sharp4(bytes, { limitInputPixels: 16777216 }).metadata();
+  const bytes = await readFile5(path);
+  const meta = await sharp6(bytes, { limitInputPixels: 16777216 }).metadata();
   if (!meta.width || !meta.height || meta.width > 4096 || meta.height > 4096 || !["png", "webp"].includes(meta.format ?? ""))
     throw new InputError("Use an RGB PNG or WebP optical map up to 4096 \xD7 4096.");
   const asset = design.sticker?.effectMap?.asset ?? "optical-map";
@@ -949,10 +1146,10 @@ async function bindStickerMap(design, layerId, path) {
 import { spawn } from "child_process";
 import { createHash as createHash3 } from "crypto";
 import { existsSync as existsSync2 } from "fs";
-import { chmod, lstat, mkdir as mkdir2, mkdtemp, readFile as readFile5, rename as rename2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { chmod, lstat, mkdir as mkdir2, mkdtemp, readFile as readFile6, rename as rename2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
 import { homedir as homedir2, tmpdir as tmpdir2 } from "os";
-import { dirname as dirname2, extname as extname3, join as join3, resolve as resolve4 } from "path";
-import sharp5 from "sharp";
+import { dirname as dirname2, extname as extname3, join as join3, resolve as resolve5 } from "path";
+import sharp7 from "sharp";
 
 // src/wallet-release.json
 var wallet_release_default = {
@@ -982,7 +1179,7 @@ var WalletError = class extends Error {
 function installation() {
   const platform = `${process.platform}-${process.arch}`;
   const cache = process.env.MAKEABLES_WALLET_CACHE ?? join3(homedir2(), "Library", "Caches", "Makeables", "wallet");
-  const root = resolve4(cache, `${wallet_release_default.version}-${platform}`);
+  const root = resolve5(cache, `${wallet_release_default.version}-${platform}`);
   return { platform, root, executable: join3(root, "makeables-wallet", "makeables-wallet") };
 }
 async function execute(command, args, progress) {
@@ -1133,7 +1330,7 @@ async function companion() {
   return info.installed;
 }
 async function walletArtwork(file, side2 = "front") {
-  const input = resolve4(file);
+  const input = resolve5(file);
   const info = await lstat(input);
   if (!info.isFile() || info.size > 12e6)
     throw new InputError("Expected a local design or artwork file below 12 MB.");
@@ -1143,13 +1340,13 @@ async function walletArtwork(file, side2 = "front") {
     if (design.product !== "card") throw new InputError("Wallet artwork requires a card document.");
     source = (await renderBadge(design, { face: side2, person: {} })).png;
   } else {
-    source = await readFile5(input);
+    source = await readFile6(input);
     if (extname3(input).toLowerCase() === ".svg") {
       const result = checkSubmittedSvg(source.toString("utf8"));
       if (!result.ok) throw new InputError(result.error);
     }
   }
-  return sharp5(source, { limitInputPixels: 24e6, density: 144 }).rotate().resize(1536, 969, { fit: "contain", background: "#000000" }).flatten({ background: "#000000" }).toColourspace("srgb").png().toBuffer();
+  return sharp7(source, { limitInputPixels: 24e6, density: 144 }).rotate().resize(1536, 969, { fit: "contain", background: "#000000" }).flatten({ background: "#000000" }).toColourspace("srgb").png().toBuffer();
 }
 async function walletCommand(command, values, progress) {
   const need = (flag) => {
@@ -1200,7 +1397,7 @@ async function walletCommand(command, values, progress) {
     try {
       const raster = join3(work, "artwork.png");
       await writeFile2(raster, png, { mode: 384 });
-      const target = command === "wallet prep" ? resolve4(need("out")) : join3(work, "assets");
+      const target = command === "wallet prep" ? resolve5(need("out")) : join3(work, "assets");
       const prepared = await invoke(
         executable,
         ["prepare", "--file", raster, "--out", target],
@@ -1231,6 +1428,12 @@ var commands = [
   "layer add --file <design.json> --sticker <petdex:slug|path> [--side front|back]",
   "layer set --file <design.json> --id <layer> [--side front|back] [--x --y --rotation] [--params <json|@file>]",
   "layer remove --file <design.json> --id <layer> [--side front|back]",
+  "cut --file <sticker.json> [--out <cut.svg>] [--overwrite]",
+  "sheet new --type classic|small|single|clear|holographic --out <new-file> [--size a5|a6|10x15] [--name <title>]",
+  "sheet add --file <sheet.json> --sticker <sticker.json|style-id> [--width-mm <mm>]",
+  "sheet pack --file <sheet.json>",
+  "sheet check --file <sheet.json>",
+  "sheet export --file <sheet.json> --out <sheet.pdf> [--preview <proof.png>] [--overwrite]",
   "render --file <design.json|design.makeables.json> --out <png> [--side front|back] [--photo <image>] [--name --role --number] [--overwrite]",
   "validate --file <design.json|artwork.svg> [--out <preview.png>]",
   "new card --file <artwork.svg|image.png> --out <card.json> [--name <title>]",
@@ -1278,7 +1481,7 @@ function emit(data, next, human, json) {
   );
 }
 async function newPath(file) {
-  const path = resolve5(file);
+  const path = resolve6(file);
   try {
     await lstat2(path);
     throw new InputError(`File already exists: ${path}. Choose a new --out path.`);
@@ -1332,7 +1535,11 @@ async function run() {
       card: { type: "string" },
       backup: { type: "string" },
       device: { type: "string" },
-      seconds: { type: "string" }
+      seconds: { type: "string" },
+      type: { type: "string" },
+      size: { type: "string" },
+      "width-mm": { type: "string" },
+      preview: { type: "string" }
     }
   });
   const json = machineOutput(Boolean(values.json));
@@ -1423,6 +1630,12 @@ From a built checkout: npm run studio -- <command>`,
     "layer add": ["file", "sticker", "side"],
     "layer set": ["file", "id", "x", "y", "rotation", "side", "params"],
     "layer remove": ["file", "id", "side"],
+    cut: ["file", "out", "overwrite"],
+    "sheet new": ["type", "size", "name", "out"],
+    "sheet add": ["file", "sticker", "width-mm"],
+    "sheet pack": ["file"],
+    "sheet check": ["file"],
+    "sheet export": ["file", "out", "preview", "overwrite"],
     render: ["file", "out", "overwrite", "side", "photo", "name", "role", "number"],
     validate: ["file", "out"]
   };
@@ -1591,7 +1804,7 @@ Run makeables skills get core for setup.`,
   }
   if (command === "mcp") {
     try {
-      const { runMcp } = await import("./mcp-LXTO7XOO.js");
+      const { runMcp } = await import("./mcp-AOJ6UJSC.js");
       await runMcp(values.root ?? process.cwd());
     } catch (error) {
       process.stderr.write(
@@ -1650,7 +1863,7 @@ Keep this process running while you design.`,
         const info = await lstat2(path2);
         if (!info.isFile() || info.size > 12e6)
           throw new InputError("Expected a params file below 12 MB.");
-        params = JSON.parse(await readFile6(path2, "utf8"));
+        params = JSON.parse(await readFile7(path2, "utf8"));
       } else if (values.params) params = JSON.parse(values.params);
     }
     const result2 = await studioRequest(
@@ -1756,14 +1969,14 @@ ${dryRun ? "Dry run. No files changed." : "2 faces \xB7 editable layers"}`,
     return;
   }
   if (!values.file) throw new InputError("Supply --file to validate a document.");
-  const path = resolve5(values.file);
+  const path = resolve6(values.file);
   const handle = await open2(path, "r");
   let input;
   try {
     const info = await handle.stat();
     if (!info.isFile() || info.size > 2 * 1024 * 1024)
       throw new InputError("Expected a JSON file smaller than 2 MB.");
-    input = JSON.parse(await readFile6(handle, "utf8"));
+    input = JSON.parse(await readFile7(handle, "utf8"));
   } finally {
     await handle.close();
   }
@@ -1782,7 +1995,7 @@ Schema and layout constraints passed.`,
 }
 async function readParams(value) {
   return JSON.parse(
-    value.startsWith("@") ? await readFile6(resolve5(value.slice(1)), "utf8") : value
+    value.startsWith("@") ? await readFile7(resolve6(value.slice(1)), "utf8") : value
   );
 }
 async function cardCommand(command, values, json) {
@@ -1844,7 +2057,7 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
     return true;
   }
   if (command === "material map") {
-    const path = resolve5(need(file, "file"));
+    const path = resolve6(need(file, "file"));
     const next = await bindStickerMap(
       await readBadge(path),
       need(values.id, "id"),
@@ -1860,10 +2073,10 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
     return true;
   }
   if (command === "material set") {
-    const path = resolve5(need(file, "file"));
+    const path = resolve6(need(file, "file"));
     const design = await readBadge(path);
     const raw = need(values.params, "params");
-    const input = JSON.parse(raw.startsWith("@") ? await readFile6(raw.slice(1), "utf8") : raw);
+    const input = JSON.parse(raw.startsWith("@") ? await readFile7(raw.slice(1), "utf8") : raw);
     if (design.product === "sticker") {
       const patch2 = stickerMaterialSchema.partial().strict().safeParse(input);
       if (!patch2.success)
@@ -1947,7 +2160,7 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
       await readBadge(path),
       face,
       need(values.sticker, "sticker"),
-      dirname3(resolve5(path))
+      dirname3(resolve6(path))
     );
     await writeAtomic(path, `${JSON.stringify(design, null, 2)}
 `);
@@ -1960,16 +2173,153 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
     );
     return true;
   }
+  if (command.startsWith("sheet ")) {
+    const write = async (target, bytes) => {
+      const handle = await open2(target, values.overwrite ? "w" : "wx", 420);
+      try {
+        await handle.writeFile(bytes);
+      } finally {
+        await handle.close();
+      }
+    };
+    const save = (path2, sheet2) => writeAtomic(path2, `${JSON.stringify(sheet2, null, 2)}
+`);
+    const checkNext = (path2) => [
+      `makeables sheet check --file ${JSON.stringify(path2)}`,
+      `makeables sheet export --file ${JSON.stringify(path2)} --out sheet.pdf --preview proof.png`
+    ];
+    if (command === "sheet new") {
+      const sheet2 = newSheet(values.type, values.size, values.name);
+      const path2 = await newPath(need(values.out, "out"));
+      await writeAtomic(path2, `${JSON.stringify(sheet2, null, 2)}
+`, true);
+      emit(
+        { path: path2, sheet: sheet2 },
+        [`makeables sheet add --file ${JSON.stringify(path2)} --sticker <sticker.json|style-id>`],
+        `${style("Sheet ready", "1", !json)} ${sheet2.name} ${path2}`,
+        json
+      );
+      return true;
+    }
+    const path = need(file, "file");
+    const sheet = await readSheet(path);
+    if (command === "sheet add") {
+      const result = await addToSheet(sheet, need(values.sticker, "sticker"), values["width-mm"]);
+      await save(path, result.sheet);
+      emit(
+        {
+          item: { ...result.item, design: void 0 },
+          placed: result.placed,
+          stickers: result.sheet.items.length
+        },
+        result.placed ? checkNext(path) : [
+          `No free spot. Run makeables sheet pack --file ${JSON.stringify(path)} or choose a smaller --width-mm.`
+        ],
+        `${style(result.placed ? "Added" : "Added, overlapping", "1", !json)} ${result.item.id} (${result.item.widthMm} mm)`,
+        json
+      );
+      return true;
+    }
+    if (command === "sheet pack") {
+      const result = await packStickerSheet(sheet);
+      await save(path, result.sheet);
+      emit(
+        { stickers: result.sheet.items.length, missing: result.missing },
+        result.missing.length ? ["Remove stickers or make them smaller, then pack again.", ...checkNext(path)] : checkNext(path),
+        `${style("Packed", "1", !json)} ${result.sheet.items.length - result.missing.length}/${result.sheet.items.length}${result.missing.length ? `, no room for ${result.missing.join(", ")}` : ""}`,
+        json
+      );
+      return true;
+    }
+    const print = await checkSheet(sheet);
+    const report = sheetReport(print);
+    const lines = [
+      ...report.violations.map(
+        (v) => v.code === "too-close" ? `  error: ${v.ids.join(" and ")} are ${v.distanceMm.toFixed(1)} mm apart; the gap is ${v.gapMm} mm.` : `  error: ${v.ids[0]} crosses the ${v.marginMm} mm margin.`
+      ),
+      ...report.issues.map((issue) => `  ${issue.severity}: ${issue.id}: ${issue.message}`)
+    ];
+    const summary = `${style(report.printable ? "Printable" : "Not printable", "1", !json)} ${report.widthMm} \xD7 ${report.heightMm} mm, ${report.stickers} sticker${report.stickers === 1 ? "" : "s"}`;
+    if (command === "sheet check") {
+      emit(
+        report,
+        report.printable ? checkNext(path).slice(1) : ["Fix the errors, then check again."],
+        [summary, ...lines].join("\n"),
+        json
+      );
+      return true;
+    }
+    if (command === "sheet export") {
+      if (!report.printable)
+        throw new InputError(
+          `The sheet is not printable. Run makeables sheet check --file ${JSON.stringify(path)}.`
+        );
+      const out = resolve6(need(values.out, "out"));
+      if (!out.endsWith(".pdf")) throw new InputError("--out must end in .pdf.");
+      const preview = typeof values.preview === "string" ? resolve6(values.preview) : void 0;
+      if (preview && !preview.endsWith(".png")) throw new InputError("--preview must end in .png.");
+      const targets = [out, ...preview ? [preview] : []];
+      if (!values.overwrite) for (const target of targets) await newPath(target);
+      await write(out, await exportSheetPdf(sheet, print));
+      if (preview) await write(preview, sheetPreviewPng(print));
+      emit(
+        { ...report, path: out, ...preview ? { preview } : {} },
+        ["Send the PDF to the printer. Confirm its spot names and template before the first run."],
+        [`${summary} ${out}${preview ? ` ${preview}` : ""}`, ...lines].join("\n"),
+        json
+      );
+      return true;
+    }
+  }
+  if (command === "cut") {
+    const design = await readBadge(need(file, "file"));
+    if (design.product !== "sticker") throw new InputError("cut applies to sticker designs.");
+    const out = typeof values.out === "string" ? resolve6(values.out) : void 0;
+    if (out && !out.endsWith(".svg")) throw new InputError("--out must end in .svg.");
+    const target = out && (values.overwrite ? out : await newPath(out));
+    const { cut, svg } = await stickerPrintCut(design);
+    if (target) {
+      const handle = await open2(target, values.overwrite ? "w" : "wx", 420);
+      try {
+        await handle.writeFile(svg);
+      } finally {
+        await handle.close();
+      }
+    }
+    const printable = !cut.issues.some((issue) => issue.severity === "error");
+    const size = `${cut.widthMm.toFixed(1)} \xD7 ${cut.heightMm.toFixed(1)} mm, border ${cut.borderMm.toFixed(2)} mm`;
+    emit(
+      {
+        ...target ? { path: target } : {},
+        printable,
+        widthMm: cut.widthMm,
+        heightMm: cut.heightMm,
+        borderMm: cut.borderMm,
+        paths: cut.paths.length,
+        issues: cut.issues
+      },
+      [
+        ...cut.issues.map((issue) => issue.message),
+        `Set the printed size with material set --params '{"widthMm":75}'.`
+      ],
+      [
+        `${style(printable ? "Printable" : "Not printable", "1", !json)} ${size}, ${cut.paths.length} cut path${cut.paths.length === 1 ? "" : "s"}${target ? ` ${target}` : ""}`,
+        ...cut.issues.map((issue) => `  ${issue.severity}: ${issue.message}`)
+      ].join("\n"),
+      json
+    );
+    return true;
+  }
   if (command === "render") {
     const path = need(file, "file");
-    const out = resolve5(need(values.out, "out"));
+    const out = resolve6(need(values.out, "out"));
     if (!out.endsWith(".png")) throw new InputError("--out must end in .png.");
     const target = values.overwrite ? out : await newPath(out);
     const number = values.number === void 0 ? void 0 : Number(values.number);
     if (number !== void 0 && !Number.isInteger(number))
       throw new InputError("--number must be an integer.");
     const face = side(values.side);
-    const value = JSON.parse(await readFile6(resolve5(path), "utf8"));
+    const value = JSON.parse(await readFile7(resolve6(path), "utf8"));
     const pkg = value?.format === "makeables-package" ? await readPackageJson(value) : void 0;
     if (pkg && ["photo", "name", "role", "number"].some((key) => values[key] !== void 0))
       throw new InputError(
@@ -2031,13 +2381,13 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
     return true;
   }
   if (command === "validate") {
-    const path = resolve5(need(file, "file"));
+    const path = resolve6(need(file, "file"));
     if (extname4(path).toLowerCase() === ".svg") {
-      const source = await readFile6(path, "utf8");
+      const source = await readFile7(path, "utf8");
       const result2 = checkSubmittedSvg(source);
       if (!result2.ok) throw new InputError(result2.error);
       const preview = values.out ? await newPath(need(values.out, "out")) : void 0;
-      if (preview) await sharp6(Buffer.from(result2.svg)).png().toFile(preview);
+      if (preview) await sharp8(Buffer.from(result2.svg)).png().toFile(preview);
       emit(
         {
           valid: true,
@@ -2054,7 +2404,7 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
       return true;
     }
     if (values.out) throw new InputError("--out is only used to preview SVG validation.");
-    const input = JSON.parse(await readFile6(path, "utf8"));
+    const input = JSON.parse(await readFile7(path, "utf8"));
     const result = badgeDesignSchema.safeParse(input);
     if (!result.success)
       throw new InputError(

package/dist/{mcp-LXTO7XOO.js → mcp-AOJ6UJSC.js}

@@ -15,7 +15,7 @@ import {
   stickerStyles,
   version,
   writeAtomic
-} from "./chunk-4AJQBAFB.js";
+} from "./chunk-QJHEOZGN.js";
 
 // src/mcp.ts
 import { readFile as readFile2 } from "fs/promises";
@@ -239,6 +239,7 @@ async function createMakeablesMcp(root, html) {
         guide: z.enum([
           "core",
           "cards",
+          "card-art-direction",
           "badges",
           "stickers",
           "sticker-art-direction",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "makeables",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Create editable cards, badges and stickers with layered designs, live materials and your coding agent.",
   "homepage": "https://makeables.dev",
   "repository": {
@@ -51,9 +51,9 @@
     "@types/proper-lockfile": "4.1.4",
     "tsup": "^8.4.0",
     "typescript": "^5.8.3",
-    "@makeables/testing": "0.0.0",
+    "@makeables/design": "0.0.1",
     "@makeables/renderer": "0.0.1",
-    "@makeables/design": "0.0.1"
+    "@makeables/testing": "0.0.0"
   },
   "engines": {
     "node": ">=22"