pixelkiln 0.82.0 → 0.84.0

package/dist/index.js

@@ -9,6 +9,7 @@ var RevisionModeSchema = z.enum([
   "outpaint",
   "reduce-colors",
   "correct-pixelart",
+  "remove-background",
   "animate",
   "animate-pixminimax",
   "animate-skeleton",
@@ -340,7 +341,22 @@ var RevisionSchema = z.object({
    * `interpolate`: required, the ending keyframe; the parent is the start.
    */
   lastFrame: z.string().min(1).optional(),
-  /** `animate-pixminimax` only: facing direction, used only alongside `enhancePrompt` to hold the sprite's facing. */
+  /**
+   * `animate`/`animate-pixminimax` only: colour de-flicker sensitivity.
+   * Frames whose foreground drifts from the first frame beyond this are
+   * corrected toward it; 0 corrects every frame and higher values correct
+   * fewer. Omit for PixelLab's default.
+   */
+  driftThreshold: z.number().min(0).optional(),
+  /**
+   * `animate-pixminimax` only: one noun phrase for what the parent shows.
+   * PixelLab reads it off the image when omitted, and can decline some
+   * images, failing the job until it is sent.
+   */
+  subjectDescription: z.string().min(1).max(300).optional(),
+  /** `animate-pixminimax` only: the pose the parent is in, read off the image by PixelLab when omitted. */
+  initialPose: z.string().min(1).max(300).optional(),
+  /** `animate-pixminimax` only: facing direction, one of the model's caption fields, so it also holds the sprite's facing. */
   direction: CharacterDirectionSchema.optional(),
   /** `animate`/`animate-pixminimax` only: let PixelLab expand the action into a fuller motion description first. */
   enhancePrompt: z.boolean().optional(),
@@ -360,12 +376,15 @@ var RevisionSchema = z.object({
    * same `mannequin`/`bear`/`cat`/`dog`/`horse`/`lion` vocabulary.
    */
   skeletonTemplate: z.string().min(1).optional(),
+  /** `remove-background` only: `simple` is faster and suits flat backgrounds; `complex` handles detailed edges. PixelLab defaults to `simple`. */
+  removalTask: z.enum(["simple", "complex"]).optional(),
   /**
-   * `animate-skeleton` only: what the character *looks like*, a noun
+   * `animate-skeleton`: what the character *looks like*, a noun
    * phrase (colours, clothing, held items) — distinct from the asset's
    * own `prompt`, which this mode sends as the motion's short label
    * (PixelLab's `action`), the same `prompt`-as-motion convention
-   * `animate`/`animate-pixminimax` already use.
+   * `animate`/`animate-pixminimax` already use. `remove-background`: a
+   * short description of the foreground, which PixelLab uses as a hint.
    */
   description: z.string().min(1).optional(),
   /**
@@ -482,7 +501,44 @@ var RevisionSchema = z.object({
       path: ["keypointsFile"]
     });
   }
-  for (const field of ["keypointsFile", "skeletonTemplate", "description"]) {
+  if (revision.driftThreshold !== void 0 && revision.mode !== "animate" && revision.mode !== "animate-pixminimax") {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "driftThreshold applies to animate/animate-pixminimax revisions only",
+      path: ["driftThreshold"]
+    });
+  }
+  for (const field of ["subjectDescription", "initialPose"]) {
+    if (revision[field] !== void 0 && revision.mode !== "animate-pixminimax") {
+      context.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `${field} applies to animate-pixminimax revisions only`,
+        path: [field]
+      });
+    }
+  }
+  if (revision.removalTask !== void 0 && revision.mode !== "remove-background") {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "removalTask applies to remove-background revisions only",
+      path: ["removalTask"]
+    });
+  }
+  if (revision.strength !== void 0 && revision.mode === "remove-background") {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "remove-background revisions do not take a strength",
+      path: ["strength"]
+    });
+  }
+  if (revision.description !== void 0 && revision.mode !== "animate-skeleton" && revision.mode !== "remove-background") {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "description applies to animate-skeleton/remove-background revisions only",
+      path: ["description"]
+    });
+  }
+  for (const field of ["keypointsFile", "skeletonTemplate"]) {
     if (revision[field] !== void 0 && revision.mode !== "animate-skeleton") {
       context.addIssue({
         code: z.ZodIssueCode.custom,
@@ -1136,6 +1192,10 @@ var LockEntrySchema = z.object({
     keypointsSha256: z.string().regex(/^[0-9a-f]{64}$/).optional(),
     skeletonTemplate: z.string().min(1).optional(),
     description: z.string().min(1).optional(),
+    removalTask: z.enum(["simple", "complex"]).optional(),
+    driftThreshold: z.number().min(0).optional(),
+    subjectDescription: z.string().min(1).max(300).optional(),
+    initialPose: z.string().min(1).max(300).optional(),
     engine: z.enum(["pro-flash"]).optional()
   }).strict().nullable().default(null),
   /** For a mirror: the asset it flips and a hash over that asset's output hashes when this was made. */
@@ -1564,6 +1624,7 @@ var CorrectPixelartResponseSchema = z3.object({
   images: z3.array(z3.object({ base64: z3.string().min(1) }).passthrough()).min(1),
   usage: z3.unknown().optional()
 }).passthrough();
+var RemoveBackgroundResponseSchema = z3.object({ image: z3.object({ base64: z3.string().min(1) }).passthrough(), usage: z3.unknown().optional() }).passthrough();
 var ProFlashImageSubmitSchema = z3.object({
   background_job_id: z3.string().min(1),
   image_id: z3.string().min(1),
@@ -1755,9 +1816,9 @@ var PixelLabClient = class {
   apiKey;
   http;
   /** Retries transport failures, 429, and 5xx; see http.ts for the policy. */
-  async request(path36, init) {
+  async request(path37, init) {
     const auth = this.apiKey.startsWith("Bearer ") ? this.apiKey : `Bearer ${this.apiKey}`;
-    const res = await this.http(`${BASE}${path36}`, {
+    const res = await this.http(`${BASE}${path37}`, {
       ...init,
       headers: {
         Authorization: auth,
@@ -1767,13 +1828,13 @@ var PixelLabClient = class {
     });
     const text = await res.text();
     if (!res.ok) {
-      throw new PixelLabError(`${init?.method ?? "GET"} ${path36} \u2192 ${res.status}`, res.status, text);
+      throw new PixelLabError(`${init?.method ?? "GET"} ${path37} \u2192 ${res.status}`, res.status, text);
     }
     if (!text) return {};
     try {
       return JSON.parse(text);
     } catch {
-      throw new Error(`${init?.method ?? "GET"} ${path36} returned invalid JSON`);
+      throw new Error(`${init?.method ?? "GET"} ${path37} returned invalid JSON`);
     }
   }
   async balance() {
@@ -2178,10 +2239,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 path36;
+    let path37;
     let body;
     if (args.mode === "v3") {
-      path36 = "/create-character-v3";
+      path37 = "/create-character-v3";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -2195,7 +2256,7 @@ var PixelLabClient = class {
         ...args.enhancePrompt ? { enhance_prompt: true } : {}
       };
     } else if (args.mode === "pro-flash") {
-      path36 = "/create-character-pro-flash";
+      path37 = "/create-character-pro-flash";
       const traits = args.styleTraits;
       body = {
         description: args.description,
@@ -2219,7 +2280,7 @@ var PixelLabClient = class {
         } : {}
       };
     } else if (args.mode === "pro") {
-      path36 = "/create-character-pro";
+      path37 = "/create-character-pro";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -2233,7 +2294,7 @@ var PixelLabClient = class {
         ...!south && args.styleCharacterId ? { style_character_id: args.styleCharacterId } : {}
       };
     } else {
-      path36 = args.directions === 4 ? "/create-character-with-4-directions" : "/create-character-with-8-directions";
+      path37 = args.directions === 4 ? "/create-character-with-4-directions" : "/create-character-with-8-directions";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -2250,8 +2311,8 @@ var PixelLabClient = class {
         ...palette
       };
     }
-    const raw = await this.request(path36, { method: "POST", body: JSON.stringify(body) });
-    return validateResponse(CharacterSubmitSchema, raw, path36.slice(1));
+    const raw = await this.request(path37, { method: "POST", body: JSON.stringify(body) });
+    return validateResponse(CharacterSubmitSchema, raw, path37.slice(1));
   }
   /** A text edit of an existing character, applied to every direction and stored as a sibling. */
   async createCharacterState(args) {
@@ -2628,6 +2689,27 @@ var PixelLabClient = class {
     const pngs = cleanupResults(res.images, images.length, "correct-pixelart");
     return { png: pngs[0], pngs, usage: res.usage };
   }
+  /**
+   * `/remove-background`: a transparent PNG from one pixel-art image,
+   * synchronously, like the rest of the Cleanup tier. The API takes at most
+   * 400x400 worth of area, one image per call. `simple` is faster and suits
+   * flat backgrounds; `complex` is slower and handles detailed edges. The
+   * schema's response example is dollar-denominated (`usd: 0.01`); the
+   * subscription cost measured 1 generation (docs/ENDPOINTS.md), and the
+   * default `simple` task is the one measured.
+   */
+  async removeBackground(args) {
+    const body = { image: args.image, image_size: { width: args.width, height: args.height } };
+    if (args.task) body.background_removal_task = args.task === "complex" ? "remove_complex_background" : "remove_simple_background";
+    if (args.text) body.text = args.text;
+    if (args.seed != null) body.seed = args.seed;
+    const res = validateResponse(
+      RemoveBackgroundResponseSchema,
+      await this.request("/remove-background", { method: "POST", body: JSON.stringify(body) }),
+      "remove-background"
+    );
+    return { png: Buffer.from(res.image.base64, "base64"), usage: res.usage };
+  }
   /**
    * `/unzoom`: recover native-resolution pixel art from an upscaled image (a
    * 32x32 sprite saved at 512x512). Synchronous like the Cleanup tier.
@@ -2736,6 +2818,7 @@ var PixelLabClient = class {
    */
   async animateWithTextV3(args) {
     const body = { first_frame: args.firstFrame, action: args.action };
+    if (args.driftThreshold != null) body.drift_threshold = args.driftThreshold;
     if (args.lastFrame) body.last_frame = args.lastFrame;
     if (args.frameCount != null) body.frame_count = args.frameCount;
     if (args.seed != null) body.seed = args.seed;
@@ -2755,6 +2838,10 @@ var PixelLabClient = class {
    */
   async animatePixminimax(args) {
     const body = { first_frame: args.firstFrame, description: args.description };
+    if (args.view) body.view = args.view;
+    if (args.subjectDescription) body.subject_description = args.subjectDescription;
+    if (args.initialPose) body.initial_pose = args.initialPose;
+    if (args.driftThreshold != null) body.drift_threshold = args.driftThreshold;
     if (args.lastFrame) body.last_frame = args.lastFrame;
     if (args.frameCount != null) body.frame_count = args.frameCount;
     if (args.seed != null) body.seed = args.seed;
@@ -2790,6 +2877,7 @@ var PixelLabClient = class {
       keypoints: args.keypoints,
       direction: args.direction
     };
+    if (args.view) body.view = args.view;
     if (args.templateId) body.template_id = args.templateId;
     if (args.action) body.action = args.action;
     if (args.description) body.description = args.description;
@@ -3437,10 +3525,10 @@ import { createReadStream } from "fs";
 function sha256(data) {
   return createHash("sha256").update(data).digest("hex");
 }
-async function sha256File(path36) {
+async function sha256File(path37) {
   return new Promise((resolve, reject) => {
     const hash = createHash("sha256");
-    const stream = createReadStream(path36);
+    const stream = createReadStream(path37);
     stream.on("data", (chunk2) => hash.update(chunk2));
     stream.on("error", reject);
     stream.on("end", () => resolve(hash.digest("hex")));
@@ -3564,6 +3652,10 @@ function specHash(spec, styleImageHashes, providerOptionIdentity = spec.provider
         keypointsSha256: spec.revision.keypointsSha256,
         skeletonTemplate: spec.revision.skeletonTemplate,
         description: spec.revision.description,
+        removalTask: spec.revision.removalTask,
+        driftThreshold: spec.revision.driftThreshold,
+        subjectDescription: spec.revision.subjectDescription,
+        initialPose: spec.revision.initialPose,
         engine: spec.revision.engine
       } : void 0
     })
@@ -3739,7 +3831,7 @@ var PixelLabProvider = class _PixelLabProvider {
    * outpaint path yet.
    */
   supportsRevision(mode2) {
-    return mode2 === "inpaint" || mode2 === "image-to-image" || mode2 === "reduce-colors" || mode2 === "correct-pixelart" || mode2 === "animate" || mode2 === "animate-pixminimax" || mode2 === "animate-skeleton" || mode2 === "interpolate" || mode2 === "edit-animation";
+    return mode2 === "inpaint" || mode2 === "image-to-image" || mode2 === "reduce-colors" || mode2 === "correct-pixelart" || mode2 === "remove-background" || mode2 === "animate" || mode2 === "animate-pixminimax" || mode2 === "animate-skeleton" || mode2 === "interpolate" || mode2 === "edit-animation";
   }
   /** PixelLab's own constraints: submissions must be >2s apart, and
    *  background jobs in flight are capped by subscription tier (Tier 1=8,
@@ -3767,6 +3859,9 @@ var PixelLabProvider = class _PixelLabProvider {
     if (spec.batch?.role === "member") {
       return { unit: "generations", amount: 0, candidates: 1 };
     }
+    if (spec.revision?.mode === "remove-background") {
+      return { unit: "generations", amount: 1, candidates: 1 };
+    }
     if (spec.revision?.mode === "reduce-colors" || spec.revision?.mode === "correct-pixelart") {
       return { unit: "generations", amount: 0.1, candidates: 1 };
     }
@@ -3855,6 +3950,12 @@ var PixelLabProvider = class _PixelLabProvider {
         throw new Error(`PixelLab correct-pixelart source is ${width}x${height}; the API takes at most 1024 pixels per side`);
       }
     }
+    if (spec.revision?.mode === "remove-background") {
+      const { sourceWidth: width, sourceHeight: height } = spec.revision;
+      if (width != null && height != null && (width > 400 || height > 400)) {
+        throw new Error(`PixelLab remove-background source is ${width}x${height}; the API takes at most 400x400`);
+      }
+    }
     if (spec.revision?.mode === "animate-skeleton") {
       const { sourceWidth: width, sourceHeight: height, frames, skeletonTemplate } = spec.revision;
       if (width != null && height != null && (width > 256 || height > 256)) {
@@ -3875,6 +3976,9 @@ var PixelLabProvider = class _PixelLabProvider {
       if (mode2 === "animate" && frames != null && frames > 16) {
         throw new Error(`PixelLab animate takes 4 to 16 frames; ${frames} is too many (use animate-pixminimax for up to 40)`);
       }
+      if (mode2 === "animate-pixminimax" && frames != null && frames % 4 !== 0) {
+        throw new Error(`PixelLab animate-pixminimax takes a multiple of 4 frames (4 to 40); ${frames} is not one`);
+      }
       if (lastFrameWidth != null && lastFrameHeight != null && width != null && height != null && (lastFrameWidth !== width || lastFrameHeight !== height)) {
         throw new Error(
           `PixelLab ${mode2} lastFrame is ${lastFrameWidth}x${lastFrameHeight}; source is ${width}x${height} \u2014 they must match`
@@ -4966,6 +5070,18 @@ var PixelLabProvider = class _PixelLabProvider {
       const res2 = await this.client.correctPixelart({ images, strength: revision.strength });
       return this.cacheCleanupResult(res2.pngs, res2.usage, roles, revision.sourceFps);
     }
+    if (revision.mode === "remove-background") {
+      if (width == null || height == null) throw new Error(`${spec.styleId}/${spec.assetId}: remove-background needs the source's size`);
+      const res2 = await this.client.removeBackground({
+        image,
+        width,
+        height,
+        task: revision.removalTask,
+        text: revision.description,
+        seed: spec.seed
+      });
+      return this.cacheCleanupResult([res2.png], 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`);
@@ -5001,7 +5117,8 @@ var PixelLabProvider = class _PixelLabProvider {
           frameCount: revision.frames,
           seed: spec.seed,
           noBackground: spec.noBackground,
-          enhancePrompt: revision.enhancePrompt
+          enhancePrompt: revision.enhancePrompt,
+          driftThreshold: revision.driftThreshold
         });
         return { jobId: res3.background_job_id };
       }
@@ -5013,7 +5130,11 @@ var PixelLabProvider = class _PixelLabProvider {
         seed: spec.seed,
         noBackground: spec.noBackground,
         enhancePrompt: revision.enhancePrompt,
-        direction: revision.direction
+        direction: revision.direction,
+        ...spec.view === "side" || spec.view === "low top-down" || spec.view === "high top-down" ? { view: spec.view } : {},
+        subjectDescription: revision.subjectDescription,
+        initialPose: revision.initialPose,
+        driftThreshold: revision.driftThreshold
       });
       return { jobId: res2.background_job_id };
     }
@@ -5030,6 +5151,9 @@ var PixelLabProvider = class _PixelLabProvider {
         firstFrameKeypoints: revision.skeleton.firstFrameKeypoints,
         keypoints: revision.skeleton.frames,
         direction: revision.direction,
+        // The style's camera, when it is one this endpoint knows; its enum is
+        // narrower than a style's free-string `view`.
+        ...spec.view === "side" || spec.view === "low top-down" || spec.view === "high top-down" ? { view: spec.view } : {},
         templateId: revision.skeletonTemplate,
         action: spec.prompt,
         description: revision.description,
@@ -5100,7 +5224,7 @@ var PixelLabProvider = class _PixelLabProvider {
   }
   async poll(jobId, generator, context) {
     const revisionMode = context?.spec?.revision?.mode;
-    if (revisionMode === "reduce-colors" || revisionMode === "correct-pixelart") {
+    if (revisionMode === "reduce-colors" || revisionMode === "correct-pixelart" || revisionMode === "remove-background") {
       return this.pollCachedRevision(jobId, context);
     }
     if (revisionMode === "animate" || revisionMode === "animate-pixminimax" || revisionMode === "animate-skeleton" || revisionMode === "interpolate" || revisionMode === "edit-animation") {
@@ -5808,9 +5932,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(path36, init = {}) {
+  async call(path37, init = {}) {
     if (!this.token) throw new Error("RD_API_KEY is not set");
-    const response = await this.request(`${this.baseUrl}${path36}`, {
+    const response = await this.request(`${this.baseUrl}${path37}`, {
       ...init,
       headers: {
         "Content-Type": "application/json",
@@ -8816,6 +8940,10 @@ async function resolveSpecs(loaded, filter) {
           } : {},
           ...asset.revision.skeletonTemplate ? { skeletonTemplate: asset.revision.skeletonTemplate } : {},
           ...asset.revision.description ? { description: asset.revision.description } : {},
+          ...asset.revision.removalTask ? { removalTask: asset.revision.removalTask } : {},
+          ...asset.revision.driftThreshold == null ? {} : { driftThreshold: asset.revision.driftThreshold },
+          ...asset.revision.subjectDescription ? { subjectDescription: asset.revision.subjectDescription } : {},
+          ...asset.revision.initialPose ? { initialPose: asset.revision.initialPose } : {},
           ...asset.revision.engine ? { engine: asset.revision.engine } : {}
         };
       }
@@ -12099,10 +12227,10 @@ function isSha256Hash(value) {
 function parseCache(value) {
   return HashCacheSchema.parse(value);
 }
-async function loadCache(path36) {
-  if (!existsSync13(path36)) return { version: 1, hashes: {} };
+async function loadCache(path37) {
+  if (!existsSync13(path37)) return { version: 1, hashes: {} };
   try {
-    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile11(path36, "utf8")));
+    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile11(path37, "utf8")));
     if (!parsed.success) return { version: 1, hashes: {} };
     return {
       version: 1,
@@ -12114,18 +12242,18 @@ async function loadCache(path36) {
     return { version: 1, hashes: {} };
   }
 }
-async function saveCache(path36, cache) {
+async function saveCache(path37, cache) {
   const sorted = {};
   for (const key of Object.keys(cache.hashes).sort()) {
     const hash = cache.hashes[key];
     if (!isSha256Hash(hash)) throw new Error(`Refusing to cache invalid SHA-256 for ${key}`);
     sorted[key] = hash;
   }
-  await mkdir5(pathModule.dirname(pathModule.resolve(path36)), { recursive: true });
-  const tmp = `${path36}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  await mkdir5(pathModule.dirname(pathModule.resolve(path37)), { recursive: true });
+  const tmp = `${path37}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
     await writeFile5(tmp, JSON.stringify({ version: 1, hashes: sorted }, null, 2) + "\n");
-    await rename4(tmp, path36);
+    await rename4(tmp, path37);
   } finally {
     await rm4(tmp, { force: true });
   }
@@ -13641,6 +13769,10 @@ async function submit(provider, loaded, items, lock, lockPath, opts = {}) {
         ...spec.revision.keypointsSha256 ? { keypointsSha256: spec.revision.keypointsSha256 } : {},
         ...spec.revision.skeletonTemplate ? { skeletonTemplate: spec.revision.skeletonTemplate } : {},
         ...spec.revision.description ? { description: spec.revision.description } : {},
+        ...spec.revision.removalTask ? { removalTask: spec.revision.removalTask } : {},
+        ...spec.revision.driftThreshold == null ? {} : { driftThreshold: spec.revision.driftThreshold },
+        ...spec.revision.subjectDescription ? { subjectDescription: spec.revision.subjectDescription } : {},
+        ...spec.revision.initialPose ? { initialPose: spec.revision.initialPose } : {},
         ...spec.revision.engine ? { engine: spec.revision.engine } : {}
       } : null,
       outfit: spec.character?.kind === "outfit" && outfitParentEntry ? {
@@ -14930,9 +15062,9 @@ async function runPicker(provider, lock, lockPath, opts = {}) {
 
 // src/gallery/snapshot.ts
 import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync25 } from "fs";
-import { readFile as readFile23, stat as stat3 } from "fs/promises";
-import path31 from "path";
+import { existsSync as existsSync26 } from "fs";
+import { readFile as readFile24, stat as stat3 } from "fs/promises";
+import path32 from "path";
 
 // src/workspace.ts
 import { mkdir as mkdir7, readFile as readFile18, rename as rename6, rm as rm7, writeFile as writeFile9 } from "fs/promises";
@@ -15068,15 +15200,16 @@ function validateWorkspace(ws, dir) {
 }
 
 // src/gallery/edit.ts
-import { readFile as readFile22, rename as rename9, writeFile as writeFile14 } from "fs/promises";
-import path30 from "path";
-import { z as z12 } from "zod";
+import { readFile as readFile23, rename as rename9, writeFile as writeFile15 } from "fs/promises";
+import path31 from "path";
+import { z as z13 } from "zod";
 
 // src/manifest-edit.ts
 import { readFile as readFile19, rename as rename7, rm as rm8, writeFile as writeFile10 } from "fs/promises";
 import path26 from "path";
 import { z as z8 } from "zod";
 var HexSha = z8.string().regex(/^[0-9a-f]{64}$/);
+var ProjectFileSchema = z8.string().min(1).refine((file) => !path26.isAbsolute(file) && !file.split(/[\\/]/).includes(".."), "must be a path inside the project");
 var AssetPatchSchema = z8.object({
   prompt: z8.string().optional(),
   /** Per-style override for the style being viewed; null removes it. */
@@ -15125,10 +15258,11 @@ var NewAssetSchema = z8.object({
   styles: z8.array(z8.string().min(1)).optional(),
   /**
    * A controlled regeneration of another asset in the same manifest,
-   * instead of a fresh generation. `inpaint` needs a mask upload the
-   * gallery does not offer yet, so only `image-to-image` and
-   * `animate-skeleton` (whose keypoints file the gallery writes first) can
-   * be created here; hand-edit the manifest for the other modes.
+   * instead of a fresh generation. Every mode but `outpaint` can be
+   * created here: `inpaint` names a mask file the gallery's mask editor
+   * wrote first, `interpolate` names an existing image as its ending
+   * keyframe, and `animate-skeleton` names the keypoints file the gallery
+   * wrote first.
    */
   revision: z8.discriminatedUnion("mode", [
     z8.object({
@@ -15137,6 +15271,52 @@ var NewAssetSchema = z8.object({
       from: z8.string().min(1),
       strength: z8.number().min(0).max(1).optional()
     }).strict(),
+    z8.object({
+      mode: z8.literal("reduce-colors"),
+      from: z8.string().min(1),
+      /** A target colour count; the gallery leaves PixelLab's default when this is omitted. */
+      numColors: z8.number().int().min(2).max(256).optional(),
+      dithering: RevisionDitheringSchema.optional(),
+      ditheringStrength: z8.number().min(0).max(10).optional()
+    }).strict(),
+    z8.object({
+      mode: z8.literal("inpaint"),
+      from: z8.string().min(1),
+      /** Black-and-white PNG the same size as the parent; white is repainted. */
+      mask: ProjectFileSchema
+    }).strict(),
+    z8.object({
+      mode: z8.literal("interpolate"),
+      from: z8.string().min(1),
+      /** The ending keyframe: an image already in the project, the parent's size. */
+      lastFrame: ProjectFileSchema,
+      fps: z8.number().int().min(1).max(60).optional()
+    }).strict(),
+    z8.object({ mode: z8.literal("correct-pixelart"), from: z8.string().min(1), strength: z8.number().min(0).max(1).optional() }).strict(),
+    z8.object({
+      mode: z8.literal("remove-background"),
+      from: z8.string().min(1),
+      removalTask: z8.enum(["simple", "complex"]).optional(),
+      /** A short description of the foreground, sent as PixelLab's text hint. */
+      description: z8.string().min(1).optional()
+    }).strict(),
+    z8.object({
+      mode: z8.enum(["animate", "animate-pixminimax"]),
+      from: z8.string().min(1),
+      frames: z8.number().int().min(4).max(40).refine((n) => n % 2 === 0, "frames must be even").optional(),
+      fps: z8.number().int().min(1).max(60).optional(),
+      enhancePrompt: z8.boolean().optional(),
+      driftThreshold: z8.number().min(0).optional(),
+      /** `animate-pixminimax` only; the loader refuses these on `animate`. */
+      direction: CharacterDirectionSchema.optional(),
+      subjectDescription: z8.string().min(1).max(300).optional(),
+      initialPose: z8.string().min(1).max(300).optional()
+    }).strict(),
+    z8.object({
+      mode: z8.literal("edit-animation"),
+      from: z8.string().min(1),
+      fps: z8.number().int().min(1).max(60).optional()
+    }).strict(),
     z8.object({
       mode: z8.literal("animate-skeleton"),
       from: z8.string().min(1),
@@ -15781,62 +15961,118 @@ async function saveProjectImage(root, request) {
   return relative.split(path28.sep).join("/");
 }
 
-// src/gallery/skeleton.ts
+// src/gallery/image-revision.ts
 import { existsSync as existsSync24 } from "fs";
-import { mkdir as mkdir10, readFile as readFile21, rm as rm10, writeFile as writeFile13 } from "fs/promises";
+import { readFile as readFile21, rm as rm10, writeFile as writeFile13 } from "fs/promises";
 import path29 from "path";
 import { z as z11 } from "zod";
-var SkeletonEstimateRequestSchema = z11.object({
-  project: z11.string().min(1).optional(),
-  styleId: z11.string().min(1),
-  assetId: z11.string().min(1),
-  frames: z11.number().int().min(3).max(15).optional()
-}).strict();
-var SkeletonAnimationRequestSchema = z11.object({
-  action: z11.literal("create-skeleton-animation"),
+var InpaintRevisionRequestSchema = z11.object({
+  action: z11.literal("create-inpaint-revision"),
   project: z11.string().min(1).optional(),
   expectedSha256: z11.string().regex(/^[0-9a-f]{64}$/),
   styleId: z11.string().min(1),
-  /** The sprite the animation poses. */
+  /** The sprite being repainted. */
   from: z11.string().min(1),
   assetId: z11.string().min(1).regex(/^[^/\\]+$/, "asset ids cannot contain slashes"),
-  /** The motion, sent as PixelLab's `action`. */
+  /** What to paint into the masked area. */
   prompt: z11.string().min(1),
+  /** Manifest-relative `.png` destination for the mask. */
+  maskPath: z11.string().min(1),
+  maskBase64: z11.string().regex(/^[A-Za-z0-9+/]*={0,2}$/),
+  /** Replace a file already at `maskPath`. */
+  overwrite: z11.boolean().optional()
+}).strict();
+async function createInpaintRevision(manifestPath, request) {
+  const root = path29.dirname(path29.resolve(manifestPath));
+  if (path29.extname(request.maskPath).toLowerCase() !== ".png") {
+    throw new ManifestEditError("the mask must be a .png path inside the project");
+  }
+  const bytes = Buffer.from(request.maskBase64, "base64");
+  const metadata = imageMetadata(bytes);
+  if (!metadata || metadata.format !== "png") throw new ManifestEditError("the mask is not a readable PNG");
+  const file = path29.resolve(root, request.maskPath);
+  const previous = existsSync24(file) ? await readFile21(file) : null;
+  const mask = await saveProjectImage(root, {
+    action: "upload-image",
+    path: request.maskPath,
+    base64: request.maskBase64,
+    ...request.overwrite ? { overwrite: true } : {}
+  });
+  try {
+    await applyManifestEdit(manifestPath, {
+      action: "add-asset",
+      assetId: request.assetId,
+      expectedSha256: request.expectedSha256,
+      asset: {
+        prompt: request.prompt,
+        styles: [request.styleId],
+        revision: { mode: "inpaint", from: request.from, mask }
+      }
+    });
+  } catch (error) {
+    if (previous) await writeFile13(file, previous);
+    else await rm10(file, { force: true });
+    throw error;
+  }
+  return mask;
+}
+
+// src/gallery/skeleton.ts
+import { existsSync as existsSync25 } from "fs";
+import { mkdir as mkdir10, readFile as readFile22, rm as rm11, writeFile as writeFile14 } from "fs/promises";
+import path30 from "path";
+import { z as z12 } from "zod";
+var SkeletonEstimateRequestSchema = z12.object({
+  project: z12.string().min(1).optional(),
+  styleId: z12.string().min(1),
+  assetId: z12.string().min(1),
+  frames: z12.number().int().min(3).max(15).optional()
+}).strict();
+var SkeletonAnimationRequestSchema = z12.object({
+  action: z12.literal("create-skeleton-animation"),
+  project: z12.string().min(1).optional(),
+  expectedSha256: z12.string().regex(/^[0-9a-f]{64}$/),
+  styleId: z12.string().min(1),
+  /** The sprite the animation poses. */
+  from: z12.string().min(1),
+  assetId: z12.string().min(1).regex(/^[^/\\]+$/, "asset ids cannot contain slashes"),
+  /** The motion, sent as PixelLab's `action`. */
+  prompt: z12.string().min(1),
   direction: CharacterDirectionSchema,
-  description: z11.string().min(1).optional(),
-  skeletonTemplate: z11.string().min(1).optional(),
+  description: z12.string().min(1).optional(),
+  skeletonTemplate: z12.string().min(1).optional(),
   /** Manifest-relative JSON path inside the project. */
-  keypointsFile: z11.string().min(1),
+  keypointsFile: z12.string().min(1),
   /** Poses to write to `keypointsFile`; omitted to use a file that already exists. */
   set: SkeletonSetSchema.optional(),
   /** Replace an existing `keypointsFile` with `set`. */
-  overwrite: z11.boolean().optional()
+  overwrite: z12.boolean().optional()
 }).strict();
-var SkeletonKeypointsUpdateSchema = z11.object({
-  action: z11.literal("update-skeleton-keypoints"),
-  project: z11.string().min(1).optional(),
-  styleId: z11.string().min(1),
-  assetId: z11.string().min(1),
+var SkeletonKeypointsUpdateSchema = z12.object({
+  action: z12.literal("update-skeleton-keypoints"),
+  project: z12.string().min(1).optional(),
+  styleId: z12.string().min(1),
+  assetId: z12.string().min(1),
   /** The file's SHA-256 when the page loaded it; anything else on disk is a concurrent edit. */
-  expectedSha256: z11.string().regex(/^[0-9a-f]{64}$/),
+  expectedSha256: z12.string().regex(/^[0-9a-f]{64}$/),
   set: SkeletonSetSchema
 }).strict();
 async function createSkeletonAnimation(manifestPath, request) {
-  const root = path29.dirname(path29.resolve(manifestPath));
-  const file = path29.resolve(root, request.keypointsFile);
-  const relative = path29.relative(root, file);
-  if (!request.keypointsFile.endsWith(".json") || relative.startsWith("..") || path29.isAbsolute(relative)) {
+  const root = path30.dirname(path30.resolve(manifestPath));
+  const file = path30.resolve(root, request.keypointsFile);
+  const relative = path30.relative(root, file);
+  if (!request.keypointsFile.endsWith(".json") || relative.startsWith("..") || path30.isAbsolute(relative)) {
     throw new ManifestEditError("the keypoints file must be a .json path inside the project");
   }
-  const existed = existsSync24(file);
+  const existed = existsSync25(file);
   let previous = null;
   if (request.set) {
     if (existed && !request.overwrite) {
       throw new ManifestEditError(`${request.keypointsFile} already exists; choose another path, or replace it`);
     }
-    if (existed) previous = await readFile21(file);
-    await mkdir10(path29.dirname(file), { recursive: true });
-    await writeFile13(file, JSON.stringify(request.set, null, 2) + "\n");
+    if (existed) previous = await readFile22(file);
+    await mkdir10(path30.dirname(file), { recursive: true });
+    await writeFile14(file, JSON.stringify(request.set, null, 2) + "\n");
   } else if (!existed) {
     throw new ManifestEditError(`${request.keypointsFile} does not exist; paste poses or estimate them from the sprite`);
   }
@@ -15851,7 +16087,7 @@ async function createSkeletonAnimation(manifestPath, request) {
         revision: {
           mode: "animate-skeleton",
           from: request.from,
-          keypointsFile: relative.split(path29.sep).join("/"),
+          keypointsFile: relative.split(path30.sep).join("/"),
           direction: request.direction,
           ...request.description ? { description: request.description } : {},
           ...request.skeletonTemplate ? { skeletonTemplate: request.skeletonTemplate } : {}
@@ -15860,8 +16096,8 @@ async function createSkeletonAnimation(manifestPath, request) {
     });
   } catch (error) {
     if (request.set) {
-      if (previous) await writeFile13(file, previous);
-      else await rm10(file, { force: true });
+      if (previous) await writeFile14(file, previous);
+      else await rm11(file, { force: true });
     }
     throw error;
   }
@@ -15872,64 +16108,64 @@ async function updateSkeletonKeypoints(ctx, request) {
   if (!spec) throw new ManifestEditError(`"${key}" is not declared by the manifest`);
   const file = spec.revision?.mode === "animate-skeleton" ? spec.revision.keypointsFile : void 0;
   if (!file) throw new ManifestEditError(`${key} is not an animate-skeleton revision`);
-  const relative = path29.relative(ctx.loaded.root, file);
-  if (relative.startsWith("..") || path29.isAbsolute(relative)) {
+  const relative = path30.relative(ctx.loaded.root, file);
+  if (relative.startsWith("..") || path30.isAbsolute(relative)) {
     throw new ManifestEditError(`${key}'s keypoints file is outside the project; edit it by hand`);
   }
-  const current = existsSync24(file) ? sha256(await readFile21(file)) : null;
+  const current = existsSync25(file) ? sha256(await readFile22(file)) : null;
   if (current !== request.expectedSha256) {
     throw Object.assign(
-      new Error(`${relative.split(path29.sep).join("/")} changed on disk since this page loaded it; press Refresh and edit again`),
+      new Error(`${relative.split(path30.sep).join("/")} changed on disk since this page loaded it; press Refresh and edit again`),
       { status: 409 }
     );
   }
-  await writeFile13(file, JSON.stringify(request.set, null, 2) + "\n");
-  return relative.split(path29.sep).join("/");
+  await writeFile14(file, JSON.stringify(request.set, null, 2) + "\n");
+  return relative.split(path30.sep).join("/");
 }
 
 // src/gallery/edit.ts
-var Base64 = z12.string().regex(/^[A-Za-z0-9+/]*={0,2}$/).max(Math.ceil(MAX_HAND_EDIT_BYTES / 3) * 4);
-var HandEditRequestSchema = z12.discriminatedUnion("action", [
-  z12.object({
-    action: z12.literal("start-edit"),
-    project: z12.string().min(1).optional(),
-    assetId: z12.string().min(1),
-    styleId: z12.string().min(1),
-    expectedSha256: z12.string().regex(/^[0-9a-f]{64}$/),
+var Base64 = z13.string().regex(/^[A-Za-z0-9+/]*={0,2}$/).max(Math.ceil(MAX_HAND_EDIT_BYTES / 3) * 4);
+var HandEditRequestSchema = z13.discriminatedUnion("action", [
+  z13.object({
+    action: z13.literal("start-edit"),
+    project: z13.string().min(1).optional(),
+    assetId: z13.string().min(1),
+    styleId: z13.string().min(1),
+    expectedSha256: z13.string().regex(/^[0-9a-f]{64}$/),
     /** Also launch the author's editor on the file. */
-    open: z12.boolean().optional()
+    open: z13.boolean().optional()
   }).strict(),
-  z12.object({
-    action: z12.literal("detach-edit"),
-    project: z12.string().min(1).optional(),
-    assetId: z12.string().min(1),
-    styleId: z12.string().min(1),
-    expectedSha256: z12.string().regex(/^[0-9a-f]{64}$/)
+  z13.object({
+    action: z13.literal("detach-edit"),
+    project: z13.string().min(1).optional(),
+    assetId: z13.string().min(1),
+    styleId: z13.string().min(1),
+    expectedSha256: z13.string().regex(/^[0-9a-f]{64}$/)
   }).strict(),
   /** From the in-browser editor: the page holds the bytes, the server validates and writes. */
-  z12.object({
-    action: z12.literal("save-edit"),
-    project: z12.string().min(1).optional(),
-    assetId: z12.string().min(1),
-    styleId: z12.string().min(1),
-    expectedSha256: z12.string().regex(/^[0-9a-f]{64}$/),
+  z13.object({
+    action: z13.literal("save-edit"),
+    project: z13.string().min(1).optional(),
+    assetId: z13.string().min(1),
+    styleId: z13.string().min(1),
+    expectedSha256: z13.string().regex(/^[0-9a-f]{64}$/),
     /** The flattened image; for a frame set, `frames` instead. */
     png: Base64.min(1).optional(),
     /** Every frame of a set, tagged with the role it was opened under (null for one added in the editor). */
-    frames: z12.array(z12.object({ role: z12.string().min(1).nullable(), png: Base64.min(1) }).strict()).min(1).max(256).optional(),
+    frames: z13.array(z13.object({ role: z13.string().min(1).nullable(), png: Base64.min(1) }).strict()).min(1).max(256).optional(),
     /** The editor's layered project file, kept beside the edit. */
     pxo: Base64.optional(),
     /** Editor identity from the bridge's ready message. */
-    editor: z12.string().min(1).max(200),
-    protocol: z12.number().int().positive()
+    editor: z13.string().min(1).max(200),
+    protocol: z13.number().int().positive()
   }).strict()
 ]);
 var UNDO_DEPTH = 20;
-var UndoRequestSchema = z12.object({
-  action: z12.literal("undo-edit"),
-  project: z12.string().min(1).optional(),
+var UndoRequestSchema = z13.object({
+  action: z13.literal("undo-edit"),
+  project: z13.string().min(1).optional(),
   /** The manifest as the page last saw it; undo refuses a manifest someone else has changed since. */
-  expectedSha256: z12.string().regex(/^[0-9a-f]{64}$/)
+  expectedSha256: z13.string().regex(/^[0-9a-f]{64}$/)
 }).strict();
 function createGalleryEditHandler(opts) {
   const log = opts.onProgress ?? (() => {
@@ -15938,7 +16174,7 @@ function createGalleryEditHandler(opts) {
   const history = /* @__PURE__ */ new Map();
   const manifestOf = async (project) => {
     try {
-      return path30.resolve(await opts.manifestFor(typeof project === "string" ? project : void 0));
+      return path31.resolve(await opts.manifestFor(typeof project === "string" ? project : void 0));
     } catch {
       return null;
     }
@@ -15948,7 +16184,7 @@ function createGalleryEditHandler(opts) {
     if (undo.success) {
       const manifestPath2 = await manifestOf(undo.data.project);
       if (!manifestPath2) throw new ManifestEditError("no manifest to undo an edit in");
-      const current = await readFile22(manifestPath2, "utf8");
+      const current = await readFile23(manifestPath2, "utf8");
       if (sha256(current) !== undo.data.expectedSha256) throw new ManifestDriftError(manifestPath2);
       const stack = history.get(manifestPath2) ?? [];
       const last = stack[stack.length - 1];
@@ -15958,17 +16194,17 @@ function createGalleryEditHandler(opts) {
         throw Object.assign(new Error("the manifest changed outside the gallery since its last edit; undo would discard that change"), { status: 409 });
       }
       const tmp = manifestPath2 + ".pixelkiln-undo";
-      await writeFile14(tmp, last.before);
+      await writeFile15(tmp, last.before);
       await rename9(tmp, manifestPath2);
       stack.pop();
-      log(`  manifest edit undone in ${path30.relative(process.cwd(), manifestPath2) || manifestPath2}`);
+      log(`  manifest edit undone in ${path31.relative(process.cwd(), manifestPath2) || manifestPath2}`);
       return opts.reload();
     }
     const manifestPath = await manifestOf(body?.project);
-    const before = manifestPath ? await readFile22(manifestPath, "utf8").catch(() => null) : null;
+    const before = manifestPath ? await readFile23(manifestPath, "utf8").catch(() => null) : null;
     const build = await apply(body);
     if (manifestPath && before !== null) {
-      const after = await readFile22(manifestPath, "utf8").catch(() => null);
+      const after = await readFile23(manifestPath, "utf8").catch(() => null);
       if (after !== null && after !== before) {
         const stack = history.get(manifestPath) ?? [];
         stack.push({ before, afterSha: sha256(after) });
@@ -16023,7 +16259,7 @@ function createEditApplier(opts, log) {
       } catch (error) {
         throw new ManifestEditError(error instanceof Error ? error.message : String(error));
       }
-      const written = await saveProjectImage(path30.dirname(path30.resolve(manifestPath2)), upload.data);
+      const written = await saveProjectImage(path31.dirname(path31.resolve(manifestPath2)), upload.data);
       log(`  image added: ${written}`);
       return opts.reload();
     }
@@ -16059,6 +16295,23 @@ function createEditApplier(opts, log) {
         "invalid skeleton animation: " + skeleton.error.issues.slice(0, 3).map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")
       );
     }
+    const inpaint = InpaintRevisionRequestSchema.safeParse(body);
+    if (inpaint.success) {
+      let manifestPath2;
+      try {
+        manifestPath2 = await opts.manifestFor(inpaint.data.project);
+      } catch (error) {
+        throw new ManifestEditError(error instanceof Error ? error.message : String(error));
+      }
+      const mask = await createInpaintRevision(manifestPath2, inpaint.data);
+      log(`  manifest edited: added inpaint revision ${inpaint.data.assetId} (mask ${mask})`);
+      return opts.reload();
+    }
+    if (body?.action === "create-inpaint-revision") {
+      throw new ManifestEditError(
+        "invalid inpaint revision: " + inpaint.error.issues.slice(0, 3).map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")
+      );
+    }
     const parsed = ManifestEditSchema.safeParse(body);
     if (!parsed.success) {
       throw new ManifestEditError(
@@ -16073,7 +16326,7 @@ function createEditApplier(opts, log) {
     }
     const result = await applyManifestEdit(manifestPath, parsed.data);
     if (result.changed) {
-      const relative = path30.relative(process.cwd(), result.manifestPath);
+      const relative = path31.relative(process.cwd(), result.manifestPath);
       const shown = !relative || relative.startsWith("..") ? result.manifestPath : relative;
       log(`  manifest edited: ${describeEdit(parsed.data)} in ${shown}`);
     }
@@ -16101,7 +16354,7 @@ function describeEdit(edit) {
 // src/gallery/snapshot.ts
 var PROJECT_FILE_TYPE = "application/octet-stream";
 function galleryMediaId(absolutePath) {
-  return createHash4("sha256").update(path31.resolve(absolutePath)).digest("hex").slice(0, 24);
+  return createHash4("sha256").update(path32.resolve(absolutePath)).digest("hex").slice(0, 24);
 }
 function galleryMediaRoute(id) {
   return `/media/${id}`;
@@ -16120,9 +16373,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 = path31.join(cacheDir, cacheFileName(output.sha256, mediaType));
+      const file = path32.join(cacheDir, cacheFileName(output.sha256, mediaType));
       let url = null;
-      if (existsSync25(file)) {
+      if (existsSync26(file)) {
         const id = galleryMediaId(file);
         media.set(id, { path: file, contentType: mediaType });
         url = `${galleryMediaRoute(id)}?v=${output.sha256.slice(0, 24)}`;
@@ -16154,7 +16407,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([readFile23(a), readFile23(b)]);
+    const [left, right] = await Promise.all([readFile24(a), readFile24(b)]);
     if (left.length > MAX_COMPARED_BYTES || right.length > MAX_COMPARED_BYTES) return false;
     const x = decodePng(left);
     const y = decodePng(right);
@@ -16252,10 +16505,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, path31.resolve(root, file)))
+    outputPaths.map((file) => describeOutput(media, root, path32.resolve(root, file)))
   );
-  const recordPath = path31.resolve(root, inspection.record);
-  const recordExists = existsSync25(recordPath);
+  const recordPath = path32.resolve(root, inspection.record);
+  const recordExists = existsSync26(recordPath);
   let options = null;
   let check = null;
   if (recordExists) {
@@ -16274,7 +16527,7 @@ async function describeQuality(media, root, inspection) {
   return {
     state: inspection.state,
     reason: inspection.reason,
-    output: portableOutputPath(path31.resolve(root, inspection.output), root),
+    output: portableOutputPath(path32.resolve(root, inspection.output), root),
     record: portableOutputPath(recordPath, root),
     recordExists,
     outputs,
@@ -16312,9 +16565,9 @@ async function buildGallerySnapshot(opts) {
   const media = /* @__PURE__ */ new Map();
   const plan = await buildPlan(specs, lock);
   const items = [];
-  const manifestText = await readFile23(loaded.path, "utf8");
+  const manifestText = await readFile24(loaded.path, "utf8");
   const manifestSha256 = sha256(manifestText);
-  const cacheDir = path31.resolve(path31.dirname(opts.lockPath), ".pixelkiln", "cache");
+  const cacheDir = path32.resolve(path32.dirname(opts.lockPath), ".pixelkiln", "cache");
   let rawStyles = {};
   try {
     const raw = JSON.parse(manifestText);
@@ -16338,12 +16591,12 @@ async function buildGallerySnapshot(opts) {
         )
       );
       if (spec.source) {
-        const editPath = path31.resolve(root, spec.source);
+        const editPath = path32.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: existsSync25(file) ? await sha256File(file) : null };
+            return { file, sha256: existsSync26(file) ? await sha256File(file) : null };
           })
         );
         edits = await Promise.all(editShas.map(({ file, sha256: editSha }) => describeOutput(media, root, file, { sha256: editSha })));
@@ -16351,7 +16604,7 @@ async function buildGallerySnapshot(opts) {
         const companion = await readHandEditCompanion(editPath);
         if (companion) {
           const projectPath = handEditProjectPath(editPath);
-          const project = companion.project && existsSync25(projectPath) ? await fileInfo(projectPath) : null;
+          const project = companion.project && existsSync26(projectPath) ? await fileInfo(projectPath) : null;
           let projectUrl = null;
           if (project) {
             const id = galleryMediaId(projectPath);
@@ -16387,8 +16640,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, path31.resolve(root, spec.source))];
-    } else if (!entry && existsSync25(spec.outFile)) {
+      outputs = [await describeOutput(media, root, path32.resolve(root, spec.source))];
+    } else if (!entry && existsSync26(spec.outFile)) {
       outputs = [await describeOutput(media, root, spec.outFile)];
     } else {
       outputs = [];
@@ -16591,7 +16844,7 @@ async function buildGallerySnapshot(opts) {
       id: loaded.manifest.name,
       name: loaded.manifest.name,
       manifest: loaded.path,
-      lock: path31.resolve(opts.lockPath),
+      lock: path32.resolve(opts.lockPath),
       root,
       provider: loaded.manifest.provider,
       account: null,
@@ -16617,7 +16870,7 @@ async function buildGallerySnapshot(opts) {
   return { snapshot, media };
 }
 async function buildWorkspaceGallerySnapshot(opts) {
-  const dir = path31.dirname(path31.resolve(opts.workspacePath));
+  const dir = path32.dirname(path32.resolve(opts.workspacePath));
   const media = /* @__PURE__ */ new Map();
   const projects = [];
   const items = [];
@@ -16660,11 +16913,11 @@ async function buildWorkspaceGallerySnapshot(opts) {
         id: project.id,
         name: loaded.manifest.name,
         manifest: manifestPath,
-        lock: path31.resolve(lockPath),
+        lock: path32.resolve(lockPath),
         root: loaded.root,
         provider: loaded.manifest.provider,
         account: project.account ?? null,
-        manifestSha256: manifestSha256 ?? sha256(await readFile23(manifestPath, "utf8")),
+        manifestSha256: manifestSha256 ?? sha256(await readFile24(manifestPath, "utf8")),
         historyLimit: historyLimit(loaded.manifest),
         entries: Object.keys(lock.entries).length,
         items: projectItems.length,
@@ -16676,8 +16929,8 @@ async function buildWorkspaceGallerySnapshot(opts) {
         id: project.id,
         name: project.id,
         manifest: manifestPath,
-        lock: path31.resolve(lockPath),
-        root: path31.dirname(manifestPath),
+        lock: path32.resolve(lockPath),
+        root: path32.dirname(manifestPath),
         provider: project.provider,
         account: project.account ?? null,
         manifestSha256: null,
@@ -16704,7 +16957,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
       version: 1,
       generatedAt: (opts.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
       project: null,
-      workspace: { path: path31.resolve(opts.workspacePath), dir, projects },
+      workspace: { path: path32.resolve(opts.workspacePath), dir, projects },
       filter,
       totals: {
         entries: projects.reduce((sum, project) => sum + project.entries, 0),
@@ -16721,7 +16974,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
 }
 
 // src/gallery/page.ts
-import { existsSync as existsSync26, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync27, readFileSync as readFileSync5 } from "fs";
 
 // src/gallery/client-bundle.ts
 import { createRequire } from "module";
@@ -16762,7 +17015,7 @@ function clientAssets() {
   const prebuilt = new URL("gallery.js", CLIENT_DIR);
   client ??= {
     css: readFileSync5(new URL("gallery.css", CLIENT_DIR), "utf8"),
-    js: existsSync26(prebuilt) ? readFileSync5(prebuilt, "utf8") : bundleGalleryClient()
+    js: existsSync27(prebuilt) ? readFileSync5(prebuilt, "utf8") : bundleGalleryClient()
   };
   return client;
 }
@@ -16905,10 +17158,10 @@ var EDITOR_RELEASE_BASE = "https://github.com/gfargo/pixelkiln/releases/download
 
 // src/editor/install.ts
 import { createHash as createHash5 } from "crypto";
-import { existsSync as existsSync27 } from "fs";
-import { mkdir as mkdir11, readFile as readFile24, rename as rename10, rm as rm11, stat as stat4, writeFile as writeFile15 } from "fs/promises";
+import { existsSync as existsSync28 } from "fs";
+import { mkdir as mkdir11, readFile as readFile25, rename as rename10, rm as rm12, stat as stat4, writeFile as writeFile16 } from "fs/promises";
 import os2 from "os";
-import path32 from "path";
+import path33 from "path";
 var EditorInstallError = class extends Error {
   constructor(message6, file) {
     super(message6);
@@ -16919,15 +17172,15 @@ var EditorInstallError = class extends Error {
 };
 function editorToolsRoot() {
   const override = process.env.PIXELKILN_TOOLS_DIR?.trim();
-  if (override) return path32.resolve(override);
-  if (process.platform === "darwin") return path32.join(os2.homedir(), "Library", "Caches", "pixelkiln", "tools");
+  if (override) return path33.resolve(override);
+  if (process.platform === "darwin") return path33.join(os2.homedir(), "Library", "Caches", "pixelkiln", "tools");
   if (process.platform === "win32") {
-    return path32.join(process.env.LOCALAPPDATA ?? path32.join(os2.homedir(), "AppData", "Local"), "pixelkiln", "tools");
+    return path33.join(process.env.LOCALAPPDATA ?? path33.join(os2.homedir(), "AppData", "Local"), "pixelkiln", "tools");
   }
-  return path32.join(process.env.XDG_CACHE_HOME ?? path32.join(os2.homedir(), ".cache"), "pixelkiln", "tools");
+  return path33.join(process.env.XDG_CACHE_HOME ?? path33.join(os2.homedir(), ".cache"), "pixelkiln", "tools");
 }
 function editorDir(pin = EDITOR_PIN, root = editorToolsRoot()) {
-  return path32.join(root, "pixelorama", pin.release ?? "unpublished");
+  return path33.join(root, "pixelorama", pin.release ?? "unpublished");
 }
 function editorBaseUrl(pin = EDITOR_PIN) {
   const override = process.env.PIXELKILN_EDITOR_URL?.trim();
@@ -16937,7 +17190,7 @@ function editorBaseUrl(pin = EDITOR_PIN) {
 }
 async function sha256Of(file) {
   try {
-    return createHash5("sha256").update(await readFile24(file)).digest("hex");
+    return createHash5("sha256").update(await readFile25(file)).digest("hex");
   } catch {
     return null;
   }
@@ -16950,8 +17203,8 @@ async function editorStatus(opts = {}) {
   let totalBytes = 0;
   for (const [name, expected] of Object.entries(pin.files)) {
     totalBytes += expected.bytes;
-    const file = path32.join(dir, name);
-    const info = existsSync27(file) ? await stat4(file).catch(() => null) : null;
+    const file = path33.join(dir, name);
+    const info = existsSync28(file) ? await stat4(file).catch(() => null) : null;
     if (info && info.size === expected.bytes && await sha256Of(file) === expected.sha256) {
       installedBytes += expected.bytes;
     } else {
@@ -17008,13 +17261,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 = path32.join(dir, name);
+    const final = path33.join(dir, name);
     const tmp = `${final}.${process.pid}.part`;
     try {
-      await writeFile15(tmp, bytes);
+      await writeFile16(tmp, bytes);
       await rename10(tmp, final);
     } finally {
-      await rm11(tmp, { force: true });
+      await rm12(tmp, { force: true });
     }
     fetchedBytes += bytes.length;
     downloaded.push(name);
@@ -17054,12 +17307,12 @@ var EDITOR_CONTENT_TYPES = {
   ".json": "application/json; charset=utf-8"
 };
 function editorContentType(name) {
-  return EDITOR_CONTENT_TYPES[path32.extname(name).toLowerCase()] ?? null;
+  return EDITOR_CONTENT_TYPES[path33.extname(name).toLowerCase()] ?? null;
 }
 
 // src/gallery/editor.ts
-import { readFile as readFile25 } from "fs/promises";
-import path33 from "path";
+import { readFile as readFile26 } from "fs/promises";
+import path34 from "path";
 function editorRoute(release, name = "index.html") {
   return `/editor/${encodeURIComponent(release)}/${encodeURIComponent(name)}`;
 }
@@ -17132,7 +17385,7 @@ function createGalleryEditorHandlers(opts = {}) {
       if (!status.installed) return null;
       let bytes;
       try {
-        bytes = await readFile25(path33.join(dir, name));
+        bytes = await readFile26(path34.join(dir, name));
       } catch {
         verified = null;
         return null;
@@ -17149,7 +17402,7 @@ function createGalleryEditorHandlers(opts = {}) {
 // src/gallery/server.ts
 import { randomBytes } from "crypto";
 import { createServer as createServer2 } from "http";
-import { readFile as readFile26 } from "fs/promises";
+import { readFile as readFile27 } from "fs/promises";
 var MAX_EDIT_BYTES = 48 * 1024 * 1024;
 var EDITOR_CSP = [
   "default-src 'self'",
@@ -17330,7 +17583,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 readFile26(asset.path);
+          const bytes = await readFile27(asset.path);
           res.writeHead(200, {
             "Content-Type": asset.contentType,
             "Cache-Control": "no-store",
@@ -17413,7 +17666,7 @@ async function serveGallery(opts) {
         if (!asset) return fail(404, "no such gallery media");
         let bytes;
         try {
-          bytes = await readFile26(asset.path);
+          bytes = await readFile27(asset.path);
         } catch {
           return fail(404, "gallery media is no longer on disk; refresh the page");
         }
@@ -17457,27 +17710,27 @@ async function serveGallery(opts) {
 
 // src/gallery/generate.ts
 import { randomBytes as randomBytes2 } from "crypto";
-import { z as z13 } from "zod";
-var GenerateRequestSchema = z13.object({
-  project: z13.string().min(1).optional(),
-  keys: z13.array(z13.string().min(1)).min(1).max(500),
+import { z as z14 } from "zod";
+var GenerateRequestSchema = z14.object({
+  project: z14.string().min(1).optional(),
+  keys: z14.array(z14.string().min(1)).min(1).max(500),
   /**
    * Regenerate work that is up to date, as `gen --force` does, and let the
    * fetch replace a locally modified or untracked file. With `restore`, put
    * the recorded bytes back over a modified file.
    */
-  force: z13.boolean().optional(),
+  force: z14.boolean().optional(),
   /** Advance in-flight, review, or selected work without submitting anything. */
-  resume: z13.boolean().optional(),
+  resume: z14.boolean().optional(),
   /** Re-download downloaded outputs and replace files whose object changed upstream. */
-  refresh: z13.boolean().optional(),
+  refresh: z14.boolean().optional(),
   /** Put recorded outputs back on disk from the cache or the provider, without generating. */
-  restore: z13.boolean().optional(),
+  restore: z14.boolean().optional(),
   /**
    * Bring a replaced generation back: 1-based position in the record's
    * history (newest first) or an output hash prefix. One key at a time.
    */
-  revert: z13.string().min(1).max(64).optional()
+  revert: z14.string().min(1).max(64).optional()
 }).strict().refine((request) => [request.resume, request.refresh, request.restore, request.revert !== void 0].filter(Boolean).length <= 1, {
   message: "resume, refresh, restore, and revert are exclusive"
 }).refine((request) => request.revert === void 0 || request.keys.length === 1, { message: "revert takes one key" });
@@ -17823,19 +18076,19 @@ function createGenerateHandlers(opts) {
 }
 
 // src/pipeline/salvage.ts
-import { readFile as readFile27 } from "fs/promises";
-import { existsSync as existsSync28 } from "fs";
-import path34 from "path";
+import { readFile as readFile28 } from "fs/promises";
+import { existsSync as existsSync29 } from "fs";
+import path35 from "path";
 function providerClaimId(provider, objectId) {
   return `${encodeURIComponent(provider)}:${encodeURIComponent(objectId)}`;
 }
 async function loadClaims(lockPaths, opts = {}) {
   const claimed = /* @__PURE__ */ new Set();
   for (const p of lockPaths) {
-    if (!existsSync28(p)) throw new Error(`Claim lockfile not found: ${p}`);
+    if (!existsSync29(p)) throw new Error(`Claim lockfile not found: ${p}`);
     let parsed;
     try {
-      parsed = parseLock(JSON.parse(await readFile27(p, "utf8")));
+      parsed = parseLock(JSON.parse(await readFile28(p, "utf8")));
     } catch {
       throw new Error(`Claim lockfile is malformed: ${p}`);
     }
@@ -17939,20 +18192,20 @@ function matchOrphanStyle(prompt, manifest) {
   return matchStyleByPattern(prompt, manifest);
 }
 async function loadSiblingManifests(ownManifestPath, workspaceManifestPaths, claimPaths) {
-  const own = path34.resolve(ownManifestPath);
+  const own = path35.resolve(ownManifestPath);
   const siblingManifestPaths = [
     .../* @__PURE__ */ new Set([
       ...workspaceManifestPaths,
-      ...claimPaths.map((c) => path34.join(path34.dirname(path34.resolve(c)), "pixelkiln.manifest.json"))
+      ...claimPaths.map((c) => path35.join(path35.dirname(path35.resolve(c)), "pixelkiln.manifest.json"))
     ])
   ];
   const siblings = [];
   for (const siblingManifestPath of siblingManifestPaths) {
-    if (path34.resolve(siblingManifestPath) === own) continue;
-    if (!existsSync28(siblingManifestPath)) continue;
+    if (path35.resolve(siblingManifestPath) === own) continue;
+    if (!existsSync29(siblingManifestPath)) continue;
     try {
       const { manifest } = await loadManifest(siblingManifestPath);
-      siblings.push({ label: path34.basename(path34.dirname(siblingManifestPath)), manifest });
+      siblings.push({ label: path35.basename(path35.dirname(siblingManifestPath)), manifest });
     } catch {
     }
   }
@@ -18072,8 +18325,8 @@ async function applyTags(provider, decisions, existing, opts = {}) {
 }
 
 // src/pick/salvage-server.ts
-import { mkdir as mkdir12, writeFile as writeFile16, readFile as readFile28 } from "fs/promises";
-import path35 from "path";
+import { mkdir as mkdir12, writeFile as writeFile17, readFile as readFile29 } from "fs/promises";
+import path36 from "path";
 
 // src/pick/salvage-sheet.ts
 var escapeHtml3 = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
@@ -18239,7 +18492,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
   });
   const html = renderSalvageSheet(orphans, {
     styleId: ctx.styleId,
-    importDir: path35.relative(process.cwd(), ctx.importDir) || "."
+    importDir: path36.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]));
@@ -18295,10 +18548,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 = path35.join("_salvaged", `${assetId}.png`);
-            const outFile = path35.resolve(ctx.importDir, rel);
-            await mkdir12(path35.dirname(outFile), { recursive: true });
-            await writeFile16(outFile, buf);
+            const rel = path36.join("_salvaged", `${assetId}.png`);
+            const outFile = path36.resolve(ctx.importDir, rel);
+            await mkdir12(path36.dirname(outFile), { recursive: true });
+            await writeFile17(outFile, buf);
             ctx.manifest.assets[assetId] = {
               prompt: orphan.prompt,
               promptByStyle: {},
@@ -18330,7 +18583,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
               sourceUrl: durableSource,
               sourceUrls: durableSource ? [{ url: durableSource }] : [],
               outputs: [{
-                path: portableOutputPath(outFile, path35.dirname(ctx.manifestPath)),
+                path: portableOutputPath(outFile, path36.dirname(ctx.manifestPath)),
                 sha256: sha256(buf)
               }],
               submittedAt: orphan.createdAt,
@@ -18354,9 +18607,9 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
         }
       }
       await applyTags(provider, decisions, existingTags, { onProgress: log, characters: characterMembers });
-      const raw = JSON.parse(await readFile28(ctx.manifestPath, "utf8"));
+      const raw = JSON.parse(await readFile29(ctx.manifestPath, "utf8"));
       for (const id of importedAssetIds) raw.assets[id] = ctx.manifest.assets[id];
-      await writeFile16(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
+      await writeFile17(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
       await saveLock(ctx.lockPath, ctx.lock);
       if (characterAssetIds.length) result.characterAssetIds = characterAssetIds;
       return result;