pixelkiln 0.68.1 → 0.70.0

package/dist/cli.js

@@ -67,8 +67,8 @@ function exitCodeFor(err) {
 }
 
 // src/cli/main.ts
-import { existsSync as existsSync33 } from "fs";
-import { readFile as readFile31 } from "fs/promises";
+import { existsSync as existsSync35 } from "fs";
+import { readFile as readFile32 } from "fs/promises";
 
 // src/cli/args.ts
 import path from "path";
@@ -107,7 +107,8 @@ var VALUE_FLAGS = [
   "--quantize",
   "--description",
   "--weight",
-  "--glyph-px"
+  "--glyph-px",
+  "--frames"
 ];
 var BOOL_FLAGS = [
   "--force",
@@ -158,6 +159,7 @@ var COMMANDS = [
   "recipe",
   "workspace",
   "estimate-skeleton",
+  "skeleton-preview",
   "unzoom",
   "font",
   "help",
@@ -256,6 +258,12 @@ function parseArgs(argv) {
     target = rest[0]?.startsWith("-") ? void 0 : rest[0];
     if (target === void 0) throw new UsageError("estimate-skeleton needs an image path");
     rest = rest.slice(1);
+  } else if (command === "skeleton-preview") {
+    target = rest[0]?.startsWith("-") ? void 0 : rest[0];
+    if (target === void 0) {
+      throw new UsageError("skeleton-preview needs a keypoints file or an animate-skeleton asset id");
+    }
+    rest = rest.slice(1);
   } else if (command === "refine") {
     subcommand = rest[0]?.startsWith("-") || rest[0] === void 0 ? "run" : rest[0];
     if (!REFINE_SUBCOMMANDS.includes(subcommand)) {
@@ -421,7 +429,8 @@ function parseArgs(argv) {
     quantize: numberOption("--quantize", { min: -1, max: 256, integer: true }),
     description: get("--description"),
     weight: get("--weight"),
-    glyphPx: numberOption("--glyph-px", { min: 8, max: 64, integer: true })
+    glyphPx: numberOption("--glyph-px", { min: 8, max: 64, integer: true }),
+    frames: numberOption("--frames", { min: 3, max: 15, integer: true })
   };
 }
 
@@ -461,11 +470,16 @@ Commands
             first. Local art is untouched.
   tag       Push manifest tags to the objects upstream (free).
   balance   Show the provider's remaining balance.
-  estimate-skeleton <image> [--out <file>]
-            PixelLab only: derive an 18-joint skeleton from an image, direct
-            and un-budgeted (like balance, not a generation). Prints the
-            keypoints JSON, or writes it with --out \u2014 the way to bootstrap
-            an animate-skeleton revision's keypointsFile.
+  estimate-skeleton <image> [--out <file>] [--frames <n>] [--force]
+            PixelLab only: derive an 18-joint skeleton from a square 16-256px
+            image, direct and un-budgeted (like balance, not a generation).
+            Prints, or writes with --out, a ready keypoints file for an
+            animate-skeleton revision: the estimated pose plus --frames copies
+            (default 4) to edit. --out refuses to replace a file without --force.
+  skeleton-preview <keypoints.json | asset> [--from <image>] [--out <file>]
+            Draw every pose of a keypoints file over its source image as one
+            PNG, locally and free. Given an animate-skeleton asset id, reads
+            its keypointsFile and source from the manifest.
   status    Summarise the lockfile.
   edit      Hand-edit an asset in your own editor: copies the generated PNG to
             <outDir>/edits/, declares it as the asset's source, and opens it.
@@ -648,10 +662,10 @@ import { createReadStream } from "fs";
 function sha256(data) {
   return createHash("sha256").update(data).digest("hex");
 }
-async function sha256File(path48) {
+async function sha256File(path49) {
   return new Promise((resolve, reject) => {
     const hash = createHash("sha256");
-    const stream = createReadStream(path48);
+    const stream = createReadStream(path49);
     stream.on("data", (chunk2) => hash.update(chunk2));
     stream.on("error", reject);
     stream.on("end", () => resolve(hash.digest("hex")));
@@ -5756,14 +5770,61 @@ import { z as z3 } from "zod";
 
 // src/skeleton.ts
 import { z as z2 } from "zod";
+var SKELETON_LABELS = [
+  "NOSE",
+  "NECK",
+  "RIGHT SHOULDER",
+  "RIGHT ELBOW",
+  "RIGHT ARM",
+  "LEFT SHOULDER",
+  "LEFT ELBOW",
+  "LEFT ARM",
+  "RIGHT HIP",
+  "RIGHT KNEE",
+  "RIGHT LEG",
+  "LEFT HIP",
+  "LEFT KNEE",
+  "LEFT LEG",
+  "RIGHT EYE",
+  "LEFT EYE",
+  "RIGHT EAR",
+  "LEFT EAR"
+];
+var SKELETON_BONES = [
+  ["NOSE", "NECK"],
+  ["NECK", "RIGHT SHOULDER"],
+  ["RIGHT SHOULDER", "RIGHT ELBOW"],
+  ["RIGHT ELBOW", "RIGHT ARM"],
+  ["NECK", "LEFT SHOULDER"],
+  ["LEFT SHOULDER", "LEFT ELBOW"],
+  ["LEFT ELBOW", "LEFT ARM"],
+  ["NECK", "RIGHT HIP"],
+  ["RIGHT HIP", "RIGHT KNEE"],
+  ["RIGHT KNEE", "RIGHT LEG"],
+  ["NECK", "LEFT HIP"],
+  ["LEFT HIP", "LEFT KNEE"],
+  ["LEFT KNEE", "LEFT LEG"],
+  ["NOSE", "RIGHT EYE"],
+  ["RIGHT EYE", "RIGHT EAR"],
+  ["NOSE", "LEFT EYE"],
+  ["LEFT EYE", "LEFT EAR"]
+];
 var SkeletonKeypointSchema = z2.object({
-  label: z2.string().min(1),
+  label: z2.enum(SKELETON_LABELS),
   x: z2.number().min(0).max(1),
   y: z2.number().min(0).max(1),
   z_index: z2.number(),
   depth: z2.number().optional()
 }).strict();
-var SkeletonFrameSchema = z2.array(SkeletonKeypointSchema).length(18);
+var SkeletonFrameSchema = z2.array(SkeletonKeypointSchema).length(18).superRefine((frame, context) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, joint] of frame.entries()) {
+    if (seen.has(joint.label)) {
+      context.addIssue({ code: z2.ZodIssueCode.custom, message: `"${joint.label}" appears twice`, path: [index, "label"] });
+    }
+    seen.add(joint.label);
+  }
+});
 var SkeletonSetSchema = z2.object({
   firstFrameKeypoints: SkeletonFrameSchema,
   frames: z2.array(SkeletonFrameSchema).min(3).max(15)
@@ -5776,6 +5837,15 @@ function parseSkeletonSet(json, file) {
   }
   return result.data;
 }
+var ESTIMATE_SKELETON_SIZES = [16, 32, 64, 128, 256];
+function estimateSkeletonSizeProblem(width, height) {
+  return width === height && ESTIMATE_SKELETON_SIZES.includes(width) ? null : `${width}x${height}; estimate-skeleton takes a square image of ${ESTIMATE_SKELETON_SIZES.join(", ")} pixels`;
+}
+var DEFAULT_SCAFFOLD_FRAMES = 4;
+function scaffoldSkeletonSet(keypoints, frames = DEFAULT_SCAFFOLD_FRAMES) {
+  const copy = () => keypoints.map((joint) => ({ ...joint }));
+  return { firstFrameKeypoints: copy(), frames: Array.from({ length: frames }, copy) };
+}
 
 // src/client.ts
 var BASE = process.env.PIXELLAB_API_BASE ?? "https://api.pixellab.ai/v2";
@@ -6090,9 +6160,9 @@ var PixelLabClient = class {
   apiKey;
   http;
   /** Retries transport failures, 429, and 5xx; see http.ts for the policy. */
-  async request(path48, init) {
+  async request(path49, init) {
     const auth = this.apiKey.startsWith("Bearer ") ? this.apiKey : `Bearer ${this.apiKey}`;
-    const res = await this.http(`${BASE}${path48}`, {
+    const res = await this.http(`${BASE}${path49}`, {
       ...init,
       headers: {
         Authorization: auth,
@@ -6102,13 +6172,13 @@ var PixelLabClient = class {
     });
     const text = await res.text();
     if (!res.ok) {
-      throw new PixelLabError(`${init?.method ?? "GET"} ${path48} \u2192 ${res.status}`, res.status, text);
+      throw new PixelLabError(`${init?.method ?? "GET"} ${path49} \u2192 ${res.status}`, res.status, text);
     }
     if (!text) return {};
     try {
       return JSON.parse(text);
     } catch {
-      throw new Error(`${init?.method ?? "GET"} ${path48} returned invalid JSON`);
+      throw new Error(`${init?.method ?? "GET"} ${path49} returned invalid JSON`);
     }
   }
   async balance() {
@@ -6500,10 +6570,10 @@ var PixelLabClient = class {
     const palette = args.paletteSwatchBase64 ? { color_image: { type: "base64", base64: args.paletteSwatchBase64, format: "png" }, force_colors: true } : {};
     const encode = (image) => ({ type: "base64", base64: image.base64, format: image.format });
     const south = args.reference?.south;
-    let path48;
+    let path49;
     let body;
     if (args.mode === "v3") {
-      path48 = "/create-character-v3";
+      path49 = "/create-character-v3";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -6517,7 +6587,7 @@ var PixelLabClient = class {
         ...args.enhancePrompt ? { enhance_prompt: true } : {}
       };
     } else if (args.mode === "pro-flash") {
-      path48 = "/create-character-pro-flash";
+      path49 = "/create-character-pro-flash";
       const traits = args.styleTraits;
       body = {
         description: args.description,
@@ -6541,7 +6611,7 @@ var PixelLabClient = class {
         } : {}
       };
     } else if (args.mode === "pro") {
-      path48 = "/create-character-pro";
+      path49 = "/create-character-pro";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -6555,7 +6625,7 @@ var PixelLabClient = class {
         ...!south && args.styleCharacterId ? { style_character_id: args.styleCharacterId } : {}
       };
     } else {
-      path48 = args.directions === 4 ? "/create-character-with-4-directions" : "/create-character-with-8-directions";
+      path49 = args.directions === 4 ? "/create-character-with-4-directions" : "/create-character-with-8-directions";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -6572,8 +6642,8 @@ var PixelLabClient = class {
         ...palette
       };
     }
-    const raw = await this.request(path48, { method: "POST", body: JSON.stringify(body) });
-    return validateResponse(CharacterSubmitSchema, raw, path48.slice(1));
+    const raw = await this.request(path49, { method: "POST", body: JSON.stringify(body) });
+    return validateResponse(CharacterSubmitSchema, raw, path49.slice(1));
   }
   /** A text edit of an existing character, applied to every direction and stored as a sibling. */
   async createCharacterState(args) {
@@ -7128,7 +7198,7 @@ var PixelLabClient = class {
    * account (see `EstimateSkeletonResponseSchema`'s own caveat).
    */
   async estimateSkeleton(args) {
-    const body = { image: args.image };
+    const body = { image: { type: "base64", base64: args.image.base64, format: args.image.format } };
     const res = validateResponse(
       EstimateSkeletonResponseSchema,
       await this.request("/estimate-skeleton", { method: "POST", body: JSON.stringify(body) }),
@@ -9420,9 +9490,9 @@ var RetroDiffusionClient = class {
     if (!response.ok) throw new ProviderError("retrodiffusion", `Retro Diffusion download failed (${response.status})`, { status: response.status });
     return Buffer.from(await response.arrayBuffer());
   }
-  async call(path48, init = {}) {
+  async call(path49, init = {}) {
     if (!this.token) throw new Error("RD_API_KEY is not set");
-    const response = await this.request(`${this.baseUrl}${path48}`, {
+    const response = await this.request(`${this.baseUrl}${path49}`, {
       ...init,
       headers: {
         "Content-Type": "application/json",
@@ -11727,10 +11797,10 @@ function isSha256Hash(value) {
 function parseCache(value) {
   return HashCacheSchema.parse(value);
 }
-async function loadCache(path48) {
-  if (!existsSync10(path48)) return { version: 1, hashes: {} };
+async function loadCache(path49) {
+  if (!existsSync10(path49)) return { version: 1, hashes: {} };
   try {
-    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile8(path48, "utf8")));
+    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile8(path49, "utf8")));
     if (!parsed.success) return { version: 1, hashes: {} };
     return {
       version: 1,
@@ -11742,18 +11812,18 @@ async function loadCache(path48) {
     return { version: 1, hashes: {} };
   }
 }
-async function saveCache(path48, cache) {
+async function saveCache(path49, cache) {
   const sorted = {};
   for (const key of Object.keys(cache.hashes).sort()) {
     const hash = cache.hashes[key];
     if (!isSha256Hash(hash)) throw new Error(`Refusing to cache invalid SHA-256 for ${key}`);
     sorted[key] = hash;
   }
-  await mkdir5(pathModule.dirname(pathModule.resolve(path48)), { recursive: true });
-  const tmp = `${path48}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  await mkdir5(pathModule.dirname(pathModule.resolve(path49)), { recursive: true });
+  const tmp = `${path49}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
     await writeFile5(tmp, JSON.stringify({ version: 1, hashes: sorted }, null, 2) + "\n");
-    await rename5(tmp, path48);
+    await rename5(tmp, path49);
   } finally {
     await rm5(tmp, { force: true });
   }
@@ -13757,15 +13827,27 @@ var NewAssetSchema = z6.object({
   /**
    * A controlled regeneration of another asset in the same manifest,
    * instead of a fresh generation. `inpaint` needs a mask upload the
-   * gallery does not offer yet, so only `image-to-image` can be created
-   * here; hand-edit the manifest for the other modes.
+   * gallery does not offer yet, so only `image-to-image` and
+   * `animate-skeleton` (whose keypoints file the gallery writes first) can
+   * be created here; hand-edit the manifest for the other modes.
    */
-  revision: z6.object({
-    mode: z6.literal("image-to-image"),
-    /** Asset id of the parent this revises; must already exist. */
-    from: z6.string().min(1),
-    strength: z6.number().min(0).max(1).optional()
-  }).strict().optional(),
+  revision: z6.discriminatedUnion("mode", [
+    z6.object({
+      mode: z6.literal("image-to-image"),
+      /** Asset id of the parent this revises; must already exist. */
+      from: z6.string().min(1),
+      strength: z6.number().min(0).max(1).optional()
+    }).strict(),
+    z6.object({
+      mode: z6.literal("animate-skeleton"),
+      from: z6.string().min(1),
+      /** Manifest-relative; checked when the manifest is loaded, like every revision input. */
+      keypointsFile: z6.string().min(1),
+      direction: CharacterDirectionSchema,
+      description: z6.string().min(1).optional(),
+      skeletonTemplate: z6.string().min(1).optional()
+    }).strict()
+  ]).optional(),
   /** A pose or outfit of an existing `character`/`objectPro` base or state. */
   state: NewStateSchema.optional(),
   /** A loop of an existing `character`/`objectPro` base or state. */
@@ -14290,52 +14372,165 @@ async function runEdit(args) {
 }
 
 // src/cli/commands/gallery.ts
-import path32 from "path";
-import { existsSync as existsSync23 } from "fs";
+import path33 from "path";
+import { existsSync as existsSync24 } from "fs";
 
 // src/gallery/snapshot.ts
 import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync19 } from "fs";
-import { readFile as readFile17, stat as stat2 } from "fs/promises";
-import path28 from "path";
+import { existsSync as existsSync20 } from "fs";
+import { readFile as readFile18, stat as stat2 } from "fs/promises";
+import path29 from "path";
 
 // src/gallery/edit.ts
+import path27 from "path";
+import { z as z9 } from "zod";
+
+// src/gallery/skeleton.ts
+import { existsSync as existsSync18 } from "fs";
+import { mkdir as mkdir10, readFile as readFile17, rm as rm9, writeFile as writeFile12 } from "fs/promises";
 import path26 from "path";
 import { z as z8 } from "zod";
-var Base64 = z8.string().regex(/^[A-Za-z0-9+/]*={0,2}$/).max(Math.ceil(MAX_HAND_EDIT_BYTES / 3) * 4);
-var HandEditRequestSchema = z8.discriminatedUnion("action", [
-  z8.object({
-    action: z8.literal("start-edit"),
-    project: z8.string().min(1).optional(),
-    assetId: z8.string().min(1),
-    styleId: z8.string().min(1),
-    expectedSha256: z8.string().regex(/^[0-9a-f]{64}$/),
+var SkeletonEstimateRequestSchema = z8.object({
+  project: z8.string().min(1).optional(),
+  styleId: z8.string().min(1),
+  assetId: z8.string().min(1),
+  frames: z8.number().int().min(3).max(15).optional()
+}).strict();
+var SkeletonAnimationRequestSchema = z8.object({
+  action: z8.literal("create-skeleton-animation"),
+  project: z8.string().min(1).optional(),
+  expectedSha256: z8.string().regex(/^[0-9a-f]{64}$/),
+  styleId: z8.string().min(1),
+  /** The sprite the animation poses. */
+  from: z8.string().min(1),
+  assetId: z8.string().min(1).regex(/^[^/\\]+$/, "asset ids cannot contain slashes"),
+  /** The motion, sent as PixelLab's `action`. */
+  prompt: z8.string().min(1),
+  direction: CharacterDirectionSchema,
+  description: z8.string().min(1).optional(),
+  skeletonTemplate: z8.string().min(1).optional(),
+  /** Manifest-relative JSON path inside the project. */
+  keypointsFile: z8.string().min(1),
+  /** Poses to write to `keypointsFile`; omitted to use a file that already exists. */
+  set: SkeletonSetSchema.optional(),
+  /** Replace an existing `keypointsFile` with `set`. */
+  overwrite: z8.boolean().optional()
+}).strict();
+function skeletonSourceFile(spec) {
+  if (spec.source) return path26.resolve(spec.root, spec.source);
+  if (spec.quality && existsSync18(spec.quality.outFile)) return spec.quality.outFile;
+  return spec.outFile;
+}
+function createGallerySkeletonHandlers(opts) {
+  const log2 = opts.onProgress ?? (() => {
+  });
+  return {
+    async estimate(body) {
+      const parsed = SkeletonEstimateRequestSchema.safeParse(body);
+      if (!parsed.success) throw new ManifestEditError(`invalid estimate request: ${parsed.error.issues[0]?.message}`);
+      const request = parsed.data;
+      const ctx = await opts.loadProject(request.project);
+      const key = lockKey(request.styleId, request.assetId);
+      const spec = ctx.specs.find((candidate) => lockKey(candidate.styleId, candidate.assetId) === key);
+      if (!spec) throw new ManifestEditError(`"${key}" is not declared by the manifest`);
+      const file = skeletonSourceFile(spec);
+      if (!existsSync18(file)) throw new ManifestEditError(`${key} has no image on disk to estimate from`);
+      const bytes = await readFile17(file);
+      const metadata = imageMetadata(bytes);
+      if (!metadata) throw new ManifestEditError(`${path26.basename(file)} is not a readable PNG or JPEG`);
+      const problem = estimateSkeletonSizeProblem(metadata.width, metadata.height);
+      if (problem) throw new ManifestEditError(`${key} is ${problem}`);
+      const client2 = (opts.client ?? clientFromEnv)();
+      const res = await client2.estimateSkeleton({ image: { base64: bytes.toString("base64"), format: metadata.format } });
+      log2(`  estimated a skeleton for ${key} (PixelLab estimate-skeleton, not budgeted)`);
+      return {
+        set: scaffoldSkeletonSet(res.keypoints, request.frames ?? DEFAULT_SCAFFOLD_FRAMES),
+        source: path26.relative(ctx.loaded.root, file).split(path26.sep).join("/")
+      };
+    }
+  };
+}
+async function createSkeletonAnimation(manifestPath, request) {
+  const root = path26.dirname(path26.resolve(manifestPath));
+  const file = path26.resolve(root, request.keypointsFile);
+  const relative = path26.relative(root, file);
+  if (!request.keypointsFile.endsWith(".json") || relative.startsWith("..") || path26.isAbsolute(relative)) {
+    throw new ManifestEditError("the keypoints file must be a .json path inside the project");
+  }
+  const existed = existsSync18(file);
+  let previous = null;
+  if (request.set) {
+    if (existed && !request.overwrite) {
+      throw new ManifestEditError(`${request.keypointsFile} already exists; choose another path, or replace it`);
+    }
+    if (existed) previous = await readFile17(file);
+    await mkdir10(path26.dirname(file), { recursive: true });
+    await writeFile12(file, JSON.stringify(request.set, null, 2) + "\n");
+  } else if (!existed) {
+    throw new ManifestEditError(`${request.keypointsFile} does not exist; paste poses or estimate them from the sprite`);
+  }
+  try {
+    await applyManifestEdit(manifestPath, {
+      action: "add-asset",
+      assetId: request.assetId,
+      expectedSha256: request.expectedSha256,
+      asset: {
+        prompt: request.prompt,
+        styles: [request.styleId],
+        revision: {
+          mode: "animate-skeleton",
+          from: request.from,
+          keypointsFile: relative.split(path26.sep).join("/"),
+          direction: request.direction,
+          ...request.description ? { description: request.description } : {},
+          ...request.skeletonTemplate ? { skeletonTemplate: request.skeletonTemplate } : {}
+        }
+      }
+    });
+  } catch (error) {
+    if (request.set) {
+      if (previous) await writeFile12(file, previous);
+      else await rm9(file, { force: true });
+    }
+    throw error;
+  }
+}
+
+// src/gallery/edit.ts
+var Base64 = z9.string().regex(/^[A-Za-z0-9+/]*={0,2}$/).max(Math.ceil(MAX_HAND_EDIT_BYTES / 3) * 4);
+var HandEditRequestSchema = z9.discriminatedUnion("action", [
+  z9.object({
+    action: z9.literal("start-edit"),
+    project: z9.string().min(1).optional(),
+    assetId: z9.string().min(1),
+    styleId: z9.string().min(1),
+    expectedSha256: z9.string().regex(/^[0-9a-f]{64}$/),
     /** Also launch the author's editor on the file. */
-    open: z8.boolean().optional()
+    open: z9.boolean().optional()
   }).strict(),
-  z8.object({
-    action: z8.literal("detach-edit"),
-    project: z8.string().min(1).optional(),
-    assetId: z8.string().min(1),
-    styleId: z8.string().min(1),
-    expectedSha256: z8.string().regex(/^[0-9a-f]{64}$/)
+  z9.object({
+    action: z9.literal("detach-edit"),
+    project: z9.string().min(1).optional(),
+    assetId: z9.string().min(1),
+    styleId: z9.string().min(1),
+    expectedSha256: z9.string().regex(/^[0-9a-f]{64}$/)
   }).strict(),
   /** From the in-browser editor: the page holds the bytes, the server validates and writes. */
-  z8.object({
-    action: z8.literal("save-edit"),
-    project: z8.string().min(1).optional(),
-    assetId: z8.string().min(1),
-    styleId: z8.string().min(1),
-    expectedSha256: z8.string().regex(/^[0-9a-f]{64}$/),
+  z9.object({
+    action: z9.literal("save-edit"),
+    project: z9.string().min(1).optional(),
+    assetId: z9.string().min(1),
+    styleId: z9.string().min(1),
+    expectedSha256: z9.string().regex(/^[0-9a-f]{64}$/),
     /** The flattened image; for a frame set, `frames` instead. */
     png: Base64.min(1).optional(),
     /** Every frame of a set, tagged with the role it was opened under (null for one added in the editor). */
-    frames: z8.array(z8.object({ role: z8.string().min(1).nullable(), png: Base64.min(1) }).strict()).min(1).max(256).optional(),
+    frames: z9.array(z9.object({ role: z9.string().min(1).nullable(), png: Base64.min(1) }).strict()).min(1).max(256).optional(),
     /** The editor's layered project file, kept beside the edit. */
     pxo: Base64.optional(),
     /** Editor identity from the bridge's ready message. */
-    editor: z8.string().min(1).max(200),
-    protocol: z8.number().int().positive()
+    editor: z9.string().min(1).max(200),
+    protocol: z9.number().int().positive()
   }).strict()
 ]);
 function createGalleryEditHandler(opts) {
@@ -14376,6 +14571,23 @@ function createGalleryEditHandler(opts) {
       }
       return opts.reload();
     }
+    const skeleton = SkeletonAnimationRequestSchema.safeParse(body);
+    if (skeleton.success) {
+      let manifestPath2;
+      try {
+        manifestPath2 = await opts.manifestFor(skeleton.data.project);
+      } catch (error) {
+        throw new ManifestEditError(error instanceof Error ? error.message : String(error));
+      }
+      await createSkeletonAnimation(manifestPath2, skeleton.data);
+      log2(`  manifest edited: added skeleton animation ${skeleton.data.assetId} (${skeleton.data.keypointsFile})`);
+      return opts.reload();
+    }
+    if (body?.action === "create-skeleton-animation") {
+      throw new ManifestEditError(
+        "invalid skeleton animation: " + skeleton.error.issues.slice(0, 3).map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")
+      );
+    }
     const parsed = ManifestEditSchema.safeParse(body);
     if (!parsed.success) {
       throw new ManifestEditError(
@@ -14390,7 +14602,7 @@ function createGalleryEditHandler(opts) {
     }
     const result = await applyManifestEdit(manifestPath, parsed.data);
     if (result.changed) {
-      const relative = path26.relative(process.cwd(), result.manifestPath);
+      const relative = path27.relative(process.cwd(), result.manifestPath);
       const shown = !relative || relative.startsWith("..") ? result.manifestPath : relative;
       const subject = parsed.data.action === "patch-style" ? `style ${parsed.data.styleId}` : parsed.data.action === "set-source" || parsed.data.action === "clear-source" ? `${parsed.data.styleId}/${parsed.data.assetId} source` : parsed.data.assetId;
       log2(`  manifest edited: ${parsed.data.action === "add-asset" ? "added" : "changed"} ${subject} in ${shown}`);
@@ -14400,8 +14612,8 @@ function createGalleryEditHandler(opts) {
 }
 
 // src/pipeline/history.ts
-import { existsSync as existsSync18 } from "fs";
-import path27 from "path";
+import { existsSync as existsSync19 } from "fs";
+import path28 from "path";
 var HISTORY_ENV = "PIXELKILN_HISTORY";
 function historyLimit(manifest, env = process.env) {
   if (manifest?.history !== void 0) return manifest.history;
@@ -14488,10 +14700,10 @@ async function revertGeneration(provider, spec, lock, lockPath, opts) {
   }
   for (let i = 0; i < entry.outputs.length; i++) {
     const file = currentEntryOutputPath(entry, spec, i);
-    if (!existsSync18(file)) continue;
+    if (!existsSync19(file)) continue;
     if (await sha256File(file) !== entry.outputs[i].sha256 && !opts.force) {
       throw new OverwriteRefusedError(
-        `${path27.relative(process.cwd(), file)} was changed after download; keep it with pixelkiln edit, or pass --force to replace it`,
+        `${path28.relative(process.cwd(), file)} was changed after download; keep it with pixelkiln edit, or pass --force to replace it`,
         [file]
       );
     }
@@ -14544,7 +14756,7 @@ async function revertGeneration(provider, spec, lock, lockPath, opts) {
 // src/gallery/snapshot.ts
 var PROJECT_FILE_TYPE = "application/octet-stream";
 function galleryMediaId(absolutePath) {
-  return createHash3("sha256").update(path28.resolve(absolutePath)).digest("hex").slice(0, 24);
+  return createHash3("sha256").update(path29.resolve(absolutePath)).digest("hex").slice(0, 24);
 }
 function galleryMediaRoute(id) {
   return `/media/${id}`;
@@ -14563,9 +14775,9 @@ function describeHistory(media, entry, cacheDir) {
   return (entry.history ?? []).map((generation, i) => {
     const outputs = generation.outputs.map((output) => {
       const mediaType = output.mediaType ?? MediaType.PNG;
-      const file = path28.join(cacheDir, cacheFileName(output.sha256, mediaType));
+      const file = path29.join(cacheDir, cacheFileName(output.sha256, mediaType));
       let url = null;
-      if (existsSync19(file)) {
+      if (existsSync20(file)) {
         const id = galleryMediaId(file);
         media.set(id, { path: file, contentType: mediaType });
         url = `${galleryMediaRoute(id)}?v=${output.sha256.slice(0, 24)}`;
@@ -14597,7 +14809,7 @@ function describeHistory(media, entry, cacheDir) {
 var MAX_COMPARED_BYTES = 8 * 1024 * 1024;
 async function samePixels(a, b) {
   try {
-    const [left, right] = await Promise.all([readFile17(a), readFile17(b)]);
+    const [left, right] = await Promise.all([readFile18(a), readFile18(b)]);
     if (left.length > MAX_COMPARED_BYTES || right.length > MAX_COMPARED_BYTES) return false;
     const x = decodePng(left);
     const y = decodePng(right);
@@ -14695,10 +14907,10 @@ async function describeOutput(media, root, absolutePath, recorded = {}) {
 async function describeQuality(media, root, inspection) {
   const outputPaths = inspection.outputs ?? [inspection.output];
   const outputs = await Promise.all(
-    outputPaths.map((file) => describeOutput(media, root, path28.resolve(root, file)))
+    outputPaths.map((file) => describeOutput(media, root, path29.resolve(root, file)))
   );
-  const recordPath = path28.resolve(root, inspection.record);
-  const recordExists = existsSync19(recordPath);
+  const recordPath = path29.resolve(root, inspection.record);
+  const recordExists = existsSync20(recordPath);
   let options = null;
   let check = null;
   if (recordExists) {
@@ -14717,7 +14929,7 @@ async function describeQuality(media, root, inspection) {
   return {
     state: inspection.state,
     reason: inspection.reason,
-    output: portableOutputPath(path28.resolve(root, inspection.output), root),
+    output: portableOutputPath(path29.resolve(root, inspection.output), root),
     record: portableOutputPath(recordPath, root),
     recordExists,
     outputs,
@@ -14755,9 +14967,9 @@ async function buildGallerySnapshot(opts) {
   const media = /* @__PURE__ */ new Map();
   const plan = await buildPlan(specs, lock);
   const items = [];
-  const manifestText = await readFile17(loaded.path, "utf8");
+  const manifestText = await readFile18(loaded.path, "utf8");
   const manifestSha256 = sha256(manifestText);
-  const cacheDir = path28.resolve(path28.dirname(opts.lockPath), ".pixelkiln", "cache");
+  const cacheDir = path29.resolve(path29.dirname(opts.lockPath), ".pixelkiln", "cache");
   let rawStyles = {};
   try {
     const raw = JSON.parse(manifestText);
@@ -14781,12 +14993,12 @@ async function buildGallerySnapshot(opts) {
         )
       );
       if (spec.source) {
-        const editPath = path28.resolve(root, spec.source);
+        const editPath = path29.resolve(root, spec.source);
         const memberCount = sourceIsStem(spec.source, entry, root) ? entry.outputs.length : 1;
         const editShas = await Promise.all(
           Array.from({ length: memberCount }, async (_, index) => {
             const file = sourceOutputPath(spec.source, entry, index, root);
-            return { file, sha256: existsSync19(file) ? await sha256File(file) : null };
+            return { file, sha256: existsSync20(file) ? await sha256File(file) : null };
           })
         );
         edits = await Promise.all(editShas.map(({ file, sha256: editSha }) => describeOutput(media, root, file, { sha256: editSha })));
@@ -14794,7 +15006,7 @@ async function buildGallerySnapshot(opts) {
         const companion = await readHandEditCompanion(editPath);
         if (companion) {
           const projectPath = handEditProjectPath(editPath);
-          const project = companion.project && existsSync19(projectPath) ? await fileInfo(projectPath) : null;
+          const project = companion.project && existsSync20(projectPath) ? await fileInfo(projectPath) : null;
           let projectUrl = null;
           if (project) {
             const id = galleryMediaId(projectPath);
@@ -14830,8 +15042,8 @@ async function buildGallerySnapshot(opts) {
         editStatus = edits.some((member) => !member.exists) ? "missing" : editChanged.every((changed) => !changed) ? "same" : regenerated ? "regenerated-since" : "edited";
       }
     } else if (spec.source) {
-      outputs = [await describeOutput(media, root, path28.resolve(root, spec.source))];
-    } else if (!entry && existsSync19(spec.outFile)) {
+      outputs = [await describeOutput(media, root, path29.resolve(root, spec.source))];
+    } else if (!entry && existsSync20(spec.outFile)) {
       outputs = [await describeOutput(media, root, spec.outFile)];
     } else {
       outputs = [];
@@ -14872,6 +15084,10 @@ async function buildGallerySnapshot(opts) {
       revision: entry?.revision ?? null,
       revisionParentKey: spec.revision ? lockKey(spec.styleId, spec.revision.sourceAssetId) : entry?.revision ? lockKey(spec.styleId, entry.revision.sourceAssetId) : null,
       mirrorOfKey: spec.mirror ? lockKey(spec.styleId, spec.mirror.sourceAssetId) : entry?.mirror ? lockKey(spec.styleId, entry.mirror.sourceAssetId) : null,
+      skeleton: spec.revision?.mode === "animate-skeleton" && spec.revision.keypointsFile ? {
+        keypointsFile: portableOutputPath(spec.revision.keypointsFile, root),
+        set: spec.revision.skeleton ?? null
+      } : null,
       character: describeCharacter(spec, entry),
       outputs,
       quality,
@@ -14936,6 +15152,7 @@ async function buildGallerySnapshot(opts) {
       revision: entry.revision,
       revisionParentKey: entry.revision ? lockKey(entry.styleId, entry.revision.sourceAssetId) : null,
       mirrorOfKey: entry.mirror ? lockKey(entry.styleId, entry.mirror.sourceAssetId) : null,
+      skeleton: null,
       character: describeCharacter(void 0, entry),
       outputs,
       quality: null,
@@ -15026,7 +15243,7 @@ async function buildGallerySnapshot(opts) {
       id: loaded.manifest.name,
       name: loaded.manifest.name,
       manifest: loaded.path,
-      lock: path28.resolve(opts.lockPath),
+      lock: path29.resolve(opts.lockPath),
       root,
       provider: loaded.manifest.provider,
       account: null,
@@ -15052,7 +15269,7 @@ async function buildGallerySnapshot(opts) {
   return { snapshot, media };
 }
 async function buildWorkspaceGallerySnapshot(opts) {
-  const dir = path28.dirname(path28.resolve(opts.workspacePath));
+  const dir = path29.dirname(path29.resolve(opts.workspacePath));
   const media = /* @__PURE__ */ new Map();
   const projects = [];
   const items = [];
@@ -15095,11 +15312,11 @@ async function buildWorkspaceGallerySnapshot(opts) {
         id: project.id,
         name: loaded.manifest.name,
         manifest: manifestPath,
-        lock: path28.resolve(lockPath),
+        lock: path29.resolve(lockPath),
         root: loaded.root,
         provider: loaded.manifest.provider,
         account: project.account ?? null,
-        manifestSha256: manifestSha256 ?? sha256(await readFile17(manifestPath, "utf8")),
+        manifestSha256: manifestSha256 ?? sha256(await readFile18(manifestPath, "utf8")),
         historyLimit: historyLimit(loaded.manifest),
         entries: Object.keys(lock.entries).length,
         items: projectItems.length,
@@ -15111,8 +15328,8 @@ async function buildWorkspaceGallerySnapshot(opts) {
         id: project.id,
         name: project.id,
         manifest: manifestPath,
-        lock: path28.resolve(lockPath),
-        root: path28.dirname(manifestPath),
+        lock: path29.resolve(lockPath),
+        root: path29.dirname(manifestPath),
         provider: project.provider,
         account: project.account ?? null,
         manifestSha256: null,
@@ -15139,7 +15356,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
       version: 1,
       generatedAt: (opts.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
       project: null,
-      workspace: { path: path28.resolve(opts.workspacePath), dir, projects },
+      workspace: { path: path29.resolve(opts.workspacePath), dir, projects },
       filter,
       totals: {
         entries: projects.reduce((sum, project) => sum + project.entries, 0),
@@ -15158,7 +15375,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
 // src/gallery/server.ts
 import { randomBytes } from "crypto";
 import { createServer as createServer2 } from "http";
-import { readFile as readFile18 } from "fs/promises";
+import { readFile as readFile19 } from "fs/promises";
 
 // src/gallery/page.ts
 import { readFileSync as readFileSync4 } from "fs";
@@ -15268,7 +15485,7 @@ async function readJsonBody(req) {
 async function serveGallery(opts) {
   const log2 = opts.onProgress ?? (() => {
   });
-  const session = opts.edit || opts.generate || opts.editor ? randomBytes(16).toString("hex") : null;
+  const session = opts.edit || opts.generate || opts.editor || opts.skeleton ? randomBytes(16).toString("hex") : null;
   let media = /* @__PURE__ */ new Map();
   let loading = null;
   const reviewAssets = /* @__PURE__ */ new Map();
@@ -15343,6 +15560,17 @@ async function serveGallery(opts) {
       }
       return;
     }
+    if (req.method === "POST" && url2.pathname === "/api/skeleton/estimate") {
+      if (!opts.skeleton || !session) return fail(405, "skeleton estimates need the gallery started with --edit");
+      try {
+        const body = await guardedBody("skeleton estimates");
+        if (body === void 0) return;
+        json(200, await opts.skeleton.estimate(body));
+      } catch (err) {
+        reportError("skeleton estimate", err);
+      }
+      return;
+    }
     if (req.method === "POST" && url2.pathname === "/api/editor/install") {
       if (!opts.editor || !session) return fail(405, "the in-browser editor is off for this gallery");
       try {
@@ -15399,7 +15627,7 @@ async function serveGallery(opts) {
         const asset = reviewAssets.get(jobId)?.get(url2.pathname);
         if (!asset) return fail(404, "no such review asset");
         try {
-          const bytes = await readFile18(asset.path);
+          const bytes = await readFile19(asset.path);
           res.writeHead(200, {
             "Content-Type": asset.contentType,
             "Cache-Control": "no-store",
@@ -15475,7 +15703,7 @@ async function serveGallery(opts) {
         if (!asset) return fail(404, "no such gallery media");
         let bytes;
         try {
-          bytes = await readFile18(asset.path);
+          bytes = await readFile19(asset.path);
         } catch {
           return fail(404, "gallery media is no longer on disk; refresh the page");
         }
@@ -15519,7 +15747,7 @@ async function serveGallery(opts) {
 
 // src/gallery/generate.ts
 import { randomBytes as randomBytes2 } from "crypto";
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 
 // src/pipeline/poll.ts
 var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
@@ -15930,13 +16158,13 @@ function ownedReferenceImageId(spec, lock, providerId) {
 }
 
 // src/pick/server.ts
-import { existsSync as existsSync21 } from "fs";
-import { readFile as readFile20 } from "fs/promises";
+import { existsSync as existsSync22 } from "fs";
+import { readFile as readFile21 } from "fs/promises";
 
 // src/pipeline/init.ts
-import { readdir, readFile as readFile19, writeFile as writeFile12 } from "fs/promises";
-import { existsSync as existsSync20 } from "fs";
-import path29 from "path";
+import { readdir, readFile as readFile20, writeFile as writeFile13 } from "fs/promises";
+import { existsSync as existsSync21 } from "fs";
+import path30 from "path";
 function pngSize(buf) {
   if (buf.length < 24) return null;
   const isPng = buf.readUInt32BE(0) === 2303741511 && buf.readUInt32BE(4) === 218765834;
@@ -15950,7 +16178,7 @@ function slugify(value) {
 async function walk(dir, exclude) {
   const out = [];
   for (const entry of await readdir(dir, { withFileTypes: true })) {
-    const full = path29.join(dir, entry.name);
+    const full = path30.join(dir, entry.name);
     if (exclude.some((x) => full.includes(x))) continue;
     if (entry.isDirectory()) out.push(...await walk(full, exclude));
     else if (entry.name.toLowerCase().endsWith(".png")) out.push(full);
@@ -15964,14 +16192,14 @@ async function scanAssets(root, opts = {}) {
   const skipped = [];
   const seen = /* @__PURE__ */ new Map();
   for (const file of files.sort()) {
-    const size = pngSize(await readFile19(file));
+    const size = pngSize(await readFile20(file));
     if (!size) {
       skipped.push(`${file} (not a readable PNG)`);
       continue;
     }
-    const rel = path29.relative(root, file);
-    const category = path29.dirname(rel) === "." ? "" : path29.dirname(rel);
-    let id = slugify(path29.basename(rel));
+    const rel = path30.relative(root, file);
+    const category = path30.dirname(rel) === "." ? "" : path30.dirname(rel);
+    let id = slugify(path30.basename(rel));
     if (seen.has(id)) {
       const n = seen.get(id) + 1;
       seen.set(id, n);
@@ -16029,10 +16257,10 @@ function mode(values) {
   return [...counts.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? 64;
 }
 async function writeManifestFile(target, manifest) {
-  if (existsSync20(target)) {
+  if (existsSync21(target)) {
     throw new Error(`${target} already exists; refusing to overwrite an existing manifest.`);
   }
-  await writeFile12(target, JSON.stringify(manifest, null, 2) + "\n");
+  await writeFile13(target, JSON.stringify(manifest, null, 2) + "\n");
 }
 
 // src/pick/sheet.ts
@@ -16445,13 +16673,13 @@ async function currentArt(entry, spec) {
   const previous = primaryOutput({ ...entry, outputs: entry.supersededOutputs });
   if (!previous) return null;
   const file = resolveOutputPath(previous.path, spec.root);
-  if (!existsSync21(file)) return null;
+  if (!existsSync22(file)) return null;
   const contentType = previous.mediaType ?? mediaTypeFromExtension(file);
   if (!contentType) return null;
   let width = entry.width;
   let height = entry.height;
   if (contentType === "image/png") {
-    const size = pngSize(await readFile20(file));
+    const size = pngSize(await readFile21(file));
     if (size) ({ width, height } = size);
   }
   return { path: file, contentType, width, height };
@@ -16619,26 +16847,26 @@ async function runPicker(provider, lock, lockPath, opts = {}) {
 }
 
 // src/gallery/generate.ts
-var GenerateRequestSchema = z9.object({
-  project: z9.string().min(1).optional(),
-  keys: z9.array(z9.string().min(1)).min(1).max(500),
+var GenerateRequestSchema = z10.object({
+  project: z10.string().min(1).optional(),
+  keys: z10.array(z10.string().min(1)).min(1).max(500),
   /**
    * Regenerate work that is up to date, as `gen --force` does, and let the
    * fetch replace a locally modified or untracked file. With `restore`, put
    * the recorded bytes back over a modified file.
    */
-  force: z9.boolean().optional(),
+  force: z10.boolean().optional(),
   /** Advance in-flight, review, or selected work without submitting anything. */
-  resume: z9.boolean().optional(),
+  resume: z10.boolean().optional(),
   /** Re-download downloaded outputs and replace files whose object changed upstream. */
-  refresh: z9.boolean().optional(),
+  refresh: z10.boolean().optional(),
   /** Put recorded outputs back on disk from the cache or the provider, without generating. */
-  restore: z9.boolean().optional(),
+  restore: z10.boolean().optional(),
   /**
    * Bring a replaced generation back: 1-based position in the record's
    * history (newest first) or an output hash prefix. One key at a time.
    */
-  revert: z9.string().min(1).max(64).optional()
+  revert: z10.string().min(1).max(64).optional()
 }).strict().refine((request) => [request.resume, request.refresh, request.restore, request.revert !== void 0].filter(Boolean).length <= 1, {
   message: "resume, refresh, restore, and revert are exclusive"
 }).refine((request) => request.revert === void 0 || request.keys.length === 1, { message: "revert takes one key" });
@@ -16948,15 +17176,15 @@ function createGenerateHandlers(opts) {
 }
 
 // src/gallery/editor.ts
-import { readFile as readFile22 } from "fs/promises";
-import path31 from "path";
+import { readFile as readFile23 } from "fs/promises";
+import path32 from "path";
 
 // src/editor/install.ts
 import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync22 } from "fs";
-import { mkdir as mkdir10, readFile as readFile21, rename as rename9, rm as rm9, stat as stat3, writeFile as writeFile13 } from "fs/promises";
+import { existsSync as existsSync23 } from "fs";
+import { mkdir as mkdir11, readFile as readFile22, rename as rename9, rm as rm10, stat as stat3, writeFile as writeFile14 } from "fs/promises";
 import os2 from "os";
-import path30 from "path";
+import path31 from "path";
 
 // tools/pixelorama-bridge/pin.json
 var pin_default = {
@@ -17020,15 +17248,15 @@ var EditorInstallError = class extends Error {
 };
 function editorToolsRoot() {
   const override = process.env.PIXELKILN_TOOLS_DIR?.trim();
-  if (override) return path30.resolve(override);
-  if (process.platform === "darwin") return path30.join(os2.homedir(), "Library", "Caches", "pixelkiln", "tools");
+  if (override) return path31.resolve(override);
+  if (process.platform === "darwin") return path31.join(os2.homedir(), "Library", "Caches", "pixelkiln", "tools");
   if (process.platform === "win32") {
-    return path30.join(process.env.LOCALAPPDATA ?? path30.join(os2.homedir(), "AppData", "Local"), "pixelkiln", "tools");
+    return path31.join(process.env.LOCALAPPDATA ?? path31.join(os2.homedir(), "AppData", "Local"), "pixelkiln", "tools");
   }
-  return path30.join(process.env.XDG_CACHE_HOME ?? path30.join(os2.homedir(), ".cache"), "pixelkiln", "tools");
+  return path31.join(process.env.XDG_CACHE_HOME ?? path31.join(os2.homedir(), ".cache"), "pixelkiln", "tools");
 }
 function editorDir(pin = EDITOR_PIN, root = editorToolsRoot()) {
-  return path30.join(root, "pixelorama", pin.release ?? "unpublished");
+  return path31.join(root, "pixelorama", pin.release ?? "unpublished");
 }
 function editorBaseUrl(pin = EDITOR_PIN) {
   const override = process.env.PIXELKILN_EDITOR_URL?.trim();
@@ -17038,7 +17266,7 @@ function editorBaseUrl(pin = EDITOR_PIN) {
 }
 async function sha256Of(file) {
   try {
-    return createHash4("sha256").update(await readFile21(file)).digest("hex");
+    return createHash4("sha256").update(await readFile22(file)).digest("hex");
   } catch {
     return null;
   }
@@ -17051,8 +17279,8 @@ async function editorStatus(opts = {}) {
   let totalBytes = 0;
   for (const [name, expected] of Object.entries(pin.files)) {
     totalBytes += expected.bytes;
-    const file = path30.join(dir, name);
-    const info = existsSync22(file) ? await stat3(file).catch(() => null) : null;
+    const file = path31.join(dir, name);
+    const info = existsSync23(file) ? await stat3(file).catch(() => null) : null;
     if (info && info.size === expected.bytes && await sha256Of(file) === expected.sha256) {
       installedBytes += expected.bytes;
     } else {
@@ -17081,7 +17309,7 @@ async function installEditor(opts = {}) {
     );
   }
   if (!baseUrl) throw new EditorInstallError("no download location for the editor build");
-  await mkdir10(dir, { recursive: true });
+  await mkdir11(dir, { recursive: true });
   const downloaded = [];
   const skipped = Object.keys(pin.files).filter((name) => !before.missing.includes(name));
   let fetchedBytes = before.installedBytes;
@@ -17109,13 +17337,13 @@ async function installEditor(opts = {}) {
     if (digest2 !== expected.sha256) {
       throw new EditorInstallError(`${name}: sha256 ${digest2.slice(0, 12)}\u2026 does not match the pinned ${expected.sha256.slice(0, 12)}\u2026`, name);
     }
-    const final = path30.join(dir, name);
+    const final = path31.join(dir, name);
     const tmp = `${final}.${process.pid}.part`;
     try {
-      await writeFile13(tmp, bytes);
+      await writeFile14(tmp, bytes);
       await rename9(tmp, final);
     } finally {
-      await rm9(tmp, { force: true });
+      await rm10(tmp, { force: true });
     }
     fetchedBytes += bytes.length;
     downloaded.push(name);
@@ -17155,7 +17383,7 @@ var EDITOR_CONTENT_TYPES = {
   ".json": "application/json; charset=utf-8"
 };
 function editorContentType(name) {
-  return EDITOR_CONTENT_TYPES[path30.extname(name).toLowerCase()] ?? null;
+  return EDITOR_CONTENT_TYPES[path31.extname(name).toLowerCase()] ?? null;
 }
 
 // src/gallery/editor.ts
@@ -17231,7 +17459,7 @@ function createGalleryEditorHandlers(opts = {}) {
       if (!status.installed) return null;
       let bytes;
       try {
-        bytes = await readFile22(path31.join(dir, name));
+        bytes = await readFile23(path32.join(dir, name));
       } catch {
         verified = null;
         return null;
@@ -17271,13 +17499,13 @@ async function serveUntilStopped(initial, reload, args, access2) {
   };
   const loadProject = async (project) => {
     const ctx = await access2.loadProject(project);
-    const dir = path32.dirname(ctx.loaded.path);
+    const dir = path33.dirname(ctx.loaded.path);
     const declared = readEnvFiles(dir);
     const credentialNames = new Set(availableProviders().flatMap((id) => providerCredentialEnvs(providerFactory(id))));
     for (const [name, value] of Object.entries(declared)) {
       if (credentialNames.has(name) && name in process.env && process.env[name] !== value) {
         throw new Error(
-          `${path32.relative(process.cwd(), dir) || "."} sets ${name} to a different value than the one this gallery already loaded; run a separate gallery for that project so its work uses its own account.`
+          `${path33.relative(process.cwd(), dir) || "."} sets ${name} to a different value than the one this gallery already loaded; run a separate gallery for that project so its work uses its own account.`
         );
       }
     }
@@ -17305,6 +17533,8 @@ async function serveUntilStopped(initial, reload, args, access2) {
     ),
     ...args.edit ? { edit: createGalleryEditHandler({ manifestFor: access2.manifestFor, loadProject: access2.loadProject, reload, onProgress: log }) } : {},
     ...budget ? { generate: createGenerateHandlers({ loadProject, providerFor, budget, reload, onProgress: log }) } : {},
+    // Estimating acts on the author's behalf and feeds a manifest edit, so it follows the write gate.
+    ...args.edit ? { skeleton: createGallerySkeletonHandlers({ loadProject, onProgress: log }) } : {},
     // The editor exists to write hand edits back, so it follows the write gate.
     ...args.edit && !args.noEditor ? { editor: createGalleryEditorHandlers({ onProgress: log }) } : {}
   });
@@ -17322,8 +17552,8 @@ async function serveUntilStopped(initial, reload, args, access2) {
 }
 async function runGallery(args) {
   if (args.workspace) {
-    const workspacePath = path32.resolve(args.workspace);
-    if (!existsSync23(workspacePath)) {
+    const workspacePath = path33.resolve(args.workspace);
+    if (!existsSync24(workspacePath)) {
       throw new Error(`Workspace catalog not found: ${workspacePath}`);
     }
     const filter2 = { styles: args.styles, assets: args.assets };
@@ -17343,7 +17573,7 @@ async function runGallery(args) {
     const registered = async (projectId) => {
       const project = (await loadWorkspace(workspacePath)).projects.find((candidate) => candidate.id === projectId);
       if (!projectId || !project) throw new Error(`unknown workspace project "${projectId ?? ""}"`);
-      return resolveProject(path32.dirname(workspacePath), project);
+      return resolveProject(path33.dirname(workspacePath), project);
     };
     await serveUntilStopped(initial, build2, args, {
       manifestFor: async (projectId) => (await registered(projectId)).manifestPath,
@@ -17368,7 +17598,7 @@ async function runGallery(args) {
     return buildGallerySnapshot({ ...fresh, filter });
   };
   await serveUntilStopped(await build(), reload, args, {
-    manifestFor: () => path32.resolve(args.manifest),
+    manifestFor: () => path33.resolve(args.manifest),
     loadProject: () => openProject(args.manifest, { lockPath: args.lock, env: false })
   });
 }
@@ -17677,18 +17907,18 @@ async function runRestoreGeneration(args) {
 }
 
 // src/cli/commands/housekeeping.ts
-import { existsSync as existsSync25 } from "fs";
+import { existsSync as existsSync26 } from "fs";
 
 // src/pipeline/cache-health.ts
-import { existsSync as existsSync24 } from "fs";
-import { readFile as readFile23, readdir as readdir2, rm as rm10 } from "fs/promises";
-import path33 from "path";
+import { existsSync as existsSync25 } from "fs";
+import { readFile as readFile24, readdir as readdir2, rm as rm11 } from "fs/promises";
+import path34 from "path";
 async function inspectCaches(lock, lockPath, options = {}) {
-  if (options.prune && !existsSync24(lockPath)) {
-    throw new Error(`Refusing to prune without an existing lockfile at ${path33.resolve(lockPath)}`);
+  if (options.prune && !existsSync25(lockPath)) {
+    throw new Error(`Refusing to prune without an existing lockfile at ${path34.resolve(lockPath)}`);
   }
-  const contentDir = path33.resolve(path33.dirname(lockPath), ".pixelkiln", "cache");
-  const remotePath = path33.resolve(cachePathFor(lockPath));
+  const contentDir = path34.resolve(path34.dirname(lockPath), ".pixelkiln", "cache");
+  const remotePath = path34.resolve(cachePathFor(lockPath));
   const referenced = referencedHashes(lock);
   let content = await inspectContentCache(contentDir, referenced);
   let remoteHashes = await inspectRemoteHashCache(remotePath);
@@ -17700,7 +17930,7 @@ async function inspectCaches(lock, lockPath, options = {}) {
     ]);
     for (const name of names) {
       try {
-        await rm10(path33.join(contentDir, name), { force: true });
+        await rm11(path34.join(contentDir, name), { force: true });
         removed.contentFiles++;
       } catch {
       }
@@ -17709,7 +17939,7 @@ async function inspectCaches(lock, lockPath, options = {}) {
       await saveCache(remotePath, { version: 1, hashes: {} });
       removed.resetRemoteHashCache = true;
     } else if (remoteHashes.invalidIds.length) {
-      const cache = parseCache(JSON.parse(await readFile23(remotePath, "utf8")));
+      const cache = parseCache(JSON.parse(await readFile24(remotePath, "utf8")));
       for (const id of remoteHashes.invalidIds) delete cache.hashes[id];
       removed.remoteHashEntries = remoteHashes.invalidIds.length;
       await saveCache(remotePath, cache);
@@ -17727,7 +17957,7 @@ async function inspectCaches(lock, lockPath, options = {}) {
 async function inspectContentCache(contentDir, referenced) {
   const report = {
     path: contentDir,
-    exists: existsSync24(contentDir),
+    exists: existsSync25(contentDir),
     files: 0,
     bytes: 0,
     valid: 0,
@@ -17748,12 +17978,12 @@ async function inspectContentCache(contentDir, referenced) {
       continue;
     }
     report.files++;
-    const file = path33.join(contentDir, entry.name);
+    const file = path34.join(contentDir, entry.name);
     const mediaType = mediaTypeFromExtension(entry.name);
     const expected = mediaType ? entry.name.slice(0, -4) : "";
     let bytes;
     try {
-      bytes = await readFile23(file);
+      bytes = await readFile24(file);
       report.bytes += bytes.length;
     } catch (err) {
       report.invalid.push({
@@ -17791,7 +18021,7 @@ async function inspectContentCache(contentDir, referenced) {
 async function inspectRemoteHashCache(remotePath) {
   const report = {
     path: remotePath,
-    exists: existsSync24(remotePath),
+    exists: existsSync25(remotePath),
     entries: 0,
     valid: 0,
     invalidIds: [],
@@ -17800,7 +18030,7 @@ async function inspectRemoteHashCache(remotePath) {
   if (!report.exists) return report;
   let cache;
   try {
-    cache = parseCache(JSON.parse(await readFile23(remotePath, "utf8")));
+    cache = parseCache(JSON.parse(await readFile24(remotePath, "utf8")));
   } catch (err) {
     report.error = err instanceof Error ? err.message : String(err);
     return report;
@@ -17864,7 +18094,7 @@ async function runAccept(args) {
     let intact = true;
     for (const output of entry.outputs) {
       const file = resolveOutputPath(output.path, item.spec.root);
-      if (!existsSync25(file) || await sha256File(file) !== output.sha256) {
+      if (!existsSync26(file) || await sha256File(file) !== output.sha256) {
         intact = false;
         break;
       }
@@ -17919,42 +18149,42 @@ This drops their provenance from the lockfile. The art on disk is`);
 }
 
 // src/cli/commands/init.ts
-import path34 from "path";
-import { existsSync as existsSync26 } from "fs";
+import path35 from "path";
+import { existsSync as existsSync27 } from "fs";
 async function runInit(args) {
   if (!args.from) throw new Error("init needs --from <dir> pointing at your existing PNGs.");
-  const root = path34.resolve(args.from);
-  if (!existsSync26(root)) throw new Error(`No directory at ${root}`);
+  const root = path35.resolve(args.from);
+  if (!existsSync27(root)) throw new Error(`No directory at ${root}`);
   const generator = args.generator ?? "map";
   if (generator !== "1dir" && generator !== "map") {
     throw new Error(`--generator must be "1dir" or "map", got "${args.generator}".`);
   }
-  const target = path34.resolve(args.out ?? "pixelkiln.manifest.json");
+  const target = path35.resolve(args.out ?? "pixelkiln.manifest.json");
   const { assets, skipped } = await scanAssets(root, { exclude: args.exclude });
   if (!assets.length) throw new Error(`No PNGs found under ${root}`);
   const manifest = buildManifest(
-    args.name ?? path34.basename(path34.dirname(target)),
+    args.name ?? path35.basename(path35.dirname(target)),
     args.styles[0] ?? "base",
     generator,
-    path34.relative(path34.dirname(target), root) || ".",
+    path35.relative(path35.dirname(target), root) || ".",
     assets
   );
   await writeManifestFile(target, manifest);
-  log(`  scanned ${assets.length} PNG(s) under ${path34.relative(process.cwd(), root)}`);
+  log(`  scanned ${assets.length} PNG(s) under ${path35.relative(process.cwd(), root)}`);
   if (skipped.length) log(`  skipped ${skipped.length} unreadable file(s)`);
-  log(`  wrote ${path34.relative(process.cwd(), target)}`);
+  log(`  wrote ${path35.relative(process.cwd(), target)}`);
   log(`
   Prompts are intentionally empty. To recover the real ones from your`);
   log(`  PixelLab account instead of inventing them:`);
   log(`
-    pixelkiln adopt --manifest ${path34.relative(process.cwd(), target)} --write-prompts
+    pixelkiln adopt --manifest ${path35.relative(process.cwd(), target)} --write-prompts
 `);
 }
 
 // src/pipeline/doctor.ts
-import { constants, existsSync as existsSync27 } from "fs";
+import { constants, existsSync as existsSync28 } from "fs";
 import { access, stat as stat4 } from "fs/promises";
-import path35 from "path";
+import path36 from "path";
 async function doctor(loaded, specs, lock, lockPath, opts = {}) {
   const checks = [];
   const add = (id, level, message6) => checks.push({ id, level, message: message6 });
@@ -17965,8 +18195,8 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
   );
   add("lock", "ok", `${Object.keys(lock.entries).length} valid v2 lock entr(ies)`);
   const dirs = [...new Set(specs.flatMap((spec) => [
-    path35.dirname(spec.outFile),
-    ...spec.quality ? [path35.dirname(spec.quality.outFile)] : []
+    path36.dirname(spec.outFile),
+    ...spec.quality ? [path36.dirname(spec.quality.outFile)] : []
   ]))];
   const unwritable = [];
   for (const dir of dirs) {
@@ -17989,7 +18219,7 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
     for (let index = 0; index < entry.outputs.length; index++) {
       const output = entry.outputs[index];
       const spec = specByKey.get(key);
-      const absolute = spec ? currentEntryOutputPath(entry, spec, index) : resolveOutputPath(output.path, path35.dirname(lockPath));
+      const absolute = spec ? currentEntryOutputPath(entry, spec, index) : resolveOutputPath(output.path, path36.dirname(lockPath));
       const owner = outputOwners.get(absolute);
       if (owner && owner !== key) duplicateOutputs.push(`${output.path} (${owner}, ${key})`);
       outputOwners.set(absolute, key);
@@ -18004,7 +18234,7 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
   } else {
     add("lock-outputs", "ok", `${outputOwners.size} recorded output path(s) are uniquely owned`);
   }
-  const cacheDir = path35.join(path35.dirname(lockPath), ".pixelkiln", "cache");
+  const cacheDir = path36.join(path36.dirname(lockPath), ".pixelkiln", "cache");
   const stranded = [];
   const invalidState = [];
   const staleMapUrls = [];
@@ -18020,11 +18250,11 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
     const hasSource = Boolean(entry.sourceUrl || entry.sourceUrls?.length);
     let hasCache = false;
     for (const output of entry.outputs) {
-      const cached = path35.join(
+      const cached = path36.join(
         cacheDir,
         cacheFileName(output.sha256, output.mediaType ?? MediaType.PNG)
       );
-      if (existsSync27(cached) && await sha256File(cached) === output.sha256) {
+      if (existsSync28(cached) && await sha256File(cached) === output.sha256) {
         hasCache = true;
         break;
       }
@@ -18120,16 +18350,16 @@ async function nearestExistingDirectory(start) {
       if ((await stat4(current)).isDirectory()) return current;
     } catch {
     }
-    const parent = path35.dirname(current);
+    const parent = path36.dirname(current);
     if (parent === current) return current;
     current = parent;
   }
 }
 
 // src/pipeline/audit.ts
-import { readFile as readFile24 } from "fs/promises";
-import { existsSync as existsSync28 } from "fs";
-import path36 from "path";
+import { readFile as readFile25 } from "fs/promises";
+import { existsSync as existsSync29 } from "fs";
+import path37 from "path";
 function paletteDistance(asset, reference) {
   if (!asset.length || !reference.length) return 0;
   let total = 0;
@@ -18165,12 +18395,12 @@ async function auditStyle(loaded, specs, styleId, lock) {
   const unreadable = [];
   for (const spec of mine) {
     for (const output of resolveSpecOutputs(spec, lock, loaded.root)) {
-      if (!existsSync28(output.absolutePath)) {
+      if (!existsSync29(output.absolutePath)) {
         missing.push(output.id);
         continue;
       }
       try {
-        const png = decodePng(await readFile24(output.absolutePath));
+        const png = decodePng(await readFile25(output.absolutePath));
         const palette = extractPalette(png, 12);
         assets.push({
           assetId: spec.assetId,
@@ -18194,10 +18424,10 @@ async function auditStyle(loaded, specs, styleId, lock) {
   let referenceFromStyleImages = false;
   const refPalettes = [];
   for (const img of style.styleImages) {
-    const abs = path36.resolve(loaded.root, img.path);
-    if (!existsSync28(abs)) continue;
+    const abs = path37.resolve(loaded.root, img.path);
+    if (!existsSync29(abs)) continue;
     try {
-      refPalettes.push(extractPalette(decodePng(await readFile24(abs)), 12));
+      refPalettes.push(extractPalette(decodePng(await readFile25(abs)), 12));
     } catch {
     }
   }
@@ -18425,24 +18655,24 @@ async function runAudit(args) {
 }
 
 // src/cli/commands/pack.ts
-import path38 from "path";
-import { readFile as readFile25 } from "fs/promises";
+import path39 from "path";
+import { readFile as readFile26 } from "fs/promises";
 
 // src/pipeline/pack.ts
 import { readFileSync as readFileSync5 } from "fs";
-import path37 from "path";
+import path38 from "path";
 var DEFAULT_FRAME_SET_FPS = 12;
 function resolvePackInputs(raw, inputsFilePath) {
   if (!Array.isArray(raw) || !raw.length) {
     throw new Error("--inputs must be a non-empty JSON array of { id, path }");
   }
-  const baseDir = path37.dirname(path37.resolve(inputsFilePath));
+  const baseDir = path38.dirname(path38.resolve(inputsFilePath));
   return raw.map((entry, i) => {
     const e = entry;
     if (typeof e.id !== "string" || typeof e.path !== "string") {
       throw new Error(`--inputs[${i}] needs string "id" and "path"`);
     }
-    return { id: e.id, path: path37.resolve(baseDir, e.path) };
+    return { id: e.id, path: path38.resolve(baseDir, e.path) };
   });
 }
 function packSprites(inputs, options = {}) {
@@ -18526,7 +18756,7 @@ function packStyle(lock, styleId, manifestDir, options = {}) {
     }
     const inputs2 = Object.entries(options.sourceOverrides).map(([id, source]) => ({
       id,
-      path: path37.resolve(source)
+      path: path38.resolve(source)
     }));
     if (!inputs2.length) throw new Error(`No approved quality outputs for style "${styleId}".`);
     const packed2 = packSprites(inputs2, options);
@@ -18550,7 +18780,7 @@ function packStyle(lock, styleId, manifestDir, options = {}) {
     let outputs = resolveEntryOutputs(entry, id, manifestDir);
     const source = sources[id];
     if (source && outputs.length <= 1) {
-      inputs.push({ id, path: path37.resolve(manifestDir, source) });
+      inputs.push({ id, path: path38.resolve(manifestDir, source) });
       continue;
     }
     if (source && sourceIsStem(source, entry, manifestDir)) {
@@ -18584,7 +18814,7 @@ function packStyle(lock, styleId, manifestDir, options = {}) {
     }
   }
   for (const [id, source] of Object.entries(sources)) {
-    if (!locked.has(id)) inputs.push({ id, path: path37.resolve(manifestDir, source) });
+    if (!locked.has(id)) inputs.push({ id, path: path38.resolve(manifestDir, source) });
   }
   if (!inputs.length) {
     throw new Error(`No readable sprites for style "${styleId}"; ${noOutput.length} skipped.`);
@@ -18692,7 +18922,7 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
     const source = sources[id];
     const entry = lock.entries[`${styleId}/${id}`];
     if (source && !(entry && sourceIsStem(source, entry, manifestDir))) {
-      placements.push({ id, path: path37.resolve(manifestDir, source), cell });
+      placements.push({ id, path: path38.resolve(manifestDir, source), cell });
       continue;
     }
     if (source && entry) {
@@ -18725,7 +18955,7 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
       `Nothing to mount for style "${styleId}": ${ids.length} asset(s) declare a cell, but none has generated output or a \`source\`. Run \`pixelkiln gen --style ${styleId}\`, or point each at a file.${detail}`
     );
   }
-  const basePng = mount.base ? readFileSync5(path37.resolve(manifestDir, mount.base)) : void 0;
+  const basePng = mount.base ? readFileSync5(path38.resolve(manifestDir, mount.base)) : void 0;
   const mounted = mountSprites(placements, {
     cellWidth: mount.cellWidth,
     cellHeight: mount.cellHeight,
@@ -18735,7 +18965,7 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
     ...mounted,
     sources: mount.base ? [{
       id: "$base",
-      path: path37.resolve(manifestDir, mount.base),
+      path: path38.resolve(manifestDir, mount.base),
       sha256: sha256(basePng),
       included: true
     }, ...mounted.sources] : mounted.sources,
@@ -19139,12 +19369,12 @@ async function runPack(args) {
     if (args.primaryOnly || args.outputRoles.length) {
       throw new Error("--primary-only and --output-role require manifest-driven pack");
     }
-    const raw = JSON.parse(await readFile25(path38.resolve(args.inputs), "utf8"));
+    const raw = JSON.parse(await readFile26(path39.resolve(args.inputs), "utf8"));
     const inputs = resolvePackInputs(raw, args.inputs);
     const { png, atlas, skipped, sources } = packSprites(inputs, { columns: args.columns });
     const format = sheetFormat(args);
-    const base = path38.resolve(args.out.replace(/\.(?:png|json|tres)$/i, ""));
-    const { extension, document } = renderSheetDocument(format, atlas, { imageName: path38.basename(`${base}.png`) });
+    const base = path39.resolve(args.out.replace(/\.(?:png|json|tres)$/i, ""));
+    const { extension, document } = renderSheetDocument(format, atlas, { imageName: path39.basename(`${base}.png`) });
     const outputs = [
       { path: `${base}.png`, data: png },
       { path: `${base}${extension}`, data: document }
@@ -19157,7 +19387,7 @@ async function runPack(args) {
     log(
       `  ${atlas.frames.length} sprite(s), ${atlas.sheet.width}x${atlas.sheet.height} in ${atlas.columns} column(s), ${(png.length / 1024).toFixed(1)} KB (${format})`
     );
-    log(`    ${path38.relative(process.cwd(), base)}.png + ${extension} + .pixelkiln.json`);
+    log(`    ${path39.relative(process.cwd(), base)}.png + ${extension} + .pixelkiln.json`);
     for (const s of skipped) log(`    skipped ${s.id}: ${s.reason}`);
     return;
   }
@@ -19165,7 +19395,7 @@ async function runPack(args) {
   if (args.primaryOnly && args.outputRoles.length) {
     throw new Error("pack accepts either --primary-only or --output-role, not both");
   }
-  const manifestDir = path38.dirname(path38.resolve(args.manifest));
+  const manifestDir = path39.dirname(path39.resolve(args.manifest));
   const styleIds = args.styles.length ? args.styles : Object.keys(loaded.manifest.styles);
   for (const styleId of styleIds) {
     const style = loaded.manifest.styles[styleId];
@@ -19180,9 +19410,9 @@ async function runPack(args) {
       sourceOverrides: qualitySources,
       sources: manifestSources(loaded.manifest, styleId)
     });
-    const base = args.out ? path38.resolve(args.out.replace(/\.(?:png|json|tres)$/i, "")) : path38.resolve(manifestDir, style.outDir, `${styleId}-sheet`);
+    const base = args.out ? path39.resolve(args.out.replace(/\.(?:png|json|tres)$/i, "")) : path39.resolve(manifestDir, style.outDir, `${styleId}-sheet`);
     const format = sheetFormat(args);
-    const { extension, document } = renderSheetDocument(format, atlas, { imageName: path38.basename(`${base}.png`) });
+    const { extension, document } = renderSheetDocument(format, atlas, { imageName: path39.basename(`${base}.png`) });
     const outputs = [
       { path: `${base}.png`, data: png },
       { path: `${base}${extension}`, data: document }
@@ -19214,13 +19444,13 @@ async function runPack(args) {
     log(
       `  ${styleId}: ${atlas.frames.length} sprite(s), ${atlas.sheet.width}x${atlas.sheet.height} in ${atlas.columns} column(s)` + (atlas.sets?.length ? `, ${atlas.sets.length} set(s)` : "") + ` (${format})`
     );
-    log(`    ${path38.relative(process.cwd(), base)}.png + ${extension} + .pixelkiln.json`);
+    log(`    ${path39.relative(process.cwd(), base)}.png + ${extension} + .pixelkiln.json`);
     for (const s of skipped) log(`    skipped ${s.id}: ${s.reason}`);
   }
 }
 async function runMount(args) {
   const { loaded, lock } = await openProject2(args);
-  const manifestDir = path38.dirname(path38.resolve(args.manifest));
+  const manifestDir = path39.dirname(path39.resolve(args.manifest));
   const styleIds = args.styles.length ? args.styles : Object.keys(loaded.manifest.styles);
   for (const styleId of styleIds) {
     const style = loaded.manifest.styles[styleId];
@@ -19259,9 +19489,9 @@ async function runMount(args) {
       sources,
       outputRoles
     );
-    const out = path38.resolve(manifestDir, style.mount.out);
+    const out = path39.resolve(manifestDir, style.mount.out);
     const format = sheetFormat(args);
-    const { extension, document } = renderSheetDocument(format, atlas, { imageName: path38.basename(out) });
+    const { extension, document } = renderSheetDocument(format, atlas, { imageName: path39.basename(out) });
     const metadata = out.replace(/\.png$/, "") + extension;
     const companion = out.replace(/\.png$/, "") + ".pixelkiln.json";
     const outputs = [
@@ -19281,7 +19511,7 @@ async function runMount(args) {
         await provenanceFile("$lock", args.lock),
         ...qualityRecords,
         ...artifactSources.filter(
-          (source) => source.id !== "$base" || path38.resolve(source.path) !== out
+          (source) => source.id !== "$base" || path39.resolve(source.path) !== out
         )
       ],
       options: {
@@ -19295,14 +19525,14 @@ async function runMount(args) {
     log(
       `  ${styleId}: ${atlas.frames.length} cell(s) into ${atlas.sheet.width}x${atlas.sheet.height}` + (overBase ? ` over ${style.mount.base}` : " (new sheet)")
     );
-    log(`    ${path38.relative(process.cwd(), out)} + atlas/provenance JSON`);
+    log(`    ${path39.relative(process.cwd(), out)} + atlas/provenance JSON`);
     for (const s of skipped) log(`    skipped ${s.id}: ${s.reason}`);
   }
 }
 async function runExport(args) {
   const { loaded, specs, lock } = await openProject2(args);
   const format = args.format ?? "generic";
-  const manifestDir = path38.dirname(path38.resolve(args.manifest));
+  const manifestDir = path39.dirname(path39.resolve(args.manifest));
   const selected = specs.filter((spec) => {
     if (spec.generator !== "tiles" && spec.generator !== "terrain") return false;
     if (args.styles.length && !args.styles.includes(spec.styleId)) return false;
@@ -19318,12 +19548,12 @@ async function runExport(args) {
   for (const spec of selected) {
     const entry = lock.entries[lockKey(spec.styleId, spec.assetId)];
     const style = loaded.manifest.styles[spec.styleId];
-    const defaultBase = path38.resolve(manifestDir, style.outDir, `${spec.assetId}-tileset`);
-    const base = args.out ? path38.resolve(args.out.replace(/\.(?:png|json|tsj|tres)$/i, "")) : defaultBase;
+    const defaultBase = path39.resolve(manifestDir, style.outDir, `${spec.assetId}-tileset`);
+    const base = args.out ? path39.resolve(args.out.replace(/\.(?:png|json|tsj|tres)$/i, "")) : defaultBase;
     const result = exportTileset(entry, spec, {
       format,
       manifestDir,
-      imageName: path38.basename(`${base}.png`),
+      imageName: path39.basename(`${base}.png`),
       columns: args.columns
     });
     const outputs = [
@@ -19341,7 +19571,7 @@ async function runExport(args) {
         asset: spec.assetId,
         columns: args.columns ?? null,
         format,
-        image: path38.basename(`${base}.png`),
+        image: path39.basename(`${base}.png`),
         providerRules: result.generic.providerRules,
         style: spec.styleId,
         tileType: spec.tileType ?? null
@@ -19351,7 +19581,7 @@ async function runExport(args) {
       `  ${spec.styleId}/${spec.assetId}: ${result.generic.tiles.length} tile(s), ${result.generic.sheet.width}x${result.generic.sheet.height} (${format})`
     );
     log(
-      `    ${path38.relative(process.cwd(), base)}.png + ${path38.basename(base)}${result.extension} + .pixelkiln.json`
+      `    ${path39.relative(process.cwd(), base)}.png + ${path39.basename(base)}${result.extension} + .pixelkiln.json`
     );
   }
 }
@@ -19364,23 +19594,23 @@ function sheetFormat(args) {
 }
 
 // src/cli/commands/pixellab-utils.ts
-import path40 from "path";
+import path41 from "path";
 
 // src/pixellab-utils.ts
-import { existsSync as existsSync29 } from "fs";
-import { mkdir as mkdir11, readFile as readFile26, writeFile as writeFile14 } from "fs/promises";
-import path39 from "path";
+import { existsSync as existsSync30 } from "fs";
+import { mkdir as mkdir12, readFile as readFile27, writeFile as writeFile15 } from "fs/promises";
+import path40 from "path";
 var UNZOOM_MIN_SIDE = 256;
 var UNZOOM_MAX_AREA = 2048 * 2048;
 function defaultUnzoomOut(input) {
-  const ext = path39.extname(input);
+  const ext = path40.extname(input);
   return `${ext ? input.slice(0, -ext.length) : input}.unzoomed.png`;
 }
 async function unzoomFile(client2, input, opts = {}) {
-  const out = path39.resolve(opts.out ?? defaultUnzoomOut(input));
-  if (path39.resolve(input) === out) throw new Error("unzoom will not overwrite its own input; pass a different --out");
-  if (existsSync29(out) && !opts.force) throw new Error(`${out} already exists; pass --force to replace it`);
-  const bytes = await readFile26(input);
+  const out = path40.resolve(opts.out ?? defaultUnzoomOut(input));
+  if (path40.resolve(input) === out) throw new Error("unzoom will not overwrite its own input; pass a different --out");
+  if (existsSync30(out) && !opts.force) throw new Error(`${out} already exists; pass --force to replace it`);
+  const bytes = await readFile27(input);
   const metadata = imageMetadata(bytes);
   if (!metadata) throw new Error(`${input} is not a readable PNG or JPEG`);
   const { width, height, format } = metadata;
@@ -19393,22 +19623,22 @@ async function unzoomFile(client2, input, opts = {}) {
     throw new Error(`${input} is ${width}x${height}; PixelLab's unzoom takes at most 2048x2048 worth of pixels`);
   }
   const res = await client2.unzoom({ image: { base64: bytes.toString("base64"), format }, quantize: opts.quantize });
-  await mkdir11(path39.dirname(out), { recursive: true });
-  await writeFile14(out, res.png);
+  await mkdir12(path40.dirname(out), { recursive: true });
+  await writeFile15(out, res.png);
   return { out, original: res.originalSize, unzoomed: res.unzoomedSize, zoomFactor: res.zoomFactor, usage: res.usage };
 }
 var FONT_WEIGHTS = ["Bold", "Regular"];
 var FONT_GLYPH_SIZES = [8, 16, 32, 64];
 var FONT_COST_GENERATIONS = 25;
 function fontOutputPaths(out) {
-  const base = path39.resolve(out.replace(/\.(ttf|png)$/i, ""));
+  const base = path40.resolve(out.replace(/\.(ttf|png)$/i, ""));
   return { ttf: `${base}.ttf`, atlas: `${base}.png` };
 }
 async function generateFont(client2, opts) {
   const { ttf, atlas } = fontOutputPaths(opts.out);
   if (!opts.force) {
     for (const file of [ttf, atlas]) {
-      if (existsSync29(file)) throw new Error(`${file} already exists; pass --force to replace it`);
+      if (existsSync30(file)) throw new Error(`${file} already exists; pass --force to replace it`);
     }
   }
   const sleep3 = opts.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
@@ -19435,9 +19665,9 @@ async function generateFont(client2, opts) {
         client2.download(job.download_ttf_url),
         client2.download(job.download_atlas_url)
       ]);
-      await mkdir11(path39.dirname(ttf), { recursive: true });
-      await writeFile14(ttf, ttfBytes);
-      await writeFile14(atlas, atlasBytes);
+      await mkdir12(path40.dirname(ttf), { recursive: true });
+      await writeFile15(ttf, ttfBytes);
+      await writeFile15(atlas, atlasBytes);
       return { jobId, ttf, atlas, glyphPx: job.glyph_px ?? null, usage: job.usage };
     }
     if (Date.now() - started > timeout) {
@@ -19451,7 +19681,7 @@ async function generateFont(client2, opts) {
 
 // src/cli/commands/pixellab-utils.ts
 function loadKeys(args) {
-  loadEnvFiles(path40.dirname(path40.resolve(args.manifest)));
+  loadEnvFiles(path41.dirname(path41.resolve(args.manifest)));
   loadEnvFiles(process.cwd());
 }
 async function runUnzoom(args) {
@@ -19517,19 +19747,19 @@ async function runFont(args) {
 }
 
 // src/cli/commands/quality.ts
-import path42 from "path";
-import { readFile as readFile28 } from "fs/promises";
+import path43 from "path";
+import { readFile as readFile29 } from "fs/promises";
 
 // src/pipeline/quality-regression.ts
-import path41 from "path";
-import { existsSync as existsSync30 } from "fs";
-import { readFile as readFile27 } from "fs/promises";
-import { z as z10 } from "zod";
+import path42 from "path";
+import { existsSync as existsSync31 } from "fs";
+import { readFile as readFile28 } from "fs/promises";
+import { z as z11 } from "zod";
 var SHA256_RE = /^[0-9a-f]{64}$/;
 var HEX_RE = /^#[0-9a-f]{6}$/;
 var MAX_REDMEAN_DISTANCE = 765;
-var QualityPathSchema = z10.string().min(1).refine(
-  (value) => !path41.posix.isAbsolute(value) && !value.includes("\\"),
+var QualityPathSchema = z11.string().min(1).refine(
+  (value) => !path42.posix.isAbsolute(value) && !value.includes("\\"),
   "expected a portable relative path"
 );
 var DEFAULT_QUALITY_TOLERANCES = {
@@ -19542,53 +19772,53 @@ var DEFAULT_QUALITY_TOLERANCES = {
   maxEdgeContrastDrop: 0.03,
   maxIsolatedPixelIncrease: 5e-3
 };
-var QualityToleranceSchema = z10.object({
-  requireExactHash: z10.boolean(),
-  maxColorCountIncrease: z10.number().int().min(0),
-  maxNewColors: z10.number().int().min(0),
-  maxTransparencyDelta: z10.number().min(0).max(1),
-  maxPartialAlphaIncrease: z10.number().min(0).max(1),
-  maxEdgeDensityDelta: z10.number().min(0).max(1),
-  maxEdgeContrastDrop: z10.number().min(0).max(1),
-  maxIsolatedPixelIncrease: z10.number().min(0).max(1)
+var QualityToleranceSchema = z11.object({
+  requireExactHash: z11.boolean(),
+  maxColorCountIncrease: z11.number().int().min(0),
+  maxNewColors: z11.number().int().min(0),
+  maxTransparencyDelta: z11.number().min(0).max(1),
+  maxPartialAlphaIncrease: z11.number().min(0).max(1),
+  maxEdgeDensityDelta: z11.number().min(0).max(1),
+  maxEdgeContrastDrop: z11.number().min(0).max(1),
+  maxIsolatedPixelIncrease: z11.number().min(0).max(1)
 }).strict();
-var ImageQualityMetricsSchema = z10.object({
-  sha256: z10.string().regex(SHA256_RE),
-  width: z10.number().int().min(1),
-  height: z10.number().int().min(1),
-  colorCount: z10.number().int().min(0),
-  colors: z10.array(z10.string().regex(HEX_RE)),
-  transparency: z10.number().min(0).max(1),
-  partialAlpha: z10.number().min(0).max(1),
-  edgeDensity: z10.number().min(0).max(1),
-  meanEdgeContrast: z10.number().min(0).max(1),
-  isolatedPixelRatio: z10.number().min(0).max(1)
+var ImageQualityMetricsSchema = z11.object({
+  sha256: z11.string().regex(SHA256_RE),
+  width: z11.number().int().min(1),
+  height: z11.number().int().min(1),
+  colorCount: z11.number().int().min(0),
+  colors: z11.array(z11.string().regex(HEX_RE)),
+  transparency: z11.number().min(0).max(1),
+  partialAlpha: z11.number().min(0).max(1),
+  edgeDensity: z11.number().min(0).max(1),
+  meanEdgeContrast: z11.number().min(0).max(1),
+  isolatedPixelRatio: z11.number().min(0).max(1)
 }).strict();
-var QualityBaselineCaseSchema = z10.object({
-  id: z10.string().regex(/^[a-z0-9][a-z0-9/_-]*$/),
+var QualityBaselineCaseSchema = z11.object({
+  id: z11.string().regex(/^[a-z0-9][a-z0-9/_-]*$/),
   file: QualityPathSchema,
-  record: z10.object({
+  record: z11.object({
     path: QualityPathSchema,
-    sha256: z10.string().regex(SHA256_RE)
+    sha256: z11.string().regex(SHA256_RE)
   }).strict().optional(),
   expected: ImageQualityMetricsSchema,
   tolerances: QualityToleranceSchema
 }).strict();
-var QualityBaselineSchema = z10.object({
-  $schema: z10.string().url().optional(),
-  format: z10.literal("pixelkiln-quality-baseline"),
-  schemaVersion: z10.literal(1),
-  cases: z10.array(QualityBaselineCaseSchema).min(1)
+var QualityBaselineSchema = z11.object({
+  $schema: z11.string().url().optional(),
+  format: z11.literal("pixelkiln-quality-baseline"),
+  schemaVersion: z11.literal(1),
+  cases: z11.array(QualityBaselineCaseSchema).min(1)
 }).strict().superRefine((baseline, context) => {
   const ids = baseline.cases.map((entry) => entry.id);
   if (new Set(ids).size !== ids.length) {
-    context.addIssue({ code: z10.ZodIssueCode.custom, path: ["cases"], message: "duplicate case id" });
+    context.addIssue({ code: z11.ZodIssueCode.custom, path: ["cases"], message: "duplicate case id" });
   }
 });
-var QualityInputSchema = z10.object({
-  id: z10.string().regex(/^[a-z0-9][a-z0-9/_-]*$/),
-  path: z10.string().min(1),
-  record: z10.string().min(1).optional(),
+var QualityInputSchema = z11.object({
+  id: z11.string().regex(/^[a-z0-9][a-z0-9/_-]*$/),
+  path: z11.string().min(1),
+  record: z11.string().min(1).optional(),
   tolerances: QualityToleranceSchema.partial().optional()
 }).strict();
 function message4(error) {
@@ -19676,10 +19906,10 @@ function measureDecodedImageQuality(png, digest2) {
   };
 }
 async function measureImageQuality(file) {
-  const absolute = path41.resolve(file);
+  const absolute = path42.resolve(file);
   let bytes;
   try {
-    bytes = await readFile27(absolute);
+    bytes = await readFile28(absolute);
   } catch (error) {
     throw new Error(`Cannot read quality image ${absolute}: ${message4(error)}`, { cause: error });
   }
@@ -19690,7 +19920,7 @@ async function measureImageQuality(file) {
   }
 }
 function resolveQualityInputs(raw, inputsFilePath) {
-  const parsed = z10.array(QualityInputSchema).min(1).safeParse(raw);
+  const parsed = z11.array(QualityInputSchema).min(1).safeParse(raw);
   if (!parsed.success) {
     throw new Error(
       "--inputs must be a non-empty JSON array of quality cases:\n" + parsed.error.issues.map((issue) => `  ${issue.path.join(".") || "$"}: ${issue.message}`).join("\n")
@@ -19698,11 +19928,11 @@ function resolveQualityInputs(raw, inputsFilePath) {
   }
   const ids = parsed.data.map((entry) => entry.id);
   if (new Set(ids).size !== ids.length) throw new Error("--inputs contains a duplicate quality case id.");
-  const root = path41.dirname(path41.resolve(inputsFilePath));
+  const root = path42.dirname(path42.resolve(inputsFilePath));
   return parsed.data.map((entry) => ({
     id: entry.id,
-    file: path41.resolve(root, entry.path),
-    ...entry.record ? { record: path41.resolve(root, entry.record) } : {},
+    file: path42.resolve(root, entry.path),
+    ...entry.record ? { record: path42.resolve(root, entry.record) } : {},
     tolerances: QualityToleranceSchema.parse({
       ...DEFAULT_QUALITY_TOLERANCES,
       ...entry.tolerances
@@ -19710,7 +19940,7 @@ function resolveQualityInputs(raw, inputsFilePath) {
   }));
 }
 function portableRelative2(from, to) {
-  return path41.relative(from, path41.resolve(to)).split(path41.sep).join("/") || ".";
+  return path42.relative(from, path42.resolve(to)).split(path42.sep).join("/") || ".";
 }
 async function verifyRecordForImage(recordPath, imagePath) {
   const verification = await verifyArtifactBundle(recordPath);
@@ -19725,20 +19955,20 @@ async function verifyRecordForImage(recordPath, imagePath) {
   if (record.kind !== "refine" || options === null || typeof options !== "object" || options.schema !== "pixelkiln-quality") {
     throw new Error(`Quality record ${recordPath} is not a PixelKiln refinement record.`);
   }
-  const outputs = record.outputs.map((output) => path41.resolve(path41.dirname(recordPath), output.path));
-  if (!outputs.includes(path41.resolve(imagePath))) {
+  const outputs = record.outputs.map((output) => path42.resolve(path42.dirname(recordPath), output.path));
+  if (!outputs.includes(path42.resolve(imagePath))) {
     throw new Error(`Quality record ${recordPath} does not own ${imagePath}.`);
   }
 }
 async function snapshotQualityBaseline(inputs, baselinePath, options = {}) {
   if (!inputs.length) throw new Error("Cannot snapshot an empty quality baseline.");
-  const absolute = path41.resolve(baselinePath);
+  const absolute = path42.resolve(baselinePath);
   for (const input of inputs) {
-    if (path41.resolve(input.file) === absolute || input.record && path41.resolve(input.record) === absolute) {
+    if (path42.resolve(input.file) === absolute || input.record && path42.resolve(input.record) === absolute) {
       throw new Error(`Quality baseline output would overwrite an input: ${absolute}.`);
     }
   }
-  const root = path41.dirname(absolute);
+  const root = path42.dirname(absolute);
   const cases = [];
   for (const input of [...inputs].sort((a, b) => a.id.localeCompare(b.id))) {
     const expected = await measureImageQuality(input.file);
@@ -19765,8 +19995,8 @@ async function snapshotQualityBaseline(inputs, baselinePath, options = {}) {
     cases
   });
   const data = Buffer.from(JSON.stringify(baseline, null, 2) + "\n");
-  if (existsSync30(absolute) && !options.force) {
-    const current = await readFile27(absolute);
+  if (existsSync31(absolute) && !options.force) {
+    const current = await readFile28(absolute);
     if (!current.equals(data)) {
       throw new OverwriteRefusedError(
         `Quality baseline already exists with different content: ${absolute}. Pass --force to replace it.`,
@@ -19778,10 +20008,10 @@ async function snapshotQualityBaseline(inputs, baselinePath, options = {}) {
   return { baseline, path: absolute, changed: result.changed.length > 0 };
 }
 async function readQualityBaseline(baselinePath) {
-  const absolute = path41.resolve(baselinePath);
+  const absolute = path42.resolve(baselinePath);
   let raw;
   try {
-    raw = JSON.parse(await readFile27(absolute, "utf8"));
+    raw = JSON.parse(await readFile28(absolute, "utf8"));
   } catch (error) {
     throw new Error(`Could not read quality baseline ${absolute}: ${message4(error)}`, { cause: error });
   }
@@ -19851,12 +20081,12 @@ function regressionViolations(expected, actual, tolerances) {
   return { violations, warnings };
 }
 async function checkQualityBaseline(baselinePath) {
-  const absolute = path41.resolve(baselinePath);
+  const absolute = path42.resolve(baselinePath);
   const baseline = await readQualityBaseline(absolute);
-  const root = path41.dirname(absolute);
+  const root = path42.dirname(absolute);
   const cases = [];
   for (const entry of baseline.cases) {
-    const file = path41.resolve(root, entry.file);
+    const file = path42.resolve(root, entry.file);
     let actual = null;
     const violations = [];
     const warnings = [];
@@ -19869,7 +20099,7 @@ async function checkQualityBaseline(baselinePath) {
       violations.push(message4(error));
     }
     if (entry.record) {
-      const recordPath = path41.resolve(root, entry.record.path);
+      const recordPath = path42.resolve(root, entry.record.path);
       try {
         const recordHash = await sha256File(recordPath);
         if (recordHash !== entry.record.sha256) violations.push("quality record hash changed");
@@ -19911,15 +20141,15 @@ async function runQuality(args) {
     if (!args.out) throw new Error("quality snapshot needs --out <pixelkiln.quality.json>.");
     let raw;
     try {
-      raw = JSON.parse(await readFile28(path42.resolve(args.inputs), "utf8"));
+      raw = JSON.parse(await readFile29(path43.resolve(args.inputs), "utf8"));
     } catch (error) {
       throw new Error(
-        `Could not read quality inputs ${path42.resolve(args.inputs)}: ${error instanceof Error ? error.message : String(error)}`,
+        `Could not read quality inputs ${path43.resolve(args.inputs)}: ${error instanceof Error ? error.message : String(error)}`,
         { cause: error }
       );
     }
     const inputs = resolveQualityInputs(raw, args.inputs);
-    if (path42.resolve(args.inputs) === path42.resolve(args.out)) {
+    if (path43.resolve(args.inputs) === path43.resolve(args.out)) {
       throw new Error("quality snapshot --out must not overwrite its --inputs file.");
     }
     const result = await snapshotQualityBaseline(inputs, args.out, { force: args.force });
@@ -19932,7 +20162,7 @@ async function runQuality(args) {
       }, null, 2));
     } else {
       log(
-        `  ${result.changed ? "wrote" : "unchanged"} ${path42.relative(process.cwd(), result.path)} (${result.baseline.cases.length} case(s))`
+        `  ${result.changed ? "wrote" : "unchanged"} ${path43.relative(process.cwd(), result.path)} (${result.baseline.cases.length} case(s))`
       );
       log(`  Review the tolerances, commit the baseline, then run quality check in CI.`);
     }
@@ -19958,54 +20188,54 @@ async function runQuality(args) {
 }
 
 // src/cli/commands/recipe.ts
-import path44 from "path";
+import path45 from "path";
 
 // src/recipes.ts
-import path43 from "path";
-import { existsSync as existsSync31 } from "fs";
-import { readdir as readdir3, readFile as readFile29 } from "fs/promises";
+import path44 from "path";
+import { existsSync as existsSync32 } from "fs";
+import { readdir as readdir3, readFile as readFile30 } from "fs/promises";
 import { fileURLToPath } from "url";
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var SHA256_RE2 = /^[0-9a-f]{64}$/;
 var RECIPE_ID_RE = /^[a-z0-9][a-z0-9-]*\/[a-z0-9][a-z0-9-]*$/;
 var VERSION_RE = /^\d+\.\d+\.\d+$/;
 var RECIPE_FILE = "pixelkiln.recipe.json";
 var RECIPE_DIR_TOKEN = "{{recipeDir}}";
-var PortablePathSchema = z11.string().min(1).refine((value) => {
-  if (value.includes("\\") || path43.posix.isAbsolute(value)) return false;
+var PortablePathSchema = z12.string().min(1).refine((value) => {
+  if (value.includes("\\") || path44.posix.isAbsolute(value)) return false;
   const parts = value.split("/");
   return !parts.includes("") && !parts.includes(".") && !parts.includes("..");
 }, "expected a portable relative path without '.', '..', or backslashes");
-var RecipeBindingSchema = z11.object({
-  nodeId: z11.string().min(1),
-  input: z11.string().min(1)
+var RecipeBindingSchema = z12.object({
+  nodeId: z12.string().min(1),
+  input: z12.string().min(1)
 }).strict();
-var RecipeSchema = z11.object({
-  $schema: z11.string().url().optional(),
-  format: z11.literal("pixelkiln-recipe"),
-  schemaVersion: z11.literal(1),
-  id: z11.string().regex(RECIPE_ID_RE, "expected provider/name"),
-  version: z11.string().regex(VERSION_RE, "expected x.y.z"),
-  provider: z11.string().regex(/^[a-z0-9][a-z0-9-]*$/),
-  summary: z11.string().min(1).max(240),
-  files: z11.array(z11.object({
+var RecipeSchema = z12.object({
+  $schema: z12.string().url().optional(),
+  format: z12.literal("pixelkiln-recipe"),
+  schemaVersion: z12.literal(1),
+  id: z12.string().regex(RECIPE_ID_RE, "expected provider/name"),
+  version: z12.string().regex(VERSION_RE, "expected x.y.z"),
+  provider: z12.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  summary: z12.string().min(1).max(240),
+  files: z12.array(z12.object({
     path: PortablePathSchema,
-    role: z11.enum(["workflow", "reference"]),
-    sha256: z11.string().regex(SHA256_RE2)
+    role: z12.enum(["workflow", "reference"]),
+    sha256: z12.string().regex(SHA256_RE2)
   }).strict()).default([]),
-  models: z11.array(z11.object({
+  models: z12.array(z12.object({
     path: PortablePathSchema,
-    sha256: z11.string().regex(SHA256_RE2),
-    source: z11.string().url(),
-    license: z11.string().min(1)
+    sha256: z12.string().regex(SHA256_RE2),
+    source: z12.string().url(),
+    license: z12.string().min(1)
   }).strict()).default([]),
-  styleId: z11.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  styleId: z12.string().regex(/^[a-z0-9][a-z0-9-]*$/),
   style: StyleSchema,
-  workflow: z11.object({
+  workflow: z12.object({
     path: PortablePathSchema,
-    outputNodeId: z11.string().min(1),
-    numImages: z11.number().int().min(1).max(16),
-    bindings: z11.object({
+    outputNodeId: z12.string().min(1),
+    numImages: z12.number().int().min(1).max(16),
+    bindings: z12.object({
       prompt: RecipeBindingSchema,
       width: RecipeBindingSchema.optional(),
       height: RecipeBindingSchema.optional(),
@@ -20016,67 +20246,67 @@ var RecipeSchema = z11.object({
       strength: RecipeBindingSchema.optional()
     }).strict()
   }).strict().optional(),
-  quality: z11.object({
-    stage: z11.enum(["composition-source", "production-candidate"]),
-    workingCanvas: z11.object({
-      width: z11.number().int().min(16),
-      height: z11.number().int().min(16)
+  quality: z12.object({
+    stage: z12.enum(["composition-source", "production-candidate"]),
+    workingCanvas: z12.object({
+      width: z12.number().int().min(16),
+      height: z12.number().int().min(16)
     }).strict(),
-    recommendedNativeSize: z11.object({
-      min: z11.number().int().min(1),
-      max: z11.number().int().min(1)
+    recommendedNativeSize: z12.object({
+      min: z12.number().int().min(1),
+      max: z12.number().int().min(1)
     }).strict(),
-    paletteColors: z11.object({
-      min: z11.number().int().min(1),
-      max: z11.number().int().min(1)
+    paletteColors: z12.object({
+      min: z12.number().int().min(1),
+      max: z12.number().int().min(1)
     }).strict(),
-    background: z11.enum(["opaque", "transparent", "full-bleed"]),
-    checks: z11.array(z11.enum([
+    background: z12.enum(["opaque", "transparent", "full-bleed"]),
+    checks: z12.array(z12.enum([
       "prompt-coverage",
       "native-grid",
       "final-palette",
       "alpha-edge",
       "human-1x"
     ])).min(1),
-    notes: z11.array(z11.string().min(1)).default([])
+    notes: z12.array(z12.string().min(1)).default([])
   }).strict(),
-  integrity: z11.object({
-    algorithm: z11.literal("sha256"),
-    digest: z11.string().regex(SHA256_RE2)
+  integrity: z12.object({
+    algorithm: z12.literal("sha256"),
+    digest: z12.string().regex(SHA256_RE2)
   }).strict()
 }).strict().superRefine((recipe, context) => {
   if (recipe.style.provider && recipe.style.provider !== recipe.provider) {
     context.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z12.ZodIssueCode.custom,
       path: ["style", "provider"],
       message: "must match the recipe provider"
     });
   }
   const filePaths = recipe.files.map((file) => file.path);
   if (new Set(filePaths).size !== filePaths.length) {
-    context.addIssue({ code: z11.ZodIssueCode.custom, path: ["files"], message: "duplicate file path" });
+    context.addIssue({ code: z12.ZodIssueCode.custom, path: ["files"], message: "duplicate file path" });
   }
   const modelPaths = recipe.models.map((model) => model.path);
   if (new Set(modelPaths).size !== modelPaths.length) {
-    context.addIssue({ code: z11.ZodIssueCode.custom, path: ["models"], message: "duplicate model path" });
+    context.addIssue({ code: z12.ZodIssueCode.custom, path: ["models"], message: "duplicate model path" });
   }
   if (filePaths.includes(RECIPE_FILE)) {
     context.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z12.ZodIssueCode.custom,
       path: ["files"],
       message: `${RECIPE_FILE} cannot hash itself`
     });
   }
   if (recipe.quality.recommendedNativeSize.min > recipe.quality.recommendedNativeSize.max) {
     context.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z12.ZodIssueCode.custom,
       path: ["quality", "recommendedNativeSize"],
       message: "min cannot exceed max"
     });
   }
   if (recipe.quality.paletteColors.min > recipe.quality.paletteColors.max) {
     context.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z12.ZodIssueCode.custom,
       path: ["quality", "paletteColors"],
       message: "min cannot exceed max"
     });
@@ -20085,7 +20315,7 @@ var RecipeSchema = z11.object({
     (file) => file.path === recipe.workflow.path && file.role === "workflow"
   )) {
     context.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z12.ZodIssueCode.custom,
       path: ["workflow", "path"],
       message: "must name a file whose role is workflow"
     });
@@ -20093,7 +20323,7 @@ var RecipeSchema = z11.object({
   if (recipe.provider === "comfyui") {
     if (!recipe.workflow) {
       context.addIssue({
-        code: z11.ZodIssueCode.custom,
+        code: z12.ZodIssueCode.custom,
         path: ["workflow"],
         message: "ComfyUI recipes require workflow metadata"
       });
@@ -20102,7 +20332,7 @@ var RecipeSchema = z11.object({
     const options = recipe.style.providerOptions.comfyui;
     if (!options || typeof options !== "object" || Array.isArray(options)) {
       context.addIssue({
-        code: z11.ZodIssueCode.custom,
+        code: z12.ZodIssueCode.custom,
         path: ["style", "providerOptions", "comfyui"],
         message: "ComfyUI recipes require ComfyUI provider options"
       });
@@ -20116,7 +20346,7 @@ var RecipeSchema = z11.object({
     };
     if (JSON.stringify(canonical3(options)) !== JSON.stringify(canonical3(expected))) {
       context.addIssue({
-        code: z11.ZodIssueCode.custom,
+        code: z12.ZodIssueCode.custom,
         path: ["style", "providerOptions", "comfyui"],
         message: "must match workflow metadata and use {{recipeDir}} for workflowFile"
       });
@@ -20148,10 +20378,10 @@ function message5(error) {
   return error instanceof Error ? error.message : String(error);
 }
 async function readRecipeFile(recipePath, bundled) {
-  const absolute = path43.resolve(recipePath);
+  const absolute = path44.resolve(recipePath);
   let raw;
   try {
-    raw = JSON.parse(await readFile29(absolute, "utf8"));
+    raw = JSON.parse(await readFile30(absolute, "utf8"));
   } catch (error) {
     throw new Error(`Could not read recipe ${absolute}: ${message5(error)}`, { cause: error });
   }
@@ -20162,13 +20392,13 @@ async function readRecipeFile(recipePath, bundled) {
 ` + parsed.error.issues.map((issue) => `  ${issue.path.join(".") || "$"}: ${issue.message}`).join("\n")
     );
   }
-  return { recipe: parsed.data, authored: raw, path: absolute, dir: path43.dirname(absolute), bundled };
+  return { recipe: parsed.data, authored: raw, path: absolute, dir: path44.dirname(absolute), bundled };
 }
 async function walkRecipeFiles(root) {
-  if (!existsSync31(root)) return [];
+  if (!existsSync32(root)) return [];
   const out = [];
   for (const entry of await readdir3(root, { withFileTypes: true })) {
-    const resolved = path43.join(root, entry.name);
+    const resolved = path44.join(root, entry.name);
     if (entry.isDirectory()) out.push(...await walkRecipeFiles(resolved));
     else if (entry.isFile() && entry.name === RECIPE_FILE) out.push(resolved);
   }
@@ -20179,7 +20409,7 @@ function bundledRecipeRoot() {
 }
 async function listBundledRecipes(root = bundledRecipeRoot()) {
   const recipes = await Promise.all(
-    (await walkRecipeFiles(path43.resolve(root))).map((file) => readRecipeFile(file, true))
+    (await walkRecipeFiles(path44.resolve(root))).map((file) => readRecipeFile(file, true))
   );
   return recipes.sort(
     (a, b) => a.recipe.id.localeCompare(b.recipe.id) || compareVersions(b.recipe.version, a.recipe.version)
@@ -20202,9 +20432,9 @@ function parseSelector(selector) {
   return { id: match[1], version: match[2] };
 }
 async function resolveRecipe(target, bundledRoot = bundledRecipeRoot()) {
-  const local = path43.resolve(target);
-  if (existsSync31(local)) {
-    const recipePath = path43.basename(local) === RECIPE_FILE ? local : path43.join(local, RECIPE_FILE);
+  const local = path44.resolve(target);
+  if (existsSync32(local)) {
+    const recipePath = path44.basename(local) === RECIPE_FILE ? local : path44.join(local, RECIPE_FILE);
     return readRecipeFile(recipePath, false);
   }
   if (target.startsWith(".") || target.startsWith("/") || target.includes("\\")) {
@@ -20218,8 +20448,8 @@ async function resolveRecipe(target, bundledRoot = bundledRecipeRoot()) {
   return matches[0];
 }
 async function verifyFile(root, file) {
-  const absolute = path43.resolve(root, ...file.path.split("/"));
-  if (!existsSync31(absolute)) {
+  const absolute = path44.resolve(root, ...file.path.split("/"));
+  if (!existsSync32(absolute)) {
     return { path: file.path, expectedSha256: file.sha256, actualSha256: null, status: "missing" };
   }
   const actualSha256 = await sha256File(absolute);
@@ -20234,7 +20464,7 @@ async function verifyRecipe(target, options = {}) {
   const loaded = await resolveRecipe(target, options.bundledRoot);
   const actualIntegrity = recipeDigest(loaded.authored);
   const files = await Promise.all(loaded.recipe.files.map((file) => verifyFile(loaded.dir, file)));
-  const modelRoot = options.modelRoot ? path43.resolve(options.modelRoot) : null;
+  const modelRoot = options.modelRoot ? path44.resolve(options.modelRoot) : null;
   const models = modelRoot ? await Promise.all(loaded.recipe.models.map(async (model) => ({
     ...await verifyFile(modelRoot, model),
     source: model.source,
@@ -20268,7 +20498,7 @@ async function verifyRecipe(target, options = {}) {
   };
 }
 function renderStyle(style, destination, cwd) {
-  const portableDir = path43.relative(cwd, destination).split(path43.sep).join("/") || ".";
+  const portableDir = path44.relative(cwd, destination).split(path44.sep).join("/") || ".";
   const replace = (value) => {
     if (typeof value === "string") return value.replaceAll(RECIPE_DIR_TOKEN, portableDir);
     if (Array.isArray(value)) return value.map(replace);
@@ -20280,25 +20510,25 @@ function renderStyle(style, destination, cwd) {
   return replace(style);
 }
 async function installRecipe(target, options = {}) {
-  const cwd = path43.resolve(options.cwd ?? process.cwd());
+  const cwd = path44.resolve(options.cwd ?? process.cwd());
   const loaded = await resolveRecipe(target, options.bundledRoot);
   const verification = await verifyRecipe(loaded.path);
   if (!verification.ok) {
     throw new Error(`Recipe ${loaded.recipe.id}@${loaded.recipe.version} failed integrity verification.`);
   }
-  const destination = options.out ? path43.resolve(cwd, options.out) : path43.join(cwd, "pixelkiln-recipes", ...loaded.recipe.id.split("/"), loaded.recipe.version);
+  const destination = options.out ? path44.resolve(cwd, options.out) : path44.join(cwd, "pixelkiln-recipes", ...loaded.recipe.id.split("/"), loaded.recipe.version);
   const sources = [
     { path: RECIPE_FILE, source: loaded.path },
-    ...loaded.recipe.files.map((file) => ({ path: file.path, source: path43.join(loaded.dir, ...file.path.split("/")) }))
+    ...loaded.recipe.files.map((file) => ({ path: file.path, source: path44.join(loaded.dir, ...file.path.split("/")) }))
   ];
   const files = await Promise.all(sources.map(async (file) => ({
-    path: path43.join(destination, ...file.path.split("/")),
-    data: await readFile29(file.source)
+    path: path44.join(destination, ...file.path.split("/")),
+    data: await readFile30(file.source)
   })));
   if (!options.force) {
     for (const file of files) {
-      if (!existsSync31(file.path)) continue;
-      const current = await readFile29(file.path);
+      if (!existsSync32(file.path)) continue;
+      const current = await readFile30(file.path);
       if (!current.equals(file.data)) {
         throw new OverwriteRefusedError(
           `Recipe destination has local changes: ${file.path}. Choose another --out or pass --force to replace declared recipe files.`,
@@ -20392,14 +20622,14 @@ async function runRecipe(args) {
       }, null, 2));
     } else {
       log(`  installed ${result.recipe.id}@${result.recipe.version}`);
-      log(`  ${path44.relative(process.cwd(), result.destination) || "."}`);
+      log(`  ${path45.relative(process.cwd(), result.destination) || "."}`);
       log(`
   Add this entry under your manifest's styles object:`);
       log(JSON.stringify({ [result.styleId]: result.style }, null, 2));
       if (result.recipe.models.length) {
         log(`
   Models are not downloaded automatically. Verify them with:`);
-        log(`  pixelkiln recipe verify ${path44.relative(process.cwd(), result.destination)} --model-root <ComfyUI/models>`);
+        log(`  pixelkiln recipe verify ${path45.relative(process.cwd(), result.destination)} --model-root <ComfyUI/models>`);
       }
     }
     return;
@@ -20407,7 +20637,7 @@ async function runRecipe(args) {
 }
 
 // src/cli/commands/refine.ts
-import path45 from "path";
+import path46 from "path";
 async function runRefine(args) {
   if (args.from || args.subcommand === "approve") {
     if (!args.from) {
@@ -20437,12 +20667,12 @@ async function runRefine(args) {
           `  recovered ${result3.detection.columns}x${result3.detection.rows} native grid (${result3.detection.confidence}: ${result3.detection.consensus})`
         );
         log(`  enforced ${result3.palette.length}-color palette without dithering`);
-        log(`  wrote ${path45.relative(process.cwd(), result3.output)}`);
-        log(`  quality record: ${path45.relative(process.cwd(), result3.record)}`);
+        log(`  wrote ${path46.relative(process.cwd(), result3.output)}`);
+        log(`  quality record: ${path46.relative(process.cwd(), result3.record)}`);
         log(`
   Automated checks passed. Human 1\xD7 review is still required:`);
         log(
-          `    pixelkiln refine approve --from ${path45.relative(process.cwd(), result3.record)} --reviewer "Your Name"`
+          `    pixelkiln refine approve --from ${path46.relative(process.cwd(), result3.record)} --reviewer "Your Name"`
         );
       }
       return;
@@ -20470,7 +20700,7 @@ async function runRefine(args) {
       if (args.json) log(JSON.stringify(result3, null, 2));
       else {
         log(
-          result3.options.frameSet ? `  approved ${result3.outputs.length} frames in ${path45.relative(process.cwd(), result3.record)} by ${args.reviewer.trim()}` : `  approved ${path45.relative(process.cwd(), result3.output)} by ${args.reviewer.trim()}`
+          result3.options.frameSet ? `  approved ${result3.outputs.length} frames in ${path46.relative(process.cwd(), result3.record)} by ${args.reviewer.trim()}` : `  approved ${path46.relative(process.cwd(), result3.output)} by ${args.reviewer.trim()}`
         );
       }
       return;
@@ -20479,7 +20709,7 @@ async function runRefine(args) {
     if (args.json) {
       log(JSON.stringify(result2, null, 2));
     } else {
-      log(`  ${result2.safe ? "release-ready" : "not release-ready"}: ${path45.relative(process.cwd(), result2.output || result2.record)}`);
+      log(`  ${result2.safe ? "release-ready" : "not release-ready"}: ${path46.relative(process.cwd(), result2.output || result2.record)}`);
       for (const reason of result2.reasons) log(`    ${reason}`);
     }
     if (!result2.safe) process.exitCode = 1;
@@ -20525,7 +20755,7 @@ async function runRefine(args) {
       log(`  ${item.state.padEnd(16)} ${item.key}  ${item.reason}`);
       if (item.state === "needs-approval") {
         log(
-          `    pixelkiln refine approve --from ${path45.relative(process.cwd(), item.record)} --reviewer "Your Name"`
+          `    pixelkiln refine approve --from ${path46.relative(process.cwd(), item.record)} --reviewer "Your Name"`
         );
       }
     }
@@ -20536,28 +20766,189 @@ async function runRefine(args) {
 }
 
 // src/cli/commands/skeleton.ts
-import path46 from "path";
-import { readFile as readFile30, writeFile as writeFile15 } from "fs/promises";
+import path47 from "path";
+import { existsSync as existsSync33 } from "fs";
+import { readFile as readFile31, writeFile as writeFile16 } from "fs/promises";
+
+// src/skeleton-preview.ts
+var RIGHT = [255, 140, 40, 255];
+var LEFT = [60, 150, 255, 255];
+var CENTER = [240, 240, 240, 255];
+var GROUND = [28, 28, 34, 255];
+var OUTLINE = [0, 0, 0, 255];
+var GUTTER = 4;
+var MIN_CELL = 192;
+function renderSkeletonSheet(set, options = {}) {
+  const poses = [set.firstFrameKeypoints, ...set.frames];
+  const source = options.source;
+  const scale = source ? Math.max(1, Math.ceil(MIN_CELL / Math.max(source.width, source.height))) : 1;
+  const cellW = source ? source.width * scale : options.cellSize ?? MIN_CELL;
+  const cellH = source ? source.height * scale : options.cellSize ?? MIN_CELL;
+  const columns = Math.min(options.columns ?? 8, poses.length);
+  const rows = Math.ceil(poses.length / columns);
+  const width = columns * cellW + (columns + 1) * GUTTER;
+  const height = rows * cellH + (rows + 1) * GUTTER;
+  const canvas = new Canvas(width, height);
+  canvas.fill(0, 0, width, height, [12, 12, 16, 255]);
+  poses.forEach((pose, index) => {
+    const left = GUTTER + index % columns * (cellW + GUTTER);
+    const top = GUTTER + Math.floor(index / columns) * (cellH + GUTTER);
+    canvas.fill(left, top, cellW, cellH, GROUND);
+    if (source) canvas.drawImage(source, left, top, scale, index === 0 ? 1 : 0.45);
+    drawPose(canvas, pose, left, top, cellW, cellH, Math.max(1, Math.round(Math.min(cellW, cellH) / 128)));
+  });
+  return encodeRgbaPng(width, height, canvas.data);
+}
+function drawPose(canvas, pose, left, top, w, h, stroke) {
+  const at = new Map(pose.map((joint) => [joint.label, joint]));
+  const point = (joint) => [left + joint.x * (w - 1), top + joint.y * (h - 1)];
+  for (const outline of [true, false]) {
+    for (const [from, to] of SKELETON_BONES) {
+      const a = at.get(from);
+      const b = at.get(to);
+      if (!a || !b) continue;
+      const [x0, y0] = point(a);
+      const [x1, y1] = point(b);
+      canvas.line(x0, y0, x1, y1, outline ? OUTLINE : colorOf(to), outline ? stroke + 2 : stroke);
+    }
+    for (const joint of pose) {
+      const [x, y] = point(joint);
+      canvas.dot(x, y, outline ? stroke + 3 : stroke + 1, outline ? OUTLINE : colorOf(joint.label));
+    }
+  }
+}
+function colorOf(label) {
+  if (label.startsWith("RIGHT")) return RIGHT;
+  if (label.startsWith("LEFT")) return LEFT;
+  return CENTER;
+}
+var Canvas = class {
+  constructor(width, height) {
+    this.width = width;
+    this.height = height;
+    this.data = Buffer.alloc(width * height * 4);
+  }
+  width;
+  height;
+  data;
+  set(x, y, [r, g, b, a]) {
+    const px = Math.round(x);
+    const py = Math.round(y);
+    if (px < 0 || py < 0 || px >= this.width || py >= this.height) return;
+    const i = (py * this.width + px) * 4;
+    this.data[i] = r;
+    this.data[i + 1] = g;
+    this.data[i + 2] = b;
+    this.data[i + 3] = a;
+  }
+  fill(x, y, w, h, color) {
+    for (let dy = 0; dy < h; dy++) for (let dx = 0; dx < w; dx++) this.set(x + dx, y + dy, color);
+  }
+  /** Nearest-neighbour upscale, composited over what is there, at `strength`. */
+  drawImage(image, left, top, scale, strength) {
+    for (let y = 0; y < image.height; y++) {
+      for (let x = 0; x < image.width; x++) {
+        const i = (y * image.width + x) * 4;
+        const alpha = image.pixels[i + 3] / 255 * strength;
+        if (alpha === 0) continue;
+        const src = [image.pixels[i], image.pixels[i + 1], image.pixels[i + 2]];
+        for (let dy = 0; dy < scale; dy++) {
+          for (let dx = 0; dx < scale; dx++) {
+            const o = ((top + y * scale + dy) * this.width + left + x * scale + dx) * 4;
+            for (let c = 0; c < 3; c++) this.data[o + c] = Math.round(src[c] * alpha + this.data[o + c] * (1 - alpha));
+          }
+        }
+      }
+    }
+  }
+  line(x0, y0, x1, y1, color, stroke) {
+    const steps = Math.max(1, Math.ceil(Math.max(Math.abs(x1 - x0), Math.abs(y1 - y0))));
+    for (let step = 0; step <= steps; step++) {
+      const t = step / steps;
+      this.dot(x0 + (x1 - x0) * t, y0 + (y1 - y0) * t, stroke, color);
+    }
+  }
+  /** A filled square `size` wide centred on (x, y): crisp at pixel-art scale. */
+  dot(x, y, size, color) {
+    const half = Math.floor(size / 2);
+    for (let dy = -half; dy < size - half; dy++) for (let dx = -half; dx < size - half; dx++) this.set(x + dx, y + dy, color);
+  }
+};
+
+// src/cli/commands/skeleton.ts
 async function runEstimateSkeleton(args) {
   const image = args.target;
   if (!image) throw new UsageError("estimate-skeleton needs an image path: pixelkiln estimate-skeleton <image> [--out keypoints.json]");
-  loadEnvFiles(path46.dirname(path46.resolve(args.manifest)));
+  if (args.out && existsSync33(path47.resolve(args.out)) && !args.force) {
+    throw new UsageError(`${args.out} already exists; pass --force to replace it`);
+  }
+  loadEnvFiles(path47.dirname(path47.resolve(args.manifest)));
   loadEnvFiles(process.cwd());
-  const bytes = await readFile30(path46.resolve(image));
+  const bytes = await readFile31(path47.resolve(image));
   const metadata = imageMetadata(bytes);
   if (!metadata) throw new UsageError(`${image} is not a readable PNG or JPEG`);
+  const sizeProblem = estimateSkeletonSizeProblem(metadata.width, metadata.height);
+  if (sizeProblem) throw new UsageError(`${image} is ${sizeProblem}`);
   const client2 = clientFromEnv();
   const res = await client2.estimateSkeleton({
     image: { base64: bytes.toString("base64"), format: metadata.format }
   });
-  const json = JSON.stringify(res.keypoints, null, 2);
+  const frames = args.frames ?? DEFAULT_SCAFFOLD_FRAMES;
+  const json = JSON.stringify(scaffoldSkeletonSet(res.keypoints, frames), null, 2);
   if (args.out) {
-    await writeFile15(path46.resolve(args.out), json + "\n");
-    log(`  wrote ${res.keypoints.length} keypoints to ${args.out}`);
+    await writeFile16(path47.resolve(args.out), json + "\n");
+    log(`  wrote ${args.out}: the estimated pose and ${frames} frames to edit`);
+    log(`  preview it with: pixelkiln skeleton-preview ${args.out} --from ${image}`);
   } else {
     log(json);
   }
 }
+async function runSkeletonPreview(args) {
+  const target = args.target;
+  let keypointsFile;
+  let sourceFile;
+  let label;
+  if (target.endsWith(".json")) {
+    keypointsFile = path47.resolve(target);
+    sourceFile = args.from ? path47.resolve(args.from) : void 0;
+    label = target;
+  } else {
+    const loaded = await loadManifest(args.manifest);
+    const specs = (await resolveSpecs(loaded, { styles: args.styles, assets: [target] })).filter((spec2) => spec2.assetId === target);
+    const spec = specs.find((candidate) => candidate.revision?.mode === "animate-skeleton");
+    if (!spec) {
+      throw new UsageError(
+        specs.length ? `${target} is not an animate-skeleton revision; pass a keypoints file instead` : `No asset "${target}" in ${args.manifest}`
+      );
+    }
+    keypointsFile = spec.revision.keypointsFile;
+    sourceFile = args.from ? path47.resolve(args.from) : spec.revision.sourceFile;
+    label = `${spec.styleId}/${spec.assetId}`;
+  }
+  if (!existsSync33(keypointsFile)) throw new UsageError(`Keypoints file does not exist yet: ${keypointsFile}`);
+  let json;
+  try {
+    json = JSON.parse(await readFile31(keypointsFile, "utf8"));
+  } catch (error) {
+    throw new UsageError(`${keypointsFile} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const set = parseSkeletonSet(json, keypointsFile);
+  let source;
+  if (sourceFile) {
+    if (!existsSync33(sourceFile)) {
+      log(`  source image does not exist yet, drawing on a plain ground: ${sourceFile}`);
+    } else {
+      const bytes = await readFile31(sourceFile);
+      if (imageMetadata(bytes)?.format !== "png") throw new UsageError(`${sourceFile} must be a PNG to preview over`);
+      source = decodePng(bytes);
+    }
+  }
+  const out = path47.resolve(args.out ?? keypointsFile.replace(/\.json$/, "") + ".preview.png");
+  await writeFile16(out, renderSkeletonSheet(set, { source }));
+  log(`  ${label}: ${set.frames.length} frames after the starting pose`);
+  const shown = path47.relative(process.cwd(), out);
+  log(`  wrote ${shown.startsWith("..") ? out : shown}`);
+}
 
 // src/cli/commands/tools.ts
 async function runTools(args) {
@@ -20601,15 +20992,15 @@ async function runTools(args) {
 }
 
 // src/cli/commands/workspace.ts
-import path47 from "path";
-import { existsSync as existsSync32 } from "fs";
+import path48 from "path";
+import { existsSync as existsSync34 } from "fs";
 async function runWorkspace(args) {
-  const workspacePath = path47.resolve(args.workspace ?? "pixelkiln.workspace.json");
-  const dir = path47.dirname(workspacePath);
+  const workspacePath = path48.resolve(args.workspace ?? "pixelkiln.workspace.json");
+  const dir = path48.dirname(workspacePath);
   if (args.subcommand === "add") {
-    const manifestPath = path47.resolve(args.target);
+    const manifestPath = path48.resolve(args.target);
     const loadedTarget = await loadManifest(manifestPath);
-    const lockPath = args.explicitLock ? path47.resolve(args.explicitLock) : path47.join(path47.dirname(manifestPath), "pixelkiln.lock.json");
+    const lockPath = args.explicitLock ? path48.resolve(args.explicitLock) : path48.join(path48.dirname(manifestPath), "pixelkiln.lock.json");
     const ws = await loadWorkspace(workspacePath);
     const id = args.name ?? loadedTarget.manifest.name;
     if (ws.projects.some((p) => p.id === id)) {
@@ -20629,10 +21020,10 @@ async function runWorkspace(args) {
       ...args.account ? { account: args.account } : {}
     };
     await saveWorkspace(workspacePath, { version: 1, projects: [...ws.projects, project] });
-    log(`  registered "${id}" in ${path47.relative(process.cwd(), workspacePath)}`);
+    log(`  registered "${id}" in ${path48.relative(process.cwd(), workspacePath)}`);
     log(`    manifest: ${project.manifest}`);
     log(`    lock:     ${project.lock}`);
-    if (!existsSync32(lockPath)) {
+    if (!existsSync34(lockPath)) {
       log(
         `  warning: no lockfile there yet; this project contributes no claims until one is generated`
       );
@@ -20641,7 +21032,7 @@ async function runWorkspace(args) {
   }
   if (args.subcommand === "remove") {
     const ws = await loadWorkspace(workspacePath);
-    const resolvedTarget = path47.resolve(args.target);
+    const resolvedTarget = path48.resolve(args.target);
     const match = ws.projects.find(
       (p) => p.id === args.target || resolveProject(dir, p).manifestPath === resolvedTarget
     );
@@ -20652,11 +21043,11 @@ async function runWorkspace(args) {
       version: 1,
       projects: ws.projects.filter((p) => p !== match)
     });
-    log(`  removed "${match.id}" from ${path47.relative(process.cwd(), workspacePath)}`);
+    log(`  removed "${match.id}" from ${path48.relative(process.cwd(), workspacePath)}`);
     return;
   }
   if (args.subcommand === "list") {
-    if (!existsSync32(workspacePath)) {
+    if (!existsSync34(workspacePath)) {
       throw new Error(`Workspace catalog not found: ${workspacePath}`);
     }
     const ws = await loadWorkspace(workspacePath);
@@ -20664,9 +21055,9 @@ async function runWorkspace(args) {
     if (args.json) {
       log(JSON.stringify({ version: 1, workspace: workspacePath, projects: ws.projects, diagnostics }, null, 2));
     } else if (!ws.projects.length) {
-      log(`  no projects registered in ${path47.relative(process.cwd(), workspacePath)}`);
+      log(`  no projects registered in ${path48.relative(process.cwd(), workspacePath)}`);
     } else {
-      log(`  ${ws.projects.length} project(s) in ${path47.relative(process.cwd(), workspacePath)}:`);
+      log(`  ${ws.projects.length} project(s) in ${path48.relative(process.cwd(), workspacePath)}:`);
       for (const p of ws.projects) {
         log(`    ${p.id.padEnd(24)} ${p.manifest.padEnd(40)} (${p.provider}${p.account ? `, ${p.account}` : ""})`);
       }
@@ -20676,7 +21067,7 @@ async function runWorkspace(args) {
     return;
   }
   if (args.subcommand === "status") {
-    if (!existsSync32(workspacePath)) {
+    if (!existsSync34(workspacePath)) {
       throw new Error(`Workspace catalog not found: ${workspacePath}`);
     }
     const ws = await loadWorkspace(workspacePath);
@@ -20684,7 +21075,7 @@ async function runWorkspace(args) {
     if (args.json) {
       log(JSON.stringify({ ...report, workspace: workspacePath }, null, 2));
     } else {
-      log(`  workspace: ${path47.relative(process.cwd(), workspacePath)}`);
+      log(`  workspace: ${path48.relative(process.cwd(), workspacePath)}`);
       for (const p of report.projects) {
         if (p.error) {
           log(`
@@ -20738,8 +21129,8 @@ async function runHelp() {
 async function runVersion() {
   for (const up of ["../package.json", "../../package.json"]) {
     const url = new URL(up, import.meta.url);
-    if (!existsSync33(url)) continue;
-    const pkg = JSON.parse(await readFile31(url, "utf8"));
+    if (!existsSync35(url)) continue;
+    const pkg = JSON.parse(await readFile32(url, "utf8"));
     if (pkg.name === "pixelkiln") {
       log(`${pkg.name} ${pkg.version}`);
       return;
@@ -20784,6 +21175,7 @@ var RUNNERS = {
   recipe: runRecipe,
   workspace: runWorkspace,
   "estimate-skeleton": runEstimateSkeleton,
+  "skeleton-preview": runSkeletonPreview,
   unzoom: runUnzoom,
   font: runFont
 };