pixelkiln 0.61.0 → 0.63.0

package/dist/index.js

@@ -1,7 +1,7 @@
 // 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",
@@ -10,7 +10,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;
@@ -191,6 +193,14 @@ var CharacterAnimationSchema = z.object({
   template: z.string().min(1).optional(),
   /** Direction to animate. */
   direction: CharacterDirectionSchema.default("south"),
+  /**
+   * Shorthand for one loop in several directions, instead of `direction`.
+   * Expanded when the manifest loads into one loop per named direction
+   * (`<id>.<direction>`) plus a mirror for each direction whose flip is
+   * not named, exactly as if each had been written out. See
+   * `src/loop-directions.ts`.
+   */
+  directions: z.array(CharacterDirectionSchema).min(1).optional(),
   /** Frames to generate without a template (v3). Even, 4 to 16. */
   frames: z.number().int().min(4).max(16).optional(),
   /** Playback rate recorded with the frames; PixelLab does not store one. */
@@ -219,6 +229,13 @@ var CharacterAnimationSchema = z.object({
   /** v3 text loops only: let PixelLab expand the action into a fuller motion description first. */
   enhancePrompt: z.boolean().optional()
 }).strict().superRefine((animation, context) => {
+  if (animation.directions !== void 0) {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "directions is expanded when the manifest loads; validate the loaded manifest, not the raw file",
+      path: ["directions"]
+    });
+  }
   if (animation.frames !== void 0 && animation.frames % 2 !== 0) {
     context.addIssue({ code: z.ZodIssueCode.custom, message: "frames must be even", path: ["frames"] });
   }
@@ -279,9 +296,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(),
@@ -325,14 +346,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,
@@ -341,6 +363,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,
@@ -352,6 +395,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(),
@@ -470,7 +515,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.
    */
@@ -1348,6 +1393,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),
@@ -1432,6 +1492,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 });
@@ -1460,9 +1531,9 @@ var PixelLabClient = class {
   apiKey;
   http;
   /** Retries transport failures, 429, and 5xx; see http.ts for the policy. */
-  async request(path33, init) {
+  async request(path34, init) {
     const auth = this.apiKey.startsWith("Bearer ") ? this.apiKey : `Bearer ${this.apiKey}`;
-    const res = await this.http(`${BASE}${path33}`, {
+    const res = await this.http(`${BASE}${path34}`, {
       ...init,
       headers: {
         Authorization: auth,
@@ -1472,13 +1543,13 @@ var PixelLabClient = class {
     });
     const text = await res.text();
     if (!res.ok) {
-      throw new PixelLabError(`${init?.method ?? "GET"} ${path33} \u2192 ${res.status}`, res.status, text);
+      throw new PixelLabError(`${init?.method ?? "GET"} ${path34} \u2192 ${res.status}`, res.status, text);
     }
     if (!text) return {};
     try {
       return JSON.parse(text);
     } catch {
-      throw new Error(`${init?.method ?? "GET"} ${path33} returned invalid JSON`);
+      throw new Error(`${init?.method ?? "GET"} ${path34} returned invalid JSON`);
     }
   }
   async balance() {
@@ -1864,10 +1935,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 path33;
+    let path34;
     let body;
     if (args.mode === "v3") {
-      path33 = "/create-character-v3";
+      path34 = "/create-character-v3";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -1881,7 +1952,7 @@ var PixelLabClient = class {
         ...args.enhancePrompt ? { enhance_prompt: true } : {}
       };
     } else if (args.mode === "pro-flash") {
-      path33 = "/create-character-pro-flash";
+      path34 = "/create-character-pro-flash";
       const traits = args.styleTraits;
       body = {
         description: args.description,
@@ -1904,7 +1975,7 @@ var PixelLabClient = class {
         } : {}
       };
     } else if (args.mode === "pro") {
-      path33 = "/create-character-pro";
+      path34 = "/create-character-pro";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -1918,7 +1989,7 @@ var PixelLabClient = class {
         ...!south && args.styleCharacterId ? { style_character_id: args.styleCharacterId } : {}
       };
     } else {
-      path33 = args.directions === 4 ? "/create-character-with-4-directions" : "/create-character-with-8-directions";
+      path34 = args.directions === 4 ? "/create-character-with-4-directions" : "/create-character-with-8-directions";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -1935,8 +2006,8 @@ var PixelLabClient = class {
         ...palette
       };
     }
-    const raw = await this.request(path33, { method: "POST", body: JSON.stringify(body) });
-    return validateResponse(CharacterSubmitSchema, raw, path33.slice(1));
+    const raw = await this.request(path34, { method: "POST", body: JSON.stringify(body) });
+    return validateResponse(CharacterSubmitSchema, raw, path34.slice(1));
   }
   /** A text edit of an existing character, applied to every direction and stored as a sibling. */
   async createCharacterState(args) {
@@ -2098,20 +2169,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;
@@ -2121,8 +2224,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
@@ -2131,19 +2236,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,
@@ -2804,10 +3007,10 @@ import { createReadStream } from "fs";
 function sha256(data) {
   return createHash("sha256").update(data).digest("hex");
 }
-async function sha256File(path33) {
+async function sha256File(path34) {
   return new Promise((resolve, reject) => {
     const hash = createHash("sha256");
-    const stream = createReadStream(path33);
+    const stream = createReadStream(path34);
     stream.on("data", (chunk2) => hash.update(chunk2));
     stream.on("error", reject);
     stream.on("end", () => resolve(hash.digest("hex")));
@@ -2835,7 +3038,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,
@@ -3042,7 +3245,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`,
@@ -3052,12 +3255,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,
@@ -3085,6 +3291,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;
@@ -3113,6 +3325,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)) {
@@ -3121,9 +3339,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`
         );
       }
     }
@@ -3147,6 +3366,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");
     }
@@ -3163,6 +3412,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, [
@@ -3246,8 +3503,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`);
     }
@@ -3814,6 +4071,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({
@@ -3942,13 +4212,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 = readFileSync(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 = readFileSync(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`);
@@ -3981,34 +4256,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 = randomUUID();
-      writeFileSync(path.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 = randomUUID();
-      writeFileSync(path.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 = readFileSync(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,
@@ -4048,6 +4334,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 = readFileSync(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 = randomUUID();
+    if (!roles) {
+      writeFileSync(path.join(_PixelLabProvider.cacheDir(), `${jobId}.png`), pngs[0]);
+      return { jobId, metadata: { revisionUsage: usage } };
+    }
+    for (const [index, png] of pngs.entries()) {
+      writeFileSync(path.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
@@ -4068,7 +4384,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);
@@ -4091,6 +4407,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") {
@@ -4117,15 +4434,32 @@ var PixelLabProvider = class _PixelLabProvider {
    * work.
    */
   async pollCachedRevision(jobId, context) {
-    const file = path.join(_PixelLabProvider.cacheDir(), `${jobId}.png`);
-    if (!existsSync(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://${path.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`)}`,
+        role: String(role)
+      }));
+      if (sources.some((source) => !existsSync(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 = path.join(_PixelLabProvider.cacheDir(), `${jobId}.png`);
+    if (!existsSync(file)) return gone;
     const sourceUrl = `file://${file}`;
-    const usage = context?.metadata?.revisionUsage;
     return { status: "ready", objectId: jobId, sourceUrl, sources: [{ url: sourceUrl }], billed: billedFromUsage(usage) };
   }
   /**
@@ -4149,16 +4483,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;
@@ -4190,7 +4529,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`
     };
   }
   /**
@@ -4280,6 +4619,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 = path.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
@@ -4440,9 +4809,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 = path.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`);
-      if (!existsSync(file)) throw new Error(`imagePro job ${jobId} has no cached candidate at index ${index}`);
+      if (!existsSync(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);
@@ -4596,6 +4965,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 = [];
@@ -4688,9 +5063,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(path33, init = {}) {
+  async call(path34, init = {}) {
     if (!this.token) throw new Error("RD_API_KEY is not set");
-    const response = await this.request(`${this.baseUrl}${path33}`, {
+    const response = await this.request(`${this.baseUrl}${path34}`, {
       ...init,
       headers: {
         "Content-Type": "application/json",
@@ -5732,14 +6107,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 {
@@ -5792,6 +6168,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");
       }
@@ -6626,6 +7007,91 @@ import { readFile as readFile3 } from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
 import path5 from "path";
 
+// src/loop-directions.ts
+var SINGLE_OUTPUT_FIELDS = ["file", "cell", "remoteId", "source", "sourceByStyle", "outputRole"];
+var MIRROR_FIELDS = ["category", "tags", "styles"];
+function loopDirectionId(shorthandId, direction) {
+  return `${shorthandId}.${direction}`;
+}
+function expandLoopDirections(raw) {
+  const families = {};
+  const issues = [];
+  if (!isObject2(raw) || !isObject2(raw.assets)) return { raw, families, issues };
+  const assets = raw.assets;
+  if (!Object.values(assets).some((asset) => isObject2(asset) && isObject2(asset.animation) && "directions" in asset.animation)) {
+    return { raw, families, issues };
+  }
+  const expanded = {};
+  const claimed = new Set(Object.keys(assets));
+  for (const [id, asset] of Object.entries(assets)) {
+    if (!isObject2(asset) || !isObject2(asset.animation) || !("directions" in asset.animation)) {
+      expanded[id] = asset;
+      continue;
+    }
+    const where = `assets.${id}.animation.directions`;
+    const { directions: rawDirections, ...animation } = asset.animation;
+    const parsed = CharacterDirectionSchema.array().min(1).safeParse(rawDirections);
+    if (!parsed.success) {
+      issues.push(`${where}: expected a non-empty list of directions (${CharacterDirectionSchema.options.join(", ")})`);
+      continue;
+    }
+    const directions = parsed.data;
+    const duplicate = directions.find((direction, index) => directions.indexOf(direction) !== index);
+    if (duplicate) {
+      issues.push(`${where}: "${duplicate}" is listed twice`);
+      continue;
+    }
+    if ("direction" in animation) {
+      issues.push(`assets.${id}.animation: direction and directions are mutually exclusive; directions names every loop to make`);
+      continue;
+    }
+    const single = SINGLE_OUTPUT_FIELDS.filter((field) => field in asset);
+    if (single.length) {
+      issues.push(
+        `assets.${id}: ${single.join(", ")} name${single.length === 1 ? "s" : ""} one output, but directions makes ${directions.length} loops; declare the loops explicitly to set ${single.length === 1 ? "it" : "them"} per direction`
+      );
+      continue;
+    }
+    const loops = directions.map((direction) => ({ id: loopDirectionId(id, direction), direction }));
+    const named = new Set(directions);
+    const mirrors = [];
+    for (const { id: loopId, direction } of loops) {
+      const flipped = MIRRORED_DIRECTION[direction];
+      if (flipped === direction || named.has(flipped)) continue;
+      named.add(flipped);
+      mirrors.push({ id: loopDirectionId(id, flipped), of: loopId });
+    }
+    const ids = [...loops.map((loop) => loop.id), ...mirrors.map((mirror) => mirror.id)];
+    const collision = ids.find((expandedId) => claimed.has(expandedId));
+    if (collision) {
+      issues.push(`${where}: expands to "${collision}", which is already declared`);
+      continue;
+    }
+    for (const expandedId of ids) claimed.add(expandedId);
+    for (const loop of loops) {
+      expanded[loop.id] = { ...asset, animation: { ...animation, direction: loop.direction } };
+    }
+    for (const mirror of mirrors) {
+      const inherited = {};
+      for (const field of MIRROR_FIELDS) if (field in asset) inherited[field] = asset[field];
+      expanded[mirror.id] = { mirror: mirror.of, ...inherited };
+    }
+    families[id] = ids;
+  }
+  return { raw: { ...raw, assets: expanded }, families, issues };
+}
+function expandAssetFilter(ids, families) {
+  if (!families) return [...ids];
+  return [...new Set(ids.flatMap((id) => families[id] ?? [id]))];
+}
+function loopShorthandOf(assetId, families) {
+  if (!families) return void 0;
+  return Object.keys(families).find((id) => families[id].includes(assetId));
+}
+function isObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/outputs.ts
 import { existsSync as existsSync3 } from "fs";
 import path4 from "path";
@@ -6944,7 +7410,12 @@ function frameSetFps(entry) {
 async function loadManifest(manifestPath) {
   const abs = path5.resolve(manifestPath);
   if (!existsSync4(abs)) throw new ProjectError(`No manifest at ${abs}`);
-  const input = ManifestInputSchema.safeParse(JSON.parse(await readFile3(abs, "utf8")));
+  const expansion = expandLoopDirections(JSON.parse(await readFile3(abs, "utf8")));
+  if (expansion.issues.length) {
+    throw new ProjectError(`Manifest at ${abs} is invalid:
+${expansion.issues.map((i) => `  ${i}`).join("\n")}`);
+  }
+  const input = ManifestInputSchema.safeParse(expansion.raw);
   if (!input.success) {
     const issues = formatManifestIssues(input.error.issues);
     throw new ProjectError(`Manifest at ${abs} is invalid:
@@ -7029,7 +7500,8 @@ ${issues}`);
     throw new ProjectError(`Manifest at ${abs} is invalid:
 ${unknownReferences.map((i) => `  ${i}`).join("\n")}`);
   }
-  return { manifest: parsed.data, root: path5.dirname(abs), path: abs };
+  const loopFamilies = Object.keys(expansion.families).length ? { loopFamilies: expansion.families } : {};
+  return { manifest: parsed.data, root: path5.dirname(abs), path: abs, ...loopFamilies };
 }
 function parentAssetId(asset) {
   return asset?.revision?.from ?? asset?.state?.of ?? asset?.animation?.of;
@@ -7113,12 +7585,13 @@ async function resolveSpecs(loaded, filter) {
       );
     }
   }
-  for (const unknownAsset of filter?.assets ?? []) {
+  const assetFilter = expandAssetFilter(filter?.assets ?? [], loaded.loopFamilies);
+  for (const unknownAsset of assetFilter) {
     if (!manifest.assets[unknownAsset]) {
       throw new UsageError(`Unknown asset "${unknownAsset}".`);
     }
   }
-  const requestedAssetIds = new Set(filter?.assets?.length ? filter.assets : Object.keys(manifest.assets));
+  const requestedAssetIds = new Set(assetFilter.length ? assetFilter : Object.keys(manifest.assets));
   const resolutionAssetIds = new Set(requestedAssetIds);
   for (const assetId of [...requestedAssetIds]) {
     let current = parentAssetId(manifest.assets[assetId]);
@@ -7213,7 +7686,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);
@@ -7280,7 +7753,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,
@@ -7320,8 +7793,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
@@ -7472,8 +7948,11 @@ async function resolveSpecs(loaded, filter) {
           );
         }
         const sourceSpec = await finalize(asset.revision.from);
-        const sourceFile = sourceSpec.quality?.outFile ?? (sourceSpec.source ? path5.resolve(root, sourceSpec.source) : sourceSpec.outFile);
-        const sourceImage = await optionalRevisionImage(sourceFile, "revision source");
+        const sourceStem = sourceSpec.quality?.outFile ?? (sourceSpec.source ? path5.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 ? path5.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)) {
@@ -7494,6 +7973,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,
@@ -7643,6 +8124,38 @@ async function optionalRevisionImage(file, label, requiredFormat) {
   }
   return { hash: sha256(bytes), ...metadata };
 }
+async function revisionSourceMembers(stem, label) {
+  if (existsSync4(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) => existsSync4(at(direction)))) {
+      roles = [...set];
+      break;
+    }
+  }
+  if (!roles.length) {
+    for (let index = 0; existsSync4(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}"`);
@@ -9325,11 +9838,16 @@ async function inspectRevision(spec, lock, seen) {
       reason: `revision source ${spec.styleId}/${revision.sourceAssetId} is not ready: ${dependency.reason}`
     };
   }
-  if (!revision.sourceSha256 || !existsSync7(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 || !existsSync7(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 || !existsSync7(revision.maskFile)) {
@@ -9339,8 +9857,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 || !existsSync7(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 (!existsSync7(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) => path11.resolve(currentEntryOutputPath(entry, parent, index))).sort();
+  const found = members.map((member) => path11.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);
@@ -10175,16 +10724,99 @@ function hex(c) {
   return `#${[c.r, c.g, c.b].map((v) => v.toString(16).padStart(2, "0")).join("")}`;
 }
 
-// src/pipeline/quality-regression.ts
-import path16 from "path";
+// src/pixellab-utils.ts
 import { existsSync as existsSync11 } from "fs";
-import { readFile as readFile9 } from "fs/promises";
+import { mkdir as mkdir4, readFile as readFile9, writeFile as writeFile4 } from "fs/promises";
+import path16 from "path";
+var UNZOOM_MIN_SIDE = 256;
+var UNZOOM_MAX_AREA = 2048 * 2048;
+function defaultUnzoomOut(input) {
+  const ext = path16.extname(input);
+  return `${ext ? input.slice(0, -ext.length) : input}.unzoomed.png`;
+}
+async function unzoomFile(client2, input, opts = {}) {
+  const out = path16.resolve(opts.out ?? defaultUnzoomOut(input));
+  if (path16.resolve(input) === out) throw new Error("unzoom will not overwrite its own input; pass a different --out");
+  if (existsSync11(out) && !opts.force) throw new Error(`${out} already exists; pass --force to replace it`);
+  const bytes = await readFile9(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 mkdir4(path16.dirname(out), { recursive: true });
+  await writeFile4(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 = path16.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 (existsSync11(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 mkdir4(path16.dirname(ttf), { recursive: true });
+      await writeFile4(ttf, ttfBytes);
+      await writeFile4(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/pipeline/quality-regression.ts
+import path17 from "path";
+import { existsSync as existsSync12 } from "fs";
+import { readFile as readFile10 } from "fs/promises";
 import { z as z4 } from "zod";
 var SHA256_RE2 = /^[0-9a-f]{64}$/;
 var HEX_RE = /^#[0-9a-f]{6}$/;
 var MAX_REDMEAN_DISTANCE = 765;
 var QualityPathSchema = z4.string().min(1).refine(
-  (value) => !path16.posix.isAbsolute(value) && !value.includes("\\"),
+  (value) => !path17.posix.isAbsolute(value) && !value.includes("\\"),
   "expected a portable relative path"
 );
 var DEFAULT_QUALITY_TOLERANCES = {
@@ -10331,10 +10963,10 @@ function measureDecodedImageQuality(png, digest2) {
   };
 }
 async function measureImageQuality(file) {
-  const absolute = path16.resolve(file);
+  const absolute = path17.resolve(file);
   let bytes;
   try {
-    bytes = await readFile9(absolute);
+    bytes = await readFile10(absolute);
   } catch (error) {
     throw new Error(`Cannot read quality image ${absolute}: ${message4(error)}`, { cause: error });
   }
@@ -10353,11 +10985,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 = path16.dirname(path16.resolve(inputsFilePath));
+  const root = path17.dirname(path17.resolve(inputsFilePath));
   return parsed.data.map((entry) => ({
     id: entry.id,
-    file: path16.resolve(root, entry.path),
-    ...entry.record ? { record: path16.resolve(root, entry.record) } : {},
+    file: path17.resolve(root, entry.path),
+    ...entry.record ? { record: path17.resolve(root, entry.record) } : {},
     tolerances: QualityToleranceSchema.parse({
       ...DEFAULT_QUALITY_TOLERANCES,
       ...entry.tolerances
@@ -10365,7 +10997,7 @@ function resolveQualityInputs(raw, inputsFilePath) {
   }));
 }
 function portableRelative2(from, to) {
-  return path16.relative(from, path16.resolve(to)).split(path16.sep).join("/") || ".";
+  return path17.relative(from, path17.resolve(to)).split(path17.sep).join("/") || ".";
 }
 async function verifyRecordForImage(recordPath, imagePath) {
   const verification = await verifyArtifactBundle(recordPath);
@@ -10380,20 +11012,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) => path16.resolve(path16.dirname(recordPath), output.path));
-  if (!outputs.includes(path16.resolve(imagePath))) {
+  const outputs = record.outputs.map((output) => path17.resolve(path17.dirname(recordPath), output.path));
+  if (!outputs.includes(path17.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 = path16.resolve(baselinePath);
+  const absolute = path17.resolve(baselinePath);
   for (const input of inputs) {
-    if (path16.resolve(input.file) === absolute || input.record && path16.resolve(input.record) === absolute) {
+    if (path17.resolve(input.file) === absolute || input.record && path17.resolve(input.record) === absolute) {
       throw new Error(`Quality baseline output would overwrite an input: ${absolute}.`);
     }
   }
-  const root = path16.dirname(absolute);
+  const root = path17.dirname(absolute);
   const cases = [];
   for (const input of [...inputs].sort((a, b) => a.id.localeCompare(b.id))) {
     const expected = await measureImageQuality(input.file);
@@ -10420,8 +11052,8 @@ async function snapshotQualityBaseline(inputs, baselinePath, options = {}) {
     cases
   });
   const data = Buffer.from(JSON.stringify(baseline, null, 2) + "\n");
-  if (existsSync11(absolute) && !options.force) {
-    const current = await readFile9(absolute);
+  if (existsSync12(absolute) && !options.force) {
+    const current = await readFile10(absolute);
     if (!current.equals(data)) {
       throw new OverwriteRefusedError(
         `Quality baseline already exists with different content: ${absolute}. Pass --force to replace it.`,
@@ -10433,10 +11065,10 @@ async function snapshotQualityBaseline(inputs, baselinePath, options = {}) {
   return { baseline, path: absolute, changed: result.changed.length > 0 };
 }
 async function readQualityBaseline(baselinePath) {
-  const absolute = path16.resolve(baselinePath);
+  const absolute = path17.resolve(baselinePath);
   let raw;
   try {
-    raw = JSON.parse(await readFile9(absolute, "utf8"));
+    raw = JSON.parse(await readFile10(absolute, "utf8"));
   } catch (error) {
     throw new Error(`Could not read quality baseline ${absolute}: ${message4(error)}`, { cause: error });
   }
@@ -10506,12 +11138,12 @@ function regressionViolations(expected, actual, tolerances) {
   return { violations, warnings };
 }
 async function checkQualityBaseline(baselinePath) {
-  const absolute = path16.resolve(baselinePath);
+  const absolute = path17.resolve(baselinePath);
   const baseline = await readQualityBaseline(absolute);
-  const root = path16.dirname(absolute);
+  const root = path17.dirname(absolute);
   const cases = [];
   for (const entry of baseline.cases) {
-    const file = path16.resolve(root, entry.file);
+    const file = path17.resolve(root, entry.file);
     let actual = null;
     const violations = [];
     const warnings = [];
@@ -10524,7 +11156,7 @@ async function checkQualityBaseline(baselinePath) {
       violations.push(message4(error));
     }
     if (entry.record) {
-      const recordPath = path16.resolve(root, entry.record.path);
+      const recordPath = path17.resolve(root, entry.record.path);
       try {
         const recordHash = await sha256File(recordPath);
         if (recordHash !== entry.record.sha256) violations.push("quality record hash changed");
@@ -10560,13 +11192,13 @@ async function checkQualityBaseline(baselinePath) {
 }
 
 // src/pipeline/cache-health.ts
-import { existsSync as existsSync15 } from "fs";
-import { readFile as readFile12, readdir as readdir2, rm as rm6 } from "fs/promises";
-import path19 from "path";
+import { existsSync as existsSync16 } from "fs";
+import { readFile as readFile13, readdir as readdir2, rm as rm6 } from "fs/promises";
+import path20 from "path";
 
 // src/cache.ts
-import { mkdir as mkdir4, readFile as readFile10, rename as rename4, rm as rm4, writeFile as writeFile4 } from "fs/promises";
-import { existsSync as existsSync12 } from "fs";
+import { mkdir as mkdir5, readFile as readFile11, rename as rename4, rm as rm4, writeFile as writeFile5 } from "fs/promises";
+import { existsSync as existsSync13 } from "fs";
 import pathModule from "path";
 import { z as z5 } from "zod";
 var HashCacheSchema = z5.object({
@@ -10581,10 +11213,10 @@ function isSha256Hash(value) {
 function parseCache(value) {
   return HashCacheSchema.parse(value);
 }
-async function loadCache(path33) {
-  if (!existsSync12(path33)) return { version: 1, hashes: {} };
+async function loadCache(path34) {
+  if (!existsSync13(path34)) return { version: 1, hashes: {} };
   try {
-    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile10(path33, "utf8")));
+    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile11(path34, "utf8")));
     if (!parsed.success) return { version: 1, hashes: {} };
     return {
       version: 1,
@@ -10596,18 +11228,18 @@ async function loadCache(path33) {
     return { version: 1, hashes: {} };
   }
 }
-async function saveCache(path33, cache) {
+async function saveCache(path34, 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 mkdir4(pathModule.dirname(pathModule.resolve(path33)), { recursive: true });
-  const tmp = `${path33}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  await mkdir5(pathModule.dirname(pathModule.resolve(path34)), { recursive: true });
+  const tmp = `${path34}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    await writeFile4(tmp, JSON.stringify({ version: 1, hashes: sorted }, null, 2) + "\n");
-    await rename4(tmp, path33);
+    await writeFile5(tmp, JSON.stringify({ version: 1, hashes: sorted }, null, 2) + "\n");
+    await rename4(tmp, path34);
   } finally {
     await rm4(tmp, { force: true });
   }
@@ -10631,20 +11263,20 @@ function cachePathFor(lockPath) {
 }
 
 // src/pipeline/history.ts
-import { existsSync as existsSync14 } from "fs";
-import path18 from "path";
+import { existsSync as existsSync15 } from "fs";
+import path19 from "path";
 
 // src/pipeline/fetch.ts
-import { existsSync as existsSync13, readFileSync as readFileSync3 } from "fs";
-import { mkdir as mkdir5, readFile as readFile11, rename as rename5, rm as rm5, writeFile as writeFile5 } from "fs/promises";
-import path17 from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync3 } from "fs";
+import { mkdir as mkdir6, readFile as readFile12, rename as rename5, rm as rm5, writeFile as writeFile6 } from "fs/promises";
+import path18 from "path";
 async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
   const log = opts.onProgress ?? (() => {
   });
   const result = { downloaded: 0, skipped: 0, failed: 0, ...opts.refresh ? { unchanged: 0 } : {} };
   const specByKey = new Map(specs.map((s) => [lockKey(s.styleId, s.assetId), s]));
   normalizeLockOutputPaths(lock, specs);
-  const cacheDir = opts.cacheDir === false ? null : path17.resolve(opts.cacheDir ?? path17.join(path17.dirname(lockPath), ".pixelkiln", "cache"));
+  const cacheDir = opts.cacheDir === false ? null : path18.resolve(opts.cacheDir ?? path18.join(path18.dirname(lockPath), ".pixelkiln", "cache"));
   const pending = Object.entries(lock.entries).filter(([key, e]) => {
     if (e.provider !== provider.id || !specByKey.has(key)) return false;
     if (specByKey.get(key)?.mirror) return false;
@@ -10655,14 +11287,14 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
     if (spec && e.specHash === spec.specHash && e.outputs.length && !postprocessCurrent(e, spec)) {
       return Boolean(opts.force) || e.outputs.every((output) => {
         const file = resolveOutputPath(output.path, spec.root);
-        return existsSync13(file) && sha256(readFileSync3(file)) === output.sha256;
+        return existsSync14(file) && sha256(readFileSync3(file)) === output.sha256;
       });
     }
     if (!opts.repair) return false;
     if (e.outputs.length === 0 || !spec) return true;
     return e.outputs.some((output) => {
       const file = resolveOutputPath(output.path, spec.root);
-      if (!existsSync13(file)) return true;
+      if (!existsSync14(file)) return true;
       const current = sha256(readFileSync3(file));
       if (current === output.sha256) return false;
       return Boolean(opts.force) || (e.supersededOutputs ?? []).some((old) => old.sha256 === current);
@@ -10746,21 +11378,21 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
             if (!source.url) throw new Error(`no durable source URL to refresh ${source.role ?? "asset"} from`);
             fresh = await provider.download(source.url);
             if (recorded && sha256(fresh) === recordedRaw && !reapply) {
-              log(`  current ${path17.relative(process.cwd(), target)}`);
+              log(`  current ${path18.relative(process.cwd(), target)}`);
               outputs.push({ ...recorded, path: portableOutputPath(target, spec.root) });
               continue;
             }
           }
           let raw = null;
           let final = null;
-          if (existsSync13(target)) {
+          if (existsSync14(target)) {
             const currentHash = await sha256File(target);
             if (recorded && currentHash === recorded.sha256) {
               if (!fresh && !reapply) {
                 if (cacheDir) {
                   await cacheMedia(
                     cacheDir,
-                    await readFile11(target),
+                    await readFile12(target),
                     recorded.mediaType ?? MediaType.PNG,
                     recorded.sha256
                   );
@@ -10769,10 +11401,10 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
                 continue;
               }
               if (reapply && !fresh) {
-                if (!recorded.raw) raw = await readFile11(target);
-                log(`  reapply ${path17.relative(process.cwd(), target)}`);
+                if (!recorded.raw) raw = await readFile12(target);
+                log(`  reapply ${path18.relative(process.cwd(), target)}`);
               } else {
-                log(`  changed ${path17.relative(process.cwd(), target)} (upstream)`);
+                log(`  changed ${path18.relative(process.cwd(), target)} (upstream)`);
               }
             } else {
               const superseded = (entry.supersededOutputs ?? []).find(
@@ -10793,14 +11425,14 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
               }
               if (outgoing && cacheDir) {
                 try {
-                  const oldBytes = await readFile11(target);
+                  const oldBytes = await readFile12(target);
                   const oldMediaType = detectMediaType(oldBytes);
                   if (oldMediaType) await cacheMedia(cacheDir, oldBytes, oldMediaType, currentHash);
                 } catch {
                 }
               }
               log(
-                `  replace ${path17.relative(process.cwd(), target)}` + (opts.force ? " (--force)" : " (previous tracked generation)")
+                `  replace ${path18.relative(process.cwd(), target)}` + (opts.force ? " (--force)" : " (previous tracked generation)")
               );
             }
           }
@@ -10809,7 +11441,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
           } else if (!raw && recorded && cacheDir) {
             if (!reapply) final = await readCachedMedia(cacheDir, recorded.sha256, expectedMediaType);
             if (!final && recordedRaw) raw = await readCachedMedia(cacheDir, recordedRaw, expectedMediaType);
-            if (final || raw) log(`  cached  ${path17.relative(process.cwd(), target)}`);
+            if (final || raw) log(`  cached  ${path18.relative(process.cwd(), target)}`);
           }
           if (!final && !raw) {
             if (!source.url) {
@@ -10836,13 +11468,13 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
             buf = processed.bytes;
             if (processed.changed) {
               rawHash = sha256(raw);
-              log(`  snapped ${path17.relative(process.cwd(), target)} to ${wanted.palette.colors.length} colours`);
+              log(`  snapped ${path18.relative(process.cwd(), target)} to ${wanted.palette.colors.length} colours`);
             }
           }
           if (cacheDir) await cacheMedia(cacheDir, buf, mediaType);
-          await mkdir5(path17.dirname(target), { recursive: true });
+          await mkdir6(path18.dirname(target), { recursive: true });
           const tmp = `${target}.pixelkiln.tmp`;
-          await writeFile5(tmp, buf);
+          await writeFile6(tmp, buf);
           outputs.push({
             path: portableOutputPath(target, spec.root),
             sha256: sha256(buf),
@@ -10854,7 +11486,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
           await saveLock(lockPath, lock);
           await rename5(tmp, target);
           wrote = true;
-          log(`  wrote   ${path17.relative(process.cwd(), target)}`);
+          log(`  wrote   ${path18.relative(process.cwd(), target)}`);
         }
         if (opts.refresh && !wrote) {
           if (rotated) {
@@ -10898,10 +11530,10 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
   return result;
 }
 async function readCachedMedia(cacheDir, hash, mediaType) {
-  const file = path17.join(cacheDir, cacheFileName(hash, mediaType));
-  if (!existsSync13(file)) return null;
+  const file = path18.join(cacheDir, cacheFileName(hash, mediaType));
+  if (!existsSync14(file)) return null;
   try {
-    const buf = await readFile11(file);
+    const buf = await readFile12(file);
     if (sha256(buf) !== hash) return null;
     validateMedia(buf, mediaType);
     return buf;
@@ -10912,15 +11544,15 @@ async function readCachedMedia(cacheDir, hash, mediaType) {
 async function cacheMedia(cacheDir, buf, mediaType, knownHash) {
   const hash = knownHash ?? sha256(buf);
   validateMedia(buf, mediaType);
-  const file = path17.join(cacheDir, cacheFileName(hash, mediaType));
+  const file = path18.join(cacheDir, cacheFileName(hash, mediaType));
   if (await readCachedMedia(cacheDir, hash, mediaType)) return;
-  await mkdir5(cacheDir, { recursive: true });
+  await mkdir6(cacheDir, { recursive: true });
   const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
-  await writeFile5(tmp, buf);
+  await writeFile6(tmp, buf);
   try {
     await rename5(tmp, file);
   } catch (err) {
-    if (!existsSync13(file)) throw err;
+    if (!existsSync14(file)) throw err;
   } finally {
     await rm5(tmp, { force: true });
   }
@@ -11039,10 +11671,10 @@ async function revertGeneration(provider, spec, lock, lockPath, opts) {
   }
   for (let i = 0; i < entry.outputs.length; i++) {
     const file = currentEntryOutputPath(entry, spec, i);
-    if (!existsSync14(file)) continue;
+    if (!existsSync15(file)) continue;
     if (await sha256File(file) !== entry.outputs[i].sha256 && !opts.force) {
       throw new OverwriteRefusedError(
-        `${path18.relative(process.cwd(), file)} was changed after download; keep it with pixelkiln edit, or pass --force to replace it`,
+        `${path19.relative(process.cwd(), file)} was changed after download; keep it with pixelkiln edit, or pass --force to replace it`,
         [file]
       );
     }
@@ -11094,11 +11726,11 @@ async function revertGeneration(provider, spec, lock, lockPath, opts) {
 
 // src/pipeline/cache-health.ts
 async function inspectCaches(lock, lockPath, options = {}) {
-  if (options.prune && !existsSync15(lockPath)) {
-    throw new Error(`Refusing to prune without an existing lockfile at ${path19.resolve(lockPath)}`);
+  if (options.prune && !existsSync16(lockPath)) {
+    throw new Error(`Refusing to prune without an existing lockfile at ${path20.resolve(lockPath)}`);
   }
-  const contentDir = path19.resolve(path19.dirname(lockPath), ".pixelkiln", "cache");
-  const remotePath = path19.resolve(cachePathFor(lockPath));
+  const contentDir = path20.resolve(path20.dirname(lockPath), ".pixelkiln", "cache");
+  const remotePath = path20.resolve(cachePathFor(lockPath));
   const referenced = referencedHashes(lock);
   let content = await inspectContentCache(contentDir, referenced);
   let remoteHashes = await inspectRemoteHashCache(remotePath);
@@ -11110,7 +11742,7 @@ async function inspectCaches(lock, lockPath, options = {}) {
     ]);
     for (const name of names) {
       try {
-        await rm6(path19.join(contentDir, name), { force: true });
+        await rm6(path20.join(contentDir, name), { force: true });
         removed.contentFiles++;
       } catch {
       }
@@ -11119,7 +11751,7 @@ async function inspectCaches(lock, lockPath, options = {}) {
       await saveCache(remotePath, { version: 1, hashes: {} });
       removed.resetRemoteHashCache = true;
     } else if (remoteHashes.invalidIds.length) {
-      const cache = parseCache(JSON.parse(await readFile12(remotePath, "utf8")));
+      const cache = parseCache(JSON.parse(await readFile13(remotePath, "utf8")));
       for (const id of remoteHashes.invalidIds) delete cache.hashes[id];
       removed.remoteHashEntries = remoteHashes.invalidIds.length;
       await saveCache(remotePath, cache);
@@ -11137,7 +11769,7 @@ async function inspectCaches(lock, lockPath, options = {}) {
 async function inspectContentCache(contentDir, referenced) {
   const report = {
     path: contentDir,
-    exists: existsSync15(contentDir),
+    exists: existsSync16(contentDir),
     files: 0,
     bytes: 0,
     valid: 0,
@@ -11158,12 +11790,12 @@ async function inspectContentCache(contentDir, referenced) {
       continue;
     }
     report.files++;
-    const file = path19.join(contentDir, entry.name);
+    const file = path20.join(contentDir, entry.name);
     const mediaType = mediaTypeFromExtension(entry.name);
     const expected = mediaType ? entry.name.slice(0, -4) : "";
     let bytes;
     try {
-      bytes = await readFile12(file);
+      bytes = await readFile13(file);
       report.bytes += bytes.length;
     } catch (err) {
       report.invalid.push({
@@ -11201,7 +11833,7 @@ async function inspectContentCache(contentDir, referenced) {
 async function inspectRemoteHashCache(remotePath) {
   const report = {
     path: remotePath,
-    exists: existsSync15(remotePath),
+    exists: existsSync16(remotePath),
     entries: 0,
     valid: 0,
     invalidIds: [],
@@ -11210,7 +11842,7 @@ async function inspectRemoteHashCache(remotePath) {
   if (!report.exists) return report;
   let cache;
   try {
-    cache = parseCache(JSON.parse(await readFile12(remotePath, "utf8")));
+    cache = parseCache(JSON.parse(await readFile13(remotePath, "utf8")));
   } catch (err) {
     report.error = err instanceof Error ? err.message : String(err);
     return report;
@@ -11226,19 +11858,19 @@ async function inspectRemoteHashCache(remotePath) {
 
 // src/pipeline/pack.ts
 import { readFileSync as readFileSync4 } from "fs";
-import path20 from "path";
+import path21 from "path";
 var DEFAULT_FRAME_SET_FPS = 12;
 function resolvePackInputs(raw, inputsFilePath) {
   if (!Array.isArray(raw) || !raw.length) {
     throw new Error("--inputs must be a non-empty JSON array of { id, path }");
   }
-  const baseDir = path20.dirname(path20.resolve(inputsFilePath));
+  const baseDir = path21.dirname(path21.resolve(inputsFilePath));
   return raw.map((entry, i) => {
     const e = entry;
     if (typeof e.id !== "string" || typeof e.path !== "string") {
       throw new Error(`--inputs[${i}] needs string "id" and "path"`);
     }
-    return { id: e.id, path: path20.resolve(baseDir, e.path) };
+    return { id: e.id, path: path21.resolve(baseDir, e.path) };
   });
 }
 function packSprites(inputs, options = {}) {
@@ -11322,7 +11954,7 @@ function packStyle(lock, styleId, manifestDir, options = {}) {
     }
     const inputs2 = Object.entries(options.sourceOverrides).map(([id, source]) => ({
       id,
-      path: path20.resolve(source)
+      path: path21.resolve(source)
     }));
     if (!inputs2.length) throw new Error(`No approved quality outputs for style "${styleId}".`);
     const packed2 = packSprites(inputs2, options);
@@ -11346,7 +11978,7 @@ function packStyle(lock, styleId, manifestDir, options = {}) {
     let outputs = resolveEntryOutputs(entry, id, manifestDir);
     const source = sources[id];
     if (source && outputs.length <= 1) {
-      inputs.push({ id, path: path20.resolve(manifestDir, source) });
+      inputs.push({ id, path: path21.resolve(manifestDir, source) });
       continue;
     }
     if (source && sourceIsStem(source, entry, manifestDir)) {
@@ -11380,7 +12012,7 @@ function packStyle(lock, styleId, manifestDir, options = {}) {
     }
   }
   for (const [id, source] of Object.entries(sources)) {
-    if (!locked.has(id)) inputs.push({ id, path: path20.resolve(manifestDir, source) });
+    if (!locked.has(id)) inputs.push({ id, path: path21.resolve(manifestDir, source) });
   }
   if (!inputs.length) {
     throw new Error(`No readable sprites for style "${styleId}"; ${noOutput.length} skipped.`);
@@ -11488,7 +12120,7 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
     const source = sources[id];
     const entry = lock.entries[`${styleId}/${id}`];
     if (source && !(entry && sourceIsStem(source, entry, manifestDir))) {
-      placements.push({ id, path: path20.resolve(manifestDir, source), cell });
+      placements.push({ id, path: path21.resolve(manifestDir, source), cell });
       continue;
     }
     if (source && entry) {
@@ -11521,7 +12153,7 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
       `Nothing to mount for style "${styleId}": ${ids.length} asset(s) declare a cell, but none has generated output or a \`source\`. Run \`pixelkiln gen --style ${styleId}\`, or point each at a file.${detail}`
     );
   }
-  const basePng = mount.base ? readFileSync4(path20.resolve(manifestDir, mount.base)) : void 0;
+  const basePng = mount.base ? readFileSync4(path21.resolve(manifestDir, mount.base)) : void 0;
   const mounted = mountSprites(placements, {
     cellWidth: mount.cellWidth,
     cellHeight: mount.cellHeight,
@@ -11531,7 +12163,7 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
     ...mounted,
     sources: mount.base ? [{
       id: "$base",
-      path: path20.resolve(manifestDir, mount.base),
+      path: path21.resolve(manifestDir, mount.base),
       sha256: sha256(basePng),
       included: true
     }, ...mounted.sources] : mounted.sources,
@@ -12309,9 +12941,9 @@ async function poll(provider, lock, lockPath, opts = {}) {
 }
 
 // src/pipeline/doctor.ts
-import { constants, existsSync as existsSync16 } from "fs";
+import { constants, existsSync as existsSync17 } from "fs";
 import { access, stat as stat2 } from "fs/promises";
-import path21 from "path";
+import path22 from "path";
 async function doctor(loaded, specs, lock, lockPath, opts = {}) {
   const checks = [];
   const add = (id, level, message6) => checks.push({ id, level, message: message6 });
@@ -12322,8 +12954,8 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
   );
   add("lock", "ok", `${Object.keys(lock.entries).length} valid v2 lock entr(ies)`);
   const dirs = [...new Set(specs.flatMap((spec) => [
-    path21.dirname(spec.outFile),
-    ...spec.quality ? [path21.dirname(spec.quality.outFile)] : []
+    path22.dirname(spec.outFile),
+    ...spec.quality ? [path22.dirname(spec.quality.outFile)] : []
   ]))];
   const unwritable = [];
   for (const dir of dirs) {
@@ -12346,7 +12978,7 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
     for (let index = 0; index < entry.outputs.length; index++) {
       const output = entry.outputs[index];
       const spec = specByKey.get(key);
-      const absolute = spec ? currentEntryOutputPath(entry, spec, index) : resolveOutputPath(output.path, path21.dirname(lockPath));
+      const absolute = spec ? currentEntryOutputPath(entry, spec, index) : resolveOutputPath(output.path, path22.dirname(lockPath));
       const owner = outputOwners.get(absolute);
       if (owner && owner !== key) duplicateOutputs.push(`${output.path} (${owner}, ${key})`);
       outputOwners.set(absolute, key);
@@ -12361,7 +12993,7 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
   } else {
     add("lock-outputs", "ok", `${outputOwners.size} recorded output path(s) are uniquely owned`);
   }
-  const cacheDir = path21.join(path21.dirname(lockPath), ".pixelkiln", "cache");
+  const cacheDir = path22.join(path22.dirname(lockPath), ".pixelkiln", "cache");
   const stranded = [];
   const invalidState = [];
   const staleMapUrls = [];
@@ -12377,11 +13009,11 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
     const hasSource = Boolean(entry.sourceUrl || entry.sourceUrls?.length);
     let hasCache = false;
     for (const output of entry.outputs) {
-      const cached = path21.join(
+      const cached = path22.join(
         cacheDir,
         cacheFileName(output.sha256, output.mediaType ?? MediaType.PNG)
       );
-      if (existsSync16(cached) && await sha256File(cached) === output.sha256) {
+      if (existsSync17(cached) && await sha256File(cached) === output.sha256) {
         hasCache = true;
         break;
       }
@@ -12477,16 +13109,16 @@ async function nearestExistingDirectory(start) {
       if ((await stat2(current)).isDirectory()) return current;
     } catch {
     }
-    const parent = path21.dirname(current);
+    const parent = path22.dirname(current);
     if (parent === current) return current;
     current = parent;
   }
 }
 
 // src/pipeline/adopt.ts
-import { existsSync as existsSync17 } from "fs";
-import { readFile as readFile13, writeFile as writeFile6 } from "fs/promises";
-import path22 from "path";
+import { existsSync as existsSync18 } from "fs";
+import { readFile as readFile14, writeFile as writeFile7 } from "fs/promises";
+import path23 from "path";
 async function adopt(provider, specs, lock, lockPath, opts = {}) {
   const log = opts.onProgress ?? (() => {
   });
@@ -12497,11 +13129,11 @@ async function adopt(provider, specs, lock, lockPath, opts = {}) {
   const localByHash = /* @__PURE__ */ new Map();
   const unmatchedLocal = [];
   for (const spec of specs) {
-    if (!existsSync17(spec.outFile)) {
+    if (!existsSync18(spec.outFile)) {
       unmatchedLocal.push(`${spec.styleId}/${spec.assetId} (no file at ${spec.outFile})`);
       continue;
     }
-    const bytes = await readFile13(spec.outFile);
+    const bytes = await readFile14(spec.outFile);
     try {
       decodePng(bytes);
     } catch (err) {
@@ -12619,13 +13251,13 @@ async function tagAdopted(provider, specs, lock, opts = {}) {
 }
 
 // src/pick/server.ts
-import { existsSync as existsSync19 } from "fs";
-import { readFile as readFile16 } from "fs/promises";
+import { existsSync as existsSync20 } from "fs";
+import { readFile as readFile17 } from "fs/promises";
 
 // src/pipeline/init.ts
-import { readdir as readdir3, readFile as readFile14, writeFile as writeFile7 } from "fs/promises";
-import { existsSync as existsSync18 } from "fs";
-import path23 from "path";
+import { readdir as readdir3, readFile as readFile15, writeFile as writeFile8 } from "fs/promises";
+import { existsSync as existsSync19 } from "fs";
+import path24 from "path";
 function pngSize(buf) {
   if (buf.length < 24) return null;
   const isPng = buf.readUInt32BE(0) === 2303741511 && buf.readUInt32BE(4) === 218765834;
@@ -12639,7 +13271,7 @@ function slugify(value) {
 async function walk(dir, exclude) {
   const out = [];
   for (const entry of await readdir3(dir, { withFileTypes: true })) {
-    const full = path23.join(dir, entry.name);
+    const full = path24.join(dir, entry.name);
     if (exclude.some((x) => full.includes(x))) continue;
     if (entry.isDirectory()) out.push(...await walk(full, exclude));
     else if (entry.name.toLowerCase().endsWith(".png")) out.push(full);
@@ -12653,14 +13285,14 @@ async function scanAssets(root, opts = {}) {
   const skipped = [];
   const seen = /* @__PURE__ */ new Map();
   for (const file of files.sort()) {
-    const size = pngSize(await readFile14(file));
+    const size = pngSize(await readFile15(file));
     if (!size) {
       skipped.push(`${file} (not a readable PNG)`);
       continue;
     }
-    const rel = path23.relative(root, file);
-    const category = path23.dirname(rel) === "." ? "" : path23.dirname(rel);
-    let id = slugify(path23.basename(rel));
+    const rel = path24.relative(root, file);
+    const category = path24.dirname(rel) === "." ? "" : path24.dirname(rel);
+    let id = slugify(path24.basename(rel));
     if (seen.has(id)) {
       const n = seen.get(id) + 1;
       seen.set(id, n);
@@ -13124,7 +13756,7 @@ document.getElementById('submit').onclick = async () => {
 
 // src/pick/review-server.ts
 import { createServer } from "http";
-import { readFile as readFile15 } from "fs/promises";
+import { readFile as readFile16 } from "fs/promises";
 function serveReviewPage(opts) {
   const log = opts.onProgress ?? (() => {
   });
@@ -13133,7 +13765,7 @@ function serveReviewPage(opts) {
       if (req.method === "GET" && req.url && opts.assets?.has(req.url)) {
         try {
           const asset = opts.assets.get(req.url);
-          const bytes = await readFile15(asset.path);
+          const bytes = await readFile16(asset.path);
           res.writeHead(200, {
             "Content-Type": asset.contentType,
             "Cache-Control": "no-store",
@@ -13209,13 +13841,13 @@ async function currentArt(entry, spec) {
   const previous = primaryOutput({ ...entry, outputs: entry.supersededOutputs });
   if (!previous) return null;
   const file = resolveOutputPath(previous.path, spec.root);
-  if (!existsSync19(file)) return null;
+  if (!existsSync20(file)) return null;
   const contentType = previous.mediaType ?? mediaTypeFromExtension(file);
   if (!contentType) return null;
   let width = entry.width;
   let height = entry.height;
   if (contentType === "image/png") {
-    const size = pngSize(await readFile16(file));
+    const size = pngSize(await readFile17(file));
     if (size) ({ width, height } = size);
   }
   return { path: file, contentType, width, height };
@@ -13384,14 +14016,14 @@ async function runPicker(provider, lock, lockPath, opts = {}) {
 
 // src/gallery/snapshot.ts
 import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync22 } from "fs";
-import { readFile as readFile20, stat as stat3 } from "fs/promises";
-import path28 from "path";
+import { existsSync as existsSync23 } from "fs";
+import { readFile as readFile21, stat as stat3 } from "fs/promises";
+import path29 from "path";
 
 // src/workspace.ts
-import { mkdir as mkdir6, readFile as readFile17, rename as rename6, rm as rm7, writeFile as writeFile8 } from "fs/promises";
-import { existsSync as existsSync20 } from "fs";
-import path24 from "path";
+import { mkdir as mkdir7, readFile as readFile18, rename as rename6, rm as rm7, writeFile as writeFile9 } from "fs/promises";
+import { existsSync as existsSync21 } from "fs";
+import path25 from "path";
 import { z as z6 } from "zod";
 var WorkspaceProjectSchema = z6.object({
   id: z6.string().min(1),
@@ -13416,10 +14048,10 @@ ${parsed.error.issues.slice(0, 5).map((i) => `  ${i.path.join(".")}: ${i.message
   );
 }
 async function loadWorkspace(workspacePath) {
-  if (!existsSync20(workspacePath)) return { version: 1, projects: [] };
+  if (!existsSync21(workspacePath)) return { version: 1, projects: [] };
   let raw;
   try {
-    raw = JSON.parse(await readFile17(workspacePath, "utf8"));
+    raw = JSON.parse(await readFile18(workspacePath, "utf8"));
   } catch (err) {
     throw new ProjectError(
       `Workspace catalog at ${workspacePath} is malformed:
@@ -13433,22 +14065,22 @@ async function saveWorkspace(workspacePath, ws) {
     version: 1,
     projects: [...ws.projects].sort((a, b) => a.id.localeCompare(b.id))
   };
-  await mkdir6(path24.dirname(path24.resolve(workspacePath)), { recursive: true });
+  await mkdir7(path25.dirname(path25.resolve(workspacePath)), { recursive: true });
   const tmp = `${workspacePath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    await writeFile8(tmp, JSON.stringify(sorted, null, 2) + "\n");
+    await writeFile9(tmp, JSON.stringify(sorted, null, 2) + "\n");
     await rename6(tmp, workspacePath);
   } finally {
     await rm7(tmp, { force: true });
   }
 }
 function toPortablePath(dir, absolute) {
-  return path24.relative(dir, absolute).split(path24.sep).join("/");
+  return path25.relative(dir, absolute).split(path25.sep).join("/");
 }
 function resolveProject(dir, project) {
   return {
-    manifestPath: path24.resolve(dir, project.manifest.split("/").join(path24.sep)),
-    lockPath: path24.resolve(dir, project.lock.split("/").join(path24.sep))
+    manifestPath: path25.resolve(dir, project.manifest.split("/").join(path25.sep)),
+    lockPath: path25.resolve(dir, project.lock.split("/").join(path25.sep))
   };
 }
 function validateWorkspace(ws, dir) {
@@ -13461,21 +14093,21 @@ function validateWorkspace(ws, dir) {
     const { manifestPath, lockPath } = resolveProject(dir, project);
     lockOwners.set(lockPath, [...lockOwners.get(lockPath) ?? [], project.id]);
     manifestOwners.set(manifestPath, [...manifestOwners.get(manifestPath) ?? [], project.id]);
-    if (path24.isAbsolute(project.manifest) || path24.isAbsolute(project.lock)) {
+    if (path25.isAbsolute(project.manifest) || path25.isAbsolute(project.lock)) {
       diagnostics.push({
         id: "absolute-path",
         level: "warning",
         message: `project "${project.id}" stores an absolute path; the catalog will not resolve correctly if this tree is cloned or moved elsewhere`
       });
     }
-    if (!existsSync20(manifestPath)) {
+    if (!existsSync21(manifestPath)) {
       diagnostics.push({
         id: "missing-manifest",
         level: "error",
         message: `project "${project.id}" manifest not found: ${manifestPath}`
       });
     }
-    if (!existsSync20(lockPath)) {
+    if (!existsSync21(lockPath)) {
       diagnostics.push({
         id: "missing-lock",
         level: "error",
@@ -13522,12 +14154,12 @@ function validateWorkspace(ws, dir) {
 }
 
 // src/gallery/edit.ts
-import path27 from "path";
+import path28 from "path";
 import { z as z9 } from "zod";
 
 // src/manifest-edit.ts
-import { readFile as readFile18, rename as rename7, rm as rm8, writeFile as writeFile9 } from "fs/promises";
-import path25 from "path";
+import { readFile as readFile19, rename as rename7, rm as rm8, writeFile as writeFile10 } from "fs/promises";
+import path26 from "path";
 import { z as z7 } from "zod";
 var HexSha = z7.string().regex(/^[0-9a-f]{64}$/);
 var AssetPatchSchema = z7.object({
@@ -13683,11 +14315,21 @@ function assetStyles(raw, asset) {
   const own = Array.isArray(asset.styles) ? asset.styles : [];
   return own.length ? own : Object.keys(raw.styles ?? {});
 }
+function declaredAssets(raw) {
+  const expanded = expandLoopDirections(raw).raw;
+  return new Set(Object.keys(expanded.assets ?? {}));
+}
+function undeclaredAsset(raw, assetId) {
+  const shorthand = loopShorthandOf(assetId, expandLoopDirections(raw).families);
+  return new ManifestEditError(
+    shorthand ? `asset "${assetId}" is expanded from "${shorthand}"'s animation.directions; edit "${shorthand}" (it applies to every direction), or write this direction out as its own asset to change it alone` : `asset "${assetId}" is not declared by the manifest`
+  );
+}
 function applyEdit(raw, edit) {
   raw.assets ??= {};
   if (edit.action === "set-source" || edit.action === "clear-source") {
     const asset2 = Object.hasOwn(raw.assets, edit.assetId) ? raw.assets[edit.assetId] : void 0;
-    if (!asset2) throw new ManifestEditError(`asset "${edit.assetId}" is not declared by the manifest`);
+    if (!asset2) throw undeclaredAsset(raw, edit.assetId);
     if (!raw.styles || !Object.hasOwn(raw.styles, edit.styleId)) {
       throw new ManifestEditError(`unknown style "${edit.styleId}"`);
     }
@@ -13739,7 +14381,7 @@ function applyEdit(raw, edit) {
     return;
   }
   if (edit.action === "add-asset") {
-    if (Object.hasOwn(raw.assets, edit.assetId)) {
+    if (declaredAssets(raw).has(edit.assetId)) {
       throw new ManifestEditError(`asset "${edit.assetId}" already exists`);
     }
     const { styles, tags, ...rest } = edit.asset;
@@ -13753,20 +14395,20 @@ function applyEdit(raw, edit) {
       }
       asset2.styles = styles;
     }
-    if (edit.asset.revision && !Object.hasOwn(raw.assets, edit.asset.revision.from)) {
+    if (edit.asset.revision && !declaredAssets(raw).has(edit.asset.revision.from)) {
       throw new ManifestEditError(`revision parent "${edit.asset.revision.from}" is not declared by the manifest`);
     }
-    if (edit.asset.state && !Object.hasOwn(raw.assets, edit.asset.state.of)) {
+    if (edit.asset.state && !declaredAssets(raw).has(edit.asset.state.of)) {
       throw new ManifestEditError(`state parent "${edit.asset.state.of}" is not declared by the manifest`);
     }
-    if (edit.asset.animation && !Object.hasOwn(raw.assets, edit.asset.animation.of)) {
+    if (edit.asset.animation && !declaredAssets(raw).has(edit.asset.animation.of)) {
       throw new ManifestEditError(`animation parent "${edit.asset.animation.of}" is not declared by the manifest`);
     }
     raw.assets[edit.assetId] = asset2;
     return;
   }
   const asset = Object.hasOwn(raw.assets, edit.assetId) ? raw.assets[edit.assetId] : void 0;
-  if (!asset) throw new ManifestEditError(`asset "${edit.assetId}" is not declared by the manifest`);
+  if (!asset) throw undeclaredAsset(raw, edit.assetId);
   const { patch } = edit;
   if (patch.prompt !== void 0) asset.prompt = patch.prompt;
   if (patch.promptForStyle) {
@@ -13790,8 +14432,8 @@ function applyEdit(raw, edit) {
   }
 }
 async function applyManifestEdit(manifestPath, edit) {
-  const absolute = path25.resolve(manifestPath);
-  const original = await readFile18(absolute, "utf8");
+  const absolute = path26.resolve(manifestPath);
+  const original = await readFile19(absolute, "utf8");
   const before = sha256(original);
   if (before !== edit.expectedSha256) throw new ManifestDriftError(absolute);
   let raw;
@@ -13805,12 +14447,12 @@ async function applyManifestEdit(manifestPath, edit) {
   applyEdit(raw, edit);
   const next = serializeLike(original, raw);
   if (next === original) return { manifestPath: absolute, sha256: before, changed: false };
-  const tmp = path25.join(
-    path25.dirname(absolute),
-    `.${path25.basename(absolute)}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`
+  const tmp = path26.join(
+    path26.dirname(absolute),
+    `.${path26.basename(absolute)}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`
   );
   try {
-    await writeFile9(tmp, next);
+    await writeFile10(tmp, next);
     try {
       const loaded = await loadManifest(tmp);
       await resolveSpecs(loaded);
@@ -13826,18 +14468,18 @@ async function applyManifestEdit(manifestPath, edit) {
 }
 
 // src/pipeline/hand-edit.ts
-import { existsSync as existsSync21 } from "fs";
-import { copyFile, mkdir as mkdir7, readFile as readFile19, rename as rename8, rm as rm9, writeFile as writeFile10 } from "fs/promises";
-import path26 from "path";
+import { existsSync as existsSync22 } from "fs";
+import { copyFile, mkdir as mkdir8, readFile as readFile20, rename as rename8, rm as rm9, writeFile as writeFile11 } from "fs/promises";
+import path27 from "path";
 import { z as z8 } from "zod";
 var HAND_EDIT_DIR = "edits";
 function handEditPath(loaded, spec) {
   const style = loaded.manifest.styles[spec.styleId];
-  const outDir = path26.resolve(loaded.root, style?.outDir ?? ".");
-  const relative = path26.relative(outDir, spec.outFile);
-  const inside = relative && !relative.startsWith("..") && !path26.isAbsolute(relative);
-  const file = inside ? relative : path26.basename(spec.outFile);
-  return path26.join(outDir, HAND_EDIT_DIR, file.replace(/\.gif$/i, ".png"));
+  const outDir = path27.resolve(loaded.root, style?.outDir ?? ".");
+  const relative = path27.relative(outDir, spec.outFile);
+  const inside = relative && !relative.startsWith("..") && !path27.isAbsolute(relative);
+  const file = inside ? relative : path27.basename(spec.outFile);
+  return path27.join(outDir, HAND_EDIT_DIR, file.replace(/\.gif$/i, ".png"));
 }
 function handEditBases(spec, lock) {
   const entry = lock.entries[lockKey(spec.styleId, spec.assetId)];
@@ -13850,10 +14492,10 @@ function handEditBases(spec, lock) {
     }));
     if (members.some((member) => member.mediaType && member.mediaType !== "image/png")) return null;
     if (entry.outputs.length === 1 && !primaryOutput(entry)) return null;
-    if (!members.every((member) => existsSync21(member.path))) return null;
+    if (!members.every((member) => existsSync22(member.path))) return null;
     return members.map(({ role, path: file }) => ({ role, path: file }));
   }
-  return existsSync21(spec.outFile) ? [{ role: null, path: spec.outFile }] : null;
+  return existsSync22(spec.outFile) ? [{ role: null, path: spec.outFile }] : null;
 }
 function handEditBase(spec, lock) {
   const bases = handEditBases(spec, lock);
@@ -13883,18 +14525,18 @@ async function startHandEdit(loaded, lock, spec, opts = {}) {
       `${spec.styleId}/${spec.assetId} declares ${spec.source}, one committed file placed for the whole set; clear that source (pixelkiln edit detach) to hand-edit the members one by one`
     );
   }
-  const existing = spec.source ? path26.resolve(loaded.root, spec.source) : null;
+  const existing = spec.source ? path27.resolve(loaded.root, spec.source) : null;
   const editPath = existing ?? handEditPath(loaded, spec);
   const members = handEditMembers(loaded, spec, lock, editPath);
   let created = false;
   for (const member of members) {
-    if (existsSync21(member.path)) continue;
+    if (existsSync22(member.path)) continue;
     if (!member.base) {
       throw new ManifestEditError(
         `${spec.styleId}/${spec.assetId} has no generated PNG on disk to start from; generate or restore it first`
       );
     }
-    await mkdir7(path26.dirname(member.path), { recursive: true });
+    await mkdir8(path27.dirname(member.path), { recursive: true });
     await copyFile(member.base, member.path);
     created = true;
   }
@@ -13973,7 +14615,7 @@ function handEditProjectPath(editPath) {
 async function readHandEditCompanion(editPath) {
   let text;
   try {
-    text = await readFile19(handEditCompanionPath(editPath), "utf8");
+    text = await readFile20(handEditCompanionPath(editPath), "utf8");
   } catch {
     return null;
   }
@@ -14016,7 +14658,7 @@ async function saveHandEdit(loaded, lock, spec, input) {
     }
   });
   const bases = handEditBases(spec, lock);
-  const expectedSize = bases?.[0] ? decodePng(await readFile19(bases[0].path)) : { width: spec.width, height: spec.height };
+  const expectedSize = bases?.[0] ? decodePng(await readFile20(bases[0].path)) : { width: spec.width, height: spec.height };
   for (const [index, image] of decoded.entries()) {
     if (image.width !== expectedSize.width || image.height !== expectedSize.height) {
       const which = memberSet ? `member ${incoming[index].role ?? index}` : "the edit";
@@ -14032,7 +14674,7 @@ async function saveHandEdit(loaded, lock, spec, input) {
     editor: input.editor,
     protocol: input.protocol,
     savedAt: (input.now ?? /* @__PURE__ */ new Date()).toISOString(),
-    project: projectPath ? path26.basename(projectPath) : null,
+    project: projectPath ? path27.basename(projectPath) : null,
     outputs: incoming.map((frame, index) => ({
       role: frame.role,
       basedOn: basedOnHash(entry, index),
@@ -14062,7 +14704,7 @@ function basedOnHash(entry, index) {
 async function replaceFile(file, bytes) {
   const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    await writeFile10(tmp, bytes);
+    await writeFile11(tmp, bytes);
     await rename8(tmp, file);
   } finally {
     await rm9(tmp, { force: true });
@@ -14162,7 +14804,7 @@ function createGalleryEditHandler(opts) {
     }
     const result = await applyManifestEdit(manifestPath, parsed.data);
     if (result.changed) {
-      const relative = path27.relative(process.cwd(), result.manifestPath);
+      const relative = path28.relative(process.cwd(), result.manifestPath);
       const shown = !relative || relative.startsWith("..") ? result.manifestPath : relative;
       const subject = parsed.data.action === "patch-style" ? `style ${parsed.data.styleId}` : parsed.data.action === "set-source" || parsed.data.action === "clear-source" ? `${parsed.data.styleId}/${parsed.data.assetId} source` : parsed.data.assetId;
       log(`  manifest edited: ${parsed.data.action === "add-asset" ? "added" : "changed"} ${subject} in ${shown}`);
@@ -14174,7 +14816,7 @@ function createGalleryEditHandler(opts) {
 // src/gallery/snapshot.ts
 var PROJECT_FILE_TYPE = "application/octet-stream";
 function galleryMediaId(absolutePath) {
-  return createHash4("sha256").update(path28.resolve(absolutePath)).digest("hex").slice(0, 24);
+  return createHash4("sha256").update(path29.resolve(absolutePath)).digest("hex").slice(0, 24);
 }
 function galleryMediaRoute(id) {
   return `/media/${id}`;
@@ -14193,9 +14835,9 @@ function describeHistory(media, entry, cacheDir) {
   return (entry.history ?? []).map((generation, i) => {
     const outputs = generation.outputs.map((output) => {
       const mediaType = output.mediaType ?? MediaType.PNG;
-      const file = path28.join(cacheDir, cacheFileName(output.sha256, mediaType));
+      const file = path29.join(cacheDir, cacheFileName(output.sha256, mediaType));
       let url = null;
-      if (existsSync22(file)) {
+      if (existsSync23(file)) {
         const id = galleryMediaId(file);
         media.set(id, { path: file, contentType: mediaType });
         url = `${galleryMediaRoute(id)}?v=${output.sha256.slice(0, 24)}`;
@@ -14227,7 +14869,7 @@ function describeHistory(media, entry, cacheDir) {
 var MAX_COMPARED_BYTES = 8 * 1024 * 1024;
 async function samePixels(a, b) {
   try {
-    const [left, right] = await Promise.all([readFile20(a), readFile20(b)]);
+    const [left, right] = await Promise.all([readFile21(a), readFile21(b)]);
     if (left.length > MAX_COMPARED_BYTES || right.length > MAX_COMPARED_BYTES) return false;
     const x = decodePng(left);
     const y = decodePng(right);
@@ -14239,6 +14881,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 {
@@ -14324,10 +14967,10 @@ async function describeOutput(media, root, absolutePath, recorded = {}) {
 async function describeQuality(media, root, inspection) {
   const outputPaths = inspection.outputs ?? [inspection.output];
   const outputs = await Promise.all(
-    outputPaths.map((file) => describeOutput(media, root, path28.resolve(root, file)))
+    outputPaths.map((file) => describeOutput(media, root, path29.resolve(root, file)))
   );
-  const recordPath = path28.resolve(root, inspection.record);
-  const recordExists = existsSync22(recordPath);
+  const recordPath = path29.resolve(root, inspection.record);
+  const recordExists = existsSync23(recordPath);
   let options = null;
   let check = null;
   if (recordExists) {
@@ -14346,7 +14989,7 @@ async function describeQuality(media, root, inspection) {
   return {
     state: inspection.state,
     reason: inspection.reason,
-    output: portableOutputPath(path28.resolve(root, inspection.output), root),
+    output: portableOutputPath(path29.resolve(root, inspection.output), root),
     record: portableOutputPath(recordPath, root),
     recordExists,
     outputs,
@@ -14379,13 +15022,14 @@ async function describeQuality(media, root, inspection) {
 }
 async function buildGallerySnapshot(opts) {
   const { loaded, specs, lock } = opts;
+  const filter = opts.filter?.assets?.length ? { ...opts.filter, assets: expandAssetFilter(opts.filter.assets, loaded.loopFamilies) } : opts.filter;
   const root = loaded.root;
   const media = /* @__PURE__ */ new Map();
   const plan = await buildPlan(specs, lock);
   const items = [];
-  const manifestText = await readFile20(loaded.path, "utf8");
+  const manifestText = await readFile21(loaded.path, "utf8");
   const manifestSha256 = sha256(manifestText);
-  const cacheDir = path28.resolve(path28.dirname(opts.lockPath), ".pixelkiln", "cache");
+  const cacheDir = path29.resolve(path29.dirname(opts.lockPath), ".pixelkiln", "cache");
   let rawStyles = {};
   try {
     const raw = JSON.parse(manifestText);
@@ -14409,12 +15053,12 @@ async function buildGallerySnapshot(opts) {
         )
       );
       if (spec.source) {
-        const editPath = path28.resolve(root, spec.source);
+        const editPath = path29.resolve(root, spec.source);
         const memberCount = sourceIsStem(spec.source, entry, root) ? entry.outputs.length : 1;
         const editShas = await Promise.all(
           Array.from({ length: memberCount }, async (_, index) => {
             const file = sourceOutputPath(spec.source, entry, index, root);
-            return { file, sha256: existsSync22(file) ? await sha256File(file) : null };
+            return { file, sha256: existsSync23(file) ? await sha256File(file) : null };
           })
         );
         edits = await Promise.all(editShas.map(({ file, sha256: editSha }) => describeOutput(media, root, file, { sha256: editSha })));
@@ -14422,7 +15066,7 @@ async function buildGallerySnapshot(opts) {
         const companion = await readHandEditCompanion(editPath);
         if (companion) {
           const projectPath = handEditProjectPath(editPath);
-          const project = companion.project && existsSync22(projectPath) ? await fileInfo(projectPath) : null;
+          const project = companion.project && existsSync23(projectPath) ? await fileInfo(projectPath) : null;
           let projectUrl = null;
           if (project) {
             const id = galleryMediaId(projectPath);
@@ -14458,8 +15102,8 @@ async function buildGallerySnapshot(opts) {
         editStatus = edits.some((member) => !member.exists) ? "missing" : editChanged.every((changed) => !changed) ? "same" : regenerated ? "regenerated-since" : "edited";
       }
     } else if (spec.source) {
-      outputs = [await describeOutput(media, root, path28.resolve(root, spec.source))];
-    } else if (!entry && existsSync22(spec.outFile)) {
+      outputs = [await describeOutput(media, root, path29.resolve(root, spec.source))];
+    } else if (!entry && existsSync23(spec.outFile)) {
       outputs = [await describeOutput(media, root, spec.outFile)];
     } else {
       outputs = [];
@@ -14523,7 +15167,7 @@ async function buildGallerySnapshot(opts) {
   for (const [key, entry] of Object.entries(lock.entries)) {
     if (shown.has(key)) continue;
     if (isDeclared(loaded, entry.styleId, entry.assetId)) continue;
-    if (!matchesFilter(opts.filter, entry.styleId, entry.assetId)) continue;
+    if (!matchesFilter(filter, entry.styleId, entry.assetId)) continue;
     const outputs = await Promise.all(
       entry.outputs.map(
         (output) => describeOutput(media, root, resolveOutputPath(output.path, root), output)
@@ -14652,7 +15296,7 @@ async function buildGallerySnapshot(opts) {
       id: loaded.manifest.name,
       name: loaded.manifest.name,
       manifest: loaded.path,
-      lock: path28.resolve(opts.lockPath),
+      lock: path29.resolve(opts.lockPath),
       root,
       provider: loaded.manifest.provider,
       account: null,
@@ -14678,7 +15322,7 @@ async function buildGallerySnapshot(opts) {
   return { snapshot, media };
 }
 async function buildWorkspaceGallerySnapshot(opts) {
-  const dir = path28.dirname(path28.resolve(opts.workspacePath));
+  const dir = path29.dirname(path29.resolve(opts.workspacePath));
   const media = /* @__PURE__ */ new Map();
   const projects = [];
   const items = [];
@@ -14689,7 +15333,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
     try {
       const loaded = await loadManifest(manifestPath);
       const styleFilter = filter.styles.filter((id) => loaded.manifest.styles[id]);
-      const assetFilter = filter.assets.filter((id) => loaded.manifest.assets[id]);
+      const assetFilter = expandAssetFilter(filter.assets, loaded.loopFamilies).filter((id) => loaded.manifest.assets[id]);
       const excluded = filter.styles.length > 0 && styleFilter.length === 0 || filter.assets.length > 0 && assetFilter.length === 0;
       const lock = await loadLock(lockPath);
       let projectItems = [];
@@ -14721,11 +15365,11 @@ async function buildWorkspaceGallerySnapshot(opts) {
         id: project.id,
         name: loaded.manifest.name,
         manifest: manifestPath,
-        lock: path28.resolve(lockPath),
+        lock: path29.resolve(lockPath),
         root: loaded.root,
         provider: loaded.manifest.provider,
         account: project.account ?? null,
-        manifestSha256: manifestSha256 ?? sha256(await readFile20(manifestPath, "utf8")),
+        manifestSha256: manifestSha256 ?? sha256(await readFile21(manifestPath, "utf8")),
         historyLimit: historyLimit(loaded.manifest),
         entries: Object.keys(lock.entries).length,
         items: projectItems.length,
@@ -14737,8 +15381,8 @@ async function buildWorkspaceGallerySnapshot(opts) {
         id: project.id,
         name: project.id,
         manifest: manifestPath,
-        lock: path28.resolve(lockPath),
-        root: path28.dirname(manifestPath),
+        lock: path29.resolve(lockPath),
+        root: path29.dirname(manifestPath),
         provider: project.provider,
         account: project.account ?? null,
         manifestSha256: null,
@@ -14765,7 +15409,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
       version: 1,
       generatedAt: (opts.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
       project: null,
-      workspace: { path: path28.resolve(opts.workspacePath), dir, projects },
+      workspace: { path: path29.resolve(opts.workspacePath), dir, projects },
       filter,
       totals: {
         entries: projects.reduce((sum, project) => sum + project.entries, 0),
@@ -14914,10 +15558,10 @@ var EDITOR_RELEASE_BASE = "https://github.com/gfargo/pixelkiln/releases/download
 
 // src/editor/install.ts
 import { createHash as createHash5 } from "crypto";
-import { existsSync as existsSync23 } from "fs";
-import { mkdir as mkdir8, readFile as readFile21, rename as rename9, rm as rm10, stat as stat4, writeFile as writeFile11 } from "fs/promises";
+import { existsSync as existsSync24 } from "fs";
+import { mkdir as mkdir9, readFile as readFile22, rename as rename9, rm as rm10, stat as stat4, writeFile as writeFile12 } from "fs/promises";
 import os2 from "os";
-import path29 from "path";
+import path30 from "path";
 var EditorInstallError = class extends Error {
   constructor(message6, file) {
     super(message6);
@@ -14928,15 +15572,15 @@ var EditorInstallError = class extends Error {
 };
 function editorToolsRoot() {
   const override = process.env.PIXELKILN_TOOLS_DIR?.trim();
-  if (override) return path29.resolve(override);
-  if (process.platform === "darwin") return path29.join(os2.homedir(), "Library", "Caches", "pixelkiln", "tools");
+  if (override) return path30.resolve(override);
+  if (process.platform === "darwin") return path30.join(os2.homedir(), "Library", "Caches", "pixelkiln", "tools");
   if (process.platform === "win32") {
-    return path29.join(process.env.LOCALAPPDATA ?? path29.join(os2.homedir(), "AppData", "Local"), "pixelkiln", "tools");
+    return path30.join(process.env.LOCALAPPDATA ?? path30.join(os2.homedir(), "AppData", "Local"), "pixelkiln", "tools");
   }
-  return path29.join(process.env.XDG_CACHE_HOME ?? path29.join(os2.homedir(), ".cache"), "pixelkiln", "tools");
+  return path30.join(process.env.XDG_CACHE_HOME ?? path30.join(os2.homedir(), ".cache"), "pixelkiln", "tools");
 }
 function editorDir(pin = EDITOR_PIN, root = editorToolsRoot()) {
-  return path29.join(root, "pixelorama", pin.release ?? "unpublished");
+  return path30.join(root, "pixelorama", pin.release ?? "unpublished");
 }
 function editorBaseUrl(pin = EDITOR_PIN) {
   const override = process.env.PIXELKILN_EDITOR_URL?.trim();
@@ -14946,7 +15590,7 @@ function editorBaseUrl(pin = EDITOR_PIN) {
 }
 async function sha256Of(file) {
   try {
-    return createHash5("sha256").update(await readFile21(file)).digest("hex");
+    return createHash5("sha256").update(await readFile22(file)).digest("hex");
   } catch {
     return null;
   }
@@ -14959,8 +15603,8 @@ async function editorStatus(opts = {}) {
   let totalBytes = 0;
   for (const [name, expected] of Object.entries(pin.files)) {
     totalBytes += expected.bytes;
-    const file = path29.join(dir, name);
-    const info = existsSync23(file) ? await stat4(file).catch(() => null) : null;
+    const file = path30.join(dir, name);
+    const info = existsSync24(file) ? await stat4(file).catch(() => null) : null;
     if (info && info.size === expected.bytes && await sha256Of(file) === expected.sha256) {
       installedBytes += expected.bytes;
     } else {
@@ -14989,7 +15633,7 @@ async function installEditor(opts = {}) {
     );
   }
   if (!baseUrl) throw new EditorInstallError("no download location for the editor build");
-  await mkdir8(dir, { recursive: true });
+  await mkdir9(dir, { recursive: true });
   const downloaded = [];
   const skipped = Object.keys(pin.files).filter((name) => !before.missing.includes(name));
   let fetchedBytes = before.installedBytes;
@@ -15017,10 +15661,10 @@ async function installEditor(opts = {}) {
     if (digest2 !== expected.sha256) {
       throw new EditorInstallError(`${name}: sha256 ${digest2.slice(0, 12)}\u2026 does not match the pinned ${expected.sha256.slice(0, 12)}\u2026`, name);
     }
-    const final = path29.join(dir, name);
+    const final = path30.join(dir, name);
     const tmp = `${final}.${process.pid}.part`;
     try {
-      await writeFile11(tmp, bytes);
+      await writeFile12(tmp, bytes);
       await rename9(tmp, final);
     } finally {
       await rm10(tmp, { force: true });
@@ -15063,12 +15707,12 @@ var EDITOR_CONTENT_TYPES = {
   ".json": "application/json; charset=utf-8"
 };
 function editorContentType(name) {
-  return EDITOR_CONTENT_TYPES[path29.extname(name).toLowerCase()] ?? null;
+  return EDITOR_CONTENT_TYPES[path30.extname(name).toLowerCase()] ?? null;
 }
 
 // src/gallery/editor.ts
-import { readFile as readFile22 } from "fs/promises";
-import path30 from "path";
+import { readFile as readFile23 } from "fs/promises";
+import path31 from "path";
 function editorRoute(release, name = "index.html") {
   return `/editor/${encodeURIComponent(release)}/${encodeURIComponent(name)}`;
 }
@@ -15141,7 +15785,7 @@ function createGalleryEditorHandlers(opts = {}) {
       if (!status.installed) return null;
       let bytes;
       try {
-        bytes = await readFile22(path30.join(dir, name));
+        bytes = await readFile23(path31.join(dir, name));
       } catch {
         verified = null;
         return null;
@@ -15158,7 +15802,7 @@ function createGalleryEditorHandlers(opts = {}) {
 // src/gallery/server.ts
 import { randomBytes } from "crypto";
 import { createServer as createServer2 } from "http";
-import { readFile as readFile23 } from "fs/promises";
+import { readFile as readFile24 } from "fs/promises";
 var MAX_EDIT_BYTES = 48 * 1024 * 1024;
 var EDITOR_CSP = [
   "default-src 'self'",
@@ -15317,7 +15961,7 @@ async function serveGallery(opts) {
         const asset = reviewAssets.get(jobId)?.get(url2.pathname);
         if (!asset) return fail(404, "no such review asset");
         try {
-          const bytes = await readFile23(asset.path);
+          const bytes = await readFile24(asset.path);
           res.writeHead(200, {
             "Content-Type": asset.contentType,
             "Cache-Control": "no-store",
@@ -15393,7 +16037,7 @@ async function serveGallery(opts) {
         if (!asset) return fail(404, "no such gallery media");
         let bytes;
         try {
-          bytes = await readFile23(asset.path);
+          bytes = await readFile24(asset.path);
         } catch {
           return fail(404, "gallery media is no longer on disk; refresh the page");
         }
@@ -15767,19 +16411,19 @@ function createGenerateHandlers(opts) {
 }
 
 // src/pipeline/salvage.ts
-import { readFile as readFile24 } from "fs/promises";
-import { existsSync as existsSync24 } from "fs";
-import path31 from "path";
+import { readFile as readFile25 } from "fs/promises";
+import { existsSync as existsSync25 } from "fs";
+import path32 from "path";
 function providerClaimId(provider, objectId) {
   return `${encodeURIComponent(provider)}:${encodeURIComponent(objectId)}`;
 }
 async function loadClaims(lockPaths, opts = {}) {
   const claimed = /* @__PURE__ */ new Set();
   for (const p of lockPaths) {
-    if (!existsSync24(p)) throw new Error(`Claim lockfile not found: ${p}`);
+    if (!existsSync25(p)) throw new Error(`Claim lockfile not found: ${p}`);
     let parsed;
     try {
-      parsed = parseLock(JSON.parse(await readFile24(p, "utf8")));
+      parsed = parseLock(JSON.parse(await readFile25(p, "utf8")));
     } catch {
       throw new Error(`Claim lockfile is malformed: ${p}`);
     }
@@ -15832,20 +16476,20 @@ function matchOrphanStyle(prompt, manifest) {
   return matchStyleByPattern(prompt, manifest);
 }
 async function loadSiblingManifests(ownManifestPath, workspaceManifestPaths, claimPaths) {
-  const own = path31.resolve(ownManifestPath);
+  const own = path32.resolve(ownManifestPath);
   const siblingManifestPaths = [
     .../* @__PURE__ */ new Set([
       ...workspaceManifestPaths,
-      ...claimPaths.map((c) => path31.join(path31.dirname(path31.resolve(c)), "pixelkiln.manifest.json"))
+      ...claimPaths.map((c) => path32.join(path32.dirname(path32.resolve(c)), "pixelkiln.manifest.json"))
     ])
   ];
   const siblings = [];
   for (const siblingManifestPath of siblingManifestPaths) {
-    if (path31.resolve(siblingManifestPath) === own) continue;
-    if (!existsSync24(siblingManifestPath)) continue;
+    if (path32.resolve(siblingManifestPath) === own) continue;
+    if (!existsSync25(siblingManifestPath)) continue;
     try {
       const { manifest } = await loadManifest(siblingManifestPath);
-      siblings.push({ label: path31.basename(path31.dirname(siblingManifestPath)), manifest });
+      siblings.push({ label: path32.basename(path32.dirname(siblingManifestPath)), manifest });
     } catch {
     }
   }
@@ -15961,8 +16605,8 @@ async function applyTags(provider, decisions, existing, opts = {}) {
 }
 
 // src/pick/salvage-server.ts
-import { mkdir as mkdir9, writeFile as writeFile12, readFile as readFile25 } from "fs/promises";
-import path32 from "path";
+import { mkdir as mkdir10, writeFile as writeFile13, readFile as readFile26 } from "fs/promises";
+import path33 from "path";
 
 // src/pick/salvage-sheet.ts
 var escapeHtml3 = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
@@ -16127,7 +16771,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
   });
   const html = renderSalvageSheet(orphans, {
     styleId: ctx.styleId,
-    importDir: path32.relative(process.cwd(), ctx.importDir) || "."
+    importDir: path33.relative(process.cwd(), ctx.importDir) || "."
   });
   const byId = new Map(orphans.map((o) => [o.id, o]));
   const existingTags = new Map(orphans.map((o) => [o.id, o.tags]));
@@ -16156,10 +16800,10 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
             if (!buf.subarray(0, 8).equals(PNG_SIGNATURE2)) throw new Error("not a PNG");
             decodePng(buf);
             const assetId = idFromPrompt(orphan.prompt, taken);
-            const rel = path32.join("_salvaged", `${assetId}.png`);
-            const outFile = path32.resolve(ctx.importDir, rel);
-            await mkdir9(path32.dirname(outFile), { recursive: true });
-            await writeFile12(outFile, buf);
+            const rel = path33.join("_salvaged", `${assetId}.png`);
+            const outFile = path33.resolve(ctx.importDir, rel);
+            await mkdir10(path33.dirname(outFile), { recursive: true });
+            await writeFile13(outFile, buf);
             ctx.manifest.assets[assetId] = {
               prompt: orphan.prompt,
               promptByStyle: {},
@@ -16191,7 +16835,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
               sourceUrl: durableSource,
               sourceUrls: durableSource ? [{ url: durableSource }] : [],
               outputs: [{
-                path: portableOutputPath(outFile, path32.dirname(ctx.manifestPath)),
+                path: portableOutputPath(outFile, path33.dirname(ctx.manifestPath)),
                 sha256: sha256(buf)
               }],
               submittedAt: orphan.createdAt,
@@ -16215,9 +16859,9 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
         }
       }
       await applyTags(provider, decisions, existingTags, { onProgress: log });
-      const raw = JSON.parse(await readFile25(ctx.manifestPath, "utf8"));
+      const raw = JSON.parse(await readFile26(ctx.manifestPath, "utf8"));
       for (const id of importedAssetIds) raw.assets[id] = ctx.manifest.assets[id];
-      await writeFile12(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
+      await writeFile13(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
       await saveLock(ctx.lockPath, ctx.lock);
       return result;
     }
@@ -16346,6 +16990,10 @@ export {
   EXIT_CODES,
   EditorInstallError,
   FAKE_PNG,
+  FONT_COST_GENERATIONS,
+  FONT_GLYPH_SIZES,
+  FONT_WEIGHTS,
+  FRAME_SET_REVISION_MODES,
   FakeProvider,
   GenerateRequestError,
   GenerateRequestSchema,
@@ -16362,6 +17010,7 @@ export {
   MAX_DOWNLOAD_BYTES,
   MAX_HAND_EDIT_BYTES,
   MAX_RETRIES,
+  MEMBER_SET_REVISION_MODES,
   MIRRORED_DIRECTION,
   ManifestDriftError,
   ManifestEditError,
@@ -16391,6 +17040,8 @@ export {
   ScenarioProvider,
   StyleInputSchema,
   StyleSchema,
+  UNZOOM_MAX_AREA,
+  UNZOOM_MIN_SIDE,
   UiElementSchema,
   UiPieceSchema,
   UnsupportedCapabilityError,
@@ -16425,6 +17076,7 @@ export {
   currentEntryOutputPath,
   currentOutputPath,
   defaultOpenCommand,
+  defaultUnzoomOut,
   detachHandEdit,
   detectMediaType,
   doctor,
@@ -16442,10 +17094,12 @@ export {
   fetchAssets,
   fetchWithRetry,
   findOrphans,
+  fontOutputPaths,
   formatCost,
   frameSetFps,
   galleryMediaId,
   galleryMediaRoute,
+  generateFont,
   generationCost,
   groupOrphansByStyle,
   handEditBase,
@@ -16581,6 +17235,7 @@ export {
   tilesCost,
   toPortablePath,
   totalSpend,
+  unzoomFile,
   upsert,
   validateCostEstimate,
   validateMedia,