makeables 0.9.0 → 0.10.0

package/dist/cli.js

@@ -1,4 +1,24 @@
 #!/usr/bin/env node
+import {
+  addKitMember,
+  addToSheet,
+  checkSheet,
+  exportKit,
+  exportSheetPdf,
+  importKit,
+  kitCover,
+  newSheet,
+  packStickerSheet,
+  readKit,
+  readSheet,
+  sheetPreviewPng,
+  sheetReport
+} from "./chunk-TRIRNJSG.js";
+import {
+  getSkill,
+  skills,
+  version
+} from "./chunk-SZTWKHNA.js";
 import {
   CloudError,
   InputError,
@@ -9,61 +29,53 @@ import {
   cardStyles,
   checkSubmittedSvg,
   connectAccount,
-  createStickerSheet,
+  createStickerDesign,
   defaultStickerMaterial,
   designCatalog,
   designProfile,
   draftFromPackage,
   findCardStyle,
   findDesign,
-  getSkill,
   hashBytes,
   jsonBytes,
+  kitDocumentSchema,
   listCardDesigns,
   logout,
   newBadge,
   newCard,
   openBrowser,
-  packSheet,
   packageJson,
-  placeNear,
-  prepareSheetPrint,
   readBadge,
   readPackageJson,
   readPackageZip,
   readSubmission,
   removeBadgeLayer,
   renderBadge,
+  renderDraftFace,
   setBadgeLayer,
-  sheetPrintPdf,
-  sheetSizes,
-  sheetSpec,
-  sheetTypeIds,
-  sheetTypes,
   side,
-  skills,
   startStudio,
   stickerCut,
   stickerCutSvg,
   stickerMaterialSchema,
-  stickerSheetSchema,
   stickerStyles,
   studioRequest,
   submitDesign,
   summarizeBadgeLayers,
   svgNodeSchema,
   svgNodeXml,
-  version,
   writeAtomic
-} from "./chunk-RFIQNWNF.js";
+} from "./chunk-G6OTYITI.js";
 
 // src/cli.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { constants as constants3 } from "fs";
-import { access, lstat as lstat4, open as open3, readFile as readFile8 } from "fs/promises";
-import { dirname as dirname4, extname as extname4, resolve as resolve7 } from "path";
+import { randomUUID as randomUUID3 } from "crypto";
+import { constants as constants4 } from "fs";
+import { access, lstat as lstat4, open as open4, readFile as readFile7 } from "fs/promises";
+import { dirname as dirname5, extname as extname4, resolve as resolve7 } from "path";
 import { parseArgs } from "util";
 import sharp8 from "sharp";
+import { ZodError } from "zod";
 import { zodToJsonSchema } from "zod-to-json-schema";
 
 // src/card-import.ts
@@ -274,6 +286,199 @@ async function extractImage(file, out) {
   return { path, bytes: bytes.length };
 }
 
