pixelkiln 0.11.0 → 0.12.0

package/dist/cli.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import path20 from "path";
-import { existsSync as existsSync15 } from "fs";
-import { readFile as readFile16 } from "fs/promises";
+import path22 from "path";
+import { existsSync as existsSync17 } from "fs";
+import { readFile as readFile17 } from "fs/promises";
 
 // src/env.ts
 import { readFileSync, existsSync } from "fs";
@@ -105,17 +105,23 @@ function formatCost(unit, amount) {
 
 // src/providers/comfyui.ts
 import { randomUUID } from "crypto";
-import { readFile as readFile2 } from "fs/promises";
+import { readFile } from "fs/promises";
 import path2 from "path";
 
 // src/hash.ts
 import { createHash } from "crypto";
-import { readFile } from "fs/promises";
+import { createReadStream } from "fs";
 function sha256(data) {
   return createHash("sha256").update(data).digest("hex");
 }
-async function sha256File(path21) {
-  return sha256(await readFile(path21));
+async function sha256File(path23) {
+  return new Promise((resolve, reject) => {
+    const hash = createHash("sha256");
+    const stream = createReadStream(path23);
+    stream.on("data", (chunk2) => hash.update(chunk2));
+    stream.on("error", reject);
+    stream.on("end", () => resolve(hash.digest("hex")));
+  });
 }
 function specHash(spec, styleImageHashes, providerOptionIdentity = spec.providerOptions) {
   return sha256(
@@ -683,7 +689,7 @@ var ComfyUIProvider = class _ComfyUIProvider {
     const workflowPath = path2.resolve(context.root, options.workflowFile);
     let raw;
     try {
-      raw = await readFile2(workflowPath, "utf8");
+      raw = await readFile(workflowPath, "utf8");
     } catch (err) {
       throw new Error(
         `ComfyUI workflow for style "${context.styleId}" could not be read at ${workflowPath}: ${err instanceof Error ? err.message : String(err)}`
@@ -974,9 +980,9 @@ function normalizeBaseUrl(value) {
 }
 function historyError(status) {
   const messages = Array.isArray(status.messages) ? status.messages : [];
-  for (const message3 of messages) {
-    if (!Array.isArray(message3) || message3[0] !== "execution_error" || !isObject(message3[1])) continue;
-    const detail = message3[1].exception_message;
+  for (const message5 of messages) {
+    if (!Array.isArray(message5) || message5[0] !== "execution_error" || !isObject(message5[1])) continue;
+    const detail = message5[1].exception_message;
     if (typeof detail === "string" && detail.trim()) {
       return `ComfyUI execution failed: ${detail.trim().slice(0, 300)}`;
     }
@@ -1097,8 +1103,8 @@ function validateResponse(schema, raw, operation) {
   throw new Error(`Invalid PixelLab response for ${operation}: ${issues}`);
 }
 var PixelLabError = class extends Error {
-  constructor(message3, status, body) {
-    super(message3);
+  constructor(message5, status, body) {
+    super(message5);
     this.status = status;
     this.body = body;
     this.name = "PixelLabError";
@@ -1123,11 +1129,11 @@ var PixelLabClient = class {
    * common than the failure mode of retrying (a duplicate object), and a
    * duplicate is visible and free to delete whereas a silent gap is neither.
    */
-  async request(path21, init, attempt = 0) {
+  async request(path23, init, attempt = 0) {
     const auth = this.apiKey.startsWith("Bearer ") ? this.apiKey : `Bearer ${this.apiKey}`;
     let res;
     try {
-      res = await fetch(`${BASE}${path21}`, {
+      res = await fetch(`${BASE}${path23}`, {
         ...init,
         signal: init?.signal ?? AbortSignal.timeout(this.timeoutMs),
         headers: {
@@ -1139,24 +1145,24 @@ var PixelLabClient = class {
     } catch (err) {
       if (attempt < MAX_RETRIES) {
         await sleep(backoffMs(attempt));
-        return this.request(path21, init, attempt + 1);
+        return this.request(path23, init, attempt + 1);
       }
       throw err;
     }
     if (!res.ok && shouldRetry(res.status) && attempt < MAX_RETRIES) {
       const waitMs = retryAfterMs(res.headers.get("retry-after")) ?? backoffMs(attempt);
       await sleep(waitMs);
-      return this.request(path21, init, attempt + 1);
+      return this.request(path23, init, attempt + 1);
     }
     const text = await res.text();
     if (!res.ok) {
-      throw new PixelLabError(`${init?.method ?? "GET"} ${path21} \u2192 ${res.status}`, res.status, text);
+      throw new PixelLabError(`${init?.method ?? "GET"} ${path23} \u2192 ${res.status}`, res.status, text);
     }
     if (!text) return {};
     try {
       return JSON.parse(text);
     } catch {
-      throw new Error(`${init?.method ?? "GET"} ${path21} returned invalid JSON`);
+      throw new Error(`${init?.method ?? "GET"} ${path23} returned invalid JSON`);
     }
   }
   async balance() {
@@ -1996,9 +2002,9 @@ var RetroDiffusionClient = class {
     }
     return balance;
   }
-  async call(path21, init = {}) {
+  async call(path23, init = {}) {
     if (!this.token) throw new Error("RD_API_KEY is not set");
-    const response = await this.request(`${this.baseUrl}${path21}`, {
+    const response = await this.request(`${this.baseUrl}${path23}`, {
       ...init,
       headers: {
         "Content-Type": "application/json",
@@ -2262,8 +2268,8 @@ function retroError(value) {
     if (details.length) return details.join("; ");
   }
   if (record.detail && typeof record.detail === "object") {
-    const message3 = record.detail.message;
-    if (typeof message3 === "string") return message3;
+    const message5 = record.detail.message;
+    if (typeof message5 === "string") return message5;
   }
   return JSON.stringify(value);
 }
@@ -2315,13 +2321,13 @@ registerProvider({
 });
 
 // src/manifest.ts
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile2 } from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
 import path4 from "path";
 async function loadManifest(manifestPath) {
   const abs = path4.resolve(manifestPath);
   if (!existsSync3(abs)) throw new Error(`No manifest at ${abs}`);
-  const parsed = ManifestSchema.safeParse(JSON.parse(await readFile3(abs, "utf8")));
+  const parsed = ManifestSchema.safeParse(JSON.parse(await readFile2(abs, "utf8")));
   if (!parsed.success) {
     const issues = parsed.error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n");
     throw new Error(`Manifest at ${abs} is invalid:
@@ -2370,7 +2376,7 @@ async function resolveSpecs(loaded, filter) {
     let hit = styleImageCache.get(abs);
     if (!hit) {
       if (!existsSync3(abs)) throw new Error(`Style image not found: ${abs}`);
-      const buf = await readFile3(abs);
+      const buf = await readFile2(abs);
       const metadata = imageMetadata(buf);
       if (!metadata) throw new Error(`Style image is not a readable PNG or JPEG: ${abs}`);
       if (metadata.width < 1 || metadata.height < 1) {
@@ -2496,7 +2502,7 @@ async function resolveStyleImages(loaded, styleId) {
   const out = [];
   for (const img of style.styleImages) {
     const file = path4.resolve(loaded.root, img.path);
-    const buf = await readFile3(file);
+    const buf = await readFile2(file);
     const metadata = imageMetadata(buf);
     if (!metadata) throw new Error(`Style image is not a readable PNG or JPEG: ${file}`);
     if (metadata.width < 1 || metadata.height < 1) {
@@ -2543,13 +2549,13 @@ import path7 from "path";
 import path6 from "path";
 
 // src/lock.ts
-import { readFile as readFile4, writeFile, rename, mkdir, rmdir, rm, stat } from "fs/promises";
+import { readFile as readFile3, writeFile, rename, mkdir, rmdir, rm, stat } from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
 import path5 from "path";
 async function loadLock(lockPath) {
   if (!existsSync4(lockPath)) return { version: 2, entries: {} };
   try {
-    return parseLock(JSON.parse(await readFile4(lockPath, "utf8")));
+    return parseLock(JSON.parse(await readFile3(lockPath, "utf8")));
   } catch (err) {
     throw new Error(
       `Lockfile at ${lockPath} is malformed:
@@ -2585,7 +2591,7 @@ async function writeLockWhileHeld(file, lock) {
   let disk = { version: 2, entries: {} };
   if (existsSync4(file)) {
     try {
-      disk = parseLock(JSON.parse(await readFile4(file, "utf8")));
+      disk = parseLock(JSON.parse(await readFile3(file, "utf8")));
     } catch (err) {
       throw new Error(
         `Refusing to overwrite malformed lockfile at ${file}: ${err instanceof Error ? err.message : String(err)}`
@@ -3262,9 +3268,9 @@ async function submit(provider, loaded, items, lock, lockPath, opts = {}) {
       );
     } catch (err) {
       failed++;
-      const message3 = err instanceof Error ? err.message : String(err);
-      upsert(lock, key, { status: "failed", error: message3, cost: 0 });
-      log2(`  FAILED ${key}: ${message3}`);
+      const message5 = err instanceof Error ? err.message : String(err);
+      upsert(lock, key, { status: "failed", error: message5, cost: 0 });
+      log2(`  FAILED ${key}: ${message5}`);
     }
     await saveLock(lockPath, lock);
   }
@@ -3335,7 +3341,7 @@ async function poll(provider, lock, lockPath, opts = {}) {
 
 // src/pipeline/fetch.ts
 import { existsSync as existsSync6 } from "fs";
-import { mkdir as mkdir2, readFile as readFile5, rename as rename2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { mkdir as mkdir2, readFile as readFile4, rename as rename2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
 import path9 from "path";
 async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
   const log2 = opts.onProgress ?? (() => {
@@ -3395,7 +3401,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
             if (cacheDir) {
               await cacheMedia(
                 cacheDir,
-                await readFile5(target),
+                await readFile4(target),
                 recorded.mediaType ?? MediaType.PNG,
                 recorded.sha256
               );
@@ -3452,14 +3458,14 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
         });
         result.downloaded++;
       } catch (err) {
-        const message3 = err instanceof Error ? err.message : String(err);
+        const message5 = err instanceof Error ? err.message : String(err);
         upsert(lock, key, {
           status: "download-failed",
           outputs: mergeOutputs(entry.outputs, outputs),
-          error: `download failed: ${message3}`
+          error: `download failed: ${message5}`
         });
         result.failed++;
-        log2(`  FAILED  ${key}: ${message3}`);
+        log2(`  FAILED  ${key}: ${message5}`);
       }
       await saveLock(lockPath, lock);
     }
@@ -3472,7 +3478,7 @@ async function readCachedMedia(cacheDir, hash, mediaType) {
   const file = path9.join(cacheDir, cacheFileName(hash, mediaType));
   if (!existsSync6(file)) return null;
   try {
-    const buf = await readFile5(file);
+    const buf = await readFile4(file);
     if (sha256(buf) !== hash) return null;
     validateMedia(buf, mediaType);
     return buf;
@@ -3529,7 +3535,7 @@ import { access, stat as stat2 } from "fs/promises";
 import path10 from "path";
 async function doctor(loaded, specs, lock, lockPath, opts = {}) {
   const checks = [];
-  const add = (id, level, message3) => checks.push({ id, level, message: message3 });
+  const add = (id, level, message5) => checks.push({ id, level, message: message5 });
   add(
     "manifest",
     "ok",
@@ -3659,11 +3665,11 @@ async function nearestExistingDirectory(start) {
 
 // src/pipeline/adopt.ts
 import { existsSync as existsSync9 } from "fs";
-import { readFile as readFile7, writeFile as writeFile4 } from "fs/promises";
+import { readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
 import path11 from "path";
 
 // src/cache.ts
-import { mkdir as mkdir3, readFile as readFile6, rename as rename3, rm as rm3, writeFile as writeFile3 } from "fs/promises";
+import { mkdir as mkdir3, readFile as readFile5, rename as rename3, rm as rm3, writeFile as writeFile3 } from "fs/promises";
 import { existsSync as existsSync8 } from "fs";
 import pathModule from "path";
 import { z as z3 } from "zod";
@@ -3679,10 +3685,10 @@ function isSha256Hash(value) {
 function parseCache(value) {
   return HashCacheSchema.parse(value);
 }
-async function loadCache(path21) {
-  if (!existsSync8(path21)) return { version: 1, hashes: {} };
+async function loadCache(path23) {
+  if (!existsSync8(path23)) return { version: 1, hashes: {} };
   try {
-    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile6(path21, "utf8")));
+    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile5(path23, "utf8")));
     if (!parsed.success) return { version: 1, hashes: {} };
     return {
       version: 1,
@@ -3694,18 +3700,18 @@ async function loadCache(path21) {
     return { version: 1, hashes: {} };
   }
 }
-async function saveCache(path21, cache) {
+async function saveCache(path23, 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 mkdir3(pathModule.dirname(pathModule.resolve(path21)), { recursive: true });
-  const tmp = `${path21}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  await mkdir3(pathModule.dirname(pathModule.resolve(path23)), { recursive: true });
+  const tmp = `${path23}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
     await writeFile3(tmp, JSON.stringify({ version: 1, hashes: sorted }, null, 2) + "\n");
-    await rename3(tmp, path21);
+    await rename3(tmp, path23);
   } finally {
     await rm3(tmp, { force: true });
   }
@@ -3740,7 +3746,7 @@ async function adopt(provider, specs, lock, lockPath, opts = {}) {
       unmatchedLocal.push(`${spec.styleId}/${spec.assetId} (no file at ${spec.outFile})`);
       continue;
     }
-    const bytes = await readFile7(spec.outFile);
+    const bytes = await readFile6(spec.outFile);
     try {
       decodePng(bytes);
     } catch (err) {
@@ -3857,7 +3863,7 @@ async function tagAdopted(provider, specs, lock, opts = {}) {
 async function writePromptsBack(manifestPath, lock, opts = {}) {
   const log2 = opts.onProgress ?? (() => {
   });
-  const raw = JSON.parse(await readFile7(manifestPath, "utf8"));
+  const raw = JSON.parse(await readFile6(manifestPath, "utf8"));
   const best = /* @__PURE__ */ new Map();
   for (const entry of Object.values(lock.entries)) {
     if (!entry.objectId || !entry.prompt) continue;
@@ -4156,10 +4162,10 @@ function serveReviewPage(opts) {
           res.end(JSON.stringify(result));
           server.close(() => resolve(result));
         } catch (err) {
-          const message3 = err instanceof Error ? err.message : String(err);
-          log2(`  apply failed: ${message3}`);
+          const message5 = err instanceof Error ? err.message : String(err);
+          log2(`  apply failed: ${message5}`);
           res.writeHead(500, { "Content-Type": "text/plain" });
-          res.end(message3);
+          res.end(message5);
         }
         return;
       }
@@ -4247,7 +4253,7 @@ async function runPicker(provider, lock, lockPath, opts = {}) {
 }
 
 // src/pipeline/init.ts
-import { readdir, readFile as readFile8, writeFile as writeFile5 } from "fs/promises";
+import { readdir, readFile as readFile7, writeFile as writeFile5 } from "fs/promises";
 import { existsSync as existsSync10 } from "fs";
 import path12 from "path";
 function pngSize(buf) {
@@ -4277,7 +4283,7 @@ async function scanAssets(root, opts = {}) {
   const skipped = [];
   const seen = /* @__PURE__ */ new Map();
   for (const file of files.sort()) {
-    const size = pngSize(await readFile8(file));
+    const size = pngSize(await readFile7(file));
     if (!size) {
       skipped.push(`${file} (not a readable PNG)`);
       continue;
@@ -4346,7 +4352,7 @@ async function writeManifestFile(target, manifest) {
 }
 
 // src/pipeline/salvage.ts
-import { readFile as readFile9 } from "fs/promises";
+import { readFile as readFile8 } from "fs/promises";
 import { existsSync as existsSync11 } from "fs";
 import path13 from "path";
 async function loadClaims(lockPaths) {
@@ -4355,7 +4361,7 @@ async function loadClaims(lockPaths) {
     if (!existsSync11(p)) throw new Error(`Claim lockfile not found: ${p}`);
     let parsed;
     try {
-      parsed = parseLock(JSON.parse(await readFile9(p, "utf8")));
+      parsed = parseLock(JSON.parse(await readFile8(p, "utf8")));
     } catch {
       throw new Error(`Claim lockfile is malformed: ${p}`);
     }
@@ -4526,7 +4532,7 @@ async function applyTags(provider, decisions, existing, opts = {}) {
 }
 
 // src/workspace.ts
-import { mkdir as mkdir4, readFile as readFile10, rename as rename4, rm as rm4, writeFile as writeFile6 } from "fs/promises";
+import { mkdir as mkdir4, readFile as readFile9, rename as rename4, rm as rm4, writeFile as writeFile6 } from "fs/promises";
 import { existsSync as existsSync12 } from "fs";
 import path14 from "path";
 import { z as z4 } from "zod";
@@ -4556,7 +4562,7 @@ async function loadWorkspace(workspacePath) {
   if (!existsSync12(workspacePath)) return { version: 1, projects: [] };
   let raw;
   try {
-    raw = JSON.parse(await readFile10(workspacePath, "utf8"));
+    raw = JSON.parse(await readFile9(workspacePath, "utf8"));
   } catch (err) {
     throw new Error(
       `Workspace catalog at ${workspacePath} is malformed:
@@ -4753,7 +4759,7 @@ async function workspaceStatus(ws, dir) {
 }
 
 // src/pipeline/audit.ts
-import { readFile as readFile11 } from "fs/promises";
+import { readFile as readFile10 } from "fs/promises";
 import { existsSync as existsSync13 } from "fs";
 import path15 from "path";
 function colorDistance(a, b) {
@@ -4805,7 +4811,7 @@ async function auditStyle(loaded, specs, styleId, lock) {
         continue;
       }
       try {
-        const png = decodePng(await readFile11(output.absolutePath));
+        const png = decodePng(await readFile10(output.absolutePath));
         const palette = extractPalette(png, 12);
         assets.push({
           assetId: spec.assetId,
@@ -4832,7 +4838,7 @@ async function auditStyle(loaded, specs, styleId, lock) {
     const abs = path15.resolve(loaded.root, img.path);
     if (!existsSync13(abs)) continue;
     try {
-      refPalettes.push(extractPalette(decodePng(await readFile11(abs)), 12));
+      refPalettes.push(extractPalette(decodePng(await readFile10(abs)), 12));
     } catch {
     }
   }
@@ -4909,7 +4915,7 @@ function hex(c) {
 
 // src/pipeline/cache-health.ts
 import { existsSync as existsSync14 } from "fs";
-import { readFile as readFile12, readdir as readdir2, rm as rm5 } from "fs/promises";
+import { readFile as readFile11, readdir as readdir2, rm as rm5 } from "fs/promises";
 import path16 from "path";
 async function inspectCaches(lock, lockPath, options = {}) {
   if (options.prune && !existsSync14(lockPath)) {
@@ -4939,7 +4945,7 @@ async function inspectCaches(lock, lockPath, options = {}) {
       await saveCache(remotePath, { version: 1, hashes: {} });
       removed.resetRemoteHashCache = true;
     } else if (remoteHashes.invalidIds.length) {
-      const cache = parseCache(JSON.parse(await readFile12(remotePath, "utf8")));
+      const cache = parseCache(JSON.parse(await readFile11(remotePath, "utf8")));
       for (const id of remoteHashes.invalidIds) delete cache.hashes[id];
       removed.remoteHashEntries = remoteHashes.invalidIds.length;
       await saveCache(remotePath, cache);
@@ -4983,7 +4989,7 @@ async function inspectContentCache(contentDir, referenced) {
     const expected = mediaType ? entry.name.slice(0, -4) : "";
     let bytes;
     try {
-      bytes = await readFile12(file);
+      bytes = await readFile11(file);
       report.bytes += bytes.length;
     } catch (err) {
       report.invalid.push({
@@ -5030,7 +5036,7 @@ async function inspectRemoteHashCache(remotePath) {
   if (!report.exists) return report;
   let cache;
   try {
-    cache = parseCache(JSON.parse(await readFile12(remotePath, "utf8")));
+    cache = parseCache(JSON.parse(await readFile11(remotePath, "utf8")));
   } catch (err) {
     report.error = err instanceof Error ? err.message : String(err);
     return report;
@@ -5047,14 +5053,14 @@ async function inspectRemoteHashCache(remotePath) {
 // src/pipeline/refine.ts
 import path18 from "path";
 import { execFile } from "child_process";
-import { mkdtemp, readFile as readFile14, rm as rm7 } from "fs/promises";
+import { mkdtemp, readFile as readFile13, rm as rm7 } from "fs/promises";
 import { tmpdir } from "os";
 import { promisify } from "util";
 
 // src/artifacts.ts
 import path17 from "path";
 import { createHash as createHash2, randomUUID as randomUUID3 } from "crypto";
-import { mkdir as mkdir5, readFile as readFile13, rename as rename5, rm as rm6, writeFile as writeFile7 } from "fs/promises";
+import { mkdir as mkdir5, readFile as readFile12, rename as rename5, rm as rm6, writeFile as writeFile7 } from "fs/promises";
 var activeTransactions = /* @__PURE__ */ new Set();
 function message(error) {
   return error instanceof Error ? error.message : String(error);
@@ -5114,11 +5120,11 @@ function parseArtifactManifest(absolute, data) {
 }
 async function readArtifactBundleManifest(manifestPath) {
   const absolute = path17.resolve(manifestPath);
-  return parseArtifactManifest(absolute, await readFile13(absolute, "utf8"));
+  return parseArtifactManifest(absolute, await readFile12(absolute, "utf8"));
 }
 async function readOptional(file) {
   try {
-    return await readFile13(file);
+    return await readFile12(file);
   } catch (error) {
     if (isCode(error, "ENOENT")) return null;
     throw error;
@@ -5307,7 +5313,7 @@ async function verifyArtifactBundle(manifestPath) {
   for (const source of raw.sources) {
     let actual = null;
     try {
-      actual = digest(await readFile13(path17.resolve(root, source.path)));
+      actual = digest(await readFile12(path17.resolve(root, source.path)));
     } catch (error) {
       if (!isCode(error, "ENOENT")) throw error;
     }
@@ -5315,7 +5321,7 @@ async function verifyArtifactBundle(manifestPath) {
   }
   for (const output of raw.outputs) {
     try {
-      if (digest(await readFile13(path17.resolve(root, output.path))) !== output.sha256) {
+      if (digest(await readFile12(path17.resolve(root, output.path))) !== output.sha256) {
         changedOutputs.push(output.path);
       }
     } catch (error) {
@@ -5387,7 +5393,7 @@ async function writeArtifactBundle(files, options = {}) {
   const unchanged = [];
   for (const artifact of normalized) {
     try {
-      const current = await readFile13(artifact.destination);
+      const current = await readFile12(artifact.destination);
       if (current.equals(artifact.data)) {
         unchanged.push(artifact.destination);
       } else {
@@ -5706,7 +5712,7 @@ async function refineAsset(options) {
   if (options.minTransparency !== void 0 && (!Number.isFinite(options.minTransparency) || options.minTransparency < 0 || options.minTransparency > 1)) throw new Error("minTransparency must be between 0 and 1.");
   let sourcePng;
   try {
-    sourcePng = decodePng(await readFile14(source));
+    sourcePng = decodePng(await readFile13(source));
   } catch (error) {
     throw new Error(`Cannot read refinement source ${source}: ${message2(error)}`, { cause: error });
   }
@@ -5733,7 +5739,7 @@ async function refineAsset(options) {
       );
     }
     const detection = parseDetection(firstJsonObject(stdout));
-    const native = decodePng(await readFile14(recovered));
+    const native = decodePng(await readFile13(recovered));
     const quantized = quantizeToPalette(native, palette);
     const png = encodeRgbaPng(quantized.width, quantized.height, quantized.pixels);
     const audit = auditRefinement(
@@ -5832,7 +5838,7 @@ async function approveQualityRecord(recordPath, approval) {
   }
   const root = path18.dirname(record);
   const outputPath = path18.resolve(root, manifest.outputs[0].path);
-  const output = await readFile14(outputPath);
+  const output = await readFile13(outputPath);
   const sources = manifest.sources.map((source) => ({
     ...source,
     path: path18.resolve(root, source.path)
@@ -6118,7 +6124,7 @@ function isRecord(value) {
 }
 
 // src/pick/salvage-server.ts
-import { mkdir as mkdir6, writeFile as writeFile8, readFile as readFile15 } from "fs/promises";
+import { mkdir as mkdir6, writeFile as writeFile8, readFile as readFile14 } from "fs/promises";
 import path19 from "path";
 
 // src/pick/salvage-sheet.ts
@@ -6366,7 +6372,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
         }
       }
       await applyTags(provider, decisions, existingTags, { onProgress: log2 });
-      const raw = JSON.parse(await readFile15(ctx.manifestPath, "utf8"));
+      const raw = JSON.parse(await readFile14(ctx.manifestPath, "utf8"));
       for (const id of importedAssetIds) raw.assets[id] = ctx.manifest.assets[id];
       await writeFile8(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
       await saveLock(ctx.lockPath, ctx.lock);
@@ -6375,14 +6381,742 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
   });
 }
 
+// src/recipes.ts
+import path20 from "path";
+import { existsSync as existsSync15 } from "fs";
+import { readdir as readdir3, readFile as readFile15 } from "fs/promises";
+import { fileURLToPath } from "url";
+import { z as z5 } from "zod";
+var SHA256_RE = /^[0-9a-f]{64}$/;
+var RECIPE_ID_RE = /^[a-z0-9][a-z0-9-]*\/[a-z0-9][a-z0-9-]*$/;
+var VERSION_RE = /^\d+\.\d+\.\d+$/;
+var RECIPE_FILE = "pixelkiln.recipe.json";
+var RECIPE_DIR_TOKEN = "{{recipeDir}}";
+var PortablePathSchema = z5.string().min(1).refine((value) => {
+  if (value.includes("\\") || path20.posix.isAbsolute(value)) return false;
+  const parts = value.split("/");
+  return !parts.includes("") && !parts.includes(".") && !parts.includes("..");
+}, "expected a portable relative path without '.', '..', or backslashes");
+var RecipeBindingSchema = z5.object({
+  nodeId: z5.string().min(1),
+  input: z5.string().min(1)
+}).strict();
+var RecipeSchema = z5.object({
+  $schema: z5.string().url().optional(),
+  format: z5.literal("pixelkiln-recipe"),
+  schemaVersion: z5.literal(1),
+  id: z5.string().regex(RECIPE_ID_RE, "expected provider/name"),
+  version: z5.string().regex(VERSION_RE, "expected x.y.z"),
+  provider: z5.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  summary: z5.string().min(1).max(240),
+  files: z5.array(z5.object({
+    path: PortablePathSchema,
+    role: z5.enum(["workflow", "reference"]),
+    sha256: z5.string().regex(SHA256_RE)
+  }).strict()).default([]),
+  models: z5.array(z5.object({
+    path: PortablePathSchema,
+    sha256: z5.string().regex(SHA256_RE),
+    source: z5.string().url(),
+    license: z5.string().min(1)
+  }).strict()).default([]),
+  styleId: z5.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  style: StyleSchema,
+  workflow: z5.object({
+    path: PortablePathSchema,
+    outputNodeId: z5.string().min(1),
+    numImages: z5.number().int().min(1).max(16),
+    bindings: z5.object({
+      prompt: RecipeBindingSchema,
+      width: RecipeBindingSchema,
+      height: RecipeBindingSchema,
+      batchSize: RecipeBindingSchema,
+      seed: RecipeBindingSchema.optional()
+    }).strict()
+  }).strict().optional(),
+  quality: z5.object({
+    stage: z5.enum(["composition-source", "production-candidate"]),
+    workingCanvas: z5.object({
+      width: z5.number().int().min(16),
+      height: z5.number().int().min(16)
+    }).strict(),
+    recommendedNativeSize: z5.object({
+      min: z5.number().int().min(1),
+      max: z5.number().int().min(1)
+    }).strict(),
+    paletteColors: z5.object({
+      min: z5.number().int().min(1),
+      max: z5.number().int().min(1)
+    }).strict(),
+    background: z5.enum(["opaque", "transparent", "full-bleed"]),
+    checks: z5.array(z5.enum([
+      "prompt-coverage",
+      "native-grid",
+      "final-palette",
+      "alpha-edge",
+      "human-1x"
+    ])).min(1),
+    notes: z5.array(z5.string().min(1)).default([])
+  }).strict(),
+  integrity: z5.object({
+    algorithm: z5.literal("sha256"),
+    digest: z5.string().regex(SHA256_RE)
+  }).strict()
+}).strict().superRefine((recipe, context) => {
+  const filePaths = recipe.files.map((file) => file.path);
+  if (new Set(filePaths).size !== filePaths.length) {
+    context.addIssue({ code: z5.ZodIssueCode.custom, path: ["files"], message: "duplicate file path" });
+  }
+  const modelPaths = recipe.models.map((model) => model.path);
+  if (new Set(modelPaths).size !== modelPaths.length) {
+    context.addIssue({ code: z5.ZodIssueCode.custom, path: ["models"], message: "duplicate model path" });
+  }
+  if (filePaths.includes(RECIPE_FILE)) {
+    context.addIssue({
+      code: z5.ZodIssueCode.custom,
+      path: ["files"],
+      message: `${RECIPE_FILE} cannot hash itself`
+    });
+  }
+  if (recipe.quality.recommendedNativeSize.min > recipe.quality.recommendedNativeSize.max) {
+    context.addIssue({
+      code: z5.ZodIssueCode.custom,
+      path: ["quality", "recommendedNativeSize"],
+      message: "min cannot exceed max"
+    });
+  }
+  if (recipe.quality.paletteColors.min > recipe.quality.paletteColors.max) {
+    context.addIssue({
+      code: z5.ZodIssueCode.custom,
+      path: ["quality", "paletteColors"],
+      message: "min cannot exceed max"
+    });
+  }
+  if (recipe.workflow && !recipe.files.some(
+    (file) => file.path === recipe.workflow.path && file.role === "workflow"
+  )) {
+    context.addIssue({
+      code: z5.ZodIssueCode.custom,
+      path: ["workflow", "path"],
+      message: "must name a file whose role is workflow"
+    });
+  }
+  if (recipe.provider === "comfyui") {
+    if (!recipe.workflow) {
+      context.addIssue({
+        code: z5.ZodIssueCode.custom,
+        path: ["workflow"],
+        message: "ComfyUI recipes require workflow metadata"
+      });
+      return;
+    }
+    const options = recipe.style.providerOptions.comfyui;
+    if (!options || typeof options !== "object" || Array.isArray(options)) {
+      context.addIssue({
+        code: z5.ZodIssueCode.custom,
+        path: ["style", "providerOptions", "comfyui"],
+        message: "ComfyUI recipes require ComfyUI provider options"
+      });
+      return;
+    }
+    const expected = {
+      workflowFile: `${RECIPE_DIR_TOKEN}/${recipe.workflow.path}`,
+      outputNodeId: recipe.workflow.outputNodeId,
+      numImages: recipe.workflow.numImages,
+      bindings: recipe.workflow.bindings
+    };
+    if (JSON.stringify(canonical3(options)) !== JSON.stringify(canonical3(expected))) {
+      context.addIssue({
+        code: z5.ZodIssueCode.custom,
+        path: ["style", "providerOptions", "comfyui"],
+        message: "must match workflow metadata and use {{recipeDir}} for workflowFile"
+      });
+    }
+  }
+});
+function canonical3(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new Error("Recipe numbers must be finite.");
+    return value;
+  }
+  if (Array.isArray(value)) return value.map(canonical3);
+  if (typeof value === "object") {
+    const sorted = {};
+    for (const key of Object.keys(value).sort()) {
+      const item = value[key];
+      if (item !== void 0) sorted[key] = canonical3(item);
+    }
+    return sorted;
+  }
+  throw new Error(`Recipe metadata cannot contain ${typeof value} values.`);
+}
+function recipeDigest(recipe) {
+  const { integrity: _integrity, ...payload } = recipe;
+  return sha256(JSON.stringify(canonical3(payload)));
+}
+function message3(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function readRecipeFile(recipePath, bundled) {
+  const absolute = path20.resolve(recipePath);
+  let raw;
+  try {
+    raw = JSON.parse(await readFile15(absolute, "utf8"));
+  } catch (error) {
+    throw new Error(`Could not read recipe ${absolute}: ${message3(error)}`, { cause: error });
+  }
+  const parsed = RecipeSchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new Error(
+      `Invalid recipe ${absolute}:
+` + parsed.error.issues.map((issue) => `  ${issue.path.join(".") || "$"}: ${issue.message}`).join("\n")
+    );
+  }
+  return { recipe: parsed.data, path: absolute, dir: path20.dirname(absolute), bundled };
+}
+async function walkRecipeFiles(root) {
+  if (!existsSync15(root)) return [];
+  const out = [];
+  for (const entry of await readdir3(root, { withFileTypes: true })) {
+    const resolved = path20.join(root, entry.name);
+    if (entry.isDirectory()) out.push(...await walkRecipeFiles(resolved));
+    else if (entry.isFile() && entry.name === RECIPE_FILE) out.push(resolved);
+  }
+  return out;
+}
+function bundledRecipeRoot() {
+  return fileURLToPath(new URL("../recipes/", import.meta.url));
+}
+async function listBundledRecipes(root = bundledRecipeRoot()) {
+  const recipes = await Promise.all(
+    (await walkRecipeFiles(path20.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)
+  );
+}
+function compareVersions(a, b) {
+  const av = a.split(".").map(Number);
+  const bv = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const difference = av[i] - bv[i];
+    if (difference) return difference;
+  }
+  return 0;
+}
+function parseSelector(selector) {
+  const match = selector.match(/^([^@]+?)(?:@(\d+\.\d+\.\d+))?$/);
+  if (!match || !RECIPE_ID_RE.test(match[1])) {
+    throw new Error(`Invalid recipe selector "${selector}". Expected provider/name or provider/name@x.y.z.`);
+  }
+  return { id: match[1], version: match[2] };
+}
+async function resolveRecipe(target, bundledRoot = bundledRecipeRoot()) {
+  const local = path20.resolve(target);
+  if (existsSync15(local)) {
+    const recipePath = path20.basename(local) === RECIPE_FILE ? local : path20.join(local, RECIPE_FILE);
+    return readRecipeFile(recipePath, false);
+  }
+  if (target.startsWith(".") || target.startsWith("/") || target.includes("\\")) {
+    throw new Error(`Recipe path not found: ${local}`);
+  }
+  const selector = parseSelector(target);
+  const matches = (await listBundledRecipes(bundledRoot)).filter(
+    (entry) => entry.recipe.id === selector.id && (selector.version === void 0 || entry.recipe.version === selector.version)
+  );
+  if (!matches.length) throw new Error(`Bundled recipe not found: ${target}`);
+  return matches[0];
+}
+async function verifyFile(root, file) {
+  const absolute = path20.resolve(root, ...file.path.split("/"));
+  if (!existsSync15(absolute)) {
+    return { path: file.path, expectedSha256: file.sha256, actualSha256: null, status: "missing" };
+  }
+  const actualSha256 = await sha256File(absolute);
+  return {
+    path: file.path,
+    expectedSha256: file.sha256,
+    actualSha256,
+    status: actualSha256 === file.sha256 ? "ok" : "mismatch"
+  };
+}
+async function verifyRecipe(target, options = {}) {
+  const loaded = await resolveRecipe(target, options.bundledRoot);
+  const actualIntegrity = recipeDigest(loaded.recipe);
+  const files = await Promise.all(loaded.recipe.files.map((file) => verifyFile(loaded.dir, file)));
+  const modelRoot = options.modelRoot ? path20.resolve(options.modelRoot) : null;
+  const models = modelRoot ? await Promise.all(loaded.recipe.models.map(async (model) => ({
+    ...await verifyFile(modelRoot, model),
+    source: model.source,
+    license: model.license
+  }))) : loaded.recipe.models.map((model) => ({
+    path: model.path,
+    expectedSha256: model.sha256,
+    actualSha256: null,
+    source: model.source,
+    license: model.license,
+    status: "unchecked"
+  }));
+  const integrityStatus = actualIntegrity === loaded.recipe.integrity.digest ? "ok" : "mismatch";
+  return {
+    version: 1,
+    ok: integrityStatus === "ok" && files.every((file) => file.status === "ok") && (!modelRoot || models.every((model) => model.status === "ok")),
+    recipe: {
+      id: loaded.recipe.id,
+      version: loaded.recipe.version,
+      path: loaded.path,
+      bundled: loaded.bundled
+    },
+    integrity: {
+      expectedSha256: loaded.recipe.integrity.digest,
+      actualSha256: actualIntegrity,
+      status: integrityStatus
+    },
+    files,
+    models,
+    modelRoot
+  };
+}
+function renderStyle(style, destination, cwd) {
+  const portableDir = path20.relative(cwd, destination).split(path20.sep).join("/") || ".";
+  const replace = (value) => {
+    if (typeof value === "string") return value.replaceAll(RECIPE_DIR_TOKEN, portableDir);
+    if (Array.isArray(value)) return value.map(replace);
+    if (value && typeof value === "object") {
+      return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, replace(item)]));
+    }
+    return value;
+  };
+  return replace(style);
+}
+async function installRecipe(target, options = {}) {
+  const cwd = path20.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 ? path20.resolve(cwd, options.out) : path20.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: path20.join(loaded.dir, ...file.path.split("/")) }))
+  ];
+  const files = await Promise.all(sources.map(async (file) => ({
+    path: path20.join(destination, ...file.path.split("/")),
+    data: await readFile15(file.source)
+  })));
+  if (!options.force) {
+    for (const file of files) {
+      if (!existsSync15(file.path)) continue;
+      const current = await readFile15(file.path);
+      if (!current.equals(file.data)) {
+        throw new Error(
+          `Recipe destination has local changes: ${file.path}. Choose another --out or pass --force to replace declared recipe files.`
+        );
+      }
+    }
+  }
+  const written = await writeArtifactBundle(files);
+  return {
+    recipe: loaded.recipe,
+    destination,
+    changed: written.changed,
+    unchanged: written.unchanged,
+    styleId: loaded.recipe.styleId,
+    style: renderStyle(loaded.recipe.style, destination, cwd)
+  };
+}
+
+// src/pipeline/quality-regression.ts
+import path21 from "path";
+import { existsSync as existsSync16 } from "fs";
+import { readFile as readFile16 } from "fs/promises";
+import { z as z6 } from "zod";
+var SHA256_RE2 = /^[0-9a-f]{64}$/;
+var HEX_RE = /^#[0-9a-f]{6}$/;
+var MAX_REDMEAN_DISTANCE = 765;
+var QualityPathSchema = z6.string().min(1).refine(
+  (value) => !path21.posix.isAbsolute(value) && !value.includes("\\"),
+  "expected a portable relative path"
+);
+var DEFAULT_QUALITY_TOLERANCES = {
+  requireExactHash: false,
+  maxColorCountIncrease: 0,
+  maxNewColors: 0,
+  maxTransparencyDelta: 0.01,
+  maxPartialAlphaIncrease: 0,
+  maxEdgeDensityDelta: 0.03,
+  maxEdgeContrastDrop: 0.03,
+  maxIsolatedPixelIncrease: 5e-3
+};
+var QualityToleranceSchema = z6.object({
+  requireExactHash: z6.boolean(),
+  maxColorCountIncrease: z6.number().int().min(0),
+  maxNewColors: z6.number().int().min(0),
+  maxTransparencyDelta: z6.number().min(0).max(1),
+  maxPartialAlphaIncrease: z6.number().min(0).max(1),
+  maxEdgeDensityDelta: z6.number().min(0).max(1),
+  maxEdgeContrastDrop: z6.number().min(0).max(1),
+  maxIsolatedPixelIncrease: z6.number().min(0).max(1)
+}).strict();
+var ImageQualityMetricsSchema = z6.object({
+  sha256: z6.string().regex(SHA256_RE2),
+  width: z6.number().int().min(1),
+  height: z6.number().int().min(1),
+  colorCount: z6.number().int().min(0),
+  colors: z6.array(z6.string().regex(HEX_RE)),
+  transparency: z6.number().min(0).max(1),
+  partialAlpha: z6.number().min(0).max(1),
+  edgeDensity: z6.number().min(0).max(1),
+  meanEdgeContrast: z6.number().min(0).max(1),
+  isolatedPixelRatio: z6.number().min(0).max(1)
+}).strict();
+var QualityBaselineCaseSchema = z6.object({
+  id: z6.string().regex(/^[a-z0-9][a-z0-9/_-]*$/),
+  file: QualityPathSchema,
+  record: z6.object({
+    path: QualityPathSchema,
+    sha256: z6.string().regex(SHA256_RE2)
+  }).strict().optional(),
+  expected: ImageQualityMetricsSchema,
+  tolerances: QualityToleranceSchema
+}).strict();
+var QualityBaselineSchema = z6.object({
+  $schema: z6.string().url().optional(),
+  format: z6.literal("pixelkiln-quality-baseline"),
+  schemaVersion: z6.literal(1),
+  cases: z6.array(QualityBaselineCaseSchema).min(1)
+}).strict().superRefine((baseline, context) => {
+  const ids = baseline.cases.map((entry) => entry.id);
+  if (new Set(ids).size !== ids.length) {
+    context.addIssue({ code: z6.ZodIssueCode.custom, path: ["cases"], message: "duplicate case id" });
+  }
+});
+var QualityInputSchema = z6.object({
+  id: z6.string().regex(/^[a-z0-9][a-z0-9/_-]*$/),
+  path: z6.string().min(1),
+  record: z6.string().min(1).optional(),
+  tolerances: QualityToleranceSchema.partial().optional()
+}).strict();
+function message4(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function round(value) {
+  return Number(value.toFixed(6));
+}
+function pixelKey(pixels, offset) {
+  const alpha = pixels[offset + 3];
+  if (alpha === 0) return 0;
+  return (pixels[offset] << 24 >>> 0 | pixels[offset + 1] << 16 | pixels[offset + 2] << 8 | alpha) >>> 0;
+}
+function edgeContrast(pixels, a, b) {
+  const alphaA = pixels[a + 3];
+  const alphaB = pixels[b + 3];
+  const alphaDistance = Math.abs(alphaA - alphaB) / 255;
+  if (alphaA === 0 || alphaB === 0) return alphaDistance;
+  const rgbDistance = colorDistance(
+    { r: pixels[a], g: pixels[a + 1], b: pixels[a + 2] },
+    { r: pixels[b], g: pixels[b + 1], b: pixels[b + 2] }
+  ) / MAX_REDMEAN_DISTANCE;
+  return Math.min(1, Math.max(alphaDistance, rgbDistance));
+}
+function measureDecodedImageQuality(png, digest2) {
+  const colors = /* @__PURE__ */ new Set();
+  let transparent = 0;
+  let partialAlpha = 0;
+  let visible = 0;
+  let isolated = 0;
+  for (let offset = 0; offset < png.pixels.length; offset += 4) {
+    const alpha = png.pixels[offset + 3];
+    if (alpha === 0) {
+      transparent++;
+      continue;
+    }
+    visible++;
+    if (alpha < 255) partialAlpha++;
+    colors.add(png.pixels[offset] << 16 | png.pixels[offset + 1] << 8 | png.pixels[offset + 2]);
+    const index = offset / 4;
+    const x = index % png.width;
+    const y = Math.floor(index / png.width);
+    const key = pixelKey(png.pixels, offset);
+    const hasSameNeighbor = x > 0 && pixelKey(png.pixels, offset - 4) === key || x + 1 < png.width && pixelKey(png.pixels, offset + 4) === key || y > 0 && pixelKey(png.pixels, offset - png.width * 4) === key || y + 1 < png.height && pixelKey(png.pixels, offset + png.width * 4) === key;
+    if (!hasSameNeighbor) {
+      isolated++;
+    }
+  }
+  let neighborPairs = 0;
+  let changedPairs = 0;
+  let contrastTotal = 0;
+  for (let y = 0; y < png.height; y++) {
+    for (let x = 0; x < png.width; x++) {
+      const offset = (y * png.width + x) * 4;
+      if (x + 1 < png.width) {
+        const neighbor = offset + 4;
+        neighborPairs++;
+        if (pixelKey(png.pixels, offset) !== pixelKey(png.pixels, neighbor)) {
+          changedPairs++;
+          contrastTotal += edgeContrast(png.pixels, offset, neighbor);
+        }
+      }
+      if (y + 1 < png.height) {
+        const neighbor = offset + png.width * 4;
+        neighborPairs++;
+        if (pixelKey(png.pixels, offset) !== pixelKey(png.pixels, neighbor)) {
+          changedPairs++;
+          contrastTotal += edgeContrast(png.pixels, offset, neighbor);
+        }
+      }
+    }
+  }
+  const total = png.width * png.height;
+  return {
+    sha256: digest2,
+    width: png.width,
+    height: png.height,
+    colorCount: colors.size,
+    colors: [...colors].sort((a, b) => a - b).map((color) => `#${color.toString(16).padStart(6, "0")}`),
+    transparency: round(total ? transparent / total : 0),
+    partialAlpha: round(total ? partialAlpha / total : 0),
+    edgeDensity: round(neighborPairs ? changedPairs / neighborPairs : 0),
+    meanEdgeContrast: round(changedPairs ? contrastTotal / changedPairs : 0),
+    isolatedPixelRatio: round(visible ? isolated / visible : 0)
+  };
+}
+async function measureImageQuality(file) {
+  const absolute = path21.resolve(file);
+  let bytes;
+  try {
+    bytes = await readFile16(absolute);
+  } catch (error) {
+    throw new Error(`Cannot read quality image ${absolute}: ${message4(error)}`, { cause: error });
+  }
+  try {
+    return measureDecodedImageQuality(decodePng(bytes), sha256(bytes));
+  } catch (error) {
+    throw new Error(`Cannot measure quality image ${absolute}: ${message4(error)}`, { cause: error });
+  }
+}
+function resolveQualityInputs(raw, inputsFilePath) {
+  const parsed = z6.array(QualityInputSchema).min(1).safeParse(raw);
+  if (!parsed.success) {
+    throw new Error(
+      "--inputs must be a non-empty JSON array of quality cases:\n" + parsed.error.issues.map((issue) => `  ${issue.path.join(".") || "$"}: ${issue.message}`).join("\n")
+    );
+  }
+  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 = path21.dirname(path21.resolve(inputsFilePath));
+  return parsed.data.map((entry) => ({
+    id: entry.id,
+    file: path21.resolve(root, entry.path),
+    ...entry.record ? { record: path21.resolve(root, entry.record) } : {},
+    tolerances: QualityToleranceSchema.parse({
+      ...DEFAULT_QUALITY_TOLERANCES,
+      ...entry.tolerances
+    })
+  }));
+}
+function portableRelative2(from, to) {
+  return path21.relative(from, path21.resolve(to)).split(path21.sep).join("/") || ".";
+}
+async function verifyRecordForImage(recordPath, imagePath) {
+  const verification = await verifyArtifactBundle(recordPath);
+  if (!verification.current) {
+    const changed = [...verification.changedSources, ...verification.changedOutputs];
+    throw new Error(
+      `Quality record is not current: ${recordPath}` + (changed.length ? ` (${changed.join(", ")})` : "")
+    );
+  }
+  const record = await readArtifactBundleManifest(recordPath);
+  const options = record.options;
+  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) => path21.resolve(path21.dirname(recordPath), output.path));
+  if (!outputs.includes(path21.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 = path21.resolve(baselinePath);
+  for (const input of inputs) {
+    if (path21.resolve(input.file) === absolute || input.record && path21.resolve(input.record) === absolute) {
+      throw new Error(`Quality baseline output would overwrite an input: ${absolute}.`);
+    }
+  }
+  const root = path21.dirname(absolute);
+  const cases = [];
+  for (const input of [...inputs].sort((a, b) => a.id.localeCompare(b.id))) {
+    const expected = await measureImageQuality(input.file);
+    let record;
+    if (input.record) {
+      await verifyRecordForImage(input.record, input.file);
+      record = {
+        path: portableRelative2(root, input.record),
+        sha256: await sha256File(input.record)
+      };
+    }
+    cases.push({
+      id: input.id,
+      file: portableRelative2(root, input.file),
+      ...record ? { record } : {},
+      expected,
+      tolerances: input.tolerances
+    });
+  }
+  const baseline = QualityBaselineSchema.parse({
+    $schema: "https://unpkg.com/pixelkiln/schema/quality-baseline.schema.json",
+    format: "pixelkiln-quality-baseline",
+    schemaVersion: 1,
+    cases
+  });
+  const data = Buffer.from(JSON.stringify(baseline, null, 2) + "\n");
+  if (existsSync16(absolute) && !options.force) {
+    const current = await readFile16(absolute);
+    if (!current.equals(data)) {
+      throw new Error(`Quality baseline already exists with different content: ${absolute}. Pass --force to replace it.`);
+    }
+  }
+  const result = await writeArtifactBundle([{ path: absolute, data }]);
+  return { baseline, path: absolute, changed: result.changed.length > 0 };
+}
+async function readQualityBaseline(baselinePath) {
+  const absolute = path21.resolve(baselinePath);
+  let raw;
+  try {
+    raw = JSON.parse(await readFile16(absolute, "utf8"));
+  } catch (error) {
+    throw new Error(`Could not read quality baseline ${absolute}: ${message4(error)}`, { cause: error });
+  }
+  const parsed = QualityBaselineSchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new Error(
+      `Invalid quality baseline ${absolute}:
+` + parsed.error.issues.map((issue) => `  ${issue.path.join(".") || "$"}: ${issue.message}`).join("\n")
+    );
+  }
+  return parsed.data;
+}
+function regressionViolations(expected, actual, tolerances) {
+  const violations = [];
+  const warnings = [];
+  const changed = actual.sha256 !== expected.sha256;
+  if (expected.width !== actual.width || expected.height !== actual.height) {
+    violations.push(
+      `dimensions changed from ${expected.width}x${expected.height} to ${actual.width}x${actual.height}`
+    );
+  }
+  if (changed && tolerances.requireExactHash) violations.push("image hash changed");
+  else if (changed) warnings.push("image hash changed; metric tolerances decide this case");
+  const colorIncrease = actual.colorCount - expected.colorCount;
+  if (colorIncrease > tolerances.maxColorCountIncrease) {
+    violations.push(
+      `color count increased by ${colorIncrease} (allowed ${tolerances.maxColorCountIncrease})`
+    );
+  }
+  const expectedColors = new Set(expected.colors);
+  const newColors = actual.colors.filter((color) => !expectedColors.has(color));
+  if (newColors.length > tolerances.maxNewColors) {
+    violations.push(
+      `${newColors.length} new color(s) exceed ${tolerances.maxNewColors}: ${newColors.slice(0, 8).join(", ")}`
+    );
+  }
+  const transparencyDelta = Math.abs(actual.transparency - expected.transparency);
+  if (transparencyDelta > tolerances.maxTransparencyDelta) {
+    violations.push(
+      `transparency changed by ${(transparencyDelta * 100).toFixed(2)} points (allowed ${(tolerances.maxTransparencyDelta * 100).toFixed(2)})`
+    );
+  }
+  const partialAlphaIncrease = actual.partialAlpha - expected.partialAlpha;
+  if (partialAlphaIncrease > tolerances.maxPartialAlphaIncrease) {
+    violations.push(
+      `partial-alpha pixels increased by ${(partialAlphaIncrease * 100).toFixed(2)} points (allowed ${(tolerances.maxPartialAlphaIncrease * 100).toFixed(2)})`
+    );
+  }
+  const edgeDensityDelta = Math.abs(actual.edgeDensity - expected.edgeDensity);
+  if (edgeDensityDelta > tolerances.maxEdgeDensityDelta) {
+    violations.push(
+      `edge density changed by ${(edgeDensityDelta * 100).toFixed(2)} points (allowed ${(tolerances.maxEdgeDensityDelta * 100).toFixed(2)})`
+    );
+  }
+  const edgeContrastDrop = expected.meanEdgeContrast - actual.meanEdgeContrast;
+  if (edgeContrastDrop > tolerances.maxEdgeContrastDrop) {
+    violations.push(
+      `mean edge contrast dropped by ${(edgeContrastDrop * 100).toFixed(2)} points (allowed ${(tolerances.maxEdgeContrastDrop * 100).toFixed(2)})`
+    );
+  }
+  const isolatedIncrease = actual.isolatedPixelRatio - expected.isolatedPixelRatio;
+  if (isolatedIncrease > tolerances.maxIsolatedPixelIncrease) {
+    violations.push(
+      `isolated-pixel ratio increased by ${(isolatedIncrease * 100).toFixed(2)} points (allowed ${(tolerances.maxIsolatedPixelIncrease * 100).toFixed(2)})`
+    );
+  }
+  return { violations, warnings };
+}
+async function checkQualityBaseline(baselinePath) {
+  const absolute = path21.resolve(baselinePath);
+  const baseline = await readQualityBaseline(absolute);
+  const root = path21.dirname(absolute);
+  const cases = [];
+  for (const entry of baseline.cases) {
+    const file = path21.resolve(root, entry.file);
+    let actual = null;
+    const violations = [];
+    const warnings = [];
+    try {
+      actual = await measureImageQuality(file);
+      const regression = regressionViolations(entry.expected, actual, entry.tolerances);
+      violations.push(...regression.violations);
+      warnings.push(...regression.warnings);
+    } catch (error) {
+      violations.push(message4(error));
+    }
+    if (entry.record) {
+      const recordPath = path21.resolve(root, entry.record.path);
+      try {
+        const recordHash = await sha256File(recordPath);
+        if (recordHash !== entry.record.sha256) violations.push("quality record hash changed");
+        await verifyRecordForImage(recordPath, file);
+      } catch (error) {
+        violations.push(message4(error));
+      }
+    }
+    cases.push({
+      id: entry.id,
+      file,
+      status: violations.length ? "fail" : "pass",
+      hashChanged: actual !== null && actual.sha256 !== entry.expected.sha256,
+      expected: entry.expected,
+      actual,
+      violations,
+      warnings
+    });
+  }
+  const failed = cases.filter((entry) => entry.status === "fail").length;
+  return {
+    version: 1,
+    safe: failed === 0,
+    baseline: absolute,
+    summary: {
+      total: cases.length,
+      passed: cases.length - failed,
+      failed,
+      changed: cases.filter((entry) => entry.hashChanged).length
+    },
+    cases
+  };
+}
+
 // src/cli.ts
 var log = (msg = "") => console.log(msg);
 async function provenanceFile(id, file) {
-  const absolute = path20.resolve(file);
+  const absolute = path22.resolve(file);
   return {
     id,
     path: absolute,
-    sha256: existsSync15(absolute) ? await sha256File(absolute) : null,
+    sha256: existsSync17(absolute) ? await sha256File(absolute) : null,
     included: true
   };
 }
@@ -6415,7 +7149,8 @@ var VALUE_FLAGS = [
   "--fixer-revision",
   "--min-grid-confidence",
   "--reviewer",
-  "--note"
+  "--note",
+  "--model-root"
 ];
 var BOOL_FLAGS = [
   "--force",
@@ -6454,7 +7189,9 @@ var COMMANDS = [
   "tag",
   "balance",
   "status",
+  "quality",
   "refine",
+  "recipe",
   "workspace",
   "help",
   "--help",
@@ -6464,6 +7201,8 @@ var COMMANDS = [
 ];
 var WORKSPACE_SUBCOMMANDS = ["add", "remove", "list", "status", "claims"];
 var REFINE_SUBCOMMANDS = ["run", "approve", "check"];
+var RECIPE_SUBCOMMANDS = ["list", "inspect", "install", "verify"];
+var QUALITY_SUBCOMMANDS = ["snapshot", "check"];
 function parseArgs(argv) {
   const [command = "help"] = argv;
   if (!COMMANDS.includes(command)) {
@@ -6472,7 +7211,36 @@ function parseArgs(argv) {
   let rest = argv.slice(1);
   let subcommand;
   let target;
-  if (command === "workspace") {
+  if (command === "quality") {
+    subcommand = rest[0];
+    if (subcommand === void 0 || subcommand.startsWith("-")) {
+      throw new Error(`quality needs a subcommand: ${QUALITY_SUBCOMMANDS.join(", ")}`);
+    }
+    if (!QUALITY_SUBCOMMANDS.includes(subcommand)) {
+      throw new Error(
+        `Unknown quality subcommand "${subcommand}". Known: ${QUALITY_SUBCOMMANDS.join(", ")}`
+      );
+    }
+    rest = rest.slice(1);
+  } else if (command === "recipe") {
+    subcommand = rest[0];
+    if (subcommand === void 0 || subcommand.startsWith("-")) {
+      throw new Error(`recipe needs a subcommand: ${RECIPE_SUBCOMMANDS.join(", ")}`);
+    }
+    if (!RECIPE_SUBCOMMANDS.includes(subcommand)) {
+      throw new Error(
+        `Unknown recipe subcommand "${subcommand}". Known: ${RECIPE_SUBCOMMANDS.join(", ")}`
+      );
+    }
+    rest = rest.slice(1);
+    if (subcommand !== "list") {
+      target = rest[0];
+      if (target === void 0 || target.startsWith("-")) {
+        throw new Error(`recipe ${subcommand} needs a recipe id, selector, or path.`);
+      }
+      rest = rest.slice(1);
+    }
+  } else if (command === "workspace") {
     subcommand = rest[0];
     if (subcommand === void 0 || subcommand.startsWith("-")) {
       throw new Error(`workspace needs a subcommand: ${WORKSPACE_SUBCOMMANDS.join(", ")}`);
@@ -6583,7 +7351,7 @@ function parseArgs(argv) {
   return {
     command,
     manifest,
-    lock: get("--lock") ?? path20.join(path20.dirname(path20.resolve(manifest)), "pixelkiln.lock.json"),
+    lock: get("--lock") ?? path22.join(path22.dirname(path22.resolve(manifest)), "pixelkiln.lock.json"),
     explicitLock: get("--lock"),
     styles: list("--style"),
     assets: list("--only"),
@@ -6620,6 +7388,7 @@ function parseArgs(argv) {
     minGridConfidence: rawGridConfidence,
     reviewer: get("--reviewer"),
     note: get("--note"),
+    modelRoot: get("--model-root"),
     subcommand,
     workspace: get("--workspace"),
     target,
@@ -6648,6 +7417,8 @@ Commands
   audit     Measure how consistently a style's assets hold together. Offline.
   refine    Recover a native pixel grid, enforce a final palette, audit it,
             and attach a verifiable human approval. run/approve/check. Offline.
+  recipe    List, inspect, install, or verify versioned workflow packs. Offline.
+  quality   Snapshot or check measurable image regressions. Offline.
   cache     Inspect local recovery/object-hash caches; optionally verify or prune.
   pack      Composite sprites into a PNG/atlas/provenance bundle. Offline.
   mount     Write a style's sprites into their declared cells of an existing
@@ -6665,7 +7436,7 @@ Commands
 Options
   --columns <n>       pack/export: sprites or tiles per row (default: near-square)
   --port <n>          Local review-server port (default: choose a free port)
-  --inputs <path>     pack: JSON [{id,path}] instead of the lockfile; needs --out
+  --inputs <path>     pack/quality snapshot: JSON input list; needs --out
   --format <format>   export: generic (default), tiled, or godot
   --output-role <r>   pack: include only this output role (repeatable)
   --primary-only      pack: include only unambiguous primary/single outputs
@@ -6679,16 +7450,17 @@ Options
   --min-grid-confidence <level>  refine: high (default), medium, or low
   --reviewer <name>   refine approve: human reviewer recorded in provenance
   --note <text>       refine approve: optional review note
+  --model-root <dir>  recipe verify: also hash required local model files
   --prune             cache: remove invalid/unreferenced local cache data
   --manifest <path>   Default: pixelkiln.manifest.json
   --lock <path>       Default: pixelkiln.lock.json beside the manifest
   --style a,b         Restrict to these styles
   --only id1,id2      Restrict to these asset ids
   --budget <n>        Refuse to spend more than n provider cost units
-  --force             Regenerate; derived commands also take over modified/unowned output
+  --force             Regenerate; also replace changed recipe files or quality baselines
   --dry-run           Never spend; doctor also skips provider connectivity
   --all               salvage --dry-run: list every unclaimed object, not just the first 30
-  --json              Machine-readable output where supported, including plan/audit/doctor/cache
+  --json              Machine-readable output where supported, including quality checks
   --check             plan/audit/cache: exit nonzero when the selected state is unsafe
   --yes, -y           Skip the confirmation prompt
   --no-open           Do not auto-open the browser during pick
@@ -6696,7 +7468,7 @@ Options
   --claims a.json,b   Other projects' lockfiles (salvage; required if account is shared)
   --workspace <path>  Workspace catalog (default: pixelkiln.workspace.json). Also
                        derives salvage's claim set instead of repeated --claims.
-  --from <dir>        Source tree for init
+  --from <path>       Source for init/refine, or baseline for quality check
   --write-prompts     adopt: recover prompts into the manifest
 
 Examples
@@ -6711,6 +7483,11 @@ Examples
   pixelkiln refine --from source.png --out final.png --palette "#101820,#f2aa4c"
   pixelkiln refine approve --from final.pixelkiln.json --reviewer "Your Name"
   pixelkiln refine check --from final.pixelkiln.json
+  pixelkiln recipe list
+  pixelkiln recipe install comfyui/pixel-art-xl-environment
+  pixelkiln recipe verify pixelkiln-recipes/comfyui/pixel-art-xl-environment/1.0.0 --model-root /path/to/ComfyUI/models
+  pixelkiln quality snapshot --inputs quality-inputs.json --out pixelkiln.quality.json
+  pixelkiln quality check --from pixelkiln.quality.json
   pixelkiln workspace add ../other-game/pixelkiln.manifest.json
   pixelkiln workspace status --json
   pixelkiln salvage --workspace pixelkiln.workspace.json
@@ -6755,10 +7532,10 @@ async function confirm(question, auto) {
   return answer === "y" || answer === "yes";
 }
 async function requireCompleteWorkspaceClaims(workspacePath) {
-  if (!existsSync15(workspacePath)) {
+  if (!existsSync17(workspacePath)) {
     throw new Error(`Workspace catalog not found: ${workspacePath}`);
   }
-  const dir = path20.dirname(path20.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");
@@ -6779,11 +7556,146 @@ async function main() {
   }
   if (args.command === "--version" || args.command === "-v") {
     const pkg = JSON.parse(
-      await readFile16(new URL("../package.json", import.meta.url), "utf8")
+      await readFile17(new URL("../package.json", import.meta.url), "utf8")
     );
     log(`${pkg.name} ${pkg.version}`);
     return;
   }
+  if (args.command === "quality") {
+    if (args.subcommand === "snapshot") {
+      if (!args.inputs) throw new Error("quality snapshot needs --inputs <quality-inputs.json>.");
+      if (!args.out) throw new Error("quality snapshot needs --out <pixelkiln.quality.json>.");
+      let raw;
+      try {
+        raw = JSON.parse(await readFile17(path22.resolve(args.inputs), "utf8"));
+      } catch (error) {
+        throw new Error(
+          `Could not read quality inputs ${path22.resolve(args.inputs)}: ${error instanceof Error ? error.message : String(error)}`,
+          { cause: error }
+        );
+      }
+      const inputs = resolveQualityInputs(raw, args.inputs);
+      if (path22.resolve(args.inputs) === path22.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 });
+      if (args.json) {
+        log(JSON.stringify({
+          version: 1,
+          path: result.path,
+          changed: result.changed,
+          baseline: result.baseline
+        }, null, 2));
+      } else {
+        log(
+          `  ${result.changed ? "wrote" : "unchanged"} ${path22.relative(process.cwd(), result.path)} (${result.baseline.cases.length} case(s))`
+        );
+        log(`  Review the tolerances, commit the baseline, then run quality check in CI.`);
+      }
+      return;
+    }
+    if (!args.from) throw new Error("quality check needs --from <pixelkiln.quality.json>.");
+    const report = await checkQualityBaseline(args.from);
+    if (args.json) {
+      log(JSON.stringify(report, null, 2));
+    } else {
+      for (const entry of report.cases) {
+        log(`  ${entry.status === "pass" ? "ok" : "ERROR"}  ${entry.id}`);
+        for (const violation of entry.violations) log(`         ${violation}`);
+        for (const warning of entry.warnings) log(`  WARN   ${warning}`);
+      }
+      log(
+        `
+  ${report.summary.passed}/${report.summary.total} passed` + (report.summary.changed ? ` \xB7 ${report.summary.changed} image hash(es) changed` : "")
+      );
+      log(`  Metrics catch structural regressions; they do not replace art review.`);
+    }
+    if (!report.safe) process.exitCode = 1;
+    return;
+  }
+  if (args.command === "recipe") {
+    if (args.subcommand === "list") {
+      const recipes = await listBundledRecipes();
+      if (args.json) {
+        log(JSON.stringify({
+          version: 1,
+          recipes: recipes.map(({ recipe }) => ({
+            id: recipe.id,
+            version: recipe.version,
+            provider: recipe.provider,
+            summary: recipe.summary,
+            selector: `${recipe.id}@${recipe.version}`
+          }))
+        }, null, 2));
+      } else {
+        log(`  ${recipes.length} bundled recipe(s):`);
+        for (const { recipe } of recipes) {
+          log(`    ${(recipe.id + "@" + recipe.version).padEnd(52)} ${recipe.summary}`);
+        }
+      }
+      return;
+    }
+    const target = args.target;
+    if (args.subcommand === "inspect") {
+      const { recipe, path: recipePath, bundled } = await resolveRecipe(target);
+      if (args.json) {
+        log(JSON.stringify({ ...recipe, path: recipePath, bundled }, null, 2));
+      } else {
+        log(`  ${recipe.id}@${recipe.version}`);
+        log(`  ${recipe.summary}`);
+        log(`  provider: ${recipe.provider} \xB7 style: ${recipe.styleId} \xB7 stage: ${recipe.quality.stage}`);
+        log(
+          `  native target: ${recipe.quality.recommendedNativeSize.min}\u2013${recipe.quality.recommendedNativeSize.max}px \xB7 palette: ${recipe.quality.paletteColors.min}\u2013${recipe.quality.paletteColors.max} colors`
+        );
+        if (recipe.workflow) log(`  workflow: ${recipe.workflow.path} \xB7 ${recipe.workflow.numImages} candidate(s)`);
+        for (const model of recipe.models) log(`  model: ${model.path} \xB7 ${model.license}`);
+        log(`  source: ${recipePath}${bundled ? " (bundled)" : ""}`);
+      }
+      return;
+    }
+    if (args.subcommand === "verify") {
+      const report = await verifyRecipe(target, { modelRoot: args.modelRoot });
+      if (args.json) {
+        log(JSON.stringify(report, null, 2));
+      } else {
+        log(`  ${report.ok ? "ok" : "ERROR"}  ${report.recipe.id}@${report.recipe.version}`);
+        log(`  ${report.integrity.status.padEnd(9)} recipe metadata`);
+        for (const file of report.files) log(`  ${file.status.padEnd(9)} ${file.path}`);
+        for (const model of report.models) log(`  ${model.status.padEnd(9)} ${model.path}`);
+        if (!report.modelRoot && report.models.length) {
+          log(`  models were not checked; pass --model-root <ComfyUI/models> to verify this workstation`);
+        }
+      }
+      if (!report.ok) process.exitCode = 1;
+      return;
+    }
+    if (args.subcommand === "install") {
+      const result = await installRecipe(target, { out: args.out, force: args.force });
+      if (args.json) {
+        log(JSON.stringify({
+          version: 1,
+          recipe: `${result.recipe.id}@${result.recipe.version}`,
+          destination: result.destination,
+          changed: result.changed,
+          unchanged: result.unchanged,
+          styleId: result.styleId,
+          style: result.style
+        }, null, 2));
+      } else {
+        log(`  installed ${result.recipe.id}@${result.recipe.version}`);
+        log(`  ${path22.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 ${path22.relative(process.cwd(), result.destination)} --model-root <ComfyUI/models>`);
+        }
+      }
+      return;
+    }
+  }
   if (args.command === "refine") {
     if (!args.from) {
       throw new Error(
@@ -6812,12 +7724,12 @@ async function main() {
           `  recovered ${result2.detection.columns}x${result2.detection.rows} native grid (${result2.detection.confidence}: ${result2.detection.consensus})`
         );
         log(`  enforced ${result2.palette.length}-color palette without dithering`);
-        log(`  wrote ${path20.relative(process.cwd(), result2.output)}`);
-        log(`  quality record: ${path20.relative(process.cwd(), result2.record)}`);
+        log(`  wrote ${path22.relative(process.cwd(), result2.output)}`);
+        log(`  quality record: ${path22.relative(process.cwd(), result2.record)}`);
         log(`
   Automated checks passed. Human 1\xD7 review is still required:`);
         log(
-          `    pixelkiln refine approve --from ${path20.relative(process.cwd(), result2.record)} --reviewer "Your Name"`
+          `    pixelkiln refine approve --from ${path22.relative(process.cwd(), result2.record)} --reviewer "Your Name"`
         );
       }
       return;
@@ -6837,21 +7749,21 @@ async function main() {
         note: args.note
       });
       if (args.json) log(JSON.stringify(result2, null, 2));
-      else log(`  approved ${path20.relative(process.cwd(), result2.output)} by ${args.reviewer.trim()}`);
+      else log(`  approved ${path22.relative(process.cwd(), result2.output)} by ${args.reviewer.trim()}`);
       return;
     }
     const result = await checkQualityRecord(args.from);
     if (args.json) {
       log(JSON.stringify(result, null, 2));
     } else {
-      log(`  ${result.safe ? "release-ready" : "not release-ready"}: ${path20.relative(process.cwd(), result.output || result.record)}`);
+      log(`  ${result.safe ? "release-ready" : "not release-ready"}: ${path22.relative(process.cwd(), result.output || result.record)}`);
       for (const reason of result.reasons) log(`    ${reason}`);
     }
     if (!result.safe) process.exitCode = 1;
     return;
   }
   if (args.command === "balance") {
-    loadEnvFiles(path20.dirname(path20.resolve(args.manifest)));
+    loadEnvFiles(path22.dirname(path22.resolve(args.manifest)));
     loadEnvFiles(process.cwd());
     const loaded2 = await loadManifest(args.manifest);
     const p = createProvider(loaded2.manifest.provider, "online");
@@ -6863,31 +7775,31 @@ async function main() {
   }
   if (args.command === "init") {
     if (!args.from) throw new Error("init needs --from <dir> pointing at your existing PNGs.");
-    const root = path20.resolve(args.from);
-    if (!existsSync15(root)) throw new Error(`No directory at ${root}`);
+    const root = path22.resolve(args.from);
+    if (!existsSync17(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 = path20.resolve(args.out ?? "pixelkiln.manifest.json");
+    const target = path22.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 ?? path20.basename(path20.dirname(target)),
+      args.name ?? path22.basename(path22.dirname(target)),
       args.styles[0] ?? "base",
       generator,
-      path20.relative(path20.dirname(target), root) || ".",
+      path22.relative(path22.dirname(target), root) || ".",
       assets
     );
     await writeManifestFile(target, manifest);
-    log(`  scanned ${assets.length} PNG(s) under ${path20.relative(process.cwd(), root)}`);
+    log(`  scanned ${assets.length} PNG(s) under ${path22.relative(process.cwd(), root)}`);
     if (skipped.length) log(`  skipped ${skipped.length} unreadable file(s)`);
-    log(`  wrote ${path20.relative(process.cwd(), target)}`);
+    log(`  wrote ${path22.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 ${path20.relative(process.cwd(), target)} --write-prompts
+    pixelkiln adopt --manifest ${path22.relative(process.cwd(), target)} --write-prompts
 `);
     return;
   }
@@ -6935,10 +7847,10 @@ async function main() {
     if (args.primaryOnly || args.outputRoles.length) {
       throw new Error("--primary-only and --output-role require manifest-driven pack");
     }
-    const raw = JSON.parse(await readFile16(path20.resolve(args.inputs), "utf8"));
+    const raw = JSON.parse(await readFile17(path22.resolve(args.inputs), "utf8"));
     const inputs = resolvePackInputs(raw, args.inputs);
     const { png, atlas, skipped, sources } = packSprites(inputs, { columns: args.columns });
-    const base = path20.resolve(args.out.replace(/\.png$/, ""));
+    const base = path22.resolve(args.out.replace(/\.png$/, ""));
     const outputs = [
       { path: `${base}.png`, data: png },
       { path: `${base}.json`, data: JSON.stringify(atlas, null, 2) + "\n" }
@@ -6951,17 +7863,17 @@ async function main() {
     log(
       `  ${atlas.frames.length} sprite(s), ${atlas.sheet.width}x${atlas.sheet.height} in ${atlas.columns} column(s) \u2014 ${(png.length / 1024).toFixed(1)} KB`
     );
-    log(`    ${path20.relative(process.cwd(), base)}.png + .json + .pixelkiln.json`);
+    log(`    ${path22.relative(process.cwd(), base)}.png + .json + .pixelkiln.json`);
     for (const s of skipped) log(`    skipped ${s.id}: ${s.reason}`);
     return;
   }
   if (args.command === "workspace") {
-    const workspacePath = path20.resolve(args.workspace ?? "pixelkiln.workspace.json");
-    const dir = path20.dirname(workspacePath);
+    const workspacePath = path22.resolve(args.workspace ?? "pixelkiln.workspace.json");
+    const dir = path22.dirname(workspacePath);
     if (args.subcommand === "add") {
-      const manifestPath = path20.resolve(args.target);
+      const manifestPath = path22.resolve(args.target);
       const loadedTarget = await loadManifest(manifestPath);
-      const lockPath = args.explicitLock ? path20.resolve(args.explicitLock) : path20.join(path20.dirname(manifestPath), "pixelkiln.lock.json");
+      const lockPath = args.explicitLock ? path22.resolve(args.explicitLock) : path22.join(path22.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)) {
@@ -6981,10 +7893,10 @@ async function main() {
         ...args.account ? { account: args.account } : {}
       };
       await saveWorkspace(workspacePath, { version: 1, projects: [...ws.projects, project] });
-      log(`  registered "${id}" in ${path20.relative(process.cwd(), workspacePath)}`);
+      log(`  registered "${id}" in ${path22.relative(process.cwd(), workspacePath)}`);
       log(`    manifest: ${project.manifest}`);
       log(`    lock:     ${project.lock}`);
-      if (!existsSync15(lockPath)) {
+      if (!existsSync17(lockPath)) {
         log(
           `  warning: no lockfile there yet \u2014 this project contributes no claims until one is generated`
         );
@@ -6993,7 +7905,7 @@ async function main() {
     }
     if (args.subcommand === "remove") {
       const ws = await loadWorkspace(workspacePath);
-      const resolvedTarget = path20.resolve(args.target);
+      const resolvedTarget = path22.resolve(args.target);
       const match = ws.projects.find(
         (p) => p.id === args.target || resolveProject(dir, p).manifestPath === resolvedTarget
       );
@@ -7004,11 +7916,11 @@ async function main() {
         version: 1,
         projects: ws.projects.filter((p) => p !== match)
       });
-      log(`  removed "${match.id}" from ${path20.relative(process.cwd(), workspacePath)}`);
+      log(`  removed "${match.id}" from ${path22.relative(process.cwd(), workspacePath)}`);
       return;
     }
     if (args.subcommand === "list") {
-      if (!existsSync15(workspacePath)) {
+      if (!existsSync17(workspacePath)) {
         throw new Error(`Workspace catalog not found: ${workspacePath}`);
       }
       const ws = await loadWorkspace(workspacePath);
@@ -7016,9 +7928,9 @@ async function main() {
       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 ${path20.relative(process.cwd(), workspacePath)}`);
+        log(`  no projects registered in ${path22.relative(process.cwd(), workspacePath)}`);
       } else {
-        log(`  ${ws.projects.length} project(s) in ${path20.relative(process.cwd(), workspacePath)}:`);
+        log(`  ${ws.projects.length} project(s) in ${path22.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}` : ""})`);
         }
@@ -7028,7 +7940,7 @@ async function main() {
       return;
     }
     if (args.subcommand === "status") {
-      if (!existsSync15(workspacePath)) {
+      if (!existsSync17(workspacePath)) {
         throw new Error(`Workspace catalog not found: ${workspacePath}`);
       }
       const ws = await loadWorkspace(workspacePath);
@@ -7036,7 +7948,7 @@ async function main() {
       if (args.json) {
         log(JSON.stringify({ ...report, workspace: workspacePath }, null, 2));
       } else {
-        log(`  workspace: ${path20.relative(process.cwd(), workspacePath)}`);
+        log(`  workspace: ${path22.relative(process.cwd(), workspacePath)}`);
         for (const p of report.projects) {
           if (p.error) {
             log(`
@@ -7080,14 +7992,14 @@ async function main() {
       return;
     }
   }
-  if (!existsSync15(path20.resolve(args.manifest))) {
+  if (!existsSync17(path22.resolve(args.manifest))) {
     throw new Error(
-      `No manifest at ${path20.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 manifestDir = path20.dirname(path20.resolve(args.manifest));
+  const manifestDir = path22.dirname(path22.resolve(args.manifest));
   const envFiles = [...loadEnvFiles(manifestDir)];
-  if (path20.resolve(process.cwd()) !== manifestDir) envFiles.push(...loadEnvFiles(process.cwd()));
+  if (path22.resolve(process.cwd()) !== manifestDir) envFiles.push(...loadEnvFiles(process.cwd()));
   const loaded = await loadManifest(args.manifest);
   const estimator = createProvider(loaded.manifest.provider, "offline");
   const specs = await resolveSpecs(loaded, {
@@ -7164,7 +8076,7 @@ async function main() {
       let intact = true;
       for (const output of entry.outputs) {
         const file = resolveOutputPath(output.path, item.spec.root);
-        if (!existsSync15(file) || await sha256File(file) !== output.sha256) {
+        if (!existsSync17(file) || await sha256File(file) !== output.sha256) {
           intact = false;
           break;
         }
@@ -7222,7 +8134,7 @@ async function main() {
     if (args.primaryOnly && args.outputRoles.length) {
       throw new Error("pack accepts either --primary-only or --output-role, not both");
     }
-    const manifestDir2 = path20.dirname(path20.resolve(args.manifest));
+    const manifestDir2 = path22.dirname(path22.resolve(args.manifest));
     const styleIds = args.styles.length ? args.styles : Object.keys(loaded.manifest.styles);
     for (const styleId of styleIds) {
       const { png, atlas, skipped, sources } = packStyle(lock, styleId, manifestDir2, {
@@ -7231,7 +8143,7 @@ async function main() {
         primaryOnly: args.primaryOnly
       });
       const style = loaded.manifest.styles[styleId];
-      const base = args.out ? path20.resolve(args.out.replace(/\.png$/, "")) : path20.resolve(manifestDir2, style.outDir, `${styleId}-sheet`);
+      const base = args.out ? path22.resolve(args.out.replace(/\.png$/, "")) : path22.resolve(manifestDir2, style.outDir, `${styleId}-sheet`);
       const outputs = [
         { path: `${base}.png`, data: png },
         { path: `${base}.json`, data: JSON.stringify(atlas, null, 2) + "\n" }
@@ -7254,13 +8166,13 @@ async function main() {
       log(
         `  ${styleId} \u2014 ${atlas.frames.length} sprite(s), ${atlas.sheet.width}x${atlas.sheet.height} in ${atlas.columns} column(s)`
       );
-      log(`    ${path20.relative(process.cwd(), base)}.png + .json + .pixelkiln.json`);
+      log(`    ${path22.relative(process.cwd(), base)}.png + .json + .pixelkiln.json`);
       for (const s of skipped) log(`    skipped ${s.id}: ${s.reason}`);
     }
     return;
   }
   if (args.command === "mount") {
-    const manifestDir2 = path20.dirname(path20.resolve(args.manifest));
+    const manifestDir2 = path22.dirname(path22.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];
@@ -7290,7 +8202,7 @@ async function main() {
         sources,
         outputRoles
       );
-      const out = path20.resolve(manifestDir2, style.mount.out);
+      const out = path22.resolve(manifestDir2, style.mount.out);
       const metadata = out.replace(/\.png$/, "") + ".json";
       const companion = out.replace(/\.png$/, "") + ".pixelkiln.json";
       const outputs = [
@@ -7303,7 +8215,7 @@ async function main() {
           await provenanceFile("$manifest", args.manifest),
           await provenanceFile("$lock", args.lock),
           ...artifactSources.filter(
-            (source) => source.id !== "$base" || path20.resolve(source.path) !== out
+            (source) => source.id !== "$base" || path22.resolve(source.path) !== out
           )
         ],
         options: {
@@ -7316,7 +8228,7 @@ async function main() {
       log(
         `  ${styleId} \u2014 ${atlas.frames.length} cell(s) into ${atlas.sheet.width}x${atlas.sheet.height}` + (overBase ? ` over ${style.mount.base}` : " (new sheet)")
       );
-      log(`    ${path20.relative(process.cwd(), out)} + atlas/provenance JSON`);
+      log(`    ${path22.relative(process.cwd(), out)} + atlas/provenance JSON`);
       for (const s of skipped) log(`    skipped ${s.id}: ${s.reason}`);
     }
     return;
@@ -7372,7 +8284,7 @@ async function main() {
   }
   if (args.command === "export") {
     const format = args.format ?? "generic";
-    const manifestDir2 = path20.dirname(path20.resolve(args.manifest));
+    const manifestDir2 = path22.dirname(path22.resolve(args.manifest));
     const selected = specs.filter((spec) => {
       if (spec.generator !== "tiles") return false;
       if (args.styles.length && !args.styles.includes(spec.styleId)) return false;
@@ -7388,12 +8300,12 @@ async function main() {
     for (const spec of selected) {
       const entry = lock.entries[lockKey(spec.styleId, spec.assetId)];
       const style = loaded.manifest.styles[spec.styleId];
-      const defaultBase = path20.resolve(manifestDir2, style.outDir, `${spec.assetId}-tileset`);
-      const base = args.out ? path20.resolve(args.out.replace(/\.(?:png|json|tsj|tres)$/i, "")) : defaultBase;
+      const defaultBase = path22.resolve(manifestDir2, style.outDir, `${spec.assetId}-tileset`);
+      const base = args.out ? path22.resolve(args.out.replace(/\.(?:png|json|tsj|tres)$/i, "")) : defaultBase;
       const result = exportTileset(entry, spec, {
         format,
         manifestDir: manifestDir2,
-        imageName: path20.basename(`${base}.png`),
+        imageName: path22.basename(`${base}.png`),
         columns: args.columns
       });
       const outputs = [
@@ -7411,7 +8323,7 @@ async function main() {
           asset: spec.assetId,
           columns: args.columns ?? null,
           format,
-          image: path20.basename(`${base}.png`),
+          image: path22.basename(`${base}.png`),
           providerRules: result.generic.providerRules,
           style: spec.styleId,
           tileType: spec.tileType ?? null
@@ -7421,7 +8333,7 @@ async function main() {
         `  ${spec.styleId}/${spec.assetId} \u2014 ${result.generic.tiles.length} tile(s), ${result.generic.sheet.width}x${result.generic.sheet.height} (${format})`
       );
       log(
-        `    ${path20.relative(process.cwd(), base)}.png + ${path20.basename(base)}${result.extension} + .pixelkiln.json`
+        `    ${path22.relative(process.cwd(), base)}.png + ${path22.basename(base)}${result.extension} + .pixelkiln.json`
       );
     }
     return;
@@ -7461,10 +8373,10 @@ async function main() {
   tagged ${n} object(s) upstream`);
     }
     if (args.writePrompts) {
-      const { filled, stillEmpty } = await writePromptsBack(path20.resolve(args.manifest), lock, {
+      const { filled, stillEmpty } = await writePromptsBack(path22.resolve(args.manifest), lock, {
         onProgress: log
       });
-      log(`  recovered ${filled} prompt(s) into ${path20.relative(process.cwd(), args.manifest)}`);
+      log(`  recovered ${filled} prompt(s) into ${path22.relative(process.cwd(), args.manifest)}`);
       const reloaded = await loadManifest(args.manifest);
       const rebased = await resolveSpecs(reloaded, {
         styles: args.styles,
@@ -7493,12 +8405,12 @@ async function main() {
   if (args.command === "salvage") {
     const jsonMode = args.dryRun && args.json;
     const diag = jsonMode ? (msg = "") => console.error(msg) : log;
-    const ownLock = path20.resolve(args.lock);
+    const ownLock = path22.resolve(args.lock);
     let workspaceProjects = [];
     let workspaceDir = "";
     if (args.workspace) {
-      const workspacePath = path20.resolve(args.workspace);
-      workspaceDir = path20.dirname(workspacePath);
+      const workspacePath = path22.resolve(args.workspace);
+      workspaceDir = path22.dirname(workspacePath);
       const complete = await requireCompleteWorkspaceClaims(workspacePath);
       workspaceProjects = complete.ws.projects;
       for (const d of complete.diagnostics) diag(`  WARN  ${d.id}: ${d.message}`);
@@ -7507,12 +8419,12 @@ async function main() {
     const lockPaths = [
       .../* @__PURE__ */ new Set([
         ...workspaceLockPaths,
-        ...existsSync15(ownLock) ? [ownLock] : [],
-        ...args.claims.map((c) => path20.resolve(c))
+        ...existsSync17(ownLock) ? [ownLock] : [],
+        ...args.claims.map((c) => path22.resolve(c))
       ])
     ];
     diag(`  claim set (${lockPaths.length} lockfile(s)):`);
-    for (const p of lockPaths) diag(`    ${path20.relative(process.cwd(), p)}`);
+    for (const p of lockPaths) diag(`    ${path22.relative(process.cwd(), p)}`);
     if (!args.claims.length && !args.workspace) {
       diag(
         `
@@ -7520,7 +8432,7 @@ async function main() {
   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 === path20.resolve(args.manifest))) {
+    } else if (args.workspace && !workspaceProjects.some((p) => resolveProject(workspaceDir, p).manifestPath === path22.resolve(args.manifest))) {
       diag(
         `
   This project's manifest is not registered in the workspace catalog. Its own
@@ -7604,7 +8516,7 @@ async function main() {
           manifestPath: loaded.path,
           manifest: loaded.manifest,
           styleId,
-          importDir: path20.resolve(loaded.root, style.outDir),
+          importDir: path22.resolve(loaded.root, style.outDir),
           lock,
           lockPath: args.lock
         },