pixelkiln 0.66.0 → 0.67.0

package/dist/index.js

@@ -11,6 +11,7 @@ var RevisionModeSchema = z.enum([
   "correct-pixelart",
   "animate",
   "animate-pixminimax",
+  "animate-skeleton",
   "interpolate",
   "edit-animation"
 ]);
@@ -329,6 +330,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
@@ -419,18 +444,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 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: z.ZodIssueCode.custom,
+      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. */
@@ -1062,11 +1110,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. */
@@ -1253,7 +1306,7 @@ function exitCodeFor(err) {
 }
 
 // src/client.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 
 // src/http.ts
 var MAX_RETRIES = 4;
@@ -1303,262 +1356,289 @@ function fetchWithRetry(request, opts = {}) {
   };
 }
 
+// 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
@@ -1566,7 +1646,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;
@@ -2597,6 +2677,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}");
@@ -3331,6 +3466,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
     })
@@ -3419,6 +3557,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) {
@@ -3477,7 +3627,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,
@@ -3485,7 +3637,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,
@@ -3516,6 +3668,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;
@@ -3597,6 +3753,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)) {
@@ -4746,6 +4914,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 = 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`
@@ -4811,7 +5000,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);
@@ -6546,11 +6735,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);
@@ -8453,6 +8643,8 @@ async function resolveSpecs(loaded, filter) {
         const paletteImage = paletteImageFile ? await optionalRevisionImage(paletteImageFile, "revision palette image", "png") : null;
         const lastFrameFile = asset.revision.lastFrame ? path5.resolve(root, asset.revision.lastFrame) : void 0;
         const lastFrame = lastFrameFile ? await optionalRevisionImage(lastFrameFile, "revision last frame") : null;
+        const keypointsFile = asset.revision.keypointsFile ? path5.resolve(root, asset.revision.keypointsFile) : void 0;
+        const keypoints = keypointsFile ? await optionalSkeletonSet(keypointsFile) : null;
         resolved.revision = {
           mode: asset.revision.mode,
           sourceAssetId: asset.revision.from,
@@ -8493,6 +8685,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 } : {}
         };
       }
@@ -8614,6 +8818,17 @@ async function optionalRevisionImage(file, label, requiredFormat) {
   }
   return { hash: sha256(bytes), ...metadata };
 }
+async function optionalSkeletonSet(file) {
+  if (!existsSync4(file)) return null;
+  const bytes = await readFile3(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 (existsSync4(stem)) return null;
   const at = (role) => memberPath(stem, role, 0, 2, MediaType.PNG);
@@ -10736,47 +10951,47 @@ import path14 from "path";
 import { existsSync as existsSync9 } from "fs";
 import { readdir, readFile as readFile7 } from "fs/promises";
 import { fileURLToPath } from "url";
-import { z as z3 } from "zod";
+import { z as z4 } from "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 = z3.string().min(1).refine((value) => {
+var PortablePathSchema = z4.string().min(1).refine((value) => {
   if (value.includes("\\") || path14.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 = z3.object({
-  nodeId: z3.string().min(1),
-  input: z3.string().min(1)
+var RecipeBindingSchema = z4.object({
+  nodeId: z4.string().min(1),
+  input: z4.string().min(1)
 }).strict();
-var RecipeSchema = z3.object({
-  $schema: z3.string().url().optional(),
-  format: z3.literal("pixelkiln-recipe"),
-  schemaVersion: z3.literal(1),
-  id: z3.string().regex(RECIPE_ID_RE, "expected provider/name"),
-  version: z3.string().regex(VERSION_RE, "expected x.y.z"),
-  provider: z3.string().regex(/^[a-z0-9][a-z0-9-]*$/),
-  summary: z3.string().min(1).max(240),
-  files: z3.array(z3.object({
+var RecipeSchema = z4.object({
+  $schema: z4.string().url().optional(),
+  format: z4.literal("pixelkiln-recipe"),
+  schemaVersion: z4.literal(1),
+  id: z4.string().regex(RECIPE_ID_RE, "expected provider/name"),
+  version: z4.string().regex(VERSION_RE, "expected x.y.z"),
+  provider: z4.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  summary: z4.string().min(1).max(240),
+  files: z4.array(z4.object({
     path: PortablePathSchema,
-    role: z3.enum(["workflow", "reference"]),
-    sha256: z3.string().regex(SHA256_RE)
+    role: z4.enum(["workflow", "reference"]),
+    sha256: z4.string().regex(SHA256_RE)
   }).strict()).default([]),
-  models: z3.array(z3.object({
+  models: z4.array(z4.object({
     path: PortablePathSchema,
-    sha256: z3.string().regex(SHA256_RE),
-    source: z3.string().url(),
-    license: z3.string().min(1)
+    sha256: z4.string().regex(SHA256_RE),
+    source: z4.string().url(),
+    license: z4.string().min(1)
   }).strict()).default([]),
-  styleId: z3.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  styleId: z4.string().regex(/^[a-z0-9][a-z0-9-]*$/),
   style: StyleSchema,
-  workflow: z3.object({
+  workflow: z4.object({
     path: PortablePathSchema,
-    outputNodeId: z3.string().min(1),
-    numImages: z3.number().int().min(1).max(16),
-    bindings: z3.object({
+    outputNodeId: z4.string().min(1),
+    numImages: z4.number().int().min(1).max(16),
+    bindings: z4.object({
       prompt: RecipeBindingSchema,
       width: RecipeBindingSchema.optional(),
       height: RecipeBindingSchema.optional(),
@@ -10787,67 +11002,67 @@ var RecipeSchema = z3.object({
       strength: RecipeBindingSchema.optional()
     }).strict()
   }).strict().optional(),
-  quality: z3.object({
-    stage: z3.enum(["composition-source", "production-candidate"]),
-    workingCanvas: z3.object({
-      width: z3.number().int().min(16),
-      height: z3.number().int().min(16)
+  quality: z4.object({
+    stage: z4.enum(["composition-source", "production-candidate"]),
+    workingCanvas: z4.object({
+      width: z4.number().int().min(16),
+      height: z4.number().int().min(16)
     }).strict(),
-    recommendedNativeSize: z3.object({
-      min: z3.number().int().min(1),
-      max: z3.number().int().min(1)
+    recommendedNativeSize: z4.object({
+      min: z4.number().int().min(1),
+      max: z4.number().int().min(1)
     }).strict(),
-    paletteColors: z3.object({
-      min: z3.number().int().min(1),
-      max: z3.number().int().min(1)
+    paletteColors: z4.object({
+      min: z4.number().int().min(1),
+      max: z4.number().int().min(1)
     }).strict(),
-    background: z3.enum(["opaque", "transparent", "full-bleed"]),
-    checks: z3.array(z3.enum([
+    background: z4.enum(["opaque", "transparent", "full-bleed"]),
+    checks: z4.array(z4.enum([
       "prompt-coverage",
       "native-grid",
       "final-palette",
       "alpha-edge",
       "human-1x"
     ])).min(1),
-    notes: z3.array(z3.string().min(1)).default([])
+    notes: z4.array(z4.string().min(1)).default([])
   }).strict(),
-  integrity: z3.object({
-    algorithm: z3.literal("sha256"),
-    digest: z3.string().regex(SHA256_RE)
+  integrity: z4.object({
+    algorithm: z4.literal("sha256"),
+    digest: z4.string().regex(SHA256_RE)
   }).strict()
 }).strict().superRefine((recipe, context) => {
   if (recipe.style.provider && recipe.style.provider !== recipe.provider) {
     context.addIssue({
-      code: z3.ZodIssueCode.custom,
+      code: z4.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: z3.ZodIssueCode.custom, path: ["files"], message: "duplicate file path" });
+    context.addIssue({ code: z4.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: z3.ZodIssueCode.custom, path: ["models"], message: "duplicate model path" });
+    context.addIssue({ code: z4.ZodIssueCode.custom, path: ["models"], message: "duplicate model path" });
   }
   if (filePaths.includes(RECIPE_FILE)) {
     context.addIssue({
-      code: z3.ZodIssueCode.custom,
+      code: z4.ZodIssueCode.custom,
       path: ["files"],
       message: `${RECIPE_FILE} cannot hash itself`
     });
   }
   if (recipe.quality.recommendedNativeSize.min > recipe.quality.recommendedNativeSize.max) {
     context.addIssue({
-      code: z3.ZodIssueCode.custom,
+      code: z4.ZodIssueCode.custom,
       path: ["quality", "recommendedNativeSize"],
       message: "min cannot exceed max"
     });
   }
   if (recipe.quality.paletteColors.min > recipe.quality.paletteColors.max) {
     context.addIssue({
-      code: z3.ZodIssueCode.custom,
+      code: z4.ZodIssueCode.custom,
       path: ["quality", "paletteColors"],
       message: "min cannot exceed max"
     });
@@ -10856,7 +11071,7 @@ var RecipeSchema = z3.object({
     (file) => file.path === recipe.workflow.path && file.role === "workflow"
   )) {
     context.addIssue({
-      code: z3.ZodIssueCode.custom,
+      code: z4.ZodIssueCode.custom,
       path: ["workflow", "path"],
       message: "must name a file whose role is workflow"
     });
@@ -10864,7 +11079,7 @@ var RecipeSchema = z3.object({
   if (recipe.provider === "comfyui") {
     if (!recipe.workflow) {
       context.addIssue({
-        code: z3.ZodIssueCode.custom,
+        code: z4.ZodIssueCode.custom,
         path: ["workflow"],
         message: "ComfyUI recipes require workflow metadata"
       });
@@ -10873,7 +11088,7 @@ var RecipeSchema = z3.object({
     const options = recipe.style.providerOptions.comfyui;
     if (!options || typeof options !== "object" || Array.isArray(options)) {
       context.addIssue({
-        code: z3.ZodIssueCode.custom,
+        code: z4.ZodIssueCode.custom,
         path: ["style", "providerOptions", "comfyui"],
         message: "ComfyUI recipes require ComfyUI provider options"
       });
@@ -10887,7 +11102,7 @@ var RecipeSchema = z3.object({
     };
     if (JSON.stringify(canonical3(options)) !== JSON.stringify(canonical3(expected))) {
       context.addIssue({
-        code: z3.ZodIssueCode.custom,
+        code: z4.ZodIssueCode.custom,
         path: ["style", "providerOptions", "comfyui"],
         message: "must match workflow metadata and use {{recipeDir}} for workflowFile"
       });
@@ -11325,11 +11540,11 @@ async function generateFont(client2, opts) {
 import path17 from "path";
 import { existsSync as existsSync12 } from "fs";
 import { readFile as readFile10 } from "fs/promises";
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var SHA256_RE2 = /^[0-9a-f]{64}$/;
 var HEX_RE = /^#[0-9a-f]{6}$/;
 var MAX_REDMEAN_DISTANCE = 765;
-var QualityPathSchema = z4.string().min(1).refine(
+var QualityPathSchema = z5.string().min(1).refine(
   (value) => !path17.posix.isAbsolute(value) && !value.includes("\\"),
   "expected a portable relative path"
 );
@@ -11343,53 +11558,53 @@ var DEFAULT_QUALITY_TOLERANCES = {
   maxEdgeContrastDrop: 0.03,
   maxIsolatedPixelIncrease: 5e-3
 };
-var QualityToleranceSchema = z4.object({
-  requireExactHash: z4.boolean(),
-  maxColorCountIncrease: z4.number().int().min(0),
-  maxNewColors: z4.number().int().min(0),
-  maxTransparencyDelta: z4.number().min(0).max(1),
-  maxPartialAlphaIncrease: z4.number().min(0).max(1),
-  maxEdgeDensityDelta: z4.number().min(0).max(1),
-  maxEdgeContrastDrop: z4.number().min(0).max(1),
-  maxIsolatedPixelIncrease: z4.number().min(0).max(1)
+var QualityToleranceSchema = z5.object({
+  requireExactHash: z5.boolean(),
+  maxColorCountIncrease: z5.number().int().min(0),
+  maxNewColors: z5.number().int().min(0),
+  maxTransparencyDelta: z5.number().min(0).max(1),
+  maxPartialAlphaIncrease: z5.number().min(0).max(1),
+  maxEdgeDensityDelta: z5.number().min(0).max(1),
+  maxEdgeContrastDrop: z5.number().min(0).max(1),
+  maxIsolatedPixelIncrease: z5.number().min(0).max(1)
 }).strict();
-var ImageQualityMetricsSchema = z4.object({
-  sha256: z4.string().regex(SHA256_RE2),
-  width: z4.number().int().min(1),
-  height: z4.number().int().min(1),
-  colorCount: z4.number().int().min(0),
-  colors: z4.array(z4.string().regex(HEX_RE)),
-  transparency: z4.number().min(0).max(1),
-  partialAlpha: z4.number().min(0).max(1),
-  edgeDensity: z4.number().min(0).max(1),
-  meanEdgeContrast: z4.number().min(0).max(1),
-  isolatedPixelRatio: z4.number().min(0).max(1)
+var ImageQualityMetricsSchema = z5.object({
+  sha256: z5.string().regex(SHA256_RE2),
+  width: z5.number().int().min(1),
+  height: z5.number().int().min(1),
+  colorCount: z5.number().int().min(0),
+  colors: z5.array(z5.string().regex(HEX_RE)),
+  transparency: z5.number().min(0).max(1),
+  partialAlpha: z5.number().min(0).max(1),
+  edgeDensity: z5.number().min(0).max(1),
+  meanEdgeContrast: z5.number().min(0).max(1),
+  isolatedPixelRatio: z5.number().min(0).max(1)
 }).strict();
-var QualityBaselineCaseSchema = z4.object({
-  id: z4.string().regex(/^[a-z0-9][a-z0-9/_-]*$/),
+var QualityBaselineCaseSchema = z5.object({
+  id: z5.string().regex(/^[a-z0-9][a-z0-9/_-]*$/),
   file: QualityPathSchema,
-  record: z4.object({
+  record: z5.object({
     path: QualityPathSchema,
-    sha256: z4.string().regex(SHA256_RE2)
+    sha256: z5.string().regex(SHA256_RE2)
   }).strict().optional(),
   expected: ImageQualityMetricsSchema,
   tolerances: QualityToleranceSchema
 }).strict();
-var QualityBaselineSchema = z4.object({
-  $schema: z4.string().url().optional(),
-  format: z4.literal("pixelkiln-quality-baseline"),
-  schemaVersion: z4.literal(1),
-  cases: z4.array(QualityBaselineCaseSchema).min(1)
+var QualityBaselineSchema = z5.object({
+  $schema: z5.string().url().optional(),
+  format: z5.literal("pixelkiln-quality-baseline"),
+  schemaVersion: z5.literal(1),
+  cases: z5.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: z4.ZodIssueCode.custom, path: ["cases"], message: "duplicate case id" });
+    context.addIssue({ code: z5.ZodIssueCode.custom, path: ["cases"], message: "duplicate case id" });
   }
 });
-var QualityInputSchema = z4.object({
-  id: z4.string().regex(/^[a-z0-9][a-z0-9/_-]*$/),
-  path: z4.string().min(1),
-  record: z4.string().min(1).optional(),
+var QualityInputSchema = z5.object({
+  id: z5.string().regex(/^[a-z0-9][a-z0-9/_-]*$/),
+  path: z5.string().min(1),
+  record: z5.string().min(1).optional(),
   tolerances: QualityToleranceSchema.partial().optional()
 }).strict();
 function message4(error) {
@@ -11491,7 +11706,7 @@ async function measureImageQuality(file) {
   }
 }
 function resolveQualityInputs(raw, inputsFilePath) {
-  const parsed = z4.array(QualityInputSchema).min(1).safeParse(raw);
+  const parsed = z5.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")
@@ -11714,11 +11929,11 @@ import path20 from "path";
 import { mkdir as mkdir5, readFile as readFile11, rename as rename4, rm as rm4, writeFile as writeFile5 } from "fs/promises";
 import { existsSync as existsSync13 } from "fs";
 import pathModule from "path";
-import { z as z5 } from "zod";
-var HashCacheSchema = z5.object({
-  version: z5.literal(1),
+import { z as z6 } from "zod";
+var HashCacheSchema = z6.object({
+  version: z6.literal(1),
   /** objectId → sha256 of that object's image bytes. */
-  hashes: z5.record(z5.string())
+  hashes: z6.record(z6.string())
 });
 var SHA256_HEX = /^[a-f0-9]{64}$/;
 function isSha256Hash(value) {
@@ -13266,6 +13481,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 ? {
@@ -14563,20 +14781,20 @@ import path29 from "path";
 import { mkdir as mkdir7, readFile as readFile18, rename as rename6, rm as rm7, writeFile as writeFile9 } from "fs/promises";
 import { existsSync as existsSync21 } from "fs";
 import path25 from "path";
-import { z as z6 } from "zod";
-var WorkspaceProjectSchema = z6.object({
-  id: z6.string().min(1),
+import { z as z7 } from "zod";
+var WorkspaceProjectSchema = z7.object({
+  id: z7.string().min(1),
   /** Manifest path, relative to the catalog file's own directory. */
-  manifest: z6.string().min(1),
+  manifest: z7.string().min(1),
   /** Lockfile path, relative to the catalog file's own directory. */
-  lock: z6.string().min(1),
-  provider: z6.string().min(1).default("pixellab"),
+  lock: z7.string().min(1),
+  provider: z7.string().min(1).default("pixellab"),
   /** Free-form label for a shared account, e.g. distinguishing sandboxes. */
-  account: z6.string().optional()
+  account: z7.string().optional()
 }).strict();
-var WorkspaceSchema = z6.object({
-  version: z6.literal(1),
-  projects: z6.array(WorkspaceProjectSchema).default([])
+var WorkspaceSchema = z7.object({
+  version: z7.literal(1),
+  projects: z7.array(WorkspaceProjectSchema).default([])
 }).strict();
 function parseWorkspace(raw) {
   const parsed = WorkspaceSchema.safeParse(raw);
@@ -14694,62 +14912,62 @@ function validateWorkspace(ws, dir) {
 
 // src/gallery/edit.ts
 import path28 from "path";
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 
 // src/manifest-edit.ts
 import { readFile as readFile19, rename as rename7, rm as rm8, writeFile as writeFile10 } from "fs/promises";
 import path26 from "path";
-import { z as z7 } from "zod";
-var HexSha = z7.string().regex(/^[0-9a-f]{64}$/);
-var AssetPatchSchema = z7.object({
-  prompt: z7.string().optional(),
+import { z as z8 } from "zod";
+var HexSha = z8.string().regex(/^[0-9a-f]{64}$/);
+var AssetPatchSchema = z8.object({
+  prompt: z8.string().optional(),
   /** Per-style override for the style being viewed; null removes it. */
-  promptForStyle: z7.object({ styleId: z7.string().min(1), prompt: z7.string().nullable() }).optional(),
-  category: z7.string().nullable().optional(),
-  width: z7.number().int().nullable().optional(),
-  height: z7.number().int().nullable().optional(),
-  size: z7.number().int().nullable().optional(),
-  tags: z7.array(z7.string()).optional()
+  promptForStyle: z8.object({ styleId: z8.string().min(1), prompt: z8.string().nullable() }).optional(),
+  category: z8.string().nullable().optional(),
+  width: z8.number().int().nullable().optional(),
+  height: z8.number().int().nullable().optional(),
+  size: z8.number().int().nullable().optional(),
+  tags: z8.array(z8.string()).optional()
 }).strict();
-var NewStateSchema = z7.object({
+var NewStateSchema = z8.object({
   /** Asset id of the parent this states; must already exist. */
-  of: z7.string().min(1),
-  paletteFromReference: z7.boolean().optional(),
-  canvas: z7.object({ width: z7.number().int().min(16).max(256), height: z7.number().int().min(16).max(256) }).strict().optional()
+  of: z8.string().min(1),
+  paletteFromReference: z8.boolean().optional(),
+  canvas: z8.object({ width: z8.number().int().min(16).max(256), height: z8.number().int().min(16).max(256) }).strict().optional()
 }).strict();
-var NewAnimationSchema = z7.object({
+var NewAnimationSchema = z8.object({
   /** Asset id of the parent this animates; must already exist. */
-  of: z7.string().min(1),
+  of: z8.string().min(1),
   /** A PixelLab template id (`character` only; `objectPro` has no template concept). */
-  template: z7.string().min(1).optional(),
+  template: z8.string().min(1).optional(),
   direction: CharacterDirectionSchema.optional(),
-  frames: z7.number().int().min(4).max(16).optional(),
-  fps: z7.number().int().min(1).max(60).optional(),
+  frames: z8.number().int().min(4).max(16).optional(),
+  fps: z8.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: z7.string().min(1).optional(),
-  enhancePrompt: z7.boolean().optional()
+  subject: z8.string().min(1).optional(),
+  enhancePrompt: z8.boolean().optional()
 }).strict();
-var NewAssetSchema = z7.object({
-  prompt: z7.string(),
-  category: z7.string().optional(),
-  width: z7.number().int().optional(),
-  height: z7.number().int().optional(),
-  size: z7.number().int().optional(),
-  tags: z7.array(z7.string()).optional(),
+var NewAssetSchema = z8.object({
+  prompt: z8.string(),
+  category: z8.string().optional(),
+  width: z8.number().int().optional(),
+  height: z8.number().int().optional(),
+  size: z8.number().int().optional(),
+  tags: z8.array(z8.string()).optional(),
   /** Restrict to these styles; empty or omitted means every style. */
-  styles: z7.array(z7.string().min(1)).optional(),
+  styles: z8.array(z8.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: z7.object({
-    mode: z7.literal("image-to-image"),
+  revision: z8.object({
+    mode: z8.literal("image-to-image"),
     /** Asset id of the parent this revises; must already exist. */
-    from: z7.string().min(1),
-    strength: z7.number().min(0).max(1).optional()
+    from: z8.string().min(1),
+    strength: z8.number().min(0).max(1).optional()
   }).strict().optional(),
   /** A pose or outfit of an existing `character`/`objectPro` base or state. */
   state: NewStateSchema.optional(),
@@ -14765,58 +14983,58 @@ var CANDIDATE_OPTION = {
   comfyui: "numImages",
   scenario: "numOutputs"
 };
-var ManifestEditSchema = z7.discriminatedUnion("action", [
-  z7.object({
-    action: z7.literal("patch-asset"),
+var ManifestEditSchema = z8.discriminatedUnion("action", [
+  z8.object({
+    action: z8.literal("patch-asset"),
     /** Workspace project id; omitted for a single-project gallery. */
-    project: z7.string().min(1).optional(),
-    assetId: z7.string().min(1),
+    project: z8.string().min(1).optional(),
+    assetId: z8.string().min(1),
     /** Manifest bytes the page last saw; a mismatch refuses the write. */
     expectedSha256: HexSha,
     patch: AssetPatchSchema
   }).strict(),
-  z7.object({
-    action: z7.literal("add-asset"),
-    project: z7.string().min(1).optional(),
-    assetId: z7.string().min(1).regex(/^[^/\\]+$/, "asset ids cannot contain slashes"),
+  z8.object({
+    action: z8.literal("add-asset"),
+    project: z8.string().min(1).optional(),
+    assetId: z8.string().min(1).regex(/^[^/\\]+$/, "asset ids cannot contain slashes"),
     expectedSha256: HexSha,
     asset: NewAssetSchema
   }).strict(),
-  z7.object({
-    action: z7.literal("set-source"),
-    project: z7.string().min(1).optional(),
-    assetId: z7.string().min(1),
-    styleId: z7.string().min(1),
+  z8.object({
+    action: z8.literal("set-source"),
+    project: z8.string().min(1).optional(),
+    assetId: z8.string().min(1),
+    styleId: z8.string().min(1),
     /** Manifest-relative path of the art that stands in for this asset in this style. */
-    source: z7.string().min(1),
+    source: z8.string().min(1),
     expectedSha256: HexSha
   }).strict(),
-  z7.object({
-    action: z7.literal("clear-source"),
-    project: z7.string().min(1).optional(),
-    assetId: z7.string().min(1),
-    styleId: z7.string().min(1),
+  z8.object({
+    action: z8.literal("clear-source"),
+    project: z8.string().min(1).optional(),
+    assetId: z8.string().min(1),
+    styleId: z8.string().min(1),
     expectedSha256: HexSha
   }).strict(),
-  z7.object({
-    action: z7.literal("patch-style"),
-    project: z7.string().min(1).optional(),
-    styleId: z7.string().min(1),
+  z8.object({
+    action: z8.literal("patch-style"),
+    project: z8.string().min(1).optional(),
+    styleId: z8.string().min(1),
     expectedSha256: HexSha,
-    patch: z7.object({
+    patch: z8.object({
       /** Candidates per generation, written to the provider's own option. */
-      candidates: z7.number().int().min(1).max(64).optional(),
+      candidates: z8.number().int().min(1).max(64).optional(),
       /** Empty clears the style's own value (inherit, or the default). */
-      promptPrefix: z7.string().optional(),
-      promptSuffix: z7.string().optional(),
+      promptPrefix: z8.string().optional(),
+      promptSuffix: z8.string().optional(),
       /** `#rrggbb` values; null or empty clears the style's own palette. */
-      palette: z7.array(z7.string().regex(/^#?[0-9a-f]{6}$/i, "expected a six-digit hex colour")).max(256).nullable().optional(),
+      palette: z8.array(z8.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: z7.boolean().optional(),
+      enforcePalette: z8.boolean().optional(),
       /** Provider view name (PixelLab: low top-down, high top-down, side); empty clears. */
-      view: z7.string().max(64).nullable().optional(),
+      view: z8.string().max(64).nullable().optional(),
       /** pixflux only; null clears the style's own value. */
-      noBackground: z7.boolean().nullable().optional()
+      noBackground: z8.boolean().nullable().optional()
     }).strict().refine((patch) => Object.keys(patch).length > 0, { message: "nothing to change" })
   }).strict()
 ]);
