pixelkiln 0.66.0 → 0.67.0

package/dist/cli.js

@@ -68,7 +68,7 @@ function exitCodeFor(err) {
 
 // src/cli/main.ts
 import { existsSync as existsSync33 } from "fs";
-import { readFile as readFile30 } from "fs/promises";
+import { readFile as readFile31 } from "fs/promises";
 
 // src/cli/args.ts
 import path from "path";
@@ -157,6 +157,7 @@ var COMMANDS = [
   "refine",
   "recipe",
   "workspace",
+  "estimate-skeleton",
   "unzoom",
   "font",
   "help",
@@ -251,6 +252,10 @@ function parseArgs(argv) {
       }
       rest = rest.slice(1);
     }
+  } else if (command === "estimate-skeleton") {
+    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 === "refine") {
     subcommand = rest[0]?.startsWith("-") || rest[0] === void 0 ? "run" : rest[0];
     if (!REFINE_SUBCOMMANDS.includes(subcommand)) {
@@ -456,6 +461,11 @@ 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.
   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.
@@ -638,10 +648,10 @@ import { createReadStream } from "fs";
 function sha256(data) {
   return createHash("sha256").update(data).digest("hex");
 }
-async function sha256File(path47) {
+async function sha256File(path48) {
   return new Promise((resolve, reject) => {
     const hash = createHash("sha256");
-    const stream = createReadStream(path47);
+    const stream = createReadStream(path48);
     stream.on("data", (chunk2) => hash.update(chunk2));
     stream.on("error", reject);
     stream.on("end", () => resolve(hash.digest("hex")));
@@ -757,6 +767,9 @@ function specHash(spec, styleImageHashes, providerOptionIdentity = spec.provider
         lastFrameSha256: spec.revision.lastFrameSha256,
         direction: spec.revision.direction,
         enhancePrompt: spec.revision.enhancePrompt,
+        keypointsSha256: spec.revision.keypointsSha256,
+        skeletonTemplate: spec.revision.skeletonTemplate,
+        description: spec.revision.description,
         engine: spec.revision.engine
       } : void 0
     })
@@ -785,6 +798,7 @@ var RevisionModeSchema = z.enum([
   "correct-pixelart",
   "animate",
   "animate-pixminimax",
+  "animate-skeleton",
   "interpolate",
   "edit-animation"
 ]);
@@ -1103,6 +1117,30 @@ var RevisionSchema = z.object({
   direction: CharacterDirectionSchema.optional(),
   /** `animate`/`animate-pixminimax` only: let PixelLab expand the action into a fuller motion description first. */
   enhancePrompt: z.boolean().optional(),
+  /**
+   * `animate-skeleton` only: manifest-relative path to a committed
+   * `SkeletonSet` JSON file (see `src/skeleton.ts`) — the pose the parent
+   * image is already in, plus 3-15 per-frame poses for the motion.
+   * Authored via `pixelkiln estimate-skeleton`, then hand-tweaked; never
+   * inline in the manifest, the same reasoning `mask`/`lastFrame` are
+   * committed files rather than inline pixel data.
+   */
+  keypointsFile: z.string().min(1).optional(),
+  /**
+   * `animate-skeleton` only: the body a joint's missing `depth` is taken
+   * from. PixelLab's default is `mannequin`; free string like `character`'s
+   * own `template` field, validated at the provider layer against the
+   * same `mannequin`/`bear`/`cat`/`dog`/`horse`/`lion` vocabulary.
+   */
+  skeletonTemplate: z.string().min(1).optional(),
+  /**
+   * `animate-skeleton` only: what the character *looks like*, a noun
+   * phrase (colours, clothing, held items) — distinct from the asset's
+   * own `prompt`, which this mode sends as the motion's short label
+   * (PixelLab's `action`), the same `prompt`-as-motion convention
+   * `animate`/`animate-pixminimax` already use.
+   */
+  description: z.string().min(1).optional(),
   /**
    * `image-to-image`/`inpaint` only: which provider engine draws the
    * edit. `pro-flash` selects PixelLab's Pro Flash edit and inpaint tier
@@ -1193,18 +1231,41 @@ var RevisionSchema = z.object({
       path: ["fps"]
     });
   }
-  if (revision.direction !== void 0 && revision.mode !== "animate-pixminimax") {
+  if (revision.direction !== void 0 && revision.mode !== "animate-pixminimax" && revision.mode !== "animate-skeleton") {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "direction applies to animate-pixminimax/animate-skeleton revisions only",
+      path: ["direction"]
+    });
+  }
+  if (revision.mode === "animate-skeleton" && revision.direction === void 0) {
     context.addIssue({
       code: z.ZodIssueCode.custom,
-      message: "direction applies to animate-pixminimax revisions only",
+      message: "animate-skeleton revisions require a direction",
       path: ["direction"]
     });
   }
   if (revision.frames !== void 0 && revision.frames % 2 !== 0) {
     context.addIssue({ code: z.ZodIssueCode.custom, message: "frames must be even", path: ["frames"] });
   }
+  if (revision.mode === "animate-skeleton" && !revision.keypointsFile) {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "animate-skeleton revisions require keypointsFile",
+      path: ["keypointsFile"]
+    });
+  }
+  for (const field of ["keypointsFile", "skeletonTemplate", "description"]) {
+    if (revision[field] !== void 0 && revision.mode !== "animate-skeleton") {
+      context.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `${field} applies to animate-skeleton revisions only`,
+        path: [field]
+      });
+    }
+  }
 });
-var FRAME_SET_REVISION_MODES = ["animate", "animate-pixminimax", "interpolate", "edit-animation"];
+var FRAME_SET_REVISION_MODES = ["animate", "animate-pixminimax", "animate-skeleton", "interpolate", "edit-animation"];
 var MEMBER_SET_REVISION_MODES = ["reduce-colors", "correct-pixelart", "edit-animation"];
 var StyleObjectSchema = z.object({
   /** Generation backend for this style. Omit to inherit the manifest default. */
@@ -1836,11 +1897,16 @@ var LockEntrySchema = z.object({
     paletteImageSha256: z.string().regex(/^[0-9a-f]{64}$/).optional(),
     dithering: RevisionDitheringSchema.optional(),
     ditheringStrength: z.number().min(0).max(10).optional(),
-    frames: z.number().int().min(4).max(40).optional(),
+    // 4-40 for animate/animate-pixminimax; animate-skeleton's own 3-15
+    // range extends the floor down to 3, hence min(3) here rather than 4.
+    frames: z.number().int().min(3).max(40).optional(),
     fps: z.number().int().min(1).max(60).optional(),
     lastFrameSha256: z.string().regex(/^[0-9a-f]{64}$/).optional(),
     direction: CharacterDirectionSchema.optional(),
     enhancePrompt: z.boolean().optional(),
+    keypointsSha256: z.string().regex(/^[0-9a-f]{64}$/).optional(),
+    skeletonTemplate: z.string().min(1).optional(),
+    description: z.string().min(1).optional(),
     engine: z.enum(["pro-flash"]).optional()
   }).strict().nullable().default(null),
   /** For a mirror: the asset it flips and a hash over that asset's output hashes when this was made. */
@@ -4993,11 +5059,12 @@ var ComfyUIProvider = class _ComfyUIProvider {
   /**
    * Everything else resolves generically to whatever the user's own
    * workflow does with `bindings.sourceImage`. The frame-set modes
-   * (`animate`, `animate-pixminimax`, `interpolate`, `edit-animation`) are
-   * the exception: they produce an ordered frame set, and this adapter's
-   * revision path always writes a single output image (see `submit`/`fetch`
-   * below) — a real structural gap, not a missing binding, so they are
-   * rejected here rather than only failing once `validate` runs.
+   * (`animate`, `animate-pixminimax`, `animate-skeleton`, `interpolate`,
+   * `edit-animation`) are the exception: they produce an ordered frame set,
+   * and this adapter's revision path always writes a single output image
+   * (see `submit`/`fetch` below) — a real structural gap, not a missing
+   * binding, so they are rejected here rather than only failing once
+   * `validate` runs.
    */
   supportsRevision(mode2) {
     return !FRAME_SET_REVISION_MODES.includes(mode2);
@@ -5657,262 +5724,291 @@ import os from "os";
 import path12 from "path";
 
 // src/client.ts
+import { z as z3 } from "zod";
+
+// src/skeleton.ts
 import { z as z2 } from "zod";
+var SkeletonKeypointSchema = z2.object({
+  label: z2.string().min(1),
+  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 SkeletonSetSchema = z2.object({
+  firstFrameKeypoints: SkeletonFrameSchema,
+  frames: z2.array(SkeletonFrameSchema).min(3).max(15)
+}).strict();
+function parseSkeletonSet(json, file) {
+  const result = SkeletonSetSchema.safeParse(json);
+  if (!result.success) {
+    const issues = result.error.issues.slice(0, 4).map((issue) => `${issue.path.join(".") || "root"}: ${issue.message}`).join("; ");
+    throw new Error(`revision keypoints file ${file} does not match the expected shape: ${issues}`);
+  }
+  return result.data;
+}
+
+// src/client.ts
 var BASE = process.env.PIXELLAB_API_BASE ?? "https://api.pixellab.ai/v2";
 var MAX_DOWNLOAD_BYTES = 64 * 1024 * 1024;
-var BalanceResponseSchema = z2.object({
-  credits: z2.object({ usd: z2.number() }).passthrough(),
-  subscription: z2.object({
-    generations: z2.number(),
-    total: z2.number(),
-    plan: z2.string().nullable().optional()
+var BalanceResponseSchema = z3.object({
+  credits: z3.object({ usd: z3.number() }).passthrough(),
+  subscription: z3.object({
+    generations: z3.number(),
+    total: z3.number(),
+    plan: z3.string().nullable().optional()
   }).passthrough()
 }).passthrough();
-var ObjectSubmitSchema = z2.object({
-  background_job_id: z2.string().min(1),
-  object_id: z2.string().min(1),
-  status: z2.string().default("queued"),
-  n_frames: z2.number().int().min(0)
+var ObjectSubmitSchema = z3.object({
+  background_job_id: z3.string().min(1),
+  object_id: z3.string().min(1),
+  status: z3.string().default("queued"),
+  n_frames: z3.number().int().min(0)
 }).passthrough();
-var MapSubmitSchema = z2.object({
-  background_job_id: z2.string().min(1),
-  object_id: z2.string().min(1),
-  status: z2.string().default("processing")
+var MapSubmitSchema = z3.object({
+  background_job_id: z3.string().min(1),
+  object_id: z3.string().min(1),
+  status: z3.string().default("processing")
 }).passthrough();
-var UsageSchema = z2.object({
-  type: z2.string().optional(),
-  usd: z2.number().nullable().optional(),
-  generations: z2.number().nullable().optional()
+var UsageSchema = z3.object({
+  type: z3.string().optional(),
+  usd: z3.number().nullable().optional(),
+  generations: z3.number().nullable().optional()
 }).passthrough().nullable().optional();
-var TilesSubmitSchema = z2.object({
-  tile_id: z2.string().min(1),
-  background_job_id: z2.string().min(1),
-  status: z2.literal("processing").default("processing")
+var TilesSubmitSchema = z3.object({
+  tile_id: z3.string().min(1),
+  background_job_id: z3.string().min(1),
+  status: z3.literal("processing").default("processing")
 }).passthrough();
-var TilesProSchema = z2.object({
-  storage_urls: z2.record(z2.string()),
-  kind: z2.string().nullable().default(null),
-  tile_rules: z2.record(z2.unknown()).nullable().optional()
+var TilesProSchema = z3.object({
+  storage_urls: z3.record(z3.string()),
+  kind: z3.string().nullable().default(null),
+  tile_rules: z3.record(z3.unknown()).nullable().optional()
 }).passthrough();
-var TilesetSubmitSchema = z2.object({
-  tileset_id: z2.string().min(1),
-  background_job_id: z2.string().min(1),
-  status: z2.literal("processing").default("processing")
+var TilesetSubmitSchema = z3.object({
+  tileset_id: z3.string().min(1),
+  background_job_id: z3.string().min(1),
+  status: z3.literal("processing").default("processing")
 }).passthrough();
-var TilesetTileSchema = z2.object({
-  id: z2.string().min(1),
-  name: z2.string(),
-  image: z2.object({ base64: z2.string().min(1), format: z2.string().default("png") }).passthrough(),
-  corners: z2.object({ NW: z2.string(), NE: z2.string(), SW: z2.string(), SE: z2.string() }).passthrough(),
-  pattern_4x4: z2.object({
-    row_0: z2.array(z2.number()),
-    row_1: z2.array(z2.number()),
-    row_2: z2.array(z2.number()),
-    row_3: z2.array(z2.number())
+var TilesetTileSchema = z3.object({
+  id: z3.string().min(1),
+  name: z3.string(),
+  image: z3.object({ base64: z3.string().min(1), format: z3.string().default("png") }).passthrough(),
+  corners: z3.object({ NW: z3.string(), NE: z3.string(), SW: z3.string(), SE: z3.string() }).passthrough(),
+  pattern_4x4: z3.object({
+    row_0: z3.array(z3.number()),
+    row_1: z3.array(z3.number()),
+    row_2: z3.array(z3.number()),
+    row_3: z3.array(z3.number())
   }).passthrough()
 }).passthrough();
-var TilesetGetSchema = z2.object({
-  tileset: z2.object({
-    total_tiles: z2.number().int().min(1),
-    tile_size: z2.object({ width: z2.number().int().positive(), height: z2.number().int().positive() }).passthrough(),
-    terrain_types: z2.array(z2.string()),
-    tiles: z2.array(TilesetTileSchema).min(1)
+var TilesetGetSchema = z3.object({
+  tileset: z3.object({
+    total_tiles: z3.number().int().min(1),
+    tile_size: z3.object({ width: z3.number().int().positive(), height: z3.number().int().positive() }).passthrough(),
+    terrain_types: z3.array(z3.string()),
+    tiles: z3.array(TilesetTileSchema).min(1)
   }).passthrough(),
   usage: UsageSchema
 }).passthrough();
-var IsometricTileSubmitSchema = z2.object({
-  tile_id: z2.string().min(1),
-  background_job_id: z2.string().min(1),
-  status: z2.literal("processing").default("processing")
+var IsometricTileSubmitSchema = z3.object({
+  tile_id: z3.string().min(1),
+  background_job_id: z3.string().min(1),
+  status: z3.literal("processing").default("processing")
 }).passthrough();
-var IsometricTileGetSchema = z2.object({
-  image: z2.object({ base64: z2.string().min(1), format: z2.string().default("png") }).passthrough(),
+var IsometricTileGetSchema = z3.object({
+  image: z3.object({ base64: z3.string().min(1), format: z3.string().default("png") }).passthrough(),
   usage: UsageSchema
 }).passthrough();
-var UiAssetSubmitSchema = z2.object({
-  ui_asset_id: z2.string().min(1),
-  background_job_id: z2.string().min(1),
-  status: z2.string().default("processing"),
+var UiAssetSubmitSchema = z3.object({
+  ui_asset_id: z3.string().min(1),
+  background_job_id: z3.string().min(1),
+  status: z3.string().default("processing"),
   usage: UsageSchema
 }).passthrough();
-var UiAssetGetSchema = z2.object({
-  id: z2.string().min(1),
-  status: z2.string().nullable().default(null),
-  image_url: z2.string().nullable().optional(),
-  progress_percent: z2.number().nullable().optional(),
-  eta_seconds: z2.number().nullable().optional()
+var UiAssetGetSchema = z3.object({
+  id: z3.string().min(1),
+  status: z3.string().nullable().default(null),
+  image_url: z3.string().nullable().optional(),
+  progress_percent: z3.number().nullable().optional(),
+  eta_seconds: z3.number().nullable().optional()
 }).passthrough();
-var RevisionJobSubmitSchema = z2.object({
-  background_job_id: z2.string().min(1),
-  status: z2.string().default("processing")
+var RevisionJobSubmitSchema = z3.object({
+  background_job_id: z3.string().min(1),
+  status: z3.string().default("processing")
 }).passthrough();
-var ObjectAnimationGroupSchema = z2.object({
-  animation_group_id: z2.string().min(1),
-  display_name: z2.string().nullable().default(null),
-  description: z2.string().default(""),
-  frame_count: z2.number().int().default(0),
-  directions: z2.array(
-    z2.object({
-      direction: z2.string(),
-      storage_urls: z2.record(z2.unknown()).default({}),
-      created_at: z2.string()
+var ObjectAnimationGroupSchema = z3.object({
+  animation_group_id: z3.string().min(1),
+  display_name: z3.string().nullable().default(null),
+  description: z3.string().default(""),
+  frame_count: z3.number().int().default(0),
+  directions: z3.array(
+    z3.object({
+      direction: z3.string(),
+      storage_urls: z3.record(z3.unknown()).default({}),
+      created_at: z3.string()
     }).passthrough()
   ).default([])
 }).passthrough();
-var PixelLabObjectSchema = z2.object({
-  id: z2.string().min(1),
-  name: z2.string().nullable().default(null),
-  state_name: z2.string().nullable().optional(),
-  prompt: z2.string().default(""),
-  size: z2.object({ width: z2.number().int().positive(), height: z2.number().int().positive() }),
-  directions: z2.number().default(0),
-  created_at: z2.string(),
-  view: z2.string().nullable().default(null),
-  preview_url: z2.string().nullable().optional(),
-  rotation_urls: z2.record(z2.string().nullable()).nullable().optional(),
-  frame_urls: z2.array(z2.string()).nullable().optional(),
-  tags: z2.array(z2.string()).default([]),
-  status: z2.string().nullable().default(null),
-  progress_percent: z2.number().nullable().optional(),
-  eta_seconds: z2.number().nullable().optional(),
-  group_id: z2.string().nullable().optional(),
-  animations: z2.array(ObjectAnimationGroupSchema).default([])
+var PixelLabObjectSchema = z3.object({
+  id: z3.string().min(1),
+  name: z3.string().nullable().default(null),
+  state_name: z3.string().nullable().optional(),
+  prompt: z3.string().default(""),
+  size: z3.object({ width: z3.number().int().positive(), height: z3.number().int().positive() }),
+  directions: z3.number().default(0),
+  created_at: z3.string(),
+  view: z3.string().nullable().default(null),
+  preview_url: z3.string().nullable().optional(),
+  rotation_urls: z3.record(z3.string().nullable()).nullable().optional(),
+  frame_urls: z3.array(z3.string()).nullable().optional(),
+  tags: z3.array(z3.string()).default([]),
+  status: z3.string().nullable().default(null),
+  progress_percent: z3.number().nullable().optional(),
+  eta_seconds: z3.number().nullable().optional(),
+  group_id: z3.string().nullable().optional(),
+  animations: z3.array(ObjectAnimationGroupSchema).default([])
+}).passthrough();
+var MapObjectSchema = z3.object({
+  object_id: z3.string().min(1),
+  status: z3.string(),
+  description: z3.string().nullable().default(null),
+  width: z3.number().nullable().default(null),
+  height: z3.number().nullable().default(null),
+  download_url: z3.string().nullable().default(null)
 }).passthrough();
-var MapObjectSchema = z2.object({
-  object_id: z2.string().min(1),
-  status: z2.string(),
-  description: z2.string().nullable().default(null),
-  width: z2.number().nullable().default(null),
-  height: z2.number().nullable().default(null),
-  download_url: z2.string().nullable().default(null)
+var ObjectListSchema = z3.object({ objects: z3.array(PixelLabObjectSchema), total: z3.number().int().min(0) }).passthrough();
+var PixfluxResponseSchema = z3.object({ image: z3.object({ base64: z3.string().min(1) }).passthrough(), usage: z3.unknown().optional() }).passthrough();
+var ReduceColorsResponseSchema = z3.object({
+  images: z3.array(z3.object({ base64: z3.string().min(1) }).passthrough()).min(1),
+  palette: z3.object({ base64: z3.string().min(1) }).passthrough(),
+  n_colors: z3.number().int(),
+  usage: z3.unknown().optional()
 }).passthrough();
-var ObjectListSchema = z2.object({ objects: z2.array(PixelLabObjectSchema), total: z2.number().int().min(0) }).passthrough();
-var PixfluxResponseSchema = z2.object({ image: z2.object({ base64: z2.string().min(1) }).passthrough(), usage: z2.unknown().optional() }).passthrough();
-var ReduceColorsResponseSchema = z2.object({
-  images: z2.array(z2.object({ base64: z2.string().min(1) }).passthrough()).min(1),
-  palette: z2.object({ base64: z2.string().min(1) }).passthrough(),
-  n_colors: z2.number().int(),
-  usage: z2.unknown().optional()
+var CorrectPixelartResponseSchema = z3.object({
+  images: z3.array(z3.object({ base64: z3.string().min(1) }).passthrough()).min(1),
+  usage: z3.unknown().optional()
 }).passthrough();
-var CorrectPixelartResponseSchema = z2.object({
-  images: z2.array(z2.object({ base64: z2.string().min(1) }).passthrough()).min(1),
-  usage: z2.unknown().optional()
+var ProFlashImageSubmitSchema = z3.object({
+  background_job_id: z3.string().min(1),
+  image_id: z3.string().min(1),
+  source_image_id: z3.string().min(1),
+  status: z3.string().default("processing"),
+  estimated_generations: z3.number().nullable().optional(),
+  usage: z3.unknown().optional()
 }).passthrough();
-var ProFlashImageSubmitSchema = z2.object({
-  background_job_id: z2.string().min(1),
-  image_id: z2.string().min(1),
-  source_image_id: z2.string().min(1),
-  status: z2.string().default("processing"),
-  estimated_generations: z2.number().nullable().optional(),
-  usage: z2.unknown().optional()
+var UnzoomResponseSchema = z3.object({
+  image: z3.object({ base64: z3.string().min(1) }).passthrough(),
+  original_size: z3.object({ width: z3.number().int(), height: z3.number().int() }).passthrough(),
+  unzoomed_size: z3.object({ width: z3.number().int(), height: z3.number().int() }).passthrough(),
+  zoom_factor_detected: z3.number(),
+  usage: z3.unknown().optional()
 }).passthrough();
-var UnzoomResponseSchema = z2.object({
-  image: z2.object({ base64: z2.string().min(1) }).passthrough(),
-  original_size: z2.object({ width: z2.number().int(), height: z2.number().int() }).passthrough(),
-  unzoomed_size: z2.object({ width: z2.number().int(), height: z2.number().int() }).passthrough(),
-  zoom_factor_detected: z2.number(),
-  usage: z2.unknown().optional()
+var FontJobSchema = z3.object({
+  job_id: z3.string().min(1),
+  status: z3.string(),
+  glyph_px: z3.number().int().nullable().optional(),
+  download_atlas_url: z3.string().nullable().optional(),
+  download_ttf_url: z3.string().nullable().optional(),
+  usage: z3.unknown().optional()
 }).passthrough();
-var FontJobSchema = z2.object({
-  job_id: z2.string().min(1),
-  status: z2.string(),
-  glyph_px: z2.number().int().nullable().optional(),
-  download_atlas_url: z2.string().nullable().optional(),
-  download_ttf_url: z2.string().nullable().optional(),
-  usage: z2.unknown().optional()
+var SelectFramesSchema = z3.object({ created_object_ids: z3.array(z3.string()) }).passthrough();
+var EstimateSkeletonResponseSchema = z3.object({
+  keypoints: z3.array(SkeletonKeypointSchema).length(18),
+  usage: z3.unknown().optional()
 }).passthrough();
-var SelectFramesSchema = z2.object({ created_object_ids: z2.array(z2.string()) }).passthrough();
-var CharacterSubmitSchema = z2.object({
-  background_job_id: z2.string().min(1),
-  character_id: z2.string().min(1),
-  status: z2.string().default("processing"),
+var CharacterSubmitSchema = z3.object({
+  background_job_id: z3.string().min(1),
+  character_id: z3.string().min(1),
+  status: z3.string().default("processing"),
   usage: UsageSchema
 }).passthrough();
-var AnimateSubmitSchema = z2.object({
-  background_job_ids: z2.array(z2.string()),
-  directions: z2.array(z2.string()),
-  status: z2.string().default("processing"),
+var AnimateSubmitSchema = z3.object({
+  background_job_ids: z3.array(z3.string()),
+  directions: z3.array(z3.string()),
+  status: z3.string().default("processing"),
   usage: UsageSchema
 }).passthrough();
-var ObjectProSubmitSchema = z2.object({
-  object_id: z2.string().min(1),
-  background_job_id: z2.string().min(1),
-  status: z2.string().default("processing"),
+var ObjectProSubmitSchema = z3.object({
+  object_id: z3.string().min(1),
+  background_job_id: z3.string().min(1),
+  status: z3.string().default("processing"),
   usage: UsageSchema
 }).passthrough();
-var DirectionSubmissionSchema = z2.object({
-  direction: z2.string(),
-  status: z2.string(),
-  background_job_id: z2.string().nullable().default(null),
-  animation_id: z2.string().nullable().default(null)
+var DirectionSubmissionSchema = z3.object({
+  direction: z3.string(),
+  status: z3.string(),
+  background_job_id: z3.string().nullable().default(null),
+  animation_id: z3.string().nullable().default(null)
 }).passthrough();
-var AnimateObjectSubmitSchema = z2.object({
-  animation_group_id: z2.string().min(1),
-  object_id: z2.string().min(1),
-  mode: z2.string(),
-  frame_count: z2.number().int(),
-  display_name: z2.string().nullable().default(null),
-  description: z2.string().default(""),
-  submissions: z2.array(DirectionSubmissionSchema),
+var AnimateObjectSubmitSchema = z3.object({
+  animation_group_id: z3.string().min(1),
+  object_id: z3.string().min(1),
+  mode: z3.string(),
+  frame_count: z3.number().int(),
+  display_name: z3.string().nullable().default(null),
+  description: z3.string().default(""),
+  submissions: z3.array(DirectionSubmissionSchema),
   usage: UsageSchema
 }).passthrough();
-var PortraitSubmitSchema = z2.object({
-  background_job_id: z2.string().min(1),
-  status: z2.string().default("processing"),
+var PortraitSubmitSchema = z3.object({
+  background_job_id: z3.string().min(1),
+  status: z3.string().default("processing"),
   usage: UsageSchema
 }).passthrough();
-var PortraitJobSchema = z2.object({
-  status: z2.string(),
-  download_url: z2.string().nullable().optional(),
-  width: z2.number().int().nullable().optional(),
-  height: z2.number().int().nullable().optional()
+var PortraitJobSchema = z3.object({
+  status: z3.string(),
+  download_url: z3.string().nullable().optional(),
+  width: z3.number().int().nullable().optional(),
+  height: z3.number().int().nullable().optional()
 }).passthrough();
-var SetPortraitSchema = z2.object({
-  character_id: z2.string().min(1),
-  size: z2.number().int().positive(),
-  url: z2.string().min(1),
+var SetPortraitSchema = z3.object({
+  character_id: z3.string().min(1),
+  size: z3.number().int().positive(),
+  url: z3.string().min(1),
   usage: UsageSchema
 }).passthrough();
-var TransferOutfitSubmitSchema = z2.object({
-  background_job_id: z2.string().min(1),
-  status: z2.string().default("processing"),
+var TransferOutfitSubmitSchema = z3.object({
+  background_job_id: z3.string().min(1),
+  status: z3.string().default("processing"),
   usage: UsageSchema
 }).passthrough();
-var CharacterAnimationDirectionSchema = z2.object({
-  direction: z2.string(),
-  frame_count: z2.number().int().min(0),
-  frames: z2.array(z2.string())
+var CharacterAnimationDirectionSchema = z3.object({
+  direction: z3.string(),
+  frame_count: z3.number().int().min(0),
+  frames: z3.array(z3.string())
 }).passthrough();
-var CharacterAnimationSchema2 = z2.object({
-  animation_type: z2.string(),
-  display_name: z2.string().nullable().optional(),
-  animation_group_id: z2.string().nullable().optional(),
-  directions: z2.array(CharacterAnimationDirectionSchema)
+var CharacterAnimationSchema2 = z3.object({
+  animation_type: z3.string(),
+  display_name: z3.string().nullable().optional(),
+  animation_group_id: z3.string().nullable().optional(),
+  directions: z3.array(CharacterAnimationDirectionSchema)
 }).passthrough();
-var CharacterSchema = z2.object({
-  id: z2.string().min(1),
-  name: z2.string().default(""),
-  state_name: z2.string().nullable().optional(),
-  prompt: z2.string().default(""),
-  size: z2.object({ width: z2.number().int().positive(), height: z2.number().int().positive() }),
-  directions: z2.number().int(),
-  created_at: z2.string(),
-  updated_at: z2.string().nullable().optional(),
-  animation_count: z2.number().int().default(0),
-  template_id: z2.string().default("mannequin"),
-  view: z2.string().nullable().optional(),
-  status: z2.string().default("completed"),
-  rotation_urls: z2.record(z2.string().nullable()).nullable().optional(),
-  tags: z2.array(z2.string()).default([]),
-  group_id: z2.string().nullable().optional(),
-  animations: z2.array(CharacterAnimationSchema2).default([]),
-  preview_url: z2.string().nullable().optional()
+var CharacterSchema = z3.object({
+  id: z3.string().min(1),
+  name: z3.string().default(""),
+  state_name: z3.string().nullable().optional(),
+  prompt: z3.string().default(""),
+  size: z3.object({ width: z3.number().int().positive(), height: z3.number().int().positive() }),
+  directions: z3.number().int(),
+  created_at: z3.string(),
+  updated_at: z3.string().nullable().optional(),
+  animation_count: z3.number().int().default(0),
+  template_id: z3.string().default("mannequin"),
+  view: z3.string().nullable().optional(),
+  status: z3.string().default("completed"),
+  rotation_urls: z3.record(z3.string().nullable()).nullable().optional(),
+  tags: z3.array(z3.string()).default([]),
+  group_id: z3.string().nullable().optional(),
+  animations: z3.array(CharacterAnimationSchema2).default([]),
+  preview_url: z3.string().nullable().optional()
 }).passthrough();
-var CharacterListSchema = z2.object({ characters: z2.array(CharacterSchema), total: z2.number().int().min(0) }).passthrough();
-var BackgroundJobSchema = z2.object({
-  id: z2.string(),
-  status: z2.string(),
-  last_response: z2.record(z2.unknown()).nullable().optional(),
+var CharacterListSchema = z3.object({ characters: z3.array(CharacterSchema), total: z3.number().int().min(0) }).passthrough();
+var BackgroundJobSchema = z3.object({
+  id: z3.string(),
+  status: z3.string(),
+  last_response: z3.record(z3.unknown()).nullable().optional(),
   /**
    * The billed amount, confirmed live for a `map` object and a standard
    * character base (docs/ENDPOINTS.md, "Limits and billing"); duplicated at
@@ -5920,7 +6016,7 @@ var BackgroundJobSchema = z2.object({
    */
   usage: UsageSchema
 }).passthrough();
-var DeleteAnimationsSchema = z2.object({ success: z2.boolean(), deleted_count: z2.number().int().default(0), error: z2.string().nullable().optional() }).passthrough();
+var DeleteAnimationsSchema = z3.object({ success: z3.boolean(), deleted_count: z3.number().int().default(0), error: z3.string().nullable().optional() }).passthrough();
 function validateResponse(schema, raw, operation) {
   const parsed = schema.safeParse(raw);
   if (parsed.success) return parsed.data;
@@ -5966,9 +6062,9 @@ var PixelLabClient = class {
   apiKey;
   http;
   /** Retries transport failures, 429, and 5xx; see http.ts for the policy. */
-  async request(path47, init) {
+  async request(path48, init) {
     const auth = this.apiKey.startsWith("Bearer ") ? this.apiKey : `Bearer ${this.apiKey}`;
-    const res = await this.http(`${BASE}${path47}`, {
+    const res = await this.http(`${BASE}${path48}`, {
       ...init,
       headers: {
         Authorization: auth,
@@ -5978,13 +6074,13 @@ var PixelLabClient = class {
     });
     const text = await res.text();
     if (!res.ok) {
-      throw new PixelLabError(`${init?.method ?? "GET"} ${path47} \u2192 ${res.status}`, res.status, text);
+      throw new PixelLabError(`${init?.method ?? "GET"} ${path48} \u2192 ${res.status}`, res.status, text);
     }
     if (!text) return {};
     try {
       return JSON.parse(text);
     } catch {
-      throw new Error(`${init?.method ?? "GET"} ${path47} returned invalid JSON`);
+      throw new Error(`${init?.method ?? "GET"} ${path48} returned invalid JSON`);
     }
   }
   async balance() {
@@ -6370,10 +6466,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 path47;
+    let path48;
     let body;
     if (args.mode === "v3") {
-      path47 = "/create-character-v3";
+      path48 = "/create-character-v3";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -6387,7 +6483,7 @@ var PixelLabClient = class {
         ...args.enhancePrompt ? { enhance_prompt: true } : {}
       };
     } else if (args.mode === "pro-flash") {
-      path47 = "/create-character-pro-flash";
+      path48 = "/create-character-pro-flash";
       const traits = args.styleTraits;
       body = {
         description: args.description,
@@ -6411,7 +6507,7 @@ var PixelLabClient = class {
         } : {}
       };
     } else if (args.mode === "pro") {
-      path47 = "/create-character-pro";
+      path48 = "/create-character-pro";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -6425,7 +6521,7 @@ var PixelLabClient = class {
         ...!south && args.styleCharacterId ? { style_character_id: args.styleCharacterId } : {}
       };
     } else {
-      path47 = args.directions === 4 ? "/create-character-with-4-directions" : "/create-character-with-8-directions";
+      path48 = args.directions === 4 ? "/create-character-with-4-directions" : "/create-character-with-8-directions";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -6442,8 +6538,8 @@ var PixelLabClient = class {
         ...palette
       };
     }
-    const raw = await this.request(path47, { method: "POST", body: JSON.stringify(body) });
-    return validateResponse(CharacterSubmitSchema, raw, path47.slice(1));
+    const raw = await this.request(path48, { method: "POST", body: JSON.stringify(body) });
+    return validateResponse(CharacterSubmitSchema, raw, path48.slice(1));
   }
   /** A text edit of an existing character, applied to every direction and stored as a sibling. */
   async createCharacterState(args) {
@@ -6951,6 +7047,61 @@ var PixelLabClient = class {
       "animate-pixminimax"
     );
   }
+  /**
+   * `/animate-with-skeleton-v3`, beta (tier 1 subscription or higher): poses
+   * one reference image frame-by-frame from a supplied skeleton per frame,
+   * rather than a text motion description. Confirmed against the live
+   * `animate_with_skeleton_v3` MCP tool schema (the same authoritative
+   * source this codebase already treats as ground truth for the
+   * character/object family) — `action`/`description` are both real,
+   * optional wire fields, contrary to an initial guess that this endpoint
+   * took no text input at all; `direction`/`keypoints`/`firstFrameKeypoints`
+   * are required. The example keypoint from that same tool schema,
+   * `{"label": "RIGHT KNEE", "x": 0.52, "y": 0.71, "z_index": 9}`, is what
+   * `SkeletonKeypointSchema` (`src/skeleton.ts`) models. Same
+   * unverified-completed-shape caveat as `animateWithTextV3`/
+   * `animatePixminimax` above — this endpoint has never been called against
+   * a live account by this codebase.
+   */
+  async animateWithSkeletonV3(args) {
+    const body = {
+      first_frame: args.firstFrame,
+      first_frame_keypoints: args.firstFrameKeypoints,
+      keypoints: args.keypoints,
+      direction: args.direction
+    };
+    if (args.templateId) body.template_id = args.templateId;
+    if (args.action) body.action = args.action;
+    if (args.description) body.description = args.description;
+    if (args.seed != null) body.seed = args.seed;
+    if (args.noBackground != null) body.no_background = args.noBackground;
+    return validateResponse(
+      RevisionJobSubmitSchema,
+      await this.request("/animate-with-skeleton-v3", { method: "POST", body: JSON.stringify(body) }),
+      "animate-with-skeleton-v3"
+    );
+  }
+  /**
+   * `/estimate-skeleton`: auto-derives a reference image's own 18-joint
+   * keypoints, directly usable as `animateWithSkeletonV3`'s
+   * `firstFrameKeypoints` (or, run against a candidate pose image, as one
+   * entry of its `keypoints` sequence). Not called anywhere in this
+   * codebase's own submit/poll pipeline — deliberately kept outside it (see
+   * `runEstimateSkeleton` in `src/cli/commands`) so the only PixelLab
+   * endpoint composed into `animate-with-skeleton-v3`'s submission is that
+   * one endpoint itself, not two unverified calls chained together.
+   * Synchronous per this endpoint's own framing; unverified against a live
+   * account (see `EstimateSkeletonResponseSchema`'s own caveat).
+   */
+  async estimateSkeleton(args) {
+    const body = { image: args.image };
+    const res = validateResponse(
+      EstimateSkeletonResponseSchema,
+      await this.request("/estimate-skeleton", { method: "POST", body: JSON.stringify(body) }),
+      "estimate-skeleton"
+    );
+    return { keypoints: res.keypoints, usage: res.usage };
+  }
   async getBackgroundJob(jobId) {
     const raw = await this.request(`/background-jobs/${encodeURIComponent(jobId)}`);
     return validateResponse(BackgroundJobSchema, raw, "background-jobs/{id}");
@@ -7084,6 +7235,18 @@ function objectProCost(spec) {
   const south = object.reference;
   return south ? proFlashObjectCost(south.width, south.height, object.directions, true) : proFlashObjectCost(spec.width, spec.height, object.directions, false);
 }
+function animateSkeletonCost(frames) {
+  const anchors = [[3, 2], [8, 3], [15, 4]];
+  for (let i = 0; i < anchors.length - 1; i++) {
+    const [lowFrames, lowCost] = anchors[i];
+    const [highFrames, highCost] = anchors[i + 1];
+    if (frames >= lowFrames && frames <= highFrames) {
+      const t = (frames - lowFrames) / (highFrames - lowFrames);
+      return lowCost + t * (highCost - lowCost);
+    }
+  }
+  return frames <= anchors[0][0] ? anchors[0][1] : anchors[anchors.length - 1][1];
+}
 var CHARACTER_TEMPLATES = ["mannequin", "bear", "cat", "dog", "horse", "lion"];
 var PRO_FLASH_TEMPLATES = [...CHARACTER_TEMPLATES, "custom"];
 function encodeAnimationJob(job) {
@@ -7142,7 +7305,9 @@ var PixelLabProvider = class _PixelLabProvider {
    * rather than a described edit — and `animate`/`animate-pixminimax`
    * (`/animate-with-text-v3`, `/animate-pixminimax`), which animate any loose
    * image from a text description with no character/object resource
-   * required — and `interpolate` (`/interpolation-v2`, the in-betweens
+   * required — `animate-skeleton` (`/animate-with-skeleton-v3`, posing the
+   * source from a supplied per-frame skeleton instead of a text description)
+   * — and `interpolate` (`/interpolation-v2`, the in-betweens
    * from one keyframe to another) and `edit-animation`
    * (`/edit-animation-v2`, one text edit applied across a whole frame set).
    * `outpaint` does not: there is no canvas-expansion endpoint in the API,
@@ -7150,7 +7315,7 @@ var PixelLabProvider = class _PixelLabProvider {
    * outpaint path yet.
    */
   supportsRevision(mode2) {
-    return mode2 === "inpaint" || mode2 === "image-to-image" || mode2 === "reduce-colors" || mode2 === "correct-pixelart" || mode2 === "animate" || mode2 === "animate-pixminimax" || mode2 === "interpolate" || mode2 === "edit-animation";
+    return mode2 === "inpaint" || mode2 === "image-to-image" || mode2 === "reduce-colors" || mode2 === "correct-pixelart" || mode2 === "animate" || mode2 === "animate-pixminimax" || mode2 === "animate-skeleton" || mode2 === "interpolate" || mode2 === "edit-animation";
   }
   /** PixelLab's own constraints: submissions must be >2s apart, and
    *  background jobs in flight are capped by subscription tier (Tier 1=8,
@@ -7181,6 +7346,10 @@ var PixelLabProvider = class _PixelLabProvider {
     if (spec.revision?.mode === "reduce-colors" || spec.revision?.mode === "correct-pixelart") {
       return { unit: "generations", amount: 0.1, candidates: 1 };
     }
+    if (spec.revision?.mode === "animate-skeleton") {
+      const frames = spec.revision.frames ?? 8;
+      return { unit: "generations", amount: Math.ceil(animateSkeletonCost(frames)), candidates: 1 };
+    }
     if (spec.revision?.mode === "interpolate" || spec.revision?.mode === "edit-animation") {
       const width = spec.revision.sourceWidth ?? spec.width;
       const height = spec.revision.sourceHeight ?? spec.height;
@@ -7262,6 +7431,18 @@ var PixelLabProvider = class _PixelLabProvider {
         throw new Error(`PixelLab correct-pixelart source is ${width}x${height}; the API takes at most 1024 pixels per side`);
       }
     }
+    if (spec.revision?.mode === "animate-skeleton") {
+      const { sourceWidth: width, sourceHeight: height, frames, skeletonTemplate } = spec.revision;
+      if (width != null && height != null && (width > 256 || height > 256)) {
+        throw new Error(`PixelLab animate-skeleton source is ${width}x${height}; the API takes at most 256 pixels per side`);
+      }
+      if (frames != null && (frames < 3 || frames > 15)) {
+        throw new Error(`PixelLab animate-skeleton takes 3 to 15 frames; the keypoints file has ${frames}`);
+      }
+      if (skeletonTemplate && !CHARACTER_TEMPLATES.includes(skeletonTemplate)) {
+        throw new Error(`PixelLab animate-skeleton template "${skeletonTemplate}" is not one of ${CHARACTER_TEMPLATES.join(", ")}`);
+      }
+    }
     if (spec.revision?.mode === "animate" || spec.revision?.mode === "animate-pixminimax") {
       const { sourceWidth: width, sourceHeight: height, mode: mode2, frames, lastFrameWidth, lastFrameHeight } = spec.revision;
       if (width != null && height != null && (width > 256 || height > 256)) {
@@ -8411,6 +8592,27 @@ var PixelLabProvider = class _PixelLabProvider {
       });
       return { jobId: res2.background_job_id };
     }
+    if (revision.mode === "animate-skeleton") {
+      if (!revision.keypointsFile || !revision.keypointsSha256 || !revision.skeleton) {
+        throw new Error(`${spec.styleId}/${spec.assetId}: revision keypoints are not ready`);
+      }
+      const keypointsBytes = readFileSync2(revision.keypointsFile);
+      if (sha256(keypointsBytes) !== revision.keypointsSha256) {
+        throw new Error(`${spec.styleId}/${spec.assetId}: revision keypoints changed after the manifest was resolved`);
+      }
+      const res2 = await this.client.animateWithSkeletonV3({
+        firstFrame: image,
+        firstFrameKeypoints: revision.skeleton.firstFrameKeypoints,
+        keypoints: revision.skeleton.frames,
+        direction: revision.direction,
+        templateId: revision.skeletonTemplate,
+        action: spec.prompt,
+        description: revision.description,
+        seed: spec.seed,
+        noBackground: spec.noBackground
+      });
+      return { jobId: res2.background_job_id };
+    }
     if (revision.strength != null) {
       throw new Error(
         `${spec.styleId}/${spec.assetId}: PixelLab image-to-image revisions take no strength; edit-images-v2 always applies the full instruction`
@@ -8476,7 +8678,7 @@ var PixelLabProvider = class _PixelLabProvider {
     if (revisionMode === "reduce-colors" || revisionMode === "correct-pixelart") {
       return this.pollCachedRevision(jobId, context);
     }
-    if (revisionMode === "animate" || revisionMode === "animate-pixminimax" || revisionMode === "interpolate" || revisionMode === "edit-animation") {
+    if (revisionMode === "animate" || revisionMode === "animate-pixminimax" || revisionMode === "animate-skeleton" || revisionMode === "interpolate" || revisionMode === "edit-animation") {
       return this.pollAnimateRevision(jobId, context);
     }
     if (context?.spec?.revision) return this.pollRevision(jobId);
@@ -9166,9 +9368,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(path47, init = {}) {
+  async call(path48, init = {}) {
     if (!this.token) throw new Error("RD_API_KEY is not set");
-    const response = await this.request(`${this.baseUrl}${path47}`, {
+    const response = await this.request(`${this.baseUrl}${path48}`, {
       ...init,
       headers: {
         "Content-Type": "application/json",
@@ -10712,6 +10914,8 @@ async function resolveSpecs(loaded, filter) {
         const paletteImage = paletteImageFile ? await optionalRevisionImage(paletteImageFile, "revision palette image", "png") : null;
         const lastFrameFile = asset.revision.lastFrame ? path13.resolve(root, asset.revision.lastFrame) : void 0;
         const lastFrame = lastFrameFile ? await optionalRevisionImage(lastFrameFile, "revision last frame") : null;
+        const keypointsFile = asset.revision.keypointsFile ? path13.resolve(root, asset.revision.keypointsFile) : void 0;
+        const keypoints = keypointsFile ? await optionalSkeletonSet(keypointsFile) : null;
         resolved.revision = {
           mode: asset.revision.mode,
           sourceAssetId: asset.revision.from,
@@ -10752,6 +10956,18 @@ async function resolveSpecs(loaded, filter) {
           } : {},
           ...asset.revision.direction ? { direction: asset.revision.direction } : {},
           ...asset.revision.enhancePrompt == null ? {} : { enhancePrompt: asset.revision.enhancePrompt },
+          ...keypointsFile ? {
+            keypointsFile,
+            keypointsSha256: keypoints?.hash ?? null,
+            skeleton: keypoints?.skeleton ?? null,
+            // The manifest's own `frames` field stays rejected for this
+            // mode (superRefine, types.ts) — the real frame count comes
+            // from the keypoints file once it exists, not a manifest
+            // number, so plan can only know it once authored.
+            ...keypoints ? { frames: keypoints.skeleton.frames.length } : {}
+          } : {},
+          ...asset.revision.skeletonTemplate ? { skeletonTemplate: asset.revision.skeletonTemplate } : {},
+          ...asset.revision.description ? { description: asset.revision.description } : {},
           ...asset.revision.engine ? { engine: asset.revision.engine } : {}
         };
       }
@@ -10873,6 +11089,17 @@ async function optionalRevisionImage(file, label, requiredFormat) {
   }
   return { hash: sha256(bytes), ...metadata };
 }
+async function optionalSkeletonSet(file) {
+  if (!existsSync8(file)) return null;
+  const bytes = await readFile6(file);
+  let json;
+  try {
+    json = JSON.parse(bytes.toString("utf8"));
+  } catch (error) {
+    throw new Error(`revision keypoints file ${file} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  return { hash: sha256(bytes), skeleton: parseSkeletonSet(json, file) };
+}
 async function revisionSourceMembers(stem, label) {
   if (existsSync8(stem)) return null;
   const at = (role) => memberPath(stem, role, 0, 2, MediaType.PNG);
@@ -11408,11 +11635,11 @@ import path15 from "path";
 import { mkdir as mkdir5, readFile as readFile8, rename as rename5, rm as rm5, writeFile as writeFile5 } from "fs/promises";
 import { existsSync as existsSync10 } from "fs";
 import pathModule from "path";
-import { z as z3 } from "zod";
-var HashCacheSchema = z3.object({
-  version: z3.literal(1),
+import { z as z4 } from "zod";
+var HashCacheSchema = z4.object({
+  version: z4.literal(1),
   /** objectId → sha256 of that object's image bytes. */
-  hashes: z3.record(z3.string())
+  hashes: z4.record(z4.string())
 });
 var SHA256_HEX = /^[a-f0-9]{64}$/;
 function isSha256Hash(value) {
@@ -11421,10 +11648,10 @@ function isSha256Hash(value) {
 function parseCache(value) {
   return HashCacheSchema.parse(value);
 }
-async function loadCache(path47) {
-  if (!existsSync10(path47)) return { version: 1, hashes: {} };
+async function loadCache(path48) {
+  if (!existsSync10(path48)) return { version: 1, hashes: {} };
   try {
-    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile8(path47, "utf8")));
+    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile8(path48, "utf8")));
     if (!parsed.success) return { version: 1, hashes: {} };
     return {
       version: 1,
@@ -11436,18 +11663,18 @@ async function loadCache(path47) {
     return { version: 1, hashes: {} };
   }
 }
-async function saveCache(path47, cache) {
+async function saveCache(path48, 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(path47)), { recursive: true });
-  const tmp = `${path47}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  await mkdir5(pathModule.dirname(pathModule.resolve(path48)), { recursive: true });
+  const tmp = `${path48}.${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, path47);
+    await rename5(tmp, path48);
   } finally {
     await rm5(tmp, { force: true });
   }
@@ -12205,20 +12432,20 @@ async function applyTags(provider, decisions, existing, opts = {}) {
 import { mkdir as mkdir7, readFile as readFile12, rename as rename6, rm as rm6, writeFile as writeFile8 } from "fs/promises";
 import { existsSync as existsSync14 } from "fs";
 import path18 from "path";
-import { z as z4 } from "zod";
-var WorkspaceProjectSchema = z4.object({
-  id: z4.string().min(1),
+import { z as z5 } from "zod";
+var WorkspaceProjectSchema = z5.object({
+  id: z5.string().min(1),
   /** Manifest path, relative to the catalog file's own directory. */
-  manifest: z4.string().min(1),
+  manifest: z5.string().min(1),
   /** Lockfile path, relative to the catalog file's own directory. */
-  lock: z4.string().min(1),
-  provider: z4.string().min(1).default("pixellab"),
+  lock: z5.string().min(1),
+  provider: z5.string().min(1).default("pixellab"),
   /** Free-form label for a shared account, e.g. distinguishing sandboxes. */
-  account: z4.string().optional()
+  account: z5.string().optional()
 }).strict();
-var WorkspaceSchema = z4.object({
-  version: z4.literal(1),
-  projects: z4.array(WorkspaceProjectSchema).default([])
+var WorkspaceSchema = z5.object({
+  version: z5.literal(1),
+  projects: z5.array(WorkspaceProjectSchema).default([])
 }).strict();
 function parseWorkspace(raw) {
   const parsed = WorkspaceSchema.safeParse(raw);
@@ -13403,62 +13630,62 @@ import path25 from "path";
 import { existsSync as existsSync17 } from "fs";
 import { copyFile, mkdir as mkdir9, readFile as readFile16, rename as rename8, rm as rm8, writeFile as writeFile11 } from "fs/promises";
 import path24 from "path";
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 
 // src/manifest-edit.ts
 import { readFile as readFile15, rename as rename7, rm as rm7, writeFile as writeFile10 } from "fs/promises";
 import path23 from "path";
-import { z as z5 } from "zod";
-var HexSha = z5.string().regex(/^[0-9a-f]{64}$/);
-var AssetPatchSchema = z5.object({
-  prompt: z5.string().optional(),
+import { z as z6 } from "zod";
+var HexSha = z6.string().regex(/^[0-9a-f]{64}$/);
+var AssetPatchSchema = z6.object({
+  prompt: z6.string().optional(),
   /** Per-style override for the style being viewed; null removes it. */
-  promptForStyle: z5.object({ styleId: z5.string().min(1), prompt: z5.string().nullable() }).optional(),
-  category: z5.string().nullable().optional(),
-  width: z5.number().int().nullable().optional(),
-  height: z5.number().int().nullable().optional(),
-  size: z5.number().int().nullable().optional(),
-  tags: z5.array(z5.string()).optional()
+  promptForStyle: z6.object({ styleId: z6.string().min(1), prompt: z6.string().nullable() }).optional(),
+  category: z6.string().nullable().optional(),
+  width: z6.number().int().nullable().optional(),
+  height: z6.number().int().nullable().optional(),
+  size: z6.number().int().nullable().optional(),
+  tags: z6.array(z6.string()).optional()
 }).strict();
-var NewStateSchema = z5.object({
+var NewStateSchema = z6.object({
   /** Asset id of the parent this states; must already exist. */
-  of: z5.string().min(1),
-  paletteFromReference: z5.boolean().optional(),
-  canvas: z5.object({ width: z5.number().int().min(16).max(256), height: z5.number().int().min(16).max(256) }).strict().optional()
+  of: z6.string().min(1),
+  paletteFromReference: z6.boolean().optional(),
+  canvas: z6.object({ width: z6.number().int().min(16).max(256), height: z6.number().int().min(16).max(256) }).strict().optional()
 }).strict();
-var NewAnimationSchema = z5.object({
+var NewAnimationSchema = z6.object({
   /** Asset id of the parent this animates; must already exist. */
-  of: z5.string().min(1),
+  of: z6.string().min(1),
   /** A PixelLab template id (`character` only; `objectPro` has no template concept). */
-  template: z5.string().min(1).optional(),
+  template: z6.string().min(1).optional(),
   direction: CharacterDirectionSchema.optional(),
-  frames: z5.number().int().min(4).max(16).optional(),
-  fps: z5.number().int().min(1).max(60).optional(),
+  frames: z6.number().int().min(4).max(16).optional(),
+  fps: z6.number().int().min(1).max(60).optional(),
   mode: CharacterAnimationModeSchema.optional(),
   /** What is being animated, when the parent's own description would mislead the model (`character` only). */
-  subject: z5.string().min(1).optional(),
-  enhancePrompt: z5.boolean().optional()
+  subject: z6.string().min(1).optional(),
+  enhancePrompt: z6.boolean().optional()
 }).strict();
-var NewAssetSchema = z5.object({
-  prompt: z5.string(),
-  category: z5.string().optional(),
-  width: z5.number().int().optional(),
-  height: z5.number().int().optional(),
-  size: z5.number().int().optional(),
-  tags: z5.array(z5.string()).optional(),
+var NewAssetSchema = z6.object({
+  prompt: z6.string(),
+  category: z6.string().optional(),
+  width: z6.number().int().optional(),
+  height: z6.number().int().optional(),
+  size: z6.number().int().optional(),
+  tags: z6.array(z6.string()).optional(),
   /** Restrict to these styles; empty or omitted means every style. */
-  styles: z5.array(z5.string().min(1)).optional(),
+  styles: z6.array(z6.string().min(1)).optional(),
   /**
    * 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.
    */
-  revision: z5.object({
-    mode: z5.literal("image-to-image"),
+  revision: z6.object({
+    mode: z6.literal("image-to-image"),
     /** Asset id of the parent this revises; must already exist. */
-    from: z5.string().min(1),
-    strength: z5.number().min(0).max(1).optional()
+    from: z6.string().min(1),
+    strength: z6.number().min(0).max(1).optional()
   }).strict().optional(),
   /** A pose or outfit of an existing `character`/`objectPro` base or state. */
   state: NewStateSchema.optional(),
@@ -13474,58 +13701,58 @@ var CANDIDATE_OPTION = {
   comfyui: "numImages",
   scenario: "numOutputs"
 };
-var ManifestEditSchema = z5.discriminatedUnion("action", [
-  z5.object({
-    action: z5.literal("patch-asset"),
+var ManifestEditSchema = z6.discriminatedUnion("action", [
+  z6.object({
+    action: z6.literal("patch-asset"),
     /** Workspace project id; omitted for a single-project gallery. */
-    project: z5.string().min(1).optional(),
-    assetId: z5.string().min(1),
+    project: z6.string().min(1).optional(),
+    assetId: z6.string().min(1),
     /** Manifest bytes the page last saw; a mismatch refuses the write. */
     expectedSha256: HexSha,
     patch: AssetPatchSchema
   }).strict(),
-  z5.object({
-    action: z5.literal("add-asset"),
-    project: z5.string().min(1).optional(),
-    assetId: z5.string().min(1).regex(/^[^/\\]+$/, "asset ids cannot contain slashes"),
+  z6.object({
+    action: z6.literal("add-asset"),
+    project: z6.string().min(1).optional(),
+    assetId: z6.string().min(1).regex(/^[^/\\]+$/, "asset ids cannot contain slashes"),
     expectedSha256: HexSha,
     asset: NewAssetSchema
   }).strict(),
-  z5.object({
-    action: z5.literal("set-source"),
-    project: z5.string().min(1).optional(),
-    assetId: z5.string().min(1),
-    styleId: z5.string().min(1),
+  z6.object({
+    action: z6.literal("set-source"),
+    project: z6.string().min(1).optional(),
+    assetId: z6.string().min(1),
+    styleId: z6.string().min(1),
     /** Manifest-relative path of the art that stands in for this asset in this style. */
-    source: z5.string().min(1),
+    source: z6.string().min(1),
     expectedSha256: HexSha
   }).strict(),
-  z5.object({
-    action: z5.literal("clear-source"),
-    project: z5.string().min(1).optional(),
-    assetId: z5.string().min(1),
-    styleId: z5.string().min(1),
+  z6.object({
+    action: z6.literal("clear-source"),
+    project: z6.string().min(1).optional(),
+    assetId: z6.string().min(1),
+    styleId: z6.string().min(1),
     expectedSha256: HexSha
   }).strict(),
-  z5.object({
-    action: z5.literal("patch-style"),
-    project: z5.string().min(1).optional(),
-    styleId: z5.string().min(1),
+  z6.object({
+    action: z6.literal("patch-style"),
+    project: z6.string().min(1).optional(),
+    styleId: z6.string().min(1),
     expectedSha256: HexSha,
-    patch: z5.object({
+    patch: z6.object({
       /** Candidates per generation, written to the provider's own option. */
-      candidates: z5.number().int().min(1).max(64).optional(),
+      candidates: z6.number().int().min(1).max(64).optional(),
       /** Empty clears the style's own value (inherit, or the default). */
-      promptPrefix: z5.string().optional(),
-      promptSuffix: z5.string().optional(),
+      promptPrefix: z6.string().optional(),
+      promptSuffix: z6.string().optional(),
       /** `#rrggbb` values; null or empty clears the style's own palette. */
-      palette: z5.array(z5.string().regex(/^#?[0-9a-f]{6}$/i, "expected a six-digit hex colour")).max(256).nullable().optional(),
+      palette: z6.array(z6.string().regex(/^#?[0-9a-f]{6}$/i, "expected a six-digit hex colour")).max(256).nullable().optional(),
       /** Snap downloaded art to the palette; false clears the style's own value. */
-      enforcePalette: z5.boolean().optional(),
+      enforcePalette: z6.boolean().optional(),
       /** Provider view name (PixelLab: low top-down, high top-down, side); empty clears. */
-      view: z5.string().max(64).nullable().optional(),
+      view: z6.string().max(64).nullable().optional(),
       /** pixflux only; null clears the style's own value. */
-      noBackground: z5.boolean().nullable().optional()
+      noBackground: z6.boolean().nullable().optional()
     }).strict().refine((patch) => Object.keys(patch).length > 0, { message: "nothing to change" })
   }).strict()
 ]);
@@ -13808,35 +14035,35 @@ async function detachHandEdit(loaded, spec, opts = {}) {
   });
   return { manifestSha256: result.sha256, changed: result.changed };
 }
-var CompanionOutputSchema = z6.object({
+var CompanionOutputSchema = z7.object({
   /** Output role for a set member; null for a single image. */
-  role: z6.string().nullable(),
+  role: z7.string().nullable(),
   /** sha256 of the generated file this member started from; null when it started from untracked art. */
-  basedOn: z6.string().regex(/^[0-9a-f]{64}$/).nullable(),
+  basedOn: z7.string().regex(/^[0-9a-f]{64}$/).nullable(),
   /** sha256 of the member as saved, so a later change by another tool is visible. */
-  sha256: z6.string().regex(/^[0-9a-f]{64}$/)
+  sha256: z7.string().regex(/^[0-9a-f]{64}$/)
 }).strict();
-var CompanionV2Schema = z6.object({
-  version: z6.literal(2),
+var CompanionV2Schema = z7.object({
+  version: z7.literal(2),
   /** Editor identity the bridge reported, e.g. `pixelorama@v1.2.2-stable`. */
-  editor: z6.string().min(1),
-  protocol: z6.number().int().positive(),
-  savedAt: z6.string().datetime(),
+  editor: z7.string().min(1),
+  protocol: z7.number().int().positive(),
+  savedAt: z7.string().datetime(),
   /** Basename of the layered project file beside the edit, when one was kept. */
-  project: z6.string().min(1).nullable(),
+  project: z7.string().min(1).nullable(),
   /** One entry per file, in output order. */
-  outputs: z6.array(CompanionOutputSchema).min(1)
+  outputs: z7.array(CompanionOutputSchema).min(1)
 }).strict();
-var CompanionV1Schema = z6.object({
-  version: z6.literal(1),
-  basedOn: z6.string().regex(/^[0-9a-f]{64}$/).nullable(),
-  sha256: z6.string().regex(/^[0-9a-f]{64}$/),
-  editor: z6.string().min(1),
-  protocol: z6.number().int().positive(),
-  savedAt: z6.string().datetime(),
-  project: z6.string().min(1).nullable()
+var CompanionV1Schema = z7.object({
+  version: z7.literal(1),
+  basedOn: z7.string().regex(/^[0-9a-f]{64}$/).nullable(),
+  sha256: z7.string().regex(/^[0-9a-f]{64}$/),
+  editor: z7.string().min(1),
+  protocol: z7.number().int().positive(),
+  savedAt: z7.string().datetime(),
+  project: z7.string().min(1).nullable()
 }).strict();
-var HandEditCompanionSchema = z6.union([CompanionV2Schema, CompanionV1Schema]).transform(
+var HandEditCompanionSchema = z7.union([CompanionV2Schema, CompanionV1Schema]).transform(
   (value) => value.version === 2 ? value : {
     version: 2,
     editor: value.editor,
@@ -13995,41 +14222,41 @@ import path28 from "path";
 
 // src/gallery/edit.ts
 import path26 from "path";
-import { z as z7 } from "zod";
-var Base64 = z7.string().regex(/^[A-Za-z0-9+/]*={0,2}$/).max(Math.ceil(MAX_HAND_EDIT_BYTES / 3) * 4);
-var HandEditRequestSchema = z7.discriminatedUnion("action", [
-  z7.object({
-    action: z7.literal("start-edit"),
-    project: z7.string().min(1).optional(),
-    assetId: z7.string().min(1),
-    styleId: z7.string().min(1),
-    expectedSha256: z7.string().regex(/^[0-9a-f]{64}$/),
+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}$/),
     /** Also launch the author's editor on the file. */
-    open: z7.boolean().optional()
+    open: z8.boolean().optional()
   }).strict(),
-  z7.object({
-    action: z7.literal("detach-edit"),
-    project: z7.string().min(1).optional(),
-    assetId: z7.string().min(1),
-    styleId: z7.string().min(1),
-    expectedSha256: z7.string().regex(/^[0-9a-f]{64}$/)
+  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}$/)
   }).strict(),
   /** From the in-browser editor: the page holds the bytes, the server validates and writes. */
-  z7.object({
-    action: z7.literal("save-edit"),
-    project: z7.string().min(1).optional(),
-    assetId: z7.string().min(1),
-    styleId: z7.string().min(1),
-    expectedSha256: z7.string().regex(/^[0-9a-f]{64}$/),
+  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}$/),
     /** 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: z7.array(z7.object({ role: z7.string().min(1).nullable(), png: Base64.min(1) }).strict()).min(1).max(256).optional(),
+    frames: z8.array(z8.object({ role: z8.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: z7.string().min(1).max(200),
-    protocol: z7.number().int().positive()
+    editor: z8.string().min(1).max(200),
+    protocol: z8.number().int().positive()
   }).strict()
 ]);
 function createGalleryEditHandler(opts) {
@@ -15213,7 +15440,7 @@ async function serveGallery(opts) {
 
 // src/gallery/generate.ts
 import { randomBytes as randomBytes2 } from "crypto";
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/pipeline/poll.ts
 var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
@@ -15494,6 +15721,9 @@ async function submit(provider, loaded, items, lock, lockPath, opts = {}) {
         ...spec.revision.lastFrameSha256 ? { lastFrameSha256: spec.revision.lastFrameSha256 } : {},
         ...spec.revision.direction ? { direction: spec.revision.direction } : {},
         ...spec.revision.enhancePrompt == null ? {} : { enhancePrompt: spec.revision.enhancePrompt },
+        ...spec.revision.keypointsSha256 ? { keypointsSha256: spec.revision.keypointsSha256 } : {},
+        ...spec.revision.skeletonTemplate ? { skeletonTemplate: spec.revision.skeletonTemplate } : {},
+        ...spec.revision.description ? { description: spec.revision.description } : {},
         ...spec.revision.engine ? { engine: spec.revision.engine } : {}
       } : null,
       outfit: spec.character?.kind === "outfit" && outfitParentEntry ? {
@@ -16310,26 +16540,26 @@ async function runPicker(provider, lock, lockPath, opts = {}) {
 }
 
 // src/gallery/generate.ts
-var GenerateRequestSchema = z8.object({
-  project: z8.string().min(1).optional(),
-  keys: z8.array(z8.string().min(1)).min(1).max(500),
+var GenerateRequestSchema = z9.object({
+  project: z9.string().min(1).optional(),
+  keys: z9.array(z9.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: z8.boolean().optional(),
+  force: z9.boolean().optional(),
   /** Advance in-flight, review, or selected work without submitting anything. */
-  resume: z8.boolean().optional(),
+  resume: z9.boolean().optional(),
   /** Re-download downloaded outputs and replace files whose object changed upstream. */
-  refresh: z8.boolean().optional(),
+  refresh: z9.boolean().optional(),
   /** Put recorded outputs back on disk from the cache or the provider, without generating. */
-  restore: z8.boolean().optional(),
+  restore: z9.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: z8.string().min(1).max(64).optional()
+  revert: z9.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" });
@@ -19215,11 +19445,11 @@ import { readFile as readFile28 } from "fs/promises";
 import path41 from "path";
 import { existsSync as existsSync30 } from "fs";
 import { readFile as readFile27 } from "fs/promises";
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var SHA256_RE = /^[0-9a-f]{64}$/;
 var HEX_RE = /^#[0-9a-f]{6}$/;
 var MAX_REDMEAN_DISTANCE = 765;
-var QualityPathSchema = z9.string().min(1).refine(
+var QualityPathSchema = z10.string().min(1).refine(
   (value) => !path41.posix.isAbsolute(value) && !value.includes("\\"),
   "expected a portable relative path"
 );
@@ -19233,53 +19463,53 @@ var DEFAULT_QUALITY_TOLERANCES = {
   maxEdgeContrastDrop: 0.03,
   maxIsolatedPixelIncrease: 5e-3
 };
-var QualityToleranceSchema = z9.object({
-  requireExactHash: z9.boolean(),
-  maxColorCountIncrease: z9.number().int().min(0),
-  maxNewColors: z9.number().int().min(0),
-  maxTransparencyDelta: z9.number().min(0).max(1),
-  maxPartialAlphaIncrease: z9.number().min(0).max(1),
-  maxEdgeDensityDelta: z9.number().min(0).max(1),
-  maxEdgeContrastDrop: z9.number().min(0).max(1),
-  maxIsolatedPixelIncrease: z9.number().min(0).max(1)
+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)
 }).strict();
-var ImageQualityMetricsSchema = z9.object({
-  sha256: z9.string().regex(SHA256_RE),
-  width: z9.number().int().min(1),
-  height: z9.number().int().min(1),
-  colorCount: z9.number().int().min(0),
-  colors: z9.array(z9.string().regex(HEX_RE)),
-  transparency: z9.number().min(0).max(1),
-  partialAlpha: z9.number().min(0).max(1),
-  edgeDensity: z9.number().min(0).max(1),
-  meanEdgeContrast: z9.number().min(0).max(1),
-  isolatedPixelRatio: z9.number().min(0).max(1)
+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)
 }).strict();
-var QualityBaselineCaseSchema = z9.object({
-  id: z9.string().regex(/^[a-z0-9][a-z0-9/_-]*$/),
+var QualityBaselineCaseSchema = z10.object({
+  id: z10.string().regex(/^[a-z0-9][a-z0-9/_-]*$/),
   file: QualityPathSchema,
-  record: z9.object({
+  record: z10.object({
     path: QualityPathSchema,
-    sha256: z9.string().regex(SHA256_RE)
+    sha256: z10.string().regex(SHA256_RE)
   }).strict().optional(),
   expected: ImageQualityMetricsSchema,
   tolerances: QualityToleranceSchema
 }).strict();
-var QualityBaselineSchema = z9.object({
-  $schema: z9.string().url().optional(),
-  format: z9.literal("pixelkiln-quality-baseline"),
-  schemaVersion: z9.literal(1),
-  cases: z9.array(QualityBaselineCaseSchema).min(1)
+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)
 }).strict().superRefine((baseline, context) => {
   const ids = baseline.cases.map((entry) => entry.id);
   if (new Set(ids).size !== ids.length) {
-    context.addIssue({ code: z9.ZodIssueCode.custom, path: ["cases"], message: "duplicate case id" });
+    context.addIssue({ code: z10.ZodIssueCode.custom, path: ["cases"], message: "duplicate case id" });
   }
 });
-var QualityInputSchema = z9.object({
-  id: z9.string().regex(/^[a-z0-9][a-z0-9/_-]*$/),
-  path: z9.string().min(1),
-  record: z9.string().min(1).optional(),
+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(),
   tolerances: QualityToleranceSchema.partial().optional()
 }).strict();
 function message4(error) {
@@ -19381,7 +19611,7 @@ async function measureImageQuality(file) {
   }
 }
 function resolveQualityInputs(raw, inputsFilePath) {
-  const parsed = z9.array(QualityInputSchema).min(1).safeParse(raw);
+  const parsed = z10.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")
@@ -19656,47 +19886,47 @@ import path43 from "path";
 import { existsSync as existsSync31 } from "fs";
 import { readdir as readdir3, readFile as readFile29 } from "fs/promises";
 import { fileURLToPath } from "url";
-import { z as z10 } from "zod";
+import { z as z11 } 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 = z10.string().min(1).refine((value) => {
+var PortablePathSchema = z11.string().min(1).refine((value) => {
   if (value.includes("\\") || path43.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 = z10.object({
-  nodeId: z10.string().min(1),
-  input: z10.string().min(1)
+var RecipeBindingSchema = z11.object({
+  nodeId: z11.string().min(1),
+  input: z11.string().min(1)
 }).strict();
-var RecipeSchema = z10.object({
-  $schema: z10.string().url().optional(),
-  format: z10.literal("pixelkiln-recipe"),
-  schemaVersion: z10.literal(1),
-  id: z10.string().regex(RECIPE_ID_RE, "expected provider/name"),
-  version: z10.string().regex(VERSION_RE, "expected x.y.z"),
-  provider: z10.string().regex(/^[a-z0-9][a-z0-9-]*$/),
-  summary: z10.string().min(1).max(240),
-  files: z10.array(z10.object({
+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({
     path: PortablePathSchema,
-    role: z10.enum(["workflow", "reference"]),
-    sha256: z10.string().regex(SHA256_RE2)
+    role: z11.enum(["workflow", "reference"]),
+    sha256: z11.string().regex(SHA256_RE2)
   }).strict()).default([]),
-  models: z10.array(z10.object({
+  models: z11.array(z11.object({
     path: PortablePathSchema,
-    sha256: z10.string().regex(SHA256_RE2),
-    source: z10.string().url(),
-    license: z10.string().min(1)
+    sha256: z11.string().regex(SHA256_RE2),
+    source: z11.string().url(),
+    license: z11.string().min(1)
   }).strict()).default([]),
-  styleId: z10.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  styleId: z11.string().regex(/^[a-z0-9][a-z0-9-]*$/),
   style: StyleSchema,
-  workflow: z10.object({
+  workflow: z11.object({
     path: PortablePathSchema,
-    outputNodeId: z10.string().min(1),
-    numImages: z10.number().int().min(1).max(16),
-    bindings: z10.object({
+    outputNodeId: z11.string().min(1),
+    numImages: z11.number().int().min(1).max(16),
+    bindings: z11.object({
       prompt: RecipeBindingSchema,
       width: RecipeBindingSchema.optional(),
       height: RecipeBindingSchema.optional(),
@@ -19707,67 +19937,67 @@ var RecipeSchema = z10.object({
       strength: RecipeBindingSchema.optional()
     }).strict()
   }).strict().optional(),
-  quality: z10.object({
-    stage: z10.enum(["composition-source", "production-candidate"]),
-    workingCanvas: z10.object({
-      width: z10.number().int().min(16),
-      height: z10.number().int().min(16)
+  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)
     }).strict(),
-    recommendedNativeSize: z10.object({
-      min: z10.number().int().min(1),
-      max: z10.number().int().min(1)
+    recommendedNativeSize: z11.object({
+      min: z11.number().int().min(1),
+      max: z11.number().int().min(1)
     }).strict(),
-    paletteColors: z10.object({
-      min: z10.number().int().min(1),
-      max: z10.number().int().min(1)
+    paletteColors: z11.object({
+      min: z11.number().int().min(1),
+      max: z11.number().int().min(1)
     }).strict(),
-    background: z10.enum(["opaque", "transparent", "full-bleed"]),
-    checks: z10.array(z10.enum([
+    background: z11.enum(["opaque", "transparent", "full-bleed"]),
+    checks: z11.array(z11.enum([
       "prompt-coverage",
       "native-grid",
       "final-palette",
       "alpha-edge",
       "human-1x"
     ])).min(1),
-    notes: z10.array(z10.string().min(1)).default([])
+    notes: z11.array(z11.string().min(1)).default([])
   }).strict(),
-  integrity: z10.object({
-    algorithm: z10.literal("sha256"),
-    digest: z10.string().regex(SHA256_RE2)
+  integrity: z11.object({
+    algorithm: z11.literal("sha256"),
+    digest: z11.string().regex(SHA256_RE2)
   }).strict()
 }).strict().superRefine((recipe, context) => {
   if (recipe.style.provider && recipe.style.provider !== recipe.provider) {
     context.addIssue({
-      code: z10.ZodIssueCode.custom,
+      code: z11.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: z10.ZodIssueCode.custom, path: ["files"], message: "duplicate file path" });
+    context.addIssue({ code: z11.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: z10.ZodIssueCode.custom, path: ["models"], message: "duplicate model path" });
+    context.addIssue({ code: z11.ZodIssueCode.custom, path: ["models"], message: "duplicate model path" });
   }
   if (filePaths.includes(RECIPE_FILE)) {
     context.addIssue({
-      code: z10.ZodIssueCode.custom,
+      code: z11.ZodIssueCode.custom,
       path: ["files"],
       message: `${RECIPE_FILE} cannot hash itself`
     });
   }
   if (recipe.quality.recommendedNativeSize.min > recipe.quality.recommendedNativeSize.max) {
     context.addIssue({
-      code: z10.ZodIssueCode.custom,
+      code: z11.ZodIssueCode.custom,
       path: ["quality", "recommendedNativeSize"],
       message: "min cannot exceed max"
     });
   }
   if (recipe.quality.paletteColors.min > recipe.quality.paletteColors.max) {
     context.addIssue({
-      code: z10.ZodIssueCode.custom,
+      code: z11.ZodIssueCode.custom,
       path: ["quality", "paletteColors"],
       message: "min cannot exceed max"
     });
@@ -19776,7 +20006,7 @@ var RecipeSchema = z10.object({
     (file) => file.path === recipe.workflow.path && file.role === "workflow"
   )) {
     context.addIssue({
-      code: z10.ZodIssueCode.custom,
+      code: z11.ZodIssueCode.custom,
       path: ["workflow", "path"],
       message: "must name a file whose role is workflow"
     });
@@ -19784,7 +20014,7 @@ var RecipeSchema = z10.object({
   if (recipe.provider === "comfyui") {
     if (!recipe.workflow) {
       context.addIssue({
-        code: z10.ZodIssueCode.custom,
+        code: z11.ZodIssueCode.custom,
         path: ["workflow"],
         message: "ComfyUI recipes require workflow metadata"
       });
@@ -19793,7 +20023,7 @@ var RecipeSchema = z10.object({
     const options = recipe.style.providerOptions.comfyui;
     if (!options || typeof options !== "object" || Array.isArray(options)) {
       context.addIssue({
-        code: z10.ZodIssueCode.custom,
+        code: z11.ZodIssueCode.custom,
         path: ["style", "providerOptions", "comfyui"],
         message: "ComfyUI recipes require ComfyUI provider options"
       });
@@ -19807,7 +20037,7 @@ var RecipeSchema = z10.object({
     };
     if (JSON.stringify(canonical3(options)) !== JSON.stringify(canonical3(expected))) {
       context.addIssue({
-        code: z10.ZodIssueCode.custom,
+        code: z11.ZodIssueCode.custom,
         path: ["style", "providerOptions", "comfyui"],
         message: "must match workflow metadata and use {{recipeDir}} for workflowFile"
       });
@@ -20226,6 +20456,30 @@ async function runRefine(args) {
   if (result.failed) process.exitCode = 1;
 }
 
+// src/cli/commands/skeleton.ts
+import path46 from "path";
+import { readFile as readFile30, writeFile as writeFile15 } from "fs/promises";
+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)));
+  loadEnvFiles(process.cwd());
+  const bytes = await readFile30(path46.resolve(image));
+  const metadata = imageMetadata(bytes);
+  if (!metadata) throw new UsageError(`${image} is not a readable PNG or JPEG`);
+  const client2 = clientFromEnv();
+  const res = await client2.estimateSkeleton({
+    image: { base64: bytes.toString("base64"), format: metadata.format }
+  });
+  const json = JSON.stringify(res.keypoints, null, 2);
+  if (args.out) {
+    await writeFile15(path46.resolve(args.out), json + "\n");
+    log(`  wrote ${res.keypoints.length} keypoints to ${args.out}`);
+  } else {
+    log(json);
+  }
+}
+
 // src/cli/commands/tools.ts
 async function runTools(args) {
   const mb = (bytes) => bytes < 1e6 ? `${(bytes / 1e3).toFixed(0)} kB` : `${(bytes / 1e6).toFixed(1)} MB`;
@@ -20268,15 +20522,15 @@ async function runTools(args) {
 }
 
 // src/cli/commands/workspace.ts
-import path46 from "path";
+import path47 from "path";
 import { existsSync as existsSync32 } from "fs";
 async function runWorkspace(args) {
-  const workspacePath = path46.resolve(args.workspace ?? "pixelkiln.workspace.json");
-  const dir = path46.dirname(workspacePath);
+  const workspacePath = path47.resolve(args.workspace ?? "pixelkiln.workspace.json");
+  const dir = path47.dirname(workspacePath);
   if (args.subcommand === "add") {
-    const manifestPath = path46.resolve(args.target);
+    const manifestPath = path47.resolve(args.target);
     const loadedTarget = await loadManifest(manifestPath);
-    const lockPath = args.explicitLock ? path46.resolve(args.explicitLock) : path46.join(path46.dirname(manifestPath), "pixelkiln.lock.json");
+    const lockPath = args.explicitLock ? path47.resolve(args.explicitLock) : path47.join(path47.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)) {
@@ -20296,7 +20550,7 @@ async function runWorkspace(args) {
       ...args.account ? { account: args.account } : {}
     };
     await saveWorkspace(workspacePath, { version: 1, projects: [...ws.projects, project] });
-    log(`  registered "${id}" in ${path46.relative(process.cwd(), workspacePath)}`);
+    log(`  registered "${id}" in ${path47.relative(process.cwd(), workspacePath)}`);
     log(`    manifest: ${project.manifest}`);
     log(`    lock:     ${project.lock}`);
     if (!existsSync32(lockPath)) {
@@ -20308,7 +20562,7 @@ async function runWorkspace(args) {
   }
   if (args.subcommand === "remove") {
     const ws = await loadWorkspace(workspacePath);
-    const resolvedTarget = path46.resolve(args.target);
+    const resolvedTarget = path47.resolve(args.target);
     const match = ws.projects.find(
       (p) => p.id === args.target || resolveProject(dir, p).manifestPath === resolvedTarget
     );
@@ -20319,7 +20573,7 @@ async function runWorkspace(args) {
       version: 1,
       projects: ws.projects.filter((p) => p !== match)
     });
-    log(`  removed "${match.id}" from ${path46.relative(process.cwd(), workspacePath)}`);
+    log(`  removed "${match.id}" from ${path47.relative(process.cwd(), workspacePath)}`);
     return;
   }
   if (args.subcommand === "list") {
@@ -20331,9 +20585,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 ${path46.relative(process.cwd(), workspacePath)}`);
+      log(`  no projects registered in ${path47.relative(process.cwd(), workspacePath)}`);
     } else {
-      log(`  ${ws.projects.length} project(s) in ${path46.relative(process.cwd(), workspacePath)}:`);
+      log(`  ${ws.projects.length} project(s) in ${path47.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}` : ""})`);
       }
@@ -20351,7 +20605,7 @@ async function runWorkspace(args) {
     if (args.json) {
       log(JSON.stringify({ ...report, workspace: workspacePath }, null, 2));
     } else {
-      log(`  workspace: ${path46.relative(process.cwd(), workspacePath)}`);
+      log(`  workspace: ${path47.relative(process.cwd(), workspacePath)}`);
       for (const p of report.projects) {
         if (p.error) {
           log(`
@@ -20406,7 +20660,7 @@ 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 readFile30(url, "utf8"));
+    const pkg = JSON.parse(await readFile31(url, "utf8"));
     if (pkg.name === "pixelkiln") {
       log(`${pkg.name} ${pkg.version}`);
       return;
@@ -20450,6 +20704,7 @@ var RUNNERS = {
   refine: runRefine,
   recipe: runRecipe,
   workspace: runWorkspace,
+  "estimate-skeleton": runEstimateSkeleton,
   unzoom: runUnzoom,
   font: runFont
 };