pixelkiln 0.83.0 → 0.85.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(path38, 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}${path38}`, {
       ...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"} ${path38} \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"} ${path38} 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 path38;
     let body;
     if (args.mode === "v3") {
-      path36 = "/create-character-v3";
+      path38 = "/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";
+      path38 = "/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";
+      path38 = "/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";
+      path38 = 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(path38, { method: "POST", body: JSON.stringify(body) });
+    return validateResponse(CharacterSubmitSchema, raw, path38.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(path38) {
   return new Promise((resolve, reject) => {
     const hash = createHash("sha256");
-    const stream = createReadStream(path36);
+    const stream = createReadStream(path38);
     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(path38, 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}${path38}`, {
       ...init,
       headers: {
         "Content-Type": "application/json",
@@ -6119,8 +6243,13 @@ function retroError(value) {
 }
 
 // src/providers/scenario.ts
+import { createHash as createHash2 } from "crypto";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync, writeFileSync as writeFileSync2 } from "fs";
+import os2 from "os";
+import path2 from "path";
 var DEFAULT_BASE_URL2 = "https://api.cloud.scenario.com/v1";
 var SOURCE_PROTOCOL2 = "scenario:";
+var SUBMIT_RETRIES = 8;
 var PROTECTED_PARAMETERS = /* @__PURE__ */ new Set([
   "dryRun",
   "height",
@@ -6167,7 +6296,11 @@ var ScenarioClient = class {
   async submit(modelId, body, projectId) {
     const response = await this.call(
       `/generate/custom/${encodeURIComponent(modelId)}`,
-      { method: "POST", body: JSON.stringify(body) },
+      // A 429 here means this account's concurrent-job limit refused the
+      // request, so nothing was accepted or billed; wait it out instead of
+      // failing the asset. The default four retries give up after about half
+      // a minute, before a running job has finished.
+      { method: "POST", body: JSON.stringify(body), retries: SUBMIT_RETRIES },
       { projectId }
     );
     const job = response?.job;
@@ -6175,6 +6308,29 @@ var ScenarioClient = class {
     if (!jobId) throw new Error("Scenario did not return an async job id");
     return jobId;
   }
+  /**
+   * Uploads one image (POST /assets) and returns its asset id, which a model's
+   * reference input takes. Free, and idempotent per image: the id is kept by
+   * content hash so a rerun does not upload the same bytes again.
+   */
+  async uploadImage(image, projectId) {
+    const bytes = Buffer.from(image.base64, "base64");
+    const digest2 = sha256(bytes);
+    const cached = readUploadCache()[uploadCacheKey(this.baseUrl, projectId, digest2)];
+    if (cached) return cached;
+    const response = await this.call(
+      "/assets",
+      {
+        method: "POST",
+        body: JSON.stringify({ image: image.base64, name: `pixelkiln-${digest2.slice(0, 12)}.${image.format === "png" ? "png" : "jpg"}` })
+      },
+      { projectId }
+    );
+    const id = response?.asset?.id;
+    if (typeof id !== "string" || !id) throw new Error("Scenario did not return an uploaded asset id");
+    writeUploadCache(uploadCacheKey(this.baseUrl, projectId, digest2), id);
+    return id;
+  }
   async job(id, projectId) {
     const response = await this.call(`/jobs/${encodeURIComponent(id)}`, {}, { projectId });
     const raw = response?.job;
@@ -6301,6 +6457,14 @@ var ScenarioProvider = class _ScenarioProvider {
   supports(generator) {
     return generator === "map";
   }
+  /**
+   * An edit is a generation with the parent as a reference image, which the
+   * editing models (GPT Image, Gemini, FLUX) take. Masked inpainting and the
+   * PixelLab-specific modes have no common Scenario input.
+   */
+  supportsRevision(mode2) {
+    return mode2 === "image-to-image";
+  }
   estimate(spec) {
     const options = scenarioOptions(spec);
     return {
@@ -6321,11 +6485,31 @@ var ScenarioProvider = class _ScenarioProvider {
     if (!Number.isInteger(count) || count < 1 || count > 4) {
       throw new Error("Scenario numOutputs must be a whole number from 1 to 4");
     }
-    if (spec.width < 128 || spec.width > 2048 || spec.width % 16 !== 0 || spec.height < 128 || spec.height > 2048 || spec.height % 16 !== 0) {
-      throw new Error("Scenario width and height must be multiples of 16 from 128 to 2048");
+    if (!Number.isInteger(spec.width) || spec.width < 16 || spec.width > 4096 || !Number.isInteger(spec.height) || spec.height < 16 || spec.height > 4096) {
+      throw new Error("Scenario width and height must be whole numbers from 16 to 4096");
     }
-    if (styleImages.length) {
-      throw new Error("Scenario styleImages are not supported yet; use a reusable Scenario model");
+    const revision = spec.revision;
+    if (revision) {
+      if (revision.sourceMembers?.length) {
+        throw new Error(
+          `Scenario edits one image; ${revision.sourceAssetId} is a ${revision.sourceMembers.length}-member set`
+        );
+      }
+      if (revision.strength != null) {
+        throw new Error("Scenario image-to-image takes no strength; use the model's own parameters");
+      }
+    }
+    const parameter = referenceParameter(options);
+    if ((styleImages.length || revision) && Object.hasOwn(options.parameters ?? {}, parameter)) {
+      throw new Error(
+        `Scenario parameters.${parameter} is the reference-image input and is filled from styleImages and revisions`
+      );
+    }
+    if (styleImages.length + (revision ? 1 : 0) > 1 && options.referenceArray === false) {
+      throw new Error(`Scenario ${parameter} takes one image; use one style image or a revision, not both`);
+    }
+    if (options.referenceParameter != null && (typeof options.referenceParameter !== "string" || !options.referenceParameter.trim())) {
+      throw new Error("Scenario referenceParameter must be a non-empty string");
     }
     if (options.projectId != null && (typeof options.projectId !== "string" || !options.projectId.trim())) {
       throw new Error("Scenario projectId must be a non-empty string");
@@ -6338,7 +6522,12 @@ var ScenarioProvider = class _ScenarioProvider {
   async submit(spec, styleImages) {
     this.validate(spec, styleImages);
     const options = scenarioOptions(spec);
-    const body = requestBody(spec, options);
+    const references = [];
+    if (spec.revision) references.push(readRevisionSource(spec));
+    for (const image of styleImages) references.push({ base64: image.base64, format: image.format });
+    const referenceAssetIds = [];
+    for (const image of references) referenceAssetIds.push(await this.client.uploadImage(image, options.projectId));
+    const body = requestBody(spec, options, referenceAssetIds);
     const quote = await this.client.quote(options.modelId, body, options.projectId);
     if (quote.total > options.maxComputeUnits + Number.EPSILON) {
       throw new Error(
@@ -6355,7 +6544,8 @@ var ScenarioProvider = class _ScenarioProvider {
         quotedComputeUnits: quote.total,
         creativeUnitsCost: quote.creativeUnitsCost,
         costDetails: quote.costDetails,
-        ipDetectionCost: quote.ipDetectionCost
+        ipDetectionCost: quote.ipDetectionCost,
+        ...referenceAssetIds.length ? { referenceAssetIds } : {}
       }
     };
   }
@@ -6377,7 +6567,13 @@ var ScenarioProvider = class _ScenarioProvider {
     }
     const assetIds = scenarioAssetIds(job);
     if (!assetIds.length) return { status: "failed", error: "Scenario job returned no asset IDs" };
-    const assets = await this.assets(assetIds, reference.projectId);
+    let assets;
+    try {
+      assets = await this.assets(assetIds, reference.projectId);
+    } catch (error) {
+      if (error instanceof UnsupportedScenarioOutput) return { status: "failed", error: error.message };
+      throw error;
+    }
     if (assets.length > 1) {
       return {
         status: "review",
@@ -6432,6 +6628,32 @@ var ScenarioProvider = class _ScenarioProvider {
     return assets.sort((left, right) => left.outputIndex - right.outputIndex || (jobOrder.get(left.id) ?? Number.MAX_SAFE_INTEGER) - (jobOrder.get(right.id) ?? Number.MAX_SAFE_INTEGER) || left.id.localeCompare(right.id));
   }
 };
+function uploadCachePath() {
+  return process.env.SCENARIO_UPLOAD_CACHE ?? path2.join(os2.tmpdir(), "pixelkiln-scenario", "uploads.json");
+}
+function uploadCacheKey(baseUrl, projectId, digest2) {
+  return createHash2("sha256").update(`${baseUrl}
+${projectId ?? ""}
+${digest2}`).digest("hex");
+}
+function readUploadCache() {
+  try {
+    const value = JSON.parse(readFileSync2(uploadCachePath(), "utf8"));
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  } catch {
+    return {};
+  }
+}
+function writeUploadCache(key, assetId) {
+  try {
+    const file = uploadCachePath();
+    mkdirSync2(path2.dirname(file), { recursive: true });
+    const tmp = `${file}.${process.pid}.tmp`;
+    writeFileSync2(tmp, JSON.stringify({ ...readUploadCache(), [key]: assetId }));
+    renameSync(tmp, file);
+  } catch {
+  }
+}
 function scenarioOptions(spec) {
   return spec.providerOptions;
 }
@@ -6447,9 +6669,25 @@ function scenarioBaseUrl(value) {
   }
   return url.href.replace(/\/$/, "");
 }
-function requestBody(spec, options) {
+function referenceParameter(options) {
+  return options.referenceParameter?.trim() || "referenceImages";
+}
+function readRevisionSource(spec) {
+  const revision = spec.revision;
+  if (!revision.sourceFile || !revision.sourceSha256 || !revision.sourceFormat) {
+    throw new Error(`${spec.styleId}/${spec.assetId}: revision source is not ready`);
+  }
+  const bytes = readFileSync2(revision.sourceFile);
+  if (sha256(bytes) !== revision.sourceSha256) {
+    throw new Error(`${spec.styleId}/${spec.assetId}: revision source changed after the manifest was resolved`);
+  }
+  return { base64: bytes.toString("base64"), format: revision.sourceFormat };
+}
+function requestBody(spec, options, referenceAssetIds = []) {
+  const parameter = referenceParameter(options);
   return {
     ...options.parameters ?? {},
+    ...referenceAssetIds.length ? { [parameter]: options.referenceArray === false ? referenceAssetIds[0] : referenceAssetIds } : {},
     prompt: spec.prompt,
     width: spec.width,
     height: spec.height,
@@ -6539,9 +6777,11 @@ function scenarioAssetIds(job) {
 function assetDownloadUrl(asset) {
   return asset.originalFileUrl || asset.url;
 }
+var UnsupportedScenarioOutput = class extends Error {
+};
 function assertPngAsset(asset) {
   if (asset.originalMimeType && asset.originalMimeType !== MediaType.PNG) {
-    throw new Error(
+    throw new UnsupportedScenarioOutput(
       `Scenario asset ${asset.id} is ${asset.originalMimeType}; PixelKiln's Scenario MVP requires PNG output`
     );
   }
@@ -6608,7 +6848,7 @@ function redactScenarioError(value, secrets) {
 // src/providers/comfyui.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { readFile } from "fs/promises";
-import path2 from "path";
+import path3 from "path";
 var DEFAULT_BASE_URL3 = "http://127.0.0.1:8188";
 var BUILTIN_BINDINGS = /* @__PURE__ */ new Set([
   "prompt",
@@ -6745,7 +6985,7 @@ var ComfyUIProvider = class _ComfyUIProvider {
   }
   async resolveOptions(value, context) {
     const options = parseOptions(value);
-    const workflowPath = path2.resolve(context.root, options.workflowFile);
+    const workflowPath = path3.resolve(context.root, options.workflowFile);
     let raw;
     try {
       raw = await readFile(workflowPath, "utf8");
@@ -6800,7 +7040,7 @@ var ComfyUIProvider = class _ComfyUIProvider {
           if (typeof item !== "string") {
             throw new Error(`ComfyUI ${label} must be a manifest-relative PNG or JPEG path`);
           }
-          const file = path2.resolve(context.root, item);
+          const file = path3.resolve(context.root, item);
           let bytes;
           try {
             bytes = await readFile(file);
@@ -7512,7 +7752,7 @@ function canonical(value) {
 }
 
 // src/providers/fake.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 var FAKE_PNG = Buffer.from(
   "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
   "base64"
@@ -7614,7 +7854,7 @@ var FakeProvider = class {
   }
   async download(url) {
     if (!url.startsWith("fake://")) throw new Error(`fake provider cannot download ${url}`);
-    const salt = createHash2("sha256").update(url).digest();
+    const salt = createHash3("sha256").update(url).digest();
     return Buffer.concat([FAKE_PNG, salt.subarray(0, 4)]);
   }
   async balance() {
@@ -7763,7 +8003,7 @@ registerProvider({
 // src/manifest.ts
 import { readFile as readFile3 } from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
-import path5 from "path";
+import path6 from "path";
 
 // src/loop-directions.ts
 var SINGLE_OUTPUT_FIELDS = ["file", "cell", "remoteId", "source", "sourceByStyle", "outputRole"];
@@ -7852,12 +8092,12 @@ function isObject2(value) {
 
 // src/outputs.ts
 import { existsSync as existsSync3 } from "fs";
-import path4 from "path";
+import path5 from "path";
 
 // src/lock.ts
 import { readFile as readFile2, writeFile, rename, mkdir, rmdir, rm, stat } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
-import path3 from "path";
+import path4 from "path";
 async function loadLock(lockPath) {
   if (!existsSync2(lockPath)) return { version: 2, entries: {} };
   try {
@@ -7874,7 +8114,7 @@ var saveQueues = /* @__PURE__ */ new Map();
 var dirtyPatches = /* @__PURE__ */ new WeakMap();
 var dirtyDeletes = /* @__PURE__ */ new WeakMap();
 function saveLock(lockPath, lock) {
-  const queueKey = path3.resolve(lockPath);
+  const queueKey = path4.resolve(lockPath);
   const previous = saveQueues.get(queueKey) ?? Promise.resolve();
   const next = previous.catch(() => {
   }).then(() => writeLockNow(lockPath, lock));
@@ -7886,7 +8126,7 @@ function saveLock(lockPath, lock) {
   return next;
 }
 async function writeLockNow(lockPath, lock) {
-  await mkdir(path3.dirname(path3.resolve(lockPath)), { recursive: true });
+  await mkdir(path4.dirname(path4.resolve(lockPath)), { recursive: true });
   const release = await acquireFileLock(lockPath);
   try {
     await writeLockWhileHeld(lockPath, lock);
@@ -8031,22 +8271,22 @@ function totalSpend(lock, unit = "generations") {
 
 // src/outputs.ts
 function portableOutputPath(file, manifestDir) {
-  const root = path4.resolve(manifestDir);
-  const absolute = path4.isAbsolute(file) ? path4.normalize(file) : path4.resolve(root, file);
-  const relative = path4.relative(root, absolute);
-  const value = path4.isAbsolute(relative) ? absolute : relative;
-  return value.split(path4.sep).join("/");
+  const root = path5.resolve(manifestDir);
+  const absolute = path5.isAbsolute(file) ? path5.normalize(file) : path5.resolve(root, file);
+  const relative = path5.relative(root, absolute);
+  const value = path5.isAbsolute(relative) ? absolute : relative;
+  return value.split(path5.sep).join("/");
 }
 function resolveOutputPath(recordedPath, manifestDir) {
-  if (path4.isAbsolute(recordedPath)) return path4.normalize(recordedPath);
-  if (path4.win32.isAbsolute(recordedPath)) return recordedPath;
-  return path4.resolve(manifestDir, recordedPath.split(/[\\/]/).join(path4.sep));
+  if (path5.isAbsolute(recordedPath)) return path5.normalize(recordedPath);
+  if (path5.win32.isAbsolute(recordedPath)) return recordedPath;
+  return path5.resolve(manifestDir, recordedPath.split(/[\\/]/).join(path5.sep));
 }
 function expectedOutputPath(spec, role, index, total, mediaType) {
   return memberPath(spec.outFile, role, index, total, mediaType);
 }
 function memberPath(file, role, index, total, mediaType) {
-  const originalExt = path4.extname(file);
+  const originalExt = path5.extname(file);
   const ext = mediaType ? mediaExtension(mediaType) : originalExt || ".png";
   const stem = originalExt ? file.slice(0, -originalExt.length) : file;
   if (total === 1) return `${stem}${ext}`;
@@ -8060,10 +8300,10 @@ function isFrameSetEntry(entry) {
   return entry.generator === "frames" && isMemberSetEntry(entry);
 }
 function sourceIsStem(source, entry, manifestDir) {
-  return isMemberSetEntry(entry) && !existsSync3(path4.resolve(manifestDir, source));
+  return isMemberSetEntry(entry) && !existsSync3(path5.resolve(manifestDir, source));
 }
 function sourceOutputPath(source, entry, index, manifestDir) {
-  const absolute = path4.resolve(manifestDir, source);
+  const absolute = path5.resolve(manifestDir, source);
   if (!sourceIsStem(source, entry, manifestDir)) return absolute;
   const output = entry.outputs[index];
   return memberPath(absolute, output.role, index, entry.outputs.length, output.mediaType);
@@ -8150,7 +8390,7 @@ function resolveSpecOutputs(spec, lock, manifestDir) {
     id: spec.assetId,
     index: 0,
     path: spec.outFile,
-    absolutePath: path4.resolve(spec.outFile),
+    absolutePath: path5.resolve(spec.outFile),
     sha256: ""
   }];
 }
@@ -8166,7 +8406,7 @@ function frameSetFps(entry) {
 
 // src/manifest.ts
 async function loadManifest(manifestPath) {
-  const abs = path5.resolve(manifestPath);
+  const abs = path6.resolve(manifestPath);
   if (!existsSync4(abs)) throw new ProjectError(`No manifest at ${abs}`);
   const expansion = expandLoopDirections(JSON.parse(await readFile3(abs, "utf8")));
   if (expansion.issues.length) {
@@ -8259,7 +8499,7 @@ ${issues}`);
 ${unknownReferences.map((i) => `  ${i}`).join("\n")}`);
   }
   const loopFamilies = Object.keys(expansion.families).length ? { loopFamilies: expansion.families } : {};
-  return { manifest: parsed.data, root: path5.dirname(abs), path: abs, ...loopFamilies };
+  return { manifest: parsed.data, root: path6.dirname(abs), path: abs, ...loopFamilies };
 }
 function parentAssetId(asset) {
   return asset?.revision?.from ?? asset?.state?.of ?? asset?.animation?.of ?? asset?.portrait?.of ?? asset?.outfit?.of;
@@ -8360,7 +8600,7 @@ async function resolveSpecs(loaded, filter) {
   }
   const styleImageCache = /* @__PURE__ */ new Map();
   async function loadStyleImage(rel, what = "Style image") {
-    const abs = path5.resolve(root, rel);
+    const abs = path6.resolve(root, rel);
     let hit = styleImageCache.get(abs);
     if (!hit) {
       if (!existsSync4(abs)) throw new Error(`${what} not found: ${abs}`);
@@ -8390,7 +8630,7 @@ async function resolveSpecs(loaded, filter) {
       styleImageDimensions.push(loadedImage);
     }
     const resolvedImages = style.styleImages.map((image) => {
-      const hit = styleImageCache.get(path5.resolve(root, image.path));
+      const hit = styleImageCache.get(path6.resolve(root, image.path));
       return { base64: hit.base64, width: hit.width, height: hit.height, format: hit.format };
     });
     const styleSpecs = /* @__PURE__ */ new Map();
@@ -8491,9 +8731,9 @@ async function resolveSpecs(loaded, filter) {
       } else {
         prompt = [style.promptPrefix, subject, style.promptSuffix].map((p) => p.trim()).filter(Boolean).join(", ");
       }
-      const relFile = asset.file ?? path5.join(asset.category ?? "", `${assetId}.png`);
-      const outFile = path5.resolve(root, style.outDir, relFile);
-      const qualityOutFile = style.quality ? path5.resolve(root, style.quality.outDir, pngPath(relFile)) : void 0;
+      const relFile = asset.file ?? path6.join(asset.category ?? "", `${assetId}.png`);
+      const outFile = path6.resolve(root, style.outDir, relFile);
+      const qualityOutFile = style.quality ? path6.resolve(root, style.quality.outDir, pngPath(relFile)) : void 0;
       const tileSize = generator === "tiles" ? size : style.tileSize ?? 32;
       const tileVariations = tileFeatureOutputCount(generator === "tiles" ? style.tileFeature : void 0) ?? tileVariationCount(countNumberedDescriptions(prompt));
       const terrainTiles = generator === "terrain" ? terrainTileCount(style.terrainTransitionSize) : 0;
@@ -8588,7 +8828,7 @@ async function resolveSpecs(loaded, filter) {
             minGridConfidence: style.quality.minGridConfidence,
             ...style.quality.minTransparency == null ? {} : { minTransparency: style.quality.minTransparency },
             ...style.quality.fixerRevision ? { fixerRevision: style.quality.fixerRevision } : {},
-            ...style.quality.fixerPython ? { fixerPython: path5.resolve(root, style.quality.fixerPython) } : {},
+            ...style.quality.fixerPython ? { fixerPython: path6.resolve(root, style.quality.fixerPython) } : {},
             ...style.quality.fps == null ? {} : { fps: style.quality.fps }
           }
         } : {},
@@ -8724,7 +8964,7 @@ async function resolveSpecs(loaded, filter) {
           animation: sourceSpec.character.animation,
           outfit: {
             reference: {
-              path: path5.resolve(root, asset.outfit.reference),
+              path: path6.resolve(root, asset.outfit.reference),
               sha256: referenceImage.hash,
               width: referenceImage.width,
               height: referenceImage.height,
@@ -8746,23 +8986,23 @@ async function resolveSpecs(loaded, filter) {
           );
         }
         const sourceSpec = await finalize(asset.revision.from);
-        const sourceStem = sourceSpec.quality?.outFile ?? (sourceSpec.source ? path5.resolve(root, sourceSpec.source) : sourceSpec.outFile);
+        const sourceStem = sourceSpec.quality?.outFile ?? (sourceSpec.source ? path6.resolve(root, sourceSpec.source) : sourceSpec.outFile);
         const sourceMembers = await revisionSourceMembers(sourceStem, `revision source ${asset.revision.from}`);
         const sourceFile = sourceMembers?.[0]?.file ?? sourceStem;
         const sourceImage = sourceMembers ? { ...sourceMembers[0], hash: sha256(JSON.stringify(sourceMembers.map((member) => member.sha256))) } : await optionalRevisionImage(sourceFile, "revision source");
         const sourceFps = sourceSpec.character?.animation?.fps ?? sourceSpec.objectPro?.animation?.fps ?? sourceSpec.revision?.fps ?? sourceSpec.revision?.sourceFps;
-        const maskFile = asset.revision.mask ? path5.resolve(root, asset.revision.mask) : void 0;
+        const maskFile = asset.revision.mask ? path6.resolve(root, asset.revision.mask) : void 0;
         const maskImage = maskFile ? await optionalRevisionImage(maskFile, "revision mask", "png") : null;
         if (sourceImage && maskImage && (sourceImage.width !== maskImage.width || sourceImage.height !== maskImage.height)) {
           throw new Error(
             `Revision mask for ${styleId}/${assetId} is ${maskImage.width}x${maskImage.height}; source ${asset.revision.from} is ${sourceImage.width}x${sourceImage.height}`
           );
         }
-        const paletteImageFile = asset.revision.paletteImage ? path5.resolve(root, asset.revision.paletteImage) : void 0;
+        const paletteImageFile = asset.revision.paletteImage ? path6.resolve(root, asset.revision.paletteImage) : void 0;
         const paletteImage = paletteImageFile ? await optionalRevisionImage(paletteImageFile, "revision palette image", "png") : null;
-        const lastFrameFile = asset.revision.lastFrame ? path5.resolve(root, asset.revision.lastFrame) : void 0;
+        const lastFrameFile = asset.revision.lastFrame ? path6.resolve(root, asset.revision.lastFrame) : void 0;
         const lastFrame = lastFrameFile ? await optionalRevisionImage(lastFrameFile, "revision last frame") : null;
-        const keypointsFile = asset.revision.keypointsFile ? path5.resolve(root, asset.revision.keypointsFile) : void 0;
+        const keypointsFile = asset.revision.keypointsFile ? path6.resolve(root, asset.revision.keypointsFile) : void 0;
         const keypoints = keypointsFile ? await optionalSkeletonSet(keypointsFile) : null;
         resolved.revision = {
           mode: asset.revision.mode,
@@ -8816,6 +9056,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 } : {}
         };
       }
@@ -8925,7 +9169,7 @@ async function resolveSpecs(loaded, filter) {
   return specs;
 }
 function pngPath(file) {
-  const extension = path5.extname(file);
+  const extension = path6.extname(file);
   return extension ? `${file.slice(0, -extension.length)}.png` : `${file}.png`;
 }
 async function resolveMapScene(root, styleId, assetId, generator, scene, provider) {
@@ -8935,12 +9179,12 @@ async function resolveMapScene(root, styleId, assetId, generator, scene, provide
   if (!provider.supportsMapScene) {
     throw new Error(`assets.${assetId}.scene: provider "${provider.id}" cannot draw into a scene; PixelLab's /map-objects can`);
   }
-  const file = path5.resolve(root, scene.image);
+  const file = path6.resolve(root, scene.image);
   const image = await optionalRevisionImage(file, "scene image", "png");
   const base = { file, sha256: image?.hash ?? null, width: image?.width ?? null, height: image?.height ?? null };
   const placement = scene.placement;
   if ("mask" in placement) {
-    const maskFile = path5.resolve(root, placement.mask);
+    const maskFile = path6.resolve(root, placement.mask);
     const mask = await optionalRevisionImage(maskFile, "scene mask", "png");
     if (image && mask && (image.width !== mask.width || image.height !== mask.height)) {
       throw new Error(
@@ -9012,7 +9256,7 @@ async function resolveStyleImages(loaded, styleId) {
   if (!style) throw new Error(`Unknown style "${styleId}"`);
   const out = [];
   for (const img of style.styleImages) {
-    const file = path5.resolve(loaded.root, img.path);
+    const file = path6.resolve(loaded.root, img.path);
     const buf = await readFile3(file);
     const metadata = imageMetadata(buf);
     if (!metadata) throw new Error(`Style image is not a readable PNG or JPEG: ${file}`);
@@ -9043,7 +9287,7 @@ async function resolveCharacterShape(asset, style, kind, files) {
   };
   if (asset.concept) {
     const image = await files.load(asset.concept, "Concept image");
-    shape.concept = { path: path5.resolve(files.root, asset.concept), sha256: image.hash, width: image.width, height: image.height, format: image.format };
+    shape.concept = { path: path6.resolve(files.root, asset.concept), sha256: image.hash, width: image.width, height: image.height, format: image.format };
   }
   if (asset.reference) {
     const byDirection = typeof asset.reference === "string" ? { south: asset.reference } : asset.reference;
@@ -9051,7 +9295,7 @@ async function resolveCharacterShape(asset, style, kind, files) {
     for (const [direction, rel] of Object.entries(byDirection)) {
       const image = await files.load(rel, `Reference sprite (${direction})`);
       shape.reference[direction] = {
-        path: path5.resolve(files.root, rel),
+        path: path6.resolve(files.root, rel),
         sha256: image.hash,
         width: image.width,
         height: image.height,
@@ -9072,7 +9316,7 @@ async function resolveCharacterShape(asset, style, kind, files) {
     const animationMode = asset.animation.mode ?? (asset.animation.template ? "template" : "v3");
     const pose = async (rel, what) => {
       const image = await files.load(rel, what);
-      return { path: path5.resolve(files.root, rel), sha256: image.hash, width: image.width, height: image.height, format: image.format };
+      return { path: path6.resolve(files.root, rel), sha256: image.hash, width: image.width, height: image.height, format: image.format };
     };
     shape.animation = {
       mode: animationMode,
@@ -9103,7 +9347,7 @@ async function resolveObjectProShape(assetId, asset, style, kind, files) {
     const south = typeof asset.reference === "string" ? asset.reference : asset.reference.south;
     if (south) {
       const image = await files.load(south, "Reference sprite");
-      shape.reference = { path: path5.resolve(files.root, south), sha256: image.hash, width: image.width, height: image.height, format: image.format };
+      shape.reference = { path: path6.resolve(files.root, south), sha256: image.hash, width: image.width, height: image.height, format: image.format };
     }
   }
   if (asset.state) {
@@ -9131,7 +9375,7 @@ async function resolveObjectProShape(assetId, asset, style, kind, files) {
     }
     const pose = async (rel, what) => {
       const image = await files.load(rel, what);
-      return { path: path5.resolve(files.root, rel), sha256: image.hash, width: image.width, height: image.height, format: image.format };
+      return { path: path6.resolve(files.root, rel), sha256: image.hash, width: image.width, height: image.height, format: image.format };
     };
     shape.animation = {
       mode: asset.animation.mode ?? "v3",
@@ -9151,11 +9395,11 @@ function characterDirections(directions) {
 }
 
 // src/project.ts
-import path13 from "path";
+import path14 from "path";
 
 // src/env.ts
-import { readFileSync as readFileSync2, existsSync as existsSync5 } from "fs";
-import path6 from "path";
+import { readFileSync as readFileSync3, existsSync as existsSync5 } from "fs";
+import path7 from "path";
 function loadEnvFiles(dir) {
   const loaded = [];
   for (const [file, vars] of envFiles(dir)) {
@@ -9169,10 +9413,10 @@ function loadEnvFiles(dir) {
 function envFiles(dir) {
   const out = [];
   for (const name of [".env.local", ".env"]) {
-    const file = path6.join(dir, name);
+    const file = path7.join(dir, name);
     if (!existsSync5(file)) continue;
     try {
-      out.push([file, parseEnv(readFileSync2(file, "utf8"))]);
+      out.push([file, parseEnv(readFileSync3(file, "utf8"))]);
     } catch {
     }
   }
@@ -9199,11 +9443,11 @@ function parseEnv(contents) {
 
 // src/pipeline/plan.ts
 import { existsSync as existsSync8 } from "fs";
-import path12 from "path";
+import path13 from "path";
 
 // src/pipeline/mirror.ts
 import { mkdir as mkdir2, readFile as readFile4, rename as rename2, writeFile as writeFile2 } from "fs/promises";
-import path7 from "path";
+import path8 from "path";
 
 // src/palette.ts
 function normalizePalette(values) {
@@ -9342,7 +9586,7 @@ async function deriveMirror(spec, lock, lockPath, opts = {}) {
   for (const [index, member] of members.entries()) {
     const bytes = flipHorizontal(await readFile4(member.file));
     const target = expectedOutputPath(spec, member.role, index, members.length, MediaType.PNG);
-    await mkdir2(path7.dirname(target), { recursive: true });
+    await mkdir2(path8.dirname(target), { recursive: true });
     const tmp = `${target}.pixelkiln.tmp`;
     await writeFile2(tmp, bytes);
     await rename2(tmp, target);
@@ -9405,28 +9649,28 @@ async function deriveMirror(spec, lock, lockPath, opts = {}) {
 
 // src/pipeline/quality-profile.ts
 import { existsSync as existsSync6 } from "fs";
-import path10 from "path";
+import path11 from "path";
 
 // src/pipeline/refine.ts
-import path9 from "path";
+import path10 from "path";
 import { execFile } from "child_process";
 import { mkdtemp, readFile as readFile6, rm as rm3 } from "fs/promises";
 import { tmpdir } from "os";
 import { promisify } from "util";
 
 // src/artifacts.ts
-import path8 from "path";
-import { createHash as createHash3, randomUUID as randomUUID3 } from "crypto";
+import path9 from "path";
+import { createHash as createHash4, randomUUID as randomUUID3 } from "crypto";
 import { mkdir as mkdir3, readFile as readFile5, rename as rename3, rm as rm2, writeFile as writeFile3 } from "fs/promises";
 var activeTransactions = /* @__PURE__ */ new Set();
 function message(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function digest(data) {
-  return createHash3("sha256").update(data).digest("hex");
+  return createHash4("sha256").update(data).digest("hex");
 }
 function portableRelative(from, to) {
-  return path8.relative(from, path8.resolve(to)).split(path8.sep).join("/") || ".";
+  return path9.relative(from, path9.resolve(to)).split(path9.sep).join("/") || ".";
 }
 function canonical2(value) {
   if (value === null || typeof value === "string" || typeof value === "boolean") return value;
@@ -9476,7 +9720,7 @@ function parseArtifactManifest(absolute, data) {
   return raw;
 }
 async function readArtifactBundleManifest(manifestPath) {
-  const absolute = path8.resolve(manifestPath);
+  const absolute = path9.resolve(manifestPath);
   return parseArtifactManifest(absolute, await readFile5(absolute, "utf8"));
 }
 async function readOptional(file) {
@@ -9500,8 +9744,8 @@ function processIsAlive(pid) {
   }
 }
 function validTemporaryPath(candidate, destination, type) {
-  return path8.dirname(candidate) === path8.dirname(destination) && path8.basename(candidate).startsWith(
-    `.${path8.basename(destination)}.pixelkiln-${type}-`
+  return path9.dirname(candidate) === path9.dirname(destination) && path9.basename(candidate).startsWith(
+    `.${path9.basename(destination)}.pixelkiln-${type}-`
   );
 }
 function parseTransaction(journal, data) {
@@ -9521,7 +9765,7 @@ async function removeTransactionFiles(journal) {
   await rm2(transactionMarker(journal), { force: true });
 }
 async function recoverArtifactTransaction(recoveryFile, allowedDestinations) {
-  const journal = path8.resolve(recoveryFile);
+  const journal = path9.resolve(recoveryFile);
   const bytes = await readOptional(journal);
   if (!bytes) {
     await rm2(transactionMarker(journal), { force: true });
@@ -9537,7 +9781,7 @@ async function recoverArtifactTransaction(recoveryFile, allowedDestinations) {
     );
   }
   for (const entry of transaction.entries) {
-    if (typeof entry.destination !== "string" || typeof entry.stage !== "string" || typeof entry.sha256 !== "string" || entry.backup !== void 0 && typeof entry.backup !== "string" || !allowedDestinations.has(path8.resolve(entry.destination)) || !validTemporaryPath(entry.stage, entry.destination, "stage") || entry.backup !== void 0 && !validTemporaryPath(entry.backup, entry.destination, "backup")) {
+    if (typeof entry.destination !== "string" || typeof entry.stage !== "string" || typeof entry.sha256 !== "string" || entry.backup !== void 0 && typeof entry.backup !== "string" || !allowedDestinations.has(path9.resolve(entry.destination)) || !validTemporaryPath(entry.stage, entry.destination, "stage") || entry.backup !== void 0 && !validTemporaryPath(entry.backup, entry.destination, "backup")) {
       throw new Error(
         `Refusing unsafe artifact recovery from ${journal}; its destinations or temporary paths do not match the current bundle.`
       );
@@ -9583,7 +9827,7 @@ async function recoverArtifactTransaction(recoveryFile, allowedDestinations) {
   await removeTransactionFiles(journal);
 }
 function createArtifactBundleManifest(manifestPath, outputs, provenance) {
-  const root = path8.dirname(path8.resolve(manifestPath));
+  const root = path9.dirname(path9.resolve(manifestPath));
   const sources = provenance.sources.map((source) => ({
     ...source,
     path: portableRelative(root, source.path)
@@ -9613,11 +9857,11 @@ function withArtifactManifest(manifestPath, outputs, provenance) {
   ];
 }
 async function writeManagedArtifactBundle(manifestPath, outputs, provenance, options = {}) {
-  const absoluteManifest = path8.resolve(manifestPath);
+  const absoluteManifest = path9.resolve(manifestPath);
   const recoveryFile = `${absoluteManifest}.transaction`;
   const allowedDestinations = /* @__PURE__ */ new Set([
     absoluteManifest,
-    ...outputs.map((output) => path8.resolve(output.path))
+    ...outputs.map((output) => path9.resolve(output.path))
   ]);
   await recoverArtifactTransaction(recoveryFile, allowedDestinations);
   const existingManifestBytes = await readOptional(absoluteManifest);
@@ -9635,13 +9879,13 @@ async function writeManagedArtifactBundle(manifestPath, outputs, provenance, opt
     }
   }
   if (!options.force) {
-    const root = path8.dirname(absoluteManifest);
+    const root = path9.dirname(absoluteManifest);
     const recorded = new Map(
-      previous?.outputs.map((output) => [path8.resolve(root, output.path), output.sha256]) ?? []
+      previous?.outputs.map((output) => [path9.resolve(root, output.path), output.sha256]) ?? []
     );
     const conflicts = [];
     for (const output of outputs) {
-      const destination = path8.resolve(output.path);
+      const destination = path9.resolve(output.path);
       const current = await readOptional(destination);
       if (!current || digest(current) === digest(output.data)) continue;
       const expected = recorded.get(destination);
@@ -9663,15 +9907,15 @@ Pass { force: true } (CLI: --force) to take ownership and replace the complete b
   );
 }
 async function verifyArtifactBundle(manifestPath) {
-  const absolute = path8.resolve(manifestPath);
+  const absolute = path9.resolve(manifestPath);
   const raw = await readArtifactBundleManifest(absolute);
-  const root = path8.dirname(absolute);
+  const root = path9.dirname(absolute);
   const changedSources = [];
   const changedOutputs = [];
   for (const source of raw.sources) {
     let actual = null;
     try {
-      actual = digest(await readFile5(path8.resolve(root, source.path)));
+      actual = digest(await readFile5(path9.resolve(root, source.path)));
     } catch (error) {
       if (!isCode(error, "ENOENT")) throw error;
     }
@@ -9679,7 +9923,7 @@ async function verifyArtifactBundle(manifestPath) {
   }
   for (const output of raw.outputs) {
     try {
-      if (digest(await readFile5(path8.resolve(root, output.path))) !== output.sha256) {
+      if (digest(await readFile5(path9.resolve(root, output.path))) !== output.sha256) {
         changedOutputs.push(output.path);
       }
     } catch (error) {
@@ -9735,7 +9979,7 @@ async function writeArtifactBundle(files, options = {}) {
   if (!files.length) throw new Error("An artifact bundle must contain at least one file.");
   const normalized = files.map((file) => {
     if (!file.path.trim()) throw new Error("Artifact paths cannot be empty.");
-    return { destination: path8.resolve(file.path), data: Buffer.from(file.data) };
+    return { destination: path9.resolve(file.path), data: Buffer.from(file.data) };
   });
   const destinations = /* @__PURE__ */ new Set();
   for (const artifact of normalized) {
@@ -9765,21 +10009,21 @@ async function writeArtifactBundle(files, options = {}) {
   if (!changed.length) return { changed: [], unchanged };
   const token = randomUUID3();
   for (const [index, artifact] of changed.entries()) {
-    const basename = path8.basename(artifact.destination);
-    artifact.stage = path8.join(
-      path8.dirname(artifact.destination),
+    const basename = path9.basename(artifact.destination);
+    artifact.stage = path9.join(
+      path9.dirname(artifact.destination),
       `.${basename}.pixelkiln-stage-${token}-${index}`
     );
     if (artifact.existed) {
-      artifact.backup = path8.join(
-        path8.dirname(artifact.destination),
+      artifact.backup = path9.join(
+        path9.dirname(artifact.destination),
         `.${basename}.pixelkiln-backup-${token}-${index}`
       );
     }
   }
-  const journal = options.recoveryFile ? path8.resolve(options.recoveryFile) : null;
+  const journal = options.recoveryFile ? path9.resolve(options.recoveryFile) : null;
   if (journal) {
-    await mkdir3(path8.dirname(journal), { recursive: true });
+    await mkdir3(path9.dirname(journal), { recursive: true });
     const transaction = {
       format: "pixelkiln-artifact-transaction",
       version: 1,
@@ -9804,7 +10048,7 @@ async function writeArtifactBundle(files, options = {}) {
   }
   try {
     for (const [index, artifact] of changed.entries()) {
-      await mkdir3(path8.dirname(artifact.destination), { recursive: true });
+      await mkdir3(path9.dirname(artifact.destination), { recursive: true });
       await options.beforeStage?.(artifact.destination, index);
       await writeFile3(artifact.stage, artifact.data, { flag: "wx" });
     }
@@ -10070,10 +10314,10 @@ function sameFrameGrid(first, next) {
   return next.detection.stepX === first.detection.stepX && next.detection.stepY === first.detection.stepY && next.detection.columns === first.detection.columns && next.detection.rows === first.detection.rows && phaseMatches(next.detection.phaseX, first.detection.phaseX, first.detection.stepX) && phaseMatches(next.detection.phaseY, first.detection.phaseY, first.detection.stepY) && next.audit.width === first.audit.width && next.audit.height === first.audit.height && next.sourceWidth === first.sourceWidth && next.sourceHeight === first.sourceHeight;
 }
 async function refineAsset(options) {
-  const source = path9.resolve(options.source);
-  const output = path9.resolve(options.output);
+  const source = path10.resolve(options.source);
+  const output = path10.resolve(options.output);
   if (source === output) throw new Error("Refinement source and output must be different files.");
-  const record = path9.resolve(qualityRecordPath(output));
+  const record = path10.resolve(qualityRecordPath(output));
   const palette = normalizePalette(options.palette).map((color) => color.hex);
   const minGridConfidence = requireConfidence(options.minGridConfidence ?? "high");
   if (options.minTransparency !== void 0 && (!Number.isFinite(options.minTransparency) || options.minTransparency < 0 || options.minTransparency > 1)) throw new Error("minTransparency must be between 0 and 1.");
@@ -10096,8 +10340,8 @@ async function refineAsset(options) {
       );
     }
   }
-  const temp = await mkdtemp(path9.join(tmpdir(), "pixelkiln-refine-"));
-  const recovered = path9.join(temp, "native.png");
+  const temp = await mkdtemp(path10.join(tmpdir(), "pixelkiln-refine-"));
+  const recovered = path10.join(temp, "native.png");
   const fixerCommand = compatibilityCommand ?? options.fixerPython ?? process.env.PIXELKILN_PIXEL_FIXER_PYTHON ?? "python3";
   const args = compatibilityCommand ? [...options.fixerArgsPrefix ?? [], source, "--extract", recovered] : ["-c", PYTHON_FIXER_BRIDGE, source, recovered];
   try {
@@ -10182,18 +10426,18 @@ async function refineFrameSet(options) {
   if (roles.some((role) => !role.trim()) || new Set(roles).size !== roles.length) {
     throw new Error("Frame-set roles must be non-empty and unique.");
   }
-  const output = path9.resolve(options.output);
-  const record = path9.resolve(qualityRecordPath(output));
+  const output = path10.resolve(options.output);
+  const record = path10.resolve(qualityRecordPath(output));
   const palette = normalizeRefinementPalette(options.palette);
   const finalOutputs = options.sources.map((source, index) => qualityFrameOutputPath(output, source.role, index));
   if (new Set(finalOutputs).size !== finalOutputs.length) {
     throw new Error("Frame-set roles resolve to duplicate output filenames.");
   }
-  const sourceSet = new Set(options.sources.map((source) => path9.resolve(source.path)));
+  const sourceSet = new Set(options.sources.map((source) => path10.resolve(source.path)));
   if (finalOutputs.some((file) => sourceSet.has(file))) {
     throw new Error("Frame-set refinement sources and outputs must be different files.");
   }
-  const temp = await mkdtemp(path9.join(tmpdir(), "pixelkiln-refine-frames-"));
+  const temp = await mkdtemp(path10.join(tmpdir(), "pixelkiln-refine-frames-"));
   try {
     const frames = [];
     const outputs = [];
@@ -10201,8 +10445,8 @@ async function refineFrameSet(options) {
     const sourcePaths = [];
     let firstOptions = null;
     for (const [index, sourceEntry] of options.sources.entries()) {
-      const source = path9.resolve(sourceEntry.path);
-      const temporaryOutput = path9.join(temp, `${String(index).padStart(2, "0")}.png`);
+      const source = path10.resolve(sourceEntry.path);
+      const temporaryOutput = path10.join(temp, `${String(index).padStart(2, "0")}.png`);
       const refined = await refineAsset({
         source,
         output: temporaryOutput,
@@ -10277,7 +10521,7 @@ async function refineFrameSet(options) {
     );
     return {
       sources: sourcePaths,
-      outputs: outputs.map((item) => path9.resolve(item.path)),
+      outputs: outputs.map((item) => path10.resolve(item.path)),
       record,
       frames,
       palette,
@@ -10288,12 +10532,12 @@ async function refineFrameSet(options) {
   }
 }
 async function checkQualityRecord(recordPath) {
-  const record = path9.resolve(recordPath);
+  const record = path10.resolve(recordPath);
   const manifest = await readArtifactBundleManifest(record);
   const options = parseRecordOptions(manifest, record);
   const verification = await verifyArtifactBundle(record);
-  const sources = manifest.sources.map((source2) => path9.resolve(path9.dirname(record), source2.path));
-  const outputs = manifest.outputs.map((output2) => path9.resolve(path9.dirname(record), output2.path));
+  const sources = manifest.sources.map((source2) => path10.resolve(path10.dirname(record), source2.path));
+  const outputs = manifest.outputs.map((output2) => path10.resolve(path10.dirname(record), output2.path));
   const source = sources[0] ?? "";
   const output = outputs[0] ?? "";
   const expectedCount = options.frameSet?.count ?? 1;
@@ -10326,7 +10570,7 @@ async function checkQualityRecord(recordPath) {
 async function approveQualityRecord(recordPath, approval) {
   const reviewer = approval.reviewer.trim();
   if (!reviewer) throw new Error("A human reviewer name is required.");
-  const record = path9.resolve(recordPath);
+  const record = path10.resolve(recordPath);
   const manifest = await readArtifactBundleManifest(record);
   const options = parseRecordOptions(manifest, record);
   const verification = await verifyArtifactBundle(record);
@@ -10347,14 +10591,14 @@ async function approveQualityRecord(recordPath, approval) {
       `A refinement record must contain exactly ${expectedCount} source(s) and output(s).`
     );
   }
-  const root = path9.dirname(record);
+  const root = path10.dirname(record);
   const outputs = await Promise.all(manifest.outputs.map(async (entry) => {
-    const outputPath = path9.resolve(root, entry.path);
+    const outputPath = path10.resolve(root, entry.path);
     return { path: outputPath, data: await readFile6(outputPath) };
   }));
   const sources = manifest.sources.map((source) => ({
     ...source,
-    path: path9.resolve(root, source.path)
+    path: path10.resolve(root, source.path)
   }));
   const approved = {
     ...options,
@@ -10386,7 +10630,7 @@ async function qualitySource(spec, lock) {
     if (spec.generator === "frames") {
       return { items: null, reason: "frame-set quality requires ordered downloaded provider outputs" };
     }
-    const source = path10.resolve(spec.root, spec.source);
+    const source = path11.resolve(spec.root, spec.source);
     return existsSync6(source) ? { items: [{ role: "source", path: source }] } : { items: null, reason: `declared source is missing: ${spec.source}` };
   }
   const entry = lock.entries[lockKey(spec.styleId, spec.assetId)];
@@ -10453,7 +10697,7 @@ async function inspectQualityProfile(spec, lock) {
     const expectedRevision = spec.quality.fixerRevision ?? PIXEL_ART_FIXER_REVISION;
     const expectedTransparency = spec.quality.minTransparency ?? null;
     const expectedFrameSet = spec.generator === "frames" ? { fps: spec.quality.fps ?? 12, count: source.items.length, roles: source.items.map((item) => item.role) } : null;
-    const contractChanged = JSON.stringify(check.sources.map((item) => path10.resolve(item))) !== JSON.stringify(sourcePaths.map((item) => path10.resolve(item))) || JSON.stringify(check.outputs.map((item) => path10.resolve(item))) !== JSON.stringify(expectedOutputs.map((item) => path10.resolve(item))) || JSON.stringify(check.options.palette.colors) !== JSON.stringify(expectedPalette) || check.options.nativeGrid.revision !== expectedRevision || check.options.audit.thresholds.minGridConfidence !== spec.quality.minGridConfidence || check.options.audit.thresholds.minTransparency !== expectedTransparency || (expectedFrameSet ? !check.options.frameSet || check.options.frameSet.fps !== expectedFrameSet.fps || check.options.frameSet.count !== expectedFrameSet.count || JSON.stringify(check.options.frameSet.roles) !== JSON.stringify(expectedFrameSet.roles) : check.options.frameSet !== void 0);
+    const contractChanged = JSON.stringify(check.sources.map((item) => path11.resolve(item))) !== JSON.stringify(sourcePaths.map((item) => path11.resolve(item))) || JSON.stringify(check.outputs.map((item) => path11.resolve(item))) !== JSON.stringify(expectedOutputs.map((item) => path11.resolve(item))) || JSON.stringify(check.options.palette.colors) !== JSON.stringify(expectedPalette) || check.options.nativeGrid.revision !== expectedRevision || check.options.audit.thresholds.minGridConfidence !== spec.quality.minGridConfidence || check.options.audit.thresholds.minTransparency !== expectedTransparency || (expectedFrameSet ? !check.options.frameSet || check.options.frameSet.fps !== expectedFrameSet.fps || check.options.frameSet.count !== expectedFrameSet.count || JSON.stringify(check.options.frameSet.roles) !== JSON.stringify(expectedFrameSet.roles) : check.options.frameSet !== void 0);
     if (contractChanged) {
       return {
         key,
@@ -10617,7 +10861,7 @@ async function requireApprovedQualitySources(specs, lock, assetIds, outputRoles)
 
 // src/pipeline/revision.ts
 import { existsSync as existsSync7 } from "fs";
-import path11 from "path";
+import path12 from "path";
 async function inspectRevisionReadiness(spec, lock) {
   if (spec.mirror) return inspectMirror(spec, lock, /* @__PURE__ */ new Set());
   if (spec.character?.kind === "outfit") return inspectOutfit(spec, lock, /* @__PURE__ */ new Set());
@@ -10760,8 +11004,8 @@ async function inspectSourceMembers(spec, lock) {
   if (parent.source) return { ready: true, reason: "declared source set is present" };
   const entry = lock.entries[lockKey(parent.styleId, parent.assetId)];
   if (!entry) return { ready: false, reason: "revision source is not in the lockfile" };
-  const recorded = entry.outputs.map((_, index) => path11.resolve(currentEntryOutputPath(entry, parent, index))).sort();
-  const found = members.map((member) => path11.resolve(member.file)).sort();
+  const recorded = entry.outputs.map((_, index) => path12.resolve(currentEntryOutputPath(entry, parent, index))).sort();
+  const found = members.map((member) => path12.resolve(member.file)).sort();
   if (recorded.length !== found.length || recorded.some((file, index) => file !== found[index])) {
     return {
       ready: false,
@@ -10810,7 +11054,7 @@ async function inspectParent(spec, lock, seen) {
     };
   }
   if (spec.source) {
-    const source = path11.resolve(spec.root, spec.source);
+    const source = path12.resolve(spec.root, spec.source);
     return existsSync7(source) ? { ready: true, reason: "declared source is present" } : { ready: false, reason: `declared source is missing: ${spec.source}` };
   }
   const entry = lock.entries[key];
@@ -10889,7 +11133,7 @@ async function buildPlan(specs, lock, opts = {}) {
       state = "missing";
       reason = "--force";
     } else if (!entry && spec.source && spec.generator !== "frames") {
-      if (existsSync8(path12.resolve(spec.root, spec.source))) {
+      if (existsSync8(path13.resolve(spec.root, spec.source))) {
         state = "ok";
         reason = `placed from ${spec.source}; not generated`;
       } else {
@@ -11031,13 +11275,13 @@ function summarize(plan) {
 
 // src/project.ts
 async function openProject(manifestPath = "pixelkiln.manifest.json", opts = {}) {
-  const absolute = path13.resolve(manifestPath);
-  const root = path13.dirname(absolute);
+  const absolute = path14.resolve(manifestPath);
+  const root = path14.dirname(absolute);
   if (opts.env !== false) {
     loadEnvFiles(root);
-    if (path13.resolve(process.cwd()) !== root) loadEnvFiles(process.cwd());
+    if (path14.resolve(process.cwd()) !== root) loadEnvFiles(process.cwd());
   }
-  const lockPath = path13.resolve(opts.lockPath ?? path13.join(root, "pixelkiln.lock.json"));
+  const lockPath = path14.resolve(opts.lockPath ?? path14.join(root, "pixelkiln.lock.json"));
   const loaded = await loadManifest(absolute);
   const specs = await resolveSpecs(loaded, { styles: opts.styles ?? [], assets: opts.assets ?? [] });
   const lock = await loadLock(lockPath);
@@ -11104,7 +11348,7 @@ function shouldPersistSourceUrl(value) {
 }
 
 // src/recipes.ts
-import path14 from "path";
+import path15 from "path";
 import { existsSync as existsSync9 } from "fs";
 import { readdir, readFile as readFile7 } from "fs/promises";
 import { fileURLToPath } from "url";
@@ -11115,7 +11359,7 @@ var VERSION_RE = /^\d+\.\d+\.\d+$/;
 var RECIPE_FILE = "pixelkiln.recipe.json";
 var RECIPE_DIR_TOKEN = "{{recipeDir}}";
 var PortablePathSchema = z4.string().min(1).refine((value) => {
-  if (value.includes("\\") || path14.posix.isAbsolute(value)) return false;
+  if (value.includes("\\") || path15.posix.isAbsolute(value)) return false;
   const parts = value.split("/");
   return !parts.includes("") && !parts.includes(".") && !parts.includes("..");
 }, "expected a portable relative path without '.', '..', or backslashes");
@@ -11291,7 +11535,7 @@ function message3(error) {
   return error instanceof Error ? error.message : String(error);
 }
 async function readRecipeFile(recipePath, bundled) {
-  const absolute = path14.resolve(recipePath);
+  const absolute = path15.resolve(recipePath);
   let raw;
   try {
     raw = JSON.parse(await readFile7(absolute, "utf8"));
@@ -11305,13 +11549,13 @@ async function readRecipeFile(recipePath, bundled) {
 ` + parsed.error.issues.map((issue) => `  ${issue.path.join(".") || "$"}: ${issue.message}`).join("\n")
     );
   }
-  return { recipe: parsed.data, authored: raw, path: absolute, dir: path14.dirname(absolute), bundled };
+  return { recipe: parsed.data, authored: raw, path: absolute, dir: path15.dirname(absolute), bundled };
 }
 async function walkRecipeFiles(root) {
   if (!existsSync9(root)) return [];
   const out = [];
   for (const entry of await readdir(root, { withFileTypes: true })) {
-    const resolved = path14.join(root, entry.name);
+    const resolved = path15.join(root, entry.name);
     if (entry.isDirectory()) out.push(...await walkRecipeFiles(resolved));
     else if (entry.isFile() && entry.name === RECIPE_FILE) out.push(resolved);
   }
@@ -11322,7 +11566,7 @@ function bundledRecipeRoot() {
 }
 async function listBundledRecipes(root = bundledRecipeRoot()) {
   const recipes = await Promise.all(
-    (await walkRecipeFiles(path14.resolve(root))).map((file) => readRecipeFile(file, true))
+    (await walkRecipeFiles(path15.resolve(root))).map((file) => readRecipeFile(file, true))
   );
   return recipes.sort(
     (a, b) => a.recipe.id.localeCompare(b.recipe.id) || compareVersions(b.recipe.version, a.recipe.version)
@@ -11345,9 +11589,9 @@ function parseSelector(selector) {
   return { id: match[1], version: match[2] };
 }
 async function resolveRecipe(target, bundledRoot = bundledRecipeRoot()) {
-  const local = path14.resolve(target);
+  const local = path15.resolve(target);
   if (existsSync9(local)) {
-    const recipePath = path14.basename(local) === RECIPE_FILE ? local : path14.join(local, RECIPE_FILE);
+    const recipePath = path15.basename(local) === RECIPE_FILE ? local : path15.join(local, RECIPE_FILE);
     return readRecipeFile(recipePath, false);
   }
   if (target.startsWith(".") || target.startsWith("/") || target.includes("\\")) {
@@ -11361,7 +11605,7 @@ async function resolveRecipe(target, bundledRoot = bundledRecipeRoot()) {
   return matches[0];
 }
 async function verifyFile(root, file) {
-  const absolute = path14.resolve(root, ...file.path.split("/"));
+  const absolute = path15.resolve(root, ...file.path.split("/"));
   if (!existsSync9(absolute)) {
     return { path: file.path, expectedSha256: file.sha256, actualSha256: null, status: "missing" };
   }
@@ -11377,7 +11621,7 @@ async function verifyRecipe(target, options = {}) {
   const loaded = await resolveRecipe(target, options.bundledRoot);
   const actualIntegrity = recipeDigest(loaded.authored);
   const files = await Promise.all(loaded.recipe.files.map((file) => verifyFile(loaded.dir, file)));
-  const modelRoot = options.modelRoot ? path14.resolve(options.modelRoot) : null;
+  const modelRoot = options.modelRoot ? path15.resolve(options.modelRoot) : null;
   const models = modelRoot ? await Promise.all(loaded.recipe.models.map(async (model) => ({
     ...await verifyFile(modelRoot, model),
     source: model.source,
@@ -11411,7 +11655,7 @@ async function verifyRecipe(target, options = {}) {
   };
 }
 function renderStyle(style, destination, cwd) {
-  const portableDir = path14.relative(cwd, destination).split(path14.sep).join("/") || ".";
+  const portableDir = path15.relative(cwd, destination).split(path15.sep).join("/") || ".";
   const replace = (value) => {
     if (typeof value === "string") return value.replaceAll(RECIPE_DIR_TOKEN, portableDir);
     if (Array.isArray(value)) return value.map(replace);
@@ -11423,19 +11667,19 @@ function renderStyle(style, destination, cwd) {
   return replace(style);
 }
 async function installRecipe(target, options = {}) {
-  const cwd = path14.resolve(options.cwd ?? process.cwd());
+  const cwd = path15.resolve(options.cwd ?? process.cwd());
   const loaded = await resolveRecipe(target, options.bundledRoot);
   const verification = await verifyRecipe(loaded.path);
   if (!verification.ok) {
     throw new Error(`Recipe ${loaded.recipe.id}@${loaded.recipe.version} failed integrity verification.`);
   }
-  const destination = options.out ? path14.resolve(cwd, options.out) : path14.join(cwd, "pixelkiln-recipes", ...loaded.recipe.id.split("/"), loaded.recipe.version);
+  const destination = options.out ? path15.resolve(cwd, options.out) : path15.join(cwd, "pixelkiln-recipes", ...loaded.recipe.id.split("/"), loaded.recipe.version);
   const sources = [
     { path: RECIPE_FILE, source: loaded.path },
-    ...loaded.recipe.files.map((file) => ({ path: file.path, source: path14.join(loaded.dir, ...file.path.split("/")) }))
+    ...loaded.recipe.files.map((file) => ({ path: file.path, source: path15.join(loaded.dir, ...file.path.split("/")) }))
   ];
   const files = await Promise.all(sources.map(async (file) => ({
-    path: path14.join(destination, ...file.path.split("/")),
+    path: path15.join(destination, ...file.path.split("/")),
     data: await readFile7(file.source)
   })));
   if (!options.force) {
@@ -11467,7 +11711,7 @@ async function installRecipe(target, options = {}) {
 // src/pipeline/audit.ts
 import { readFile as readFile8 } from "fs/promises";
 import { existsSync as existsSync10 } from "fs";
-import path15 from "path";
+import path16 from "path";
 function paletteDistance(asset, reference) {
   if (!asset.length || !reference.length) return 0;
   let total = 0;
@@ -11532,7 +11776,7 @@ async function auditStyle(loaded, specs, styleId, lock) {
   let referenceFromStyleImages = false;
   const refPalettes = [];
   for (const img of style.styleImages) {
-    const abs = path15.resolve(loaded.root, img.path);
+    const abs = path16.resolve(loaded.root, img.path);
     if (!existsSync10(abs)) continue;
     try {
       refPalettes.push(extractPalette(decodePng(await readFile8(abs)), 12));
@@ -11613,16 +11857,16 @@ function hex(c) {
 // src/pixellab-utils.ts
 import { existsSync as existsSync11 } from "fs";
 import { mkdir as mkdir4, readFile as readFile9, writeFile as writeFile4 } from "fs/promises";
-import path16 from "path";
+import path17 from "path";
 var UNZOOM_MIN_SIDE = 256;
 var UNZOOM_MAX_AREA = 2048 * 2048;
 function defaultUnzoomOut(input) {
-  const ext = path16.extname(input);
+  const ext = path17.extname(input);
   return `${ext ? input.slice(0, -ext.length) : input}.unzoomed.png`;
 }
 async function unzoomFile(client2, input, opts = {}) {
-  const out = path16.resolve(opts.out ?? defaultUnzoomOut(input));
-  if (path16.resolve(input) === out) throw new Error("unzoom will not overwrite its own input; pass a different --out");
+  const out = path17.resolve(opts.out ?? defaultUnzoomOut(input));
+  if (path17.resolve(input) === out) throw new Error("unzoom will not overwrite its own input; pass a different --out");
   if (existsSync11(out) && !opts.force) throw new Error(`${out} already exists; pass --force to replace it`);
   const bytes = await readFile9(input);
   const metadata = imageMetadata(bytes);
@@ -11637,7 +11881,7 @@ async function unzoomFile(client2, input, opts = {}) {
     throw new Error(`${input} is ${width}x${height}; PixelLab's unzoom takes at most 2048x2048 worth of pixels`);
   }
   const res = await client2.unzoom({ image: { base64: bytes.toString("base64"), format }, quantize: opts.quantize });
-  await mkdir4(path16.dirname(out), { recursive: true });
+  await mkdir4(path17.dirname(out), { recursive: true });
   await writeFile4(out, res.png);
   return { out, original: res.originalSize, unzoomed: res.unzoomedSize, zoomFactor: res.zoomFactor, usage: res.usage };
 }
@@ -11645,7 +11889,7 @@ var FONT_WEIGHTS = ["Bold", "Regular"];
 var FONT_GLYPH_SIZES = [8, 16, 32, 64];
 var FONT_COST_GENERATIONS = 25;
 function fontOutputPaths(out) {
-  const base = path16.resolve(out.replace(/\.(ttf|png)$/i, ""));
+  const base = path17.resolve(out.replace(/\.(ttf|png)$/i, ""));
   return { ttf: `${base}.ttf`, atlas: `${base}.png` };
 }
 async function generateFont(client2, opts) {
@@ -11679,7 +11923,7 @@ async function generateFont(client2, opts) {
         client2.download(job.download_ttf_url),
         client2.download(job.download_atlas_url)
       ]);
-      await mkdir4(path16.dirname(ttf), { recursive: true });
+      await mkdir4(path17.dirname(ttf), { recursive: true });
       await writeFile4(ttf, ttfBytes);
       await writeFile4(atlas, atlasBytes);
       return { jobId, ttf, atlas, glyphPx: job.glyph_px ?? null, usage: job.usage };
@@ -11694,7 +11938,7 @@ async function generateFont(client2, opts) {
 }
 
 // src/pipeline/quality-regression.ts
-import path17 from "path";
+import path18 from "path";
 import { existsSync as existsSync12 } from "fs";
 import { readFile as readFile10 } from "fs/promises";
 import { z as z5 } from "zod";
@@ -11702,7 +11946,7 @@ var SHA256_RE2 = /^[0-9a-f]{64}$/;
 var HEX_RE = /^#[0-9a-f]{6}$/;
 var MAX_REDMEAN_DISTANCE = 765;
 var QualityPathSchema = z5.string().min(1).refine(
-  (value) => !path17.posix.isAbsolute(value) && !value.includes("\\"),
+  (value) => !path18.posix.isAbsolute(value) && !value.includes("\\"),
   "expected a portable relative path"
 );
 var DEFAULT_QUALITY_TOLERANCES = {
@@ -11849,7 +12093,7 @@ function measureDecodedImageQuality(png, digest2) {
   };
 }
 async function measureImageQuality(file) {
-  const absolute = path17.resolve(file);
+  const absolute = path18.resolve(file);
   let bytes;
   try {
     bytes = await readFile10(absolute);
@@ -11871,11 +12115,11 @@ function resolveQualityInputs(raw, inputsFilePath) {
   }
   const ids = parsed.data.map((entry) => entry.id);
   if (new Set(ids).size !== ids.length) throw new Error("--inputs contains a duplicate quality case id.");
-  const root = path17.dirname(path17.resolve(inputsFilePath));
+  const root = path18.dirname(path18.resolve(inputsFilePath));
   return parsed.data.map((entry) => ({
     id: entry.id,
-    file: path17.resolve(root, entry.path),
-    ...entry.record ? { record: path17.resolve(root, entry.record) } : {},
+    file: path18.resolve(root, entry.path),
+    ...entry.record ? { record: path18.resolve(root, entry.record) } : {},
     tolerances: QualityToleranceSchema.parse({
       ...DEFAULT_QUALITY_TOLERANCES,
       ...entry.tolerances
@@ -11883,7 +12127,7 @@ function resolveQualityInputs(raw, inputsFilePath) {
   }));
 }
 function portableRelative2(from, to) {
-  return path17.relative(from, path17.resolve(to)).split(path17.sep).join("/") || ".";
+  return path18.relative(from, path18.resolve(to)).split(path18.sep).join("/") || ".";
 }
 async function verifyRecordForImage(recordPath, imagePath) {
   const verification = await verifyArtifactBundle(recordPath);
@@ -11898,20 +12142,20 @@ async function verifyRecordForImage(recordPath, imagePath) {
   if (record.kind !== "refine" || options === null || typeof options !== "object" || options.schema !== "pixelkiln-quality") {
     throw new Error(`Quality record ${recordPath} is not a PixelKiln refinement record.`);
   }
-  const outputs = record.outputs.map((output) => path17.resolve(path17.dirname(recordPath), output.path));
-  if (!outputs.includes(path17.resolve(imagePath))) {
+  const outputs = record.outputs.map((output) => path18.resolve(path18.dirname(recordPath), output.path));
+  if (!outputs.includes(path18.resolve(imagePath))) {
     throw new Error(`Quality record ${recordPath} does not own ${imagePath}.`);
   }
 }
 async function snapshotQualityBaseline(inputs, baselinePath, options = {}) {
   if (!inputs.length) throw new Error("Cannot snapshot an empty quality baseline.");
-  const absolute = path17.resolve(baselinePath);
+  const absolute = path18.resolve(baselinePath);
   for (const input of inputs) {
-    if (path17.resolve(input.file) === absolute || input.record && path17.resolve(input.record) === absolute) {
+    if (path18.resolve(input.file) === absolute || input.record && path18.resolve(input.record) === absolute) {
       throw new Error(`Quality baseline output would overwrite an input: ${absolute}.`);
     }
   }
-  const root = path17.dirname(absolute);
+  const root = path18.dirname(absolute);
   const cases = [];
   for (const input of [...inputs].sort((a, b) => a.id.localeCompare(b.id))) {
     const expected = await measureImageQuality(input.file);
@@ -11951,7 +12195,7 @@ async function snapshotQualityBaseline(inputs, baselinePath, options = {}) {
   return { baseline, path: absolute, changed: result.changed.length > 0 };
 }
 async function readQualityBaseline(baselinePath) {
-  const absolute = path17.resolve(baselinePath);
+  const absolute = path18.resolve(baselinePath);
   let raw;
   try {
     raw = JSON.parse(await readFile10(absolute, "utf8"));
@@ -12024,12 +12268,12 @@ function regressionViolations(expected, actual, tolerances) {
   return { violations, warnings };
 }
 async function checkQualityBaseline(baselinePath) {
-  const absolute = path17.resolve(baselinePath);
+  const absolute = path18.resolve(baselinePath);
   const baseline = await readQualityBaseline(absolute);
-  const root = path17.dirname(absolute);
+  const root = path18.dirname(absolute);
   const cases = [];
   for (const entry of baseline.cases) {
-    const file = path17.resolve(root, entry.file);
+    const file = path18.resolve(root, entry.file);
     let actual = null;
     const violations = [];
     const warnings = [];
@@ -12042,7 +12286,7 @@ async function checkQualityBaseline(baselinePath) {
       violations.push(message4(error));
     }
     if (entry.record) {
-      const recordPath = path17.resolve(root, entry.record.path);
+      const recordPath = path18.resolve(root, entry.record.path);
       try {
         const recordHash = await sha256File(recordPath);
         if (recordHash !== entry.record.sha256) violations.push("quality record hash changed");
@@ -12080,7 +12324,7 @@ async function checkQualityBaseline(baselinePath) {
 // src/pipeline/cache-health.ts
 import { existsSync as existsSync16 } from "fs";
 import { readFile as readFile13, readdir as readdir2, rm as rm6 } from "fs/promises";
-import path20 from "path";
+import path21 from "path";
 
 // src/cache.ts
 import { mkdir as mkdir5, readFile as readFile11, rename as rename4, rm as rm4, writeFile as writeFile5 } from "fs/promises";
@@ -12099,10 +12343,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(path38) {
+  if (!existsSync13(path38)) return { version: 1, hashes: {} };
   try {
-    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile11(path36, "utf8")));
+    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile11(path38, "utf8")));
     if (!parsed.success) return { version: 1, hashes: {} };
     return {
       version: 1,
@@ -12114,18 +12358,18 @@ async function loadCache(path36) {
     return { version: 1, hashes: {} };
   }
 }
-async function saveCache(path36, cache) {
+async function saveCache(path38, 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(path38)), { recursive: true });
+  const tmp = `${path38}.${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, path38);
   } finally {
     await rm4(tmp, { force: true });
   }
@@ -12150,19 +12394,19 @@ function cachePathFor(lockPath) {
 
 // src/pipeline/history.ts
 import { existsSync as existsSync15 } from "fs";
-import path19 from "path";
+import path20 from "path";
 
 // src/pipeline/fetch.ts
-import { existsSync as existsSync14, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync4 } from "fs";
 import { mkdir as mkdir6, readFile as readFile12, rename as rename5, rm as rm5, writeFile as writeFile6 } from "fs/promises";
-import path18 from "path";
+import path19 from "path";
 async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
   const log = opts.onProgress ?? (() => {
   });
   const result = { downloaded: 0, skipped: 0, failed: 0, ...opts.refresh ? { unchanged: 0 } : {} };
   const specByKey = new Map(specs.map((s) => [lockKey(s.styleId, s.assetId), s]));
   normalizeLockOutputPaths(lock, specs);
-  const cacheDir = opts.cacheDir === false ? null : path18.resolve(opts.cacheDir ?? path18.join(path18.dirname(lockPath), ".pixelkiln", "cache"));
+  const cacheDir = opts.cacheDir === false ? null : path19.resolve(opts.cacheDir ?? path19.join(path19.dirname(lockPath), ".pixelkiln", "cache"));
   const pending = Object.entries(lock.entries).filter(([key, e]) => {
     if (e.provider !== provider.id || !specByKey.has(key)) return false;
     if (specByKey.get(key)?.mirror) return false;
@@ -12173,7 +12417,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
     if (spec && e.specHash === spec.specHash && e.outputs.length && !postprocessCurrent(e, spec)) {
       return Boolean(opts.force) || e.outputs.every((output) => {
         const file = resolveOutputPath(output.path, spec.root);
-        return existsSync14(file) && sha256(readFileSync3(file)) === output.sha256;
+        return existsSync14(file) && sha256(readFileSync4(file)) === output.sha256;
       });
     }
     if (!opts.repair) return false;
@@ -12181,7 +12425,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
     return e.outputs.some((output) => {
       const file = resolveOutputPath(output.path, spec.root);
       if (!existsSync14(file)) return true;
-      const current = sha256(readFileSync3(file));
+      const current = sha256(readFileSync4(file));
       if (current === output.sha256) return false;
       return Boolean(opts.force) || (e.supersededOutputs ?? []).some((old) => old.sha256 === current);
     });
@@ -12264,7 +12508,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
             if (!source.url) throw new Error(`no durable source URL to refresh ${source.role ?? "asset"} from`);
             fresh = await provider.download(source.url);
             if (recorded && sha256(fresh) === recordedRaw && !reapply) {
-              log(`  current ${path18.relative(process.cwd(), target)}`);
+              log(`  current ${path19.relative(process.cwd(), target)}`);
               outputs.push({ ...recorded, path: portableOutputPath(target, spec.root) });
               continue;
             }
@@ -12288,9 +12532,9 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
               }
               if (reapply && !fresh) {
                 if (!recorded.raw) raw = await readFile12(target);
-                log(`  reapply ${path18.relative(process.cwd(), target)}`);
+                log(`  reapply ${path19.relative(process.cwd(), target)}`);
               } else {
-                log(`  changed ${path18.relative(process.cwd(), target)} (upstream)`);
+                log(`  changed ${path19.relative(process.cwd(), target)} (upstream)`);
               }
             } else {
               const superseded = (entry.supersededOutputs ?? []).find(
@@ -12318,7 +12562,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
                 }
               }
               log(
-                `  replace ${path18.relative(process.cwd(), target)}` + (opts.force ? " (--force)" : " (previous tracked generation)")
+                `  replace ${path19.relative(process.cwd(), target)}` + (opts.force ? " (--force)" : " (previous tracked generation)")
               );
             }
           }
@@ -12327,7 +12571,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
           } else if (!raw && recorded && cacheDir) {
             if (!reapply) final = await readCachedMedia(cacheDir, recorded.sha256, expectedMediaType);
             if (!final && recordedRaw) raw = await readCachedMedia(cacheDir, recordedRaw, expectedMediaType);
-            if (final || raw) log(`  cached  ${path18.relative(process.cwd(), target)}`);
+            if (final || raw) log(`  cached  ${path19.relative(process.cwd(), target)}`);
           }
           if (!final && !raw) {
             if (!source.url) {
@@ -12354,11 +12598,11 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
             buf = processed.bytes;
             if (processed.changed) {
               rawHash = sha256(raw);
-              log(`  snapped ${path18.relative(process.cwd(), target)} to ${wanted.palette.colors.length} colours`);
+              log(`  snapped ${path19.relative(process.cwd(), target)} to ${wanted.palette.colors.length} colours`);
             }
           }
           if (cacheDir) await cacheMedia(cacheDir, buf, mediaType);
-          await mkdir6(path18.dirname(target), { recursive: true });
+          await mkdir6(path19.dirname(target), { recursive: true });
           const tmp = `${target}.pixelkiln.tmp`;
           await writeFile6(tmp, buf);
           outputs.push({
@@ -12372,7 +12616,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
           await saveLock(lockPath, lock);
           await rename5(tmp, target);
           wrote = true;
-          log(`  wrote   ${path18.relative(process.cwd(), target)}`);
+          log(`  wrote   ${path19.relative(process.cwd(), target)}`);
         }
         if (opts.refresh && !wrote) {
           if (rotated) {
@@ -12416,7 +12660,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
   return result;
 }
 async function readCachedMedia(cacheDir, hash, mediaType) {
-  const file = path18.join(cacheDir, cacheFileName(hash, mediaType));
+  const file = path19.join(cacheDir, cacheFileName(hash, mediaType));
   if (!existsSync14(file)) return null;
   try {
     const buf = await readFile12(file);
@@ -12430,7 +12674,7 @@ async function readCachedMedia(cacheDir, hash, mediaType) {
 async function cacheMedia(cacheDir, buf, mediaType, knownHash) {
   const hash = knownHash ?? sha256(buf);
   validateMedia(buf, mediaType);
-  const file = path18.join(cacheDir, cacheFileName(hash, mediaType));
+  const file = path19.join(cacheDir, cacheFileName(hash, mediaType));
   if (await readCachedMedia(cacheDir, hash, mediaType)) return;
   await mkdir6(cacheDir, { recursive: true });
   const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
@@ -12560,7 +12804,7 @@ async function revertGeneration(provider, spec, lock, lockPath, opts) {
     if (!existsSync15(file)) continue;
     if (await sha256File(file) !== entry.outputs[i].sha256 && !opts.force) {
       throw new OverwriteRefusedError(
-        `${path19.relative(process.cwd(), file)} was changed after download; keep it with pixelkiln edit, or pass --force to replace it`,
+        `${path20.relative(process.cwd(), file)} was changed after download; keep it with pixelkiln edit, or pass --force to replace it`,
         [file]
       );
     }
@@ -12613,10 +12857,10 @@ async function revertGeneration(provider, spec, lock, lockPath, opts) {
 // src/pipeline/cache-health.ts
 async function inspectCaches(lock, lockPath, options = {}) {
   if (options.prune && !existsSync16(lockPath)) {
-    throw new Error(`Refusing to prune without an existing lockfile at ${path20.resolve(lockPath)}`);
+    throw new Error(`Refusing to prune without an existing lockfile at ${path21.resolve(lockPath)}`);
   }
-  const contentDir = path20.resolve(path20.dirname(lockPath), ".pixelkiln", "cache");
-  const remotePath = path20.resolve(cachePathFor(lockPath));
+  const contentDir = path21.resolve(path21.dirname(lockPath), ".pixelkiln", "cache");
+  const remotePath = path21.resolve(cachePathFor(lockPath));
   const referenced = referencedHashes(lock);
   let content = await inspectContentCache(contentDir, referenced);
   let remoteHashes = await inspectRemoteHashCache(remotePath);
@@ -12628,7 +12872,7 @@ async function inspectCaches(lock, lockPath, options = {}) {
     ]);
     for (const name of names) {
       try {
-        await rm6(path20.join(contentDir, name), { force: true });
+        await rm6(path21.join(contentDir, name), { force: true });
         removed.contentFiles++;
       } catch {
       }
@@ -12676,7 +12920,7 @@ async function inspectContentCache(contentDir, referenced) {
       continue;
     }
     report.files++;
-    const file = path20.join(contentDir, entry.name);
+    const file = path21.join(contentDir, entry.name);
     const mediaType = mediaTypeFromExtension(entry.name);
     const expected = mediaType ? entry.name.slice(0, -4) : "";
     let bytes;
@@ -12743,20 +12987,20 @@ async function inspectRemoteHashCache(remotePath) {
 }
 
 // src/pipeline/pack.ts
-import { readFileSync as readFileSync4 } from "fs";
-import path21 from "path";
+import { readFileSync as readFileSync5 } from "fs";
+import path22 from "path";
 var DEFAULT_FRAME_SET_FPS = 12;
 function resolvePackInputs(raw, inputsFilePath) {
   if (!Array.isArray(raw) || !raw.length) {
     throw new Error("--inputs must be a non-empty JSON array of { id, path }");
   }
-  const baseDir = path21.dirname(path21.resolve(inputsFilePath));
+  const baseDir = path22.dirname(path22.resolve(inputsFilePath));
   return raw.map((entry, i) => {
     const e = entry;
     if (typeof e.id !== "string" || typeof e.path !== "string") {
       throw new Error(`--inputs[${i}] needs string "id" and "path"`);
     }
-    return { id: e.id, path: path21.resolve(baseDir, e.path) };
+    return { id: e.id, path: path22.resolve(baseDir, e.path) };
   });
 }
 function packSprites(inputs, options = {}) {
@@ -12777,7 +13021,7 @@ function packSprites(inputs, options = {}) {
   for (const input of ordered) {
     let sourceHash = null;
     try {
-      const bytes = readFileSync4(input.path);
+      const bytes = readFileSync5(input.path);
       sourceHash = sha256(bytes);
       const png = decodePng(bytes);
       sprites.push({ id: input.id, width: png.width, height: png.height, pixels: png.pixels });
@@ -12840,7 +13084,7 @@ function packStyle(lock, styleId, manifestDir, options = {}) {
     }
     const inputs2 = Object.entries(options.sourceOverrides).map(([id, source]) => ({
       id,
-      path: path21.resolve(source)
+      path: path22.resolve(source)
     }));
     if (!inputs2.length) throw new Error(`No approved quality outputs for style "${styleId}".`);
     const packed2 = packSprites(inputs2, options);
@@ -12864,7 +13108,7 @@ function packStyle(lock, styleId, manifestDir, options = {}) {
     let outputs = resolveEntryOutputs(entry, id, manifestDir);
     const source = sources[id];
     if (source && outputs.length <= 1) {
-      inputs.push({ id, path: path21.resolve(manifestDir, source) });
+      inputs.push({ id, path: path22.resolve(manifestDir, source) });
       continue;
     }
     if (source && sourceIsStem(source, entry, manifestDir)) {
@@ -12898,7 +13142,7 @@ function packStyle(lock, styleId, manifestDir, options = {}) {
     }
   }
   for (const [id, source] of Object.entries(sources)) {
-    if (!locked.has(id)) inputs.push({ id, path: path21.resolve(manifestDir, source) });
+    if (!locked.has(id)) inputs.push({ id, path: path22.resolve(manifestDir, source) });
   }
   if (!inputs.length) {
     throw new Error(`No readable sprites for style "${styleId}"; ${noOutput.length} skipped.`);
@@ -12935,7 +13179,7 @@ function mountSprites(placements, options) {
   for (const p of placements) {
     let sourceHash = null;
     try {
-      const bytes = readFileSync4(p.path);
+      const bytes = readFileSync5(p.path);
       sourceHash = sha256(bytes);
       const png = decodePng(bytes);
       if (png.width > cellWidth || png.height > cellHeight) {
@@ -13006,7 +13250,7 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
     const source = sources[id];
     const entry = lock.entries[`${styleId}/${id}`];
     if (source && !(entry && sourceIsStem(source, entry, manifestDir))) {
-      placements.push({ id, path: path21.resolve(manifestDir, source), cell });
+      placements.push({ id, path: path22.resolve(manifestDir, source), cell });
       continue;
     }
     if (source && entry) {
@@ -13039,7 +13283,7 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
       `Nothing to mount for style "${styleId}": ${ids.length} asset(s) declare a cell, but none has generated output or a \`source\`. Run \`pixelkiln gen --style ${styleId}\`, or point each at a file.${detail}`
     );
   }
-  const basePng = mount.base ? readFileSync4(path21.resolve(manifestDir, mount.base)) : void 0;
+  const basePng = mount.base ? readFileSync5(path22.resolve(manifestDir, mount.base)) : void 0;
   const mounted = mountSprites(placements, {
     cellWidth: mount.cellWidth,
     cellHeight: mount.cellHeight,
@@ -13049,7 +13293,7 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
     ...mounted,
     sources: mount.base ? [{
       id: "$base",
-      path: path21.resolve(manifestDir, mount.base),
+      path: path22.resolve(manifestDir, mount.base),
       sha256: sha256(basePng),
       included: true
     }, ...mounted.sources] : mounted.sources,
@@ -13641,6 +13885,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 ? {
@@ -13857,7 +14105,7 @@ async function poll(provider, lock, lockPath, opts = {}) {
 // src/pipeline/doctor.ts
 import { constants, existsSync as existsSync17 } from "fs";
 import { access, stat as stat2 } from "fs/promises";
-import path22 from "path";
+import path23 from "path";
 async function doctor(loaded, specs, lock, lockPath, opts = {}) {
   const checks = [];
   const add = (id, level, message6) => checks.push({ id, level, message: message6 });
@@ -13868,8 +14116,8 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
   );
   add("lock", "ok", `${Object.keys(lock.entries).length} valid v2 lock entr(ies)`);
   const dirs = [...new Set(specs.flatMap((spec) => [
-    path22.dirname(spec.outFile),
-    ...spec.quality ? [path22.dirname(spec.quality.outFile)] : []
+    path23.dirname(spec.outFile),
+    ...spec.quality ? [path23.dirname(spec.quality.outFile)] : []
   ]))];
   const unwritable = [];
   for (const dir of dirs) {
@@ -13892,7 +14140,7 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
     for (let index = 0; index < entry.outputs.length; index++) {
       const output = entry.outputs[index];
       const spec = specByKey.get(key);
-      const absolute = spec ? currentEntryOutputPath(entry, spec, index) : resolveOutputPath(output.path, path22.dirname(lockPath));
+      const absolute = spec ? currentEntryOutputPath(entry, spec, index) : resolveOutputPath(output.path, path23.dirname(lockPath));
       const owner = outputOwners.get(absolute);
       if (owner && owner !== key) duplicateOutputs.push(`${output.path} (${owner}, ${key})`);
       outputOwners.set(absolute, key);
@@ -13907,7 +14155,7 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
   } else {
     add("lock-outputs", "ok", `${outputOwners.size} recorded output path(s) are uniquely owned`);
   }
-  const cacheDir = path22.join(path22.dirname(lockPath), ".pixelkiln", "cache");
+  const cacheDir = path23.join(path23.dirname(lockPath), ".pixelkiln", "cache");
   const stranded = [];
   const invalidState = [];
   const staleMapUrls = [];
@@ -13923,7 +14171,7 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
     const hasSource = Boolean(entry.sourceUrl || entry.sourceUrls?.length);
     let hasCache = false;
     for (const output of entry.outputs) {
-      const cached = path22.join(
+      const cached = path23.join(
         cacheDir,
         cacheFileName(output.sha256, output.mediaType ?? MediaType.PNG)
       );
@@ -14023,7 +14271,7 @@ async function nearestExistingDirectory(start) {
       if ((await stat2(current)).isDirectory()) return current;
     } catch {
     }
-    const parent = path22.dirname(current);
+    const parent = path23.dirname(current);
     if (parent === current) return current;
     current = parent;
   }
@@ -14032,7 +14280,7 @@ async function nearestExistingDirectory(start) {
 // src/pipeline/adopt.ts
 import { existsSync as existsSync18 } from "fs";
 import { readFile as readFile14, writeFile as writeFile7 } from "fs/promises";
-import path23 from "path";
+import path24 from "path";
 async function adopt(provider, specs, lock, lockPath, opts = {}) {
   const log = opts.onProgress ?? (() => {
   });
@@ -14171,7 +14419,7 @@ import { readFile as readFile17 } from "fs/promises";
 // src/pipeline/init.ts
 import { readdir as readdir3, readFile as readFile15, writeFile as writeFile8 } from "fs/promises";
 import { existsSync as existsSync19 } from "fs";
-import path24 from "path";
+import path25 from "path";
 function pngSize(buf) {
   if (buf.length < 24) return null;
   const isPng = buf.readUInt32BE(0) === 2303741511 && buf.readUInt32BE(4) === 218765834;
@@ -14185,7 +14433,7 @@ function slugify(value) {
 async function walk(dir, exclude) {
   const out = [];
   for (const entry of await readdir3(dir, { withFileTypes: true })) {
-    const full = path24.join(dir, entry.name);
+    const full = path25.join(dir, entry.name);
     if (exclude.some((x) => full.includes(x))) continue;
     if (entry.isDirectory()) out.push(...await walk(full, exclude));
     else if (entry.name.toLowerCase().endsWith(".png")) out.push(full);
@@ -14204,9 +14452,9 @@ async function scanAssets(root, opts = {}) {
       skipped.push(`${file} (not a readable PNG)`);
       continue;
     }
-    const rel = path24.relative(root, file);
-    const category = path24.dirname(rel) === "." ? "" : path24.dirname(rel);
-    let id = slugify(path24.basename(rel));
+    const rel = path25.relative(root, file);
+    const category = path25.dirname(rel) === "." ? "" : path25.dirname(rel);
+    let id = slugify(path25.basename(rel));
     if (seen.has(id)) {
       const n = seen.get(id) + 1;
       seen.set(id, n);
@@ -14929,15 +15177,15 @@ 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 { createHash as createHash5 } from "crypto";
+import { existsSync as existsSync26 } from "fs";
+import { readFile as readFile24, stat as stat3 } from "fs/promises";
+import path33 from "path";
 
 // src/workspace.ts
 import { mkdir as mkdir7, readFile as readFile18, rename as rename6, rm as rm7, writeFile as writeFile9 } from "fs/promises";
 import { existsSync as existsSync21 } from "fs";
-import path25 from "path";
+import path26 from "path";
 import { z as z7 } from "zod";
 var WorkspaceProjectSchema = z7.object({
   id: z7.string().min(1),
@@ -14979,7 +15227,7 @@ async function saveWorkspace(workspacePath, ws) {
     version: 1,
     projects: [...ws.projects].sort((a, b) => a.id.localeCompare(b.id))
   };
-  await mkdir7(path25.dirname(path25.resolve(workspacePath)), { recursive: true });
+  await mkdir7(path26.dirname(path26.resolve(workspacePath)), { recursive: true });
   const tmp = `${workspacePath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
     await writeFile9(tmp, JSON.stringify(sorted, null, 2) + "\n");
@@ -14989,12 +15237,12 @@ async function saveWorkspace(workspacePath, ws) {
   }
 }
 function toPortablePath(dir, absolute) {
-  return path25.relative(dir, absolute).split(path25.sep).join("/");
+  return path26.relative(dir, absolute).split(path26.sep).join("/");
 }
 function resolveProject(dir, project) {
   return {
-    manifestPath: path25.resolve(dir, project.manifest.split("/").join(path25.sep)),
-    lockPath: path25.resolve(dir, project.lock.split("/").join(path25.sep))
+    manifestPath: path26.resolve(dir, project.manifest.split("/").join(path26.sep)),
+    lockPath: path26.resolve(dir, project.lock.split("/").join(path26.sep))
   };
 }
 function validateWorkspace(ws, dir) {
@@ -15007,7 +15255,7 @@ function validateWorkspace(ws, dir) {
     const { manifestPath, lockPath } = resolveProject(dir, project);
     lockOwners.set(lockPath, [...lockOwners.get(lockPath) ?? [], project.id]);
     manifestOwners.set(manifestPath, [...manifestOwners.get(manifestPath) ?? [], project.id]);
-    if (path25.isAbsolute(project.manifest) || path25.isAbsolute(project.lock)) {
+    if (path26.isAbsolute(project.manifest) || path26.isAbsolute(project.lock)) {
       diagnostics.push({
         id: "absolute-path",
         level: "warning",
@@ -15068,15 +15316,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 path32 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 path27 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) => !path27.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 +15374,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 and
-   * `interpolate` an ending-keyframe image the gallery does not offer, so
-   * those two are hand-edited; every other mode can be created here
-   * (`animate-skeleton` after the gallery writes its keypoints file).
+   * 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({
@@ -15145,15 +15395,38 @@ var NewAssetSchema = z8.object({
       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(),
-      /** `animate-pixminimax` only; the loader refuses it on `animate`. */
-      direction: CharacterDirectionSchema.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"),
@@ -15471,7 +15744,7 @@ function applyEdit(raw, edit) {
   }
 }
 async function withCandidate(manifestPath, edit, use, unchanged) {
-  const absolute = path26.resolve(manifestPath);
+  const absolute = path27.resolve(manifestPath);
   const original = await readFile19(absolute, "utf8");
   if (sha256(original) !== edit.expectedSha256) throw new ManifestDriftError(absolute);
   let raw;
@@ -15485,9 +15758,9 @@ async function withCandidate(manifestPath, edit, use, unchanged) {
   applyEdit(raw, edit);
   const next = serializeLike(original, raw);
   if (next === original) return unchanged(absolute, original);
-  const tmp = path26.join(
-    path26.dirname(absolute),
-    `.${path26.basename(absolute)}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`
+  const tmp = path27.join(
+    path27.dirname(absolute),
+    `.${path27.basename(absolute)}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`
   );
   try {
     await writeFile10(tmp, next);
@@ -15518,16 +15791,16 @@ async function applyManifestEdit(manifestPath, edit) {
 // src/pipeline/hand-edit.ts
 import { existsSync as existsSync22 } from "fs";
 import { copyFile, mkdir as mkdir8, readFile as readFile20, rename as rename8, rm as rm9, writeFile as writeFile11 } from "fs/promises";
-import path27 from "path";
+import path28 from "path";
 import { z as z9 } from "zod";
 var HAND_EDIT_DIR = "edits";
 function handEditPath(loaded, spec) {
   const style = loaded.manifest.styles[spec.styleId];
-  const outDir = path27.resolve(loaded.root, style?.outDir ?? ".");
-  const relative = path27.relative(outDir, spec.outFile);
-  const inside = relative && !relative.startsWith("..") && !path27.isAbsolute(relative);
-  const file = inside ? relative : path27.basename(spec.outFile);
-  return path27.join(outDir, HAND_EDIT_DIR, file.replace(/\.gif$/i, ".png"));
+  const outDir = path28.resolve(loaded.root, style?.outDir ?? ".");
+  const relative = path28.relative(outDir, spec.outFile);
+  const inside = relative && !relative.startsWith("..") && !path28.isAbsolute(relative);
+  const file = inside ? relative : path28.basename(spec.outFile);
+  return path28.join(outDir, HAND_EDIT_DIR, file.replace(/\.gif$/i, ".png"));
 }
 function handEditBases(spec, lock) {
   const entry = lock.entries[lockKey(spec.styleId, spec.assetId)];
@@ -15573,7 +15846,7 @@ async function startHandEdit(loaded, lock, spec, opts = {}) {
       `${spec.styleId}/${spec.assetId} declares ${spec.source}, one committed file placed for the whole set; clear that source (pixelkiln edit detach) to hand-edit the members one by one`
     );
   }
-  const existing = spec.source ? path27.resolve(loaded.root, spec.source) : null;
+  const existing = spec.source ? path28.resolve(loaded.root, spec.source) : null;
   const editPath = existing ?? handEditPath(loaded, spec);
   const members = handEditMembers(loaded, spec, lock, editPath);
   let created = false;
@@ -15584,7 +15857,7 @@ async function startHandEdit(loaded, lock, spec, opts = {}) {
         `${spec.styleId}/${spec.assetId} has no generated PNG on disk to start from; generate or restore it first`
       );
     }
-    await mkdir8(path27.dirname(member.path), { recursive: true });
+    await mkdir8(path28.dirname(member.path), { recursive: true });
     await copyFile(member.base, member.path);
     created = true;
   }
@@ -15722,7 +15995,7 @@ async function saveHandEdit(loaded, lock, spec, input) {
     editor: input.editor,
     protocol: input.protocol,
     savedAt: (input.now ?? /* @__PURE__ */ new Date()).toISOString(),
-    project: projectPath ? path27.basename(projectPath) : null,
+    project: projectPath ? path28.basename(projectPath) : null,
     outputs: incoming.map((frame, index) => ({
       role: frame.role,
       basedOn: basedOnHash(entry, index),
@@ -15766,7 +16039,7 @@ function openInEditor(file, editor = process.env.PIXELKILN_EDITOR) {
 // src/gallery/upload.ts
 import { existsSync as existsSync23 } from "fs";
 import { mkdir as mkdir9, writeFile as writeFile12 } from "fs/promises";
-import path28 from "path";
+import path29 from "path";
 import { z as z10 } from "zod";
 var MAX_UPLOAD_BYTES = 8 * 1024 * 1024;
 var UploadImageSchema = z10.object({
@@ -15779,12 +16052,12 @@ var UploadImageSchema = z10.object({
   overwrite: z10.boolean().optional()
 }).strict();
 async function saveProjectImage(root, request) {
-  const file = path28.resolve(root, request.path);
-  const relative = path28.relative(root, file);
-  if (relative.startsWith("..") || path28.isAbsolute(relative)) {
+  const file = path29.resolve(root, request.path);
+  const relative = path29.relative(root, file);
+  if (relative.startsWith("..") || path29.isAbsolute(relative)) {
     throw new ManifestEditError("an upload must stay inside the project");
   }
-  const extension = path28.extname(file).toLowerCase();
+  const extension = path29.extname(file).toLowerCase();
   const expected = extension === ".png" ? "png" : extension === ".jpg" || extension === ".jpeg" ? "jpeg" : null;
   if (!expected) throw new ManifestEditError("an upload must be a .png, .jpg, or .jpeg path");
   const bytes = Buffer.from(request.base64, "base64");
@@ -15797,69 +16070,125 @@ async function saveProjectImage(root, request) {
     throw new ManifestEditError(`the upload is a ${metadata.format.toUpperCase()}; name it ${metadata.format === "png" ? ".png" : ".jpg"}`);
   }
   if (existsSync23(file) && !request.overwrite) {
-    throw new ManifestEditError(`${relative.split(path28.sep).join("/")} already exists; choose another name, or replace it`);
+    throw new ManifestEditError(`${relative.split(path29.sep).join("/")} already exists; choose another name, or replace it`);
   }
-  await mkdir9(path28.dirname(file), { recursive: true });
+  await mkdir9(path29.dirname(file), { recursive: true });
   await writeFile12(file, bytes);
-  return relative.split(path28.sep).join("/");
+  return relative.split(path29.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 path29 from "path";
+import { readFile as readFile21, rm as rm10, writeFile as writeFile13 } from "fs/promises";
+import path30 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 = path30.dirname(path30.resolve(manifestPath));
+  if (path30.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 = path30.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 path31 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 = path31.dirname(path31.resolve(manifestPath));
+  const file = path31.resolve(root, request.keypointsFile);
+  const relative = path31.relative(root, file);
+  if (!request.keypointsFile.endsWith(".json") || relative.startsWith("..") || path31.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(path31.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`);
   }
@@ -15874,7 +16203,7 @@ async function createSkeletonAnimation(manifestPath, request) {
         revision: {
           mode: "animate-skeleton",
           from: request.from,
-          keypointsFile: relative.split(path29.sep).join("/"),
+          keypointsFile: relative.split(path31.sep).join("/"),
           direction: request.direction,
           ...request.description ? { description: request.description } : {},
           ...request.skeletonTemplate ? { skeletonTemplate: request.skeletonTemplate } : {}
@@ -15883,8 +16212,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;
   }
@@ -15895,64 +16224,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 = path31.relative(ctx.loaded.root, file);
+  if (relative.startsWith("..") || path31.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(path31.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(path31.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 ?? (() => {
@@ -15961,7 +16290,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 path32.resolve(await opts.manifestFor(typeof project === "string" ? project : void 0));
     } catch {
       return null;
     }
@@ -15971,7 +16300,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];
@@ -15981,17 +16310,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 ${path32.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) });
@@ -16046,7 +16375,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(path32.dirname(path32.resolve(manifestPath2)), upload.data);
       log(`  image added: ${written}`);
       return opts.reload();
     }
@@ -16082,6 +16411,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(
@@ -16096,7 +16442,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 = path32.relative(process.cwd(), result.manifestPath);
       const shown = !relative || relative.startsWith("..") ? result.manifestPath : relative;
       log(`  manifest edited: ${describeEdit(parsed.data)} in ${shown}`);
     }
@@ -16124,7 +16470,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 createHash5("sha256").update(path33.resolve(absolutePath)).digest("hex").slice(0, 24);
 }
 function galleryMediaRoute(id) {
   return `/media/${id}`;
@@ -16143,9 +16489,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 = path33.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)}`;
@@ -16177,7 +16523,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);
@@ -16275,10 +16621,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, path33.resolve(root, file)))
   );
-  const recordPath = path31.resolve(root, inspection.record);
-  const recordExists = existsSync25(recordPath);
+  const recordPath = path33.resolve(root, inspection.record);
+  const recordExists = existsSync26(recordPath);
   let options = null;
   let check = null;
   if (recordExists) {
@@ -16297,7 +16643,7 @@ async function describeQuality(media, root, inspection) {
   return {
     state: inspection.state,
     reason: inspection.reason,
-    output: portableOutputPath(path31.resolve(root, inspection.output), root),
+    output: portableOutputPath(path33.resolve(root, inspection.output), root),
     record: portableOutputPath(recordPath, root),
     recordExists,
     outputs,
@@ -16335,9 +16681,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 = path33.resolve(path33.dirname(opts.lockPath), ".pixelkiln", "cache");
   let rawStyles = {};
   try {
     const raw = JSON.parse(manifestText);
@@ -16361,12 +16707,12 @@ async function buildGallerySnapshot(opts) {
         )
       );
       if (spec.source) {
-        const editPath = path31.resolve(root, spec.source);
+        const editPath = path33.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 })));
@@ -16374,7 +16720,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);
@@ -16410,8 +16756,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, path33.resolve(root, spec.source))];
+    } else if (!entry && existsSync26(spec.outFile)) {
       outputs = [await describeOutput(media, root, spec.outFile)];
     } else {
       outputs = [];
@@ -16614,7 +16960,7 @@ async function buildGallerySnapshot(opts) {
       id: loaded.manifest.name,
       name: loaded.manifest.name,
       manifest: loaded.path,
-      lock: path31.resolve(opts.lockPath),
+      lock: path33.resolve(opts.lockPath),
       root,
       provider: loaded.manifest.provider,
       account: null,
@@ -16640,7 +16986,7 @@ async function buildGallerySnapshot(opts) {
   return { snapshot, media };
 }
 async function buildWorkspaceGallerySnapshot(opts) {
-  const dir = path31.dirname(path31.resolve(opts.workspacePath));
+  const dir = path33.dirname(path33.resolve(opts.workspacePath));
   const media = /* @__PURE__ */ new Map();
   const projects = [];
   const items = [];
@@ -16683,11 +17029,11 @@ async function buildWorkspaceGallerySnapshot(opts) {
         id: project.id,
         name: loaded.manifest.name,
         manifest: manifestPath,
-        lock: path31.resolve(lockPath),
+        lock: path33.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,
@@ -16699,8 +17045,8 @@ async function buildWorkspaceGallerySnapshot(opts) {
         id: project.id,
         name: project.id,
         manifest: manifestPath,
-        lock: path31.resolve(lockPath),
-        root: path31.dirname(manifestPath),
+        lock: path33.resolve(lockPath),
+        root: path33.dirname(manifestPath),
         provider: project.provider,
         account: project.account ?? null,
         manifestSha256: null,
@@ -16727,7 +17073,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: path33.resolve(opts.workspacePath), dir, projects },
       filter,
       totals: {
         entries: projects.reduce((sum, project) => sum + project.entries, 0),
@@ -16744,7 +17090,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
 }
 
 // src/gallery/page.ts
-import { existsSync as existsSync26, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync27, readFileSync as readFileSync6 } from "fs";
 
 // src/gallery/client-bundle.ts
 import { createRequire } from "module";
@@ -16784,8 +17130,8 @@ var client;
 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()
+    css: readFileSync6(new URL("gallery.css", CLIENT_DIR), "utf8"),
+    js: existsSync27(prebuilt) ? readFileSync6(prebuilt, "utf8") : bundleGalleryClient()
   };
   return client;
 }
@@ -16927,11 +17273,11 @@ var EDITOR_PIN = pin_default;
 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 os2 from "os";
-import path32 from "path";
+import { createHash as createHash6 } from "crypto";
+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 os3 from "os";
+import path34 from "path";
 var EditorInstallError = class extends Error {
   constructor(message6, file) {
     super(message6);
@@ -16942,15 +17288,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 path34.resolve(override);
+  if (process.platform === "darwin") return path34.join(os3.homedir(), "Library", "Caches", "pixelkiln", "tools");
   if (process.platform === "win32") {
-    return path32.join(process.env.LOCALAPPDATA ?? path32.join(os2.homedir(), "AppData", "Local"), "pixelkiln", "tools");
+    return path34.join(process.env.LOCALAPPDATA ?? path34.join(os3.homedir(), "AppData", "Local"), "pixelkiln", "tools");
   }
-  return path32.join(process.env.XDG_CACHE_HOME ?? path32.join(os2.homedir(), ".cache"), "pixelkiln", "tools");
+  return path34.join(process.env.XDG_CACHE_HOME ?? path34.join(os3.homedir(), ".cache"), "pixelkiln", "tools");
 }
 function editorDir(pin = EDITOR_PIN, root = editorToolsRoot()) {
-  return path32.join(root, "pixelorama", pin.release ?? "unpublished");
+  return path34.join(root, "pixelorama", pin.release ?? "unpublished");
 }
 function editorBaseUrl(pin = EDITOR_PIN) {
   const override = process.env.PIXELKILN_EDITOR_URL?.trim();
@@ -16960,7 +17306,7 @@ function editorBaseUrl(pin = EDITOR_PIN) {
 }
 async function sha256Of(file) {
   try {
-    return createHash5("sha256").update(await readFile24(file)).digest("hex");
+    return createHash6("sha256").update(await readFile25(file)).digest("hex");
   } catch {
     return null;
   }
@@ -16973,8 +17319,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 = path34.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 {
@@ -17027,17 +17373,17 @@ async function installEditor(opts = {}) {
     if (bytes.length !== expected.bytes) {
       throw new EditorInstallError(`${name}: expected ${expected.bytes} bytes, got ${bytes.length}`, name);
     }
-    const digest2 = createHash5("sha256").update(bytes).digest("hex");
+    const digest2 = createHash6("sha256").update(bytes).digest("hex");
     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 = path34.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);
@@ -17077,12 +17423,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[path34.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 path35 from "path";
 function editorRoute(release, name = "index.html") {
   return `/editor/${encodeURIComponent(release)}/${encodeURIComponent(name)}`;
 }
@@ -17155,7 +17501,7 @@ function createGalleryEditorHandlers(opts = {}) {
       if (!status.installed) return null;
       let bytes;
       try {
-        bytes = await readFile25(path33.join(dir, name));
+        bytes = await readFile26(path35.join(dir, name));
       } catch {
         verified = null;
         return null;
@@ -17172,7 +17518,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'",
@@ -17353,7 +17699,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",
@@ -17436,7 +17782,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");
         }
@@ -17480,27 +17826,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" });
@@ -17846,19 +18192,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 path36 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}`);
     }
@@ -17962,20 +18308,20 @@ function matchOrphanStyle(prompt, manifest) {
   return matchStyleByPattern(prompt, manifest);
 }
 async function loadSiblingManifests(ownManifestPath, workspaceManifestPaths, claimPaths) {
-  const own = path34.resolve(ownManifestPath);
+  const own = path36.resolve(ownManifestPath);
   const siblingManifestPaths = [
     .../* @__PURE__ */ new Set([
       ...workspaceManifestPaths,
-      ...claimPaths.map((c) => path34.join(path34.dirname(path34.resolve(c)), "pixelkiln.manifest.json"))
+      ...claimPaths.map((c) => path36.join(path36.dirname(path36.resolve(c)), "pixelkiln.manifest.json"))
     ])
   ];
   const siblings = [];
   for (const siblingManifestPath of siblingManifestPaths) {
-    if (path34.resolve(siblingManifestPath) === own) continue;
-    if (!existsSync28(siblingManifestPath)) continue;
+    if (path36.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: path36.basename(path36.dirname(siblingManifestPath)), manifest });
     } catch {
     }
   }
@@ -18095,8 +18441,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 path37 from "path";
 
 // src/pick/salvage-sheet.ts
 var escapeHtml3 = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
@@ -18262,7 +18608,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
   });
   const html = renderSalvageSheet(orphans, {
     styleId: ctx.styleId,
-    importDir: path35.relative(process.cwd(), ctx.importDir) || "."
+    importDir: path37.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]));
@@ -18318,10 +18664,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 = path37.join("_salvaged", `${assetId}.png`);
+            const outFile = path37.resolve(ctx.importDir, rel);
+            await mkdir12(path37.dirname(outFile), { recursive: true });
+            await writeFile17(outFile, buf);
             ctx.manifest.assets[assetId] = {
               prompt: orphan.prompt,
               promptByStyle: {},
@@ -18353,7 +18699,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, path37.dirname(ctx.manifestPath)),
                 sha256: sha256(buf)
               }],
               submittedAt: orphan.createdAt,
@@ -18377,9 +18723,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;