pixelkiln 0.84.0 → 0.85.0

package/dist/cli.js

@@ -665,10 +665,10 @@ import { createReadStream } from "fs";
 function sha256(data) {
   return createHash("sha256").update(data).digest("hex");
 }
-async function sha256File(path51) {
+async function sha256File(path52) {
   return new Promise((resolve, reject) => {
     const hash = createHash("sha256");
-    const stream = createReadStream(path51);
+    const stream = createReadStream(path52);
     stream.on("data", (chunk2) => hash.update(chunk2));
     stream.on("error", reject);
     stream.on("end", () => resolve(hash.digest("hex")));
@@ -4818,7 +4818,7 @@ async function confirm(question, auto) {
 }
 
 // src/cli/commands/account.ts
-import path22 from "path";
+import path23 from "path";
 import { existsSync as existsSync16 } from "fs";
 
 // src/env.ts
@@ -6251,9 +6251,9 @@ var PixelLabClient = class {
   apiKey;
   http;
   /** Retries transport failures, 429, and 5xx; see http.ts for the policy. */
-  async request(path51, init) {
+  async request(path52, init) {
     const auth = this.apiKey.startsWith("Bearer ") ? this.apiKey : `Bearer ${this.apiKey}`;
-    const res = await this.http(`${BASE}${path51}`, {
+    const res = await this.http(`${BASE}${path52}`, {
       ...init,
       headers: {
         Authorization: auth,
@@ -6263,13 +6263,13 @@ var PixelLabClient = class {
     });
     const text = await res.text();
     if (!res.ok) {
-      throw new PixelLabError(`${init?.method ?? "GET"} ${path51} \u2192 ${res.status}`, res.status, text);
+      throw new PixelLabError(`${init?.method ?? "GET"} ${path52} \u2192 ${res.status}`, res.status, text);
     }
     if (!text) return {};
     try {
       return JSON.parse(text);
     } catch {
-      throw new Error(`${init?.method ?? "GET"} ${path51} returned invalid JSON`);
+      throw new Error(`${init?.method ?? "GET"} ${path52} returned invalid JSON`);
     }
   }
   async balance() {
@@ -6674,10 +6674,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 path51;
+    let path52;
     let body;
     if (args.mode === "v3") {
-      path51 = "/create-character-v3";
+      path52 = "/create-character-v3";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -6691,7 +6691,7 @@ var PixelLabClient = class {
         ...args.enhancePrompt ? { enhance_prompt: true } : {}
       };
     } else if (args.mode === "pro-flash") {
-      path51 = "/create-character-pro-flash";
+      path52 = "/create-character-pro-flash";
       const traits = args.styleTraits;
       body = {
         description: args.description,
@@ -6715,7 +6715,7 @@ var PixelLabClient = class {
         } : {}
       };
     } else if (args.mode === "pro") {
-      path51 = "/create-character-pro";
+      path52 = "/create-character-pro";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -6729,7 +6729,7 @@ var PixelLabClient = class {
         ...!south && args.styleCharacterId ? { style_character_id: args.styleCharacterId } : {}
       };
     } else {
-      path51 = args.directions === 4 ? "/create-character-with-4-directions" : "/create-character-with-8-directions";
+      path52 = args.directions === 4 ? "/create-character-with-4-directions" : "/create-character-with-8-directions";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -6746,8 +6746,8 @@ var PixelLabClient = class {
         ...palette
       };
     }
-    const raw = await this.request(path51, { method: "POST", body: JSON.stringify(body) });
-    return validateResponse(CharacterSubmitSchema, raw, path51.slice(1));
+    const raw = await this.request(path52, { method: "POST", body: JSON.stringify(body) });
+    return validateResponse(CharacterSubmitSchema, raw, path52.slice(1));
   }
   /** A text edit of an existing character, applied to every direction and stored as a sibling. */
   async createCharacterState(args) {
@@ -9725,9 +9725,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(path51, init = {}) {
+  async call(path52, init = {}) {
     if (!this.token) throw new Error("RD_API_KEY is not set");
-    const response = await this.request(`${this.baseUrl}${path51}`, {
+    const response = await this.request(`${this.baseUrl}${path52}`, {
       ...init,
       headers: {
         "Content-Type": "application/json",
@@ -10036,8 +10036,13 @@ function retroError(value) {
 }
 
 // src/providers/scenario.ts
+import { createHash as createHash3 } from "crypto";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, renameSync, writeFileSync as writeFileSync2 } from "fs";
+import os2 from "os";
+import path13 from "path";
 var DEFAULT_BASE_URL3 = "https://api.cloud.scenario.com/v1";
 var SOURCE_PROTOCOL2 = "scenario:";
+var SUBMIT_RETRIES = 8;
 var PROTECTED_PARAMETERS = /* @__PURE__ */ new Set([
   "dryRun",
   "height",
@@ -10084,7 +10089,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;
@@ -10092,6 +10101,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;
@@ -10218,6 +10250,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 {
@@ -10238,11 +10278,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");
@@ -10255,7 +10315,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(
@@ -10272,7 +10337,8 @@ var ScenarioProvider = class _ScenarioProvider {
         quotedComputeUnits: quote.total,
         creativeUnitsCost: quote.creativeUnitsCost,
         costDetails: quote.costDetails,
-        ipDetectionCost: quote.ipDetectionCost
+        ipDetectionCost: quote.ipDetectionCost,
+        ...referenceAssetIds.length ? { referenceAssetIds } : {}
       }
     };
   }
@@ -10294,7 +10360,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",
@@ -10349,6 +10421,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 ?? path13.join(os2.tmpdir(), "pixelkiln-scenario", "uploads.json");
+}
+function uploadCacheKey(baseUrl, projectId, digest2) {
+  return createHash3("sha256").update(`${baseUrl}
+${projectId ?? ""}
+${digest2}`).digest("hex");
+}
+function readUploadCache() {
+  try {
+    const value = JSON.parse(readFileSync3(uploadCachePath(), "utf8"));
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  } catch {
+    return {};
+  }
+}
+function writeUploadCache(key, assetId) {
+  try {
+    const file = uploadCachePath();
+    mkdirSync2(path13.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;
 }
@@ -10364,9 +10462,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 = readFileSync3(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,
@@ -10456,9 +10570,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`
     );
   }
@@ -10586,7 +10702,7 @@ registerProvider({
 // src/manifest.ts
 import { readFile as readFile6 } from "fs/promises";
 import { existsSync as existsSync8 } from "fs";
-import path13 from "path";
+import path14 from "path";
 
 // src/loop-directions.ts
 var SINGLE_OUTPUT_FIELDS = ["file", "cell", "remoteId", "source", "sourceByStyle", "outputRole"];
@@ -10675,7 +10791,7 @@ function isObject2(value) {
 
 // src/manifest.ts
 async function loadManifest(manifestPath) {
-  const abs = path13.resolve(manifestPath);
+  const abs = path14.resolve(manifestPath);
   if (!existsSync8(abs)) throw new ProjectError(`No manifest at ${abs}`);
   const expansion = expandLoopDirections(JSON.parse(await readFile6(abs, "utf8")));
   if (expansion.issues.length) {
@@ -10768,7 +10884,7 @@ ${issues}`);
 ${unknownReferences.map((i) => `  ${i}`).join("\n")}`);
   }
   const loopFamilies = Object.keys(expansion.families).length ? { loopFamilies: expansion.families } : {};
-  return { manifest: parsed.data, root: path13.dirname(abs), path: abs, ...loopFamilies };
+  return { manifest: parsed.data, root: path14.dirname(abs), path: abs, ...loopFamilies };
 }
 function parentAssetId(asset) {
   return asset?.revision?.from ?? asset?.state?.of ?? asset?.animation?.of ?? asset?.portrait?.of ?? asset?.outfit?.of;
@@ -10869,7 +10985,7 @@ async function resolveSpecs(loaded, filter) {
   }
   const styleImageCache = /* @__PURE__ */ new Map();
   async function loadStyleImage(rel, what = "Style image") {
-    const abs = path13.resolve(root, rel);
+    const abs = path14.resolve(root, rel);
     let hit = styleImageCache.get(abs);
     if (!hit) {
       if (!existsSync8(abs)) throw new Error(`${what} not found: ${abs}`);
@@ -10899,7 +11015,7 @@ async function resolveSpecs(loaded, filter) {
       styleImageDimensions.push(loadedImage);
     }
     const resolvedImages = style.styleImages.map((image) => {
-      const hit = styleImageCache.get(path13.resolve(root, image.path));
+      const hit = styleImageCache.get(path14.resolve(root, image.path));
       return { base64: hit.base64, width: hit.width, height: hit.height, format: hit.format };
     });
     const styleSpecs = /* @__PURE__ */ new Map();
@@ -11000,9 +11116,9 @@ async function resolveSpecs(loaded, filter) {
       } else {
         prompt = [style.promptPrefix, subject, style.promptSuffix].map((p) => p.trim()).filter(Boolean).join(", ");
       }
-      const relFile = asset.file ?? path13.join(asset.category ?? "", `${assetId}.png`);
-      const outFile = path13.resolve(root, style.outDir, relFile);
-      const qualityOutFile = style.quality ? path13.resolve(root, style.quality.outDir, pngPath(relFile)) : void 0;
+      const relFile = asset.file ?? path14.join(asset.category ?? "", `${assetId}.png`);
+      const outFile = path14.resolve(root, style.outDir, relFile);
+      const qualityOutFile = style.quality ? path14.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;
@@ -11097,7 +11213,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: path13.resolve(root, style.quality.fixerPython) } : {},
+            ...style.quality.fixerPython ? { fixerPython: path14.resolve(root, style.quality.fixerPython) } : {},
             ...style.quality.fps == null ? {} : { fps: style.quality.fps }
           }
         } : {},
@@ -11233,7 +11349,7 @@ async function resolveSpecs(loaded, filter) {
           animation: sourceSpec.character.animation,
           outfit: {
             reference: {
-              path: path13.resolve(root, asset.outfit.reference),
+              path: path14.resolve(root, asset.outfit.reference),
               sha256: referenceImage.hash,
               width: referenceImage.width,
               height: referenceImage.height,
@@ -11255,23 +11371,23 @@ async function resolveSpecs(loaded, filter) {
           );
         }
         const sourceSpec = await finalize(asset.revision.from);
-        const sourceStem = sourceSpec.quality?.outFile ?? (sourceSpec.source ? path13.resolve(root, sourceSpec.source) : sourceSpec.outFile);
+        const sourceStem = sourceSpec.quality?.outFile ?? (sourceSpec.source ? path14.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 ? path13.resolve(root, asset.revision.mask) : void 0;
+        const maskFile = asset.revision.mask ? path14.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 ? path13.resolve(root, asset.revision.paletteImage) : void 0;
+        const paletteImageFile = asset.revision.paletteImage ? path14.resolve(root, asset.revision.paletteImage) : void 0;
         const paletteImage = paletteImageFile ? await optionalRevisionImage(paletteImageFile, "revision palette image", "png") : null;
-        const lastFrameFile = asset.revision.lastFrame ? path13.resolve(root, asset.revision.lastFrame) : void 0;
+        const lastFrameFile = asset.revision.lastFrame ? path14.resolve(root, asset.revision.lastFrame) : void 0;
         const lastFrame = lastFrameFile ? await optionalRevisionImage(lastFrameFile, "revision last frame") : null;
-        const keypointsFile = asset.revision.keypointsFile ? path13.resolve(root, asset.revision.keypointsFile) : void 0;
+        const keypointsFile = asset.revision.keypointsFile ? path14.resolve(root, asset.revision.keypointsFile) : void 0;
         const keypoints = keypointsFile ? await optionalSkeletonSet(keypointsFile) : null;
         resolved.revision = {
           mode: asset.revision.mode,
@@ -11438,7 +11554,7 @@ async function resolveSpecs(loaded, filter) {
   return specs;
 }
 function pngPath(file) {
-  const extension = path13.extname(file);
+  const extension = path14.extname(file);
   return extension ? `${file.slice(0, -extension.length)}.png` : `${file}.png`;
 }
 async function resolveMapScene(root, styleId, assetId, generator, scene, provider) {
@@ -11448,12 +11564,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 = path13.resolve(root, scene.image);
+  const file = path14.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 = path13.resolve(root, placement.mask);
+    const maskFile = path14.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(
@@ -11525,7 +11641,7 @@ async function resolveStyleImages(loaded, styleId) {
   if (!style) throw new Error(`Unknown style "${styleId}"`);
   const out = [];
   for (const img of style.styleImages) {
-    const file = path13.resolve(loaded.root, img.path);
+    const file = path14.resolve(loaded.root, img.path);
     const buf = await readFile6(file);
     const metadata = imageMetadata(buf);
     if (!metadata) throw new Error(`Style image is not a readable PNG or JPEG: ${file}`);
@@ -11553,7 +11669,7 @@ async function resolveCharacterShape(asset, style, kind, files) {
   };
   if (asset.concept) {
     const image = await files.load(asset.concept, "Concept image");
-    shape.concept = { path: path13.resolve(files.root, asset.concept), sha256: image.hash, width: image.width, height: image.height, format: image.format };
+    shape.concept = { path: path14.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;
@@ -11561,7 +11677,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: path13.resolve(files.root, rel),
+        path: path14.resolve(files.root, rel),
         sha256: image.hash,
         width: image.width,
         height: image.height,
@@ -11582,7 +11698,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: path13.resolve(files.root, rel), sha256: image.hash, width: image.width, height: image.height, format: image.format };
+      return { path: path14.resolve(files.root, rel), sha256: image.hash, width: image.width, height: image.height, format: image.format };
     };
     shape.animation = {
       mode: animationMode,
@@ -11613,7 +11729,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: path13.resolve(files.root, south), sha256: image.hash, width: image.width, height: image.height, format: image.format };
+      shape.reference = { path: path14.resolve(files.root, south), sha256: image.hash, width: image.width, height: image.height, format: image.format };
     }
   }
   if (asset.state) {
@@ -11641,7 +11757,7 @@ async function resolveObjectProShape(assetId, asset, style, kind, files) {
     }
     const pose = async (rel, what) => {
       const image = await files.load(rel, what);
-      return { path: path13.resolve(files.root, rel), sha256: image.hash, width: image.width, height: image.height, format: image.format };
+      return { path: path14.resolve(files.root, rel), sha256: image.hash, width: image.width, height: image.height, format: image.format };
     };
     shape.animation = {
       mode: asset.animation.mode ?? "v3",
@@ -11658,9 +11774,9 @@ async function resolveObjectProShape(assetId, asset, style, kind, files) {
 }
 
 // src/pipeline/fetch.ts
-import { existsSync as existsSync9, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync4 } from "fs";
 import { mkdir as mkdir4, readFile as readFile7, rename as rename4, rm as rm4, writeFile as writeFile4 } from "fs/promises";
-import path14 from "path";
+import path15 from "path";
 
 // src/source-url.ts
 var SENSITIVE_QUERY_KEYS = /* @__PURE__ */ new Set([
@@ -11706,7 +11822,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
   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 : path14.resolve(opts.cacheDir ?? path14.join(path14.dirname(lockPath), ".pixelkiln", "cache"));
+  const cacheDir = opts.cacheDir === false ? null : path15.resolve(opts.cacheDir ?? path15.join(path15.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;
@@ -11717,7 +11833,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 existsSync9(file) && sha256(readFileSync3(file)) === output.sha256;
+        return existsSync9(file) && sha256(readFileSync4(file)) === output.sha256;
       });
     }
     if (!opts.repair) return false;
@@ -11725,7 +11841,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
     return e.outputs.some((output) => {
       const file = resolveOutputPath(output.path, spec.root);
       if (!existsSync9(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);
     });
@@ -11808,7 +11924,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) {
-              log2(`  current ${path14.relative(process.cwd(), target)}`);
+              log2(`  current ${path15.relative(process.cwd(), target)}`);
               outputs.push({ ...recorded, path: portableOutputPath(target, spec.root) });
               continue;
             }
@@ -11832,9 +11948,9 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
               }
               if (reapply && !fresh) {
                 if (!recorded.raw) raw = await readFile7(target);
-                log2(`  reapply ${path14.relative(process.cwd(), target)}`);
+                log2(`  reapply ${path15.relative(process.cwd(), target)}`);
               } else {
-                log2(`  changed ${path14.relative(process.cwd(), target)} (upstream)`);
+                log2(`  changed ${path15.relative(process.cwd(), target)} (upstream)`);
               }
             } else {
               const superseded = (entry.supersededOutputs ?? []).find(
@@ -11862,7 +11978,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
                 }
               }
               log2(
-                `  replace ${path14.relative(process.cwd(), target)}` + (opts.force ? " (--force)" : " (previous tracked generation)")
+                `  replace ${path15.relative(process.cwd(), target)}` + (opts.force ? " (--force)" : " (previous tracked generation)")
               );
             }
           }
@@ -11871,7 +11987,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) log2(`  cached  ${path14.relative(process.cwd(), target)}`);
+            if (final || raw) log2(`  cached  ${path15.relative(process.cwd(), target)}`);
           }
           if (!final && !raw) {
             if (!source.url) {
@@ -11898,11 +12014,11 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
             buf = processed.bytes;
             if (processed.changed) {
               rawHash = sha256(raw);
-              log2(`  snapped ${path14.relative(process.cwd(), target)} to ${wanted.palette.colors.length} colours`);
+              log2(`  snapped ${path15.relative(process.cwd(), target)} to ${wanted.palette.colors.length} colours`);
             }
           }
           if (cacheDir) await cacheMedia(cacheDir, buf, mediaType);
-          await mkdir4(path14.dirname(target), { recursive: true });
+          await mkdir4(path15.dirname(target), { recursive: true });
           const tmp = `${target}.pixelkiln.tmp`;
           await writeFile4(tmp, buf);
           outputs.push({
@@ -11916,7 +12032,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
           await saveLock(lockPath, lock);
           await rename4(tmp, target);
           wrote = true;
-          log2(`  wrote   ${path14.relative(process.cwd(), target)}`);
+          log2(`  wrote   ${path15.relative(process.cwd(), target)}`);
         }
         if (opts.refresh && !wrote) {
           if (rotated) {
@@ -11960,7 +12076,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
   return result;
 }
 async function readCachedMedia(cacheDir, hash, mediaType) {
-  const file = path14.join(cacheDir, cacheFileName(hash, mediaType));
+  const file = path15.join(cacheDir, cacheFileName(hash, mediaType));
   if (!existsSync9(file)) return null;
   try {
     const buf = await readFile7(file);
@@ -11974,7 +12090,7 @@ async function readCachedMedia(cacheDir, hash, mediaType) {
 async function cacheMedia(cacheDir, buf, mediaType, knownHash) {
   const hash = knownHash ?? sha256(buf);
   validateMedia(buf, mediaType);
-  const file = path14.join(cacheDir, cacheFileName(hash, mediaType));
+  const file = path15.join(cacheDir, cacheFileName(hash, mediaType));
   if (await readCachedMedia(cacheDir, hash, mediaType)) return;
   await mkdir4(cacheDir, { recursive: true });
   const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
@@ -12017,7 +12133,7 @@ async function pushTags(provider, specs, lock, opts = {}) {
 // src/pipeline/adopt.ts
 import { existsSync as existsSync11 } from "fs";
 import { readFile as readFile9, writeFile as writeFile6 } from "fs/promises";
-import path15 from "path";
+import path16 from "path";
 
 // src/cache.ts
 import { mkdir as mkdir5, readFile as readFile8, rename as rename5, rm as rm5, writeFile as writeFile5 } from "fs/promises";
@@ -12036,10 +12152,10 @@ function isSha256Hash(value) {
 function parseCache(value) {
   return HashCacheSchema.parse(value);
 }
-async function loadCache(path51) {
-  if (!existsSync10(path51)) return { version: 1, hashes: {} };
+async function loadCache(path52) {
+  if (!existsSync10(path52)) return { version: 1, hashes: {} };
   try {
-    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile8(path51, "utf8")));
+    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile8(path52, "utf8")));
     if (!parsed.success) return { version: 1, hashes: {} };
     return {
       version: 1,
@@ -12051,18 +12167,18 @@ async function loadCache(path51) {
     return { version: 1, hashes: {} };
   }
 }
-async function saveCache(path51, cache) {
+async function saveCache(path52, 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(path51)), { recursive: true });
-  const tmp = `${path51}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  await mkdir5(pathModule.dirname(pathModule.resolve(path52)), { recursive: true });
+  const tmp = `${path52}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
     await writeFile5(tmp, JSON.stringify({ version: 1, hashes: sorted }, null, 2) + "\n");
-    await rename5(tmp, path51);
+    await rename5(tmp, path52);
   } finally {
     await rm5(tmp, { force: true });
   }
@@ -12255,7 +12371,7 @@ function formatUnmatchedRemote(objects, limit = 15) {
 // src/pipeline/adopt-characters.ts
 import { existsSync as existsSync12 } from "fs";
 import { mkdir as mkdir6, readFile as readFile10, writeFile as writeFile7 } from "fs/promises";
-import path16 from "path";
+import path17 from "path";
 async function adoptCharacters(provider, specs, lock, lockPath, opts) {
   const log2 = opts.onProgress ?? (() => {
   });
@@ -12307,11 +12423,11 @@ async function adoptCharacters(provider, specs, lock, lockPath, opts) {
       const hash = sha256(bytes);
       const file = expectedOutputPath(spec, source.role, index, sources.length);
       if (existsSync12(file)) {
-        if (sha256(await readFile10(file)) !== hash) result.differing.push(path16.relative(process.cwd(), file));
+        if (sha256(await readFile10(file)) !== hash) result.differing.push(path17.relative(process.cwd(), file));
       } else {
-        await mkdir6(path16.dirname(file), { recursive: true });
+        await mkdir6(path17.dirname(file), { recursive: true });
         await writeFile7(file, bytes);
-        result.written.push(path16.relative(process.cwd(), file));
+        result.written.push(path17.relative(process.cwd(), file));
       }
       outputs.push({ path: portableOutputPath(file, spec.root), sha256: hash, ...source.role ? { role: source.role } : {} });
     }
@@ -12350,7 +12466,7 @@ async function adoptCharacters(provider, specs, lock, lockPath, opts) {
     } else {
       const south = expectedOutputPath(spec, "south", 0, spec.character.directions);
       if (!existsSync12(south)) {
-        result.unmatched.push(`${key}: no remoteId and no ${path16.relative(process.cwd(), south)} to match by`);
+        result.unmatched.push(`${key}: no remoteId and no ${path17.relative(process.cwd(), south)} to match by`);
         return false;
       }
       const localHash = sha256(await readFile10(south));
@@ -12362,7 +12478,7 @@ async function adoptCharacters(provider, specs, lock, lockPath, opts) {
         }
       }
       if (!match) {
-        result.unmatched.push(`${key}: no character's south rotation has the bytes of ${path16.relative(process.cwd(), south)}`);
+        result.unmatched.push(`${key}: no character's south rotation has the bytes of ${path17.relative(process.cwd(), south)}`);
         return false;
       }
     }
@@ -12432,7 +12548,7 @@ async function adoptCharacters(provider, specs, lock, lockPath, opts) {
       if (!existsSync12(first)) {
         const byName = candidates.find((a) => a.name === characterAnimationName(spec));
         if (!byName) {
-          result.unmatched.push(`${key}: no remoteId and no ${path16.relative(process.cwd(), first)} to match by`);
+          result.unmatched.push(`${key}: no remoteId and no ${path17.relative(process.cwd(), first)} to match by`);
           return false;
         }
         match = byName;
@@ -12445,7 +12561,7 @@ async function adoptCharacters(provider, specs, lock, lockPath, opts) {
           }
         }
         if (!match) {
-          result.unmatched.push(`${key}: no ${animation.direction} animation of character ${parentId} starts with the bytes of ${path16.relative(process.cwd(), first)}`);
+          result.unmatched.push(`${key}: no ${animation.direction} animation of character ${parentId} starts with the bytes of ${path17.relative(process.cwd(), first)}`);
           return false;
         }
       }
@@ -12507,7 +12623,7 @@ async function adoptCharacters(provider, specs, lock, lockPath, opts) {
 // src/pipeline/salvage.ts
 import { readFile as readFile11 } from "fs/promises";
 import { existsSync as existsSync13 } from "fs";
-import path17 from "path";
+import path18 from "path";
 function providerClaimId(provider, objectId) {
   return `${encodeURIComponent(provider)}:${encodeURIComponent(objectId)}`;
 }
@@ -12684,20 +12800,20 @@ function matchStyleByPattern(prompt, manifest) {
   return null;
 }
 async function loadSiblingManifests(ownManifestPath, workspaceManifestPaths, claimPaths) {
-  const own = path17.resolve(ownManifestPath);
+  const own = path18.resolve(ownManifestPath);
   const siblingManifestPaths = [
     .../* @__PURE__ */ new Set([
       ...workspaceManifestPaths,
-      ...claimPaths.map((c) => path17.join(path17.dirname(path17.resolve(c)), "pixelkiln.manifest.json"))
+      ...claimPaths.map((c) => path18.join(path18.dirname(path18.resolve(c)), "pixelkiln.manifest.json"))
     ])
   ];
   const siblings = [];
   for (const siblingManifestPath of siblingManifestPaths) {
-    if (path17.resolve(siblingManifestPath) === own) continue;
+    if (path18.resolve(siblingManifestPath) === own) continue;
     if (!existsSync13(siblingManifestPath)) continue;
     try {
       const { manifest } = await loadManifest(siblingManifestPath);
-      siblings.push({ label: path17.basename(path17.dirname(siblingManifestPath)), manifest });
+      siblings.push({ label: path18.basename(path18.dirname(siblingManifestPath)), manifest });
     } catch {
     }
   }
@@ -12819,7 +12935,7 @@ async function applyTags(provider, decisions, existing, opts = {}) {
 // src/workspace.ts
 import { mkdir as mkdir7, readFile as readFile12, rename as rename6, rm as rm6, writeFile as writeFile8 } from "fs/promises";
 import { existsSync as existsSync14 } from "fs";
-import path18 from "path";
+import path19 from "path";
 import { z as z5 } from "zod";
 var WorkspaceProjectSchema = z5.object({
   id: z5.string().min(1),
@@ -12861,7 +12977,7 @@ async function saveWorkspace(workspacePath, ws) {
     version: 1,
     projects: [...ws.projects].sort((a, b) => a.id.localeCompare(b.id))
   };
-  await mkdir7(path18.dirname(path18.resolve(workspacePath)), { recursive: true });
+  await mkdir7(path19.dirname(path19.resolve(workspacePath)), { recursive: true });
   const tmp = `${workspacePath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
     await writeFile8(tmp, JSON.stringify(sorted, null, 2) + "\n");
@@ -12871,12 +12987,12 @@ async function saveWorkspace(workspacePath, ws) {
   }
 }
 function toPortablePath(dir, absolute) {
-  return path18.relative(dir, absolute).split(path18.sep).join("/");
+  return path19.relative(dir, absolute).split(path19.sep).join("/");
 }
 function resolveProject(dir, project) {
   return {
-    manifestPath: path18.resolve(dir, project.manifest.split("/").join(path18.sep)),
-    lockPath: path18.resolve(dir, project.lock.split("/").join(path18.sep))
+    manifestPath: path19.resolve(dir, project.manifest.split("/").join(path19.sep)),
+    lockPath: path19.resolve(dir, project.lock.split("/").join(path19.sep))
   };
 }
 function validateWorkspace(ws, dir) {
@@ -12889,7 +13005,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 (path18.isAbsolute(project.manifest) || path18.isAbsolute(project.lock)) {
+    if (path19.isAbsolute(project.manifest) || path19.isAbsolute(project.lock)) {
       diagnostics.push({
         id: "absolute-path",
         level: "warning",
@@ -12951,7 +13067,7 @@ function validateWorkspace(ws, dir) {
 
 // src/pick/salvage-server.ts
 import { mkdir as mkdir8, writeFile as writeFile9, readFile as readFile14 } from "fs/promises";
-import path19 from "path";
+import path20 from "path";
 
 // src/pick/salvage-sheet.ts
 var escapeHtml = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
@@ -13216,7 +13332,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
   });
   const html = renderSalvageSheet(orphans, {
     styleId: ctx.styleId,
-    importDir: path19.relative(process.cwd(), ctx.importDir) || "."
+    importDir: path20.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]));
@@ -13272,9 +13388,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 = path19.join("_salvaged", `${assetId}.png`);
-            const outFile = path19.resolve(ctx.importDir, rel);
-            await mkdir8(path19.dirname(outFile), { recursive: true });
+            const rel = path20.join("_salvaged", `${assetId}.png`);
+            const outFile = path20.resolve(ctx.importDir, rel);
+            await mkdir8(path20.dirname(outFile), { recursive: true });
             await writeFile9(outFile, buf);
             ctx.manifest.assets[assetId] = {
               prompt: orphan.prompt,
@@ -13307,7 +13423,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
               sourceUrl: durableSource,
               sourceUrls: durableSource ? [{ url: durableSource }] : [],
               outputs: [{
-                path: portableOutputPath(outFile, path19.dirname(ctx.manifestPath)),
+                path: portableOutputPath(outFile, path20.dirname(ctx.manifestPath)),
                 sha256: sha256(buf)
               }],
               submittedAt: orphan.createdAt,
@@ -13342,19 +13458,19 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
 }
 
 // src/cli/project.ts
-import path21 from "path";
+import path22 from "path";
 import { existsSync as existsSync15 } from "fs";
 
 // src/project.ts
-import path20 from "path";
+import path21 from "path";
 async function openProject(manifestPath = "pixelkiln.manifest.json", opts = {}) {
-  const absolute = path20.resolve(manifestPath);
-  const root = path20.dirname(absolute);
+  const absolute = path21.resolve(manifestPath);
+  const root = path21.dirname(absolute);
   if (opts.env !== false) {
     loadEnvFiles(root);
-    if (path20.resolve(process.cwd()) !== root) loadEnvFiles(process.cwd());
+    if (path21.resolve(process.cwd()) !== root) loadEnvFiles(process.cwd());
   }
-  const lockPath = path20.resolve(opts.lockPath ?? path20.join(root, "pixelkiln.lock.json"));
+  const lockPath = path21.resolve(opts.lockPath ?? path21.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);
@@ -13485,7 +13601,7 @@ async function workspaceStatus(ws, dir) {
 
 // src/cli/project.ts
 async function provenanceFile(id, file) {
-  const absolute = path21.resolve(file);
+  const absolute = path22.resolve(file);
   return {
     id,
     path: absolute,
@@ -13564,7 +13680,7 @@ async function requireCompleteWorkspaceClaims(workspacePath) {
   if (!existsSync15(workspacePath)) {
     throw new ProjectError(`Workspace catalog not found: ${workspacePath}`);
   }
-  const dir = path21.dirname(path21.resolve(workspacePath));
+  const dir = path22.dirname(path22.resolve(workspacePath));
   const ws = await loadWorkspace(workspacePath);
   const diagnostics = validateWorkspace(ws, dir);
   const errors = diagnostics.filter((d) => d.level === "error");
@@ -13587,9 +13703,9 @@ async function openAccountProject(args) {
   return project;
 }
 async function open(args) {
-  if (!existsSync15(path21.resolve(args.manifest))) {
+  if (!existsSync15(path22.resolve(args.manifest))) {
     throw new ProjectError(
-      `No manifest at ${path21.resolve(args.manifest)}. Pass --manifest, or run \`pixelkiln init --from <dir>\`.`
+      `No manifest at ${path22.resolve(args.manifest)}. Pass --manifest, or run \`pixelkiln init --from <dir>\`.`
     );
   }
   const project = await openProject(args.manifest, { lockPath: args.lock, styles: args.styles, assets: args.assets });
@@ -13631,7 +13747,7 @@ function providerCache(mode2) {
 
 // src/cli/commands/account.ts
 async function runBalance(args) {
-  loadEnvFiles(path22.dirname(path22.resolve(args.manifest)));
+  loadEnvFiles(path23.dirname(path23.resolve(args.manifest)));
   loadEnvFiles(process.cwd());
   const loaded = await loadManifest(args.manifest);
   const selectedProvider = accountProviderId(loaded.manifest, args.provider, "balance");
@@ -13704,12 +13820,12 @@ async function runAdopt(args) {
   tagged ${n} object(s) upstream`);
   }
   if (args.writePrompts) {
-    const { filled, stillEmpty } = await writePromptsBack(path22.resolve(args.manifest), lock, {
+    const { filled, stillEmpty } = await writePromptsBack(path23.resolve(args.manifest), lock, {
       onProgress: log,
       provider: provider.id,
       assetIds: specs.map((spec) => spec.assetId)
     });
-    log(`  recovered ${filled} prompt(s) into ${path22.relative(process.cwd(), args.manifest)}`);
+    log(`  recovered ${filled} prompt(s) into ${path23.relative(process.cwd(), args.manifest)}`);
     const reloaded = await loadManifest(args.manifest);
     const rebased = (await resolveSpecs(reloaded, {
       styles: args.styles,
@@ -13739,12 +13855,12 @@ async function runSalvage2(args) {
   const provider = providerFor(accountProvider);
   const jsonMode = args.dryRun && args.json;
   const diag = jsonMode ? (msg = "") => console.error(msg) : log;
-  const ownLock = path22.resolve(args.lock);
+  const ownLock = path23.resolve(args.lock);
   let workspaceProjects = [];
   let workspaceDir = "";
   if (args.workspace) {
-    const workspacePath = path22.resolve(args.workspace);
-    workspaceDir = path22.dirname(workspacePath);
+    const workspacePath = path23.resolve(args.workspace);
+    workspaceDir = path23.dirname(workspacePath);
     const complete = await requireCompleteWorkspaceClaims(workspacePath);
     workspaceProjects = complete.ws.projects;
     for (const d of complete.diagnostics) diag(`  WARN  ${d.id}: ${d.message}`);
@@ -13754,11 +13870,11 @@ async function runSalvage2(args) {
     .../* @__PURE__ */ new Set([
       ...workspaceLockPaths,
       ...existsSync16(ownLock) ? [ownLock] : [],
-      ...args.claims.map((c) => path22.resolve(c))
+      ...args.claims.map((c) => path23.resolve(c))
     ])
   ];
   diag(`  claim set (${lockPaths.length} lockfile(s)):`);
-  for (const p of lockPaths) diag(`    ${path22.relative(process.cwd(), p)}`);
+  for (const p of lockPaths) diag(`    ${path23.relative(process.cwd(), p)}`);
   if (!args.claims.length && !args.workspace) {
     diag(
       `
@@ -13766,7 +13882,7 @@ async function runSalvage2(args) {
   pass every other project's lockfile via --claims a.json,b.json, or
   register every project in a workspace catalog and pass --workspace.`
     );
-  } else if (args.workspace && !workspaceProjects.some((p) => resolveProject(workspaceDir, p).manifestPath === path22.resolve(args.manifest))) {
+  } else if (args.workspace && !workspaceProjects.some((p) => resolveProject(workspaceDir, p).manifestPath === path23.resolve(args.manifest))) {
     diag(
       `
   This project's manifest is not registered in the workspace catalog. Its own
@@ -13885,7 +14001,7 @@ async function runSalvage2(args) {
         manifestPath: loaded.path,
         manifest: accountManifest,
         styleId,
-        importDir: path22.resolve(loaded.root, style.outDir),
+        importDir: path23.resolve(loaded.root, style.outDir),
         lock,
         lockPath: args.lock
       },
@@ -14012,20 +14128,20 @@ async function runTag(args) {
 }
 
 // src/cli/commands/edit.ts
-import path25 from "path";
+import path26 from "path";
 
 // src/pipeline/hand-edit.ts
 import { existsSync as existsSync17 } from "fs";
 import { copyFile, mkdir as mkdir9, readFile as readFile16, rename as rename8, rm as rm8, writeFile as writeFile11 } from "fs/promises";
-import path24 from "path";
+import path25 from "path";
 import { z as z7 } from "zod";
 
 // src/manifest-edit.ts
 import { readFile as readFile15, rename as rename7, rm as rm7, writeFile as writeFile10 } from "fs/promises";
-import path23 from "path";
+import path24 from "path";
 import { z as z6 } from "zod";
 var HexSha = z6.string().regex(/^[0-9a-f]{64}$/);
-var ProjectFileSchema = z6.string().min(1).refine((file) => !path23.isAbsolute(file) && !file.split(/[\\/]/).includes(".."), "must be a path inside the project");
+var ProjectFileSchema = z6.string().min(1).refine((file) => !path24.isAbsolute(file) && !file.split(/[\\/]/).includes(".."), "must be a path inside the project");
 var AssetPatchSchema = z6.object({
   prompt: z6.string().optional(),
   /** Per-style override for the style being viewed; null removes it. */
@@ -14444,7 +14560,7 @@ function applyEdit(raw, edit) {
   }
 }
 async function withCandidate(manifestPath, edit, use, unchanged) {
-  const absolute = path23.resolve(manifestPath);
+  const absolute = path24.resolve(manifestPath);
   const original = await readFile15(absolute, "utf8");
   if (sha256(original) !== edit.expectedSha256) throw new ManifestDriftError(absolute);
   let raw;
@@ -14458,9 +14574,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 = path23.join(
-    path23.dirname(absolute),
-    `.${path23.basename(absolute)}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`
+  const tmp = path24.join(
+    path24.dirname(absolute),
+    `.${path24.basename(absolute)}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`
   );
   try {
     await writeFile10(tmp, next);
@@ -14533,11 +14649,11 @@ async function priceManifestEdit(manifestPath, edit, opts = {}) {
 var HAND_EDIT_DIR = "edits";
 function handEditPath(loaded, spec) {
   const style = loaded.manifest.styles[spec.styleId];
-  const outDir = path24.resolve(loaded.root, style?.outDir ?? ".");
-  const relative = path24.relative(outDir, spec.outFile);
-  const inside = relative && !relative.startsWith("..") && !path24.isAbsolute(relative);
-  const file = inside ? relative : path24.basename(spec.outFile);
-  return path24.join(outDir, HAND_EDIT_DIR, file.replace(/\.gif$/i, ".png"));
+  const outDir = path25.resolve(loaded.root, style?.outDir ?? ".");
+  const relative = path25.relative(outDir, spec.outFile);
+  const inside = relative && !relative.startsWith("..") && !path25.isAbsolute(relative);
+  const file = inside ? relative : path25.basename(spec.outFile);
+  return path25.join(outDir, HAND_EDIT_DIR, file.replace(/\.gif$/i, ".png"));
 }
 function handEditBases(spec, lock) {
   const entry = lock.entries[lockKey(spec.styleId, spec.assetId)];
@@ -14579,7 +14695,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 ? path24.resolve(loaded.root, spec.source) : null;
+  const existing = spec.source ? path25.resolve(loaded.root, spec.source) : null;
   const editPath = existing ?? handEditPath(loaded, spec);
   const members = handEditMembers(loaded, spec, lock, editPath);
   let created = false;
@@ -14590,7 +14706,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 mkdir9(path24.dirname(member.path), { recursive: true });
+    await mkdir9(path25.dirname(member.path), { recursive: true });
     await copyFile(member.base, member.path);
     created = true;
   }
@@ -14728,7 +14844,7 @@ async function saveHandEdit(loaded, lock, spec, input) {
     editor: input.editor,
     protocol: input.protocol,
     savedAt: (input.now ?? /* @__PURE__ */ new Date()).toISOString(),
-    project: projectPath ? path24.basename(projectPath) : null,
+    project: projectPath ? path25.basename(projectPath) : null,
     outputs: incoming.map((frame, index) => ({
       role: frame.role,
       basedOn: basedOnHash(entry, index),
@@ -14788,7 +14904,7 @@ async function runEdit(args) {
   const set = started.members.length > 1;
   const kind = spec.generator === "frames" ? "frames" : "members";
   log(`  ${started.created ? "created" : "found"} ${started.source}${set ? ` (${started.members.length} ${kind})` : ""}${started.declared ? " and declared it as the asset's source" : ""}`);
-  if (set) for (const member of started.members) log(`    ${member.role ?? ""}  ${path25.relative(process.cwd(), member.path)}`);
+  if (set) for (const member of started.members) log(`    ${member.role ?? ""}  ${path26.relative(process.cwd(), member.path)}`);
   if (args.noOpen) {
     log(`  edit ${set ? "them" : "it"} with your own tool, then run pixelkiln plan; mount and pack place ${set ? "them" : "it"} in place of the generated art`);
   } else {
@@ -14798,24 +14914,24 @@ async function runEdit(args) {
 }
 
 // src/cli/commands/gallery.ts
-import path35 from "path";
+import path36 from "path";
 import { existsSync as existsSync27 } from "fs";
 
 // src/gallery/snapshot.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 import { existsSync as existsSync22 } from "fs";
 import { readFile as readFile20, stat as stat2 } from "fs/promises";
-import path31 from "path";
+import path32 from "path";
 
 // src/gallery/edit.ts
 import { readFile as readFile19, rename as rename9, writeFile as writeFile15 } from "fs/promises";
-import path29 from "path";
+import path30 from "path";
 import { z as z11 } from "zod";
 
 // src/gallery/upload.ts
 import { existsSync as existsSync18 } from "fs";
 import { mkdir as mkdir10, writeFile as writeFile12 } from "fs/promises";
-import path26 from "path";
+import path27 from "path";
 import { z as z8 } from "zod";
 var MAX_UPLOAD_BYTES = 8 * 1024 * 1024;
 var UploadImageSchema = z8.object({
@@ -14828,12 +14944,12 @@ var UploadImageSchema = z8.object({
   overwrite: z8.boolean().optional()
 }).strict();
 async function saveProjectImage(root, request) {
-  const file = path26.resolve(root, request.path);
-  const relative = path26.relative(root, file);
-  if (relative.startsWith("..") || path26.isAbsolute(relative)) {
+  const file = path27.resolve(root, request.path);
+  const relative = path27.relative(root, file);
+  if (relative.startsWith("..") || path27.isAbsolute(relative)) {
     throw new ManifestEditError("an upload must stay inside the project");
   }
-  const extension = path26.extname(file).toLowerCase();
+  const extension = path27.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");
@@ -14846,17 +14962,17 @@ async function saveProjectImage(root, request) {
     throw new ManifestEditError(`the upload is a ${metadata.format.toUpperCase()}; name it ${metadata.format === "png" ? ".png" : ".jpg"}`);
   }
   if (existsSync18(file) && !request.overwrite) {
-    throw new ManifestEditError(`${relative.split(path26.sep).join("/")} already exists; choose another name, or replace it`);
+    throw new ManifestEditError(`${relative.split(path27.sep).join("/")} already exists; choose another name, or replace it`);
   }
-  await mkdir10(path26.dirname(file), { recursive: true });
+  await mkdir10(path27.dirname(file), { recursive: true });
   await writeFile12(file, bytes);
-  return relative.split(path26.sep).join("/");
+  return relative.split(path27.sep).join("/");
 }
 
 // src/gallery/image-revision.ts
 import { existsSync as existsSync19 } from "fs";
 import { readFile as readFile17, rm as rm9, writeFile as writeFile13 } from "fs/promises";
-import path27 from "path";
+import path28 from "path";
 import { z as z9 } from "zod";
 var InpaintRevisionRequestSchema = z9.object({
   action: z9.literal("create-inpaint-revision"),
@@ -14875,14 +14991,14 @@ var InpaintRevisionRequestSchema = z9.object({
   overwrite: z9.boolean().optional()
 }).strict();
 async function createInpaintRevision(manifestPath, request) {
-  const root = path27.dirname(path27.resolve(manifestPath));
-  if (path27.extname(request.maskPath).toLowerCase() !== ".png") {
+  const root = path28.dirname(path28.resolve(manifestPath));
+  if (path28.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 = path27.resolve(root, request.maskPath);
+  const file = path28.resolve(root, request.maskPath);
   const previous = existsSync19(file) ? await readFile17(file) : null;
   const mask = await saveProjectImage(root, {
     action: "upload-image",
@@ -14912,7 +15028,7 @@ async function createInpaintRevision(manifestPath, request) {
 // src/gallery/skeleton.ts
 import { existsSync as existsSync20 } from "fs";
 import { mkdir as mkdir11, readFile as readFile18, rm as rm10, writeFile as writeFile14 } from "fs/promises";
-import path28 from "path";
+import path29 from "path";
 import { z as z10 } from "zod";
 var SkeletonEstimateRequestSchema = z10.object({
   project: z10.string().min(1).optional(),
@@ -14951,7 +15067,7 @@ var SkeletonKeypointsUpdateSchema = z10.object({
 }).strict();
 var DEFAULT_ESTIMATE_LIMIT = 10;
 function skeletonSourceFile(spec) {
-  if (spec.source) return path28.resolve(spec.root, spec.source);
+  if (spec.source) return path29.resolve(spec.root, spec.source);
   if (spec.quality && existsSync20(spec.quality.outFile)) return spec.quality.outFile;
   return spec.outFile;
 }
@@ -14976,7 +15092,7 @@ function createGallerySkeletonHandlers(opts) {
       if (!existsSync20(file)) throw new ManifestEditError(`${key} has no image on disk to estimate from`);
       const bytes = await readFile18(file);
       const metadata = imageMetadata(bytes);
-      if (!metadata) throw new ManifestEditError(`${path28.basename(file)} is not a readable PNG or JPEG`);
+      if (!metadata) throw new ManifestEditError(`${path29.basename(file)} is not a readable PNG or JPEG`);
       const problem = estimateSkeletonSizeProblem(metadata.width, metadata.height);
       if (problem) throw new ManifestEditError(`${key} is ${problem}`);
       if (used >= limit) {
@@ -14993,7 +15109,7 @@ function createGallerySkeletonHandlers(opts) {
       log2(`  estimated a skeleton for ${key} (PixelLab estimate-skeleton, ${used}/${limit} this session${billed ? `, billed ${billed.amount} ${billed.unit}` : ""})`);
       return {
         set: scaffoldSkeletonSet(res.keypoints, request.frames ?? DEFAULT_SCAFFOLD_FRAMES),
-        source: path28.relative(ctx.loaded.root, file).split(path28.sep).join("/"),
+        source: path29.relative(ctx.loaded.root, file).split(path29.sep).join("/"),
         session: status()
       };
     }
@@ -15007,10 +15123,10 @@ function billedAmount(usage) {
   return typeof amount === "number" && Number.isFinite(amount) ? { unit: type, amount } : null;
 }
 async function createSkeletonAnimation(manifestPath, request) {
-  const root = path28.dirname(path28.resolve(manifestPath));
-  const file = path28.resolve(root, request.keypointsFile);
-  const relative = path28.relative(root, file);
-  if (!request.keypointsFile.endsWith(".json") || relative.startsWith("..") || path28.isAbsolute(relative)) {
+  const root = path29.dirname(path29.resolve(manifestPath));
+  const file = path29.resolve(root, request.keypointsFile);
+  const relative = path29.relative(root, file);
+  if (!request.keypointsFile.endsWith(".json") || relative.startsWith("..") || path29.isAbsolute(relative)) {
     throw new ManifestEditError("the keypoints file must be a .json path inside the project");
   }
   const existed = existsSync20(file);
@@ -15020,7 +15136,7 @@ async function createSkeletonAnimation(manifestPath, request) {
       throw new ManifestEditError(`${request.keypointsFile} already exists; choose another path, or replace it`);
     }
     if (existed) previous = await readFile18(file);
-    await mkdir11(path28.dirname(file), { recursive: true });
+    await mkdir11(path29.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`);
@@ -15036,7 +15152,7 @@ async function createSkeletonAnimation(manifestPath, request) {
         revision: {
           mode: "animate-skeleton",
           from: request.from,
-          keypointsFile: relative.split(path28.sep).join("/"),
+          keypointsFile: relative.split(path29.sep).join("/"),
           direction: request.direction,
           ...request.description ? { description: request.description } : {},
           ...request.skeletonTemplate ? { skeletonTemplate: request.skeletonTemplate } : {}
@@ -15057,19 +15173,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 = path28.relative(ctx.loaded.root, file);
-  if (relative.startsWith("..") || path28.isAbsolute(relative)) {
+  const relative = path29.relative(ctx.loaded.root, file);
+  if (relative.startsWith("..") || path29.isAbsolute(relative)) {
     throw new ManifestEditError(`${key}'s keypoints file is outside the project; edit it by hand`);
   }
   const current = existsSync20(file) ? sha256(await readFile18(file)) : null;
   if (current !== request.expectedSha256) {
     throw Object.assign(
-      new Error(`${relative.split(path28.sep).join("/")} changed on disk since this page loaded it; press Refresh and edit again`),
+      new Error(`${relative.split(path29.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(path28.sep).join("/");
+  return relative.split(path29.sep).join("/");
 }
 
 // src/gallery/edit.ts
@@ -15123,7 +15239,7 @@ function createGalleryEditHandler(opts) {
   const history = /* @__PURE__ */ new Map();
   const manifestOf = async (project) => {
     try {
-      return path29.resolve(await opts.manifestFor(typeof project === "string" ? project : void 0));
+      return path30.resolve(await opts.manifestFor(typeof project === "string" ? project : void 0));
     } catch {
       return null;
     }
@@ -15146,7 +15262,7 @@ function createGalleryEditHandler(opts) {
       await writeFile15(tmp, last.before);
       await rename9(tmp, manifestPath2);
       stack.pop();
-      log2(`  manifest edit undone in ${path29.relative(process.cwd(), manifestPath2) || manifestPath2}`);
+      log2(`  manifest edit undone in ${path30.relative(process.cwd(), manifestPath2) || manifestPath2}`);
       return opts.reload();
     }
     const manifestPath = await manifestOf(body?.project);
@@ -15208,7 +15324,7 @@ function createEditApplier(opts, log2) {
       } catch (error) {
         throw new ManifestEditError(error instanceof Error ? error.message : String(error));
       }
-      const written = await saveProjectImage(path29.dirname(path29.resolve(manifestPath2)), upload.data);
+      const written = await saveProjectImage(path30.dirname(path30.resolve(manifestPath2)), upload.data);
       log2(`  image added: ${written}`);
       return opts.reload();
     }
@@ -15275,7 +15391,7 @@ function createEditApplier(opts, log2) {
     }
     const result = await applyManifestEdit(manifestPath, parsed.data);
     if (result.changed) {
-      const relative = path29.relative(process.cwd(), result.manifestPath);
+      const relative = path30.relative(process.cwd(), result.manifestPath);
       const shown = !relative || relative.startsWith("..") ? result.manifestPath : relative;
       log2(`  manifest edited: ${describeEdit(parsed.data)} in ${shown}`);
     }
@@ -15327,7 +15443,7 @@ function createGalleryPriceHandler(opts) {
 
 // src/pipeline/history.ts
 import { existsSync as existsSync21 } from "fs";
-import path30 from "path";
+import path31 from "path";
 var HISTORY_ENV = "PIXELKILN_HISTORY";
 function historyLimit(manifest, env = process.env) {
   if (manifest?.history !== void 0) return manifest.history;
@@ -15417,7 +15533,7 @@ async function revertGeneration(provider, spec, lock, lockPath, opts) {
     if (!existsSync21(file)) continue;
     if (await sha256File(file) !== entry.outputs[i].sha256 && !opts.force) {
       throw new OverwriteRefusedError(
-        `${path30.relative(process.cwd(), file)} was changed after download; keep it with pixelkiln edit, or pass --force to replace it`,
+        `${path31.relative(process.cwd(), file)} was changed after download; keep it with pixelkiln edit, or pass --force to replace it`,
         [file]
       );
     }
@@ -15470,7 +15586,7 @@ async function revertGeneration(provider, spec, lock, lockPath, opts) {
 // src/gallery/snapshot.ts
 var PROJECT_FILE_TYPE = "application/octet-stream";
 function galleryMediaId(absolutePath) {
-  return createHash3("sha256").update(path31.resolve(absolutePath)).digest("hex").slice(0, 24);
+  return createHash4("sha256").update(path32.resolve(absolutePath)).digest("hex").slice(0, 24);
 }
 function galleryMediaRoute(id) {
   return `/media/${id}`;
@@ -15489,7 +15605,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 = path31.join(cacheDir, cacheFileName(output.sha256, mediaType));
+      const file = path32.join(cacheDir, cacheFileName(output.sha256, mediaType));
       let url = null;
       if (existsSync22(file)) {
         const id = galleryMediaId(file);
@@ -15621,9 +15737,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, path31.resolve(root, file)))
+    outputPaths.map((file) => describeOutput(media, root, path32.resolve(root, file)))
   );
-  const recordPath = path31.resolve(root, inspection.record);
+  const recordPath = path32.resolve(root, inspection.record);
   const recordExists = existsSync22(recordPath);
   let options = null;
   let check = null;
@@ -15643,7 +15759,7 @@ async function describeQuality(media, root, inspection) {
   return {
     state: inspection.state,
     reason: inspection.reason,
-    output: portableOutputPath(path31.resolve(root, inspection.output), root),
+    output: portableOutputPath(path32.resolve(root, inspection.output), root),
     record: portableOutputPath(recordPath, root),
     recordExists,
     outputs,
@@ -15683,7 +15799,7 @@ async function buildGallerySnapshot(opts) {
   const items = [];
   const manifestText = await readFile20(loaded.path, "utf8");
   const manifestSha256 = sha256(manifestText);
-  const cacheDir = path31.resolve(path31.dirname(opts.lockPath), ".pixelkiln", "cache");
+  const cacheDir = path32.resolve(path32.dirname(opts.lockPath), ".pixelkiln", "cache");
   let rawStyles = {};
   try {
     const raw = JSON.parse(manifestText);
@@ -15707,7 +15823,7 @@ async function buildGallerySnapshot(opts) {
         )
       );
       if (spec.source) {
-        const editPath = path31.resolve(root, spec.source);
+        const editPath = path32.resolve(root, spec.source);
         const memberCount = sourceIsStem(spec.source, entry, root) ? entry.outputs.length : 1;
         const editShas = await Promise.all(
           Array.from({ length: memberCount }, async (_, index) => {
@@ -15756,7 +15872,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, path31.resolve(root, spec.source))];
+      outputs = [await describeOutput(media, root, path32.resolve(root, spec.source))];
     } else if (!entry && existsSync22(spec.outFile)) {
       outputs = [await describeOutput(media, root, spec.outFile)];
     } else {
@@ -15960,7 +16076,7 @@ async function buildGallerySnapshot(opts) {
       id: loaded.manifest.name,
       name: loaded.manifest.name,
       manifest: loaded.path,
-      lock: path31.resolve(opts.lockPath),
+      lock: path32.resolve(opts.lockPath),
       root,
       provider: loaded.manifest.provider,
       account: null,
@@ -15986,7 +16102,7 @@ async function buildGallerySnapshot(opts) {
   return { snapshot, media };
 }
 async function buildWorkspaceGallerySnapshot(opts) {
-  const dir = path31.dirname(path31.resolve(opts.workspacePath));
+  const dir = path32.dirname(path32.resolve(opts.workspacePath));
   const media = /* @__PURE__ */ new Map();
   const projects = [];
   const items = [];
@@ -16029,7 +16145,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
         id: project.id,
         name: loaded.manifest.name,
         manifest: manifestPath,
-        lock: path31.resolve(lockPath),
+        lock: path32.resolve(lockPath),
         root: loaded.root,
         provider: loaded.manifest.provider,
         account: project.account ?? null,
@@ -16045,8 +16161,8 @@ async function buildWorkspaceGallerySnapshot(opts) {
         id: project.id,
         name: project.id,
         manifest: manifestPath,
-        lock: path31.resolve(lockPath),
-        root: path31.dirname(manifestPath),
+        lock: path32.resolve(lockPath),
+        root: path32.dirname(manifestPath),
         provider: project.provider,
         account: project.account ?? null,
         manifestSha256: null,
@@ -16073,7 +16189,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
       version: 1,
       generatedAt: (opts.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
       project: null,
-      workspace: { path: path31.resolve(opts.workspacePath), dir, projects },
+      workspace: { path: path32.resolve(opts.workspacePath), dir, projects },
       filter,
       totals: {
         entries: projects.reduce((sum, project) => sum + project.entries, 0),
@@ -16095,7 +16211,7 @@ import { createServer as createServer2 } from "http";
 import { readFile as readFile21 } from "fs/promises";
 
 // src/gallery/page.ts
-import { existsSync as existsSync23, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync23, readFileSync as readFileSync5 } from "fs";
 
 // src/gallery/client-bundle.ts
 import { createRequire } from "module";
@@ -16135,8 +16251,8 @@ var client;
 function clientAssets() {
   const prebuilt = new URL("gallery.js", CLIENT_DIR);
   client ??= {
-    css: readFileSync4(new URL("gallery.css", CLIENT_DIR), "utf8"),
-    js: existsSync23(prebuilt) ? readFileSync4(prebuilt, "utf8") : bundleGalleryClient()
+    css: readFileSync5(new URL("gallery.css", CLIENT_DIR), "utf8"),
+    js: existsSync23(prebuilt) ? readFileSync5(prebuilt, "utf8") : bundleGalleryClient()
   };
   return client;
 }
@@ -16955,7 +17071,7 @@ import { readFile as readFile23 } from "fs/promises";
 // src/pipeline/init.ts
 import { readdir, readFile as readFile22, writeFile as writeFile16 } from "fs/promises";
 import { existsSync as existsSync24 } from "fs";
-import path32 from "path";
+import path33 from "path";
 function pngSize(buf) {
   if (buf.length < 24) return null;
   const isPng = buf.readUInt32BE(0) === 2303741511 && buf.readUInt32BE(4) === 218765834;
@@ -16969,7 +17085,7 @@ function slugify(value) {
 async function walk(dir, exclude) {
   const out = [];
   for (const entry of await readdir(dir, { withFileTypes: true })) {
-    const full = path32.join(dir, entry.name);
+    const full = path33.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);
@@ -16988,9 +17104,9 @@ async function scanAssets(root, opts = {}) {
       skipped.push(`${file} (not a readable PNG)`);
       continue;
     }
-    const rel = path32.relative(root, file);
-    const category = path32.dirname(rel) === "." ? "" : path32.dirname(rel);
-    let id = slugify(path32.basename(rel));
+    const rel = path33.relative(root, file);
+    const category = path33.dirname(rel) === "." ? "" : path33.dirname(rel);
+    let id = slugify(path33.basename(rel));
     if (seen.has(id)) {
       const n = seen.get(id) + 1;
       seen.set(id, n);
@@ -18004,14 +18120,14 @@ function createGenerateHandlers(opts) {
 
 // src/gallery/editor.ts
 import { readFile as readFile25 } from "fs/promises";
-import path34 from "path";
+import path35 from "path";
 
 // src/editor/install.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 import { existsSync as existsSync26 } from "fs";
 import { mkdir as mkdir12, readFile as readFile24, rename as rename10, rm as rm11, stat as stat3, writeFile as writeFile17 } from "fs/promises";
-import os2 from "os";
-import path33 from "path";
+import os3 from "os";
+import path34 from "path";
 
 // tools/pixelorama-bridge/pin.json
 var pin_default = {
@@ -18075,15 +18191,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();
@@ -18093,7 +18209,7 @@ function editorBaseUrl(pin = EDITOR_PIN) {
 }
 async function sha256Of(file) {
   try {
-    return createHash4("sha256").update(await readFile24(file)).digest("hex");
+    return createHash5("sha256").update(await readFile24(file)).digest("hex");
   } catch {
     return null;
   }
@@ -18106,7 +18222,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 = existsSync26(file) ? await stat3(file).catch(() => null) : null;
     if (info && info.size === expected.bytes && await sha256Of(file) === expected.sha256) {
       installedBytes += expected.bytes;
@@ -18160,11 +18276,11 @@ async function installEditor(opts = {}) {
     if (bytes.length !== expected.bytes) {
       throw new EditorInstallError(`${name}: expected ${expected.bytes} bytes, got ${bytes.length}`, name);
     }
-    const digest2 = createHash4("sha256").update(bytes).digest("hex");
+    const digest2 = createHash5("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 writeFile17(tmp, bytes);
@@ -18210,7 +18326,7 @@ 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
@@ -18286,7 +18402,7 @@ function createGalleryEditorHandlers(opts = {}) {
       if (!status.installed) return null;
       let bytes;
       try {
-        bytes = await readFile25(path34.join(dir, name));
+        bytes = await readFile25(path35.join(dir, name));
       } catch {
         verified = null;
         return null;
@@ -18326,7 +18442,7 @@ async function serveUntilStopped(initial, reload, args, access2) {
   };
   const loadProject = async (project) => {
     const ctx = await access2.loadProject(project);
-    loadProjectEnv(path35.dirname(ctx.loaded.path));
+    loadProjectEnv(path36.dirname(ctx.loaded.path));
     return ctx;
   };
   const loadProjectEnv = (dir) => {
@@ -18335,7 +18451,7 @@ async function serveUntilStopped(initial, reload, args, access2) {
     for (const [name, value] of Object.entries(declared)) {
       if (credentialNames.has(name) && name in process.env && process.env[name] !== value) {
         throw new Error(
-          `${path35.relative(process.cwd(), dir) || "."} sets ${name} to a different value than the one this gallery already loaded; run a separate gallery for that project so its work uses its own account.`
+          `${path36.relative(process.cwd(), dir) || "."} sets ${name} to a different value than the one this gallery already loaded; run a separate gallery for that project so its work uses its own account.`
         );
       }
     }
@@ -18343,7 +18459,7 @@ async function serveUntilStopped(initial, reload, args, access2) {
   };
   const quoters = /* @__PURE__ */ new Map();
   const quoteFor = async (project) => {
-    loadProjectEnv(path35.dirname(path35.resolve(await access2.manifestFor(project))));
+    loadProjectEnv(path36.dirname(path36.resolve(await access2.manifestFor(project))));
     const key = process.env.PIXELLAB_API_KEY;
     if (!key) return null;
     let quoter = quoters.get(key);
@@ -18394,7 +18510,7 @@ async function serveUntilStopped(initial, reload, args, access2) {
 }
 async function runGallery(args) {
   if (args.workspace) {
-    const workspacePath = path35.resolve(args.workspace);
+    const workspacePath = path36.resolve(args.workspace);
     if (!existsSync27(workspacePath)) {
       throw new Error(`Workspace catalog not found: ${workspacePath}`);
     }
@@ -18415,7 +18531,7 @@ async function runGallery(args) {
     const registered = async (projectId) => {
       const project = (await loadWorkspace(workspacePath)).projects.find((candidate) => candidate.id === projectId);
       if (!projectId || !project) throw new Error(`unknown workspace project "${projectId ?? ""}"`);
-      return resolveProject(path35.dirname(workspacePath), project);
+      return resolveProject(path36.dirname(workspacePath), project);
     };
     await serveUntilStopped(initial, build2, args, {
       manifestFor: async (projectId) => (await registered(projectId)).manifestPath,
@@ -18440,7 +18556,7 @@ async function runGallery(args) {
     return buildGallerySnapshot({ ...fresh, filter });
   };
   await serveUntilStopped(await build(), reload, args, {
-    manifestFor: () => path35.resolve(args.manifest),
+    manifestFor: () => path36.resolve(args.manifest),
     loadProject: () => openProject(args.manifest, { lockPath: args.lock, env: false })
   });
 }
@@ -18754,13 +18870,13 @@ import { existsSync as existsSync29 } from "fs";
 // src/pipeline/cache-health.ts
 import { existsSync as existsSync28 } from "fs";
 import { readFile as readFile26, readdir as readdir2, rm as rm12 } from "fs/promises";
-import path36 from "path";
+import path37 from "path";
 async function inspectCaches(lock, lockPath, options = {}) {
   if (options.prune && !existsSync28(lockPath)) {
-    throw new Error(`Refusing to prune without an existing lockfile at ${path36.resolve(lockPath)}`);
+    throw new Error(`Refusing to prune without an existing lockfile at ${path37.resolve(lockPath)}`);
   }
-  const contentDir = path36.resolve(path36.dirname(lockPath), ".pixelkiln", "cache");
-  const remotePath = path36.resolve(cachePathFor(lockPath));
+  const contentDir = path37.resolve(path37.dirname(lockPath), ".pixelkiln", "cache");
+  const remotePath = path37.resolve(cachePathFor(lockPath));
   const referenced = referencedHashes(lock);
   let content = await inspectContentCache(contentDir, referenced);
   let remoteHashes = await inspectRemoteHashCache(remotePath);
@@ -18772,7 +18888,7 @@ async function inspectCaches(lock, lockPath, options = {}) {
     ]);
     for (const name of names) {
       try {
-        await rm12(path36.join(contentDir, name), { force: true });
+        await rm12(path37.join(contentDir, name), { force: true });
         removed.contentFiles++;
       } catch {
       }
@@ -18820,7 +18936,7 @@ async function inspectContentCache(contentDir, referenced) {
       continue;
     }
     report.files++;
-    const file = path36.join(contentDir, entry.name);
+    const file = path37.join(contentDir, entry.name);
     const mediaType = mediaTypeFromExtension(entry.name);
     const expected = mediaType ? entry.name.slice(0, -4) : "";
     let bytes;
@@ -18991,42 +19107,42 @@ This drops their provenance from the lockfile. The art on disk is`);
 }
 
 // src/cli/commands/init.ts
-import path37 from "path";
+import path38 from "path";
 import { existsSync as existsSync30 } from "fs";
 async function runInit(args) {
   if (!args.from) throw new Error("init needs --from <dir> pointing at your existing PNGs.");
-  const root = path37.resolve(args.from);
+  const root = path38.resolve(args.from);
   if (!existsSync30(root)) throw new Error(`No directory at ${root}`);
   const generator = args.generator ?? "map";
   if (generator !== "1dir" && generator !== "map") {
     throw new Error(`--generator must be "1dir" or "map", got "${args.generator}".`);
   }
-  const target = path37.resolve(args.out ?? "pixelkiln.manifest.json");
+  const target = path38.resolve(args.out ?? "pixelkiln.manifest.json");
   const { assets, skipped } = await scanAssets(root, { exclude: args.exclude });
   if (!assets.length) throw new Error(`No PNGs found under ${root}`);
   const manifest = buildManifest(
-    args.name ?? path37.basename(path37.dirname(target)),
+    args.name ?? path38.basename(path38.dirname(target)),
     args.styles[0] ?? "base",
     generator,
-    path37.relative(path37.dirname(target), root) || ".",
+    path38.relative(path38.dirname(target), root) || ".",
     assets
   );
   await writeManifestFile(target, manifest);
-  log(`  scanned ${assets.length} PNG(s) under ${path37.relative(process.cwd(), root)}`);
+  log(`  scanned ${assets.length} PNG(s) under ${path38.relative(process.cwd(), root)}`);
   if (skipped.length) log(`  skipped ${skipped.length} unreadable file(s)`);
-  log(`  wrote ${path37.relative(process.cwd(), target)}`);
+  log(`  wrote ${path38.relative(process.cwd(), target)}`);
   log(`
   Prompts are intentionally empty. To recover the real ones from your`);
   log(`  PixelLab account instead of inventing them:`);
   log(`
-    pixelkiln adopt --manifest ${path37.relative(process.cwd(), target)} --write-prompts
+    pixelkiln adopt --manifest ${path38.relative(process.cwd(), target)} --write-prompts
 `);
 }
 
 // src/pipeline/doctor.ts
 import { constants, existsSync as existsSync31 } from "fs";
 import { access, stat as stat4 } from "fs/promises";
-import path38 from "path";
+import path39 from "path";
 async function doctor(loaded, specs, lock, lockPath, opts = {}) {
   const checks = [];
   const add = (id, level, message6) => checks.push({ id, level, message: message6 });
@@ -19037,8 +19153,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) => [
-    path38.dirname(spec.outFile),
-    ...spec.quality ? [path38.dirname(spec.quality.outFile)] : []
+    path39.dirname(spec.outFile),
+    ...spec.quality ? [path39.dirname(spec.quality.outFile)] : []
   ]))];
   const unwritable = [];
   for (const dir of dirs) {
@@ -19061,7 +19177,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, path38.dirname(lockPath));
+      const absolute = spec ? currentEntryOutputPath(entry, spec, index) : resolveOutputPath(output.path, path39.dirname(lockPath));
       const owner = outputOwners.get(absolute);
       if (owner && owner !== key) duplicateOutputs.push(`${output.path} (${owner}, ${key})`);
       outputOwners.set(absolute, key);
@@ -19076,7 +19192,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 = path38.join(path38.dirname(lockPath), ".pixelkiln", "cache");
+  const cacheDir = path39.join(path39.dirname(lockPath), ".pixelkiln", "cache");
   const stranded = [];
   const invalidState = [];
   const staleMapUrls = [];
@@ -19092,7 +19208,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 = path38.join(
+      const cached = path39.join(
         cacheDir,
         cacheFileName(output.sha256, output.mediaType ?? MediaType.PNG)
       );
@@ -19192,7 +19308,7 @@ async function nearestExistingDirectory(start) {
       if ((await stat4(current)).isDirectory()) return current;
     } catch {
     }
-    const parent = path38.dirname(current);
+    const parent = path39.dirname(current);
     if (parent === current) return current;
     current = parent;
   }
@@ -19201,7 +19317,7 @@ async function nearestExistingDirectory(start) {
 // src/pipeline/audit.ts
 import { readFile as readFile27 } from "fs/promises";
 import { existsSync as existsSync32 } from "fs";
-import path39 from "path";
+import path40 from "path";
 function paletteDistance(asset, reference) {
   if (!asset.length || !reference.length) return 0;
   let total = 0;
@@ -19266,7 +19382,7 @@ async function auditStyle(loaded, specs, styleId, lock) {
   let referenceFromStyleImages = false;
   const refPalettes = [];
   for (const img of style.styleImages) {
-    const abs = path39.resolve(loaded.root, img.path);
+    const abs = path40.resolve(loaded.root, img.path);
     if (!existsSync32(abs)) continue;
     try {
       refPalettes.push(extractPalette(decodePng(await readFile27(abs)), 12));
@@ -19497,24 +19613,24 @@ async function runAudit(args) {
 }
 
 // src/cli/commands/pack.ts
-import path41 from "path";
+import path42 from "path";
 import { readFile as readFile28 } from "fs/promises";
 
 // src/pipeline/pack.ts
-import { readFileSync as readFileSync5 } from "fs";
-import path40 from "path";
+import { readFileSync as readFileSync6 } from "fs";
+import path41 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 = path40.dirname(path40.resolve(inputsFilePath));
+  const baseDir = path41.dirname(path41.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: path40.resolve(baseDir, e.path) };
+    return { id: e.id, path: path41.resolve(baseDir, e.path) };
   });
 }
 function packSprites(inputs, options = {}) {
@@ -19535,7 +19651,7 @@ function packSprites(inputs, options = {}) {
   for (const input of ordered) {
     let sourceHash = null;
     try {
-      const bytes = readFileSync5(input.path);
+      const bytes = readFileSync6(input.path);
       sourceHash = sha256(bytes);
       const png = decodePng(bytes);
       sprites.push({ id: input.id, width: png.width, height: png.height, pixels: png.pixels });
@@ -19598,7 +19714,7 @@ function packStyle(lock, styleId, manifestDir, options = {}) {
     }
     const inputs2 = Object.entries(options.sourceOverrides).map(([id, source]) => ({
       id,
-      path: path40.resolve(source)
+      path: path41.resolve(source)
     }));
     if (!inputs2.length) throw new Error(`No approved quality outputs for style "${styleId}".`);
     const packed2 = packSprites(inputs2, options);
@@ -19622,7 +19738,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: path40.resolve(manifestDir, source) });
+      inputs.push({ id, path: path41.resolve(manifestDir, source) });
       continue;
     }
     if (source && sourceIsStem(source, entry, manifestDir)) {
@@ -19656,7 +19772,7 @@ function packStyle(lock, styleId, manifestDir, options = {}) {
     }
   }
   for (const [id, source] of Object.entries(sources)) {
-    if (!locked.has(id)) inputs.push({ id, path: path40.resolve(manifestDir, source) });
+    if (!locked.has(id)) inputs.push({ id, path: path41.resolve(manifestDir, source) });
   }
   if (!inputs.length) {
     throw new Error(`No readable sprites for style "${styleId}"; ${noOutput.length} skipped.`);
@@ -19693,7 +19809,7 @@ function mountSprites(placements, options) {
   for (const p of placements) {
     let sourceHash = null;
     try {
-      const bytes = readFileSync5(p.path);
+      const bytes = readFileSync6(p.path);
       sourceHash = sha256(bytes);
       const png = decodePng(bytes);
       if (png.width > cellWidth || png.height > cellHeight) {
@@ -19764,7 +19880,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: path40.resolve(manifestDir, source), cell });
+      placements.push({ id, path: path41.resolve(manifestDir, source), cell });
       continue;
     }
     if (source && entry) {
@@ -19797,7 +19913,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 ? readFileSync5(path40.resolve(manifestDir, mount.base)) : void 0;
+  const basePng = mount.base ? readFileSync6(path41.resolve(manifestDir, mount.base)) : void 0;
   const mounted = mountSprites(placements, {
     cellWidth: mount.cellWidth,
     cellHeight: mount.cellHeight,
@@ -19807,7 +19923,7 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
     ...mounted,
     sources: mount.base ? [{
       id: "$base",
-      path: path40.resolve(manifestDir, mount.base),
+      path: path41.resolve(manifestDir, mount.base),
       sha256: sha256(basePng),
       included: true
     }, ...mounted.sources] : mounted.sources,
@@ -20211,12 +20327,12 @@ async function runPack(args) {
     if (args.primaryOnly || args.outputRoles.length) {
       throw new Error("--primary-only and --output-role require manifest-driven pack");
     }
-    const raw = JSON.parse(await readFile28(path41.resolve(args.inputs), "utf8"));
+    const raw = JSON.parse(await readFile28(path42.resolve(args.inputs), "utf8"));
     const inputs = resolvePackInputs(raw, args.inputs);
     const { png, atlas, skipped, sources } = packSprites(inputs, { columns: args.columns });
     const format = sheetFormat(args);
-    const base = path41.resolve(args.out.replace(/\.(?:png|json|tres)$/i, ""));
-    const { extension, document } = renderSheetDocument(format, atlas, { imageName: path41.basename(`${base}.png`) });
+    const base = path42.resolve(args.out.replace(/\.(?:png|json|tres)$/i, ""));
+    const { extension, document } = renderSheetDocument(format, atlas, { imageName: path42.basename(`${base}.png`) });
     const outputs = [
       { path: `${base}.png`, data: png },
       { path: `${base}${extension}`, data: document }
@@ -20229,7 +20345,7 @@ async function runPack(args) {
     log(
       `  ${atlas.frames.length} sprite(s), ${atlas.sheet.width}x${atlas.sheet.height} in ${atlas.columns} column(s), ${(png.length / 1024).toFixed(1)} KB (${format})`
     );
-    log(`    ${path41.relative(process.cwd(), base)}.png + ${extension} + .pixelkiln.json`);
+    log(`    ${path42.relative(process.cwd(), base)}.png + ${extension} + .pixelkiln.json`);
     for (const s of skipped) log(`    skipped ${s.id}: ${s.reason}`);
     return;
   }
@@ -20237,7 +20353,7 @@ async function runPack(args) {
   if (args.primaryOnly && args.outputRoles.length) {
     throw new Error("pack accepts either --primary-only or --output-role, not both");
   }
-  const manifestDir = path41.dirname(path41.resolve(args.manifest));
+  const manifestDir = path42.dirname(path42.resolve(args.manifest));
   const styleIds = args.styles.length ? args.styles : Object.keys(loaded.manifest.styles);
   for (const styleId of styleIds) {
     const style = loaded.manifest.styles[styleId];
@@ -20252,9 +20368,9 @@ async function runPack(args) {
       sourceOverrides: qualitySources,
       sources: manifestSources(loaded.manifest, styleId)
     });
-    const base = args.out ? path41.resolve(args.out.replace(/\.(?:png|json|tres)$/i, "")) : path41.resolve(manifestDir, style.outDir, `${styleId}-sheet`);
+    const base = args.out ? path42.resolve(args.out.replace(/\.(?:png|json|tres)$/i, "")) : path42.resolve(manifestDir, style.outDir, `${styleId}-sheet`);
     const format = sheetFormat(args);
-    const { extension, document } = renderSheetDocument(format, atlas, { imageName: path41.basename(`${base}.png`) });
+    const { extension, document } = renderSheetDocument(format, atlas, { imageName: path42.basename(`${base}.png`) });
     const outputs = [
       { path: `${base}.png`, data: png },
       { path: `${base}${extension}`, data: document }
@@ -20286,13 +20402,13 @@ async function runPack(args) {
     log(
       `  ${styleId}: ${atlas.frames.length} sprite(s), ${atlas.sheet.width}x${atlas.sheet.height} in ${atlas.columns} column(s)` + (atlas.sets?.length ? `, ${atlas.sets.length} set(s)` : "") + ` (${format})`
     );
-    log(`    ${path41.relative(process.cwd(), base)}.png + ${extension} + .pixelkiln.json`);
+    log(`    ${path42.relative(process.cwd(), base)}.png + ${extension} + .pixelkiln.json`);
     for (const s of skipped) log(`    skipped ${s.id}: ${s.reason}`);
   }
 }
 async function runMount(args) {
   const { loaded, lock } = await openProject2(args);
-  const manifestDir = path41.dirname(path41.resolve(args.manifest));
+  const manifestDir = path42.dirname(path42.resolve(args.manifest));
   const styleIds = args.styles.length ? args.styles : Object.keys(loaded.manifest.styles);
   for (const styleId of styleIds) {
     const style = loaded.manifest.styles[styleId];
@@ -20331,9 +20447,9 @@ async function runMount(args) {
       sources,
       outputRoles
     );
-    const out = path41.resolve(manifestDir, style.mount.out);
+    const out = path42.resolve(manifestDir, style.mount.out);
     const format = sheetFormat(args);
-    const { extension, document } = renderSheetDocument(format, atlas, { imageName: path41.basename(out) });
+    const { extension, document } = renderSheetDocument(format, atlas, { imageName: path42.basename(out) });
     const metadata = out.replace(/\.png$/, "") + extension;
     const companion = out.replace(/\.png$/, "") + ".pixelkiln.json";
     const outputs = [
@@ -20353,7 +20469,7 @@ async function runMount(args) {
         await provenanceFile("$lock", args.lock),
         ...qualityRecords,
         ...artifactSources.filter(
-          (source) => source.id !== "$base" || path41.resolve(source.path) !== out
+          (source) => source.id !== "$base" || path42.resolve(source.path) !== out
         )
       ],
       options: {
@@ -20367,14 +20483,14 @@ async function runMount(args) {
     log(
       `  ${styleId}: ${atlas.frames.length} cell(s) into ${atlas.sheet.width}x${atlas.sheet.height}` + (overBase ? ` over ${style.mount.base}` : " (new sheet)")
     );
-    log(`    ${path41.relative(process.cwd(), out)} + atlas/provenance JSON`);
+    log(`    ${path42.relative(process.cwd(), out)} + atlas/provenance JSON`);
     for (const s of skipped) log(`    skipped ${s.id}: ${s.reason}`);
   }
 }
 async function runExport(args) {
   const { loaded, specs, lock } = await openProject2(args);
   const format = args.format ?? "generic";
-  const manifestDir = path41.dirname(path41.resolve(args.manifest));
+  const manifestDir = path42.dirname(path42.resolve(args.manifest));
   const selected = specs.filter((spec) => {
     if (spec.generator !== "tiles" && spec.generator !== "terrain") return false;
     if (args.styles.length && !args.styles.includes(spec.styleId)) return false;
@@ -20390,12 +20506,12 @@ async function runExport(args) {
   for (const spec of selected) {
     const entry = lock.entries[lockKey(spec.styleId, spec.assetId)];
     const style = loaded.manifest.styles[spec.styleId];
-    const defaultBase = path41.resolve(manifestDir, style.outDir, `${spec.assetId}-tileset`);
-    const base = args.out ? path41.resolve(args.out.replace(/\.(?:png|json|tsj|tres)$/i, "")) : defaultBase;
+    const defaultBase = path42.resolve(manifestDir, style.outDir, `${spec.assetId}-tileset`);
+    const base = args.out ? path42.resolve(args.out.replace(/\.(?:png|json|tsj|tres)$/i, "")) : defaultBase;
     const result = exportTileset(entry, spec, {
       format,
       manifestDir,
-      imageName: path41.basename(`${base}.png`),
+      imageName: path42.basename(`${base}.png`),
       columns: args.columns
     });
     const outputs = [
@@ -20413,7 +20529,7 @@ async function runExport(args) {
         asset: spec.assetId,
         columns: args.columns ?? null,
         format,
-        image: path41.basename(`${base}.png`),
+        image: path42.basename(`${base}.png`),
         providerRules: result.generic.providerRules,
         style: spec.styleId,
         tileType: spec.tileType ?? null
@@ -20423,7 +20539,7 @@ async function runExport(args) {
       `  ${spec.styleId}/${spec.assetId}: ${result.generic.tiles.length} tile(s), ${result.generic.sheet.width}x${result.generic.sheet.height} (${format})`
     );
     log(
-      `    ${path41.relative(process.cwd(), base)}.png + ${path41.basename(base)}${result.extension} + .pixelkiln.json`
+      `    ${path42.relative(process.cwd(), base)}.png + ${path42.basename(base)}${result.extension} + .pixelkiln.json`
     );
   }
 }
@@ -20436,21 +20552,21 @@ function sheetFormat(args) {
 }
 
 // src/cli/commands/pixellab-utils.ts
-import path43 from "path";
+import path44 from "path";
 
 // src/pixellab-utils.ts
 import { existsSync as existsSync33 } from "fs";
 import { mkdir as mkdir13, readFile as readFile29, writeFile as writeFile18 } from "fs/promises";
-import path42 from "path";
+import path43 from "path";
 var UNZOOM_MIN_SIDE = 256;
 var UNZOOM_MAX_AREA = 2048 * 2048;
 function defaultUnzoomOut(input) {
-  const ext = path42.extname(input);
+  const ext = path43.extname(input);
   return `${ext ? input.slice(0, -ext.length) : input}.unzoomed.png`;
 }
 async function unzoomFile(client2, input, opts = {}) {
-  const out = path42.resolve(opts.out ?? defaultUnzoomOut(input));
-  if (path42.resolve(input) === out) throw new Error("unzoom will not overwrite its own input; pass a different --out");
+  const out = path43.resolve(opts.out ?? defaultUnzoomOut(input));
+  if (path43.resolve(input) === out) throw new Error("unzoom will not overwrite its own input; pass a different --out");
   if (existsSync33(out) && !opts.force) throw new Error(`${out} already exists; pass --force to replace it`);
   const bytes = await readFile29(input);
   const metadata = imageMetadata(bytes);
@@ -20465,7 +20581,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 mkdir13(path42.dirname(out), { recursive: true });
+  await mkdir13(path43.dirname(out), { recursive: true });
   await writeFile18(out, res.png);
   return { out, original: res.originalSize, unzoomed: res.unzoomedSize, zoomFactor: res.zoomFactor, usage: res.usage };
 }
@@ -20473,7 +20589,7 @@ var FONT_WEIGHTS = ["Bold", "Regular"];
 var FONT_GLYPH_SIZES = [8, 16, 32, 64];
 var FONT_COST_GENERATIONS = 25;
 function fontOutputPaths(out) {
-  const base = path42.resolve(out.replace(/\.(ttf|png)$/i, ""));
+  const base = path43.resolve(out.replace(/\.(ttf|png)$/i, ""));
   return { ttf: `${base}.ttf`, atlas: `${base}.png` };
 }
 async function generateFont(client2, opts) {
@@ -20507,7 +20623,7 @@ async function generateFont(client2, opts) {
         client2.download(job.download_ttf_url),
         client2.download(job.download_atlas_url)
       ]);
-      await mkdir13(path42.dirname(ttf), { recursive: true });
+      await mkdir13(path43.dirname(ttf), { recursive: true });
       await writeFile18(ttf, ttfBytes);
       await writeFile18(atlas, atlasBytes);
       return { jobId, ttf, atlas, glyphPx: job.glyph_px ?? null, usage: job.usage };
@@ -20523,7 +20639,7 @@ async function generateFont(client2, opts) {
 
 // src/cli/commands/pixellab-utils.ts
 function loadKeys(args) {
-  loadEnvFiles(path43.dirname(path43.resolve(args.manifest)));
+  loadEnvFiles(path44.dirname(path44.resolve(args.manifest)));
   loadEnvFiles(process.cwd());
 }
 async function runUnzoom(args) {
@@ -20589,11 +20705,11 @@ async function runFont(args) {
 }
 
 // src/cli/commands/quality.ts
-import path45 from "path";
+import path46 from "path";
 import { readFile as readFile31 } from "fs/promises";
 
 // src/pipeline/quality-regression.ts
-import path44 from "path";
+import path45 from "path";
 import { existsSync as existsSync34 } from "fs";
 import { readFile as readFile30 } from "fs/promises";
 import { z as z13 } from "zod";
@@ -20601,7 +20717,7 @@ var SHA256_RE = /^[0-9a-f]{64}$/;
 var HEX_RE = /^#[0-9a-f]{6}$/;
 var MAX_REDMEAN_DISTANCE = 765;
 var QualityPathSchema = z13.string().min(1).refine(
-  (value) => !path44.posix.isAbsolute(value) && !value.includes("\\"),
+  (value) => !path45.posix.isAbsolute(value) && !value.includes("\\"),
   "expected a portable relative path"
 );
 var DEFAULT_QUALITY_TOLERANCES = {
@@ -20748,7 +20864,7 @@ function measureDecodedImageQuality(png, digest2) {
   };
 }
 async function measureImageQuality(file) {
-  const absolute = path44.resolve(file);
+  const absolute = path45.resolve(file);
   let bytes;
   try {
     bytes = await readFile30(absolute);
@@ -20770,11 +20886,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 = path44.dirname(path44.resolve(inputsFilePath));
+  const root = path45.dirname(path45.resolve(inputsFilePath));
   return parsed.data.map((entry) => ({
     id: entry.id,
-    file: path44.resolve(root, entry.path),
-    ...entry.record ? { record: path44.resolve(root, entry.record) } : {},
+    file: path45.resolve(root, entry.path),
+    ...entry.record ? { record: path45.resolve(root, entry.record) } : {},
     tolerances: QualityToleranceSchema.parse({
       ...DEFAULT_QUALITY_TOLERANCES,
       ...entry.tolerances
@@ -20782,7 +20898,7 @@ function resolveQualityInputs(raw, inputsFilePath) {
   }));
 }
 function portableRelative2(from, to) {
-  return path44.relative(from, path44.resolve(to)).split(path44.sep).join("/") || ".";
+  return path45.relative(from, path45.resolve(to)).split(path45.sep).join("/") || ".";
 }
 async function verifyRecordForImage(recordPath, imagePath) {
   const verification = await verifyArtifactBundle(recordPath);
@@ -20797,20 +20913,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) => path44.resolve(path44.dirname(recordPath), output.path));
-  if (!outputs.includes(path44.resolve(imagePath))) {
+  const outputs = record.outputs.map((output) => path45.resolve(path45.dirname(recordPath), output.path));
+  if (!outputs.includes(path45.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 = path44.resolve(baselinePath);
+  const absolute = path45.resolve(baselinePath);
   for (const input of inputs) {
-    if (path44.resolve(input.file) === absolute || input.record && path44.resolve(input.record) === absolute) {
+    if (path45.resolve(input.file) === absolute || input.record && path45.resolve(input.record) === absolute) {
       throw new Error(`Quality baseline output would overwrite an input: ${absolute}.`);
     }
   }
-  const root = path44.dirname(absolute);
+  const root = path45.dirname(absolute);
   const cases = [];
   for (const input of [...inputs].sort((a, b) => a.id.localeCompare(b.id))) {
     const expected = await measureImageQuality(input.file);
@@ -20850,7 +20966,7 @@ async function snapshotQualityBaseline(inputs, baselinePath, options = {}) {
   return { baseline, path: absolute, changed: result.changed.length > 0 };
 }
 async function readQualityBaseline(baselinePath) {
-  const absolute = path44.resolve(baselinePath);
+  const absolute = path45.resolve(baselinePath);
   let raw;
   try {
     raw = JSON.parse(await readFile30(absolute, "utf8"));
@@ -20923,12 +21039,12 @@ function regressionViolations(expected, actual, tolerances) {
   return { violations, warnings };
 }
 async function checkQualityBaseline(baselinePath) {
-  const absolute = path44.resolve(baselinePath);
+  const absolute = path45.resolve(baselinePath);
   const baseline = await readQualityBaseline(absolute);
-  const root = path44.dirname(absolute);
+  const root = path45.dirname(absolute);
   const cases = [];
   for (const entry of baseline.cases) {
-    const file = path44.resolve(root, entry.file);
+    const file = path45.resolve(root, entry.file);
     let actual = null;
     const violations = [];
     const warnings = [];
@@ -20941,7 +21057,7 @@ async function checkQualityBaseline(baselinePath) {
       violations.push(message4(error));
     }
     if (entry.record) {
-      const recordPath = path44.resolve(root, entry.record.path);
+      const recordPath = path45.resolve(root, entry.record.path);
       try {
         const recordHash = await sha256File(recordPath);
         if (recordHash !== entry.record.sha256) violations.push("quality record hash changed");
@@ -20983,15 +21099,15 @@ async function runQuality(args) {
     if (!args.out) throw new Error("quality snapshot needs --out <pixelkiln.quality.json>.");
     let raw;
     try {
-      raw = JSON.parse(await readFile31(path45.resolve(args.inputs), "utf8"));
+      raw = JSON.parse(await readFile31(path46.resolve(args.inputs), "utf8"));
     } catch (error) {
       throw new Error(
-        `Could not read quality inputs ${path45.resolve(args.inputs)}: ${error instanceof Error ? error.message : String(error)}`,
+        `Could not read quality inputs ${path46.resolve(args.inputs)}: ${error instanceof Error ? error.message : String(error)}`,
         { cause: error }
       );
     }
     const inputs = resolveQualityInputs(raw, args.inputs);
-    if (path45.resolve(args.inputs) === path45.resolve(args.out)) {
+    if (path46.resolve(args.inputs) === path46.resolve(args.out)) {
       throw new Error("quality snapshot --out must not overwrite its --inputs file.");
     }
     const result = await snapshotQualityBaseline(inputs, args.out, { force: args.force });
@@ -21004,7 +21120,7 @@ async function runQuality(args) {
       }, null, 2));
     } else {
       log(
-        `  ${result.changed ? "wrote" : "unchanged"} ${path45.relative(process.cwd(), result.path)} (${result.baseline.cases.length} case(s))`
+        `  ${result.changed ? "wrote" : "unchanged"} ${path46.relative(process.cwd(), result.path)} (${result.baseline.cases.length} case(s))`
       );
       log(`  Review the tolerances, commit the baseline, then run quality check in CI.`);
     }
@@ -21030,10 +21146,10 @@ async function runQuality(args) {
 }
 
 // src/cli/commands/recipe.ts
-import path47 from "path";
+import path48 from "path";
 
 // src/recipes.ts
-import path46 from "path";
+import path47 from "path";
 import { existsSync as existsSync35 } from "fs";
 import { readdir as readdir3, readFile as readFile32 } from "fs/promises";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -21044,7 +21160,7 @@ var VERSION_RE = /^\d+\.\d+\.\d+$/;
 var RECIPE_FILE = "pixelkiln.recipe.json";
 var RECIPE_DIR_TOKEN = "{{recipeDir}}";
 var PortablePathSchema = z14.string().min(1).refine((value) => {
-  if (value.includes("\\") || path46.posix.isAbsolute(value)) return false;
+  if (value.includes("\\") || path47.posix.isAbsolute(value)) return false;
   const parts = value.split("/");
   return !parts.includes("") && !parts.includes(".") && !parts.includes("..");
 }, "expected a portable relative path without '.', '..', or backslashes");
@@ -21220,7 +21336,7 @@ function message5(error) {
   return error instanceof Error ? error.message : String(error);
 }
 async function readRecipeFile(recipePath, bundled) {
-  const absolute = path46.resolve(recipePath);
+  const absolute = path47.resolve(recipePath);
   let raw;
   try {
     raw = JSON.parse(await readFile32(absolute, "utf8"));
@@ -21234,13 +21350,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: path46.dirname(absolute), bundled };
+  return { recipe: parsed.data, authored: raw, path: absolute, dir: path47.dirname(absolute), bundled };
 }
 async function walkRecipeFiles(root) {
   if (!existsSync35(root)) return [];
   const out = [];
   for (const entry of await readdir3(root, { withFileTypes: true })) {
-    const resolved = path46.join(root, entry.name);
+    const resolved = path47.join(root, entry.name);
     if (entry.isDirectory()) out.push(...await walkRecipeFiles(resolved));
     else if (entry.isFile() && entry.name === RECIPE_FILE) out.push(resolved);
   }
@@ -21251,7 +21367,7 @@ function bundledRecipeRoot() {
 }
 async function listBundledRecipes(root = bundledRecipeRoot()) {
   const recipes = await Promise.all(
-    (await walkRecipeFiles(path46.resolve(root))).map((file) => readRecipeFile(file, true))
+    (await walkRecipeFiles(path47.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)
@@ -21274,9 +21390,9 @@ function parseSelector(selector) {
   return { id: match[1], version: match[2] };
 }
 async function resolveRecipe(target, bundledRoot = bundledRecipeRoot()) {
-  const local = path46.resolve(target);
+  const local = path47.resolve(target);
   if (existsSync35(local)) {
-    const recipePath = path46.basename(local) === RECIPE_FILE ? local : path46.join(local, RECIPE_FILE);
+    const recipePath = path47.basename(local) === RECIPE_FILE ? local : path47.join(local, RECIPE_FILE);
     return readRecipeFile(recipePath, false);
   }
   if (target.startsWith(".") || target.startsWith("/") || target.includes("\\")) {
@@ -21290,7 +21406,7 @@ async function resolveRecipe(target, bundledRoot = bundledRecipeRoot()) {
   return matches[0];
 }
 async function verifyFile(root, file) {
-  const absolute = path46.resolve(root, ...file.path.split("/"));
+  const absolute = path47.resolve(root, ...file.path.split("/"));
   if (!existsSync35(absolute)) {
     return { path: file.path, expectedSha256: file.sha256, actualSha256: null, status: "missing" };
   }
@@ -21306,7 +21422,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 ? path46.resolve(options.modelRoot) : null;
+  const modelRoot = options.modelRoot ? path47.resolve(options.modelRoot) : null;
   const models = modelRoot ? await Promise.all(loaded.recipe.models.map(async (model) => ({
     ...await verifyFile(modelRoot, model),
     source: model.source,
@@ -21340,7 +21456,7 @@ async function verifyRecipe(target, options = {}) {
   };
 }
 function renderStyle(style, destination, cwd) {
-  const portableDir = path46.relative(cwd, destination).split(path46.sep).join("/") || ".";
+  const portableDir = path47.relative(cwd, destination).split(path47.sep).join("/") || ".";
   const replace = (value) => {
     if (typeof value === "string") return value.replaceAll(RECIPE_DIR_TOKEN, portableDir);
     if (Array.isArray(value)) return value.map(replace);
@@ -21352,19 +21468,19 @@ function renderStyle(style, destination, cwd) {
   return replace(style);
 }
 async function installRecipe(target, options = {}) {
-  const cwd = path46.resolve(options.cwd ?? process.cwd());
+  const cwd = path47.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 ? path46.resolve(cwd, options.out) : path46.join(cwd, "pixelkiln-recipes", ...loaded.recipe.id.split("/"), loaded.recipe.version);
+  const destination = options.out ? path47.resolve(cwd, options.out) : path47.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: path46.join(loaded.dir, ...file.path.split("/")) }))
+    ...loaded.recipe.files.map((file) => ({ path: file.path, source: path47.join(loaded.dir, ...file.path.split("/")) }))
   ];
   const files = await Promise.all(sources.map(async (file) => ({
-    path: path46.join(destination, ...file.path.split("/")),
+    path: path47.join(destination, ...file.path.split("/")),
     data: await readFile32(file.source)
   })));
   if (!options.force) {
@@ -21464,14 +21580,14 @@ async function runRecipe(args) {
       }, null, 2));
     } else {
       log(`  installed ${result.recipe.id}@${result.recipe.version}`);
-      log(`  ${path47.relative(process.cwd(), result.destination) || "."}`);
+      log(`  ${path48.relative(process.cwd(), result.destination) || "."}`);
       log(`
   Add this entry under your manifest's styles object:`);
       log(JSON.stringify({ [result.styleId]: result.style }, null, 2));
       if (result.recipe.models.length) {
         log(`
   Models are not downloaded automatically. Verify them with:`);
-        log(`  pixelkiln recipe verify ${path47.relative(process.cwd(), result.destination)} --model-root <ComfyUI/models>`);
+        log(`  pixelkiln recipe verify ${path48.relative(process.cwd(), result.destination)} --model-root <ComfyUI/models>`);
       }
     }
     return;
@@ -21479,7 +21595,7 @@ async function runRecipe(args) {
 }
 
 // src/cli/commands/refine.ts
-import path48 from "path";
+import path49 from "path";
 async function runRefine(args) {
   if (args.from || args.subcommand === "approve") {
     if (!args.from) {
@@ -21509,12 +21625,12 @@ async function runRefine(args) {
           `  recovered ${result3.detection.columns}x${result3.detection.rows} native grid (${result3.detection.confidence}: ${result3.detection.consensus})`
         );
         log(`  enforced ${result3.palette.length}-color palette without dithering`);
-        log(`  wrote ${path48.relative(process.cwd(), result3.output)}`);
-        log(`  quality record: ${path48.relative(process.cwd(), result3.record)}`);
+        log(`  wrote ${path49.relative(process.cwd(), result3.output)}`);
+        log(`  quality record: ${path49.relative(process.cwd(), result3.record)}`);
         log(`
   Automated checks passed. Human 1\xD7 review is still required:`);
         log(
-          `    pixelkiln refine approve --from ${path48.relative(process.cwd(), result3.record)} --reviewer "Your Name"`
+          `    pixelkiln refine approve --from ${path49.relative(process.cwd(), result3.record)} --reviewer "Your Name"`
         );
       }
       return;
@@ -21542,7 +21658,7 @@ async function runRefine(args) {
       if (args.json) log(JSON.stringify(result3, null, 2));
       else {
         log(
-          result3.options.frameSet ? `  approved ${result3.outputs.length} frames in ${path48.relative(process.cwd(), result3.record)} by ${args.reviewer.trim()}` : `  approved ${path48.relative(process.cwd(), result3.output)} by ${args.reviewer.trim()}`
+          result3.options.frameSet ? `  approved ${result3.outputs.length} frames in ${path49.relative(process.cwd(), result3.record)} by ${args.reviewer.trim()}` : `  approved ${path49.relative(process.cwd(), result3.output)} by ${args.reviewer.trim()}`
         );
       }
       return;
@@ -21551,7 +21667,7 @@ async function runRefine(args) {
     if (args.json) {
       log(JSON.stringify(result2, null, 2));
     } else {
-      log(`  ${result2.safe ? "release-ready" : "not release-ready"}: ${path48.relative(process.cwd(), result2.output || result2.record)}`);
+      log(`  ${result2.safe ? "release-ready" : "not release-ready"}: ${path49.relative(process.cwd(), result2.output || result2.record)}`);
       for (const reason of result2.reasons) log(`    ${reason}`);
     }
     if (!result2.safe) process.exitCode = 1;
@@ -21597,7 +21713,7 @@ async function runRefine(args) {
       log(`  ${item.state.padEnd(16)} ${item.key}  ${item.reason}`);
       if (item.state === "needs-approval") {
         log(
-          `    pixelkiln refine approve --from ${path48.relative(process.cwd(), item.record)} --reviewer "Your Name"`
+          `    pixelkiln refine approve --from ${path49.relative(process.cwd(), item.record)} --reviewer "Your Name"`
         );
       }
     }
@@ -21608,7 +21724,7 @@ async function runRefine(args) {
 }
 
 // src/cli/commands/skeleton.ts
-import path49 from "path";
+import path50 from "path";
 import { existsSync as existsSync36 } from "fs";
 import { readFile as readFile33, writeFile as writeFile19 } from "fs/promises";
 
@@ -21721,12 +21837,12 @@ var Canvas = class {
 async function runEstimateSkeleton(args) {
   const image = args.target;
   if (!image) throw new UsageError("estimate-skeleton needs an image path: pixelkiln estimate-skeleton <image> [--out keypoints.json]");
-  if (args.out && existsSync36(path49.resolve(args.out)) && !args.force) {
+  if (args.out && existsSync36(path50.resolve(args.out)) && !args.force) {
     throw new UsageError(`${args.out} already exists; pass --force to replace it`);
   }
-  loadEnvFiles(path49.dirname(path49.resolve(args.manifest)));
+  loadEnvFiles(path50.dirname(path50.resolve(args.manifest)));
   loadEnvFiles(process.cwd());
-  const bytes = await readFile33(path49.resolve(image));
+  const bytes = await readFile33(path50.resolve(image));
   const metadata = imageMetadata(bytes);
   if (!metadata) throw new UsageError(`${image} is not a readable PNG or JPEG`);
   const sizeProblem = estimateSkeletonSizeProblem(metadata.width, metadata.height);
@@ -21738,7 +21854,7 @@ async function runEstimateSkeleton(args) {
   const frames = args.frames ?? DEFAULT_SCAFFOLD_FRAMES;
   const json = JSON.stringify(scaffoldSkeletonSet(res.keypoints, frames), null, 2);
   if (args.out) {
-    await writeFile19(path49.resolve(args.out), json + "\n");
+    await writeFile19(path50.resolve(args.out), json + "\n");
     log(`  wrote ${args.out}: the estimated pose and ${frames} frames to edit`);
     log(`  preview it with: pixelkiln skeleton-preview ${args.out} --from ${image}`);
   } else {
@@ -21751,8 +21867,8 @@ async function runSkeletonPreview(args) {
   let sourceFile;
   let label;
   if (target.endsWith(".json")) {
-    keypointsFile = path49.resolve(target);
-    sourceFile = args.from ? path49.resolve(args.from) : void 0;
+    keypointsFile = path50.resolve(target);
+    sourceFile = args.from ? path50.resolve(args.from) : void 0;
     label = target;
   } else {
     const loaded = await loadManifest(args.manifest);
@@ -21764,7 +21880,7 @@ async function runSkeletonPreview(args) {
       );
     }
     keypointsFile = spec.revision.keypointsFile;
-    sourceFile = args.from ? path49.resolve(args.from) : spec.revision.sourceFile;
+    sourceFile = args.from ? path50.resolve(args.from) : spec.revision.sourceFile;
     label = `${spec.styleId}/${spec.assetId}`;
   }
   if (!existsSync36(keypointsFile)) throw new UsageError(`Keypoints file does not exist yet: ${keypointsFile}`);
@@ -21785,10 +21901,10 @@ async function runSkeletonPreview(args) {
       source = decodePng(bytes);
     }
   }
-  const out = path49.resolve(args.out ?? keypointsFile.replace(/\.json$/, "") + ".preview.png");
+  const out = path50.resolve(args.out ?? keypointsFile.replace(/\.json$/, "") + ".preview.png");
   await writeFile19(out, renderSkeletonSheet(set, { source }));
   log(`  ${label}: ${set.frames.length} frames after the starting pose`);
-  const shown = path49.relative(process.cwd(), out);
+  const shown = path50.relative(process.cwd(), out);
   log(`  wrote ${shown.startsWith("..") ? out : shown}`);
 }
 
@@ -21834,15 +21950,15 @@ async function runTools(args) {
 }
 
 // src/cli/commands/workspace.ts
-import path50 from "path";
+import path51 from "path";
 import { existsSync as existsSync37 } from "fs";
 async function runWorkspace(args) {
-  const workspacePath = path50.resolve(args.workspace ?? "pixelkiln.workspace.json");
-  const dir = path50.dirname(workspacePath);
+  const workspacePath = path51.resolve(args.workspace ?? "pixelkiln.workspace.json");
+  const dir = path51.dirname(workspacePath);
   if (args.subcommand === "add") {
-    const manifestPath = path50.resolve(args.target);
+    const manifestPath = path51.resolve(args.target);
     const loadedTarget = await loadManifest(manifestPath);
-    const lockPath = args.explicitLock ? path50.resolve(args.explicitLock) : path50.join(path50.dirname(manifestPath), "pixelkiln.lock.json");
+    const lockPath = args.explicitLock ? path51.resolve(args.explicitLock) : path51.join(path51.dirname(manifestPath), "pixelkiln.lock.json");
     const ws = await loadWorkspace(workspacePath);
     const id = args.name ?? loadedTarget.manifest.name;
     if (ws.projects.some((p) => p.id === id)) {
@@ -21862,7 +21978,7 @@ async function runWorkspace(args) {
       ...args.account ? { account: args.account } : {}
     };
     await saveWorkspace(workspacePath, { version: 1, projects: [...ws.projects, project] });
-    log(`  registered "${id}" in ${path50.relative(process.cwd(), workspacePath)}`);
+    log(`  registered "${id}" in ${path51.relative(process.cwd(), workspacePath)}`);
     log(`    manifest: ${project.manifest}`);
     log(`    lock:     ${project.lock}`);
     if (!existsSync37(lockPath)) {
@@ -21874,7 +21990,7 @@ async function runWorkspace(args) {
   }
   if (args.subcommand === "remove") {
     const ws = await loadWorkspace(workspacePath);
-    const resolvedTarget = path50.resolve(args.target);
+    const resolvedTarget = path51.resolve(args.target);
     const match = ws.projects.find(
       (p) => p.id === args.target || resolveProject(dir, p).manifestPath === resolvedTarget
     );
@@ -21885,7 +22001,7 @@ async function runWorkspace(args) {
       version: 1,
       projects: ws.projects.filter((p) => p !== match)
     });
-    log(`  removed "${match.id}" from ${path50.relative(process.cwd(), workspacePath)}`);
+    log(`  removed "${match.id}" from ${path51.relative(process.cwd(), workspacePath)}`);
     return;
   }
   if (args.subcommand === "list") {
@@ -21897,9 +22013,9 @@ async function runWorkspace(args) {
     if (args.json) {
       log(JSON.stringify({ version: 1, workspace: workspacePath, projects: ws.projects, diagnostics }, null, 2));
     } else if (!ws.projects.length) {
-      log(`  no projects registered in ${path50.relative(process.cwd(), workspacePath)}`);
+      log(`  no projects registered in ${path51.relative(process.cwd(), workspacePath)}`);
     } else {
-      log(`  ${ws.projects.length} project(s) in ${path50.relative(process.cwd(), workspacePath)}:`);
+      log(`  ${ws.projects.length} project(s) in ${path51.relative(process.cwd(), workspacePath)}:`);
       for (const p of ws.projects) {
         log(`    ${p.id.padEnd(24)} ${p.manifest.padEnd(40)} (${p.provider}${p.account ? `, ${p.account}` : ""})`);
       }
@@ -21917,7 +22033,7 @@ async function runWorkspace(args) {
     if (args.json) {
       log(JSON.stringify({ ...report, workspace: workspacePath }, null, 2));
     } else {
-      log(`  workspace: ${path50.relative(process.cwd(), workspacePath)}`);
+      log(`  workspace: ${path51.relative(process.cwd(), workspacePath)}`);
       for (const p of report.projects) {
         if (p.error) {
           log(`