makeables 0.8.0 → 0.10.0

package/dist/cli.js

@@ -1,66 +1,81 @@
 #!/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,
+  PACKAGE_LIMIT,
   addBadgeSticker,
   badgeDesignObjectSchema,
   badgeDesignSchema,
   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-NOES67KG.js";
+} from "./chunk-G6OTYITI.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 readFile7 } from "fs/promises";
-import { dirname as dirname3, extname as extname4, resolve as resolve6 } 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
@@ -222,12 +237,13 @@ async function readToolResult(path) {
   if (!info.isFile() || info.size > 12e6)
     throw new InputError("Expected a result file below 12 MB.");
   let value = JSON.parse(await readFile2(path, "utf8"));
-  if ("success" in value) {
+  if (typeof value === "string") value = JSON.parse(value);
+  if (value && typeof value === "object" && "success" in value) {
     if (!value.success) throw new InputError("The browser command failed.");
     value = value.data.output;
   }
   if (typeof value === "string") value = JSON.parse(value);
-  if (!value?.ok)
+  if (!value?.ok || !value.data || typeof value.data !== "object")
     throw new InputError(value?.error?.message || "The tool returned an invalid result.");
   return value.data;
 }
@@ -270,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) {
@@ -294,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",
@@ -319,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))}
@@ -328,56 +537,60 @@ async function saveBundle(url, out) {
   } finally {
     await file.close();
   }
+  const saved = await readFile3(path);
   return {
     path,
+    bytes: saved.length,
+    sha256: await hashBytes(saved),
+    downloadVerified: true,
     snapshotHash: await hashBytes(jsonBytes(pkg.manifest)),
     name: pkg.manifest.title,
     complete: true,
     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);
@@ -396,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;
@@ -472,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(
@@ -485,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++) {
@@ -502,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]];
@@ -545,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;
@@ -564,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,
@@ -596,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));
@@ -649,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",
@@ -676,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}">
@@ -689,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,
@@ -699,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.");
@@ -798,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
@@ -824,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
   };
 }
@@ -851,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",
@@ -892,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":
@@ -920,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) {
@@ -1106,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) {
@@ -1116,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.");
@@ -1142,32 +1186,283 @@ 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, 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 resolve5 } from "path";
+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 dirname4, extname as extname3, join as join7, resolve as resolve6 } from "path";
 import sharp7 from "sharp";
 
 // src/wallet-release.json
 var wallet_release_default = {
-  version: "0.3.0",
+  version: "0.3.1",
   protocol: 1,
   repository: "crafter-station/makeables-community",
   platforms: {
     "darwin-arm64": {
-      asset: "makeables-wallet-0.3.0-darwin-arm64.tar.gz",
-      sha256: "ebd275228d84c75836820e12a999bcaa7e586dfbb215ba06882ae161a2e4a09f"
+      asset: "makeables-wallet-0.3.1-darwin-arm64.tar.gz",
+      sha256: "4ab38b2f451492f5365c4d8800c375d4c0112c246b7f6bb8e46ca85772298afc"
     },
     "darwin-x64": {
-      asset: "makeables-wallet-0.3.0-darwin-x64.tar.gz",
-      sha256: "c5bd51863895e6612be838b5023f7a1322424568ea4249651125930a66ff4ccb"
+      asset: "makeables-wallet-0.3.1-darwin-x64.tar.gz",
+      sha256: "f301d7be01bdeda2976b182cdf10b3eb30611f2bb88ef3edb520bfa29b814048"
     }
   }
 };
 
