pixelkiln 0.66.0 → 0.67.0

package/dist/index.cjs

@@ -332,6 +332,7 @@ var RevisionModeSchema = import_zod.z.enum([
   "correct-pixelart",
   "animate",
   "animate-pixminimax",
+  "animate-skeleton",
   "interpolate",
   "edit-animation"
 ]);
@@ -650,6 +651,30 @@ var RevisionSchema = import_zod.z.object({
   direction: CharacterDirectionSchema.optional(),
   /** `animate`/`animate-pixminimax` only: let PixelLab expand the action into a fuller motion description first. */
   enhancePrompt: import_zod.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: import_zod.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: import_zod.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: import_zod.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
@@ -740,18 +765,41 @@ var RevisionSchema = import_zod.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: import_zod.z.ZodIssueCode.custom,
-      message: "direction applies to animate-pixminimax revisions only",
+      message: "direction applies to animate-pixminimax/animate-skeleton revisions only",
+      path: ["direction"]
+    });
+  }
+  if (revision.mode === "animate-skeleton" && revision.direction === void 0) {
+    context.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      message: "animate-skeleton revisions require a direction",
       path: ["direction"]
     });
   }
   if (revision.frames !== void 0 && revision.frames % 2 !== 0) {
     context.addIssue({ code: import_zod.z.ZodIssueCode.custom, message: "frames must be even", path: ["frames"] });
   }
