pixelkiln 0.82.0 → 0.84.0

package/dist/index.cjs

@@ -334,6 +334,7 @@ var RevisionModeSchema = import_zod.z.enum([
   "outpaint",
   "reduce-colors",
   "correct-pixelart",
+  "remove-background",
   "animate",
   "animate-pixminimax",
   "animate-skeleton",
@@ -665,7 +666,22 @@ var RevisionSchema = import_zod.z.object({
    * `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. */
+  /**
+   * `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: import_zod.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: import_zod.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: import_zod.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: import_zod.z.boolean().optional(),
@@ -685,12 +701,15 @@ var RevisionSchema = import_zod.z.object({
    * same `mannequin`/`bear`/`cat`/`dog`/`horse`/`lion` vocabulary.
    */
   skeletonTemplate: import_zod.z.string().min(1).optional(),
+  /** `remove-background` only: `simple` is faster and suits flat backgrounds; `complex` handles detailed edges. PixelLab defaults to `simple`. */
+  removalTask: import_zod.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: import_zod.z.string().min(1).optional(),
   /**
@@ -807,7 +826,44 @@ var RevisionSchema = import_zod.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: import_zod.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: import_zod.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: import_zod.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: import_zod.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: import_zod.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: import_zod.z.ZodIssueCode.custom,
@@ -1461,6 +1517,10 @@ var LockEntrySchema = import_zod.z.object({
     keypointsSha256: import_zod.z.string().regex(/^[0-9a-f]{64}$/).optional(),
     skeletonTemplate: import_zod.z.string().min(1).optional(),
     description: import_zod.z.string().min(1).optional(),
+    removalTask: import_zod.z.enum(["simple", "complex"]).optional(),
+    driftThreshold: import_zod.z.number().min(0).optional(),
+    subjectDescription: import_zod.z.string().min(1).max(300).optional(),
+    initialPose: import_zod.z.string().min(1).max(300).optional(),
     engine: import_zod.z.enum(["pro-flash"]).optional()
   }).strict().nullable().default(null),
   /** For a mirror: the asset it flips and a hash over that asset's output hashes when this was made. */
@@ -1889,6 +1949,7 @@ var CorrectPixelartResponseSchema = import_zod3.z.object({
   images: import_zod3.z.array(import_zod3.z.object({ base64: import_zod3.z.string().min(1) }).passthrough()).min(1),
   usage: import_zod3.z.unknown().optional()
 }).passthrough();
+var RemoveBackgroundResponseSchema = import_zod3.z.object({ image: import_zod3.z.object({ base64: import_zod3.z.string().min(1) }).passthrough(), usage: import_zod3.z.unknown().optional() }).passthrough();
 var ProFlashImageSubmitSchema = import_zod3.z.object({
   background_job_id: import_zod3.z.string().min(1),
   image_id: import_zod3.z.string().min(1),
@@ -2080,9 +2141,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,
@@ -2092,13 +2153,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() {
@@ -2503,10 +2564,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,
@@ -2520,7 +2581,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,
@@ -2544,7 +2605,7 @@ var PixelLabClient = class {
         } : {}
       };
     } else if (args.mode === "pro") {
-      path36 = "/create-character-pro";
+      path37 = "/create-character-pro";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -2558,7 +2619,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,
@@ -2575,8 +2636,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) {
@@ -2953,6 +3014,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.
@@ -3061,6 +3143,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;
@@ -3080,6 +3163,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;
@@ -3115,6 +3202,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;
@@ -3762,10 +3850,10 @@ var import_node_fs = require("fs");
 function sha256(data) {
   return (0, import_node_crypto.createHash)("sha256").update(data).digest("hex");
 }
-async function sha256File(path36) {
+async function sha256File(path37) {
   return new Promise((resolve, reject) => {
     const hash = (0, import_node_crypto.createHash)("sha256");
-    const stream = (0, import_node_fs.createReadStream)(path36);
+    const stream = (0, import_node_fs.createReadStream)(path37);
     stream.on("data", (chunk2) => hash.update(chunk2));
     stream.on("error", reject);
     stream.on("end", () => resolve(hash.digest("hex")));
@@ -3889,6 +3977,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
     })
@@ -4064,7 +4156,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,
@@ -4092,6 +4184,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 };
     }
@@ -4180,6 +4275,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)) {
@@ -4200,6 +4301,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`
@@ -5291,6 +5395,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`);
@@ -5326,7 +5442,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 };
       }
@@ -5338,7 +5455,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 };
     }
@@ -5355,6 +5476,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,
@@ -5425,7 +5549,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") {
@@ -6133,9 +6257,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",
@@ -9141,6 +9265,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 } : {}
         };
       }
