npm - pixelkiln - Versions diffs - 0.84.0 → 0.85.0 - Mend

pixelkiln 0.84.0 → 0.85.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

package/PROVIDERS.md +3 -3
package/dist/cli.js +462 -346
package/dist/cli.js.map +1 -1
package/dist/index.cjs +549 -433
package/dist/index.cjs.map +1 -1
package/dist/index.d.cts +25 -0
package/dist/index.d.ts +25 -0
package/dist/index.js +444 -328
package/dist/index.js.map +1 -1
package/docs/REVISIONS.md +4 -2
package/docs/SCENARIO.md +174 -7
package/package.json +1 -1
package/skills/pixelkiln/references/scenario.md +8 -4

package/dist/index.js CHANGED Viewed

@@ -1816,9 +1816,9 @@ var PixelLabClient = class {
   apiKey;
   http;
   /** Retries transport failures, 429, and 5xx; see http.ts for the policy. */
-  async request(path37, init) {
+  async request(path38, init) {
     const auth = this.apiKey.startsWith("Bearer ") ? this.apiKey : `Bearer ${this.apiKey}`;
-    const res = await this.http(`${BASE}${path37}`, {
+    const res = await this.http(`${BASE}${path38}`, {
       ...init,
       headers: {
         Authorization: auth,
@@ -1828,13 +1828,13 @@ var PixelLabClient = class {
     });
     const text = await res.text();
     if (!res.ok) {
-      throw new PixelLabError(`${init?.method ?? "GET"} ${path37} \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"} ${path37} returned invalid JSON`);
+      throw new Error(`${init?.method ?? "GET"} ${path38} returned invalid JSON`);
     }
   }
   async balance() {
@@ -2239,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 path37;
+    let path38;
     let body;
     if (args.mode === "v3") {
-      path37 = "/create-character-v3";
+      path38 = "/create-character-v3";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -2256,7 +2256,7 @@ var PixelLabClient = class {
         ...args.enhancePrompt ? { enhance_prompt: true } : {}
       };
     } else if (args.mode === "pro-flash") {
-      path37 = "/create-character-pro-flash";
+      path38 = "/create-character-pro-flash";
       const traits = args.styleTraits;
       body = {
         description: args.description,
@@ -2280,7 +2280,7 @@ var PixelLabClient = class {
         } : {}
       };
     } else if (args.mode === "pro") {
-      path37 = "/create-character-pro";
+      path38 = "/create-character-pro";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -2294,7 +2294,7 @@ var PixelLabClient = class {
         ...!south && args.styleCharacterId ? { style_character_id: args.styleCharacterId } : {}
       };
     } else {
-      path37 = 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,
@@ -2311,8 +2311,8 @@ var PixelLabClient = class {
         ...palette
       };
     }
-    const raw = await this.request(path37, { method: "POST", body: JSON.stringify(body) });
-    return validateResponse(CharacterSubmitSchema, raw, path37.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) {
@@ -3525,10 +3525,10 @@ import { createReadStream } from "fs";
 function sha256(data) {
   return createHash("sha256").update(data).digest("hex");
 }
-async function sha256File(path37) {
+async function sha256File(path38) {
   return new Promise((resolve, reject) => {
     const hash = createHash("sha256");
-    const stream = createReadStream(path37);
+    const stream = createReadStream(path38);
     stream.on("data", (chunk2) => hash.update(chunk2));
     stream.on("error", reject);
     stream.on("end", () => resolve(hash.digest("hex")));
@@ -5932,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(path37, init = {}) {
+  async call(path38, init = {}) {
     if (!this.token) throw new Error("RD_API_KEY is not set");
-    const response = await this.request(`${this.baseUrl}${path37}`, {
+    const response = await this.request(`${this.baseUrl}${path38}`, {
       ...init,
       headers: {
         "Content-Type": "application/json",
@@ -6243,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",
@@ -6291,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;
@@ -6299,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;
@@ -6425,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 {
@@ -6445,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");
@@ -6462,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(
@@ -6479,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 } : {}
       }
     };
   }
@@ -6501,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",
@@ -6556,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;
 }
@@ -6571,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,
@@ -6663,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`
     );
   }
@@ -6732,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",
@@ -6869,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");
@@ -6924,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);
@@ -7636,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"
@@ -7738,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() {
@@ -7887,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"];
@@ -7976,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 {
@@ -7998,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));
@@ -8010,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);
@@ -8155,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}`;
@@ -8184,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);
@@ -8274,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: ""
   }];
 }
@@ -8290,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) {
@@ -8383,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;
@@ -8484,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}`);
@@ -8514,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();
@@ -8615,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;
@@ -8712,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 }
           }
         } : {},
@@ -8848,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,
@@ -8870,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,
@@ -9053,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) {
@@ -9063,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(
@@ -9140,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}`);
@@ -9171,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;
@@ -9179,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,
@@ -9200,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,
@@ -9231,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) {
@@ -9259,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",
@@ -9279,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)) {
@@ -9297,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 {
     }
   }
@@ -9327,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) {
@@ -9470,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);
@@ -9533,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;
@@ -9604,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) {
@@ -9628,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) {
@@ -9649,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 });
@@ -9665,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.`
       );
@@ -9711,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)
@@ -9741,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);
@@ -9763,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);
@@ -9791,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;
     }
@@ -9807,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) {
@@ -9863,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) {
@@ -9893,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,
@@ -9932,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" });
     }
@@ -10198,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.");
@@ -10224,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 {
@@ -10310,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 = [];
@@ -10329,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,
@@ -10405,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,
@@ -10416,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;
@@ -10454,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);
@@ -10475,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,
@@ -10514,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)];
@@ -10581,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,
@@ -10745,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());
@@ -10888,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,
@@ -10938,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];
@@ -11017,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 {
@@ -11159,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);
@@ -11232,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";
@@ -11243,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");
@@ -11419,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"));
@@ -11433,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);
   }
@@ -11450,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)
@@ -11473,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("\\")) {
@@ -11489,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" };
   }
@@ -11505,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,
@@ -11539,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);
@@ -11551,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) {
@@ -11595,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;
@@ -11660,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));
@@ -11741,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);
@@ -11765,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 };
 }
@@ -11773,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) {
@@ -11807,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 };
@@ -11822,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";
@@ -11830,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 = {
@@ -11977,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);
@@ -11999,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
@@ -12011,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);
@@ -12026,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);
@@ -12079,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"));
@@ -12152,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 = [];
@@ -12170,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");
@@ -12208,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";
@@ -12227,10 +12343,10 @@ function isSha256Hash(value) {
 function parseCache(value) {
   return HashCacheSchema.parse(value);
 }
-async function loadCache(path37) {
-  if (!existsSync13(path37)) return { version: 1, hashes: {} };
+async function loadCache(path38) {
+  if (!existsSync13(path38)) return { version: 1, hashes: {} };
   try {
-    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile11(path37, "utf8")));
+    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile11(path38, "utf8")));
     if (!parsed.success) return { version: 1, hashes: {} };
     return {
       version: 1,
@@ -12242,18 +12358,18 @@ async function loadCache(path37) {
     return { version: 1, hashes: {} };
   }
 }
-async function saveCache(path37, 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(path37)), { recursive: true });
-  const tmp = `${path37}.${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, path37);
+    await rename4(tmp, path38);
   } finally {
     await rm4(tmp, { force: true });
   }
@@ -12278,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;
@@ -12301,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;
@@ -12309,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);
     });
@@ -12392,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;
             }
