pixelkiln 0.10.0 → 0.12.0

package/dist/cli.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import path19 from "path";
-import { existsSync as existsSync15 } from "fs";
-import { readFile as readFile15 } 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(path20) {
-  return sha256(await readFile(path20));
+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 message2 of messages) {
-    if (!Array.isArray(message2) || message2[0] !== "execution_error" || !isObject(message2[1])) continue;
-    const detail = message2[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(message2, status, body) {
-    super(message2);
+  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(path20, 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}${path20}`, {
+      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(path20, 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(path20, init, attempt + 1);
+      return this.request(path23, init, attempt + 1);
     }
     const text = await res.text();
     if (!res.ok) {
-      throw new PixelLabError(`${init?.method ?? "GET"} ${path20} \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"} ${path20} 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(path20, init = {}) {
+  async call(path23, init = {}) {
     if (!this.token) throw new Error("RD_API_KEY is not set");
-    const response = await this.request(`${this.baseUrl}${path20}`, {
+    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 message2 = record.detail.message;
-    if (typeof message2 === "string") return message2;
+    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 message2 = err instanceof Error ? err.message : String(err);
-      upsert(lock, key, { status: "failed", error: message2, cost: 0 });
-      log2(`  FAILED ${key}: ${message2}`);
+      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 message2 = 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: ${message2}`
+          error: `download failed: ${message5}`
         });
         result.failed++;
-        log2(`  FAILED  ${key}: ${message2}`);
+        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, message2) => checks.push({ id, level, message: message2 });
+  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(path20) {
-  if (!existsSync8(path20)) return { version: 1, hashes: {} };
+async function loadCache(path23) {
+  if (!existsSync8(path23)) return { version: 1, hashes: {} };
   try {
-    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile6(path20, "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(path20) {
     return { version: 1, hashes: {} };
   }
 }
-async function saveCache(path20, 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(path20)), { recursive: true });
-  const tmp = `${path20}.${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, path20);
+    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 message2 = err instanceof Error ? err.message : String(err);
-          log2(`  apply failed: ${message2}`);
+          const message5 = err instanceof Error ? err.message : String(err);
+          log2(`  apply failed: ${message5}`);
           res.writeHead(500, { "Content-Type": "text/plain" });
-          res.end(message2);
+          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;
@@ -5044,110 +5050,927 @@ async function inspectRemoteHashCache(remotePath) {
   return report;
 }
 
-// src/pipeline/tileset-export.ts
-function normalizeTileRules(raw) {
-  if (!isRecord(raw)) return null;
-  const ruleType = raw.rule_type;
-  const arity = raw.arity;
-  if (ruleType !== "edge" && ruleType !== "corner" && ruleType !== "outline") return null;
-  if (arity !== 4 && arity !== 6) return null;
-  const masks = {};
-  if (isRecord(raw.tiles)) {
-    for (const [key, value] of Object.entries(raw.tiles)) {
-      const index = tileIndex(key);
-      const mask = typeof value === "number" ? value : isRecord(value) && typeof value.bitmask === "number" ? value.bitmask : isRecord(value) && typeof value.mask === "number" ? value.mask : null;
-      if (index !== null && mask !== null && Number.isInteger(mask) && mask >= 0) masks[index] = mask;
+// src/pipeline/refine.ts
+import path18 from "path";
+import { execFile } from "child_process";
+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 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);
+}
+function digest(data) {
+  return createHash2("sha256").update(data).digest("hex");
+}
+function portableRelative(from, to) {
+  return path17.relative(from, path17.resolve(to)).split(path17.sep).join("/") || ".";
+}
+function canonical2(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new Error("Artifact provenance numbers must be finite.");
+    return value;
+  }
+  if (Array.isArray(value)) return value.map(canonical2);
+  if (typeof value === "object") {
+    const sorted = {};
+    for (const key of Object.keys(value).sort()) {
+      const item = value[key];
+      if (item !== void 0) sorted[key] = canonical2(item);
     }
+    return sorted;
   }
-  const connectivity = raw.connectivity === "same" || raw.connectivity === "other" ? raw.connectivity : void 0;
-  const terrains = Array.isArray(raw.terrains) ? raw.terrains.filter((item) => typeof item === "string") : [];
-  return {
-    ruleType,
-    arity,
-    ...connectivity ? { connectivity } : {},
-    terrains,
-    masks,
-    raw
-  };
+  throw new Error(`Artifact provenance cannot contain ${typeof value} values.`);
 }
-function exportTileset(entry, spec, options) {
-  const outputs = resolveSpecEntryOutputs(entry, spec);
-  if (!outputs.length) throw new Error(`${spec.styleId}/${spec.assetId} has no downloaded outputs`);
-  const packed = packSprites(
-    outputs.map((output) => ({
-      id: output.role ?? fallbackOutputRole(output.index),
-      path: output.absolutePath
-    })),
-    { columns: options.columns, order: "input" }
-  );
-  if (packed.skipped.length) {
-    throw new Error(
-      `Cannot export ${spec.styleId}/${spec.assetId}: ` + packed.skipped.map((item) => `${item.id}: ${item.reason}`).join("; ")
-    );
+function fingerprint(provenance) {
+  return digest(JSON.stringify(canonical2({
+    kind: provenance.kind,
+    sources: provenance.sources,
+    options: provenance.options,
+    outputs: provenance.outputs
+  })));
+}
+function parseArtifactManifest(absolute, data) {
+  let raw;
+  try {
+    raw = JSON.parse(data);
+  } catch (error) {
+    throw new Error(`${absolute} is not valid JSON: ${message(error)}`, { cause: error });
   }
-  const metadata = entry.providerMetadata?.[entry.provider];
-  const rawRules = isRecord(metadata) ? metadata.tileRules : void 0;
-  const rules = normalizeTileRules(rawRules);
-  const frames = packed.atlas.frames;
-  const generic = buildGeneric(
-    spec,
-    options.imageName,
-    packed.atlas,
-    frames,
-    isRecord(rawRules) ? rawRules : null,
-    rules
+  if (raw.format !== "pixelkiln-artifact-bundle" || raw.version !== 1 || raw.kind !== "pack" && raw.kind !== "mount" && raw.kind !== "tileset" && raw.kind !== "refine" || typeof raw.fingerprint !== "string" || raw.options === void 0 || !Array.isArray(raw.sources) || !Array.isArray(raw.outputs)) {
+    throw new Error(`${absolute} is not a PixelKiln artifact bundle manifest.`);
+  }
+  for (const source of raw.sources) {
+    if (!source || typeof source.id !== "string" || typeof source.path !== "string" || source.sha256 !== null && typeof source.sha256 !== "string" || typeof source.included !== "boolean") {
+      throw new Error(`${absolute} contains an invalid artifact source.`);
+    }
+  }
+  for (const output of raw.outputs) {
+    if (!output || typeof output.path !== "string" || typeof output.sha256 !== "string") {
+      throw new Error(`${absolute} contains an invalid artifact output.`);
+    }
+  }
+  return raw;
+}
+async function readArtifactBundleManifest(manifestPath) {
+  const absolute = path17.resolve(manifestPath);
+  return parseArtifactManifest(absolute, await readFile12(absolute, "utf8"));
+}
+async function readOptional(file) {
+  try {
+    return await readFile12(file);
+  } catch (error) {
+    if (isCode(error, "ENOENT")) return null;
+    throw error;
+  }
+}
+function transactionMarker(journal) {
+  return `${journal}.committed`;
+}
+function processIsAlive(pid) {
+  if (!Number.isInteger(pid) || pid < 1) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return !isCode(error, "ESRCH");
+  }
+}
+function validTemporaryPath(candidate, destination, type) {
+  return path17.dirname(candidate) === path17.dirname(destination) && path17.basename(candidate).startsWith(
+    `.${path17.basename(destination)}.pixelkiln-${type}-`
   );
-  if (options.format === "generic") {
-    return {
-      png: packed.png,
-      extension: ".json",
-      document: JSON.stringify(generic, null, 2) + "\n",
-      generic,
-      sources: packed.sources
-    };
+}
+function parseTransaction(journal, data) {
+  let raw;
+  try {
+    raw = JSON.parse(data);
+  } catch (error) {
+    throw new Error(`${journal} is not valid transaction JSON: ${message(error)}`, { cause: error });
   }
-  assertUniformTiles(generic);
-  if ((rawRules !== void 0 || entry.tileFeature) && !rules) {
-    throw new Error(
-      `${options.format} export needs recognized adjacency rules; use --format generic to retain this provider rule object without guessing`
-    );
+  if (raw.format !== "pixelkiln-artifact-transaction" || raw.version !== 1 || !Number.isInteger(raw.pid) || typeof raw.createdAt !== "string" || !Array.isArray(raw.entries) || !raw.entries.length) {
+    throw new Error(`${journal} is not a PixelKiln artifact transaction.`);
   }
-  if (rules?.arity === 6) {
+  return raw;
+}
+async function removeTransactionFiles(journal) {
+  await rm6(journal, { force: true });
+  await rm6(transactionMarker(journal), { force: true });
+}
+async function recoverArtifactTransaction(recoveryFile, allowedDestinations) {
+  const journal = path17.resolve(recoveryFile);
+  const bytes = await readOptional(journal);
+  if (!bytes) {
+    await rm6(transactionMarker(journal), { force: true });
+    return;
+  }
+  if (activeTransactions.has(journal)) {
+    throw new Error(`Another artifact write in this process is already using ${journal}.`);
+  }
+  const transaction = parseTransaction(journal, bytes.toString("utf8"));
+  if (transaction.pid !== process.pid && processIsAlive(transaction.pid)) {
     throw new Error(
-      `${options.format} export does not yet map six-edge hex masks safely; use --format generic`
+      `Artifact transaction ${journal} is still owned by live process ${transaction.pid}; refusing concurrent recovery.`
     );
   }
-  if (rules?.ruleType === "outline") {
+  for (const entry of transaction.entries) {
+    if (typeof entry.destination !== "string" || typeof entry.stage !== "string" || typeof entry.sha256 !== "string" || entry.backup !== void 0 && typeof entry.backup !== "string" || !allowedDestinations.has(path17.resolve(entry.destination)) || !validTemporaryPath(entry.stage, entry.destination, "stage") || entry.backup !== void 0 && !validTemporaryPath(entry.backup, entry.destination, "backup")) {
+      throw new Error(
+        `Refusing unsafe artifact recovery from ${journal}; its destinations or temporary paths do not match the current bundle.`
+      );
+    }
+  }
+  const committed = await readOptional(transactionMarker(journal)) !== null;
+  const errors = [];
+  if (committed) {
+    for (const entry of transaction.entries) {
+      if (entry.backup) await remove2(entry.backup, errors);
+      await remove2(entry.stage, errors);
+    }
+  } else {
+    for (const entry of [...transaction.entries].reverse()) {
+      const backup = entry.backup ? await readOptional(entry.backup) : null;
+      const destination = await readOptional(entry.destination);
+      if (backup) {
+        if (destination && digest(destination) !== entry.sha256) {
+          errors.push(
+            `destination changed during interrupted recovery: ${entry.destination}; previous file remains at ${entry.backup}`
+          );
+          continue;
+        }
+        await remove2(entry.destination, errors);
+        try {
+          await rename5(entry.backup, entry.destination);
+        } catch (error) {
+          errors.push(
+            `could not restore ${entry.destination}; previous file remains at ${entry.backup}: ${message(error)}`
+          );
+        }
+      } else if (destination && digest(destination) === entry.sha256) {
+        await remove2(entry.destination, errors);
+      }
+      await remove2(entry.stage, errors);
+    }
+  }
+  if (errors.length) {
     throw new Error(
-      `${options.format} export cannot infer adjacency from outline/stamp-only rules; use --format generic`
+      `Artifact transaction recovery needs attention; journal retained at ${journal}: ` + errors.join("; ")
     );
   }
-  if (options.format === "tiled") {
-    return {
-      png: packed.png,
-      extension: ".tsj",
-      document: JSON.stringify(buildTiled(generic), null, 2) + "\n",
-      generic,
-      sources: packed.sources
-    };
-  }
-  return {
-    png: packed.png,
-    extension: ".tres",
-    document: buildGodot(generic, spec),
-    generic,
-    sources: packed.sources
-  };
+  await removeTransactionFiles(journal);
 }
-function buildGeneric(spec, imageName, atlas, frames, providerRules, rules) {
+function createArtifactBundleManifest(manifestPath, outputs, provenance) {
+  const root = path17.dirname(path17.resolve(manifestPath));
+  const sources = provenance.sources.map((source) => ({
+    ...source,
+    path: portableRelative(root, source.path)
+  }));
+  const normalized = {
+    kind: provenance.kind,
+    sources,
+    options: canonical2(provenance.options)
+  };
+  const manifestOutputs = outputs.map((output) => ({
+    path: portableRelative(root, output.path),
+    sha256: digest(output.data)
+  }));
   return {
-    format: "pixelkiln-tileset",
+    format: "pixelkiln-artifact-bundle",
     version: 1,
-    name: `${spec.styleId}/${spec.assetId}`,
-    style: spec.styleId,
-    asset: spec.assetId,
-    image: imageName,
-    tile: { ...atlas.cell },
+    ...normalized,
+    fingerprint: fingerprint({ ...normalized, outputs: manifestOutputs }),
+    outputs: manifestOutputs
+  };
+}
+function withArtifactManifest(manifestPath, outputs, provenance) {
+  const manifest = createArtifactBundleManifest(manifestPath, outputs, provenance);
+  return [
+    ...outputs,
+    { path: manifestPath, data: JSON.stringify(manifest, null, 2) + "\n" }
+  ];
+}
+async function writeManagedArtifactBundle(manifestPath, outputs, provenance, options = {}) {
+  const absoluteManifest = path17.resolve(manifestPath);
+  const recoveryFile = `${absoluteManifest}.transaction`;
+  const allowedDestinations = /* @__PURE__ */ new Set([
+    absoluteManifest,
+    ...outputs.map((output) => path17.resolve(output.path))
+  ]);
+  await recoverArtifactTransaction(recoveryFile, allowedDestinations);
+  const existingManifestBytes = await readOptional(absoluteManifest);
+  let previous = null;
+  if (existingManifestBytes && !options.force) {
+    try {
+      previous = parseArtifactManifest(absoluteManifest, existingManifestBytes.toString("utf8"));
+      const valid = previous.fingerprint === fingerprint(previous);
+      if (!valid) throw new Error("its integrity fingerprint does not match");
+    } catch (error) {
+      throw new Error(
+        `Refusing to replace unrecognized or modified provenance at ${absoluteManifest}: ${message(error)}. Pass { force: true } (CLI: --force) to take ownership of this artifact bundle.`,
+        { cause: error }
+      );
+    }
+  }
+  if (!options.force) {
+    const root = path17.dirname(absoluteManifest);
+    const recorded = new Map(
+      previous?.outputs.map((output) => [path17.resolve(root, output.path), output.sha256]) ?? []
+    );
+    const conflicts = [];
+    for (const output of outputs) {
+      const destination = path17.resolve(output.path);
+      const current = await readOptional(destination);
+      if (!current || digest(current) === digest(output.data)) continue;
+      const expected = recorded.get(destination);
+      if (!expected || digest(current) !== expected) conflicts.push(destination);
+    }
+    if (conflicts.length) {
+      throw new Error(
+        `Refusing to overwrite modified or unowned artifact file(s):
+` + conflicts.map((file) => `  ${file}`).join("\n") + `
+Pass { force: true } (CLI: --force) to take ownership and replace the complete bundle.`
+      );
+    }
+  }
+  const { force: _force, ...bundleOptions } = options;
+  return writeArtifactBundle(
+    withArtifactManifest(absoluteManifest, outputs, provenance),
+    { ...bundleOptions, recoveryFile }
+  );
+}
+async function verifyArtifactBundle(manifestPath) {
+  const absolute = path17.resolve(manifestPath);
+  const raw = await readArtifactBundleManifest(absolute);
+  const root = path17.dirname(absolute);
+  const changedSources = [];
+  const changedOutputs = [];
+  for (const source of raw.sources) {
+    let actual = null;
+    try {
+      actual = digest(await readFile12(path17.resolve(root, source.path)));
+    } catch (error) {
+      if (!isCode(error, "ENOENT")) throw error;
+    }
+    if (actual !== source.sha256) changedSources.push(source.id);
+  }
+  for (const output of raw.outputs) {
+    try {
+      if (digest(await readFile12(path17.resolve(root, output.path))) !== output.sha256) {
+        changedOutputs.push(output.path);
+      }
+    } catch (error) {
+      if (!isCode(error, "ENOENT")) throw error;
+      changedOutputs.push(output.path);
+    }
+  }
+  const fingerprintValid = raw.fingerprint === fingerprint({
+    kind: raw.kind,
+    sources: raw.sources,
+    options: raw.options,
+    outputs: raw.outputs
+  });
+  return {
+    current: fingerprintValid && !changedSources.length && !changedOutputs.length,
+    fingerprintValid,
+    changedSources,
+    changedOutputs
+  };
+}
+function isCode(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+async function remove2(file, errors) {
+  try {
+    await rm6(file, { force: true });
+  } catch (error) {
+    errors?.push(`could not remove ${file}: ${message(error)}`);
+  }
+}
+async function rollback(prepared) {
+  const errors = [];
+  for (const artifact of [...prepared].reverse()) {
+    if (artifact.promoted) await remove2(artifact.destination, errors);
+  }
+  for (const artifact of [...prepared].reverse()) {
+    if (!artifact.backup || !artifact.backedUp) continue;
+    try {
+      await rename5(artifact.backup, artifact.destination);
+      artifact.backedUp = false;
+    } catch (error) {
+      errors.push(
+        `could not restore ${artifact.destination}; previous file remains at ${artifact.backup}: ${message(error)}`
+      );
+    }
+  }
+  for (const artifact of prepared) {
+    if (artifact.stage) await remove2(artifact.stage, errors);
+  }
+  return errors;
+}
+async function writeArtifactBundle(files, options = {}) {
+  if (!files.length) throw new Error("An artifact bundle must contain at least one file.");
+  const normalized = files.map((file) => {
+    if (!file.path.trim()) throw new Error("Artifact paths cannot be empty.");
+    return { destination: path17.resolve(file.path), data: Buffer.from(file.data) };
+  });
+  const destinations = /* @__PURE__ */ new Set();
+  for (const artifact of normalized) {
+    if (destinations.has(artifact.destination)) {
+      throw new Error(`Artifact bundle contains duplicate destination: ${artifact.destination}`);
+    }
+    destinations.add(artifact.destination);
+  }
+  if (options.recoveryFile) {
+    await recoverArtifactTransaction(options.recoveryFile, destinations);
+  }
+  const changed = [];
+  const unchanged = [];
+  for (const artifact of normalized) {
+    try {
+      const current = await readFile12(artifact.destination);
+      if (current.equals(artifact.data)) {
+        unchanged.push(artifact.destination);
+      } else {
+        changed.push({ ...artifact, existed: true, backedUp: false, promoted: false });
+      }
+    } catch (error) {
+      if (!isCode(error, "ENOENT")) throw error;
+      changed.push({ ...artifact, existed: false, backedUp: false, promoted: false });
+    }
+  }
+  if (!changed.length) return { changed: [], unchanged };
+  const token = randomUUID3();
+  for (const [index, artifact] of changed.entries()) {
+    const basename = path17.basename(artifact.destination);
+    artifact.stage = path17.join(
+      path17.dirname(artifact.destination),
+      `.${basename}.pixelkiln-stage-${token}-${index}`
+    );
+    if (artifact.existed) {
+      artifact.backup = path17.join(
+        path17.dirname(artifact.destination),
+        `.${basename}.pixelkiln-backup-${token}-${index}`
+      );
+    }
+  }
+  const journal = options.recoveryFile ? path17.resolve(options.recoveryFile) : null;
+  if (journal) {
+    await mkdir5(path17.dirname(journal), { recursive: true });
+    const transaction = {
+      format: "pixelkiln-artifact-transaction",
+      version: 1,
+      pid: process.pid,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      entries: changed.map((artifact) => ({
+        destination: artifact.destination,
+        stage: artifact.stage,
+        ...artifact.backup ? { backup: artifact.backup } : {},
+        sha256: digest(artifact.data)
+      }))
+    };
+    try {
+      await writeFile7(journal, JSON.stringify(transaction, null, 2) + "\n", { flag: "wx" });
+      activeTransactions.add(journal);
+    } catch (error) {
+      throw new Error(
+        `Could not start durable artifact transaction at ${journal}: ${message(error)}`,
+        { cause: error }
+      );
+    }
+  }
+  try {
+    for (const [index, artifact] of changed.entries()) {
+      await mkdir5(path17.dirname(artifact.destination), { recursive: true });
+      await options.beforeStage?.(artifact.destination, index);
+      await writeFile7(artifact.stage, artifact.data, { flag: "wx" });
+    }
+  } catch (error) {
+    const cleanupErrors2 = await rollback(changed);
+    if (journal && !cleanupErrors2.length) await removeTransactionFiles(journal);
+    if (journal) activeTransactions.delete(journal);
+    const suffix = cleanupErrors2.length ? ` Cleanup also failed: ${cleanupErrors2.join("; ")}` : "";
+    throw new Error(`Could not stage artifact bundle: ${message(error)}.${suffix}`, { cause: error });
+  }
+  let durableCommit = false;
+  try {
+    for (const artifact of changed) {
+      if (!artifact.existed) continue;
+      await rename5(artifact.destination, artifact.backup);
+      artifact.backedUp = true;
+    }
+    for (const [index, artifact] of changed.entries()) {
+      await options.beforePromote?.(artifact.destination, index);
+      await rename5(artifact.stage, artifact.destination);
+      artifact.stage = void 0;
+      artifact.promoted = true;
+    }
+    if (journal) {
+      await writeFile7(transactionMarker(journal), `${token}
+`, { flag: "wx" });
+      durableCommit = true;
+      await options.afterCommit?.();
+    }
+  } catch (error) {
+    if (durableCommit) {
+      if (journal) activeTransactions.delete(journal);
+      throw new Error(
+        `Artifact bundle was committed, but final cleanup was interrupted: ${message(error)}. The next write will finish cleanup from ${journal}.`,
+        { cause: error }
+      );
+    }
+    const rollbackErrors = await rollback(changed);
+    if (journal && !rollbackErrors.length) await removeTransactionFiles(journal);
+    if (journal) activeTransactions.delete(journal);
+    const suffix = rollbackErrors.length ? ` Rollback needs attention: ${rollbackErrors.join("; ")}` : " Previous bundle restored.";
+    throw new Error(`Could not promote artifact bundle: ${message(error)}.${suffix}`, { cause: error });
+  }
+  const cleanupErrors = [];
+  for (const artifact of changed) {
+    if (artifact.backup) await remove2(artifact.backup, cleanupErrors);
+  }
+  if (cleanupErrors.length) {
+    if (journal) activeTransactions.delete(journal);
+    throw new Error(
+      `Artifact bundle was written, but old backup cleanup failed: ${cleanupErrors.join("; ")}`
+    );
+  }
+  if (journal) {
+    try {
+      await removeTransactionFiles(journal);
+    } finally {
+      activeTransactions.delete(journal);
+    }
+  }
+  return {
+    changed: changed.map((artifact) => artifact.destination),
+    unchanged
+  };
+}
+
+// src/pipeline/refine.ts
+var execFileAsync = promisify(execFile);
+var PIXEL_ART_FIXER_URL = "https://github.com/Retro-Diffusion/pixel-art-fixer";
+var PIXEL_ART_FIXER_REVISION = "ef376e57e1c272633ca2dbf5f29ec3fcf6596465";
+function message2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function qualityRecordPath(output) {
+  if (!/\.png$/i.test(output)) throw new Error("Refined output must be a .png file.");
+  return output.replace(/\.png$/i, ".pixelkiln.json");
+}
+function confidenceFor(consensus) {
+  if (consensus.startsWith("fast:")) return "high";
+  if (consensus === "arbitrated" || consensus === "forced" || consensus.startsWith("fastmode:") && consensus.includes("+")) return "medium";
+  return "low";
+}
+var confidenceRank = { low: 0, medium: 1, high: 2 };
+function requireConfidence(value) {
+  if (value === "low" || value === "medium" || value === "high") return value;
+  throw new Error(`Unknown grid confidence "${value}"; expected low, medium, or high.`);
+}
+function firstJsonObject(text) {
+  const start = text.indexOf("{");
+  if (start < 0) throw new Error("Pixel Art Fixer did not print detection JSON.");
+  let depth = 0;
+  let string = false;
+  let escaped = false;
+  for (let i = start; i < text.length; i++) {
+    const char = text[i];
+    if (string) {
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === '"') string = false;
+      continue;
+    }
+    if (char === '"') string = true;
+    else if (char === "{") depth++;
+    else if (char === "}" && --depth === 0) {
+      try {
+        return JSON.parse(text.slice(start, i + 1));
+      } catch (error) {
+        throw new Error(`Pixel Art Fixer printed invalid detection JSON: ${message2(error)}`);
+      }
+    }
+  }
+  throw new Error("Pixel Art Fixer printed incomplete detection JSON.");
+}
+var PYTHON_FIXER_BRIDGE = [
+  "import json, sys",
+  "from pixelfixer.api import process",
+  "result = process(open(sys.argv[1], 'rb').read(), mode='full')",
+  "open(sys.argv[2], 'wb').write(result.pop('png'))",
+  "print(json.dumps(result))"
+].join("; ");
+function parseDetection(raw) {
+  if (!raw || typeof raw !== "object") throw new Error("Pixel Art Fixer returned no detection result.");
+  const value = raw;
+  const stepX = Number(value.step_x);
+  const stepY = Number(value.step_y);
+  const columns = Number(value.cols);
+  const rows = Number(value.rows);
+  const consensus = value.consensus;
+  if (!Number.isFinite(stepX) || stepX <= 0 || !Number.isFinite(stepY) || stepY <= 0 || !Number.isInteger(columns) || columns < 1 || !Number.isInteger(rows) || rows < 1 || typeof consensus !== "string" || !consensus) {
+    throw new Error("Pixel Art Fixer returned an invalid grid detection result.");
+  }
+  return {
+    stepX,
+    stepY,
+    columns,
+    rows,
+    consensus,
+    confidence: confidenceFor(consensus)
+  };
+}
+function normalizePalette(values) {
+  const colors = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    const rgb = parseHex(value);
+    const hex2 = `#${rgb.r.toString(16).padStart(2, "0")}${rgb.g.toString(16).padStart(2, "0")}${rgb.b.toString(16).padStart(2, "0")}`;
+    colors.set(hex2, { hex: hex2, ...rgb });
+  }
+  if (colors.size < 2 || colors.size > 256) {
+    throw new Error(`A refinement palette must contain 2\u2013256 unique colors; got ${colors.size}.`);
+  }
+  return [...colors.values()];
+}
+function quantizeToPalette(png, palette) {
+  const colors = normalizePalette(palette);
+  const pixels = Buffer.from(png.pixels);
+  for (let i = 0; i < pixels.length; i += 4) {
+    const alpha = pixels[i + 3];
+    if (alpha === 0) {
+      pixels[i] = 0;
+      pixels[i + 1] = 0;
+      pixels[i + 2] = 0;
+      continue;
+    }
+    const pixel = { r: pixels[i], g: pixels[i + 1], b: pixels[i + 2] };
+    let nearest = colors[0];
+    let distance = colorDistance(pixel, nearest);
+    for (let j = 1; j < colors.length; j++) {
+      const candidate = colors[j];
+      const candidateDistance = colorDistance(pixel, candidate);
+      if (candidateDistance < distance) {
+        nearest = candidate;
+        distance = candidateDistance;
+      }
+    }
+    pixels[i] = nearest.r;
+    pixels[i + 1] = nearest.g;
+    pixels[i + 2] = nearest.b;
+  }
+  return { width: png.width, height: png.height, pixels };
+}
+function colorCount(png) {
+  const colors = /* @__PURE__ */ new Set();
+  for (let i = 0; i < png.pixels.length; i += 4) {
+    if (png.pixels[i + 3] < 128) continue;
+    colors.add(png.pixels[i] << 16 | png.pixels[i + 1] << 8 | png.pixels[i + 2]);
+  }
+  return colors.size;
+}
+function unexpectedPaletteColors(png, palette) {
+  const allowed = new Set(palette.map((hex2) => {
+    const color = parseHex(hex2);
+    return color.r << 16 | color.g << 8 | color.b;
+  }));
+  const unexpected = /* @__PURE__ */ new Set();
+  for (let i = 0; i < png.pixels.length; i += 4) {
+    if (png.pixels[i + 3] === 0) continue;
+    const color = png.pixels[i] << 16 | png.pixels[i + 1] << 8 | png.pixels[i + 2];
+    if (!allowed.has(color)) unexpected.add(color);
+  }
+  return unexpected.size;
+}
+function auditRefinement(png, detection, palette, minTransparency, minGridConfidence) {
+  const colors = colorCount(png);
+  const unexpectedColors = unexpectedPaletteColors(png, palette);
+  const transparency = transparencyRatio(png);
+  const reasons = [];
+  if (png.width !== detection.columns || png.height !== detection.rows) {
+    reasons.push(
+      `native output is ${png.width}x${png.height}, expected detected grid ${detection.columns}x${detection.rows}`
+    );
+  }
+  if (colors > palette.length) reasons.push(`opaque color count ${colors} exceeds ${palette.length}`);
+  if (unexpectedColors) reasons.push(`${unexpectedColors} visible color(s) are outside the final palette`);
+  if (minTransparency !== void 0 && transparency < minTransparency) {
+    reasons.push(
+      `transparency ${(transparency * 100).toFixed(1)}% is below ${(minTransparency * 100).toFixed(1)}%`
+    );
+  }
+  if (confidenceRank[detection.confidence] < confidenceRank[minGridConfidence]) {
+    reasons.push(
+      `grid confidence ${detection.confidence} is below required ${minGridConfidence} (${detection.consensus})`
+    );
+  }
+  return {
+    width: png.width,
+    height: png.height,
+    colorCount: colors,
+    paletteConformant: unexpectedColors === 0,
+    transparency,
+    thresholds: {
+      maxColors: palette.length,
+      minTransparency: minTransparency ?? null,
+      minGridConfidence
+    },
+    safe: reasons.length === 0,
+    reasons
+  };
+}
+function isGridConfidence(value) {
+  return value === "low" || value === "medium" || value === "high";
+}
+function parseRecordOptions(manifest, record) {
+  if (manifest.kind !== "refine") throw new Error(`${record} is not a PixelKiln refinement record.`);
+  const raw = manifest.options;
+  if (!raw || typeof raw !== "object") throw new Error(`${record} has invalid quality metadata.`);
+  const options = raw;
+  const grid = options.nativeGrid;
+  const palette = options.palette;
+  const audit = options.audit;
+  const review = options.review;
+  if (options.schema !== "pixelkiln-quality" || options.version !== 1 || !grid || grid.tool !== "pixel-art-fixer" || grid.url !== PIXEL_ART_FIXER_URL || typeof grid.revision !== "string" || !grid.revision || grid.protocol !== "python-api-v1" && grid.protocol !== "python-cli-v1" || !isGridConfidence(grid.confidence) || typeof grid.consensus !== "string" || !Number.isFinite(grid.stepX) || !Number.isFinite(grid.stepY) || !Number.isInteger(grid.sourceWidth) || !Number.isInteger(grid.sourceHeight) || !Number.isInteger(grid.nativeWidth) || !Number.isInteger(grid.nativeHeight) || !palette || !Array.isArray(palette.colors) || palette.colors.length < 2 || !palette.colors.every((color) => typeof color === "string") || palette.dither !== "none" || palette.distance !== "redmean" || !audit || typeof audit.safe !== "boolean" || typeof audit.paletteConformant !== "boolean" || !Array.isArray(audit.reasons) || !review || review.status !== "pending" && review.status !== "approved") {
+    throw new Error(`${record} has invalid quality metadata.`);
+  }
+  return options;
+}
+async function refineAsset(options) {
+  const source = path18.resolve(options.source);
+  const output = path18.resolve(options.output);
+  if (source === output) throw new Error("Refinement source and output must be different files.");
+  const record = path18.resolve(qualityRecordPath(output));
+  const palette = normalizePalette(options.palette).map((color) => color.hex);
+  const minGridConfidence = requireConfidence(options.minGridConfidence ?? "high");
+  if (options.minTransparency !== void 0 && (!Number.isFinite(options.minTransparency) || options.minTransparency < 0 || options.minTransparency > 1)) throw new Error("minTransparency must be between 0 and 1.");
+  let sourcePng;
+  try {
+    sourcePng = decodePng(await readFile13(source));
+  } catch (error) {
+    throw new Error(`Cannot read refinement source ${source}: ${message2(error)}`, { cause: error });
+  }
+  const temp = await mkdtemp(path18.join(tmpdir(), "pixelkiln-refine-"));
+  const recovered = path18.join(temp, "native.png");
+  const compatibilityCommand = options.fixerCommand;
+  const fixerCommand = compatibilityCommand ?? options.fixerPython ?? process.env.PIXELKILN_PIXEL_FIXER_PYTHON ?? "python3";
+  const args = compatibilityCommand ? [...options.fixerArgsPrefix ?? [], source, "--extract", recovered] : ["-c", PYTHON_FIXER_BRIDGE, source, recovered];
+  try {
+    let stdout;
+    try {
+      const result = await execFileAsync(fixerCommand, args, {
+        encoding: "utf8",
+        maxBuffer: 4 * 1024 * 1024,
+        timeout: 10 * 60 * 1e3
+      });
+      stdout = result.stdout;
+    } catch (error) {
+      const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "";
+      const install = `Install the pinned Python package from ${PIXEL_ART_FIXER_URL} at ${options.fixerRevision ?? PIXEL_ART_FIXER_REVISION}, or pass --fixer-python.`;
+      throw new Error(
+        code === "ENOENT" ? `Pixel Art Fixer command not found: ${fixerCommand}. ${install}` : `Pixel Art Fixer failed: ${message2(error)}. ${install}`,
+        { cause: error }
+      );
+    }
+    const detection = parseDetection(firstJsonObject(stdout));
+    const native = decodePng(await readFile13(recovered));
+    const quantized = quantizeToPalette(native, palette);
+    const png = encodeRgbaPng(quantized.width, quantized.height, quantized.pixels);
+    const audit = auditRefinement(
+      quantized,
+      detection,
+      palette,
+      options.minTransparency,
+      minGridConfidence
+    );
+    if (!audit.safe) {
+      throw new Error(`Refinement failed its quality audit: ${audit.reasons.join("; ")}`);
+    }
+    const provenanceSource = {
+      id: "source",
+      path: source,
+      sha256: await sha256File(source),
+      included: true
+    };
+    const recordOptions = {
+      schema: "pixelkiln-quality",
+      version: 1,
+      nativeGrid: {
+        tool: "pixel-art-fixer",
+        url: PIXEL_ART_FIXER_URL,
+        revision: options.fixerRevision ?? PIXEL_ART_FIXER_REVISION,
+        protocol: compatibilityCommand ? "python-cli-v1" : "python-api-v1",
+        confidence: detection.confidence,
+        consensus: detection.consensus,
+        stepX: detection.stepX,
+        stepY: detection.stepY,
+        sourceWidth: sourcePng.width,
+        sourceHeight: sourcePng.height,
+        nativeWidth: quantized.width,
+        nativeHeight: quantized.height
+      },
+      palette: { colors: palette, dither: "none", distance: "redmean" },
+      audit,
+      review: { status: "pending" }
+    };
+    await writeManagedArtifactBundle(
+      record,
+      [{ path: output, data: png }],
+      { kind: "refine", sources: [provenanceSource], options: recordOptions },
+      { force: options.force }
+    );
+    return { source, output, record, detection, palette, audit };
+  } finally {
+    await rm7(temp, { recursive: true, force: true });
+  }
+}
+async function checkQualityRecord(recordPath) {
+  const record = path18.resolve(recordPath);
+  const manifest = await readArtifactBundleManifest(record);
+  const options = parseRecordOptions(manifest, record);
+  const verification = await verifyArtifactBundle(record);
+  const output = manifest.outputs.length === 1 ? path18.resolve(path18.dirname(record), manifest.outputs[0].path) : "";
+  const reasons = [];
+  if (!verification.fingerprintValid) reasons.push("quality record fingerprint changed");
+  for (const source of verification.changedSources) reasons.push(`source changed: ${source}`);
+  for (const changed of verification.changedOutputs) reasons.push(`output changed: ${changed}`);
+  if (manifest.sources.length !== 1) reasons.push("quality record must contain exactly one source");
+  if (manifest.outputs.length !== 1) reasons.push("quality record must contain exactly one output");
+  if (!options.audit.safe) reasons.push(...options.audit.reasons.map((reason) => `audit: ${reason}`));
+  if (options.review.status !== "approved") reasons.push("human 1\xD7 review is pending");
+  return {
+    safe: reasons.length === 0,
+    current: verification.current,
+    approved: options.review.status === "approved",
+    auditSafe: options.audit.safe,
+    record,
+    output,
+    options,
+    reasons
+  };
+}
+async function approveQualityRecord(recordPath, approval) {
+  const reviewer = approval.reviewer.trim();
+  if (!reviewer) throw new Error("A human reviewer name is required.");
+  const record = path18.resolve(recordPath);
+  const manifest = await readArtifactBundleManifest(record);
+  const options = parseRecordOptions(manifest, record);
+  const verification = await verifyArtifactBundle(record);
+  if (!verification.current) {
+    const changes = [
+      ...verification.changedSources.map((source) => `source ${source}`),
+      ...verification.changedOutputs.map((output2) => `output ${output2}`),
+      ...!verification.fingerprintValid ? ["quality metadata"] : []
+    ];
+    throw new Error(`Cannot approve a stale refinement; changed: ${changes.join(", ")}. Run refine again.`);
+  }
+  if (!options.audit.safe) {
+    throw new Error(`Cannot approve a failed quality audit: ${options.audit.reasons.join("; ")}`);
+  }
+  if (manifest.sources.length !== 1 || manifest.outputs.length !== 1) {
+    throw new Error("A refinement record must contain exactly one source and one output.");
+  }
+  const root = path18.dirname(record);
+  const outputPath = path18.resolve(root, manifest.outputs[0].path);
+  const output = await readFile13(outputPath);
+  const sources = manifest.sources.map((source) => ({
+    ...source,
+    path: path18.resolve(root, source.path)
+  }));
+  const approved = {
+    ...options,
+    review: {
+      status: "approved",
+      reviewer,
+      approvedAt: (approval.approvedAt ?? /* @__PURE__ */ new Date()).toISOString(),
+      checklist: {
+        nativeScale: true,
+        crispEdges: true,
+        subjectReadable: true,
+        paletteSeparation: true,
+        alphaAndSeams: true
+      },
+      ...approval.note?.trim() ? { note: approval.note.trim() } : {}
+    }
+  };
+  await writeManagedArtifactBundle(
+    record,
+    [{ path: outputPath, data: output }],
+    { kind: "refine", sources, options: approved }
+  );
+  return checkQualityRecord(record);
+}
+
+// src/pipeline/tileset-export.ts
+function normalizeTileRules(raw) {
+  if (!isRecord(raw)) return null;
+  const ruleType = raw.rule_type;
+  const arity = raw.arity;
+  if (ruleType !== "edge" && ruleType !== "corner" && ruleType !== "outline") return null;
+  if (arity !== 4 && arity !== 6) return null;
+  const masks = {};
+  if (isRecord(raw.tiles)) {
+    for (const [key, value] of Object.entries(raw.tiles)) {
+      const index = tileIndex(key);
+      const mask = typeof value === "number" ? value : isRecord(value) && typeof value.bitmask === "number" ? value.bitmask : isRecord(value) && typeof value.mask === "number" ? value.mask : null;
+      if (index !== null && mask !== null && Number.isInteger(mask) && mask >= 0) masks[index] = mask;
+    }
+  }
+  const connectivity = raw.connectivity === "same" || raw.connectivity === "other" ? raw.connectivity : void 0;
+  const terrains = Array.isArray(raw.terrains) ? raw.terrains.filter((item) => typeof item === "string") : [];
+  return {
+    ruleType,
+    arity,
+    ...connectivity ? { connectivity } : {},
+    terrains,
+    masks,
+    raw
+  };
+}
+function exportTileset(entry, spec, options) {
+  const outputs = resolveSpecEntryOutputs(entry, spec);
+  if (!outputs.length) throw new Error(`${spec.styleId}/${spec.assetId} has no downloaded outputs`);
+  const packed = packSprites(
+    outputs.map((output) => ({
+      id: output.role ?? fallbackOutputRole(output.index),
+      path: output.absolutePath
+    })),
+    { columns: options.columns, order: "input" }
+  );
+  if (packed.skipped.length) {
+    throw new Error(
+      `Cannot export ${spec.styleId}/${spec.assetId}: ` + packed.skipped.map((item) => `${item.id}: ${item.reason}`).join("; ")
+    );
+  }
+  const metadata = entry.providerMetadata?.[entry.provider];
+  const rawRules = isRecord(metadata) ? metadata.tileRules : void 0;
+  const rules = normalizeTileRules(rawRules);
+  const frames = packed.atlas.frames;
+  const generic = buildGeneric(
+    spec,
+    options.imageName,
+    packed.atlas,
+    frames,
+    isRecord(rawRules) ? rawRules : null,
+    rules
+  );
+  if (options.format === "generic") {
+    return {
+      png: packed.png,
+      extension: ".json",
+      document: JSON.stringify(generic, null, 2) + "\n",
+      generic,
+      sources: packed.sources
+    };
+  }
+  assertUniformTiles(generic);
+  if ((rawRules !== void 0 || entry.tileFeature) && !rules) {
+    throw new Error(
+      `${options.format} export needs recognized adjacency rules; use --format generic to retain this provider rule object without guessing`
+    );
+  }
+  if (rules?.arity === 6) {
+    throw new Error(
+      `${options.format} export does not yet map six-edge hex masks safely; use --format generic`
+    );
+  }
+  if (rules?.ruleType === "outline") {
+    throw new Error(
+      `${options.format} export cannot infer adjacency from outline/stamp-only rules; use --format generic`
+    );
+  }
+  if (options.format === "tiled") {
+    return {
+      png: packed.png,
+      extension: ".tsj",
+      document: JSON.stringify(buildTiled(generic), null, 2) + "\n",
+      generic,
+      sources: packed.sources
+    };
+  }
+  return {
+    png: packed.png,
+    extension: ".tres",
+    document: buildGodot(generic, spec),
+    generic,
+    sources: packed.sources
+  };
+}
+function buildGeneric(spec, imageName, atlas, frames, providerRules, rules) {
+  return {
+    format: "pixelkiln-tileset",
+    version: 1,
+    name: `${spec.styleId}/${spec.assetId}`,
+    style: spec.styleId,
+    asset: spec.assetId,
+    image: imageName,
+    tile: { ...atlas.cell },
     sheet: { ...atlas.sheet, columns: atlas.columns },
     tiles: frames.map((frame, index) => {
       const sourceIndex = tileIndex(frame.id) ?? index;
@@ -5301,8 +6124,8 @@ function isRecord(value) {
 }
 
 // src/pick/salvage-server.ts
-import { mkdir as mkdir5, writeFile as writeFile7, readFile as readFile13 } from "fs/promises";
-import path17 from "path";
+import { mkdir as mkdir6, writeFile as writeFile8, readFile as readFile14 } from "fs/promises";
+import path19 from "path";
 
 // src/pick/salvage-sheet.ts
 var escapeHtml2 = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
@@ -5467,7 +6290,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
   });
   const html = renderSalvageSheet(orphans, {
     styleId: ctx.styleId,
-    importDir: path17.relative(process.cwd(), ctx.importDir) || "."
+    importDir: path19.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]));
@@ -5496,10 +6319,10 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
             if (!buf.subarray(0, 8).equals(PNG_SIGNATURE2)) throw new Error("not a PNG");
             decodePng(buf);
             const assetId = idFromPrompt(orphan.prompt, taken);
-            const rel = path17.join("_salvaged", `${assetId}.png`);
-            const outFile = path17.resolve(ctx.importDir, rel);
-            await mkdir5(path17.dirname(outFile), { recursive: true });
-            await writeFile7(outFile, buf);
+            const rel = path19.join("_salvaged", `${assetId}.png`);
+            const outFile = path19.resolve(ctx.importDir, rel);
+            await mkdir6(path19.dirname(outFile), { recursive: true });
+            await writeFile8(outFile, buf);
             ctx.manifest.assets[assetId] = {
               prompt: orphan.prompt,
               promptByStyle: {},
@@ -5525,7 +6348,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
               error: null,
               sourceUrl: orphan.previewUrl,
               outputs: [{
-                path: portableOutputPath(outFile, path17.dirname(ctx.manifestPath)),
+                path: portableOutputPath(outFile, path19.dirname(ctx.manifestPath)),
                 sha256: sha256(buf)
               }],
               submittedAt: orphan.createdAt,
@@ -5549,437 +6372,751 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
         }
       }
       await applyTags(provider, decisions, existingTags, { onProgress: log2 });
-      const raw = JSON.parse(await readFile13(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 writeFile7(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
+      await writeFile8(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
       await saveLock(ctx.lockPath, ctx.lock);
       return result;
     }
   });
 }
 
-// src/artifacts.ts
-import path18 from "path";
-import { createHash as createHash2, randomUUID as randomUUID3 } from "crypto";
-import { mkdir as mkdir6, readFile as readFile14, rename as rename5, rm as rm6, writeFile as writeFile8 } from "fs/promises";
-var activeTransactions = /* @__PURE__ */ new Set();
-function message(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function digest(data) {
-  return createHash2("sha256").update(data).digest("hex");
-}
-function portableRelative(from, to) {
-  return path18.relative(from, path18.resolve(to)).split(path18.sep).join("/") || ".";
-}
-function canonical2(value) {
+// 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("Artifact provenance numbers must be finite.");
+    if (!Number.isFinite(value)) throw new Error("Recipe numbers must be finite.");
     return value;
   }
-  if (Array.isArray(value)) return value.map(canonical2);
+  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] = canonical2(item);
+      if (item !== void 0) sorted[key] = canonical3(item);
     }
     return sorted;
   }
-  throw new Error(`Artifact provenance cannot contain ${typeof value} values.`);
+  throw new Error(`Recipe metadata cannot contain ${typeof value} values.`);
 }
-function fingerprint(provenance) {
-  return digest(JSON.stringify(canonical2({
-    kind: provenance.kind,
-    sources: provenance.sources,
-    options: provenance.options,
-    outputs: provenance.outputs
-  })));
+function recipeDigest(recipe) {
+  const { integrity: _integrity, ...payload } = recipe;
+  return sha256(JSON.stringify(canonical3(payload)));
 }
-function parseArtifactManifest(absolute, data) {
+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(data);
+    raw = JSON.parse(await readFile15(absolute, "utf8"));
   } catch (error) {
-    throw new Error(`${absolute} is not valid JSON: ${message(error)}`, { cause: error });
+    throw new Error(`Could not read recipe ${absolute}: ${message3(error)}`, { cause: error });
   }
-  if (raw.format !== "pixelkiln-artifact-bundle" || raw.version !== 1 || raw.kind !== "pack" && raw.kind !== "mount" && raw.kind !== "tileset" || typeof raw.fingerprint !== "string" || raw.options === void 0 || !Array.isArray(raw.sources) || !Array.isArray(raw.outputs)) {
-    throw new Error(`${absolute} is not a PixelKiln artifact bundle manifest.`);
-  }
-  for (const source of raw.sources) {
-    if (!source || typeof source.id !== "string" || typeof source.path !== "string" || source.sha256 !== null && typeof source.sha256 !== "string" || typeof source.included !== "boolean") {
-      throw new Error(`${absolute} contains an invalid artifact source.`);
-    }
-  }
-  for (const output of raw.outputs) {
-    if (!output || typeof output.path !== "string" || typeof output.sha256 !== "string") {
-      throw new Error(`${absolute} contains an invalid artifact output.`);
-    }
+  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 raw;
+  return { recipe: parsed.data, path: absolute, dir: path20.dirname(absolute), bundled };
 }
-async function readOptional(file) {
-  try {
-    return await readFile14(file);
-  } catch (error) {
-    if (isCode(error, "ENOENT")) return null;
-    throw error;
+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 transactionMarker(journal) {
-  return `${journal}.committed`;
-}
-function processIsAlive(pid) {
-  if (!Number.isInteger(pid) || pid < 1) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return !isCode(error, "ESRCH");
-  }
+function bundledRecipeRoot() {
+  return fileURLToPath(new URL("../recipes/", import.meta.url));
 }
-function validTemporaryPath(candidate, destination, type) {
-  return path18.dirname(candidate) === path18.dirname(destination) && path18.basename(candidate).startsWith(
-    `.${path18.basename(destination)}.pixelkiln-${type}-`
+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 parseTransaction(journal, data) {
-  let raw;
-  try {
-    raw = JSON.parse(data);
-  } catch (error) {
-    throw new Error(`${journal} is not valid transaction JSON: ${message(error)}`, { cause: error });
-  }
-  if (raw.format !== "pixelkiln-artifact-transaction" || raw.version !== 1 || !Number.isInteger(raw.pid) || typeof raw.createdAt !== "string" || !Array.isArray(raw.entries) || !raw.entries.length) {
-    throw new Error(`${journal} is not a PixelKiln artifact transaction.`);
+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 raw;
-}
-async function removeTransactionFiles(journal) {
-  await rm6(journal, { force: true });
-  await rm6(transactionMarker(journal), { force: true });
+  return 0;
 }
-async function recoverArtifactTransaction(recoveryFile, allowedDestinations) {
-  const journal = path18.resolve(recoveryFile);
-  const bytes = await readOptional(journal);
-  if (!bytes) {
-    await rm6(transactionMarker(journal), { force: true });
-    return;
-  }
-  if (activeTransactions.has(journal)) {
-    throw new Error(`Another artifact write in this process is already using ${journal}.`);
-  }
-  const transaction = parseTransaction(journal, bytes.toString("utf8"));
-  if (transaction.pid !== process.pid && processIsAlive(transaction.pid)) {
-    throw new Error(
-      `Artifact transaction ${journal} is still owned by live process ${transaction.pid}; refusing concurrent recovery.`
-    );
+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.`);
   }
-  for (const entry of transaction.entries) {
-    if (typeof entry.destination !== "string" || typeof entry.stage !== "string" || typeof entry.sha256 !== "string" || entry.backup !== void 0 && typeof entry.backup !== "string" || !allowedDestinations.has(path18.resolve(entry.destination)) || !validTemporaryPath(entry.stage, entry.destination, "stage") || entry.backup !== void 0 && !validTemporaryPath(entry.backup, entry.destination, "backup")) {
-      throw new Error(
-        `Refusing unsafe artifact recovery from ${journal}; its destinations or temporary paths do not match the current bundle.`
-      );
-    }
-  }
-  const committed = await readOptional(transactionMarker(journal)) !== null;
-  const errors = [];
-  if (committed) {
-    for (const entry of transaction.entries) {
-      if (entry.backup) await remove2(entry.backup, errors);
-      await remove2(entry.stage, errors);
-    }
-  } else {
-    for (const entry of [...transaction.entries].reverse()) {
-      const backup = entry.backup ? await readOptional(entry.backup) : null;
-      const destination = await readOptional(entry.destination);
-      if (backup) {
-        if (destination && digest(destination) !== entry.sha256) {
-          errors.push(
-            `destination changed during interrupted recovery: ${entry.destination}; previous file remains at ${entry.backup}`
-          );
-          continue;
-        }
-        await remove2(entry.destination, errors);
-        try {
-          await rename5(entry.backup, entry.destination);
-        } catch (error) {
-          errors.push(
-            `could not restore ${entry.destination}; previous file remains at ${entry.backup}: ${message(error)}`
-          );
-        }
-      } else if (destination && digest(destination) === entry.sha256) {
-        await remove2(entry.destination, errors);
-      }
-      await remove2(entry.stage, errors);
-    }
+  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 (errors.length) {
-    throw new Error(
-      `Artifact transaction recovery needs attention; journal retained at ${journal}: ` + errors.join("; ")
-    );
+  if (target.startsWith(".") || target.startsWith("/") || target.includes("\\")) {
+    throw new Error(`Recipe path not found: ${local}`);
   }
-  await removeTransactionFiles(journal);
+  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];
 }
-function createArtifactBundleManifest(manifestPath, outputs, provenance) {
-  const root = path18.dirname(path18.resolve(manifestPath));
-  const sources = provenance.sources.map((source) => ({
-    ...source,
-    path: portableRelative(root, source.path)
-  }));
-  const normalized = {
-    kind: provenance.kind,
-    sources,
-    options: canonical2(provenance.options)
+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"
   };
-  const manifestOutputs = outputs.map((output) => ({
-    path: portableRelative(root, output.path),
-    sha256: digest(output.data)
+}
+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 {
-    format: "pixelkiln-artifact-bundle",
     version: 1,
-    ...normalized,
-    fingerprint: fingerprint({ ...normalized, outputs: manifestOutputs }),
-    outputs: manifestOutputs
+    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 withArtifactManifest(manifestPath, outputs, provenance) {
-  const manifest = createArtifactBundleManifest(manifestPath, outputs, provenance);
-  return [
-    ...outputs,
-    { path: manifestPath, data: JSON.stringify(manifest, null, 2) + "\n" }
+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("/")) }))
   ];
-}
-async function writeManagedArtifactBundle(manifestPath, outputs, provenance, options = {}) {
-  const absoluteManifest = path18.resolve(manifestPath);
-  const recoveryFile = `${absoluteManifest}.transaction`;
-  const allowedDestinations = /* @__PURE__ */ new Set([
-    absoluteManifest,
-    ...outputs.map((output) => path18.resolve(output.path))
-  ]);
-  await recoverArtifactTransaction(recoveryFile, allowedDestinations);
-  const existingManifestBytes = await readOptional(absoluteManifest);
-  let previous = null;
-  if (existingManifestBytes && !options.force) {
-    try {
-      previous = parseArtifactManifest(absoluteManifest, existingManifestBytes.toString("utf8"));
-      const valid = previous.fingerprint === fingerprint(previous);
-      if (!valid) throw new Error("its integrity fingerprint does not match");
-    } catch (error) {
-      throw new Error(
-        `Refusing to replace unrecognized or modified provenance at ${absoluteManifest}: ${message(error)}. Pass { force: true } (CLI: --force) to take ownership of this artifact bundle.`,
-        { cause: error }
-      );
+  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.`
+        );
+      }
     }
   }
-  if (!options.force) {
-    const root = path18.dirname(absoluteManifest);
-    const recorded = new Map(
-      previous?.outputs.map((output) => [path18.resolve(root, output.path), output.sha256]) ?? []
-    );
-    const conflicts = [];
-    for (const output of outputs) {
-      const destination = path18.resolve(output.path);
-      const current = await readOptional(destination);
-      if (!current || digest(current) === digest(output.data)) continue;
-      const expected = recorded.get(destination);
-      if (!expected || digest(current) !== expected) conflicts.push(destination);
+  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;
     }
-    if (conflicts.length) {
-      throw new Error(
-        `Refusing to overwrite modified or unowned artifact file(s):
-` + conflicts.map((file) => `  ${file}`).join("\n") + `
-Pass { force: true } (CLI: --force) to take ownership and replace the complete bundle.`
-      );
+    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 { force: _force, ...bundleOptions } = options;
-  return writeArtifactBundle(
-    withArtifactManifest(absoluteManifest, outputs, provenance),
-    { ...bundleOptions, recoveryFile }
-  );
-}
-function isCode(error, code) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+  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 remove2(file, errors) {
+async function measureImageQuality(file) {
+  const absolute = path21.resolve(file);
+  let bytes;
   try {
-    await rm6(file, { force: true });
+    bytes = await readFile16(absolute);
   } catch (error) {
-    errors?.push(`could not remove ${file}: ${message(error)}`);
+    throw new Error(`Cannot read quality image ${absolute}: ${message4(error)}`, { cause: error });
   }
-}
-async function rollback(prepared) {
-  const errors = [];
-  for (const artifact of [...prepared].reverse()) {
-    if (artifact.promoted) await remove2(artifact.destination, errors);
-  }
-  for (const artifact of [...prepared].reverse()) {
-    if (!artifact.backup || !artifact.backedUp) continue;
-    try {
-      await rename5(artifact.backup, artifact.destination);
-      artifact.backedUp = false;
-    } catch (error) {
-      errors.push(
-        `could not restore ${artifact.destination}; previous file remains at ${artifact.backup}: ${message(error)}`
-      );
-    }
+  try {
+    return measureDecodedImageQuality(decodePng(bytes), sha256(bytes));
+  } catch (error) {
+    throw new Error(`Cannot measure quality image ${absolute}: ${message4(error)}`, { cause: error });
   }
-  for (const artifact of prepared) {
-    if (artifact.stage) await remove2(artifact.stage, errors);
+}
+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")
+    );
   }
-  return errors;
+  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
+    })
+  }));
 }
-async function writeArtifactBundle(files, options = {}) {
-  if (!files.length) throw new Error("An artifact bundle must contain at least one file.");
-  const normalized = files.map((file) => {
-    if (!file.path.trim()) throw new Error("Artifact paths cannot be empty.");
-    return { destination: path18.resolve(file.path), data: Buffer.from(file.data) };
-  });
-  const destinations = /* @__PURE__ */ new Set();
-  for (const artifact of normalized) {
-    if (destinations.has(artifact.destination)) {
-      throw new Error(`Artifact bundle contains duplicate destination: ${artifact.destination}`);
-    }
-    destinations.add(artifact.destination);
+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(", ")})` : "")
+    );
   }
-  if (options.recoveryFile) {
-    await recoverArtifactTransaction(options.recoveryFile, destinations);
+  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 changed = [];
-  const unchanged = [];
-  for (const artifact of normalized) {
-    try {
-      const current = await readFile14(artifact.destination);
-      if (current.equals(artifact.data)) {
-        unchanged.push(artifact.destination);
-      } else {
-        changed.push({ ...artifact, existed: true, backedUp: false, promoted: false });
-      }
-    } catch (error) {
-      if (!isCode(error, "ENOENT")) throw error;
-      changed.push({ ...artifact, existed: false, backedUp: false, promoted: false });
-    }
+  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}.`);
   }
-  if (!changed.length) return { changed: [], unchanged };
-  const token = randomUUID3();
-  for (const [index, artifact] of changed.entries()) {
-    const basename = path18.basename(artifact.destination);
-    artifact.stage = path18.join(
-      path18.dirname(artifact.destination),
-      `.${basename}.pixelkiln-stage-${token}-${index}`
-    );
-    if (artifact.existed) {
-      artifact.backup = path18.join(
-        path18.dirname(artifact.destination),
-        `.${basename}.pixelkiln-backup-${token}-${index}`
-      );
+}
+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 journal = options.recoveryFile ? path18.resolve(options.recoveryFile) : null;
-  if (journal) {
-    await mkdir6(path18.dirname(journal), { recursive: true });
-    const transaction = {
-      format: "pixelkiln-artifact-transaction",
-      version: 1,
-      pid: process.pid,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      entries: changed.map((artifact) => ({
-        destination: artifact.destination,
-        stage: artifact.stage,
-        ...artifact.backup ? { backup: artifact.backup } : {},
-        sha256: digest(artifact.data)
-      }))
-    };
-    try {
-      await writeFile8(journal, JSON.stringify(transaction, null, 2) + "\n", { flag: "wx" });
-      activeTransactions.add(journal);
-    } catch (error) {
-      throw new Error(
-        `Could not start durable artifact transaction at ${journal}: ${message(error)}`,
-        { cause: error }
-      );
+  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 {
-    for (const [index, artifact] of changed.entries()) {
-      await mkdir6(path18.dirname(artifact.destination), { recursive: true });
-      await options.beforeStage?.(artifact.destination, index);
-      await writeFile8(artifact.stage, artifact.data, { flag: "wx" });
-    }
+    raw = JSON.parse(await readFile16(absolute, "utf8"));
   } catch (error) {
-    const cleanupErrors2 = await rollback(changed);
-    if (journal && !cleanupErrors2.length) await removeTransactionFiles(journal);
-    if (journal) activeTransactions.delete(journal);
-    const suffix = cleanupErrors2.length ? ` Cleanup also failed: ${cleanupErrors2.join("; ")}` : "";
-    throw new Error(`Could not stage artifact bundle: ${message(error)}.${suffix}`, { cause: error });
+    throw new Error(`Could not read quality baseline ${absolute}: ${message4(error)}`, { cause: error });
   }
-  let durableCommit = false;
-  try {
-    for (const artifact of changed) {
-      if (!artifact.existed) continue;
-      await rename5(artifact.destination, artifact.backup);
-      artifact.backedUp = true;
-    }
-    for (const [index, artifact] of changed.entries()) {
-      await options.beforePromote?.(artifact.destination, index);
-      await rename5(artifact.stage, artifact.destination);
-      artifact.stage = void 0;
-      artifact.promoted = true;
-    }
-    if (journal) {
-      await writeFile8(transactionMarker(journal), `${token}
-`, { flag: "wx" });
-      durableCommit = true;
-      await options.afterCommit?.();
-    }
-  } catch (error) {
-    if (durableCommit) {
-      if (journal) activeTransactions.delete(journal);
-      throw new Error(
-        `Artifact bundle was committed, but final cleanup was interrupted: ${message(error)}. The next write will finish cleanup from ${journal}.`,
-        { cause: error }
-      );
-    }
-    const rollbackErrors = await rollback(changed);
-    if (journal && !rollbackErrors.length) await removeTransactionFiles(journal);
-    if (journal) activeTransactions.delete(journal);
-    const suffix = rollbackErrors.length ? ` Rollback needs attention: ${rollbackErrors.join("; ")}` : " Previous bundle restored.";
-    throw new Error(`Could not promote artifact bundle: ${message(error)}.${suffix}`, { 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")
+    );
   }
-  const cleanupErrors = [];
-  for (const artifact of changed) {
-    if (artifact.backup) await remove2(artifact.backup, cleanupErrors);
+  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 (cleanupErrors.length) {
-    if (journal) activeTransactions.delete(journal);
-    throw new Error(
-      `Artifact bundle was written, but old backup cleanup failed: ${cleanupErrors.join("; ")}`
+  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})`
     );
   }
-  if (journal) {
+  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 {
-      await removeTransactionFiles(journal);
-    } finally {
-      activeTransactions.delete(journal);
+      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 {
-    changed: changed.map((artifact) => artifact.destination),
-    unchanged
+    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 = path19.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
   };
 }
@@ -6006,7 +7143,14 @@ var VALUE_FLAGS = [
   "--sigma",
   "--workspace",
   "--provider",
-  "--account"
+  "--account",
+  "--palette",
+  "--fixer-python",
+  "--fixer-revision",
+  "--min-grid-confidence",
+  "--reviewer",
+  "--note",
+  "--model-root"
 ];
 var BOOL_FLAGS = [
   "--force",
@@ -6045,6 +7189,9 @@ var COMMANDS = [
   "tag",
   "balance",
   "status",
+  "quality",
+  "refine",
+  "recipe",
   "workspace",
   "help",
   "--help",
@@ -6053,6 +7200,9 @@ var COMMANDS = [
   "-v"
 ];
 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)) {
@@ -6061,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(", ")}`);
@@ -6081,6 +7260,14 @@ function parseArgs(argv) {
       }
       rest = rest.slice(1);
     }
+  } else if (command === "refine") {
+    subcommand = rest[0]?.startsWith("-") || rest[0] === void 0 ? "run" : rest[0];
+    if (!REFINE_SUBCOMMANDS.includes(subcommand)) {
+      throw new Error(
+        `Unknown refine subcommand "${subcommand}". Known: ${REFINE_SUBCOMMANDS.join(", ")}`
+      );
+    }
+    if (rest[0] === subcommand) rest = rest.slice(1);
   }
   for (let i = 0; i < rest.length; i++) {
     const token = rest[i];
@@ -6155,10 +7342,16 @@ function parseArgs(argv) {
     }
     return value;
   };
+  const rawGridConfidence = get("--min-grid-confidence");
+  if (rawGridConfidence !== void 0 && rawGridConfidence !== "low" && rawGridConfidence !== "medium" && rawGridConfidence !== "high") {
+    throw new Error(
+      `--min-grid-confidence must be low, medium, or high, got "${rawGridConfidence}"`
+    );
+  }
   return {
     command,
     manifest,
-    lock: get("--lock") ?? path19.join(path19.dirname(path19.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"),
@@ -6189,6 +7382,13 @@ function parseArgs(argv) {
     minTransparency: numberOption("--min-transparency", { min: 0, max: 1 }),
     maxColors: numberOption("--max-colors", { min: 1, integer: true }),
     sigma: numberOption("--sigma", { min: Number.EPSILON }),
+    palette: list("--palette"),
+    fixerPython: get("--fixer-python"),
+    fixerRevision: get("--fixer-revision"),
+    minGridConfidence: rawGridConfidence,
+    reviewer: get("--reviewer"),
+    note: get("--note"),
+    modelRoot: get("--model-root"),
     subcommand,
     workspace: get("--workspace"),
     target,
@@ -6215,6 +7415,10 @@ Commands
   salvage   Triage account objects no lockfile claims. Recovers usable art.
             One session per matching style unless --style forces a single one.
   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
@@ -6232,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
@@ -6240,16 +7444,23 @@ Options
   --min-transparency <0..1>  audit: minimum transparent canvas share
   --max-colors <n>    audit: maximum distinct opaque colors
   --sigma <n>         audit: relative outlier cutoff (default: 1.5)
+  --palette <hexes>   refine: final comma-separated #rrggbb colors (repeatable)
+  --fixer-python <path>  refine: Python with Pixel Art Fixer installed
+  --fixer-revision <sha>  refine: Pixel Art Fixer revision to record
+  --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
@@ -6257,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
@@ -6269,6 +7480,14 @@ Examples
   pixelkiln pack --inputs sprites.json --out dist/sheet   # no manifest needed
   pixelkiln mount --style ground
   pixelkiln export --style ground --only terrain --format tiled
+  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
@@ -6313,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 = path19.dirname(path19.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");
@@ -6337,13 +7556,214 @@ async function main() {
   }
   if (args.command === "--version" || args.command === "-v") {
     const pkg = JSON.parse(
-      await readFile15(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(
+        args.subcommand === "run" ? "refine needs --from <source.png>." : `refine ${args.subcommand} needs --from <output.pixelkiln.json>.`
+      );
+    }
+    if (args.subcommand === "run") {
+      if (!args.out) throw new Error("refine needs --out <final.png>.");
+      if (!args.palette.length) {
+        throw new Error("refine needs an explicit final palette via --palette <#rrggbb,...>.");
+      }
+      const result2 = await refineAsset({
+        source: args.from,
+        output: args.out,
+        palette: args.palette,
+        fixerPython: args.fixerPython,
+        fixerRevision: args.fixerRevision,
+        minGridConfidence: args.minGridConfidence,
+        minTransparency: args.minTransparency,
+        force: args.force
+      });
+      if (args.json) {
+        log(JSON.stringify(result2, null, 2));
+      } else {
+        log(
+          `  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 ${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 ${path22.relative(process.cwd(), result2.record)} --reviewer "Your Name"`
+        );
+      }
+      return;
+    }
+    if (args.subcommand === "approve") {
+      if (!args.reviewer?.trim()) {
+        throw new Error("refine approve needs --reviewer <name>.");
+      }
+      log(`  Inspect the final PNG at 1\xD7 and integer zoom.`);
+      log(`  Confirm crisp edges, readable forms, palette separation, alpha, and seams.`);
+      if (!await confirm("  Record this asset as human-approved?", args.yes)) {
+        log("  approval not recorded");
+        return;
+      }
+      const result2 = await approveQualityRecord(args.from, {
+        reviewer: args.reviewer,
+        note: args.note
+      });
+      if (args.json) log(JSON.stringify(result2, null, 2));
+      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"}: ${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(path19.dirname(path19.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");
@@ -6355,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 = path19.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 = path19.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 ?? path19.basename(path19.dirname(target)),
+      args.name ?? path22.basename(path22.dirname(target)),
       args.styles[0] ?? "base",
       generator,
-      path19.relative(path19.dirname(target), root) || ".",
+      path22.relative(path22.dirname(target), root) || ".",
       assets
     );
     await writeManifestFile(target, manifest);
-    log(`  scanned ${assets.length} PNG(s) under ${path19.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 ${path19.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 ${path19.relative(process.cwd(), target)} --write-prompts
+    pixelkiln adopt --manifest ${path22.relative(process.cwd(), target)} --write-prompts
 `);
     return;
   }
@@ -6427,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 readFile15(path19.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 = path19.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" }
@@ -6443,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(`    ${path19.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 = path19.resolve(args.workspace ?? "pixelkiln.workspace.json");
-    const dir = path19.dirname(workspacePath);
+    const workspacePath = path22.resolve(args.workspace ?? "pixelkiln.workspace.json");
+    const dir = path22.dirname(workspacePath);
     if (args.subcommand === "add") {
-      const manifestPath = path19.resolve(args.target);
+      const manifestPath = path22.resolve(args.target);
       const loadedTarget = await loadManifest(manifestPath);
-      const lockPath = args.explicitLock ? path19.resolve(args.explicitLock) : path19.join(path19.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)) {
@@ -6473,10 +7893,10 @@ async function main() {
         ...args.account ? { account: args.account } : {}
       };
       await saveWorkspace(workspacePath, { version: 1, projects: [...ws.projects, project] });
-      log(`  registered "${id}" in ${path19.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`
         );
@@ -6485,7 +7905,7 @@ async function main() {
     }
     if (args.subcommand === "remove") {
       const ws = await loadWorkspace(workspacePath);
-      const resolvedTarget = path19.resolve(args.target);
+      const resolvedTarget = path22.resolve(args.target);
       const match = ws.projects.find(
         (p) => p.id === args.target || resolveProject(dir, p).manifestPath === resolvedTarget
       );
@@ -6496,11 +7916,11 @@ async function main() {
         version: 1,
         projects: ws.projects.filter((p) => p !== match)
       });
-      log(`  removed "${match.id}" from ${path19.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);
@@ -6508,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 ${path19.relative(process.cwd(), workspacePath)}`);
+        log(`  no projects registered in ${path22.relative(process.cwd(), workspacePath)}`);
       } else {
-        log(`  ${ws.projects.length} project(s) in ${path19.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}` : ""})`);
         }
@@ -6520,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);
@@ -6528,7 +7948,7 @@ async function main() {
       if (args.json) {
         log(JSON.stringify({ ...report, workspace: workspacePath }, null, 2));
       } else {
-        log(`  workspace: ${path19.relative(process.cwd(), workspacePath)}`);
+        log(`  workspace: ${path22.relative(process.cwd(), workspacePath)}`);
         for (const p of report.projects) {
           if (p.error) {
             log(`
@@ -6572,14 +7992,14 @@ async function main() {
       return;
     }
   }
-  if (!existsSync15(path19.resolve(args.manifest))) {
+  if (!existsSync17(path22.resolve(args.manifest))) {
     throw new Error(
-      `No manifest at ${path19.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 = path19.dirname(path19.resolve(args.manifest));
+  const manifestDir = path22.dirname(path22.resolve(args.manifest));
   const envFiles = [...loadEnvFiles(manifestDir)];
-  if (path19.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, {
@@ -6656,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;
         }
@@ -6714,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 = path19.dirname(path19.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, {
@@ -6723,7 +8143,7 @@ async function main() {
         primaryOnly: args.primaryOnly
       });
       const style = loaded.manifest.styles[styleId];
-      const base = args.out ? path19.resolve(args.out.replace(/\.png$/, "")) : path19.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" }
@@ -6746,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(`    ${path19.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 = path19.dirname(path19.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];
@@ -6782,7 +8202,7 @@ async function main() {
         sources,
         outputRoles
       );
-      const out = path19.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 = [
@@ -6795,7 +8215,7 @@ async function main() {
           await provenanceFile("$manifest", args.manifest),
           await provenanceFile("$lock", args.lock),
           ...artifactSources.filter(
-            (source) => source.id !== "$base" || path19.resolve(source.path) !== out
+            (source) => source.id !== "$base" || path22.resolve(source.path) !== out
           )
         ],
         options: {
@@ -6808,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(`    ${path19.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;
@@ -6864,7 +8284,7 @@ async function main() {
   }
   if (args.command === "export") {
     const format = args.format ?? "generic";
-    const manifestDir2 = path19.dirname(path19.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;
@@ -6880,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 = path19.resolve(manifestDir2, style.outDir, `${spec.assetId}-tileset`);
-      const base = args.out ? path19.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: path19.basename(`${base}.png`),
+        imageName: path22.basename(`${base}.png`),
         columns: args.columns
       });
       const outputs = [
@@ -6903,7 +8323,7 @@ async function main() {
           asset: spec.assetId,
           columns: args.columns ?? null,
           format,
-          image: path19.basename(`${base}.png`),
+          image: path22.basename(`${base}.png`),
           providerRules: result.generic.providerRules,
           style: spec.styleId,
           tileType: spec.tileType ?? null
@@ -6913,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(
-        `    ${path19.relative(process.cwd(), base)}.png + ${path19.basename(base)}${result.extension} + .pixelkiln.json`
+        `    ${path22.relative(process.cwd(), base)}.png + ${path22.basename(base)}${result.extension} + .pixelkiln.json`
       );
     }
     return;
@@ -6953,10 +8373,10 @@ async function main() {
   tagged ${n} object(s) upstream`);
     }
     if (args.writePrompts) {
-      const { filled, stillEmpty } = await writePromptsBack(path19.resolve(args.manifest), lock, {
+      const { filled, stillEmpty } = await writePromptsBack(path22.resolve(args.manifest), lock, {
         onProgress: log
       });
-      log(`  recovered ${filled} prompt(s) into ${path19.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,
@@ -6985,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 = path19.resolve(args.lock);
+    const ownLock = path22.resolve(args.lock);
     let workspaceProjects = [];
     let workspaceDir = "";
     if (args.workspace) {
-      const workspacePath = path19.resolve(args.workspace);
-      workspaceDir = path19.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}`);
@@ -6999,12 +8419,12 @@ async function main() {
     const lockPaths = [
       .../* @__PURE__ */ new Set([
         ...workspaceLockPaths,
-        ...existsSync15(ownLock) ? [ownLock] : [],
-        ...args.claims.map((c) => path19.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(`    ${path19.relative(process.cwd(), p)}`);
+    for (const p of lockPaths) diag(`    ${path22.relative(process.cwd(), p)}`);
     if (!args.claims.length && !args.workspace) {
       diag(
         `
@@ -7012,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 === path19.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
@@ -7096,7 +8516,7 @@ async function main() {
           manifestPath: loaded.path,
           manifest: loaded.manifest,
           styleId,
-          importDir: path19.resolve(loaded.root, style.outDir),
+          importDir: path22.resolve(loaded.root, style.outDir),
           lock,
           lockPath: args.lock
         },