pixelkiln 0.61.0 → 0.63.0

package/dist/index.cjs

@@ -52,6 +52,10 @@ __export(index_exports, {
   EXIT_CODES: () => EXIT_CODES,
   EditorInstallError: () => EditorInstallError,
   FAKE_PNG: () => FAKE_PNG,
+  FONT_COST_GENERATIONS: () => FONT_COST_GENERATIONS,
+  FONT_GLYPH_SIZES: () => FONT_GLYPH_SIZES,
+  FONT_WEIGHTS: () => FONT_WEIGHTS,
+  FRAME_SET_REVISION_MODES: () => FRAME_SET_REVISION_MODES,
   FakeProvider: () => FakeProvider,
   GenerateRequestError: () => GenerateRequestError,
   GenerateRequestSchema: () => GenerateRequestSchema,
@@ -68,6 +72,7 @@ __export(index_exports, {
   MAX_DOWNLOAD_BYTES: () => MAX_DOWNLOAD_BYTES,
   MAX_HAND_EDIT_BYTES: () => MAX_HAND_EDIT_BYTES,
   MAX_RETRIES: () => MAX_RETRIES,
+  MEMBER_SET_REVISION_MODES: () => MEMBER_SET_REVISION_MODES,
   MIRRORED_DIRECTION: () => MIRRORED_DIRECTION,
   ManifestDriftError: () => ManifestDriftError,
   ManifestEditError: () => ManifestEditError,
@@ -97,6 +102,8 @@ __export(index_exports, {
   ScenarioProvider: () => ScenarioProvider,
   StyleInputSchema: () => StyleInputSchema,
   StyleSchema: () => StyleSchema,
+  UNZOOM_MAX_AREA: () => UNZOOM_MAX_AREA,
+  UNZOOM_MIN_SIDE: () => UNZOOM_MIN_SIDE,
   UiElementSchema: () => UiElementSchema,
   UiPieceSchema: () => UiPieceSchema,
   UnsupportedCapabilityError: () => UnsupportedCapabilityError,
@@ -131,6 +138,7 @@ __export(index_exports, {
   currentEntryOutputPath: () => currentEntryOutputPath,
   currentOutputPath: () => currentOutputPath,
   defaultOpenCommand: () => defaultOpenCommand,
+  defaultUnzoomOut: () => defaultUnzoomOut,
   detachHandEdit: () => detachHandEdit,
   detectMediaType: () => detectMediaType,
   doctor: () => doctor,
@@ -148,10 +156,12 @@ __export(index_exports, {
   fetchAssets: () => fetchAssets,
   fetchWithRetry: () => fetchWithRetry,
   findOrphans: () => findOrphans,
+  fontOutputPaths: () => fontOutputPaths,
   formatCost: () => formatCost,
   frameSetFps: () => frameSetFps,
   galleryMediaId: () => galleryMediaId,
   galleryMediaRoute: () => galleryMediaRoute,
+  generateFont: () => generateFont,
   generationCost: () => generationCost,
   groupOrphansByStyle: () => groupOrphansByStyle,
   handEditBase: () => handEditBase,
@@ -287,6 +297,7 @@ __export(index_exports, {
   tilesCost: () => tilesCost,
   toPortablePath: () => toPortablePath,
   totalSpend: () => totalSpend,
+  unzoomFile: () => unzoomFile,
   upsert: () => upsert,
   validateCostEstimate: () => validateCostEstimate,
   validateMedia: () => validateMedia,
@@ -308,7 +319,7 @@ var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
 // src/types.ts
 var import_zod = require("zod");
 var MediaTypeSchema = import_zod.z.enum(["image/png", "image/gif"]);
-var GeneratorSchema = import_zod.z.enum(["1dir", "map", "pixflux", "tiles", "animation", "frames", "character", "terrain", "imagePro", "isometricTile", "objectPro", "uiAsset"]);
+var GeneratorSchema = import_zod.z.enum(["1dir", "map", "pixflux", "tiles", "animation", "frames", "character", "terrain", "imagePro", "isometricTile", "objectPro", "uiAsset", "uiElement"]);
 var GridConfidenceSchema = import_zod.z.enum(["low", "medium", "high"]);
 var RevisionModeSchema = import_zod.z.enum([
   "image-to-image",
@@ -317,7 +328,9 @@ var RevisionModeSchema = import_zod.z.enum([
   "reduce-colors",
   "correct-pixelart",
   "animate",
-  "animate-pixminimax"
+  "animate-pixminimax",
+  "interpolate",
+  "edit-animation"
 ]);
 function tileVariationCount(descriptions) {
   return Math.max(1, descriptions) * 4;
@@ -498,6 +511,14 @@ var CharacterAnimationSchema = import_zod.z.object({
   template: import_zod.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: import_zod.z.array(CharacterDirectionSchema).min(1).optional(),
   /** Frames to generate without a template (v3). Even, 4 to 16. */
   frames: import_zod.z.number().int().min(4).max(16).optional(),
   /** Playback rate recorded with the frames; PixelLab does not store one. */
@@ -526,6 +547,13 @@ var CharacterAnimationSchema = import_zod.z.object({
   /** v3 text loops only: let PixelLab expand the action into a fuller motion description first. */
   enhancePrompt: import_zod.z.boolean().optional()
 }).strict().superRefine((animation, context) => {
+  if (animation.directions !== void 0) {
+    context.addIssue({
+      code: import_zod.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: import_zod.z.ZodIssueCode.custom, message: "frames must be even", path: ["frames"] });
   }
@@ -586,9 +614,13 @@ var RevisionSchema = import_zod.z.object({
    * the provider layer, since it differs by mode).
    */
   frames: import_zod.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: import_zod.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: import_zod.z.string().min(1).optional(),
   /** `animate-pixminimax` only: facing direction, used only alongside `enhancePrompt` to hold the sprite's facing. */
   direction: CharacterDirectionSchema.optional(),
@@ -632,14 +664,15 @@ var RevisionSchema = import_zod.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: import_zod.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: import_zod.z.ZodIssueCode.custom,
@@ -648,6 +681,27 @@ var RevisionSchema = import_zod.z.object({
       });
     }
   }
+  if (revision.lastFrame !== void 0 && revision.mode !== "animate" && revision.mode !== "animate-pixminimax" && revision.mode !== "interpolate") {
+    context.addIssue({
+      code: import_zod.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: import_zod.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: import_zod.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: import_zod.z.ZodIssueCode.custom,
@@ -659,6 +713,8 @@ var RevisionSchema = import_zod.z.object({
     context.addIssue({ code: import_zod.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 = import_zod.z.object({
   /** Generation backend for this style. Omit to inherit the manifest default. */
   provider: import_zod.z.string().min(1).optional(),
@@ -777,7 +833,7 @@ var StyleObjectSchema = import_zod.z.object({
    */
   terrainMode: import_zod.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.
    */
@@ -1655,6 +1711,21 @@ var CorrectPixelartResponseSchema = import_zod2.z.object({
   images: import_zod2.z.array(import_zod2.z.object({ base64: import_zod2.z.string().min(1) }).passthrough()).min(1),
   usage: import_zod2.z.unknown().optional()
 }).passthrough();
+var UnzoomResponseSchema = import_zod2.z.object({
+  image: import_zod2.z.object({ base64: import_zod2.z.string().min(1) }).passthrough(),
+  original_size: import_zod2.z.object({ width: import_zod2.z.number().int(), height: import_zod2.z.number().int() }).passthrough(),
+  unzoomed_size: import_zod2.z.object({ width: import_zod2.z.number().int(), height: import_zod2.z.number().int() }).passthrough(),
+  zoom_factor_detected: import_zod2.z.number(),
+  usage: import_zod2.z.unknown().optional()
+}).passthrough();
+var FontJobSchema = import_zod2.z.object({
+  job_id: import_zod2.z.string().min(1),
+  status: import_zod2.z.string(),
+  glyph_px: import_zod2.z.number().int().nullable().optional(),
+  download_atlas_url: import_zod2.z.string().nullable().optional(),
+  download_ttf_url: import_zod2.z.string().nullable().optional(),
+  usage: import_zod2.z.unknown().optional()
+}).passthrough();
 var SelectFramesSchema = import_zod2.z.object({ created_object_ids: import_zod2.z.array(import_zod2.z.string()) }).passthrough();
 var CharacterSubmitSchema = import_zod2.z.object({
   background_job_id: import_zod2.z.string().min(1),
@@ -1739,6 +1810,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 });
@@ -1767,9 +1849,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,
@@ -1779,13 +1861,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() {
@@ -2171,10 +2253,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,
@@ -2188,7 +2270,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,
@@ -2211,7 +2293,7 @@ var PixelLabClient = class {
         } : {}
       };
     } else if (args.mode === "pro") {
-      path33 = "/create-character-pro";
+      path34 = "/create-character-pro";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -2225,7 +2307,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,
@@ -2242,8 +2324,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) {
@@ -2405,20 +2487,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;
@@ -2428,8 +2542,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
@@ -2438,19 +2554,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,
@@ -3111,10 +3325,10 @@ var import_node_fs = require("fs");
 function sha256(data) {
   return (0, import_node_crypto.createHash)("sha256").update(data).digest("hex");
 }
-async function sha256File(path33) {
+async function sha256File(path34) {
   return new Promise((resolve, reject) => {
     const hash = (0, import_node_crypto.createHash)("sha256");
-    const stream = (0, import_node_fs.createReadStream)(path33);
+    const stream = (0, import_node_fs.createReadStream)(path34);
     stream.on("data", (chunk2) => hash.update(chunk2));
     stream.on("error", reject);
     stream.on("end", () => resolve(hash.digest("hex")));
@@ -3142,7 +3356,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,
@@ -3349,7 +3563,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`,
@@ -3359,12 +3573,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,
@@ -3392,6 +3609,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;
@@ -3420,6 +3643,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)) {
@@ -3428,9 +3657,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`
         );
       }
     }
@@ -3454,6 +3684,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");
     }
@@ -3470,6 +3730,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, [
@@ -3553,8 +3821,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`);
     }
@@ -4121,6 +4389,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({
@@ -4249,13 +4530,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 = (0, import_node_fs2.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 = (0, import_node_fs2.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`);
@@ -4288,34 +4574,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 = (0, import_node_crypto2.randomUUID)();
-      (0, import_node_fs2.writeFileSync)(import_node_path.default.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 = (0, import_node_crypto2.randomUUID)();
-      (0, import_node_fs2.writeFileSync)(import_node_path.default.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 = (0, import_node_fs2.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,
@@ -4355,6 +4652,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 = (0, import_node_fs2.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 = (0, import_node_crypto2.randomUUID)();
+    if (!roles) {
+      (0, import_node_fs2.writeFileSync)(import_node_path.default.join(_PixelLabProvider.cacheDir(), `${jobId}.png`), pngs[0]);
+      return { jobId, metadata: { revisionUsage: usage } };
+    }
+    for (const [index, png] of pngs.entries()) {
+      (0, import_node_fs2.writeFileSync)(import_node_path.default.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
@@ -4375,7 +4702,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);
@@ -4398,6 +4725,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") {
@@ -4424,15 +4752,32 @@ var PixelLabProvider = class _PixelLabProvider {
    * work.
    */
   async pollCachedRevision(jobId, context) {
-    const file = import_node_path.default.join(_PixelLabProvider.cacheDir(), `${jobId}.png`);
-    if (!(0, import_node_fs2.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://${import_node_path.default.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`)}`,
+        role: String(role)
+      }));
+      if (sources.some((source) => !(0, import_node_fs2.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 = import_node_path.default.join(_PixelLabProvider.cacheDir(), `${jobId}.png`);
+    if (!(0, import_node_fs2.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) };
   }
   /**
@@ -4456,16 +4801,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;
@@ -4497,7 +4847,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`
     };
   }
   /**
@@ -4587,6 +4937,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 = import_node_path.default.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`);
+      (0, import_node_fs2.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
@@ -4747,9 +5127,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 = import_node_path.default.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`);
-      if (!(0, import_node_fs2.existsSync)(file)) throw new Error(`imagePro job ${jobId} has no cached candidate at index ${index}`);
+      if (!(0, import_node_fs2.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);
@@ -4903,6 +5283,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 = [];
@@ -4995,9 +5381,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",
@@ -6039,14 +6425,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 {
@@ -6099,6 +6486,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");
       }
@@ -6933,6 +7325,91 @@ var import_promises3 = require("fs/promises");
 var import_node_fs5 = require("fs");
 var import_node_path5 = __toESM(require("path"), 1);
 
+// 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
 var import_node_fs4 = require("fs");
 var import_node_path4 = __toESM(require("path"), 1);
@@ -7251,7 +7728,12 @@ function frameSetFps(entry) {
 async function loadManifest(manifestPath) {
   const abs = import_node_path5.default.resolve(manifestPath);
   if (!(0, import_node_fs5.existsSync)(abs)) throw new ProjectError(`No manifest at ${abs}`);
-  const input = ManifestInputSchema.safeParse(JSON.parse(await (0, import_promises3.readFile)(abs, "utf8")));
+  const expansion = expandLoopDirections(JSON.parse(await (0, import_promises3.readFile)(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:
@@ -7336,7 +7818,8 @@ ${issues}`);
     throw new ProjectError(`Manifest at ${abs} is invalid:
 ${unknownReferences.map((i) => `  ${i}`).join("\n")}`);
   }
-  return { manifest: parsed.data, root: import_node_path5.default.dirname(abs), path: abs };
+  const loopFamilies = Object.keys(expansion.families).length ? { loopFamilies: expansion.families } : {};
+  return { manifest: parsed.data, root: import_node_path5.default.dirname(abs), path: abs, ...loopFamilies };
 }
 function parentAssetId(asset) {
   return asset?.revision?.from ?? asset?.state?.of ?? asset?.animation?.of;
@@ -7420,12 +7903,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]);
@@ -7520,7 +8004,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);
@@ -7587,7 +8071,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,
@@ -7627,8 +8111,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
@@ -7779,8 +8266,11 @@ async function resolveSpecs(loaded, filter) {
           );
         }
         const sourceSpec = await finalize(asset.revision.from);
-        const sourceFile = sourceSpec.quality?.outFile ?? (sourceSpec.source ? import_node_path5.default.resolve(root, sourceSpec.source) : sourceSpec.outFile);
-        const sourceImage = await optionalRevisionImage(sourceFile, "revision source");
+        const sourceStem = sourceSpec.quality?.outFile ?? (sourceSpec.source ? import_node_path5.default.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 ? import_node_path5.default.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)) {
@@ -7801,6 +8291,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,
@@ -7950,6 +8442,38 @@ async function optionalRevisionImage(file, label, requiredFormat) {
   }
   return { hash: sha256(bytes), ...metadata };
 }
+async function revisionSourceMembers(stem, label) {
+  if ((0, import_node_fs5.existsSync)(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) => (0, import_node_fs5.existsSync)(at(direction)))) {
+      roles = [...set];
+      break;
+    }
+  }
+  if (!roles.length) {
+    for (let index = 0; (0, import_node_fs5.existsSync)(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}"`);
@@ -9632,11 +10156,16 @@ async function inspectRevision(spec, lock, seen) {
       reason: `revision source ${spec.styleId}/${revision.sourceAssetId} is not ready: ${dependency.reason}`
     };
   }
-  if (!revision.sourceSha256 || !(0, import_node_fs8.existsSync)(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 || !(0, import_node_fs8.existsSync)(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 || !(0, import_node_fs8.existsSync)(revision.maskFile)) {
@@ -9646,8 +10175,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 || !(0, import_node_fs8.existsSync)(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 (!(0, import_node_fs8.existsSync)(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) => import_node_path11.default.resolve(currentEntryOutputPath(entry, parent, index))).sort();
+  const found = members.map((member) => import_node_path11.default.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);
@@ -10482,16 +11042,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
-var import_node_path16 = __toESM(require("path"), 1);
+// src/pixellab-utils.ts
 var import_node_fs12 = require("fs");
 var import_promises9 = require("fs/promises");
+var import_node_path16 = __toESM(require("path"), 1);
+var UNZOOM_MIN_SIDE = 256;
+var UNZOOM_MAX_AREA = 2048 * 2048;
+function defaultUnzoomOut(input) {
+  const ext = import_node_path16.default.extname(input);
+  return `${ext ? input.slice(0, -ext.length) : input}.unzoomed.png`;
+}
+async function unzoomFile(client2, input, opts = {}) {
+  const out = import_node_path16.default.resolve(opts.out ?? defaultUnzoomOut(input));
+  if (import_node_path16.default.resolve(input) === out) throw new Error("unzoom will not overwrite its own input; pass a different --out");
+  if ((0, import_node_fs12.existsSync)(out) && !opts.force) throw new Error(`${out} already exists; pass --force to replace it`);
+  const bytes = await (0, import_promises9.readFile)(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 (0, import_promises9.mkdir)(import_node_path16.default.dirname(out), { recursive: true });
+  await (0, import_promises9.writeFile)(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 = import_node_path16.default.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 ((0, import_node_fs12.existsSync)(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 (0, import_promises9.mkdir)(import_node_path16.default.dirname(ttf), { recursive: true });
+      await (0, import_promises9.writeFile)(ttf, ttfBytes);
+      await (0, import_promises9.writeFile)(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
+var import_node_path17 = __toESM(require("path"), 1);
+var import_node_fs13 = require("fs");
+var import_promises10 = require("fs/promises");
 var import_zod4 = require("zod");
 var SHA256_RE2 = /^[0-9a-f]{64}$/;
 var HEX_RE = /^#[0-9a-f]{6}$/;
 var MAX_REDMEAN_DISTANCE = 765;
 var QualityPathSchema = import_zod4.z.string().min(1).refine(
-  (value) => !import_node_path16.default.posix.isAbsolute(value) && !value.includes("\\"),
+  (value) => !import_node_path17.default.posix.isAbsolute(value) && !value.includes("\\"),
   "expected a portable relative path"
 );
 var DEFAULT_QUALITY_TOLERANCES = {
@@ -10638,10 +11281,10 @@ function measureDecodedImageQuality(png, digest2) {
   };
 }
 async function measureImageQuality(file) {
-  const absolute = import_node_path16.default.resolve(file);
+  const absolute = import_node_path17.default.resolve(file);
   let bytes;
   try {
-    bytes = await (0, import_promises9.readFile)(absolute);
+    bytes = await (0, import_promises10.readFile)(absolute);
   } catch (error) {
     throw new Error(`Cannot read quality image ${absolute}: ${message4(error)}`, { cause: error });
   }
@@ -10660,11 +11303,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 = import_node_path16.default.dirname(import_node_path16.default.resolve(inputsFilePath));
+  const root = import_node_path17.default.dirname(import_node_path17.default.resolve(inputsFilePath));
   return parsed.data.map((entry) => ({
     id: entry.id,
-    file: import_node_path16.default.resolve(root, entry.path),
-    ...entry.record ? { record: import_node_path16.default.resolve(root, entry.record) } : {},
+    file: import_node_path17.default.resolve(root, entry.path),
+    ...entry.record ? { record: import_node_path17.default.resolve(root, entry.record) } : {},
     tolerances: QualityToleranceSchema.parse({
       ...DEFAULT_QUALITY_TOLERANCES,
       ...entry.tolerances
@@ -10672,7 +11315,7 @@ function resolveQualityInputs(raw, inputsFilePath) {
   }));
 }
 function portableRelative2(from, to) {
-  return import_node_path16.default.relative(from, import_node_path16.default.resolve(to)).split(import_node_path16.default.sep).join("/") || ".";
+  return import_node_path17.default.relative(from, import_node_path17.default.resolve(to)).split(import_node_path17.default.sep).join("/") || ".";
 }
 async function verifyRecordForImage(recordPath, imagePath) {
   const verification = await verifyArtifactBundle(recordPath);
@@ -10687,20 +11330,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) => import_node_path16.default.resolve(import_node_path16.default.dirname(recordPath), output.path));
-  if (!outputs.includes(import_node_path16.default.resolve(imagePath))) {
+  const outputs = record.outputs.map((output) => import_node_path17.default.resolve(import_node_path17.default.dirname(recordPath), output.path));
+  if (!outputs.includes(import_node_path17.default.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 = import_node_path16.default.resolve(baselinePath);
+  const absolute = import_node_path17.default.resolve(baselinePath);
   for (const input of inputs) {
-    if (import_node_path16.default.resolve(input.file) === absolute || input.record && import_node_path16.default.resolve(input.record) === absolute) {
+    if (import_node_path17.default.resolve(input.file) === absolute || input.record && import_node_path17.default.resolve(input.record) === absolute) {
       throw new Error(`Quality baseline output would overwrite an input: ${absolute}.`);
     }
   }
-  const root = import_node_path16.default.dirname(absolute);
+  const root = import_node_path17.default.dirname(absolute);
   const cases = [];
   for (const input of [...inputs].sort((a, b) => a.id.localeCompare(b.id))) {
     const expected = await measureImageQuality(input.file);
@@ -10727,8 +11370,8 @@ async function snapshotQualityBaseline(inputs, baselinePath, options = {}) {
     cases
   });
   const data = Buffer.from(JSON.stringify(baseline, null, 2) + "\n");
-  if ((0, import_node_fs12.existsSync)(absolute) && !options.force) {
-    const current = await (0, import_promises9.readFile)(absolute);
+  if ((0, import_node_fs13.existsSync)(absolute) && !options.force) {
+    const current = await (0, import_promises10.readFile)(absolute);
     if (!current.equals(data)) {
       throw new OverwriteRefusedError(
         `Quality baseline already exists with different content: ${absolute}. Pass --force to replace it.`,
@@ -10740,10 +11383,10 @@ async function snapshotQualityBaseline(inputs, baselinePath, options = {}) {
   return { baseline, path: absolute, changed: result.changed.length > 0 };
 }
 async function readQualityBaseline(baselinePath) {
-  const absolute = import_node_path16.default.resolve(baselinePath);
+  const absolute = import_node_path17.default.resolve(baselinePath);
   let raw;
   try {
-    raw = JSON.parse(await (0, import_promises9.readFile)(absolute, "utf8"));
+    raw = JSON.parse(await (0, import_promises10.readFile)(absolute, "utf8"));
   } catch (error) {
     throw new Error(`Could not read quality baseline ${absolute}: ${message4(error)}`, { cause: error });
   }
@@ -10813,12 +11456,12 @@ function regressionViolations(expected, actual, tolerances) {
   return { violations, warnings };
 }
 async function checkQualityBaseline(baselinePath) {
-  const absolute = import_node_path16.default.resolve(baselinePath);
+  const absolute = import_node_path17.default.resolve(baselinePath);
   const baseline = await readQualityBaseline(absolute);
-  const root = import_node_path16.default.dirname(absolute);
+  const root = import_node_path17.default.dirname(absolute);
   const cases = [];
   for (const entry of baseline.cases) {
-    const file = import_node_path16.default.resolve(root, entry.file);
+    const file = import_node_path17.default.resolve(root, entry.file);
     let actual = null;
     const violations = [];
     const warnings = [];
@@ -10831,7 +11474,7 @@ async function checkQualityBaseline(baselinePath) {
       violations.push(message4(error));
     }
     if (entry.record) {
-      const recordPath = import_node_path16.default.resolve(root, entry.record.path);
+      const recordPath = import_node_path17.default.resolve(root, entry.record.path);
       try {
         const recordHash = await sha256File(recordPath);
         if (recordHash !== entry.record.sha256) violations.push("quality record hash changed");
@@ -10867,14 +11510,14 @@ async function checkQualityBaseline(baselinePath) {
 }
 
 // src/pipeline/cache-health.ts
-var import_node_fs16 = require("fs");
-var import_promises12 = require("fs/promises");
-var import_node_path20 = __toESM(require("path"), 1);
+var import_node_fs17 = require("fs");
+var import_promises13 = require("fs/promises");
+var import_node_path21 = __toESM(require("path"), 1);
 
 // src/cache.ts
-var import_promises10 = require("fs/promises");
-var import_node_fs13 = require("fs");
-var import_node_path17 = __toESM(require("path"), 1);
+var import_promises11 = require("fs/promises");
+var import_node_fs14 = require("fs");
+var import_node_path18 = __toESM(require("path"), 1);
 var import_zod5 = require("zod");
 var HashCacheSchema = import_zod5.z.object({
   version: import_zod5.z.literal(1),
@@ -10888,10 +11531,10 @@ function isSha256Hash(value) {
 function parseCache(value) {
   return HashCacheSchema.parse(value);
 }
-async function loadCache(path33) {
-  if (!(0, import_node_fs13.existsSync)(path33)) return { version: 1, hashes: {} };
+async function loadCache(path34) {
+  if (!(0, import_node_fs14.existsSync)(path34)) return { version: 1, hashes: {} };
   try {
-    const parsed = HashCacheSchema.safeParse(JSON.parse(await (0, import_promises10.readFile)(path33, "utf8")));
+    const parsed = HashCacheSchema.safeParse(JSON.parse(await (0, import_promises11.readFile)(path34, "utf8")));
     if (!parsed.success) return { version: 1, hashes: {} };
     return {
       version: 1,
@@ -10903,20 +11546,20 @@ 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 (0, import_promises10.mkdir)(import_node_path17.default.dirname(import_node_path17.default.resolve(path33)), { recursive: true });
-  const tmp = `${path33}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  await (0, import_promises11.mkdir)(import_node_path18.default.dirname(import_node_path18.default.resolve(path34)), { recursive: true });
+  const tmp = `${path34}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    await (0, import_promises10.writeFile)(tmp, JSON.stringify({ version: 1, hashes: sorted }, null, 2) + "\n");
-    await (0, import_promises10.rename)(tmp, path33);
+    await (0, import_promises11.writeFile)(tmp, JSON.stringify({ version: 1, hashes: sorted }, null, 2) + "\n");
+    await (0, import_promises11.rename)(tmp, path34);
   } finally {
-    await (0, import_promises10.rm)(tmp, { force: true });
+    await (0, import_promises11.rm)(tmp, { force: true });
   }
 }
 function pruneCache(cache, liveIds, namespace = "") {
@@ -10938,20 +11581,20 @@ function cachePathFor(lockPath) {
 }
 
 // src/pipeline/history.ts
-var import_node_fs15 = require("fs");
-var import_node_path19 = __toESM(require("path"), 1);
+var import_node_fs16 = require("fs");
+var import_node_path20 = __toESM(require("path"), 1);
 
 // src/pipeline/fetch.ts
-var import_node_fs14 = require("fs");
-var import_promises11 = require("fs/promises");
-var import_node_path18 = __toESM(require("path"), 1);
+var import_node_fs15 = require("fs");
+var import_promises12 = require("fs/promises");
+var import_node_path19 = __toESM(require("path"), 1);
 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 : import_node_path18.default.resolve(opts.cacheDir ?? import_node_path18.default.join(import_node_path18.default.dirname(lockPath), ".pixelkiln", "cache"));
+  const cacheDir = opts.cacheDir === false ? null : import_node_path19.default.resolve(opts.cacheDir ?? import_node_path19.default.join(import_node_path19.default.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;
@@ -10962,15 +11605,15 @@ 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 (0, import_node_fs14.existsSync)(file) && sha256((0, import_node_fs14.readFileSync)(file)) === output.sha256;
+        return (0, import_node_fs15.existsSync)(file) && sha256((0, import_node_fs15.readFileSync)(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 (!(0, import_node_fs14.existsSync)(file)) return true;
-      const current = sha256((0, import_node_fs14.readFileSync)(file));
+      if (!(0, import_node_fs15.existsSync)(file)) return true;
+      const current = sha256((0, import_node_fs15.readFileSync)(file));
       if (current === output.sha256) return false;
       return Boolean(opts.force) || (e.supersededOutputs ?? []).some((old) => old.sha256 === current);
     });
@@ -11053,21 +11696,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 ${import_node_path18.default.relative(process.cwd(), target)}`);
+              log(`  current ${import_node_path19.default.relative(process.cwd(), target)}`);
               outputs.push({ ...recorded, path: portableOutputPath(target, spec.root) });
               continue;
             }
           }
           let raw = null;
           let final = null;
-          if ((0, import_node_fs14.existsSync)(target)) {
+          if ((0, import_node_fs15.existsSync)(target)) {
             const currentHash = await sha256File(target);
             if (recorded && currentHash === recorded.sha256) {
               if (!fresh && !reapply) {
                 if (cacheDir) {
                   await cacheMedia(
                     cacheDir,
-                    await (0, import_promises11.readFile)(target),
+                    await (0, import_promises12.readFile)(target),
                     recorded.mediaType ?? MediaType.PNG,
                     recorded.sha256
                   );
@@ -11076,10 +11719,10 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
                 continue;
               }
               if (reapply && !fresh) {
-                if (!recorded.raw) raw = await (0, import_promises11.readFile)(target);
-                log(`  reapply ${import_node_path18.default.relative(process.cwd(), target)}`);
+                if (!recorded.raw) raw = await (0, import_promises12.readFile)(target);
+                log(`  reapply ${import_node_path19.default.relative(process.cwd(), target)}`);
               } else {
-                log(`  changed ${import_node_path18.default.relative(process.cwd(), target)} (upstream)`);
+                log(`  changed ${import_node_path19.default.relative(process.cwd(), target)} (upstream)`);
               }
             } else {
               const superseded = (entry.supersededOutputs ?? []).find(
@@ -11100,14 +11743,14 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
               }
               if (outgoing && cacheDir) {
                 try {
-                  const oldBytes = await (0, import_promises11.readFile)(target);
+                  const oldBytes = await (0, import_promises12.readFile)(target);
                   const oldMediaType = detectMediaType(oldBytes);
                   if (oldMediaType) await cacheMedia(cacheDir, oldBytes, oldMediaType, currentHash);
                 } catch {
                 }
               }
               log(
-                `  replace ${import_node_path18.default.relative(process.cwd(), target)}` + (opts.force ? " (--force)" : " (previous tracked generation)")
+                `  replace ${import_node_path19.default.relative(process.cwd(), target)}` + (opts.force ? " (--force)" : " (previous tracked generation)")
               );
             }
           }
@@ -11116,7 +11759,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  ${import_node_path18.default.relative(process.cwd(), target)}`);
+            if (final || raw) log(`  cached  ${import_node_path19.default.relative(process.cwd(), target)}`);
           }
           if (!final && !raw) {
             if (!source.url) {
@@ -11143,13 +11786,13 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
             buf = processed.bytes;
             if (processed.changed) {
               rawHash = sha256(raw);
-              log(`  snapped ${import_node_path18.default.relative(process.cwd(), target)} to ${wanted.palette.colors.length} colours`);
+              log(`  snapped ${import_node_path19.default.relative(process.cwd(), target)} to ${wanted.palette.colors.length} colours`);
             }
           }
           if (cacheDir) await cacheMedia(cacheDir, buf, mediaType);
-          await (0, import_promises11.mkdir)(import_node_path18.default.dirname(target), { recursive: true });
+          await (0, import_promises12.mkdir)(import_node_path19.default.dirname(target), { recursive: true });
           const tmp = `${target}.pixelkiln.tmp`;
-          await (0, import_promises11.writeFile)(tmp, buf);
+          await (0, import_promises12.writeFile)(tmp, buf);
           outputs.push({
             path: portableOutputPath(target, spec.root),
             sha256: sha256(buf),
@@ -11159,9 +11802,9 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
           });
           upsert(lock, key, { outputs: mergeOutputs(entry.outputs, outputs) });
           await saveLock(lockPath, lock);
-          await (0, import_promises11.rename)(tmp, target);
+          await (0, import_promises12.rename)(tmp, target);
           wrote = true;
-          log(`  wrote   ${import_node_path18.default.relative(process.cwd(), target)}`);
+          log(`  wrote   ${import_node_path19.default.relative(process.cwd(), target)}`);
         }
         if (opts.refresh && !wrote) {
           if (rotated) {
@@ -11205,10 +11848,10 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
   return result;
 }
 async function readCachedMedia(cacheDir, hash, mediaType) {
-  const file = import_node_path18.default.join(cacheDir, cacheFileName(hash, mediaType));
-  if (!(0, import_node_fs14.existsSync)(file)) return null;
+  const file = import_node_path19.default.join(cacheDir, cacheFileName(hash, mediaType));
+  if (!(0, import_node_fs15.existsSync)(file)) return null;
   try {
-    const buf = await (0, import_promises11.readFile)(file);
+    const buf = await (0, import_promises12.readFile)(file);
     if (sha256(buf) !== hash) return null;
     validateMedia(buf, mediaType);
     return buf;
@@ -11219,17 +11862,17 @@ async function readCachedMedia(cacheDir, hash, mediaType) {
 async function cacheMedia(cacheDir, buf, mediaType, knownHash) {
   const hash = knownHash ?? sha256(buf);
   validateMedia(buf, mediaType);
-  const file = import_node_path18.default.join(cacheDir, cacheFileName(hash, mediaType));
+  const file = import_node_path19.default.join(cacheDir, cacheFileName(hash, mediaType));
   if (await readCachedMedia(cacheDir, hash, mediaType)) return;
-  await (0, import_promises11.mkdir)(cacheDir, { recursive: true });
+  await (0, import_promises12.mkdir)(cacheDir, { recursive: true });
   const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
-  await (0, import_promises11.writeFile)(tmp, buf);
+  await (0, import_promises12.writeFile)(tmp, buf);
   try {
-    await (0, import_promises11.rename)(tmp, file);
+    await (0, import_promises12.rename)(tmp, file);
   } catch (err) {
-    if (!(0, import_node_fs14.existsSync)(file)) throw err;
+    if (!(0, import_node_fs15.existsSync)(file)) throw err;
   } finally {
-    await (0, import_promises11.rm)(tmp, { force: true });
+    await (0, import_promises12.rm)(tmp, { force: true });
   }
 }
 function mergeOutputs(previous, current) {
@@ -11346,10 +11989,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 (!(0, import_node_fs15.existsSync)(file)) continue;
+    if (!(0, import_node_fs16.existsSync)(file)) continue;
     if (await sha256File(file) !== entry.outputs[i].sha256 && !opts.force) {
       throw new OverwriteRefusedError(
-        `${import_node_path19.default.relative(process.cwd(), file)} was changed after download; keep it with pixelkiln edit, or pass --force to replace it`,
+        `${import_node_path20.default.relative(process.cwd(), file)} was changed after download; keep it with pixelkiln edit, or pass --force to replace it`,
         [file]
       );
     }
@@ -11401,11 +12044,11 @@ async function revertGeneration(provider, spec, lock, lockPath, opts) {
 
 // src/pipeline/cache-health.ts
 async function inspectCaches(lock, lockPath, options = {}) {
-  if (options.prune && !(0, import_node_fs16.existsSync)(lockPath)) {
-    throw new Error(`Refusing to prune without an existing lockfile at ${import_node_path20.default.resolve(lockPath)}`);
+  if (options.prune && !(0, import_node_fs17.existsSync)(lockPath)) {
+    throw new Error(`Refusing to prune without an existing lockfile at ${import_node_path21.default.resolve(lockPath)}`);
   }
-  const contentDir = import_node_path20.default.resolve(import_node_path20.default.dirname(lockPath), ".pixelkiln", "cache");
-  const remotePath = import_node_path20.default.resolve(cachePathFor(lockPath));
+  const contentDir = import_node_path21.default.resolve(import_node_path21.default.dirname(lockPath), ".pixelkiln", "cache");
+  const remotePath = import_node_path21.default.resolve(cachePathFor(lockPath));
   const referenced = referencedHashes(lock);
   let content = await inspectContentCache(contentDir, referenced);
   let remoteHashes = await inspectRemoteHashCache(remotePath);
@@ -11417,7 +12060,7 @@ async function inspectCaches(lock, lockPath, options = {}) {
     ]);
     for (const name of names) {
       try {
-        await (0, import_promises12.rm)(import_node_path20.default.join(contentDir, name), { force: true });
+        await (0, import_promises13.rm)(import_node_path21.default.join(contentDir, name), { force: true });
         removed.contentFiles++;
       } catch {
       }
@@ -11426,7 +12069,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 (0, import_promises12.readFile)(remotePath, "utf8")));
+      const cache = parseCache(JSON.parse(await (0, import_promises13.readFile)(remotePath, "utf8")));
       for (const id of remoteHashes.invalidIds) delete cache.hashes[id];
       removed.remoteHashEntries = remoteHashes.invalidIds.length;
       await saveCache(remotePath, cache);
@@ -11444,7 +12087,7 @@ async function inspectCaches(lock, lockPath, options = {}) {
 async function inspectContentCache(contentDir, referenced) {
   const report = {
     path: contentDir,
-    exists: (0, import_node_fs16.existsSync)(contentDir),
+    exists: (0, import_node_fs17.existsSync)(contentDir),
     files: 0,
     bytes: 0,
     valid: 0,
@@ -11458,19 +12101,19 @@ async function inspectContentCache(contentDir, referenced) {
     return report;
   }
   const present = /* @__PURE__ */ new Set();
-  const entries = await (0, import_promises12.readdir)(contentDir, { withFileTypes: true });
+  const entries = await (0, import_promises13.readdir)(contentDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isFile()) {
       report.invalid.push({ name: entry.name, reason: "not a regular file" });
       continue;
     }
     report.files++;
-    const file = import_node_path20.default.join(contentDir, entry.name);
+    const file = import_node_path21.default.join(contentDir, entry.name);
     const mediaType = mediaTypeFromExtension(entry.name);
     const expected = mediaType ? entry.name.slice(0, -4) : "";
     let bytes;
     try {
-      bytes = await (0, import_promises12.readFile)(file);
+      bytes = await (0, import_promises13.readFile)(file);
       report.bytes += bytes.length;
     } catch (err) {
       report.invalid.push({
@@ -11508,7 +12151,7 @@ async function inspectContentCache(contentDir, referenced) {
 async function inspectRemoteHashCache(remotePath) {
   const report = {
     path: remotePath,
-    exists: (0, import_node_fs16.existsSync)(remotePath),
+    exists: (0, import_node_fs17.existsSync)(remotePath),
     entries: 0,
     valid: 0,
     invalidIds: [],
@@ -11517,7 +12160,7 @@ async function inspectRemoteHashCache(remotePath) {
   if (!report.exists) return report;
   let cache;
   try {
-    cache = parseCache(JSON.parse(await (0, import_promises12.readFile)(remotePath, "utf8")));
+    cache = parseCache(JSON.parse(await (0, import_promises13.readFile)(remotePath, "utf8")));
   } catch (err) {
     report.error = err instanceof Error ? err.message : String(err);
     return report;
@@ -11532,20 +12175,20 @@ async function inspectRemoteHashCache(remotePath) {
 }
 
 // src/pipeline/pack.ts
-var import_node_fs17 = require("fs");
-var import_node_path21 = __toESM(require("path"), 1);
+var import_node_fs18 = require("fs");
+var import_node_path22 = __toESM(require("path"), 1);
 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 = import_node_path21.default.dirname(import_node_path21.default.resolve(inputsFilePath));
+  const baseDir = import_node_path22.default.dirname(import_node_path22.default.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: import_node_path21.default.resolve(baseDir, e.path) };
+    return { id: e.id, path: import_node_path22.default.resolve(baseDir, e.path) };
   });
 }
 function packSprites(inputs, options = {}) {
@@ -11566,7 +12209,7 @@ function packSprites(inputs, options = {}) {
   for (const input of ordered) {
     let sourceHash = null;
     try {
-      const bytes = (0, import_node_fs17.readFileSync)(input.path);
+      const bytes = (0, import_node_fs18.readFileSync)(input.path);
       sourceHash = sha256(bytes);
       const png = decodePng(bytes);
       sprites.push({ id: input.id, width: png.width, height: png.height, pixels: png.pixels });
@@ -11629,7 +12272,7 @@ function packStyle(lock, styleId, manifestDir, options = {}) {
     }
     const inputs2 = Object.entries(options.sourceOverrides).map(([id, source]) => ({
       id,
-      path: import_node_path21.default.resolve(source)
+      path: import_node_path22.default.resolve(source)
     }));
     if (!inputs2.length) throw new Error(`No approved quality outputs for style "${styleId}".`);
     const packed2 = packSprites(inputs2, options);
@@ -11653,7 +12296,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: import_node_path21.default.resolve(manifestDir, source) });
+      inputs.push({ id, path: import_node_path22.default.resolve(manifestDir, source) });
       continue;
     }
     if (source && sourceIsStem(source, entry, manifestDir)) {
@@ -11687,7 +12330,7 @@ function packStyle(lock, styleId, manifestDir, options = {}) {
     }
   }
   for (const [id, source] of Object.entries(sources)) {
-    if (!locked.has(id)) inputs.push({ id, path: import_node_path21.default.resolve(manifestDir, source) });
+    if (!locked.has(id)) inputs.push({ id, path: import_node_path22.default.resolve(manifestDir, source) });
   }
   if (!inputs.length) {
     throw new Error(`No readable sprites for style "${styleId}"; ${noOutput.length} skipped.`);
@@ -11724,7 +12367,7 @@ function mountSprites(placements, options) {
   for (const p of placements) {
     let sourceHash = null;
     try {
-      const bytes = (0, import_node_fs17.readFileSync)(p.path);
+      const bytes = (0, import_node_fs18.readFileSync)(p.path);
       sourceHash = sha256(bytes);
       const png = decodePng(bytes);
       if (png.width > cellWidth || png.height > cellHeight) {
@@ -11795,7 +12438,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: import_node_path21.default.resolve(manifestDir, source), cell });
+      placements.push({ id, path: import_node_path22.default.resolve(manifestDir, source), cell });
       continue;
     }
     if (source && entry) {
@@ -11828,7 +12471,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 ? (0, import_node_fs17.readFileSync)(import_node_path21.default.resolve(manifestDir, mount.base)) : void 0;
+  const basePng = mount.base ? (0, import_node_fs18.readFileSync)(import_node_path22.default.resolve(manifestDir, mount.base)) : void 0;
   const mounted = mountSprites(placements, {
     cellWidth: mount.cellWidth,
     cellHeight: mount.cellHeight,
@@ -11838,7 +12481,7 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
     ...mounted,
     sources: mount.base ? [{
       id: "$base",
-      path: import_node_path21.default.resolve(manifestDir, mount.base),
+      path: import_node_path22.default.resolve(manifestDir, mount.base),
       sha256: sha256(basePng),
       included: true
     }, ...mounted.sources] : mounted.sources,
@@ -12616,9 +13259,9 @@ async function poll(provider, lock, lockPath, opts = {}) {
 }
 
 // src/pipeline/doctor.ts
-var import_node_fs18 = require("fs");
-var import_promises13 = require("fs/promises");
-var import_node_path22 = __toESM(require("path"), 1);
+var import_node_fs19 = require("fs");
+var import_promises14 = require("fs/promises");
+var import_node_path23 = __toESM(require("path"), 1);
 async function doctor(loaded, specs, lock, lockPath, opts = {}) {
   const checks = [];
   const add = (id, level, message6) => checks.push({ id, level, message: message6 });
@@ -12629,14 +13272,14 @@ 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) => [
-    import_node_path22.default.dirname(spec.outFile),
-    ...spec.quality ? [import_node_path22.default.dirname(spec.quality.outFile)] : []
+    import_node_path23.default.dirname(spec.outFile),
+    ...spec.quality ? [import_node_path23.default.dirname(spec.quality.outFile)] : []
   ]))];
   const unwritable = [];
   for (const dir of dirs) {
     const ancestor = await nearestExistingDirectory(dir);
     try {
-      await (0, import_promises13.access)(ancestor, import_node_fs18.constants.W_OK);
+      await (0, import_promises14.access)(ancestor, import_node_fs19.constants.W_OK);
     } catch {
       unwritable.push(dir);
     }
@@ -12653,7 +13296,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, import_node_path22.default.dirname(lockPath));
+      const absolute = spec ? currentEntryOutputPath(entry, spec, index) : resolveOutputPath(output.path, import_node_path23.default.dirname(lockPath));
       const owner = outputOwners.get(absolute);
       if (owner && owner !== key) duplicateOutputs.push(`${output.path} (${owner}, ${key})`);
       outputOwners.set(absolute, key);
@@ -12668,7 +13311,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 = import_node_path22.default.join(import_node_path22.default.dirname(lockPath), ".pixelkiln", "cache");
+  const cacheDir = import_node_path23.default.join(import_node_path23.default.dirname(lockPath), ".pixelkiln", "cache");
   const stranded = [];
   const invalidState = [];
   const staleMapUrls = [];
@@ -12684,11 +13327,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 = import_node_path22.default.join(
+      const cached = import_node_path23.default.join(
         cacheDir,
         cacheFileName(output.sha256, output.mediaType ?? MediaType.PNG)
       );
-      if ((0, import_node_fs18.existsSync)(cached) && await sha256File(cached) === output.sha256) {
+      if ((0, import_node_fs19.existsSync)(cached) && await sha256File(cached) === output.sha256) {
         hasCache = true;
         break;
       }
@@ -12781,19 +13424,19 @@ async function nearestExistingDirectory(start) {
   let current = start;
   for (; ; ) {
     try {
-      if ((await (0, import_promises13.stat)(current)).isDirectory()) return current;
+      if ((await (0, import_promises14.stat)(current)).isDirectory()) return current;
     } catch {
     }
-    const parent = import_node_path22.default.dirname(current);
+    const parent = import_node_path23.default.dirname(current);
     if (parent === current) return current;
     current = parent;
   }
 }
 
 // src/pipeline/adopt.ts
-var import_node_fs19 = require("fs");
-var import_promises14 = require("fs/promises");
-var import_node_path23 = __toESM(require("path"), 1);
+var import_node_fs20 = require("fs");
+var import_promises15 = require("fs/promises");
+var import_node_path24 = __toESM(require("path"), 1);
 async function adopt(provider, specs, lock, lockPath, opts = {}) {
   const log = opts.onProgress ?? (() => {
   });
@@ -12804,11 +13447,11 @@ async function adopt(provider, specs, lock, lockPath, opts = {}) {
   const localByHash = /* @__PURE__ */ new Map();
   const unmatchedLocal = [];
   for (const spec of specs) {
-    if (!(0, import_node_fs19.existsSync)(spec.outFile)) {
+    if (!(0, import_node_fs20.existsSync)(spec.outFile)) {
       unmatchedLocal.push(`${spec.styleId}/${spec.assetId} (no file at ${spec.outFile})`);
       continue;
     }
-    const bytes = await (0, import_promises14.readFile)(spec.outFile);
+    const bytes = await (0, import_promises15.readFile)(spec.outFile);
     try {
       decodePng(bytes);
     } catch (err) {
@@ -12926,13 +13569,13 @@ async function tagAdopted(provider, specs, lock, opts = {}) {
 }
 
 // src/pick/server.ts
-var import_node_fs21 = require("fs");
-var import_promises17 = require("fs/promises");
+var import_node_fs22 = require("fs");
+var import_promises18 = require("fs/promises");
 
 // src/pipeline/init.ts
-var import_promises15 = require("fs/promises");
-var import_node_fs20 = require("fs");
-var import_node_path24 = __toESM(require("path"), 1);
+var import_promises16 = require("fs/promises");
+var import_node_fs21 = require("fs");
+var import_node_path25 = __toESM(require("path"), 1);
 function pngSize(buf) {
   if (buf.length < 24) return null;
   const isPng = buf.readUInt32BE(0) === 2303741511 && buf.readUInt32BE(4) === 218765834;
@@ -12945,8 +13588,8 @@ function slugify(value) {
 }
 async function walk(dir, exclude) {
   const out = [];
-  for (const entry of await (0, import_promises15.readdir)(dir, { withFileTypes: true })) {
-    const full = import_node_path24.default.join(dir, entry.name);
+  for (const entry of await (0, import_promises16.readdir)(dir, { withFileTypes: true })) {
+    const full = import_node_path25.default.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);
@@ -12960,14 +13603,14 @@ async function scanAssets(root, opts = {}) {
   const skipped = [];
   const seen = /* @__PURE__ */ new Map();
   for (const file of files.sort()) {
-    const size = pngSize(await (0, import_promises15.readFile)(file));
+    const size = pngSize(await (0, import_promises16.readFile)(file));
     if (!size) {
       skipped.push(`${file} (not a readable PNG)`);
       continue;
     }
-    const rel = import_node_path24.default.relative(root, file);
-    const category = import_node_path24.default.dirname(rel) === "." ? "" : import_node_path24.default.dirname(rel);
-    let id = slugify(import_node_path24.default.basename(rel));
+    const rel = import_node_path25.default.relative(root, file);
+    const category = import_node_path25.default.dirname(rel) === "." ? "" : import_node_path25.default.dirname(rel);
+    let id = slugify(import_node_path25.default.basename(rel));
     if (seen.has(id)) {
       const n = seen.get(id) + 1;
       seen.set(id, n);
@@ -13431,7 +14074,7 @@ document.getElementById('submit').onclick = async () => {
 
 // src/pick/review-server.ts
 var import_node_http = require("http");
-var import_promises16 = require("fs/promises");
+var import_promises17 = require("fs/promises");
 function serveReviewPage(opts) {
   const log = opts.onProgress ?? (() => {
   });
@@ -13440,7 +14083,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 (0, import_promises16.readFile)(asset.path);
+          const bytes = await (0, import_promises17.readFile)(asset.path);
           res.writeHead(200, {
             "Content-Type": asset.contentType,
             "Cache-Control": "no-store",
@@ -13516,13 +14159,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 (!(0, import_node_fs21.existsSync)(file)) return null;
+  if (!(0, import_node_fs22.existsSync)(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 (0, import_promises17.readFile)(file));
+    const size = pngSize(await (0, import_promises18.readFile)(file));
     if (size) ({ width, height } = size);
   }
   return { path: file, contentType, width, height };
@@ -13691,14 +14334,14 @@ async function runPicker(provider, lock, lockPath, opts = {}) {
 
 // src/gallery/snapshot.ts
 var import_node_crypto6 = require("crypto");
-var import_node_fs24 = require("fs");
-var import_promises21 = require("fs/promises");
-var import_node_path29 = __toESM(require("path"), 1);
+var import_node_fs25 = require("fs");
+var import_promises22 = require("fs/promises");
+var import_node_path30 = __toESM(require("path"), 1);
 
 // src/workspace.ts
-var import_promises18 = require("fs/promises");
-var import_node_fs22 = require("fs");
-var import_node_path25 = __toESM(require("path"), 1);
+var import_promises19 = require("fs/promises");
+var import_node_fs23 = require("fs");
+var import_node_path26 = __toESM(require("path"), 1);
 var import_zod6 = require("zod");
 var WorkspaceProjectSchema = import_zod6.z.object({
   id: import_zod6.z.string().min(1),
@@ -13723,10 +14366,10 @@ ${parsed.error.issues.slice(0, 5).map((i) => `  ${i.path.join(".")}: ${i.message
   );
 }
 async function loadWorkspace(workspacePath) {
-  if (!(0, import_node_fs22.existsSync)(workspacePath)) return { version: 1, projects: [] };
+  if (!(0, import_node_fs23.existsSync)(workspacePath)) return { version: 1, projects: [] };
   let raw;
   try {
-    raw = JSON.parse(await (0, import_promises18.readFile)(workspacePath, "utf8"));
+    raw = JSON.parse(await (0, import_promises19.readFile)(workspacePath, "utf8"));
   } catch (err) {
     throw new ProjectError(
       `Workspace catalog at ${workspacePath} is malformed:
@@ -13740,22 +14383,22 @@ async function saveWorkspace(workspacePath, ws) {
     version: 1,
     projects: [...ws.projects].sort((a, b) => a.id.localeCompare(b.id))
   };
-  await (0, import_promises18.mkdir)(import_node_path25.default.dirname(import_node_path25.default.resolve(workspacePath)), { recursive: true });
+  await (0, import_promises19.mkdir)(import_node_path26.default.dirname(import_node_path26.default.resolve(workspacePath)), { recursive: true });
   const tmp = `${workspacePath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    await (0, import_promises18.writeFile)(tmp, JSON.stringify(sorted, null, 2) + "\n");
-    await (0, import_promises18.rename)(tmp, workspacePath);
+    await (0, import_promises19.writeFile)(tmp, JSON.stringify(sorted, null, 2) + "\n");
+    await (0, import_promises19.rename)(tmp, workspacePath);
   } finally {
-    await (0, import_promises18.rm)(tmp, { force: true });
+    await (0, import_promises19.rm)(tmp, { force: true });
   }
 }
 function toPortablePath(dir, absolute) {
-  return import_node_path25.default.relative(dir, absolute).split(import_node_path25.default.sep).join("/");
+  return import_node_path26.default.relative(dir, absolute).split(import_node_path26.default.sep).join("/");
 }
 function resolveProject(dir, project) {
   return {
-    manifestPath: import_node_path25.default.resolve(dir, project.manifest.split("/").join(import_node_path25.default.sep)),
-    lockPath: import_node_path25.default.resolve(dir, project.lock.split("/").join(import_node_path25.default.sep))
+    manifestPath: import_node_path26.default.resolve(dir, project.manifest.split("/").join(import_node_path26.default.sep)),
+    lockPath: import_node_path26.default.resolve(dir, project.lock.split("/").join(import_node_path26.default.sep))
   };
 }
 function validateWorkspace(ws, dir) {
@@ -13768,21 +14411,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 (import_node_path25.default.isAbsolute(project.manifest) || import_node_path25.default.isAbsolute(project.lock)) {
+    if (import_node_path26.default.isAbsolute(project.manifest) || import_node_path26.default.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 (!(0, import_node_fs22.existsSync)(manifestPath)) {
+    if (!(0, import_node_fs23.existsSync)(manifestPath)) {
       diagnostics.push({
         id: "missing-manifest",
         level: "error",
         message: `project "${project.id}" manifest not found: ${manifestPath}`
       });
     }
-    if (!(0, import_node_fs22.existsSync)(lockPath)) {
+    if (!(0, import_node_fs23.existsSync)(lockPath)) {
       diagnostics.push({
         id: "missing-lock",
         level: "error",
@@ -13829,12 +14472,12 @@ function validateWorkspace(ws, dir) {
 }
 
 // src/gallery/edit.ts
-var import_node_path28 = __toESM(require("path"), 1);
+var import_node_path29 = __toESM(require("path"), 1);
 var import_zod9 = require("zod");
 
 // src/manifest-edit.ts
-var import_promises19 = require("fs/promises");
-var import_node_path26 = __toESM(require("path"), 1);
+var import_promises20 = require("fs/promises");
+var import_node_path27 = __toESM(require("path"), 1);
 var import_zod7 = require("zod");
 var HexSha = import_zod7.z.string().regex(/^[0-9a-f]{64}$/);
 var AssetPatchSchema = import_zod7.z.object({
@@ -13990,11 +14633,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}"`);
     }
@@ -14046,7 +14699,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;
@@ -14060,20 +14713,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) {
@@ -14097,8 +14750,8 @@ function applyEdit(raw, edit) {
   }
 }
 async function applyManifestEdit(manifestPath, edit) {
-  const absolute = import_node_path26.default.resolve(manifestPath);
-  const original = await (0, import_promises19.readFile)(absolute, "utf8");
+  const absolute = import_node_path27.default.resolve(manifestPath);
+  const original = await (0, import_promises20.readFile)(absolute, "utf8");
   const before = sha256(original);
   if (before !== edit.expectedSha256) throw new ManifestDriftError(absolute);
   let raw;
@@ -14112,12 +14765,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 = import_node_path26.default.join(
-    import_node_path26.default.dirname(absolute),
-    `.${import_node_path26.default.basename(absolute)}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`
+  const tmp = import_node_path27.default.join(
+    import_node_path27.default.dirname(absolute),
+    `.${import_node_path27.default.basename(absolute)}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`
   );
   try {
-    await (0, import_promises19.writeFile)(tmp, next);
+    await (0, import_promises20.writeFile)(tmp, next);
     try {
       const loaded = await loadManifest(tmp);
       await resolveSpecs(loaded);
@@ -14125,26 +14778,26 @@ async function applyManifestEdit(manifestPath, edit) {
       const message6 = error instanceof Error ? error.message : String(error);
       throw new ManifestEditError(message6.replace(tmp, absolute));
     }
-    await (0, import_promises19.rename)(tmp, absolute);
+    await (0, import_promises20.rename)(tmp, absolute);
   } finally {
-    await (0, import_promises19.rm)(tmp, { force: true });
+    await (0, import_promises20.rm)(tmp, { force: true });
   }
   return { manifestPath: absolute, sha256: sha256(next), changed: true };
 }
 
 // src/pipeline/hand-edit.ts
-var import_node_fs23 = require("fs");
-var import_promises20 = require("fs/promises");
-var import_node_path27 = __toESM(require("path"), 1);
+var import_node_fs24 = require("fs");
+var import_promises21 = require("fs/promises");
+var import_node_path28 = __toESM(require("path"), 1);
 var import_zod8 = require("zod");
 var HAND_EDIT_DIR = "edits";
 function handEditPath(loaded, spec) {
   const style = loaded.manifest.styles[spec.styleId];
-  const outDir = import_node_path27.default.resolve(loaded.root, style?.outDir ?? ".");
-  const relative = import_node_path27.default.relative(outDir, spec.outFile);
-  const inside = relative && !relative.startsWith("..") && !import_node_path27.default.isAbsolute(relative);
-  const file = inside ? relative : import_node_path27.default.basename(spec.outFile);
-  return import_node_path27.default.join(outDir, HAND_EDIT_DIR, file.replace(/\.gif$/i, ".png"));
+  const outDir = import_node_path28.default.resolve(loaded.root, style?.outDir ?? ".");
+  const relative = import_node_path28.default.relative(outDir, spec.outFile);
+  const inside = relative && !relative.startsWith("..") && !import_node_path28.default.isAbsolute(relative);
+  const file = inside ? relative : import_node_path28.default.basename(spec.outFile);
+  return import_node_path28.default.join(outDir, HAND_EDIT_DIR, file.replace(/\.gif$/i, ".png"));
 }
 function handEditBases(spec, lock) {
   const entry = lock.entries[lockKey(spec.styleId, spec.assetId)];
@@ -14157,10 +14810,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) => (0, import_node_fs23.existsSync)(member.path))) return null;
+    if (!members.every((member) => (0, import_node_fs24.existsSync)(member.path))) return null;
     return members.map(({ role, path: file }) => ({ role, path: file }));
   }
-  return (0, import_node_fs23.existsSync)(spec.outFile) ? [{ role: null, path: spec.outFile }] : null;
+  return (0, import_node_fs24.existsSync)(spec.outFile) ? [{ role: null, path: spec.outFile }] : null;
 }
 function handEditBase(spec, lock) {
   const bases = handEditBases(spec, lock);
@@ -14190,19 +14843,19 @@ 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 ? import_node_path27.default.resolve(loaded.root, spec.source) : null;
+  const existing = spec.source ? import_node_path28.default.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 ((0, import_node_fs23.existsSync)(member.path)) continue;
+    if ((0, import_node_fs24.existsSync)(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 (0, import_promises20.mkdir)(import_node_path27.default.dirname(member.path), { recursive: true });
-    await (0, import_promises20.copyFile)(member.base, member.path);
+    await (0, import_promises21.mkdir)(import_node_path28.default.dirname(member.path), { recursive: true });
+    await (0, import_promises21.copyFile)(member.base, member.path);
     created = true;
   }
   const source = portableOutputPath(editPath, loaded.root);
@@ -14280,7 +14933,7 @@ function handEditProjectPath(editPath) {
 async function readHandEditCompanion(editPath) {
   let text;
   try {
-    text = await (0, import_promises20.readFile)(handEditCompanionPath(editPath), "utf8");
+    text = await (0, import_promises21.readFile)(handEditCompanionPath(editPath), "utf8");
   } catch {
     return null;
   }
@@ -14323,7 +14976,7 @@ async function saveHandEdit(loaded, lock, spec, input) {
     }
   });
   const bases = handEditBases(spec, lock);
-  const expectedSize = bases?.[0] ? decodePng(await (0, import_promises20.readFile)(bases[0].path)) : { width: spec.width, height: spec.height };
+  const expectedSize = bases?.[0] ? decodePng(await (0, import_promises21.readFile)(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";
@@ -14339,7 +14992,7 @@ async function saveHandEdit(loaded, lock, spec, input) {
     editor: input.editor,
     protocol: input.protocol,
     savedAt: (input.now ?? /* @__PURE__ */ new Date()).toISOString(),
-    project: projectPath ? import_node_path27.default.basename(projectPath) : null,
+    project: projectPath ? import_node_path28.default.basename(projectPath) : null,
     outputs: incoming.map((frame, index) => ({
       role: frame.role,
       basedOn: basedOnHash(entry, index),
@@ -14369,10 +15022,10 @@ function basedOnHash(entry, index) {
 async function replaceFile(file, bytes) {
   const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    await (0, import_promises20.writeFile)(tmp, bytes);
-    await (0, import_promises20.rename)(tmp, file);
+    await (0, import_promises21.writeFile)(tmp, bytes);
+    await (0, import_promises21.rename)(tmp, file);
   } finally {
-    await (0, import_promises20.rm)(tmp, { force: true });
+    await (0, import_promises21.rm)(tmp, { force: true });
   }
 }
 function openInEditor(file, editor = process.env.PIXELKILN_EDITOR) {
@@ -14469,7 +15122,7 @@ function createGalleryEditHandler(opts) {
     }
     const result = await applyManifestEdit(manifestPath, parsed.data);
     if (result.changed) {
-      const relative = import_node_path28.default.relative(process.cwd(), result.manifestPath);
+      const relative = import_node_path29.default.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}`);
@@ -14481,7 +15134,7 @@ function createGalleryEditHandler(opts) {
 // src/gallery/snapshot.ts
 var PROJECT_FILE_TYPE = "application/octet-stream";
 function galleryMediaId(absolutePath) {
-  return (0, import_node_crypto6.createHash)("sha256").update(import_node_path29.default.resolve(absolutePath)).digest("hex").slice(0, 24);
+  return (0, import_node_crypto6.createHash)("sha256").update(import_node_path30.default.resolve(absolutePath)).digest("hex").slice(0, 24);
 }
 function galleryMediaRoute(id) {
   return `/media/${id}`;
@@ -14500,9 +15153,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 = import_node_path29.default.join(cacheDir, cacheFileName(output.sha256, mediaType));
+      const file = import_node_path30.default.join(cacheDir, cacheFileName(output.sha256, mediaType));
       let url = null;
-      if ((0, import_node_fs24.existsSync)(file)) {
+      if ((0, import_node_fs25.existsSync)(file)) {
         const id = galleryMediaId(file);
         media.set(id, { path: file, contentType: mediaType });
         url = `${galleryMediaRoute(id)}?v=${output.sha256.slice(0, 24)}`;
@@ -14534,7 +15187,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([(0, import_promises21.readFile)(a), (0, import_promises21.readFile)(b)]);
+    const [left, right] = await Promise.all([(0, import_promises22.readFile)(a), (0, import_promises22.readFile)(b)]);
     if (left.length > MAX_COMPARED_BYTES || right.length > MAX_COMPARED_BYTES) return false;
     const x = decodePng(left);
     const y = decodePng(right);
@@ -14546,6 +15199,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 {
@@ -14599,7 +15253,7 @@ function describeCharacter(spec, entry) {
 }
 async function fileInfo(absolutePath) {
   try {
-    const info = await (0, import_promises21.stat)(absolutePath);
+    const info = await (0, import_promises22.stat)(absolutePath);
     return info.isFile() ? { bytes: info.size, modifiedAt: info.mtime.toISOString() } : null;
   } catch {
     return null;
@@ -14631,10 +15285,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, import_node_path29.default.resolve(root, file)))
+    outputPaths.map((file) => describeOutput(media, root, import_node_path30.default.resolve(root, file)))
   );
-  const recordPath = import_node_path29.default.resolve(root, inspection.record);
-  const recordExists = (0, import_node_fs24.existsSync)(recordPath);
+  const recordPath = import_node_path30.default.resolve(root, inspection.record);
+  const recordExists = (0, import_node_fs25.existsSync)(recordPath);
   let options = null;
   let check = null;
   if (recordExists) {
@@ -14653,7 +15307,7 @@ async function describeQuality(media, root, inspection) {
   return {
     state: inspection.state,
     reason: inspection.reason,
-    output: portableOutputPath(import_node_path29.default.resolve(root, inspection.output), root),
+    output: portableOutputPath(import_node_path30.default.resolve(root, inspection.output), root),
     record: portableOutputPath(recordPath, root),
     recordExists,
     outputs,
@@ -14686,13 +15340,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 (0, import_promises21.readFile)(loaded.path, "utf8");
+  const manifestText = await (0, import_promises22.readFile)(loaded.path, "utf8");
   const manifestSha256 = sha256(manifestText);
-  const cacheDir = import_node_path29.default.resolve(import_node_path29.default.dirname(opts.lockPath), ".pixelkiln", "cache");
+  const cacheDir = import_node_path30.default.resolve(import_node_path30.default.dirname(opts.lockPath), ".pixelkiln", "cache");
   let rawStyles = {};
   try {
     const raw = JSON.parse(manifestText);
@@ -14716,12 +15371,12 @@ async function buildGallerySnapshot(opts) {
         )
       );
       if (spec.source) {
-        const editPath = import_node_path29.default.resolve(root, spec.source);
+        const editPath = import_node_path30.default.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: (0, import_node_fs24.existsSync)(file) ? await sha256File(file) : null };
+            return { file, sha256: (0, import_node_fs25.existsSync)(file) ? await sha256File(file) : null };
           })
         );
         edits = await Promise.all(editShas.map(({ file, sha256: editSha }) => describeOutput(media, root, file, { sha256: editSha })));
@@ -14729,7 +15384,7 @@ async function buildGallerySnapshot(opts) {
         const companion = await readHandEditCompanion(editPath);
         if (companion) {
           const projectPath = handEditProjectPath(editPath);
-          const project = companion.project && (0, import_node_fs24.existsSync)(projectPath) ? await fileInfo(projectPath) : null;
+          const project = companion.project && (0, import_node_fs25.existsSync)(projectPath) ? await fileInfo(projectPath) : null;
           let projectUrl = null;
           if (project) {
             const id = galleryMediaId(projectPath);
@@ -14765,8 +15420,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, import_node_path29.default.resolve(root, spec.source))];
-    } else if (!entry && (0, import_node_fs24.existsSync)(spec.outFile)) {
+      outputs = [await describeOutput(media, root, import_node_path30.default.resolve(root, spec.source))];
+    } else if (!entry && (0, import_node_fs25.existsSync)(spec.outFile)) {
       outputs = [await describeOutput(media, root, spec.outFile)];
     } else {
       outputs = [];
@@ -14830,7 +15485,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)
@@ -14959,7 +15614,7 @@ async function buildGallerySnapshot(opts) {
       id: loaded.manifest.name,
       name: loaded.manifest.name,
       manifest: loaded.path,
-      lock: import_node_path29.default.resolve(opts.lockPath),
+      lock: import_node_path30.default.resolve(opts.lockPath),
       root,
       provider: loaded.manifest.provider,
       account: null,
@@ -14985,7 +15640,7 @@ async function buildGallerySnapshot(opts) {
   return { snapshot, media };
 }
 async function buildWorkspaceGallerySnapshot(opts) {
-  const dir = import_node_path29.default.dirname(import_node_path29.default.resolve(opts.workspacePath));
+  const dir = import_node_path30.default.dirname(import_node_path30.default.resolve(opts.workspacePath));
   const media = /* @__PURE__ */ new Map();
   const projects = [];
   const items = [];
@@ -14996,7 +15651,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 = [];
@@ -15028,11 +15683,11 @@ async function buildWorkspaceGallerySnapshot(opts) {
         id: project.id,
         name: loaded.manifest.name,
         manifest: manifestPath,
-        lock: import_node_path29.default.resolve(lockPath),
+        lock: import_node_path30.default.resolve(lockPath),
         root: loaded.root,
         provider: loaded.manifest.provider,
         account: project.account ?? null,
-        manifestSha256: manifestSha256 ?? sha256(await (0, import_promises21.readFile)(manifestPath, "utf8")),
+        manifestSha256: manifestSha256 ?? sha256(await (0, import_promises22.readFile)(manifestPath, "utf8")),
         historyLimit: historyLimit(loaded.manifest),
         entries: Object.keys(lock.entries).length,
         items: projectItems.length,
@@ -15044,8 +15699,8 @@ async function buildWorkspaceGallerySnapshot(opts) {
         id: project.id,
         name: project.id,
         manifest: manifestPath,
-        lock: import_node_path29.default.resolve(lockPath),
-        root: import_node_path29.default.dirname(manifestPath),
+        lock: import_node_path30.default.resolve(lockPath),
+        root: import_node_path30.default.dirname(manifestPath),
         provider: project.provider,
         account: project.account ?? null,
         manifestSha256: null,
@@ -15072,7 +15727,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
       version: 1,
       generatedAt: (opts.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
       project: null,
-      workspace: { path: import_node_path29.default.resolve(opts.workspacePath), dir, projects },
+      workspace: { path: import_node_path30.default.resolve(opts.workspacePath), dir, projects },
       filter,
       totals: {
         entries: projects.reduce((sum, project) => sum + project.entries, 0),
@@ -15089,13 +15744,13 @@ async function buildWorkspaceGallerySnapshot(opts) {
 }
 
 // src/gallery/page.ts
-var import_node_fs25 = require("fs");
+var import_node_fs26 = require("fs");
 var CLIENT_DIR = new URL("./client/", importMetaUrl);
 var client;
 function clientAssets() {
   client ??= {
-    css: (0, import_node_fs25.readFileSync)(new URL("gallery.css", CLIENT_DIR), "utf8"),
-    js: (0, import_node_fs25.readFileSync)(new URL("gallery.js", CLIENT_DIR), "utf8")
+    css: (0, import_node_fs26.readFileSync)(new URL("gallery.css", CLIENT_DIR), "utf8"),
+    js: (0, import_node_fs26.readFileSync)(new URL("gallery.js", CLIENT_DIR), "utf8")
   };
   return client;
 }
@@ -15221,10 +15876,10 @@ var EDITOR_RELEASE_BASE = "https://github.com/gfargo/pixelkiln/releases/download
 
 // src/editor/install.ts
 var import_node_crypto7 = require("crypto");
-var import_node_fs26 = require("fs");
-var import_promises22 = require("fs/promises");
+var import_node_fs27 = require("fs");
+var import_promises23 = require("fs/promises");
 var import_node_os3 = __toESM(require("os"), 1);
-var import_node_path30 = __toESM(require("path"), 1);
+var import_node_path31 = __toESM(require("path"), 1);
 var EditorInstallError = class extends Error {
   constructor(message6, file) {
     super(message6);
@@ -15235,15 +15890,15 @@ var EditorInstallError = class extends Error {
 };
 function editorToolsRoot() {
   const override = process.env.PIXELKILN_TOOLS_DIR?.trim();
-  if (override) return import_node_path30.default.resolve(override);
-  if (process.platform === "darwin") return import_node_path30.default.join(import_node_os3.default.homedir(), "Library", "Caches", "pixelkiln", "tools");
+  if (override) return import_node_path31.default.resolve(override);
+  if (process.platform === "darwin") return import_node_path31.default.join(import_node_os3.default.homedir(), "Library", "Caches", "pixelkiln", "tools");
   if (process.platform === "win32") {
-    return import_node_path30.default.join(process.env.LOCALAPPDATA ?? import_node_path30.default.join(import_node_os3.default.homedir(), "AppData", "Local"), "pixelkiln", "tools");
+    return import_node_path31.default.join(process.env.LOCALAPPDATA ?? import_node_path31.default.join(import_node_os3.default.homedir(), "AppData", "Local"), "pixelkiln", "tools");
   }
-  return import_node_path30.default.join(process.env.XDG_CACHE_HOME ?? import_node_path30.default.join(import_node_os3.default.homedir(), ".cache"), "pixelkiln", "tools");
+  return import_node_path31.default.join(process.env.XDG_CACHE_HOME ?? import_node_path31.default.join(import_node_os3.default.homedir(), ".cache"), "pixelkiln", "tools");
 }
 function editorDir(pin = EDITOR_PIN, root = editorToolsRoot()) {
-  return import_node_path30.default.join(root, "pixelorama", pin.release ?? "unpublished");
+  return import_node_path31.default.join(root, "pixelorama", pin.release ?? "unpublished");
 }
 function editorBaseUrl(pin = EDITOR_PIN) {
   const override = process.env.PIXELKILN_EDITOR_URL?.trim();
@@ -15253,7 +15908,7 @@ function editorBaseUrl(pin = EDITOR_PIN) {
 }
 async function sha256Of(file) {
   try {
-    return (0, import_node_crypto7.createHash)("sha256").update(await (0, import_promises22.readFile)(file)).digest("hex");
+    return (0, import_node_crypto7.createHash)("sha256").update(await (0, import_promises23.readFile)(file)).digest("hex");
   } catch {
     return null;
   }
@@ -15266,8 +15921,8 @@ async function editorStatus(opts = {}) {
   let totalBytes = 0;
   for (const [name, expected] of Object.entries(pin.files)) {
     totalBytes += expected.bytes;
-    const file = import_node_path30.default.join(dir, name);
-    const info = (0, import_node_fs26.existsSync)(file) ? await (0, import_promises22.stat)(file).catch(() => null) : null;
+    const file = import_node_path31.default.join(dir, name);
+    const info = (0, import_node_fs27.existsSync)(file) ? await (0, import_promises23.stat)(file).catch(() => null) : null;
     if (info && info.size === expected.bytes && await sha256Of(file) === expected.sha256) {
       installedBytes += expected.bytes;
     } else {
@@ -15296,7 +15951,7 @@ async function installEditor(opts = {}) {
     );
   }
   if (!baseUrl) throw new EditorInstallError("no download location for the editor build");
-  await (0, import_promises22.mkdir)(dir, { recursive: true });
+  await (0, import_promises23.mkdir)(dir, { recursive: true });
   const downloaded = [];
   const skipped = Object.keys(pin.files).filter((name) => !before.missing.includes(name));
   let fetchedBytes = before.installedBytes;
@@ -15324,13 +15979,13 @@ 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 = import_node_path30.default.join(dir, name);
+    const final = import_node_path31.default.join(dir, name);
     const tmp = `${final}.${process.pid}.part`;
     try {
-      await (0, import_promises22.writeFile)(tmp, bytes);
-      await (0, import_promises22.rename)(tmp, final);
+      await (0, import_promises23.writeFile)(tmp, bytes);
+      await (0, import_promises23.rename)(tmp, final);
     } finally {
-      await (0, import_promises22.rm)(tmp, { force: true });
+      await (0, import_promises23.rm)(tmp, { force: true });
     }
     fetchedBytes += bytes.length;
     downloaded.push(name);
@@ -15370,12 +16025,12 @@ var EDITOR_CONTENT_TYPES = {
   ".json": "application/json; charset=utf-8"
 };
 function editorContentType(name) {
-  return EDITOR_CONTENT_TYPES[import_node_path30.default.extname(name).toLowerCase()] ?? null;
+  return EDITOR_CONTENT_TYPES[import_node_path31.default.extname(name).toLowerCase()] ?? null;
 }
 
 // src/gallery/editor.ts
-var import_promises23 = require("fs/promises");
-var import_node_path31 = __toESM(require("path"), 1);
+var import_promises24 = require("fs/promises");
+var import_node_path32 = __toESM(require("path"), 1);
 function editorRoute(release, name = "index.html") {
   return `/editor/${encodeURIComponent(release)}/${encodeURIComponent(name)}`;
 }
@@ -15448,7 +16103,7 @@ function createGalleryEditorHandlers(opts = {}) {
       if (!status.installed) return null;
       let bytes;
       try {
-        bytes = await (0, import_promises23.readFile)(import_node_path31.default.join(dir, name));
+        bytes = await (0, import_promises24.readFile)(import_node_path32.default.join(dir, name));
       } catch {
         verified = null;
         return null;
@@ -15465,7 +16120,7 @@ function createGalleryEditorHandlers(opts = {}) {
 // src/gallery/server.ts
 var import_node_crypto8 = require("crypto");
 var import_node_http2 = require("http");
-var import_promises24 = require("fs/promises");
+var import_promises25 = require("fs/promises");
 var MAX_EDIT_BYTES = 48 * 1024 * 1024;
 var EDITOR_CSP = [
   "default-src 'self'",
@@ -15624,7 +16279,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 (0, import_promises24.readFile)(asset.path);
+          const bytes = await (0, import_promises25.readFile)(asset.path);
           res.writeHead(200, {
             "Content-Type": asset.contentType,
             "Cache-Control": "no-store",
@@ -15700,7 +16355,7 @@ async function serveGallery(opts) {
         if (!asset) return fail(404, "no such gallery media");
         let bytes;
         try {
-          bytes = await (0, import_promises24.readFile)(asset.path);
+          bytes = await (0, import_promises25.readFile)(asset.path);
         } catch {
           return fail(404, "gallery media is no longer on disk; refresh the page");
         }
@@ -16074,19 +16729,19 @@ function createGenerateHandlers(opts) {
 }
 
 // src/pipeline/salvage.ts
-var import_promises25 = require("fs/promises");
-var import_node_fs27 = require("fs");
-var import_node_path32 = __toESM(require("path"), 1);
+var import_promises26 = require("fs/promises");
+var import_node_fs28 = require("fs");
+var import_node_path33 = __toESM(require("path"), 1);
 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 (!(0, import_node_fs27.existsSync)(p)) throw new Error(`Claim lockfile not found: ${p}`);
+    if (!(0, import_node_fs28.existsSync)(p)) throw new Error(`Claim lockfile not found: ${p}`);
     let parsed;
     try {
-      parsed = parseLock(JSON.parse(await (0, import_promises25.readFile)(p, "utf8")));
+      parsed = parseLock(JSON.parse(await (0, import_promises26.readFile)(p, "utf8")));
     } catch {
       throw new Error(`Claim lockfile is malformed: ${p}`);
     }
@@ -16139,20 +16794,20 @@ function matchOrphanStyle(prompt, manifest) {
   return matchStyleByPattern(prompt, manifest);
 }
 async function loadSiblingManifests(ownManifestPath, workspaceManifestPaths, claimPaths) {
-  const own = import_node_path32.default.resolve(ownManifestPath);
+  const own = import_node_path33.default.resolve(ownManifestPath);
   const siblingManifestPaths = [
     .../* @__PURE__ */ new Set([
       ...workspaceManifestPaths,
-      ...claimPaths.map((c) => import_node_path32.default.join(import_node_path32.default.dirname(import_node_path32.default.resolve(c)), "pixelkiln.manifest.json"))
+      ...claimPaths.map((c) => import_node_path33.default.join(import_node_path33.default.dirname(import_node_path33.default.resolve(c)), "pixelkiln.manifest.json"))
     ])
   ];
   const siblings = [];
   for (const siblingManifestPath of siblingManifestPaths) {
-    if (import_node_path32.default.resolve(siblingManifestPath) === own) continue;
-    if (!(0, import_node_fs27.existsSync)(siblingManifestPath)) continue;
+    if (import_node_path33.default.resolve(siblingManifestPath) === own) continue;
+    if (!(0, import_node_fs28.existsSync)(siblingManifestPath)) continue;
     try {
       const { manifest } = await loadManifest(siblingManifestPath);
-      siblings.push({ label: import_node_path32.default.basename(import_node_path32.default.dirname(siblingManifestPath)), manifest });
+      siblings.push({ label: import_node_path33.default.basename(import_node_path33.default.dirname(siblingManifestPath)), manifest });
     } catch {
     }
   }
@@ -16268,8 +16923,8 @@ async function applyTags(provider, decisions, existing, opts = {}) {
 }
 
 // src/pick/salvage-server.ts
-var import_promises26 = require("fs/promises");
-var import_node_path33 = __toESM(require("path"), 1);
+var import_promises27 = require("fs/promises");
+var import_node_path34 = __toESM(require("path"), 1);
 
 // src/pick/salvage-sheet.ts
 var escapeHtml3 = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
@@ -16434,7 +17089,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
   });
   const html = renderSalvageSheet(orphans, {
     styleId: ctx.styleId,
-    importDir: import_node_path33.default.relative(process.cwd(), ctx.importDir) || "."
+    importDir: import_node_path34.default.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]));
@@ -16463,10 +17118,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 = import_node_path33.default.join("_salvaged", `${assetId}.png`);
-            const outFile = import_node_path33.default.resolve(ctx.importDir, rel);
-            await (0, import_promises26.mkdir)(import_node_path33.default.dirname(outFile), { recursive: true });
-            await (0, import_promises26.writeFile)(outFile, buf);
+            const rel = import_node_path34.default.join("_salvaged", `${assetId}.png`);
+            const outFile = import_node_path34.default.resolve(ctx.importDir, rel);
+            await (0, import_promises27.mkdir)(import_node_path34.default.dirname(outFile), { recursive: true });
+            await (0, import_promises27.writeFile)(outFile, buf);
             ctx.manifest.assets[assetId] = {
               prompt: orphan.prompt,
               promptByStyle: {},
@@ -16498,7 +17153,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
               sourceUrl: durableSource,
               sourceUrls: durableSource ? [{ url: durableSource }] : [],
               outputs: [{
-                path: portableOutputPath(outFile, import_node_path33.default.dirname(ctx.manifestPath)),
+                path: portableOutputPath(outFile, import_node_path34.default.dirname(ctx.manifestPath)),
                 sha256: sha256(buf)
               }],
               submittedAt: orphan.createdAt,
@@ -16522,9 +17177,9 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
         }
       }
       await applyTags(provider, decisions, existingTags, { onProgress: log });
-      const raw = JSON.parse(await (0, import_promises26.readFile)(ctx.manifestPath, "utf8"));
+      const raw = JSON.parse(await (0, import_promises27.readFile)(ctx.manifestPath, "utf8"));
       for (const id of importedAssetIds) raw.assets[id] = ctx.manifest.assets[id];
-      await (0, import_promises26.writeFile)(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
+      await (0, import_promises27.writeFile)(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
       await saveLock(ctx.lockPath, ctx.lock);
       return result;
     }
@@ -16654,6 +17309,10 @@ async function workspaceStatus(ws, dir) {
   EXIT_CODES,
   EditorInstallError,
   FAKE_PNG,
+  FONT_COST_GENERATIONS,
+  FONT_GLYPH_SIZES,
+  FONT_WEIGHTS,
+  FRAME_SET_REVISION_MODES,
   FakeProvider,
   GenerateRequestError,
   GenerateRequestSchema,
@@ -16670,6 +17329,7 @@ async function workspaceStatus(ws, dir) {
   MAX_DOWNLOAD_BYTES,
   MAX_HAND_EDIT_BYTES,
   MAX_RETRIES,
+  MEMBER_SET_REVISION_MODES,
   MIRRORED_DIRECTION,
   ManifestDriftError,
   ManifestEditError,
@@ -16699,6 +17359,8 @@ async function workspaceStatus(ws, dir) {
   ScenarioProvider,
   StyleInputSchema,
   StyleSchema,
+  UNZOOM_MAX_AREA,
+  UNZOOM_MIN_SIDE,
   UiElementSchema,
   UiPieceSchema,
   UnsupportedCapabilityError,
@@ -16733,6 +17395,7 @@ async function workspaceStatus(ws, dir) {
   currentEntryOutputPath,
   currentOutputPath,
   defaultOpenCommand,
+  defaultUnzoomOut,
   detachHandEdit,
   detectMediaType,
   doctor,
@@ -16750,10 +17413,12 @@ async function workspaceStatus(ws, dir) {
   fetchAssets,
   fetchWithRetry,
   findOrphans,
+  fontOutputPaths,
   formatCost,
   frameSetFps,
   galleryMediaId,
   galleryMediaRoute,
+  generateFont,
   generationCost,
   groupOrphansByStyle,
   handEditBase,
@@ -16889,6 +17554,7 @@ async function workspaceStatus(ws, dir) {
   tilesCost,
   toPortablePath,
   totalSpend,
+  unzoomFile,
   upsert,
   validateCostEstimate,
   validateMedia,