+// src/kit-extract.ts
+import { mkdir, mkdtemp, rename, rm, writeFile as writeFile2 } from "fs/promises";
+import { dirname, join, resolve as resolve2 } from "path";
+import sharp2 from "sharp";
+import { z } from "zod";
+var regionSchema = z.object({
+  x: z.number().int().nonnegative(),
+  y: z.number().int().nonnegative(),
+  w: z.number().int().positive(),
+  h: z.number().int().positive(),
+  name: z.string().trim().min(1).max(60).optional()
+}).strict();
+var optionsSchema = z.object({
+  name: z.string().trim().min(1).max(60).default("Artwork kit"),
+  gap: z.number().int().min(0).max(40).default(12),
+  tolerance: z.number().int().min(0).max(150).default(40),
+  minArea: z.number().int().min(1).max(1e5).default(64),
+  regions: z.array(regionSchema).min(1).max(24).optional()
+}).strict();
+function dilate(mask, w, h, radius) {
+  const horizontal = new Uint8Array(mask.length), out = new Uint8Array(mask.length);
+  for (let y = 0; y < h; y++) {
+    let count = 0;
+    for (let x = -radius; x < w; x++) {
+      if (x + radius < w) count += mask[y * w + x + radius];
+      if (x - radius - 1 >= 0) count -= mask[y * w + x - radius - 1];
+      if (x >= 0) horizontal[y * w + x] = count > 0 ? 1 : 0;
+    }
+  }
+  for (let x = 0; x < w; x++) {
+    let count = 0;
+    for (let y = -radius; y < h; y++) {
+      if (y + radius < h) count += horizontal[(y + radius) * w + x];
+      if (y - radius - 1 >= 0) count -= horizontal[(y - radius - 1) * w + x];
+      if (y >= 0) out[y * w + x] = count > 0 ? 1 : 0;
+    }
+  }
+  return out;
+}
+function artworkRegions(foreground, w, h, gap, minArea) {
+  const mask = dilate(foreground, w, h, gap), queue = new Int32Array(mask.length);
+  const regions = [];
+  for (let start = 0; start < mask.length; start++) {
+    if (!mask[start]) continue;
+    let head = 0, tail = 1, x0 = w, y0 = h, x1 = -1, y1 = -1, area = 0;
+    queue[0] = start;
+    mask[start] = 0;
+    while (head < tail) {
+      const p = queue[head++], x = p % w, y = Math.floor(p / w);
+      if (foreground[p]) {
+        x0 = Math.min(x0, x);
+        x1 = Math.max(x1, x);
+        y0 = Math.min(y0, y);
+        y1 = Math.max(y1, y);
+        area++;
+      }
+      for (const n of [
+        x > 0 ? p - 1 : -1,
+        x < w - 1 ? p + 1 : -1,
+        y > 0 ? p - w : -1,
+        y < h - 1 ? p + w : -1
+      ])
+        if (n >= 0 && mask[n]) {
+          mask[n] = 0;
+          queue[tail++] = n;
+        }
+    }
+    if (area >= minArea)
+      regions.push({
+        x: Math.max(0, x0 - 2),
+        y: Math.max(0, y0 - 2),
+        w: Math.min(w - 1, x1 + 2) - Math.max(0, x0 - 2) + 1,
+        h: Math.min(h - 1, y1 + 2) - Math.max(0, y0 - 2) + 1
+      });
+  }
+  return regions.sort((a, b) => a.y - b.y || a.x - b.x);
+}
+function removeOuterBackground(rgba, w, h, background, tolerance) {
+  const result = new Uint8Array(rgba), seen = new Uint8Array(w * h), queue = new Int32Array(w * h);
+  let head = 0, tail = 0;
+  const add = (p) => {
+    if (seen[p]) return;
+    seen[p] = 1;
+    if (rgba[p * 4 + 3] < 16 || [0, 1, 2].reduce((n, c) => n + Math.abs(rgba[p * 4 + c] - background[c]), 0) <= tolerance)
+      queue[tail++] = p;
+  };
+  for (let x = 0; x < w; x++) {
+    add(x);
+    add((h - 1) * w + x);
+  }
+  for (let y = 0; y < h; y++) {
+    add(y * w);
+    add(y * w + w - 1);
+  }
+  while (head < tail) {
+    const p = queue[head++], x = p % w, y = Math.floor(p / w);
+    result[p * 4 + 3] = 0;
+    if (x) add(p - 1);
+    if (x < w - 1) add(p + 1);
+    if (y) add(p - w);
+    if (y < h - 1) add(p + w);
+  }
+  return result;
+}
+async function extractKit(file, out, input) {
+  const options = optionsSchema.parse(input);
+  const { data, info } = await sharp2(resolve2(file), { limitInputPixels: 24e6 }).rotate().ensureAlpha().toColourspace("srgb").raw().toBuffer({ resolveWithObject: true });
+  const w = info.width, h = info.height;
+  const corners = [0, w - 1, (h - 1) * w, w * h - 1];
+  const transparentBackground = corners.every((p) => data[p * 4 + 3] < 16);
+  const background = [0, 1, 2].map(
+    (c) => Math.round(corners.reduce((n, p) => n + data[p * 4 + c], 0) / 4)
+  );
+  const foreground = new Uint8Array(w * h);
+  for (let p = 0; p < foreground.length; p++)
+    foreground[p] = data[p * 4 + 3] >= 16 && (transparentBackground || [0, 1, 2].reduce((n, c) => n + Math.abs(data[p * 4 + c] - background[c]), 0) > options.tolerance) ? 1 : 0;
+  const regions = options.regions ?? artworkRegions(foreground, w, h, options.gap, options.minArea);
+  if (!regions.length || regions.length > 24)
+    throw new InputError("Choose 1\u201324 regions using --params, or adjust gap/minArea.");
+  if (regions.some((r) => r.x + r.w > w || r.y + r.h > h))
+    throw new InputError("Every region must fit inside the image.");
+  const target = resolve2(out), temporary = await mkdtemp(join(dirname(target), ".makeables-extract-"));
+  try {
+    await mkdir(join(temporary, "pieces"));
+    const kit = {
+      format: "makeables-kit",
+      version: 1,
+      name: options.name,
+      items: [],
+      sheets: []
+    };
+    const views = [];
+    for (const [index, region] of regions.entries()) {
+      const id = `piece-${String(index + 1).padStart(2, "0")}`, name = region.name ?? `Piece ${index + 1}`;
+      const crop = await sharp2(data, { raw: { width: w, height: h, channels: 4 } }).extract({ left: region.x, top: region.y, width: region.w, height: region.h }).raw().toBuffer();
+      const pixels = transparentBackground ? crop : removeOuterBackground(crop, region.w, region.h, background, options.tolerance);
+      const png = await sharp2(pixels, { raw: { width: region.w, height: region.h, channels: 4 } }).png().toBuffer();
+      const design = createStickerDesign();
+      design.sticker = { ...defaultStickerMaterial, finish: "vinyl", sparkle: 0, holography: 0 };
+      design.name = name;
+      design.source = id;
+      design.assets = {
+        artwork: {
+          source: "image",
+          name,
+          data: `data:image/png;base64,${png.toString("base64")}`,
+          sourcePixels: { width: region.w, height: region.h }
+        }
+      };
+      design.front = {
+        background: "#00000000",
+        layers: [
+          {
+            id: "artwork",
+            kind: "image",
+            asset: "artwork",
+            name,
+            x: 64,
+            y: 64,
+            w: 896,
+            h: 896,
+            fit: "contain",
+            opacity: 1,
+            radius: 0
+          }
+        ]
+      };
+      design.back = { background: "#00000000", layers: [] };
+      await writeFile2(
+        join(temporary, `pieces/${id}.json`),
+        JSON.stringify(badgeDesignSchema.parse(design), null, 2)
+      );
+      kit.items.push({ id, file: `pieces/${id}.json` });
+      views.push({ name, bytes: png });
+    }
+    await writeFile2(join(temporary, "kit.json"), JSON.stringify(kit, null, 2));
+    await writeFile2(join(temporary, "contact.png"), await kitCover(options.name, views));
+    await mkdir(target);
+    await rename(temporary, target);
+    return {
+      path: join(target, "kit.json"),
+      preview: join(target, "contact.png"),
+      items: kit.items.length,
+      regions,
+      source: { width: w, height: h },
+      notice: "Review the contact proof. Raster lettering remains part of each image; preserve new text as native layers."
+    };
+  } catch (error) {
+    await rm(temporary, { recursive: true, force: true });
+    throw error;
+  }
+}
+
 // src/presentation.ts
 import { stripVTControlCharacters } from "util";
 function machineOutput(json) {
@@ -298,11 +503,11 @@ function banner(version2) {
 // src/publish.ts
 import { createHash as createHash2, randomUUID } from "crypto";
 import { constants } from "fs";
-import { appendFile, link, mkdir, open, readFile as readFile3, rename, rm } from "fs/promises";
+import { appendFile, link, mkdir as mkdir2, open, readFile as readFile3, rename as rename2, rm as rm2 } from "fs/promises";
 import { homedir } from "os";
-import { dirname, join, resolve as resolve2 } from "path";
-import sharp2 from "sharp";
-import { z } from "zod";
+import { dirname as dirname2, join as join2, resolve as resolve3 } from "path";
+import sharp3 from "sharp";
+import { z as z2 } from "zod";
 async function saveBundle(url, out) {
   const state = await studioRequest(url, "/call", {
     name: "badge_inspect",
@@ -323,7 +528,7 @@ async function saveBundle(url, out) {
       result.error?.message ?? "The editor could not export a bundle. Refresh it after saving the current draft."
     );
   const pkg = await readPackageJson(result.data);
-  const path = resolve2(out);
+  const path = resolve3(out);
   const file = await open(path, "wx", 384);
   try {
     await file.writeFile(`${JSON.stringify(packageJson(pkg))}
@@ -344,48 +549,48 @@ async function saveBundle(url, out) {
     published: false
   };
 }
-var receiptSchema = z.object({
-  id: z.string().uuid(),
-  version: z.number().int().positive(),
-  state: z.enum(["published", "withdrawn"]),
-  url: z.string()
+var receiptSchema = z2.object({
+  id: z2.string().uuid(),
+  version: z2.number().int().positive(),
+  state: z2.enum(["published", "withdrawn"]),
+  url: z2.string()
 });
 
 // src/reference-image.ts
 import { spawnSync } from "child_process";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "fs";
 import { tmpdir } from "os";
-import { join as join2, resolve as resolve3 } from "path";
+import { join as join3, resolve as resolve4 } from "path";
 import { DOMParser as DOMParser2, XMLSerializer } from "@xmldom/xmldom";
-import sharp3 from "sharp";
-import { z as z2 } from "zod";
+import sharp4 from "sharp";
+import { z as z3 } from "zod";
 var W = 1200;
 var H = 756;
 var N = W * H;
-var optionSchema = z2.object({
-  crop: z2.string().optional(),
-  patch: z2.array(z2.string()).default([]),
-  "edge-band": z2.coerce.number().min(0).max(1e3).optional(),
-  "bg-tol": z2.coerce.number().min(0).max(765).optional(),
-  title: z2.string().min(1).max(200).optional(),
-  desc: z2.string().max(5e3).optional(),
-  credit: z2.string().max(5e3).optional(),
-  tones: z2.coerce.number().int().min(2).max(12).optional(),
-  ink: z2.coerce.number().min(0).max(1).optional(),
-  raster: z2.boolean().optional(),
-  points: z2.array(z2.string()).max(100).optional(),
-  box: z2.string().optional(),
-  rows: z2.string().optional(),
-  cols: z2.string().optional(),
-  dark: z2.coerce.number().min(0).max(765).optional(),
-  colors: z2.coerce.number().int().min(1).max(12).optional(),
-  at: z2.string().optional(),
-  up: z2.coerce.number().int().min(1).max(8).optional(),
-  k: z2.coerce.number().min(0).max(1).optional(),
-  fill: z2.string().regex(/^#[a-fA-F0-9]{6}$/).optional(),
-  top: z2.enum(["left", "right"]).optional(),
-  upright: z2.enum(["left", "right"]).optional(),
-  "ref-box": z2.string().optional()
+var optionSchema = z3.object({
+  crop: z3.string().optional(),
+  patch: z3.array(z3.string()).default([]),
+  "edge-band": z3.coerce.number().min(0).max(1e3).optional(),
+  "bg-tol": z3.coerce.number().min(0).max(765).optional(),
+  title: z3.string().min(1).max(200).optional(),
+  desc: z3.string().max(5e3).optional(),
+  credit: z3.string().max(5e3).optional(),
+  tones: z3.coerce.number().int().min(2).max(12).optional(),
+  ink: z3.coerce.number().min(0).max(1).optional(),
+  raster: z3.boolean().optional(),
+  points: z3.array(z3.string()).max(100).optional(),
+  box: z3.string().optional(),
+  rows: z3.string().optional(),
+  cols: z3.string().optional(),
+  dark: z3.coerce.number().min(0).max(765).optional(),
+  colors: z3.coerce.number().int().min(1).max(12).optional(),
+  at: z3.string().optional(),
+  up: z3.coerce.number().int().min(1).max(8).optional(),
+  k: z3.coerce.number().min(0).max(1).optional(),
+  fill: z3.string().regex(/^#[a-fA-F0-9]{6}$/).optional(),
+  top: z3.enum(["left", "right"]).optional(),
+  upright: z3.enum(["left", "right"]).optional(),
+  "ref-box": z3.string().optional()
 }).strict();
 function fail(message) {
   throw new InputError(message);
@@ -404,7 +609,7 @@ function validBox(values, width, height) {
 }
 var lumOf = (r, g, b) => 0.299 * r + 0.587 * g + 0.114 * b;
 async function detect(file) {
-  const { data, info } = await sharp3(file, { limitInputPixels: 24e6 }).toColourspace("srgb").removeAlpha().raw().toBuffer({ resolveWithObject: true });
+  const { data, info } = await sharp4(file, { limitInputPixels: 24e6 }).toColourspace("srgb").removeAlpha().raw().toBuffer({ resolveWithObject: true });
   const { width: w, height: h } = info;
   const px = (x, y) => {
     const i = (y * w + x) * 3;
@@ -480,7 +685,7 @@ async function detect(file) {
 async function prepare(file, o) {
   if (!o.crop || !o.out) fail('prepare needs --out <dir> and --params with {"crop":"x,y,w,h"}.');
   const [cx, cy, cw, ch] = nums(o.crop, 4, "crop");
-  const meta = await sharp3(file, { limitInputPixels: 24e6 }).metadata();
+  const meta = await sharp4(file, { limitInputPixels: 24e6 }).metadata();
   validBox([cx, cy, cw, ch], meta.width ?? 0, meta.height ?? 0);
   if (Math.abs(cw / ch / (W / H) - 1) > 0.03)
     fail(
@@ -493,12 +698,12 @@ async function prepare(file, o) {
     if (feather < 0 || ![0, 1].includes(flop))
       fail("Patch feather must be nonnegative and flop must be 0 or 1.");
   }
-  const out = resolve3(o.out);
+  const out = resolve4(o.out);
   mkdirSync(out);
   const layers = [];
   for (const spec of o.patch) {
     const [dx, dy, pw, ph, sx, sy, feather = 6, flop = 0] = nums(spec, 6, "patch");
-    const patch = await sharp3(file).extract({ left: sx, top: sy, width: pw, height: ph }).flop(!!flop).toColourspace("srgb").removeAlpha().raw().toBuffer();
+    const patch = await sharp4(file).extract({ left: sx, top: sy, width: pw, height: ph }).flop(!!flop).toColourspace("srgb").removeAlpha().raw().toBuffer();
     const rgba = Buffer.alloc(pw * ph * 4);
     for (let y = 0; y < ph; y++)
       for (let x = 0; x < pw; x++) {
@@ -510,10 +715,10 @@ async function prepare(file, o) {
       }
     layers.push({ input: rgba, raw: { width: pw, height: ph, channels: 4 }, left: dx, top: dy });
   }
-  const patched = await sharp3(file).removeAlpha().composite(layers).png().toBuffer();
-  const card = await sharp3(patched).extract({ left: cx, top: cy, width: cw, height: ch }).toColourspace("srgb").removeAlpha().raw().toBuffer({ resolveWithObject: true });
+  const patched = await sharp4(file).removeAlpha().composite(layers).png().toBuffer();
+  const card = await sharp4(patched).extract({ left: cx, top: cy, width: cw, height: ch }).toColourspace("srgb").removeAlpha().raw().toBuffer({ resolveWithObject: true });
   const px = card.data, CW = card.info.width, CH = card.info.height;
-  const src = await sharp3(file, { limitInputPixels: 24e6 }).toColourspace("srgb").removeAlpha().raw().toBuffer({ resolveWithObject: true });
+  const src = await sharp4(file, { limitInputPixels: 24e6 }).toColourspace("srgb").removeAlpha().raw().toBuffer({ resolveWithObject: true });
   const sp = (x, y) => {
     const i = (y * src.info.width + x) * 3;
     return [src.data[i], src.data[i + 1], src.data[i + 2]];
@@ -553,14 +758,14 @@ async function prepare(file, o) {
     if (y > 0) queue.push(i - CW);
     if (y < CH - 1) queue.push(i + CW);
   }
-  const cardPng = await sharp3(px, { raw: card.info }).png().toBuffer();
-  const resized = sharp3(cardPng).resize(W, H, { fit: "fill", kernel: "lanczos3" });
-  await resized.clone().png().toFile(join2(out, "card.png"));
-  await resized.clone().jpeg({ quality: 84, mozjpeg: true }).toFile(join2(out, "card.jpg"));
+  const cardPng = await sharp4(px, { raw: card.info }).png().toBuffer();
+  const resized = sharp4(cardPng).resize(W, H, { fit: "fill", kernel: "lanczos3" });
+  await resized.clone().png().toFile(join3(out, "card.png"));
+  await resized.clone().jpeg({ quality: 84, mozjpeg: true }).toFile(join3(out, "card.jpg"));
   const rgb = await resized.clone().toColourspace("srgb").raw().toBuffer();
   const g = await resized.clone().toColourspace("b-w").raw().toBuffer();
-  writeFileSync(join2(out, "rgb.raw"), rgb);
-  writeFileSync(join2(out, "lum.raw"), g);
+  writeFileSync(join3(out, "rgb.raw"), rgb);
+  writeFileSync(join3(out, "lum.raw"), g);
   const GW = W * 2, GH = H * 2, big = Buffer.alloc(GW * GH);
   for (let y = 0; y < GH; y++) {
     const fy = Math.min(H - 1, Math.max(0, (y + 0.5) / 2 - 0.5)), y0 = Math.floor(fy), y1 = Math.min(H - 1, y0 + 1), ty = fy - y0;
@@ -572,14 +777,14 @@ async function prepare(file, o) {
       );
     }
   }
-  writeFileSync(join2(out, "ink.pgm"), Buffer.concat([Buffer.from(`P5
+  writeFileSync(join3(out, "ink.pgm"), Buffer.concat([Buffer.from(`P5
 ${GW} ${GH}
 255
 `), big]));
   const hex = paper.map((v) => Math.round(v).toString(16).padStart(2, "0")).join("");
   return {
     out,
-    preview: join2(out, "card.png"),
+    preview: join3(out, "card.png"),
     paper: `#${hex}`,
     patches: o.patch.length,
     filledEdgePixels: filled,
@@ -604,10 +809,10 @@ function potrace(input, extra) {
 }
 var esc = (s) => String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 function vectorize(dir, o) {
-  dir = resolve3(dir);
+  dir = resolve4(dir);
   if (!o.out || !o.title) fail("vectorize needs --out <file.svg> and --title");
   const K = Number(o.tones ?? 7);
-  const lum = readFileSync(join2(dir, "lum.raw")), rgb = readFileSync(join2(dir, "rgb.raw"));
+  const lum = readFileSync(join3(dir, "lum.raw")), rgb = readFileSync(join3(dir, "rgb.raw"));
   if (lum.length !== N || rgb.length !== N * 3)
     fail("Expected an intact directory created by image prepare.");
   let c = [...Array(K)].map((_, i) => 30 + i * 200 / (K - 1));
@@ -657,11 +862,11 @@ function vectorize(dir, o) {
   const L = used.length;
   const inkK = o.ink !== void 0 ? Number(o.ink) : L > 1 ? (c[used[0]] + c[used[1]]) / 2 / 255 : 0.25;
   const groups = [];
-  const maskFile = join2(dir, "mask.pbm");
+  const maskFile = join3(dir, "mask.pbm");
   for (let j = o.raster ? 0 : L - 2; j >= 0; j--) {
     let traced;
     if (j === 0) {
-      traced = potrace(join2(dir, "ink.pgm"), [
+      traced = potrace(join3(dir, "ink.pgm"), [
         "-k",
         inkK.toFixed(4),
         "-t",
@@ -684,7 +889,7 @@ ${W} ${H}
     if (traced) groups.push(`<g transform="${traced.tr}" fill="${colors[j]}">${traced.paths}</g>`);
   }
   const base = o.raster ? `<rect width="${W}" height="${H}" fill="${colors[L - 1]}"/>
-<image width="${W}" height="${H}" preserveAspectRatio="none" href="data:image/jpeg;base64,${readFileSync(join2(dir, "card.jpg")).toString("base64")}"/>` : `<rect width="${W}" height="${H}" fill="${colors[L - 1]}"/>`;
+<image width="${W}" height="${H}" preserveAspectRatio="none" href="data:image/jpeg;base64,${readFileSync(join3(dir, "card.jpg")).toString("base64")}"/>` : `<rect width="${W}" height="${H}" fill="${colors[L - 1]}"/>`;
   const title = esc(o.title), desc = esc(o.desc ?? `${o.title} card artwork.`);
   const meta = esc(o.credit ?? "Original artwork traced from a reference image.");
   const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${W}" height="${H}" viewBox="0 0 ${W} ${H}" role="img" aria-label="${desc}">
@@ -697,9 +902,9 @@ ${groups.join("\n")}
 `;
   const checked = checkSubmittedSvg(svg);
   if (!checked.ok) fail(checked.error);
-  writeFileSync(resolve3(o.out), svg, { flag: "wx" });
+  writeFileSync(resolve4(o.out), svg, { flag: "wx" });
   return {
-    out: resolve3(o.out),
+    out: resolve4(o.out),
     bytes: Buffer.byteLength(svg),
     mode: o.raster ? "raster background + vector ink" : "pure vector",
     tones: colors,
@@ -707,7 +912,7 @@ ${groups.join("\n")}
   };
 }
 async function rawImage(file) {
-  const { data, info } = await sharp3(file, { limitInputPixels: 24e6 }).toColourspace("srgb").removeAlpha().raw().toBuffer({ resolveWithObject: true });
+  const { data, info } = await sharp4(file, { limitInputPixels: 24e6 }).toColourspace("srgb").removeAlpha().raw().toBuffer({ resolveWithObject: true });
   const px = (x, y) => {
     if (!Number.isInteger(x) || !Number.isInteger(y) || x < 0 || y < 0 || x >= info.width || y >= info.height)
       fail("Pixel coordinates are outside the image.");
@@ -806,14 +1011,14 @@ async function glyphs(file, o) {
   if (!o.box || !o.at) fail("glyphs needs --box x,y,w,h and --at X,Y");
   const [bx, by, bw, bh] = nums(o.box, 4, "box");
   const [ax, ay] = nums(o.at, 2, "at");
-  const meta = await sharp3(file, { limitInputPixels: 24e6 }).metadata();
+  const meta = await sharp4(file, { limitInputPixels: 24e6 }).metadata();
   validBox([bx, by, bw, bh], meta.width ?? 0, meta.height ?? 0);
   const up = Number(o.up ?? 4);
   if (bw * bh * up * up > 24e6)
     fail("Trace region is too large; lower up or choose a smaller box.");
-  const { data, info } = await sharp3(file).extract({ left: bx, top: by, width: bw, height: bh }).greyscale().removeAlpha().resize({ width: bw * up, kernel: "lanczos3" }).raw().toBuffer({ resolveWithObject: true });
-  const temp = mkdtempSync(join2(tmpdir(), "makeables-glyphs-"));
-  const pgm = join2(temp, "glyphs.pgm");
+  const { data, info } = await sharp4(file).extract({ left: bx, top: by, width: bw, height: bh }).greyscale().removeAlpha().resize({ width: bw * up, kernel: "lanczos3" }).raw().toBuffer({ resolveWithObject: true });
+  const temp = mkdtempSync(join3(tmpdir(), "makeables-glyphs-"));
+  const pgm = join3(temp, "glyphs.pgm");
   writeFileSync(pgm, Buffer.concat([Buffer.from(`P5
 ${info.width} ${info.height}
 255
@@ -832,12 +1037,12 @@ ${info.width} ${info.height}
   const paths = [...svg.matchAll(/ d="([^"]+)"/g)].map((m) => m[1].replace(/\s+/g, " ")).join(" ");
   if (!tr || !paths) fail("nothing dark enough to trace in that box; lower --k or check the box");
   const snippet = `<g transform="translate(${ax} ${ay}) scale(${+(1 / up).toFixed(6)})"><path transform="${tr}" fill="${o.fill ?? "#0a0a0a"}" fill-rule="evenodd" d="${paths}"/></g>`;
-  if (o.out) writeFileSync(resolve3(o.out), snippet, { flag: "wx" });
+  if (o.out) writeFileSync(resolve4(o.out), snippet, { flag: "wx" });
   return {
     box: { x: bx, y: by, w: bw, h: bh },
     at: { x: ax, y: ay },
     bytes: snippet.length,
-    out: o.out ? resolve3(o.out) : null,
+    out: o.out ? resolve4(o.out) : null,
     snippet: o.out ? void 0 : snippet
   };
 }
@@ -859,28 +1064,28 @@ function rotate(file, o) {
   const svg = `<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="${W}" height="${H}" viewBox="0 0 ${W} ${H}"><g transform="${transform}"><g${inherited}>${body}</g></g></svg>`;
   const checked = checkSubmittedSvg(svg);
   if (!checked.ok) fail(checked.error);
-  writeFileSync(resolve3(o.out), svg, { flag: "wx" });
-  return { out: resolve3(o.out), transform, bytes: Buffer.byteLength(svg) };
+  writeFileSync(resolve4(o.out), svg, { flag: "wx" });
+  return { out: resolve4(o.out), transform, bytes: Buffer.byteLength(svg) };
 }
 async function compare(file, ref, o) {
   if (!o.out) fail("compare needs --out <file.png>");
-  let card = sharp3(readFileSync(file));
+  let card = sharp4(readFileSync(file));
   if (o.upright) card = card.rotate(o.upright === "left" ? 90 : -90);
   const cardPng = await card.png().toBuffer();
-  let reference = sharp3(ref);
+  let reference = sharp4(ref);
   if (o["ref-box"]) {
     const [x, y, w, h] = nums(o["ref-box"], 4, "ref-box");
     reference = reference.extract({ left: x, top: y, width: w, height: h });
   }
   const height = 900;
-  const a = await sharp3(cardPng).resize({ height }).png().toBuffer({ resolveWithObject: true });
-  const b = await sharp3(await reference.png().toBuffer()).resize({ height }).png().toBuffer({ resolveWithObject: true });
+  const a = await sharp4(cardPng).resize({ height }).png().toBuffer({ resolveWithObject: true });
+  const b = await sharp4(await reference.png().toBuffer()).resize({ height }).png().toBuffer({ resolveWithObject: true });
   const gap = 24, width = a.info.width + b.info.width + gap * 3;
-  await sharp3({ create: { width, height: height + gap * 2, channels: 3, background: "#ffffff" } }).composite([
+  await sharp4({ create: { width, height: height + gap * 2, channels: 3, background: "#ffffff" } }).composite([
     { input: a.data, left: gap, top: gap },
     { input: b.data, left: a.info.width + gap * 2, top: gap }
-  ]).png().toFile(resolve3(o.out));
-  return { out: resolve3(o.out), left: "card", right: "reference" };
+  ]).png().toFile(resolve4(o.out));
+  return { out: resolve4(o.out), left: "card", right: "reference" };
 }
 var imageTools = [
   "detect",
@@ -900,7 +1105,7 @@ async function referenceImage(command, file, options, out, reference) {
       parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")
     );
   const o = { ...parsed.data, out };
-  if (out && existsSync(resolve3(out))) fail("Output already exists. Choose a new --out path.");
+  if (out && existsSync(resolve4(out))) fail("Output already exists. Choose a new --out path.");
   if (!existsSync(file)) fail("Input file does not exist.");
   switch (command) {
     case "detect":
@@ -928,175 +1133,6 @@ 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) {
@@ -1114,7 +1150,7 @@ async function stickerPrintCut(design) {
 }
 
 // src/sticker-material.ts
-import { readFile as readFile5, stat as stat3 } from "fs/promises";
+import { readFile as readFile4, stat as stat3 } from "fs/promises";
 import { basename as basename2 } from "path";
 import sharp6 from "sharp";
 async function bindStickerMap(design, layerId, path) {
@@ -1124,7 +1160,7 @@ 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 readFile5(path);
+  const bytes = await readFile4(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.");
@@ -1150,13 +1186,48 @@ async function bindStickerMap(design, layerId, path) {
   });
 }
 
+// src/trace.ts
+import { constants as constants2 } from "fs";
+import { open as open2 } from "fs/promises";
+async function appendTrace(path, event) {
+  const file = await open2(
+    path,
+    constants2.O_APPEND | constants2.O_CREAT | constants2.O_WRONLY | constants2.O_NOFOLLOW,
+    384
+  );
+  try {
+    if (!(await file.stat()).isFile()) throw new Error("Choose a regular trace file.");
+    await file.chmod(384);
+    await file.writeFile(`${JSON.stringify(event)}
+`);
+  } finally {
+    await file.close();
+  }
+}
+function compactReceipt(value) {
+  if (Array.isArray(value)) return value.map(compactReceipt);
+  if (value && typeof value === "object")
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [
+        key,
+        key === "design" && entry && typeof entry === "object" ? {
+          name: "name" in entry ? entry.name : void 0,
+          product: "product" in entry ? entry.product : "badge",
+          omitted: true
+        } : compactReceipt(entry)
+      ])
+    );
+  if (typeof value === "string" && value.length > 2e3) return "[omitted; inspect the saved file]";
+  return value;
+}
+
 // src/wallet.ts
 import { spawn } from "child_process";
 import { createHash as createHash3 } from "crypto";
 import { existsSync as existsSync2 } from "fs";
-import { chmod as chmod2, lstat as lstat3, mkdir as mkdir3, mkdtemp as mkdtemp2, readFile as readFile7, rename as rename3, rm as rm4, writeFile as writeFile3 } from "fs/promises";
+import { chmod as chmod2, lstat as lstat3, mkdir as mkdir4, mkdtemp as mkdtemp3, readFile as readFile6, rename as rename4, rm as rm5, writeFile as writeFile4 } from "fs/promises";
 import { homedir as homedir3, tmpdir as tmpdir2 } from "os";
-import { dirname as dirname3, extname as extname3, join as join6, resolve as resolve6 } from "path";
+import { dirname as dirname4, extname as extname3, join as join7, resolve as resolve6 } from "path";
 import sharp7 from "sharp";
 
 // src/wallet-release.json
@@ -1178,18 +1249,18 @@ var wallet_release_default = {
 
 // src/wallet-storage.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { constants as constants2 } from "fs";
-import { chmod, lstat, mkdir as mkdir2, open as open2, rename as rename2, rm as rm2 } from "fs/promises";
+import { constants as constants3 } from "fs";
+import { chmod, lstat, mkdir as mkdir3, open as open3, rename as rename3, rm as rm3 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { dirname as dirname2, join as join3, resolve as resolve5 } from "path";
+import { dirname as dirname3, join as join4, resolve as resolve5 } from "path";
 function walletHome() {
   return resolve5(
-    process.env.MAKEABLES_WALLET_HOME ?? join3(homedir2(), "Library", "Application Support", "Makeables", "Wallet")
+    process.env.MAKEABLES_WALLET_HOME ?? join4(homedir2(), "Library", "Application Support", "Makeables", "Wallet")
   );
 }
 async function privateDirectory(path) {
   const absolute = resolve5(path);
-  const parent = dirname2(absolute);
+  const parent = dirname3(absolute);
   if (parent !== absolute) {
     try {
       const info = await lstat(parent);
@@ -1200,14 +1271,14 @@ async function privateDirectory(path) {
       await privateDirectory(parent);
     }
   }
-  await mkdir2(absolute, { recursive: true, mode: 448 });
+  await mkdir3(absolute, { recursive: true, mode: 448 });
   if (!(await lstat(absolute)).isDirectory())
     throw new InputError("Wallet storage must be a directory, not a symbolic link.");
   await chmod(absolute, 448);
   return absolute;
 }
 async function readPrivateJson(path) {
-  const handle = await open2(path, constants2.O_RDONLY | constants2.O_NOFOLLOW);
+  const handle = await open3(path, constants3.O_RDONLY | constants3.O_NOFOLLOW);
   try {
     const info = await handle.stat();
     if (!info.isFile() || info.size > 1e6)
@@ -1218,9 +1289,9 @@ async function readPrivateJson(path) {
   }
 }
 async function writePrivateJson(path, value) {
-  const temporary = join3(dirname2(path), `.${randomUUID2()}.json`);
+  const temporary = join4(dirname3(path), `.${randomUUID2()}.json`);
   try {
-    const handle = await open2(temporary, "wx", 384);
+    const handle = await open3(temporary, "wx", 384);
     try {
       await handle.writeFile(`${JSON.stringify(value)}
 `);
@@ -1228,15 +1299,15 @@ async function writePrivateJson(path, value) {
     } finally {
       await handle.close();
     }
-    await rename2(temporary, path);
+    await rename3(temporary, path);
   } finally {
-    await rm2(temporary, { force: true });
+    await rm3(temporary, { force: true });
   }
 }
 
 // src/wallet-submission.ts
-import { mkdtemp, readFile as readFile6, rm as rm3, writeFile as writeFile2 } from "fs/promises";
-import { join as join4 } from "path";
+import { mkdtemp as mkdtemp2, readFile as readFile5, rm as rm4, writeFile as writeFile3 } from "fs/promises";
+import { join as join5 } from "path";
 var uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function submissionId(input) {
   if (uuid.test(input)) return input.toLowerCase();
@@ -1254,7 +1325,7 @@ function submissionId(input) {
   return id.toLowerCase();
 }
 async function downloadWalletSubmission(input) {
-  const started = performance.now();
+  const started2 = performance.now();
   const id = submissionId(input);
   const response = await fetch(`https://makeables.dev/api/submissions/${id}/files?download=1`, {
     redirect: "error",
@@ -1284,16 +1355,16 @@ async function downloadWalletSubmission(input) {
   const pkg = await readPackageZip(bytes);
   if (pkg.manifest.product !== "card")
     throw new InputError("Wallet artwork requires a card submission.");
-  const directory = await mkdtemp(
-    join4(
-      await privateDirectory(join4(await privateDirectory(walletHome()), "submissions")),
+  const directory = await mkdtemp2(
+    join5(
+      await privateDirectory(join5(await privateDirectory(walletHome()), "submissions")),
       "download-"
     )
   );
   try {
-    const path = join4(directory, `${id}.makeables.zip`);
-    await writeFile2(path, bytes, { mode: 384, flag: "wx" });
-    const saved = await readFile6(path);
+    const path = join5(directory, `${id}.makeables.zip`);
+    await writeFile3(path, bytes, { mode: 384, flag: "wx" });
+    const saved = await readFile5(path);
     const sha256 = await hashBytes(saved);
     if (saved.length !== bytes.length || sha256 !== await hashBytes(bytes))
       throw new Error("Saved submission checksum does not match.");
@@ -1304,34 +1375,34 @@ async function downloadWalletSubmission(input) {
       submissionId: id,
       title: pkg.manifest.title,
       downloadVerified: true,
-      elapsedMs: Math.round(performance.now() - started)
+      elapsedMs: Math.round(performance.now() - started2)
     };
   } catch (error) {
-    await rm3(directory, { recursive: true, force: true });
+    await rm4(directory, { recursive: true, force: true });
     throw error;
   }
 }
 
 // src/wallet-targets.ts
 import { lstat as lstat2 } from "fs/promises";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 import lockfile from "proper-lockfile";
-import { z as z3 } from "zod";
-var alias = z3.string().regex(/^[a-z][a-z0-9-]{0,47}$/).refine((value) => !/\d{5}/.test(value));
-var label = z3.string().trim().min(1).max(60).refine(
+import { z as z4 } from "zod";
+var alias = z4.string().regex(/^[a-z][a-z0-9-]{0,47}$/).refine((value) => !/\d{5}/.test(value));
+var label = z4.string().trim().min(1).max(60).refine(
   (value) => !/\d{5}/.test(value) && [...value].every(
     (character) => character.charCodeAt(0) >= 32 && character.charCodeAt(0) !== 127
   )
 );
-var targetSchema = z3.object({
+var targetSchema = z4.object({
   target: alias,
   label,
-  last4: z3.string().regex(/^\d{4}$/).optional(),
-  identitySource: z3.literal("user-confirmed"),
-  backup: z3.string().min(1),
-  createdAt: z3.string().datetime()
+  last4: z4.string().regex(/^\d{4}$/).optional(),
+  identitySource: z4.literal("user-confirmed"),
+  backup: z4.string().min(1),
+  createdAt: z4.string().datetime()
 }).strict();
-var registrySchema = z3.object({ version: z3.literal(1), targets: z3.array(targetSchema).max(100) }).strict();
+var registrySchema = z4.object({ version: z4.literal(1), targets: z4.array(targetSchema).max(100) }).strict();
 function targetIdentity(values, key = "remember") {
   const result = targetSchema.pick({ target: true, label: true, last4: true }).safeParse({
     target: values[key],
@@ -1345,12 +1416,12 @@ function targetIdentity(values, key = "remember") {
   return result.data;
 }
 function registryPath() {
-  return join5(walletHome(), "targets", "registry.json");
+  return join6(walletHome(), "targets", "registry.json");
 }
 async function walletTargets() {
   const path = registryPath();
   try {
-    for (const parent of [walletHome(), join5(walletHome(), "targets")]) {
+    for (const parent of [walletHome(), join6(walletHome(), "targets")]) {
       if (!(await lstat2(parent)).isDirectory())
         throw new InputError("Invalid Wallet target storage.");
     }
@@ -1373,7 +1444,7 @@ function targetChoices(targets) {
   }));
 }
 async function withWalletTargets(action) {
-  const directory = await privateDirectory(join5(await privateDirectory(walletHome()), "targets"));
+  const directory = await privateDirectory(join6(await privateDirectory(walletHome()), "targets"));
   const release = await lockfile.lock(directory, { realpath: false, retries: 0 });
   try {
     return await action(await walletTargets(), async (targets) => {
@@ -1402,9 +1473,9 @@ var WalletError = class extends Error {
 };
 function installation() {
   const platform = `${process.platform}-${process.arch}`;
-  const cache = process.env.MAKEABLES_WALLET_CACHE ?? join6(homedir3(), "Library", "Caches", "Makeables", "wallet");
+  const cache = process.env.MAKEABLES_WALLET_CACHE ?? join7(homedir3(), "Library", "Caches", "Makeables", "wallet");
   const root = resolve6(cache, `${wallet_release_default.version}-${platform}`);
-  return { platform, root, executable: join6(root, "makeables-wallet", "makeables-wallet") };
+  return { platform, root, executable: join7(root, "makeables-wallet", "makeables-wallet") };
 }
 async function execute(command, args, progress) {
   return new Promise((accept, reject) => {
@@ -1535,25 +1606,25 @@ async function setupWallet(progress) {
   const bytes = Buffer.concat(chunks);
   if (createHash3("sha256").update(bytes).digest("hex") !== artifact.sha256)
     throw new Error("Wallet companion checksum did not match. Nothing was installed.");
-  await mkdir3(dirname3(root), { recursive: true, mode: 448 });
-  const stage = await mkdtemp2(join6(dirname3(root), ".install-"));
+  await mkdir4(dirname4(root), { recursive: true, mode: 448 });
+  const stage = await mkdtemp3(join7(dirname4(root), ".install-"));
   try {
-    const archive = join6(stage, "companion.tar.gz");
-    await writeFile3(archive, bytes, { mode: 384, flag: "wx" });
+    const archive = join7(stage, "companion.tar.gz");
+    await writeFile4(archive, bytes, { mode: 384, flag: "wx" });
     const members = (await execute("tar", ["-tzf", archive])).trim().split("\n");
     if (members.some(
       (path) => !path.startsWith("makeables-wallet/") || path.split("/").includes("..")
     ))
       throw new Error("Unexpected companion archive contents.");
     await execute("tar", ["-xzf", archive, "-C", stage]);
-    await rm4(archive);
-    await chmod2(join6(stage, "makeables-wallet", "makeables-wallet"), 448);
-    const info = await invoke(join6(stage, "makeables-wallet", "makeables-wallet"), ["version"]);
+    await rm5(archive);
+    await chmod2(join7(stage, "makeables-wallet", "makeables-wallet"), 448);
+    const info = await invoke(join7(stage, "makeables-wallet", "makeables-wallet"), ["version"]);
     if (info.version !== wallet_release_default.version || info.protocol !== wallet_release_default.protocol)
       throw new Error("Companion version does not match the installed CLI.");
-    await rename3(stage, root);
+    await rename4(stage, root);
   } finally {
-    await rm4(stage, { recursive: true, force: true });
+    await rm5(stage, { recursive: true, force: true });
   }
   return walletDoctor();
 }
@@ -1571,7 +1642,7 @@ async function walletArtwork(file, side2 = "front") {
     if (!path) throw new InputError("This package has no back artwork.");
     source = Buffer.from(pkg.files[path]);
   } else {
-    source = await readFile7(input);
+    source = await readFile6(input);
     if (extname3(input).toLowerCase() === ".svg") {
       const result = checkSubmittedSvg(source.toString("utf8"));
       if (!result.ok) throw new InputError(result.error);
@@ -1588,15 +1659,15 @@ async function preparedArtwork(directory) {
     "cardBackgroundCombined@2x.png",
     "cardBackgroundCombined.pdf"
   ]) {
-    const file = join6(path, name);
+    const file = join7(path, name);
     const info = await lstat3(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 readFile7(file)).subarray(0, signature.length).equals(signature))
+    if (!(await readFile6(file)).subarray(0, signature.length).equals(signature))
       throw new InputError(`Invalid prepared asset: ${name}. Run wallet prep again.`);
   }
-  return { path, preview: join6(path, "cardBackgroundCombined@3x.png") };
+  return { path, preview: join7(path, "cardBackgroundCombined@3x.png") };
 }
 async function walletCommand(command, values, progress) {
   if (values.remember) {
@@ -1630,8 +1701,8 @@ async function walletCommand(command, values, progress) {
   return runWalletCommand(command, values, progress);
 }
 async function runWalletCommand(command, values, progress) {
-  const started = performance.now();
-  const elapsed = () => Math.round(performance.now() - started);
+  const started2 = performance.now();
+  const elapsed = () => Math.round(performance.now() - started2);
   let latestPhase;
   const report = (phase, message) => {
     latestPhase = phase;
@@ -1806,7 +1877,7 @@ async function runWalletCommand(command, values, progress) {
     }
   }
   if (command === "wallet prep" || applying || installing) {
-    const work = await mkdtemp2(join6(tmpdir2(), "makeables-wallet-"));
+    const work = await mkdtemp3(join7(tmpdir2(), "makeables-wallet-"));
     let phase = "prepare";
     let deviceWriteAttempted = false;
     let persistent;
@@ -1819,18 +1890,18 @@ async function runWalletCommand(command, values, progress) {
       } else {
         report("prepare", "Preparing the complete card artwork.");
         const png = await walletArtwork(need("file"), values.side === "back" ? "back" : "front");
-        const raster = join6(work, "artwork.png");
-        await writeFile3(raster, png, { mode: 384 });
+        const raster = join7(work, "artwork.png");
+        await writeFile4(raster, png, { mode: 384 });
         if (command === "wallet prep") {
           target = resolve6(need("out"));
         } else if (installing && !applying) {
           const root = await privateDirectory(
-            join6(await privateDirectory(walletHome()), "prepared")
+            join7(await privateDirectory(walletHome()), "prepared")
           );
-          persistent = await mkdtemp2(join6(root, "install-"));
-          target = join6(persistent, "assets");
+          persistent = await mkdtemp3(join7(root, "install-"));
+          target = join7(persistent, "assets");
         } else {
-          target = join6(work, "assets");
+          target = join7(work, "assets");
         }
         prepared = await invoke(
           executable,
@@ -1916,8 +1987,8 @@ async function runWalletCommand(command, values, progress) {
       }
       throw error;
     } finally {
-      await rm4(work, { recursive: true, force: true });
-      if (persistent && phase === "prepare") await rm4(persistent, { recursive: true, force: true });
+      await rm5(work, { recursive: true, force: true });
+      if (persistent && phase === "prepare") await rm5(persistent, { recursive: true, force: true });
     }
   }
   throw new InputError("Unknown Wallet command.");
@@ -1968,6 +2039,14 @@ function walletSummary(result) {
 
 // src/cli.ts
 var commands = [
+  "kit new --name <title> --out <kit.json>",
+  "kit extract --file <artwork-sheet.png> --out <new-directory> [--params <json|@file>]",
+  "kit add --file <kit.json> --ref <design|package> --id <piece-id>",
+  "kit sheet --file <kit.json> --ref <sheet.json> --id <sheet-id>",
+  "kit inspect --file <kit.json|kit.makeables.zip>",
+  "kit render --file <kit.json|kit.makeables.zip> --out <mockup.png> [--overwrite]",
+  "kit export --file <kit.json|kit.makeables.zip> --out <kit.makeables.zip> [--overwrite]",
+  "kit import --file <kit.makeables.zip> --out <new-directory>",
   "designs list",
   "new card --design <slug> | --style <id> --out <new-file> [--dry-run]",
   "material set --file <design.json> --params <json|@file>",
@@ -1975,7 +2054,7 @@ var commands = [
   "new badge --style <id> --out <new-file> [--dry-run]",
   "new sticker --style <id> --out <new-file> [--dry-run]",
   "layer list --file <design.json>",
-  "layer add --file <design.json> --sticker <petdex:slug|path> [--side front|back]",
+  "layer add --file <design.json> --sticker <petdex:slug|path> [--side front|back] [--relative-to document|cwd]",
   "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]",
@@ -1984,7 +2063,7 @@ var commands = [
   "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]",
+  "render --file <design.json|design.makeables.json> --out <png> [--appearance flat|material] [--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>]",
   ...imageTools.map(
@@ -2027,9 +2106,22 @@ var commands = [
   "schema"
 ];
 var nextSteps = ["makeables skills get core", "makeables doctor"];
+var compact = false;
+var stdoutClosed = false;
+var traceFile;
+var traceCommand = "invalid";
+var traceCode;
+var elapsedStartup = process.uptime() * 1e3;
+var startedAt = new Date(Date.now() - elapsedStartup).toISOString();
+var started = performance.now() - elapsedStartup;
+process.stdout.on("error", (error) => {
+  if (error.code === "EPIPE") stdoutClosed = true;
+  else throw error;
+});
 function emit(data, next, human, json) {
+  if (stdoutClosed) return;
   process.stdout.write(
-    json ? `${JSON.stringify({ ok: true, version, data, nextSteps: next })}
+    json ? `${JSON.stringify({ ok: true, version, data: compact ? compactReceipt(data) : data, nextSteps: next })}
 ` : `${human}
 `
   );
@@ -2042,7 +2134,7 @@ async function newPath(file) {
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
   }
-  await access(dirname4(path), constants3.W_OK);
+  await access(dirname5(path), constants4.W_OK);
   return path;
 }
 async function run() {
@@ -2100,10 +2192,16 @@ async function run() {
       type: { type: "string" },
       size: { type: "string" },
       "width-mm": { type: "string" },
-      preview: { type: "string" }
+      preview: { type: "string" },
+      appearance: { type: "string" },
+      "relative-to": { type: "string" },
+      compact: { type: "boolean" },
+      trace: { type: "string" }
     }
   });
   const json = machineOutput(Boolean(values.json));
+  compact = Boolean(values.compact);
+  traceFile = values.trace;
   if (values.version) {
     emit({ version }, nextSteps, version, json);
     return;
@@ -2116,7 +2214,7 @@ async function run() {
     emit(
       {
         commands: helpCommands,
-        flags: ["--json", "--help", "--version"],
+        flags: ["--json", "--help", "--version", "--compact", "--trace <local.jsonl>"],
         exitCodes: { success: 0, invalidInput: 2, systemFailure: 1 }
       },
       nextSteps,
@@ -2132,6 +2230,14 @@ From a built checkout: npm run studio -- <command>`,
   }
   const command = ["skills get", "studio call"].includes(positionals.slice(0, 2).join(" ")) ? positionals.slice(0, 2).join(" ") : positionals.join(" ");
   const allowed = {
+    "kit new": ["name", "out"],
+    "kit extract": ["file", "out", "params"],
+    "kit add": ["file", "ref", "id"],
+    "kit sheet": ["file", "ref", "id"],
+    "kit inspect": ["file"],
+    "kit render": ["file", "out", "overwrite"],
+    "kit export": ["file", "out", "overwrite"],
+    "kit import": ["file", "out"],
     ...Object.fromEntries(
       imageTools.map((tool) => [`image ${tool}`, ["file", "out", "params", "ref"]])
     ),
@@ -2210,7 +2316,7 @@ From a built checkout: npm run studio -- <command>`,
     "material map": ["file", "id", "ref"],
     "new badge": ["style", "out", "dry-run"],
     "layer list": ["file"],
-    "layer add": ["file", "sticker", "side"],
+    "layer add": ["file", "sticker", "side", "relative-to"],
     "layer set": ["file", "id", "x", "y", "rotation", "side", "params"],
     "layer remove": ["file", "id", "side"],
     cut: ["file", "out", "overwrite"],
@@ -2219,17 +2325,90 @@ From a built checkout: npm run studio -- <command>`,
     "sheet pack": ["file"],
     "sheet check": ["file"],
     "sheet export": ["file", "out", "preview", "overwrite"],
-    render: ["file", "out", "overwrite", "side", "photo", "name", "role", "number"],
+    render: ["file", "out", "overwrite", "side", "photo", "name", "role", "number", "appearance"],
     validate: ["file", "out"]
   };
   if (!(command in allowed)) throw new InputError(`Unknown command: ${command}`);
+  traceCommand = command;
   for (const flag of Object.keys(values))
-    if (!["json", "help", "version", ...allowed[command]].includes(flag))
+    if (!["json", "help", "version", "compact", "trace", ...allowed[command]].includes(flag))
       throw new InputError(`--${flag} is not supported by ${command}`);
   const progress = (data) => process.stderr.write(`${JSON.stringify(data)}
 `);
   if (values.product && !["card", "badge", "sticker"].includes(values.product))
     throw new InputError("--product must be card, badge or sticker.");
+  if (command.startsWith("kit ")) {
+    const required = (value, flag) => {
+      if (!value) throw new InputError(`Supply --${flag}.`);
+      return value;
+    };
+    let result2;
+    if (command === "kit extract") {
+      result2 = await extractKit(
+        required(values.file, "file"),
+        required(values.out, "out"),
+        values.params ? await readParams(values.params) : {}
+      );
+    } else if (command === "kit new") {
+      const path2 = await newPath(required(values.out, "out"));
+      const kit = kitDocumentSchema.parse({
+        format: "makeables-kit",
+        version: 1,
+        name: required(values.name, "name"),
+        items: [],
+        sheets: []
+      });
+      await writeAtomic(path2, JSON.stringify(kit, null, 2), true);
+      result2 = { path: path2, kit };
+    } else if (command === "kit add" || command === "kit sheet") {
+      const path2 = required(values.file, "file");
+      const kit = await addKitMember(
+        path2,
+        required(values.ref, "ref"),
+        required(values.id, "id"),
+        command === "kit add" ? "items" : "sheets"
+      );
+      await writeAtomic(path2, JSON.stringify(kit, null, 2));
+      result2 = { path: resolve7(path2), items: kit.items.length, sheets: kit.sheets.length };
+    } else if (command === "kit import") {
+      result2 = await importKit(required(values.file, "file"), required(values.out, "out"));
+    } else if (command === "kit inspect" && !required(values.file, "file").toLowerCase().endsWith(".zip")) {
+      const value = JSON.parse(await readFile7(required(values.file, "file"), "utf8"));
+      if (value.format === "makeables-kit") result2 = await readKit(required(values.file, "file"));
+      else {
+        const pkg = await readSubmission(required(values.file, "file"));
+        if (pkg.manifest.product !== "kit")
+          throw new InputError("Choose a kit document or package.");
+        result2 = pkg.manifest;
+      }
+    } else {
+      const { pkg, bytes } = await exportKit(required(values.file, "file"));
+      if (command === "kit inspect") result2 = pkg.manifest;
+      else {
+        const out = resolve7(required(values.out, "out"));
+        const rendering = command === "kit render";
+        if (!out.endsWith(rendering ? ".png" : ".zip"))
+          throw new InputError(rendering ? "--out must end in .png." : "--out must end in .zip.");
+        const handle2 = await open4(
+          values.overwrite ? out : await newPath(out),
+          values.overwrite ? "w" : "wx"
+        );
+        try {
+          await handle2.writeFile(rendering ? pkg.files[pkg.manifest.front] : bytes);
+        } finally {
+          await handle2.close();
+        }
+        result2 = {
+          path: out,
+          product: "kit",
+          title: pkg.manifest.title,
+          bytes: rendering ? pkg.files[pkg.manifest.front].length : bytes.length
+        };
+      }
+    }
+    emit(result2, ["makeables skills get kits"], "Kit ready.", json);
+    return;
+  }
   if (command.startsWith("wallet ")) {
     const walletProgress = (data) => {
       if (json) return progress(data);
@@ -2395,7 +2574,7 @@ Run makeables skills get core for setup.`,
   }
   if (command === "mcp") {
     try {
-      const { runMcp } = await import("./mcp-HS2XZXSO.js");
+      const { runMcp } = await import("./mcp-VS5XYXVM.js");
       await runMcp(values.root ?? process.cwd());
     } catch (error) {
       process.stderr.write(
@@ -2454,7 +2633,7 @@ Keep this process running while you design.`,
         const info = await lstat4(path2);
         if (!info.isFile() || info.size > 12e6)
           throw new InputError("Expected a params file below 12 MB.");
-        params = JSON.parse(await readFile8(path2, "utf8"));
+        params = JSON.parse(await readFile7(path2, "utf8"));
       } else if (values.params) params = JSON.parse(values.params);
     }
     const result2 = await studioRequest(
@@ -2537,7 +2716,7 @@ ${styles.map((entry) => `${column(entry.id ?? "", 25)}${entry.name}`).join("\n")
     const path2 = values.out ? await newPath(values.out) : null;
     const dryRun = Boolean(values["dry-run"]);
     if (path2 && !dryRun) {
-      const handle2 = await open3(path2, "wx", 384);
+      const handle2 = await open4(path2, "wx", 384);
       try {
         await handle2.writeFile(`${JSON.stringify(design, null, 2)}
 `);
@@ -2561,13 +2740,13 @@ ${dryRun ? "Dry run. No files changed." : "2 faces \xB7 editable layers"}`,
   }
   if (!values.file) throw new InputError("Supply --file to validate a document.");
   const path = resolve7(values.file);
-  const handle = await open3(path, "r");
+  const handle = await open4(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 readFile8(handle, "utf8"));
+    input = JSON.parse(await readFile7(handle, "utf8"));
   } finally {
     await handle.close();
   }
@@ -2586,7 +2765,7 @@ Schema and layout constraints passed.`,
 }
 async function readParams(value) {
   return JSON.parse(
-    value.startsWith("@") ? await readFile8(resolve7(value.slice(1)), "utf8") : value
+    value.startsWith("@") ? await readFile7(resolve7(value.slice(1)), "utf8") : value
   );
 }
 async function cardCommand(command, values, json) {
@@ -2667,7 +2846,7 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
     const path = resolve7(need(file, "file"));
     const design = await readBadge(path);
     const raw = need(values.params, "params");
-    const input = JSON.parse(raw.startsWith("@") ? await readFile8(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)
@@ -2747,11 +2926,13 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
   if (command === "layer add") {
     const path = need(file, "file");
     const face = side(values.side);
+    if (values["relative-to"] && !["cwd", "document"].includes(String(values["relative-to"])))
+      throw new InputError("--relative-to must be document or cwd.");
     const design = await addBadgeSticker(
       await readBadge(path),
       face,
       need(values.sticker, "sticker"),
-      dirname4(resolve7(path))
+      values["relative-to"] === "cwd" ? process.cwd() : dirname5(resolve7(path))
     );
     await writeAtomic(path, `${JSON.stringify(design, null, 2)}
 `);
@@ -2766,7 +2947,7 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
   }
   if (command.startsWith("sheet ")) {
     const write = async (target, bytes) => {
-      const handle = await open3(target, values.overwrite ? "w" : "wx", 420);
+      const handle = await open4(target, values.overwrite ? "w" : "wx", 420);
       try {
         await handle.writeFile(bytes);
       } finally {
@@ -2870,7 +3051,7 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
     const target = out && (values.overwrite ? out : await newPath(out));
     const { cut, svg } = await stickerPrintCut(design);
     if (target) {
-      const handle = await open3(target, values.overwrite ? "w" : "wx", 420);
+      const handle = await open4(target, values.overwrite ? "w" : "wx", 420);
       try {
         await handle.writeFile(svg);
       } finally {
@@ -2902,6 +3083,9 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
     return true;
   }
   if (command === "render") {
+    if (values.appearance && !["flat", "material"].includes(String(values.appearance)))
+      throw new InputError("--appearance must be flat or material.");
+    const appearance = values.appearance;
     const path = need(file, "file");
     const out = resolve7(need(values.out, "out"));
     if (!out.endsWith(".png")) throw new InputError("--out must end in .png.");
@@ -2910,7 +3094,7 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
     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 readFile8(resolve7(path), "utf8"));
+    const value = JSON.parse(await readFile7(resolve7(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(
@@ -2922,11 +3106,12 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
     if (pkg && !previewPath) throw new InputError("This package has no back preview.");
     const card = design.product === "card" || design.product === "sticker";
     const { png, person, samplePortrait } = pkg && previewPath ? {
-      png: Buffer.from(pkg.files[previewPath]),
+      png: appearance && draft ? await renderDraftFace(draft, face, appearance) : Buffer.from(pkg.files[previewPath]),
       person: draft?.participant,
       samplePortrait: false
     } : await renderBadge(design, {
       face,
+      appearance,
       photo: typeof values.photo === "string" ? values.photo : void 0,
       person: {
         ...typeof values.name === "string" ? { name: values.name } : {},
@@ -2934,7 +3119,7 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
         ...number === void 0 ? {} : { number }
       }
     });
-    const handle = await open3(target, values.overwrite ? "w" : "wx", 420);
+    const handle = await open4(target, values.overwrite ? "w" : "wx", 420);
     try {
       await handle.writeFile(png);
     } finally {
@@ -2949,12 +3134,13 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
         side: face,
         width,
         height,
+        appearance: appearance ?? (pkg && design.product === "sticker" ? "material" : "flat"),
         ...card ? {} : { person, samplePortrait }
       },
       [
         `Open ${target} to review.`,
         ...portrait ? ["Pass --photo <image> to use the person's portrait."] : [],
-        ...pkg && design.product === "sticker" ? ["The transparent PNG includes the sticker material."] : ["This is flat artwork. Use an available integrated preview for live materials."]
+        ...(appearance === "material" || pkg && !appearance) && design.product === "sticker" ? ["The transparent PNG includes the sticker material."] : ["This is flat artwork. Use an available integrated preview for live materials."]
       ],
       `${style("Rendered", "1", !json)} ${face} ${target}${portrait ? "\n  note: sample portrait; pass --photo" : ""}`,
       json
@@ -2974,7 +3160,7 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
   if (command === "validate") {
     const path = resolve7(need(file, "file"));
     if (extname4(path).toLowerCase() === ".svg") {
-      const source = await readFile8(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;
@@ -2995,7 +3181,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 readFile8(path, "utf8"));
+    const input = JSON.parse(await readFile7(path, "utf8"));
     const result = badgeDesignSchema.safeParse(input);
     if (!result.success)
       throw new InputError(
@@ -3013,7 +3199,7 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
   return false;
 }
 run().catch((error) => {
-  const userError = error instanceof InputError || error instanceof WalletError && error.details.code === "INVALID_INPUT" || error instanceof SyntaxError || [
+  const userError = error instanceof InputError || error instanceof ZodError || 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",
@@ -3032,10 +3218,28 @@ run().catch((error) => {
     },
     nextSteps
   };
-  if (machineOutput(process.argv.includes("--json")))
+  traceCode = payload.error.code;
+  if (!stdoutClosed && machineOutput(process.argv.includes("--json")))
     process.stdout.write(`${JSON.stringify(payload)}
 `);
   process.stderr.write(`makeables: ${error.message}
 `);
   process.exitCode = exitCode;
+}).finally(async () => {
+  if (!traceFile) return;
+  try {
+    const supplied = process.env.MAKEABLES_TRACE_SESSION;
+    await appendTrace(resolve7(traceFile), {
+      sessionId: supplied && /^[a-zA-Z0-9_-]{1,80}$/.test(supplied) ? supplied : randomUUID3(),
+      version,
+      command: traceCommand,
+      startedAt,
+      endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      durationMs: Math.round(performance.now() - started),
+      ok: !traceCode,
+      ...traceCode ? { code: traceCode } : {}
+    });
+  } catch {
+    process.stderr.write("makeables: Could not write the optional local trace.\n");
+  }
 });