pixelkiln 0.65.0 → 0.67.0

package/dist/index.cjs

@@ -322,7 +322,7 @@ var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
 // src/types.ts
 var import_zod = require("zod");
 var MediaTypeSchema = import_zod.z.enum(["image/png", "image/gif"]);
-var GeneratorSchema = import_zod.z.enum(["1dir", "map", "pixflux", "tiles", "animation", "frames", "character", "terrain", "imagePro", "isometricTile", "objectPro", "uiAsset", "uiElement"]);
+var GeneratorSchema = import_zod.z.enum(["1dir", "map", "pixflux", "tiles", "animation", "frames", "character", "terrain", "imagePro", "isometricTile", "objectPro", "uiAsset", "uiElement", "imageProFlash"]);
 var GridConfidenceSchema = import_zod.z.enum(["low", "medium", "high"]);
 var RevisionModeSchema = import_zod.z.enum([
   "image-to-image",
@@ -332,6 +332,7 @@ var RevisionModeSchema = import_zod.z.enum([
   "correct-pixelart",
   "animate",
   "animate-pixminimax",
+  "animate-skeleton",
   "interpolate",
   "edit-animation"
 ]);
@@ -649,8 +650,46 @@ var RevisionSchema = import_zod.z.object({
   /** `animate-pixminimax` only: facing direction, used only alongside `enhancePrompt` to hold the sprite's facing. */
   direction: CharacterDirectionSchema.optional(),
   /** `animate`/`animate-pixminimax` only: let PixelLab expand the action into a fuller motion description first. */
-  enhancePrompt: import_zod.z.boolean().optional()
+  enhancePrompt: import_zod.z.boolean().optional(),
+  /**
+   * `animate-skeleton` only: manifest-relative path to a committed
+   * `SkeletonSet` JSON file (see `src/skeleton.ts`) — the pose the parent
+   * image is already in, plus 3-15 per-frame poses for the motion.
+   * Authored via `pixelkiln estimate-skeleton`, then hand-tweaked; never
+   * inline in the manifest, the same reasoning `mask`/`lastFrame` are
+   * committed files rather than inline pixel data.
+   */
+  keypointsFile: import_zod.z.string().min(1).optional(),
+  /**
+   * `animate-skeleton` only: the body a joint's missing `depth` is taken
+   * from. PixelLab's default is `mannequin`; free string like `character`'s
+   * own `template` field, validated at the provider layer against the
+   * same `mannequin`/`bear`/`cat`/`dog`/`horse`/`lion` vocabulary.
+   */
+  skeletonTemplate: import_zod.z.string().min(1).optional(),
+  /**
+   * `animate-skeleton` only: what the character *looks like*, a noun
+   * phrase (colours, clothing, held items) — distinct from the asset's
+   * own `prompt`, which this mode sends as the motion's short label
+   * (PixelLab's `action`), the same `prompt`-as-motion convention
+   * `animate`/`animate-pixminimax` already use.
+   */
+  description: import_zod.z.string().min(1).optional(),
+  /**
+   * `image-to-image`/`inpaint` only: which provider engine draws the
+   * edit. `pro-flash` selects PixelLab's Pro Flash edit and inpaint tier
+   * (`/edit-image-pro-flash`, `/inpaint-image-pro-flash`) instead of the
+   * default Pro endpoints; omit it for the default.
+   */
+  engine: import_zod.z.enum(["pro-flash"]).optional()
 }).strict().superRefine((revision, context) => {
+  if (revision.engine !== void 0 && revision.mode !== "image-to-image" && revision.mode !== "inpaint") {
+    context.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      message: "engine applies to image-to-image and inpaint revisions only",
+      path: ["engine"]
+    });
+  }
   if (revision.mode === "inpaint" && !revision.mask) {
     context.addIssue({
       code: import_zod.z.ZodIssueCode.custom,
@@ -726,18 +765,41 @@ var RevisionSchema = import_zod.z.object({
       path: ["fps"]
     });
   }
-  if (revision.direction !== void 0 && revision.mode !== "animate-pixminimax") {
+  if (revision.direction !== void 0 && revision.mode !== "animate-pixminimax" && revision.mode !== "animate-skeleton") {
     context.addIssue({
       code: import_zod.z.ZodIssueCode.custom,
-      message: "direction applies to animate-pixminimax revisions only",
+      message: "direction applies to animate-pixminimax/animate-skeleton revisions only",
+      path: ["direction"]
+    });
+  }
+  if (revision.mode === "animate-skeleton" && revision.direction === void 0) {
+    context.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      message: "animate-skeleton revisions require a direction",
       path: ["direction"]
     });
   }
   if (revision.frames !== void 0 && revision.frames % 2 !== 0) {
     context.addIssue({ code: import_zod.z.ZodIssueCode.custom, message: "frames must be even", path: ["frames"] });
   }
+  if (revision.mode === "animate-skeleton" && !revision.keypointsFile) {
+    context.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      message: "animate-skeleton revisions require keypointsFile",
+      path: ["keypointsFile"]
+    });
+  }
+  for (const field of ["keypointsFile", "skeletonTemplate", "description"]) {
+    if (revision[field] !== void 0 && revision.mode !== "animate-skeleton") {
+      context.addIssue({
+        code: import_zod.z.ZodIssueCode.custom,
+        message: `${field} applies to animate-skeleton revisions only`,
+        path: [field]
+      });
+    }
+  }
 });
