makeables 0.6.0 → 0.8.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-NOES67KG.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,24 +1146,24 @@ 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 = {
-  version: "0.2.0",
+  version: "0.3.0",
   protocol: 1,
   repository: "crafter-station/makeables-community",
   platforms: {
     "darwin-arm64": {
-      asset: "makeables-wallet-0.2.0-darwin-arm64.tar.gz",
-      sha256: "5c51f0bd17c80875c12d5913845f368d22501e0a37b03ce8cbcbdc17a0433c37"
+      asset: "makeables-wallet-0.3.0-darwin-arm64.tar.gz",
+      sha256: "ebd275228d84c75836820e12a999bcaa7e586dfbb215ba06882ae161a2e4a09f"
     },
     "darwin-x64": {
-      asset: "makeables-wallet-0.2.0-darwin-x64.tar.gz",
-      sha256: "39705b13b59034fa04872433ab4fa7cd04f6c5d1714df2a41698b316afcf95d8"
+      asset: "makeables-wallet-0.3.0-darwin-x64.tar.gz",
+      sha256: "c5bd51863895e6612be838b5023f7a1322424568ea4249651125930a66ff4ccb"
     }
   }
 };
@@ -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) {
@@ -1022,13 +1219,24 @@ async function execute(command, args, progress) {
   });
 }
 async function invoke(executable, args, progress) {
-  const result = JSON.parse(await execute(executable, args, progress));
+  let result;
+  try {
+    result = JSON.parse(await execute(executable, args, progress));
+    if (!result || typeof result.ok !== "boolean") throw new Error("Missing companion result.");
+  } catch {
+    throw new WalletError({
+      code: "WALLET_COMPANION_FAILED",
+      message: "The Wallet companion ended without a valid receipt. Inspect wallet backups and doctor before another device operation."
+    });
+  }
   if (!result.ok) {
-    if (result.error?.code === "INVALID_INPUT")
-      throw new InputError(result.error.message ?? "Invalid Wallet input.");
     throw new WalletError(result.error ?? {});
   }
-  if (!result.data) throw new Error("Wallet companion returned no receipt.");
+  if (!result.data || typeof result.data !== "object" || Array.isArray(result.data))
+    throw new WalletError({
+      code: "WALLET_COMPANION_FAILED",
+      message: "The Wallet companion returned no receipt. Inspect wallet backups before another device operation."
+    });
   return result.data;
 }
 async function walletDoctor() {
@@ -1081,6 +1289,7 @@ async function setupWallet(progress) {
   const url = `https://github.com/${wallet_release_default.repository}/releases/download/wallet-v${wallet_release_default.version}/${artifact.asset}`;
   progress?.({
     event: "wallet_progress",
+    phase: "setup",
     message: `Downloading the Wallet companion ${wallet_release_default.version} for ${platform}.`
   });
   const response = await fetch(url, { signal: AbortSignal.timeout(18e4) });
@@ -1124,16 +1333,8 @@ async function setupWallet(progress) {
   }
   return walletDoctor();
 }
-async function companion() {
-  const info = await walletDoctor();
-  if (!info.ready || !("installed" in info) || typeof info.installed !== "string")
-    throw new InputError(
-      "Run makeables wallet setup first. It installs the macOS companion without a source checkout."
-    );
-  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,81 +1344,276 @@ 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 preparedArtwork(directory) {
+  const path = resolve5(directory);
+  if (!(await lstat(path)).isDirectory())
+    throw new InputError("--assets must be a prepared artwork directory.");
+  for (const name of [
+    "cardBackgroundCombined@3x.png",
+    "cardBackgroundCombined@2x.png",
+    "cardBackgroundCombined.pdf"
+  ]) {
+    const file = join3(path, name);
+    const info = await lstat(file);
+    if (!info.isFile() || info.size === 0 || info.size > 16 * 1024 * 1024)
+      throw new InputError(`Invalid prepared asset: ${name}. Run wallet prep again.`);
+    const signature = Buffer.from(name.endsWith(".pdf") ? "%PDF-" : "\x89PNG\r\n\n", "latin1");
+    if (!(await readFile6(file)).subarray(0, signature.length).equals(signature))
+      throw new InputError(`Invalid prepared asset: ${name}. Run wallet prep again.`);
+  }
+  return { path, preview: join3(path, "cardBackgroundCombined@3x.png") };
 }
 async function walletCommand(command, values, progress) {
+  const started = performance.now();
+  const elapsed = () => Math.round(performance.now() - started);
+  let latestPhase;
+  const report = (phase, message) => {
+    latestPhase = phase;
+    progress({
+      event: "wallet_progress",
+      phase,
+      message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      elapsedMs: elapsed()
+    });
+  };
+  const forward = (data) => {
+    if (data && typeof data === "object") {
+      if ("phase" in data && typeof data.phase === "string") latestPhase = data.phase;
+      progress({
+        ...data,
+        phase: latestPhase,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        elapsedMs: elapsed()
+      });
+    }
+  };
   const need = (flag) => {
     const value = values[flag];
     if (typeof value !== "string" || !value) throw new InputError(`Supply --${flag}.`);
     return value;
   };
   if (command === "wallet doctor") return walletDoctor();
-  if (command === "wallet setup") return setupWallet(progress);
-  if (command === "wallet apply" || command === "wallet restore" || command === "wallet recover") {
+  if (command === "wallet setup") return setupWallet(forward);
+  const installing = command === "wallet install";
+  const applying = command === "wallet apply" || installing && Boolean(values.card || values.backup);
+  if (applying || command === "wallet restore" || command === "wallet recover") {
     if (!values.yes)
       throw new InputError(
         "Use --yes only after the user requests this operation on the selected card."
       );
   }
-  if (command === "wallet apply" && Boolean(values.card) === Boolean(values.backup))
+  if (applying && Boolean(values.card) === Boolean(values.backup))
     throw new InputError("Choose exactly one --card selection or --backup original.");
-  const executable = await companion();
+  if (installing && values.yes && !applying)
+    throw new InputError("Select an explicit --card or --backup before using --yes.");
+  if (installing && applying && (values.device || values.seconds))
+    throw new InputError(
+      "--device and --seconds are for selection; --card or --backup already binds the target."
+    );
+  if (values.seconds && (!/^\d+$/.test(String(values.seconds)) || Number(values.seconds) < 1 || Number(values.seconds) > 300))
+    throw new InputError("--seconds must be between 1 and 300.");
+  if (installing || applying) {
+    if (Boolean(values.file) === Boolean(values.assets))
+      throw new InputError("Supply exactly one --file artwork or --assets prepared directory.");
+    if (values.assets && values.side)
+      throw new InputError("--side applies to --file, not already prepared --assets.");
+  }
+  if (values.side && !["front", "back"].includes(String(values.side)))
+    throw new InputError("--side must be front or back.");
+  if (command === "wallet prep") {
+    need("file");
+    need("out");
+  }
+  if (command === "wallet restore") need("backup");
+  const existing = values.assets ? await preparedArtwork(need("assets")) : void 0;
+  if (installing) report("setup", "Checking the Wallet companion.");
+  const info = installing ? await setupWallet(forward) : await walletDoctor();
+  if (!info.ready || !("installed" in info) || typeof info.installed !== "string")
+    throw new InputError("Run makeables wallet setup first.");
+  const executable = info.installed;
+  const capabilities = "capabilities" in info && Array.isArray(info.capabilities) ? info.capabilities : [];
   if (command === "wallet list") {
     const args = ["list"];
     for (const flag of ["device", "seconds"])
       if (typeof values[flag] === "string") args.push(`--${flag}`, String(values[flag]));
-    return invoke(executable, args, progress);
+    if (values.first) {
+      if (!capabilities.includes("first-selection"))
+        throw new InputError(
+          "This companion needs an update for --first. Omit --first for a full scan."
+        );
+      args.push("--first");
+    }
+    return invoke(executable, args, forward);
   }
   if (command === "wallet backups") {
     return invoke(
       executable,
       ["backups", ...values.backup ? ["--backup", need("backup")] : []],
-      progress
+      forward
     );
   }
   if (command === "wallet recover") {
     return invoke(
       executable,
       ["recover", "--backup", need("backup"), "--device", need("device"), "--yes"],
-      progress
+      forward
     );
   }
   if (command === "wallet restore") {
-    return invoke(executable, ["restore", "--backup", need("backup"), "--yes"], progress);
-  }
-  if (command === "wallet prep" || command === "wallet apply") {
-    const file = need("file");
-    if (values.side && !["front", "back"].includes(String(values.side)))
-      throw new InputError("--side must be front or back.");
-    const png = await walletArtwork(file, values.side === "back" ? "back" : "front");
-    const work = await mkdtemp(join3(tmpdir2(), "makeables-wallet-"));
+    report("preflight", "Checking the original artwork backup and connected iPhone.");
     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 prepared = await invoke(
+      const result = await invoke(
         executable,
-        ["prepare", "--file", raster, "--out", target],
-        progress
+        ["restore", "--backup", need("backup"), "--yes"],
+        forward
       );
+      return { ...result, elapsedMs: elapsed() };
+    } catch (error) {
+      if (error instanceof WalletError)
+        throw new WalletError({
+          ...error.details,
+          phase: error.details.phase ?? latestPhase ?? "preflight",
+          deviceWriteAttempted: error.details.deviceWriteAttempted ?? true,
+          nextAction: error.details.nextAction ?? "inspect-backups"
+        });
+      throw error;
+    }
+  }
+  if (command === "wallet prep" || applying || installing) {
+    const work = await mkdtemp(join3(tmpdir2(), "makeables-wallet-"));
+    let phase = "prepare";
+    let deviceWriteAttempted = false;
+    let persistent;
+    let prepared;
+    try {
+      let target;
+      if (existing) {
+        target = resolve5(need("assets"));
+        prepared = existing;
+      } else {
+        report("prepare", "Preparing the complete card artwork.");
+        const png = await walletArtwork(need("file"), values.side === "back" ? "back" : "front");
+        const raster = join3(work, "artwork.png");
+        await writeFile2(raster, png, { mode: 384 });
+        if (command === "wallet prep") {
+          target = resolve5(need("out"));
+        } else if (installing && !applying) {
+          const root = join3(
+            process.env.MAKEABLES_WALLET_HOME ?? join3(homedir2(), "Library", "Application Support", "Makeables", "Wallet"),
+            "prepared"
+          );
+          await mkdir2(root, { recursive: true, mode: 448 });
+          if ((await lstat(root)).isSymbolicLink())
+            throw new InputError("Prepared artwork storage cannot be a symbolic link.");
+          persistent = await mkdtemp(join3(root, "install-"));
+          target = join3(persistent, "assets");
+        } else {
+          target = join3(work, "assets");
+        }
+        prepared = await invoke(
+          executable,
+          ["prepare", "--file", raster, "--out", target],
+          forward
+        );
+        await preparedArtwork(target);
+      }
       if (command === "wallet prep") return prepared;
-      progress({ event: "wallet_progress", message: "Full artwork rendered and prepared." });
+      if (installing && !applying) {
+        phase = "selection";
+        report("selection", "Artwork is ready. Open Wallet and tap the card to customize.");
+        const args2 = ["list"];
+        for (const flag of ["device", "seconds"])
+          if (typeof values[flag] === "string") args2.push(`--${flag}`, String(values[flag]));
+        if (capabilities.includes("first-selection")) args2.push("--first");
+        const selection = await invoke(executable, args2, forward);
+        const hasCards = Array.isArray(selection.cards) && selection.cards.length > 0;
+        const status = selection.needsDevice ? "needs-device" : hasCards ? "needs-selection" : "needs-card";
+        return {
+          ...selection,
+          status,
+          assets: target,
+          preview: prepared.preview,
+          deviceWriteAttempted: false,
+          nextAction: selection.needsDevice ? "select-device" : hasCards ? "confirm-card" : "tap-card",
+          next: {
+            command: "wallet install",
+            args: ["--assets", target],
+            required: selection.needsDevice ? ["device"] : hasCards ? ["card", "yes"] : []
+          },
+          elapsedMs: elapsed()
+        };
+      }
+      report("preflight", "Artwork is ready. Keep the selected iPhone connected.");
       const args = ["apply", "--assets", target, "--yes"];
       if (values.card) args.push("--card", need("card"));
       if (values.backup) args.push("--backup", need("backup"));
-      return invoke(executable, args, progress);
+      phase = "apply";
+      deviceWriteAttempted = true;
+      const result = await invoke(executable, args, forward);
+      return { ...result, elapsedMs: elapsed() };
+    } catch (error) {
+      if (error instanceof WalletError) {
+        throw new WalletError({
+          ...error.details,
+          phase: error.details.phase ?? latestPhase ?? phase,
+          deviceWriteAttempted: error.details.deviceWriteAttempted ?? deviceWriteAttempted,
+          ...phase === "selection" && prepared ? {
+            assets: String(prepared.path),
+            preview: String(prepared.preview),
+            nextAction: "retry-selection"
+          } : {}
+        });
+      }
+      throw error;
     } finally {
       await rm2(work, { recursive: true, force: true });
+      if (persistent && phase === "prepare") await rm2(persistent, { recursive: true, force: true });
     }
   }
   throw new InputError("Unknown Wallet command.");
 }
+function walletSummary(result) {
+  if (result.status === "restored") {
+    const seconds = typeof result.elapsedMs === "number" ? ` in ${(result.elapsedMs / 1e3).toFixed(1)}s` : "";
+    return [
+      `Original Wallet artwork restored${seconds}.`,
+      ...result.backupVerified ? ["Original backup preserved and verified."] : [],
+      ...typeof result.backup === "string" ? [`Backup: ${result.backup}`] : [],
+      "Force-close Wallet, reopen it and check the original design."
+    ].join("\n");
+  }
+  if (result.status === "complete") {
+    const seconds = typeof result.elapsedMs === "number" ? ` in ${(result.elapsedMs / 1e3).toFixed(1)}s` : "";
+    return [
+      `Wallet artwork installed${seconds}.`,
+      result.backupVerified ? "Original artwork backup saved and verified." : "Original artwork backup saved.",
+      ...typeof result.backup === "string" ? [`Backup: ${result.backup}`] : [],
+      typeof result.refresh === "string" ? result.refresh : "Close and reopen Wallet to see the design."
+    ].join("\n");
+  }
+  if (["needs-device", "needs-selection", "needs-card"].includes(String(result.status)))
+    return [
+      "Artwork prepared. No card has been changed.",
+      `Preview: ${String(result.preview)}`,
+      result.status === "needs-device" ? "Connect an unlocked iPhone or choose a listed device." : result.status === "needs-card" ? "No card was detected. Open Wallet, tap the card, and repeat using the prepared assets." : "Confirm which observed card you want to customize, then use its selection handle with --yes.",
+      JSON.stringify(
+        { assets: result.assets, devices: result.devices, cards: result.cards },
+        null,
+        2
+      ),
+      `Continue: makeables wallet install --assets '${String(result.assets).replaceAll("'", "'\\''")}'${result.status === "needs-selection" ? " --card <selection> --yes" : result.status === "needs-device" ? " --device <selection>" : ""}`
+    ].join("\n");
+  return JSON.stringify(result, null, 2);
+}
 
 // src/cli.ts
 var commands = [
@@ -1231,6 +1627,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>]",
@@ -1239,9 +1641,10 @@ var commands = [
   ),
   "wallet setup",
   "wallet doctor",
-  "wallet list [--device <selection>] [--seconds 45]",
+  "wallet install (--file <artwork> | --assets <directory>) [(--card <selection> | --backup <id|path>) --yes]",
+  "wallet list [--device <selection>] [--seconds 45] [--first]",
   "wallet prep --file <card.json|artwork.svg|image.png> --out <new-directory> [--side front|back]",
-  "wallet apply --file <artwork> --card <selection> | --backup <id|path> --yes",
+  "wallet apply (--file <artwork> | --assets <directory>) (--card <selection> | --backup <id|path>) --yes",
   "wallet restore --backup <id|path> --yes",
   "wallet backups [--backup <id|path>]",
   "wallet recover --backup <transaction-path> --device <selection> --yes",
@@ -1278,7 +1681,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 +1735,13 @@ async function run() {
       card: { type: "string" },
       backup: { type: "string" },
       device: { type: "string" },
-      seconds: { type: "string" }
+      seconds: { type: "string" },
+      assets: { type: "string" },
+      first: { type: "boolean" },
+      type: { type: "string" },
+      size: { type: "string" },
+      "width-mm": { type: "string" },
+      preview: { type: "string" }
     }
   });
   const json = machineOutput(Boolean(values.json));
@@ -1366,9 +1775,10 @@ From a built checkout: npm run studio -- <command>`,
     ),
     "wallet setup": [],
     "wallet doctor": [],
-    "wallet list": ["device", "seconds"],
+    "wallet install": ["file", "assets", "card", "backup", "side", "device", "seconds", "yes"],
+    "wallet list": ["device", "seconds", "first"],
     "wallet prep": ["file", "out", "side"],
-    "wallet apply": ["file", "card", "backup", "side", "yes"],
+    "wallet apply": ["file", "assets", "card", "backup", "side", "yes"],
     "wallet restore": ["backup", "yes"],
     "wallet backups": ["backup"],
     "wallet recover": ["backup", "device", "yes"],
@@ -1423,6 +1833,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"]
   };
@@ -1435,8 +1851,16 @@ From a built checkout: npm run studio -- <command>`,
   if (values.product && !["card", "badge", "sticker"].includes(values.product))
     throw new InputError("--product must be card, badge or sticker.");
   if (command.startsWith("wallet ")) {
-    const result2 = await walletCommand(command, values, progress);
-    emit(result2, ["makeables skills get wallet"], JSON.stringify(result2, null, 2), json);
+    const walletProgress = (data) => {
+      if (json) return progress(data);
+      if (data && typeof data === "object" && "message" in data) {
+        const phase = "phase" in data ? `[${String(data.phase)}] ` : "";
+        process.stderr.write(`${phase}${String(data.message)}
+`);
+      }
+    };
+    const result2 = await walletCommand(command, values, walletProgress);
+    emit(result2, ["makeables skills get wallet"], walletSummary(result2), json);
     return;
   }
   if (command.startsWith("image ") && imageTools.some((tool) => command === `image ${tool}`)) {
@@ -1591,7 +2015,7 @@ Run makeables skills get core for setup.`,
   }
   if (command === "mcp") {
     try {
-      const { runMcp } = await import("./mcp-LXTO7XOO.js");
+      const { runMcp } = await import("./mcp-54KV55QM.js");
       await runMcp(values.root ?? process.cwd());
     } catch (error) {
       process.stderr.write(
@@ -1650,7 +2074,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 +2180,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 +2206,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 +2268,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 +2284,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 +2371,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 +2384,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 +2592,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 +2615,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(
@@ -2072,7 +2633,7 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
   return false;
 }
 run().catch((error) => {
-  const userError = error instanceof InputError || error instanceof SyntaxError || [
+  const userError = error instanceof InputError || error instanceof WalletError && error.details.code === "INVALID_INPUT" || error instanceof SyntaxError || [
     "ERR_PARSE_ARGS_UNKNOWN_OPTION",
     "ERR_PARSE_ARGS_INVALID_OPTION_VALUE",
     "ERR_PARSE_ARGS_UNEXPECTED_POSITIONAL",