@@ -12416,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(
@@ -12446,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)")
               );
             }
           }
@@ -12455,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) {
@@ -12482,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({
@@ -12500,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) {
@@ -12544,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);
@@ -12558,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`;
@@ -12688,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]
       );
     }
@@ -12741,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);
@@ -12756,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 {
       }
@@ -12804,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;
@@ -12871,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 = {}) {
@@ -12905,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 });
@@ -12968,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);
@@ -12992,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)) {
@@ -13026,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.`);
@@ -13063,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) {
@@ -13134,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) {
@@ -13167,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,
@@ -13177,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,
@@ -13989,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 });
@@ -14000,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) {
@@ -14024,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);
@@ -14039,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 = [];
@@ -14055,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)
       );
@@ -14155,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;
   }
@@ -14164,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 ?? (() => {
   });
@@ -14303,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;
@@ -14317,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);
@@ -14336,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);
@@ -15061,15 +15177,15 @@ async function runPicker(provider, lock, lockPath, opts = {}) {
 }
 // src/gallery/snapshot.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 import { existsSync as existsSync26 } from "fs";
 import { readFile as readFile24, stat as stat3 } from "fs/promises";
-import path32 from "path";
+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),
@@ -15111,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");
@@ -15121,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) {
@@ -15139,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",
@@ -15201,15 +15317,15 @@ function validateWorkspace(ws, dir) {
 // src/gallery/edit.ts
 import { readFile as readFile23, rename as rename9, writeFile as writeFile15 } from "fs/promises";
-import path31 from "path";
+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) => !path26.isAbsolute(file) && !file.split(/[\\/]/).includes(".."), "must be a path inside the project");
+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. */
@@ -15628,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;
@@ -15642,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);
@@ -15675,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)];
@@ -15730,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;
@@ -15741,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;
   }