@@ -12424,10 +12552,10 @@ function isSha256Hash(value) {
 function parseCache(value) {
   return HashCacheSchema.parse(value);
 }
-async function loadCache(path36) {
-  if (!(0, import_node_fs14.existsSync)(path36)) return { version: 1, hashes: {} };
+async function loadCache(path37) {
+  if (!(0, import_node_fs14.existsSync)(path37)) return { version: 1, hashes: {} };
   try {
-    const parsed = HashCacheSchema.safeParse(JSON.parse(await (0, import_promises11.readFile)(path36, "utf8")));
+    const parsed = HashCacheSchema.safeParse(JSON.parse(await (0, import_promises11.readFile)(path37, "utf8")));
     if (!parsed.success) return { version: 1, hashes: {} };
     return {
       version: 1,
@@ -12439,18 +12567,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 (0, import_promises11.mkdir)(import_node_path18.default.dirname(import_node_path18.default.resolve(path36)), { recursive: true });
-  const tmp = `${path36}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  await (0, import_promises11.mkdir)(import_node_path18.default.dirname(import_node_path18.default.resolve(path37)), { recursive: true });
+  const tmp = `${path37}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
     await (0, import_promises11.writeFile)(tmp, JSON.stringify({ version: 1, hashes: sorted }, null, 2) + "\n");
-    await (0, import_promises11.rename)(tmp, path36);
+    await (0, import_promises11.rename)(tmp, path37);
   } finally {
     await (0, import_promises11.rm)(tmp, { force: true });
   }
@@ -13966,6 +14094,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 ? {
@@ -15255,9 +15387,9 @@ async function runPicker(provider, lock, lockPath, opts = {}) {
 
 // src/gallery/snapshot.ts
 var import_node_crypto6 = require("crypto");
-var import_node_fs27 = require("fs");
-var import_promises25 = require("fs/promises");
-var import_node_path32 = __toESM(require("path"), 1);
+var import_node_fs28 = require("fs");
+var import_promises26 = require("fs/promises");
+var import_node_path33 = __toESM(require("path"), 1);
 
 // src/workspace.ts
 var import_promises19 = require("fs/promises");
@@ -15393,15 +15525,16 @@ function validateWorkspace(ws, dir) {
 }
 
 // src/gallery/edit.ts
-var import_promises24 = require("fs/promises");
-var import_node_path31 = __toESM(require("path"), 1);
-var import_zod12 = require("zod");
+var import_promises25 = require("fs/promises");
+var import_node_path32 = __toESM(require("path"), 1);
+var import_zod13 = require("zod");
 
 // src/manifest-edit.ts
 var import_promises20 = require("fs/promises");
 var import_node_path27 = __toESM(require("path"), 1);
 var import_zod8 = require("zod");
 var HexSha = import_zod8.z.string().regex(/^[0-9a-f]{64}$/);
+var ProjectFileSchema = import_zod8.z.string().min(1).refine((file) => !import_node_path27.default.isAbsolute(file) && !file.split(/[\\/]/).includes(".."), "must be a path inside the project");
 var AssetPatchSchema = import_zod8.z.object({
   prompt: import_zod8.z.string().optional(),
   /** Per-style override for the style being viewed; null removes it. */
@@ -15450,10 +15583,11 @@ var NewAssetSchema = import_zod8.z.object({
   styles: import_zod8.z.array(import_zod8.z.string().min(1)).optional(),
   /**
    * A controlled regeneration of another asset in the same manifest,
-   * instead of a fresh generation. `inpaint` needs a mask upload the
-   * gallery does not offer yet, so only `image-to-image` 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: import_zod8.z.discriminatedUnion("mode", [
     import_zod8.z.object({
@@ -15462,6 +15596,52 @@ var NewAssetSchema = import_zod8.z.object({
       from: import_zod8.z.string().min(1),
       strength: import_zod8.z.number().min(0).max(1).optional()
     }).strict(),
+    import_zod8.z.object({
+      mode: import_zod8.z.literal("reduce-colors"),
+      from: import_zod8.z.string().min(1),
+      /** A target colour count; the gallery leaves PixelLab's default when this is omitted. */
+      numColors: import_zod8.z.number().int().min(2).max(256).optional(),
+      dithering: RevisionDitheringSchema.optional(),
+      ditheringStrength: import_zod8.z.number().min(0).max(10).optional()
+    }).strict(),
+    import_zod8.z.object({
+      mode: import_zod8.z.literal("inpaint"),
+      from: import_zod8.z.string().min(1),
+      /** Black-and-white PNG the same size as the parent; white is repainted. */
+      mask: ProjectFileSchema
+    }).strict(),
+    import_zod8.z.object({
+      mode: import_zod8.z.literal("interpolate"),
+      from: import_zod8.z.string().min(1),
+      /** The ending keyframe: an image already in the project, the parent's size. */
+      lastFrame: ProjectFileSchema,
+      fps: import_zod8.z.number().int().min(1).max(60).optional()
+    }).strict(),
+    import_zod8.z.object({ mode: import_zod8.z.literal("correct-pixelart"), from: import_zod8.z.string().min(1), strength: import_zod8.z.number().min(0).max(1).optional() }).strict(),
+    import_zod8.z.object({
+      mode: import_zod8.z.literal("remove-background"),
+      from: import_zod8.z.string().min(1),
+      removalTask: import_zod8.z.enum(["simple", "complex"]).optional(),
+      /** A short description of the foreground, sent as PixelLab's text hint. */
+      description: import_zod8.z.string().min(1).optional()
+    }).strict(),
+    import_zod8.z.object({
+      mode: import_zod8.z.enum(["animate", "animate-pixminimax"]),
+      from: import_zod8.z.string().min(1),
+      frames: import_zod8.z.number().int().min(4).max(40).refine((n) => n % 2 === 0, "frames must be even").optional(),
+      fps: import_zod8.z.number().int().min(1).max(60).optional(),
+      enhancePrompt: import_zod8.z.boolean().optional(),
+      driftThreshold: import_zod8.z.number().min(0).optional(),
+      /** `animate-pixminimax` only; the loader refuses these on `animate`. */
+      direction: CharacterDirectionSchema.optional(),
+      subjectDescription: import_zod8.z.string().min(1).max(300).optional(),
+      initialPose: import_zod8.z.string().min(1).max(300).optional()
+    }).strict(),
+    import_zod8.z.object({
+      mode: import_zod8.z.literal("edit-animation"),
+      from: import_zod8.z.string().min(1),
+      fps: import_zod8.z.number().int().min(1).max(60).optional()
+    }).strict(),
     import_zod8.z.object({
       mode: import_zod8.z.literal("animate-skeleton"),
       from: import_zod8.z.string().min(1),
@@ -16106,62 +16286,118 @@ async function saveProjectImage(root, request) {
   return relative.split(import_node_path29.default.sep).join("/");
 }
 
-// src/gallery/skeleton.ts
+// src/gallery/image-revision.ts
 var import_node_fs26 = require("fs");
 var import_promises23 = require("fs/promises");
 var import_node_path30 = __toESM(require("path"), 1);
 var import_zod11 = require("zod");
-var SkeletonEstimateRequestSchema = import_zod11.z.object({
-  project: import_zod11.z.string().min(1).optional(),
-  styleId: import_zod11.z.string().min(1),
-  assetId: import_zod11.z.string().min(1),
-  frames: import_zod11.z.number().int().min(3).max(15).optional()
-}).strict();
-var SkeletonAnimationRequestSchema = import_zod11.z.object({
-  action: import_zod11.z.literal("create-skeleton-animation"),
+var InpaintRevisionRequestSchema = import_zod11.z.object({
+  action: import_zod11.z.literal("create-inpaint-revision"),
   project: import_zod11.z.string().min(1).optional(),
   expectedSha256: import_zod11.z.string().regex(/^[0-9a-f]{64}$/),
   styleId: import_zod11.z.string().min(1),
-  /** The sprite the animation poses. */
+  /** The sprite being repainted. */
   from: import_zod11.z.string().min(1),
   assetId: import_zod11.z.string().min(1).regex(/^[^/\\]+$/, "asset ids cannot contain slashes"),
-  /** The motion, sent as PixelLab's `action`. */
+  /** What to paint into the masked area. */
   prompt: import_zod11.z.string().min(1),
+  /** Manifest-relative `.png` destination for the mask. */
+  maskPath: import_zod11.z.string().min(1),
+  maskBase64: import_zod11.z.string().regex(/^[A-Za-z0-9+/]*={0,2}$/),
+  /** Replace a file already at `maskPath`. */
+  overwrite: import_zod11.z.boolean().optional()
+}).strict();
+async function createInpaintRevision(manifestPath, request) {
+  const root = import_node_path30.default.dirname(import_node_path30.default.resolve(manifestPath));
+  if (import_node_path30.default.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 = import_node_path30.default.resolve(root, request.maskPath);
+  const previous = (0, import_node_fs26.existsSync)(file) ? await (0, import_promises23.readFile)(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 (0, import_promises23.writeFile)(file, previous);
+    else await (0, import_promises23.rm)(file, { force: true });
+    throw error;
+  }
+  return mask;
+}
+
+// src/gallery/skeleton.ts
+var import_node_fs27 = require("fs");
+var import_promises24 = require("fs/promises");
+var import_node_path31 = __toESM(require("path"), 1);
+var import_zod12 = require("zod");
+var SkeletonEstimateRequestSchema = import_zod12.z.object({
+  project: import_zod12.z.string().min(1).optional(),
+  styleId: import_zod12.z.string().min(1),
+  assetId: import_zod12.z.string().min(1),
+  frames: import_zod12.z.number().int().min(3).max(15).optional()
+}).strict();
+var SkeletonAnimationRequestSchema = import_zod12.z.object({
+  action: import_zod12.z.literal("create-skeleton-animation"),
+  project: import_zod12.z.string().min(1).optional(),
+  expectedSha256: import_zod12.z.string().regex(/^[0-9a-f]{64}$/),
+  styleId: import_zod12.z.string().min(1),
+  /** The sprite the animation poses. */
+  from: import_zod12.z.string().min(1),
+  assetId: import_zod12.z.string().min(1).regex(/^[^/\\]+$/, "asset ids cannot contain slashes"),
+  /** The motion, sent as PixelLab's `action`. */
+  prompt: import_zod12.z.string().min(1),
   direction: CharacterDirectionSchema,
-  description: import_zod11.z.string().min(1).optional(),
-  skeletonTemplate: import_zod11.z.string().min(1).optional(),
+  description: import_zod12.z.string().min(1).optional(),
+  skeletonTemplate: import_zod12.z.string().min(1).optional(),
   /** Manifest-relative JSON path inside the project. */
-  keypointsFile: import_zod11.z.string().min(1),
+  keypointsFile: import_zod12.z.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: import_zod11.z.boolean().optional()
+  overwrite: import_zod12.z.boolean().optional()
 }).strict();
-var SkeletonKeypointsUpdateSchema = import_zod11.z.object({
-  action: import_zod11.z.literal("update-skeleton-keypoints"),
-  project: import_zod11.z.string().min(1).optional(),
-  styleId: import_zod11.z.string().min(1),
-  assetId: import_zod11.z.string().min(1),
+var SkeletonKeypointsUpdateSchema = import_zod12.z.object({
+  action: import_zod12.z.literal("update-skeleton-keypoints"),
+  project: import_zod12.z.string().min(1).optional(),
+  styleId: import_zod12.z.string().min(1),
+  assetId: import_zod12.z.string().min(1),
   /** The file's SHA-256 when the page loaded it; anything else on disk is a concurrent edit. */
-  expectedSha256: import_zod11.z.string().regex(/^[0-9a-f]{64}$/),
+  expectedSha256: import_zod12.z.string().regex(/^[0-9a-f]{64}$/),
   set: SkeletonSetSchema
 }).strict();
 async function createSkeletonAnimation(manifestPath, request) {
-  const root = import_node_path30.default.dirname(import_node_path30.default.resolve(manifestPath));
-  const file = import_node_path30.default.resolve(root, request.keypointsFile);
-  const relative = import_node_path30.default.relative(root, file);
-  if (!request.keypointsFile.endsWith(".json") || relative.startsWith("..") || import_node_path30.default.isAbsolute(relative)) {
+  const root = import_node_path31.default.dirname(import_node_path31.default.resolve(manifestPath));
+  const file = import_node_path31.default.resolve(root, request.keypointsFile);
+  const relative = import_node_path31.default.relative(root, file);
+  if (!request.keypointsFile.endsWith(".json") || relative.startsWith("..") || import_node_path31.default.isAbsolute(relative)) {
     throw new ManifestEditError("the keypoints file must be a .json path inside the project");
   }
-  const existed = (0, import_node_fs26.existsSync)(file);
+  const existed = (0, import_node_fs27.existsSync)(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 (0, import_promises23.readFile)(file);
-    await (0, import_promises23.mkdir)(import_node_path30.default.dirname(file), { recursive: true });
-    await (0, import_promises23.writeFile)(file, JSON.stringify(request.set, null, 2) + "\n");
+    if (existed) previous = await (0, import_promises24.readFile)(file);
+    await (0, import_promises24.mkdir)(import_node_path31.default.dirname(file), { recursive: true });
+    await (0, import_promises24.writeFile)(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`);
   }
@@ -16176,7 +16412,7 @@ async function createSkeletonAnimation(manifestPath, request) {
         revision: {
           mode: "animate-skeleton",
           from: request.from,
-          keypointsFile: relative.split(import_node_path30.default.sep).join("/"),
+          keypointsFile: relative.split(import_node_path31.default.sep).join("/"),
           direction: request.direction,
           ...request.description ? { description: request.description } : {},
           ...request.skeletonTemplate ? { skeletonTemplate: request.skeletonTemplate } : {}
@@ -16185,8 +16421,8 @@ async function createSkeletonAnimation(manifestPath, request) {
     });
   } catch (error) {
     if (request.set) {
-      if (previous) await (0, import_promises23.writeFile)(file, previous);
-      else await (0, import_promises23.rm)(file, { force: true });
+      if (previous) await (0, import_promises24.writeFile)(file, previous);
+      else await (0, import_promises24.rm)(file, { force: true });
     }
     throw error;
   }
@@ -16197,64 +16433,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 = import_node_path30.default.relative(ctx.loaded.root, file);
-  if (relative.startsWith("..") || import_node_path30.default.isAbsolute(relative)) {
+  const relative = import_node_path31.default.relative(ctx.loaded.root, file);
+  if (relative.startsWith("..") || import_node_path31.default.isAbsolute(relative)) {
     throw new ManifestEditError(`${key}'s keypoints file is outside the project; edit it by hand`);
   }
-  const current = (0, import_node_fs26.existsSync)(file) ? sha256(await (0, import_promises23.readFile)(file)) : null;
+  const current = (0, import_node_fs27.existsSync)(file) ? sha256(await (0, import_promises24.readFile)(file)) : null;
   if (current !== request.expectedSha256) {
     throw Object.assign(
-      new Error(`${relative.split(import_node_path30.default.sep).join("/")} changed on disk since this page loaded it; press Refresh and edit again`),
+      new Error(`${relative.split(import_node_path31.default.sep).join("/")} changed on disk since this page loaded it; press Refresh and edit again`),
       { status: 409 }
     );
   }
-  await (0, import_promises23.writeFile)(file, JSON.stringify(request.set, null, 2) + "\n");
-  return relative.split(import_node_path30.default.sep).join("/");
+  await (0, import_promises24.writeFile)(file, JSON.stringify(request.set, null, 2) + "\n");
+  return relative.split(import_node_path31.default.sep).join("/");
 }
 
 // src/gallery/edit.ts
-var Base64 = import_zod12.z.string().regex(/^[A-Za-z0-9+/]*={0,2}$/).max(Math.ceil(MAX_HAND_EDIT_BYTES / 3) * 4);
-var HandEditRequestSchema = import_zod12.z.discriminatedUnion("action", [
-  import_zod12.z.object({
-    action: import_zod12.z.literal("start-edit"),
-    project: import_zod12.z.string().min(1).optional(),
-    assetId: import_zod12.z.string().min(1),
-    styleId: import_zod12.z.string().min(1),
-    expectedSha256: import_zod12.z.string().regex(/^[0-9a-f]{64}$/),
+var Base64 = import_zod13.z.string().regex(/^[A-Za-z0-9+/]*={0,2}$/).max(Math.ceil(MAX_HAND_EDIT_BYTES / 3) * 4);
+var HandEditRequestSchema = import_zod13.z.discriminatedUnion("action", [
+  import_zod13.z.object({
+    action: import_zod13.z.literal("start-edit"),
+    project: import_zod13.z.string().min(1).optional(),
+    assetId: import_zod13.z.string().min(1),
+    styleId: import_zod13.z.string().min(1),
+    expectedSha256: import_zod13.z.string().regex(/^[0-9a-f]{64}$/),
     /** Also launch the author's editor on the file. */
-    open: import_zod12.z.boolean().optional()
+    open: import_zod13.z.boolean().optional()
   }).strict(),
-  import_zod12.z.object({
-    action: import_zod12.z.literal("detach-edit"),
-    project: import_zod12.z.string().min(1).optional(),
-    assetId: import_zod12.z.string().min(1),
-    styleId: import_zod12.z.string().min(1),
-    expectedSha256: import_zod12.z.string().regex(/^[0-9a-f]{64}$/)
+  import_zod13.z.object({
+    action: import_zod13.z.literal("detach-edit"),
+    project: import_zod13.z.string().min(1).optional(),
+    assetId: import_zod13.z.string().min(1),
+    styleId: import_zod13.z.string().min(1),
+    expectedSha256: import_zod13.z.string().regex(/^[0-9a-f]{64}$/)
   }).strict(),
   /** From the in-browser editor: the page holds the bytes, the server validates and writes. */
-  import_zod12.z.object({
-    action: import_zod12.z.literal("save-edit"),
-    project: import_zod12.z.string().min(1).optional(),
-    assetId: import_zod12.z.string().min(1),
-    styleId: import_zod12.z.string().min(1),
-    expectedSha256: import_zod12.z.string().regex(/^[0-9a-f]{64}$/),
+  import_zod13.z.object({
+    action: import_zod13.z.literal("save-edit"),
+    project: import_zod13.z.string().min(1).optional(),
+    assetId: import_zod13.z.string().min(1),
+    styleId: import_zod13.z.string().min(1),
+    expectedSha256: import_zod13.z.string().regex(/^[0-9a-f]{64}$/),
     /** The flattened image; for a frame set, `frames` instead. */
     png: Base64.min(1).optional(),
     /** Every frame of a set, tagged with the role it was opened under (null for one added in the editor). */
-    frames: import_zod12.z.array(import_zod12.z.object({ role: import_zod12.z.string().min(1).nullable(), png: Base64.min(1) }).strict()).min(1).max(256).optional(),
+    frames: import_zod13.z.array(import_zod13.z.object({ role: import_zod13.z.string().min(1).nullable(), png: Base64.min(1) }).strict()).min(1).max(256).optional(),
     /** The editor's layered project file, kept beside the edit. */
     pxo: Base64.optional(),
     /** Editor identity from the bridge's ready message. */
-    editor: import_zod12.z.string().min(1).max(200),
-    protocol: import_zod12.z.number().int().positive()
+    editor: import_zod13.z.string().min(1).max(200),
+    protocol: import_zod13.z.number().int().positive()
   }).strict()
 ]);
 var UNDO_DEPTH = 20;
-var UndoRequestSchema = import_zod12.z.object({
-  action: import_zod12.z.literal("undo-edit"),
-  project: import_zod12.z.string().min(1).optional(),
+var UndoRequestSchema = import_zod13.z.object({
+  action: import_zod13.z.literal("undo-edit"),
+  project: import_zod13.z.string().min(1).optional(),
   /** The manifest as the page last saw it; undo refuses a manifest someone else has changed since. */
-  expectedSha256: import_zod12.z.string().regex(/^[0-9a-f]{64}$/)
+  expectedSha256: import_zod13.z.string().regex(/^[0-9a-f]{64}$/)
 }).strict();
 function createGalleryEditHandler(opts) {
   const log = opts.onProgress ?? (() => {
@@ -16263,7 +16499,7 @@ function createGalleryEditHandler(opts) {
   const history = /* @__PURE__ */ new Map();
   const manifestOf = async (project) => {
     try {
-      return import_node_path31.default.resolve(await opts.manifestFor(typeof project === "string" ? project : void 0));
+      return import_node_path32.default.resolve(await opts.manifestFor(typeof project === "string" ? project : void 0));
     } catch {
       return null;
     }
@@ -16273,7 +16509,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 (0, import_promises24.readFile)(manifestPath2, "utf8");
+      const current = await (0, import_promises25.readFile)(manifestPath2, "utf8");
       if (sha256(current) !== undo.data.expectedSha256) throw new ManifestDriftError(manifestPath2);
       const stack = history.get(manifestPath2) ?? [];
       const last = stack[stack.length - 1];
@@ -16283,17 +16519,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 (0, import_promises24.writeFile)(tmp, last.before);
-      await (0, import_promises24.rename)(tmp, manifestPath2);
+      await (0, import_promises25.writeFile)(tmp, last.before);
+      await (0, import_promises25.rename)(tmp, manifestPath2);
       stack.pop();
-      log(`  manifest edit undone in ${import_node_path31.default.relative(process.cwd(), manifestPath2) || manifestPath2}`);
+      log(`  manifest edit undone in ${import_node_path32.default.relative(process.cwd(), manifestPath2) || manifestPath2}`);
       return opts.reload();
     }
     const manifestPath = await manifestOf(body?.project);
-    const before = manifestPath ? await (0, import_promises24.readFile)(manifestPath, "utf8").catch(() => null) : null;
+    const before = manifestPath ? await (0, import_promises25.readFile)(manifestPath, "utf8").catch(() => null) : null;
     const build = await apply(body);
     if (manifestPath && before !== null) {
-      const after = await (0, import_promises24.readFile)(manifestPath, "utf8").catch(() => null);
+      const after = await (0, import_promises25.readFile)(manifestPath, "utf8").catch(() => null);
       if (after !== null && after !== before) {
         const stack = history.get(manifestPath) ?? [];
         stack.push({ before, afterSha: sha256(after) });
@@ -16348,7 +16584,7 @@ function createEditApplier(opts, log) {
       } catch (error) {
         throw new ManifestEditError(error instanceof Error ? error.message : String(error));
       }
-      const written = await saveProjectImage(import_node_path31.default.dirname(import_node_path31.default.resolve(manifestPath2)), upload.data);
+      const written = await saveProjectImage(import_node_path32.default.dirname(import_node_path32.default.resolve(manifestPath2)), upload.data);
       log(`  image added: ${written}`);
       return opts.reload();
     }
@@ -16384,6 +16620,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(
@@ -16398,7 +16651,7 @@ function createEditApplier(opts, log) {
     }
     const result = await applyManifestEdit(manifestPath, parsed.data);
     if (result.changed) {
-      const relative = import_node_path31.default.relative(process.cwd(), result.manifestPath);
+      const relative = import_node_path32.default.relative(process.cwd(), result.manifestPath);
       const shown = !relative || relative.startsWith("..") ? result.manifestPath : relative;
       log(`  manifest edited: ${describeEdit(parsed.data)} in ${shown}`);
     }
@@ -16426,7 +16679,7 @@ function describeEdit(edit) {
 // src/gallery/snapshot.ts
 var PROJECT_FILE_TYPE = "application/octet-stream";
 function galleryMediaId(absolutePath) {
-  return (0, import_node_crypto6.createHash)("sha256").update(import_node_path32.default.resolve(absolutePath)).digest("hex").slice(0, 24);
+  return (0, import_node_crypto6.createHash)("sha256").update(import_node_path33.default.resolve(absolutePath)).digest("hex").slice(0, 24);
 }
 function galleryMediaRoute(id) {
   return `/media/${id}`;
@@ -16445,9 +16698,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_path32.default.join(cacheDir, cacheFileName(output.sha256, mediaType));
+      const file = import_node_path33.default.join(cacheDir, cacheFileName(output.sha256, mediaType));
       let url = null;
-      if ((0, import_node_fs27.existsSync)(file)) {
+      if ((0, import_node_fs28.existsSync)(file)) {
         const id = galleryMediaId(file);
         media.set(id, { path: file, contentType: mediaType });
         url = `${galleryMediaRoute(id)}?v=${output.sha256.slice(0, 24)}`;
@@ -16479,7 +16732,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_promises25.readFile)(a), (0, import_promises25.readFile)(b)]);
+    const [left, right] = await Promise.all([(0, import_promises26.readFile)(a), (0, import_promises26.readFile)(b)]);
     if (left.length > MAX_COMPARED_BYTES || right.length > MAX_COMPARED_BYTES) return false;
     const x = decodePng(left);
     const y = decodePng(right);
@@ -16545,7 +16798,7 @@ function describeCharacter(spec, entry) {
 }
 async function fileInfo(absolutePath) {
   try {
-    const info = await (0, import_promises25.stat)(absolutePath);
+    const info = await (0, import_promises26.stat)(absolutePath);
     return info.isFile() ? { bytes: info.size, modifiedAt: info.mtime.toISOString() } : null;
   } catch {
     return null;
@@ -16577,10 +16830,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_path32.default.resolve(root, file)))
+    outputPaths.map((file) => describeOutput(media, root, import_node_path33.default.resolve(root, file)))
   );
-  const recordPath = import_node_path32.default.resolve(root, inspection.record);
-  const recordExists = (0, import_node_fs27.existsSync)(recordPath);
+  const recordPath = import_node_path33.default.resolve(root, inspection.record);
+  const recordExists = (0, import_node_fs28.existsSync)(recordPath);
   let options = null;
   let check = null;
   if (recordExists) {
@@ -16599,7 +16852,7 @@ async function describeQuality(media, root, inspection) {
   return {
     state: inspection.state,
     reason: inspection.reason,
-    output: portableOutputPath(import_node_path32.default.resolve(root, inspection.output), root),
+    output: portableOutputPath(import_node_path33.default.resolve(root, inspection.output), root),
     record: portableOutputPath(recordPath, root),
     recordExists,
     outputs,
@@ -16637,9 +16890,9 @@ async function buildGallerySnapshot(opts) {
   const media = /* @__PURE__ */ new Map();
   const plan = await buildPlan(specs, lock);
   const items = [];
-  const manifestText = await (0, import_promises25.readFile)(loaded.path, "utf8");
+  const manifestText = await (0, import_promises26.readFile)(loaded.path, "utf8");
   const manifestSha256 = sha256(manifestText);
-  const cacheDir = import_node_path32.default.resolve(import_node_path32.default.dirname(opts.lockPath), ".pixelkiln", "cache");
+  const cacheDir = import_node_path33.default.resolve(import_node_path33.default.dirname(opts.lockPath), ".pixelkiln", "cache");
   let rawStyles = {};
   try {
     const raw = JSON.parse(manifestText);
@@ -16663,12 +16916,12 @@ async function buildGallerySnapshot(opts) {
         )
       );
       if (spec.source) {
-        const editPath = import_node_path32.default.resolve(root, spec.source);
+        const editPath = import_node_path33.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_fs27.existsSync)(file) ? await sha256File(file) : null };
+            return { file, sha256: (0, import_node_fs28.existsSync)(file) ? await sha256File(file) : null };
           })
         );
         edits = await Promise.all(editShas.map(({ file, sha256: editSha }) => describeOutput(media, root, file, { sha256: editSha })));
@@ -16676,7 +16929,7 @@ async function buildGallerySnapshot(opts) {
         const companion = await readHandEditCompanion(editPath);
         if (companion) {
           const projectPath = handEditProjectPath(editPath);
-          const project = companion.project && (0, import_node_fs27.existsSync)(projectPath) ? await fileInfo(projectPath) : null;
+          const project = companion.project && (0, import_node_fs28.existsSync)(projectPath) ? await fileInfo(projectPath) : null;
           let projectUrl = null;
           if (project) {
             const id = galleryMediaId(projectPath);
@@ -16712,8 +16965,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_path32.default.resolve(root, spec.source))];
-    } else if (!entry && (0, import_node_fs27.existsSync)(spec.outFile)) {
+      outputs = [await describeOutput(media, root, import_node_path33.default.resolve(root, spec.source))];
+    } else if (!entry && (0, import_node_fs28.existsSync)(spec.outFile)) {
       outputs = [await describeOutput(media, root, spec.outFile)];
     } else {
       outputs = [];
@@ -16916,7 +17169,7 @@ async function buildGallerySnapshot(opts) {
       id: loaded.manifest.name,
       name: loaded.manifest.name,
       manifest: loaded.path,
-      lock: import_node_path32.default.resolve(opts.lockPath),
+      lock: import_node_path33.default.resolve(opts.lockPath),
       root,
       provider: loaded.manifest.provider,
       account: null,
@@ -16942,7 +17195,7 @@ async function buildGallerySnapshot(opts) {
   return { snapshot, media };
 }
 async function buildWorkspaceGallerySnapshot(opts) {
-  const dir = import_node_path32.default.dirname(import_node_path32.default.resolve(opts.workspacePath));
+  const dir = import_node_path33.default.dirname(import_node_path33.default.resolve(opts.workspacePath));
   const media = /* @__PURE__ */ new Map();
   const projects = [];
   const items = [];
@@ -16985,11 +17238,11 @@ async function buildWorkspaceGallerySnapshot(opts) {
         id: project.id,
         name: loaded.manifest.name,
         manifest: manifestPath,
-        lock: import_node_path32.default.resolve(lockPath),
+        lock: import_node_path33.default.resolve(lockPath),
         root: loaded.root,
         provider: loaded.manifest.provider,
         account: project.account ?? null,
-        manifestSha256: manifestSha256 ?? sha256(await (0, import_promises25.readFile)(manifestPath, "utf8")),
+        manifestSha256: manifestSha256 ?? sha256(await (0, import_promises26.readFile)(manifestPath, "utf8")),
         historyLimit: historyLimit(loaded.manifest),
         entries: Object.keys(lock.entries).length,
         items: projectItems.length,
@@ -17001,8 +17254,8 @@ async function buildWorkspaceGallerySnapshot(opts) {
         id: project.id,
         name: project.id,
         manifest: manifestPath,
-        lock: import_node_path32.default.resolve(lockPath),
-        root: import_node_path32.default.dirname(manifestPath),
+        lock: import_node_path33.default.resolve(lockPath),
+        root: import_node_path33.default.dirname(manifestPath),
         provider: project.provider,
         account: project.account ?? null,
         manifestSha256: null,
@@ -17029,7 +17282,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
       version: 1,
       generatedAt: (opts.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
       project: null,
-      workspace: { path: import_node_path32.default.resolve(opts.workspacePath), dir, projects },
+      workspace: { path: import_node_path33.default.resolve(opts.workspacePath), dir, projects },
       filter,
       totals: {
         entries: projects.reduce((sum, project) => sum + project.entries, 0),
@@ -17046,7 +17299,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
 }
 
 // src/gallery/page.ts
-var import_node_fs28 = require("fs");
+var import_node_fs29 = require("fs");
 
 // src/gallery/client-bundle.ts
 var import_node_module = require("module");
@@ -17086,8 +17339,8 @@ var client;
 function clientAssets() {
   const prebuilt = new URL("gallery.js", CLIENT_DIR);
   client ??= {
-    css: (0, import_node_fs28.readFileSync)(new URL("gallery.css", CLIENT_DIR), "utf8"),
-    js: (0, import_node_fs28.existsSync)(prebuilt) ? (0, import_node_fs28.readFileSync)(prebuilt, "utf8") : bundleGalleryClient()
+    css: (0, import_node_fs29.readFileSync)(new URL("gallery.css", CLIENT_DIR), "utf8"),
+    js: (0, import_node_fs29.existsSync)(prebuilt) ? (0, import_node_fs29.readFileSync)(prebuilt, "utf8") : bundleGalleryClient()
   };
   return client;
 }
@@ -17230,10 +17483,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_fs29 = require("fs");
-var import_promises26 = require("fs/promises");
+var import_node_fs30 = require("fs");
+var import_promises27 = require("fs/promises");
 var import_node_os3 = __toESM(require("os"), 1);
-var import_node_path33 = __toESM(require("path"), 1);
+var import_node_path34 = __toESM(require("path"), 1);
 var EditorInstallError = class extends Error {
   constructor(message6, file) {
     super(message6);
@@ -17244,15 +17497,15 @@ var EditorInstallError = class extends Error {
 };
 function editorToolsRoot() {
   const override = process.env.PIXELKILN_TOOLS_DIR?.trim();
-  if (override) return import_node_path33.default.resolve(override);
-  if (process.platform === "darwin") return import_node_path33.default.join(import_node_os3.default.homedir(), "Library", "Caches", "pixelkiln", "tools");
+  if (override) return import_node_path34.default.resolve(override);
+  if (process.platform === "darwin") return import_node_path34.default.join(import_node_os3.default.homedir(), "Library", "Caches", "pixelkiln", "tools");
   if (process.platform === "win32") {
-    return import_node_path33.default.join(process.env.LOCALAPPDATA ?? import_node_path33.default.join(import_node_os3.default.homedir(), "AppData", "Local"), "pixelkiln", "tools");
+    return import_node_path34.default.join(process.env.LOCALAPPDATA ?? import_node_path34.default.join(import_node_os3.default.homedir(), "AppData", "Local"), "pixelkiln", "tools");
   }
-  return import_node_path33.default.join(process.env.XDG_CACHE_HOME ?? import_node_path33.default.join(import_node_os3.default.homedir(), ".cache"), "pixelkiln", "tools");
+  return import_node_path34.default.join(process.env.XDG_CACHE_HOME ?? import_node_path34.default.join(import_node_os3.default.homedir(), ".cache"), "pixelkiln", "tools");
 }
 function editorDir(pin = EDITOR_PIN, root = editorToolsRoot()) {
-  return import_node_path33.default.join(root, "pixelorama", pin.release ?? "unpublished");
+  return import_node_path34.default.join(root, "pixelorama", pin.release ?? "unpublished");
 }
 function editorBaseUrl(pin = EDITOR_PIN) {
   const override = process.env.PIXELKILN_EDITOR_URL?.trim();
@@ -17262,7 +17515,7 @@ function editorBaseUrl(pin = EDITOR_PIN) {
 }
 async function sha256Of(file) {
   try {
-    return (0, import_node_crypto7.createHash)("sha256").update(await (0, import_promises26.readFile)(file)).digest("hex");
+    return (0, import_node_crypto7.createHash)("sha256").update(await (0, import_promises27.readFile)(file)).digest("hex");
   } catch {
     return null;
   }
@@ -17275,8 +17528,8 @@ async function editorStatus(opts = {}) {
   let totalBytes = 0;
   for (const [name, expected] of Object.entries(pin.files)) {
     totalBytes += expected.bytes;
-    const file = import_node_path33.default.join(dir, name);
-    const info = (0, import_node_fs29.existsSync)(file) ? await (0, import_promises26.stat)(file).catch(() => null) : null;
+    const file = import_node_path34.default.join(dir, name);
+    const info = (0, import_node_fs30.existsSync)(file) ? await (0, import_promises27.stat)(file).catch(() => null) : null;
     if (info && info.size === expected.bytes && await sha256Of(file) === expected.sha256) {
       installedBytes += expected.bytes;
     } else {
@@ -17305,7 +17558,7 @@ async function installEditor(opts = {}) {
     );
   }
   if (!baseUrl) throw new EditorInstallError("no download location for the editor build");
-  await (0, import_promises26.mkdir)(dir, { recursive: true });
+  await (0, import_promises27.mkdir)(dir, { recursive: true });
   const downloaded = [];
   const skipped = Object.keys(pin.files).filter((name) => !before.missing.includes(name));
   let fetchedBytes = before.installedBytes;
@@ -17333,13 +17586,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_path33.default.join(dir, name);
+    const final = import_node_path34.default.join(dir, name);
     const tmp = `${final}.${process.pid}.part`;
     try {
-      await (0, import_promises26.writeFile)(tmp, bytes);
-      await (0, import_promises26.rename)(tmp, final);
+      await (0, import_promises27.writeFile)(tmp, bytes);
+      await (0, import_promises27.rename)(tmp, final);
     } finally {
-      await (0, import_promises26.rm)(tmp, { force: true });
+      await (0, import_promises27.rm)(tmp, { force: true });
     }
     fetchedBytes += bytes.length;
     downloaded.push(name);
@@ -17379,12 +17632,12 @@ var EDITOR_CONTENT_TYPES = {
   ".json": "application/json; charset=utf-8"
 };
 function editorContentType(name) {
-  return EDITOR_CONTENT_TYPES[import_node_path33.default.extname(name).toLowerCase()] ?? null;
+  return EDITOR_CONTENT_TYPES[import_node_path34.default.extname(name).toLowerCase()] ?? null;
 }
 
 // src/gallery/editor.ts
-var import_promises27 = require("fs/promises");
-var import_node_path34 = __toESM(require("path"), 1);
+var import_promises28 = require("fs/promises");
+var import_node_path35 = __toESM(require("path"), 1);
 function editorRoute(release, name = "index.html") {
   return `/editor/${encodeURIComponent(release)}/${encodeURIComponent(name)}`;
 }
@@ -17457,7 +17710,7 @@ function createGalleryEditorHandlers(opts = {}) {
       if (!status.installed) return null;
       let bytes;
       try {
-        bytes = await (0, import_promises27.readFile)(import_node_path34.default.join(dir, name));
+        bytes = await (0, import_promises28.readFile)(import_node_path35.default.join(dir, name));
       } catch {
         verified = null;
         return null;
@@ -17474,7 +17727,7 @@ function createGalleryEditorHandlers(opts = {}) {
 // src/gallery/server.ts
 var import_node_crypto8 = require("crypto");
 var import_node_http2 = require("http");
-var import_promises28 = require("fs/promises");
+var import_promises29 = require("fs/promises");
 var MAX_EDIT_BYTES = 48 * 1024 * 1024;
 var EDITOR_CSP = [
   "default-src 'self'",
@@ -17655,7 +17908,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_promises28.readFile)(asset.path);
+          const bytes = await (0, import_promises29.readFile)(asset.path);
           res.writeHead(200, {
             "Content-Type": asset.contentType,
             "Cache-Control": "no-store",
@@ -17738,7 +17991,7 @@ async function serveGallery(opts) {
         if (!asset) return fail(404, "no such gallery media");
         let bytes;
         try {
-          bytes = await (0, import_promises28.readFile)(asset.path);
+          bytes = await (0, import_promises29.readFile)(asset.path);
         } catch {
           return fail(404, "gallery media is no longer on disk; refresh the page");
         }
@@ -17782,27 +18035,27 @@ async function serveGallery(opts) {
 
 // src/gallery/generate.ts
 var import_node_crypto9 = require("crypto");
-var import_zod13 = require("zod");
-var GenerateRequestSchema = import_zod13.z.object({
-  project: import_zod13.z.string().min(1).optional(),
-  keys: import_zod13.z.array(import_zod13.z.string().min(1)).min(1).max(500),
+var import_zod14 = require("zod");
+var GenerateRequestSchema = import_zod14.z.object({
+  project: import_zod14.z.string().min(1).optional(),
+  keys: import_zod14.z.array(import_zod14.z.string().min(1)).min(1).max(500),
   /**
    * Regenerate work that is up to date, as `gen --force` does, and let the
    * fetch replace a locally modified or untracked file. With `restore`, put
    * the recorded bytes back over a modified file.
    */
-  force: import_zod13.z.boolean().optional(),
+  force: import_zod14.z.boolean().optional(),
   /** Advance in-flight, review, or selected work without submitting anything. */
-  resume: import_zod13.z.boolean().optional(),
+  resume: import_zod14.z.boolean().optional(),
   /** Re-download downloaded outputs and replace files whose object changed upstream. */
-  refresh: import_zod13.z.boolean().optional(),
+  refresh: import_zod14.z.boolean().optional(),
   /** Put recorded outputs back on disk from the cache or the provider, without generating. */
-  restore: import_zod13.z.boolean().optional(),
+  restore: import_zod14.z.boolean().optional(),
   /**
    * Bring a replaced generation back: 1-based position in the record's
    * history (newest first) or an output hash prefix. One key at a time.
    */
-  revert: import_zod13.z.string().min(1).max(64).optional()
+  revert: import_zod14.z.string().min(1).max(64).optional()
 }).strict().refine((request) => [request.resume, request.refresh, request.restore, request.revert !== void 0].filter(Boolean).length <= 1, {
   message: "resume, refresh, restore, and revert are exclusive"
 }).refine((request) => request.revert === void 0 || request.keys.length === 1, { message: "revert takes one key" });
@@ -18148,19 +18401,19 @@ function createGenerateHandlers(opts) {
 }
 
 // src/pipeline/salvage.ts
-var import_promises29 = require("fs/promises");
-var import_node_fs30 = require("fs");
-var import_node_path35 = __toESM(require("path"), 1);
+var import_promises30 = require("fs/promises");
+var import_node_fs31 = require("fs");
+var import_node_path36 = __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_fs30.existsSync)(p)) throw new Error(`Claim lockfile not found: ${p}`);
+    if (!(0, import_node_fs31.existsSync)(p)) throw new Error(`Claim lockfile not found: ${p}`);
     let parsed;
     try {
-      parsed = parseLock(JSON.parse(await (0, import_promises29.readFile)(p, "utf8")));
+      parsed = parseLock(JSON.parse(await (0, import_promises30.readFile)(p, "utf8")));
     } catch {
       throw new Error(`Claim lockfile is malformed: ${p}`);
     }
@@ -18264,20 +18517,20 @@ function matchOrphanStyle(prompt, manifest) {
   return matchStyleByPattern(prompt, manifest);
 }
 async function loadSiblingManifests(ownManifestPath, workspaceManifestPaths, claimPaths) {
-  const own = import_node_path35.default.resolve(ownManifestPath);
+  const own = import_node_path36.default.resolve(ownManifestPath);
   const siblingManifestPaths = [
     .../* @__PURE__ */ new Set([
       ...workspaceManifestPaths,
-      ...claimPaths.map((c) => import_node_path35.default.join(import_node_path35.default.dirname(import_node_path35.default.resolve(c)), "pixelkiln.manifest.json"))
+      ...claimPaths.map((c) => import_node_path36.default.join(import_node_path36.default.dirname(import_node_path36.default.resolve(c)), "pixelkiln.manifest.json"))
     ])
   ];
   const siblings = [];
   for (const siblingManifestPath of siblingManifestPaths) {
-    if (import_node_path35.default.resolve(siblingManifestPath) === own) continue;
-    if (!(0, import_node_fs30.existsSync)(siblingManifestPath)) continue;
+    if (import_node_path36.default.resolve(siblingManifestPath) === own) continue;
+    if (!(0, import_node_fs31.existsSync)(siblingManifestPath)) continue;
     try {
       const { manifest } = await loadManifest(siblingManifestPath);
-      siblings.push({ label: import_node_path35.default.basename(import_node_path35.default.dirname(siblingManifestPath)), manifest });
+      siblings.push({ label: import_node_path36.default.basename(import_node_path36.default.dirname(siblingManifestPath)), manifest });
     } catch {
     }
   }
@@ -18397,8 +18650,8 @@ async function applyTags(provider, decisions, existing, opts = {}) {
 }
 
 // src/pick/salvage-server.ts
-var import_promises30 = require("fs/promises");
-var import_node_path36 = __toESM(require("path"), 1);
+var import_promises31 = require("fs/promises");
+var import_node_path37 = __toESM(require("path"), 1);
 
 // src/pick/salvage-sheet.ts
 var escapeHtml3 = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
@@ -18564,7 +18817,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
   });
   const html = renderSalvageSheet(orphans, {
     styleId: ctx.styleId,
-    importDir: import_node_path36.default.relative(process.cwd(), ctx.importDir) || "."
+    importDir: import_node_path37.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]));
@@ -18620,10 +18873,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_path36.default.join("_salvaged", `${assetId}.png`);
-            const outFile = import_node_path36.default.resolve(ctx.importDir, rel);
-            await (0, import_promises30.mkdir)(import_node_path36.default.dirname(outFile), { recursive: true });
-            await (0, import_promises30.writeFile)(outFile, buf);
+            const rel = import_node_path37.default.join("_salvaged", `${assetId}.png`);
+            const outFile = import_node_path37.default.resolve(ctx.importDir, rel);
+            await (0, import_promises31.mkdir)(import_node_path37.default.dirname(outFile), { recursive: true });
+            await (0, import_promises31.writeFile)(outFile, buf);
             ctx.manifest.assets[assetId] = {
               prompt: orphan.prompt,
               promptByStyle: {},
@@ -18655,7 +18908,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
               sourceUrl: durableSource,
               sourceUrls: durableSource ? [{ url: durableSource }] : [],
               outputs: [{
-                path: portableOutputPath(outFile, import_node_path36.default.dirname(ctx.manifestPath)),
+                path: portableOutputPath(outFile, import_node_path37.default.dirname(ctx.manifestPath)),
                 sha256: sha256(buf)
               }],
               submittedAt: orphan.createdAt,
@@ -18679,9 +18932,9 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
         }
       }
       await applyTags(provider, decisions, existingTags, { onProgress: log, characters: characterMembers });
-      const raw = JSON.parse(await (0, import_promises30.readFile)(ctx.manifestPath, "utf8"));
+      const raw = JSON.parse(await (0, import_promises31.readFile)(ctx.manifestPath, "utf8"));
       for (const id of importedAssetIds) raw.assets[id] = ctx.manifest.assets[id];
-      await (0, import_promises30.writeFile)(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
+      await (0, import_promises31.writeFile)(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
       await saveLock(ctx.lockPath, ctx.lock);
       if (characterAssetIds.length) result.characterAssetIds = characterAssetIds;
       return result;