-var FRAME_SET_REVISION_MODES = ["animate", "animate-pixminimax", "interpolate", "edit-animation"];
+var FRAME_SET_REVISION_MODES = ["animate", "animate-pixminimax", "animate-skeleton", "interpolate", "edit-animation"];
 var MEMBER_SET_REVISION_MODES = ["reduce-colors", "correct-pixelart", "edit-animation"];
 var StyleObjectSchema = import_zod.z.object({
   /** Generation backend for this style. Omit to inherit the manifest default. */
@@ -939,8 +1001,8 @@ var StyleObjectSchema = import_zod.z.object({
   /** `character` only. Body template: `mannequin` (default), a quadruped (`bear`, `cat`, `dog`, `horse`, `lion`), or `custom` for `pro-flash`. */
   template: import_zod.z.string().min(1).optional(),
   /**
-   * `character` only, `pro-flash` bases with a style image: which traits
-   * the style image lends. Each defaults to true.
+   * `character` `pro-flash` bases and `imageProFlash` styles, with a
+   * style image: which traits the style image lends. Each defaults to true.
    */
   styleTraits: import_zod.z.object({
     palette: import_zod.z.boolean().optional(),
@@ -1369,11 +1431,17 @@ var LockEntrySchema = import_zod.z.object({
     paletteImageSha256: import_zod.z.string().regex(/^[0-9a-f]{64}$/).optional(),
     dithering: RevisionDitheringSchema.optional(),
     ditheringStrength: import_zod.z.number().min(0).max(10).optional(),
-    frames: import_zod.z.number().int().min(4).max(40).optional(),
+    // 4-40 for animate/animate-pixminimax; animate-skeleton's own 3-15
+    // range extends the floor down to 3, hence min(3) here rather than 4.
+    frames: import_zod.z.number().int().min(3).max(40).optional(),
     fps: import_zod.z.number().int().min(1).max(60).optional(),
     lastFrameSha256: import_zod.z.string().regex(/^[0-9a-f]{64}$/).optional(),
     direction: CharacterDirectionSchema.optional(),
-    enhancePrompt: import_zod.z.boolean().optional()
+    enhancePrompt: import_zod.z.boolean().optional(),
+    keypointsSha256: import_zod.z.string().regex(/^[0-9a-f]{64}$/).optional(),
+    skeletonTemplate: import_zod.z.string().min(1).optional(),
+    description: import_zod.z.string().min(1).optional(),
+    engine: import_zod.z.enum(["pro-flash"]).optional()
   }).strict().nullable().default(null),
   /** For a mirror: the asset it flips and a hash over that asset's output hashes when this was made. */
   mirror: import_zod.z.object({
@@ -1559,7 +1627,7 @@ function exitCodeFor(err) {
 }
 
 // src/client.ts
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 
 // src/http.ts
 var MAX_RETRIES = 4;
@@ -1609,254 +1677,289 @@ function fetchWithRetry(request, opts = {}) {
   };
 }
 
+// src/skeleton.ts
+var import_zod2 = require("zod");
+var SkeletonKeypointSchema = import_zod2.z.object({
+  label: import_zod2.z.string().min(1),
+  x: import_zod2.z.number().min(0).max(1),
+  y: import_zod2.z.number().min(0).max(1),
+  z_index: import_zod2.z.number(),
+  depth: import_zod2.z.number().optional()
+}).strict();
+var SkeletonFrameSchema = import_zod2.z.array(SkeletonKeypointSchema).length(18);
+var SkeletonSetSchema = import_zod2.z.object({
+  firstFrameKeypoints: SkeletonFrameSchema,
+  frames: import_zod2.z.array(SkeletonFrameSchema).min(3).max(15)
+}).strict();
+function parseSkeletonSet(json, file) {
+  const result = SkeletonSetSchema.safeParse(json);
+  if (!result.success) {
+    const issues = result.error.issues.slice(0, 4).map((issue) => `${issue.path.join(".") || "root"}: ${issue.message}`).join("; ");
+    throw new Error(`revision keypoints file ${file} does not match the expected shape: ${issues}`);
+  }
+  return result.data;
+}
+
 // src/client.ts
 var BASE = process.env.PIXELLAB_API_BASE ?? "https://api.pixellab.ai/v2";
 var MAX_DOWNLOAD_BYTES = 64 * 1024 * 1024;
-var BalanceResponseSchema = import_zod2.z.object({
-  credits: import_zod2.z.object({ usd: import_zod2.z.number() }).passthrough(),
-  subscription: import_zod2.z.object({
-    generations: import_zod2.z.number(),
-    total: import_zod2.z.number(),
-    plan: import_zod2.z.string().nullable().optional()
+var BalanceResponseSchema = import_zod3.z.object({
+  credits: import_zod3.z.object({ usd: import_zod3.z.number() }).passthrough(),
+  subscription: import_zod3.z.object({
+    generations: import_zod3.z.number(),
+    total: import_zod3.z.number(),
+    plan: import_zod3.z.string().nullable().optional()
   }).passthrough()
 }).passthrough();
-var ObjectSubmitSchema = import_zod2.z.object({
-  background_job_id: import_zod2.z.string().min(1),
-  object_id: import_zod2.z.string().min(1),
-  status: import_zod2.z.string().default("queued"),
-  n_frames: import_zod2.z.number().int().min(0)
+var ObjectSubmitSchema = import_zod3.z.object({
+  background_job_id: import_zod3.z.string().min(1),
+  object_id: import_zod3.z.string().min(1),
+  status: import_zod3.z.string().default("queued"),
+  n_frames: import_zod3.z.number().int().min(0)
 }).passthrough();
-var MapSubmitSchema = import_zod2.z.object({
-  background_job_id: import_zod2.z.string().min(1),
-  object_id: import_zod2.z.string().min(1),
-  status: import_zod2.z.string().default("processing")
+var MapSubmitSchema = import_zod3.z.object({
+  background_job_id: import_zod3.z.string().min(1),
+  object_id: import_zod3.z.string().min(1),
+  status: import_zod3.z.string().default("processing")
 }).passthrough();
-var UsageSchema = import_zod2.z.object({
-  type: import_zod2.z.string().optional(),
-  usd: import_zod2.z.number().nullable().optional(),
-  generations: import_zod2.z.number().nullable().optional()
+var UsageSchema = import_zod3.z.object({
+  type: import_zod3.z.string().optional(),
+  usd: import_zod3.z.number().nullable().optional(),
+  generations: import_zod3.z.number().nullable().optional()
 }).passthrough().nullable().optional();
-var TilesSubmitSchema = import_zod2.z.object({
-  tile_id: import_zod2.z.string().min(1),
-  background_job_id: import_zod2.z.string().min(1),
-  status: import_zod2.z.literal("processing").default("processing")
+var TilesSubmitSchema = import_zod3.z.object({
+  tile_id: import_zod3.z.string().min(1),
+  background_job_id: import_zod3.z.string().min(1),
+  status: import_zod3.z.literal("processing").default("processing")
 }).passthrough();
-var TilesProSchema = import_zod2.z.object({
-  storage_urls: import_zod2.z.record(import_zod2.z.string()),
-  kind: import_zod2.z.string().nullable().default(null),
-  tile_rules: import_zod2.z.record(import_zod2.z.unknown()).nullable().optional()
+var TilesProSchema = import_zod3.z.object({
+  storage_urls: import_zod3.z.record(import_zod3.z.string()),
+  kind: import_zod3.z.string().nullable().default(null),
+  tile_rules: import_zod3.z.record(import_zod3.z.unknown()).nullable().optional()
 }).passthrough();
-var TilesetSubmitSchema = import_zod2.z.object({
-  tileset_id: import_zod2.z.string().min(1),
-  background_job_id: import_zod2.z.string().min(1),
-  status: import_zod2.z.literal("processing").default("processing")
+var TilesetSubmitSchema = import_zod3.z.object({
+  tileset_id: import_zod3.z.string().min(1),
+  background_job_id: import_zod3.z.string().min(1),
+  status: import_zod3.z.literal("processing").default("processing")
 }).passthrough();
-var TilesetTileSchema = import_zod2.z.object({
-  id: import_zod2.z.string().min(1),
-  name: import_zod2.z.string(),
-  image: import_zod2.z.object({ base64: import_zod2.z.string().min(1), format: import_zod2.z.string().default("png") }).passthrough(),
-  corners: import_zod2.z.object({ NW: import_zod2.z.string(), NE: import_zod2.z.string(), SW: import_zod2.z.string(), SE: import_zod2.z.string() }).passthrough(),
-  pattern_4x4: import_zod2.z.object({
-    row_0: import_zod2.z.array(import_zod2.z.number()),
-    row_1: import_zod2.z.array(import_zod2.z.number()),
-    row_2: import_zod2.z.array(import_zod2.z.number()),
-    row_3: import_zod2.z.array(import_zod2.z.number())
+var TilesetTileSchema = import_zod3.z.object({
+  id: import_zod3.z.string().min(1),
+  name: import_zod3.z.string(),
+  image: import_zod3.z.object({ base64: import_zod3.z.string().min(1), format: import_zod3.z.string().default("png") }).passthrough(),
+  corners: import_zod3.z.object({ NW: import_zod3.z.string(), NE: import_zod3.z.string(), SW: import_zod3.z.string(), SE: import_zod3.z.string() }).passthrough(),
+  pattern_4x4: import_zod3.z.object({
+    row_0: import_zod3.z.array(import_zod3.z.number()),
+    row_1: import_zod3.z.array(import_zod3.z.number()),
+    row_2: import_zod3.z.array(import_zod3.z.number()),
+    row_3: import_zod3.z.array(import_zod3.z.number())
   }).passthrough()
 }).passthrough();
-var TilesetGetSchema = import_zod2.z.object({
-  tileset: import_zod2.z.object({
-    total_tiles: import_zod2.z.number().int().min(1),
-    tile_size: import_zod2.z.object({ width: import_zod2.z.number().int().positive(), height: import_zod2.z.number().int().positive() }).passthrough(),
-    terrain_types: import_zod2.z.array(import_zod2.z.string()),
-    tiles: import_zod2.z.array(TilesetTileSchema).min(1)
+var TilesetGetSchema = import_zod3.z.object({
+  tileset: import_zod3.z.object({
+    total_tiles: import_zod3.z.number().int().min(1),
+    tile_size: import_zod3.z.object({ width: import_zod3.z.number().int().positive(), height: import_zod3.z.number().int().positive() }).passthrough(),
+    terrain_types: import_zod3.z.array(import_zod3.z.string()),
+    tiles: import_zod3.z.array(TilesetTileSchema).min(1)
   }).passthrough(),
   usage: UsageSchema
 }).passthrough();
-var IsometricTileSubmitSchema = import_zod2.z.object({
-  tile_id: import_zod2.z.string().min(1),
-  background_job_id: import_zod2.z.string().min(1),
-  status: import_zod2.z.literal("processing").default("processing")
+var IsometricTileSubmitSchema = import_zod3.z.object({
+  tile_id: import_zod3.z.string().min(1),
+  background_job_id: import_zod3.z.string().min(1),
+  status: import_zod3.z.literal("processing").default("processing")
 }).passthrough();
-var IsometricTileGetSchema = import_zod2.z.object({
-  image: import_zod2.z.object({ base64: import_zod2.z.string().min(1), format: import_zod2.z.string().default("png") }).passthrough(),
+var IsometricTileGetSchema = import_zod3.z.object({
+  image: import_zod3.z.object({ base64: import_zod3.z.string().min(1), format: import_zod3.z.string().default("png") }).passthrough(),
   usage: UsageSchema
 }).passthrough();
-var UiAssetSubmitSchema = import_zod2.z.object({
-  ui_asset_id: import_zod2.z.string().min(1),
-  background_job_id: import_zod2.z.string().min(1),
-  status: import_zod2.z.string().default("processing"),
+var UiAssetSubmitSchema = import_zod3.z.object({
+  ui_asset_id: import_zod3.z.string().min(1),
+  background_job_id: import_zod3.z.string().min(1),
+  status: import_zod3.z.string().default("processing"),
   usage: UsageSchema
 }).passthrough();
-var UiAssetGetSchema = import_zod2.z.object({
-  id: import_zod2.z.string().min(1),
-  status: import_zod2.z.string().nullable().default(null),
-  image_url: import_zod2.z.string().nullable().optional(),
-  progress_percent: import_zod2.z.number().nullable().optional(),
-  eta_seconds: import_zod2.z.number().nullable().optional()
+var UiAssetGetSchema = import_zod3.z.object({
+  id: import_zod3.z.string().min(1),
+  status: import_zod3.z.string().nullable().default(null),
+  image_url: import_zod3.z.string().nullable().optional(),
+  progress_percent: import_zod3.z.number().nullable().optional(),
+  eta_seconds: import_zod3.z.number().nullable().optional()
 }).passthrough();
-var RevisionJobSubmitSchema = import_zod2.z.object({
-  background_job_id: import_zod2.z.string().min(1),
-  status: import_zod2.z.string().default("processing")
+var RevisionJobSubmitSchema = import_zod3.z.object({
+  background_job_id: import_zod3.z.string().min(1),
+  status: import_zod3.z.string().default("processing")
 }).passthrough();
-var ObjectAnimationGroupSchema = import_zod2.z.object({
-  animation_group_id: import_zod2.z.string().min(1),
-  display_name: import_zod2.z.string().nullable().default(null),
-  description: import_zod2.z.string().default(""),
-  frame_count: import_zod2.z.number().int().default(0),
-  directions: import_zod2.z.array(
-    import_zod2.z.object({
-      direction: import_zod2.z.string(),
-      storage_urls: import_zod2.z.record(import_zod2.z.unknown()).default({}),
-      created_at: import_zod2.z.string()
+var ObjectAnimationGroupSchema = import_zod3.z.object({
+  animation_group_id: import_zod3.z.string().min(1),
+  display_name: import_zod3.z.string().nullable().default(null),
+  description: import_zod3.z.string().default(""),
+  frame_count: import_zod3.z.number().int().default(0),
+  directions: import_zod3.z.array(
+    import_zod3.z.object({
+      direction: import_zod3.z.string(),
+      storage_urls: import_zod3.z.record(import_zod3.z.unknown()).default({}),
+      created_at: import_zod3.z.string()
     }).passthrough()
   ).default([])
 }).passthrough();
-var PixelLabObjectSchema = import_zod2.z.object({
-  id: import_zod2.z.string().min(1),
-  name: import_zod2.z.string().nullable().default(null),
-  state_name: import_zod2.z.string().nullable().optional(),
-  prompt: import_zod2.z.string().default(""),
-  size: import_zod2.z.object({ width: import_zod2.z.number().int().positive(), height: import_zod2.z.number().int().positive() }),
-  directions: import_zod2.z.number().default(0),
-  created_at: import_zod2.z.string(),
-  view: import_zod2.z.string().nullable().default(null),
-  preview_url: import_zod2.z.string().nullable().optional(),
-  rotation_urls: import_zod2.z.record(import_zod2.z.string().nullable()).nullable().optional(),
-  frame_urls: import_zod2.z.array(import_zod2.z.string()).nullable().optional(),
-  tags: import_zod2.z.array(import_zod2.z.string()).default([]),
-  status: import_zod2.z.string().nullable().default(null),
-  progress_percent: import_zod2.z.number().nullable().optional(),
-  eta_seconds: import_zod2.z.number().nullable().optional(),
-  group_id: import_zod2.z.string().nullable().optional(),
-  animations: import_zod2.z.array(ObjectAnimationGroupSchema).default([])
+var PixelLabObjectSchema = import_zod3.z.object({
+  id: import_zod3.z.string().min(1),
+  name: import_zod3.z.string().nullable().default(null),
+  state_name: import_zod3.z.string().nullable().optional(),
+  prompt: import_zod3.z.string().default(""),
+  size: import_zod3.z.object({ width: import_zod3.z.number().int().positive(), height: import_zod3.z.number().int().positive() }),
+  directions: import_zod3.z.number().default(0),
+  created_at: import_zod3.z.string(),
+  view: import_zod3.z.string().nullable().default(null),
+  preview_url: import_zod3.z.string().nullable().optional(),
+  rotation_urls: import_zod3.z.record(import_zod3.z.string().nullable()).nullable().optional(),
+  frame_urls: import_zod3.z.array(import_zod3.z.string()).nullable().optional(),
+  tags: import_zod3.z.array(import_zod3.z.string()).default([]),
+  status: import_zod3.z.string().nullable().default(null),
+  progress_percent: import_zod3.z.number().nullable().optional(),
+  eta_seconds: import_zod3.z.number().nullable().optional(),
+  group_id: import_zod3.z.string().nullable().optional(),
+  animations: import_zod3.z.array(ObjectAnimationGroupSchema).default([])
+}).passthrough();
+var MapObjectSchema = import_zod3.z.object({
+  object_id: import_zod3.z.string().min(1),
+  status: import_zod3.z.string(),
+  description: import_zod3.z.string().nullable().default(null),
+  width: import_zod3.z.number().nullable().default(null),
+  height: import_zod3.z.number().nullable().default(null),
+  download_url: import_zod3.z.string().nullable().default(null)
+}).passthrough();
+var ObjectListSchema = import_zod3.z.object({ objects: import_zod3.z.array(PixelLabObjectSchema), total: import_zod3.z.number().int().min(0) }).passthrough();
+var PixfluxResponseSchema = import_zod3.z.object({ image: import_zod3.z.object({ base64: import_zod3.z.string().min(1) }).passthrough(), usage: import_zod3.z.unknown().optional() }).passthrough();
+var ReduceColorsResponseSchema = import_zod3.z.object({
+  images: import_zod3.z.array(import_zod3.z.object({ base64: import_zod3.z.string().min(1) }).passthrough()).min(1),
+  palette: import_zod3.z.object({ base64: import_zod3.z.string().min(1) }).passthrough(),
+  n_colors: import_zod3.z.number().int(),
+  usage: import_zod3.z.unknown().optional()
 }).passthrough();
-var MapObjectSchema = import_zod2.z.object({
-  object_id: import_zod2.z.string().min(1),
-  status: import_zod2.z.string(),
-  description: import_zod2.z.string().nullable().default(null),
-  width: import_zod2.z.number().nullable().default(null),
-  height: import_zod2.z.number().nullable().default(null),
-  download_url: import_zod2.z.string().nullable().default(null)
+var CorrectPixelartResponseSchema = import_zod3.z.object({
+  images: import_zod3.z.array(import_zod3.z.object({ base64: import_zod3.z.string().min(1) }).passthrough()).min(1),
+  usage: import_zod3.z.unknown().optional()
 }).passthrough();
-var ObjectListSchema = import_zod2.z.object({ objects: import_zod2.z.array(PixelLabObjectSchema), total: import_zod2.z.number().int().min(0) }).passthrough();
-var PixfluxResponseSchema = import_zod2.z.object({ image: import_zod2.z.object({ base64: import_zod2.z.string().min(1) }).passthrough(), usage: import_zod2.z.unknown().optional() }).passthrough();
-var ReduceColorsResponseSchema = import_zod2.z.object({
-  images: import_zod2.z.array(import_zod2.z.object({ base64: import_zod2.z.string().min(1) }).passthrough()).min(1),
-  palette: import_zod2.z.object({ base64: import_zod2.z.string().min(1) }).passthrough(),
-  n_colors: import_zod2.z.number().int(),
-  usage: import_zod2.z.unknown().optional()
+var ProFlashImageSubmitSchema = import_zod3.z.object({
+  background_job_id: import_zod3.z.string().min(1),
+  image_id: import_zod3.z.string().min(1),
+  source_image_id: import_zod3.z.string().min(1),
+  status: import_zod3.z.string().default("processing"),
+  estimated_generations: import_zod3.z.number().nullable().optional(),
+  usage: import_zod3.z.unknown().optional()
 }).passthrough();
-var CorrectPixelartResponseSchema = import_zod2.z.object({
-  images: import_zod2.z.array(import_zod2.z.object({ base64: import_zod2.z.string().min(1) }).passthrough()).min(1),
-  usage: import_zod2.z.unknown().optional()
+var UnzoomResponseSchema = import_zod3.z.object({
+  image: import_zod3.z.object({ base64: import_zod3.z.string().min(1) }).passthrough(),
+  original_size: import_zod3.z.object({ width: import_zod3.z.number().int(), height: import_zod3.z.number().int() }).passthrough(),
+  unzoomed_size: import_zod3.z.object({ width: import_zod3.z.number().int(), height: import_zod3.z.number().int() }).passthrough(),
+  zoom_factor_detected: import_zod3.z.number(),
+  usage: import_zod3.z.unknown().optional()
 }).passthrough();
-var UnzoomResponseSchema = import_zod2.z.object({
-  image: import_zod2.z.object({ base64: import_zod2.z.string().min(1) }).passthrough(),
-  original_size: import_zod2.z.object({ width: import_zod2.z.number().int(), height: import_zod2.z.number().int() }).passthrough(),
-  unzoomed_size: import_zod2.z.object({ width: import_zod2.z.number().int(), height: import_zod2.z.number().int() }).passthrough(),
-  zoom_factor_detected: import_zod2.z.number(),
-  usage: import_zod2.z.unknown().optional()
+var FontJobSchema = import_zod3.z.object({
+  job_id: import_zod3.z.string().min(1),
+  status: import_zod3.z.string(),
+  glyph_px: import_zod3.z.number().int().nullable().optional(),
+  download_atlas_url: import_zod3.z.string().nullable().optional(),
+  download_ttf_url: import_zod3.z.string().nullable().optional(),
+  usage: import_zod3.z.unknown().optional()
 }).passthrough();
-var FontJobSchema = import_zod2.z.object({
-  job_id: import_zod2.z.string().min(1),
-  status: import_zod2.z.string(),
-  glyph_px: import_zod2.z.number().int().nullable().optional(),
-  download_atlas_url: import_zod2.z.string().nullable().optional(),
-  download_ttf_url: import_zod2.z.string().nullable().optional(),
-  usage: import_zod2.z.unknown().optional()
+var SelectFramesSchema = import_zod3.z.object({ created_object_ids: import_zod3.z.array(import_zod3.z.string()) }).passthrough();
+var EstimateSkeletonResponseSchema = import_zod3.z.object({
+  keypoints: import_zod3.z.array(SkeletonKeypointSchema).length(18),
+  usage: import_zod3.z.unknown().optional()
 }).passthrough();
-var SelectFramesSchema = import_zod2.z.object({ created_object_ids: import_zod2.z.array(import_zod2.z.string()) }).passthrough();
-var CharacterSubmitSchema = import_zod2.z.object({
-  background_job_id: import_zod2.z.string().min(1),
-  character_id: import_zod2.z.string().min(1),
-  status: import_zod2.z.string().default("processing"),
+var CharacterSubmitSchema = import_zod3.z.object({
+  background_job_id: import_zod3.z.string().min(1),
+  character_id: import_zod3.z.string().min(1),
+  status: import_zod3.z.string().default("processing"),
   usage: UsageSchema
 }).passthrough();
-var AnimateSubmitSchema = import_zod2.z.object({
-  background_job_ids: import_zod2.z.array(import_zod2.z.string()),
-  directions: import_zod2.z.array(import_zod2.z.string()),
-  status: import_zod2.z.string().default("processing"),
+var AnimateSubmitSchema = import_zod3.z.object({
+  background_job_ids: import_zod3.z.array(import_zod3.z.string()),
+  directions: import_zod3.z.array(import_zod3.z.string()),
+  status: import_zod3.z.string().default("processing"),
   usage: UsageSchema
 }).passthrough();
-var ObjectProSubmitSchema = import_zod2.z.object({
-  object_id: import_zod2.z.string().min(1),
-  background_job_id: import_zod2.z.string().min(1),
-  status: import_zod2.z.string().default("processing"),
+var ObjectProSubmitSchema = import_zod3.z.object({
+  object_id: import_zod3.z.string().min(1),
+  background_job_id: import_zod3.z.string().min(1),
+  status: import_zod3.z.string().default("processing"),
   usage: UsageSchema
 }).passthrough();
-var DirectionSubmissionSchema = import_zod2.z.object({
-  direction: import_zod2.z.string(),
-  status: import_zod2.z.string(),
-  background_job_id: import_zod2.z.string().nullable().default(null),
-  animation_id: import_zod2.z.string().nullable().default(null)
+var DirectionSubmissionSchema = import_zod3.z.object({
+  direction: import_zod3.z.string(),
+  status: import_zod3.z.string(),
+  background_job_id: import_zod3.z.string().nullable().default(null),
+  animation_id: import_zod3.z.string().nullable().default(null)
 }).passthrough();
-var AnimateObjectSubmitSchema = import_zod2.z.object({
-  animation_group_id: import_zod2.z.string().min(1),
-  object_id: import_zod2.z.string().min(1),
-  mode: import_zod2.z.string(),
-  frame_count: import_zod2.z.number().int(),
-  display_name: import_zod2.z.string().nullable().default(null),
-  description: import_zod2.z.string().default(""),
-  submissions: import_zod2.z.array(DirectionSubmissionSchema),
+var AnimateObjectSubmitSchema = import_zod3.z.object({
+  animation_group_id: import_zod3.z.string().min(1),
+  object_id: import_zod3.z.string().min(1),
+  mode: import_zod3.z.string(),
+  frame_count: import_zod3.z.number().int(),
+  display_name: import_zod3.z.string().nullable().default(null),
+  description: import_zod3.z.string().default(""),
+  submissions: import_zod3.z.array(DirectionSubmissionSchema),
   usage: UsageSchema
 }).passthrough();
-var PortraitSubmitSchema = import_zod2.z.object({
-  background_job_id: import_zod2.z.string().min(1),
-  status: import_zod2.z.string().default("processing"),
+var PortraitSubmitSchema = import_zod3.z.object({
+  background_job_id: import_zod3.z.string().min(1),
+  status: import_zod3.z.string().default("processing"),
   usage: UsageSchema
 }).passthrough();
-var PortraitJobSchema = import_zod2.z.object({
-  status: import_zod2.z.string(),
-  download_url: import_zod2.z.string().nullable().optional(),
-  width: import_zod2.z.number().int().nullable().optional(),
-  height: import_zod2.z.number().int().nullable().optional()
+var PortraitJobSchema = import_zod3.z.object({
+  status: import_zod3.z.string(),
+  download_url: import_zod3.z.string().nullable().optional(),
+  width: import_zod3.z.number().int().nullable().optional(),
+  height: import_zod3.z.number().int().nullable().optional()
 }).passthrough();
-var SetPortraitSchema = import_zod2.z.object({
-  character_id: import_zod2.z.string().min(1),
-  size: import_zod2.z.number().int().positive(),
-  url: import_zod2.z.string().min(1),
+var SetPortraitSchema = import_zod3.z.object({
+  character_id: import_zod3.z.string().min(1),
+  size: import_zod3.z.number().int().positive(),
+  url: import_zod3.z.string().min(1),
   usage: UsageSchema
 }).passthrough();
-var TransferOutfitSubmitSchema = import_zod2.z.object({
-  background_job_id: import_zod2.z.string().min(1),
-  status: import_zod2.z.string().default("processing"),
+var TransferOutfitSubmitSchema = import_zod3.z.object({
+  background_job_id: import_zod3.z.string().min(1),
+  status: import_zod3.z.string().default("processing"),
   usage: UsageSchema
 }).passthrough();
-var CharacterAnimationDirectionSchema = import_zod2.z.object({
-  direction: import_zod2.z.string(),
-  frame_count: import_zod2.z.number().int().min(0),
-  frames: import_zod2.z.array(import_zod2.z.string())
+var CharacterAnimationDirectionSchema = import_zod3.z.object({
+  direction: import_zod3.z.string(),
+  frame_count: import_zod3.z.number().int().min(0),
+  frames: import_zod3.z.array(import_zod3.z.string())
 }).passthrough();
-var CharacterAnimationSchema2 = import_zod2.z.object({
-  animation_type: import_zod2.z.string(),
-  display_name: import_zod2.z.string().nullable().optional(),
-  animation_group_id: import_zod2.z.string().nullable().optional(),
-  directions: import_zod2.z.array(CharacterAnimationDirectionSchema)
+var CharacterAnimationSchema2 = import_zod3.z.object({
+  animation_type: import_zod3.z.string(),
+  display_name: import_zod3.z.string().nullable().optional(),
+  animation_group_id: import_zod3.z.string().nullable().optional(),
+  directions: import_zod3.z.array(CharacterAnimationDirectionSchema)
 }).passthrough();
-var CharacterSchema = import_zod2.z.object({
-  id: import_zod2.z.string().min(1),
-  name: import_zod2.z.string().default(""),
-  state_name: import_zod2.z.string().nullable().optional(),
-  prompt: import_zod2.z.string().default(""),
-  size: import_zod2.z.object({ width: import_zod2.z.number().int().positive(), height: import_zod2.z.number().int().positive() }),
-  directions: import_zod2.z.number().int(),
-  created_at: import_zod2.z.string(),
-  updated_at: import_zod2.z.string().nullable().optional(),
-  animation_count: import_zod2.z.number().int().default(0),
-  template_id: import_zod2.z.string().default("mannequin"),
-  view: import_zod2.z.string().nullable().optional(),
-  status: import_zod2.z.string().default("completed"),
-  rotation_urls: import_zod2.z.record(import_zod2.z.string().nullable()).nullable().optional(),
-  tags: import_zod2.z.array(import_zod2.z.string()).default([]),
-  group_id: import_zod2.z.string().nullable().optional(),
-  animations: import_zod2.z.array(CharacterAnimationSchema2).default([]),
-  preview_url: import_zod2.z.string().nullable().optional()
+var CharacterSchema = import_zod3.z.object({
+  id: import_zod3.z.string().min(1),
+  name: import_zod3.z.string().default(""),
+  state_name: import_zod3.z.string().nullable().optional(),
+  prompt: import_zod3.z.string().default(""),
+  size: import_zod3.z.object({ width: import_zod3.z.number().int().positive(), height: import_zod3.z.number().int().positive() }),
+  directions: import_zod3.z.number().int(),
+  created_at: import_zod3.z.string(),
+  updated_at: import_zod3.z.string().nullable().optional(),
+  animation_count: import_zod3.z.number().int().default(0),
+  template_id: import_zod3.z.string().default("mannequin"),
+  view: import_zod3.z.string().nullable().optional(),
+  status: import_zod3.z.string().default("completed"),
+  rotation_urls: import_zod3.z.record(import_zod3.z.string().nullable()).nullable().optional(),
+  tags: import_zod3.z.array(import_zod3.z.string()).default([]),
+  group_id: import_zod3.z.string().nullable().optional(),
+  animations: import_zod3.z.array(CharacterAnimationSchema2).default([]),
+  preview_url: import_zod3.z.string().nullable().optional()
 }).passthrough();
-var CharacterListSchema = import_zod2.z.object({ characters: import_zod2.z.array(CharacterSchema), total: import_zod2.z.number().int().min(0) }).passthrough();
-var BackgroundJobSchema = import_zod2.z.object({
-  id: import_zod2.z.string(),
-  status: import_zod2.z.string(),
-  last_response: import_zod2.z.record(import_zod2.z.unknown()).nullable().optional(),
+var CharacterListSchema = import_zod3.z.object({ characters: import_zod3.z.array(CharacterSchema), total: import_zod3.z.number().int().min(0) }).passthrough();
+var BackgroundJobSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  status: import_zod3.z.string(),
+  last_response: import_zod3.z.record(import_zod3.z.unknown()).nullable().optional(),
   /**
    * The billed amount, confirmed live for a `map` object and a standard
    * character base (docs/ENDPOINTS.md, "Limits and billing"); duplicated at
@@ -1864,7 +1967,7 @@ var BackgroundJobSchema = import_zod2.z.object({
    */
   usage: UsageSchema
 }).passthrough();
-var DeleteAnimationsSchema = import_zod2.z.object({ success: import_zod2.z.boolean(), deleted_count: import_zod2.z.number().int().default(0), error: import_zod2.z.string().nullable().optional() }).passthrough();
+var DeleteAnimationsSchema = import_zod3.z.object({ success: import_zod3.z.boolean(), deleted_count: import_zod3.z.number().int().default(0), error: import_zod3.z.string().nullable().optional() }).passthrough();
 function validateResponse(schema, raw, operation) {
   const parsed = schema.safeParse(raw);
   if (parsed.success) return parsed.data;
@@ -2190,7 +2293,7 @@ var PixelLabClient = class {
     const body = {
       description: args.description,
       n_directions: args.directions,
-      ...args.reference ? { first_frame: encode(args.reference) } : { image_size: { width: args.size, height: args.size } },
+      ...args.sourceImageId ? { source_image_id: args.sourceImageId } : args.reference ? { first_frame: encode(args.reference) } : { image_size: { width: args.size, height: args.size } },
       ...args.view ? { view: args.view } : {},
       ...args.seed != null ? { seed: args.seed } : {},
       ...args.styleReference && args.styleReferenceSize ? {
@@ -2337,8 +2440,9 @@ var PixelLabClient = class {
         description: args.description,
         template_id: args.template,
         n_directions: 8,
-        // The author's sprite sets the canvas; a size only applies to text creation.
-        ...south ? { first_frame: encode(south) } : { image_size: imageSize },
+        // The author's sprite sets the canvas; a size only applies to text
+        // creation. An owned copy of the same sprite is referenced by id.
+        ...args.sourceImageId ? { source_image_id: args.sourceImageId } : south ? { first_frame: encode(south) } : { image_size: imageSize },
         ...args.view ? { view: args.view } : {},
         ...args.seed != null ? { seed: args.seed } : {},
         ...args.styleReference && args.styleReferenceSize ? {
@@ -2610,6 +2714,66 @@ var PixelLabClient = class {
       "generate-image-v2"
     );
   }
+  /**
+   * `/create-image-pro-flash`: one native pixel-art image from a
+   * description, optionally styled after a style image with per-trait
+   * toggles, on the same Pro Flash model `character`/`objectPro` use for
+   * their `pro-flash` engine. Sizes run 16 to 256 per side in multiples of 4.
+   * A plain background job; `pollRevision`'s generic reader takes the
+   * finished image. The response's `source_image_id` is what a Pro Flash
+   * character or object can reuse instead of an upload.
+   */
+  async createImageProFlash(args) {
+    const body = {
+      description: args.description,
+      image_size: { width: args.width, height: args.height }
+    };
+    if (args.noBackground != null) body.no_background = args.noBackground;
+    if (args.seed != null) body.seed = args.seed;
+    if (args.styleImage) {
+      body.style_image = { image: args.styleImage.image, size: { width: args.styleImage.width, height: args.styleImage.height } };
+      const traits = args.styleTraits;
+      if (traits) {
+        body.style_options = {
+          ...traits.palette !== void 0 ? { color_palette: traits.palette } : {},
+          ...traits.outline !== void 0 ? { outline: traits.outline } : {},
+          ...traits.detail !== void 0 ? { detail: traits.detail } : {},
+          ...traits.shading !== void 0 ? { shading: traits.shading } : {}
+        };
+      }
+    }
+    return validateResponse(
+      ProFlashImageSubmitSchema,
+      await this.request("/create-image-pro-flash", { method: "POST", body: JSON.stringify(body) }),
+      "create-image-pro-flash"
+    );
+  }
+  /** `/edit-image-pro-flash`, text method: edit one image at its own size. The canvas never grows or resizes. */
+  async editImageProFlash(args) {
+    const body = { image: args.image, method: "text", description: args.description };
+    if (args.noBackground != null) body.no_background = args.noBackground;
+    if (args.seed != null) body.seed = args.seed;
+    return validateResponse(
+      ProFlashImageSubmitSchema,
+      await this.request("/edit-image-pro-flash", { method: "POST", body: JSON.stringify(body) }),
+      "edit-image-pro-flash"
+    );
+  }
+  /**
+   * `/inpaint-image-pro-flash`: replace only the white pixels of a same-size
+   * black/white mask, keeping everything else exactly. `Modify current
+   * layer` (the endpoint's default) returns the full composite.
+   */
+  async inpaintImageProFlash(args) {
+    const body = { image: args.image, mask_image: args.maskImage, description: args.description };
+    if (args.noBackground != null) body.no_background = args.noBackground;
+    if (args.seed != null) body.seed = args.seed;
+    return validateResponse(
+      ProFlashImageSubmitSchema,
+      await this.request("/inpaint-image-pro-flash", { method: "POST", body: JSON.stringify(body) }),
+      "inpaint-image-pro-flash"
+    );
+  }
   /**
    * `/generate-ui-v2` ("Generate UI (Pro)"): one UI element (a button, a
    * health bar, an inventory slot, a dialogue box) from a description,
@@ -2834,6 +2998,61 @@ var PixelLabClient = class {
       "animate-pixminimax"
     );
   }
+  /**
+   * `/animate-with-skeleton-v3`, beta (tier 1 subscription or higher): poses
+   * one reference image frame-by-frame from a supplied skeleton per frame,
+   * rather than a text motion description. Confirmed against the live
+   * `animate_with_skeleton_v3` MCP tool schema (the same authoritative
+   * source this codebase already treats as ground truth for the
+   * character/object family) — `action`/`description` are both real,
+   * optional wire fields, contrary to an initial guess that this endpoint
+   * took no text input at all; `direction`/`keypoints`/`firstFrameKeypoints`
+   * are required. The example keypoint from that same tool schema,
+   * `{"label": "RIGHT KNEE", "x": 0.52, "y": 0.71, "z_index": 9}`, is what
+   * `SkeletonKeypointSchema` (`src/skeleton.ts`) models. Same
+   * unverified-completed-shape caveat as `animateWithTextV3`/
+   * `animatePixminimax` above — this endpoint has never been called against
+   * a live account by this codebase.
+   */
+  async animateWithSkeletonV3(args) {
+    const body = {
+      first_frame: args.firstFrame,
+      first_frame_keypoints: args.firstFrameKeypoints,
+      keypoints: args.keypoints,
+      direction: args.direction
+    };
+    if (args.templateId) body.template_id = args.templateId;
+    if (args.action) body.action = args.action;
+    if (args.description) body.description = args.description;
+    if (args.seed != null) body.seed = args.seed;
+    if (args.noBackground != null) body.no_background = args.noBackground;
+    return validateResponse(
+      RevisionJobSubmitSchema,
+      await this.request("/animate-with-skeleton-v3", { method: "POST", body: JSON.stringify(body) }),
+      "animate-with-skeleton-v3"
+    );
+  }
+  /**
+   * `/estimate-skeleton`: auto-derives a reference image's own 18-joint
+   * keypoints, directly usable as `animateWithSkeletonV3`'s
+   * `firstFrameKeypoints` (or, run against a candidate pose image, as one
+   * entry of its `keypoints` sequence). Not called anywhere in this
+   * codebase's own submit/poll pipeline — deliberately kept outside it (see
+   * `runEstimateSkeleton` in `src/cli/commands`) so the only PixelLab
+   * endpoint composed into `animate-with-skeleton-v3`'s submission is that
+   * one endpoint itself, not two unverified calls chained together.
+   * Synchronous per this endpoint's own framing; unverified against a live
+   * account (see `EstimateSkeletonResponseSchema`'s own caveat).
+   */
+  async estimateSkeleton(args) {
+    const body = { image: args.image };
+    const res = validateResponse(
+      EstimateSkeletonResponseSchema,
+      await this.request("/estimate-skeleton", { method: "POST", body: JSON.stringify(body) }),
+      "estimate-skeleton"
+    );
+    return { keypoints: res.keypoints, usage: res.usage };
+  }
   async getBackgroundJob(jobId) {
     const raw = await this.request(`/background-jobs/${encodeURIComponent(jobId)}`);
     return validateResponse(BackgroundJobSchema, raw, "background-jobs/{id}");
@@ -3490,6 +3709,7 @@ function specHash(spec, styleImageHashes, providerOptionIdentity = spec.provider
       uiPieces: spec.uiPieces,
       uiElements: spec.uiElements,
       uiColorPalette: spec.uiColorPalette,
+      styleTraits: spec.styleTraits,
       styleImages: styleImageHashes,
       // A character family: the engine and rotations of a base, the parent's
       // generated bytes for a state or animation (so a regenerated parent
@@ -3566,7 +3786,11 @@ function specHash(spec, styleImageHashes, providerOptionIdentity = spec.provider
         fps: spec.revision.fps,
         lastFrameSha256: spec.revision.lastFrameSha256,
         direction: spec.revision.direction,
-        enhancePrompt: spec.revision.enhancePrompt
+        enhancePrompt: spec.revision.enhancePrompt,
+        keypointsSha256: spec.revision.keypointsSha256,
+        skeletonTemplate: spec.revision.skeletonTemplate,
+        description: spec.revision.description,
+        engine: spec.revision.engine
       } : void 0
     })
   );
@@ -3622,8 +3846,11 @@ function proFlashCharacterCost(width, height, fromReference) {
   const side = Math.max(32, Math.ceil(Math.max(width, height) / 4) * 4);
   const rotations = Math.max(1, Math.ceil(side * side * 8 / 65536));
   if (fromReference) return rotations;
-  const image = side <= 96 ? 5 : side <= 208 ? 6 : 9;
-  return image + rotations;
+  return proFlashImageCost(side, side) + rotations;
+}
+function proFlashImageCost(width, height) {
+  const side = Math.max(width, height);
+  return side <= 96 ? 5 : side <= 208 ? 6 : 9;
 }
 function characterAnimationName(spec) {
   return `pixelkiln:${spec.styleId}/${spec.assetId}`;
@@ -3651,6 +3878,18 @@ function objectProCost(spec) {
   const south = object.reference;
   return south ? proFlashObjectCost(south.width, south.height, object.directions, true) : proFlashObjectCost(spec.width, spec.height, object.directions, false);
 }
+function animateSkeletonCost(frames) {
+  const anchors = [[3, 2], [8, 3], [15, 4]];
+  for (let i = 0; i < anchors.length - 1; i++) {
+    const [lowFrames, lowCost] = anchors[i];
+    const [highFrames, highCost] = anchors[i + 1];
+    if (frames >= lowFrames && frames <= highFrames) {
+      const t = (frames - lowFrames) / (highFrames - lowFrames);
+      return lowCost + t * (highCost - lowCost);
+    }
+  }
+  return frames <= anchors[0][0] ? anchors[0][1] : anchors[anchors.length - 1][1];
+}
 var CHARACTER_TEMPLATES = ["mannequin", "bear", "cat", "dog", "horse", "lion"];
 var PRO_FLASH_TEMPLATES = [...CHARACTER_TEMPLATES, "custom"];
 function encodeAnimationJob(job) {
@@ -3699,7 +3938,7 @@ var PixelLabProvider = class _PixelLabProvider {
     return new _PixelLabProvider(new PixelLabClient("download-only"));
   }
   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";
+    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";
   }
   /**
    * `inpaint` (`/inpaint-v3`, a mask) and `image-to-image` (`/edit-images-v2`,
@@ -3709,7 +3948,9 @@ var PixelLabProvider = class _PixelLabProvider {
    * rather than a described edit — and `animate`/`animate-pixminimax`
    * (`/animate-with-text-v3`, `/animate-pixminimax`), which animate any loose
    * image from a text description with no character/object resource
-   * required — and `interpolate` (`/interpolation-v2`, the in-betweens
+   * required — `animate-skeleton` (`/animate-with-skeleton-v3`, posing the
+   * source from a supplied per-frame skeleton instead of a text description)
+   * — and `interpolate` (`/interpolation-v2`, the in-betweens
    * from one keyframe to another) and `edit-animation`
    * (`/edit-animation-v2`, one text edit applied across a whole frame set).
    * `outpaint` does not: there is no canvas-expansion endpoint in the API,
@@ -3717,7 +3958,7 @@ var PixelLabProvider = class _PixelLabProvider {
    * outpaint path yet.
    */
   supportsRevision(mode2) {
-    return mode2 === "inpaint" || mode2 === "image-to-image" || mode2 === "reduce-colors" || mode2 === "correct-pixelart" || mode2 === "animate" || mode2 === "animate-pixminimax" || mode2 === "interpolate" || mode2 === "edit-animation";
+    return mode2 === "inpaint" || mode2 === "image-to-image" || mode2 === "reduce-colors" || mode2 === "correct-pixelart" || mode2 === "animate" || mode2 === "animate-pixminimax" || mode2 === "animate-skeleton" || mode2 === "interpolate" || mode2 === "edit-animation";
   }
   /** PixelLab's own constraints: submissions must be >2s apart, and
    *  background jobs in flight are capped by subscription tier (Tier 1=8,
@@ -3748,6 +3989,10 @@ var PixelLabProvider = class _PixelLabProvider {
     if (spec.revision?.mode === "reduce-colors" || spec.revision?.mode === "correct-pixelart") {
       return { unit: "generations", amount: 0.1, candidates: 1 };
     }
+    if (spec.revision?.mode === "animate-skeleton") {
+      const frames = spec.revision.frames ?? 8;
+      return { unit: "generations", amount: Math.ceil(animateSkeletonCost(frames)), candidates: 1 };
+    }
     if (spec.revision?.mode === "interpolate" || spec.revision?.mode === "edit-animation") {
       const width = spec.revision.sourceWidth ?? spec.width;
       const height = spec.revision.sourceHeight ?? spec.height;
@@ -3761,6 +4006,13 @@ var PixelLabProvider = class _PixelLabProvider {
       const base = Math.max(1, Math.ceil(width * height * frames / 65536));
       return { unit: "generations", amount: spec.revision.enhancePrompt ? base + 0.05 : base, candidates: 1 };
     }
+    if (spec.revision?.engine === "pro-flash") {
+      return {
+        unit: "generations",
+        amount: proFlashImageCost(spec.revision.sourceWidth ?? spec.width, spec.revision.sourceHeight ?? spec.height),
+        candidates: 1
+      };
+    }
     if (spec.revision) {
       const width = spec.revision.sourceWidth ?? spec.width;
       const height = spec.revision.sourceHeight ?? spec.height;
@@ -3775,6 +4027,9 @@ var PixelLabProvider = class _PixelLabProvider {
     if (spec.generator === "objectPro") {
       return { unit: "generations", amount: objectProCost(spec), candidates: 1 };
     }
+    if (spec.generator === "imageProFlash") {
+      return { unit: "generations", amount: proFlashImageCost(spec.width, spec.height), candidates: 1 };
+    }
     return {
       unit: "generations",
       amount: generationCost(spec.width, spec.height, spec.generator),
@@ -3788,7 +4043,17 @@ var PixelLabProvider = class _PixelLabProvider {
         `PixelLab ${spec.revision.mode} reads one source image; ${spec.revision.sourceAssetId} is a ${members.length}-member set (${members[0].role}, ...). Revise one member through a declared source, or use reduce-colors, correct-pixelart, or edit-animation, which take the whole set`
       );
     }
-    if (spec.revision?.mode === "inpaint") {
+    if (spec.revision?.engine === "pro-flash") {
+      const { sourceWidth: width, sourceHeight: height, mode: mode2 } = spec.revision;
+      if (width != null && height != null && (width < 32 || height < 32 || width > 256 || height > 256 || width % 4 || height % 4)) {
+        throw new Error(
+          `PixelLab pro-flash ${mode2} source is ${width}x${height}; the API takes 32 to 256 pixels per side, in multiples of 4`
+        );
+      }
+      if (spec.revision.strength != null) {
+        throw new Error(`PixelLab pro-flash ${mode2} takes no strength; the edit applies in full`);
+      }
+    } else if (spec.revision?.mode === "inpaint") {
       const { sourceWidth: width, sourceHeight: height } = spec.revision;
       if (width != null && height != null && (width < 32 || height < 32 || width > 512 || height > 512)) {
         throw new Error(`PixelLab inpaint source is ${width}x${height}; the API takes 32 to 512 pixels per side`);
@@ -3809,6 +4074,18 @@ var PixelLabProvider = class _PixelLabProvider {
         throw new Error(`PixelLab correct-pixelart source is ${width}x${height}; the API takes at most 1024 pixels per side`);
       }
     }
+    if (spec.revision?.mode === "animate-skeleton") {
+      const { sourceWidth: width, sourceHeight: height, frames, skeletonTemplate } = spec.revision;
+      if (width != null && height != null && (width > 256 || height > 256)) {
+        throw new Error(`PixelLab animate-skeleton source is ${width}x${height}; the API takes at most 256 pixels per side`);
+      }
+      if (frames != null && (frames < 3 || frames > 15)) {
+        throw new Error(`PixelLab animate-skeleton takes 3 to 15 frames; the keypoints file has ${frames}`);
+      }
+      if (skeletonTemplate && !CHARACTER_TEMPLATES.includes(skeletonTemplate)) {
+        throw new Error(`PixelLab animate-skeleton template "${skeletonTemplate}" is not one of ${CHARACTER_TEMPLATES.join(", ")}`);
+      }
+    }
     if (spec.revision?.mode === "animate" || spec.revision?.mode === "animate-pixminimax") {
       const { sourceWidth: width, sourceHeight: height, mode: mode2, frames, lastFrameWidth, lastFrameHeight } = spec.revision;
       if (width != null && height != null && (width > 256 || height > 256)) {
@@ -3869,6 +4146,19 @@ var PixelLabProvider = class _PixelLabProvider {
         `PixelLab uiAsset is ${spec.width}x${spec.height}; the API takes 192 to 688 pixels per side (the exact ceiling also depends on aspect ratio \u2014 square tops out at 512, 16:9 at 688x384, 9:16 at 384x688, 4:3 at 600x448, 3:4 at 448x600)`
       );
     }
+    if (spec.generator === "imageProFlash") {
+      if (spec.width < 16 || spec.height < 16 || spec.width > 256 || spec.height > 256 || spec.width % 4 || spec.height % 4) {
+        throw new Error(
+          `PixelLab imageProFlash is ${spec.width}x${spec.height}; the API takes 16 to 256 pixels per side, in multiples of 4`
+        );
+      }
+      if (styleImages.length > 1) {
+        throw new Error("PixelLab imageProFlash takes one style image; list at most one styleImages entry");
+      }
+      if (spec.styleTraits && !styleImages.length) {
+        throw new Error("PixelLab imageProFlash: styleTraits choose what a style image lends; add a styleImages entry or drop them");
+      }
+    }
     if (spec.generator === "uiElement" && (spec.width < 16 || spec.height < 16 || spec.width > 792 || spec.height > 688)) {
       throw new Error(
         `PixelLab uiElement is ${spec.width}x${spec.height}; the API takes 16 to 792 wide and 16 to 688 tall (the exact ceiling depends on aspect ratio \u2014 square tops out at 512, 16:9 at 688x384)`
@@ -4222,7 +4512,8 @@ var PixelLabProvider = class _PixelLabProvider {
         concept: character.concept ? readPose(spec, "concept image", character.concept) : void 0,
         styleCharacterId: character.styleAnchor ? requireStyleObjectId(spec, context) : void 0,
         styleReferenceSize: styleImage ? { width: styleImage.width, height: styleImage.height } : void 0,
-        styleTraits: character.styleTraits
+        styleTraits: character.styleTraits,
+        sourceImageId: character.mode === "pro-flash" ? context?.referenceSourceImageId : void 0
       });
       return { jobId: res2.character_id, metadata: { character: { kind: "base", characterId: res2.character_id, mode: character.mode, directions: character.directions, backgroundJobId: res2.background_job_id } } };
     }
@@ -4357,7 +4648,8 @@ var PixelLabProvider = class _PixelLabProvider {
         reference: object.reference ? readPose(spec, "reference sprite", object.reference) : void 0,
         styleReference: styleImage ? { base64: styleImage.base64, format: styleImage.format } : void 0,
         styleReferenceSize: styleImage ? { width: styleImage.width, height: styleImage.height } : void 0,
-        styleTraits: object.styleTraits
+        styleTraits: object.styleTraits,
+        sourceImageId: context?.referenceSourceImageId
       });
       return { jobId: res2.object_id, metadata: { objectPro: { kind: "base", objectId: res2.object_id, directions: object.directions, backgroundJobId: res2.background_job_id } } };
     }
@@ -4656,6 +4948,19 @@ var PixelLabProvider = class _PixelLabProvider {
       });
       return { jobId: res2.ui_asset_id, metadata: { backgroundJobId: res2.background_job_id } };
     }
+    if (spec.generator === "imageProFlash") {
+      const style = styleImages[0];
+      const res2 = await this.client.createImageProFlash({
+        description: spec.prompt,
+        width: spec.width,
+        height: spec.height,
+        noBackground: spec.noBackground,
+        seed: spec.seed,
+        styleImage: style ? { image: { base64: style.base64, format: style.format }, width: style.width, height: style.height } : void 0,
+        styleTraits: spec.styleTraits
+      });
+      return { jobId: res2.background_job_id, metadata: { imageProFlash: proFlashRecord(res2) } };
+    }
     if (spec.generator === "uiElement") {
       const concept = styleImages[0];
       const res2 = await this.client.generateUiV2({
@@ -4809,6 +5114,32 @@ var PixelLabProvider = class _PixelLabProvider {
     const width = revision.sourceWidth;
     const height = revision.sourceHeight;
     const roles = revision.sourceMembers?.map((member) => member.role);
+    if (revision.engine === "pro-flash") {
+      if (revision.mode === "inpaint") {
+        if (!revision.maskFile || !revision.maskSha256 || !revision.maskFormat) {
+          throw new Error(`${spec.styleId}/${spec.assetId}: revision mask is not ready`);
+        }
+        const maskBytes = (0, import_node_fs2.readFileSync)(revision.maskFile);
+        if (sha256(maskBytes) !== revision.maskSha256) {
+          throw new Error(`${spec.styleId}/${spec.assetId}: revision mask changed after the manifest was resolved`);
+        }
+        const res3 = await this.client.inpaintImageProFlash({
+          image,
+          maskImage: { base64: maskBytes.toString("base64"), format: revision.maskFormat },
+          description: spec.prompt,
+          noBackground: spec.noBackground,
+          seed: spec.seed
+        });
+        return { jobId: res3.background_job_id, metadata: { imageProFlash: proFlashRecord(res3) } };
+      }
+      const res2 = await this.client.editImageProFlash({
+        image,
+        description: spec.prompt,
+        noBackground: spec.noBackground,
+        seed: spec.seed
+      });
+      return { jobId: res2.background_job_id, metadata: { imageProFlash: proFlashRecord(res2) } };
+    }
     if (revision.mode === "inpaint") {
       if (!revision.maskFile || !revision.maskSha256 || !revision.maskFormat) {
         throw new Error(`${spec.styleId}/${spec.assetId}: revision mask is not ready`);
@@ -4904,6 +5235,27 @@ var PixelLabProvider = class _PixelLabProvider {
       });
       return { jobId: res2.background_job_id };
     }
+    if (revision.mode === "animate-skeleton") {
+      if (!revision.keypointsFile || !revision.keypointsSha256 || !revision.skeleton) {
+        throw new Error(`${spec.styleId}/${spec.assetId}: revision keypoints are not ready`);
+      }
+      const keypointsBytes = (0, import_node_fs2.readFileSync)(revision.keypointsFile);
+      if (sha256(keypointsBytes) !== revision.keypointsSha256) {
+        throw new Error(`${spec.styleId}/${spec.assetId}: revision keypoints changed after the manifest was resolved`);
+      }
+      const res2 = await this.client.animateWithSkeletonV3({
+        firstFrame: image,
+        firstFrameKeypoints: revision.skeleton.firstFrameKeypoints,
+        keypoints: revision.skeleton.frames,
+        direction: revision.direction,
+        templateId: revision.skeletonTemplate,
+        action: spec.prompt,
+        description: revision.description,
+        seed: spec.seed,
+        noBackground: spec.noBackground
+      });
+      return { jobId: res2.background_job_id };
+    }
     if (revision.strength != null) {
       throw new Error(
         `${spec.styleId}/${spec.assetId}: PixelLab image-to-image revisions take no strength; edit-images-v2 always applies the full instruction`
@@ -4969,10 +5321,11 @@ 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);
+    if (generator === "imageProFlash") return this.pollRevision(jobId);
     if (generator === "pixflux") {
       const file = import_node_path.default.join(_PixelLabProvider.cacheDir(), `${jobId}.png`);
       if ((0, import_node_fs2.existsSync)(file)) {
@@ -5553,6 +5906,13 @@ function readPose(spec, what, image) {
   }
   return { base64: bytes.toString("base64"), format: image.format };
 }
+function proFlashRecord(res) {
+  return {
+    imageId: res.image_id,
+    sourceImageId: res.source_image_id,
+    ...res.estimated_generations != null ? { estimatedGenerations: res.estimated_generations } : {}
+  };
+}
 function editAnimationFrameCeiling(width, height) {
   const side = Math.max(width, height);
   if (side <= 64) return 16;
@@ -6696,11 +7056,12 @@ var ComfyUIProvider = class _ComfyUIProvider {
   /**
    * Everything else resolves generically to whatever the user's own
    * workflow does with `bindings.sourceImage`. The frame-set modes
-   * (`animate`, `animate-pixminimax`, `interpolate`, `edit-animation`) are
-   * the exception: they produce an ordered frame set, and this adapter's
-   * revision path always writes a single output image (see `submit`/`fetch`
-   * below) — a real structural gap, not a missing binding, so they are
-   * rejected here rather than only failing once `validate` runs.
+   * (`animate`, `animate-pixminimax`, `animate-skeleton`, `interpolate`,
+   * `edit-animation`) are the exception: they produce an ordered frame set,
+   * and this adapter's revision path always writes a single output image
+   * (see `submit`/`fetch` below) — a real structural gap, not a missing
+   * binding, so they are rejected here rather than only failing once
+   * `validate` runs.
    */
   supportsRevision(mode2) {
     return !FRAME_SET_REVISION_MODES.includes(mode2);
@@ -6756,6 +7117,11 @@ var ComfyUIProvider = class _ComfyUIProvider {
       throw new Error("ComfyUI providerOptions.frames requires generator: frames");
     }
     if (spec.revision) {
+      if (spec.revision.engine) {
+        throw new Error(
+          `ComfyUI has no "${spec.revision.engine}" revision engine; that selects PixelLab's Pro Flash edit/inpaint endpoints. Drop engine to run the revision through this style's own workflow.`
+        );
+      }
       if (spec.revision.sourceMembers) {
         throw new Error(
           `ComfyUI revisions read one source image; ${spec.revision.sourceAssetId} is a ${spec.revision.sourceMembers.length}-member set (directions or frames)`
@@ -8353,6 +8719,7 @@ async function resolveSpecs(loaded, filter) {
         uiPieces: generator === "uiAsset" ? asset.pieces : void 0,
         uiElements: generator === "uiAsset" ? asset.elements : void 0,
         uiColorPalette: generator === "uiAsset" || generator === "uiElement" ? style.uiColorPalette : void 0,
+        ...generator === "imageProFlash" && style.styleTraits ? { styleTraits: style.styleTraits } : {},
         palette: style.palette,
         enforcePalette: style.enforcePalette,
         noBackground: style.noBackground,
@@ -8597,6 +8964,8 @@ async function resolveSpecs(loaded, filter) {
         const paletteImage = paletteImageFile ? await optionalRevisionImage(paletteImageFile, "revision palette image", "png") : null;
         const lastFrameFile = asset.revision.lastFrame ? import_node_path5.default.resolve(root, asset.revision.lastFrame) : void 0;
         const lastFrame = lastFrameFile ? await optionalRevisionImage(lastFrameFile, "revision last frame") : null;
+        const keypointsFile = asset.revision.keypointsFile ? import_node_path5.default.resolve(root, asset.revision.keypointsFile) : void 0;
+        const keypoints = keypointsFile ? await optionalSkeletonSet(keypointsFile) : null;
         resolved.revision = {
           mode: asset.revision.mode,
           sourceAssetId: asset.revision.from,
@@ -8636,7 +9005,20 @@ async function resolveSpecs(loaded, filter) {
             lastFrameFormat: lastFrame?.format ?? null
           } : {},
           ...asset.revision.direction ? { direction: asset.revision.direction } : {},
-          ...asset.revision.enhancePrompt == null ? {} : { enhancePrompt: asset.revision.enhancePrompt }
+          ...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 } : {}
         };
       }
       if (asset.batch) {
@@ -8757,6 +9139,17 @@ async function optionalRevisionImage(file, label, requiredFormat) {
   }
   return { hash: sha256(bytes), ...metadata };
 }
+async function optionalSkeletonSet(file) {
+  if (!(0, import_node_fs5.existsSync)(file)) return null;
+  const bytes = await (0, import_promises3.readFile)(file);
+  let json;
+  try {
+    json = JSON.parse(bytes.toString("utf8"));
+  } catch (error) {
+    throw new Error(`revision keypoints file ${file} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  return { hash: sha256(bytes), skeleton: parseSkeletonSet(json, file) };
+}
 async function revisionSourceMembers(stem, label) {
   if ((0, import_node_fs5.existsSync)(stem)) return null;
   const at = (role) => memberPath(stem, role, 0, 2, MediaType.PNG);
@@ -10879,47 +11272,47 @@ var import_node_path14 = __toESM(require("path"), 1);
 var import_node_fs10 = require("fs");
 var import_promises7 = require("fs/promises");
 var import_node_url = require("url");
-var import_zod3 = require("zod");
+var import_zod4 = require("zod");
 var SHA256_RE = /^[0-9a-f]{64}$/;
 var RECIPE_ID_RE = /^[a-z0-9][a-z0-9-]*\/[a-z0-9][a-z0-9-]*$/;
 var VERSION_RE = /^\d+\.\d+\.\d+$/;
 var RECIPE_FILE = "pixelkiln.recipe.json";
 var RECIPE_DIR_TOKEN = "{{recipeDir}}";
-var PortablePathSchema = import_zod3.z.string().min(1).refine((value) => {
+var PortablePathSchema = import_zod4.z.string().min(1).refine((value) => {
   if (value.includes("\\") || import_node_path14.default.posix.isAbsolute(value)) return false;
   const parts = value.split("/");
   return !parts.includes("") && !parts.includes(".") && !parts.includes("..");
 }, "expected a portable relative path without '.', '..', or backslashes");
-var RecipeBindingSchema = import_zod3.z.object({
-  nodeId: import_zod3.z.string().min(1),
-  input: import_zod3.z.string().min(1)
+var RecipeBindingSchema = import_zod4.z.object({
+  nodeId: import_zod4.z.string().min(1),
+  input: import_zod4.z.string().min(1)
 }).strict();
-var RecipeSchema = import_zod3.z.object({
-  $schema: import_zod3.z.string().url().optional(),
-  format: import_zod3.z.literal("pixelkiln-recipe"),
-  schemaVersion: import_zod3.z.literal(1),
-  id: import_zod3.z.string().regex(RECIPE_ID_RE, "expected provider/name"),
-  version: import_zod3.z.string().regex(VERSION_RE, "expected x.y.z"),
-  provider: import_zod3.z.string().regex(/^[a-z0-9][a-z0-9-]*$/),
-  summary: import_zod3.z.string().min(1).max(240),
-  files: import_zod3.z.array(import_zod3.z.object({
+var RecipeSchema = import_zod4.z.object({
+  $schema: import_zod4.z.string().url().optional(),
+  format: import_zod4.z.literal("pixelkiln-recipe"),
+  schemaVersion: import_zod4.z.literal(1),
+  id: import_zod4.z.string().regex(RECIPE_ID_RE, "expected provider/name"),
+  version: import_zod4.z.string().regex(VERSION_RE, "expected x.y.z"),
+  provider: import_zod4.z.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  summary: import_zod4.z.string().min(1).max(240),
+  files: import_zod4.z.array(import_zod4.z.object({
     path: PortablePathSchema,
-    role: import_zod3.z.enum(["workflow", "reference"]),
-    sha256: import_zod3.z.string().regex(SHA256_RE)
+    role: import_zod4.z.enum(["workflow", "reference"]),
+    sha256: import_zod4.z.string().regex(SHA256_RE)
   }).strict()).default([]),
-  models: import_zod3.z.array(import_zod3.z.object({
+  models: import_zod4.z.array(import_zod4.z.object({
     path: PortablePathSchema,
-    sha256: import_zod3.z.string().regex(SHA256_RE),
-    source: import_zod3.z.string().url(),
-    license: import_zod3.z.string().min(1)
+    sha256: import_zod4.z.string().regex(SHA256_RE),
+    source: import_zod4.z.string().url(),
+    license: import_zod4.z.string().min(1)
   }).strict()).default([]),
-  styleId: import_zod3.z.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  styleId: import_zod4.z.string().regex(/^[a-z0-9][a-z0-9-]*$/),
   style: StyleSchema,
-  workflow: import_zod3.z.object({
+  workflow: import_zod4.z.object({
     path: PortablePathSchema,
-    outputNodeId: import_zod3.z.string().min(1),
-    numImages: import_zod3.z.number().int().min(1).max(16),
-    bindings: import_zod3.z.object({
+    outputNodeId: import_zod4.z.string().min(1),
+    numImages: import_zod4.z.number().int().min(1).max(16),
+    bindings: import_zod4.z.object({
       prompt: RecipeBindingSchema,
       width: RecipeBindingSchema.optional(),
       height: RecipeBindingSchema.optional(),
@@ -10930,67 +11323,67 @@ var RecipeSchema = import_zod3.z.object({
       strength: RecipeBindingSchema.optional()
     }).strict()
   }).strict().optional(),
-  quality: import_zod3.z.object({
-    stage: import_zod3.z.enum(["composition-source", "production-candidate"]),
-    workingCanvas: import_zod3.z.object({
-      width: import_zod3.z.number().int().min(16),
-      height: import_zod3.z.number().int().min(16)
+  quality: import_zod4.z.object({
+    stage: import_zod4.z.enum(["composition-source", "production-candidate"]),
+    workingCanvas: import_zod4.z.object({
+      width: import_zod4.z.number().int().min(16),
+      height: import_zod4.z.number().int().min(16)
     }).strict(),
-    recommendedNativeSize: import_zod3.z.object({
-      min: import_zod3.z.number().int().min(1),
-      max: import_zod3.z.number().int().min(1)
+    recommendedNativeSize: import_zod4.z.object({
+      min: import_zod4.z.number().int().min(1),
+      max: import_zod4.z.number().int().min(1)
     }).strict(),
-    paletteColors: import_zod3.z.object({
-      min: import_zod3.z.number().int().min(1),
-      max: import_zod3.z.number().int().min(1)
+    paletteColors: import_zod4.z.object({
+      min: import_zod4.z.number().int().min(1),
+      max: import_zod4.z.number().int().min(1)
     }).strict(),
-    background: import_zod3.z.enum(["opaque", "transparent", "full-bleed"]),
-    checks: import_zod3.z.array(import_zod3.z.enum([
+    background: import_zod4.z.enum(["opaque", "transparent", "full-bleed"]),
+    checks: import_zod4.z.array(import_zod4.z.enum([
       "prompt-coverage",
       "native-grid",
       "final-palette",
       "alpha-edge",
       "human-1x"
     ])).min(1),
-    notes: import_zod3.z.array(import_zod3.z.string().min(1)).default([])
+    notes: import_zod4.z.array(import_zod4.z.string().min(1)).default([])
   }).strict(),
-  integrity: import_zod3.z.object({
-    algorithm: import_zod3.z.literal("sha256"),
-    digest: import_zod3.z.string().regex(SHA256_RE)
+  integrity: import_zod4.z.object({
+    algorithm: import_zod4.z.literal("sha256"),
+    digest: import_zod4.z.string().regex(SHA256_RE)
   }).strict()
 }).strict().superRefine((recipe, context) => {
   if (recipe.style.provider && recipe.style.provider !== recipe.provider) {
     context.addIssue({
-      code: import_zod3.z.ZodIssueCode.custom,
+      code: import_zod4.z.ZodIssueCode.custom,
       path: ["style", "provider"],
       message: "must match the recipe provider"
     });
   }
   const filePaths = recipe.files.map((file) => file.path);
   if (new Set(filePaths).size !== filePaths.length) {
-    context.addIssue({ code: import_zod3.z.ZodIssueCode.custom, path: ["files"], message: "duplicate file path" });
+    context.addIssue({ code: import_zod4.z.ZodIssueCode.custom, path: ["files"], message: "duplicate file path" });
   }
   const modelPaths = recipe.models.map((model) => model.path);
   if (new Set(modelPaths).size !== modelPaths.length) {
-    context.addIssue({ code: import_zod3.z.ZodIssueCode.custom, path: ["models"], message: "duplicate model path" });
+    context.addIssue({ code: import_zod4.z.ZodIssueCode.custom, path: ["models"], message: "duplicate model path" });
   }
   if (filePaths.includes(RECIPE_FILE)) {
     context.addIssue({
-      code: import_zod3.z.ZodIssueCode.custom,
+      code: import_zod4.z.ZodIssueCode.custom,
       path: ["files"],
       message: `${RECIPE_FILE} cannot hash itself`
     });
   }
   if (recipe.quality.recommendedNativeSize.min > recipe.quality.recommendedNativeSize.max) {
     context.addIssue({
-      code: import_zod3.z.ZodIssueCode.custom,
+      code: import_zod4.z.ZodIssueCode.custom,
       path: ["quality", "recommendedNativeSize"],
       message: "min cannot exceed max"
     });
   }
   if (recipe.quality.paletteColors.min > recipe.quality.paletteColors.max) {
     context.addIssue({
-      code: import_zod3.z.ZodIssueCode.custom,
+      code: import_zod4.z.ZodIssueCode.custom,
       path: ["quality", "paletteColors"],
       message: "min cannot exceed max"
     });
@@ -10999,7 +11392,7 @@ var RecipeSchema = import_zod3.z.object({
     (file) => file.path === recipe.workflow.path && file.role === "workflow"
   )) {
     context.addIssue({
-      code: import_zod3.z.ZodIssueCode.custom,
+      code: import_zod4.z.ZodIssueCode.custom,
       path: ["workflow", "path"],
       message: "must name a file whose role is workflow"
     });
@@ -11007,7 +11400,7 @@ var RecipeSchema = import_zod3.z.object({
   if (recipe.provider === "comfyui") {
     if (!recipe.workflow) {
       context.addIssue({
-        code: import_zod3.z.ZodIssueCode.custom,
+        code: import_zod4.z.ZodIssueCode.custom,
         path: ["workflow"],
         message: "ComfyUI recipes require workflow metadata"
       });
@@ -11016,7 +11409,7 @@ var RecipeSchema = import_zod3.z.object({
     const options = recipe.style.providerOptions.comfyui;
     if (!options || typeof options !== "object" || Array.isArray(options)) {
       context.addIssue({
-        code: import_zod3.z.ZodIssueCode.custom,
+        code: import_zod4.z.ZodIssueCode.custom,
         path: ["style", "providerOptions", "comfyui"],
         message: "ComfyUI recipes require ComfyUI provider options"
       });
@@ -11030,7 +11423,7 @@ var RecipeSchema = import_zod3.z.object({
     };
     if (JSON.stringify(canonical3(options)) !== JSON.stringify(canonical3(expected))) {
       context.addIssue({
-        code: import_zod3.z.ZodIssueCode.custom,
+        code: import_zod4.z.ZodIssueCode.custom,
         path: ["style", "providerOptions", "comfyui"],
         message: "must match workflow metadata and use {{recipeDir}} for workflowFile"
       });
@@ -11468,11 +11861,11 @@ async function generateFont(client2, opts) {
 var import_node_path17 = __toESM(require("path"), 1);
 var import_node_fs13 = require("fs");
 var import_promises10 = require("fs/promises");
-var import_zod4 = require("zod");
+var import_zod5 = require("zod");
 var SHA256_RE2 = /^[0-9a-f]{64}$/;
 var HEX_RE = /^#[0-9a-f]{6}$/;
 var MAX_REDMEAN_DISTANCE = 765;
-var QualityPathSchema = import_zod4.z.string().min(1).refine(
+var QualityPathSchema = import_zod5.z.string().min(1).refine(
   (value) => !import_node_path17.default.posix.isAbsolute(value) && !value.includes("\\"),
   "expected a portable relative path"
 );
@@ -11486,53 +11879,53 @@ var DEFAULT_QUALITY_TOLERANCES = {
   maxEdgeContrastDrop: 0.03,
   maxIsolatedPixelIncrease: 5e-3
 };
-var QualityToleranceSchema = import_zod4.z.object({
-  requireExactHash: import_zod4.z.boolean(),
-  maxColorCountIncrease: import_zod4.z.number().int().min(0),
-  maxNewColors: import_zod4.z.number().int().min(0),
-  maxTransparencyDelta: import_zod4.z.number().min(0).max(1),
-  maxPartialAlphaIncrease: import_zod4.z.number().min(0).max(1),
-  maxEdgeDensityDelta: import_zod4.z.number().min(0).max(1),
-  maxEdgeContrastDrop: import_zod4.z.number().min(0).max(1),
-  maxIsolatedPixelIncrease: import_zod4.z.number().min(0).max(1)
+var QualityToleranceSchema = import_zod5.z.object({
+  requireExactHash: import_zod5.z.boolean(),
+  maxColorCountIncrease: import_zod5.z.number().int().min(0),
+  maxNewColors: import_zod5.z.number().int().min(0),
+  maxTransparencyDelta: import_zod5.z.number().min(0).max(1),
+  maxPartialAlphaIncrease: import_zod5.z.number().min(0).max(1),
+  maxEdgeDensityDelta: import_zod5.z.number().min(0).max(1),
+  maxEdgeContrastDrop: import_zod5.z.number().min(0).max(1),
+  maxIsolatedPixelIncrease: import_zod5.z.number().min(0).max(1)
 }).strict();
-var ImageQualityMetricsSchema = import_zod4.z.object({
-  sha256: import_zod4.z.string().regex(SHA256_RE2),
-  width: import_zod4.z.number().int().min(1),
-  height: import_zod4.z.number().int().min(1),
-  colorCount: import_zod4.z.number().int().min(0),
-  colors: import_zod4.z.array(import_zod4.z.string().regex(HEX_RE)),
-  transparency: import_zod4.z.number().min(0).max(1),
-  partialAlpha: import_zod4.z.number().min(0).max(1),
-  edgeDensity: import_zod4.z.number().min(0).max(1),
-  meanEdgeContrast: import_zod4.z.number().min(0).max(1),
-  isolatedPixelRatio: import_zod4.z.number().min(0).max(1)
+var ImageQualityMetricsSchema = import_zod5.z.object({
+  sha256: import_zod5.z.string().regex(SHA256_RE2),
+  width: import_zod5.z.number().int().min(1),
+  height: import_zod5.z.number().int().min(1),
+  colorCount: import_zod5.z.number().int().min(0),
+  colors: import_zod5.z.array(import_zod5.z.string().regex(HEX_RE)),
+  transparency: import_zod5.z.number().min(0).max(1),
+  partialAlpha: import_zod5.z.number().min(0).max(1),
+  edgeDensity: import_zod5.z.number().min(0).max(1),
+  meanEdgeContrast: import_zod5.z.number().min(0).max(1),
+  isolatedPixelRatio: import_zod5.z.number().min(0).max(1)
 }).strict();
-var QualityBaselineCaseSchema = import_zod4.z.object({
-  id: import_zod4.z.string().regex(/^[a-z0-9][a-z0-9/_-]*$/),
+var QualityBaselineCaseSchema = import_zod5.z.object({
+  id: import_zod5.z.string().regex(/^[a-z0-9][a-z0-9/_-]*$/),
   file: QualityPathSchema,
-  record: import_zod4.z.object({
+  record: import_zod5.z.object({
     path: QualityPathSchema,
-    sha256: import_zod4.z.string().regex(SHA256_RE2)
+    sha256: import_zod5.z.string().regex(SHA256_RE2)
   }).strict().optional(),
   expected: ImageQualityMetricsSchema,
   tolerances: QualityToleranceSchema
 }).strict();
-var QualityBaselineSchema = import_zod4.z.object({
-  $schema: import_zod4.z.string().url().optional(),
-  format: import_zod4.z.literal("pixelkiln-quality-baseline"),
-  schemaVersion: import_zod4.z.literal(1),
-  cases: import_zod4.z.array(QualityBaselineCaseSchema).min(1)
+var QualityBaselineSchema = import_zod5.z.object({
+  $schema: import_zod5.z.string().url().optional(),
+  format: import_zod5.z.literal("pixelkiln-quality-baseline"),
+  schemaVersion: import_zod5.z.literal(1),
+  cases: import_zod5.z.array(QualityBaselineCaseSchema).min(1)
 }).strict().superRefine((baseline, context) => {
   const ids = baseline.cases.map((entry) => entry.id);
   if (new Set(ids).size !== ids.length) {
-    context.addIssue({ code: import_zod4.z.ZodIssueCode.custom, path: ["cases"], message: "duplicate case id" });
+    context.addIssue({ code: import_zod5.z.ZodIssueCode.custom, path: ["cases"], message: "duplicate case id" });
   }
 });
-var QualityInputSchema = import_zod4.z.object({
-  id: import_zod4.z.string().regex(/^[a-z0-9][a-z0-9/_-]*$/),
-  path: import_zod4.z.string().min(1),
-  record: import_zod4.z.string().min(1).optional(),
+var QualityInputSchema = import_zod5.z.object({
+  id: import_zod5.z.string().regex(/^[a-z0-9][a-z0-9/_-]*$/),
+  path: import_zod5.z.string().min(1),
+  record: import_zod5.z.string().min(1).optional(),
   tolerances: QualityToleranceSchema.partial().optional()
 }).strict();
 function message4(error) {
@@ -11634,7 +12027,7 @@ async function measureImageQuality(file) {
   }
 }
 function resolveQualityInputs(raw, inputsFilePath) {
-  const parsed = import_zod4.z.array(QualityInputSchema).min(1).safeParse(raw);
+  const parsed = import_zod5.z.array(QualityInputSchema).min(1).safeParse(raw);
   if (!parsed.success) {
     throw new Error(
       "--inputs must be a non-empty JSON array of quality cases:\n" + parsed.error.issues.map((issue) => `  ${issue.path.join(".") || "$"}: ${issue.message}`).join("\n")
@@ -11857,11 +12250,11 @@ var import_node_path21 = __toESM(require("path"), 1);
 var import_promises11 = require("fs/promises");
 var import_node_fs14 = require("fs");
 var import_node_path18 = __toESM(require("path"), 1);
-var import_zod5 = require("zod");
-var HashCacheSchema = import_zod5.z.object({
-  version: import_zod5.z.literal(1),
+var import_zod6 = require("zod");
+var HashCacheSchema = import_zod6.z.object({
+  version: import_zod6.z.literal(1),
   /** objectId → sha256 of that object's image bytes. */
-  hashes: import_zod5.z.record(import_zod5.z.string())
+  hashes: import_zod6.z.record(import_zod6.z.string())
 });
 var SHA256_HEX = /^[a-f0-9]{64}$/;
 function isSha256Hash(value) {
@@ -13408,7 +13801,11 @@ async function submit(provider, loaded, items, lock, lockPath, opts = {}) {
         ...spec.revision.fps == null ? {} : { fps: spec.revision.fps },
         ...spec.revision.lastFrameSha256 ? { lastFrameSha256: spec.revision.lastFrameSha256 } : {},
         ...spec.revision.direction ? { direction: spec.revision.direction } : {},
-        ...spec.revision.enhancePrompt == null ? {} : { enhancePrompt: spec.revision.enhancePrompt }
+        ...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 ? {
         sourceAssetId: spec.character.parentAssetId,
@@ -13452,8 +13849,10 @@ async function submit(provider, loaded, items, lock, lockPath, opts = {}) {
         path: currentEntryOutputPath(parentEntry, spec.character.parentSpec, index),
         role: output.role
       })) : void 0;
+      const referenceSourceImageId = ownedReferenceImageId(spec, lock, provider.id);
       const { jobId, metadata } = await provider.submit(spec, refs, {
         ...previousJobId ? { previousJobId } : {},
+        ...referenceSourceImageId ? { referenceSourceImageId } : {},
         ...parentEntry?.objectId ? { parentObjectId: parentEntry.objectId } : {},
         ...anchorEntry?.objectId ? { styleObjectId: anchorEntry.objectId } : {},
         ...parentOutputs ? { parentOutputs } : {},
@@ -13520,6 +13919,17 @@ async function submit(provider, loaded, items, lock, lockPath, opts = {}) {
   }
   return { submitted, failed, spent, unit };
 }
+function ownedReferenceImageId(spec, lock, providerId) {
+  const sha2562 = spec.character?.kind === "base" && spec.character.mode === "pro-flash" ? spec.character.reference?.south?.sha256 : spec.objectPro?.kind === "base" ? spec.objectPro.reference?.sha256 : void 0;
+  if (!sha2562) return void 0;
+  for (const entry of Object.values(lock.entries)) {
+    if (entry.provider !== providerId || entry.generator !== "imageProFlash" || entry.status !== "downloaded") continue;
+    if (entry.outputs.length !== 1 || entry.outputs[0].sha256 !== sha2562) continue;
+    const recorded = entry.providerMetadata?.[providerId]?.imageProFlash;
+    if (typeof recorded?.sourceImageId === "string" && recorded.sourceImageId) return recorded.sourceImageId;
+  }
+  return void 0;
+}
 
 // src/pipeline/poll.ts
 var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
@@ -14692,20 +15102,20 @@ var import_node_path30 = __toESM(require("path"), 1);
 var import_promises19 = require("fs/promises");
 var import_node_fs23 = require("fs");
 var import_node_path26 = __toESM(require("path"), 1);
-var import_zod6 = require("zod");
-var WorkspaceProjectSchema = import_zod6.z.object({
-  id: import_zod6.z.string().min(1),
+var import_zod7 = require("zod");
+var WorkspaceProjectSchema = import_zod7.z.object({
+  id: import_zod7.z.string().min(1),
   /** Manifest path, relative to the catalog file's own directory. */
-  manifest: import_zod6.z.string().min(1),
+  manifest: import_zod7.z.string().min(1),
   /** Lockfile path, relative to the catalog file's own directory. */
-  lock: import_zod6.z.string().min(1),
-  provider: import_zod6.z.string().min(1).default("pixellab"),
+  lock: import_zod7.z.string().min(1),
+  provider: import_zod7.z.string().min(1).default("pixellab"),
   /** Free-form label for a shared account, e.g. distinguishing sandboxes. */
-  account: import_zod6.z.string().optional()
+  account: import_zod7.z.string().optional()
 }).strict();
-var WorkspaceSchema = import_zod6.z.object({
-  version: import_zod6.z.literal(1),
-  projects: import_zod6.z.array(WorkspaceProjectSchema).default([])
+var WorkspaceSchema = import_zod7.z.object({
+  version: import_zod7.z.literal(1),
+  projects: import_zod7.z.array(WorkspaceProjectSchema).default([])
 }).strict();
 function parseWorkspace(raw) {
   const parsed = WorkspaceSchema.safeParse(raw);
@@ -14823,62 +15233,62 @@ function validateWorkspace(ws, dir) {
 
 // src/gallery/edit.ts
 var import_node_path29 = __toESM(require("path"), 1);
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 
 // src/manifest-edit.ts
 var import_promises20 = require("fs/promises");
 var import_node_path27 = __toESM(require("path"), 1);
-var import_zod7 = require("zod");
-var HexSha = import_zod7.z.string().regex(/^[0-9a-f]{64}$/);
-var AssetPatchSchema = import_zod7.z.object({
-  prompt: import_zod7.z.string().optional(),
+var import_zod8 = require("zod");
+var HexSha = import_zod8.z.string().regex(/^[0-9a-f]{64}$/);
+var AssetPatchSchema = import_zod8.z.object({
+  prompt: import_zod8.z.string().optional(),
   /** Per-style override for the style being viewed; null removes it. */
-  promptForStyle: import_zod7.z.object({ styleId: import_zod7.z.string().min(1), prompt: import_zod7.z.string().nullable() }).optional(),
-  category: import_zod7.z.string().nullable().optional(),
-  width: import_zod7.z.number().int().nullable().optional(),
-  height: import_zod7.z.number().int().nullable().optional(),
-  size: import_zod7.z.number().int().nullable().optional(),
-  tags: import_zod7.z.array(import_zod7.z.string()).optional()
+  promptForStyle: import_zod8.z.object({ styleId: import_zod8.z.string().min(1), prompt: import_zod8.z.string().nullable() }).optional(),
+  category: import_zod8.z.string().nullable().optional(),
+  width: import_zod8.z.number().int().nullable().optional(),
+  height: import_zod8.z.number().int().nullable().optional(),
+  size: import_zod8.z.number().int().nullable().optional(),
+  tags: import_zod8.z.array(import_zod8.z.string()).optional()
 }).strict();
-var NewStateSchema = import_zod7.z.object({
+var NewStateSchema = import_zod8.z.object({
   /** Asset id of the parent this states; must already exist. */
-  of: import_zod7.z.string().min(1),
-  paletteFromReference: import_zod7.z.boolean().optional(),
-  canvas: import_zod7.z.object({ width: import_zod7.z.number().int().min(16).max(256), height: import_zod7.z.number().int().min(16).max(256) }).strict().optional()
+  of: import_zod8.z.string().min(1),
+  paletteFromReference: import_zod8.z.boolean().optional(),
+  canvas: import_zod8.z.object({ width: import_zod8.z.number().int().min(16).max(256), height: import_zod8.z.number().int().min(16).max(256) }).strict().optional()
 }).strict();
-var NewAnimationSchema = import_zod7.z.object({
+var NewAnimationSchema = import_zod8.z.object({
   /** Asset id of the parent this animates; must already exist. */
-  of: import_zod7.z.string().min(1),
+  of: import_zod8.z.string().min(1),
   /** A PixelLab template id (`character` only; `objectPro` has no template concept). */
-  template: import_zod7.z.string().min(1).optional(),
+  template: import_zod8.z.string().min(1).optional(),
   direction: CharacterDirectionSchema.optional(),
-  frames: import_zod7.z.number().int().min(4).max(16).optional(),
-  fps: import_zod7.z.number().int().min(1).max(60).optional(),
+  frames: import_zod8.z.number().int().min(4).max(16).optional(),
+  fps: import_zod8.z.number().int().min(1).max(60).optional(),
   mode: CharacterAnimationModeSchema.optional(),
   /** What is being animated, when the parent's own description would mislead the model (`character` only). */
-  subject: import_zod7.z.string().min(1).optional(),
-  enhancePrompt: import_zod7.z.boolean().optional()
+  subject: import_zod8.z.string().min(1).optional(),
+  enhancePrompt: import_zod8.z.boolean().optional()
 }).strict();
-var NewAssetSchema = import_zod7.z.object({
-  prompt: import_zod7.z.string(),
-  category: import_zod7.z.string().optional(),
-  width: import_zod7.z.number().int().optional(),
-  height: import_zod7.z.number().int().optional(),
-  size: import_zod7.z.number().int().optional(),
-  tags: import_zod7.z.array(import_zod7.z.string()).optional(),
+var NewAssetSchema = import_zod8.z.object({
+  prompt: import_zod8.z.string(),
+  category: import_zod8.z.string().optional(),
+  width: import_zod8.z.number().int().optional(),
+  height: import_zod8.z.number().int().optional(),
+  size: import_zod8.z.number().int().optional(),
+  tags: import_zod8.z.array(import_zod8.z.string()).optional(),
   /** Restrict to these styles; empty or omitted means every style. */
-  styles: import_zod7.z.array(import_zod7.z.string().min(1)).optional(),
+  styles: import_zod8.z.array(import_zod8.z.string().min(1)).optional(),
   /**
    * A controlled regeneration of another asset in the same manifest,
    * instead of a fresh generation. `inpaint` needs a mask upload the
    * gallery does not offer yet, so only `image-to-image` can be created
    * here; hand-edit the manifest for the other modes.
    */
-  revision: import_zod7.z.object({
-    mode: import_zod7.z.literal("image-to-image"),
+  revision: import_zod8.z.object({
+    mode: import_zod8.z.literal("image-to-image"),
     /** Asset id of the parent this revises; must already exist. */
-    from: import_zod7.z.string().min(1),
-    strength: import_zod7.z.number().min(0).max(1).optional()
+    from: import_zod8.z.string().min(1),
+    strength: import_zod8.z.number().min(0).max(1).optional()
   }).strict().optional(),
   /** A pose or outfit of an existing `character`/`objectPro` base or state. */
   state: NewStateSchema.optional(),
@@ -14894,58 +15304,58 @@ var CANDIDATE_OPTION = {
   comfyui: "numImages",
   scenario: "numOutputs"
 };
-var ManifestEditSchema = import_zod7.z.discriminatedUnion("action", [
-  import_zod7.z.object({
-    action: import_zod7.z.literal("patch-asset"),
+var ManifestEditSchema = import_zod8.z.discriminatedUnion("action", [
+  import_zod8.z.object({
+    action: import_zod8.z.literal("patch-asset"),
     /** Workspace project id; omitted for a single-project gallery. */
-    project: import_zod7.z.string().min(1).optional(),
-    assetId: import_zod7.z.string().min(1),
+    project: import_zod8.z.string().min(1).optional(),
+    assetId: import_zod8.z.string().min(1),
     /** Manifest bytes the page last saw; a mismatch refuses the write. */
     expectedSha256: HexSha,
     patch: AssetPatchSchema
   }).strict(),
-  import_zod7.z.object({
-    action: import_zod7.z.literal("add-asset"),
-    project: import_zod7.z.string().min(1).optional(),
-    assetId: import_zod7.z.string().min(1).regex(/^[^/\\]+$/, "asset ids cannot contain slashes"),
+  import_zod8.z.object({
+    action: import_zod8.z.literal("add-asset"),
+    project: import_zod8.z.string().min(1).optional(),
+    assetId: import_zod8.z.string().min(1).regex(/^[^/\\]+$/, "asset ids cannot contain slashes"),
     expectedSha256: HexSha,
     asset: NewAssetSchema
   }).strict(),
-  import_zod7.z.object({
-    action: import_zod7.z.literal("set-source"),
-    project: import_zod7.z.string().min(1).optional(),
-    assetId: import_zod7.z.string().min(1),
-    styleId: import_zod7.z.string().min(1),
+  import_zod8.z.object({
+    action: import_zod8.z.literal("set-source"),
+    project: import_zod8.z.string().min(1).optional(),
+    assetId: import_zod8.z.string().min(1),
+    styleId: import_zod8.z.string().min(1),
     /** Manifest-relative path of the art that stands in for this asset in this style. */
-    source: import_zod7.z.string().min(1),
+    source: import_zod8.z.string().min(1),
     expectedSha256: HexSha
   }).strict(),
-  import_zod7.z.object({
-    action: import_zod7.z.literal("clear-source"),
-    project: import_zod7.z.string().min(1).optional(),
-    assetId: import_zod7.z.string().min(1),
-    styleId: import_zod7.z.string().min(1),
+  import_zod8.z.object({
+    action: import_zod8.z.literal("clear-source"),
+    project: import_zod8.z.string().min(1).optional(),
+    assetId: import_zod8.z.string().min(1),
+    styleId: import_zod8.z.string().min(1),
     expectedSha256: HexSha
   }).strict(),
-  import_zod7.z.object({
-    action: import_zod7.z.literal("patch-style"),
-    project: import_zod7.z.string().min(1).optional(),
-    styleId: import_zod7.z.string().min(1),
+  import_zod8.z.object({
+    action: import_zod8.z.literal("patch-style"),
+    project: import_zod8.z.string().min(1).optional(),
+    styleId: import_zod8.z.string().min(1),
     expectedSha256: HexSha,
-    patch: import_zod7.z.object({
+    patch: import_zod8.z.object({
       /** Candidates per generation, written to the provider's own option. */
-      candidates: import_zod7.z.number().int().min(1).max(64).optional(),
+      candidates: import_zod8.z.number().int().min(1).max(64).optional(),
       /** Empty clears the style's own value (inherit, or the default). */
-      promptPrefix: import_zod7.z.string().optional(),
-      promptSuffix: import_zod7.z.string().optional(),
+      promptPrefix: import_zod8.z.string().optional(),
+      promptSuffix: import_zod8.z.string().optional(),
       /** `#rrggbb` values; null or empty clears the style's own palette. */
-      palette: import_zod7.z.array(import_zod7.z.string().regex(/^#?[0-9a-f]{6}$/i, "expected a six-digit hex colour")).max(256).nullable().optional(),
+      palette: import_zod8.z.array(import_zod8.z.string().regex(/^#?[0-9a-f]{6}$/i, "expected a six-digit hex colour")).max(256).nullable().optional(),
       /** Snap downloaded art to the palette; false clears the style's own value. */
-      enforcePalette: import_zod7.z.boolean().optional(),
+      enforcePalette: import_zod8.z.boolean().optional(),
       /** Provider view name (PixelLab: low top-down, high top-down, side); empty clears. */
-      view: import_zod7.z.string().max(64).nullable().optional(),
+      view: import_zod8.z.string().max(64).nullable().optional(),
       /** pixflux only; null clears the style's own value. */
-      noBackground: import_zod7.z.boolean().nullable().optional()
+      noBackground: import_zod8.z.boolean().nullable().optional()
     }).strict().refine((patch) => Object.keys(patch).length > 0, { message: "nothing to change" })
   }).strict()
 ]);
@@ -15139,7 +15549,7 @@ async function applyManifestEdit(manifestPath, edit) {
 var import_node_fs24 = require("fs");
 var import_promises21 = require("fs/promises");
 var import_node_path28 = __toESM(require("path"), 1);
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 var HAND_EDIT_DIR = "edits";
 function handEditPath(loaded, spec) {
   const style = loaded.manifest.styles[spec.styleId];
@@ -15236,35 +15646,35 @@ async function detachHandEdit(loaded, spec, opts = {}) {
   });
   return { manifestSha256: result.sha256, changed: result.changed };
 }
-var CompanionOutputSchema = import_zod8.z.object({
+var CompanionOutputSchema = import_zod9.z.object({
   /** Output role for a set member; null for a single image. */
-  role: import_zod8.z.string().nullable(),
+  role: import_zod9.z.string().nullable(),
   /** sha256 of the generated file this member started from; null when it started from untracked art. */
-  basedOn: import_zod8.z.string().regex(/^[0-9a-f]{64}$/).nullable(),
+  basedOn: import_zod9.z.string().regex(/^[0-9a-f]{64}$/).nullable(),
   /** sha256 of the member as saved, so a later change by another tool is visible. */
-  sha256: import_zod8.z.string().regex(/^[0-9a-f]{64}$/)
+  sha256: import_zod9.z.string().regex(/^[0-9a-f]{64}$/)
 }).strict();
-var CompanionV2Schema = import_zod8.z.object({
-  version: import_zod8.z.literal(2),
+var CompanionV2Schema = import_zod9.z.object({
+  version: import_zod9.z.literal(2),
   /** Editor identity the bridge reported, e.g. `pixelorama@v1.2.2-stable`. */
-  editor: import_zod8.z.string().min(1),
-  protocol: import_zod8.z.number().int().positive(),
-  savedAt: import_zod8.z.string().datetime(),
+  editor: import_zod9.z.string().min(1),
+  protocol: import_zod9.z.number().int().positive(),
+  savedAt: import_zod9.z.string().datetime(),
   /** Basename of the layered project file beside the edit, when one was kept. */
-  project: import_zod8.z.string().min(1).nullable(),
+  project: import_zod9.z.string().min(1).nullable(),
   /** One entry per file, in output order. */
-  outputs: import_zod8.z.array(CompanionOutputSchema).min(1)
+  outputs: import_zod9.z.array(CompanionOutputSchema).min(1)
 }).strict();
-var CompanionV1Schema = import_zod8.z.object({
-  version: import_zod8.z.literal(1),
-  basedOn: import_zod8.z.string().regex(/^[0-9a-f]{64}$/).nullable(),
-  sha256: import_zod8.z.string().regex(/^[0-9a-f]{64}$/),
-  editor: import_zod8.z.string().min(1),
-  protocol: import_zod8.z.number().int().positive(),
-  savedAt: import_zod8.z.string().datetime(),
-  project: import_zod8.z.string().min(1).nullable()
+var CompanionV1Schema = import_zod9.z.object({
+  version: import_zod9.z.literal(1),
+  basedOn: import_zod9.z.string().regex(/^[0-9a-f]{64}$/).nullable(),
+  sha256: import_zod9.z.string().regex(/^[0-9a-f]{64}$/),
+  editor: import_zod9.z.string().min(1),
+  protocol: import_zod9.z.number().int().positive(),
+  savedAt: import_zod9.z.string().datetime(),
+  project: import_zod9.z.string().min(1).nullable()
 }).strict();
-var HandEditCompanionSchema = import_zod8.z.union([CompanionV2Schema, CompanionV1Schema]).transform(
+var HandEditCompanionSchema = import_zod9.z.union([CompanionV2Schema, CompanionV1Schema]).transform(
   (value) => value.version === 2 ? value : {
     version: 2,
     editor: value.editor,
@@ -15384,40 +15794,40 @@ function openInEditor(file, editor = process.env.PIXELKILN_EDITOR) {
 }
 
 // src/gallery/edit.ts
-var Base64 = import_zod9.z.string().regex(/^[A-Za-z0-9+/]*={0,2}$/).max(Math.ceil(MAX_HAND_EDIT_BYTES / 3) * 4);
-var HandEditRequestSchema = import_zod9.z.discriminatedUnion("action", [
-  import_zod9.z.object({
-    action: import_zod9.z.literal("start-edit"),
-    project: import_zod9.z.string().min(1).optional(),
-    assetId: import_zod9.z.string().min(1),
-    styleId: import_zod9.z.string().min(1),
-    expectedSha256: import_zod9.z.string().regex(/^[0-9a-f]{64}$/),
+var Base64 = import_zod10.z.string().regex(/^[A-Za-z0-9+/]*={0,2}$/).max(Math.ceil(MAX_HAND_EDIT_BYTES / 3) * 4);
+var HandEditRequestSchema = import_zod10.z.discriminatedUnion("action", [
+  import_zod10.z.object({
+    action: import_zod10.z.literal("start-edit"),
+    project: import_zod10.z.string().min(1).optional(),
+    assetId: import_zod10.z.string().min(1),
+    styleId: import_zod10.z.string().min(1),
+    expectedSha256: import_zod10.z.string().regex(/^[0-9a-f]{64}$/),
     /** Also launch the author's editor on the file. */
-    open: import_zod9.z.boolean().optional()
+    open: import_zod10.z.boolean().optional()
   }).strict(),
-  import_zod9.z.object({
-    action: import_zod9.z.literal("detach-edit"),
-    project: import_zod9.z.string().min(1).optional(),
-    assetId: import_zod9.z.string().min(1),
-    styleId: import_zod9.z.string().min(1),
-    expectedSha256: import_zod9.z.string().regex(/^[0-9a-f]{64}$/)
+  import_zod10.z.object({
+    action: import_zod10.z.literal("detach-edit"),
+    project: import_zod10.z.string().min(1).optional(),
+    assetId: import_zod10.z.string().min(1),
+    styleId: import_zod10.z.string().min(1),
+    expectedSha256: import_zod10.z.string().regex(/^[0-9a-f]{64}$/)
   }).strict(),
   /** From the in-browser editor: the page holds the bytes, the server validates and writes. */
-  import_zod9.z.object({
-    action: import_zod9.z.literal("save-edit"),
-    project: import_zod9.z.string().min(1).optional(),
-    assetId: import_zod9.z.string().min(1),
-    styleId: import_zod9.z.string().min(1),
-    expectedSha256: import_zod9.z.string().regex(/^[0-9a-f]{64}$/),
+  import_zod10.z.object({
+    action: import_zod10.z.literal("save-edit"),
+    project: import_zod10.z.string().min(1).optional(),
+    assetId: import_zod10.z.string().min(1),
+    styleId: import_zod10.z.string().min(1),
+    expectedSha256: import_zod10.z.string().regex(/^[0-9a-f]{64}$/),
     /** The flattened image; for a frame set, `frames` instead. */
     png: Base64.min(1).optional(),
     /** Every frame of a set, tagged with the role it was opened under (null for one added in the editor). */
-    frames: import_zod9.z.array(import_zod9.z.object({ role: import_zod9.z.string().min(1).nullable(), png: Base64.min(1) }).strict()).min(1).max(256).optional(),
+    frames: import_zod10.z.array(import_zod10.z.object({ role: import_zod10.z.string().min(1).nullable(), png: Base64.min(1) }).strict()).min(1).max(256).optional(),
     /** The editor's layered project file, kept beside the edit. */
     pxo: Base64.optional(),
     /** Editor identity from the bridge's ready message. */
-    editor: import_zod9.z.string().min(1).max(200),
-    protocol: import_zod9.z.number().int().positive()
+    editor: import_zod10.z.string().min(1).max(200),
+    protocol: import_zod10.z.number().int().positive()
   }).strict()
 ]);
 function createGalleryEditHandler(opts) {
@@ -16751,27 +17161,27 @@ async function serveGallery(opts) {
 
 // src/gallery/generate.ts
 var import_node_crypto9 = require("crypto");
-var import_zod10 = require("zod");
-var GenerateRequestSchema = import_zod10.z.object({
-  project: import_zod10.z.string().min(1).optional(),
-  keys: import_zod10.z.array(import_zod10.z.string().min(1)).min(1).max(500),
+var import_zod11 = require("zod");
+var GenerateRequestSchema = import_zod11.z.object({
+  project: import_zod11.z.string().min(1).optional(),
+  keys: import_zod11.z.array(import_zod11.z.string().min(1)).min(1).max(500),
   /**
    * Regenerate work that is up to date, as `gen --force` does, and let the
    * fetch replace a locally modified or untracked file. With `restore`, put
    * the recorded bytes back over a modified file.
    */
-  force: import_zod10.z.boolean().optional(),
+  force: import_zod11.z.boolean().optional(),
   /** Advance in-flight, review, or selected work without submitting anything. */
-  resume: import_zod10.z.boolean().optional(),
+  resume: import_zod11.z.boolean().optional(),
   /** Re-download downloaded outputs and replace files whose object changed upstream. */
-  refresh: import_zod10.z.boolean().optional(),
+  refresh: import_zod11.z.boolean().optional(),
   /** Put recorded outputs back on disk from the cache or the provider, without generating. */
-  restore: import_zod10.z.boolean().optional(),
+  restore: import_zod11.z.boolean().optional(),
   /**
    * Bring a replaced generation back: 1-based position in the record's
    * history (newest first) or an output hash prefix. One key at a time.
    */
-  revert: import_zod10.z.string().min(1).max(64).optional()
+  revert: import_zod11.z.string().min(1).max(64).optional()
 }).strict().refine((request) => [request.resume, request.refresh, request.restore, request.revert !== void 0].filter(Boolean).length <= 1, {
   message: "resume, refresh, restore, and revert are exclusive"
 }).refine((request) => request.revert === void 0 || request.keys.length === 1, { message: "revert takes one key" });