+// src/wallet-storage.ts
+import { randomUUID as randomUUID2 } from "crypto";
+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 dirname3, join as join4, resolve as resolve5 } from "path";
+function walletHome() {
+  return resolve5(
+    process.env.MAKEABLES_WALLET_HOME ?? join4(homedir2(), "Library", "Application Support", "Makeables", "Wallet")
+  );
+}
+async function privateDirectory(path) {
+  const absolute = resolve5(path);
+  const parent = dirname3(absolute);
+  if (parent !== absolute) {
+    try {
+      const info = await lstat(parent);
+      if (info.isSymbolicLink()) throw new InputError("Wallet storage cannot use symbolic links.");
+      if (!info.isDirectory()) throw new InputError("Wallet storage must be a directory.");
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+      await privateDirectory(parent);
+    }
+  }
+  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 open3(path, constants3.O_RDONLY | constants3.O_NOFOLLOW);
+  try {
+    const info = await handle.stat();
+    if (!info.isFile() || info.size > 1e6)
+      throw new InputError("Invalid Wallet target registry.");
+    return JSON.parse(await handle.readFile("utf8"));
+  } finally {
+    await handle.close();
+  }
+}
+async function writePrivateJson(path, value) {
+  const temporary = join4(dirname3(path), `.${randomUUID2()}.json`);
+  try {
+    const handle = await open3(temporary, "wx", 384);
+    try {
+      await handle.writeFile(`${JSON.stringify(value)}
+`);
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    await rename3(temporary, path);
+  } finally {
+    await rm3(temporary, { force: true });
+  }
+}
+
+// src/wallet-submission.ts
+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();
+  let url;
+  try {
+    url = new URL(input);
+  } catch {
+    throw new InputError("Supply a submission UUID or official Makeables card URL.");
+  }
+  if (url.origin !== "https://makeables.dev" || url.username || url.password || url.hash)
+    throw new InputError("Submission URLs must use https://makeables.dev.");
+  const id = url.pathname === "/make/card" ? url.searchParams.get("submission") : /^\/submissions\/([^/]+)$/.exec(url.pathname)?.[1];
+  if (!id || !uuid.test(id))
+    throw new InputError("This URL does not identify a Makeables card submission.");
+  return id.toLowerCase();
+}
+async function downloadWalletSubmission(input) {
+  const started2 = performance.now();
+  const id = submissionId(input);
+  const response = await fetch(`https://makeables.dev/api/submissions/${id}/files?download=1`, {
+    redirect: "error",
+    signal: AbortSignal.timeout(3e4)
+  });
+  if (!response.ok || !response.body)
+    throw new InputError(
+      `Submission download failed (${response.status}). Use an approved public card or a local exported package.`
+    );
+  const reader = response.body.getReader();
+  const chunks = [];
+  let size = 0;
+  try {
+    if (Number(response.headers.get("content-length")) > PACKAGE_LIMIT)
+      throw new InputError("Submission package exceeds 24 MB.");
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      size += value.length;
+      if (size > PACKAGE_LIMIT) throw new InputError("Submission package exceeds 24 MB.");
+      chunks.push(value);
+    }
+  } finally {
+    await reader.cancel();
+  }
+  const bytes = Buffer.concat(chunks);
+  const pkg = await readPackageZip(bytes);
+  if (pkg.manifest.product !== "card")
+    throw new InputError("Wallet artwork requires a card submission.");
+  const directory = await mkdtemp2(
+    join5(
+      await privateDirectory(join5(await privateDirectory(walletHome()), "submissions")),
+      "download-"
+    )
+  );
+  try {
+    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.");
+    return {
+      path,
+      bytes: saved.length,
+      sha256,
+      submissionId: id,
+      title: pkg.manifest.title,
+      downloadVerified: true,
+      elapsedMs: Math.round(performance.now() - started2)
+    };
+  } catch (error) {
+    await rm4(directory, { recursive: true, force: true });
+    throw error;
+  }
+}
+
+// src/wallet-targets.ts
+import { lstat as lstat2 } from "fs/promises";
+import { join as join6 } from "path";
+import lockfile from "proper-lockfile";
+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 = z4.object({
+  target: alias,
+  label,
+  last4: z4.string().regex(/^\d{4}$/).optional(),
+  identitySource: z4.literal("user-confirmed"),
+  backup: z4.string().min(1),
+  createdAt: z4.string().datetime()
+}).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],
+    label: values.label,
+    last4: values.last4
+  });
+  if (!result.success)
+    throw new InputError(
+      `Supply --${key} with a lowercase alias and --label with the user-confirmed card name. Optional --last4 must be exactly four digits; never supply a full card number.`
+    );
+  return result.data;
+}
+function registryPath() {
+  return join6(walletHome(), "targets", "registry.json");
+}
+async function walletTargets() {
+  const path = registryPath();
+  try {
+    for (const parent of [walletHome(), join6(walletHome(), "targets")]) {
+      if (!(await lstat2(parent)).isDirectory())
+        throw new InputError("Invalid Wallet target storage.");
+    }
+    const result = registrySchema.safeParse(await readPrivateJson(path));
+    if (!result.success || new Set(result.data.targets.map((entry) => entry.target)).size !== result.data.targets.length)
+      throw new InputError("Invalid Wallet target registry. Inspect local Wallet storage.");
+    return result.data.targets;
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+}
+function targetChoices(targets) {
+  return targets.map(({ target, label: label2, last4, identitySource }) => ({
+    target,
+    label: label2,
+    ...last4 ? { last4 } : {},
+    displayName: `${label2}${last4 ? ` \u2022\u2022\u2022\u2022${last4}` : ""}`,
+    identitySource
+  }));
+}
+async function withWalletTargets(action) {
+  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) => {
+      const registry = registrySchema.parse({ version: 1, targets });
+      await writePrivateJson(registryPath(), registry);
+    });
+  } finally {
+    await release();
+  }
+}
+function requireNewTarget(targets, target) {
+  if (targets.some((entry) => entry.target === target))
+    throw new InputError(
+      `Target "${target}" already exists. Choose a new alias; existing bindings are never replaced.`
+    );
+  if (targets.length >= 100) throw new InputError("Remove an unused target before adding another.");
+}
+
 // src/wallet.ts
 var WalletError = class extends Error {
   constructor(details) {
@@ -1178,9 +1473,9 @@ 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 = resolve5(cache, `${wallet_release_default.version}-${platform}`);
-  return { platform, root, executable: join3(root, "makeables-wallet", "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: join7(root, "makeables-wallet", "makeables-wallet") };
 }
 async function execute(command, args, progress) {
   return new Promise((accept, reject) => {
@@ -1311,38 +1606,41 @@ 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 mkdir2(dirname2(root), { recursive: true, mode: 448 });
-  const stage = await mkdtemp(join3(dirname2(root), ".install-"));
+  await mkdir4(dirname4(root), { recursive: true, mode: 448 });
+  const stage = await mkdtemp3(join7(dirname4(root), ".install-"));
   try {
-    const archive = join3(stage, "companion.tar.gz");
-    await writeFile2(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 rm2(archive);
-    await chmod(join3(stage, "makeables-wallet", "makeables-wallet"), 448);
-    const info = await invoke(join3(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 rename2(stage, root);
+    await rename4(stage, root);
   } finally {
-    await rm2(stage, { recursive: true, force: true });
+    await rm5(stage, { recursive: true, force: true });
   }
   return walletDoctor();
 }
 async function walletArtwork(file, side2 = "front") {
-  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.");
+  const input = resolve6(file);
+  const info = await lstat3(input);
+  if (!info.isFile() || info.size > 336e5)
+    throw new InputError("Expected artwork or a complete Makeables package below 32 MB.");
   let source;
-  if (extname3(input).toLowerCase() === ".json") {
-    const design = await readBadge(input);
-    if (design.product !== "card") throw new InputError("Wallet artwork requires a card document.");
-    source = (await renderBadge(design, { face: side2, person: {} })).png;
+  if ([".json", ".zip"].includes(extname3(input).toLowerCase())) {
+    const pkg = await readSubmission(input);
+    if (pkg.manifest.product !== "card")
+      throw new InputError("Wallet artwork requires a card document.");
+    const path = side2 === "front" ? pkg.manifest.front : pkg.manifest.back;
+    if (!path) throw new InputError("This package has no back artwork.");
+    source = Buffer.from(pkg.files[path]);
   } else {
     source = await readFile6(input);
     if (extname3(input).toLowerCase() === ".svg") {
@@ -1353,27 +1651,58 @@ async function walletArtwork(file, side2 = "front") {
   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())
+  const path = resolve6(directory);
+  if (!(await lstat3(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);
+    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 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") };
+  return { path, preview: join7(path, "cardBackgroundCombined@3x.png") };
 }
 async function walletCommand(command, values, progress) {
-  const started = performance.now();
-  const elapsed = () => Math.round(performance.now() - started);
+  if (values.remember) {
+    const identity = targetIdentity(values);
+    return withWalletTargets(async (targets, save) => {
+      requireNewTarget(targets, identity.target);
+      const result = await runWalletCommand(command, values, progress);
+      if (result.status !== "complete") return result;
+      try {
+        if (!result.backupVerified || typeof result.backupId !== "string")
+          throw new Error("The companion did not provide a verified backup binding.");
+        await save([
+          ...targets,
+          {
+            ...identity,
+            backup: result.backupId,
+            identitySource: "user-confirmed",
+            createdAt: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        ]);
+        return { ...result, targetSaved: true, target: identity.target };
+      } catch {
+        return {
+          ...result,
+          targetSaved: false,
+          warning: "Artwork installed, but the card label was not saved. Use wallet targets add with the verified backup; do not repeat the installation."
+        };
+      }
+    });
+  }
+  return runWalletCommand(command, values, progress);
+}
+async function runWalletCommand(command, values, progress) {
+  const started2 = performance.now();
+  const elapsed = () => Math.round(performance.now() - started2);
   let latestPhase;
   const report = (phase, message) => {
     latestPhase = phase;
@@ -1388,9 +1717,12 @@ async function walletCommand(command, values, progress) {
   const forward = (data) => {
     if (data && typeof data === "object") {
       if ("phase" in data && typeof data.phase === "string") latestPhase = data.phase;
+      const ready = latestPhase === "selection-ready" || "message" in data && data.message === "Connected to iPhone activity stream.";
+      if (ready) latestPhase = "selection-ready";
       progress({
         ...data,
         phase: latestPhase,
+        ...ready ? { ready: true, message: "Listening. Open Wallet and tap the exact card to customize." } : {},
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         elapsedMs: elapsed()
       });
@@ -1403,6 +1735,47 @@ async function walletCommand(command, values, progress) {
   };
   if (command === "wallet doctor") return walletDoctor();
   if (command === "wallet setup") return setupWallet(forward);
+  if (command === "wallet targets list") return { targets: targetChoices(await walletTargets()) };
+  if (command === "wallet targets remove") {
+    const name = need("target");
+    return withWalletTargets(async (targets, save) => {
+      if (!targets.some((entry) => entry.target === name))
+        throw new InputError("Unknown saved target.");
+      await save(targets.filter((entry) => entry.target !== name));
+      return { removed: name, backupPreserved: true };
+    });
+  }
+  if (command === "wallet targets add") {
+    const identity = targetIdentity(values, "target");
+    const backup = need("backup");
+    if (!values.yes)
+      throw new InputError("Use --yes after the user confirms which card this backup belongs to.");
+    return withWalletTargets(async (targets, save) => {
+      requireNewTarget(targets, identity.target);
+      const info2 = await walletDoctor();
+      if (!info2.ready || !("installed" in info2) || typeof info2.installed !== "string")
+        throw new InputError("Run makeables wallet setup first.");
+      const verified = await invoke(info2.installed, ["backups", "--backup", backup], forward);
+      if (verified.verified !== true || typeof verified.path !== "string" || !["complete", "restored"].includes(String(verified.status)))
+        throw new InputError("Choose a verified original backup from a completed operation.");
+      const entry = {
+        ...identity,
+        backup: verified.path,
+        identitySource: "user-confirmed",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await save([...targets, entry]);
+      return { targetSaved: true, ...targetChoices([entry])[0] };
+    });
+  }
+  const targetCount = [values.target, values.card, values.backup].filter(Boolean).length;
+  if (targetCount > 1)
+    throw new InputError("Choose exactly one --target, --card selection or --backup original.");
+  if (values.target) {
+    const target = (await walletTargets()).find((entry) => entry.target === values.target);
+    if (!target) throw new InputError("Unknown saved target. Run makeables wallet targets list.");
+    values = { ...values, backup: target.backup };
+  }
   const installing = command === "wallet install";
   const applying = command === "wallet apply" || installing && Boolean(values.card || values.backup);
   if (applying || command === "wallet restore" || command === "wallet recover") {
@@ -1414,29 +1787,44 @@ async function walletCommand(command, values, progress) {
   if (applying && Boolean(values.card) === Boolean(values.backup))
     throw new InputError("Choose exactly one --card selection or --backup original.");
   if (installing && values.yes && !applying)
-    throw new InputError("Select an explicit --card or --backup before using --yes.");
+    throw new InputError("Select an explicit --target, --card or --backup before using --yes.");
+  if (values.scan && (applying || values.yes))
+    throw new InputError("--scan discovers a new card; omit --target, --card, --backup and --yes.");
+  if ((values.label || values.last4) && !values.remember)
+    throw new InputError("--label and --last4 require --remember.");
+  if (values.remember && (!installing || values.target || values.backup))
+    throw new InputError(
+      "--remember is for a newly selected card. Use wallet targets add for an existing backup."
+    );
   if (installing && applying && (values.device || values.seconds))
     throw new InputError(
-      "--device and --seconds are for selection; --card or --backup already binds the target."
+      "--device and --seconds are for selection; --target, --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 (installing || applying || command === "wallet prep") {
+    if ([values.file, values.assets, values.submission].filter(Boolean).length !== 1)
+      throw new InputError(
+        "Supply exactly one --file artwork, --submission URL or UUID, or --assets prepared directory."
+      );
     if (values.assets && values.side)
-      throw new InputError("--side applies to --file, not already prepared --assets.");
+      throw new InputError("--side applies to --file or --submission, not 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;
+  let source;
+  if (values.submission) {
+    report("download", "Downloading and verifying the complete card package.");
+    source = await downloadWalletSubmission(need("submission"));
+    values = { ...values, file: String(source.path) };
+  }
   if (installing) report("setup", "Checking the Wallet companion.");
-  const info = installing ? await setupWallet(forward) : await walletDoctor();
+  const info = installing || command === "wallet prep" ? 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;
@@ -1489,7 +1877,7 @@ async function walletCommand(command, values, progress) {
     }
   }
   if (command === "wallet prep" || applying || installing) {
-    const work = await mkdtemp(join3(tmpdir2(), "makeables-wallet-"));
+    const work = await mkdtemp3(join7(tmpdir2(), "makeables-wallet-"));
     let phase = "prepare";
     let deviceWriteAttempted = false;
     let persistent;
@@ -1497,27 +1885,23 @@ async function walletCommand(command, values, progress) {
     try {
       let target;
       if (existing) {
-        target = resolve5(need("assets"));
+        target = resolve6(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 });
+        const raster = join7(work, "artwork.png");
+        await writeFile4(raster, png, { mode: 384 });
         if (command === "wallet prep") {
-          target = resolve5(need("out"));
+          target = resolve6(need("out"));
         } else if (installing && !applying) {
-          const root = join3(
-            process.env.MAKEABLES_WALLET_HOME ?? join3(homedir2(), "Library", "Application Support", "Makeables", "Wallet"),
-            "prepared"
+          const root = await privateDirectory(
+            join7(await privateDirectory(walletHome()), "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");
+          persistent = await mkdtemp3(join7(root, "install-"));
+          target = join7(persistent, "assets");
         } else {
-          target = join3(work, "assets");
+          target = join7(work, "assets");
         }
         prepared = await invoke(
           executable,
@@ -1526,10 +1910,32 @@ async function walletCommand(command, values, progress) {
         );
         await preparedArtwork(target);
       }
-      if (command === "wallet prep") return prepared;
+      if (command === "wallet prep") return { ...prepared, source, elapsedMs: elapsed() };
       if (installing && !applying) {
         phase = "selection";
-        report("selection", "Artwork is ready. Open Wallet and tap the card to customize.");
+        const continuation = ["--assets", target];
+        for (const flag of ["remember", "label", "last4"])
+          if (typeof values[flag] === "string")
+            continuation.push(`--${flag}`, String(values[flag]));
+        const saved = await walletTargets();
+        if (saved.length && !values.scan && !values.device)
+          return {
+            status: "needs-target",
+            targets: targetChoices(saved),
+            source,
+            assets: target,
+            preview: prepared.preview,
+            deviceWriteAttempted: false,
+            nextAction: "choose-saved-target-or-scan",
+            next: {
+              command: "wallet install",
+              args: ["--assets", target],
+              required: ["target", "yes"],
+              alternative: { args: [...continuation, "--scan"], required: [] }
+            },
+            elapsedMs: elapsed()
+          };
+        report("selection", "Artwork is ready. Connecting to the iPhone activity stream.");
         const args2 = ["list"];
         for (const flag of ["device", "seconds"])
           if (typeof values[flag] === "string") args2.push(`--${flag}`, String(values[flag]));
@@ -1542,11 +1948,12 @@ async function walletCommand(command, values, progress) {
           status,
           assets: target,
           preview: prepared.preview,
+          source,
           deviceWriteAttempted: false,
           nextAction: selection.needsDevice ? "select-device" : hasCards ? "confirm-card" : "tap-card",
           next: {
             command: "wallet install",
-            args: ["--assets", target],
+            args: !hasCards && (values.scan || saved.length) ? [...continuation, "--scan"] : continuation,
             required: selection.needsDevice ? ["device"] : hasCards ? ["card", "yes"] : []
           },
           elapsedMs: elapsed()
@@ -1559,7 +1966,12 @@ async function walletCommand(command, values, progress) {
       phase = "apply";
       deviceWriteAttempted = true;
       const result = await invoke(executable, args, forward);
-      return { ...result, elapsedMs: elapsed() };
+      return {
+        ...result,
+        ...values.target ? { target: values.target } : {},
+        source,
+        elapsedMs: elapsed()
+      };
     } catch (error) {
       if (error instanceof WalletError) {
         throw new WalletError({
@@ -1575,8 +1987,8 @@ async function walletCommand(command, values, progress) {
       }
       throw error;
     } finally {
-      await rm2(work, { recursive: true, force: true });
-      if (persistent && phase === "prepare") await rm2(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.");
@@ -1597,9 +2009,19 @@ function walletSummary(result) {
       `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."
+      typeof result.refresh === "string" ? result.refresh : "Close and reopen Wallet to see the design.",
+      ...typeof result.warning === "string" ? [result.warning] : []
     ].join("\n");
   }
+  if (result.status === "needs-target")
+    return [
+      "Artwork prepared. No card has been changed.",
+      ...(result.targets ?? []).map(
+        (entry) => `${entry.target}: ${entry.displayName} (user-confirmed)`
+      ),
+      "Choose a saved --target with --yes, or use --scan and tap a different card after selection-ready.",
+      `Prepared assets: ${String(result.assets)}`
+    ].join("\n");
   if (["needs-device", "needs-selection", "needs-card"].includes(String(result.status)))
     return [
       "Artwork prepared. No card has been changed.",
@@ -1617,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>",
@@ -1624,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]",
@@ -1633,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(
@@ -1641,9 +2071,12 @@ var commands = [
   ),
   "wallet setup",
   "wallet doctor",
-  "wallet install (--file <artwork> | --assets <directory>) [(--card <selection> | --backup <id|path>) --yes]",
+  "wallet install (--submission <UUID|URL> | --file <artwork|package> | --assets <directory>) [(--target <alias> | --card <selection> | --backup <id|path>) --yes] [--scan] [--remember <alias> --label <name> --last4 <digits>]",
+  "wallet targets list",
+  "wallet targets add --target <alias> --backup <id|path> --label <name> [--last4 <digits>] --yes",
+  "wallet targets remove --target <alias>",
   "wallet list [--device <selection>] [--seconds 45] [--first]",
-  "wallet prep --file <card.json|artwork.svg|image.png> --out <new-directory> [--side front|back]",
+  "wallet prep (--submission <UUID|URL> | --file <card.json|package.zip|artwork.svg|image.png>) --out <new-directory> [--side front|back]",
   "wallet apply (--file <artwork> | --assets <directory>) (--card <selection> | --backup <id|path>) --yes",
   "wallet restore --backup <id|path> --yes",
   "wallet backups [--backup <id|path>]",
@@ -1673,22 +2106,35 @@ 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}
 `
   );
 }
 async function newPath(file) {
-  const path = resolve6(file);
+  const path = resolve7(file);
   try {
-    await lstat2(path);
+    await lstat4(path);
     throw new InputError(`File already exists: ${path}. Choose a new --out path.`);
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
   }
-  await access(dirname3(path), constants2.W_OK);
+  await access(dirname5(path), constants4.W_OK);
   return path;
 }
 async function run() {
@@ -1738,28 +2184,42 @@ async function run() {
       seconds: { type: "string" },
       assets: { type: "string" },
       first: { type: "boolean" },
+      submission: { type: "string" },
+      scan: { type: "boolean" },
+      remember: { type: "string" },
+      label: { type: "string" },
+      last4: { type: "string" },
       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;
   }
   if (values.help || !positionals.length) {
+    const prefix = positionals.join(" ");
+    const helpCommands = prefix ? commands.filter((entry) => entry === prefix || entry.startsWith(`${prefix} `)) : commands;
+    if (!helpCommands.length) throw new InputError(`Unknown command: ${prefix}`);
     if (!json) banner(version);
     emit(
       {
-        commands,
-        flags: ["--json", "--help", "--version"],
+        commands: helpCommands,
+        flags: ["--json", "--help", "--version", "--compact", "--trace <local.jsonl>"],
         exitCodes: { success: 0, invalidInput: 2, systemFailure: 1 }
       },
       nextSteps,
       `${style("Commands", "1", !json)}
-${commands.map((command2) => `  npx makeables ${command2}`).join("\n")}
+${helpCommands.map((command2) => `  npx makeables ${command2}`).join("\n")}
 
 JSON is automatic when piped. --out creates new files only.
 Install globally: npm install --global makeables
@@ -1770,14 +2230,40 @@ 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"]])
     ),
     "wallet setup": [],
     "wallet doctor": [],
-    "wallet install": ["file", "assets", "card", "backup", "side", "device", "seconds", "yes"],
+    "wallet install": [
+      "submission",
+      "file",
+      "assets",
+      "target",
+      "card",
+      "backup",
+      "side",
+      "device",
+      "seconds",
+      "yes",
+      "scan",
+      "remember",
+      "label",
+      "last4"
+    ],
+    "wallet targets list": [],
+    "wallet targets add": ["target", "backup", "label", "last4", "yes"],
+    "wallet targets remove": ["target"],
     "wallet list": ["device", "seconds", "first"],
-    "wallet prep": ["file", "out", "side"],
+    "wallet prep": ["submission", "file", "out", "side"],
     "wallet apply": ["file", "assets", "card", "backup", "side", "yes"],
     "wallet restore": ["backup", "yes"],
     "wallet backups": ["backup"],
@@ -1830,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"],
@@ -1839,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);
@@ -2015,7 +2574,7 @@ Run makeables skills get core for setup.`,
   }
   if (command === "mcp") {
     try {
-      const { runMcp } = await import("./mcp-54KV55QM.js");
+      const { runMcp } = await import("./mcp-VS5XYXVM.js");
       await runMcp(values.root ?? process.cwd());
     } catch (error) {
       process.stderr.write(
@@ -2071,7 +2630,7 @@ Keep this process running while you design.`,
       if (positionals.length !== 3) throw new InputError("Supply one discovered tool name.");
       if (values.params?.startsWith("@")) {
         const path2 = values.params.slice(1);
-        const info = await lstat2(path2);
+        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 readFile7(path2, "utf8"));
@@ -2157,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 open2(path2, "wx", 384);
+      const handle2 = await open4(path2, "wx", 384);
       try {
         await handle2.writeFile(`${JSON.stringify(design, null, 2)}
 `);
@@ -2180,8 +2739,8 @@ ${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 = resolve6(values.file);
-  const handle = await open2(path, "r");
+  const path = resolve7(values.file);
+  const handle = await open4(path, "r");
   let input;
   try {
     const info = await handle.stat();
@@ -2206,7 +2765,7 @@ Schema and layout constraints passed.`,
 }
 async function readParams(value) {
   return JSON.parse(
-    value.startsWith("@") ? await readFile7(resolve6(value.slice(1)), "utf8") : value
+    value.startsWith("@") ? await readFile7(resolve7(value.slice(1)), "utf8") : value
   );
 }
 async function cardCommand(command, values, json) {
@@ -2268,7 +2827,7 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
     return true;
   }
   if (command === "material map") {
-    const path = resolve6(need(file, "file"));
+    const path = resolve7(need(file, "file"));
     const next = await bindStickerMap(
       await readBadge(path),
       need(values.id, "id"),
@@ -2284,7 +2843,7 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
     return true;
   }
   if (command === "material set") {
-    const path = resolve6(need(file, "file"));
+    const path = resolve7(need(file, "file"));
     const design = await readBadge(path);
     const raw = need(values.params, "params");
     const input = JSON.parse(raw.startsWith("@") ? await readFile7(raw.slice(1), "utf8") : raw);
@@ -2367,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"),
-      dirname3(resolve6(path))
+      values["relative-to"] === "cwd" ? process.cwd() : dirname5(resolve7(path))
     );
     await writeAtomic(path, `${JSON.stringify(design, null, 2)}
 `);
@@ -2386,7 +2947,7 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
   }
   if (command.startsWith("sheet ")) {
     const write = async (target, bytes) => {
-      const handle = await open2(target, values.overwrite ? "w" : "wx", 420);
+      const handle = await open4(target, values.overwrite ? "w" : "wx", 420);
       try {
         await handle.writeFile(bytes);
       } finally {
@@ -2465,9 +3026,9 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
         throw new InputError(
           `The sheet is not printable. Run makeables sheet check --file ${JSON.stringify(path)}.`
         );
-      const out = resolve6(need(values.out, "out"));
+      const out = resolve7(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;
+      const preview = typeof values.preview === "string" ? resolve7(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);
@@ -2485,12 +3046,12 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
   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;
+    const out = typeof values.out === "string" ? resolve7(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);
+      const handle = await open4(target, values.overwrite ? "w" : "wx", 420);
       try {
         await handle.writeFile(svg);
       } finally {
@@ -2522,15 +3083,18 @@ ${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 = resolve6(need(values.out, "out"));
+    const out = resolve7(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 readFile7(resolve6(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(
@@ -2542,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 } : {},
@@ -2554,7 +3119,7 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
         ...number === void 0 ? {} : { number }
       }
     });
-    const handle = await open2(target, values.overwrite ? "w" : "wx", 420);
+    const handle = await open4(target, values.overwrite ? "w" : "wx", 420);
     try {
       await handle.writeFile(png);
     } finally {
@@ -2569,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
@@ -2592,7 +3158,7 @@ ${path ?? `No file written. Add --out ${kind}.json.`}`,
     return true;
   }
   if (command === "validate") {
-    const path = resolve6(need(file, "file"));
+    const path = resolve7(need(file, "file"));
     if (extname4(path).toLowerCase() === ".svg") {
       const source = await readFile7(path, "utf8");
       const result2 = checkSubmittedSvg(source);
@@ -2633,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",
@@ -2652,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");
+  }
 });