pixelkiln 0.61.0 → 0.62.0

package/dist/cli.js

@@ -67,8 +67,8 @@ function exitCodeFor(err) {
 }
 
 // src/cli/main.ts
-import { existsSync as existsSync32 } from "fs";
-import { readFile as readFile29 } from "fs/promises";
+import { existsSync as existsSync33 } from "fs";
+import { readFile as readFile30 } from "fs/promises";
 
 // src/cli/args.ts
 import path from "path";
@@ -103,7 +103,11 @@ var VALUE_FLAGS = [
   "--reviewer",
   "--note",
   "--model-root",
-  "--generation"
+  "--generation",
+  "--quantize",
+  "--description",
+  "--weight",
+  "--glyph-px"
 ];
 var BOOL_FLAGS = [
   "--force",
@@ -153,6 +157,8 @@ var COMMANDS = [
   "refine",
   "recipe",
   "workspace",
+  "unzoom",
+  "font",
   "help",
   "--help",
   "-h",
@@ -406,7 +412,11 @@ function parseArgs(argv) {
     workspace: get("--workspace"),
     target,
     provider: get("--provider"),
-    account: get("--account")
+    account: get("--account"),
+    quantize: numberOption("--quantize", { min: -1, max: 256, integer: true }),
+    description: get("--description"),
+    weight: get("--weight"),
+    glyphPx: numberOption("--glyph-px", { min: 8, max: 64, integer: true })
   };
 }
 
@@ -461,6 +471,10 @@ Commands
             verified against pinned hashes. Offline once installed.
   workspace Register sibling projects and derive account-wide claims/status.
             add/remove/list/status/claims. Offline.
+  unzoom    PixelLab: shrink an upscaled image (--from) back to its native
+            pixel grid before using it as a style or reference image.
+  font      PixelLab: generate a pixel font (--description, --out); writes a
+            .ttf and a glyph atlas PNG. 25 generations; asks first.
 
 Options
   --columns <n>       pack/export: sprites or tiles per row (default: near-square)
@@ -482,6 +496,10 @@ Options
   --note <text>       refine approve: optional review note
   --model-root <dir>  recipe verify: also hash required local model files
   --generation <n|hash>  restore: the previous generation to bring back (1 = newest)
+  --quantize <n>      unzoom: 0 auto palette (default), -1 keep all colors, 2-256 exact
+  --description <text>  font: the style to draw, e.g. "warm orange arcade font"
+  --weight <w>        font: Bold or Regular (default)
+  --glyph-px <n>      font: native glyph size, 8, 16 (default), 32, or 64
   --prune             cache: remove invalid/unreferenced local cache data
   --manifest <path>   Default: pixelkiln.manifest.json
   --lock <path>       Default: pixelkiln.lock.json beside the manifest
@@ -537,6 +555,8 @@ Examples
   pixelkiln recipe verify pixelkiln-recipes/comfyui/pixel-art-xl-environment/1.0.0 --model-root /path/to/ComfyUI/models
   pixelkiln quality snapshot --inputs quality-inputs.json --out pixelkiln.quality.json
   pixelkiln quality check --from pixelkiln.quality.json
+  pixelkiln unzoom --from refs/knight-512.png --out refs/knight.png
+  pixelkiln font --description "warm orange arcade font" --weight Bold --out fonts/arcade
   pixelkiln workspace add ../other-game/pixelkiln.manifest.json
   pixelkiln workspace status --json
   pixelkiln salvage --workspace pixelkiln.workspace.json
@@ -618,10 +638,10 @@ import { createReadStream } from "fs";
 function sha256(data) {
   return createHash("sha256").update(data).digest("hex");
 }
-async function sha256File(path45) {
+async function sha256File(path47) {
   return new Promise((resolve, reject) => {
     const hash = createHash("sha256");
-    const stream = createReadStream(path45);
+    const stream = createReadStream(path47);
     stream.on("data", (chunk2) => hash.update(chunk2));
     stream.on("error", reject);
     stream.on("end", () => resolve(hash.digest("hex")));
@@ -649,7 +669,7 @@ function specHash(spec, styleImageHashes, providerOptionIdentity = spec.provider
       // tile fields are undefined for every other generator. `tileSize` is
       // intentionally absent; width/height are derived from it, so it is
       // already covered.
-      noBackground: spec.generator === "pixflux" || spec.generator === "uiAsset" || spec.provider !== "pixellab" ? spec.noBackground : void 0,
+      noBackground: spec.generator === "pixflux" || spec.generator === "uiAsset" || spec.generator === "uiElement" || spec.provider !== "pixellab" ? spec.noBackground : void 0,
       tileType: spec.tileType,
       tileView: spec.tileView,
       tileFeature: spec.tileFeature,
@@ -744,7 +764,7 @@ import path2 from "path";
 // src/types.ts
 import { z } from "zod";
 var MediaTypeSchema = z.enum(["image/png", "image/gif"]);
-var GeneratorSchema = z.enum(["1dir", "map", "pixflux", "tiles", "animation", "frames", "character", "terrain", "imagePro", "isometricTile", "objectPro", "uiAsset"]);
+var GeneratorSchema = z.enum(["1dir", "map", "pixflux", "tiles", "animation", "frames", "character", "terrain", "imagePro", "isometricTile", "objectPro", "uiAsset", "uiElement"]);
 var GridConfidenceSchema = z.enum(["low", "medium", "high"]);
 var RevisionModeSchema = z.enum([
   "image-to-image",
@@ -753,7 +773,9 @@ var RevisionModeSchema = z.enum([
   "reduce-colors",
   "correct-pixelart",
   "animate",
-  "animate-pixminimax"
+  "animate-pixminimax",
+  "interpolate",
+  "edit-animation"
 ]);
 function tileVariationCount(descriptions) {
   return Math.max(1, descriptions) * 4;
@@ -1022,9 +1044,13 @@ var RevisionSchema = z.object({
    * the provider layer, since it differs by mode).
    */
   frames: z.number().int().min(4).max(40).optional(),
-  /** `animate`/`animate-pixminimax` only: playback rate recorded with the frames; PixelLab does not store one. */
+  /** `animate`/`animate-pixminimax`/`interpolate`/`edit-animation` only: playback rate recorded with the frames; PixelLab does not store one. */
   fps: z.number().int().min(1).max(60).optional(),
-  /** `animate`/`animate-pixminimax` only: manifest-relative image pinning where the motion ends (interpolation instead of open-ended animation). */
+  /**
+   * `animate`/`animate-pixminimax`: manifest-relative image pinning where
+   * the motion ends (interpolation instead of open-ended animation).
+   * `interpolate`: required, the ending keyframe; the parent is the start.
+   */
   lastFrame: z.string().min(1).optional(),
   /** `animate-pixminimax` only: facing direction, used only alongside `enhancePrompt` to hold the sprite's facing. */
   direction: CharacterDirectionSchema.optional(),
@@ -1068,14 +1094,15 @@ var RevisionSchema = z.object({
       path: ["strength"]
     });
   }
-  if (revision.strength !== void 0 && (revision.mode === "animate" || revision.mode === "animate-pixminimax")) {
+  const generative = revision.mode === "animate" || revision.mode === "animate-pixminimax" || revision.mode === "interpolate" || revision.mode === "edit-animation";
+  if (revision.strength !== void 0 && generative) {
     context.addIssue({
       code: z.ZodIssueCode.custom,
-      message: `${revision.mode} revisions do not take a strength; use enhancePrompt`,
+      message: revision.mode === "animate" || revision.mode === "animate-pixminimax" ? `${revision.mode} revisions do not take a strength; use enhancePrompt` : `${revision.mode} revisions do not take a strength`,
       path: ["strength"]
     });
   }
-  for (const field of ["frames", "fps", "lastFrame", "enhancePrompt"]) {
+  for (const field of ["frames", "enhancePrompt"]) {
     if (revision[field] !== void 0 && revision.mode !== "animate" && revision.mode !== "animate-pixminimax") {
       context.addIssue({
         code: z.ZodIssueCode.custom,
@@ -1084,6 +1111,27 @@ var RevisionSchema = z.object({
       });
     }
   }
+  if (revision.lastFrame !== void 0 && revision.mode !== "animate" && revision.mode !== "animate-pixminimax" && revision.mode !== "interpolate") {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "lastFrame applies to animate/animate-pixminimax/interpolate revisions only",
+      path: ["lastFrame"]
+    });
+  }
+  if (revision.mode === "interpolate" && revision.lastFrame === void 0) {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "interpolate revisions require lastFrame: the ending keyframe to interpolate toward",
+      path: ["lastFrame"]
+    });
+  }
+  if (revision.fps !== void 0 && !generative) {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "fps applies to animate/animate-pixminimax/interpolate/edit-animation revisions only",
+      path: ["fps"]
+    });
+  }
   if (revision.direction !== void 0 && revision.mode !== "animate-pixminimax") {
     context.addIssue({
       code: z.ZodIssueCode.custom,
@@ -1095,6 +1143,8 @@ var RevisionSchema = z.object({
     context.addIssue({ code: z.ZodIssueCode.custom, message: "frames must be even", path: ["frames"] });
   }
 });
+var FRAME_SET_REVISION_MODES = ["animate", "animate-pixminimax", "interpolate", "edit-animation"];
+var MEMBER_SET_REVISION_MODES = ["reduce-colors", "correct-pixelart", "edit-animation"];
 var StyleObjectSchema = z.object({
   /** Generation backend for this style. Omit to inherit the manifest default. */
   provider: z.string().min(1).optional(),
@@ -1213,7 +1263,7 @@ var StyleObjectSchema = z.object({
    */
   terrainMode: z.enum(["standard", "pro"]).optional(),
   /**
-   * `uiAsset` generator only. A natural-language palette hint sent as-is
+   * `uiAsset` and `uiElement` generators only. A natural-language palette hint sent as-is
    * (e.g. "brown and gold"), distinct from `palette`'s hex-color array —
    * this is a prompt-level steer, not a local quantization target.
    */
@@ -4087,11 +4137,16 @@ async function inspectRevision(spec, lock, seen) {
       reason: `revision source ${spec.styleId}/${revision.sourceAssetId} is not ready: ${dependency.reason}`
     };
   }
-  if (!revision.sourceSha256 || !existsSync4(revision.sourceFile)) {
-    return { ready: false, reason: `revision source is missing: ${revision.sourceFile}` };
-  }
-  if (await sha256File(revision.sourceFile) !== revision.sourceSha256) {
-    return { ready: false, reason: "revision source changed after the manifest was resolved" };
+  if (revision.sourceMembers) {
+    const members = await inspectSourceMembers(spec, lock);
+    if (!members.ready) return members;
+  } else {
+    if (!revision.sourceSha256 || !existsSync4(revision.sourceFile)) {
+      return { ready: false, reason: `revision source is missing: ${revision.sourceFile}` };
+    }
+    if (await sha256File(revision.sourceFile) !== revision.sourceSha256) {
+      return { ready: false, reason: "revision source changed after the manifest was resolved" };
+    }
   }
   if (revision.maskFile) {
     if (!revision.maskSha256 || !existsSync4(revision.maskFile)) {
@@ -4101,8 +4156,39 @@ async function inspectRevision(spec, lock, seen) {
       return { ready: false, reason: "revision mask changed after the manifest was resolved" };
     }
   }
+  if (revision.lastFrameFile) {
+    if (!revision.lastFrameSha256 || !existsSync4(revision.lastFrameFile)) {
+      return { ready: false, reason: `revision last frame is missing: ${revision.lastFrameFile}` };
+    }
+    if (await sha256File(revision.lastFrameFile) !== revision.lastFrameSha256) {
+      return { ready: false, reason: "revision last frame changed after the manifest was resolved" };
+    }
+  }
   return { ready: true, reason: "revision inputs are current" };
 }
+async function inspectSourceMembers(spec, lock) {
+  const revision = spec.revision;
+  const members = revision.sourceMembers;
+  for (const member of members) {
+    if (!existsSync4(member.file)) return { ready: false, reason: `revision source member is missing: ${member.file}` };
+    if (await sha256File(member.file) !== member.sha256) {
+      return { ready: false, reason: `revision source member changed after the manifest was resolved: ${member.file}` };
+    }
+  }
+  const parent = revision.sourceSpec;
+  if (parent.source) return { ready: true, reason: "declared source set is present" };
+  const entry = lock.entries[lockKey(parent.styleId, parent.assetId)];
+  if (!entry) return { ready: false, reason: "revision source is not in the lockfile" };
+  const recorded = entry.outputs.map((_, index) => path8.resolve(currentEntryOutputPath(entry, parent, index))).sort();
+  const found = members.map((member) => path8.resolve(member.file)).sort();
+  if (recorded.length !== found.length || recorded.some((file, index) => file !== found[index])) {
+    return {
+      ready: false,
+      reason: `revision source ${parent.assetId} records ${recorded.length} output(s) but ${found.length} member file(s) were found beside it; remove files left over from an earlier generation, or re-fetch the parent`
+    };
+  }
+  return { ready: true, reason: "revision source set is current" };
+}
 async function requireRevisionReady(spec, lock) {
   const inspection = await inspectRevisionReadiness(spec, lock);
   if (inspection && !inspection.ready) throw new Error(inspection.reason);
@@ -4808,14 +4894,15 @@ var ComfyUIProvider = class _ComfyUIProvider {
   }
   /**
    * Everything else resolves generically to whatever the user's own
-   * workflow does with `bindings.sourceImage`. `animate`/`animate-pixminimax`
-   * are the one 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 it is rejected here rather than only failing once `validate` runs.
+   * 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.
    */
   supportsRevision(mode2) {
-    return mode2 !== "animate" && mode2 !== "animate-pixminimax";
+    return !FRAME_SET_REVISION_MODES.includes(mode2);
   }
   estimate(spec) {
     return {
@@ -4868,6 +4955,11 @@ var ComfyUIProvider = class _ComfyUIProvider {
       throw new Error("ComfyUI providerOptions.frames requires generator: frames");
     }
     if (spec.revision) {
+      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)`
+        );
+      }
       if (!options.bindings.sourceImage) {
         throw new Error("ComfyUI revisions require bindings.sourceImage");
       }
@@ -5603,6 +5695,21 @@ var CorrectPixelartResponseSchema = z2.object({
   images: z2.array(z2.object({ base64: z2.string().min(1) }).passthrough()).min(1),
   usage: z2.unknown().optional()
 }).passthrough();
+var UnzoomResponseSchema = z2.object({
+  image: z2.object({ base64: z2.string().min(1) }).passthrough(),
+  original_size: z2.object({ width: z2.number().int(), height: z2.number().int() }).passthrough(),
+  unzoomed_size: z2.object({ width: z2.number().int(), height: z2.number().int() }).passthrough(),
+  zoom_factor_detected: z2.number(),
+  usage: z2.unknown().optional()
+}).passthrough();
+var FontJobSchema = z2.object({
+  job_id: z2.string().min(1),
+  status: z2.string(),
+  glyph_px: z2.number().int().nullable().optional(),
+  download_atlas_url: z2.string().nullable().optional(),
+  download_ttf_url: z2.string().nullable().optional(),
+  usage: z2.unknown().optional()
+}).passthrough();
 var SelectFramesSchema = z2.object({ created_object_ids: z2.array(z2.string()) }).passthrough();
 var CharacterSubmitSchema = z2.object({
   background_job_id: z2.string().min(1),
@@ -5687,6 +5794,17 @@ function validateResponse(schema, raw, operation) {
   const issues = parsed.error.issues.slice(0, 4).map((i) => `${i.path.join(".") || "response"}: ${i.message}`).join("; ");
   throw new Error(`Invalid PixelLab response for ${operation}: ${issues}`);
 }
+function cleanupImages(args, operation) {
+  const images = args.images ?? (args.image ? [args.image] : []);
+  if (!images.length) throw new Error(`${operation} needs at least one image`);
+  return images;
+}
+function cleanupResults(images, sent, operation) {
+  if (images.length !== sent) {
+    throw new Error(`Invalid PixelLab response for ${operation}: sent ${sent} image(s), got ${images.length} back`);
+  }
+  return images.map((image) => Buffer.from(image.base64, "base64"));
+}
 var PixelLabError = class extends ProviderError {
   constructor(message6, status, body) {
     super("pixellab", message6, { status });
@@ -5715,9 +5833,9 @@ var PixelLabClient = class {
   apiKey;
   http;
   /** Retries transport failures, 429, and 5xx; see http.ts for the policy. */
-  async request(path45, init) {
+  async request(path47, init) {
     const auth = this.apiKey.startsWith("Bearer ") ? this.apiKey : `Bearer ${this.apiKey}`;
-    const res = await this.http(`${BASE}${path45}`, {
+    const res = await this.http(`${BASE}${path47}`, {
       ...init,
       headers: {
         Authorization: auth,
@@ -5727,13 +5845,13 @@ var PixelLabClient = class {
     });
     const text = await res.text();
     if (!res.ok) {
-      throw new PixelLabError(`${init?.method ?? "GET"} ${path45} \u2192 ${res.status}`, res.status, text);
+      throw new PixelLabError(`${init?.method ?? "GET"} ${path47} \u2192 ${res.status}`, res.status, text);
     }
     if (!text) return {};
     try {
       return JSON.parse(text);
     } catch {
-      throw new Error(`${init?.method ?? "GET"} ${path45} returned invalid JSON`);
+      throw new Error(`${init?.method ?? "GET"} ${path47} returned invalid JSON`);
     }
   }
   async balance() {
@@ -6119,10 +6237,10 @@ var PixelLabClient = class {
     const palette = args.paletteSwatchBase64 ? { color_image: { type: "base64", base64: args.paletteSwatchBase64, format: "png" }, force_colors: true } : {};
     const encode = (image) => ({ type: "base64", base64: image.base64, format: image.format });
     const south = args.reference?.south;
-    let path45;
+    let path47;
     let body;
     if (args.mode === "v3") {
-      path45 = "/create-character-v3";
+      path47 = "/create-character-v3";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -6136,7 +6254,7 @@ var PixelLabClient = class {
         ...args.enhancePrompt ? { enhance_prompt: true } : {}
       };
     } else if (args.mode === "pro-flash") {
-      path45 = "/create-character-pro-flash";
+      path47 = "/create-character-pro-flash";
       const traits = args.styleTraits;
       body = {
         description: args.description,
@@ -6159,7 +6277,7 @@ var PixelLabClient = class {
         } : {}
       };
     } else if (args.mode === "pro") {
-      path45 = "/create-character-pro";
+      path47 = "/create-character-pro";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -6173,7 +6291,7 @@ var PixelLabClient = class {
         ...!south && args.styleCharacterId ? { style_character_id: args.styleCharacterId } : {}
       };
     } else {
-      path45 = args.directions === 4 ? "/create-character-with-4-directions" : "/create-character-with-8-directions";
+      path47 = args.directions === 4 ? "/create-character-with-4-directions" : "/create-character-with-8-directions";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -6190,8 +6308,8 @@ var PixelLabClient = class {
         ...palette
       };
     }
-    const raw = await this.request(path45, { method: "POST", body: JSON.stringify(body) });
-    return validateResponse(CharacterSubmitSchema, raw, path45.slice(1));
+    const raw = await this.request(path47, { method: "POST", body: JSON.stringify(body) });
+    return validateResponse(CharacterSubmitSchema, raw, path47.slice(1));
   }
   /** A text edit of an existing character, applied to every direction and stored as a sibling. */
   async createCharacterState(args) {
@@ -6353,20 +6471,52 @@ var PixelLabClient = class {
     );
   }
   /**
-   * `/reduce-colors`, PixelLab's "Cleanup" tier: quantize one image onto a
-   * smaller palette, synchronously — no `background_job_id`, the result
-   * comes back in this same response, like `createImagePixflux`. The
-   * schema's own response example is dollar-denominated (`usage: {type:
-   * "usd", usd: 0.02}`), which — matching this codebase's repeated
-   * experience with PixelLab's documented-vs-billed cost mismatches
-   * (`isometricTile`, `objectPro`) — did not hold: confirmed live against a
-   * Tier 2 account at exactly 0.1 generations for a 32x32 source
-   * (docs/REVISIONS.md). `numColors` and `paletteImage` are mutually
-   * exclusive upstream; the manifest schema already enforces that before
-   * this is ever called.
+   * `/generate-ui-v2` ("Generate UI (Pro)"): one UI element (a button, a
+   * health bar, an inventory slot, a dialogue box) from a description,
+   * guided by an optional concept image and a natural-language color
+   * palette. A plain background job; unlike `/create-ui-asset` there is no
+   * piece/element layout, and sizes start at 16px instead of 192. Its
+   * completed shape has not been exercised live; `pollUiElement` reads it
+   * defensively.
+   */
+  async generateUiV2(args) {
+    const body = {
+      description: args.description,
+      image_size: { width: args.width, height: args.height }
+    };
+    if (args.conceptImage) {
+      body.concept_image = {
+        image: args.conceptImage.image,
+        size: { width: args.conceptImage.width, height: args.conceptImage.height }
+      };
+    }
+    if (args.colorPalette) body.color_palette = args.colorPalette;
+    if (args.noBackground != null) body.no_background = args.noBackground;
+    if (args.seed != null) body.seed = args.seed;
+    return validateResponse(
+      RevisionJobSubmitSchema,
+      await this.request("/generate-ui-v2", { method: "POST", body: JSON.stringify(body) }),
+      "generate-ui-v2"
+    );
+  }
+  /**
+   * `/reduce-colors`, PixelLab's "Cleanup" tier: quantize one image, or
+   * several same-size frames together onto ONE shared palette, synchronously
+   * — no `background_job_id`, the result comes back in this same response,
+   * like `createImagePixflux`. Passing every frame of an animation (or every
+   * direction of a character) in one call is the endpoint's whole point:
+   * frames quantized separately drift onto different palettes. The schema's
+   * own response example is dollar-denominated (`usage: {type: "usd", usd:
+   * 0.02}`), which — matching this codebase's repeated experience with
+   * PixelLab's documented-vs-billed cost mismatches (`isometricTile`,
+   * `objectPro`) — did not hold: confirmed live against a Tier 2 account at
+   * exactly 0.1 generations for a 32x32 source (docs/REVISIONS.md).
+   * `numColors` and `paletteImage` are mutually exclusive upstream; the
+   * manifest schema already enforces that before this is ever called.
    */
   async reduceColors(args) {
-    const body = { images: [args.image] };
+    const images = cleanupImages(args, "reduce-colors");
+    const body = { images };
     if (args.numColors != null) body.num_colors = args.numColors;
     if (args.paletteImage) body.palette_image = args.paletteImage;
     if (args.dithering) body.dithering = args.dithering;
@@ -6376,8 +6526,10 @@ var PixelLabClient = class {
       await this.request("/reduce-colors", { method: "POST", body: JSON.stringify(body) }),
       "reduce-colors"
     );
+    const pngs = cleanupResults(res.images, images.length, "reduce-colors");
     return {
-      png: Buffer.from(res.images[0].base64, "base64"),
+      png: pngs[0],
+      pngs,
       paletteStripPng: Buffer.from(res.palette.base64, "base64"),
       nColors: res.n_colors,
       usage: res.usage
@@ -6386,19 +6538,117 @@ var PixelLabClient = class {
   /**
    * `/correct-pixelart`, PixelLab's "Cleanup" tier: sharpen edges and drop
    * stray pixels without resizing, synchronously — same shape as
-   * `reduceColors` above, no background job. Cost is likewise confirmed
-   * live at 0.1 generations for a 32x32 source, not the schema's own
+   * `reduceColors` above, no background job, and likewise corrects several
+   * same-size frames together when given `images`. Cost is confirmed live
+   * at 0.1 generations for a 32x32 source, not the schema's own
    * dollar-denominated example (`usage: {type: "usd", usd: 0.02}`).
    */
   async correctPixelart(args) {
-    const body = { images: [args.image] };
+    const images = cleanupImages(args, "correct-pixelart");
+    const body = { images };
     if (args.strength != null) body.strength = args.strength;
     const res = validateResponse(
       CorrectPixelartResponseSchema,
       await this.request("/correct-pixelart", { method: "POST", body: JSON.stringify(body) }),
       "correct-pixelart"
     );
-    return { png: Buffer.from(res.images[0].base64, "base64"), usage: res.usage };
+    const pngs = cleanupResults(res.images, images.length, "correct-pixelart");
+    return { png: pngs[0], pngs, usage: res.usage };
+  }
+  /**
+   * `/unzoom`: recover native-resolution pixel art from an upscaled image (a
+   * 32x32 sprite saved at 512x512). Synchronous like the Cleanup tier.
+   * PixelLab's own API overview names this "the most common cause of
+   * disappointing output": run it on outside artwork before it becomes a
+   * style or reference image. The input must be at least 256x256 and at
+   * most 2048x2048 in area, and the result is opaque — transparency is
+   * composited onto white before the grid is detected. `quantize` is 0 to
+   * auto-detect a palette, -1 to keep every color, or 2-256 for exactly
+   * that many.
+   */
+  async unzoom(args) {
+    const body = { image: args.image };
+    if (args.quantize != null) body.quantize = args.quantize;
+    const res = validateResponse(
+      UnzoomResponseSchema,
+      await this.request("/unzoom", { method: "POST", body: JSON.stringify(body) }),
+      "unzoom"
+    );
+    return {
+      png: Buffer.from(res.image.base64, "base64"),
+      originalSize: { width: res.original_size.width, height: res.original_size.height },
+      unzoomedSize: { width: res.unzoomed_size.width, height: res.unzoomed_size.height },
+      zoomFactor: res.zoom_factor_detected,
+      usage: res.usage
+    };
+  }
+  /**
+   * `/interpolation-v2` ("Interpolate (Pro)"): generate the in-between
+   * frames from one keyframe to another, guided by a short `action`. Unlike
+   * `last_frame` on `/animate-with-text-v3`, both ends are required and the
+   * frame count is the model's own choice (its docs say "typically 4-8").
+   * Output frames are 16 to 128 pixels per side. A plain background job;
+   * its completed shape is read defensively by `pollAnimateRevision`.
+   */
+  async interpolationV2(args) {
+    const size = { width: args.width, height: args.height };
+    const body = {
+      start_image: { image: args.startImage, size },
+      end_image: { image: args.endImage, size },
+      action: args.action,
+      image_size: size
+    };
+    if (args.seed != null) body.seed = args.seed;
+    if (args.noBackground != null) body.no_background = args.noBackground;
+    return validateResponse(
+      RevisionJobSubmitSchema,
+      await this.request("/interpolation-v2", { method: "POST", body: JSON.stringify(body) }),
+      "interpolation-v2"
+    );
+  }
+  /**
+   * `/edit-animation-v2` ("Edit animation (Pro)"): apply one text edit
+   * across every frame of an existing animation at once, so the change
+   * stays consistent frame to frame. 2 to 16 frames, but the real ceiling
+   * shrinks with frame size because every frame is packed into one grid:
+   * 16 at up to 64px, 9 at 65-80px, 4 at 81-256px.
+   */
+  async editAnimationV2(args) {
+    const size = { width: args.width, height: args.height };
+    const body = {
+      description: args.description,
+      frames: args.frames.map((image) => ({ image, size })),
+      image_size: size
+    };
+    if (args.seed != null) body.seed = args.seed;
+    if (args.noBackground != null) body.no_background = args.noBackground;
+    return validateResponse(
+      RevisionJobSubmitSchema,
+      await this.request("/edit-animation-v2", { method: "POST", body: JSON.stringify(body) }),
+      "edit-animation-v2"
+    );
+  }
+  /**
+   * `/generate-font-pro`: an 80-glyph pixel font (A-Z, a-z, 0-9, common
+   * game-UI punctuation) from a style description, delivered as a glyph
+   * atlas PNG plus a ready-to-use `.ttf`. Documented at 25 subscription
+   * generations. Poll with `getFontJob`.
+   */
+  async generateFontPro(args) {
+    const body = { description: args.description, weight: args.weight };
+    if (args.glyphPx != null) body.glyph_px = args.glyphPx;
+    if (args.seed != null) body.seed = args.seed;
+    if (args.fontName) body.font_name = args.fontName;
+    return validateResponse(
+      RevisionJobSubmitSchema,
+      await this.request("/generate-font-pro", { method: "POST", body: JSON.stringify(body) }),
+      "generate-font-pro"
+    );
+  }
+  /** `GET /generate-font-pro/{job_id}`: status, then no-auth atlas and `.ttf` URLs once completed. */
+  async getFontJob(jobId) {
+    const raw = await this.request(`/generate-font-pro/${encodeURIComponent(jobId)}`);
+    return validateResponse(FontJobSchema, raw, "generate-font-pro/{job_id}");
   }
   /**
    * `/animate-with-text-v3`: animate a loose image from a text description,
@@ -6619,7 +6869,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";
+    return generator === "1dir" || generator === "map" || generator === "pixflux" || generator === "tiles" || generator === "terrain" || generator === "imagePro" || generator === "character" || generator === "isometricTile" || generator === "objectPro" || generator === "uiAsset" || generator === "uiElement";
   }
   /**
    * `inpaint` (`/inpaint-v3`, a mask) and `image-to-image` (`/edit-images-v2`,
@@ -6629,12 +6879,15 @@ 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. `outpaint` does not: there is no canvas-expansion endpoint in
-   * the API, matching docs/REVISIONS.md's note that no provider ships a
-   * tested outpaint path yet.
+   * required — 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,
+   * matching docs/REVISIONS.md's note that no provider ships a tested
+   * outpaint path yet.
    */
   supportsRevision(mode2) {
-    return mode2 === "inpaint" || mode2 === "image-to-image" || mode2 === "reduce-colors" || mode2 === "correct-pixelart" || mode2 === "animate" || mode2 === "animate-pixminimax";
+    return mode2 === "inpaint" || mode2 === "image-to-image" || mode2 === "reduce-colors" || mode2 === "correct-pixelart" || mode2 === "animate" || mode2 === "animate-pixminimax" || 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,
@@ -6662,6 +6915,12 @@ 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 === "interpolate" || spec.revision?.mode === "edit-animation") {
+      const width = spec.revision.sourceWidth ?? spec.width;
+      const height = spec.revision.sourceHeight ?? spec.height;
+      const side = spec.revision.mode === "edit-animation" ? Math.ceil(Math.sqrt(Math.max(1, spec.revision.sourceMembers?.length ?? 1))) : 1;
+      return { unit: "generations", amount: generationCost(width * side, height * side, "1dir"), candidates: 1 };
+    }
     if (spec.revision?.mode === "animate" || spec.revision?.mode === "animate-pixminimax") {
       const width = spec.revision.sourceWidth ?? spec.width;
       const height = spec.revision.sourceHeight ?? spec.height;
@@ -6690,6 +6949,12 @@ var PixelLabProvider = class _PixelLabProvider {
     };
   }
   validate(spec, styleImages) {
+    const members = spec.revision?.sourceMembers;
+    if (spec.revision && members && !MEMBER_SET_REVISION_MODES.includes(spec.revision.mode)) {
+      throw new Error(
+        `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") {
       const { sourceWidth: width, sourceHeight: height } = spec.revision;
       if (width != null && height != null && (width < 32 || height < 32 || width > 512 || height > 512)) {
@@ -6698,9 +6963,10 @@ var PixelLabProvider = class _PixelLabProvider {
     }
     if (spec.revision?.mode === "reduce-colors") {
       const { sourceWidth: width, sourceHeight: height } = spec.revision;
-      if (width != null && height != null && width * height > 512 * 512) {
+      const count = members?.length ?? 1;
+      if (width != null && height != null && width * height * count > 512 * 512) {
         throw new Error(
-          `PixelLab reduce-colors source is ${width}x${height} (${width * height}px\xB2); the API takes at most 512x512 worth of pixels per call`
+          `PixelLab reduce-colors source is ${count > 1 ? `${count} frames of ` : ""}${width}x${height} (${width * height * count}px\xB2 in all); the API takes at most 512x512 worth of pixels per call`
         );
       }
     }
@@ -6724,6 +6990,36 @@ var PixelLabProvider = class _PixelLabProvider {
         );
       }
     }
+    if (spec.revision?.mode === "interpolate") {
+      const { sourceWidth: width, sourceHeight: height, lastFrameWidth, lastFrameHeight } = spec.revision;
+      if (width != null && height != null && (width < 16 || height < 16 || width > 128 || height > 128)) {
+        throw new Error(`PixelLab interpolate keyframes are ${width}x${height}; the API takes 16 to 128 pixels per side`);
+      }
+      if (lastFrameWidth != null && lastFrameHeight != null && width != null && height != null && (lastFrameWidth !== width || lastFrameHeight !== height)) {
+        throw new Error(
+          `PixelLab interpolate lastFrame is ${lastFrameWidth}x${lastFrameHeight}; the start keyframe is ${width}x${height} \u2014 they must match`
+        );
+      }
+    }
+    if (spec.revision?.mode === "edit-animation") {
+      const { sourceWidth: width, sourceHeight: height, sourceAssetId } = spec.revision;
+      if (width != null && height != null) {
+        if (!members || members.length < 2) {
+          throw new Error(
+            `PixelLab edit-animation needs a frame set to edit; ${sourceAssetId} is a single image (revise an animation, a character's directions, or another frame-set revision)`
+          );
+        }
+        if (width < 16 || height < 16 || width > 256 || height > 256) {
+          throw new Error(`PixelLab edit-animation frames are ${width}x${height}; the API takes 16 to 256 pixels per side`);
+        }
+        const ceiling = editAnimationFrameCeiling(width, height);
+        if (members.length > ceiling) {
+          throw new Error(
+            `PixelLab edit-animation takes at most ${ceiling} frames at ${width}x${height} (every frame is packed into one grid); ${sourceAssetId} has ${members.length}`
+          );
+        }
+      }
+    }
     if (spec.generator === "1dir" && (spec.width < 32 || spec.width > 256)) {
       throw new Error("PixelLab 1dir dimensions must be between 32 and 256 pixels");
     }
@@ -6740,6 +7036,14 @@ 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 === "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)`
+      );
+    }
+    if (spec.generator === "uiElement" && styleImages.length > 1) {
+      throw new Error("PixelLab uiElement takes one concept image; list at most one styleImages entry");
+    }
     if (spec.generator === "map") {
       requirePixelLabOption("map", "view", spec.view, ["low top-down", "high top-down", "side"]);
       requirePixelLabOption("map", "outline", spec.outline, [
@@ -6823,8 +7127,8 @@ var PixelLabProvider = class _PixelLabProvider {
         throw new Error(`PixelLab isometricTile: size must be 16 to 64 pixels, got ${spec.width}`);
       }
     }
-    if (spec.generator === "character") this.validateCharacter(spec, styleImages);
-    if (spec.generator === "objectPro") this.validateObjectPro(spec, styleImages);
+    if (spec.generator === "character" && !spec.revision) this.validateCharacter(spec, styleImages);
+    if (spec.generator === "objectPro" && !spec.revision) this.validateObjectPro(spec, styleImages);
     if ((spec.generator === "map" || spec.generator === "pixflux") && styleImages.length) {
       throw new Error(`PixelLab ${spec.generator} does not support style images`);
     }
@@ -7391,6 +7695,19 @@ var PixelLabProvider = class _PixelLabProvider {
       });
       return { jobId: res2.ui_asset_id, metadata: { backgroundJobId: res2.background_job_id } };
     }
+    if (spec.generator === "uiElement") {
+      const concept = styleImages[0];
+      const res2 = await this.client.generateUiV2({
+        description: spec.prompt,
+        width: spec.width,
+        height: spec.height,
+        conceptImage: concept ? { image: { base64: concept.base64, format: concept.format }, width: concept.width, height: concept.height } : void 0,
+        colorPalette: spec.uiColorPalette,
+        noBackground: spec.noBackground,
+        seed: spec.seed
+      });
+      return { jobId: res2.background_job_id };
+    }
     if (spec.generator === "pixflux") {
       const swatch = spec.palette.length ? paletteSwatch(spec.palette).toString("base64") : void 0;
       const { png } = await this.client.createImagePixflux({
@@ -7519,13 +7836,18 @@ var PixelLabProvider = class _PixelLabProvider {
     if (!revision.sourceSha256 || !revision.sourceFormat || revision.sourceWidth == null || revision.sourceHeight == null) {
       throw new Error(`${spec.styleId}/${spec.assetId}: revision source is not ready`);
     }
-    const sourceBytes = readFileSync2(revision.sourceFile);
-    if (sha256(sourceBytes) !== revision.sourceSha256) {
-      throw new Error(`${spec.styleId}/${spec.assetId}: revision source changed after the manifest was resolved`);
-    }
-    const image = { base64: sourceBytes.toString("base64"), format: revision.sourceFormat };
+    const sourceFiles = revision.sourceMembers ?? [{ file: revision.sourceFile, sha256: revision.sourceSha256, format: revision.sourceFormat }];
+    const images = sourceFiles.map((member) => {
+      const bytes = readFileSync2(member.file);
+      if (sha256(bytes) !== member.sha256) {
+        throw new Error(`${spec.styleId}/${spec.assetId}: revision source changed after the manifest was resolved`);
+      }
+      return { base64: bytes.toString("base64"), format: member.format };
+    });
+    const image = images[0];
     const width = revision.sourceWidth;
     const height = revision.sourceHeight;
+    const roles = revision.sourceMembers?.map((member) => member.role);
     if (revision.mode === "inpaint") {
       if (!revision.maskFile || !revision.maskSha256 || !revision.maskFormat) {
         throw new Error(`${spec.styleId}/${spec.assetId}: revision mask is not ready`);
@@ -7558,34 +7880,45 @@ var PixelLabProvider = class _PixelLabProvider {
         paletteImage = { base64: paletteBytes.toString("base64"), format: revision.paletteImageFormat };
       }
       const res2 = await this.client.reduceColors({
-        image,
+        images,
         numColors: revision.numColors,
         paletteImage,
         dithering: revision.dithering,
         ditheringStrength: revision.ditheringStrength
       });
-      const jobId = randomUUID3();
-      writeFileSync(path12.join(_PixelLabProvider.cacheDir(), `${jobId}.png`), res2.png);
-      return { jobId, metadata: { revisionUsage: res2.usage } };
+      return this.cacheCleanupResult(res2.pngs, res2.usage, roles, revision.sourceFps);
     }
     if (revision.mode === "correct-pixelart") {
-      const res2 = await this.client.correctPixelart({ image, strength: revision.strength });
-      const jobId = randomUUID3();
-      writeFileSync(path12.join(_PixelLabProvider.cacheDir(), `${jobId}.png`), res2.png);
-      return { jobId, metadata: { revisionUsage: res2.usage } };
+      const res2 = await this.client.correctPixelart({ images, strength: revision.strength });
+      return this.cacheCleanupResult(res2.pngs, res2.usage, roles, revision.sourceFps);
+    }
+    if (revision.mode === "interpolate") {
+      const lastFrame = this.readLastFrame(spec);
+      if (!lastFrame) throw new Error(`${spec.styleId}/${spec.assetId}: interpolate needs lastFrame, the ending keyframe`);
+      const res2 = await this.client.interpolationV2({
+        startImage: image,
+        endImage: lastFrame,
+        width,
+        height,
+        action: spec.prompt,
+        seed: spec.seed,
+        noBackground: spec.noBackground
+      });
+      return { jobId: res2.background_job_id };
+    }
+    if (revision.mode === "edit-animation") {
+      const res2 = await this.client.editAnimationV2({
+        frames: images,
+        width,
+        height,
+        description: spec.prompt,
+        seed: spec.seed,
+        noBackground: spec.noBackground
+      });
+      return { jobId: res2.background_job_id };
     }
     if (revision.mode === "animate" || revision.mode === "animate-pixminimax") {
-      let lastFrame;
-      if (revision.lastFrameFile) {
-        if (!revision.lastFrameSha256 || !revision.lastFrameFormat) {
-          throw new Error(`${spec.styleId}/${spec.assetId}: revision last frame is not ready`);
-        }
-        const lastFrameBytes = readFileSync2(revision.lastFrameFile);
-        if (sha256(lastFrameBytes) !== revision.lastFrameSha256) {
-          throw new Error(`${spec.styleId}/${spec.assetId}: revision last frame changed after the manifest was resolved`);
-        }
-        lastFrame = { base64: lastFrameBytes.toString("base64"), format: revision.lastFrameFormat };
-      }
+      const lastFrame = this.readLastFrame(spec);
       if (revision.mode === "animate") {
         const res3 = await this.client.animateWithTextV3({
           firstFrame: image,
@@ -7625,6 +7958,36 @@ var PixelLabProvider = class _PixelLabProvider {
     });
     return { jobId: res.background_job_id };
   }
+  /** A revision's pinned ending frame, proven to be the bytes the spec hashed; undefined when none is declared. */
+  readLastFrame(spec) {
+    const revision = spec.revision;
+    if (!revision.lastFrameFile) return void 0;
+    if (!revision.lastFrameSha256 || !revision.lastFrameFormat) {
+      throw new Error(`${spec.styleId}/${spec.assetId}: revision last frame is not ready`);
+    }
+    const bytes = readFileSync2(revision.lastFrameFile);
+    if (sha256(bytes) !== revision.lastFrameSha256) {
+      throw new Error(`${spec.styleId}/${spec.assetId}: revision last frame changed after the manifest was resolved`);
+    }
+    return { base64: bytes.toString("base64"), format: revision.lastFrameFormat };
+  }
+  /**
+   * Park a synchronous Cleanup-tier result the way pixflux parks its own:
+   * one `<id>.png` for a single image, or `<id>-<n>.png` per member with the
+   * member roles recorded so `pollCachedRevision` hands them back under the
+   * same names the parent's set used.
+   */
+  cacheCleanupResult(pngs, usage, roles, fps) {
+    const jobId = randomUUID3();
+    if (!roles) {
+      writeFileSync(path12.join(_PixelLabProvider.cacheDir(), `${jobId}.png`), pngs[0]);
+      return { jobId, metadata: { revisionUsage: usage } };
+    }
+    for (const [index, png] of pngs.entries()) {
+      writeFileSync(path12.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`), png);
+    }
+    return { jobId, metadata: { revisionUsage: usage, revisionMembers: roles, ...fps != null ? { revisionFps: fps } : {} } };
+  }
   /**
    * What a background job actually billed, once its own record is still
    * around to ask; see `billedFromUsage`. A stale or already-cleaned-up job
@@ -7645,7 +8008,7 @@ var PixelLabProvider = class _PixelLabProvider {
     if (revisionMode === "reduce-colors" || revisionMode === "correct-pixelart") {
       return this.pollCachedRevision(jobId, context);
     }
-    if (revisionMode === "animate" || revisionMode === "animate-pixminimax") {
+    if (revisionMode === "animate" || revisionMode === "animate-pixminimax" || revisionMode === "interpolate" || revisionMode === "edit-animation") {
       return this.pollAnimateRevision(jobId, context);
     }
     if (context?.spec?.revision) return this.pollRevision(jobId);
@@ -7668,6 +8031,7 @@ var PixelLabProvider = class _PixelLabProvider {
     if (generator === "character") return this.pollCharacter(jobId, context);
     if (generator === "objectPro") return this.pollObjectPro(jobId, context);
     if (generator === "uiAsset") return this.pollUiAsset(jobId, context);
+    if (generator === "uiElement") return this.pollUiElement(jobId);
     const backgroundJobId = context?.metadata?.backgroundJobId;
     const obj = await this.client.getObject(jobId);
     if (obj.status === "review") {
@@ -7694,15 +8058,32 @@ var PixelLabProvider = class _PixelLabProvider {
    * work.
    */
   async pollCachedRevision(jobId, context) {
-    const file = path12.join(_PixelLabProvider.cacheDir(), `${jobId}.png`);
-    if (!existsSync7(file)) {
+    const usage = context?.metadata?.revisionUsage;
+    const roles = context?.metadata?.revisionMembers;
+    const gone = {
+      status: "failed",
+      error: "revision result is no longer cached locally; re-run submit for this asset"
+    };
+    if (Array.isArray(roles) && roles.length) {
+      const sources = roles.map((role, index) => ({
+        url: `file://${path12.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`)}`,
+        role: String(role)
+      }));
+      if (sources.some((source) => !existsSync7(source.url.slice("file://".length)))) return gone;
+      const fps = context?.metadata?.revisionFps;
+      const frames = sources.every((source) => source.role.startsWith("frame-"));
       return {
-        status: "failed",
-        error: "revision result is no longer cached locally; re-run submit for this asset"
+        status: "ready",
+        objectId: jobId,
+        sourceUrl: sources[0].url,
+        sources,
+        ...frames && typeof fps === "number" ? { metadata: { frameSet: { fps, count: sources.length } } } : {},
+        billed: billedFromUsage(usage)
       };
     }
+    const file = path12.join(_PixelLabProvider.cacheDir(), `${jobId}.png`);
+    if (!existsSync7(file)) return gone;
     const sourceUrl = `file://${file}`;
-    const usage = context?.metadata?.revisionUsage;
     return { status: "ready", objectId: jobId, sourceUrl, sources: [{ url: sourceUrl }], billed: billedFromUsage(usage) };
   }
   /**
@@ -7726,16 +8107,21 @@ var PixelLabProvider = class _PixelLabProvider {
     if (job.status !== "completed") return { status: "processing" };
     const billed = billedFromUsage(job.usage);
     const done = job.last_response ?? {};
-    const fps = context?.spec?.revision?.fps ?? 8;
-    const review = (frameUrls) => ({
-      status: "review-set",
-      objectId: jobId,
-      frameUrls,
-      sources: frameUrls.map((url, index) => ({ url, role: `frame-${String(index).padStart(2, "0")}` })),
-      fps,
-      metadata: { frameSet: { fps, count: frameUrls.length } },
-      billed
-    });
+    const revision = context?.spec?.revision;
+    const fps = revision?.fps ?? revision?.sourceFps ?? 8;
+    const memberRoles = revision?.mode === "edit-animation" ? revision.sourceMembers?.map((member) => member.role) : void 0;
+    const review = (frameUrls) => {
+      const roles = memberRoles?.length === frameUrls.length ? memberRoles : frameUrls.map((_, index) => `frame-${String(index).padStart(2, "0")}`);
+      return {
+        status: "review-set",
+        objectId: jobId,
+        frameUrls,
+        sources: frameUrls.map((url, index) => ({ url, role: roles[index] })),
+        fps,
+        metadata: roles.every((role) => role.startsWith("frame-")) ? { frameSet: { fps, count: frameUrls.length } } : {},
+        billed
+      };
+    };
     for (const key of ["frame_urls", "frames", "images"]) {
       const list = done[key];
       if (!Array.isArray(list) || !list.length) continue;
@@ -7767,7 +8153,7 @@ var PixelLabProvider = class _PixelLabProvider {
     }
     return {
       status: "failed",
-      error: `Invalid PixelLab response for animate job ${jobId}: completed with no recognized frame list (got: ${Object.keys(done).join(", ") || "no keys"}); update pollAnimateRevision in src/providers/pixellab.ts with the real shape`
+      error: `Invalid PixelLab response for ${revision?.mode ?? "animate"} job ${jobId}: completed with no recognized frame list (got: ${Object.keys(done).join(", ") || "no keys"}); update pollAnimateRevision in src/providers/pixellab.ts with the real shape`
     };
   }
   /**
@@ -7857,6 +8243,36 @@ var PixelLabProvider = class _PixelLabProvider {
       error: `Invalid PixelLab response for imagePro job ${jobId}: completed with no recognized images array (got: ${Object.keys(done).join(", ") || "no keys"}); this endpoint's completed shape has not been exercised live yet -- update pollImagePro in src/providers/pixellab.ts with the real shape`
     };
   }
+  /**
+   * `/generate-ui-v2` completes a plain background job whose
+   * `last_response.images` (per its own docs and Python client) holds the
+   * result. One image is the expected case and goes straight to selected;
+   * should the endpoint ever return several, they go to review like
+   * imagePro's candidates, decoded to the same local cache. The shape has
+   * not been observed live, so anything else fails naming the keys received.
+   */
+  async pollUiElement(jobId) {
+    const job = await this.client.getBackgroundJob(jobId);
+    if (job.status === "failed") return { status: "failed", error: "UI element job failed upstream" };
+    if (job.status !== "completed") return { status: "processing" };
+    const billed = billedFromUsage(job.usage);
+    const done = job.last_response ?? {};
+    const images = Array.isArray(done.images) ? done.images : done.image ? [done.image] : [];
+    const urls = [];
+    for (const [index, candidate] of images.entries()) {
+      const base64 = extractBase64(candidate);
+      if (!base64) continue;
+      const file = path12.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`);
+      writeFileSync(file, Buffer.from(base64, "base64"));
+      urls.push(`file://${file}`);
+    }
+    if (urls.length === 1) return { status: "ready", objectId: jobId, sourceUrl: urls[0], sources: [{ url: urls[0] }], billed };
+    if (urls.length > 1) return { status: "review", candidateUrls: urls, billed };
+    return {
+      status: "failed",
+      error: `Invalid PixelLab response for uiElement job ${jobId}: completed with no recognized image (got: ${Object.keys(done).join(", ") || "no keys"}); update pollUiElement in src/providers/pixellab.ts with the real shape`
+    };
+  }
   /**
    * Map objects need their own path because the `/map-objects/{id}` record is
    * deleted upstream roughly 8 hours after creation while the image survives in
@@ -8017,9 +8433,9 @@ var PixelLabProvider = class _PixelLabProvider {
       if (!url) throw new Error(`tiles job ${jobId} has no variation at index ${index}`);
       return { objectId: `${jobId}#${index}`, sourceUrl: url };
     }
-    if (generator === "imagePro") {
+    if (generator === "imagePro" || generator === "uiElement") {
       const file = path12.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`);
-      if (!existsSync7(file)) throw new Error(`imagePro job ${jobId} has no cached candidate at index ${index}`);
+      if (!existsSync7(file)) throw new Error(`${generator} job ${jobId} has no cached candidate at index ${index}`);
       return { objectId: `${jobId}#${index}`, sourceUrl: `file://${file}` };
     }
     const promoted = await this.client.selectFrames(jobId, [index], commonTag);
@@ -8173,6 +8589,12 @@ function readPose(spec, what, image) {
   }
   return { base64: bytes.toString("base64"), format: image.format };
 }
+function editAnimationFrameCeiling(width, height) {
+  const side = Math.max(width, height);
+  if (side <= 64) return 16;
+  if (side <= 80) return 9;
+  return 4;
+}
 function rotationSources(character) {
   const order = character.directions === 4 ? CHARACTER_DIRECTIONS_4 : CHARACTER_DIRECTIONS_8;
   const sources = [];
@@ -8265,9 +8687,9 @@ var RetroDiffusionClient = class {
     if (!response.ok) throw new ProviderError("retrodiffusion", `Retro Diffusion download failed (${response.status})`, { status: response.status });
     return Buffer.from(await response.arrayBuffer());
   }
-  async call(path45, init = {}) {
+  async call(path47, init = {}) {
     if (!this.token) throw new Error("RD_API_KEY is not set");
-    const response = await this.request(`${this.baseUrl}${path45}`, {
+    const response = await this.request(`${this.baseUrl}${path47}`, {
       ...init,
       headers: {
         "Content-Type": "application/json",
@@ -9399,7 +9821,7 @@ async function resolveSpecs(loaded, filter) {
         size = asset.size ?? style.size ?? 64;
         width = size;
         height = size;
-      } else if (generator === "uiAsset") {
+      } else if (generator === "uiAsset" || generator === "uiElement") {
         width = asset.width ?? style.size ?? 256;
         height = asset.height ?? style.size ?? 256;
         size = Math.max(width, height);
@@ -9466,7 +9888,7 @@ async function resolveSpecs(loaded, filter) {
         seed: style.seed,
         uiPieces: generator === "uiAsset" ? asset.pieces : void 0,
         uiElements: generator === "uiAsset" ? asset.elements : void 0,
-        uiColorPalette: generator === "uiAsset" ? style.uiColorPalette : void 0,
+        uiColorPalette: generator === "uiAsset" || generator === "uiElement" ? style.uiColorPalette : void 0,
         palette: style.palette,
         enforcePalette: style.enforcePalette,
         noBackground: style.noBackground,
@@ -9506,8 +9928,11 @@ async function resolveSpecs(loaded, filter) {
         terrainView: generator === "terrain" ? style.terrainView : void 0,
         isometricTileSize: generator === "isometricTile" ? style.isometricTileSize : void 0,
         isometricTileShape: generator === "isometricTile" ? style.isometricTileShape : void 0,
-        ...generator === "character" ? { character: await resolveCharacterShape(asset, style, characterKind, { root, load: loadStyleImage }) } : {},
-        ...generator === "objectPro" ? { objectPro: await resolveObjectProShape(assetId, asset, style, characterKind, { root, load: loadStyleImage }) } : {},
+        // A revision in a character or objectPro style is a provider edit of
+        // its parent's pixels, not a new character: giving it a base shape
+        // would have packing, the gallery, and adoption treat it as one.
+        ...generator === "character" && !asset.revision ? { character: await resolveCharacterShape(asset, style, characterKind, { root, load: loadStyleImage }) } : {},
+        ...generator === "objectPro" && !asset.revision ? { objectPro: await resolveObjectProShape(assetId, asset, style, characterKind, { root, load: loadStyleImage }) } : {},
         cost: generator === "tiles" ? tilesCost(tileSize, tileVariations) : generator === "terrain" ? tilesCost(size, terrainTiles) : generator === "isometricTile" ? isometricTileCost() : generationCost(width, height, generator),
         costUnit: "generations",
         candidates: generator === "tiles" ? tileVariations : generator === "terrain" ? terrainTiles : generator === "1dir" || generator === "imagePro" ? candidateCount(size) : 1
@@ -9658,8 +10083,11 @@ async function resolveSpecs(loaded, filter) {
           );
         }
         const sourceSpec = await finalize(asset.revision.from);
-        const sourceFile = sourceSpec.quality?.outFile ?? (sourceSpec.source ? path13.resolve(root, sourceSpec.source) : sourceSpec.outFile);
-        const sourceImage = await optionalRevisionImage(sourceFile, "revision source");
+        const sourceStem = sourceSpec.quality?.outFile ?? (sourceSpec.source ? path13.resolve(root, sourceSpec.source) : sourceSpec.outFile);
+        const sourceMembers = await revisionSourceMembers(sourceStem, `revision source ${asset.revision.from}`);
+        const sourceFile = sourceMembers?.[0]?.file ?? sourceStem;
+        const sourceImage = sourceMembers ? { ...sourceMembers[0], hash: sha256(JSON.stringify(sourceMembers.map((member) => member.sha256))) } : await optionalRevisionImage(sourceFile, "revision source");
+        const sourceFps = sourceSpec.character?.animation?.fps ?? sourceSpec.objectPro?.animation?.fps ?? sourceSpec.revision?.fps ?? sourceSpec.revision?.sourceFps;
         const maskFile = asset.revision.mask ? path13.resolve(root, asset.revision.mask) : void 0;
         const maskImage = maskFile ? await optionalRevisionImage(maskFile, "revision mask", "png") : null;
         if (sourceImage && maskImage && (sourceImage.width !== maskImage.width || sourceImage.height !== maskImage.height)) {
@@ -9680,6 +10108,8 @@ async function resolveSpecs(loaded, filter) {
           sourceHeight: sourceImage?.height ?? null,
           sourceFormat: sourceImage?.format ?? null,
           sourceSpec,
+          ...sourceMembers ? { sourceMembers } : {},
+          ...sourceMembers && sourceFps != null ? { sourceFps } : {},
           ...maskFile ? {
             maskFile,
             maskSha256: maskImage?.hash ?? null,
@@ -9829,6 +10259,38 @@ async function optionalRevisionImage(file, label, requiredFormat) {
   }
   return { hash: sha256(bytes), ...metadata };
 }
+async function revisionSourceMembers(stem, label) {
+  if (existsSync8(stem)) return null;
+  const at = (role) => memberPath(stem, role, 0, 2, MediaType.PNG);
+  let roles = [];
+  for (const set of [CHARACTER_DIRECTIONS_8, CHARACTER_DIRECTIONS_4]) {
+    if (set.every((direction) => existsSync8(at(direction)))) {
+      roles = [...set];
+      break;
+    }
+  }
+  if (!roles.length) {
+    for (let index = 0; existsSync8(at(`frame-${String(index).padStart(2, "0")}`)); index++) {
+      roles.push(`frame-${String(index).padStart(2, "0")}`);
+    }
+  }
+  if (!roles.length) return null;
+  const members = [];
+  for (const role of roles) {
+    const file = at(role);
+    const image = await optionalRevisionImage(file, `${label} (${role})`);
+    if (!image) return null;
+    members.push({ role, file, sha256: image.hash, width: image.width, height: image.height, format: image.format });
+  }
+  const first = members[0];
+  const odd = members.find((member) => member.width !== first.width || member.height !== first.height);
+  if (odd) {
+    throw new Error(
+      `${label} is a set whose members differ in size (${first.role} is ${first.width}x${first.height}, ${odd.role} is ${odd.width}x${odd.height}); a revision reads every member as one same-size batch`
+    );
+  }
+  return members;
+}
 async function resolveStyleImages(loaded, styleId) {
   const style = loaded.manifest.styles[styleId];
   if (!style) throw new Error(`Unknown style "${styleId}"`);
@@ -10342,10 +10804,10 @@ function isSha256Hash(value) {
 function parseCache(value) {
   return HashCacheSchema.parse(value);
 }
-async function loadCache(path45) {
-  if (!existsSync10(path45)) return { version: 1, hashes: {} };
+async function loadCache(path47) {
+  if (!existsSync10(path47)) return { version: 1, hashes: {} };
   try {
-    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile8(path45, "utf8")));
+    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile8(path47, "utf8")));
     if (!parsed.success) return { version: 1, hashes: {} };
     return {
       version: 1,
@@ -10357,18 +10819,18 @@ async function loadCache(path45) {
     return { version: 1, hashes: {} };
   }
 }
-async function saveCache(path45, cache) {
+async function saveCache(path47, cache) {
   const sorted = {};
   for (const key of Object.keys(cache.hashes).sort()) {
     const hash = cache.hashes[key];
     if (!isSha256Hash(hash)) throw new Error(`Refusing to cache invalid SHA-256 for ${key}`);
     sorted[key] = hash;
   }
-  await mkdir5(pathModule.dirname(pathModule.resolve(path45)), { recursive: true });
-  const tmp = `${path45}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  await mkdir5(pathModule.dirname(pathModule.resolve(path47)), { recursive: true });
+  const tmp = `${path47}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
     await writeFile5(tmp, JSON.stringify({ version: 1, hashes: sorted }, null, 2) + "\n");
-    await rename5(tmp, path45);
+    await rename5(tmp, path47);
   } finally {
     await rm5(tmp, { force: true });
   }
@@ -13001,6 +13463,7 @@ async function samePixels(a, b) {
 var metadataFps = (entry) => entry ? frameSetFps(entry) : null;
 function describeCharacter(spec, entry) {
   const recordedCharacter = entry?.providerMetadata?.[entry.provider]?.character;
+  if (spec?.revision) return null;
   if (spec?.character) {
     const character = spec.character;
     return {
@@ -17723,20 +18186,173 @@ function sheetFormat(args) {
   return format;
 }
 
-// src/cli/commands/quality.ts
+// src/cli/commands/pixellab-utils.ts
 import path40 from "path";
-import { readFile as readFile27 } from "fs/promises";
 
-// src/pipeline/quality-regression.ts
-import path39 from "path";
+// src/pixellab-utils.ts
 import { existsSync as existsSync29 } from "fs";
-import { readFile as readFile26 } from "fs/promises";
+import { mkdir as mkdir11, readFile as readFile26, writeFile as writeFile14 } from "fs/promises";
+import path39 from "path";
+var UNZOOM_MIN_SIDE = 256;
+var UNZOOM_MAX_AREA = 2048 * 2048;
+function defaultUnzoomOut(input) {
+  const ext = path39.extname(input);
+  return `${ext ? input.slice(0, -ext.length) : input}.unzoomed.png`;
+}
+async function unzoomFile(client2, input, opts = {}) {
+  const out = path39.resolve(opts.out ?? defaultUnzoomOut(input));
+  if (path39.resolve(input) === out) throw new Error("unzoom will not overwrite its own input; pass a different --out");
+  if (existsSync29(out) && !opts.force) throw new Error(`${out} already exists; pass --force to replace it`);
+  const bytes = await readFile26(input);
+  const metadata = imageMetadata(bytes);
+  if (!metadata) throw new Error(`${input} is not a readable PNG or JPEG`);
+  const { width, height, format } = metadata;
+  if (width < UNZOOM_MIN_SIDE || height < UNZOOM_MIN_SIDE) {
+    throw new Error(
+      `${input} is ${width}x${height}; PixelLab's unzoom needs at least ${UNZOOM_MIN_SIDE}x${UNZOOM_MIN_SIDE} to find the pixel grid, so this is probably already at its native size`
+    );
+  }
+  if (width * height > UNZOOM_MAX_AREA) {
+    throw new Error(`${input} is ${width}x${height}; PixelLab's unzoom takes at most 2048x2048 worth of pixels`);
+  }
+  const res = await client2.unzoom({ image: { base64: bytes.toString("base64"), format }, quantize: opts.quantize });
+  await mkdir11(path39.dirname(out), { recursive: true });
+  await writeFile14(out, res.png);
+  return { out, original: res.originalSize, unzoomed: res.unzoomedSize, zoomFactor: res.zoomFactor, usage: res.usage };
+}
+var FONT_WEIGHTS = ["Bold", "Regular"];
+var FONT_GLYPH_SIZES = [8, 16, 32, 64];
+var FONT_COST_GENERATIONS = 25;
+function fontOutputPaths(out) {
+  const base = path39.resolve(out.replace(/\.(ttf|png)$/i, ""));
+  return { ttf: `${base}.ttf`, atlas: `${base}.png` };
+}
+async function generateFont(client2, opts) {
+  const { ttf, atlas } = fontOutputPaths(opts.out);
+  if (!opts.force) {
+    for (const file of [ttf, atlas]) {
+      if (existsSync29(file)) throw new Error(`${file} already exists; pass --force to replace it`);
+    }
+  }
+  const sleep3 = opts.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const interval = opts.intervalMs ?? 5e3;
+  const timeout = opts.timeoutMs ?? 10 * 6e4;
+  const submitted = await client2.generateFontPro({
+    description: opts.description,
+    weight: opts.weight,
+    glyphPx: opts.glyphPx,
+    seed: opts.seed,
+    fontName: opts.fontName
+  });
+  const jobId = submitted.background_job_id;
+  const started = Date.now();
+  for (; ; ) {
+    const job = await client2.getFontJob(jobId);
+    opts.onProgress?.(job.status);
+    if (job.status === "failed") throw new Error(`PixelLab font job ${jobId} failed upstream`);
+    if (job.status === "completed") {
+      if (!job.download_ttf_url || !job.download_atlas_url) {
+        throw new Error(`PixelLab font job ${jobId} completed without both download URLs`);
+      }
+      const [ttfBytes, atlasBytes] = await Promise.all([
+        client2.download(job.download_ttf_url),
+        client2.download(job.download_atlas_url)
+      ]);
+      await mkdir11(path39.dirname(ttf), { recursive: true });
+      await writeFile14(ttf, ttfBytes);
+      await writeFile14(atlas, atlasBytes);
+      return { jobId, ttf, atlas, glyphPx: job.glyph_px ?? null, usage: job.usage };
+    }
+    if (Date.now() - started > timeout) {
+      throw new Error(
+        `PixelLab font job ${jobId} is still ${job.status} after ${Math.round(timeout / 1e3)} s; it keeps running upstream, but this command has stopped waiting`
+      );
+    }
+    await sleep3(interval);
+  }
+}
+
+// src/cli/commands/pixellab-utils.ts
+function loadKeys(args) {
+  loadEnvFiles(path40.dirname(path40.resolve(args.manifest)));
+  loadEnvFiles(process.cwd());
+}
+async function runUnzoom(args) {
+  if (!args.from) throw new UsageError("unzoom needs --from <image>: the upscaled PNG or JPEG to shrink back to its native grid");
+  const out = args.out ?? defaultUnzoomOut(args.from);
+  if (args.dryRun) {
+    log(`  would unzoom ${args.from} \u2192 ${out}${args.quantize === void 0 ? "" : ` (quantize ${args.quantize})`}; nothing sent`);
+    return;
+  }
+  loadKeys(args);
+  const res = await unzoomFile(clientFromEnv(), args.from, { out, quantize: args.quantize, force: args.force });
+  if (args.json) {
+    log(JSON.stringify({ version: 1, ...res }, null, 2));
+    return;
+  }
+  log(
+    `  ${res.original.width}x${res.original.height} \u2192 ${res.unzoomed.width}x${res.unzoomed.height} (each art pixel was ${res.zoomFactor}x${res.zoomFactor}); wrote ${res.out}`
+  );
+  log("  the result is opaque: PixelLab composites transparency onto white first");
+}
+async function runFont(args) {
+  if (!args.description) throw new UsageError('font needs --description "<style>", e.g. "warm orange arcade font"');
+  if (!args.out) throw new UsageError("font needs --out <base>: <base>.ttf and <base>.png are written");
+  const weight = args.weight ?? "Regular";
+  if (!FONT_WEIGHTS.includes(weight)) {
+    throw new UsageError(`--weight must be ${FONT_WEIGHTS.join(" or ")}, got "${args.weight}"`);
+  }
+  const glyphPx = args.glyphPx ?? 16;
+  if (!FONT_GLYPH_SIZES.includes(glyphPx)) {
+    throw new UsageError(`--glyph-px must be ${FONT_GLYPH_SIZES.join(", ")}, got "${args.glyphPx}"`);
+  }
+  const { ttf, atlas } = fontOutputPaths(args.out);
+  log(`  font: "${args.description}", ${weight}, ${glyphPx}px glyphs \u2192 ${ttf} + ${atlas}`);
+  log(`  cost: ${FONT_COST_GENERATIONS} generations (PixelLab's documented price)`);
+  if (args.budget !== void 0 && args.budget < FONT_COST_GENERATIONS) {
+    throw new Error(`--budget ${args.budget} is below this font's ${FONT_COST_GENERATIONS}-generation cost`);
+  }
+  if (args.dryRun) {
+    log("  dry run: nothing sent");
+    return;
+  }
+  if (!await confirm(`  Spend ${FONT_COST_GENERATIONS} generations on this font?`, args.yes)) return;
+  loadKeys(args);
+  let last = "";
+  const res = await generateFont(clientFromEnv(), {
+    description: args.description,
+    weight,
+    glyphPx,
+    fontName: args.name,
+    out: args.out,
+    force: args.force,
+    onProgress: (status) => {
+      if (status !== last) log(`  ${status}\u2026`);
+      last = status;
+    }
+  });
+  if (args.json) {
+    log(JSON.stringify({ version: 1, ...res }, null, 2));
+    return;
+  }
+  log(`  wrote ${res.ttf}`);
+  log(`  wrote ${res.atlas}`);
+}
+
+// src/cli/commands/quality.ts
+import path42 from "path";
+import { readFile as readFile28 } from "fs/promises";
+
+// src/pipeline/quality-regression.ts
+import path41 from "path";
+import { existsSync as existsSync30 } from "fs";
+import { readFile as readFile27 } from "fs/promises";
 import { z as z9 } from "zod";
 var SHA256_RE = /^[0-9a-f]{64}$/;
 var HEX_RE = /^#[0-9a-f]{6}$/;
 var MAX_REDMEAN_DISTANCE = 765;
 var QualityPathSchema = z9.string().min(1).refine(
-  (value) => !path39.posix.isAbsolute(value) && !value.includes("\\"),
+  (value) => !path41.posix.isAbsolute(value) && !value.includes("\\"),
   "expected a portable relative path"
 );
 var DEFAULT_QUALITY_TOLERANCES = {
@@ -17883,10 +18499,10 @@ function measureDecodedImageQuality(png, digest2) {
   };
 }
 async function measureImageQuality(file) {
-  const absolute = path39.resolve(file);
+  const absolute = path41.resolve(file);
   let bytes;
   try {
-    bytes = await readFile26(absolute);
+    bytes = await readFile27(absolute);
   } catch (error) {
     throw new Error(`Cannot read quality image ${absolute}: ${message4(error)}`, { cause: error });
   }
@@ -17905,11 +18521,11 @@ function resolveQualityInputs(raw, inputsFilePath) {
   }
   const ids = parsed.data.map((entry) => entry.id);
   if (new Set(ids).size !== ids.length) throw new Error("--inputs contains a duplicate quality case id.");
-  const root = path39.dirname(path39.resolve(inputsFilePath));
+  const root = path41.dirname(path41.resolve(inputsFilePath));
   return parsed.data.map((entry) => ({
     id: entry.id,
-    file: path39.resolve(root, entry.path),
-    ...entry.record ? { record: path39.resolve(root, entry.record) } : {},
+    file: path41.resolve(root, entry.path),
+    ...entry.record ? { record: path41.resolve(root, entry.record) } : {},
     tolerances: QualityToleranceSchema.parse({
       ...DEFAULT_QUALITY_TOLERANCES,
       ...entry.tolerances
@@ -17917,7 +18533,7 @@ function resolveQualityInputs(raw, inputsFilePath) {
   }));
 }
 function portableRelative2(from, to) {
-  return path39.relative(from, path39.resolve(to)).split(path39.sep).join("/") || ".";
+  return path41.relative(from, path41.resolve(to)).split(path41.sep).join("/") || ".";
 }
 async function verifyRecordForImage(recordPath, imagePath) {
   const verification = await verifyArtifactBundle(recordPath);
@@ -17932,20 +18548,20 @@ async function verifyRecordForImage(recordPath, imagePath) {
   if (record.kind !== "refine" || options === null || typeof options !== "object" || options.schema !== "pixelkiln-quality") {
     throw new Error(`Quality record ${recordPath} is not a PixelKiln refinement record.`);
   }
-  const outputs = record.outputs.map((output) => path39.resolve(path39.dirname(recordPath), output.path));
-  if (!outputs.includes(path39.resolve(imagePath))) {
+  const outputs = record.outputs.map((output) => path41.resolve(path41.dirname(recordPath), output.path));
+  if (!outputs.includes(path41.resolve(imagePath))) {
     throw new Error(`Quality record ${recordPath} does not own ${imagePath}.`);
   }
 }
 async function snapshotQualityBaseline(inputs, baselinePath, options = {}) {
   if (!inputs.length) throw new Error("Cannot snapshot an empty quality baseline.");
-  const absolute = path39.resolve(baselinePath);
+  const absolute = path41.resolve(baselinePath);
   for (const input of inputs) {
-    if (path39.resolve(input.file) === absolute || input.record && path39.resolve(input.record) === absolute) {
+    if (path41.resolve(input.file) === absolute || input.record && path41.resolve(input.record) === absolute) {
       throw new Error(`Quality baseline output would overwrite an input: ${absolute}.`);
     }
   }
-  const root = path39.dirname(absolute);
+  const root = path41.dirname(absolute);
   const cases = [];
   for (const input of [...inputs].sort((a, b) => a.id.localeCompare(b.id))) {
     const expected = await measureImageQuality(input.file);
@@ -17972,8 +18588,8 @@ async function snapshotQualityBaseline(inputs, baselinePath, options = {}) {
     cases
   });
   const data = Buffer.from(JSON.stringify(baseline, null, 2) + "\n");
-  if (existsSync29(absolute) && !options.force) {
-    const current = await readFile26(absolute);
+  if (existsSync30(absolute) && !options.force) {
+    const current = await readFile27(absolute);
     if (!current.equals(data)) {
       throw new OverwriteRefusedError(
         `Quality baseline already exists with different content: ${absolute}. Pass --force to replace it.`,
@@ -17985,10 +18601,10 @@ async function snapshotQualityBaseline(inputs, baselinePath, options = {}) {
   return { baseline, path: absolute, changed: result.changed.length > 0 };
 }
 async function readQualityBaseline(baselinePath) {
-  const absolute = path39.resolve(baselinePath);
+  const absolute = path41.resolve(baselinePath);
   let raw;
   try {
-    raw = JSON.parse(await readFile26(absolute, "utf8"));
+    raw = JSON.parse(await readFile27(absolute, "utf8"));
   } catch (error) {
     throw new Error(`Could not read quality baseline ${absolute}: ${message4(error)}`, { cause: error });
   }
@@ -18058,12 +18674,12 @@ function regressionViolations(expected, actual, tolerances) {
   return { violations, warnings };
 }
 async function checkQualityBaseline(baselinePath) {
-  const absolute = path39.resolve(baselinePath);
+  const absolute = path41.resolve(baselinePath);
   const baseline = await readQualityBaseline(absolute);
-  const root = path39.dirname(absolute);
+  const root = path41.dirname(absolute);
   const cases = [];
   for (const entry of baseline.cases) {
-    const file = path39.resolve(root, entry.file);
+    const file = path41.resolve(root, entry.file);
     let actual = null;
     const violations = [];
     const warnings = [];
@@ -18076,7 +18692,7 @@ async function checkQualityBaseline(baselinePath) {
       violations.push(message4(error));
     }
     if (entry.record) {
-      const recordPath = path39.resolve(root, entry.record.path);
+      const recordPath = path41.resolve(root, entry.record.path);
       try {
         const recordHash = await sha256File(recordPath);
         if (recordHash !== entry.record.sha256) violations.push("quality record hash changed");
@@ -18118,15 +18734,15 @@ async function runQuality(args) {
     if (!args.out) throw new Error("quality snapshot needs --out <pixelkiln.quality.json>.");
     let raw;
     try {
-      raw = JSON.parse(await readFile27(path40.resolve(args.inputs), "utf8"));
+      raw = JSON.parse(await readFile28(path42.resolve(args.inputs), "utf8"));
     } catch (error) {
       throw new Error(
-        `Could not read quality inputs ${path40.resolve(args.inputs)}: ${error instanceof Error ? error.message : String(error)}`,
+        `Could not read quality inputs ${path42.resolve(args.inputs)}: ${error instanceof Error ? error.message : String(error)}`,
         { cause: error }
       );
     }
     const inputs = resolveQualityInputs(raw, args.inputs);
-    if (path40.resolve(args.inputs) === path40.resolve(args.out)) {
+    if (path42.resolve(args.inputs) === path42.resolve(args.out)) {
       throw new Error("quality snapshot --out must not overwrite its --inputs file.");
     }
     const result = await snapshotQualityBaseline(inputs, args.out, { force: args.force });
@@ -18139,7 +18755,7 @@ async function runQuality(args) {
       }, null, 2));
     } else {
       log(
-        `  ${result.changed ? "wrote" : "unchanged"} ${path40.relative(process.cwd(), result.path)} (${result.baseline.cases.length} case(s))`
+        `  ${result.changed ? "wrote" : "unchanged"} ${path42.relative(process.cwd(), result.path)} (${result.baseline.cases.length} case(s))`
       );
       log(`  Review the tolerances, commit the baseline, then run quality check in CI.`);
     }
@@ -18165,12 +18781,12 @@ async function runQuality(args) {
 }
 
 // src/cli/commands/recipe.ts
-import path42 from "path";
+import path44 from "path";
 
 // src/recipes.ts
-import path41 from "path";
-import { existsSync as existsSync30 } from "fs";
-import { readdir as readdir3, readFile as readFile28 } from "fs/promises";
+import path43 from "path";
+import { existsSync as existsSync31 } from "fs";
+import { readdir as readdir3, readFile as readFile29 } from "fs/promises";
 import { fileURLToPath } from "url";
 import { z as z10 } from "zod";
 var SHA256_RE2 = /^[0-9a-f]{64}$/;
@@ -18179,7 +18795,7 @@ var VERSION_RE = /^\d+\.\d+\.\d+$/;
 var RECIPE_FILE = "pixelkiln.recipe.json";
 var RECIPE_DIR_TOKEN = "{{recipeDir}}";
 var PortablePathSchema = z10.string().min(1).refine((value) => {
-  if (value.includes("\\") || path41.posix.isAbsolute(value)) return false;
+  if (value.includes("\\") || path43.posix.isAbsolute(value)) return false;
   const parts = value.split("/");
   return !parts.includes("") && !parts.includes(".") && !parts.includes("..");
 }, "expected a portable relative path without '.', '..', or backslashes");
@@ -18355,10 +18971,10 @@ function message5(error) {
   return error instanceof Error ? error.message : String(error);
 }
 async function readRecipeFile(recipePath, bundled) {
-  const absolute = path41.resolve(recipePath);
+  const absolute = path43.resolve(recipePath);
   let raw;
   try {
-    raw = JSON.parse(await readFile28(absolute, "utf8"));
+    raw = JSON.parse(await readFile29(absolute, "utf8"));
   } catch (error) {
     throw new Error(`Could not read recipe ${absolute}: ${message5(error)}`, { cause: error });
   }
@@ -18369,13 +18985,13 @@ async function readRecipeFile(recipePath, bundled) {
 ` + parsed.error.issues.map((issue) => `  ${issue.path.join(".") || "$"}: ${issue.message}`).join("\n")
     );
   }
-  return { recipe: parsed.data, authored: raw, path: absolute, dir: path41.dirname(absolute), bundled };
+  return { recipe: parsed.data, authored: raw, path: absolute, dir: path43.dirname(absolute), bundled };
 }
 async function walkRecipeFiles(root) {
-  if (!existsSync30(root)) return [];
+  if (!existsSync31(root)) return [];
   const out = [];
   for (const entry of await readdir3(root, { withFileTypes: true })) {
-    const resolved = path41.join(root, entry.name);
+    const resolved = path43.join(root, entry.name);
     if (entry.isDirectory()) out.push(...await walkRecipeFiles(resolved));
     else if (entry.isFile() && entry.name === RECIPE_FILE) out.push(resolved);
   }
@@ -18386,7 +19002,7 @@ function bundledRecipeRoot() {
 }
 async function listBundledRecipes(root = bundledRecipeRoot()) {
   const recipes = await Promise.all(
-    (await walkRecipeFiles(path41.resolve(root))).map((file) => readRecipeFile(file, true))
+    (await walkRecipeFiles(path43.resolve(root))).map((file) => readRecipeFile(file, true))
   );
   return recipes.sort(
     (a, b) => a.recipe.id.localeCompare(b.recipe.id) || compareVersions(b.recipe.version, a.recipe.version)
@@ -18409,9 +19025,9 @@ function parseSelector(selector) {
   return { id: match[1], version: match[2] };
 }
 async function resolveRecipe(target, bundledRoot = bundledRecipeRoot()) {
-  const local = path41.resolve(target);
-  if (existsSync30(local)) {
-    const recipePath = path41.basename(local) === RECIPE_FILE ? local : path41.join(local, RECIPE_FILE);
+  const local = path43.resolve(target);
+  if (existsSync31(local)) {
+    const recipePath = path43.basename(local) === RECIPE_FILE ? local : path43.join(local, RECIPE_FILE);
     return readRecipeFile(recipePath, false);
   }
   if (target.startsWith(".") || target.startsWith("/") || target.includes("\\")) {
@@ -18425,8 +19041,8 @@ async function resolveRecipe(target, bundledRoot = bundledRecipeRoot()) {
   return matches[0];
 }
 async function verifyFile(root, file) {
-  const absolute = path41.resolve(root, ...file.path.split("/"));
-  if (!existsSync30(absolute)) {
+  const absolute = path43.resolve(root, ...file.path.split("/"));
+  if (!existsSync31(absolute)) {
     return { path: file.path, expectedSha256: file.sha256, actualSha256: null, status: "missing" };
   }
   const actualSha256 = await sha256File(absolute);
@@ -18441,7 +19057,7 @@ async function verifyRecipe(target, options = {}) {
   const loaded = await resolveRecipe(target, options.bundledRoot);
   const actualIntegrity = recipeDigest(loaded.authored);
   const files = await Promise.all(loaded.recipe.files.map((file) => verifyFile(loaded.dir, file)));
-  const modelRoot = options.modelRoot ? path41.resolve(options.modelRoot) : null;
+  const modelRoot = options.modelRoot ? path43.resolve(options.modelRoot) : null;
   const models = modelRoot ? await Promise.all(loaded.recipe.models.map(async (model) => ({
     ...await verifyFile(modelRoot, model),
     source: model.source,
@@ -18475,7 +19091,7 @@ async function verifyRecipe(target, options = {}) {
   };
 }
 function renderStyle(style, destination, cwd) {
-  const portableDir = path41.relative(cwd, destination).split(path41.sep).join("/") || ".";
+  const portableDir = path43.relative(cwd, destination).split(path43.sep).join("/") || ".";
   const replace = (value) => {
     if (typeof value === "string") return value.replaceAll(RECIPE_DIR_TOKEN, portableDir);
     if (Array.isArray(value)) return value.map(replace);
@@ -18487,25 +19103,25 @@ function renderStyle(style, destination, cwd) {
   return replace(style);
 }
 async function installRecipe(target, options = {}) {
-  const cwd = path41.resolve(options.cwd ?? process.cwd());
+  const cwd = path43.resolve(options.cwd ?? process.cwd());
   const loaded = await resolveRecipe(target, options.bundledRoot);
   const verification = await verifyRecipe(loaded.path);
   if (!verification.ok) {
     throw new Error(`Recipe ${loaded.recipe.id}@${loaded.recipe.version} failed integrity verification.`);
   }
-  const destination = options.out ? path41.resolve(cwd, options.out) : path41.join(cwd, "pixelkiln-recipes", ...loaded.recipe.id.split("/"), loaded.recipe.version);
+  const destination = options.out ? path43.resolve(cwd, options.out) : path43.join(cwd, "pixelkiln-recipes", ...loaded.recipe.id.split("/"), loaded.recipe.version);
   const sources = [
     { path: RECIPE_FILE, source: loaded.path },
-    ...loaded.recipe.files.map((file) => ({ path: file.path, source: path41.join(loaded.dir, ...file.path.split("/")) }))
+    ...loaded.recipe.files.map((file) => ({ path: file.path, source: path43.join(loaded.dir, ...file.path.split("/")) }))
   ];
   const files = await Promise.all(sources.map(async (file) => ({
-    path: path41.join(destination, ...file.path.split("/")),
-    data: await readFile28(file.source)
+    path: path43.join(destination, ...file.path.split("/")),
+    data: await readFile29(file.source)
   })));
   if (!options.force) {
     for (const file of files) {
-      if (!existsSync30(file.path)) continue;
-      const current = await readFile28(file.path);
+      if (!existsSync31(file.path)) continue;
+      const current = await readFile29(file.path);
       if (!current.equals(file.data)) {
         throw new OverwriteRefusedError(
           `Recipe destination has local changes: ${file.path}. Choose another --out or pass --force to replace declared recipe files.`,
@@ -18599,14 +19215,14 @@ async function runRecipe(args) {
       }, null, 2));
     } else {
       log(`  installed ${result.recipe.id}@${result.recipe.version}`);
-      log(`  ${path42.relative(process.cwd(), result.destination) || "."}`);
+      log(`  ${path44.relative(process.cwd(), result.destination) || "."}`);
       log(`
   Add this entry under your manifest's styles object:`);
       log(JSON.stringify({ [result.styleId]: result.style }, null, 2));
       if (result.recipe.models.length) {
         log(`
   Models are not downloaded automatically. Verify them with:`);
-        log(`  pixelkiln recipe verify ${path42.relative(process.cwd(), result.destination)} --model-root <ComfyUI/models>`);
+        log(`  pixelkiln recipe verify ${path44.relative(process.cwd(), result.destination)} --model-root <ComfyUI/models>`);
       }
     }
     return;
@@ -18614,7 +19230,7 @@ async function runRecipe(args) {
 }
 
 // src/cli/commands/refine.ts
-import path43 from "path";
+import path45 from "path";
 async function runRefine(args) {
   if (args.from || args.subcommand === "approve") {
     if (!args.from) {
@@ -18644,12 +19260,12 @@ async function runRefine(args) {
           `  recovered ${result3.detection.columns}x${result3.detection.rows} native grid (${result3.detection.confidence}: ${result3.detection.consensus})`
         );
         log(`  enforced ${result3.palette.length}-color palette without dithering`);
-        log(`  wrote ${path43.relative(process.cwd(), result3.output)}`);
-        log(`  quality record: ${path43.relative(process.cwd(), result3.record)}`);
+        log(`  wrote ${path45.relative(process.cwd(), result3.output)}`);
+        log(`  quality record: ${path45.relative(process.cwd(), result3.record)}`);
         log(`
   Automated checks passed. Human 1\xD7 review is still required:`);
         log(
-          `    pixelkiln refine approve --from ${path43.relative(process.cwd(), result3.record)} --reviewer "Your Name"`
+          `    pixelkiln refine approve --from ${path45.relative(process.cwd(), result3.record)} --reviewer "Your Name"`
         );
       }
       return;
@@ -18677,7 +19293,7 @@ async function runRefine(args) {
       if (args.json) log(JSON.stringify(result3, null, 2));
       else {
         log(
-          result3.options.frameSet ? `  approved ${result3.outputs.length} frames in ${path43.relative(process.cwd(), result3.record)} by ${args.reviewer.trim()}` : `  approved ${path43.relative(process.cwd(), result3.output)} by ${args.reviewer.trim()}`
+          result3.options.frameSet ? `  approved ${result3.outputs.length} frames in ${path45.relative(process.cwd(), result3.record)} by ${args.reviewer.trim()}` : `  approved ${path45.relative(process.cwd(), result3.output)} by ${args.reviewer.trim()}`
         );
       }
       return;
@@ -18686,7 +19302,7 @@ async function runRefine(args) {
     if (args.json) {
       log(JSON.stringify(result2, null, 2));
     } else {
-      log(`  ${result2.safe ? "release-ready" : "not release-ready"}: ${path43.relative(process.cwd(), result2.output || result2.record)}`);
+      log(`  ${result2.safe ? "release-ready" : "not release-ready"}: ${path45.relative(process.cwd(), result2.output || result2.record)}`);
       for (const reason of result2.reasons) log(`    ${reason}`);
     }
     if (!result2.safe) process.exitCode = 1;
@@ -18732,7 +19348,7 @@ async function runRefine(args) {
       log(`  ${item.state.padEnd(16)} ${item.key}  ${item.reason}`);
       if (item.state === "needs-approval") {
         log(
-          `    pixelkiln refine approve --from ${path43.relative(process.cwd(), item.record)} --reviewer "Your Name"`
+          `    pixelkiln refine approve --from ${path45.relative(process.cwd(), item.record)} --reviewer "Your Name"`
         );
       }
     }
@@ -18784,15 +19400,15 @@ async function runTools(args) {
 }
 
 // src/cli/commands/workspace.ts
-import path44 from "path";
-import { existsSync as existsSync31 } from "fs";
+import path46 from "path";
+import { existsSync as existsSync32 } from "fs";
 async function runWorkspace(args) {
-  const workspacePath = path44.resolve(args.workspace ?? "pixelkiln.workspace.json");
-  const dir = path44.dirname(workspacePath);
+  const workspacePath = path46.resolve(args.workspace ?? "pixelkiln.workspace.json");
+  const dir = path46.dirname(workspacePath);
   if (args.subcommand === "add") {
-    const manifestPath = path44.resolve(args.target);
+    const manifestPath = path46.resolve(args.target);
     const loadedTarget = await loadManifest(manifestPath);
-    const lockPath = args.explicitLock ? path44.resolve(args.explicitLock) : path44.join(path44.dirname(manifestPath), "pixelkiln.lock.json");
+    const lockPath = args.explicitLock ? path46.resolve(args.explicitLock) : path46.join(path46.dirname(manifestPath), "pixelkiln.lock.json");
     const ws = await loadWorkspace(workspacePath);
     const id = args.name ?? loadedTarget.manifest.name;
     if (ws.projects.some((p) => p.id === id)) {
@@ -18812,10 +19428,10 @@ async function runWorkspace(args) {
       ...args.account ? { account: args.account } : {}
     };
     await saveWorkspace(workspacePath, { version: 1, projects: [...ws.projects, project] });
-    log(`  registered "${id}" in ${path44.relative(process.cwd(), workspacePath)}`);
+    log(`  registered "${id}" in ${path46.relative(process.cwd(), workspacePath)}`);
     log(`    manifest: ${project.manifest}`);
     log(`    lock:     ${project.lock}`);
-    if (!existsSync31(lockPath)) {
+    if (!existsSync32(lockPath)) {
       log(
         `  warning: no lockfile there yet; this project contributes no claims until one is generated`
       );
@@ -18824,7 +19440,7 @@ async function runWorkspace(args) {
   }
   if (args.subcommand === "remove") {
     const ws = await loadWorkspace(workspacePath);
-    const resolvedTarget = path44.resolve(args.target);
+    const resolvedTarget = path46.resolve(args.target);
     const match = ws.projects.find(
       (p) => p.id === args.target || resolveProject(dir, p).manifestPath === resolvedTarget
     );
@@ -18835,11 +19451,11 @@ async function runWorkspace(args) {
       version: 1,
       projects: ws.projects.filter((p) => p !== match)
     });
-    log(`  removed "${match.id}" from ${path44.relative(process.cwd(), workspacePath)}`);
+    log(`  removed "${match.id}" from ${path46.relative(process.cwd(), workspacePath)}`);
     return;
   }
   if (args.subcommand === "list") {
-    if (!existsSync31(workspacePath)) {
+    if (!existsSync32(workspacePath)) {
       throw new Error(`Workspace catalog not found: ${workspacePath}`);
     }
     const ws = await loadWorkspace(workspacePath);
@@ -18847,9 +19463,9 @@ async function runWorkspace(args) {
     if (args.json) {
       log(JSON.stringify({ version: 1, workspace: workspacePath, projects: ws.projects, diagnostics }, null, 2));
     } else if (!ws.projects.length) {
-      log(`  no projects registered in ${path44.relative(process.cwd(), workspacePath)}`);
+      log(`  no projects registered in ${path46.relative(process.cwd(), workspacePath)}`);
     } else {
-      log(`  ${ws.projects.length} project(s) in ${path44.relative(process.cwd(), workspacePath)}:`);
+      log(`  ${ws.projects.length} project(s) in ${path46.relative(process.cwd(), workspacePath)}:`);
       for (const p of ws.projects) {
         log(`    ${p.id.padEnd(24)} ${p.manifest.padEnd(40)} (${p.provider}${p.account ? `, ${p.account}` : ""})`);
       }
@@ -18859,7 +19475,7 @@ async function runWorkspace(args) {
     return;
   }
   if (args.subcommand === "status") {
-    if (!existsSync31(workspacePath)) {
+    if (!existsSync32(workspacePath)) {
       throw new Error(`Workspace catalog not found: ${workspacePath}`);
     }
     const ws = await loadWorkspace(workspacePath);
@@ -18867,7 +19483,7 @@ async function runWorkspace(args) {
     if (args.json) {
       log(JSON.stringify({ ...report, workspace: workspacePath }, null, 2));
     } else {
-      log(`  workspace: ${path44.relative(process.cwd(), workspacePath)}`);
+      log(`  workspace: ${path46.relative(process.cwd(), workspacePath)}`);
       for (const p of report.projects) {
         if (p.error) {
           log(`
@@ -18921,8 +19537,8 @@ async function runHelp() {
 async function runVersion() {
   for (const up of ["../package.json", "../../package.json"]) {
     const url = new URL(up, import.meta.url);
-    if (!existsSync32(url)) continue;
-    const pkg = JSON.parse(await readFile29(url, "utf8"));
+    if (!existsSync33(url)) continue;
+    const pkg = JSON.parse(await readFile30(url, "utf8"));
     if (pkg.name === "pixelkiln") {
       log(`${pkg.name} ${pkg.version}`);
       return;
@@ -18965,7 +19581,9 @@ var RUNNERS = {
   quality: runQuality,
   refine: runRefine,
   recipe: runRecipe,
-  workspace: runWorkspace
+  workspace: runWorkspace,
+  unzoom: runUnzoom,
+  font: runFont
 };
 async function main(argv = process.argv.slice(2)) {
   const args = parseArgs(argv);