pixelkiln 0.66.0 → 0.68.0

package/dist/index.js

@@ -11,6 +11,7 @@ var RevisionModeSchema = z.enum([
   "correct-pixelart",
   "animate",
   "animate-pixminimax",
+  "animate-skeleton",
   "interpolate",
   "edit-animation"
 ]);
@@ -199,6 +200,16 @@ var CharacterPortraitSchema = z.object({
   of: z.string().min(1),
   size: CharacterPortraitSizeSchema.default(64)
 }).strict();
+var MapScenePlacementSchema = z.union([
+  z.object({ oval: z.number().min(0.05).max(0.95) }).strict(),
+  z.object({ rectangle: z.number().min(0.05).max(0.95) }).strict(),
+  z.object({ mask: z.string().min(1) }).strict()
+]);
+var MapSceneSchema = z.object({
+  /** Manifest-relative PNG of the scene. Any earlier asset's output file works. */
+  image: z.string().min(1),
+  placement: MapScenePlacementSchema.default({ oval: 0.3 })
+}).strict();
 var CharacterOutfitSchema = z.object({
   /** The loop (a character animation asset) to re-clothe, in the same style. */
   of: z.string().min(1),
@@ -329,6 +340,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 +454,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. */
@@ -846,6 +904,8 @@ var AssetSchema = z.object({
   portrait: CharacterPortraitSchema.optional(),
   /** `character` styles: this asset re-clothes an existing loop's frames with a reference outfit. */
   outfit: CharacterOutfitSchema.optional(),
+  /** `map` styles only: draw this object in the style of a scene image. See `MapSceneSchema`. */
+  scene: MapSceneSchema.optional(),
   /** `character` styles, `standard` humanoid bases: this character's proportions, over the style's. */
   proportions: CharacterProportionsSchema.optional(),
   /**
@@ -922,7 +982,7 @@ var AssetSchema = z.object({
       path: ["revision"]
     });
   }
-  const shapes = [asset.revision && "revision", asset.state && "state", asset.animation && "animation", asset.mirror && "mirror", asset.batch && "batch", asset.portrait && "portrait", asset.outfit && "outfit"].filter(Boolean);
+  const shapes = [asset.revision && "revision", asset.state && "state", asset.animation && "animation", asset.mirror && "mirror", asset.batch && "batch", asset.portrait && "portrait", asset.outfit && "outfit", asset.scene && "scene"].filter(Boolean);
   if (shapes.length > 1) {
     context.addIssue({
       code: z.ZodIssueCode.custom,
@@ -1062,11 +1122,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 +1318,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 +1368,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 = 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 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 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 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 CorrectPixelartResponseSchema = z2.object({
-  images: z2.array(z2.object({ base64: z2.string().min(1) }).passthrough()).min(1),
-  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 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 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 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 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 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 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 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 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 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 +1658,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;
@@ -1686,6 +1778,12 @@ var PixelLabClient = class {
     if (args.shading) body.shading = args.shading;
     if (args.detail) body.detail = args.detail;
     if (args.seed != null) body.seed = args.seed;
+    if (args.scene) {
+      const encode = (image) => ({ type: "base64", base64: image.base64, format: image.format });
+      const placement = args.scene.placement;
+      body.background_image = encode(args.scene.image);
+      body.inpainting = placement.type === "mask" ? { type: "mask", mask_image: encode(placement.mask) } : { type: placement.type, fraction: placement.fraction };
+    }
     return validateResponse(
       MapSubmitSchema,
       await this.request("/map-objects", { method: "POST", body: JSON.stringify(body) }),
@@ -2597,6 +2695,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}");
@@ -3253,6 +3406,11 @@ function specHash(spec, styleImageHashes, providerOptionIdentity = spec.provider
       uiPieces: spec.uiPieces,
       uiElements: spec.uiElements,
       uiColorPalette: spec.uiColorPalette,
+      // Scene and mask enter as their bytes' hashes, never their paths.
+      scene: spec.scene ? {
+        image: spec.scene.sha256,
+        placement: spec.scene.placement.type === "mask" ? { type: "mask", mask: spec.scene.placement.sha256 } : spec.scene.placement
+      } : void 0,
       styleTraits: spec.styleTraits,
       styleImages: styleImageHashes,
       // A character family: the engine and rotations of a base, the parent's
@@ -3331,6 +3489,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 +3580,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) {
@@ -3469,6 +3642,8 @@ var PixelLabProvider = class _PixelLabProvider {
   supports(generator) {
     return generator === "1dir" || generator === "map" || generator === "pixflux" || generator === "tiles" || generator === "terrain" || generator === "imagePro" || generator === "character" || generator === "isometricTile" || generator === "objectPro" || generator === "uiAsset" || generator === "uiElement" || generator === "imageProFlash";
   }
+  /** `/map-objects` style matching: `background_image` plus `inpainting`. */
+  supportsMapScene = true;
   /**
    * `inpaint` (`/inpaint-v3`, a mask) and `image-to-image` (`/edit-images-v2`,
    * no mask) both exist on PixelLab, and so do `reduce-colors`
@@ -3477,7 +3652,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 +3662,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 +3693,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 +3778,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)) {
@@ -4596,7 +4789,8 @@ var PixelLabProvider = class _PixelLabProvider {
       outline: spec.outline,
       shading: spec.shading,
       detail: spec.detail,
-      seed: spec.seed
+      seed: spec.seed,
+      scene: spec.scene ? mapScenePayload(spec) : void 0
     });
     return { jobId: res.object_id, metadata: { backgroundJobId: res.background_job_id } };
   }
@@ -4746,6 +4940,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 +5026,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);
@@ -5452,6 +5667,21 @@ function findObjectAnimation(object, name, direction, animationId) {
   }
   return null;
 }
+function mapScenePayload(spec) {
+  const scene = spec.scene;
+  const read = (file, hash, label) => {
+    const bytes = readFileSync(file);
+    if (!hash || sha256(bytes) !== hash) {
+      throw new Error(`${spec.styleId}/${spec.assetId}: ${label} changed after the manifest was resolved`);
+    }
+    return { base64: bytes.toString("base64"), format: "png" };
+  };
+  const placement = scene.placement;
+  return {
+    image: read(scene.file, scene.sha256, "scene image"),
+    placement: placement.type === "mask" ? { type: "mask", mask: read(placement.file, placement.sha256, "scene mask") } : placement
+  };
+}
 
 // src/providers/retrodiffusion.ts
 var DEFAULT_BASE_URL = "https://api.retrodiffusion.ai/v1";
@@ -6546,11 +6776,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);
@@ -7230,6 +7461,7 @@ var FakeProvider = class {
   supports(generator) {
     return generator === "1dir" || generator === "map" || generator === "character";
   }
+  supportsMapScene = true;
   supportsRevision(_mode) {
     return true;
   }
@@ -8453,6 +8685,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 +8727,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 } : {}
         };
       }
@@ -8546,6 +8792,7 @@ async function resolveSpecs(loaded, filter) {
           };
         }
       }
+      if (asset.scene) resolved.scene = await resolveMapScene(root, styleId, assetId, resolved.generator, asset.scene, activeProvider);
       resolved.specHash = specHash(
         resolved,
         styleImageHashes,
@@ -8604,6 +8851,32 @@ function pngPath(file) {
   const extension = path5.extname(file);
   return extension ? `${file.slice(0, -extension.length)}.png` : `${file}.png`;
 }
+async function resolveMapScene(root, styleId, assetId, generator, scene, provider) {
+  if (generator !== "map") {
+    throw new Error(`assets.${assetId}.scene: only a map object can be drawn into a scene; style "${styleId}" uses "${generator}"`);
+  }
+  if (!provider.supportsMapScene) {
+    throw new Error(`assets.${assetId}.scene: provider "${provider.id}" cannot draw into a scene; PixelLab's /map-objects can`);
+  }
+  const file = path5.resolve(root, scene.image);
+  const image = await optionalRevisionImage(file, "scene image", "png");
+  const base = { file, sha256: image?.hash ?? null, width: image?.width ?? null, height: image?.height ?? null };
+  const placement = scene.placement;
+  if ("mask" in placement) {
+    const maskFile = path5.resolve(root, placement.mask);
+    const mask = await optionalRevisionImage(maskFile, "scene mask", "png");
+    if (image && mask && (image.width !== mask.width || image.height !== mask.height)) {
+      throw new Error(
+        `assets.${assetId}.scene: the mask is ${mask.width}x${mask.height}; the scene ${scene.image} is ${image.width}x${image.height}`
+      );
+    }
+    return {
+      ...base,
+      placement: { type: "mask", file: maskFile, sha256: mask?.hash ?? null, width: mask?.width ?? null, height: mask?.height ?? null }
+    };
+  }
+  return "oval" in placement ? { ...base, placement: { type: "oval", fraction: placement.oval } } : { ...base, placement: { type: "rectangle", fraction: placement.rectangle } };
+}
 async function optionalRevisionImage(file, label, requiredFormat) {
   if (!existsSync4(file)) return null;
   const bytes = await readFile3(file);
@@ -8614,6 +8887,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);
@@ -10263,6 +10547,7 @@ async function inspectRevisionReadiness(spec, lock) {
   if (spec.character?.parentSpec) return inspectCharacterParent(spec, lock, /* @__PURE__ */ new Set());
   if (spec.character?.styleAnchor) return inspectStyleAnchor(spec, lock, /* @__PURE__ */ new Set());
   if (spec.objectPro?.parentSpec) return inspectObjectProParent(spec, lock, /* @__PURE__ */ new Set());
+  if (spec.scene) return inspectScene(spec);
   if (!spec.revision) return null;
   return inspectRevision(spec, lock, /* @__PURE__ */ new Set());
 }
@@ -10280,6 +10565,16 @@ async function inspectStyleAnchor(spec, lock, seen) {
   }
   return { ready: true, reason: `${label} is current` };
 }
+async function inspectScene(spec) {
+  const scene = spec.scene;
+  const files = [{ label: "scene image", file: scene.file, sha256: scene.sha256 }];
+  if (scene.placement.type === "mask") files.push({ label: "scene mask", file: scene.placement.file, sha256: scene.placement.sha256 });
+  for (const { label, file, sha256: sha2562 } of files) {
+    if (!sha2562 || !existsSync7(file)) return { ready: false, reason: `${label} does not exist yet: ${file}` };
+    if (await sha256File(file) !== sha2562) return { ready: false, reason: `${label} changed after the manifest was resolved` };
+  }
+  return { ready: true, reason: "scene is current" };
+}
 async function inspectMirror(spec, lock, seen) {
   const source = spec.mirror.sourceSpec;
   const label = `mirror source ${spec.styleId}/${spec.mirror.sourceAssetId}`;
@@ -10736,47 +11031,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 +11082,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 +11151,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 +11159,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 +11168,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 +11182,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 +11620,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 +11638,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 +11786,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 +12009,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 +13561,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 +14861,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 +14992,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 +15063,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 +15308,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 +15405,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 +15553,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 +16920,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" });
@@ -17645,6 +17943,8 @@ export {
   ManifestEditSchema,
   ManifestInputSchema,
   ManifestSchema,
+  MapScenePlacementSchema,
+  MapSceneSchema,
   MediaType,
   OverwriteRefusedError,
   PIXEL_ART_FIXER_REVISION,