@@ -15879,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),
@@ -15923,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({
@@ -15936,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");
@@ -15954,17 +16070,17 @@ 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/image-revision.ts
 import { existsSync as existsSync24 } from "fs";
 import { readFile as readFile21, rm as rm10, writeFile as writeFile13 } from "fs/promises";
-import path29 from "path";
+import path30 from "path";
 import { z as z11 } from "zod";
 var InpaintRevisionRequestSchema = z11.object({
   action: z11.literal("create-inpaint-revision"),
@@ -15983,14 +16099,14 @@ var InpaintRevisionRequestSchema = z11.object({
   overwrite: z11.boolean().optional()
 }).strict();
 async function createInpaintRevision(manifestPath, request) {
-  const root = path29.dirname(path29.resolve(manifestPath));
-  if (path29.extname(request.maskPath).toLowerCase() !== ".png") {
+  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 = path29.resolve(root, request.maskPath);
+  const file = path30.resolve(root, request.maskPath);
   const previous = existsSync24(file) ? await readFile21(file) : null;
   const mask = await saveProjectImage(root, {
     action: "upload-image",
@@ -16020,7 +16136,7 @@ async function createInpaintRevision(manifestPath, request) {
 // src/gallery/skeleton.ts
 import { existsSync as existsSync25 } from "fs";
 import { mkdir as mkdir10, readFile as readFile22, rm as rm11, writeFile as writeFile14 } from "fs/promises";
-import path30 from "path";
+import path31 from "path";
 import { z as z12 } from "zod";
 var SkeletonEstimateRequestSchema = z12.object({
   project: z12.string().min(1).optional(),
@@ -16058,10 +16174,10 @@ var SkeletonKeypointsUpdateSchema = z12.object({
   set: SkeletonSetSchema
 }).strict();
 async function createSkeletonAnimation(manifestPath, request) {
-  const root = path30.dirname(path30.resolve(manifestPath));
-  const file = path30.resolve(root, request.keypointsFile);
-  const relative = path30.relative(root, file);
-  if (!request.keypointsFile.endsWith(".json") || relative.startsWith("..") || path30.isAbsolute(relative)) {
+  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 = existsSync25(file);
@@ -16071,7 +16187,7 @@ async function createSkeletonAnimation(manifestPath, request) {
       throw new ManifestEditError(`${request.keypointsFile} already exists; choose another path, or replace it`);
     }
     if (existed) previous = await readFile22(file);
-    await mkdir10(path30.dirname(file), { recursive: true });
+    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`);
@@ -16087,7 +16203,7 @@ async function createSkeletonAnimation(manifestPath, request) {
         revision: {
           mode: "animate-skeleton",
           from: request.from,
-          keypointsFile: relative.split(path30.sep).join("/"),
+          keypointsFile: relative.split(path31.sep).join("/"),
           direction: request.direction,
           ...request.description ? { description: request.description } : {},
           ...request.skeletonTemplate ? { skeletonTemplate: request.skeletonTemplate } : {}
@@ -16108,19 +16224,19 @@ 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 = path30.relative(ctx.loaded.root, file);
-  if (relative.startsWith("..") || path30.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 = existsSync25(file) ? sha256(await readFile22(file)) : null;
   if (current !== request.expectedSha256) {
     throw Object.assign(
-      new Error(`${relative.split(path30.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 writeFile14(file, JSON.stringify(request.set, null, 2) + "\n");
-  return relative.split(path30.sep).join("/");
+  return relative.split(path31.sep).join("/");
 }
 // src/gallery/edit.ts
@@ -16174,7 +16290,7 @@ function createGalleryEditHandler(opts) {
   const history = /* @__PURE__ */ new Map();
   const manifestOf = async (project) => {
     try {
-      return path31.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;
     }
@@ -16197,7 +16313,7 @@ function createGalleryEditHandler(opts) {
       await writeFile15(tmp, last.before);
       await rename9(tmp, manifestPath2);
       stack.pop();
-      log(`  manifest edit undone in ${path31.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);
@@ -16259,7 +16375,7 @@ function createEditApplier(opts, log) {
       } catch (error) {
         throw new ManifestEditError(error instanceof Error ? error.message : String(error));
       }
-      const written = await saveProjectImage(path31.dirname(path31.resolve(manifestPath2)), upload.data);
+      const written = await saveProjectImage(path32.dirname(path32.resolve(manifestPath2)), upload.data);
       log(`  image added: ${written}`);
       return opts.reload();
     }
@@ -16326,7 +16442,7 @@ function createEditApplier(opts, log) {
     }
     const result = await applyManifestEdit(manifestPath, parsed.data);
     if (result.changed) {
-      const relative = path31.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}`);
     }
@@ -16354,7 +16470,7 @@ function describeEdit(edit) {
 // src/gallery/snapshot.ts
 var PROJECT_FILE_TYPE = "application/octet-stream";
 function galleryMediaId(absolutePath) {
-  return createHash4("sha256").update(path32.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}`;
@@ -16373,7 +16489,7 @@ 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 = path32.join(cacheDir, cacheFileName(output.sha256, mediaType));
+      const file = path33.join(cacheDir, cacheFileName(output.sha256, mediaType));
       let url = null;
       if (existsSync26(file)) {
         const id = galleryMediaId(file);
@@ -16505,9 +16621,9 @@ 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, path32.resolve(root, file)))
+    outputPaths.map((file) => describeOutput(media, root, path33.resolve(root, file)))
   );
-  const recordPath = path32.resolve(root, inspection.record);
+  const recordPath = path33.resolve(root, inspection.record);
   const recordExists = existsSync26(recordPath);
   let options = null;
   let check = null;
@@ -16527,7 +16643,7 @@ async function describeQuality(media, root, inspection) {
   return {
     state: inspection.state,
     reason: inspection.reason,
-    output: portableOutputPath(path32.resolve(root, inspection.output), root),
+    output: portableOutputPath(path33.resolve(root, inspection.output), root),
     record: portableOutputPath(recordPath, root),
     recordExists,
     outputs,
@@ -16567,7 +16683,7 @@ async function buildGallerySnapshot(opts) {
   const items = [];
   const manifestText = await readFile24(loaded.path, "utf8");
   const manifestSha256 = sha256(manifestText);
-  const cacheDir = path32.resolve(path32.dirname(opts.lockPath), ".pixelkiln", "cache");
+  const cacheDir = path33.resolve(path33.dirname(opts.lockPath), ".pixelkiln", "cache");
   let rawStyles = {};
   try {
     const raw = JSON.parse(manifestText);
@@ -16591,7 +16707,7 @@ async function buildGallerySnapshot(opts) {
         )
       );
       if (spec.source) {
-        const editPath = path32.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) => {
@@ -16640,7 +16756,7 @@ 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, path32.resolve(root, spec.source))];
+      outputs = [await describeOutput(media, root, path33.resolve(root, spec.source))];
     } else if (!entry && existsSync26(spec.outFile)) {
       outputs = [await describeOutput(media, root, spec.outFile)];
     } else {
@@ -16844,7 +16960,7 @@ async function buildGallerySnapshot(opts) {
       id: loaded.manifest.name,
       name: loaded.manifest.name,
       manifest: loaded.path,
-      lock: path32.resolve(opts.lockPath),
+      lock: path33.resolve(opts.lockPath),
       root,
       provider: loaded.manifest.provider,
       account: null,
@@ -16870,7 +16986,7 @@ async function buildGallerySnapshot(opts) {
   return { snapshot, media };
 }
 async function buildWorkspaceGallerySnapshot(opts) {
-  const dir = path32.dirname(path32.resolve(opts.workspacePath));
+  const dir = path33.dirname(path33.resolve(opts.workspacePath));
   const media = /* @__PURE__ */ new Map();
   const projects = [];
   const items = [];
@@ -16913,7 +17029,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
         id: project.id,
         name: loaded.manifest.name,
         manifest: manifestPath,
-        lock: path32.resolve(lockPath),
+        lock: path33.resolve(lockPath),
         root: loaded.root,
         provider: loaded.manifest.provider,
         account: project.account ?? null,
@@ -16929,8 +17045,8 @@ async function buildWorkspaceGallerySnapshot(opts) {
         id: project.id,
         name: project.id,
         manifest: manifestPath,
-        lock: path32.resolve(lockPath),
-        root: path32.dirname(manifestPath),
+        lock: path33.resolve(lockPath),
+        root: path33.dirname(manifestPath),
         provider: project.provider,
         account: project.account ?? null,
         manifestSha256: null,
@@ -16957,7 +17073,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
       version: 1,
       generatedAt: (opts.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
       project: null,
-      workspace: { path: path32.resolve(opts.workspacePath), dir, projects },
+      workspace: { path: path33.resolve(opts.workspacePath), dir, projects },
       filter,
       totals: {
         entries: projects.reduce((sum, project) => sum + project.entries, 0),
@@ -16974,7 +17090,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
 }
 // src/gallery/page.ts
-import { existsSync as existsSync27, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync27, readFileSync as readFileSync6 } from "fs";
 // src/gallery/client-bundle.ts
 import { createRequire } from "module";
@@ -17014,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: existsSync27(prebuilt) ? readFileSync5(prebuilt, "utf8") : bundleGalleryClient()
+    css: readFileSync6(new URL("gallery.css", CLIENT_DIR), "utf8"),
+    js: existsSync27(prebuilt) ? readFileSync6(prebuilt, "utf8") : bundleGalleryClient()
   };
   return client;
 }
@@ -17157,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 { 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 os2 from "os";
-import path33 from "path";
+import os3 from "os";
+import path34 from "path";
 var EditorInstallError = class extends Error {
   constructor(message6, file) {
     super(message6);
@@ -17172,15 +17288,15 @@ var EditorInstallError = class extends Error {
 };
 function editorToolsRoot() {
   const override = process.env.PIXELKILN_TOOLS_DIR?.trim();
-  if (override) return path33.resolve(override);
-  if (process.platform === "darwin") return path33.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 path33.join(process.env.LOCALAPPDATA ?? path33.join(os2.homedir(), "AppData", "Local"), "pixelkiln", "tools");
+    return path34.join(process.env.LOCALAPPDATA ?? path34.join(os3.homedir(), "AppData", "Local"), "pixelkiln", "tools");
   }
-  return path33.join(process.env.XDG_CACHE_HOME ?? path33.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 path33.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();
@@ -17190,7 +17306,7 @@ function editorBaseUrl(pin = EDITOR_PIN) {
 }
 async function sha256Of(file) {
   try {
-    return createHash5("sha256").update(await readFile25(file)).digest("hex");
+    return createHash6("sha256").update(await readFile25(file)).digest("hex");
   } catch {
     return null;
   }
@@ -17203,7 +17319,7 @@ async function editorStatus(opts = {}) {
   let totalBytes = 0;
   for (const [name, expected] of Object.entries(pin.files)) {
     totalBytes += expected.bytes;
-    const file = path33.join(dir, name);
+    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;
@@ -17257,11 +17373,11 @@ 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 = path33.join(dir, name);
+    const final = path34.join(dir, name);
     const tmp = `${final}.${process.pid}.part`;
     try {
       await writeFile16(tmp, bytes);
@@ -17307,12 +17423,12 @@ var EDITOR_CONTENT_TYPES = {
   ".json": "application/json; charset=utf-8"
 };
 function editorContentType(name) {
-  return EDITOR_CONTENT_TYPES[path33.extname(name).toLowerCase()] ?? null;
+  return EDITOR_CONTENT_TYPES[path34.extname(name).toLowerCase()] ?? null;
 }
 // src/gallery/editor.ts
 import { readFile as readFile26 } from "fs/promises";
-import path34 from "path";
+import path35 from "path";
 function editorRoute(release, name = "index.html") {
   return `/editor/${encodeURIComponent(release)}/${encodeURIComponent(name)}`;
 }
@@ -17385,7 +17501,7 @@ function createGalleryEditorHandlers(opts = {}) {
       if (!status.installed) return null;
       let bytes;
       try {
-        bytes = await readFile26(path34.join(dir, name));
+        bytes = await readFile26(path35.join(dir, name));
       } catch {
         verified = null;
         return null;
@@ -18078,7 +18194,7 @@ function createGenerateHandlers(opts) {
 // src/pipeline/salvage.ts
 import { readFile as readFile28 } from "fs/promises";
 import { existsSync as existsSync29 } from "fs";
-import path35 from "path";
+import path36 from "path";
 function providerClaimId(provider, objectId) {
   return `${encodeURIComponent(provider)}:${encodeURIComponent(objectId)}`;
 }
@@ -18192,20 +18308,20 @@ function matchOrphanStyle(prompt, manifest) {
   return matchStyleByPattern(prompt, manifest);
 }
 async function loadSiblingManifests(ownManifestPath, workspaceManifestPaths, claimPaths) {
-  const own = path35.resolve(ownManifestPath);
+  const own = path36.resolve(ownManifestPath);
   const siblingManifestPaths = [
     .../* @__PURE__ */ new Set([
       ...workspaceManifestPaths,
-      ...claimPaths.map((c) => path35.join(path35.dirname(path35.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 (path35.resolve(siblingManifestPath) === own) continue;
+    if (path36.resolve(siblingManifestPath) === own) continue;
     if (!existsSync29(siblingManifestPath)) continue;
     try {
       const { manifest } = await loadManifest(siblingManifestPath);
-      siblings.push({ label: path35.basename(path35.dirname(siblingManifestPath)), manifest });
+      siblings.push({ label: path36.basename(path36.dirname(siblingManifestPath)), manifest });
     } catch {
     }
   }
@@ -18326,7 +18442,7 @@ async function applyTags(provider, decisions, existing, opts = {}) {
 // src/pick/salvage-server.ts
 import { mkdir as mkdir12, writeFile as writeFile17, readFile as readFile29 } from "fs/promises";
-import path36 from "path";
+import path37 from "path";
 // src/pick/salvage-sheet.ts
 var escapeHtml3 = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
@@ -18492,7 +18608,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
   });
   const html = renderSalvageSheet(orphans, {
     styleId: ctx.styleId,
-    importDir: path36.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]));
@@ -18548,9 +18664,9 @@ 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 = path36.join("_salvaged", `${assetId}.png`);
-            const outFile = path36.resolve(ctx.importDir, rel);
-            await mkdir12(path36.dirname(outFile), { recursive: true });
+            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,
@@ -18583,7 +18699,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
               sourceUrl: durableSource,
               sourceUrls: durableSource ? [{ url: durableSource }] : [],
               outputs: [{
-                path: portableOutputPath(outFile, path36.dirname(ctx.manifestPath)),
+                path: portableOutputPath(outFile, path37.dirname(ctx.manifestPath)),
                 sha256: sha256(buf)
               }],
               submittedAt: orphan.createdAt,