+  if (revision.mode === "animate-skeleton" && !revision.keypointsFile) {
+    context.addIssue({
+      code: import_zod.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: import_zod.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 = import_zod.z.object({
   /** Generation backend for this style. Omit to inherit the manifest default. */
@@ -1383,11 +1431,16 @@ var LockEntrySchema = import_zod.z.object({
     paletteImageSha256: import_zod.z.string().regex(/^[0-9a-f]{64}$/).optional(),
     dithering: RevisionDitheringSchema.optional(),
     ditheringStrength: import_zod.z.number().min(0).max(10).optional(),
-    frames: import_zod.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: import_zod.z.number().int().min(3).max(40).optional(),
     fps: import_zod.z.number().int().min(1).max(60).optional(),
     lastFrameSha256: import_zod.z.string().regex(/^[0-9a-f]{64}$/).optional(),
     direction: CharacterDirectionSchema.optional(),
     enhancePrompt: import_zod.z.boolean().optional(),
+    keypointsSha256: import_zod.z.string().regex(/^[0-9a-f]{64}$/).optional(),
+    skeletonTemplate: import_zod.z.string().min(1).optional(),
+    description: import_zod.z.string().min(1).optional(),
     engine: import_zod.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. */
@@ -1574,7 +1627,7 @@ function exitCodeFor(err) {
 }
 
 // src/client.ts
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 
 // src/http.ts
 var MAX_RETRIES = 4;
@@ -1624,262 +1677,289 @@ function fetchWithRetry(request, opts = {}) {
   };
 }
 
+// src/skeleton.ts
+var import_zod2 = require("zod");
+var SkeletonKeypointSchema = import_zod2.z.object({
+  label: import_zod2.z.string().min(1),
+  x: import_zod2.z.number().min(0).max(1),
+  y: import_zod2.z.number().min(0).max(1),
+  z_index: import_zod2.z.number(),
+  depth: import_zod2.z.number().optional()
+}).strict();
+var SkeletonFrameSchema = import_zod2.z.array(SkeletonKeypointSchema).length(18);
+var SkeletonSetSchema = import_zod2.z.object({
+  firstFrameKeypoints: SkeletonFrameSchema,
+  frames: import_zod2.z.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 = import_zod2.z.object({
-  credits: import_zod2.z.object({ usd: import_zod2.z.number() }).passthrough(),
-  subscription: import_zod2.z.object({
-    generations: import_zod2.z.number(),
-    total: import_zod2.z.number(),
-    plan: import_zod2.z.string().nullable().optional()
+var BalanceResponseSchema = import_zod3.z.object({
+  credits: import_zod3.z.object({ usd: import_zod3.z.number() }).passthrough(),
+  subscription: import_zod3.z.object({
+    generations: import_zod3.z.number(),
+    total: import_zod3.z.number(),
+    plan: import_zod3.z.string().nullable().optional()
   }).passthrough()
 }).passthrough();
-var ObjectSubmitSchema = import_zod2.z.object({
-  background_job_id: import_zod2.z.string().min(1),
-  object_id: import_zod2.z.string().min(1),
-  status: import_zod2.z.string().default("queued"),
-  n_frames: import_zod2.z.number().int().min(0)
+var ObjectSubmitSchema = import_zod3.z.object({
+  background_job_id: import_zod3.z.string().min(1),
+  object_id: import_zod3.z.string().min(1),
+  status: import_zod3.z.string().default("queued"),
+  n_frames: import_zod3.z.number().int().min(0)
 }).passthrough();
-var MapSubmitSchema = import_zod2.z.object({
-  background_job_id: import_zod2.z.string().min(1),
-  object_id: import_zod2.z.string().min(1),
-  status: import_zod2.z.string().default("processing")
+var MapSubmitSchema = import_zod3.z.object({
+  background_job_id: import_zod3.z.string().min(1),
+  object_id: import_zod3.z.string().min(1),
+  status: import_zod3.z.string().default("processing")
 }).passthrough();
-var UsageSchema = import_zod2.z.object({
-  type: import_zod2.z.string().optional(),
-  usd: import_zod2.z.number().nullable().optional(),
-  generations: import_zod2.z.number().nullable().optional()
+var UsageSchema = import_zod3.z.object({
+  type: import_zod3.z.string().optional(),
+  usd: import_zod3.z.number().nullable().optional(),
+  generations: import_zod3.z.number().nullable().optional()
 }).passthrough().nullable().optional();
-var TilesSubmitSchema = import_zod2.z.object({
-  tile_id: import_zod2.z.string().min(1),
-  background_job_id: import_zod2.z.string().min(1),
-  status: import_zod2.z.literal("processing").default("processing")
+var TilesSubmitSchema = import_zod3.z.object({
+  tile_id: import_zod3.z.string().min(1),
+  background_job_id: import_zod3.z.string().min(1),
+  status: import_zod3.z.literal("processing").default("processing")
 }).passthrough();
-var TilesProSchema = import_zod2.z.object({
-  storage_urls: import_zod2.z.record(import_zod2.z.string()),
-  kind: import_zod2.z.string().nullable().default(null),
-  tile_rules: import_zod2.z.record(import_zod2.z.unknown()).nullable().optional()
+var TilesProSchema = import_zod3.z.object({
+  storage_urls: import_zod3.z.record(import_zod3.z.string()),
+  kind: import_zod3.z.string().nullable().default(null),
+  tile_rules: import_zod3.z.record(import_zod3.z.unknown()).nullable().optional()
 }).passthrough();
-var TilesetSubmitSchema = import_zod2.z.object({
-  tileset_id: import_zod2.z.string().min(1),
-  background_job_id: import_zod2.z.string().min(1),
-  status: import_zod2.z.literal("processing").default("processing")
+var TilesetSubmitSchema = import_zod3.z.object({
+  tileset_id: import_zod3.z.string().min(1),
+  background_job_id: import_zod3.z.string().min(1),
+  status: import_zod3.z.literal("processing").default("processing")
 }).passthrough();
-var TilesetTileSchema = import_zod2.z.object({
-  id: import_zod2.z.string().min(1),
-  name: import_zod2.z.string(),
-  image: import_zod2.z.object({ base64: import_zod2.z.string().min(1), format: import_zod2.z.string().default("png") }).passthrough(),
-  corners: import_zod2.z.object({ NW: import_zod2.z.string(), NE: import_zod2.z.string(), SW: import_zod2.z.string(), SE: import_zod2.z.string() }).passthrough(),
-  pattern_4x4: import_zod2.z.object({
-    row_0: import_zod2.z.array(import_zod2.z.number()),
-    row_1: import_zod2.z.array(import_zod2.z.number()),
-    row_2: import_zod2.z.array(import_zod2.z.number()),
-    row_3: import_zod2.z.array(import_zod2.z.number())
+var TilesetTileSchema = import_zod3.z.object({
+  id: import_zod3.z.string().min(1),
+  name: import_zod3.z.string(),
+  image: import_zod3.z.object({ base64: import_zod3.z.string().min(1), format: import_zod3.z.string().default("png") }).passthrough(),
+  corners: import_zod3.z.object({ NW: import_zod3.z.string(), NE: import_zod3.z.string(), SW: import_zod3.z.string(), SE: import_zod3.z.string() }).passthrough(),
+  pattern_4x4: import_zod3.z.object({
+    row_0: import_zod3.z.array(import_zod3.z.number()),
+    row_1: import_zod3.z.array(import_zod3.z.number()),
+    row_2: import_zod3.z.array(import_zod3.z.number()),
+    row_3: import_zod3.z.array(import_zod3.z.number())
   }).passthrough()
 }).passthrough();
-var TilesetGetSchema = import_zod2.z.object({
-  tileset: import_zod2.z.object({
-    total_tiles: import_zod2.z.number().int().min(1),
-    tile_size: import_zod2.z.object({ width: import_zod2.z.number().int().positive(), height: import_zod2.z.number().int().positive() }).passthrough(),
-    terrain_types: import_zod2.z.array(import_zod2.z.string()),
-    tiles: import_zod2.z.array(TilesetTileSchema).min(1)
+var TilesetGetSchema = import_zod3.z.object({
+  tileset: import_zod3.z.object({
+    total_tiles: import_zod3.z.number().int().min(1),
+    tile_size: import_zod3.z.object({ width: import_zod3.z.number().int().positive(), height: import_zod3.z.number().int().positive() }).passthrough(),
+    terrain_types: import_zod3.z.array(import_zod3.z.string()),
+    tiles: import_zod3.z.array(TilesetTileSchema).min(1)
   }).passthrough(),
   usage: UsageSchema
 }).passthrough();
-var IsometricTileSubmitSchema = import_zod2.z.object({
-  tile_id: import_zod2.z.string().min(1),
-  background_job_id: import_zod2.z.string().min(1),
-  status: import_zod2.z.literal("processing").default("processing")
+var IsometricTileSubmitSchema = import_zod3.z.object({
+  tile_id: import_zod3.z.string().min(1),
+  background_job_id: import_zod3.z.string().min(1),
+  status: import_zod3.z.literal("processing").default("processing")
 }).passthrough();
-var IsometricTileGetSchema = import_zod2.z.object({
-  image: import_zod2.z.object({ base64: import_zod2.z.string().min(1), format: import_zod2.z.string().default("png") }).passthrough(),
+var IsometricTileGetSchema = import_zod3.z.object({
+  image: import_zod3.z.object({ base64: import_zod3.z.string().min(1), format: import_zod3.z.string().default("png") }).passthrough(),
   usage: UsageSchema
 }).passthrough();
-var UiAssetSubmitSchema = import_zod2.z.object({
-  ui_asset_id: import_zod2.z.string().min(1),
-  background_job_id: import_zod2.z.string().min(1),
-  status: import_zod2.z.string().default("processing"),
+var UiAssetSubmitSchema = import_zod3.z.object({
+  ui_asset_id: import_zod3.z.string().min(1),
+  background_job_id: import_zod3.z.string().min(1),
+  status: import_zod3.z.string().default("processing"),
   usage: UsageSchema
 }).passthrough();
-var UiAssetGetSchema = import_zod2.z.object({
-  id: import_zod2.z.string().min(1),
-  status: import_zod2.z.string().nullable().default(null),
-  image_url: import_zod2.z.string().nullable().optional(),
-  progress_percent: import_zod2.z.number().nullable().optional(),
-  eta_seconds: import_zod2.z.number().nullable().optional()
+var UiAssetGetSchema = import_zod3.z.object({
+  id: import_zod3.z.string().min(1),
+  status: import_zod3.z.string().nullable().default(null),
+  image_url: import_zod3.z.string().nullable().optional(),
+  progress_percent: import_zod3.z.number().nullable().optional(),
+  eta_seconds: import_zod3.z.number().nullable().optional()
 }).passthrough();
-var RevisionJobSubmitSchema = import_zod2.z.object({
-  background_job_id: import_zod2.z.string().min(1),
-  status: import_zod2.z.string().default("processing")
+var RevisionJobSubmitSchema = import_zod3.z.object({
+  background_job_id: import_zod3.z.string().min(1),
+  status: import_zod3.z.string().default("processing")
 }).passthrough();
-var ObjectAnimationGroupSchema = import_zod2.z.object({
-  animation_group_id: import_zod2.z.string().min(1),
-  display_name: import_zod2.z.string().nullable().default(null),
-  description: import_zod2.z.string().default(""),
-  frame_count: import_zod2.z.number().int().default(0),
-  directions: import_zod2.z.array(
-    import_zod2.z.object({
-      direction: import_zod2.z.string(),
-      storage_urls: import_zod2.z.record(import_zod2.z.unknown()).default({}),
-      created_at: import_zod2.z.string()
+var ObjectAnimationGroupSchema = import_zod3.z.object({
+  animation_group_id: import_zod3.z.string().min(1),
+  display_name: import_zod3.z.string().nullable().default(null),
+  description: import_zod3.z.string().default(""),
+  frame_count: import_zod3.z.number().int().default(0),
+  directions: import_zod3.z.array(
+    import_zod3.z.object({
+      direction: import_zod3.z.string(),
+      storage_urls: import_zod3.z.record(import_zod3.z.unknown()).default({}),
+      created_at: import_zod3.z.string()
     }).passthrough()
   ).default([])
 }).passthrough();
-var PixelLabObjectSchema = import_zod2.z.object({
-  id: import_zod2.z.string().min(1),
-  name: import_zod2.z.string().nullable().default(null),
-  state_name: import_zod2.z.string().nullable().optional(),
-  prompt: import_zod2.z.string().default(""),
-  size: import_zod2.z.object({ width: import_zod2.z.number().int().positive(), height: import_zod2.z.number().int().positive() }),
-  directions: import_zod2.z.number().default(0),
-  created_at: import_zod2.z.string(),
-  view: import_zod2.z.string().nullable().default(null),
-  preview_url: import_zod2.z.string().nullable().optional(),
-  rotation_urls: import_zod2.z.record(import_zod2.z.string().nullable()).nullable().optional(),
-  frame_urls: import_zod2.z.array(import_zod2.z.string()).nullable().optional(),
-  tags: import_zod2.z.array(import_zod2.z.string()).default([]),
-  status: import_zod2.z.string().nullable().default(null),
-  progress_percent: import_zod2.z.number().nullable().optional(),
-  eta_seconds: import_zod2.z.number().nullable().optional(),
-  group_id: import_zod2.z.string().nullable().optional(),
-  animations: import_zod2.z.array(ObjectAnimationGroupSchema).default([])
+var PixelLabObjectSchema = import_zod3.z.object({
+  id: import_zod3.z.string().min(1),
+  name: import_zod3.z.string().nullable().default(null),
+  state_name: import_zod3.z.string().nullable().optional(),
+  prompt: import_zod3.z.string().default(""),
+  size: import_zod3.z.object({ width: import_zod3.z.number().int().positive(), height: import_zod3.z.number().int().positive() }),
+  directions: import_zod3.z.number().default(0),
+  created_at: import_zod3.z.string(),
+  view: import_zod3.z.string().nullable().default(null),
+  preview_url: import_zod3.z.string().nullable().optional(),
+  rotation_urls: import_zod3.z.record(import_zod3.z.string().nullable()).nullable().optional(),
+  frame_urls: import_zod3.z.array(import_zod3.z.string()).nullable().optional(),
+  tags: import_zod3.z.array(import_zod3.z.string()).default([]),
+  status: import_zod3.z.string().nullable().default(null),
+  progress_percent: import_zod3.z.number().nullable().optional(),
+  eta_seconds: import_zod3.z.number().nullable().optional(),
+  group_id: import_zod3.z.string().nullable().optional(),
+  animations: import_zod3.z.array(ObjectAnimationGroupSchema).default([])
+}).passthrough();
+var MapObjectSchema = import_zod3.z.object({
+  object_id: import_zod3.z.string().min(1),
+  status: import_zod3.z.string(),
+  description: import_zod3.z.string().nullable().default(null),
+  width: import_zod3.z.number().nullable().default(null),
+  height: import_zod3.z.number().nullable().default(null),
+  download_url: import_zod3.z.string().nullable().default(null)
 }).passthrough();
-var MapObjectSchema = import_zod2.z.object({
-  object_id: import_zod2.z.string().min(1),
-  status: import_zod2.z.string(),
-  description: import_zod2.z.string().nullable().default(null),
-  width: import_zod2.z.number().nullable().default(null),
-  height: import_zod2.z.number().nullable().default(null),
-  download_url: import_zod2.z.string().nullable().default(null)
+var ObjectListSchema = import_zod3.z.object({ objects: import_zod3.z.array(PixelLabObjectSchema), total: import_zod3.z.number().int().min(0) }).passthrough();
+var PixfluxResponseSchema = import_zod3.z.object({ image: import_zod3.z.object({ base64: import_zod3.z.string().min(1) }).passthrough(), usage: import_zod3.z.unknown().optional() }).passthrough();
+var ReduceColorsResponseSchema = import_zod3.z.object({
+  images: import_zod3.z.array(import_zod3.z.object({ base64: import_zod3.z.string().min(1) }).passthrough()).min(1),
+  palette: import_zod3.z.object({ base64: import_zod3.z.string().min(1) }).passthrough(),
+  n_colors: import_zod3.z.number().int(),
+  usage: import_zod3.z.unknown().optional()
 }).passthrough();
-var ObjectListSchema = import_zod2.z.object({ objects: import_zod2.z.array(PixelLabObjectSchema), total: import_zod2.z.number().int().min(0) }).passthrough();
-var PixfluxResponseSchema = import_zod2.z.object({ image: import_zod2.z.object({ base64: import_zod2.z.string().min(1) }).passthrough(), usage: import_zod2.z.unknown().optional() }).passthrough();
-var ReduceColorsResponseSchema = import_zod2.z.object({
-  images: import_zod2.z.array(import_zod2.z.object({ base64: import_zod2.z.string().min(1) }).passthrough()).min(1),
-  palette: import_zod2.z.object({ base64: import_zod2.z.string().min(1) }).passthrough(),
-  n_colors: import_zod2.z.number().int(),
-  usage: import_zod2.z.unknown().optional()
+var CorrectPixelartResponseSchema = import_zod3.z.object({
+  images: import_zod3.z.array(import_zod3.z.object({ base64: import_zod3.z.string().min(1) }).passthrough()).min(1),
+  usage: import_zod3.z.unknown().optional()
 }).passthrough();
-var CorrectPixelartResponseSchema = import_zod2.z.object({
-  images: import_zod2.z.array(import_zod2.z.object({ base64: import_zod2.z.string().min(1) }).passthrough()).min(1),
-  usage: import_zod2.z.unknown().optional()
+var ProFlashImageSubmitSchema = import_zod3.z.object({
+  background_job_id: import_zod3.z.string().min(1),
+  image_id: import_zod3.z.string().min(1),
+  source_image_id: import_zod3.z.string().min(1),
+  status: import_zod3.z.string().default("processing"),
+  estimated_generations: import_zod3.z.number().nullable().optional(),
+  usage: import_zod3.z.unknown().optional()
 }).passthrough();
-var ProFlashImageSubmitSchema = import_zod2.z.object({
-  background_job_id: import_zod2.z.string().min(1),
-  image_id: import_zod2.z.string().min(1),
-  source_image_id: import_zod2.z.string().min(1),
-  status: import_zod2.z.string().default("processing"),
-  estimated_generations: import_zod2.z.number().nullable().optional(),
-  usage: import_zod2.z.unknown().optional()
+var UnzoomResponseSchema = import_zod3.z.object({
+  image: import_zod3.z.object({ base64: import_zod3.z.string().min(1) }).passthrough(),
+  original_size: import_zod3.z.object({ width: import_zod3.z.number().int(), height: import_zod3.z.number().int() }).passthrough(),
+  unzoomed_size: import_zod3.z.object({ width: import_zod3.z.number().int(), height: import_zod3.z.number().int() }).passthrough(),
+  zoom_factor_detected: import_zod3.z.number(),
+  usage: import_zod3.z.unknown().optional()
 }).passthrough();
-var UnzoomResponseSchema = import_zod2.z.object({
-  image: import_zod2.z.object({ base64: import_zod2.z.string().min(1) }).passthrough(),
-  original_size: import_zod2.z.object({ width: import_zod2.z.number().int(), height: import_zod2.z.number().int() }).passthrough(),
-  unzoomed_size: import_zod2.z.object({ width: import_zod2.z.number().int(), height: import_zod2.z.number().int() }).passthrough(),
-  zoom_factor_detected: import_zod2.z.number(),
-  usage: import_zod2.z.unknown().optional()
+var FontJobSchema = import_zod3.z.object({
+  job_id: import_zod3.z.string().min(1),
+  status: import_zod3.z.string(),
+  glyph_px: import_zod3.z.number().int().nullable().optional(),
+  download_atlas_url: import_zod3.z.string().nullable().optional(),
+  download_ttf_url: import_zod3.z.string().nullable().optional(),
+  usage: import_zod3.z.unknown().optional()
 }).passthrough();
-var FontJobSchema = import_zod2.z.object({
-  job_id: import_zod2.z.string().min(1),
-  status: import_zod2.z.string(),
-  glyph_px: import_zod2.z.number().int().nullable().optional(),
-  download_atlas_url: import_zod2.z.string().nullable().optional(),
-  download_ttf_url: import_zod2.z.string().nullable().optional(),
-  usage: import_zod2.z.unknown().optional()
+var SelectFramesSchema = import_zod3.z.object({ created_object_ids: import_zod3.z.array(import_zod3.z.string()) }).passthrough();
+var EstimateSkeletonResponseSchema = import_zod3.z.object({
+  keypoints: import_zod3.z.array(SkeletonKeypointSchema).length(18),
+  usage: import_zod3.z.unknown().optional()
 }).passthrough();
-var SelectFramesSchema = import_zod2.z.object({ created_object_ids: import_zod2.z.array(import_zod2.z.string()) }).passthrough();
-var CharacterSubmitSchema = import_zod2.z.object({
-  background_job_id: import_zod2.z.string().min(1),
-  character_id: import_zod2.z.string().min(1),
-  status: import_zod2.z.string().default("processing"),
+var CharacterSubmitSchema = import_zod3.z.object({
+  background_job_id: import_zod3.z.string().min(1),
+  character_id: import_zod3.z.string().min(1),
+  status: import_zod3.z.string().default("processing"),
   usage: UsageSchema
 }).passthrough();
-var AnimateSubmitSchema = import_zod2.z.object({
-  background_job_ids: import_zod2.z.array(import_zod2.z.string()),
-  directions: import_zod2.z.array(import_zod2.z.string()),
-  status: import_zod2.z.string().default("processing"),
+var AnimateSubmitSchema = import_zod3.z.object({
+  background_job_ids: import_zod3.z.array(import_zod3.z.string()),
+  directions: import_zod3.z.array(import_zod3.z.string()),
+  status: import_zod3.z.string().default("processing"),
   usage: UsageSchema
 }).passthrough();
-var ObjectProSubmitSchema = import_zod2.z.object({
-  object_id: import_zod2.z.string().min(1),
-  background_job_id: import_zod2.z.string().min(1),
-  status: import_zod2.z.string().default("processing"),
+var ObjectProSubmitSchema = import_zod3.z.object({
+  object_id: import_zod3.z.string().min(1),
+  background_job_id: import_zod3.z.string().min(1),
+  status: import_zod3.z.string().default("processing"),
   usage: UsageSchema
 }).passthrough();
-var DirectionSubmissionSchema = import_zod2.z.object({
-  direction: import_zod2.z.string(),
-  status: import_zod2.z.string(),
-  background_job_id: import_zod2.z.string().nullable().default(null),
-  animation_id: import_zod2.z.string().nullable().default(null)
+var DirectionSubmissionSchema = import_zod3.z.object({
+  direction: import_zod3.z.string(),
+  status: import_zod3.z.string(),
+  background_job_id: import_zod3.z.string().nullable().default(null),
+  animation_id: import_zod3.z.string().nullable().default(null)
 }).passthrough();
-var AnimateObjectSubmitSchema = import_zod2.z.object({
-  animation_group_id: import_zod2.z.string().min(1),
-  object_id: import_zod2.z.string().min(1),
-  mode: import_zod2.z.string(),
-  frame_count: import_zod2.z.number().int(),
-  display_name: import_zod2.z.string().nullable().default(null),
-  description: import_zod2.z.string().default(""),
-  submissions: import_zod2.z.array(DirectionSubmissionSchema),
+var AnimateObjectSubmitSchema = import_zod3.z.object({
+  animation_group_id: import_zod3.z.string().min(1),
+  object_id: import_zod3.z.string().min(1),
+  mode: import_zod3.z.string(),
+  frame_count: import_zod3.z.number().int(),
+  display_name: import_zod3.z.string().nullable().default(null),
+  description: import_zod3.z.string().default(""),
+  submissions: import_zod3.z.array(DirectionSubmissionSchema),
   usage: UsageSchema
 }).passthrough();
-var PortraitSubmitSchema = import_zod2.z.object({
-  background_job_id: import_zod2.z.string().min(1),
-  status: import_zod2.z.string().default("processing"),
+var PortraitSubmitSchema = import_zod3.z.object({
+  background_job_id: import_zod3.z.string().min(1),
+  status: import_zod3.z.string().default("processing"),
   usage: UsageSchema
 }).passthrough();
-var PortraitJobSchema = import_zod2.z.object({
-  status: import_zod2.z.string(),
-  download_url: import_zod2.z.string().nullable().optional(),
-  width: import_zod2.z.number().int().nullable().optional(),
-  height: import_zod2.z.number().int().nullable().optional()
+var PortraitJobSchema = import_zod3.z.object({
+  status: import_zod3.z.string(),
+  download_url: import_zod3.z.string().nullable().optional(),
+  width: import_zod3.z.number().int().nullable().optional(),
+  height: import_zod3.z.number().int().nullable().optional()
 }).passthrough();
-var SetPortraitSchema = import_zod2.z.object({
-  character_id: import_zod2.z.string().min(1),
-  size: import_zod2.z.number().int().positive(),
-  url: import_zod2.z.string().min(1),
+var SetPortraitSchema = import_zod3.z.object({
+  character_id: import_zod3.z.string().min(1),
+  size: import_zod3.z.number().int().positive(),
+  url: import_zod3.z.string().min(1),
   usage: UsageSchema
 }).passthrough();
-var TransferOutfitSubmitSchema = import_zod2.z.object({
-  background_job_id: import_zod2.z.string().min(1),
-  status: import_zod2.z.string().default("processing"),
+var TransferOutfitSubmitSchema = import_zod3.z.object({
+  background_job_id: import_zod3.z.string().min(1),
+  status: import_zod3.z.string().default("processing"),
   usage: UsageSchema
 }).passthrough();
-var CharacterAnimationDirectionSchema = import_zod2.z.object({
-  direction: import_zod2.z.string(),
-  frame_count: import_zod2.z.number().int().min(0),
-  frames: import_zod2.z.array(import_zod2.z.string())
+var CharacterAnimationDirectionSchema = import_zod3.z.object({
+  direction: import_zod3.z.string(),
+  frame_count: import_zod3.z.number().int().min(0),
+  frames: import_zod3.z.array(import_zod3.z.string())
 }).passthrough();
-var CharacterAnimationSchema2 = import_zod2.z.object({
-  animation_type: import_zod2.z.string(),
-  display_name: import_zod2.z.string().nullable().optional(),
-  animation_group_id: import_zod2.z.string().nullable().optional(),
-  directions: import_zod2.z.array(CharacterAnimationDirectionSchema)
+var CharacterAnimationSchema2 = import_zod3.z.object({
+  animation_type: import_zod3.z.string(),
+  display_name: import_zod3.z.string().nullable().optional(),
+  animation_group_id: import_zod3.z.string().nullable().optional(),
+  directions: import_zod3.z.array(CharacterAnimationDirectionSchema)
 }).passthrough();
-var CharacterSchema = import_zod2.z.object({
-  id: import_zod2.z.string().min(1),
-  name: import_zod2.z.string().default(""),
-  state_name: import_zod2.z.string().nullable().optional(),
-  prompt: import_zod2.z.string().default(""),
-  size: import_zod2.z.object({ width: import_zod2.z.number().int().positive(), height: import_zod2.z.number().int().positive() }),
-  directions: import_zod2.z.number().int(),
-  created_at: import_zod2.z.string(),
-  updated_at: import_zod2.z.string().nullable().optional(),
-  animation_count: import_zod2.z.number().int().default(0),
-  template_id: import_zod2.z.string().default("mannequin"),
-  view: import_zod2.z.string().nullable().optional(),
-  status: import_zod2.z.string().default("completed"),
-  rotation_urls: import_zod2.z.record(import_zod2.z.string().nullable()).nullable().optional(),
-  tags: import_zod2.z.array(import_zod2.z.string()).default([]),
-  group_id: import_zod2.z.string().nullable().optional(),
-  animations: import_zod2.z.array(CharacterAnimationSchema2).default([]),
-  preview_url: import_zod2.z.string().nullable().optional()
+var CharacterSchema = import_zod3.z.object({
+  id: import_zod3.z.string().min(1),
+  name: import_zod3.z.string().default(""),
+  state_name: import_zod3.z.string().nullable().optional(),
+  prompt: import_zod3.z.string().default(""),
+  size: import_zod3.z.object({ width: import_zod3.z.number().int().positive(), height: import_zod3.z.number().int().positive() }),
+  directions: import_zod3.z.number().int(),
+  created_at: import_zod3.z.string(),
+  updated_at: import_zod3.z.string().nullable().optional(),
+  animation_count: import_zod3.z.number().int().default(0),
+  template_id: import_zod3.z.string().default("mannequin"),
+  view: import_zod3.z.string().nullable().optional(),
+  status: import_zod3.z.string().default("completed"),
+  rotation_urls: import_zod3.z.record(import_zod3.z.string().nullable()).nullable().optional(),
+  tags: import_zod3.z.array(import_zod3.z.string()).default([]),
+  group_id: import_zod3.z.string().nullable().optional(),
+  animations: import_zod3.z.array(CharacterAnimationSchema2).default([]),
+  preview_url: import_zod3.z.string().nullable().optional()
 }).passthrough();
-var CharacterListSchema = import_zod2.z.object({ characters: import_zod2.z.array(CharacterSchema), total: import_zod2.z.number().int().min(0) }).passthrough();
-var BackgroundJobSchema = import_zod2.z.object({
-  id: import_zod2.z.string(),
-  status: import_zod2.z.string(),
-  last_response: import_zod2.z.record(import_zod2.z.unknown()).nullable().optional(),
+var CharacterListSchema = import_zod3.z.object({ characters: import_zod3.z.array(CharacterSchema), total: import_zod3.z.number().int().min(0) }).passthrough();
+var BackgroundJobSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  status: import_zod3.z.string(),
+  last_response: import_zod3.z.record(import_zod3.z.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
@@ -1887,7 +1967,7 @@ var BackgroundJobSchema = import_zod2.z.object({
    */
   usage: UsageSchema
 }).passthrough();
-var DeleteAnimationsSchema = import_zod2.z.object({ success: import_zod2.z.boolean(), deleted_count: import_zod2.z.number().int().default(0), error: import_zod2.z.string().nullable().optional() }).passthrough();
+var DeleteAnimationsSchema = import_zod3.z.object({ success: import_zod3.z.boolean(), deleted_count: import_zod3.z.number().int().default(0), error: import_zod3.z.string().nullable().optional() }).passthrough();
 function validateResponse(schema, raw, operation) {
   const parsed = schema.safeParse(raw);
   if (parsed.success) return parsed.data;
@@ -2918,6 +2998,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}");
@@ -3652,6 +3787,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
     })
@@ -3740,6 +3878,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) {
@@ -3798,7 +3948,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,
@@ -3806,7 +3958,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,
@@ -3837,6 +3989,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;
@@ -3918,6 +4074,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)) {
@@ -5067,6 +5235,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 = (0, import_node_fs2.readFileSync)(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`
@@ -5132,7 +5321,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);
@@ -6867,11 +7056,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);
@@ -8774,6 +8964,8 @@ async function resolveSpecs(loaded, filter) {
         const paletteImage = paletteImageFile ? await optionalRevisionImage(paletteImageFile, "revision palette image", "png") : null;
         const lastFrameFile = asset.revision.lastFrame ? import_node_path5.default.resolve(root, asset.revision.lastFrame) : void 0;
         const lastFrame = lastFrameFile ? await optionalRevisionImage(lastFrameFile, "revision last frame") : null;
+        const keypointsFile = asset.revision.keypointsFile ? import_node_path5.default.resolve(root, asset.revision.keypointsFile) : void 0;
+        const keypoints = keypointsFile ? await optionalSkeletonSet(keypointsFile) : null;
         resolved.revision = {
           mode: asset.revision.mode,
           sourceAssetId: asset.revision.from,
@@ -8814,6 +9006,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 } : {}
         };
       }
@@ -8935,6 +9139,17 @@ async function optionalRevisionImage(file, label, requiredFormat) {
   }
   return { hash: sha256(bytes), ...metadata };
 }
+async function optionalSkeletonSet(file) {
+  if (!(0, import_node_fs5.existsSync)(file)) return null;
+  const bytes = await (0, import_promises3.readFile)(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 ((0, import_node_fs5.existsSync)(stem)) return null;
   const at = (role) => memberPath(stem, role, 0, 2, MediaType.PNG);
@@ -11057,47 +11272,47 @@ var import_node_path14 = __toESM(require("path"), 1);
 var import_node_fs10 = require("fs");
 var import_promises7 = require("fs/promises");
 var import_node_url = require("url");
-var import_zod3 = require("zod");
+var import_zod4 = require("zod");
 var SHA256_RE = /^[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 = import_zod3.z.string().min(1).refine((value) => {
+var PortablePathSchema = import_zod4.z.string().min(1).refine((value) => {
   if (value.includes("\\") || import_node_path14.default.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 = import_zod3.z.object({
-  nodeId: import_zod3.z.string().min(1),
-  input: import_zod3.z.string().min(1)
+var RecipeBindingSchema = import_zod4.z.object({
+  nodeId: import_zod4.z.string().min(1),
+  input: import_zod4.z.string().min(1)
 }).strict();
-var RecipeSchema = import_zod3.z.object({
-  $schema: import_zod3.z.string().url().optional(),
-  format: import_zod3.z.literal("pixelkiln-recipe"),
-  schemaVersion: import_zod3.z.literal(1),
-  id: import_zod3.z.string().regex(RECIPE_ID_RE, "expected provider/name"),
-  version: import_zod3.z.string().regex(VERSION_RE, "expected x.y.z"),
-  provider: import_zod3.z.string().regex(/^[a-z0-9][a-z0-9-]*$/),
-  summary: import_zod3.z.string().min(1).max(240),
-  files: import_zod3.z.array(import_zod3.z.object({
+var RecipeSchema = import_zod4.z.object({
+  $schema: import_zod4.z.string().url().optional(),
+  format: import_zod4.z.literal("pixelkiln-recipe"),
+  schemaVersion: import_zod4.z.literal(1),
+  id: import_zod4.z.string().regex(RECIPE_ID_RE, "expected provider/name"),
+  version: import_zod4.z.string().regex(VERSION_RE, "expected x.y.z"),
+  provider: import_zod4.z.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  summary: import_zod4.z.string().min(1).max(240),
+  files: import_zod4.z.array(import_zod4.z.object({
     path: PortablePathSchema,
-    role: import_zod3.z.enum(["workflow", "reference"]),
-    sha256: import_zod3.z.string().regex(SHA256_RE)
+    role: import_zod4.z.enum(["workflow", "reference"]),
+    sha256: import_zod4.z.string().regex(SHA256_RE)
   }).strict()).default([]),
-  models: import_zod3.z.array(import_zod3.z.object({
+  models: import_zod4.z.array(import_zod4.z.object({
     path: PortablePathSchema,
-    sha256: import_zod3.z.string().regex(SHA256_RE),
-    source: import_zod3.z.string().url(),
-    license: import_zod3.z.string().min(1)
+    sha256: import_zod4.z.string().regex(SHA256_RE),
+    source: import_zod4.z.string().url(),
+    license: import_zod4.z.string().min(1)
   }).strict()).default([]),
-  styleId: import_zod3.z.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  styleId: import_zod4.z.string().regex(/^[a-z0-9][a-z0-9-]*$/),
   style: StyleSchema,
-  workflow: import_zod3.z.object({
+  workflow: import_zod4.z.object({
     path: PortablePathSchema,
-    outputNodeId: import_zod3.z.string().min(1),
-    numImages: import_zod3.z.number().int().min(1).max(16),
-    bindings: import_zod3.z.object({
+    outputNodeId: import_zod4.z.string().min(1),
+    numImages: import_zod4.z.number().int().min(1).max(16),
+    bindings: import_zod4.z.object({
       prompt: RecipeBindingSchema,
       width: RecipeBindingSchema.optional(),
       height: RecipeBindingSchema.optional(),
@@ -11108,67 +11323,67 @@ var RecipeSchema = import_zod3.z.object({
       strength: RecipeBindingSchema.optional()
     }).strict()
   }).strict().optional(),
-  quality: import_zod3.z.object({
-    stage: import_zod3.z.enum(["composition-source", "production-candidate"]),
-    workingCanvas: import_zod3.z.object({
-      width: import_zod3.z.number().int().min(16),
-      height: import_zod3.z.number().int().min(16)
+  quality: import_zod4.z.object({
+    stage: import_zod4.z.enum(["composition-source", "production-candidate"]),
+    workingCanvas: import_zod4.z.object({
+      width: import_zod4.z.number().int().min(16),
+      height: import_zod4.z.number().int().min(16)
     }).strict(),
-    recommendedNativeSize: import_zod3.z.object({
-      min: import_zod3.z.number().int().min(1),
-      max: import_zod3.z.number().int().min(1)
+    recommendedNativeSize: import_zod4.z.object({
+      min: import_zod4.z.number().int().min(1),
+      max: import_zod4.z.number().int().min(1)
     }).strict(),
-    paletteColors: import_zod3.z.object({
-      min: import_zod3.z.number().int().min(1),
-      max: import_zod3.z.number().int().min(1)
+    paletteColors: import_zod4.z.object({
+      min: import_zod4.z.number().int().min(1),
+      max: import_zod4.z.number().int().min(1)
     }).strict(),
-    background: import_zod3.z.enum(["opaque", "transparent", "full-bleed"]),
-    checks: import_zod3.z.array(import_zod3.z.enum([
+    background: import_zod4.z.enum(["opaque", "transparent", "full-bleed"]),
+    checks: import_zod4.z.array(import_zod4.z.enum([
       "prompt-coverage",
       "native-grid",
       "final-palette",
       "alpha-edge",
       "human-1x"
     ])).min(1),
-    notes: import_zod3.z.array(import_zod3.z.string().min(1)).default([])
+    notes: import_zod4.z.array(import_zod4.z.string().min(1)).default([])
   }).strict(),
-  integrity: import_zod3.z.object({
-    algorithm: import_zod3.z.literal("sha256"),
-    digest: import_zod3.z.string().regex(SHA256_RE)
+  integrity: import_zod4.z.object({
+    algorithm: import_zod4.z.literal("sha256"),
+    digest: import_zod4.z.string().regex(SHA256_RE)
   }).strict()
 }).strict().superRefine((recipe, context) => {
   if (recipe.style.provider && recipe.style.provider !== recipe.provider) {
     context.addIssue({
-      code: import_zod3.z.ZodIssueCode.custom,
+      code: import_zod4.z.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: import_zod3.z.ZodIssueCode.custom, path: ["files"], message: "duplicate file path" });
+    context.addIssue({ code: import_zod4.z.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: import_zod3.z.ZodIssueCode.custom, path: ["models"], message: "duplicate model path" });
+    context.addIssue({ code: import_zod4.z.ZodIssueCode.custom, path: ["models"], message: "duplicate model path" });
   }
   if (filePaths.includes(RECIPE_FILE)) {
     context.addIssue({
-      code: import_zod3.z.ZodIssueCode.custom,
+      code: import_zod4.z.ZodIssueCode.custom,
       path: ["files"],
       message: `${RECIPE_FILE} cannot hash itself`
     });
   }
   if (recipe.quality.recommendedNativeSize.min > recipe.quality.recommendedNativeSize.max) {
     context.addIssue({
-      code: import_zod3.z.ZodIssueCode.custom,
+      code: import_zod4.z.ZodIssueCode.custom,
       path: ["quality", "recommendedNativeSize"],
       message: "min cannot exceed max"
     });
   }
   if (recipe.quality.paletteColors.min > recipe.quality.paletteColors.max) {
     context.addIssue({
-      code: import_zod3.z.ZodIssueCode.custom,
+      code: import_zod4.z.ZodIssueCode.custom,
       path: ["quality", "paletteColors"],
       message: "min cannot exceed max"
     });
@@ -11177,7 +11392,7 @@ var RecipeSchema = import_zod3.z.object({
     (file) => file.path === recipe.workflow.path && file.role === "workflow"
   )) {
     context.addIssue({
-      code: import_zod3.z.ZodIssueCode.custom,
+      code: import_zod4.z.ZodIssueCode.custom,
       path: ["workflow", "path"],
       message: "must name a file whose role is workflow"
     });
@@ -11185,7 +11400,7 @@ var RecipeSchema = import_zod3.z.object({
   if (recipe.provider === "comfyui") {
     if (!recipe.workflow) {
       context.addIssue({
-        code: import_zod3.z.ZodIssueCode.custom,
+        code: import_zod4.z.ZodIssueCode.custom,
         path: ["workflow"],
         message: "ComfyUI recipes require workflow metadata"
       });
@@ -11194,7 +11409,7 @@ var RecipeSchema = import_zod3.z.object({
     const options = recipe.style.providerOptions.comfyui;
     if (!options || typeof options !== "object" || Array.isArray(options)) {
       context.addIssue({
-        code: import_zod3.z.ZodIssueCode.custom,
+        code: import_zod4.z.ZodIssueCode.custom,
         path: ["style", "providerOptions", "comfyui"],
         message: "ComfyUI recipes require ComfyUI provider options"
       });
@@ -11208,7 +11423,7 @@ var RecipeSchema = import_zod3.z.object({
     };
     if (JSON.stringify(canonical3(options)) !== JSON.stringify(canonical3(expected))) {
       context.addIssue({
-        code: import_zod3.z.ZodIssueCode.custom,
+        code: import_zod4.z.ZodIssueCode.custom,
         path: ["style", "providerOptions", "comfyui"],
         message: "must match workflow metadata and use {{recipeDir}} for workflowFile"
       });
@@ -11646,11 +11861,11 @@ async function generateFont(client2, opts) {
 var import_node_path17 = __toESM(require("path"), 1);
 var import_node_fs13 = require("fs");
 var import_promises10 = require("fs/promises");
-var import_zod4 = require("zod");
+var import_zod5 = require("zod");
 var SHA256_RE2 = /^[0-9a-f]{64}$/;
 var HEX_RE = /^#[0-9a-f]{6}$/;
 var MAX_REDMEAN_DISTANCE = 765;
-var QualityPathSchema = import_zod4.z.string().min(1).refine(
+var QualityPathSchema = import_zod5.z.string().min(1).refine(
   (value) => !import_node_path17.default.posix.isAbsolute(value) && !value.includes("\\"),
   "expected a portable relative path"
 );
@@ -11664,53 +11879,53 @@ var DEFAULT_QUALITY_TOLERANCES = {
   maxEdgeContrastDrop: 0.03,
   maxIsolatedPixelIncrease: 5e-3
 };
-var QualityToleranceSchema = import_zod4.z.object({
-  requireExactHash: import_zod4.z.boolean(),
-  maxColorCountIncrease: import_zod4.z.number().int().min(0),
-  maxNewColors: import_zod4.z.number().int().min(0),
-  maxTransparencyDelta: import_zod4.z.number().min(0).max(1),
-  maxPartialAlphaIncrease: import_zod4.z.number().min(0).max(1),
-  maxEdgeDensityDelta: import_zod4.z.number().min(0).max(1),
-  maxEdgeContrastDrop: import_zod4.z.number().min(0).max(1),
-  maxIsolatedPixelIncrease: import_zod4.z.number().min(0).max(1)
+var QualityToleranceSchema = import_zod5.z.object({
+  requireExactHash: import_zod5.z.boolean(),
+  maxColorCountIncrease: import_zod5.z.number().int().min(0),
+  maxNewColors: import_zod5.z.number().int().min(0),
+  maxTransparencyDelta: import_zod5.z.number().min(0).max(1),
+  maxPartialAlphaIncrease: import_zod5.z.number().min(0).max(1),
+  maxEdgeDensityDelta: import_zod5.z.number().min(0).max(1),
+  maxEdgeContrastDrop: import_zod5.z.number().min(0).max(1),
+  maxIsolatedPixelIncrease: import_zod5.z.number().min(0).max(1)
 }).strict();
-var ImageQualityMetricsSchema = import_zod4.z.object({
-  sha256: import_zod4.z.string().regex(SHA256_RE2),
-  width: import_zod4.z.number().int().min(1),
-  height: import_zod4.z.number().int().min(1),
-  colorCount: import_zod4.z.number().int().min(0),
-  colors: import_zod4.z.array(import_zod4.z.string().regex(HEX_RE)),
-  transparency: import_zod4.z.number().min(0).max(1),
-  partialAlpha: import_zod4.z.number().min(0).max(1),
-  edgeDensity: import_zod4.z.number().min(0).max(1),
-  meanEdgeContrast: import_zod4.z.number().min(0).max(1),
-  isolatedPixelRatio: import_zod4.z.number().min(0).max(1)
+var ImageQualityMetricsSchema = import_zod5.z.object({
+  sha256: import_zod5.z.string().regex(SHA256_RE2),
+  width: import_zod5.z.number().int().min(1),
+  height: import_zod5.z.number().int().min(1),
+  colorCount: import_zod5.z.number().int().min(0),
+  colors: import_zod5.z.array(import_zod5.z.string().regex(HEX_RE)),
+  transparency: import_zod5.z.number().min(0).max(1),
+  partialAlpha: import_zod5.z.number().min(0).max(1),
+  edgeDensity: import_zod5.z.number().min(0).max(1),
+  meanEdgeContrast: import_zod5.z.number().min(0).max(1),
+  isolatedPixelRatio: import_zod5.z.number().min(0).max(1)
 }).strict();
-var QualityBaselineCaseSchema = import_zod4.z.object({
-  id: import_zod4.z.string().regex(/^[a-z0-9][a-z0-9/_-]*$/),
+var QualityBaselineCaseSchema = import_zod5.z.object({
+  id: import_zod5.z.string().regex(/^[a-z0-9][a-z0-9/_-]*$/),
   file: QualityPathSchema,
-  record: import_zod4.z.object({
+  record: import_zod5.z.object({
     path: QualityPathSchema,
-    sha256: import_zod4.z.string().regex(SHA256_RE2)
+    sha256: import_zod5.z.string().regex(SHA256_RE2)
   }).strict().optional(),
   expected: ImageQualityMetricsSchema,
   tolerances: QualityToleranceSchema
 }).strict();
-var QualityBaselineSchema = import_zod4.z.object({
-  $schema: import_zod4.z.string().url().optional(),
-  format: import_zod4.z.literal("pixelkiln-quality-baseline"),
-  schemaVersion: import_zod4.z.literal(1),
-  cases: import_zod4.z.array(QualityBaselineCaseSchema).min(1)
+var QualityBaselineSchema = import_zod5.z.object({
+  $schema: import_zod5.z.string().url().optional(),
+  format: import_zod5.z.literal("pixelkiln-quality-baseline"),
+  schemaVersion: import_zod5.z.literal(1),
+  cases: import_zod5.z.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: import_zod4.z.ZodIssueCode.custom, path: ["cases"], message: "duplicate case id" });
+    context.addIssue({ code: import_zod5.z.ZodIssueCode.custom, path: ["cases"], message: "duplicate case id" });
   }
 });
-var QualityInputSchema = import_zod4.z.object({
-  id: import_zod4.z.string().regex(/^[a-z0-9][a-z0-9/_-]*$/),
-  path: import_zod4.z.string().min(1),
-  record: import_zod4.z.string().min(1).optional(),
+var QualityInputSchema = import_zod5.z.object({
+  id: import_zod5.z.string().regex(/^[a-z0-9][a-z0-9/_-]*$/),
+  path: import_zod5.z.string().min(1),
+  record: import_zod5.z.string().min(1).optional(),
   tolerances: QualityToleranceSchema.partial().optional()
 }).strict();
 function message4(error) {
@@ -11812,7 +12027,7 @@ async function measureImageQuality(file) {
   }
 }
 function resolveQualityInputs(raw, inputsFilePath) {
-  const parsed = import_zod4.z.array(QualityInputSchema).min(1).safeParse(raw);
+  const parsed = import_zod5.z.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")
@@ -12035,11 +12250,11 @@ var import_node_path21 = __toESM(require("path"), 1);
 var import_promises11 = require("fs/promises");
 var import_node_fs14 = require("fs");
 var import_node_path18 = __toESM(require("path"), 1);
-var import_zod5 = require("zod");
-var HashCacheSchema = import_zod5.z.object({
-  version: import_zod5.z.literal(1),
+var import_zod6 = require("zod");
+var HashCacheSchema = import_zod6.z.object({
+  version: import_zod6.z.literal(1),
   /** objectId → sha256 of that object's image bytes. */
-  hashes: import_zod5.z.record(import_zod5.z.string())
+  hashes: import_zod6.z.record(import_zod6.z.string())
 });
 var SHA256_HEX = /^[a-f0-9]{64}$/;
 function isSha256Hash(value) {
@@ -13587,6 +13802,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 ? {
@@ -14884,20 +15102,20 @@ var import_node_path30 = __toESM(require("path"), 1);
 var import_promises19 = require("fs/promises");
 var import_node_fs23 = require("fs");
 var import_node_path26 = __toESM(require("path"), 1);
-var import_zod6 = require("zod");
-var WorkspaceProjectSchema = import_zod6.z.object({
-  id: import_zod6.z.string().min(1),
+var import_zod7 = require("zod");
+var WorkspaceProjectSchema = import_zod7.z.object({
+  id: import_zod7.z.string().min(1),
   /** Manifest path, relative to the catalog file's own directory. */
-  manifest: import_zod6.z.string().min(1),
+  manifest: import_zod7.z.string().min(1),
   /** Lockfile path, relative to the catalog file's own directory. */
-  lock: import_zod6.z.string().min(1),
-  provider: import_zod6.z.string().min(1).default("pixellab"),
+  lock: import_zod7.z.string().min(1),
+  provider: import_zod7.z.string().min(1).default("pixellab"),
   /** Free-form label for a shared account, e.g. distinguishing sandboxes. */
-  account: import_zod6.z.string().optional()
+  account: import_zod7.z.string().optional()
 }).strict();
-var WorkspaceSchema = import_zod6.z.object({
-  version: import_zod6.z.literal(1),
-  projects: import_zod6.z.array(WorkspaceProjectSchema).default([])
+var WorkspaceSchema = import_zod7.z.object({
+  version: import_zod7.z.literal(1),
+  projects: import_zod7.z.array(WorkspaceProjectSchema).default([])
 }).strict();
 function parseWorkspace(raw) {
   const parsed = WorkspaceSchema.safeParse(raw);
@@ -15015,62 +15233,62 @@ function validateWorkspace(ws, dir) {
 
 // src/gallery/edit.ts
 var import_node_path29 = __toESM(require("path"), 1);
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 
 // src/manifest-edit.ts
 var import_promises20 = require("fs/promises");
 var import_node_path27 = __toESM(require("path"), 1);
-var import_zod7 = require("zod");
-var HexSha = import_zod7.z.string().regex(/^[0-9a-f]{64}$/);
-var AssetPatchSchema = import_zod7.z.object({
-  prompt: import_zod7.z.string().optional(),
+var import_zod8 = require("zod");
+var HexSha = import_zod8.z.string().regex(/^[0-9a-f]{64}$/);
+var AssetPatchSchema = import_zod8.z.object({
+  prompt: import_zod8.z.string().optional(),
   /** Per-style override for the style being viewed; null removes it. */
-  promptForStyle: import_zod7.z.object({ styleId: import_zod7.z.string().min(1), prompt: import_zod7.z.string().nullable() }).optional(),
-  category: import_zod7.z.string().nullable().optional(),
-  width: import_zod7.z.number().int().nullable().optional(),
-  height: import_zod7.z.number().int().nullable().optional(),
-  size: import_zod7.z.number().int().nullable().optional(),
-  tags: import_zod7.z.array(import_zod7.z.string()).optional()
+  promptForStyle: import_zod8.z.object({ styleId: import_zod8.z.string().min(1), prompt: import_zod8.z.string().nullable() }).optional(),
+  category: import_zod8.z.string().nullable().optional(),
+  width: import_zod8.z.number().int().nullable().optional(),
+  height: import_zod8.z.number().int().nullable().optional(),
+  size: import_zod8.z.number().int().nullable().optional(),
+  tags: import_zod8.z.array(import_zod8.z.string()).optional()
 }).strict();
-var NewStateSchema = import_zod7.z.object({
+var NewStateSchema = import_zod8.z.object({
   /** Asset id of the parent this states; must already exist. */
-  of: import_zod7.z.string().min(1),
-  paletteFromReference: import_zod7.z.boolean().optional(),
-  canvas: import_zod7.z.object({ width: import_zod7.z.number().int().min(16).max(256), height: import_zod7.z.number().int().min(16).max(256) }).strict().optional()
+  of: import_zod8.z.string().min(1),
+  paletteFromReference: import_zod8.z.boolean().optional(),
+  canvas: import_zod8.z.object({ width: import_zod8.z.number().int().min(16).max(256), height: import_zod8.z.number().int().min(16).max(256) }).strict().optional()
 }).strict();
-var NewAnimationSchema = import_zod7.z.object({
+var NewAnimationSchema = import_zod8.z.object({
   /** Asset id of the parent this animates; must already exist. */
-  of: import_zod7.z.string().min(1),
+  of: import_zod8.z.string().min(1),
   /** A PixelLab template id (`character` only; `objectPro` has no template concept). */
-  template: import_zod7.z.string().min(1).optional(),
+  template: import_zod8.z.string().min(1).optional(),
   direction: CharacterDirectionSchema.optional(),
-  frames: import_zod7.z.number().int().min(4).max(16).optional(),
-  fps: import_zod7.z.number().int().min(1).max(60).optional(),
+  frames: import_zod8.z.number().int().min(4).max(16).optional(),
+  fps: import_zod8.z.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: import_zod7.z.string().min(1).optional(),
-  enhancePrompt: import_zod7.z.boolean().optional()
+  subject: import_zod8.z.string().min(1).optional(),
+  enhancePrompt: import_zod8.z.boolean().optional()
 }).strict();
-var NewAssetSchema = import_zod7.z.object({
-  prompt: import_zod7.z.string(),
-  category: import_zod7.z.string().optional(),
-  width: import_zod7.z.number().int().optional(),
-  height: import_zod7.z.number().int().optional(),
-  size: import_zod7.z.number().int().optional(),
-  tags: import_zod7.z.array(import_zod7.z.string()).optional(),
+var NewAssetSchema = import_zod8.z.object({
+  prompt: import_zod8.z.string(),
+  category: import_zod8.z.string().optional(),
+  width: import_zod8.z.number().int().optional(),
+  height: import_zod8.z.number().int().optional(),
+  size: import_zod8.z.number().int().optional(),
+  tags: import_zod8.z.array(import_zod8.z.string()).optional(),
   /** Restrict to these styles; empty or omitted means every style. */
-  styles: import_zod7.z.array(import_zod7.z.string().min(1)).optional(),
+  styles: import_zod8.z.array(import_zod8.z.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: import_zod7.z.object({
-    mode: import_zod7.z.literal("image-to-image"),
+  revision: import_zod8.z.object({
+    mode: import_zod8.z.literal("image-to-image"),
     /** Asset id of the parent this revises; must already exist. */
-    from: import_zod7.z.string().min(1),
-    strength: import_zod7.z.number().min(0).max(1).optional()
+    from: import_zod8.z.string().min(1),
+    strength: import_zod8.z.number().min(0).max(1).optional()
   }).strict().optional(),
   /** A pose or outfit of an existing `character`/`objectPro` base or state. */
   state: NewStateSchema.optional(),
@@ -15086,58 +15304,58 @@ var CANDIDATE_OPTION = {
   comfyui: "numImages",
   scenario: "numOutputs"
 };
-var ManifestEditSchema = import_zod7.z.discriminatedUnion("action", [
-  import_zod7.z.object({
-    action: import_zod7.z.literal("patch-asset"),
+var ManifestEditSchema = import_zod8.z.discriminatedUnion("action", [
+  import_zod8.z.object({
+    action: import_zod8.z.literal("patch-asset"),
     /** Workspace project id; omitted for a single-project gallery. */
-    project: import_zod7.z.string().min(1).optional(),
-    assetId: import_zod7.z.string().min(1),
+    project: import_zod8.z.string().min(1).optional(),
+    assetId: import_zod8.z.string().min(1),
     /** Manifest bytes the page last saw; a mismatch refuses the write. */
     expectedSha256: HexSha,
     patch: AssetPatchSchema
   }).strict(),
-  import_zod7.z.object({
-    action: import_zod7.z.literal("add-asset"),
-    project: import_zod7.z.string().min(1).optional(),
-    assetId: import_zod7.z.string().min(1).regex(/^[^/\\]+$/, "asset ids cannot contain slashes"),
+  import_zod8.z.object({
+    action: import_zod8.z.literal("add-asset"),
+    project: import_zod8.z.string().min(1).optional(),
+    assetId: import_zod8.z.string().min(1).regex(/^[^/\\]+$/, "asset ids cannot contain slashes"),
     expectedSha256: HexSha,
     asset: NewAssetSchema
   }).strict(),
-  import_zod7.z.object({
-    action: import_zod7.z.literal("set-source"),
-    project: import_zod7.z.string().min(1).optional(),
-    assetId: import_zod7.z.string().min(1),
-    styleId: import_zod7.z.string().min(1),
+  import_zod8.z.object({
+    action: import_zod8.z.literal("set-source"),
+    project: import_zod8.z.string().min(1).optional(),
+    assetId: import_zod8.z.string().min(1),
+    styleId: import_zod8.z.string().min(1),
     /** Manifest-relative path of the art that stands in for this asset in this style. */
-    source: import_zod7.z.string().min(1),
+    source: import_zod8.z.string().min(1),
     expectedSha256: HexSha
   }).strict(),
-  import_zod7.z.object({
-    action: import_zod7.z.literal("clear-source"),
-    project: import_zod7.z.string().min(1).optional(),
-    assetId: import_zod7.z.string().min(1),
-    styleId: import_zod7.z.string().min(1),
+  import_zod8.z.object({
+    action: import_zod8.z.literal("clear-source"),
+    project: import_zod8.z.string().min(1).optional(),
+    assetId: import_zod8.z.string().min(1),
+    styleId: import_zod8.z.string().min(1),
     expectedSha256: HexSha
   }).strict(),
-  import_zod7.z.object({
-    action: import_zod7.z.literal("patch-style"),
-    project: import_zod7.z.string().min(1).optional(),
-    styleId: import_zod7.z.string().min(1),
+  import_zod8.z.object({
+    action: import_zod8.z.literal("patch-style"),
+    project: import_zod8.z.string().min(1).optional(),
+    styleId: import_zod8.z.string().min(1),
     expectedSha256: HexSha,
-    patch: import_zod7.z.object({
+    patch: import_zod8.z.object({
       /** Candidates per generation, written to the provider's own option. */
-      candidates: import_zod7.z.number().int().min(1).max(64).optional(),
+      candidates: import_zod8.z.number().int().min(1).max(64).optional(),
       /** Empty clears the style's own value (inherit, or the default). */
-      promptPrefix: import_zod7.z.string().optional(),
-      promptSuffix: import_zod7.z.string().optional(),
+      promptPrefix: import_zod8.z.string().optional(),
+      promptSuffix: import_zod8.z.string().optional(),
       /** `#rrggbb` values; null or empty clears the style's own palette. */
-      palette: import_zod7.z.array(import_zod7.z.string().regex(/^#?[0-9a-f]{6}$/i, "expected a six-digit hex colour")).max(256).nullable().optional(),
+      palette: import_zod8.z.array(import_zod8.z.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: import_zod7.z.boolean().optional(),
+      enforcePalette: import_zod8.z.boolean().optional(),
       /** Provider view name (PixelLab: low top-down, high top-down, side); empty clears. */
-      view: import_zod7.z.string().max(64).nullable().optional(),
+      view: import_zod8.z.string().max(64).nullable().optional(),
       /** pixflux only; null clears the style's own value. */
-      noBackground: import_zod7.z.boolean().nullable().optional()
+      noBackground: import_zod8.z.boolean().nullable().optional()
     }).strict().refine((patch) => Object.keys(patch).length > 0, { message: "nothing to change" })
   }).strict()
 ]);
@@ -15331,7 +15549,7 @@ async function applyManifestEdit(manifestPath, edit) {
 var import_node_fs24 = require("fs");
 var import_promises21 = require("fs/promises");
 var import_node_path28 = __toESM(require("path"), 1);
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 var HAND_EDIT_DIR = "edits";
 function handEditPath(loaded, spec) {
   const style = loaded.manifest.styles[spec.styleId];
@@ -15428,35 +15646,35 @@ async function detachHandEdit(loaded, spec, opts = {}) {
   });
   return { manifestSha256: result.sha256, changed: result.changed };
 }
-var CompanionOutputSchema = import_zod8.z.object({
+var CompanionOutputSchema = import_zod9.z.object({
   /** Output role for a set member; null for a single image. */
-  role: import_zod8.z.string().nullable(),
+  role: import_zod9.z.string().nullable(),
   /** sha256 of the generated file this member started from; null when it started from untracked art. */
-  basedOn: import_zod8.z.string().regex(/^[0-9a-f]{64}$/).nullable(),
+  basedOn: import_zod9.z.string().regex(/^[0-9a-f]{64}$/).nullable(),
   /** sha256 of the member as saved, so a later change by another tool is visible. */
-  sha256: import_zod8.z.string().regex(/^[0-9a-f]{64}$/)
+  sha256: import_zod9.z.string().regex(/^[0-9a-f]{64}$/)
 }).strict();
-var CompanionV2Schema = import_zod8.z.object({
-  version: import_zod8.z.literal(2),
+var CompanionV2Schema = import_zod9.z.object({
+  version: import_zod9.z.literal(2),
   /** Editor identity the bridge reported, e.g. `pixelorama@v1.2.2-stable`. */
-  editor: import_zod8.z.string().min(1),
-  protocol: import_zod8.z.number().int().positive(),
-  savedAt: import_zod8.z.string().datetime(),
+  editor: import_zod9.z.string().min(1),
+  protocol: import_zod9.z.number().int().positive(),
+  savedAt: import_zod9.z.string().datetime(),
   /** Basename of the layered project file beside the edit, when one was kept. */
-  project: import_zod8.z.string().min(1).nullable(),
+  project: import_zod9.z.string().min(1).nullable(),
   /** One entry per file, in output order. */
-  outputs: import_zod8.z.array(CompanionOutputSchema).min(1)
+  outputs: import_zod9.z.array(CompanionOutputSchema).min(1)
 }).strict();
-var CompanionV1Schema = import_zod8.z.object({
-  version: import_zod8.z.literal(1),
-  basedOn: import_zod8.z.string().regex(/^[0-9a-f]{64}$/).nullable(),
-  sha256: import_zod8.z.string().regex(/^[0-9a-f]{64}$/),
-  editor: import_zod8.z.string().min(1),
-  protocol: import_zod8.z.number().int().positive(),
-  savedAt: import_zod8.z.string().datetime(),
-  project: import_zod8.z.string().min(1).nullable()
+var CompanionV1Schema = import_zod9.z.object({
+  version: import_zod9.z.literal(1),
+  basedOn: import_zod9.z.string().regex(/^[0-9a-f]{64}$/).nullable(),
+  sha256: import_zod9.z.string().regex(/^[0-9a-f]{64}$/),
+  editor: import_zod9.z.string().min(1),
+  protocol: import_zod9.z.number().int().positive(),
+  savedAt: import_zod9.z.string().datetime(),
+  project: import_zod9.z.string().min(1).nullable()
 }).strict();
-var HandEditCompanionSchema = import_zod8.z.union([CompanionV2Schema, CompanionV1Schema]).transform(
+var HandEditCompanionSchema = import_zod9.z.union([CompanionV2Schema, CompanionV1Schema]).transform(
   (value) => value.version === 2 ? value : {
     version: 2,
     editor: value.editor,
@@ -15576,40 +15794,40 @@ function openInEditor(file, editor = process.env.PIXELKILN_EDITOR) {
 }
 
 // src/gallery/edit.ts
-var Base64 = import_zod9.z.string().regex(/^[A-Za-z0-9+/]*={0,2}$/).max(Math.ceil(MAX_HAND_EDIT_BYTES / 3) * 4);
-var HandEditRequestSchema = import_zod9.z.discriminatedUnion("action", [
-  import_zod9.z.object({
-    action: import_zod9.z.literal("start-edit"),
-    project: import_zod9.z.string().min(1).optional(),
-    assetId: import_zod9.z.string().min(1),
-    styleId: import_zod9.z.string().min(1),
-    expectedSha256: import_zod9.z.string().regex(/^[0-9a-f]{64}$/),
+var Base64 = import_zod10.z.string().regex(/^[A-Za-z0-9+/]*={0,2}$/).max(Math.ceil(MAX_HAND_EDIT_BYTES / 3) * 4);
+var HandEditRequestSchema = import_zod10.z.discriminatedUnion("action", [
+  import_zod10.z.object({
+    action: import_zod10.z.literal("start-edit"),
+    project: import_zod10.z.string().min(1).optional(),
+    assetId: import_zod10.z.string().min(1),
+    styleId: import_zod10.z.string().min(1),
+    expectedSha256: import_zod10.z.string().regex(/^[0-9a-f]{64}$/),
     /** Also launch the author's editor on the file. */
-    open: import_zod9.z.boolean().optional()
+    open: import_zod10.z.boolean().optional()
   }).strict(),
-  import_zod9.z.object({
-    action: import_zod9.z.literal("detach-edit"),
-    project: import_zod9.z.string().min(1).optional(),
-    assetId: import_zod9.z.string().min(1),
-    styleId: import_zod9.z.string().min(1),
-    expectedSha256: import_zod9.z.string().regex(/^[0-9a-f]{64}$/)
+  import_zod10.z.object({
+    action: import_zod10.z.literal("detach-edit"),
+    project: import_zod10.z.string().min(1).optional(),
+    assetId: import_zod10.z.string().min(1),
+    styleId: import_zod10.z.string().min(1),
+    expectedSha256: import_zod10.z.string().regex(/^[0-9a-f]{64}$/)
   }).strict(),
   /** From the in-browser editor: the page holds the bytes, the server validates and writes. */
-  import_zod9.z.object({
-    action: import_zod9.z.literal("save-edit"),
-    project: import_zod9.z.string().min(1).optional(),
-    assetId: import_zod9.z.string().min(1),
-    styleId: import_zod9.z.string().min(1),
-    expectedSha256: import_zod9.z.string().regex(/^[0-9a-f]{64}$/),
+  import_zod10.z.object({
+    action: import_zod10.z.literal("save-edit"),
+    project: import_zod10.z.string().min(1).optional(),
+    assetId: import_zod10.z.string().min(1),
+    styleId: import_zod10.z.string().min(1),
+    expectedSha256: import_zod10.z.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: import_zod9.z.array(import_zod9.z.object({ role: import_zod9.z.string().min(1).nullable(), png: Base64.min(1) }).strict()).min(1).max(256).optional(),
+    frames: import_zod10.z.array(import_zod10.z.object({ role: import_zod10.z.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: import_zod9.z.string().min(1).max(200),
-    protocol: import_zod9.z.number().int().positive()
+    editor: import_zod10.z.string().min(1).max(200),
+    protocol: import_zod10.z.number().int().positive()
   }).strict()
 ]);
 function createGalleryEditHandler(opts) {
@@ -16943,27 +17161,27 @@ async function serveGallery(opts) {
 
 // src/gallery/generate.ts
 var import_node_crypto9 = require("crypto");
-var import_zod10 = require("zod");
-var GenerateRequestSchema = import_zod10.z.object({
-  project: import_zod10.z.string().min(1).optional(),
-  keys: import_zod10.z.array(import_zod10.z.string().min(1)).min(1).max(500),
+var import_zod11 = require("zod");
+var GenerateRequestSchema = import_zod11.z.object({
+  project: import_zod11.z.string().min(1).optional(),
+  keys: import_zod11.z.array(import_zod11.z.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: import_zod10.z.boolean().optional(),
+  force: import_zod11.z.boolean().optional(),
   /** Advance in-flight, review, or selected work without submitting anything. */
-  resume: import_zod10.z.boolean().optional(),
+  resume: import_zod11.z.boolean().optional(),
   /** Re-download downloaded outputs and replace files whose object changed upstream. */
-  refresh: import_zod10.z.boolean().optional(),
+  refresh: import_zod11.z.boolean().optional(),
   /** Put recorded outputs back on disk from the cache or the provider, without generating. */
-  restore: import_zod10.z.boolean().optional(),
+  restore: import_zod11.z.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: import_zod10.z.string().min(1).max(64).optional()
+  revert: import_zod11.z.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" });