@@ -15010,7 +15228,7 @@ async function applyManifestEdit(manifestPath, edit) {
 import { existsSync as existsSync22 } from "fs";
 import { copyFile, mkdir as mkdir8, readFile as readFile20, rename as rename8, rm as rm9, writeFile as writeFile11 } from "fs/promises";
 import path27 from "path";
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var HAND_EDIT_DIR = "edits";
 function handEditPath(loaded, spec) {
   const style = loaded.manifest.styles[spec.styleId];
@@ -15107,35 +15325,35 @@ async function detachHandEdit(loaded, spec, opts = {}) {
   });
   return { manifestSha256: result.sha256, changed: result.changed };
 }
-var CompanionOutputSchema = z8.object({
+var CompanionOutputSchema = z9.object({
   /** Output role for a set member; null for a single image. */
-  role: z8.string().nullable(),
+  role: z9.string().nullable(),
   /** sha256 of the generated file this member started from; null when it started from untracked art. */
-  basedOn: z8.string().regex(/^[0-9a-f]{64}$/).nullable(),
+  basedOn: z9.string().regex(/^[0-9a-f]{64}$/).nullable(),
   /** sha256 of the member as saved, so a later change by another tool is visible. */
-  sha256: z8.string().regex(/^[0-9a-f]{64}$/)
+  sha256: z9.string().regex(/^[0-9a-f]{64}$/)
 }).strict();
-var CompanionV2Schema = z8.object({
-  version: z8.literal(2),
+var CompanionV2Schema = z9.object({
+  version: z9.literal(2),
   /** Editor identity the bridge reported, e.g. `pixelorama@v1.2.2-stable`. */
-  editor: z8.string().min(1),
-  protocol: z8.number().int().positive(),
-  savedAt: z8.string().datetime(),
+  editor: z9.string().min(1),
+  protocol: z9.number().int().positive(),
+  savedAt: z9.string().datetime(),
   /** Basename of the layered project file beside the edit, when one was kept. */
-  project: z8.string().min(1).nullable(),
+  project: z9.string().min(1).nullable(),
   /** One entry per file, in output order. */
-  outputs: z8.array(CompanionOutputSchema).min(1)
+  outputs: z9.array(CompanionOutputSchema).min(1)
 }).strict();
-var CompanionV1Schema = z8.object({
-  version: z8.literal(1),
-  basedOn: z8.string().regex(/^[0-9a-f]{64}$/).nullable(),
-  sha256: z8.string().regex(/^[0-9a-f]{64}$/),
-  editor: z8.string().min(1),
-  protocol: z8.number().int().positive(),
-  savedAt: z8.string().datetime(),
-  project: z8.string().min(1).nullable()
+var CompanionV1Schema = z9.object({
+  version: z9.literal(1),
+  basedOn: z9.string().regex(/^[0-9a-f]{64}$/).nullable(),
+  sha256: z9.string().regex(/^[0-9a-f]{64}$/),
+  editor: z9.string().min(1),
+  protocol: z9.number().int().positive(),
+  savedAt: z9.string().datetime(),
+  project: z9.string().min(1).nullable()
 }).strict();
-var HandEditCompanionSchema = z8.union([CompanionV2Schema, CompanionV1Schema]).transform(
+var HandEditCompanionSchema = z9.union([CompanionV2Schema, CompanionV1Schema]).transform(
   (value) => value.version === 2 ? value : {
     version: 2,
     editor: value.editor,
@@ -15255,40 +15473,40 @@ function openInEditor(file, editor = process.env.PIXELKILN_EDITOR) {
 }
 
 // src/gallery/edit.ts
-var Base64 = z9.string().regex(/^[A-Za-z0-9+/]*={0,2}$/).max(Math.ceil(MAX_HAND_EDIT_BYTES / 3) * 4);
-var HandEditRequestSchema = z9.discriminatedUnion("action", [
-  z9.object({
-    action: z9.literal("start-edit"),
-    project: z9.string().min(1).optional(),
-    assetId: z9.string().min(1),
-    styleId: z9.string().min(1),
-    expectedSha256: z9.string().regex(/^[0-9a-f]{64}$/),
+var Base64 = z10.string().regex(/^[A-Za-z0-9+/]*={0,2}$/).max(Math.ceil(MAX_HAND_EDIT_BYTES / 3) * 4);
+var HandEditRequestSchema = z10.discriminatedUnion("action", [
+  z10.object({
+    action: z10.literal("start-edit"),
+    project: z10.string().min(1).optional(),
+    assetId: z10.string().min(1),
+    styleId: z10.string().min(1),
+    expectedSha256: z10.string().regex(/^[0-9a-f]{64}$/),
     /** Also launch the author's editor on the file. */
-    open: z9.boolean().optional()
+    open: z10.boolean().optional()
   }).strict(),
-  z9.object({
-    action: z9.literal("detach-edit"),
-    project: z9.string().min(1).optional(),
-    assetId: z9.string().min(1),
-    styleId: z9.string().min(1),
-    expectedSha256: z9.string().regex(/^[0-9a-f]{64}$/)
+  z10.object({
+    action: z10.literal("detach-edit"),
+    project: z10.string().min(1).optional(),
+    assetId: z10.string().min(1),
+    styleId: z10.string().min(1),
+    expectedSha256: z10.string().regex(/^[0-9a-f]{64}$/)
   }).strict(),
   /** From the in-browser editor: the page holds the bytes, the server validates and writes. */
-  z9.object({
-    action: z9.literal("save-edit"),
-    project: z9.string().min(1).optional(),
-    assetId: z9.string().min(1),
-    styleId: z9.string().min(1),
-    expectedSha256: z9.string().regex(/^[0-9a-f]{64}$/),
+  z10.object({
+    action: z10.literal("save-edit"),
+    project: z10.string().min(1).optional(),
+    assetId: z10.string().min(1),
+    styleId: z10.string().min(1),
+    expectedSha256: z10.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: z9.array(z9.object({ role: z9.string().min(1).nullable(), png: Base64.min(1) }).strict()).min(1).max(256).optional(),
+    frames: z10.array(z10.object({ role: z10.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: z9.string().min(1).max(200),
-    protocol: z9.number().int().positive()
+    editor: z10.string().min(1).max(200),
+    protocol: z10.number().int().positive()
   }).strict()
 ]);
 function createGalleryEditHandler(opts) {
@@ -16622,27 +16840,27 @@ async function serveGallery(opts) {
 
 // src/gallery/generate.ts
 import { randomBytes as randomBytes2 } from "crypto";
-import { z as z10 } from "zod";
-var GenerateRequestSchema = z10.object({
-  project: z10.string().min(1).optional(),
-  keys: z10.array(z10.string().min(1)).min(1).max(500),
+import { z as z11 } from "zod";
+var GenerateRequestSchema = z11.object({
+  project: z11.string().min(1).optional(),
+  keys: z11.array(z11.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: z10.boolean().optional(),
+  force: z11.boolean().optional(),
   /** Advance in-flight, review, or selected work without submitting anything. */
-  resume: z10.boolean().optional(),
+  resume: z11.boolean().optional(),
   /** Re-download downloaded outputs and replace files whose object changed upstream. */
-  refresh: z10.boolean().optional(),
+  refresh: z11.boolean().optional(),
   /** Put recorded outputs back on disk from the cache or the provider, without generating. */
-  restore: z10.boolean().optional(),
+  restore: z11.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: z10.string().min(1).max(64).optional()
+  revert: z11.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" });